Fix tests.

Author: cfallin

cranelift/codegen/src/dominator_tree.rs

@@ -644,7 +644,7 @@ mod tests {
         cur.insert_block(block1);
         let v1 = cur.ins().iconst(I32, 1);
         let v2 = cur.ins().iadd(v0, v1);
-        cur.ins().jump(block0, &[v2]);
+        cur.ins().jump(block0, &[v2.into()]);
 
         cur.insert_block(block2);
         cur.ins().return_(&[v0]);

cranelift/codegen/src/dominator_tree/simple.rs

@@ -365,7 +365,7 @@ mod tests {
         cur.insert_block(block1);
         let v1 = cur.ins().iconst(I32, 1);
         let v2 = cur.ins().iadd(v0, v1);
-        cur.ins().jump(block0, &[v2]);
+        cur.ins().jump(block0, &[v2.into()]);
 
         cur.insert_block(block2);
         cur.ins().return_(&[v0]);

cranelift/codegen/src/ir/jumptable.rs

@@ -113,13 +113,14 @@ mod tests {
     use super::JumpTableData;
     use crate::entity::EntityRef;
     use crate::ir::instructions::ValueListPool;
-    use crate::ir::{Block, BlockCall, Value};
+    use crate::ir::{Block, BlockArg, BlockCall, Value};
+    use alloc::vec::Vec;
     use std::string::ToString;
 
     #[test]
     fn empty() {
         let mut pool = ValueListPool::default();
-        let def = BlockCall::new(Block::new(0), &[], &mut pool);
+        let def = BlockCall::new(Block::new(0), core::iter::empty(), &mut pool);
 
         let jt = JumpTableData::new(def, &[]);
 
@@ -145,10 +146,10 @@ mod tests {
         let e1 = Block::new(1);
         let e2 = Block::new(2);
 
-        let def = BlockCall::new(e0, &[], &mut pool);
-        let b1 = BlockCall::new(e1, &[v0], &mut pool);
-        let b2 = BlockCall::new(e2, &[], &mut pool);
-        let b3 = BlockCall::new(e1, &[v1], &mut pool);
+        let def = BlockCall::new(e0, core::iter::empty(), &mut pool);
+        let b1 = BlockCall::new(e1, core::iter::once(v0.into()), &mut pool);
+        let b2 = BlockCall::new(e2, core::iter::empty(), &mut pool);
+        let b3 = BlockCall::new(e1, core::iter::once(v1.into()), &mut pool);
 
         let jt = JumpTableData::new(def, &[b1, b2, b3]);
 
@@ -161,8 +162,14 @@ mod tests {
         assert_eq!(jt.all_branches(), [def, b1, b2, b3]);
         assert_eq!(jt.as_slice(), [b1, b2, b3]);
 
-        assert_eq!(jt.as_slice()[0].args_slice(&pool), [v0]);
-        assert_eq!(jt.as_slice()[1].args_slice(&pool), []);
-        assert_eq!(jt.as_slice()[2].args_slice(&pool), [v1]);
+        assert_eq!(
+            jt.as_slice()[0].args(&pool).collect::<Vec<_>>(),
+            [BlockArg::Value(v0)]
+        );
+        assert_eq!(jt.as_slice()[1].args(&pool).collect::<Vec<_>>(), []);
+        assert_eq!(
+            jt.as_slice()[2].args(&pool).collect::<Vec<_>>(),
+            [BlockArg::Value(v1)]
+        );
     }
 }

cranelift/codegen/src/isa/x64/inst/emit_tests.rs

@@ -5123,7 +5123,7 @@ fn test_x64_emit() {
     for (insn, expected_encoding, expected_printing) in insns {
         // Check the printed text is as expected.
         let actual_printing = insn.pretty_print_inst(&mut Default::default());
-        assert_eq!(expected_printing, actual_printing);
+        assert_eq!(expected_printing, actual_printing.trim());
         let mut buffer = MachBuffer::new();
 
         insn.emit(&mut buffer, &emit_info, &mut Default::default());

cranelift/codegen/src/traversals.rs

@@ -194,7 +194,7 @@ mod tests {
         cur.insert_block(block1);
         let v1 = cur.ins().iconst(I32, 1);
         let v2 = cur.ins().iadd(v0, v1);
-        cur.ins().jump(block0, &[v2]);
+        cur.ins().jump(block0, &[v2.into()]);
 
         // block2:
         //   return v0

cranelift/frontend/src/frontend/safepoints.rs

@@ -840,7 +840,7 @@ mod tests {
         builder.declare_value_needs_stack_map(b);
         builder.switch_to_block(block0);
         builder.ins().call(func_ref, &[a]);
-        builder.ins().jump(block0, &[a, b]);
+        builder.ins().jump(block0, &[a.into(), b.into()]);
         builder.seal_all_blocks();
         builder.finalize();
 
@@ -1434,15 +1434,15 @@ block2:
         let v2 = builder.ins().iconst(ir::types::I64, 2);
         builder.declare_value_needs_stack_map(v2);
         builder.ins().call(func_ref, &[]);
-        builder.ins().jump(block3, &[v1, v2]);
+        builder.ins().jump(block3, &[v1.into(), v2.into()]);
 
         builder.switch_to_block(block2);
         let v3 = builder.ins().iconst(ir::types::I64, 3);
         builder.declare_value_needs_stack_map(v3);
         let v4 = builder.ins().iconst(ir::types::I64, 4);
         builder.declare_value_needs_stack_map(v4);
         builder.ins().call(func_ref, &[]);
-        builder.ins().jump(block3, &[v3, v3]);
+        builder.ins().jump(block3, &[v3.into(), v3.into()]);
 
         builder.switch_to_block(block3);
         builder.append_block_param(block3, ir::types::I64);
@@ -2338,7 +2338,7 @@ block4:
         builder.declare_value_needs_stack_map(v2);
         let v3 = builder.func.dfg.block_params(block0)[3];
 
-        builder.ins().jump(block1, &[v3]);
+        builder.ins().jump(block1, &[v3.into()]);
 
         builder.switch_to_block(block1);
         let v4 = builder.append_block_param(block1, ir::types::I32);
@@ -2352,7 +2352,7 @@ block4:
         builder.ins().call(bar_func_ref, &[v1]);
         builder.ins().call(foo_func_ref, &[]);
         let v5 = builder.ins().iadd_imm(v4, -1);
-        builder.ins().brif(v4, block1, &[v5], block3, &[]);
+        builder.ins().brif(v4, block1, &[v5.into()], block3, &[]);
 
         builder.switch_to_block(block3);
         builder.ins().call(foo_func_ref, &[]);
@@ -2573,7 +2573,7 @@ block3:
         let v1 = builder.func.dfg.first_result(call_inst);
         builder.def_var(var_array, v1);
         let v2 = builder.ins().iconst(ir::types::I32, 0);
-        builder.ins().jump(block_array_init_loop_head, &[v2]);
+        builder.ins().jump(block_array_init_loop_head, &[v2.into()]);
 
         builder.switch_to_block(block_array_init_loop_head);
         let v3 = builder.append_block_param(block_array_init_loop_head, ir::types::I32);
@@ -2594,7 +2594,7 @@ block3:
         builder.ins().call(array_init_elem, &[v1, v4]);
         let v6 = builder.ins().iconst(ir::types::I32, 1);
         let v7 = builder.ins().iadd(v4, v6);
-        builder.ins().jump(block_array_init_loop_head, &[v7]);
+        builder.ins().jump(block_array_init_loop_head, &[v7.into()]);
         builder.seal_block(block_array_init_loop_head);
 
         builder.switch_to_block(block_array_init_loop_done);
@@ -2608,7 +2608,7 @@ block3:
         builder.ins().brif(
             v10,
             block_ref_test_done,
-            &[v9],
+            &[v9.into()],
             block_ref_test_non_null,
             &[],
         );
@@ -2620,15 +2620,19 @@ block3:
         let v12 = builder.ins().iconst(ir::types::I32, 0xbeefbeef);
         let v13 = builder.ins().icmp(ir::condcodes::IntCC::Equal, v11, v12);
         let v14 = builder.ins().iconst(ir::types::I32, 1);
-        builder
-            .ins()
-            .brif(v13, block_ref_test_done, &[v14], block_ref_test_slow, &[]);
+        builder.ins().brif(
+            v13,
+            block_ref_test_done,
+            &[v14.into()],
+            block_ref_test_slow,
+            &[],
+        );
 
         builder.switch_to_block(block_ref_test_slow);
         builder.seal_block(block_ref_test_slow);
         let call_inst = builder.ins().call(ref_test, &[v8, v12]);
         let v15 = builder.func.dfg.first_result(call_inst);
-        builder.ins().jump(block_ref_test_done, &[v15]);
+        builder.ins().jump(block_ref_test_done, &[v15.into()]);
 
         builder.switch_to_block(block_ref_test_done);
         let v16 = builder.append_block_param(block_ref_test_done, ir::types::I32);

cranelift/frontend/src/ssa.rs

@@ -769,9 +769,9 @@ mod tests {
                 ..
             } => {
                 assert_eq!(block_then.block(&func.dfg.value_lists), block2);
-                assert_eq!(block_then.args_slice(&func.dfg.value_lists).len(), 0);
+                assert_eq!(block_then.args(&func.dfg.value_lists).len(), 0);
                 assert_eq!(block_else.block(&func.dfg.value_lists), block1);
-                assert_eq!(block_else.args_slice(&func.dfg.value_lists).len(), 0);
+                assert_eq!(block_else.args(&func.dfg.value_lists).len(), 0);
             }
             _ => assert!(false),
         };
@@ -781,9 +781,9 @@ mod tests {
                 ..
             } => {
                 assert_eq!(block_then.block(&func.dfg.value_lists), block2);
-                assert_eq!(block_then.args_slice(&func.dfg.value_lists).len(), 0);
+                assert_eq!(block_then.args(&func.dfg.value_lists).len(), 0);
                 assert_eq!(block_else.block(&func.dfg.value_lists), block1);
-                assert_eq!(block_else.args_slice(&func.dfg.value_lists).len(), 0);
+                assert_eq!(block_else.args(&func.dfg.value_lists).len(), 0);
             }
             _ => assert!(false),
         };
@@ -792,7 +792,7 @@ mod tests {
                 destination: dest, ..
             } => {
                 assert_eq!(dest.block(&func.dfg.value_lists), block2);
-                assert_eq!(dest.args_slice(&func.dfg.value_lists).len(), 0);
+                assert_eq!(dest.args(&func.dfg.value_lists).len(), 0);
             }
             _ => assert!(false),
         };

crates/cranelift/src/func_environ/gc/enabled.rs

@@ -567,7 +567,7 @@ fn emit_array_fill_impl(
 
     // Current block: jump to the loop header block with the first element's
     // address.
-    builder.ins().jump(loop_header_block, &[elem_addr]);
+    builder.ins().jump(loop_header_block, &[elem_addr.into()]);
 
     // Loop header block: check if we're done, then jump to either the continue
     // block or the loop body block.
@@ -586,7 +586,9 @@ fn emit_array_fill_impl(
     log::trace!("emit_array_fill_impl: loop body");
     emit_elem_write(func_env, builder, elem_addr)?;
     let next_elem_addr = builder.ins().iadd(elem_addr, elem_size);
-    builder.ins().jump(loop_header_block, &[next_elem_addr]);
+    builder
+        .ins()
+        .jump(loop_header_block, &[next_elem_addr.into()]);
 
     // Continue...
     builder.switch_to_block(continue_block);
@@ -930,7 +932,7 @@ pub fn translate_ref_test(
     builder.ins().brif(
         is_null,
         continue_block,
-        &[result_when_is_null],
+        &[result_when_is_null.into()],
         non_null_block,
         &[],
     );
@@ -957,7 +959,7 @@ pub fn translate_ref_test(
         builder.ins().brif(
             is_i31,
             continue_block,
-            &[result_when_is_i31],
+            &[result_when_is_i31.into()],
             non_null_non_i31_block,
             &[],
         );
@@ -1066,7 +1068,7 @@ pub fn translate_ref_test(
 
         WasmHeapType::Cont | WasmHeapType::ConcreteCont(_) | WasmHeapType::NoCont => todo!(), // FIXME: #10248 stack switching support.
     };
-    builder.ins().jump(continue_block, &[result]);
+    builder.ins().jump(continue_block, &[result.into()]);
 
     // Control flow join point with the result.
     builder.switch_to_block(continue_block);
@@ -1446,9 +1448,13 @@ impl FuncEnvironment<'_> {
         log::trace!("is_subtype: fast path check for exact same types");
         let same_ty = builder.ins().icmp(IntCC::Equal, a, b);
         let same_ty = builder.ins().uextend(ir::types::I32, same_ty);
-        builder
-            .ins()
-            .brif(same_ty, continue_block, &[same_ty], diff_tys_block, &[]);
+        builder.ins().brif(
+            same_ty,
+            continue_block,
+            &[same_ty.into()],
+            diff_tys_block,
+            &[],
+        );
 
         // Different types block: fall back to the `is_subtype` libcall.
         builder.switch_to_block(diff_tys_block);
@@ -1457,7 +1463,7 @@ impl FuncEnvironment<'_> {
         let vmctx = self.vmctx_val(&mut builder.cursor());
         let call_inst = builder.ins().call(is_subtype, &[vmctx, a, b]);
         let result = builder.func.dfg.first_result(call_inst);
-        builder.ins().jump(continue_block, &[result]);
+        builder.ins().jump(continue_block, &[result.into()]);
 
         // Continue block: join point for the result.
         builder.switch_to_block(continue_block);