compiler.cfg.linear-scan.*: change compute-live-intervals so that it

returns only one sequence, it makes some words a little simpler

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

@@ -63,6 +63,6 @@ M: sync-point handle ( sync-point -- )
     handled-intervals get
     active-intervals inactive-intervals [ get values concat ] bi@ 3append ;
 
-: allocate-registers ( live-intervals sync-point registers -- live-intervals' )
+: allocate-registers ( intervals/sync-point registers -- live-intervals' )
     init-allocator unhandled-min-heap get (allocate-registers)
     gather-intervals ;

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

@@ -9,7 +9,7 @@ IN: compiler.cfg.linear-scan.allocation.state.tests
 {
     V{ T{ live-interval-state { reg-class int-regs } { vreg 123 } } }
 } [
-    f f machine-registers init-allocator
+    f machine-registers init-allocator
     T{ live-interval-state { reg-class int-regs } { vreg 123 } }
     [ add-active ] keep active-intervals-for
 ] unit-test
@@ -29,7 +29,7 @@ IN: compiler.cfg.linear-scan.allocation.state.tests
         { float-regs V{ } }
     }
 } [
-    f f machine-registers init-allocator
+    f machine-registers init-allocator
     T{ live-interval-state { reg-class int-regs } { vreg 123 } } add-active
     active-intervals get
 ] unit-test
@@ -164,8 +164,6 @@ cpu x86.64? [
         T{ live-interval-state { start 20 } { end 30 } }
         T{ live-interval-state { start 20 } { end 28 } }
         T{ live-interval-state { start 33 } { end 999 } }
-    }
-    {
         T{ sync-point { n 5 } }
         T{ sync-point { n 33 } }
         T{ sync-point { n 100 } }
@@ -177,5 +175,5 @@ cpu x86.64? [
     {
         T{ live-interval-state { start 20 } { end 30 } }
         T{ live-interval-state { start 20 } { end 30 } }
-    } { } >unhandled-min-heap heap-size
+    } >unhandled-min-heap heap-size
 ] unit-test

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

@@ -26,11 +26,8 @@ M: live-interval-state interval/sync-point-key
 M: sync-point interval/sync-point-key
     n>> 1/0. 1/0. 3array ;
 
-: zip-keyed ( seq quot: ( elt -- key ) -- alist )
+: >unhandled-min-heap ( intervals/sync-points -- min-heap )
-    [ keep ] curry { } map>assoc ; inline
+    [ [ interval/sync-point-key ] keep 2array ] map >min-heap ;
-
-: >unhandled-min-heap ( live-intervals sync-points -- min-heap )
-    append [ interval/sync-point-key ] zip-keyed >min-heap ;
 
 SYMBOL: registers
 
@@ -134,7 +131,7 @@ SYMBOL: spill-slots
 : lookup-spill-slot ( coalesced-vreg rep -- spill-slot )
     rep-size 2array spill-slots get ?at [ ] [ bad-vreg ] if ;
 
-: init-allocator ( live-intervals sync-points registers -- )
+: init-allocator ( intervals/sync-points registers -- )
     registers set
     >unhandled-min-heap unhandled-min-heap set
     [ V{ } clone ] reg-class-assoc active-intervals set

basis/compiler/cfg/linear-scan/debugger/debugger.factor

@@ -10,7 +10,6 @@ IN: compiler.cfg.linear-scan.debugger
     [
         [ clone ] map dup [ [ vreg>> ] keep ] H{ } map>assoc
         live-intervals set
-        f
     ] dip
     allocate-registers drop ;
 

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

