66 lines
2.5 KiB
Rust
66 lines
2.5 KiB
Rust
use crate::cdsl::operands::{OperandKind, OperandKindBuilder as Builder, OperandKindFields};
|
|
|
|
/// Small helper to initialize an OperandBuilder with the right kind, for a given name and doc.
|
|
fn create(name: &'static str, doc: &'static str) -> Builder {
|
|
Builder::new(name, OperandKindFields::EntityRef).doc(doc)
|
|
}
|
|
|
|
pub fn define() -> Vec<OperandKind> {
|
|
let mut kinds = Vec::new();
|
|
|
|
// A reference to an extended basic block in the same function.
|
|
// This is primarliy used in control flow instructions.
|
|
let ebb = create("ebb", "An extended basic block in the same function.")
|
|
.default_member("destination")
|
|
.finish();
|
|
kinds.push(ebb);
|
|
|
|
// A reference to a stack slot declared in the function preamble.
|
|
let stack_slot = create("stack_slot", "A stack slot").finish();
|
|
kinds.push(stack_slot);
|
|
|
|
// A reference to a global value.
|
|
let global_value = create("global_value", "A global value.").finish();
|
|
kinds.push(global_value);
|
|
|
|
// A reference to a function signature declared in the function preamble.
|
|
// This is used to provide the call signature in a call_indirect instruction.
|
|
let sig_ref = create("sig_ref", "A function signature.").finish();
|
|
kinds.push(sig_ref);
|
|
|
|
// A reference to an external function declared in the function preamble.
|
|
// This is used to provide the callee and signature in a call instruction.
|
|
let func_ref = create("func_ref", "An external function.").finish();
|
|
kinds.push(func_ref);
|
|
|
|
// A reference to a jump table declared in the function preamble.
|
|
let jump_table = create("jump_table", "A jump table.")
|
|
.default_member("table")
|
|
.finish();
|
|
kinds.push(jump_table);
|
|
|
|
// A reference to a heap declared in the function preamble.
|
|
let heap = create("heap", "A heap.").finish();
|
|
kinds.push(heap);
|
|
|
|
// A reference to a table declared in the function preamble.
|
|
let table = create("table", "A table.").finish();
|
|
kinds.push(table);
|
|
|
|
// A variable-sized list of value operands. Use for Ebb and function call arguments.
|
|
let varargs = Builder::new("variable_args", OperandKindFields::VariableArgs)
|
|
.doc(
|
|
r#"
|
|
A variable size list of `value` operands.
|
|
|
|
Use this to represent arguments passed to a function call, arguments
|
|
passed to an extended basic block, or a variable number of results
|
|
returned from an instruction.
|
|
"#,
|
|
)
|
|
.finish();
|
|
kinds.push(varargs);
|
|
|
|
return kinds;
|
|
}
|