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

   1 USING: accessors arrays classes compiler.cfg
   2 compiler.cfg.instructions compiler.cfg.linear-scan.debugger
   3 compiler.cfg.linear-scan.live-intervals
   4 compiler.cfg.linear-scan.numbering
   5 compiler.cfg.linear-scan.resolve compiler.cfg.predecessors
   6 compiler.cfg.registers compiler.cfg.rpo cpu.architecture kernel
   7 multiline namespaces tools.test vectors ;
   8 IN: compiler.cfg.linear-scan.resolve.tests
   9
  10 [ { 1 2 3 4 5 6 } ] [
  11     { 3 4 } V{ 1 2 } clone [ { 5 6 } 3append-here ] keep >array
  12 ] unit-test
  13
  14 V{
  15     T{ ##peek f V int-regs 0 D 0 }
  16     T{ ##branch }
  17 } 0 test-bb
  18
  19 V{
  20     T{ ##replace f V int-regs 0 D 1 }
  21     T{ ##return }
  22 } 1 test-bb
  23
  24 1 get 1vector 0 get (>>successors)
  25
  26 cfg new 0 get >>entry
  27 compute-predecessors
  28 dup reverse-post-order number-instructions
  29 drop
  30
  31 CONSTANT: test-live-interval-1
  32 T{ live-interval
  33    { start 0 }
  34    { end 6 }
  35    { uses V{ 0 6 } }
  36    { ranges V{ T{ live-range f 0 2 } T{ live-range f 4 6 } } }
  37    { spill-to 0 }
  38    { vreg V int-regs 0 }
  39 }
  40
  41 [ f ] [
  42     0 get test-live-interval-1 spill-to
  43 ] unit-test
  44
  45 [ 0 ] [
  46     1 get test-live-interval-1 spill-to
  47 ] unit-test
  48
  49 CONSTANT: test-live-interval-2
  50 T{ live-interval
  51    { start 0 }
  52    { end 6 }
  53    { uses V{ 0 6 } }
  54    { ranges V{ T{ live-range f 0 2 } T{ live-range f 4 6 } } }
  55    { reload-from 0 }
  56    { vreg V int-regs 0 }
  57 }
  58
  59 [ 0 ] [
  60     0 get test-live-interval-2 reload-from
  61 ] unit-test
  62
  63 [ f ] [
  64     1 get test-live-interval-2 reload-from
  65 ] unit-test
  66
  67 [
  68     {
  69         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  70         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  71     }
  72 ] [
  73     {
  74         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  75         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  76     } trace-chains
  77 ] unit-test
  78
  79 [
  80     {
  81         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
  82         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  83         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  84     }
  85 ] [
  86     {
  87         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
  88         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  89         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  90     } trace-chains
  91 ] unit-test
  92
  93 [
  94     {
  95         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
  96         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  97         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  98     }
  99 ] [
 100     {
 101         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 102         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 103         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 104     } trace-chains
 105 ] unit-test
 106
 107 [
 108     {
 109         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 110         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 111         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 112     }
 113 ] [
 114     {
 115         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 116         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 117         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 118     } trace-chains
 119 ] unit-test
 120
 121 [
 122     {
 123         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 124         T{ register->memory { from 1 } { to 2 } { reg-class int-regs } }
 125         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 126     }
 127 ] [
 128     {
 129         T{ register->memory { from 1 } { to 2 } { reg-class int-regs } }
 130         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 131         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 132     } trace-chains
 133 ] unit-test
 134
 135 [
 136     {
 137         T{ _copy { dst 5 } { src 4 } { class int-regs } }
 138         T{ _spill { src 1 } { class int-regs } { n 6 } }
 139         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 140         T{ _reload { dst 0 } { class int-regs } { n 6 } }
 141         T{ _spill { src 1 } { class float-regs } { n 7 } }
 142         T{ _copy { dst 1 } { src 0 } { class float-regs } }
 143         T{ _reload { dst 0 } { class float-regs } { n 7 } }
 144     }
 145 ] [
 146     {
 147         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 148         T{ register->register { from 1 } { to 0 } { reg-class int-regs } }
 149         T{ register->register { from 0 } { to 1 } { reg-class float-regs } }
 150         T{ register->register { from 1 } { to 0 } { reg-class float-regs } }
 151         T{ register->register { from 4 } { to 5 } { reg-class int-regs } }
 152     } mapping-instructions
 153 ] unit-test
 154
 155 [
 156     {
 157         T{ _spill { src 1 } { class int-regs } { n 3 } }
 158         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 159         T{ _copy { dst 0 } { src 2 } { class int-regs } }
 160         T{ _reload { dst 2 } { class int-regs } { n 3 } }
 161     }
 162 ] [
 163     {
 164         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 165         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 166         T{ register->register { from 2 } { to 0 } { reg-class int-regs } }
 167     } mapping-instructions
 168 ] unit-test
 169
 170 [
 171     {
 172         T{ _spill { src 1 } { class int-regs } { n 3 } }
 173         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 174         T{ _copy { dst 0 } { src 2 } { class int-regs } }
 175         T{ _reload { dst 2 } { class int-regs } { n 3 } }
 176     }
 177 ] [
 178     {
 179         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 180         T{ register->register { from 2 } { to 0 } { reg-class int-regs } }
 181         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 182     } mapping-instructions
 183 ] unit-test
 184
 185 [
 186     {
 187         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 188         T{ _copy { dst 2 } { src 0 } { class int-regs } }
 189     }
 190 ] [
 191     {
 192         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 193         T{ register->register { from 0 } { to 2 } { reg-class int-regs } }
 194     } mapping-instructions
 195 ] unit-test
 196
 197 [
 198     { }
 199 ] [
 200     {
 201        T{ register->register { from 4 } { to 4 } { reg-class int-regs } }
 202     } mapping-instructions
 203 ] unit-test
 204
 205 [
 206     { T{ _spill { src 4 } { class int-regs } { n 4 } } }
 207 ] [
 208     {
 209        T{ register->memory { from 4 } { to 4 } { reg-class int-regs } }
 210     } mapping-instructions
 211 ] unit-test