Enum ExecutionError 

pub enum ExecutionError<Address>
where
    Address: Copy,
{
    UnalignedInstruction {
        address: PackedAddress<Address>,
    },
    OutOfBoundsRead {
        address: PackedAddress<u64>,
    },
    OutOfBoundsWrite {
        address: PackedAddress<u64>,
    },
    MisalignedRead {
        address: PackedAddress<u64>,
    },
    MisalignedWrite {
        address: PackedAddress<u64>,
    },
    MisalignedAtomic {
        address: PackedAddress<u64>,
    },
    EcallUnsupported {
        address: PackedAddress<Address>,
    },
    IllegalInstruction {
        address: PackedAddress<Address>,
    },
    CsrReadOnly {
        csr_index: u16,
    },
    CsrIllegalRead {
        csr_index: u16,
    },
    CsrIllegalWrite {
        csr_index: u16,
    },
    CsrUnknown {
        csr_index: u16,
    },
    CsrInsufficientPrivilege {
        csr_index: u16,
        required: PrivilegeLevel,
        current: PrivilegeLevel,
    },
    UnsupportedPlatform,
    Custom([u8; 8]),
}

Execution errors.

The variants of VirtualMemoryError and CsrError are inlined here rather than nested. Nesting cost an extra discriminant per level, which made this type 24 bytes; flattened it is 16, which is what lets Result<_, ExecutionError> be returned in registers instead of through a hidden out-pointer. From implementations for all three are provided, so ? on them keeps working unchanged.

Variants

UnalignedInstruction

Unaligned instruction

Fields

address: PackedAddress<Address>

Address of the unaligned instruction fetch

OutOfBoundsRead

Out-of-bounds read

Fields

address: PackedAddress<u64>

Address of the out-of-bounds read

OutOfBoundsWrite

Out-of-bounds write

Fields

address: PackedAddress<u64>

Address of the out-of-bounds write

MisalignedRead

Misaligned read from an instruction that requires natural alignment (e.g. lr), unlike ordinary loads

Fields

address: PackedAddress<u64>

Address of the misaligned read

MisalignedWrite

Misaligned write from an instruction that requires natural alignment (e.g. sc), unlike ordinary stores

Fields

address: PackedAddress<u64>

Address of the misaligned write

MisalignedAtomic

Misaligned atomic access (e.g. AMO) whose accessed bytes are not all within the same misaligned atomicity granule, unlike an ordinary misaligned read or write

Fields

address: PackedAddress<u64>

Address of the misaligned atomic access

EcallUnsupported

Unsupported ecall instruction

Fields

address: PackedAddress<Address>

Address of the unsupported instruction

IllegalInstruction

Unimplemented/illegal instruction

Fields

address: PackedAddress<Address>

Address of the unimp instruction

CsrReadOnly

Read only CSR

Fields

csr_index: u16

Index of CSR where write was attempted

CsrIllegalRead

Illegal read access

Fields

csr_index: u16

Index of the accessed CSR

CsrIllegalWrite

Illegal write access

Fields

csr_index: u16

Index of the accessed CSR

CsrUnknown

Unknown CSR

Fields

csr_index: u16

Index of the accessed CSR

CsrInsufficientPrivilege

Insufficient privilege level

Fields

csr_index: u16

Index of the accessed CSR

required: PrivilegeLevel

Required privilege level

current: PrivilegeLevel

Current privilege level

UnsupportedPlatform

Threaded execution is not supported on this platform.

See OpaqueThreadedExecutionResult::platform_supported() for what makes a platform unsupported and why the answer is a run-time one.

Custom([u8; 8])

Custom error

Trait Implementations

impl<Address> Debug for ExecutionError<Address>

where Address: Copy + Debug,

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

Formats the value using the given formatter.

impl<Address> Display for ExecutionError<Address>

where Address: Copy, PackedAddress<Address>: Display + LowerHex,

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

Formats the value using the given formatter.

impl<Address> Error for ExecutionError<Address>

where Address: Copy, Self: Debug + Display,

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<Address> From<CsrError> for ExecutionError<Address>

where Address: Copy,

fn from(value: CsrError) -> Self

Converts to this type from the input type.

impl<Reg> From<ExecutionError<<Reg as Register>::Type>> for ExecutionResult<Reg>

where Reg: Register,

fn from(error: ExecutionError<Reg::Type>) -> Self

Converts to this type from the input type.

impl<Address> From<VirtualMemoryError> for ExecutionError<Address>

where Address: Copy,

fn from(value: VirtualMemoryError) -> Self

Converts to this type from the input type.