Struct Body

pub struct Body {
    pub blocks: Vec<BasicBlock>,
    pub(super) locals: Vec<LocalDecl>,
    pub(super) arg_count: usize,
    pub var_debug_info: Vec<VarDebugInfo>,
    pub(super) spread_arg: Option<Local>,
    pub span: Span,
}

The SMIR representation of a single function.

Fields

blocks: Vec<BasicBlock>

locals: Vec<LocalDecl>

Declarations of locals within the function.

The first local is the return value pointer, followed by arg_count locals for the function arguments, followed by any user-declared variables and temporaries.

arg_count: usize

The number of arguments this function takes.

var_debug_info: Vec<VarDebugInfo>

Debug information pertaining to user variables, including captures.

spread_arg: Option<Local>

Mark an argument (which must be a tuple) as getting passed as its individual components.

This is used for the “rust-call” ABI such as closures.

span: Span

The span that covers the entire function body.

Implementations

impl Body

pub fn new( blocks: Vec<BasicBlock>, locals: Vec<LocalDecl>, arg_count: usize, var_debug_info: Vec<VarDebugInfo>, spread_arg: Option<Local>, span: Span, ) -> Self

Constructs a Body.

A constructor is required to build a Body from outside the crate because the arg_count and locals fields are private.

pub fn ret_local(&self) -> &LocalDecl

Return local that holds this function’s return value.

pub fn arg_locals(&self) -> &[LocalDecl]

Locals in self that correspond to this function’s arguments.

pub fn inner_locals(&self) -> &[LocalDecl]

Inner locals for this function. These are the locals that are neither the return local nor the argument locals.

pub fn locals(&self) -> &[LocalDecl]

Convenience function to get all the locals in this function.

Locals are typically accessed via the more specific methods ret_local, arg_locals, and inner_locals.

pub fn local_decl(&self, local: Local) -> Option<&LocalDecl>

Get the local declaration for this local.

pub fn local_decls(&self) -> impl Iterator<Item = (Local, &LocalDecl)>

Get an iterator for all local declarations.

pub fn dump<W: Write>(&self, w: &mut W, fn_name: &str) -> Result<()>

Emit the body using the provided name for the signature.

pub fn spread_arg(&self) -> Option<Local>

Trait Implementations

impl Clone for Body

fn clone(&self) -> Body

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Body

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

Formats the value using the given formatter.

impl Serialize for Body

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 104 bytes