From c14141a6b530e920f08fa301895feb9d238ddb19 Mon Sep 17 00:00:00 2001
From: Alex Vondrak <ajvondrak@csupomona.edu>
Date: Sat, 4 Aug 2012 22:49:27 -0700
Subject: [PATCH] compiler.cfg.gvn.tests: fix the old, single-basic-block tests
 from compiler.cfg.value-numbering (which was nearly all of them) to work with
 new gvn interface

---
 extra/compiler/cfg/gvn/gvn-tests.factor | 1066 ++++++++++++-----------
 1 file changed, 536 insertions(+), 530 deletions(-)

diff --git a/extra/compiler/cfg/gvn/gvn-tests.factor b/extra/compiler/cfg/gvn/gvn-tests.factor
index e6337f1ab4..ee2f1d9b5d 100644
--- a/extra/compiler/cfg/gvn/gvn-tests.factor
+++ b/extra/compiler/cfg/gvn/gvn-tests.factor
@@ -26,114 +26,120 @@ IN: compiler.cfg.gvn.tests
         } 1|| [ f >>temp ] when
     ] map ;
 
+: value-number-bb ( insns -- insns' )
+    0 test-bb
+    cfg new 0 get >>entry dup cfg set
+    value-numbering
+    entry>> instructions>> ;
+
 ! Folding constants together
 [
-    {
+    V{
         T{ ##load-reference f 0 0.0 }
         T{ ##load-reference f 1 -0.0 }
     }
 ] [
-    {
+    V{
         T{ ##load-reference f 0 0.0 }
         T{ ##load-reference f 1 -0.0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-reference f 0 0.0 }
         T{ ##copy f 1 0 any-rep }
     }
 ] [
-    {
+    V{
         T{ ##load-reference f 0 0.0 }
         T{ ##load-reference f 1 0.0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-reference f 0 t }
         T{ ##copy f 1 0 any-rep }
     }
 ] [
-    {
+    V{
         T{ ##load-reference f 0 t }
         T{ ##load-reference f 1 t }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! ##load-reference/##replace fusion
 cpu x86? [
     [
-        {
+        V{
             T{ ##load-integer f 0 10 }
             T{ ##replace-imm f 10 D 0 }
         }
     ] [
-        {
+        V{
             T{ ##load-integer f 0 10 }
             T{ ##replace f 0 D 0 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##load-reference f 0 f }
             T{ ##replace-imm f f D 0 }
         }
     ] [
-        {
+        V{
             T{ ##load-reference f 0 f }
             T{ ##replace f 0 D 0 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 ] when
 
 cpu x86.32? [
     [
-        {
+        V{
             T{ ##load-reference f 0 + }
             T{ ##replace-imm f + D 0 }
         }
     ] [
-        {
+        V{
             T{ ##load-reference f 0 + }
             T{ ##replace f 0 D 0 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 ] when
 
 cpu x86.64? [
     [
-        {
+        V{
             T{ ##load-integer f 0 10,000,000,000 }
             T{ ##replace f 0 D 0 }
         }
     ] [
-        {
+        V{
             T{ ##load-integer f 0 10,000,000,000 }
             T{ ##replace f 0 D 0 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     ! Boundary case
     [
-        {
+        V{
             T{ ##load-integer f 0 0x7fffffff }
             T{ ##replace f 0 D 0 }
         }
     ] [
-        {
+        V{
             T{ ##load-integer f 0 0x7fffffff }
             T{ ##replace f 0 D 0 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 ] when
 
 ! Double compare elimination
 [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##peek f 2 D 2 }
         T{ ##compare f 4 2 1 cc= }
@@ -141,33 +147,33 @@ cpu x86.64? [
         T{ ##replace f 6 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##peek f 2 D 2 }
         T{ ##compare f 4 2 1 cc= }
         T{ ##compare-imm f 6 4 f cc/= }
         T{ ##replace f 6 D 0 }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##compare-imm f 2 1 16 cc= }
         T{ ##copy f 3 2 any-rep }
         T{ ##replace f 3 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##compare-imm f 2 1 16 cc= }
         T{ ##compare-imm f 3 2 f cc/= }
         T{ ##replace f 3 D 0 }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##peek f 2 D 2 }
         T{ ##compare-integer f 4 2 1 cc> }
@@ -175,17 +181,17 @@ cpu x86.64? [
         T{ ##replace f 6 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##peek f 2 D 2 }
         T{ ##compare-integer f 4 2 1 cc> }
         T{ ##compare-imm f 6 4 f cc/= }
         T{ ##replace f 6 D 0 }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##peek f 2 D 2 }
         T{ ##compare-integer f 4 2 1 cc<= }
@@ -193,33 +199,33 @@ cpu x86.64? [
         T{ ##replace f 6 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##peek f 2 D 2 }
         T{ ##compare-integer f 4 2 1 cc<= }
         T{ ##compare-imm f 6 4 f cc= }
         T{ ##replace f 6 D 0 }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##compare-integer-imm f 2 1 100 cc<= }
         T{ ##compare-integer-imm f 3 1 100 cc/<= }
         T{ ##replace f 3 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 1 D 1 }
         T{ ##compare-integer-imm f 2 1 100 cc<= }
         T{ ##compare-imm f 3 2 f cc= }
         T{ ##replace f 3 D 0 }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 8 D 0 }
         T{ ##peek f 9 D -1 }
         T{ ##compare-float-unordered f 12 8 9 cc< }
@@ -227,1066 +233,1066 @@ cpu x86.64? [
         T{ ##replace f 14 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 8 D 0 }
         T{ ##peek f 9 D -1 }
         T{ ##compare-float-unordered f 12 8 9 cc< }
         T{ ##compare-imm f 14 12 f cc= }
         T{ ##replace f 14 D 0 }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 29 D -1 }
         T{ ##peek f 30 D -2 }
         T{ ##compare f 33 29 30 cc= }
         T{ ##compare-branch f 29 30 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 29 D -1 }
         T{ ##peek f 30 D -2 }
         T{ ##compare f 33 29 30 cc= }
         T{ ##compare-imm-branch f 33 f cc/= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 29 D -1 }
         T{ ##peek f 30 D -2 }
         T{ ##compare-integer f 33 29 30 cc<= }
         T{ ##compare-integer-branch f 29 30 cc<= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 29 D -1 }
         T{ ##peek f 30 D -2 }
         T{ ##compare-integer f 33 29 30 cc<= }
         T{ ##compare-imm-branch f 33 f cc/= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 29 D -1 }
         T{ ##peek f 30 D -2 }
         T{ ##test f 33 29 30 cc= }
         T{ ##test-branch f 29 30 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 29 D -1 }
         T{ ##peek f 30 D -2 }
         T{ ##test f 33 29 30 cc= }
         T{ ##compare-imm-branch f 33 f cc/= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 29 D -1 }
         T{ ##test-imm f 33 29 30 cc= }
         T{ ##test-imm-branch f 29 30 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 29 D -1 }
         T{ ##test-imm f 33 29 30 cc= }
         T{ ##compare-imm-branch f 33 f cc/= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 1 D -1 }
         T{ ##test-vector f 2 1 f float-4-rep vcc-any }
         T{ ##test-vector-branch f 1 f float-4-rep vcc-any }
     }
 ] [
-    {
+    V{
         T{ ##peek f 1 D -1 }
         T{ ##test-vector f 2 1 f float-4-rep vcc-any }
         T{ ##compare-imm-branch f 2 f cc/= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 cpu x86.32? [
     [
-        {
+        V{
             T{ ##peek f 1 D 0 }
             T{ ##compare-imm f 2 1 + cc= }
             T{ ##compare-imm-branch f 1 + cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 1 D 0 }
             T{ ##compare-imm f 2 1 + cc= }
             T{ ##compare-imm-branch f 2 f cc/= }
-        } value-numbering-step trim-temps
+        } value-number-bb trim-temps
     ] unit-test
 ] when
 
 ! Immediate operand fusion
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add f 2 0 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add f 2 1 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add-imm f 2 0 -100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##sub f 2 0 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##sub f 1 0 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##mul-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##mul f 2 0 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##mul-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##mul f 2 1 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 1 D 0 }
         T{ ##shl-imm f 2 1 3 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 1 D 0 }
         T{ ##mul-imm f 2 1 8 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 -1 }
         T{ ##neg f 2 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 -1 }
         T{ ##mul f 2 0 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 -1 }
         T{ ##neg f 2 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 -1 }
         T{ ##mul f 2 1 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 0 }
         T{ ##neg f 2 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 0 }
         T{ ##sub f 2 1 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 0 }
         T{ ##neg f 2 0 }
         T{ ##copy f 3 0 any-rep }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 0 }
         T{ ##sub f 2 1 0 }
         T{ ##sub f 3 1 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##neg f 1 0 }
         T{ ##copy f 2 0 any-rep }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##neg f 1 0 }
         T{ ##neg f 2 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##not f 1 0 }
         T{ ##copy f 2 0 any-rep }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##not f 1 0 }
         T{ ##not f 2 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##and-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##and f 2 0 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##and-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##and f 2 1 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##or-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##or f 2 0 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##or-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##or f 2 1 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##xor-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##xor f 2 0 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##xor-imm f 2 0 100 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##xor f 2 1 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-imm f 2 0 100 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare f 2 0 1 cc= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer-imm f 2 0 100 cc<= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer f 2 0 1 cc<= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 cpu x86.32? [
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-reference f 1 + }
             T{ ##compare-imm f 2 0 + cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-reference f 1 + }
             T{ ##compare f 2 0 1 cc= }
-        } value-numbering-step trim-temps
+        } value-number-bb trim-temps
     ] unit-test
 
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-reference f 1 + }
             T{ ##compare-imm-branch f 0 + cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-reference f 1 + }
             T{ ##compare-branch f 0 1 cc= }
-        } value-numbering-step trim-temps
+        } value-number-bb trim-temps
     ] unit-test
 ] when
 
 cpu x86.32? [
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-reference f 1 3.5 }
             T{ ##compare f 2 0 1 cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-reference f 1 3.5 }
             T{ ##compare f 2 0 1 cc= }
-        } value-numbering-step trim-temps
+        } value-number-bb trim-temps
     ] unit-test
 
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-reference f 1 3.5 }
             T{ ##compare-branch f 0 1 cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-reference f 1 3.5 }
             T{ ##compare-branch f 0 1 cc= }
-        } value-numbering-step trim-temps
+        } value-number-bb trim-temps
     ] unit-test
 ] unless
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer-imm f 2 0 100 cc>= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer f 2 1 0 cc<= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer-imm-branch f 0 100 cc<= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer-branch f 0 1 cc<= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer-imm-branch f 0 100 cc>= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer-branch f 1 0 cc<= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 ! Compare folding
 [
-    {
+    V{
         T{ ##load-integer f 1 100 }
         T{ ##load-integer f 2 200 }
         T{ ##load-reference f 3 t }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 100 }
         T{ ##load-integer f 2 200 }
         T{ ##compare-integer f 3 1 2 cc<= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 100 }
         T{ ##load-integer f 2 200 }
         T{ ##load-reference f 3 f }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 100 }
         T{ ##load-integer f 2 200 }
         T{ ##compare-integer f 3 1 2 cc= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 100 }
         T{ ##load-reference f 2 f }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 100 }
         T{ ##compare-integer-imm f 2 1 123 cc= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##load-integer f 2 20 }
         T{ ##load-reference f 3 f }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##load-integer f 2 20 }
         T{ ##compare-integer f 3 1 2 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 2 }
         T{ ##load-reference f 3 t }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 2 }
         T{ ##compare-integer f 3 1 2 cc/= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 2 }
         T{ ##load-reference f 3 t }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 2 }
         T{ ##compare-integer f 3 1 2 cc< }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##load-integer f 2 20 }
         T{ ##load-reference f 3 f }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##load-integer f 2 20 }
         T{ ##compare-integer f 3 2 1 cc< }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-reference f 1 f }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##compare-integer f 1 0 0 cc< }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 1 0 any-rep }
         T{ ##load-reference f 2 f }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 1 0 any-rep }
         T{ ##compare-integer f 2 0 1 cc< }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-reference f 1 t }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##compare-integer f 1 0 0 cc<= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-reference f 1 f }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##compare-integer f 1 0 0 cc> }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-reference f 1 t }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##compare-integer f 1 0 0 cc>= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-reference f 1 f }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##compare-integer f 1 0 0 cc/= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-reference f 1 t }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##compare-integer f 1 0 0 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##load-reference f 2 t }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##compare-imm f 2 1 10 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##load-reference f 2 f }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##compare-imm f 2 1 20 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##load-reference f 2 t }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##compare-imm f 2 1 100 cc/= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##load-reference f 2 f }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 10 }
         T{ ##compare-imm f 2 1 10 cc/= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 cpu x86.32? [
     [
-        {
+        V{
             T{ ##load-reference f 1 + }
             T{ ##load-reference f 2 f }
         }
     ] [
-        {
+        V{
             T{ ##load-reference f 1 + }
             T{ ##compare-imm f 2 1 + cc/= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##load-reference f 1 + }
             T{ ##load-reference f 2 t }
         }
     ] [
-        {
+        V{
             T{ ##load-reference f 1 + }
             T{ ##compare-imm f 2 1 * cc/= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##load-reference f 1 + }
             T{ ##load-reference f 2 t }
         }
     ] [
-        {
+        V{
             T{ ##load-reference f 1 + }
             T{ ##compare-imm f 2 1 + cc= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##load-reference f 1 + }
             T{ ##load-reference f 2 f }
         }
     ] [
-        {
+        V{
             T{ ##load-reference f 1 + }
             T{ ##compare-imm f 2 1 * cc= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 ] when
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-reference f 1 t }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##compare f 1 0 0 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-reference f 1 f }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##compare f 1 0 0 cc/= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 12 }
         T{ ##load-reference f 3 t }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 12 }
         T{ ##test-imm f 3 1 13 cc/= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 15 }
         T{ ##load-reference f 3 f }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 15 }
         T{ ##test-imm f 3 1 16 cc/= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 12 }
         T{ ##load-reference f 3 f }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 12 }
         T{ ##test-imm f 3 1 13 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 15 }
         T{ ##load-reference f 3 t }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 15 }
         T{ ##test-imm f 3 1 16 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Rewriting a ##test of an ##and into a ##test
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##peek f 1 D 1 }
         T{ ##and f 2 0 1 }
         T{ ##test f 3 0 1 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##peek f 1 D 1 }
         T{ ##and f 2 0 1 }
         T{ ##test f 3 2 2 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##and-imm f 2 0 12 }
         T{ ##test-imm f 3 0 12 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##and-imm f 2 0 12 }
         T{ ##test f 3 2 2 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Rewriting ##test into ##test-imm
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test-imm f 2 0 10 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test f 2 0 1 cc= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test-imm f 2 0 10 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test f 2 1 0 cc= }
-    } value-numbering-step trim-temps
+    } value-number-bb trim-temps
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test-imm-branch f 0 10 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test-branch f 0 1 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test-imm-branch f 0 10 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test-branch f 1 0 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test-imm-branch f 0 10 cc= }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 10 }
         T{ ##test-branch f 1 0 cc= }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Make sure the immediate fits
 cpu x86.64? [
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 1 100000000000 }
             T{ ##test f 2 1 0 cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 1 100000000000 }
             T{ ##test f 2 1 0 cc= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 1 100000000000 }
             T{ ##test-branch f 1 0 cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 1 100000000000 }
             T{ ##test-branch f 1 0 cc= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 ] when
 
 ! Rewriting ##compare into ##test
 cpu x86? [
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##test f 1 0 0 cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##compare-integer-imm f 1 0 0 cc= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##test f 1 0 0 cc/= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##compare-integer-imm f 1 0 0 cc/= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##compare-integer-imm f 1 0 0 cc<= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##compare-integer-imm f 1 0 0 cc<= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
     
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##test-branch f 0 0 cc= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##compare-integer-imm-branch f 0 0 cc= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##test-branch f 0 0 cc/= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##compare-integer-imm-branch f 0 0 cc/= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##compare-integer-imm-branch f 0 0 cc<= }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##compare-integer-imm-branch f 0 0 cc<= }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 ] when
 
 ! Reassociation
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add-imm f 2 0 100 }
@@ -1294,17 +1300,17 @@ cpu x86? [
         T{ ##add-imm f 4 0 150 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add f 2 0 1 }
         T{ ##load-integer f 3 50 }
         T{ ##add f 4 2 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add-imm f 2 0 100 }
@@ -1312,17 +1318,17 @@ cpu x86? [
         T{ ##add-imm f 4 0 150 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add f 2 1 0 }
         T{ ##load-integer f 3 50 }
         T{ ##add f 4 3 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add-imm f 2 0 100 }
@@ -1330,17 +1336,17 @@ cpu x86? [
         T{ ##add-imm f 4 0 50 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add f 2 0 1 }
         T{ ##load-integer f 3 50 }
         T{ ##sub f 4 2 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##add-imm f 2 0 -100 }
@@ -1348,17 +1354,17 @@ cpu x86? [
         T{ ##add-imm f 4 0 -150 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##sub f 2 0 1 }
         T{ ##load-integer f 3 50 }
         T{ ##sub f 4 2 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##mul-imm f 2 0 100 }
@@ -1366,17 +1372,17 @@ cpu x86? [
         T{ ##mul-imm f 4 0 5000 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##mul f 2 0 1 }
         T{ ##load-integer f 3 50 }
         T{ ##mul f 4 2 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##mul-imm f 2 0 100 }
@@ -1384,17 +1390,17 @@ cpu x86? [
         T{ ##mul-imm f 4 0 5000 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##mul f 2 1 0 }
         T{ ##load-integer f 3 50 }
         T{ ##mul f 4 3 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##and-imm f 2 0 100 }
@@ -1402,17 +1408,17 @@ cpu x86? [
         T{ ##and-imm f 4 0 32 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##and f 2 0 1 }
         T{ ##load-integer f 3 50 }
         T{ ##and f 4 2 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##and-imm f 2 0 100 }
@@ -1420,17 +1426,17 @@ cpu x86? [
         T{ ##and-imm f 4 0 32 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##and f 2 1 0 }
         T{ ##load-integer f 3 50 }
         T{ ##and f 4 3 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##or-imm f 2 0 100 }
@@ -1438,17 +1444,17 @@ cpu x86? [
         T{ ##or-imm f 4 0 118 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##or f 2 0 1 }
         T{ ##load-integer f 3 50 }
         T{ ##or f 4 2 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##or-imm f 2 0 100 }
@@ -1456,17 +1462,17 @@ cpu x86? [
         T{ ##or-imm f 4 0 118 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##or f 2 1 0 }
         T{ ##load-integer f 3 50 }
         T{ ##or f 4 3 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##xor-imm f 2 0 100 }
@@ -1474,17 +1480,17 @@ cpu x86? [
         T{ ##xor-imm f 4 0 86 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##xor f 2 0 1 }
         T{ ##load-integer f 3 50 }
         T{ ##xor f 4 2 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##xor-imm f 2 0 100 }
@@ -1492,132 +1498,132 @@ cpu x86? [
         T{ ##xor-imm f 4 0 86 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 100 }
         T{ ##xor f 2 1 0 }
         T{ ##load-integer f 3 50 }
         T{ ##xor f 4 3 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shl-imm f 1 0 10 }
         T{ ##shl-imm f 2 0 21 }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shl-imm f 1 0 10 }
         T{ ##shl-imm f 2 1 11 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shl-imm f 1 0 10 }
         T{ ##shl-imm f 2 1 $[ cell-bits 1 - ] }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shl-imm f 1 0 10 }
         T{ ##shl-imm f 2 1 $[ cell-bits 1 - ] }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##sar-imm f 1 0 10 }
         T{ ##sar-imm f 2 0 21 }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##sar-imm f 1 0 10 }
         T{ ##sar-imm f 2 1 11 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##sar-imm f 1 0 10 }
         T{ ##sar-imm f 2 1 $[ cell-bits 1 - ] }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##sar-imm f 1 0 10 }
         T{ ##sar-imm f 2 1 $[ cell-bits 1 - ] }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shr-imm f 1 0 10 }
         T{ ##shr-imm f 2 0 21 }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shr-imm f 1 0 10 }
         T{ ##shr-imm f 2 1 11 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shr-imm f 1 0 10 }
         T{ ##shr-imm f 2 1 $[ cell-bits 1 - ] }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shr-imm f 1 0 10 }
         T{ ##shr-imm f 2 1 $[ cell-bits 1 - ] }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shr-imm f 1 0 10 }
         T{ ##sar-imm f 2 1 11 }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shr-imm f 1 0 10 }
         T{ ##sar-imm f 2 1 11 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Distributive law
 2 \ vreg-counter set-global
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##add-imm f 1 0 10 }
         T{ ##shl-imm f 3 0 2 }
@@ -1625,16 +1631,16 @@ cpu x86? [
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##add-imm f 1 0 10 }
         T{ ##shl-imm f 2 1 2 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##add-imm f 1 0 10 }
         T{ ##mul-imm f 4 0 3 }
@@ -1642,16 +1648,16 @@ cpu x86? [
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##add-imm f 1 0 10 }
         T{ ##mul-imm f 2 1 3 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##add-imm f 1 0 -10 }
         T{ ##shl-imm f 5 0 2 }
@@ -1659,16 +1665,16 @@ cpu x86? [
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##sub-imm f 1 0 10 }
         T{ ##shl-imm f 2 1 2 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##add-imm f 1 0 -10 }
         T{ ##mul-imm f 6 0 3 }
@@ -1676,541 +1682,541 @@ cpu x86? [
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##sub-imm f 1 0 10 }
         T{ ##mul-imm f 2 1 3 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Simplification
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##peek f 1 D 1 }
         T{ ##copy f 3 0 any-rep }
         T{ ##replace f 3 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##peek f 1 D 1 }
         T{ ##add-imm f 3 0 0 }
         T{ ##replace f 3 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##peek f 1 D 1 }
         T{ ##copy f 3 0 any-rep }
         T{ ##replace f 3 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##peek f 1 D 1 }
         T{ ##or-imm f 3 0 0 }
         T{ ##replace f 3 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##peek f 1 D 1 }
         T{ ##copy f 3 0 any-rep }
         T{ ##replace f 3 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##peek f 1 D 1 }
         T{ ##xor-imm f 3 0 0 }
         T{ ##replace f 3 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##and-imm f 1 0 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 1 0 any-rep }
         T{ ##replace f 1 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##and-imm f 1 0 -1 }
         T{ ##replace f 1 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 1 0 any-rep }
         T{ ##replace f 1 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##and f 1 0 0 }
         T{ ##replace f 1 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 1 0 any-rep }
         T{ ##replace f 1 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##or-imm f 1 0 0 }
         T{ ##replace f 1 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 -1 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##or-imm f 1 0 -1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 1 0 any-rep }
         T{ ##replace f 1 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##or f 1 0 0 }
         T{ ##replace f 1 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 1 0 any-rep }
         T{ ##replace f 1 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##xor-imm f 1 0 0 }
         T{ ##replace f 1 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##not f 1 0 }
         T{ ##replace f 1 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##xor-imm f 1 0 -1 }
         T{ ##replace f 1 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##xor f 1 0 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 2 0 any-rep }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##mul-imm f 2 0 1 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 2 0 any-rep }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shl-imm f 2 0 0 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 2 0 any-rep }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##shr-imm f 2 0 0 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##copy f 2 0 any-rep }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##sar-imm f 2 0 0 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Constant folding
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 3 }
         T{ ##load-integer f 3 4 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 3 }
         T{ ##add f 3 1 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 3 }
         T{ ##load-integer f 3 -2 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 3 }
         T{ ##sub f 3 1 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 2 }
         T{ ##load-integer f 2 3 }
         T{ ##load-integer f 3 6 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 2 }
         T{ ##load-integer f 2 3 }
         T{ ##mul f 3 1 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 2 }
         T{ ##load-integer f 2 1 }
         T{ ##load-integer f 3 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 2 }
         T{ ##load-integer f 2 1 }
         T{ ##and f 3 1 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 2 }
         T{ ##load-integer f 2 1 }
         T{ ##load-integer f 3 3 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 2 }
         T{ ##load-integer f 2 1 }
         T{ ##or f 3 1 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 2 }
         T{ ##load-integer f 2 3 }
         T{ ##load-integer f 3 1 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 2 }
         T{ ##load-integer f 2 3 }
         T{ ##xor f 3 1 2 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 3 8 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##shl-imm f 3 1 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 cell 8 = [
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 1 -1 }
             T{ ##load-integer f 3 0xffffffffffff }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 1 -1 }
             T{ ##shr-imm f 3 1 16 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 ] when
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 -8 }
         T{ ##load-integer f 3 -4 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 -8 }
         T{ ##sar-imm f 3 1 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 cell 8 = [
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 1 65536 }
             T{ ##load-integer f 2 140737488355328 }
             T{ ##add f 3 0 2 }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 1 65536 }
             T{ ##shl-imm f 2 1 31 }
             T{ ##add f 3 0 2 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 2 140737488355328 }
             T{ ##add f 3 0 2 }
         }
     ] [
-        {
+        V{
             T{ ##peek f 0 D 0 }
             T{ ##load-integer f 2 140737488355328 }
             T{ ##add f 3 0 2 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 
     ! PPC ADDI can't hold immediates this big.
     cpu ppc? [
         [
-            {
+            V{
                 T{ ##peek f 0 D 0 }
                 T{ ##load-integer f 2 2147483647 }
                 T{ ##add-imm f 3 0 2147483647 }
                 T{ ##add-imm f 4 3 2147483647 }
             }
         ] [
-            {
+            V{
                 T{ ##peek f 0 D 0 }
                 T{ ##load-integer f 2 2147483647 }
                 T{ ##add f 3 0 2 }
                 T{ ##add f 4 3 2 }
-            } value-numbering-step
+            } value-number-bb
         ] unit-test
     ] unless
 ] when
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 -1 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##neg f 2 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##load-integer f 2 -2 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 1 1 }
         T{ ##not f 2 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! ##tagged>integer constant folding
 [
-    {
+    V{
         T{ ##load-reference f 1 f }
         T{ ##load-integer f 2 $[ \ f type-number ] }
         T{ ##copy f 3 2 any-rep }
     }
 ] [
-    {
+    V{
         T{ ##load-reference f 1 f }
         T{ ##tagged>integer f 2 1 }
         T{ ##and-imm f 3 2 15 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 1 100 }
         T{ ##load-integer f 2 $[ 100 tag-fixnum ] }
         T{ ##load-integer f 3 $[ 100 tag-fixnum 1 + ] }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 1 100 }
         T{ ##tagged>integer f 2 1 }
         T{ ##add-imm f 3 2 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Alien boxing and unboxing
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##box-alien f 1 0 }
         T{ ##copy f 2 0 any-rep }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##box-alien f 1 0 }
         T{ ##unbox-alien f 2 1 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##box-alien f 1 0 }
         T{ ##copy f 2 0 any-rep }
         T{ ##replace f 2 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##box-alien f 1 0 }
         T{ ##unbox-any-c-ptr f 2 1 }
         T{ ##replace f 2 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 2 0 }
         T{ ##copy f 1 0 any-rep }
         T{ ##replace f 1 D 0 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 2 0 }
         T{ ##box-displaced-alien f 1 2 0 c-ptr }
         T{ ##replace f 1 D 0 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 3 vreg-counter set-global
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 2 16 }
         T{ ##box-displaced-alien f 1 2 0 c-ptr }
@@ -2218,18 +2224,18 @@ cell 8 = [
         T{ ##add-imm f 3 4 16 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 2 16 }
         T{ ##box-displaced-alien f 1 2 0 c-ptr }
         T{ ##unbox-any-c-ptr f 3 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 4 vreg-counter set-global
 
 [
-    {
+    V{
         T{ ##box-alien f 0 1 }
         T{ ##load-integer f 2 16 }
         T{ ##box-displaced-alien f 3 2 0 c-ptr }
@@ -2237,167 +2243,167 @@ cell 8 = [
         T{ ##add-imm f 4 5 16 }
     }
 ] [
-    {
+    V{
         T{ ##box-alien f 0 1 }
         T{ ##load-integer f 2 16 }
         T{ ##box-displaced-alien f 3 2 0 c-ptr }
         T{ ##unbox-any-c-ptr f 4 3 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 3 vreg-counter set-global
 
 [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 2 0 }
         T{ ##copy f 3 0 any-rep }
         T{ ##replace f 3 D 1 }
     }
 ] [
-    {
+    V{
         T{ ##peek f 0 D 0 }
         T{ ##load-integer f 2 0 }
         T{ ##box-displaced-alien f 3 2 0 c-ptr }
         T{ ##replace f 3 D 1 }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Various SIMD simplifications
 [
-    {
+    V{
         T{ ##vector>scalar f 1 0 float-4-rep }
         T{ ##copy f 2 0 any-rep }
     }
 ] [
-    {
+    V{
         T{ ##vector>scalar f 1 0 float-4-rep }
         T{ ##scalar>vector f 2 1 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##copy f 1 0 any-rep }
     }
 ] [
-    {
+    V{
         T{ ##shuffle-vector-imm f 1 0 { 0 1 2 3 } float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##shuffle-vector-imm f 1 0 { 1 2 3 0 } float-4-rep }
         T{ ##shuffle-vector-imm f 2 0 { 0 2 3 1 } float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##shuffle-vector-imm f 1 0 { 1 2 3 0 } float-4-rep }
         T{ ##shuffle-vector-imm f 2 1 { 3 1 2 0 } float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##shuffle-vector-imm f 1 0 { 1 2 3 0 } float-4-rep }
         T{ ##shuffle-vector-imm f 2 1 { 1 0 } double-2-rep }
     }
 ] [
-    {
+    V{
         T{ ##shuffle-vector-imm f 1 0 { 1 2 3 0 } float-4-rep }
         T{ ##shuffle-vector-imm f 2 1 { 1 0 } double-2-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 0 55 }
         T{ ##load-reference f 1 B{ 55 0 0 0  55 0 0 0  55 0 0 0  55 0 0 0 } }
         T{ ##load-reference f 2 B{ 55 0 0 0  55 0 0 0  55 0 0 0  55 0 0 0 } }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 0 55 }
         T{ ##scalar>vector f 1 0 int-4-rep }
         T{ ##shuffle-vector-imm f 2 1 { 0 0 0 0 } float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-reference f 0 1.25 }
         T{ ##load-reference f 1 B{ 0 0 160 63 0 0 160 63 0 0 160 63 0 0 160 63 } }
         T{ ##load-reference f 2 B{ 0 0 160 63 0 0 160 63 0 0 160 63 0 0 160 63 } }
     }
 ] [
-    {
+    V{
         T{ ##load-reference f 0 1.25 }
         T{ ##scalar>vector f 1 0 float-4-rep }
         T{ ##shuffle-vector-imm f 2 1 { 0 0 0 0 } float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-reference f 0 1.25 }
         T{ ##load-reference f 1 B{ 0 0 160 63 0 0 160 63 0 0 160 63 0 0 160 63 } }
         T{ ##load-reference f 2 B{ 0 0 160 63 0 0 160 63 0 0 160 63 0 0 160 63 } }
     }
 ] [
-    {
+    V{
         T{ ##load-reference f 0 1.25 }
         T{ ##scalar>vector f 1 0 float-4-rep }
         T{ ##shuffle-vector-imm f 2 1 { 0 0 0 0 } float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 0 55 }
         T{ ##load-reference f 1 B{ 55 0 55 0 55 0 55 0 55 0 55 0 55 0 55 0 } }
         T{ ##load-reference f 2 B{ 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 } }
         T{ ##load-reference f 3 B{ 0 55 0 55 0 55 0 55 0 55 0 55 0 55 0 55 } }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 0 55 }
         T{ ##scalar>vector f 1 0 short-8-rep }
         T{ ##load-reference f 2 B{ 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 } }
         T{ ##shuffle-vector f 3 1 2 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-reference f 0 1.25 }
         T{ ##load-reference f 2 3.75 }
         T{ ##load-reference f 4 B{ 0 0 0 0 0 0 244 63 0 0 0 0 0 0 14 64 } }
     }
 ] [
-    {
+    V{
         T{ ##load-reference f 0 1.25 }
         T{ ##load-reference f 2 3.75 }
         T{ ##gather-vector-2 f 4 0 2 double-2-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 0 125 }
         T{ ##load-integer f 2 375 }
         T{ ##load-reference f 4 B{ 125 0 0 0 0 0 0 0 119 1 0 0 0 0 0 0 } }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 0 125 }
         T{ ##load-integer f 2 375 }
         T{ ##gather-vector-2 f 4 0 2 longlong-2-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-reference f 0 1.25 }
         T{ ##load-reference f 1 2.50 }
         T{ ##load-reference f 2 3.75 }
@@ -2405,17 +2411,17 @@ cell 8 = [
         T{ ##load-reference f 4 B{ 0 0 160 63 0 0 32 64 0 0 112 64 0 0 160 64 } }
     }
 ] [
-    {
+    V{
         T{ ##load-reference f 0 1.25 }
         T{ ##load-reference f 1 2.50 }
         T{ ##load-reference f 2 3.75 }
         T{ ##load-reference f 3 5.00 }
         T{ ##gather-vector-4 f 4 0 1 2 3 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##load-integer f 0 125 }
         T{ ##load-integer f 1 250 }
         T{ ##load-integer f 2 375 }
@@ -2423,113 +2429,113 @@ cell 8 = [
         T{ ##load-reference f 4 B{ 125 0 0 0 250 0 0 0 119 1 0 0 244 1 0 0 } }
     }
 ] [
-    {
+    V{
         T{ ##load-integer f 0 125 }
         T{ ##load-integer f 1 250 }
         T{ ##load-integer f 2 375 }
         T{ ##load-integer f 3 500 }
         T{ ##gather-vector-4 f 4 0 1 2 3 int-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##zero-vector f 2 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##xor-vector f 2 1 1 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! NOT x AND y => x ANDN y
 
 [
-    {
+    V{
         T{ ##fill-vector f 3 float-4-rep }
         T{ ##xor-vector  f 4 0 3 float-4-rep }
         T{ ##andn-vector f 5 0 1 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##fill-vector f 3 float-4-rep }
         T{ ##xor-vector  f 4 0 3 float-4-rep }
         T{ ##and-vector  f 5 4 1 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##not-vector  f 4 0 float-4-rep }
         T{ ##andn-vector f 5 0 1 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##not-vector  f 4 0 float-4-rep }
         T{ ##and-vector  f 5 4 1 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! x AND NOT y => y ANDN x
 
 [
-    {
+    V{
         T{ ##fill-vector f 3 float-4-rep }
         T{ ##xor-vector  f 4 0 3 float-4-rep }
         T{ ##andn-vector f 5 0 1 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##fill-vector f 3 float-4-rep }
         T{ ##xor-vector  f 4 0 3 float-4-rep }
         T{ ##and-vector  f 5 1 4 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##not-vector  f 4 0 float-4-rep }
         T{ ##andn-vector f 5 0 1 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##not-vector  f 4 0 float-4-rep }
         T{ ##and-vector  f 5 1 4 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! NOT x ANDN y => x AND y
 
 [
-    {
+    V{
         T{ ##fill-vector f 3 float-4-rep }
         T{ ##xor-vector  f 4 0 3 float-4-rep }
         T{ ##and-vector  f 5 0 1 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##fill-vector f 3 float-4-rep }
         T{ ##xor-vector  f 4 0 3 float-4-rep }
         T{ ##andn-vector f 5 4 1 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##not-vector  f 4 0 float-4-rep }
         T{ ##and-vector  f 5 0 1 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##not-vector  f 4 0 float-4-rep }
         T{ ##andn-vector f 5 4 1 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! AND <=> ANDN
 
 [
-    {
+    V{
         T{ ##fill-vector f 3 float-4-rep }
         T{ ##xor-vector  f 4 0 3 float-4-rep }
         T{ ##andn-vector f 5 0 1 float-4-rep }
@@ -2537,29 +2543,29 @@ cell 8 = [
         T{ ##or-vector   f 7 5 6 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##fill-vector f 3 float-4-rep }
         T{ ##xor-vector  f 4 0 3 float-4-rep }
         T{ ##and-vector  f 5 4 1 float-4-rep }
         T{ ##andn-vector f 6 4 2 float-4-rep }
         T{ ##or-vector   f 7 5 6 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
-    {
+    V{
         T{ ##not-vector  f 4 0   float-4-rep }
         T{ ##andn-vector f 5 0 1 float-4-rep }
         T{ ##and-vector  f 6 0 2 float-4-rep }
         T{ ##or-vector   f 7 5 6 float-4-rep }
     }
 ] [
-    {
+    V{
         T{ ##not-vector  f 4 0   float-4-rep }
         T{ ##and-vector  f 5 4 1 float-4-rep }
         T{ ##andn-vector f 6 4 2 float-4-rep }
         T{ ##or-vector   f 7 5 6 float-4-rep }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Branch folding
@@ -2878,7 +2884,7 @@ cpu x86? [
             T{ ##peek f 1 D 1 }
             T{ ##add-imm f 2 1 2 }
             T{ ##slot f 3 0 2 $[ cell log2 ] 7 }
-        } value-numbering-step
+        } value-number-bb
     ] unit-test
 ] when
 
@@ -2898,7 +2904,7 @@ cpu x86? [
         T{ ##tagged>integer f 2 1 }
         T{ ##add-imm f 3 2 10 }
         T{ ##load-memory-imm f 4 3 0 int-rep c:uchar }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
@@ -2918,7 +2924,7 @@ cpu x86? [
         T{ ##tagged>integer f 3 1 }
         T{ ##add-imm f 4 3 10 }
         T{ ##store-memory-imm f 2 4 0 int-rep c:uchar }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Displacement fusion on ##load/store-memory-imm
@@ -2939,7 +2945,7 @@ cpu x86? [
         T{ ##tagged>integer f 3 1 }
         T{ ##add f 4 2 3 }
         T{ ##load-memory-imm f 5 4 0 int-rep c:uchar }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 [
@@ -2959,7 +2965,7 @@ cpu x86? [
         T{ ##tagged>integer f 3 1 }
         T{ ##add f 4 2 3 }
         T{ ##store-memory-imm f 5 4 0 int-rep c:uchar }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Base offset fusion on ##load/store-memory -- only on x86
@@ -2992,7 +2998,7 @@ cpu x86?
         T{ ##tagged>integer f 3 1 }
         T{ ##add-imm f 4 2 31337 }
         T{ ##load-memory f 5 4 3 0 0 int-rep c:uchar }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Displacement offset fusion on ##load/store-memory -- only on x86
@@ -3025,7 +3031,7 @@ cpu x86?
         T{ ##tagged>integer f 3 1 }
         T{ ##add-imm f 4 3 31337 }
         T{ ##load-memory f 5 2 4 0 1 int-rep c:uchar }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 ! Displacement offset fusion should not occur on
@@ -3038,7 +3044,7 @@ cpu x86?
         T{ ##tagged>integer f 3 1 }
         T{ ##add-imm f 4 3 10 }
         T{ ##load-memory f 5 2 4 1 1 int-rep c:uchar }
-    } dup value-numbering-step assert=
+    } dup value-number-bb assert=
 ] unit-test
 
 ! Scale fusion on ##load/store-memory
@@ -3071,7 +3077,7 @@ cpu x86?
         T{ ##tagged>integer f 3 1 }
         T{ ##shl-imm f 4 3 2 }
         T{ ##load-memory f 5 2 4 0 0 int-rep c:uchar }
-    } value-numbering-step
+    } value-number-bb
 ] unit-test
 
 cpu x86? [
@@ -3084,7 +3090,7 @@ cpu x86? [
             T{ ##tagged>integer f 3 1 }
             T{ ##shl-imm f 4 3 2 }
             T{ ##load-memory f 5 2 4 1 0 int-rep c:uchar }
-        } dup value-numbering-step assert=
+        } dup value-number-bb assert=
     ] unit-test
 
     ! Don't do scale fusion if the scale factor is out of range
@@ -3096,6 +3102,6 @@ cpu x86? [
             T{ ##tagged>integer f 3 1 }
             T{ ##shl-imm f 4 3 4 }
             T{ ##load-memory f 5 2 4 0 0 int-rep c:uchar }
-        } dup value-numbering-step assert=
+        } dup value-number-bb assert=
     ] unit-test
 ] when