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 ABICallee<I = I>>,
    emit_info: I::Info,
    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) -> &mut dyn ABICallee<I = I>

Get the ABICallee.

fn retval(&self, idx: usize) -> ValueRegs<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 get_vm_context(&self) -> Option<Reg>

Returns the vreg containing the VmContext parameter, if there’s one.

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 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_as_source_or_const(&self, ir_inst: Inst, idx: usize) -> NonRegInput

Get the input as one of two options other than a direct register:

fn put_input_in_regs(&mut self, ir_inst: Inst, idx: usize) -> ValueRegs<Reg>

Put the idxth input into register(s) and return the assigned register.

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

Get the idxth output register(s) 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, ty: Type) -> ValueRegs<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 sink_inst(&mut self, ir_inst: Inst)

Indicate that the side-effect of an instruction has been sunk to the current scan location. This should only be done with the instruction’s original results are not used (i.e., put_input_in_regs is not invoked for the input produced by the sunk instruction), otherwise the side-effect will occur twice.

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

Retrieve constant data given a handle.

fn use_constant(&mut self, constant: VCodeConstantData) -> VCodeConstant

Indicate that a constant should be emitted.

fn get_immediate(&self, ir_inst: Inst) -> Option<DataValue>

Retrieve the value immediate from an instruction. This will perform necessary lookups on the DataFlowGraph to retrieve even large immediates.

fn ensure_in_vreg(&mut self, reg: Reg, ty: Type) -> Reg

Cause the value in reg to be in a virtual reg, by copying it into a new virtual reg if reg is a real reg. ty describes the type of the value in reg.