compiler.*: Remove the scrubbing part of the GC maps

[factor.git] / basis / compiler / codegen / gc-maps / gc-maps-tests.factor

diff --git a/basis/compiler/codegen/gc-maps/gc-maps-tests.factor b/basis/compiler/codegen/gc-maps/gc-maps-tests.factor
index 7b86f8dbba93cbf1b8823f1b53e96fcacfa52366..cff79e6ef6f87c7e2e7be48baff02a02cfaf8fc6 100644 (file)
--- a/basis/compiler/codegen/gc-maps/gc-maps-tests.factor
+++ b/basis/compiler/codegen/gc-maps/gc-maps-tests.factor
@@ -1,7 +1,8 @@
-USING: accessors alien.c-types arrays bit-arrays classes.struct compiler.cfg
-compiler.cfg.instructions compiler.cfg.stack-frame compiler.cfg.utilities
+USING: accessors alien.c-types arrays bit-arrays byte-arrays
+classes.struct compiler.cfg compiler.cfg.instructions
+compiler.cfg.stack-frame compiler.cfg.utilities
 compiler.codegen.gc-maps compiler.codegen.relocation cpu.architecture
-cpu.x86 byte-arrays make namespaces kernel layouts math sequences
+cpu.x86 kernel layouts make math namespaces sequences
 specialized-arrays system tools.test ;
 QUALIFIED: vm
 SPECIALIZED-ARRAY: uint
@@ -25,8 +26,6 @@ M: fake-cpu gc-root-offset ;
     50 <byte-array> %
 
     T{ gc-map
-       { scrub-d { 0 1 1 1 0 } }
-       { scrub-r { 1 0 } }
        { gc-roots V{ 1 3 } }
        { derived-roots V{ { 2 4 } } }
     } gc-map-here
