Cranelift: add get_exception_handler_address.

This is designed to enable applications such as bytecodealliance#11592 that use
alternative unwinding mechanisms that may not necessarily want to walk a
stack and look up exception tables. The idea is that whenever it would
be valid to resume to an exception handler that is active on the stack,
we can provide the same PC as a first-class runtime value that would be
found in the exception table for the given handler edge. A "custom"
resume step can then use this PC as a resume-point as long as it follows
the relevant exception ABI (i.e.: restore SP, FP, any other saved
registers that the exception ABI specifies, and provide appropriate
payload value(s)).

Handlers are associated with edges out of `try_call`s (or
`try_call_indirect`s); and edges specifically, not blocks, because there
could be multiple out-edges to one block. The instruction thus takes the
block that contains the try-call and an immediate that indexes its
exceptional edges.

This CLIF instruction required a bit of infrastructure to (i) allow
naming raw blocks, not just block calls, as instruction arguments, and
(ii) allow getting the MachLabel for any other lowered block during
lowering. But given that, the lowerings themselves are straightforward
uses of MachBuffer labels to fix-up PC-relative address-loading
instructions (e.g., `LEA` or `ADR` or `AUIPC`+`ADDI`).

Author: cfallin

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

@@ -40,6 +40,8 @@ pub(crate) struct InstructionFormat {
 
     pub num_block_operands: usize,
 
+    pub num_raw_block_operands: usize,
+
     /// Index of the value input operand that is used to infer the controlling type variable. By
     /// default, this is `0`, the first `value` operand. The index is relative to the values only,
     /// ignoring immediate operands.
@@ -52,6 +54,7 @@ pub(crate) struct FormatStructure {
     pub num_value_operands: usize,
     pub has_value_list: bool,
     pub num_block_operands: usize,
+    pub num_raw_block_operands: usize,
     /// Tuples of (Rust field name / Rust type) for each immediate field.
     pub imm_field_names: Vec<(&'static str, &'static str)>,
 }
@@ -65,8 +68,12 @@ impl fmt::Display for InstructionFormat {
             .collect::<Vec<_>>()
             .join(", ");
         fmt.write_fmt(format_args!(
-            "{}(imms=({}), vals={}, blocks={})",
-            self.name, imm_args, self.num_value_operands, self.num_block_operands,
+            "{}(imms=({}), vals={}, blocks={}, raw_blocks={})",
+            self.name,
+            imm_args,
+            self.num_value_operands,
+            self.num_block_operands,
+            self.num_raw_block_operands,
         ))?;
         Ok(())
     }
@@ -79,6 +86,7 @@ impl InstructionFormat {
             num_value_operands: self.num_value_operands,
             has_value_list: self.has_value_list,
             num_block_operands: self.num_block_operands,
+            num_raw_block_operands: self.num_raw_block_operands,
             imm_field_names: self
                 .imm_fields
                 .iter()
@@ -97,6 +105,7 @@ impl InstructionFormatBuilder {
             num_value_operands: 0,
             has_value_list: false,
             num_block_operands: 0,
+            num_raw_block_operands: 0,
             imm_fields: Vec::new(),
             typevar_operand: None,
         })
@@ -117,6 +126,11 @@ impl InstructionFormatBuilder {
         self
     }
 
+    pub fn raw_block(mut self) -> Self {
+        self.0.num_raw_block_operands += 1;
+        self
+    }
+
     pub fn imm(mut self, operand_kind: &OperandKind) -> Self {
         let field = FormatField {
             kind: operand_kind.clone(),

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

@@ -288,6 +288,7 @@ fn verify_format(inst_name: &str, operands_in: &[Operand], format: &InstructionF
     // - whether it has a value list or not.
     let mut num_values = 0;
     let mut num_blocks = 0;
+    let mut num_raw_blocks = 0;
     let mut num_immediates = 0;
 
     for operand in operands_in.iter() {
@@ -304,6 +305,8 @@ fn verify_format(inst_name: &str, operands_in: &[Operand], format: &InstructionF
         }
         if operand.kind.is_block() {
             num_blocks += 1;
+        } else if operand.kind.is_raw_block() {
+            num_raw_blocks += 1;
         } else if operand.is_immediate_or_entityref() {
             if let Some(format_field) = format.imm_fields.get(num_immediates) {
                 assert_eq!(
@@ -335,6 +338,13 @@ fn verify_format(inst_name: &str, operands_in: &[Operand], format: &InstructionF
         inst_name, format.name,
     );
 
+    assert_eq!(
+        num_raw_blocks, format.num_raw_block_operands,
+        "inst {} doesn't have as many raw-block input operands as its format {} declares; you may need \
+         to use a different format.",
+        inst_name, format.name,
+    );
+
     assert_eq!(
         num_immediates,
         format.imm_fields.len(),

cranelift/codegen/meta/src/cdsl/operands.rs

@@ -150,6 +150,10 @@ impl OperandKind {
     pub(crate) fn is_block(&self) -> bool {
         self.rust_type == "ir::BlockCall"
     }
+
+    pub(crate) fn is_raw_block(&self) -> bool {
+        self.rust_type == "ir::Block"
+    }
 }
 
 impl From<&TypeVar> for OperandKind {

cranelift/codegen/meta/src/gen_inst.rs

@@ -87,6 +87,12 @@ fn gen_instruction_data(formats: &[Rc<InstructionFormat>], fmt: &mut Formatter)
                     n => panic!("Too many block operands in instruction: {n}"),
                 }
 
+                match format.num_raw_block_operands {
+                    0 => (),
+                    1 => fmt.line("block: ir::Block,"),
+                    n => panic!("Too many block operands in instruction: {n}"),
+                }
+
                 for field in &format.imm_fields {
                     fmtln!(fmt, "{}: {},", field.member, field.kind.rust_type);
                 }
@@ -249,6 +255,15 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         }
                     };
 
+                    let raw_blocks_eq = match format.num_raw_block_operands {
+                        0 => None,
+                        1 => {
+                            members.push("block");
+                            Some("block1 == block2")
+                        }
+                        _ => unreachable!("Not a valid format"),
+                    };
+
                     for field in &format.imm_fields {
                         members.push(field.member);
                     }
@@ -266,6 +281,9 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         if let Some(blocks_eq) = blocks_eq {
                             fmtln!(fmt, "&& {}", blocks_eq);
                         }
+                        if let Some(raw_blocks_eq) = raw_blocks_eq {
+                            fmtln!(fmt, "&& {}", raw_blocks_eq);
+                        }
                     });
                 }
                 fmt.line("_ => unreachable!()");
@@ -314,6 +332,15 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         }
                     };
 
+                    let raw_block = match format.num_raw_block_operands {
+                        0 => None,
+                        1 => {
+                            members.push("block");
+                            Some("block")
+                        }
+                        _ => panic!("Too many raw block operands"),
+                    };
+
                     for field in &format.imm_fields {
                         members.push(field.member);
                     }
@@ -341,6 +368,10 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                                 });
                             });
                         }
