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