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