+
+                        if let Some(raw_block) = raw_block {
+                            fmtln!(fmt, "::core::hash::Hash::hash(&{raw_block}, state);");
+                        }
                     });
                 }
             });
@@ -378,6 +409,14 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         }
                     };
 
+                    match format.num_raw_block_operands {
+                        0 => {}
+                        1 => {
+                            members.push("block");
+                        }
+                        _ => panic!("Too many raw-block operands to format"),
+                    }
+
                     for field in &format.imm_fields {
                         members.push(field.member);
                     }
@@ -406,6 +445,14 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                                 _ => panic!("Too many block targets in instruction"),
                             }
 
+                            match format.num_raw_block_operands {
+                                0 => {}
+                                1 => {
+                                    fmtln!(fmt, "block,");
+                                }
+                                _ => panic!("Too many raw-block operands in instruction"),
+                            }
+
                             for field in &format.imm_fields {
                                 fmtln!(fmt, "{},", field.member);
                             }
@@ -442,6 +489,14 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         }
                     };
 
+                    match format.num_raw_block_operands {
+                        0 => {}
+                        1 => {
+                            members.push("block");
+                        }
+                        _ => panic!("Too many raw-block operands"),
+                    }
+
                     for field in &format.imm_fields {
                         members.push(field.member);
                     }
@@ -474,6 +529,14 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                                 _ => panic!("Too many block targets in instruction"),
                             }
 
+                            match format.num_raw_block_operands {
+                                0 => {}
+                                1 => {
+                                    fmtln!(fmt, "block: mapper.map_block(block),");
+                                }
+                                _ => panic!("Too many raw block arguments in instruction"),
+                            }
+
                             for field in &format.imm_fields {
                                 let member = field.member;
                                 match &field.kind.fields {
@@ -958,6 +1021,13 @@ fn gen_member_inits(format: &InstructionFormat, fmt: &mut Formatter) {
             fmtln!(fmt, "blocks: [{}],", blocks.join(", "));
         }
     }
+
+    // Raw block operands.
+    match format.num_raw_block_operands {
+        0 => (),
+        1 => fmt.line("block: block0,"),
+        _ => panic!("Too many raw block arguments"),
+    }
 }
 
 /// Emit a method for creating and inserting an instruction format.
@@ -972,6 +1042,9 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
         "ctrl_typevar: Type".into(),
     ];
 
