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

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