Struct cranelift_codegen::machinst::lower::Lower

pub struct Lower<'func, I: VCodeInst> { /* fields omitted */ }

Machine-independent lowering driver / machine-instruction container. Maintains a correspondence from original Inst to MachInsts.

Implementations

impl<'func, I: VCodeInst> Lower<'func, I>

pub fn new(
    f: &'func Function,
    abi: Box<dyn ABIBody<I = I>>,
    block_order: BlockLoweringOrder
) -> CodegenResult<Lower<'func, I>>

Prepare a new lowering context for the given IR function.

pub fn lower<B: LowerBackend<MInst = I>>(
    self,
    backend: &B
) -> CodegenResult<(VCode<I>, StackmapRequestInfo)>

Lower the function.

Trait Implementations

impl<'func, I: VCodeInst> LowerCtx for Lower<'func, I>

type I = I

The instruction type for which this lowering framework is instantiated.

fn abi(&mut self) -> &dyn ABIBody<I = I>

Get the ABIBody.

fn retval(&self, idx: usize) -> Writable<Reg>

Get the (virtual) register that receives the return value. A return instruction should lower into a sequence that fills this register. (Why not allow the backend to specify its own result register for the return? Because there may be multiple return points.)

fn data(&self, ir_inst: Inst) -> &InstructionData

Get the instdata for a given IR instruction.

fn ty(&self, ir_inst: Inst) -> Type

Get the controlling type for a polymorphic IR instruction.

fn call_target<'b>(
    &'b self,
    ir_inst: Inst
) -> Option<(&'b ExternalName, RelocDistance)>

Get the target for a call instruction, as an ExternalName. Returns a tuple providing this name and the “relocation distance”, i.e., whether the backend can assume the target will be “nearby” (within some small offset) or an arbitrary address. (This comes from the colocated bit in the CLIF.)

fn call_sig<'b>(&'b self, ir_inst: Inst) -> Option<&'b Signature>

Get the signature for a call or call-indirect instruction.

fn symbol_value<'b>(
    &'b self,
    ir_inst: Inst
) -> Option<(&'b ExternalName, RelocDistance, i64)>

Get the symbol name, relocation distance estimate, and offset for a symbol_value instruction.

fn memflags(&self, ir_inst: Inst) -> Option<MemFlags>

Returns the memory flags of a given memory access.

fn srcloc(&self, ir_inst: Inst) -> SourceLoc

Get the source location for a given instruction.

fn inst_color(&self, ir_inst: Inst) -> InstColor

Get the side-effect color of the given instruction (specifically, at the program point just prior to the instruction). The “color” changes at every side-effecting op; the backend should not try to merge across side-effect colors unless the op being merged is known to be pure.

fn num_inputs(&self, ir_inst: Inst) -> usize

Get the number of inputs to the given IR instruction.

fn num_outputs(&self, ir_inst: Inst) -> usize

Get the number of outputs to the given IR instruction.

fn input_ty(&self, ir_inst: Inst, idx: usize) -> Type

Get the type for an instruction’s input.

fn output_ty(&self, ir_inst: Inst, idx: usize) -> Type

Get the type for an instruction’s output.

fn get_constant(&self, ir_inst: Inst) -> Option<u64>

Get the value of a constant instruction (iconst, etc.) as a 64-bit value, if possible.

fn get_input(&self, ir_inst: Inst, idx: usize) -> LowerInput

Get the input in any combination of three forms:

fn get_output(&self, ir_inst: Inst, idx: usize) -> Writable<Reg>

Get the idxth output register of the given IR instruction. When backend.lower_inst_to_regs(ctx, inst) is called, it is expected that the backend will write results to these output register(s). This register will always be “fresh”; it is guaranteed not to overlap with any of the inputs, and can be freely used as a scratch register within the lowered instruction sequence, as long as its final value is the result of the computation.

fn alloc_tmp(&mut self, rc: RegClass, ty: Type) -> Writable<Reg>

Get a new temp.

fn emit(&mut self, mach_inst: I)

Emit a machine instruction.

fn emit_safepoint(&mut self, mach_inst: I)

Emit a machine instruction that is a safepoint.

fn use_input_reg(&mut self, input: LowerInput)

Indicate that the given input uses the register returned by get_input(). Codegen may not happen otherwise for the producing instruction if it has no side effects and no uses.

fn is_reg_needed(&self, ir_inst: Inst, reg: Reg) -> bool

Is the given register output needed after the given instruction? Allows instructions with multiple outputs to make fine-grained decisions on which outputs to actually generate.

fn get_constant_data(&self, constant_handle: Constant) -> &ConstantData

Retrieve constant data given a handle.