basis/compiler/cfg/linear-scan/resolve/resolve-tests.factor

   1 USING: accessors arrays classes compiler.cfg
   2 compiler.cfg.debugger compiler.cfg.instructions
   3 compiler.cfg.linear-scan.debugger
   4 compiler.cfg.linear-scan.live-intervals
   5 compiler.cfg.linear-scan.numbering
   6 compiler.cfg.linear-scan.allocation.state
   7 compiler.cfg.linear-scan.resolve compiler.cfg.predecessors
   8 compiler.cfg.registers compiler.cfg.rpo cpu.architecture kernel
   9 namespaces tools.test vectors ;
  10 IN: compiler.cfg.linear-scan.resolve.tests
  11
  12 [ { 1 2 3 4 5 6 } ] [
  13     { 3 4 } V{ 1 2 } clone [ { 5 6 } 3append-here ] keep >array
  14 ] unit-test
  15
  16 H{ { int-regs 10 } { float-regs 20 } } clone spill-counts set
  17 H{ } clone spill-temps set
  18
  19 [
  20     {
  21         T{ _copy { dst 5 } { src 4 } { class int-regs } }
  22         T{ _spill { src 1 } { class int-regs } { n 10 } }
  23         T{ _copy { dst 1 } { src 0 } { class int-regs } }
  24         T{ _reload { dst 0 } { class int-regs } { n 10 } }
  25         T{ _spill { src 1 } { class float-regs } { n 20 } }
  26         T{ _copy { dst 1 } { src 0 } { class float-regs } }
  27         T{ _reload { dst 0 } { class float-regs } { n 20 } }
  28     }
  29 ] [
  30     {
  31         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  32         T{ register->register { from 1 } { to 0 } { reg-class int-regs } }
  33         T{ register->register { from 0 } { to 1 } { reg-class float-regs } }
  34         T{ register->register { from 1 } { to 0 } { reg-class float-regs } }
  35         T{ register->register { from 4 } { to 5 } { reg-class int-regs } }
  36     } mapping-instructions
  37 ] unit-test
  38
  39 [
  40     {
  41         T{ _spill { src 2 } { class int-regs } { n 10 } }
  42         T{ _copy { dst 2 } { src 1 } { class int-regs } }
  43         T{ _copy { dst 1 } { src 0 } { class int-regs } }
  44         T{ _reload { dst 0 } { class int-regs } { n 10 } }
  45     }
  46 ] [
  47     {
  48         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  49         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  50         T{ register->register { from 2 } { to 0 } { reg-class int-regs } }
  51     } mapping-instructions
  52 ] unit-test
  53
  54 [
  55     {
  56         T{ _spill { src 0 } { class int-regs } { n 10 } }
  57         T{ _copy { dst 0 } { src 2 } { class int-regs } }
  58         T{ _copy { dst 2 } { src 1 } { class int-regs } }
  59         T{ _reload { dst 1 } { class int-regs } { n 10 } }
  60     }
  61 ] [
  62     {
  63         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  64         T{ register->register { from 2 } { to 0 } { reg-class int-regs } }
  65         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  66     } mapping-instructions
  67 ] unit-test
  68
  69 [
  70     {
  71         T{ _copy { dst 1 } { src 0 } { class int-regs } }
  72         T{ _copy { dst 2 } { src 0 } { class int-regs } }
  73     }
  74 ] [
  75     {
  76         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  77         T{ register->register { from 0 } { to 2 } { reg-class int-regs } }
  78     } mapping-instructions
  79 ] unit-test
  80
  81 [
  82     { }
  83 ] [
  84     {
  85        T{ register->register { from 4 } { to 4 } { reg-class int-regs } }
  86     } mapping-instructions
  87 ] unit-test
  88
  89 [
  90     {
  91         T{ _spill { src 3 } { class int-regs } { n 4 } }
  92         T{ _reload { dst 2 } { class int-regs } { n 1 } }
  93     }
  94 ] [
  95     {
  96         T{ register->memory { from 3 } { to T{ spill-slot f 4 } } { reg-class int-regs } }
  97         T{ memory->register { from T{ spill-slot f 1 } } { to 2 } { reg-class int-regs } }
  98     } mapping-instructions
  99 ] unit-test
 100
 101
 102 [
 103     {
 104         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 105         T{ _copy { dst 2 } { src 0 } { class int-regs } }
 106         T{ _copy { dst 0 } { src 3 } { class int-regs } }
 107     }
 108 ] [
 109     {
 110         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 111         T{ register->register { from 3 } { to 0 } { reg-class int-regs } }
 112         T{ register->register { from 0 } { to 2 } { reg-class int-regs } }
 113     } mapping-instructions
 114 ] unit-test
 115
 116 [
 117     {
 118         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 119         T{ _copy { dst 2 } { src 0 } { class int-regs } }
 120         T{ _spill { src 4 } { class int-regs } { n 10 } }
 121         T{ _copy { dst 4 } { src 0 } { class int-regs } }
 122         T{ _copy { dst 0 } { src 3 } { class int-regs } }
 123         T{ _reload { dst 3 } { class int-regs } { n 10 } }
 124     }
 125 ] [
 126     {
 127         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 128         T{ register->register { from 0 } { to 2 } { reg-class int-regs } }
 129         T{ register->register { from 3 } { to 0 } { reg-class int-regs } }
 130         T{ register->register { from 4 } { to 3 } { reg-class int-regs } }
 131         T{ register->register { from 0 } { to 4 } { reg-class int-regs } }
 132     } mapping-instructions
 133 ] unit-test
 134
 135 [
 136     {
 137         T{ _copy { dst 2 } { src 0 } { class int-regs } }
 138         T{ _copy { dst 9 } { src 1 } { class int-regs } }
 139         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 140         T{ _spill { src 4 } { class int-regs } { n 10 } }
 141         T{ _copy { dst 4 } { src 0 } { class int-regs } }
 142         T{ _copy { dst 0 } { src 3 } { class int-regs } }
 143         T{ _reload { dst 3 } { class int-regs } { n 10 } }
 144     }
 145 ] [
 146     {
 147         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 148         T{ register->register { from 0 } { to 2 } { reg-class int-regs } }
 149         T{ register->register { from 1 } { to 9 } { reg-class int-regs } }
 150         T{ register->register { from 3 } { to 0 } { reg-class int-regs } }
 151         T{ register->register { from 4 } { to 3 } { reg-class int-regs } }
 152         T{ register->register { from 0 } { to 4 } { reg-class int-regs } }
 153     } mapping-instructions
 154 ] unit-test