Struct FunctionRef 

pub struct FunctionRef<'str, 'ctx, R = ModuleView<'ctx, 'str>> {
    pub id: FunctionId,
    /* private fields */
}

Fields

id: FunctionId

Implementations

impl<'s, 'ctx: 's, 'str: 'ctx, R> FunctionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

pub fn address(&'s self) -> Option<u64>

The function interface’s entry address.

pub fn is_external(&'s self) -> bool

Whether the function interface marks this function external.

pub fn import_ordinal(&'s self) -> Option<u16>

The ordinal this import was brought in at, for a PE import resolved from an ordinal-only entry. None for named imports and local functions.

pub fn signature(&'s self) -> Option<&'ctx FunctionSignature>

A reference to the function interface’s signature, if any.

pub fn users_of(&'s self, value: ValueId) -> Vec<InstructionId>

This function’s instructions that use value as an operand. See FunctionBody::users_of; this is the function-scoped read every pass wants for an SSA value (all its users are intra-function).

pub fn local_users_of(&'s self, value: ValueId) -> &'ctx [LocalInsnId]

This function’s users of value in their stored, body-local form.

Borrowed rather than built: a pass that reads the list once per instruction should not allocate one per instruction to do it. Qualify with this function’s id when a whole InstructionId is needed.

pub fn has_users(&'s self, value: ValueId) -> bool

Whether this function uses value at all, without building the user list to ask. See FunctionBody::has_users.

pub fn user_map_entries( &'s self, ) -> impl Iterator<Item = (ValueId, Vec<InstructionId>)> + 's

Iterate this function’s recorded (value, users) reverse-use entries (see FunctionBody::user_map_entries).

pub fn local_named(&'s self, name: &str) -> Option<ValueId>

Resolve a block/instruction/param/Temp name within this function’s local name table (see FunctionBody::names). None if this function has no such name.

pub fn param_attr(&'s self, index: usize) -> Option<ParamAttrs>

The inferred pointer attributes for positional argument index, or None when this function has no analyzed attributes (treat conservatively: the argument escapes and may be written through). See FunctionSignature::param_attrs.

pub fn param_attrs(&'s self) -> Option<&'ctx [ParamAttrs]>

The full per-parameter attribute vector, if analyzed.

pub fn written_spaces(&'s self) -> Option<&'ctx [SpaceId]>

The non-register memory spaces this function may (transitively) write, as set by analysis. Some(spaces) is exact (a space not listed is never written); None conflates “unstamped” and “stamped unbounded” — both are treated conservatively (may write any space) by consumers. For the tri-state distinction use written_spaces_state. See FunctionSignature::written_spaces.

pub fn written_spaces_state(&'s self) -> WrittenSpaces<'ctx>

The tri-state written_spaces verdict, distinguishing a never-stamped fresh mint (WrittenSpaces::Unstamped) from a deliberately recorded ⊤ (WrittenSpaces::Unbounded). See FunctionSignature::written_spaces.

pub fn is_reg_materialized(&'s self) -> bool

Whether this function’s register interface has been materialized (argpromote v2) — i.e. its effects are RegisterChannelState::Materialized. Legacy name for the register-channel “functionalized” predicate.

pub fn effects(&'s self) -> &'ctx FunctionEffects

This function’s call-graph-closed register FunctionEffects summary. RegisterChannelState::Unsolved until the effect-analysis pass runs (and after a snapshot load). See FunctionInterface::effects.

pub fn is_pure(&'s self) -> bool

Whether argpromote has functionalized every side-effect channel of this function — it is a deterministic pure function of its by-value params, touching no caller-visible memory or registers. Strictly stronger than is_reg_materialized. See FunctionSignature::is_pure.

pub fn is_lambda(&'s self) -> bool

Whether this is a pure value-level lambda rather than a machine function.

pub fn kind(&'s self) -> FunctionKind

pub fn extern_interface(&'s self) -> Option<&'ctx ExternInterface>

The C-prototype-derived external call interface, if external_sigs planned one. Read by argpromote_external to rewrite call sites. See FunctionSignature::extern_interface.

pub fn argmem(&'s self) -> Option<&'ctx ExternArgmem>

The C-prototype-derived argmem summary for a prototyped external, or None when this function is not a prototyped external. See FunctionSignature::argmem.

pub fn input_arg_name(&'s self, index: usize) -> Option<String>

The display name for the call-site argument bound to input index: the name of the callee’s root block param at index, or — for a bodyless external with no root block — the C-prototype argument name recorded in its extern_interface. None when there is no input at index or it is unnamed.

pub fn reads_unbounded_stack(&'s self) -> bool

Whether this function performs an unresolved/dynamic stack read (or forwards a stack pointer into one). See FunctionSignature::reads_unbounded_stack.

pub fn frame_escapes_to_unbounded(&'s self) -> bool

Whether this function hands a pointer into its own frame to a callee that may read it unboundedly. See FunctionSignature::frame_escapes_to_unbounded.

pub fn name(&'s self) -> &'ctx str

The function interface’s name.

pub fn instruction_addrs(&'s self) -> impl Iterator<Item = u64> + 'ctx

The addresses of every machine instruction lifted into this function, in ascending order. Unlike blocks, this is stable across optimization, so it drives the raw disassembly view.

pub fn has_map(&'s self) -> bool

Whether this function contains at least one Map instruction — a lane-wise array map operation. Surfaced as an advanced filter in the function list.

pub fn has_scan(&'s self) -> bool

Whether this function contains at least one Scan instruction — a lane-wise prefix-fold array operation. Surfaced as an advanced filter in the function list, alongside has_map.

pub fn root(&'s self) -> Option<BlockRef<'str, 'ctx, R>>

The root block of this function, if it exists.

pub fn blocks(&'s self) -> impl Iterator<Item = BlockRef<'str, 'ctx, R>> + 's

An iterator over the (live) blocks belonging to this function.

pub fn block_ids(&'s self) -> Vec<BlockId>

The composite ids of this function’s live blocks, in roster order.

pub fn instruction_ids(&'s self) -> Vec<InstructionId>

The composite IDs of this function’s live instructions, in dense physical order — including any currently detached (parent == None).

pub fn edge_ids(&'s self) -> Vec<EdgeId>

The IDs of every live CFG edge in this function’s edge arena, in dense physical order.

pub fn iter(&'s self) -> BlockIter<'str, 'ctx, R>

Iterates over the (live) blocks in this function in arena order (i.e. not sorted by address, unlike blocks).

impl<'str, 'ctx, R> FunctionRef<'str, 'ctx, R>

pub fn new(view: R, id: FunctionId) -> Self

pub fn id(&self) -> ValueId

impl<'str, 'ctx> FunctionRef<'str, 'ctx>

pub fn from_id(ctx: &'ctx Context<'str>, id: FunctionId) -> Self

Trait Implementations

impl<'str: 'ctx, 'ctx, R> Cfg for FunctionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

type NodeId = BlockId

type Hasher = FxBuildHasher

Hasher backing the analyses’ node-keyed maps. Picking a fixed-seed hasher (e.g. FxBuildHasher) keeps successors iteration — and thus the derived dominator structures — deterministic across runs, whereas the std default (RandomState) reseeds per process.

fn successors(&self, b: BlockId) -> impl Iterator<Item = BlockId> + '_

The successors of n (the targets of its outgoing edges).

impl<'str, 'ctx, R: Clone> Clone for FunctionRef<'str, 'ctx, R>

fn clone(&self) -> FunctionRef<'str, 'ctx, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'str, 'ctx, R: Copy> Copy for FunctionRef<'str, 'ctx, R>

impl<'str: 'ctx, 'ctx, R> Display for FunctionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

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

Formats the value using the given formatter.

impl<'str, 'ctx, R> From<FunctionRef<'str, 'ctx, R>> for ValueRef<'str, 'ctx, R>

fn from(fn_ref: FunctionRef<'str, 'ctx, R>) -> Self

Converts to this type from the input type.

impl<'str: 'ctx, 'ctx, R> IntoIterator for &FunctionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

type Item = BlockRef<'str, 'ctx, R>

The type of the elements being iterated over.

type IntoIter = BlockIter<'str, 'ctx, R>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'str: 'ctx, 'ctx, R> Named for FunctionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

fn name(&self) -> Option<&str>

impl<'str: 'ctx, 'ctx, R> Value<'str, 'ctx> for FunctionRef<'str, 'ctx, R>

where R: QCodeView<'ctx, 'str>,

fn id(&self) -> ValueId

The context-unique identifier for this value.

fn size(&self) -> usize

The size of this value’s output in bytes, or 0 for non-data values (terminators, blocks, functions).

impl<'s, 'ctx: 's, 'str: 'ctx> WithCtx<'s, 'ctx, 'str> for FunctionRef<'str, 'ctx>

fn ctx(&'s self) -> &'ctx Context<'str>