Struct ExceptionTableData

pub struct ExceptionTableData { /* private fields */ }

Contents of an exception table.

An exception table consists of a “no exception” (“normal”) destination block-call, and a series of exceptional destination block-calls associated with tags.

The exceptional tags can also be interspersed with “dynamic context” entries, which result in a particular value being stored in the stack frame and accessible at an offset given in the compiled exception-table metadata. This is needed for some kinds of tag-matching where different dynamic instances of tags may exist (e.g., in the WebAssembly exception-handling proposal).

The sequence of targets is semantically a list of context-or-tagged-blockcall; e.g., [context v0, tag1: block1(v1, v2), context v2, tag2: block2(), tag3: block3()].

The “no exception” target can be accessed through the normal_return and normal_return_mut functions. Exceptional catch clauses may be iterated using the catches and catches_mut functions. All targets may be iterated over using the all_targets and all_targets_mut functions.

Implementations

impl ExceptionTableData

pub fn new( sig: SigRef, normal_return: BlockCall, matches: impl IntoIterator<Item = ExceptionTableItem>, ) -> Self

Create new exception-table data.

This data represents the destinations upon return from try_call or try_call_indirect instruction. There are two possibilities: “normal return” (no exception thrown), or an exceptional return corresponding to one of the listed exception tags.

The given tags are passed through to the metadata provided alongside the provided function body, and Cranelift itself does not implement an unwinder; thus, the meaning of the tags is ultimately up to the embedder of Cranelift. The tags are wrapped in Option to allow encoding a “catch-all” handler.

The BlockCalls must have signatures that match the targeted blocks, as usual. These calls are allowed to use BlockArg::TryCallRet in the normal-return case, with types corresponding to the signature’s return values, and BlockArg::TryCallExn in the exceptional-return cases, with types corresponding to native machine words and an arity corresponding to the number of payload values that the calling convention and platform support. (See [isa::CallConv] for more details.)

pub fn display<'a>( &'a self, pool: &'a ValueListPool, ) -> DisplayExceptionTable<'a>

Return a value that can display the contents of this exception table.

pub fn deep_clone(&self, pool: &mut ValueListPool) -> Self

Deep-clone this exception table.

pub fn normal_return(&self) -> &BlockCall

Get the default target for the non-exceptional return case.

pub fn normal_return_mut(&mut self) -> &mut BlockCall

Get the default target for the non-exceptional return case.

pub fn items(&self) -> impl Iterator<Item = ExceptionTableItem> + '_

Get the exception-catch items: dynamic context updates for interpreting tags, tag-associated targets, and catch-all targets.

pub fn all_branches(&self) -> &[BlockCall]

Get all branch targets.

pub fn all_branches_mut(&mut self) -> &mut [BlockCall]

Get all branch targets.

pub fn signature(&self) -> SigRef

Get the signature of the function called with this exception table.

pub fn clear(&mut self)

Clears all entries in this exception table, but leaves the function signature.

Trait Implementations

impl Clone for ExceptionTableData

fn clone(&self) -> ExceptionTableData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExceptionTableData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExceptionTableData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ExceptionTableData

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 ExceptionTableData

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExceptionTableData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExceptionTableData