cranelift: Remove brz and brnz (#5630)

Remove the brz and brnz instructions, as their behavior is now redundant with brif.

cranelift/codegen/meta/src/shared/formats.rs

@@ -8,9 +8,8 @@ pub(crate) struct Formats {
     pub(crate) binary: Rc<InstructionFormat>,
     pub(crate) binary_imm8: Rc<InstructionFormat>,
     pub(crate) binary_imm64: Rc<InstructionFormat>,
-    pub(crate) brif: Rc<InstructionFormat>,
-    pub(crate) branch: Rc<InstructionFormat>,
     pub(crate) branch_table: Rc<InstructionFormat>,
+    pub(crate) brif: Rc<InstructionFormat>,
     pub(crate) call: Rc<InstructionFormat>,
     pub(crate) call_indirect: Rc<InstructionFormat>,
     pub(crate) cond_trap: Rc<InstructionFormat>,
@@ -114,8 +113,6 @@ impl Formats {
 
             jump: Builder::new("Jump").block().build(),
 
-            branch: Builder::new("Branch").value().block().build(),
-
             brif: Builder::new("Brif").value().block().block().build(),
 
             branch_table: Builder::new("BranchTable")

cranelift/codegen/meta/src/shared/instructions.rs

@@ -65,38 +65,6 @@ fn define_control_flow(
         );
     }
 
-    {
-        let c = &Operand::new("c", ScalarTruthy).with_doc("Controlling value to test");
-
-        ig.push(
-            Inst::new(
-                "brz",
-                r#"
-        Branch when zero.
-
-        Take the branch when ``c = 0``.
-        "#,
-                &formats.branch,
-            )
-            .operands_in(vec![c, block_call])
-            .is_branch(true),
-        );
-
-        ig.push(
-            Inst::new(
-                "brnz",
-                r#"
-        Branch when non-zero.
-
-        Take the branch when ``c != 0``.
-        "#,
-                &formats.branch,
-            )
-            .operands_in(vec![c, block_call])
-            .is_branch(true),
-        );
-    }
-
     {
         let _i32 = &TypeVar::new(
             "i32",

cranelift/codegen/src/cfg_printer.rs

@@ -53,7 +53,7 @@ impl<'a> CFGPrinter<'a> {
             write!(w, "    {} [shape=record, label=\"{{", block)?;
             crate::write::write_block_header(w, self.func, block, 4)?;
             // Add all outgoing branch instructions to the label.
-            for inst in self.func.layout.block_likely_branches(block) {
+            if let Some(inst) = self.func.layout.last_inst(block) {
                 write!(w, " | <{}>", inst)?;
                 PlainWriter.write_instruction(w, self.func, &aliases, inst, 0)?;
             }

cranelift/codegen/src/context.rs

@@ -285,7 +285,7 @@ impl Context {
 
     /// Perform pre-legalization rewrites on the function.
     pub fn preopt(&mut self, isa: &dyn TargetIsa) -> CodegenResult<()> {
-        do_preopt(&mut self.func, &mut self.cfg, isa);
+        do_preopt(&mut self.func, isa);
         self.verify_if(isa)?;
         Ok(())
     }

cranelift/codegen/src/dominator_tree.rs

@@ -351,7 +351,7 @@ impl DominatorTree {
     /// post-order. Split-invariant means that if a block is split in two, we get the same
     /// post-order except for the insertion of the new block header at the split point.
     fn push_successors(&mut self, func: &Function, block: Block) {
-        for inst in func.layout.block_likely_branches(block) {
+        if let Some(inst) = func.layout.last_inst(block) {
             match func.dfg.analyze_branch(inst) {
                 BranchInfo::SingleDest(succ) => {
                     self.push_if_unseen(succ.block(&func.dfg.value_lists))
@@ -653,11 +653,14 @@ mod tests {
         let v0 = func.dfg.append_block_param(block0, I32);
         let block1 = func.dfg.make_block();
         let block2 = func.dfg.make_block();
+        let trap_block = func.dfg.make_block();
 
         let mut cur = FuncCursor::new(&mut func);
 
         cur.insert_block(block0);
-        cur.ins().brnz(v0, block2, &[]);
+        cur.ins().brif(v0, block2, &[], trap_block, &[]);
+
+        cur.insert_block(trap_block);
         cur.ins().trap(TrapCode::User(0));
 
         cur.insert_block(block1);
@@ -674,13 +677,13 @@ mod tests {
         // Fall-through-first, prune-at-source DFT:
         //
         // block0 {
-        //   brnz block2 {
+        //   brif block2 {
         //     trap
         //     block2 {
         //       return
         //     } block2
         // } block0
-        assert_eq!(dt.cfg_postorder(), &[block2, block0]);
+        assert_eq!(dt.cfg_postorder(), &[trap_block, block2, block0]);
 
         let v2_def = cur.func.dfg.value_def(v2).unwrap_inst();
         assert!(!dt.dominates(v2_def, block0, &cur.func.layout));
@@ -714,8 +717,7 @@ mod tests {
         let jmp_block3_block1 = cur.ins().jump(block1, &[]);
 
         cur.insert_block(block1);
-        let br_block1_block0 = cur.ins().brnz(cond, block0, &[]);
+        let br_block1_block0_block2 = cur.ins().brif(cond, block0, &[], block2, &[]);
-        let jmp_block1_block2 = cur.ins().jump(block2, &[]);
 
         cur.insert_block(block2);
         cur.ins().jump(block0, &[]);
@@ -730,7 +732,7 @@ mod tests {
         // block3 {
         //   block3:jump block1 {
         //     block1 {
-        //       block1:brnz block0 {
+        //       block1:brif block0 {
         //         block1:jump block2 {
         //           block2 {
         //             block2:jump block0 (seen)
@@ -738,7 +740,7 @@ mod tests {
         //         } block1:jump block2
         //         block0 {
         //         } block0
-        //       } block1:brnz block0
+        //       } block1:brif block0
         //     } block1
         //   } block3:jump block1
         // } block3
@@ -748,12 +750,16 @@ mod tests {
         assert_eq!(cur.func.layout.entry_block().unwrap(), block3);
         assert_eq!(dt.idom(block3), None);
         assert_eq!(dt.idom(block1).unwrap(), jmp_block3_block1);
-        assert_eq!(dt.idom(block2).unwrap(), jmp_block1_block2);
+        assert_eq!(dt.idom(block2).unwrap(), br_block1_block0_block2);
-        assert_eq!(dt.idom(block0).unwrap(), br_block1_block0);
+        assert_eq!(dt.idom(block0).unwrap(), br_block1_block0_block2);
 
-        assert!(dt.dominates(br_block1_block0, br_block1_block0, &cur.func.layout));
+        assert!(dt.dominates(
-        assert!(!dt.dominates(br_block1_block0, jmp_block3_block1, &cur.func.layout));
+            br_block1_block0_block2,
-        assert!(dt.dominates(jmp_block3_block1, br_block1_block0, &cur.func.layout));
+            br_block1_block0_block2,
+            &cur.func.layout
+        ));
+        assert!(!dt.dominates(br_block1_block0_block2, jmp_block3_block1, &cur.func.layout));
+        assert!(dt.dominates(jmp_block3_block1, br_block1_block0_block2, &cur.func.layout));
 
         assert_eq!(
             dt.rpo_cmp(block3, block3, &cur.func.layout),
@@ -765,7 +771,7 @@ mod tests {
             Ordering::Less
         );
         assert_eq!(
-            dt.rpo_cmp(jmp_block3_block1, jmp_block1_block2, &cur.func.layout),
+            dt.rpo_cmp(jmp_block3_block1, br_block1_block0_block2, &cur.func.layout),
             Ordering::Less
         );
     }

cranelift/codegen/src/egraph/elaborate.rs

@@ -465,11 +465,7 @@ impl<'a> Elaborator<'a> {
                             ));
                             // Determine the instruction at which we
                             // insert in `data.hoist_block`.
-                            let before = self
+                            let before = self.func.layout.last_inst(data.hoist_block).unwrap();
-                                .func
-                                .layout
-                                .canonical_branch_inst(&self.func.dfg, data.hoist_block)
-                                .unwrap();
                             (data.scope_depth as usize, before, data.hoist_block)
                         };
 

cranelift/codegen/src/flowgraph.rs

@@ -11,17 +11,14 @@
 //!
 //!         ...
 //!
-//!         brz vx, Block1 ; end of basic block
+//!         brif vx, Block1, Block2 ; end of basic block
 //!
-//!         ...          ; beginning of basic block
+//!     Block1:
-//!
+//!         jump block3
-//!         ...
-//!
-//!         jmp Block2     ; end of basic block
 //! ```
 //!
-//! Here `Block1` and `Block2` would each have a single predecessor denoted as `(Block0, brz)`
+//! Here `Block1` and `Block2` would each have a single predecessor denoted as `(Block0, brif)`,
-//! and `(Block0, jmp Block2)` respectively.
+//! while `Block3` would have a single predecessor denoted as `(Block1, jump block3)`.
 
 use crate::bforest;
 use crate::entity::SecondaryMap;
@@ -120,7 +117,7 @@ impl ControlFlowGraph {
     }
 
     fn compute_block(&mut self, func: &Function, block: Block) {
-        for inst in func.layout.block_likely_branches(block) {
+        if let Some(inst) = func.layout.last_inst(block) {
             match func.dfg.analyze_branch(inst) {
                 BranchInfo::SingleDest(dest) => {
                     self.add_edge(block, inst, dest.block(&func.dfg.value_lists));
@@ -253,21 +250,17 @@ mod tests {
         let block1 = func.dfg.make_block();
         let block2 = func.dfg.make_block();
 
-        let br_block0_block2;
+        let br_block0_block2_block1;
-        let br_block1_block1;
+        let br_block1_block1_block2;
-        let jmp_block0_block1;
-        let jmp_block1_block2;
 
         {
             let mut cur = FuncCursor::new(&mut func);
 
             cur.insert_block(block0);
-            br_block0_block2 = cur.ins().brnz(cond, block2, &[]);
+            br_block0_block2_block1 = cur.ins().brif(cond, block2, &[], block1, &[]);
-            jmp_block0_block1 = cur.ins().jump(block1, &[]);
 
             cur.insert_block(block1);
-            br_block1_block1 = cur.ins().brnz(cond, block1, &[]);
+            br_block1_block1_block2 = cur.ins().brif(cond, block1, &[], block2, &[]);
-            jmp_block1_block2 = cur.ins().jump(block2, &[]);
 
             cur.insert_block(block2);
         }
@@ -288,19 +281,23 @@ mod tests {
             assert_eq!(block2_predecessors.len(), 2);
 
             assert_eq!(
-                block1_predecessors.contains(&BlockPredecessor::new(block0, jmp_block0_block1)),
+                block1_predecessors
+                    .contains(&BlockPredecessor::new(block0, br_block0_block2_block1)),
                 true
             );
             assert_eq!(
-                block1_predecessors.contains(&BlockPredecessor::new(block1, br_block1_block1)),
+                block1_predecessors
+                    .contains(&BlockPredecessor::new(block1, br_block1_block1_block2)),
                 true
             );
             assert_eq!(
-                block2_predecessors.contains(&BlockPredecessor::new(block0, br_block0_block2)),
+                block2_predecessors
+                    .contains(&BlockPredecessor::new(block0, br_block0_block2_block1)),
                 true
             );
             assert_eq!(
-                block2_predecessors.contains(&BlockPredecessor::new(block1, jmp_block1_block2)),
+                block2_predecessors
+                    .contains(&BlockPredecessor::new(block1, br_block1_block1_block2)),
                 true
             );
 
@@ -309,11 +306,22 @@ mod tests {
             assert_eq!(block2_successors, []);
         }
 
-        // Change some instructions and recompute block0
+        // Add a new block to hold a return instruction
-        func.dfg.replace(br_block0_block2).brnz(cond, block1, &[]);
+        let ret_block = func.dfg.make_block();
-        func.dfg.replace(jmp_block0_block1).return_(&[]);
+
+        {
+            let mut cur = FuncCursor::new(&mut func);
+            cur.insert_block(ret_block);
+            cur.ins().return_(&[]);
+        }
+
+        // Change some instructions and recompute block0 and ret_block
+        func.dfg
+            .replace(br_block0_block2_block1)
+            .brif(cond, block1, &[], ret_block, &[]);
         cfg.recompute_block(&mut func, block0);
-        let br_block0_block1 = br_block0_block2;
+        cfg.recompute_block(&mut func, ret_block);
+        let br_block0_block1_ret_block = br_block0_block2_block1;
 
         {
             let block0_predecessors = cfg.pred_iter(block0).collect::<Vec<_>>();
@@ -329,23 +337,27 @@ mod tests {
             assert_eq!(block2_predecessors.len(), 1);
 
             assert_eq!(
-                block1_predecessors.contains(&BlockPredecessor::new(block0, br_block0_block1)),
+                block1_predecessors
+                    .contains(&BlockPredecessor::new(block0, br_block0_block1_ret_block)),
                 true
             );
             assert_eq!(
-                block1_predecessors.contains(&BlockPredecessor::new(block1, br_block1_block1)),
+                block1_predecessors
+                    .contains(&BlockPredecessor::new(block1, br_block1_block1_block2)),
                 true
             );
             assert_eq!(
-                block2_predecessors.contains(&BlockPredecessor::new(block0, br_block0_block2)),
+                block2_predecessors
+                    .contains(&BlockPredecessor::new(block0, br_block0_block1_ret_block)),
                 false
             );
             assert_eq!(
-                block2_predecessors.contains(&BlockPredecessor::new(block1, jmp_block1_block2)),
+                block2_predecessors
+                    .contains(&BlockPredecessor::new(block1, br_block1_block1_block2)),
                 true
             );
 
-            assert_eq!(block0_successors.collect::<Vec<_>>(), [block1]);
+            assert_eq!(block0_successors.collect::<Vec<_>>(), [block1, ret_block]);
             assert_eq!(block1_successors.collect::<Vec<_>>(), [block1, block2]);
             assert_eq!(block2_successors.collect::<Vec<_>>(), []);
         }

cranelift/codegen/src/inst_predicates.rs

@@ -175,7 +175,7 @@ pub(crate) fn visit_block_succs<F: FnMut(Inst, Block, bool)>(
     block: Block,
     mut visit: F,
 ) {
-    for inst in f.layout.block_likely_branches(block) {
+    if let Some(inst) = f.layout.last_inst(block) {
         match f.dfg.insts[inst].analyze_branch() {
             BranchInfo::NotABranch => {}
             BranchInfo::SingleDest(dest) => {

cranelift/codegen/src/ir/instructions.rs

@@ -270,7 +270,6 @@ impl InstructionData {
     pub fn analyze_branch(&self) -> BranchInfo {
         match *self {
             Self::Jump { destination, .. } => BranchInfo::SingleDest(destination),
-            Self::Branch { destination, .. } => BranchInfo::SingleDest(destination),
             Self::Brif {
                 blocks: [block_then, block_else],
                 ..
@@ -292,9 +291,6 @@ impl InstructionData {
         match self {
             Self::Jump {
                 ref destination, ..
-            }
-            | Self::Branch {
-                ref destination, ..
             } => std::slice::from_ref(destination),
             Self::Brif { blocks, .. } => blocks,
             Self::BranchTable { .. } => &[],
@@ -313,10 +309,6 @@ impl InstructionData {
             Self::Jump {
                 ref mut destination,
                 ..
-            }
-            | Self::Branch {
-                ref mut destination,
-                ..
             } => std::slice::from_mut(destination),
             Self::Brif { blocks, .. } => blocks,
             Self::BranchTable { .. } => &mut [],

cranelift/codegen/src/ir/layout.rs

@@ -4,7 +4,6 @@
 //! determined by the `Layout` data structure defined in this module.
 
 use crate::entity::SecondaryMap;
-use crate::ir::dfg::DataFlowGraph;
 use crate::ir::progpoint::{ExpandedProgramPoint, ProgramOrder};
 use crate::ir::{Block, Inst};
 use crate::packed_option::PackedOption;
@@ -594,19 +593,6 @@ impl Layout {
         self.insts[inst].prev.expand()
     }
 
-    /// Fetch the first instruction in a block's terminal branch group.
-    pub fn canonical_branch_inst(&self, dfg: &DataFlowGraph, block: Block) -> Option<Inst> {
-        // Basic blocks permit at most two terminal branch instructions.
-        // If two, the former is conditional and the latter is unconditional.
-        let last = self.last_inst(block)?;
-        if let Some(prev) = self.prev_inst(last) {
-            if dfg.insts[prev].opcode().is_branch() {
-                return Some(prev);
-            }
-        }
-        Some(last)
-    }
-
     /// Insert `inst` before the instruction `before` in the same block.
     pub fn insert_inst(&mut self, inst: Inst, before: Inst) {
         debug_assert_eq!(self.inst_block(inst), None);
@@ -662,24 +648,6 @@ impl Layout {
         }
     }
 
-    /// Iterate over a limited set of instruction which are likely the branches of `block` in layout
-    /// order. Any instruction not visited by this iterator is not a branch, but an instruction visited by this may not be a branch.
-    pub fn block_likely_branches(&self, block: Block) -> Insts {
-        // Note: Checking whether an instruction is a branch or not while walking backward might add
-        // extra overhead. However, we know that the number of branches is limited to 2 at the end of
-        // each block, and therefore we can just iterate over the last 2 instructions.
-        let mut iter = self.block_insts(block);
-        let head = iter.head;
-        let tail = iter.tail;
-        iter.next_back();
-        let head = iter.next_back().or(head);
-        Insts {
-            layout: self,
-            head,
-            tail,
-        }
-    }
-
     /// Split the block containing `before` in two.
     ///
     /// Insert `new_block` after the old block and move `before` and the following instructions to

cranelift/codegen/src/isa/aarch64/inst/unwind/systemv.rs

@@ -160,8 +160,7 @@ mod tests {
 
         let mut pos = FuncCursor::new(&mut func);
         pos.insert_block(block0);
-        pos.ins().brnz(v0, block2, &[]);
+        pos.ins().brif(v0, block2, &[], block1, &[]);
-        pos.ins().jump(block1, &[]);
 
         pos.insert_block(block1);
         pos.ins().return_(&[]);

cranelift/codegen/src/isa/aarch64/lower.isle

@@ -2507,93 +2507,6 @@
         (with_flags_side_effect flags
          (cond_br taken not_taken (cond_br_not_zero rt))))))
 
-;;; Rules for `brz`/`brnz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; `brz` following `icmp`
-(rule (lower_branch (brz (maybe_uextend (icmp cc x @ (value_type ty) y)) _) targets)
-      (let ((comparison FlagsAndCC (lower_icmp_into_flags cc x y ty))
-            ;; Negate the condition for `brz`.
-            (cond Cond (invert_cond (cond_code (flags_and_cc_cc comparison))))
-            (taken BranchTarget (branch_target targets 0))
-            (not_taken BranchTarget (branch_target targets 1)))
-        (emit_side_effect
-         (with_flags_side_effect (flags_and_cc_flags comparison)
-                                 (cond_br taken
-                                          not_taken
-                                          (cond_br_cond cond))))))
-;; `brnz` following `icmp`
-(rule (lower_branch (brnz (maybe_uextend (icmp cc x @ (value_type ty) y)) _) targets)
-      (let ((comparison FlagsAndCC (lower_icmp_into_flags cc x y ty))
-            (cond Cond (cond_code (flags_and_cc_cc comparison)))
-            (taken BranchTarget (branch_target targets 0))
-            (not_taken BranchTarget (branch_target targets 1)))
-        (emit_side_effect
-         (with_flags_side_effect (flags_and_cc_flags comparison)
-                                 (cond_br taken
-                                          not_taken
-                                          (cond_br_cond cond))))))
-;; `brz` following `fcmp`
-(rule (lower_branch (brz (maybe_uextend (fcmp cc x @ (value_type (ty_scalar_float ty)) y)) _) targets)
-      (let ((cond Cond (fp_cond_code cc))
-            (cond Cond (invert_cond cond)) ;; negate for `brz`
-            (taken BranchTarget (branch_target targets 0))
-            (not_taken BranchTarget (branch_target targets 1)))
-       (emit_side_effect
-        (with_flags_side_effect (fpu_cmp (scalar_size ty) x y)
-                                (cond_br taken not_taken
-                                 (cond_br_cond cond))))))
-;; `brnz` following `fcmp`
-(rule (lower_branch (brnz (maybe_uextend (fcmp cc x @ (value_type (ty_scalar_float ty)) y)) _) targets)
-      (let ((cond Cond (fp_cond_code cc))
-            (taken BranchTarget (branch_target targets 0))
-            (not_taken BranchTarget (branch_target targets 1)))
-       (emit_side_effect
-        (with_flags_side_effect (fpu_cmp (scalar_size ty) x y)
-                                (cond_br taken not_taken
-                                 (cond_br_cond cond))))))
-;; standard `brz`
-(rule -1 (lower_branch (brz c @ (value_type $I128) _) targets)
-      (let ((flags ProducesFlags (flags_to_producesflags c))
-            (c ValueRegs (put_in_regs c))
-            (c_lo Reg (value_regs_get c 0))
-            (c_hi Reg (value_regs_get c 1))
-            (rt Reg (orr $I64 c_lo c_hi))
-            (taken BranchTarget (branch_target targets 0))
-            (not_taken BranchTarget (branch_target targets 1)))
-       (emit_side_effect
-        (with_flags_side_effect flags
-         (cond_br taken not_taken (cond_br_zero rt))))))
-(rule -2 (lower_branch (brz c @ (value_type ty) _) targets)
-      (if (ty_int_ref_scalar_64 ty))
-      (let ((flags ProducesFlags (flags_to_producesflags c))
-            (rt Reg (put_in_reg_zext64 c))
-            (taken BranchTarget (branch_target targets 0))
-            (not_taken BranchTarget (branch_target targets 1)))
-       (emit_side_effect
-        (with_flags_side_effect flags
-         (cond_br taken not_taken (cond_br_zero rt))))))
-;; standard `brnz`
-(rule -1 (lower_branch (brnz c @ (value_type $I128) _) targets)
-      (let ((flags ProducesFlags (flags_to_producesflags c))
-            (c ValueRegs (put_in_regs c))
-            (c_lo Reg (value_regs_get c 0))
-            (c_hi Reg (value_regs_get c 1))
-            (rt Reg (orr $I64 c_lo c_hi))
-            (taken BranchTarget (branch_target targets 0))
-            (not_taken BranchTarget (branch_target targets 1)))
-       (emit_side_effect
-        (with_flags_side_effect flags
-         (cond_br taken not_taken (cond_br_not_zero rt))))))
-(rule -2 (lower_branch (brnz c @ (value_type ty) _) targets)
-      (if (ty_int_ref_scalar_64 ty))
-      (let ((flags ProducesFlags (flags_to_producesflags c))
-            (rt Reg (put_in_reg_zext64 c))
-            (taken BranchTarget (branch_target targets 0))
-            (not_taken BranchTarget (branch_target targets 1)))
-       (emit_side_effect
-        (with_flags_side_effect flags
-         (cond_br taken not_taken (cond_br_not_zero rt))))))
-
 ;;; Rules for `jump` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower_branch (jump _) targets)

cranelift/codegen/src/isa/aarch64/mod.rs

@@ -293,15 +293,12 @@ mod test {
         pos.insert_block(bb0);
         let v0 = pos.ins().iconst(I32, 0x1234);
         let v1 = pos.ins().iadd(arg0, v0);
-        pos.ins().brnz(v1, bb1, &[]);
+        pos.ins().brif(v1, bb1, &[], bb2, &[]);
-        pos.ins().jump(bb2, &[]);
         pos.insert_block(bb1);
-        pos.ins().brnz(v1, bb2, &[]);
+        pos.ins().brif(v1, bb2, &[], bb3, &[]);
-        pos.ins().jump(bb3, &[]);
         pos.insert_block(bb2);
         let v2 = pos.ins().iadd(v1, v0);
-        pos.ins().brnz(v2, bb2, &[]);
+        pos.ins().brif(v2, bb2, &[], bb1, &[]);
-        pos.ins().jump(bb1, &[]);
         pos.insert_block(bb3);
         let v3 = pos.ins().isub(v1, v0);
         pos.ins().return_(&[v3]);

cranelift/codegen/src/isa/riscv64/inst.isle

@@ -1868,8 +1868,8 @@
 (decl int_zero_reg (Type) ValueRegs)
 (extern constructor int_zero_reg int_zero_reg)
 
-(decl lower_brz_or_nz (IntCC ValueRegs VecMachLabel Type) Unit)
+(decl lower_cond_br (IntCC ValueRegs VecMachLabel Type) Unit)
-(extern constructor lower_brz_or_nz lower_brz_or_nz)
+(extern constructor lower_cond_br lower_cond_br)
 
 ;; Normalize a value for comparision.
 ;;
@@ -1901,14 +1901,14 @@
 ;; Default behavior for branching based on an input value.
 (rule
   (lower_branch (brif v @ (value_type ty) _ _) targets)
-  (lower_brz_or_nz (IntCC.NotEqual) (normalize_cmp_value ty v) targets ty))
+  (lower_cond_br (IntCC.NotEqual) (normalize_cmp_value ty v) targets ty))
 
 ;; Special case for SI128 to reify the comparison value and branch on it.
 (rule 2
   (lower_branch (brif v @ (value_type $I128) _ _) targets)
   (let ((zero ValueRegs (value_regs (zero_reg) (zero_reg)))
         (cmp Reg (gen_icmp (IntCC.NotEqual) v zero $I128)))
-    (lower_brz_or_nz (IntCC.NotEqual) cmp targets $I64)))
+    (lower_cond_br (IntCC.NotEqual) cmp targets $I64)))
 
 ;; Branching on the result of an icmp
 (rule 1
@@ -1930,66 +1930,6 @@
         (else BranchTarget (label_to_br_target (vec_label_get targets 1))))
     (emit_side_effect (cond_br (emit_fcmp cc ty a b) then else))))
 
-;;;;;
-(rule
-  (lower_branch (brz v @ (value_type ty) _) targets)
-  (lower_brz_or_nz (IntCC.Equal) (normalize_cmp_value ty v) targets ty))
-
-;; Special case for SI128 to reify the comparison value and branch on it.
-(rule 2
-  (lower_branch (brz v @ (value_type $I128) _) targets)
-  (let ((zero ValueRegs (value_regs (zero_reg) (zero_reg)))
-        (cmp Reg (gen_icmp (IntCC.Equal) v zero $I128)))
-    (lower_brz_or_nz (IntCC.NotEqual) cmp targets $I64)))
-
-(rule 1
-  (lower_branch (brz (maybe_uextend (icmp cc a @ (value_type ty) b)) _) targets)
-  (lower_br_icmp (intcc_inverse cc) a b targets ty))
-
-(rule 1
-  (lower_branch (brz (maybe_uextend (fcmp cc a @ (value_type ty) b)) _) targets)
-  (if-let $true (floatcc_unordered cc))
-  (let ((then BranchTarget (label_to_br_target (vec_label_get targets 0)))
-        (else BranchTarget (label_to_br_target (vec_label_get targets 1))))
-    (emit_side_effect (cond_br (emit_fcmp (floatcc_inverse cc) ty a b) then else))))
-
-(rule 1
-  (lower_branch (brz (maybe_uextend (fcmp cc a @ (value_type ty) b)) _) targets)
-  (if-let $false (floatcc_unordered cc))
-  (let ((then BranchTarget (label_to_br_target (vec_label_get targets 0)))
-        (else BranchTarget (label_to_br_target (vec_label_get targets 1))))
-    (emit_side_effect (cond_br (emit_fcmp cc ty a b) else then))))
-
-;;;;
-(rule
-  (lower_branch (brnz v @ (value_type ty) _) targets)
-  (lower_brz_or_nz (IntCC.NotEqual) (normalize_cmp_value ty v) targets ty))
-
-;; Special case for SI128 to reify the comparison value and branch on it.
-(rule 2
-  (lower_branch (brnz v @ (value_type $I128) _) targets)
-  (let ((zero ValueRegs (value_regs (zero_reg) (zero_reg)))
-        (cmp Reg (gen_icmp (IntCC.NotEqual) v zero $I128)))
-    (lower_brz_or_nz (IntCC.NotEqual) cmp targets $I64)))
-
-(rule 1
-  (lower_branch (brnz (maybe_uextend (icmp cc a @ (value_type ty) b)) _) targets)
-  (lower_br_icmp cc a b targets ty))
-
-(rule 1
-  (lower_branch (brnz (maybe_uextend (fcmp cc a @ (value_type ty) b)) _) targets)
-  (if-let $true (floatcc_unordered cc))
-  (let ((then BranchTarget (label_to_br_target (vec_label_get targets 0)))
-        (else BranchTarget (label_to_br_target (vec_label_get targets 1))))
-    (emit_side_effect (cond_br (emit_fcmp (floatcc_inverse cc) ty a b) else then))))
-
-(rule 1
-  (lower_branch (brnz (maybe_uextend (fcmp cc a @ (value_type ty) b)) _) targets)
-  (if-let $false (floatcc_unordered cc))
-  (let ((then BranchTarget (label_to_br_target (vec_label_get targets 0)))
-        (else BranchTarget (label_to_br_target (vec_label_get targets 1))))
-    (emit_side_effect (cond_br (emit_fcmp cc ty a b) then else))))
-
 ;;;
 (decl lower_br_table (Reg VecMachLabel) Unit)
 (extern constructor lower_br_table lower_br_table)

cranelift/codegen/src/isa/riscv64/inst/args.rs

@@ -118,7 +118,6 @@ impl Into<AMode> for StackAMode {
 }
 
 /// risc-v always take two register to compare
-/// brz can be compare with zero register which has the value 0
 #[derive(Clone, Copy, Debug)]
 pub struct IntegerCompare {
     pub(crate) kind: IntCC,

cranelift/codegen/src/isa/riscv64/inst/unwind/systemv.rs

@@ -159,8 +159,7 @@ mod tests {
 
         let mut pos = FuncCursor::new(&mut func);
         pos.insert_block(block0);
-        pos.ins().brnz(v0, block2, &[]);
+        pos.ins().brif(v0, block2, &[], block1, &[]);
-        pos.ins().jump(block1, &[]);
 
         pos.insert_block(block1);
         pos.ins().return_(&[]);

cranelift/codegen/src/isa/riscv64/lower/isle.rs

@@ -61,7 +61,7 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, Riscv64Backend> {
         }
     }
 
-    fn lower_brz_or_nz(
+    fn lower_cond_br(
         &mut self,
         cc: &IntCC,
         a: ValueRegs,

cranelift/codegen/src/isa/s390x/inst/unwind/systemv.rs

@@ -194,8 +194,7 @@ mod tests {
 
         let mut pos = FuncCursor::new(&mut func);
         pos.insert_block(block0);
-        pos.ins().brnz(v0, block2, &[]);
+        pos.ins().brif(v0, block2, &[], block1, &[]);
-        pos.ins().jump(block1, &[]);
 
         pos.insert_block(block1);
         pos.ins().return_(&[]);

cranelift/codegen/src/isa/s390x/lower.isle

@@ -3761,28 +3761,6 @@
                                       (vec_element targets 1))))
 
 
-;;;; Rules for `brz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Two-way conditional branch on zero.  `targets` contains:
-;; - element 0: target if the condition is true (i.e. value is zero)
-;; - element 1: target if the condition is false (i.e. value is nonzero)
-(rule (lower_branch (brz val_cond _) targets)
-      (emit_side_effect (cond_br_bool (invert_bool (value_nonzero val_cond))
-                                      (vec_element targets 0)
-                                      (vec_element targets 1))))
-
-
-;;;; Rules for `brnz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Two-way conditional branch on nonzero.  `targets` contains:
-;; - element 0: target if the condition is true (i.e. value is nonzero)
-;; - element 1: target if the condition is false (i.e. value is zero)
-(rule (lower_branch (brnz val_cond _) targets)
-      (emit_side_effect (cond_br_bool (value_nonzero val_cond)
-                                     (vec_element targets 0)
-                                     (vec_element targets 1))))
-
-
 ;;;; Rules for `trap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (trap trap_code))

cranelift/codegen/src/isa/s390x/mod.rs

@@ -265,15 +265,12 @@ mod test {
         pos.insert_block(bb0);
         let v0 = pos.ins().iconst(I32, 0x1234);
         let v1 = pos.ins().iadd(arg0, v0);
-        pos.ins().brnz(v1, bb1, &[]);
+        pos.ins().brif(v1, bb1, &[], bb2, &[]);
-        pos.ins().jump(bb2, &[]);
         pos.insert_block(bb1);
-        pos.ins().brnz(v1, bb2, &[]);
+        pos.ins().brif(v1, bb2, &[], bb3, &[]);
-        pos.ins().jump(bb3, &[]);
         pos.insert_block(bb2);
         let v2 = pos.ins().iadd(v1, v0);
-        pos.ins().brnz(v2, bb2, &[]);
+        pos.ins().brif(v2, bb2, &[], bb1, &[]);
-        pos.ins().jump(bb1, &[]);
         pos.insert_block(bb3);
         let v3 = pos.ins().isub(v1, v0);
         pos.ins().return_(&[v3]);

cranelift/codegen/src/isa/x64/inst.isle

@@ -362,7 +362,7 @@
        ;; One-way conditional branch: jcond cond target.
        ;;
        ;; This instruction is useful when we have conditional jumps depending on
-       ;; more than two conditions, see for instance the lowering of Brz/brnz
+       ;; more than two conditions, see for instance the lowering of Brif
        ;; with Fcmp inputs.
        ;;
        ;; A note of caution: in contexts where the branch target is another

cranelift/codegen/src/isa/x64/inst/unwind/systemv.rs

@@ -184,8 +184,7 @@ mod tests {
 
         let mut pos = FuncCursor::new(&mut func);
         pos.insert_block(block0);
-        pos.ins().brnz(v0, block2, &[]);
+        pos.ins().brif(v0, block2, &[], block1, &[]);
-        pos.ins().jump(block1, &[]);
 
         pos.insert_block(block1);
         pos.ins().return_(&[]);

cranelift/codegen/src/isa/x64/lower.isle

@@ -2904,41 +2904,6 @@
                           (jmp_cond (CC.NZ) then else))))
 
 
-;; Rules for `brz` and `brnz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule 2 (lower_branch (brz (maybe_uextend (icmp cc a b)) _) (two_targets taken not_taken))
-      (let ((cmp IcmpCondResult (invert_icmp_cond_result (emit_cmp cc a b))))
-        (emit_side_effect (jmp_cond_icmp cmp taken not_taken))))
-
-(rule 2 (lower_branch (brz (maybe_uextend (fcmp cc a b)) _) (two_targets taken not_taken))
-      (let ((cmp FcmpCondResult (emit_fcmp (floatcc_inverse cc) a b)))
-        (emit_side_effect (jmp_cond_fcmp cmp taken not_taken))))
-
-(rule 1 (lower_branch (brz val @ (value_type $I128) _) (two_targets taken not_taken))
-      (emit_side_effect (jmp_cond_icmp (cmp_zero_i128 (CC.NZ) val) taken not_taken)))
-
-(rule 0 (lower_branch (brz val @ (value_type (ty_int_bool_or_ref)) _) (two_targets taken not_taken))
-      (emit_side_effect
-        (with_flags_side_effect (cmp_zero_int_bool_ref val)
-                                (jmp_cond (CC.Z) taken not_taken))))
-
-
-(rule 2 (lower_branch (brnz (maybe_uextend (icmp cc a b)) _) (two_targets taken not_taken))
-      (emit_side_effect (jmp_cond_icmp (emit_cmp cc a b) taken not_taken)))
-
-(rule 2 (lower_branch (brnz (maybe_uextend (fcmp cc a b)) _) (two_targets taken not_taken))
-      (let ((cmp FcmpCondResult (emit_fcmp cc a b)))
-        (emit_side_effect (jmp_cond_fcmp cmp taken not_taken))))
-
-(rule 1 (lower_branch (brnz val @ (value_type $I128) _) (two_targets taken not_taken))
-      (emit_side_effect (jmp_cond_icmp (cmp_zero_i128 (CC.Z) val) taken not_taken)))
-
-(rule 0 (lower_branch (brnz val @ (value_type (ty_int_bool_or_ref)) _) (two_targets taken not_taken))
-      (emit_side_effect
-        (with_flags_side_effect (cmp_zero_int_bool_ref val)
-                                (jmp_cond (CC.NZ) taken not_taken))))
-
-
 ;; Compare an I128 value to zero, returning a flags result suitable for making a
 ;; jump decision. The comparison is implemented as `(hi == 0) && (low == 0)`,
 ;; and the result can be interpreted as follows

cranelift/codegen/src/isa/x64/mod.rs

@@ -261,23 +261,20 @@ mod test {
         let v0 = pos.ins().iconst(I32, 0x1234);
         pos.set_srcloc(SourceLoc::new(2));
         let v1 = pos.ins().iadd(arg0, v0);
-        pos.ins().brnz(v1, bb1, &[v1]);
+        pos.ins().brif(v1, bb1, &[v1], bb2, &[]);
-        pos.ins().jump(bb2, &[]);
 
         pos.insert_block(bb1);
         pos.set_srcloc(SourceLoc::new(3));
         let v2 = pos.ins().isub(v1, v0);
         pos.set_srcloc(SourceLoc::new(4));
         let v3 = pos.ins().iadd(v2, bb1_param);
-        pos.ins().brnz(v1, bb2, &[]);
+        pos.ins().brif(v1, bb2, &[], bb3, &[v3]);
-        pos.ins().jump(bb3, &[v3]);
 
         pos.func.layout.set_cold(bb2);
         pos.insert_block(bb2);
         pos.set_srcloc(SourceLoc::new(5));
         let v4 = pos.ins().iadd(v1, v0);
-        pos.ins().brnz(v4, bb2, &[]);
+        pos.ins().brif(v4, bb2, &[], bb1, &[v4]);
-        pos.ins().jump(bb1, &[v4]);
 
         pos.insert_block(bb3);
         pos.set_srcloc(SourceLoc::new(6));

cranelift/codegen/src/legalizer/mod.rs

@@ -268,8 +268,7 @@ fn expand_cond_trap(
     //
     // Becomes:
     //
-    //     brz arg, new_block_resume
+    //     brif arg, new_block_trap, new_block_resume
-    //     jump new_block_trap
     //
     //   new_block_trap:
     //     trap
@@ -285,17 +284,18 @@ fn expand_cond_trap(
 
     // Replace trap instruction by the inverted condition.
     if trapz {
-        func.dfg.replace(inst).brnz(arg, new_block_resume, &[]);
+        func.dfg
+            .replace(inst)
+            .brif(arg, new_block_resume, &[], new_block_trap, &[]);
     } else {
-        func.dfg.replace(inst).brz(arg, new_block_resume, &[]);
+        func.dfg
+            .replace(inst)
+            .brif(arg, new_block_trap, &[], new_block_resume, &[]);
     }
 
-    // Add jump instruction after the inverted branch.
+    // Insert the new label and the unconditional trap terminator.
     let mut pos = FuncCursor::new(func).after_inst(inst);
     pos.use_srcloc(inst);
-    pos.ins().jump(new_block_trap, &[]);
-
-    // Insert the new label and the unconditional trap terminator.
     pos.insert_block(new_block_trap);
 
     match opcode {

cranelift/codegen/src/loop_analysis.rs

@@ -330,6 +330,7 @@ mod tests {
         let block1 = func.dfg.make_block();
         let block2 = func.dfg.make_block();
         let block3 = func.dfg.make_block();
+        let block4 = func.dfg.make_block();
         let cond = func.dfg.append_block_param(block0, types::I32);
 
         {
@@ -342,11 +343,13 @@ mod tests {
             cur.ins().jump(block2, &[]);
 
             cur.insert_block(block2);
-            cur.ins().brnz(cond, block1, &[]);
+            cur.ins().brif(cond, block1, &[], block3, &[]);
-            cur.ins().jump(block3, &[]);
 
             cur.insert_block(block3);
-            cur.ins().brnz(cond, block0, &[]);
+            cur.ins().brif(cond, block0, &[], block4, &[]);
+
+            cur.insert_block(block4);
+            cur.ins().return_(&[]);
         }
 
         let mut loop_analysis = LoopAnalysis::new();
@@ -385,31 +388,32 @@ mod tests {
         let block3 = func.dfg.make_block();
         let block4 = func.dfg.make_block();
         let block5 = func.dfg.make_block();
+        let block6 = func.dfg.make_block();
         let cond = func.dfg.append_block_param(block0, types::I32);
 
         {
             let mut cur = FuncCursor::new(&mut func);
 
             cur.insert_block(block0);
-            cur.ins().brnz(cond, block1, &[]);
+            cur.ins().brif(cond, block1, &[], block3, &[]);
-            cur.ins().jump(block3, &[]);
 
             cur.insert_block(block1);
             cur.ins().jump(block2, &[]);
 
             cur.insert_block(block2);
-            cur.ins().brnz(cond, block1, &[]);
+            cur.ins().brif(cond, block1, &[], block5, &[]);
-            cur.ins().jump(block5, &[]);
 
             cur.insert_block(block3);
             cur.ins().jump(block4, &[]);
 
             cur.insert_block(block4);
-            cur.ins().brnz(cond, block3, &[]);
+            cur.ins().brif(cond, block3, &[], block5, &[]);
-            cur.ins().jump(block5, &[]);
 
             cur.insert_block(block5);
-            cur.ins().brnz(cond, block0, &[]);
+            cur.ins().brif(cond, block0, &[], block6, &[]);
+
+            cur.insert_block(block6);
+            cur.ins().return_(&[]);
         }
 
         let mut loop_analysis = LoopAnalysis::new();

cranelift/codegen/src/machinst/blockorder.rs

@@ -250,7 +250,7 @@ impl BlockLoweringOrder {
             let block_succ_end = block_succs.len();
             block_succ_range[block] = (block_succ_start, block_succ_end);
 
-            for inst in f.layout.block_likely_branches(block) {
+            if let Some(inst) = f.layout.last_inst(block) {
                 if f.dfg.insts[inst].opcode() == Opcode::Return {
                     // Implicit output edge for any return.
                     block_out_count[block] += 1;
@@ -276,7 +276,7 @@ impl BlockLoweringOrder {
         // could not be, in cases of br_table with no table and just a
         // default label, for example.)
         for block in f.layout.blocks() {
-            for inst in f.layout.block_likely_branches(block) {
+            if let Some(inst) = f.layout.last_inst(block) {
                 // If the block has a branch with any "fixed args"
                 // (not blockparam args) ...
                 if f.dfg.insts[inst].opcode().is_branch() && f.dfg.inst_fixed_args(inst).len() > 0 {
@@ -561,8 +561,8 @@ mod test {
             } else if succs.len() == 1 {
                 pos.ins().jump(blocks[succs[0]], &[]);
             } else if succs.len() == 2 {
-                pos.ins().brnz(arg0, blocks[succs[0]], &[]);
+                pos.ins()
-                pos.ins().jump(blocks[succs[1]], &[]);
+                    .brif(arg0, blocks[succs[0]], &[], blocks[succs[1]], &[]);
             } else {
                 panic!("Too many successors");
             }

cranelift/codegen/src/remove_constant_phis.rs

@@ -16,10 +16,9 @@ use smallvec::SmallVec;
 // "formal parameters" to mean the `Value`s listed in the block head, and
 // "actual parameters" to mean the `Value`s passed in a branch or a jump:
 //
-// block4(v16: i32, v18: i32):    <-- formal parameters
+// block4(v16: i32, v18: i32):            <-- formal parameters
 //   ...
-//   brnz v27, block7(v22, v24)   <-- actual parameters
+//   brif v27, block7(v22, v24), block6   <-- actual parameters
-//   jump block6
 
 // This transformation pass (conceptually) partitions all values in the
 // function into two groups:

cranelift/codegen/src/simple_preopt.rs

@@ -6,12 +6,11 @@
 use crate::cursor::{Cursor, FuncCursor};
 use crate::divconst_magic_numbers::{magic_s32, magic_s64, magic_u32, magic_u64};
 use crate::divconst_magic_numbers::{MS32, MS64, MU32, MU64};
-use crate::flowgraph::ControlFlowGraph;
 use crate::ir::{
-    condcodes::{CondCode, IntCC},
+    condcodes::IntCC,
     instructions::Opcode,
-    types::{I128, I32, I64, INVALID},
+    types::{I128, I32, I64},
-    Block, DataFlowGraph, Function, Inst, InstBuilder, InstructionData, Type, Value,
+    DataFlowGraph, Function, Inst, InstBuilder, InstructionData, Type, Value,
 };
 use crate::isa::TargetIsa;
 use crate::timing;
@@ -465,71 +464,6 @@ fn do_divrem_transformation(divrem_info: &DivRemByConstInfo, pos: &mut FuncCurso
     }
 }
 
-/// Reorder branches to encourage fallthroughs.
-///
-/// When a block ends with a conditional branch followed by an unconditional
-/// branch, this will reorder them if one of them is branching to the next Block
-/// layout-wise. The unconditional jump can then become a fallthrough.
-fn branch_order(pos: &mut FuncCursor, cfg: &mut ControlFlowGraph, block: Block, inst: Inst) {
-    let (term_inst, term_dest, cond_inst, cond_dest, kind, cond_arg) =
-        match pos.func.dfg.insts[inst] {
-            InstructionData::Jump {
-                opcode: Opcode::Jump,
-                destination,
-            } => {
-                let next_block = if let Some(next_block) = pos.func.layout.next_block(block) {
-                    next_block
-                } else {
-                    return;
-                };
-
-                if destination.block(&pos.func.dfg.value_lists) == next_block {
-                    return;
-                }
-
-                let prev_inst = if let Some(prev_inst) = pos.func.layout.prev_inst(inst) {
-                    prev_inst
-                } else {
-                    return;
-                };
-
-                match &pos.func.dfg.insts[prev_inst] {
-                    &InstructionData::Branch {
-                        opcode,
-                        arg,
-                        destination: cond_dest,
-                    } => {
-                        if cond_dest.block(&pos.func.dfg.value_lists) != next_block {
-                            return;
-                        }
-
-                        let kind = match opcode {
-                            Opcode::Brz => Opcode::Brnz,
-                            Opcode::Brnz => Opcode::Brz,
-                            _ => panic!("unexpected opcode"),
-                        };
-
-                        (inst, destination, prev_inst, cond_dest, kind, arg)
-                    }
-                    _ => return,
-                }
-            }
-
-            _ => return,
-        };
-
-    pos.func
-        .dfg
-        .replace(term_inst)
-        .Jump(Opcode::Jump, INVALID, cond_dest);
-    pos.func
-        .dfg
-        .replace(cond_inst)
-        .Branch(kind, INVALID, term_dest, cond_arg);
-
-    cfg.recompute_block(pos.func, block);
-}
-
 mod simplify {
     use super::*;
     use crate::ir::{
@@ -789,12 +723,11 @@ mod simplify {
     /// Fold comparisons into branch operations when possible.
     ///
     /// This matches against operations which compare against zero, then use the
-    /// result in a `brz` or `brnz` branch. It folds those two operations into a
+    /// result in a conditional branch.
-    /// single `brz` or `brnz`.
     fn branch_opt(pos: &mut FuncCursor, inst: Inst) {
-        let (cmp_arg, new_opcode) = if let InstructionData::Branch {
+        let (cmp_arg, new_then, new_else) = if let InstructionData::Brif {
-            opcode: br_opcode,
             arg: first_arg,
+            blocks: [block_then, block_else],
             ..
         } = pos.func.dfg.insts[inst]
         {
@@ -817,21 +750,13 @@ mod simplify {
                     return;
                 }
 
-                // icmp_imm returns non-zero when the comparison is true. So, if
+                let (new_then, new_else) = match cmp_cond {
-                // we're branching on zero, we need to invert the condition.
+                    IntCC::Equal => (block_else, block_then),
-                let cond = match br_opcode {
+                    IntCC::NotEqual => (block_then, block_else),
-                    Opcode::Brz => cmp_cond.inverse(),
-                    Opcode::Brnz => cmp_cond,
                     _ => return,
                 };
 
-                let new_opcode = match cond {
+                (cmp_arg, new_then, new_else)
-                    IntCC::Equal => Opcode::Brz,
-                    IntCC::NotEqual => Opcode::Brnz,
-                    _ => return,
-                };
-
-                (cmp_arg, new_opcode)
             } else {
                 return;
             }
@@ -839,9 +764,10 @@ mod simplify {
             return;
         };
 
-        if let InstructionData::Branch { opcode, arg, .. } = &mut pos.func.dfg.insts[inst] {
+        if let InstructionData::Brif { arg, blocks, .. } = &mut pos.func.dfg.insts[inst] {
-            *opcode = new_opcode;
             *arg = cmp_arg;
+            blocks[0] = new_then;
+            blocks[1] = new_else;
         } else {
             unreachable!();
         }
@@ -849,14 +775,14 @@ mod simplify {
 }
 
 /// The main pre-opt pass.
-pub fn do_preopt(func: &mut Function, cfg: &mut ControlFlowGraph, isa: &dyn TargetIsa) {
+pub fn do_preopt(func: &mut Function, isa: &dyn TargetIsa) {
     let _tt = timing::preopt();
 
     let mut pos = FuncCursor::new(func);
     let native_word_width = isa.pointer_bytes() as u32;
     let mut optimizer = simplify::peephole_optimizer(isa);
 
-    while let Some(block) = pos.next_block() {
+    while let Some(_) = pos.next_block() {
         while let Some(inst) = pos.next_inst() {
             simplify::apply_all(&mut optimizer, &mut pos, inst, native_word_width);
 
@@ -865,8 +791,6 @@ pub fn do_preopt(func: &mut Function, cfg: &mut ControlFlowGraph, isa: &dyn Targ
                 do_divrem_transformation(&divrem_info, &mut pos, inst);
                 continue;
             }
-
-            branch_order(&mut pos, cfg, block, inst);
         }
     }
 }

cranelift/codegen/src/verifier/mod.rs

@@ -584,7 +584,7 @@ impl<'a> Verifier<'a> {
             MultiAry { ref args, .. } => {
                 self.verify_value_list(inst, args, errors)?;
             }
-            Jump { destination, .. } | Branch { destination, .. } => {
+            Jump { destination, .. } => {
                 self.verify_block(inst, destination.block(&self.func.dfg.value_lists), errors)?;
             }
             Brif {

cranelift/codegen/src/write.rs

@@ -428,12 +428,6 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt
             write!(w, ", {}", block_else.block(pool))?;
             write_block_args(w, block_else.args_slice(pool))
         }
-        Branch {
-            arg, destination, ..
-        } => {
-            write!(w, " {}, {}", arg, destination.block(pool))?;
-            write_block_args(w, destination.args_slice(pool))
-        }
         BranchTable {
             arg,
             destination,

cranelift/docs/ir.md

@@ -49,8 +49,7 @@ function %average(i32, i32) -> f32 system_v {
 block1(v0: i32, v1: i32):
     v2 = f64const 0x0.0
     stack_store v2, ss0
-    brz v1, block5                  ; Handle count == 0.
+    brif v1, block2, block5                  ; Handle count == 0.
-    jump block2
 
 block2:
     v3 = iconst.i32 0
@@ -66,8 +65,7 @@ block3(v4: i32):
     stack_store v10, ss0
     v11 = iadd_imm v4, 1
     v12 = icmp ult v11, v1
-    brnz v12, block3(v11)           ; Loop backedge.
+    brif v12, block3(v11), block4 ; Loop backedge.
-    jump block4
 
 block4:
     v13 = stack_load.f64 ss0
@@ -414,8 +412,7 @@ function %gcd(i32 uext, i32 uext) -> i32 uext system_v {
     fn0 = %divmod(i32 uext, i32 uext) -> i32 uext, i32 uext
 
 block1(v0: i32, v1: i32):
-    brz v1, block3
+    brif v1, block2, block3
-    jump block2
 
 block2:
     v2, v3 = call fn0(v0, v1)

cranelift/docs/testing.md

@@ -169,12 +169,12 @@ command:
     function %nonsense(i32, i32) -> f32 {
     ; check: digraph %nonsense {
     ; regex: I=\binst\d+\b
-    ; check: label="{block0 | <$(BRZ=$I)>brz block2 | <$(JUMP=$I)>jump block1}"]
+    ; check: label="{block0 | <$(BRIF=$I)>brif v1, block1(v2), block2 }"]
 
     block0(v0: i32, v1: i32):
-        brz v1, block2            ; unordered: block0:$BRZ -> block2
         v2 = iconst.i32 0
-        jump block1(v2)           ; unordered: block0:$JUMP -> block1
+        brif v1, block1(v2), block2  ; unordered: block0:$BRIF -> block1
+                                     ; unordered: block0:$BRIF -> block2
 
     block1(v5: i32):
         return v0
@@ -195,10 +195,9 @@ Compute the dominator tree of each function and validate it against the
 
     function %test(i32) {
         block0(v0: i32):
-            jump block1     ; dominates: block1
+            jump block1              ; dominates: block1
         block1:
-            brz v0, block3  ; dominates: block3
+            brif v0, block2, block3  ; dominates: block2, block3
-            jump block2     ; dominates: block2
         block2:
             jump block3
         block3:

cranelift/filetests/filetests/alias/multiple-blocks.clif

@@ -11,8 +11,7 @@ function %f0(i64 vmctx, i32) -> i32 {
 block0(v0: i64, v1: i32):
     v2 = global_value.i64 gv1
     v3 = load.i32 v2+8
-    brz v2, block1
+    brif v2, block2, block1
-    jump block2
 
 block1:
     v4 = load.i32 v2+8

cranelift/filetests/filetests/alias/partial-redundancy.clif

@@ -11,8 +11,7 @@ function %f0(i64 vmctx, i32) -> i32, i32 {
     fn0 = %g(i64 vmctx)
 
 block0(v0: i64, v1: i32):
-    brz v1, block1
+    brif v1, block2, block1
-    jump block2
 
 block1:
     v2 = global_value.i64 gv1

cranelift/filetests/filetests/cfg/loop.clif

@@ -6,15 +6,13 @@ function %nonsense(i32, i32) -> f32 {
 ; regex: I=\binst\d+\b
 ; check: digraph "%nonsense" {
 ; check:     block0 [shape=record, label="{block0(v1: i32, v2: i32):
-; check: | <$(BRZ=$I)>brz v2, block2
+; check: | <$(BRIF=$I)>brif v2, block3, block2
-; nextln: | <$(JUMP0=$I)>jump block3
 ; nextln: }"]
 ; nextln:     block3 [shape=record, label="{block3:
 ; check: | <$(JUMP3=$I)>jump block1(v4)
 ; nextln: }"]
 ; nextln:     block1 [shape=record, label="{block1(v5: i32):
-; check:  | <$(BRNZ1=$I)>brnz v13, block1(v12)
+; check:  | <$(BRIF1=$I)>brif v13, block1(v12), block4
-; nextln: | <$(JUMP1=$I)>jump block4
 ; nextln: }"]
 ; nextln:    block4 [shape=record, label="{block4:
 ; check:  | <$I>return v17
@@ -24,8 +22,8 @@ function %nonsense(i32, i32) -> f32 {
 ; check:}"]
 block0(v1: i32, v2: i32):
     v3 = f64const 0x0.0
-    brz v2, block2            ; unordered: block0:$BRZ -> block2
+    brif v2, block3, block2   ; unordered: block0:$BRIF -> block2
-    jump block3               ; unordered: block0:$JUMP0 -> block3
+                              ; unordered: block0:$BRIF -> block3
 
 block3:
     v4 = iconst.i32 0
@@ -40,8 +38,8 @@ block1(v5: i32):
     v11 = fadd v9, v10
     v12 = iadd_imm v5, 1
     v13 = icmp ult v12, v2
-    brnz v13, block1(v12)     ; unordered: block1:$BRNZ1 -> block1
+    brif v13, block1(v12), block4 ; unordered: block1:$BRIF1 -> block1
-    jump block4               ; unordered: block1:$JUMP1 -> block4
+                                  ; unordered: block1:$BRIF1 -> block4
 
 block4:
     v14 = f64const 0.0

cranelift/filetests/filetests/cfg/traps_early.clif

@@ -8,13 +8,13 @@ function %nonsense(i32) {
 
 block0(v1: i32):
     trap user0      ; error: terminator instruction was encountered before the end
-    brnz v1, block2   ; unordered: block0:inst1 -> block2
+    brif v1, block2, block1   ; unordered: block0:inst1 -> block2
-    jump block1       ; unordered: block0:inst2 -> block1
+                              ; unordered: block0:inst1 -> block1
 
 block1:
     v2 = iconst.i32 0
     v3 = iadd v1, v3
-    jump block0(v3)   ; unordered: block1:inst5 -> block0
+    jump block0(v3)   ; unordered: block1:inst4 -> block0
 
 block2:
     return v1

cranelift/filetests/filetests/cfg/unused_node.clif

@@ -4,24 +4,28 @@ test print-cfg
 function %not_reached(i32) -> i32 {
 ; check: digraph "%not_reached" {
 ; check:     block0 [shape=record, label="{block0(v0: i32):
-; check:  | <inst0>brnz v0, block2
+; check:  | <inst0>brif v0, block2, block3
-; check:  | <inst1>trap user0
 ; check: }"]
 ; check:     block1 [shape=record, label="{block1:
-; check:  | <inst4>jump block0(v2)
+; check:  | <inst3>jump block0(v2)
 ; check: }"]
 ; check:     block2 [shape=record, label="{block2:
-; check:  | <inst5>return v0
+; check:  | <inst4>return v0
+; check: }"]
+; check:     block3 [shape=record, label="{block3:
+; check:  | <inst5>trap user0
 ; check: }"]
 block0(v0: i32):
-    brnz v0, block2       ; unordered: block0:inst0 -> block2
+    brif v0, block2, block3       ; unordered: block0:inst0 -> block2
-    trap user0
 
 block1:
     v1 = iconst.i32 1
     v2 = iadd v0, v1
-    jump block0(v2)       ; unordered: block1:inst4 -> block0
+    jump block0(v2)       ; unordered: block1:inst3 -> block0
 
 block2:
     return v0
+
+block3:
+    trap user0
 }

cranelift/filetests/filetests/dce/basic.clif

@@ -18,8 +18,7 @@ block0(v0: i32, v1: i32):
     v4 = iconst.i32 71
     v5 = iconst.i32 72
     v8 = iconst.i32 73
-    brz v0, block1
+    brif v0, block2(v8), block1
-    jump block2(v8)
 
 block1:
     v2 = iadd v0, v3
@@ -34,8 +33,7 @@ block2(v9: i32):
 ; nextln: block0(v0: i32, v1: i32):
 ; nextln:     v4 = iconst.i32 71
 ; nextln:     v8 = iconst.i32 73
-; nextln:     brz v0, block1
+; nextln:     brif v0, block2(v8), block1
-; nextln:     jump block2(v8)
 ; nextln: 
 ; nextln: block1:
 ; nextln:     return v0

cranelift/filetests/filetests/domtree/basic.clif

@@ -2,24 +2,23 @@ test domtree
 
 function %test(i32) {
     block0(v0: i32):
-        jump block1     ; dominates: block1
+        jump block1              ; dominates: block1
     block1:
-        brz v0, block3  ; dominates: block3
+        brif v0, block2, block3  ; dominates: block2 block3
-        jump block2     ; dominates: block2
     block2:
         jump block3
     block3:
         return
 }
 ; check: cfg_postorder:
-; sameln: block2
 ; sameln: block3
+; sameln: block2
 ; sameln: block1
 ; sameln: block0
 
 ; check: domtree_preorder {
 ; nextln: block0: block1
-; nextln: block1: block3 block2
+; nextln: block1: block2 block3
-; nextln: block3:
 ; nextln: block2:
+; nextln: block3:
 ; nextln: }

cranelift/filetests/filetests/domtree/loops.clif

@@ -2,33 +2,29 @@ test domtree
 
 function %test(i32) {
     block0(v0: i32):
-        brz v0, block1  ; dominates: block1 block3 block4 block5
+        brif v0, block2, block1  ; dominates: block1 block2 block3 block4 block5
-        jump block2     ; dominates: block2
     block1:
         jump block3
     block2:
-        brz v0, block4
+        brif v0, block5, block4
-        jump block5
     block3:
         jump block4
     block4:
-        brz v0, block3
+        brif v0, block5, block3
-        jump block5
     block5:
-        brz v0, block4
+        brif v0, block6, block4 ; dominates: block6
-        jump block6     ; dominates: block6
     block6:
         return
 }
 ; Fall-through-first, prune-at-source DFT:
 ;
 ; block0 {
-;     block0:brz v0, block1 {
+;     block0:brif v0, block1 {
 ;         block0:jump block2 {
 ;             block2 {
-;                 block2:brz v2, block2 -
+;                 block2:brif v2, block2 -
-;                 block2:brz v3, block1 -
+;                 block2:brif v3, block1 -
-;                 block2:brz v4, block4 {
+;                 block2:brif v4, block4 {
 ;                     block2: jump block5 {
 ;                         block5: jump block6 {
 ;                             block6 {}
@@ -49,42 +45,37 @@ function %test(i32) {
 ; check: cfg_postorder:
 ; sameln: block6
 ; sameln: block5
-; sameln: block3
 ; sameln: block4
-; sameln: block2
+; sameln: block3
 ; sameln: block1
+; sameln: block2
 ; sameln: block0
 
 ; check: domtree_preorder {
-; nextln: block0: block1 block2 block4 block3 block5
+; nextln: block0: block2 block1 block3 block4 block5
-; nextln: block1:
 ; nextln: block2:
-; nextln: block4:
+; nextln: block1:
 ; nextln: block3:
+; nextln: block4:
 ; nextln: block5: block6
 ; nextln: block6:
 ; nextln: }
 
 function %loop2(i32) system_v {
     block0(v0: i32):
-        brz v0, block1    ; dominates: block1 block3 block4 block5
+        brif v0, block2, block1    ; dominates: block2 block1 block3 block4 block5
-        jump block2       ; dominates: block2
     block1:
         jump block3
     block2:
-        brz v0, block4
+        brif v0, block5, block4
-        jump block5
     block3:
         jump block4
     block4:
-        brz v0, block3
+        brif v0, block8, block3 ; dominates: block8
-        jump block8       ; dominates: block8
     block8:
-        brnz v0, block5
+        brif v0, block5, block6 ; dominates: block6
-        jump block6       ; dominates: block6
     block5:
-        brz v0, block4
+        brif v0, block9, block4 ; dominates: block9
-        jump block9       ; dominates: block9
     block9:
         trap user0
     block6:
@@ -93,26 +84,26 @@ function %loop2(i32) system_v {
         return
 }
 ; check: cfg_postorder:
-; sameln: block9
-; sameln: block5
 ; sameln: block7
 ; sameln: block6
+; sameln: block9
+; sameln: block5
 ; sameln: block8
-; sameln: block3
 ; sameln: block4
-; sameln: block2
+; sameln: block3
 ; sameln: block1
+; sameln: block2
 ; sameln: block0
 
 ; check: domtree_preorder {
-; nextln: block0: block1 block2 block4 block3 block5
+; nextln: block0: block2 block1 block3 block4 block5
-; nextln: block1:
 ; nextln: block2:
+; nextln: block1:
+; nextln: block3:
 ; nextln: block4: block8
 ; nextln: block8: block6
 ; nextln: block6: block7
 ; nextln: block7:
-; nextln: block3:
 ; nextln: block5: block9
 ; nextln: block9:
 ; nextln: }

cranelift/filetests/filetests/domtree/loops2.clif

@@ -2,30 +2,23 @@ test domtree
 
 function %loop1(i32) {
     block0(v0: i32):
-        brz v0, block1    ; dominates: block1 block6
+        brif v0, block10, block1    ; dominates: block10 block1 block6
-        jump block10      ; dominates: block10
     block10:
-        brnz v0, block2   ; dominates: block2 block9
+        brif v0, block2, block3     ; dominates: block2 block9 block3
-        jump block3       ; dominates: block3
     block1:
         jump block6
     block2:
-        brz v0, block4    ; dominates: block4 block7 block8
+        brif v0, block5, block4     ; dominates: block5 block4 block7 block8
-        jump block5       ; dominates: block5
     block3:
         jump block9
     block4:
-        brz v0, block4
+        brif v0, block11, block4    ; dominates: block11
-        jump block11      ; dominates: block11
     block11:
-        brnz v0, block6
+        brif v0, block6, block7
-        jump block7
     block5:
-        brz v0, block7
+        brif v0, block12, block7    ; dominates: block12
-        jump block12      ; dominates: block12
     block12:
-        brnz v0, block8
+        brif v0, block8, block9
-        jump block9
     block6:
         return
     block7:
@@ -37,56 +30,52 @@ function %loop1(i32) {
 }
 
 ; check: domtree_preorder {
-; nextln: block0: block1 block10 block6
+; nextln: block0: block10 block1 block6
-; nextln: block1:
 ; nextln: block10: block2 block3 block9
-; nextln: block2: block4 block5 block7 block8
+; nextln: block2: block5 block4 block7 block8
-; nextln: block4: block11
-; nextln: block11:
 ; nextln: block5: block12
 ; nextln: block12:
+; nextln: block4: block11
+; nextln: block11:
 ; nextln: block7:
 ; nextln: block8:
 ; nextln: block3:
 ; nextln: block9:
+; nextln: block1:
 ; nextln: block6:
 ; nextln: }
 
 function %loop2(i32) system_v {
     block0(v0: i32):
-        brz v0, block1    ; dominates: block1 block3 block4 block5
+        brif v0, block2, block1    ; dominates: block2 block1 block3 block4 block5
-        jump block2       ; dominates: block2
     block1:
         jump block3
     block2:
-        brz v0, block4
+        brif v0, block5, block4
-        jump block5
     block3:
         jump block4
     block4:
-        brz v0, block3
+        brif v0, block5, block3
-        jump block5
     block5:
-        brz v0, block4
+        brif v0, block6, block4    ; dominates: block6
-        jump block6       ; dominates: block6
     block6:
         return
 }
 ; check: cfg_postorder:
 ; sameln: block6
 ; sameln: block5
-; sameln: block3
 ; sameln: block4
-; sameln: block2
+; sameln: block3
 ; sameln: block1
+; sameln: block2
 ; sameln: block0
 
 ; check: domtree_preorder {
-; nextln: block0: block1 block2 block4 block3 block5
+; nextln: block0: block2 block1 block3 block4 block5
-; nextln: block1:
 ; nextln: block2:
-; nextln: block4:
+; nextln: block1:
 ; nextln: block3:
+; nextln: block4:
 ; nextln: block5: block6
 ; nextln: block6:
 ; nextln: }

cranelift/filetests/filetests/domtree/tall-tree.clif

@@ -2,11 +2,9 @@ test domtree
 
 function %test(i32) {
     block0(v0: i32):
-        brz v0, block1    ; dominates: block1
+        brif v0, block12, block1    ; dominates: block12 block1
-        jump block12      ; dominates: block12
     block12:
-        brnz v0, block2   ; dominates: block2 block5
+        brif v0, block2, block3   ; dominates: block2 block5 block3
-        jump block3       ; dominates: block3
     block1:
         jump block4       ; dominates: block4
     block2:
@@ -14,16 +12,13 @@ function %test(i32) {
     block3:
         jump block5
     block4:
-        brz v0, block6    ; dominates: block6 block10
+        brif v0, block7, block6    ; dominates: block7 block6 block10
-        jump block7       ; dominates: block7
     block5:
         return
     block6:
-        brz v0, block8    ; dominates: block11 block8
+        brif v0, block13, block8    ; dominates: block13 block11 block8
-        jump block13      ; dominates: block13
     block13:
-        brnz v0, block9   ; dominates: block9
+        brif v0, block9, block10   ; dominates: block9
-        jump block10
     block7:
         jump block10
     block8:
@@ -37,18 +32,18 @@ function %test(i32) {
 }
 
 ; check: domtree_preorder {
-; nextln: block0: block1 block12
+; nextln: block0: block12 block1
-; nextln: block1: block4
-; nextln: block4: block6 block7 block10
-; nextln: block6: block8 block13 block11
-; nextln: block8:
-; nextln: block13: block9
-; nextln: block9:
-; nextln: block11:
-; nextln: block7:
-; nextln: block10:
 ; nextln: block12: block2 block3 block5
 ; nextln: block2:
 ; nextln: block3:
 ; nextln: block5:
+; nextln: block1: block4
+; nextln: block4: block7 block6 block10
+; nextln: block7:
+; nextln: block6: block13 block8 block11
+; nextln: block13: block9
+; nextln: block9:
+; nextln: block8:
+; nextln: block11:
+; nextln: block10:
 ; nextln: }

cranelift/filetests/filetests/domtree/wide-tree.clif

@@ -2,20 +2,15 @@ test domtree
 
 function %test(i32) {
     block0(v0: i32):
-        brz v0, block13   ; dominates: block13
+        brif v0, block1, block13   ; dominates: block1 block13
-        jump block1       ; dominates: block1
     block1:
-        brz v0, block2    ; dominates: block2 block7
+        brif v0, block20, block2   ; dominates: block20 block2 block7
-        jump block20      ; dominates: block20
     block20:
-        brnz v0, block3   ; dominates: block3
+        brif v0, block3, block21   ; dominates: block3 block21
-        jump block21      ; dominates: block21
     block21:
-        brz v0, block4    ; dominates: block4
+        brif v0, block22, block4   ; dominates: block22 block4
-        jump block22      ; dominates: block22
     block22:
-        brnz v0, block5   ; dominates: block5
+        brif v0, block5, block6    ; dominates: block5 block6
-        jump block6       ; dominates: block6
     block2:
         jump block7
     block3:
@@ -27,21 +22,17 @@ function %test(i32) {
     block6:
         jump block7
     block7:
-        brnz v0, block8   ; dominates: block8 block12
+        brif v0, block8, block23   ; dominates: block8 block12 block23
-        jump block23      ; dominates: block23
     block23:
-        brz v0, block9    ; dominates: block9
+        brif v0, block24, block9   ; dominates: block24 block9
-        jump block24      ; dominates: block24
     block24:
-        brnz v0, block10  ; dominates: block10
+        brif v0, block10, block11  ; dominates: block10 block11
-        jump block11      ; dominates: block11
     block8:
         jump block12
     block9:
         jump block12
     block10:
-        brz v0, block13
+        brif v0, block12, block13
-        jump block12
     block11:
         jump block13
     block12:
@@ -51,23 +42,23 @@ function %test(i32) {
 }
 
 ; check: domtree_preorder {
-; nextln: block0: block13 block1
+; nextln: block0: block1 block13
-; nextln: block13:
+; nextln: block1: block20 block2 block7
-; nextln: block1: block2 block20 block7
-; nextln: block2:
 ; nextln: block20: block3 block21
 ; nextln: block3:
-; nextln: block21: block4 block22
+; nextln: block21: block22 block4
-; nextln: block4:
 ; nextln: block22: block5 block6
 ; nextln: block5:
 ; nextln: block6:
+; nextln: block4:
+; nextln: block2:
 ; nextln: block7: block8 block23 block12
 ; nextln: block8:
-; nextln: block23: block9 block24
+; nextln: block23: block24 block9
-; nextln: block9:
 ; nextln: block24: block10 block11
 ; nextln: block10:
 ; nextln: block11:
+; nextln: block9:
 ; nextln: block12:
+; nextln: block13:
 ; nextln: }

cranelift/filetests/filetests/egraph/basic-gvn.clif

@@ -6,8 +6,7 @@ target x86_64
 function %f(i32, i32) -> i32 {
 block0(v0: i32, v1: i32):
     v2 = iadd v0, v1
-    brnz v2, block1(v0)
+    brif v2, block1(v0), block2(v1)
-    jump block2(v1)
 
 block1(v3: i32):
     v4 = iadd v0, v1

cranelift/filetests/filetests/egraph/issue-5437.clif

@@ -17,8 +17,7 @@ function u0:0(i64 vmctx, i64) fast {
                                 block0(v0: i64, v1: i64):
 @0019                               v2 = vconst.i8x16 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 @001b                               v3 = iconst.i32 0
-@001d                               brz v3, block2  ; v3 = 0
+@001d                               brif v3, block3, block2  ; v3 = 0
-@001d                               jump block3
 
                                 block3:
 @001f                               trap unreachable
@@ -30,8 +29,7 @@ function u0:0(i64 vmctx, i64) fast {
 @0027                               v7 = bitcast.i32x4 little v6
 @0027                               v8 = vhigh_bits.i32 v7
 @002a                               v9 = iconst.i32 0
-@002c                               brnz v9, block1  ; v9 = 0
+@002c                               brif v9, block1, block4  ; v9 = 0
-@002c                               jump block4
 
                                 block4:
 @002e                               call fn0(v0, v0)

cranelift/filetests/filetests/egraph/licm.clif

@@ -14,8 +14,7 @@ block1(v2: i32):
     v6 = icmp eq v2, v5
     v7 = iconst.i32 1
     v8 = iadd.i32 v2, v7
-    brnz v6, block2(v4)
+    brif v6, block2(v4), block1(v8)
-    jump block1(v8)
 
 block2(v9: i32):
     return v9
@@ -30,8 +29,7 @@ block2(v9: i32):
 ; check:      v6 = icmp eq v2, v5
 ; check:      v3 = iconst.i32 1
 ; check:      v8 = iadd v2, v3
-; check:      brnz v6, block2
+; check:      brif v6, block2, block1(v8)
-; check:      jump block1(v8)
 
 ; check:  block2:
 ; check:      v10 = iconst.i32 1

cranelift/filetests/filetests/egraph/remat.clif

@@ -7,8 +7,7 @@ function %f(i32) -> i32 {
 block0(v0: i32):
     v1 = iconst.i32 42
     v2 = iadd.i32 v0, v1
-    brnz v2, block1
+    brif v2, block1, block2
-    jump block2
 
 block1:
     v3 = iconst.i32 84
@@ -22,8 +21,7 @@ block2:
 ; check:  block0(v0: i32):
 ; check:      v1 = iconst.i32 42
 ; check:      v2 = iadd v0, v1
-; check:      brnz v2, block1
+; check:      brif v2, block1, block2
-; check:      jump block2
 ; check:   block1:
 ; check:      v11 = iconst.i32 126
 ; check:      v13 = iadd.i32 v0, v11

cranelift/filetests/filetests/isa/aarch64/condbr.clif

@@ -153,8 +153,7 @@ function %f(i64, i64) -> i64 {
 block0(v0: i64, v1: i64):
   v2 = icmp eq v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block2
-  jump block2
 
 block1:
   v4 = iconst.i64 1
@@ -179,8 +178,7 @@ function %f(i64, i64) -> i64 {
 block0(v0: i64, v1: i64):
   v2 = icmp eq v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   v4 = iconst.i64 1
@@ -198,10 +196,9 @@ block1:
 ;   movz x0, #1
 ;   ret
 
-function %i128_brz(i128){
+function %i128_brif_false(i128){
 block0(v0: i128):
-    brz v0, block1
+    brif v0, block1, block1
-    jump block1
 
 block1:
     nop
@@ -210,7 +207,7 @@ block1:
 
 ; block0:
 ;   orr x3, x0, x1
-;   cbz x3, label1 ; b label2
+;   cbnz x3, label1 ; b label2
 ; block1:
 ;   b label3
 ; block2:
@@ -218,10 +215,9 @@ block1:
 ; block3:
 ;   ret
 
-function %i128_brnz(i128){
+function %i128_brif_true(i128){
 block0(v0: i128):
-    brnz v0, block1
+    brif v0, block1, block1
-    jump block1
 
 block1:
     nop
@@ -242,8 +238,7 @@ function %i128_bricmp_eq(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp eq v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -264,8 +259,7 @@ function %i128_bricmp_ne(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp ne v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -286,8 +280,7 @@ function %i128_bricmp_slt(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp slt v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -312,8 +305,7 @@ function %i128_bricmp_ult(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp ult v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -338,8 +330,7 @@ function %i128_bricmp_sle(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp sle v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -365,8 +356,7 @@ function %i128_bricmp_ule(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp ule v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -392,8 +382,7 @@ function %i128_bricmp_sgt(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp sgt v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -418,8 +407,7 @@ function %i128_bricmp_ugt(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp ugt v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -444,8 +432,7 @@ function %i128_bricmp_sge(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp sge v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return
@@ -471,8 +458,7 @@ function %i128_bricmp_uge(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp uge v0, v1
   v3 = uextend.i32 v2
-  brnz v3, block1
+  brif v3, block1, block1
-  jump block1
 
 block1:
   return

cranelift/filetests/filetests/isa/aarch64/reftypes.clif

@@ -49,8 +49,7 @@ function %f4(r64, r64) -> r64, r64, r64 {
 block0(v0: r64, v1: r64):
     v2 = call fn0(v0)
     stack_store.r64 v0, ss0
-    brz v2, block1(v1, v0)
+    brif v2, block2(v0, v1), block1(v1, v0)
-    jump block2(v0, v1)
 
 block1(v3: r64, v4: r64):
     jump block3(v3, v4)
@@ -75,18 +74,18 @@ block3(v7: r64, v8: r64):
 ;   ldr x6, [sp, #8]
 ;   str x6, [x15]
 ;   uxtb w0, w0
-;   cbz x0, label1 ; b label3
+;   cbnz x0, label1 ; b label3
 ; block1:
 ;   b label2
 ; block2:
-;   mov x1, x6
+;   mov x0, x6
-;   ldr x0, [sp, #16]
+;   ldr x1, [sp, #16]
 ;   b label5
 ; block3:
 ;   b label4
 ; block4:
-;   mov x0, x6
+;   mov x1, x6
-;   ldr x1, [sp, #16]
+;   ldr x0, [sp, #16]
 ;   b label5
 ; block5:
 ;   mov x2, sp

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat

@@ -45,14 +45,14 @@
 ;;   ldr x8, [x2, #8]
 ;;   sub x8, x8, #4
 ;;   subs xzr, x7, x8
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x2]
-;;   str w1, [x9, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x2]
+;;   str w1, [x10, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -61,12 +61,12 @@
 ;;   ldr x8, [x1, #8]
 ;;   sub x8, x8, #4
 ;;   subs xzr, x7, x8
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x1]
-;;   ldr w0, [x9, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x1]
+;;   ldr w0, [x10, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -46,15 +46,15 @@
 ;;   movn x8, #4099
 ;;   add x10, x10, x8
 ;;   subs xzr, x9, x10
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x11, [x2]
-;;   add x11, x11, #4096
-;;   str w1, [x11, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x12, [x2]
+;;   add x12, x12, #4096
+;;   str w1, [x12, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -64,13 +64,13 @@
 ;;   movn x8, #4099
 ;;   add x10, x10, x8
 ;;   subs xzr, x9, x10
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x11, [x1]
-;;   add x10, x11, #4096
-;;   ldr w0, [x10, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x12, [x1]
+;;   add x11, x12, #4096
+;;   ldr w0, [x11, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat

@@ -47,16 +47,16 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x12, [x2, #8]
 ;;   subs xzr, x11, x12
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x13, [x2]
-;;   movz x14, #65535, LSL #16
-;;   add x13, x14, x13
-;;   str w1, [x13, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x14, [x2]
+;;   movz x15, #65535, LSL #16
+;;   add x14, x15, x14
+;;   str w1, [x14, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -67,14 +67,14 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x12, [x1, #8]
 ;;   subs xzr, x11, x12
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x13, [x1]
-;;   movz x12, #65535, LSL #16
-;;   add x12, x12, x13
-;;   ldr w0, [x12, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x14, [x1]
+;;   movz x13, #65535, LSL #16
+;;   add x13, x13, x14
+;;   ldr w0, [x13, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat

@@ -44,14 +44,14 @@
 ;;   mov w6, w0
 ;;   ldr x7, [x2, #8]
 ;;   subs xzr, x6, x7
-;;   b.lo label1 ; b label3
+;;   b.hs label1 ; b label2
-;; block1:
-;;   ldr x8, [x2]
-;;   strb w1, [x8, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x2]
+;;   strb w1, [x9, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -59,12 +59,12 @@
 ;;   mov w6, w0
 ;;   ldr x7, [x1, #8]
 ;;   subs xzr, x6, x7
-;;   b.lo label1 ; b label3
+;;   b.hs label1 ; b label2
-;; block1:
-;;   ldr x8, [x1]
-;;   ldrb w0, [x8, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x1]
+;;   ldrb w0, [x9, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat

@@ -46,15 +46,15 @@
 ;;   movn x8, #4096
 ;;   add x10, x10, x8
 ;;   subs xzr, x9, x10
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x11, [x2]
-;;   add x11, x11, #4096
-;;   strb w1, [x11, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x12, [x2]
+;;   add x12, x12, #4096
+;;   strb w1, [x12, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -64,13 +64,13 @@
 ;;   movn x8, #4096
 ;;   add x10, x10, x8
 ;;   subs xzr, x9, x10
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x11, [x1]
-;;   add x10, x11, #4096
-;;   ldrb w0, [x10, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x12, [x1]
+;;   add x11, x12, #4096
+;;   ldrb w0, [x11, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat

@@ -47,16 +47,16 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x12, [x2, #8]
 ;;   subs xzr, x11, x12
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x13, [x2]
-;;   movz x14, #65535, LSL #16
-;;   add x13, x14, x13
-;;   strb w1, [x13, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x14, [x2]
+;;   movz x15, #65535, LSL #16
+;;   add x14, x15, x14
+;;   strb w1, [x14, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -67,14 +67,14 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x12, [x1, #8]
 ;;   subs xzr, x11, x12
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x13, [x1]
-;;   movz x12, #65535, LSL #16
-;;   add x12, x12, x13
-;;   ldrb w0, [x12, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x14, [x1]
+;;   movz x13, #65535, LSL #16
+;;   add x13, x13, x14
+;;   ldrb w0, [x13, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat

@@ -45,14 +45,14 @@
 ;;   ldr x8, [x2, #8]
 ;;   sub x8, x8, #4
 ;;   subs xzr, x7, x8
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x2]
-;;   str w1, [x9, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x2]
+;;   str w1, [x10, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -61,12 +61,12 @@
 ;;   ldr x8, [x1, #8]
 ;;   sub x8, x8, #4
 ;;   subs xzr, x7, x8
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x1]
-;;   ldr w0, [x9, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x1]
+;;   ldr w0, [x10, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -46,15 +46,15 @@
 ;;   movn x8, #4099
 ;;   add x10, x10, x8
 ;;   subs xzr, x9, x10
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x11, [x2]
-;;   add x11, x11, #4096
-;;   str w1, [x11, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x12, [x2]
+;;   add x12, x12, #4096
+;;   str w1, [x12, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -64,13 +64,13 @@
 ;;   movn x8, #4099
 ;;   add x10, x10, x8
 ;;   subs xzr, x9, x10
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x11, [x1]
-;;   add x10, x11, #4096
-;;   ldr w0, [x10, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x12, [x1]
+;;   add x11, x12, #4096
+;;   ldr w0, [x11, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat

@@ -47,16 +47,16 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x12, [x2, #8]
 ;;   subs xzr, x11, x12
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x13, [x2]
-;;   movz x14, #65535, LSL #16
-;;   add x13, x14, x13
-;;   str w1, [x13, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x14, [x2]
+;;   movz x15, #65535, LSL #16
+;;   add x14, x15, x14
+;;   str w1, [x14, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -67,14 +67,14 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x12, [x1, #8]
 ;;   subs xzr, x11, x12
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x13, [x1]
-;;   movz x12, #65535, LSL #16
-;;   add x12, x12, x13
-;;   ldr w0, [x12, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x14, [x1]
+;;   movz x13, #65535, LSL #16
+;;   add x13, x13, x14
+;;   ldr w0, [x13, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat

@@ -44,14 +44,14 @@
 ;;   mov w6, w0
 ;;   ldr x7, [x2, #8]
 ;;   subs xzr, x6, x7
-;;   b.lo label1 ; b label3
+;;   b.hs label1 ; b label2
-;; block1:
-;;   ldr x8, [x2]
-;;   strb w1, [x8, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x2]
+;;   strb w1, [x9, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -59,12 +59,12 @@
 ;;   mov w6, w0
 ;;   ldr x7, [x1, #8]
 ;;   subs xzr, x6, x7
-;;   b.lo label1 ; b label3
+;;   b.hs label1 ; b label2
-;; block1:
-;;   ldr x8, [x1]
-;;   ldrb w0, [x8, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x1]
+;;   ldrb w0, [x9, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat

@@ -46,15 +46,15 @@
 ;;   movn x8, #4096
 ;;   add x10, x10, x8
 ;;   subs xzr, x9, x10
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x11, [x2]
-;;   add x11, x11, #4096
-;;   strb w1, [x11, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x12, [x2]
+;;   add x12, x12, #4096
+;;   strb w1, [x12, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -64,13 +64,13 @@
 ;;   movn x8, #4096
 ;;   add x10, x10, x8
 ;;   subs xzr, x9, x10
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x11, [x1]
-;;   add x10, x11, #4096
-;;   ldrb w0, [x10, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x12, [x1]
+;;   add x11, x12, #4096
+;;   ldrb w0, [x11, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat

@@ -47,16 +47,16 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x12, [x2, #8]
 ;;   subs xzr, x11, x12
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x13, [x2]
-;;   movz x14, #65535, LSL #16
-;;   add x13, x14, x13
-;;   strb w1, [x13, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x14, [x2]
+;;   movz x15, #65535, LSL #16
+;;   add x14, x15, x14
+;;   strb w1, [x14, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -67,14 +67,14 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x12, [x1, #8]
 ;;   subs xzr, x11, x12
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x13, [x1]
-;;   movz x12, #65535, LSL #16
-;;   add x12, x12, x13
-;;   ldrb w0, [x12, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x14, [x1]
+;;   movz x13, #65535, LSL #16
+;;   add x13, x13, x14
+;;   ldrb w0, [x13, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat

@@ -44,14 +44,14 @@
 ;;   ldr x6, [x2, #8]
 ;;   sub x6, x6, #4
 ;;   subs xzr, x0, x6
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x8, [x2]
-;;   str w1, [x8, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x2]
+;;   str w1, [x9, x0]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -59,12 +59,12 @@
 ;;   ldr x6, [x1, #8]
 ;;   sub x6, x6, #4
 ;;   subs xzr, x0, x6
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x8, [x1]
-;;   ldr w0, [x8, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x1]
+;;   ldr w0, [x9, x0]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -45,15 +45,15 @@
 ;;   movn x7, #4099
 ;;   add x9, x8, x7
 ;;   subs xzr, x0, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x2]
-;;   add x11, x0, #4096
-;;   str w1, [x11, x10]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x2]
+;;   add x12, x0, #4096
+;;   str w1, [x12, x11]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -62,13 +62,13 @@
 ;;   movn x7, #4099
 ;;   add x9, x8, x7
 ;;   subs xzr, x0, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x0, #4096
-;;   ldr w0, [x9, x10]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x1]
+;;   add x10, x0, #4096
+;;   ldr w0, [x10, x11]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat

@@ -46,16 +46,16 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x11, [x2, #8]
 ;;   subs xzr, x10, x11
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x12, [x2]
-;;   movz x13, #65535, LSL #16
-;;   add x13, x13, x0
-;;   str w1, [x13, x12]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x13, [x2]
+;;   movz x14, #65535, LSL #16
+;;   add x14, x14, x0
+;;   str w1, [x14, x13]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -65,14 +65,14 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x11, [x1, #8]
 ;;   subs xzr, x10, x11
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x12, [x1]
-;;   movz x11, #65535, LSL #16
-;;   add x11, x11, x0
-;;   ldr w0, [x11, x12]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x13, [x1]
+;;   movz x12, #65535, LSL #16
+;;   add x12, x12, x0
+;;   ldr w0, [x12, x13]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat

@@ -43,26 +43,26 @@
 ;; block0:
 ;;   ldr x5, [x2, #8]
 ;;   subs xzr, x0, x5
-;;   b.lo label1 ; b label3
+;;   b.hs label1 ; b label2
-;; block1:
-;;   ldr x7, [x2]
-;;   strb w1, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x2]
+;;   strb w1, [x8, x0]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
 ;; block0:
 ;;   ldr x5, [x1, #8]
 ;;   subs xzr, x0, x5
-;;   b.lo label1 ; b label3
+;;   b.hs label1 ; b label2
-;; block1:
-;;   ldr x7, [x1]
-;;   ldrb w0, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x1]
+;;   ldrb w0, [x8, x0]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat

@@ -45,15 +45,15 @@
 ;;   movn x7, #4096
 ;;   add x9, x8, x7
 ;;   subs xzr, x0, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x2]
-;;   add x11, x0, #4096
-;;   strb w1, [x11, x10]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x2]
+;;   add x12, x0, #4096
+;;   strb w1, [x12, x11]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -62,13 +62,13 @@
 ;;   movn x7, #4096
 ;;   add x9, x8, x7
 ;;   subs xzr, x0, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x0, #4096
-;;   ldrb w0, [x9, x10]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x1]
+;;   add x10, x0, #4096
+;;   ldrb w0, [x10, x11]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat

@@ -46,16 +46,16 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x11, [x2, #8]
 ;;   subs xzr, x10, x11
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x12, [x2]
-;;   movz x13, #65535, LSL #16
-;;   add x13, x13, x0
-;;   strb w1, [x13, x12]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x13, [x2]
+;;   movz x14, #65535, LSL #16
+;;   add x14, x14, x0
+;;   strb w1, [x14, x13]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -65,14 +65,14 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x11, [x1, #8]
 ;;   subs xzr, x10, x11
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x12, [x1]
-;;   movz x11, #65535, LSL #16
-;;   add x11, x11, x0
-;;   ldrb w0, [x11, x12]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x13, [x1]
+;;   movz x12, #65535, LSL #16
+;;   add x12, x12, x0
+;;   ldrb w0, [x12, x13]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat

@@ -44,14 +44,14 @@
 ;;   ldr x6, [x2, #8]
 ;;   sub x6, x6, #4
 ;;   subs xzr, x0, x6
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x8, [x2]
-;;   str w1, [x8, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x2]
+;;   str w1, [x9, x0]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -59,12 +59,12 @@
 ;;   ldr x6, [x1, #8]
 ;;   sub x6, x6, #4
 ;;   subs xzr, x0, x6
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x8, [x1]
-;;   ldr w0, [x8, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x1]
+;;   ldr w0, [x9, x0]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -45,15 +45,15 @@
 ;;   movn x7, #4099
 ;;   add x9, x8, x7
 ;;   subs xzr, x0, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x2]
-;;   add x11, x0, #4096
-;;   str w1, [x11, x10]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x2]
+;;   add x12, x0, #4096
+;;   str w1, [x12, x11]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -62,13 +62,13 @@
 ;;   movn x7, #4099
 ;;   add x9, x8, x7
 ;;   subs xzr, x0, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x0, #4096
-;;   ldr w0, [x9, x10]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x1]
+;;   add x10, x0, #4096
+;;   ldr w0, [x10, x11]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat

@@ -46,16 +46,16 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x11, [x2, #8]
 ;;   subs xzr, x10, x11
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x12, [x2]
-;;   movz x13, #65535, LSL #16
-;;   add x13, x13, x0
-;;   str w1, [x13, x12]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x13, [x2]
+;;   movz x14, #65535, LSL #16
+;;   add x14, x14, x0
+;;   str w1, [x14, x13]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -65,14 +65,14 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x11, [x1, #8]
 ;;   subs xzr, x10, x11
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x12, [x1]
-;;   movz x11, #65535, LSL #16
-;;   add x11, x11, x0
-;;   ldr w0, [x11, x12]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x13, [x1]
+;;   movz x12, #65535, LSL #16
+;;   add x12, x12, x0
+;;   ldr w0, [x12, x13]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat

@@ -43,26 +43,26 @@
 ;; block0:
 ;;   ldr x5, [x2, #8]
 ;;   subs xzr, x0, x5
-;;   b.lo label1 ; b label3
+;;   b.hs label1 ; b label2
-;; block1:
-;;   ldr x7, [x2]
-;;   strb w1, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x2]
+;;   strb w1, [x8, x0]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
 ;; block0:
 ;;   ldr x5, [x1, #8]
 ;;   subs xzr, x0, x5
-;;   b.lo label1 ; b label3
+;;   b.hs label1 ; b label2
-;; block1:
-;;   ldr x7, [x1]
-;;   ldrb w0, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x1]
+;;   ldrb w0, [x8, x0]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat

@@ -45,15 +45,15 @@
 ;;   movn x7, #4096
 ;;   add x9, x8, x7
 ;;   subs xzr, x0, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x2]
-;;   add x11, x0, #4096
-;;   strb w1, [x11, x10]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x2]
+;;   add x12, x0, #4096
+;;   strb w1, [x12, x11]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -62,13 +62,13 @@
 ;;   movn x7, #4096
 ;;   add x9, x8, x7
 ;;   subs xzr, x0, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x0, #4096
-;;   ldrb w0, [x9, x10]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x1]
+;;   add x10, x0, #4096
+;;   ldrb w0, [x10, x11]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat

@@ -46,16 +46,16 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x11, [x2, #8]
 ;;   subs xzr, x10, x11
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x12, [x2]
-;;   movz x13, #65535, LSL #16
-;;   add x13, x13, x0
-;;   strb w1, [x13, x12]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x13, [x2]
+;;   movz x14, #65535, LSL #16
+;;   add x14, x14, x0
+;;   strb w1, [x14, x13]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -65,14 +65,14 @@
 ;;   b.lo 8 ; udf
 ;;   ldr x11, [x1, #8]
 ;;   subs xzr, x10, x11
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x12, [x1]
-;;   movz x11, #65535, LSL #16
-;;   add x11, x11, x0
-;;   ldrb w0, [x11, x12]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x13, [x1]
+;;   movz x12, #65535, LSL #16
+;;   add x12, x12, x0
+;;   ldrb w0, [x12, x13]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat

@@ -42,14 +42,14 @@
 ;;   mov w6, w0
 ;;   orr x7, xzr, #268435452
 ;;   subs xzr, x6, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x8, [x2]
-;;   str w1, [x8, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x2]
+;;   str w1, [x9, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -57,12 +57,12 @@
 ;;   mov w6, w0
 ;;   orr x7, xzr, #268435452
 ;;   subs xzr, x6, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x8, [x1]
-;;   ldr w0, [x8, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x1]
+;;   ldr w0, [x9, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -43,15 +43,15 @@
 ;;   movz w9, #61436
 ;;   movk w9, w9, #4095, LSL #16
 ;;   subs xzr, x8, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x2]
-;;   add x10, x10, #4096
-;;   str w1, [x10, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x2]
+;;   add x11, x11, #4096
+;;   str w1, [x11, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -60,13 +60,13 @@
 ;;   movz w9, #61436
 ;;   movk w9, w9, #4095, LSL #16
 ;;   subs xzr, x8, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x10, #4096
-;;   ldr w0, [x9, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x1]
+;;   add x10, x11, #4096
+;;   ldr w0, [x10, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat

@@ -42,14 +42,14 @@
 ;;   mov w6, w0
 ;;   orr x7, xzr, #268435455
 ;;   subs xzr, x6, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x8, [x2]
-;;   strb w1, [x8, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x2]
+;;   strb w1, [x9, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -57,12 +57,12 @@
 ;;   mov w6, w0
 ;;   orr x7, xzr, #268435455
 ;;   subs xzr, x6, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x8, [x1]
-;;   ldrb w0, [x8, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x9, [x1]
+;;   ldrb w0, [x9, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat

@@ -43,15 +43,15 @@
 ;;   movz w9, #61439
 ;;   movk w9, w9, #4095, LSL #16
 ;;   subs xzr, x8, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x2]
-;;   add x10, x10, #4096
-;;   strb w1, [x10, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x2]
+;;   add x11, x11, #4096
+;;   strb w1, [x11, w0, UXTW]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -60,13 +60,13 @@
 ;;   movz w9, #61439
 ;;   movk w9, w9, #4095, LSL #16
 ;;   subs xzr, x8, x9
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x10, #4096
-;;   ldrb w0, [x9, w0, UXTW]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x11, [x1]
+;;   add x10, x11, #4096
+;;   ldrb w0, [x10, w0, UXTW]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat

@@ -41,26 +41,26 @@
 ;; block0:
 ;;   orr x5, xzr, #268435452
 ;;   subs xzr, x0, x5
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x7, [x2]
-;;   str w1, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x2]
+;;   str w1, [x8, x0]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
 ;; block0:
 ;;   orr x5, xzr, #268435452
 ;;   subs xzr, x0, x5
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x7, [x1]
-;;   ldr w0, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x1]
+;;   ldr w0, [x8, x0]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -42,15 +42,15 @@
 ;;   movz w7, #61436
 ;;   movk w7, w7, #4095, LSL #16
 ;;   subs xzr, x0, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x2]
-;;   add x10, x0, #4096
-;;   str w1, [x10, x9]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x2]
+;;   add x11, x0, #4096
+;;   str w1, [x11, x10]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -58,13 +58,13 @@
 ;;   movz w7, #61436
 ;;   movk w7, w7, #4095, LSL #16
 ;;   subs xzr, x0, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x0, #4096
-;;   ldr w0, [x8, x9]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x1]
+;;   add x9, x0, #4096
+;;   ldr w0, [x9, x10]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat

@@ -41,26 +41,26 @@
 ;; block0:
 ;;   orr x5, xzr, #268435455
 ;;   subs xzr, x0, x5
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x7, [x2]
-;;   strb w1, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x2]
+;;   strb w1, [x8, x0]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
 ;; block0:
 ;;   orr x5, xzr, #268435455
 ;;   subs xzr, x0, x5
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x7, [x1]
-;;   ldrb w0, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x1]
+;;   ldrb w0, [x8, x0]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat

@@ -42,15 +42,15 @@
 ;;   movz w7, #61439
 ;;   movk w7, w7, #4095, LSL #16
 ;;   subs xzr, x0, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x2]
-;;   add x10, x0, #4096
-;;   strb w1, [x10, x9]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x2]
+;;   add x11, x0, #4096
+;;   strb w1, [x11, x10]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -58,13 +58,13 @@
 ;;   movz w7, #61439
 ;;   movk w7, w7, #4095, LSL #16
 ;;   subs xzr, x0, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x0, #4096
-;;   ldrb w0, [x8, x9]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x1]
+;;   add x9, x0, #4096
+;;   ldrb w0, [x9, x10]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat

@@ -41,26 +41,26 @@
 ;; block0:
 ;;   orr x5, xzr, #268435452
 ;;   subs xzr, x0, x5
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x7, [x2]
-;;   str w1, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x2]
+;;   str w1, [x8, x0]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
 ;; block0:
 ;;   orr x5, xzr, #268435452
 ;;   subs xzr, x0, x5
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x7, [x1]
-;;   ldr w0, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x1]
+;;   ldr w0, [x8, x0]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -42,15 +42,15 @@
 ;;   movz w7, #61436
 ;;   movk w7, w7, #4095, LSL #16
 ;;   subs xzr, x0, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x2]
-;;   add x10, x0, #4096
-;;   str w1, [x10, x9]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x2]
+;;   add x11, x0, #4096
+;;   str w1, [x11, x10]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -58,13 +58,13 @@
 ;;   movz w7, #61436
 ;;   movk w7, w7, #4095, LSL #16
 ;;   subs xzr, x0, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x0, #4096
-;;   ldr w0, [x8, x9]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x1]
+;;   add x9, x0, #4096
+;;   ldr w0, [x9, x10]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat

@@ -41,26 +41,26 @@
 ;; block0:
 ;;   orr x5, xzr, #268435455
 ;;   subs xzr, x0, x5
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x7, [x2]
-;;   strb w1, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x2]
+;;   strb w1, [x8, x0]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
 ;; block0:
 ;;   orr x5, xzr, #268435455
 ;;   subs xzr, x0, x5
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x7, [x1]
-;;   ldrb w0, [x7, x0]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x8, [x1]
+;;   ldrb w0, [x8, x0]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat

@@ -42,15 +42,15 @@
 ;;   movz w7, #61439
 ;;   movk w7, w7, #4095, LSL #16
 ;;   subs xzr, x0, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x2]
-;;   add x10, x0, #4096
-;;   strb w1, [x10, x9]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x2]
+;;   add x11, x0, #4096
+;;   strb w1, [x11, x10]
+;;   b label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf #0xc11f
 ;;
 ;; function u0:1:
@@ -58,13 +58,13 @@
 ;;   movz w7, #61439
 ;;   movk w7, w7, #4095, LSL #16
 ;;   subs xzr, x0, x7
-;;   b.ls label1 ; b label3
+;;   b.hi label1 ; b label2
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x0, #4096
-;;   ldrb w0, [x8, x9]
-;;   b label2
 ;; block2:
-;;   ret
+;;   ldr x10, [x1]
+;;   add x9, x0, #4096
+;;   ldrb w0, [x9, x10]
+;;   b label3
 ;; block3:
-;;   udf #0xc11f
+;;   ret
+;; block1:
+;;   udf #0xc11f

cranelift/filetests/filetests/isa/riscv64/condbr.clif

@@ -115,8 +115,7 @@ block0(v0: i128, v1: i128):
 function %f(i64, i64) -> i64 {
 block0(v0: i64, v1: i64):
   v2 = icmp eq v0, v1
-  brnz v2, block1
+  brif v2, block1, block2
-  jump block2
 
 block1:
   v4 = iconst.i64 1
@@ -140,8 +139,7 @@ block2:
 function %f(i64, i64) -> i64 {
 block0(v0: i64, v1: i64):
   v2 = icmp eq v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   v4 = iconst.i64 1
@@ -159,30 +157,9 @@ block1:
 ;   li a0,1
 ;   ret
 
-function %i128_brz(i128){
+function %i128_brif(i128){
 block0(v0: i128):
-    brz v0, block1
+    brif v0, block1, block1
-    jump block1
-
-block1:
-    nop
-    return
-}
-
-; block0:
-;   eq a0,[a0,a1],[zerozero]##ty=i128
-;   bne a0,zero,taken(label1),not_taken(label2)
-; block1:
-;   j label3
-; block2:
-;   j label3
-; block3:
-;   ret
-
-function %i128_brnz(i128){
-block0(v0: i128):
-    brnz v0, block1
-    jump block1
 
 block1:
     nop
@@ -202,8 +179,7 @@ block1:
 function %i128_bricmp_eq(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp eq v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -222,8 +198,7 @@ block1:
 function %i128_bricmp_ne(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp ne v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -242,8 +217,7 @@ block1:
 function %i128_bricmp_slt(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp slt v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -262,8 +236,7 @@ block1:
 function %i128_bricmp_ult(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp ult v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -282,8 +255,7 @@ block1:
 function %i128_bricmp_sle(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp sle v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -302,8 +274,7 @@ block1:
 function %i128_bricmp_ule(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp ule v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -322,8 +293,7 @@ block1:
 function %i128_bricmp_sgt(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp sgt v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -342,8 +312,7 @@ block1:
 function %i128_bricmp_ugt(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp ugt v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -362,8 +331,7 @@ block1:
 function %i128_bricmp_sge(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp sge v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -382,8 +350,7 @@ block1:
 function %i128_bricmp_uge(i128, i128) {
 block0(v0: i128, v1: i128):
   v2 = icmp uge v0, v1
-  brnz v2, block1
+  brif v2, block1, block1
-  jump block1
 
 block1:
   return
@@ -401,30 +368,9 @@ block1:
 
 
 
-function %i8_brz(i8){
+function %i8_brif(i8){
 block0(v0: i8):
-    brz v0, block1
+    brif v0, block1, block1
-    jump block1
-
-block1:
-    nop
-    return
-}
-
-; block0:
-;   andi t2,a0,255
-;   beq t2,zero,taken(label1),not_taken(label2)
-; block1:
-;   j label3
-; block2:
-;   j label3
-; block3:
-;   ret
-
-function %i8_brnz(i8){
-block0(v0: i8):
-    brnz v0, block1
-    jump block1
 
 block1:
     nop
@@ -441,32 +387,9 @@ block1:
 ; block3:
 ;   ret
 
-function %i16_brz(i16){
+function %i16_brif(i16){
 block0(v0: i16):
-    brz v0, block1
+    brif v0, block1, block1
-    jump block1
-
-block1:
-    nop
-    return
-}
-
-; block0:
-;   lui a1,16
-;   addi a1,a1,4095
-;   and a3,a0,a1
-;   beq a3,zero,taken(label1),not_taken(label2)
-; block1:
-;   j label3
-; block2:
-;   j label3
-; block3:
-;   ret
-
-function %i16_brnz(i16){
-block0(v0: i16):
-    brnz v0, block1
-    jump block1
 
 block1:
     nop
@@ -485,30 +408,9 @@ block1:
 ; block3:
 ;   ret
 
-function %i32_brz(i32){
+function %i32_brif(i32){
 block0(v0: i32):
-    brz v0, block1
+    brif v0, block1, block1
-    jump block1
-
-block1:
-    nop
-    return
-}
-
-; block0:
-;   addiw t2,a0,0
-;   beq t2,zero,taken(label1),not_taken(label2)
-; block1:
-;   j label3
-; block2:
-;   j label3
-; block3:
-;   ret
-
-function %i32_brnz(i32){
-block0(v0: i32):
-    brnz v0, block1
-    jump block1
 
 block1:
     nop
@@ -525,29 +427,9 @@ block1:
 ; block3:
 ;   ret
 
-function %i64_brz(i64){
+function %i64_brif(i64){
 block0(v0: i64):
-    brz v0, block1
+    brif v0, block1, block1
-    jump block1
-
-block1:
-    nop
-    return
-}
-
-; block0:
-;   beq a0,zero,taken(label1),not_taken(label2)
-; block1:
-;   j label3
-; block2:
-;   j label3
-; block3:
-;   ret
-
-function %i64_brnz(i64){
-block0(v0: i64):
-    brnz v0, block1
-    jump block1
 
 block1:
     nop

cranelift/filetests/filetests/isa/riscv64/fcmp.clif

@@ -6,33 +6,31 @@ function %f0() {
 block0:
     v0 = f64const 0.0
     v1 = fcmp ult v0, v0
-    brz v1, block1
+    brif v1, block1, block1
-    jump block1
+
-
+block1:
-block1:
+    return
-    return
+}
-}
+
-
+; block0:
-; block0:
+;   li t1,0
-;   li t1,0
+;   fmv.d.x ft1,t1
-;   fmv.d.x ft1,t1
+;   li a2,0
-;   li a2,0
+;   fmv.d.x ft5,a2
-;   fmv.d.x ft5,a2
+;   fle.d a5,ft5,ft1
-;   fle.d a5,ft5,ft1
+;   bne a5,zero,taken(label2),not_taken(label1)
-;   bne a5,zero,taken(label1),not_taken(label2)
+; block1:
-; block1:
+;   j label3
-;   j label3
+; block2:
-; block2:
+;   j label3
-;   j label3
+; block3:
-; block3:
+;   ret
-;   ret
+
-
+function %f1() {
-function %f1() {
+block0:
-block0:
+    v0 = f64const 0.0
-    v0 = f64const 0.0
+    v1 = fcmp ult v0, v0
-    v1 = fcmp ult v0, v0
+    brif v1, block1, block1
-    brnz v1, block1
-    jump block1
 
 block1:
     return

cranelift/filetests/filetests/isa/riscv64/reftypes.clif

@@ -47,8 +47,7 @@ function %f4(r64, r64) -> r64, r64, r64 {
 block0(v0: r64, v1: r64):
     v2 = call fn0(v0)
     stack_store.r64 v0, ss0
-    brz v2, block1(v1, v0)
+    brif v2, block2(v0, v1), block1(v1, v0)
-    jump block2(v0, v1)
 
 block1(v3: r64, v4: r64):
     jump block3(v3, v4)
@@ -77,18 +76,18 @@ block3(v7: r64, v8: r64):
 ;   ld t4,8(nominal_sp)
 ;   sd t4,0(a1)
 ;   andi a1,a0,255
-;   beq a1,zero,taken(label1),not_taken(label3)
+;   bne a1,zero,taken(label1),not_taken(label3)
 ; block1:
 ;   j label2
 ; block2:
-;   mv a1,t4
+;   mv a0,t4
-;   ld a0,16(nominal_sp)
+;   ld a1,16(nominal_sp)
 ;   j label5
 ; block3:
 ;   j label4
 ; block4:
-;   mv a0,t4
+;   mv a1,t4
-;   ld a1,16(nominal_sp)
+;   ld a0,16(nominal_sp)
 ;   j label5
 ; block5:
 ;   load_addr a2,nsp+0

cranelift/filetests/filetests/isa/riscv64/traps.clif

@@ -20,11 +20,11 @@ block0(v0: i64):
 
 ; block0:
 ;   li t2,42
-;   ne a1,a0,t2##ty=i64
+;   eq a1,a0,t2##ty=i64
 ;   bne a1,zero,taken(label1),not_taken(label2)
-; block1:
-;   ret
 ; block2:
+;   ret
+; block1:
 ;   udf##trap_code=user0
 
 function %h() {

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat

@@ -44,16 +44,16 @@
 ;;   uext.w a6,a0
 ;;   ld a7,8(a2)
 ;;   addi a7,a7,-4
-;;   ule a7,a6,a7##ty=i64
+;;   ugt a7,a6,a7##ty=i64
-;;   bne a7,zero,taken(label1),not_taken(label3)
+;;   bne a7,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld a7,0(a2)
-;;   add a7,a7,a6
-;;   sw a1,0(a7)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t3,0(a2)
+;;   add t3,t3,a6
+;;   sw a1,0(t3)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
@@ -61,14 +61,14 @@
 ;;   uext.w a6,a0
 ;;   ld a7,8(a1)
 ;;   addi a7,a7,-4
-;;   ule a7,a6,a7##ty=i64
+;;   ugt a7,a6,a7##ty=i64
-;;   bne a7,zero,taken(label1),not_taken(label3)
+;;   bne a7,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld a7,0(a1)
-;;   add a7,a7,a6
-;;   lw a0,0(a7)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t3,0(a1)
+;;   add t3,t3,a6
+;;   lw a0,0(t3)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -46,18 +46,18 @@
 ;;   lui t4,1048575
 ;;   addi t4,t4,4092
 ;;   add t2,t1,t4
-;;   ule t1,t0,t2##ty=i64
+;;   ugt t1,t0,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t1,0(a2)
-;;   add t1,t1,t0
-;;   lui t0,1
-;;   add t2,t1,t0
-;;   sw a1,0(t2)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t2,0(a2)
+;;   add t2,t2,t0
+;;   lui t1,1
+;;   add a0,t2,t1
+;;   sw a1,0(a0)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
@@ -67,16 +67,16 @@
 ;;   lui t4,1048575
 ;;   addi t4,t4,4092
 ;;   add t2,t1,t4
-;;   ule t1,t0,t2##ty=i64
+;;   ugt t1,t0,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t1,0(a1)
-;;   add t1,t1,t0
-;;   lui t0,1
-;;   add t2,t1,t0
-;;   lw a0,0(t2)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t2,0(a1)
+;;   add t2,t2,t0
+;;   lui t1,1
+;;   add a0,t2,t1
+;;   lw a0,0(a0)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat

@@ -47,18 +47,18 @@
 ;;   ult t2,t1,t0##ty=i64
 ;;   trap_if t2,heap_oob
 ;;   ld t2,8(a2)
-;;   ule t1,t1,t2##ty=i64
+;;   ugt t1,t1,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t2,0(a2)
-;;   add t2,t2,t0
-;;   auipc t1,0; ld t1,12(t1); j 12; .8byte 0xffff0000
-;;   add a0,t2,t1
-;;   sw a1,0(a0)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a0,0(a2)
+;;   add a0,a0,t0
+;;   auipc t2,0; ld t2,12(t2); j 12; .8byte 0xffff0000
+;;   add a2,a0,t2
+;;   sw a1,0(a2)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
@@ -69,16 +69,16 @@
 ;;   ult t2,t1,t0##ty=i64
 ;;   trap_if t2,heap_oob
 ;;   ld t2,8(a1)
-;;   ule t1,t1,t2##ty=i64
+;;   ugt t1,t1,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t2,0(a1)
-;;   add t2,t2,t0
-;;   auipc t1,0; ld t1,12(t1); j 12; .8byte 0xffff0000
-;;   add a0,t2,t1
-;;   lw a0,0(a0)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a0,0(a1)
+;;   add a0,a0,t0
+;;   auipc t2,0; ld t2,12(t2); j 12; .8byte 0xffff0000
+;;   add a1,a0,t2
+;;   lw a0,0(a1)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat

@@ -43,30 +43,30 @@
 ;; block0:
 ;;   uext.w a5,a0
 ;;   ld a6,8(a2)
-;;   ult a6,a5,a6##ty=i64
+;;   uge a6,a5,a6##ty=i64
-;;   bne a6,zero,taken(label1),not_taken(label3)
+;;   bne a6,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld a6,0(a2)
-;;   add a6,a6,a5
-;;   sb a1,0(a6)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a7,0(a2)
+;;   add a7,a7,a5
+;;   sb a1,0(a7)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
 ;; block0:
 ;;   uext.w a5,a0
 ;;   ld a6,8(a1)
-;;   ult a6,a5,a6##ty=i64
+;;   uge a6,a5,a6##ty=i64
-;;   bne a6,zero,taken(label1),not_taken(label3)
+;;   bne a6,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld a6,0(a1)
-;;   add a6,a6,a5
-;;   lbu a0,0(a6)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a7,0(a1)
+;;   add a7,a7,a5
+;;   lbu a0,0(a7)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat

@@ -46,18 +46,18 @@
 ;;   lui t4,1048575
 ;;   addi t4,t4,4095
 ;;   add t2,t1,t4
-;;   ule t1,t0,t2##ty=i64
+;;   ugt t1,t0,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t1,0(a2)
-;;   add t1,t1,t0
-;;   lui t0,1
-;;   add t2,t1,t0
-;;   sb a1,0(t2)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t2,0(a2)
+;;   add t2,t2,t0
+;;   lui t1,1
+;;   add a0,t2,t1
+;;   sb a1,0(a0)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
@@ -67,16 +67,16 @@
 ;;   lui t4,1048575
 ;;   addi t4,t4,4095
 ;;   add t2,t1,t4
-;;   ule t1,t0,t2##ty=i64
+;;   ugt t1,t0,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t1,0(a1)
-;;   add t1,t1,t0
-;;   lui t0,1
-;;   add t2,t1,t0
-;;   lbu a0,0(t2)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t2,0(a1)
+;;   add t2,t2,t0
+;;   lui t1,1
+;;   add a0,t2,t1
+;;   lbu a0,0(a0)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat

@@ -47,18 +47,18 @@
 ;;   ult t2,t1,t0##ty=i64
 ;;   trap_if t2,heap_oob
 ;;   ld t2,8(a2)
-;;   ule t1,t1,t2##ty=i64
+;;   ugt t1,t1,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t2,0(a2)
-;;   add t2,t2,t0
-;;   auipc t1,0; ld t1,12(t1); j 12; .8byte 0xffff0000
-;;   add a0,t2,t1
-;;   sb a1,0(a0)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a0,0(a2)
+;;   add a0,a0,t0
+;;   auipc t2,0; ld t2,12(t2); j 12; .8byte 0xffff0000
+;;   add a2,a0,t2
+;;   sb a1,0(a2)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
@@ -69,16 +69,16 @@
 ;;   ult t2,t1,t0##ty=i64
 ;;   trap_if t2,heap_oob
 ;;   ld t2,8(a1)
-;;   ule t1,t1,t2##ty=i64
+;;   ugt t1,t1,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t2,0(a1)
-;;   add t2,t2,t0
-;;   auipc t1,0; ld t1,12(t1); j 12; .8byte 0xffff0000
-;;   add a0,t2,t1
-;;   lbu a0,0(a0)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a0,0(a1)
+;;   add a0,a0,t0
+;;   auipc t2,0; ld t2,12(t2); j 12; .8byte 0xffff0000
+;;   add a1,a0,t2
+;;   lbu a0,0(a1)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat

@@ -44,16 +44,16 @@
 ;;   uext.w a6,a0
 ;;   ld a7,8(a2)
 ;;   addi a7,a7,-4
-;;   ule a7,a6,a7##ty=i64
+;;   ugt a7,a6,a7##ty=i64
-;;   bne a7,zero,taken(label1),not_taken(label3)
+;;   bne a7,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld a7,0(a2)
-;;   add a7,a7,a6
-;;   sw a1,0(a7)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t3,0(a2)
+;;   add t3,t3,a6
+;;   sw a1,0(t3)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
@@ -61,14 +61,14 @@
 ;;   uext.w a6,a0
 ;;   ld a7,8(a1)
 ;;   addi a7,a7,-4
-;;   ule a7,a6,a7##ty=i64
+;;   ugt a7,a6,a7##ty=i64
-;;   bne a7,zero,taken(label1),not_taken(label3)
+;;   bne a7,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld a7,0(a1)
-;;   add a7,a7,a6
-;;   lw a0,0(a7)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t3,0(a1)
+;;   add t3,t3,a6
+;;   lw a0,0(t3)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat

@@ -46,18 +46,18 @@
 ;;   lui t4,1048575
 ;;   addi t4,t4,4092
 ;;   add t2,t1,t4
-;;   ule t1,t0,t2##ty=i64
+;;   ugt t1,t0,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t1,0(a2)
-;;   add t1,t1,t0
-;;   lui t0,1
-;;   add t2,t1,t0
-;;   sw a1,0(t2)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t2,0(a2)
+;;   add t2,t2,t0
+;;   lui t1,1
+;;   add a0,t2,t1
+;;   sw a1,0(a0)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
@@ -67,16 +67,16 @@
 ;;   lui t4,1048575
 ;;   addi t4,t4,4092
 ;;   add t2,t1,t4
-;;   ule t1,t0,t2##ty=i64
+;;   ugt t1,t0,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t1,0(a1)
-;;   add t1,t1,t0
-;;   lui t0,1
-;;   add t2,t1,t0
-;;   lw a0,0(t2)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld t2,0(a1)
+;;   add t2,t2,t0
+;;   lui t1,1
+;;   add a0,t2,t1
+;;   lw a0,0(a0)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat

@@ -47,18 +47,18 @@
 ;;   ult t2,t1,t0##ty=i64
 ;;   trap_if t2,heap_oob
 ;;   ld t2,8(a2)
-;;   ule t1,t1,t2##ty=i64
+;;   ugt t1,t1,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t2,0(a2)
-;;   add t2,t2,t0
-;;   auipc t1,0; ld t1,12(t1); j 12; .8byte 0xffff0000
-;;   add a0,t2,t1
-;;   sw a1,0(a0)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a0,0(a2)
+;;   add a0,a0,t0
+;;   auipc t2,0; ld t2,12(t2); j 12; .8byte 0xffff0000
+;;   add a2,a0,t2
+;;   sw a1,0(a2)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
@@ -69,16 +69,16 @@
 ;;   ult t2,t1,t0##ty=i64
 ;;   trap_if t2,heap_oob
 ;;   ld t2,8(a1)
-;;   ule t1,t1,t2##ty=i64
+;;   ugt t1,t1,t2##ty=i64
-;;   bne t1,zero,taken(label1),not_taken(label3)
+;;   bne t1,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld t2,0(a1)
-;;   add t2,t2,t0
-;;   auipc t1,0; ld t1,12(t1); j 12; .8byte 0xffff0000
-;;   add a0,t2,t1
-;;   lw a0,0(a0)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a0,0(a1)
+;;   add a0,a0,t0
+;;   auipc t2,0; ld t2,12(t2); j 12; .8byte 0xffff0000
+;;   add a1,a0,t2
+;;   lw a0,0(a1)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob

cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat

@@ -43,30 +43,30 @@
 ;; block0:
 ;;   uext.w a5,a0
 ;;   ld a6,8(a2)
-;;   ult a6,a5,a6##ty=i64
+;;   uge a6,a5,a6##ty=i64
-;;   bne a6,zero,taken(label1),not_taken(label3)
+;;   bne a6,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld a6,0(a2)
-;;   add a6,a6,a5
-;;   sb a1,0(a6)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a7,0(a2)
+;;   add a7,a7,a5
+;;   sb a1,0(a7)
+;;   j label3
 ;; block3:
+;;   ret
+;; block1:
 ;;   udf##trap_code=heap_oob
 ;;
 ;; function u0:1:
 ;; block0:
 ;;   uext.w a5,a0
 ;;   ld a6,8(a1)
-;;   ult a6,a5,a6##ty=i64
+;;   uge a6,a5,a6##ty=i64
-;;   bne a6,zero,taken(label1),not_taken(label3)
+;;   bne a6,zero,taken(label1),not_taken(label2)
-;; block1:
-;;   ld a6,0(a1)
-;;   add a6,a6,a5
-;;   lbu a0,0(a6)
-;;   j label2
 ;; block2:
-;;   ret
+;;   ld a7,0(a1)
+;;   add a7,a7,a5
+;;   lbu a0,0(a7)
+;;   j label3
 ;; block3:
-;;   udf##trap_code=heap_oob
+;;   ret
+;; block1:
+;;   udf##trap_code=heap_oob