Make tests less sensitive to specific value numbers.

filetests/parser/branch.cton

@@ -19,65 +19,65 @@ ebb1:
 
 ; Jumps with 1 arg.
 function onearg(i32) {
-ebb0(vx0: i32):
-    jump ebb1(vx0)
+ebb0(v90: i32):
+    jump ebb1(v90)
 
-ebb1(vx1: i32):
-    jump ebb0(vx1)
+ebb1(v91: i32):
+    jump ebb0(v91)
 }
 ; sameln: function onearg(i32) {
-; nextln: ebb0(vx0: i32):
-; nextln:     jump ebb1(vx0)
+; nextln: ebb0($v90: i32):
+; nextln:     jump ebb1($v90)
 ; nextln: 
-; nextln: ebb1(vx1: i32):
-; nextln:     jump ebb0(vx1)
+; nextln: ebb1($v91: i32):
+; nextln:     jump ebb0($v91)
 ; nextln: }
 
 ; Jumps with 2 args.
 function twoargs(i32, f32) {
-ebb0(vx0: i32, vx1: f32):
-    jump ebb1(vx0, vx1)
+ebb0(v90: i32, v91: f32):
+    jump ebb1(v90, v91)
 
-ebb1(vx2: i32, vx3: f32):
-    jump ebb0(vx2, vx3)
+ebb1(v92: i32, v93: f32):
+    jump ebb0(v92, v93)
 }
 ; sameln: function twoargs(i32, f32) {
-; nextln: ebb0(vx0: i32, vx1: f32):
-; nextln:     jump ebb1(vx0, vx1)
+; nextln: ebb0($v90: i32, $v91: f32):
+; nextln:     jump ebb1($v90, $v91)
 ; nextln: 
-; nextln: ebb1(vx2: i32, vx3: f32):
-; nextln:     jump ebb0(vx2, vx3)
+; nextln: ebb1($v92: i32, $v93: f32):
+; nextln:     jump ebb0($v92, $v93)
 ; nextln: }
 
 ; Branches with no arguments. The '()' empty argument list is optional.
 function minimal(i32) {
-ebb0(vx0: i32):
-    brz vx0, ebb1
+ebb0(v90: i32):
+    brz v90, ebb1
 
 ebb1:
-    brnz vx0, ebb1()
+    brnz v90, ebb1()
 }
 ; sameln: function minimal(i32) {
-; nextln: ebb0(vx0: i32):
-; nextln:     brz vx0, ebb1
+; nextln: ebb0($v90: i32):
+; nextln:     brz $v90, ebb1
 ; nextln: 
 ; nextln: ebb1:
-; nextln:     brnz.i32 vx0, ebb1
+; nextln:     brnz.i32 $v90, ebb1
 ; nextln: }
 
 function twoargs(i32, f32) {
-ebb0(vx0: i32, vx1: f32):
-    brz vx0, ebb1(vx0, vx1)
+ebb0(v90: i32, v91: f32):
+    brz v90, ebb1(v90, v91)
 
-ebb1(vx2: i32, vx3: f32):
-    brnz vx0, ebb0(vx2, vx3)
+ebb1(v92: i32, v93: f32):
+    brnz v90, ebb0(v92, v93)
 }
 ; sameln: function twoargs(i32, f32) {
-; nextln: ebb0(vx0: i32, vx1: f32):
-; nextln:     brz vx0, ebb1(vx0, vx1)
+; nextln: ebb0($v90: i32, $v91: f32):
+; nextln:     brz $v90, ebb1($v90, $v91)
 ; nextln: 
-; nextln: ebb1(vx2: i32, vx3: f32):
-; nextln:     brnz.i32 vx0, ebb0(vx2, vx3)
+; nextln: ebb1($v92: i32, $v93: f32):
+; nextln:     brnz.i32 $v90, ebb0($v92, $v93)
 ; nextln: }
 
 function jumptable(i32) {
@@ -98,8 +98,8 @@ ebb40:
 ; nextln:     jt0 = jump_table 0
 ; nextln:     jt1 = jump_table 0, 0, ebb0, ebb3, ebb1, ebb2
 ; nextln: 
-; nextln: ebb0(vx0: i32):
-; nextln:     br_table vx0, jt1
+; nextln: ebb0($v3: i32):
+; nextln:     br_table $v3, jt1
 ; nextln:     trap
 ; nextln: 
 ; nextln: ebb1:

filetests/parser/call.cton

@@ -18,9 +18,9 @@ ebb1:
 }
 ; sameln: function r1() -> i32, f32 {
 ; nextln: ebb0:
-; nextln:     v0 = iconst.i32 3
-; nextln:     v1 = f32const 0.0
-; nextln:     return v0, v1
+; nextln:     $v1 = iconst.i32 3
+; nextln:     $v2 = f32const 0.0
+; nextln:     return $v1, $v2
 ; nextln: }
 
 function signatures() {

filetests/parser/rewrite.cton

@@ -26,12 +26,12 @@ ebb100(v20: i32):
 function use_value() {
 ebb100(v20: i32):
     v1000 = iadd_imm v20, 5
-    vx200 = iadd v20, v1000
+    v200 = iadd v20, v1000
     jump ebb100(v1000)
 }
 ; sameln: function use_value() {
-; nextln: ebb0(vx0: i32):
-; nextln:     v0 = iadd_imm vx0, 5
-; nextln:     v1 = iadd vx0, v0
-; nextln:     jump ebb0(v0)
+; nextln: ebb0($v20: i32):
+; nextln:     $v1000 = iadd_imm $v20, 5
+; nextln:     $v200 = iadd $v20, $v1000
+; nextln:     jump ebb0($v1000)
 ; nextln: }

filetests/parser/tiny.cton

@@ -20,19 +20,19 @@ ebb0:
 }
 ; sameln: function ivalues() {
 ; nextln: ebb0:
-; nextln:     v0 = iconst.i32 2
-; nextln:     v1 = iconst.i8 6
-; nextln:     v2 = ishl v0, v1
+; nextln:     $v0 = iconst.i32 2
+; nextln:     $v1 = iconst.i8 6
+; nextln:     $v2 = ishl $v0, $v1
 ; nextln: }
 
 ; Polymorphic istruction controlled by second operand.
 function select() {
-ebb0(vx0: i32, vx1: i32, vx2: b1):
-    v0 = select vx2, vx0, vx1
+ebb0(v90: i32, v91: i32, v92: b1):
+    v0 = select v92, v90, v91
 }
 ; sameln: function select() {
-; nextln: ebb0(vx0: i32, vx1: i32, vx2: b1):
-; nextln:     v0 = select vx2, vx0, vx1
+; nextln: ebb0($v90: i32, $v91: i32, $v92: b1):
+; nextln:     $v0 = select $v92, $v90, $v91
 ; nextln: }
 
 ; Lane indexes.
