Enum EncodeError 

#[non_exhaustive]
pub enum EncodeError {
    NoForm {
        mnemonic: Mnemonic,
    },
    ImmediateOutOfRange {
        value: i64,
    },
    TargetOutOfRange {
        offset: i64,
    },
    HighByteWithRex,
    BaseNotQword {
        base: Reg,
    },
    IndexNotQword {
        index: Reg,
    },
    RspIndex,
    RipWithIndex,
}

Why an instruction could not be encoded.

The encoder tries every form of the mnemonic and reports the failure of the form that came closest: an operand-kind mismatch only when no form took the operand kinds at all.

Examples

use isa_lang::x86_64::{encode, EncodeError, Inst, Mem, Mnemonic, Operand, Reg, Size};

// Memory to memory has no form.
let m = Mem::new(Size::Qword, Reg::RAX);
let err = encode(&Inst::new(Mnemonic::Mov, [m.into(), m.into()])).unwrap_err();
assert_eq!(err, EncodeError::NoForm { mnemonic: Mnemonic::Mov });

// A 64-bit add takes a sign-extended 32-bit immediate at most.
let err = encode(&Inst::new(Mnemonic::Add, [Reg::RAX.into(), Operand::Imm(1 << 40)])).unwrap_err();
assert_eq!(err, EncodeError::ImmediateOutOfRange { value: 1 << 40 });
assert_eq!(err.to_string(), "immediate 0x10000000000 does not fit any form for these operands");

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.

NoForm

No form of the mnemonic takes operands of these kinds, sizes, and count. Check the operand order (destination first) and widths.

Fields

mnemonic: Mnemonic

The mnemonic that was asked for.

ImmediateOutOfRange

Forms take these operand kinds, but the immediate is outside every one’s range. Immediates are signed values of the operation’s width; write -1, not 0xFFFF_FFFF, for a 32-bit all-ones value, and load wider constants into a register first.

Fields

value: i64

The immediate as given.

TargetOutOfRange

The branch target is beyond the reach of a 32-bit displacement.

Fields

offset: i64

The target, relative to the start of the instruction.

HighByteWithRex

AH, CH, DH, or BH appears in an instruction that needs a REX prefix (64-bit operation, R8-R15, or SPL/BPL/SIL/DIL), where those encodings mean SPL-DIL instead. Use another register.

BaseNotQword

A memory operand’s base register is not a 64-bit register.

Fields

base: Reg

The offending base.

IndexNotQword

A memory operand’s index register is not a 64-bit register.

Fields

index: Reg

The offending index.

RspIndex

RSP is used as an index register, which the SIB byte cannot express. Swap base and index if the scale is 1.

RipWithIndex

A RIP-relative memory operand has an index register.

Trait Implementations

impl Clone for EncodeError

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 EncodeError

impl Debug for EncodeError

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

Formats the value using the given formatter.

impl Display for EncodeError

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

Formats the value using the given formatter.

impl Eq for EncodeError

impl Error for EncodeError

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<EncodeError> for AsmError

fn from(e: EncodeError) -> AsmError

Converts to this type from the input type.

impl Hash for EncodeError

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 EncodeError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for EncodeError