compiler.*: new cfg instruction ##clear, it makes it easier to see where

the compiler.cfg.stacks.clearing pass inserts extra instructions

basis/compiler/cfg/instructions/instructions.factor

@@ -57,6 +57,9 @@ literal: loc ;
 INSN: ##replace-imm
 literal: src loc ;
 
+INSN: ##clear
+literal: loc ;
+
 INSN: ##inc
 literal: loc ;
 

basis/compiler/cfg/stacks/clearing/clearing-tests.factor

@@ -7,8 +7,8 @@ IN: compiler.cfg.stacks.clearing.tests
 {
     V{
         T{ ##inc { loc D 2 } { insn# 0 } }
-        T{ ##replace-imm { src 297 } { loc T{ ds-loc { n 1 } } } }
-        T{ ##replace-imm { src 297 } { loc T{ ds-loc } } }
+        T{ ##clear { loc T{ ds-loc { n 1 } } } }
+        T{ ##clear { loc T{ ds-loc } } }
         T{ ##peek { loc D 2 } { insn# 1 } }
     }
 } [

basis/compiler/cfg/stacks/clearing/clearing.factor

@@ -3,22 +3,20 @@ compiler.cfg.instructions compiler.cfg.registers compiler.cfg.rpo
 compiler.cfg.stacks compiler.cfg.stacks.padding kernel math sequences ;
 IN: compiler.cfg.stacks.clearing
 
-! This step maybe is redundant.
-
-: state>replaces ( state -- replaces )
+: state>clears ( state -- clears )
     [ second ] map { ds-loc rs-loc } [ swap create-locs ] 2map concat
-    [ 297 swap f ##replace-imm boa ] map ;
+    [ f ##clear boa ] map ;
 
 : dangerous-insn? ( state insn -- ? )
     { [ nip ##peek? ] [ underflowable-peek? ] } 2&& ;
 
-: clearing-replaces ( assoc insn -- insns' )
+: clearing-insns ( assoc insn -- insns' )
     [ insn#>> of ] keep 2dup dangerous-insn? [
-        drop state>replaces
+        drop state>clears
     ] [ 2drop { } ] if ;
 
 : visit-insns ( assoc insns -- insns' )
-    [ [ clearing-replaces ] keep suffix ] with map V{ } concat-as ;
+    [ [ clearing-insns ] keep suffix ] with map V{ } concat-as ;
 
 : clear-uninitialized ( cfg -- )
     [ trace-stack-state2 ] keep [

basis/compiler/codegen/codegen.factor

@@ -147,6 +147,7 @@ CODEGEN: ##load-vector %load-vector
 CODEGEN: ##peek %peek
 CODEGEN: ##replace %replace
 CODEGEN: ##replace-imm %replace-imm
+CODEGEN: ##clear %clear
 CODEGEN: ##inc %inc
 CODEGEN: ##call %call
 CODEGEN: ##jump %jump

basis/cpu/architecture/architecture.factor

@@ -231,6 +231,7 @@ HOOK: %load-vector cpu ( reg val rep -- )
 HOOK: %peek cpu ( vreg loc -- )
 HOOK: %replace cpu ( vreg loc -- )
 HOOK: %replace-imm cpu ( src loc -- )
+HOOK: %clear cpu ( loc -- )
 HOOK: %inc cpu ( loc -- )
 
 HOOK: stack-frame-size cpu ( stack-frame -- n )

basis/cpu/ppc/ppc.factor

@@ -184,6 +184,9 @@ M:: ppc %replace-imm ( src loc -- )
     } cond
     scratch-reg reg offset %store-cell ;
 
+M: ppc %clear ( loc -- )
+    297 swap %replace-imm ;
+
 ! Increment stack pointer by n cells.
 M: ppc %inc ( loc -- )
     [ ds-loc? [ ds-reg ds-reg ] [ rs-reg rs-reg ] if ] [ n>> ] bi cells ADDI ;

basis/cpu/x86/x86.factor

@@ -90,6 +90,9 @@ M: x86 %replace-imm
         [ [ 0xffffffff MOV ] dip rc-absolute rel-literal ]
     } cond ;
 
+M: x86 %clear ( loc -- )
+    loc>operand 297 MOV ;
+
 : (%inc) ( n reg -- ) swap cells dup 0 > [ ADD ] [ neg SUB ] if ; inline
 
 M: x86 %inc ( loc -- )