@@ -40,7 +40,7 @@ V{
 : test-live-intervals ( -- )
     0 get block>cfg
     [ cfg set ] [ number-instructions ] [ compute-live-intervals ] tri
-    2drop ;
+    drop ;
 
 [ ] [
     H{

basis/compiler/cfg/linear-scan/live-intervals/live-intervals-tests.factor

@@ -1,4 +1,6 @@
-USING: compiler.cfg.linear-scan.live-intervals cpu.architecture kernel
+USING: arrays compiler.cfg compiler.cfg.linear-scan.live-intervals
+compiler.cfg.liveness compiler.cfg.registers
+compiler.cfg.ssa.destruction.leaders cpu.architecture kernel namespaces
 sequences tools.test ;
 IN: compiler.cfg.linear-scan.live-intervals.tests
 
@@ -14,3 +16,61 @@ IN: compiler.cfg.linear-scan.live-intervals.tests
     5 int-rep <live-interval> dup
     { { 5 10 } { 8 12 } } [ first2 rot add-range ] with each
 ] unit-test
+
+{
+    T{ live-interval-state
+       { vreg 5 }
+       { ranges V{ T{ live-range { from 5 } { to 12 } } } }
+       { uses V{ } }
+       { reg-class int-rep }
+    }
+} [
+    5 int-rep <live-interval> dup
+    { { 10 12 } { 5 10 } } [ first2 rot add-range ] with each
+] unit-test
+
+! handle-live-out
+{ } [
+    H{ } clone live-outs set
+    <basic-block> handle-live-out
+] unit-test
+
+{
+    H{
+        {
+            8
+            T{ live-interval-state
+               { vreg 8 }
+               { ranges V{ T{ live-range { from -10 } { to 23 } } } }
+               { uses V{ } }
+               { reg-class int-regs }
+            }
+        }
+        {
+            9
+            T{ live-interval-state
+               { vreg 9 }
+               { ranges V{ T{ live-range { from -10 } { to 23 } } } }
+               { uses V{ } }
+               { reg-class int-regs }
+            }
+        }
+        {
+            4
+            T{ live-interval-state
+               { vreg 4 }
+               { ranges V{ T{ live-range { from -10 } { to 23 } } } }
+               { uses V{ } }
+               { reg-class int-regs }
+            }
+        }
+    }
+} [
+    -10 from set
+    23 to set
+    init-live-intervals
+    H{ { 4 4 } { 8 8 } { 9 9 } } leader-map set
+    H{ { 4 int-rep } { 8 int-rep } { 9 int-rep } } representations set
+    <basic-block> [ H{ { 4 4 } { 8 8 } { 9 9 } } 2array 1array live-outs set ]
+    [ handle-live-out ] bi live-intervals get
+] unit-test

basis/compiler/cfg/linear-scan/live-intervals/live-intervals.factor

@@ -154,10 +154,8 @@ M: hairy-clobber-insn compute-live-intervals* ( insn -- )
     2tri ;
 
 : handle-live-out ( bb -- )
-    live-out dup assoc-empty? [ drop ] [
+    [ from get to get ] dip live-out keys
-        [ from get to get ] dip keys
+    [ live-interval add-range ] 2with each ;
-        [ live-interval add-range ] 2with each
-    ] if ;
 
 TUPLE: sync-point n keep-dst? ;
 
@@ -202,8 +200,8 @@ ERROR: bad-live-interval live-interval ;
 : check-start ( live-interval -- )
     dup start>> -1 = [ bad-live-interval ] [ drop ] if ;
 
-: finish-live-intervals ( live-intervals -- seq )
+: finish-live-intervals ( live-intervals -- )
-    values dup [
+    [
         {
             [ [ { } like reverse! ] change-ranges drop ]
             [ [ { } like reverse! ] change-uses drop ]
@@ -212,12 +210,12 @@ ERROR: bad-live-interval live-interval ;
         } cleave
     ] each ;
 
-: compute-live-intervals ( cfg -- live-intervals sync-points )
+: compute-live-intervals ( cfg -- intervals/sync-points )
     init-live-intervals
-    linearization-order <reversed> [ kill-block?>> ] reject
+    linearization-order [ kill-block?>> ] reject <reversed>
     [ compute-live-intervals-step ] each
-    live-intervals get finish-live-intervals
+    live-intervals get values dup finish-live-intervals
-    sync-points get ;
+    sync-points get append ;
 
 : relevant-ranges ( interval1 interval2 -- ranges1 ranges2 )
     [ [ ranges>> ] bi@ ] [ nip start>> ] 2bi '[ to>> _ >= ] filter ;