832666c45e
* Manually rename BasicBlock to BlockPredecessor BasicBlock is a pair of (Ebb, Inst) that is used to represent the basic block subcomponent of an Ebb that is a predecessor to an Ebb. Eventually we will be able to remove this struct, but for now it makes sense to give it a non-conflicting name so that we can start to transition Ebb to represent a basic block. I have not updated any comments that refer to BasicBlock, as eventually we will remove BlockPredecessor and replace with Block, which is a basic block, so the comments will become correct. * Manually rename SSABuilder block types to avoid conflict SSABuilder has its own Block and BlockData types. These along with associated identifier will cause conflicts in a later commit, so they are renamed to be more verbose here. * Automatically rename 'Ebb' to 'Block' in *.rs * Automatically rename 'EBB' to 'block' in *.rs * Automatically rename 'ebb' to 'block' in *.rs * Automatically rename 'extended basic block' to 'basic block' in *.rs * Automatically rename 'an basic block' to 'a basic block' in *.rs * Manually update comment for `Block` `Block`'s wikipedia article required an update. * Automatically rename 'an `Block`' to 'a `Block`' in *.rs * Automatically rename 'extended_basic_block' to 'basic_block' in *.rs * Automatically rename 'ebb' to 'block' in *.clif * Manually rename clif constant that contains 'ebb' as substring to avoid conflict * Automatically rename filecheck uses of 'EBB' to 'BB' 'regex: EBB' -> 'regex: BB' '$EBB' -> '$BB' * Automatically rename 'EBB' 'Ebb' to 'block' in *.clif * Automatically rename 'an block' to 'a block' in *.clif * Fix broken testcase when function name length increases Test function names are limited to 16 characters. This causes the new longer name to be truncated and fail a filecheck test. An outdated comment was also fixed.
74 lines
2.7 KiB
Rust
74 lines
2.7 KiB
Rust
use crate::cdsl::operands::{OperandKind, OperandKindFields};
|
|
|
|
/// Small helper to initialize an OperandBuilder with the right kind, for a given name and doc.
|
|
fn new(format_field_name: &'static str, rust_type: &'static str, doc: &'static str) -> OperandKind {
|
|
OperandKind::new(format_field_name, rust_type, OperandKindFields::EntityRef).with_doc(doc)
|
|
}
|
|
|
|
pub(crate) struct EntityRefs {
|
|
/// A reference to a basic block in the same function.
|
|
/// This is primarliy used in control flow instructions.
|
|
pub(crate) block: OperandKind,
|
|
|
|
/// A reference to a stack slot declared in the function preamble.
|
|
pub(crate) stack_slot: OperandKind,
|
|
|
|
/// A reference to a global value.
|
|
pub(crate) global_value: OperandKind,
|
|
|
|
/// A reference to a function signature declared in the function preamble.
|
|
/// This is used to provide the call signature in a call_indirect instruction.
|
|
pub(crate) sig_ref: OperandKind,
|
|
|
|
/// A reference to an external function declared in the function preamble.
|
|
/// This is used to provide the callee and signature in a call instruction.
|
|
pub(crate) func_ref: OperandKind,
|
|
|
|
/// A reference to a jump table declared in the function preamble.
|
|
pub(crate) jump_table: OperandKind,
|
|
|
|
/// A reference to a heap declared in the function preamble.
|
|
pub(crate) heap: OperandKind,
|
|
|
|
/// A reference to a table declared in the function preamble.
|
|
pub(crate) table: OperandKind,
|
|
|
|
/// A variable-sized list of value operands. Use for Block and function call arguments.
|
|
pub(crate) varargs: OperandKind,
|
|
}
|
|
|
|
impl EntityRefs {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
block: new(
|
|
"destination",
|
|
"ir::Block",
|
|
"a basic block in the same function.",
|
|
),
|
|
stack_slot: new("stack_slot", "ir::StackSlot", "A stack slot"),
|
|
|
|
global_value: new("global_value", "ir::GlobalValue", "A global value."),
|
|
|
|
sig_ref: new("sig_ref", "ir::SigRef", "A function signature."),
|
|
|
|
func_ref: new("func_ref", "ir::FuncRef", "An external function."),
|
|
|
|
jump_table: new("table", "ir::JumpTable", "A jump table."),
|
|
|
|
heap: new("heap", "ir::Heap", "A heap."),
|
|
|
|
table: new("table", "ir::Table", "A table."),
|
|
|
|
varargs: OperandKind::new("", "&[Value]", OperandKindFields::VariableArgs).with_doc(
|
|
r#"
|
|
A variable size list of `value` operands.
|
|
|
|
Use this to represent arguments passed to a function call, arguments
|
|
passed to a basic block, or a variable number of results
|
|
returned from an instruction.
|
|
"#,
|
|
),
|
|
}
|
|
}
|
|
}
|