@@ -39,30 +38,24 @@ M: fake-cpu gc-root-offset ;
 [
     100 <byte-array> %
 
-    ! The below data is 38 bytes -- 6 bytes padding needed to
+    ! The below data is 29 bytes -- 15 bytes padding needed to
     ! align
-    6 <byte-array> %
+    15 <byte-array> %
 
-    ! Bitmap - 2 bytes
+    ! Bitmap - 1 byte
     ?{
-        ! scrub-d
-        t f f f t
-        ! scrub-r
-        f t
         ! gc-roots
         f t f t
     } underlying>> %
 
-    ! Derived pointers
+    ! Derived pointers - 12 bytes
     uint-array{ -1 -1 4 } underlying>> %
 
-    ! Return addresses
+    ! Return addresses - 4 bytes
     uint-array{ 100 } underlying>> %
 
-    ! GC info footer - 20 bytes
+    ! GC info footer - 12 bytes
     S{ vm:gc-info
-       { scrub-d-count 5 }
-       { scrub-r-count 2 }
        { gc-root-count 4 }
        { derived-root-count 3 }
        { return-address-count 1 }
@@ -83,55 +76,40 @@ M: linux-x86.64 gc-root-offset
     stack-frame new swap >>spill-area-base
     { } insns>cfg swap >>stack-frame ;
 
+: array>spill-slots ( seq -- spills )
+    [ spill-slot boa ] map ;
+
+: <gc-map/spills> ( spills -- gc-map )
+    array>spill-slots { } gc-map boa ;
+
 cpu x86.64? [
     linux-x86.64 \ cpu set
 
     ! gc-root-offsets
     { { 1 3 } } [
         0 cfg-w-spill-area-base cfg [
-            T{ gc-map
-               { gc-roots {
-                   T{ spill-slot { n 0 } }
-                   T{ spill-slot { n 16 } }
-               } }
-            } gc-root-offsets
+            { 0 16 } <gc-map/spills> gc-root-offsets
         ] with-variable
     ] unit-test
 
     { { 6 10 } } [
         32 cfg-w-spill-area-base cfg [
-            T{ gc-map
-               { gc-roots {
-                   T{ spill-slot { n 8 } }
-                   T{ spill-slot { n 40 } }
-               } }
-            } gc-root-offsets
+            { 8 40 } <gc-map/spills> gc-root-offsets
         ] with-variable
     ] unit-test
 
-    ! scrub-d scrub-r gc-roots
-    { { 0 0 5 } } [
+    { 5 B{ 18 } } [
         0 cfg-w-spill-area-base cfg [
-            T{ gc-map
-               { gc-roots {
-                   T{ spill-slot { n 0 } }
-                   T{ spill-slot { n 24 } }
-               } }
-            } 1array
-            [ emit-gc-info-bitmaps ] B{ } make drop
+            { 0 24 } <gc-map/spills> 1array
+            [ emit-gc-info-bitmap ] B{ } make
         ] with-variable
     ] unit-test
 
     ! scrub-d scrub-r gc-roots
-    { { 0 0 9 } } [
+    { 9 B{ 32 1 } } [
         32 cfg-w-spill-area-base cfg [
-            T{ gc-map
-               { gc-roots {
-                   T{ spill-slot { n 0 } }
-                   T{ spill-slot { n 24 } }
-               } }
-            } 1array
-            [ emit-gc-info-bitmaps ] B{ } make drop
+            { 0 24 } <gc-map/spills> 1array
+            [ emit-gc-info-bitmap ] B{ } make
         ] with-variable
     ] unit-test
 
@@ -149,35 +127,18 @@ cpu x86.64? [
 ] unit-test
 
 ! gc-map-needed?
-{ t t } [
-    T{ gc-map { scrub-d { 0 1 1 1 0 } } { scrub-r { 1 0 } } } gc-map-needed?
-    T{ gc-map { scrub-d { 0 1 1 1 } } } gc-map-needed?
-] unit-test
-
-! emit-scrub
-{ 3 V{ t t t f f f } } [
-    [ { { 0 0 0 } { 1 1 1 } } emit-scrub ] V{ } make
-] unit-test
-
-! emit-gc-info-bitmaps
-{
-    { 4 2 0 }
-    V{ 1 }
-} [
-    { T{ gc-map { scrub-d { 0 1 1 1 } } { scrub-r { 1 1 } } } }
-    [ emit-gc-info-bitmaps ] V{ } make
+{ f } [
+    T{ gc-map } gc-map-needed?
 ] unit-test
 
+! emit-gc-info-bitmap
 {
-    { 1 0 0 }
-    V{ 1 }
+    0 V{ }
 } [
-    { T{ gc-map { scrub-d { 0 } } } }
-    [ emit-gc-info-bitmaps ] V{ } make
+    { T{ gc-map } } [ emit-gc-info-bitmap ] V{ } make
 ] unit-test
 
-! derived-root-offsets
-USING: present prettyprint ;
+! ! derived-root-offsets
 {
     V{ { 2 4 } }
 } [
@@ -201,19 +162,17 @@ USING: present prettyprint ;
 ] unit-test
 
 {
-    B{ 17 123 0 0 0 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 }
+    B{ 123 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 }
 } [
     { 123 } return-addresses set
-    { T{ gc-map { scrub-d { 0 1 1 1 0 } } } } gc-maps set
+    { T{ gc-map } } gc-maps set
     serialize-gc-maps
 ] unit-test
 
 ! gc-info + ret-addr + 9bits (5+2+2) = 20 + 4 + 2 = 26
-{ 26 } [
+{ 17 } [
     {
         T{ gc-map
-           { scrub-d { 0 1 1 1 0 } }
-           { scrub-r { 1 0 } }
            { gc-roots V{ 1 3 } }
         }
     } gc-maps set
@@ -222,11 +181,9 @@ USING: present prettyprint ;
 ] unit-test
 
 ! gc-info + ret-addr + 3 base-pointers + 9bits = 20 + 4 + 12 + 2 = 38
-{ 38 } [
+{ 29 } [
     {
         T{ gc-map
-           { scrub-d { 0 1 1 1 0 } }
-           { scrub-r { 1 0 } }
            { gc-roots V{ 1 3 } }
            { derived-roots V{ { 2 4 } } }
         }