Struct ExceptionTableData

pub struct ExceptionTableData { /* private fields */ }

Contents of an exception table.

The “no exception” target for is stored as the last element of the underlying vector. It 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, tags_and_targets: impl IntoIterator<Item = (Option<ExceptionTag>, BlockCall)>, ) -> 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 catches( &self, ) -> impl Iterator<Item = (Option<ExceptionTag>, &BlockCall)> + '_

Get the targets for exceptional return cases, together with their tags.

pub fn catches_mut( &mut self, ) -> impl Iterator<Item = (Option<ExceptionTag>, &mut BlockCall)> + '_

Get the targets for exceptional return cases, together with their tags.

pub fn len_catches(&self) -> usize

The number of catch edges in this exception table.

pub fn get_catch( &self, index: usize, ) -> Option<(Option<ExceptionTag>, &BlockCall)>

Get the indexth catch edge from this table.

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.

pub fn push_catch(&mut self, tag: Option<ExceptionTag>, block_call: BlockCall)

Push a catch target onto this exception table.

Panics

Panics if this exception table has been cleared.

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