Enum EmitError 

#[non_exhaustive]
pub enum EmitError {
    Mir(MirError),
    Frame(FrameError),
    Moves(MoveError),
    UnsupportedTarget,
    VirtualRegister {
        block: Block,
        inst: Option<Inst>,
    },
    TiedMismatch {
        inst: Inst,
    },
    ReservedWrite {
        block: Block,
        inst: Option<Inst>,
    },
    Unencodable {
        inst: Option<Inst>,
    },
    Encode {
        inst: Option<Inst>,
        error: EncodeError,
    },
    Asm(AsmError),
    UndefinedSymbol(String),
    DuplicateSymbol(String),
    ProbeScratch,
}

Why a function could not be emitted.

Examples

use backend_lang::mir::{Function, Operand};
use backend_lang::x86_64::{op, EmitError, GPR, SYSV};

// Emission needs physical registers: run register allocation first.
let mut f = Function::new("f", &SYSV);
let b = f.block()?;
let v = f.vreg(GPR)?;
f.push(b, op::MOV64RI, &[v.into(), Operand::Imm(1)])?;
f.push(b, op::RET, &[])?;
let err = backend_lang::emit(&f).unwrap_err();
assert!(matches!(err, EmitError::VirtualRegister { .. }));

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Mir(MirError)

The function is malformed (Function::verify fails).

Frame(FrameError)

The frame cannot be laid out.

Moves(MoveError)

A parallel copy cannot be resolved.

UnsupportedTarget

The function’s target is not this crate’s x86-64 description (a custom Target must reuse its register and instruction tables to be emitted by this emitter).

VirtualRegister

A virtual register remains (in an instruction, or, with inst absent, in a block parameter). Emission runs after register allocation.

Fields

block: Block

The block.

inst: Option<Inst>

The instruction, if not a parameter.

TiedMismatch

A tied use is not the same register as its definition. The register allocator must give them one register (or insert a copy).

Fields

inst: Inst

The instruction.

ReservedWrite

The body writes the stack pointer, or the frame pointer while it is kept (in an instruction, or, with inst absent, as a block parameter). The frame owns both.

Fields

block: Block

The block.

inst: Option<Inst>

The instruction, if not a parameter.

Unencodable

The operation needs an instruction isa-lang 0.2 does not encode: a move of a vector register, or a Win64 prologue saving one. (With inst absent: a prologue, epilogue, or edge move.)

Fields

inst: Option<Inst>

The instruction, if one.

Encode

isa-lang refused an instruction (with inst absent: a prologue, epilogue, or edge move).

Fields

inst: Option<Inst>

The instruction, if one.

error: EncodeError

isa-lang’s reason.

Asm(AsmError)

The assembler failed (code beyond 2 GiB, or a label error).

UndefinedSymbol(String)

A function was called (or its address taken) but never emitted.

DuplicateSymbol(String)

Two functions with one name were emitted.

ProbeScratch

A frame large enough to need a probe loop takes its counter in r11 or r10, and the entry block receives values in both.

Trait Implementations

impl Clone for EmitError

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EmitError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for EmitError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for EmitError

impl Error for EmitError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<FrameError> for EmitError

fn from(e: FrameError) -> EmitError

Converts to this type from the input type.

impl From<MirError> for EmitError

fn from(e: MirError) -> EmitError

Converts to this type from the input type.

impl From<MoveError> for EmitError

fn from(e: MoveError) -> EmitError

Converts to this type from the input type.

impl PartialEq for EmitError

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for EmitError