From 0160919945e3836cbc3c42158cc6109f2e500bea Mon Sep 17 00:00:00 2001 From: Jamey Sharp Date: Fri, 22 Mar 2024 14:14:31 -0700 Subject: [PATCH] Resolve value aliases in disas tests This reverts commit 6c5184809db3a92de4ee0c718c403bedc9a9ff4f, "Cranelift: resolve value aliases when printing CLIF functions (#8214)", then applies the same effect a different way. In discussion on #8223, we decided to handle this a different way. So I've introduced a method on DataFlowGraph which eliminates all value aliases, and we can call it when necessary. If that function is not called then the CLIF printer should print value aliases the same way it did before #8214. In this PR, I've specifically called it in disas tests. The changes to write.rs and frontend.rs are from the revert, while the changes to disas.rs are new. In these tests, value aliases are just clutter that distracts from understanding what code will actually be generated. They may change due to changes in legalization, but that doesn't signal anything about whatever the test was intended to check. Because the new helper deletes aliases after it's done resolving them, those aliases now disappear from the test expectations. Aside from that, the test expectations are unchanged compared to what #8214 did. --- cranelift/codegen/src/write.rs | 69 +++++++++---------- cranelift/frontend/src/frontend.rs | 40 +++++------ tests/disas.rs | 6 +- tests/disas/dead-code.wat | 1 - .../disas/duplicate-loads-dynamic-memory.wat | 10 --- tests/disas/duplicate-loads-static-memory.wat | 6 -- ...re-access-same-index-different-offsets.wat | 15 ---- ...re-access-same-index-different-offsets.wat | 15 ---- tests/disas/icall-loop.wat | 8 --- tests/disas/if-unreachable-else-params.wat | 1 - tests/disas/readonly-funcrefs.wat | 3 - tests/disas/table-get-fixed-size.wat | 8 --- tests/disas/table-get.wat | 10 --- tests/disas/table-set-fixed-size.wat | 4 -- tests/disas/table-set.wat | 6 -- tests/disas/typed-funcrefs.wat | 24 ------- 16 files changed, 56 insertions(+), 170 deletions(-) diff --git a/cranelift/codegen/src/write.rs b/cranelift/codegen/src/write.rs index 7e998a665983..190e1c20e63b 100644 --- a/cranelift/codegen/src/write.rs +++ b/cranelift/codegen/src/write.rs @@ -352,14 +352,13 @@ fn write_instruction( // Write out the result values, if any. let mut has_results = false; for r in func.dfg.inst_results(inst) { - let r = func.dfg.resolve_aliases(*r); if !has_results { has_results = true; write!(w, "{}", r)?; } else { write!(w, ", {}", r)?; } - if let Some(f) = &func.dfg.facts[r] { + if let Some(f) = &func.dfg.facts[*r] { write!(w, " ! {}", f)?; } } @@ -389,23 +388,13 @@ fn write_instruction( pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt::Result { let pool = &dfg.value_lists; let jump_tables = &dfg.jump_tables; - - // Resolve a value to its alias, if any. - let v = |v: Value| dfg.resolve_aliases(v); - - // Resolve a list of values to their aliases and format them. - let vs = |vs: &[_]| { - let vs: Vec<_> = vs.iter().copied().map(v).collect(); - DisplayValues(&vs).to_string() - }; - use crate::ir::instructions::InstructionData::*; match dfg.insts[inst] { - AtomicRmw { op, args, .. } => write!(w, " {} {}, {}", op, v(args[0]), v(args[1])), - AtomicCas { args, .. } => write!(w, " {}, {}, {}", v(args[0]), v(args[1]), v(args[2])), - LoadNoOffset { flags, arg, .. } => write!(w, "{} {}", flags, v(arg)), - StoreNoOffset { flags, args, .. } => write!(w, "{} {}, {}", flags, v(args[0]), v(args[1])), - Unary { arg, .. } => write!(w, " {}", v(arg)), + AtomicRmw { op, args, .. } => write!(w, " {} {}, {}", op, args[0], args[1]), + AtomicCas { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]), + LoadNoOffset { flags, arg, .. } => write!(w, "{} {}", flags, arg), + StoreNoOffset { flags, args, .. } => write!(w, "{} {}, {}", flags, args[0], args[1]), + Unary { arg, .. } => write!(w, " {}", arg), UnaryImm { imm, .. } => write!(w, " {}", imm), UnaryIeee32 { imm, .. } => write!(w, " {}", imm), UnaryIeee64 { imm, .. } => write!(w, " {}", imm), @@ -413,29 +402,29 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt UnaryConst { constant_handle, .. } => write!(w, " {}", constant_handle), - Binary { args, .. } => write!(w, " {}, {}", v(args[0]), v(args[1])), - BinaryImm8 { arg, imm, .. } => write!(w, " {}, {}", v(arg), imm), - BinaryImm64 { arg, imm, .. } => write!(w, " {}, {}", v(arg), imm), - Ternary { args, .. } => write!(w, " {}, {}, {}", v(args[0]), v(args[1]), v(args[2])), + Binary { args, .. } => write!(w, " {}, {}", args[0], args[1]), + BinaryImm8 { arg, imm, .. } => write!(w, " {}, {}", arg, imm), + BinaryImm64 { arg, imm, .. } => write!(w, " {}, {}", arg, imm), + Ternary { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]), MultiAry { ref args, .. } => { if args.is_empty() { write!(w, "") } else { - write!(w, " {}", vs(args.as_slice(pool))) + write!(w, " {}", DisplayValues(args.as_slice(pool))) } } NullAry { .. } => write!(w, " "), - TernaryImm8 { imm, args, .. } => write!(w, " {}, {}, {}", v(args[0]), v(args[1]), imm), + TernaryImm8 { imm, args, .. } => write!(w, " {}, {}, {}", args[0], args[1], imm), Shuffle { imm, args, .. } => { let data = dfg.immediates.get(imm).expect( "Expected the shuffle mask to already be inserted into the immediates table", ); - write!(w, " {}, {}, {}", v(args[0]), v(args[1]), data) + write!(w, " {}, {}, {}", args[0], args[1], data) } - IntCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, v(args[0]), v(args[1])), + IntCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]), IntCompareImm { cond, arg, imm, .. } => write!(w, " {} {}, {}", cond, arg, imm), - IntAddTrap { args, code, .. } => write!(w, " {}, {}, {}", v(args[0]), v(args[1]), code), - FloatCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, v(args[0]), v(args[1])), + IntAddTrap { args, code, .. } => write!(w, " {}, {}, {}", args[0], args[1], code), + FloatCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]), Jump { destination, .. } => { write!(w, " {}", destination.display(pool)) } @@ -444,20 +433,26 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt blocks: [block_then, block_else], .. } => { - write!(w, " {}, {}", v(arg), block_then.display(pool))?; + write!(w, " {}, {}", arg, block_then.display(pool))?; write!(w, ", {}", block_else.display(pool)) } BranchTable { arg, table, .. } => { - write!(w, " {}, {}", v(arg), jump_tables[table].display(pool)) + write!(w, " {}, {}", arg, jump_tables[table].display(pool)) } Call { func_ref, ref args, .. - } => write!(w, " {}({})", func_ref, vs(args.as_slice(pool))), + } => write!(w, " {}({})", func_ref, DisplayValues(args.as_slice(pool))), CallIndirect { sig_ref, ref args, .. } => { let args = args.as_slice(pool); - write!(w, " {}, {}({})", sig_ref, args[0], vs(&args[1..])) + write!( + w, + " {}, {}({})", + sig_ref, + args[0], + DisplayValues(&args[1..]) + ) } FuncAddr { func_ref, .. } => write!(w, " {}", func_ref), StackLoad { @@ -468,7 +463,7 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt stack_slot, offset, .. - } => write!(w, " {}, {}{}", v(arg), stack_slot, offset), + } => write!(w, " {}, {}{}", arg, stack_slot, offset), DynamicStackLoad { dynamic_stack_slot, .. } => write!(w, " {}", dynamic_stack_slot), @@ -479,15 +474,15 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt } => write!(w, " {}, {}", arg, dynamic_stack_slot), Load { flags, arg, offset, .. - } => write!(w, "{} {}{}", flags, v(arg), offset), + } => write!(w, "{} {}{}", flags, arg, offset), Store { flags, args, offset, .. - } => write!(w, "{} {}, {}{}", flags, v(args[0]), v(args[1]), offset), + } => write!(w, "{} {}, {}{}", flags, args[0], args[1], offset), Trap { code, .. } => write!(w, " {}", code), - CondTrap { arg, code, .. } => write!(w, " {}, {}", v(arg), code), + CondTrap { arg, code, .. } => write!(w, " {}, {}", arg, code), }?; let mut sep = " ; "; @@ -502,7 +497,7 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt } => constant_handle.to_string(), _ => continue, }; - write!(w, "{}{} = {}", sep, v(arg), imm)?; + write!(w, "{}{} = {}", sep, arg, imm)?; sep = ", "; } } @@ -608,7 +603,7 @@ mod tests { } assert_eq!( func.to_string(), - "function u0:0() fast {\nblock0(v3: i32):\n v0 -> v3\n v2 -> v0\n v4 = iconst.i32 42\n v5 = iadd v3, v3\n v1 -> v5\n v6 = iconst.i32 23\n v7 = iadd v5, v5\n}\n" + "function u0:0() fast {\nblock0(v3: i32):\n v0 -> v3\n v2 -> v0\n v4 = iconst.i32 42\n v5 = iadd v0, v0\n v1 -> v5\n v6 = iconst.i32 23\n v7 = iadd v1, v1\n}\n" ); } diff --git a/cranelift/frontend/src/frontend.rs b/cranelift/frontend/src/frontend.rs index d2af6a7eaf50..631f6ba8cb8e 100644 --- a/cranelift/frontend/src/frontend.rs +++ b/cranelift/frontend/src/frontend.rs @@ -1294,8 +1294,8 @@ block0: v1 -> v4 v3 = iconst.i64 0 v0 -> v3 - v2 = call fn0(v4, v3, v4) ; v4 = 0, v3 = 0, v4 = 0 - return v4 ; v4 = 0 + v2 = call fn0(v1, v0, v1) ; v1 = 0, v0 = 0, v1 = 0 + return v1 ; v1 = 0 } ", ); @@ -1347,9 +1347,9 @@ block0: v1 -> v4 v3 = iconst.i64 0 v0 -> v3 - v2 = load.i64 aligned v3 ; v3 = 0 - store aligned v2, v4 ; v4 = 0 - return v4 ; v4 = 0 + v2 = load.i64 aligned v0 ; v0 = 0 + store aligned v2, v1 ; v1 = 0 + return v1 ; v1 = 0 } ", ); @@ -1405,8 +1405,8 @@ block0: v4 = iconst.i64 0 v0 -> v4 v2 = iconst.i64 8192 - v3 = call fn0(v5, v4, v2) ; v5 = 0, v4 = 0, v2 = 8192 - return v5 ; v5 = 0 + v3 = call fn0(v1, v0, v2) ; v1 = 0, v0 = 0, v2 = 8192 + return v1 ; v1 = 0 } ", ); @@ -1445,8 +1445,8 @@ block0: v2 = iconst.i64 0 v0 -> v2 v1 = iconst.i64 0x0101_0101_0101_0101 - store aligned v1, v2 ; v1 = 0x0101_0101_0101_0101, v2 = 0 - return v2 ; v2 = 0 + store aligned v1, v0 ; v1 = 0x0101_0101_0101_0101, v0 = 0 + return v0 ; v0 = 0 } ", ); @@ -1490,8 +1490,8 @@ block0: v1 = iconst.i8 1 v2 = iconst.i64 8192 v3 = uextend.i32 v1 ; v1 = 1 - v4 = call fn0(v5, v3, v2) ; v5 = 0, v2 = 8192 - return v5 ; v5 = 0 + v4 = call fn0(v0, v3, v2) ; v0 = 0, v2 = 8192 + return v0 ; v0 = 0 } ", ); @@ -1555,7 +1555,7 @@ block0: v1 -> v5 v4 = iconst.i64 0 v0 -> v4 - v3 = call fn0(v4, v5, v6) ; v4 = 0, v5 = 0, v6 = 0 + v3 = call fn0(v0, v1, v2) ; v0 = 0, v1 = 0, v2 = 0 return v3 } ", @@ -1599,8 +1599,8 @@ block0: v1 -> v6 v5 = iconst.i64 0 v0 -> v5 - v2 = load.i8 aligned v5 ; v5 = 0 - v3 = load.i8 aligned v6 ; v6 = 0 + v2 = load.i8 aligned v0 ; v0 = 0 + v3 = load.i8 aligned v1 ; v1 = 0 v4 = icmp ugt v2, v3 return v4", |builder, target, x, y| { @@ -1628,8 +1628,8 @@ block0: v1 -> v6 v5 = iconst.i64 0 v0 -> v5 - v2 = load.i32 aligned v5 ; v5 = 0 - v3 = load.i32 aligned v6 ; v6 = 0 + v2 = load.i32 aligned v0 ; v0 = 0 + v3 = load.i32 aligned v1 ; v1 = 0 v4 = icmp eq v2, v3 return v4", |builder, target, x, y| { @@ -1657,8 +1657,8 @@ block0: v1 -> v6 v5 = iconst.i64 0 v0 -> v5 - v2 = load.i128 v5 ; v5 = 0 - v3 = load.i128 v6 ; v6 = 0 + v2 = load.i128 v0 ; v0 = 0 + v3 = load.i128 v1 ; v1 = 0 v4 = icmp ne v2, v3 return v4", |builder, target, x, y| { @@ -1690,7 +1690,7 @@ block0: v5 = iconst.i64 0 v0 -> v5 v2 = iconst.i64 3 - v3 = call fn0(v5, v6, v2) ; v5 = 0, v6 = 0, v2 = 3 + v3 = call fn0(v0, v1, v2) ; v0 = 0, v1 = 0, v2 = 3 v4 = icmp_imm sge v3, 0 return v4", |builder, target, x, y| { @@ -1801,7 +1801,7 @@ block0: v1 -> v4 v3 = vconst.i8x16 const0 v0 -> v3 - return v3, v4, v6 ; v3 = const0, v4 = const0 + return v0, v1, v2 ; v0 = const0, v1 = const0 } ", ); diff --git a/tests/disas.rs b/tests/disas.rs index 1bfe53967ec8..b71fda2e3b02 100644 --- a/tests/disas.rs +++ b/tests/disas.rs @@ -118,7 +118,6 @@ fn run_test(path: &Path) -> Result<()> { UserFuncName::Testcase(_) => unreachable!(), }); - // And finally, use `cranelift_filetests` to perform the rest of the test. run_functions( &test.path, &test.contents, @@ -271,7 +270,7 @@ pub enum TestKind { } /// Assert that `wat` contains the test expectations necessary for `funcs`. -pub fn run_functions( +fn run_functions( path: &Path, wat: &str, isa: &dyn TargetIsa, @@ -294,9 +293,12 @@ pub fn run_functions( let mut ctx = cranelift_codegen::Context::for_function(func.clone()); ctx.optimize(isa, &mut Default::default()) .map_err(|e| codegen_error_to_anyhow_error(&ctx.func, e))?; + ctx.func.dfg.resolve_all_aliases(); writeln!(&mut actual, "{}", ctx.func.display()).unwrap(); } TestKind::Clif => { + let mut func = func.clone(); + func.dfg.resolve_all_aliases(); writeln!(&mut actual, "{}", func.display()).unwrap(); } } diff --git a/tests/disas/dead-code.wat b/tests/disas/dead-code.wat index d7933ef8f90d..3ece339d748f 100644 --- a/tests/disas/dead-code.wat +++ b/tests/disas/dead-code.wat @@ -28,7 +28,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v3 -> v2 ;; @0023 jump block2 ;; ;; block2: diff --git a/tests/disas/duplicate-loads-dynamic-memory.wat b/tests/disas/duplicate-loads-dynamic-memory.wat index 5ebfa6c61a9c..b1581785d7a4 100644 --- a/tests/disas/duplicate-loads-dynamic-memory.wat +++ b/tests/disas/duplicate-loads-dynamic-memory.wat @@ -32,10 +32,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v21 -> v0 -;; v22 -> v0 -;; v23 -> v0 -;; v24 -> v0 ;; @0057 v6 = load.i64 notrap aligned v0+88 ;; @0057 v8 = load.i64 notrap aligned checked v0+80 ;; @0057 v5 = uextend.i64 v2 @@ -44,7 +40,6 @@ ;; @0057 v9 = iadd v8, v5 ;; @0057 v11 = select_spectre_guard v7, v10, v9 ; v10 = 0 ;; @0057 v12 = load.i32 little heap v11 -;; v3 -> v12 ;; @005f jump block1 ;; ;; block1: @@ -61,10 +56,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v25 -> v0 -;; v26 -> v0 -;; v27 -> v0 -;; v28 -> v0 ;; @0064 v6 = load.i64 notrap aligned v0+88 ;; @0064 v8 = load.i64 notrap aligned checked v0+80 ;; @0064 v5 = uextend.i64 v2 @@ -75,7 +66,6 @@ ;; @0064 v11 = iadd v9, v10 ; v10 = 1234 ;; @0064 v13 = select_spectre_guard v7, v12, v11 ; v12 = 0 ;; @0064 v14 = load.i32 little heap v13 -;; v3 -> v14 ;; @006e jump block1 ;; ;; block1: diff --git a/tests/disas/duplicate-loads-static-memory.wat b/tests/disas/duplicate-loads-static-memory.wat index 36aad4e58647..a95c25e046a4 100644 --- a/tests/disas/duplicate-loads-static-memory.wat +++ b/tests/disas/duplicate-loads-static-memory.wat @@ -26,13 +26,10 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v13 -> v0 -;; v14 -> v0 ;; @0057 v6 = load.i64 notrap aligned readonly checked v0+80 ;; @0057 v5 = uextend.i64 v2 ;; @0057 v7 = iadd v6, v5 ;; @0057 v8 = load.i32 little heap v7 -;; v3 -> v8 ;; @005f jump block1 ;; ;; block1: @@ -48,15 +45,12 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v17 -> v0 -;; v18 -> v0 ;; @0064 v6 = load.i64 notrap aligned readonly checked v0+80 ;; @0064 v5 = uextend.i64 v2 ;; @0064 v7 = iadd v6, v5 ;; @0064 v8 = iconst.i64 1234 ;; @0064 v9 = iadd v7, v8 ; v8 = 1234 ;; @0064 v10 = load.i32 little heap v9 -;; v3 -> v10 ;; @006e jump block1 ;; ;; block1: diff --git a/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat b/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat index 120a10b83872..b43365c9087b 100644 --- a/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat +++ b/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat @@ -45,12 +45,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v30 -> v0 -;; v31 -> v0 -;; v32 -> v0 -;; v33 -> v0 -;; v34 -> v0 -;; v35 -> v0 ;; @0047 v7 = load.i64 notrap aligned v0+88 ;; @0047 v6 = uextend.i64 v2 ;; @0047 v8 = icmp ugt v6, v7 @@ -63,7 +57,6 @@ ;; @0047 v9 = load.i64 notrap aligned checked v0+80 ;; @0047 v10 = iadd v9, v6 ;; @0047 v11 = load.i32 little heap v10 -;; v3 -> v11 ;; @004c brif.i8 v8, block4, block5 ;; ;; block4 cold: @@ -73,7 +66,6 @@ ;; @004c v17 = iconst.i64 4 ;; @004c v18 = iadd.i64 v10, v17 ; v17 = 4 ;; @004c v19 = load.i32 little heap v18 -;; v4 -> v19 ;; @0051 v21 = iconst.i64 0x0010_0003 ;; @0051 v22 = uadd_overflow_trap.i64 v6, v21, heap_oob ; v21 = 0x0010_0003 ;; @0051 v24 = icmp ugt v22, v7 @@ -88,7 +80,6 @@ ;; @0051 v27 = iconst.i64 0x000f_ffff ;; @0051 v28 = iadd v26, v27 ; v27 = 0x000f_ffff ;; @0051 v29 = load.i32 little heap v28 -;; v5 -> v29 ;; @0056 jump block1 ;; ;; block1: @@ -105,12 +96,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32): -;; v27 -> v0 -;; v28 -> v0 -;; v29 -> v0 -;; v30 -> v0 -;; v31 -> v0 -;; v32 -> v0 ;; @005d v7 = load.i64 notrap aligned v0+88 ;; @005d v6 = uextend.i64 v2 ;; @005d v8 = icmp ugt v6, v7 diff --git a/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat b/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat index 44e3a8700f93..a774e6c961de 100644 --- a/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat +++ b/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat @@ -41,12 +41,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v36 -> v0 -;; v37 -> v0 -;; v38 -> v0 -;; v39 -> v0 -;; v40 -> v0 -;; v41 -> v0 ;; @0047 v7 = load.i64 notrap aligned v0+88 ;; @0047 v9 = load.i64 notrap aligned checked v0+80 ;; @0047 v6 = uextend.i64 v2 @@ -55,12 +49,10 @@ ;; @0047 v10 = iadd v9, v6 ;; @0047 v12 = select_spectre_guard v8, v11, v10 ; v11 = 0 ;; @0047 v13 = load.i32 little heap v12 -;; v3 -> v13 ;; @004c v19 = iconst.i64 4 ;; @004c v20 = iadd v10, v19 ; v19 = 4 ;; @004c v22 = select_spectre_guard v8, v11, v20 ; v11 = 0 ;; @004c v23 = load.i32 little heap v22 -;; v4 -> v23 ;; @0051 v25 = iconst.i64 0x0010_0003 ;; @0051 v26 = uadd_overflow_trap v6, v25, heap_oob ; v25 = 0x0010_0003 ;; @0051 v28 = icmp ugt v26, v7 @@ -68,7 +60,6 @@ ;; @0051 v32 = iadd v10, v31 ; v31 = 0x000f_ffff ;; @0051 v34 = select_spectre_guard v28, v11, v32 ; v11 = 0 ;; @0051 v35 = load.i32 little heap v34 -;; v5 -> v35 ;; @0056 jump block1 ;; ;; block1: @@ -85,12 +76,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32): -;; v33 -> v0 -;; v34 -> v0 -;; v35 -> v0 -;; v36 -> v0 -;; v37 -> v0 -;; v38 -> v0 ;; @005d v7 = load.i64 notrap aligned v0+88 ;; @005d v9 = load.i64 notrap aligned checked v0+80 ;; @005d v6 = uextend.i64 v2 diff --git a/tests/disas/icall-loop.wat b/tests/disas/icall-loop.wat index ea5f27ea116c..b9752503a614 100644 --- a/tests/disas/icall-loop.wat +++ b/tests/disas/icall-loop.wat @@ -34,11 +34,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v16 -> v0 -;; v18 -> v0 -;; v27 -> v0 -;; v3 -> v2 -;; v26 -> v3 ;; @002b v4 = iconst.i32 2 ;; @002b v5 = icmp uge v2, v4 ; v4 = 2 ;; @002b v10 = iconst.i64 0 @@ -92,9 +87,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; v15 -> v0 -;; v17 -> v0 -;; v25 -> v0 ;; @0038 v6 = load.i64 notrap aligned readonly v0+72 ;; v36 = iconst.i64 8 ;; @0038 v8 = iadd v6, v36 ; v36 = 8 diff --git a/tests/disas/if-unreachable-else-params.wat b/tests/disas/if-unreachable-else-params.wat index 075c58c8e208..377fff60d2a0 100644 --- a/tests/disas/if-unreachable-else-params.wat +++ b/tests/disas/if-unreachable-else-params.wat @@ -51,7 +51,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v5 -> v2 ;; @0043 v3 = iconst.i32 35 ;; @0045 jump block2(v3) ; v3 = 35 ;; diff --git a/tests/disas/readonly-funcrefs.wat b/tests/disas/readonly-funcrefs.wat index 0e36fb3e6802..64119b59d72b 100644 --- a/tests/disas/readonly-funcrefs.wat +++ b/tests/disas/readonly-funcrefs.wat @@ -43,9 +43,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v15 -> v0 -;; v17 -> v0 -;; v24 -> v0 ;; @0031 v3 = iconst.i32 2 ;; @0031 v4 = icmp uge v2, v3 ; v3 = 2 ;; @0031 v9 = iconst.i64 0 diff --git a/tests/disas/table-get-fixed-size.wat b/tests/disas/table-get-fixed-size.wat index bfb360ed5dae..5e17122e16e9 100644 --- a/tests/disas/table-get-fixed-size.wat +++ b/tests/disas/table-get-fixed-size.wat @@ -26,9 +26,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; v14 -> v0 -;; v19 -> v0 -;; v23 -> v0 ;; @0052 v3 = iconst.i32 0 ;; @0054 v4 = iconst.i32 7 ;; @0054 v5 = icmp uge v3, v4 ; v3 = 0, v4 = 7 @@ -40,7 +37,6 @@ ;; @0054 v10 = iconst.i64 0 ;; @0054 v11 = select_spectre_guard v5, v10, v9 ; v10 = 0 ;; @0054 v12 = load.r64 table_oob aligned table v11 -;; v2 -> v12 ;; @0054 v13 = is_null v12 ;; @0054 brif v13, block2, block3 ;; @@ -84,9 +80,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v14 -> v0 -;; v19 -> v0 -;; v23 -> v0 ;; @005b v4 = iconst.i32 7 ;; @005b v5 = icmp uge v2, v4 ; v4 = 7 ;; @005b v6 = uextend.i64 v2 @@ -97,7 +90,6 @@ ;; @005b v10 = iconst.i64 0 ;; @005b v11 = select_spectre_guard v5, v10, v9 ; v10 = 0 ;; @005b v12 = load.r64 table_oob aligned table v11 -;; v3 -> v12 ;; @005b v13 = is_null v12 ;; @005b brif v13, block2, block3 ;; diff --git a/tests/disas/table-get.wat b/tests/disas/table-get.wat index 2d05c4836acf..939c84979913 100644 --- a/tests/disas/table-get.wat +++ b/tests/disas/table-get.wat @@ -26,10 +26,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; v14 -> v0 -;; v19 -> v0 -;; v23 -> v0 -;; v24 -> v0 ;; @0051 v3 = iconst.i32 0 ;; @0053 v4 = load.i32 notrap aligned v0+80 ;; @0053 v5 = icmp uge v3, v4 ; v3 = 0 @@ -41,7 +37,6 @@ ;; @0053 v10 = iconst.i64 0 ;; @0053 v11 = select_spectre_guard v5, v10, v9 ; v10 = 0 ;; @0053 v12 = load.r64 table_oob aligned table v11 -;; v2 -> v12 ;; @0053 v13 = is_null v12 ;; @0053 brif v13, block2, block3 ;; @@ -86,10 +81,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32): -;; v14 -> v0 -;; v19 -> v0 -;; v23 -> v0 -;; v24 -> v0 ;; @005a v4 = load.i32 notrap aligned v0+80 ;; @005a v5 = icmp uge v2, v4 ;; @005a v6 = uextend.i64 v2 @@ -100,7 +91,6 @@ ;; @005a v10 = iconst.i64 0 ;; @005a v11 = select_spectre_guard v5, v10, v9 ; v10 = 0 ;; @005a v12 = load.r64 table_oob aligned table v11 -;; v3 -> v12 ;; @005a v13 = is_null v12 ;; @005a brif v13, block2, block3 ;; diff --git a/tests/disas/table-set-fixed-size.wat b/tests/disas/table-set-fixed-size.wat index 421726e12ccd..efa51e51b2cd 100644 --- a/tests/disas/table-set-fixed-size.wat +++ b/tests/disas/table-set-fixed-size.wat @@ -27,8 +27,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: r64): -;; v20 -> v0 -;; v21 -> v0 ;; @0052 v3 = iconst.i32 0 ;; @0056 v4 = iconst.i32 7 ;; @0056 v5 = icmp uge v3, v4 ; v3 = 0, v4 = 7 @@ -87,8 +85,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: r64): -;; v20 -> v0 -;; v21 -> v0 ;; @005f v4 = iconst.i32 7 ;; @005f v5 = icmp uge v2, v4 ; v4 = 7 ;; @005f v6 = uextend.i64 v2 diff --git a/tests/disas/table-set.wat b/tests/disas/table-set.wat index ae146a2e4b9f..2ef0466689e4 100644 --- a/tests/disas/table-set.wat +++ b/tests/disas/table-set.wat @@ -28,9 +28,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: r64): -;; v20 -> v0 -;; v21 -> v0 -;; v22 -> v0 ;; @0051 v3 = iconst.i32 0 ;; @0055 v4 = load.i32 notrap aligned v0+80 ;; @0055 v5 = icmp uge v3, v4 ; v3 = 0 @@ -90,9 +87,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: r64): -;; v20 -> v0 -;; v21 -> v0 -;; v22 -> v0 ;; @005e v4 = load.i32 notrap aligned v0+80 ;; @005e v5 = icmp uge v2, v4 ;; @005e v6 = uextend.i64 v2 diff --git a/tests/disas/typed-funcrefs.wat b/tests/disas/typed-funcrefs.wat index 94b985ebeba6..74f45701a728 100644 --- a/tests/disas/typed-funcrefs.wat +++ b/tests/disas/typed-funcrefs.wat @@ -120,7 +120,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32): -;; v6 -> v2 ;; @0039 jump block1 ;; ;; block1: @@ -139,14 +138,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32): -;; v21 -> v0 -;; v45 -> v0 -;; v52 -> v0 -;; v55 -> v0 -;; v28 -> v2 -;; v29 -> v3 -;; v30 -> v4 -;; v31 -> v5 ;; @0048 v12 = load.i64 notrap aligned readonly v0+72 ;; v66 = iconst.i64 8 ;; @0048 v14 = iadd v12, v66 ; v66 = 8 @@ -157,7 +148,6 @@ ;; ;; block2 cold: ;; @003c v7 = iconst.i32 0 -;; v26 -> v7 ;; @0046 v8 = iconst.i32 1 ;; @0048 v22 = call fn0(v0, v7, v8) ; v7 = 0, v8 = 1 ;; @0048 jump block3(v22) @@ -187,7 +177,6 @@ ;; ;; block1: ;; @0061 v51 = iadd.i32 v49, v25 -;; v6 -> v51 ;; @0066 return v51 ;; } ;; @@ -203,14 +192,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32): -;; v21 -> v0 -;; v45 -> v0 -;; v52 -> v0 -;; v55 -> v0 -;; v28 -> v2 -;; v29 -> v3 -;; v30 -> v4 -;; v31 -> v5 ;; @0075 v12 = load.i64 notrap aligned readonly v0+72 ;; v66 = iconst.i64 8 ;; @0075 v14 = iadd v12, v66 ; v66 = 8 @@ -221,7 +202,6 @@ ;; ;; block2 cold: ;; @0069 v7 = iconst.i32 0 -;; v26 -> v7 ;; @0073 v8 = iconst.i32 1 ;; @0075 v22 = call fn0(v0, v7, v8) ; v7 = 0, v8 = 1 ;; @0075 jump block3(v22) @@ -251,7 +231,6 @@ ;; ;; block1: ;; @008c v51 = iadd.i32 v49, v25 -;; v6 -> v51 ;; @0091 return v51 ;; } ;; @@ -264,8 +243,6 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32): -;; v8 -> v0 -;; v14 -> v0 ;; @009e v9 = load.i64 notrap aligned table v0+96 ;; @00a0 v10 = load.i64 null_reference aligned readonly v9+16 ;; @00a0 v11 = load.i64 notrap aligned readonly v9+32 @@ -278,6 +255,5 @@ ;; ;; block1: ;; @00b5 v19 = iadd.i32 v18, v12 -;; v6 -> v19 ;; @00ba return v19 ;; }