Remove support for entity variables in filecheck.

Now that the parser doesn't renumber indices, there's no need for entity
variables like $v0.

cranelift/filetests/isa/riscv/encoding.cton

@@ -5,15 +5,15 @@ function %int32(i32, i32) {
 ebb0(v1: i32, v2: i32):
     v10 = iadd v1, v2
     ; check: [R#0c]
-    ; sameln: $v10 = iadd
+    ; sameln: v10 = iadd
 
     v11 = isub v1, v2
     ; check: [R#200c]
-    ; sameln: $v11 = isub
+    ; sameln: v11 = isub
 
     v12 = imul v1, v2
     ; check: [R#10c]
-    ; sameln: $v12 = imul
+    ; sameln: v12 = imul
 
     return
     ; check: [Iret#19]

cranelift/filetests/isa/riscv/expand-i32.cton

@@ -14,9 +14,9 @@ ebb0(v1: i32, v2: i32):
     v3, v4 = iadd_cout v1, v2
     return v3, v4
 }
-; check: $v3 = iadd $v1, $v2
-; check: $v4 = icmp ult $v3, $v1
-; check: return $v3, $v4
+; check: v3 = iadd v1, v2
+; check: v4 = icmp ult v3, v1
+; check: return v3, v4
 
 ; Expanding illegal immediate constants.
 ; Note that at some point we'll probably expand the iconst as well.
@@ -26,8 +26,8 @@ ebb0(v0: i32):
     return v1
 }
 ; check: $(cst=$V) = iconst.i32 0x3b9a_ca00
-; check: $v1 = iadd $v0, $cst
-; check: return $v1
+; check: v1 = iadd v0, $cst
+; check: return v1
 
 function %bitclear(i32, i32) -> i32 {
 ebb0(v0: i32, v1: i32):

cranelift/filetests/isa/riscv/legalize-abi.cton

@@ -8,10 +8,10 @@ isa riscv
 
 function %int_split_args(i64) -> i64 {
 ebb0(v0: i64):
-    ; check: $ebb0($(v0l=$V): i32, $(v0h=$V): i32, $(link=$V): i32):
-    ; check: $v0 = iconcat $v0l, $v0h
+    ; check: ebb0($(v0l=$V): i32, $(v0h=$V): i32, $(link=$V): i32):
+    ; check: v0 = iconcat $v0l, $v0h
     v1 = iadd_imm v0, 1
-    ; check: $(v1l=$V), $(v1h=$V) = isplit $v1
+    ; check: $(v1l=$V), $(v1h=$V) = isplit v1
     ; check: return $v1l, $v1h, $link
     return v1
 }
@@ -22,10 +22,10 @@ function %split_call_arg(i32) {
 ebb0(v0: i32):
     v1 = uextend.i64 v0
     call fn1(v1)
-    ; check: $(v1l=$V), $(v1h=$V) = isplit $v1
-    ; check: call $fn1($v1l, $v1h)
+    ; check: $(v1l=$V), $(v1h=$V) = isplit v1
+    ; check: call fn1($v1l, $v1h)
     call fn2(v0, v1)
-    ; check: call $fn2($v0, $V, $V)
+    ; check: call fn2(v0, $V, $V)
     return
 }
 
@@ -33,11 +33,11 @@ function %split_ret_val() {
     fn1 = function %foo() -> i64
 ebb0:
     v1 = call fn1()
-    ; check: $ebb0($(link=$V): i32):
-    ; nextln: $(v1l=$V), $(v1h=$V) = call $fn1()
-    ; check: $v1 = iconcat $v1l, $v1h
+    ; check: ebb0($(link=$V): i32):
+    ; nextln: $(v1l=$V), $(v1h=$V) = call fn1()
+    ; check: v1 = iconcat $v1l, $v1h
     jump ebb1(v1)
-    ; check: jump $ebb1($v1)
+    ; check: jump ebb1(v1)
 
 ebb1(v10: i64):
     jump ebb1(v10)
@@ -48,11 +48,11 @@ function %split_ret_val2() {
     fn1 = function %foo() -> i32, i64
 ebb0:
     v1, v2 = call fn1()
-    ; check: $ebb0($(link=$V): i32):
-    ; nextln: $v1, $(v2l=$V), $(v2h=$V) = call $fn1()
-    ; check: $v2 = iconcat $v2l, $v2h
+    ; check: ebb0($(link=$V): i32):
+    ; nextln: v1, $(v2l=$V), $(v2h=$V) = call fn1()
+    ; check: v2 = iconcat $v2l, $v2h
     jump ebb1(v1, v2)
-    ; check: jump $ebb1($v1, $v2)
+    ; check: jump ebb1(v1, v2)
 
 ebb1(v9: i32, v10: i64):
     jump ebb1(v9, v10)
@@ -60,10 +60,10 @@ ebb1(v9: i32, v10: i64):
 
 function %int_ext(i8, i8 sext, i8 uext) -> i8 uext {
 ebb0(v1: i8, v2: i8, v3: i8):
-    ; check: $ebb0($v1: i8, $(v2x=$V): i32, $(v3x=$V): i32, $(link=$V): i32):
-    ; check: $v2 = ireduce.i8 $v2x
-    ; check: $v3 = ireduce.i8 $v3x
-    ; check: $(v1x=$V) = uextend.i32 $v1
+    ; check: ebb0(v1: i8, $(v2x=$V): i32, $(v3x=$V): i32, $(link=$V): i32):
+    ; check: v2 = ireduce.i8 $v2x
+    ; check: v3 = ireduce.i8 $v3x
+    ; check: $(v1x=$V) = uextend.i32 v1
     ; check: return $v1x, $link
     return v1
 }
@@ -73,11 +73,11 @@ function %ext_ret_val() {
     fn1 = function %foo() -> i8 sext
 ebb0:
     v1 = call fn1()
-    ; check: $ebb0($V: i32):
-    ; nextln: $(rv=$V) = call $fn1()
-    ; check: $v1 = ireduce.i8 $rv
+    ; check: ebb0($V: i32):
+    ; nextln: $(rv=$V) = call fn1()
+    ; check: v1 = ireduce.i8 $rv
     jump ebb1(v1)
-    ; check: jump $ebb1($v1)
+    ; check: jump ebb1(v1)
 
 ebb1(v10: i8):
     jump ebb1(v10)
@@ -85,16 +85,16 @@ ebb1(v10: i8):
 
 function %vector_split_args(i64x4) -> i64x4 {
 ebb0(v0: i64x4):
-    ; check: $ebb0($(v0al=$V): i32, $(v0ah=$V): i32, $(v0bl=$V): i32, $(v0bh=$V): i32, $(v0cl=$V): i32, $(v0ch=$V): i32, $(v0dl=$V): i32, $(v0dh=$V): i32, $(link=$V): i32):
+    ; check: ebb0($(v0al=$V): i32, $(v0ah=$V): i32, $(v0bl=$V): i32, $(v0bh=$V): i32, $(v0cl=$V): i32, $(v0ch=$V): i32, $(v0dl=$V): i32, $(v0dh=$V): i32, $(link=$V): i32):
     ; check: $(v0a=$V) = iconcat $v0al, $v0ah
     ; check: $(v0b=$V) = iconcat $v0bl, $v0bh
     ; check: $(v0ab=$V) = vconcat $v0a, $v0b
     ; check: $(v0c=$V) = iconcat $v0cl, $v0ch
     ; check: $(v0d=$V) = iconcat $v0dl, $v0dh
     ; check: $(v0cd=$V) = vconcat $v0c, $v0d
-    ; check: $v0 = vconcat $v0ab, $v0cd
+    ; check: v0 = vconcat $v0ab, $v0cd
     v1 = bxor v0, v0
-    ; check: $(v1ab=$V), $(v1cd=$V) = vsplit $v1
+    ; check: $(v1ab=$V), $(v1cd=$V) = vsplit v1
     ; check: $(v1a=$V), $(v1b=$V) = vsplit $v1ab
     ; check: $(v1al=$V), $(v1ah=$V) = isplit $v1a
     ; check: $(v1bl=$V), $(v1bh=$V) = isplit $v1b
@@ -117,7 +117,7 @@ function %indirect_arg(i32, f32x2) {
     sig1 = (f32x2) native
 ebb0(v0: i32, v1: f32x2):
     call_indirect sig1, v0(v1)
-    ; check: call_indirect $sig1, $v0($V, $V)
+    ; check: call_indirect sig1, v0($V, $V)
     return
 }
 
@@ -128,7 +128,7 @@ function %stack_args(i32) {
 ebb0(v0: i32):
     v1 = iconst.i64 1
     call fn1(v1, v1, v1, v1, v0)
-    ; check: [GPsp#48,$ss0]$WS $(v0s=$V) = spill $v0
-    ; check: call $fn1($(=.*), $v0s)
+    ; check: [GPsp#48,$ss0]$WS $(v0s=$V) = spill v0
+    ; check: call fn1($(=.*), $v0s)
     return
 }

cranelift/filetests/isa/riscv/legalize-i64.cton

@@ -9,12 +9,12 @@ ebb0(v1: i64, v2: i64):
     v3 = band v1, v2
     return v3
 }
-; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
+; check: ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
 ; check: [R#ec
 ; sameln: $(v3l=$V) = band $v1l, $v2l
 ; check: [R#ec
 ; sameln: $(v3h=$V) = band $v1h, $v2h
-; check: $v3 = iconcat $v3l, $v3h
+; check: v3 = iconcat $v3l, $v3h
 ; check: return $v3l, $v3h, $link
 
 function %bitwise_or(i64, i64) -> i64 {
@@ -22,12 +22,12 @@ ebb0(v1: i64, v2: i64):
     v3 = bor v1, v2
     return v3
 }
-; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
+; check: ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
 ; check: [R#cc
 ; sameln: $(v3l=$V) = bor $v1l, $v2l
 ; check: [R#cc
 ; sameln: $(v3h=$V) = bor $v1h, $v2h
-; check: $v3 = iconcat $v3l, $v3h
+; check: v3 = iconcat $v3l, $v3h
 ; check: return $v3l, $v3h, $link
 
 function %bitwise_xor(i64, i64) -> i64 {
@@ -35,12 +35,12 @@ ebb0(v1: i64, v2: i64):
     v3 = bxor v1, v2
     return v3
 }
-; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
+; check: ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
 ; check: [R#8c
 ; sameln: $(v3l=$V) = bxor $v1l, $v2l
 ; check: [R#8c
 ; sameln: $(v3h=$V) = bxor $v1h, $v2h
-; check: $v3 = iconcat $v3l, $v3h
+; check: v3 = iconcat $v3l, $v3h
 ; check: return $v3l, $v3h, $link
 
 function %arith_add(i64, i64) -> i64 {
@@ -51,7 +51,7 @@ ebb0(v1: i64, v2: i64):
     v3 = iadd v1, v2
     return v3
 }
-; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
+; check: ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
 ; check: [R#0c
 ; sameln: $(v3l=$V) = iadd $v1l, $v2l
 ; check: $(c=$V) = icmp ult $v3l, $v1l
@@ -60,5 +60,5 @@ ebb0(v1: i64, v2: i64):
 ; check: $(c_int=$V) = bint.i32 $c
 ; check: [R#0c
 ; sameln: $(v3h=$V) = iadd $v3h1, $c_int
-; check: $v3 = iconcat $v3l, $v3h
+; check: v3 = iconcat $v3l, $v3h
 ; check: return $v3l, $v3h, $link

cranelift/filetests/isa/riscv/split-args.cton

@@ -6,12 +6,12 @@ isa riscv
 
 function %simple(i64, i64) -> i64 {
 ebb0(v1: i64, v2: i64):
-; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
+; check: ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
     jump ebb1(v1)
-    ; check: jump $ebb1($v1l, $v1h)
+    ; check: jump ebb1($v1l, $v1h)
 
 ebb1(v3: i64):
-; check: $ebb1($(v3l=$V): i32, $(v3h=$V): i32):
+; check: ebb1($(v3l=$V): i32, $(v3h=$V): i32):
     v4 = band v3, v2
     ; check: $(v4l=$V) = band $v3l, $v2l
     ; check: $(v4h=$V) = band $v3h, $v2h
@@ -21,17 +21,17 @@ ebb1(v3: i64):
 
 function %multi(i64) -> i64 {
 ebb1(v1: i64):
-; check: $ebb1($(v1l=$V): i32, $(v1h=$V): i32, $(link=$V): i32):
+; check: ebb1($(v1l=$V): i32, $(v1h=$V): i32, $(link=$V): i32):
     jump ebb2(v1, v1)
-    ; check: jump $ebb2($v1l, $v1l, $v1h, $v1h)
+    ; check: jump ebb2($v1l, $v1l, $v1h, $v1h)
 
 ebb2(v2: i64, v3: i64):
-; check: $ebb2($(v2l=$V): i32, $(v3l=$V): i32, $(v2h=$V): i32, $(v3h=$V): i32):
+; check: ebb2($(v2l=$V): i32, $(v3l=$V): i32, $(v2h=$V): i32, $(v3h=$V): i32):
     jump ebb3(v2)
-    ; check: jump $ebb3($v2l, $v2h)
+    ; check: jump ebb3($v2l, $v2h)
 
 ebb3(v4: i64):
-; check: $ebb3($(v4l=$V): i32, $(v4h=$V): i32):
+; check: ebb3($(v4l=$V): i32, $(v4h=$V): i32):
     v5 = band v4, v3
     ; check: $(v5l=$V) = band $v4l, $v3l
     ; check: $(v5h=$V) = band $v4h, $v3h
@@ -41,15 +41,15 @@ ebb3(v4: i64):
 
 function %loop(i64, i64) -> i64 {
 ebb0(v1: i64, v2: i64):
-; check: $ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
+; check: ebb0($(v1l=$V): i32, $(v1h=$V): i32, $(v2l=$V): i32, $(v2h=$V): i32, $(link=$V): i32):
     jump ebb1(v1)
-    ; check: jump $ebb1($v1l, $v1h)
+    ; check: jump ebb1($v1l, $v1h)
 
 ebb1(v3: i64):
-; check: $ebb1($(v3l=$V): i32, $(v3h=$V): i32):
+; check: ebb1($(v3l=$V): i32, $(v3h=$V): i32):
     v4 = band v3, v2
     ; check: $(v4l=$V) = band $v3l, $v2l
     ; check: $(v4h=$V) = band $v3h, $v2h
     jump ebb1(v4)
-    ; check: jump $ebb1($v4l, $v4h)
+    ; check: jump ebb1($v4l, $v4h)
 }