+    // Raw block operands.
+    args.extend((0..format.num_raw_block_operands).map(|i| format!("block{i}: ir::Block")));
+
     // Normal operand arguments. Start with the immediate operands.
     for f in &format.imm_fields {
         args.push(format!("{}: {}", f.member, f.kind.rust_type));
@@ -1074,6 +1147,9 @@ fn gen_inst_builder(inst: &Instruction, format: &InstructionFormat, fmt: &mut Fo
             args_doc.push(format!("- {}_args: {}", op.name, "Block arguments"));
 
             block_args.push(op);
+        } else if op.kind.is_raw_block() {
+            args.push("block: ir::Block".into());
+            args_doc.push("- block: raw basic block".into());
         } else {
             let t = if op.is_immediate() {
                 let t = format!("T{}", tmpl_types.len() + 1);

cranelift/codegen/meta/src/gen_isle.rs

@@ -142,6 +142,10 @@ fn gen_common_isle(
         fmt.empty_line();
     }
 
+    // Raw block entities.
+    fmtln!(fmt, "(type Block extern (enum))");
+    fmt.empty_line();
+
     // Generate the extern type declaration for `Opcode`.
     fmt.line(";;;; `Opcode` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
     fmt.empty_line();
@@ -184,6 +188,12 @@ fn gen_common_isle(
                     n => write!(&mut s, " (blocks BlockArray{n})").unwrap(),
                 }
 
+                match format.num_raw_block_operands {
+                    0 => (),
+                    1 => write!(&mut s, "(block Block)").unwrap(),
+                    _ => panic!("Too many raw block arguments"),
+                }
+
                 for field in &format.imm_fields {
                     write!(
                         &mut s,
@@ -322,7 +332,9 @@ fn gen_common_isle(
             let imm_operands: Vec<_> = inst
                 .operands_in
                 .iter()
-                .filter(|o| !o.is_value() && !o.is_varargs() && !o.kind.is_block())
+                .filter(|o| {
+                    !o.is_value() && !o.is_varargs() && !o.kind.is_block() && !o.kind.is_raw_block()
+                })
                 .collect();
             assert_eq!(imm_operands.len(), inst.format.imm_fields.len(),);
             for op in imm_operands {
@@ -353,6 +365,15 @@ fn gen_common_isle(
                 }
             }
 
+            // Raw blocks.
+            match inst.format.num_raw_block_operands {
+                0 => {}
+                1 => {
+                    write!(&mut s, " block").unwrap();
+                }
+                _ => panic!("Too many raw block arguments"),
+            }
+
             s.push_str("))");
             fmt.line(&s);
         });
@@ -441,12 +462,18 @@ fn gen_common_isle(
                     }
                 }
 
+                match inst.format.num_raw_block_operands {
+                    0 => {}
+                    1 => {
+                        write!(&mut s, " block").unwrap();
+                    }
+                    _ => panic!("Too many raw block arguments"),
+                }
+
                 // Immediates (non-value args).
-                for o in inst
-                    .operands_in
-                    .iter()
-                    .filter(|o| !o.is_value() && !o.is_varargs() && !o.kind.is_block())
-                {
+                for o in inst.operands_in.iter().filter(|o| {
+                    !o.is_value() && !o.is_varargs() && !o.kind.is_block() && !o.kind.is_raw_block()
+                }) {
                     write!(&mut s, " {}", o.name).unwrap();
                 }
                 s.push_str("))");

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

@@ -23,6 +23,11 @@ pub(crate) struct EntityRefs {
     /// This is primarily used in control flow instructions.
     pub(crate) block_else: OperandKind,
 
+    /// A reference to a basic block in the same function, without any arguments.
+    /// This is primarily used to refer to block `try_call` terminators to get
+    /// exception metadata (e.g., resume PCs) as first-class values.
+    pub(crate) raw_block: OperandKind,
+
     /// A reference to a stack slot declared in the function preamble.
     pub(crate) stack_slot: OperandKind,
 
@@ -84,6 +89,12 @@ impl EntityRefs {
                 "a basic block in the same function, with its arguments provided.",
             ),
 
+            raw_block: new(
+                "raw_block",
+                "ir::Block",
+                "a basic block in the same function, with no arguments provided.",
+            ),
+
             stack_slot: new("stack_slot", "ir::StackSlot", "A stack slot"),
 
             dynamic_stack_slot: new(

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

@@ -42,6 +42,7 @@ pub(crate) struct Formats {
     pub(crate) unary_ieee32: Rc<InstructionFormat>,
     pub(crate) unary_ieee64: Rc<InstructionFormat>,
     pub(crate) unary_imm: Rc<InstructionFormat>,
+    pub(crate) exception_handler_address: Rc<InstructionFormat>,
 }
 
 impl Formats {
@@ -219,6 +220,11 @@ impl Formats {
                 .value()
                 .imm(&imm.trapcode)
                 .build(),
+
+            exception_handler_address: Builder::new("ExceptionHandlerAddress")
+                .raw_block()
+                .imm(&imm.imm64)
+                .build(),
         }
     }
 }