basis/compiler/cfg/linear-scan/allocation/state/state-tests.factor

   1 USING: accessors arrays assocs combinators.extras compiler.cfg
   2 compiler.cfg.instructions compiler.cfg.linear-scan.allocation
   3 compiler.cfg.linear-scan.allocation.state
   4 compiler.cfg.linear-scan.live-intervals compiler.cfg.utilities cpu.architecture
   5 cpu.x86.assembler.operands heaps kernel layouts namespaces sequences system
   6 tools.test ;
   7 IN: compiler.cfg.linear-scan.allocation.state.tests
   8
   9 ! active-intervals-for
  10 {
  11     V{ T{ live-interval-state { reg-class int-regs } { vreg 123 } } }
  12 } [
  13     f machine-registers init-allocator
  14     T{ live-interval-state { reg-class int-regs } { vreg 123 } }
  15     [ add-active ] keep active-intervals-for
  16 ] unit-test
  17
  18 ! add-active
  19 {
  20     {
  21         {
  22             int-regs
  23             V{
  24                 T{ live-interval-state
  25                    { vreg 123 }
  26                    { reg-class int-regs }
  27                 }
  28             }
  29         }
  30         { float-regs V{ } }
  31     }
  32 } [
  33     f machine-registers init-allocator
  34     T{ live-interval-state { reg-class int-regs } { vreg 123 } } add-active
  35     active-intervals get
  36 ] unit-test
  37
  38 ! add-use-position
  39 cpu x86.64? [
  40     {
  41         {
  42             { XMM0 1/0. }
  43             { XMM1 25 }
  44             { XMM2 1/0. }
  45             { XMM3 1/0. }
  46             { XMM4 1/0. }
  47             { XMM5 1/0. }
  48             { XMM6 1/0. }
  49             { XMM7 1/0. }
  50             { XMM8 1/0. }
  51             { XMM9 1/0. }
  52             { XMM10 1/0. }
  53             { XMM11 1/0. }
  54             { XMM12 1/0. }
  55             { XMM13 1/0. }
  56             { XMM14 1/0. }
  57             { XMM15 1/0. }
  58         }
  59     } [
  60         25 XMM1 machine-registers float-regs free-positions
  61         [ add-use-position ] keep
  62     ] unit-test
  63 ] when
  64
  65 ! add-use-position
  66 { { { "prutt" 12 } } } [
  67     30 "prutt" { { "prutt" 12 } } [ add-use-position ] keep
  68 ] unit-test
  69
  70 ! assign-spill-slot
  71 cpu x86.32?
  72 H{
  73     { { 3 4 } T{ spill-slot { n 32 } } }
  74     { { 1234 4 } T{ spill-slot } }
  75     { { 45 16 } T{ spill-slot { n 16 } } }
  76 }
  77 H{
  78     { { 3 8 } T{ spill-slot { n 32 } } }
  79     { { 1234 8 } T{ spill-slot } }
  80     { { 45 16 } T{ spill-slot { n 16 } } }
  81 } ? 1array
  82 [
  83     H{ } clone spill-slots set
  84     f f <basic-block> <cfg> cfg set
  85     { 1234 45 3 } { int-rep double-2-rep tagged-rep }
  86     [ assign-spill-slot drop ] 2each
  87     spill-slots get
  88 ] unit-test
  89
  90 { t } [
  91     H{ } clone spill-slots set
  92     f f <basic-block> <cfg> cfg set
  93     55 int-rep assign-spill-slot spill-slots get values first eq?
  94 ] unit-test
  95
  96 ! check-handled
  97 { } [
  98     40 progress set
  99     T{ live-interval-state
 100        { end 34 }
 101        { reg-class int-regs }
 102        { vreg 123 }
 103     }
 104     check-handled
 105 ] unit-test
 106
 107 ! align-spill-area
 108 { t } [
 109     3 f f { } 0 insns>block <cfg> [ align-spill-area ] keep
 110     spill-area-align>> cell =
 111 ] unit-test
 112
 113 ! inactive-intervals-for
 114 {
 115     V{ T{ live-interval-state { reg-class int-regs } { vreg 123 } } }
 116 } [
 117     f machine-registers init-allocator
 118     T{ live-interval-state { reg-class int-regs } { vreg 123 } }
 119     [ add-inactive ] keep inactive-intervals-for
 120 ] unit-test
 121
 122 ! interval/sync-point-key
 123 { { 33 1/0.0 1/0.0 } } [
 124     T{ sync-point { n 33 } } interval/sync-point-key
 125 ] unit-test
 126
 127 ! next-spill-slot
 128 {
 129     T{ spill-slot f 0 }
 130     T{ spill-slot f 8 }
 131     T{ cfg { spill-area-size 16 } }
 132 } [
 133     H{ } clone spill-slots set
 134     T{ cfg { spill-area-size 0 } } cfg set
 135     [ 8 next-spill-slot ] twice
 136     cfg get
 137 ] unit-test
 138
 139 ! >unhandled-min-heap
 140 {
 141     {
 142         { { 5 1/0. 1/0. } T{ sync-point { n 5 } } }
 143         {
 144             { 20 28 f }
 145             T{ live-interval-state { start 20 } { end 28 } }
 146         }
 147         {
 148             { 20 30 f }
 149             T{ live-interval-state { start 20 } { end 30 } }
 150         }
 151         {
 152             { 33 999 f }
 153             T{ live-interval-state { start 33 } { end 999 } }
 154         }
 155         { { 33 1/0. 1/0. } T{ sync-point { n 33 } } }
 156         { { 100 1/0. 1/0. } T{ sync-point { n 100 } } }
 157     }
 158 } [
 159     {
 160         T{ live-interval-state { start 20 } { end 30 } }
 161         T{ live-interval-state { start 20 } { end 28 } }
 162         T{ live-interval-state { start 33 } { end 999 } }
 163         T{ sync-point { n 5 } }
 164         T{ sync-point { n 33 } }
 165         T{ sync-point { n 100 } }
 166     }
 167     >unhandled-min-heap heap-pop-all
 168 ] unit-test
 169
 170 { 2 } [
 171     {
 172         T{ live-interval-state { start 20 } { end 30 } }
 173         T{ live-interval-state { start 20 } { end 30 } }
 174     } >unhandled-min-heap heap-size
 175 ] unit-test