Enum MirError 

#[non_exhaustive]
pub enum MirError {
    UnknownOpcode {
        inst: Inst,
        opcode: Opcode,
    },
    OperandCount {
        inst: Inst,
        expected: usize,
        found: usize,
    },
    OperandShape {
        inst: Inst,
        index: usize,
    },
    RegClass {
        inst: Inst,
        index: usize,
    },
    ImmediateRange {
        inst: Inst,
        index: usize,
        value: i64,
    },
    TooManyMemOperands {
        inst: Inst,
    },
    ArgCount {
        inst: Inst,
        block: Block,
        expected: usize,
        found: usize,
    },
    ArgClass {
        inst: Inst,
        block: Block,
        index: usize,
    },
    DuplicateDestination {
        inst: Inst,
    },
    BadParam {
        block: Block,
    },
    BadArg {
        block: Block,
    },
    UnknownVReg(VReg),
    UnknownPReg(PReg),
    UnknownSlot(StackSlot),
    UnknownBlock(Block),
    UnknownSymbol(Symbol),
    UnknownClass(RegClass),
    MultipleDefs {
        vreg: VReg,
    },
    MissingTerminator {
        block: Block,
    },
    MisplacedTerminator {
        inst: Inst,
    },
    NoBlocks,
    NotACall {
        inst: Inst,
    },
    UndefinedVReg {
        vreg: VReg,
    },
    NotDominated {
        vreg: VReg,
        inst: Inst,
    },
    Limit,
}

Why an instruction or function is malformed.

Every variant names where the problem is: the instruction (and operand index), the block, or the entity that does not exist.

Examples

use backend_lang::mir::{Function, MirError, Operand};
use backend_lang::x86_64::{op, SYSV, XMM0};

let mut f = Function::new("f", &SYSV);
let b = f.block()?;
// A vector register where add64 wants a general-purpose one.
let err = f.push(b, op::ADD64, &[XMM0.into(), XMM0.into(), Operand::Imm(1)]).unwrap_err();
assert!(matches!(err, MirError::RegClass { index: 0, .. }));
assert_eq!(err.to_string(), "inst0: operand 0 is a register of the wrong class");

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.

UnknownOpcode

The target has no such opcode.

Fields

inst: Inst

The instruction.

opcode: Opcode

The opcode.

OperandCount

The instruction has the wrong number of explicit operands. (For pcopy, an odd number.)

Fields

inst: Inst

The instruction.

expected: usize

How many the opcode takes.

found: usize

How many were given.

OperandShape

An operand has a shape its position does not take (a memory operand where only a register fits, a slot with an offset in a copy, an unknown condition code, …). The opcode’s OperandRules list what fits.

Fields

inst: Inst

The instruction.

index: usize

The operand’s position.

RegClass

A register operand is of the wrong class (or, for a tied use or a copy, not of its partner’s class).

Fields

inst: Inst

The instruction.

index: usize

The operand’s position.

ImmediateRange

An immediate is outside the range its position takes. Load wider constants into a register first (mov64ri).

Fields

inst: Inst

The instruction.

index: usize

The operand’s position.

value: i64

The immediate.

TooManyMemOperands

The instruction has more memory operands than the target allows in one instruction (one, on x86-64).

Fields

inst: Inst

The instruction.

ArgCount

A branch passes a different number of arguments than its target block has parameters. (Add a block’s parameters before branches to it.)

Fields

inst: Inst

The branch.

block: Block

The target block.

expected: usize

The block’s parameter count.

found: usize

The arguments given.

ArgClass

A branch argument’s class differs from its parameter’s.

Fields

inst: Inst

The branch.

block: Block

The target block.

index: usize

The argument’s position.

DuplicateDestination

A parallel copy writes the same register or slot twice.

Fields

inst: Inst

The copy.

BadParam

A block parameter that is not a register or a whole stack slot.

Fields

block: Block

The block.

BadArg

A branch argument that is not a register, a whole stack slot, or an immediate.

Fields

block: Block

The target block.

UnknownVReg(VReg)

A virtual register the function does not have.

UnknownPReg(PReg)

A physical register the target does not have.

UnknownSlot(StackSlot)

A stack slot the function does not have.

UnknownBlock(Block)

A block the function does not have, or a branch target this function did not make.

UnknownSymbol(Symbol)

A symbol the function does not have.

UnknownClass(RegClass)

A register class the target does not have.

MultipleDefs

A virtual register is defined more than once (by instructions or as a block parameter). Before register allocation MIR is in SSA form.

Fields

vreg: VReg

The register.

MissingTerminator

A block does not end with a terminator (jump, branch, return, trap), or is empty.

Fields

block: Block

The block.

MisplacedTerminator

A terminator is followed by more instructions in its block.

Fields

inst: Inst

The terminator.

NoBlocks

The function has no blocks.

NotACall

A call-site record (stack map or landing pad) names an instruction that is not a call.

Fields

inst: Inst

The instruction.

UndefinedVReg

A virtual register is used but never defined (Function::verify_ssa).

Fields

vreg: VReg

The register.

NotDominated

A use of a virtual register in a block reachable from the entry is not dominated by its definition (Function::verify_ssa).

Fields

vreg: VReg

The register.

inst: Inst

The instruction that uses it.

Limit

A table of the function (instructions, operands, blocks, …) would exceed its 32-bit ids, or virtual registers would exceed VReg::MAX.

Trait Implementations

impl Clone for MirError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MirError

impl Debug for MirError

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

Formats the value using the given formatter.

impl Display for MirError

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

Formats the value using the given formatter.

impl Eq for MirError

impl Error for MirError

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<MirError> for IselError

fn from(e: MirError) -> IselError

Converts to this type from the input type.

impl From<MirError> for RegAllocError

fn from(e: MirError) -> RegAllocError

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 Hash for MirError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MirError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for MirError