Trait cranelift_codegen::isa::TargetIsa[−][src]

pub trait TargetIsa: Display {
    fn name(&self) -> &'static str;

    fn triple(&self) -> &Triple;

    fn flags(&self) -> &Flags;

    fn register_info(&self) -> RegInfo;

    fn legal_encodings<'a>(
        &'a self, 
        func: &'a Function, 
        inst: &'a InstructionData, 
        ctrl_typevar: Type
    ) -> Encodings<'a>;

    fn encoding_info(&self) -> EncInfo;

    fn legalize_signature(&self, sig: &mut Signature, current: bool);

    fn regclass_for_abi_type(&self, ty: Type) -> RegClass;

    fn allocatable_registers(&self, func: &Function) -> RegisterSet;

    fn emit_inst(
        &self, 
        func: &Function, 
        inst: Inst, 
        divert: &mut RegDiversions, 
        sink: &mut CodeSink
    );

    fn emit_function_to_memory(
        &self, 
        func: &Function, 
        sink: &mut MemoryCodeSink
    );

    fn pointer_type(&self) -> Type { ... }

    fn pointer_bits(&self) -> u8 { ... }

    fn pointer_bytes(&self) -> u8 { ... }

    fn uses_cpu_flags(&self) -> bool { ... }

    fn uses_complex_addresses(&self) -> bool { ... }

    fn encode(
        &self, 
        func: &Function, 
        inst: &InstructionData, 
        ctrl_typevar: Type
    ) -> Result<Encoding, Legalize> { ... }

    fn prologue_epilogue(&self, func: &mut Function) -> CodegenResult<()> { ... }
}

Methods that are specialized to a target ISA. Implies a Display trait that shows the shared flags, as well as any isa-specific flags.

Required Methods

Get the name of this ISA.

Get the target triple that was used to make this trait object.

Get the ISA-independent flags that were used to make this trait object.

Get a data structure describing the registers in this ISA.

Returns an iterartor over legal encodings for the instruction.

Get a data structure describing the instruction encodings in this ISA.

Legalize a function signature.

This is used to legalize both the signature of the function being compiled and any called functions. The signature should be modified by adding ArgumentLoc annotations to all arguments and return values.

Arguments with types that are not supported by the ABI can be expanded into multiple arguments:

  • Integer types that are too large to fit in a register can be broken into multiple arguments of a smaller integer type.
  • Floating point types can be bit-cast to an integer type of the same size, and possible broken into smaller integer types.
  • Vector types can be bit-cast and broken down into smaller vectors or scalars.

The legalizer will adapt argument and return values as necessary at all ABI boundaries.

When this function is called to legalize the signature of the function currently being compiled, current is true. The legalized signature can then also contain special purpose arguments and return values such as:

  • A link argument representing the link registers on RISC architectures that don't push the return address on the stack.
  • A link return value which will receive the value that was passed to the link argument.
  • An sret argument can be added if one wasn't present already. This is necessary if the signature returns more values than registers are available for returning values.
  • An sret return value can be added if the ABI requires a function to return its sret argument in a register.

Arguments and return values for the caller's frame pointer and other callee-saved registers should not be added by this function. These arguments are not added until after register allocation.

Get the register class that should be used to represent an ABI argument or return value of type ty. This should be the top-level register class that contains the argument registers.

This function can assume that it will only be asked to provide register classes for types that legalize_signature() produces in ArgumentLoc::Reg entries.

Get the set of allocatable registers that can be used when compiling func.

This set excludes reserved registers like the stack pointer and other special-purpose registers.

Emit binary machine code for a single instruction into the sink trait object.

Note that this will call put* methods on the sink trait object via its vtable which is not the fastest way of emitting code.

Emit a whole function into memory.

This is more performant than calling emit_inst for each instruction.

Provided Methods

Get the pointer type of this ISA.

Get the width of pointers on this ISA, in units of bits.

Get the width of pointers on this ISA, in units of bytes.

Does the CPU implement scalar comparisons using a CPU flags register?

Does the CPU implement multi-register addressing?

Encode an instruction after determining it is legal.

If inst can legally be encoded in this ISA, produce the corresponding Encoding object. Otherwise, return Legalize action.

This is also the main entry point for determining if an instruction is legal.

Compute the stack layout and insert prologue and epilogue code into func.

Return an error if the stack frame is too large.

Trait Implementations

impl<'a> From<&'a TargetIsa> for FlagsOrIsa<'a>
[src]

Performs the conversion.

Implementors