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     0 get test-live-interval-1 spill-to
  44 ] unit-test
  45
  46 [ 0 ] [
  47     1 get test-live-interval-1 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     0 get test-live-interval-2 reload-from
  62 ] unit-test
  63
  64 [ f ] [
  65     1 get test-live-interval-2 reload-from
  66 ] unit-test
  67
  68 [
  69     {
  70         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  71         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  72     }
  73 ] [
  74     {
  75         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  76         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  77     } trace-chains
  78 ] unit-test
  79
  80 [
  81     {
  82         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
  83         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  84         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  85     }
  86 ] [
  87     {
  88         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
  89         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  90         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  91     } trace-chains
  92 ] unit-test
  93
  94 [
  95     {
  96         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
  97         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
  98         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
  99     }
 100 ] [
 101     {
 102         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 103         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 104         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 105     } trace-chains
 106 ] unit-test
 107
 108 [
 109     {
 110         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 111         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 112         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 113     }
 114 ] [
 115     {
 116         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 117         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 118         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 119     } trace-chains
 120 ] unit-test
 121
 122 [
 123     {
 124         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 125         T{ register->memory { from 1 } { to 2 } { reg-class int-regs } }
 126         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 127     }
 128 ] [
 129     {
 130         T{ register->memory { from 1 } { to 2 } { reg-class int-regs } }
 131         T{ register->register { from 2 } { to 3 } { reg-class int-regs } }
 132         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 133     } trace-chains
 134 ] unit-test
 135
 136 [
 137     {
 138         T{ _copy { dst 5 } { src 4 } { class int-regs } }
 139         T{ _spill { src 1 } { class int-regs } { n 6 } }
 140         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 141         T{ _reload { dst 0 } { class int-regs } { n 6 } }
 142         T{ _spill { src 1 } { class float-regs } { n 7 } }
 143         T{ _copy { dst 1 } { src 0 } { class float-regs } }
 144         T{ _reload { dst 0 } { class float-regs } { n 7 } }
 145     }
 146 ] [
 147     {
 148         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 149         T{ register->register { from 1 } { to 0 } { reg-class int-regs } }
 150         T{ register->register { from 0 } { to 1 } { reg-class float-regs } }
 151         T{ register->register { from 1 } { to 0 } { reg-class float-regs } }
 152         T{ register->register { from 4 } { to 5 } { reg-class int-regs } }
 153     } mapping-instructions
 154 ] unit-test
 155
 156 [
 157     {
 158         T{ _spill { src 1 } { class int-regs } { n 3 } }
 159         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 160         T{ _copy { dst 0 } { src 2 } { class int-regs } }
 161         T{ _reload { dst 2 } { class int-regs } { n 3 } }
 162     }
 163 ] [
 164     {
 165         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 166         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 167         T{ register->register { from 2 } { to 0 } { reg-class int-regs } }
 168     } mapping-instructions
 169 ] unit-test
 170
 171 [
 172     {
 173         T{ _spill { src 1 } { class int-regs } { n 3 } }
 174         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 175         T{ _copy { dst 0 } { src 2 } { class int-regs } }
 176         T{ _reload { dst 2 } { class int-regs } { n 3 } }
 177     }
 178 ] [
 179     {
 180         T{ register->register { from 1 } { to 2 } { reg-class int-regs } }
 181         T{ register->register { from 2 } { to 0 } { reg-class int-regs } }
 182         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 183     } mapping-instructions
 184 ] unit-test
 185
 186 [
 187     {
 188         T{ _copy { dst 1 } { src 0 } { class int-regs } }
 189         T{ _copy { dst 2 } { src 0 } { class int-regs } }
 190     }
 191 ] [
 192     {
 193         T{ register->register { from 0 } { to 1 } { reg-class int-regs } }
 194         T{ register->register { from 0 } { to 2 } { reg-class int-regs } }
 195     } mapping-instructions
 196 ] unit-test
 197
 198 [
 199     { }
 200 ] [
 201     {
 202        T{ register->register { from 4 } { to 4 } { reg-class int-regs } }
 203     } mapping-instructions
 204 ] unit-test
 205
 206 [
 207     { T{ _spill { src 4 } { class int-regs } { n 4 } } }
 208 ] [
 209     {
 210        T{ register->memory { from 4 } { to 4 } { reg-class int-regs } }
 211     } mapping-instructions
 212 ] unit-test