@@ -44,54 +44,54 @@ ebb0:
 }
 ; sameln: function lanes() {
 ; nextln: ebb0:
-; nextln:     v0 = iconst.i32x4 2
-; nextln:     v1 = extractlane v0, 3
-; nextln:     v2 = insertlane v0, 1, v1
+; nextln:     $v0 = iconst.i32x4 2
+; nextln:     $v1 = extractlane $v0, 3
+; nextln:     $v2 = insertlane $v0, 1, $v1
 ; nextln: }
 
 ; Integer condition codes.
 function icmp(i32, i32) {
-ebb0(vx0: i32, vx1: i32):
-    v0 = icmp eq vx0, vx1
-    v1 = icmp ult vx0, vx1
-    v2 = icmp_imm sge vx0, -12
-    v3 = irsub_imm vx1, 45
-    br_icmp eq vx0, vx1, ebb0(vx1, vx0)
+ebb0(v90: i32, v91: i32):
+    v0 = icmp eq v90, v91
+    v1 = icmp ult v90, v91
+    v2 = icmp_imm sge v90, -12
+    v3 = irsub_imm v91, 45
+    br_icmp eq v90, v91, ebb0(v91, v90)
 }
 ; sameln: function icmp(i32, i32) {
-; nextln: ebb0(vx0: i32, vx1: i32):
-; nextln:     v0 = icmp eq vx0, vx1
-; nextln:     v1 = icmp ult vx0, vx1
-; nextln:     v2 = icmp_imm sge vx0, -12
-; nextln:     v3 = irsub_imm vx1, 45
-; nextln:     br_icmp eq vx0, vx1, ebb0(vx1, vx0)
+; nextln: ebb0($v90: i32, $v91: i32):
+; nextln:     $v0 = icmp eq $v90, $v91
+; nextln:     $v1 = icmp ult $v90, $v91
+; nextln:     $v2 = icmp_imm sge $v90, -12
+; nextln:     $v3 = irsub_imm $v91, 45
+; nextln:     br_icmp eq $v90, $v91, ebb0($v91, $v90)
 ; nextln: }
 
 ; Floating condition codes.
 function fcmp(f32, f32) {
-ebb0(vx0: f32, vx1: f32):
-    v0 = fcmp eq vx0, vx1
-    v1 = fcmp uno vx0, vx1
-    v2 = fcmp lt vx0, vx1
+ebb0(v90: f32, v91: f32):
+    v0 = fcmp eq v90, v91
+    v1 = fcmp uno v90, v91
+    v2 = fcmp lt v90, v91
 }
 ; sameln: function fcmp(f32, f32) {
-; nextln: ebb0(vx0: f32, vx1: f32):
-; nextln:     v0 = fcmp eq vx0, vx1
-; nextln:     v1 = fcmp uno vx0, vx1
-; nextln:     v2 = fcmp lt vx0, vx1
+; nextln: ebb0($v90: f32, $v91: f32):
+; nextln:     $v0 = fcmp eq $v90, $v91
+; nextln:     $v1 = fcmp uno $v90, $v91
+; nextln:     $v2 = fcmp lt $v90, $v91
 ; nextln: }
 
 ; The bitcast instruction has two type variables: The controlling type variable
 ; controls the outout type, and the input type is a free variable.
 function bitcast(i32, f32) {
-ebb0(vx0: i32, vx1: f32):
-    v0 = bitcast.i8x4 vx0
-    v1 = bitcast.i32 vx1
+ebb0(v90: i32, v91: f32):
+    v0 = bitcast.i8x4 v90
+    v1 = bitcast.i32 v91
 }
 ; sameln: function bitcast(i32, f32) {
-; nextln: ebb0(vx0: i32, vx1: f32):
-; nextln:     v0 = bitcast.i8x4 vx0
-; nextln:     v1 = bitcast.i32 vx1
+; nextln: ebb0($v90: i32, $v91: f32):
+; nextln:     $v0 = bitcast.i8x4 $v90
+; nextln:     $v1 = bitcast.i32 $v91
 ; nextln: }
 
 ; Stack slot references