Struct EntryAnalyzer 

struct EntryAnalyzer<'gcx> {

    gcx: Gcx<'gcx>,
    bases: &'gcx [ContractId],
    writes: HashMap<VariableId, HashSet<FunctionId>>,
    aliases: AliasState,
    guards: HashSet<FunctionId>,
    call_returns: HashMap<ExprId, Vec<HashSet<VariableId>>>,
    call_summaries: HashMap<CallContext, CallSummary>,
    seen_calls: HashSet<CallContext>,
    evaluated_calls: HashSet<CallContext>,
    stack: Vec<FunctionId>,
    return_stack: Vec<Vec<HashSet<VariableId>>>,
    return_flow: Vec<Option<FlowState>>,
    loop_flow: Vec<LoopFlow>,
    modifier_continuations: Vec<ModifierContinuation<'gcx>>,
    assembly_depth: usize,
}

Fields

gcx: Gcx<'gcx>

bases: &'gcx [ContractId]

writes: HashMap<VariableId, HashSet<FunctionId>>

Written state variables to the guards that held at every write.

aliases: AliasState

guards: HashSet<FunctionId>

call_returns: HashMap<ExprId, Vec<HashSet<VariableId>>>

Storage roots returned by each analyzed call expression.

call_summaries: HashMap<CallContext, CallSummary>

seen_calls: HashSet<CallContext>

Contexts currently being analyzed (recursion detection).

evaluated_calls: HashSet<CallContext>

Contexts already analyzed in this pass.

stack: Vec<FunctionId>

return_stack: Vec<Vec<HashSet<VariableId>>>

Per active function, the storage roots flowing into each return slot.

return_flow: Vec<Option<FlowState>>

Per active function, the joined state at its return statements.

loop_flow: Vec<LoopFlow>

modifier_continuations: Vec<ModifierContinuation<'gcx>>

assembly_depth: usize

Implementations

impl<'gcx> EntryAnalyzer<'gcx>

fn analyze_function(&mut self, function_id: FunctionId) -> CallSummary

fn analyze_modifier_chain( &mut self, modifiers: &'gcx [Modifier<'gcx>], index: usize, body: Block<'gcx>, ) -> bool

Analyzes the modifier at index (or the body once the chain is exhausted). Returns whether control can complete normally.

fn analyze_call( &mut self, function_id: FunctionId, arguments: &[&'gcx Expr<'gcx>], ) -> CallSummary

fn argument_aliases( &self, function_id: FunctionId, arguments: &[&'gcx Expr<'gcx>], ) -> AliasState

Aliases of function_id’s parameters when bound to arguments under the current state.

fn analyze_block(&mut self, block: Block<'gcx>) -> bool

fn analyze_alternatives<T: Copy>( &mut self, alternatives: impl IntoIterator<Item = T>, merged: Option<FlowState>, analyze: impl Fn(&mut Self, T) -> bool, ) -> bool

Analyzes each alternative from the current state and joins the states of those that complete (plus merged, the state of any implicit fall-through path). Returns whether any path completes.

fn analyze_stmt(&mut self, statement: &'gcx Stmt<'gcx>) -> bool

Analyzes a statement, returning whether control can continue past it.

fn analyze_loop(&mut self, block: Block<'gcx>, source: LoopSource<'gcx>) -> bool

Iterates the loop body from the joined loop-head state until the alias/guard state stops changing. Returns whether the loop can be left normally.

fn analyze_loop_stmts( &mut self, analyze: impl FnOnce(&mut Self) -> bool, ) -> (Option<FlowState>, Option<FlowState>, bool)

Runs analyze inside a fresh loop frame, returning the break state, the continue state and whether the body completed.

fn flow_state(&self) -> FlowState

fn set_flow_state(&mut self, state: FlowState)

fn capture_return_flow(&mut self)

fn analyze_expr(&mut self, expression: &'gcx Expr<'gcx>) -> bool

Analyzes an expression, returning whether its evaluation can complete.

fn record_write(&mut self, expression: &Expr<'_>)

fn record_roots(&mut self, roots: HashSet<VariableId>)

fn set_storage_alias( &mut self, variable_id: VariableId, roots: HashSet<VariableId>, )

fn set_slot_alias( &mut self, variable_id: VariableId, roots: HashSet<VariableId>, )

fn alias_local(&mut self, variable_id: VariableId, roots: HashSet<VariableId>)

Storage pointer locals alias the roots they are bound to; inside assembly, Yul locals also track the slots they hold.

fn alias_local_from_expr( &mut self, variable_id: VariableId, expression: &Expr<'_>, )

fn apply_assignment( &mut self, lhs: &'gcx Expr<'gcx>, rhs: &'gcx Expr<'gcx>, compound: bool, )

fn set_return_aliases(&mut self, expression: &'gcx Expr<'gcx>)

fn capture_named_returns(&mut self)

fn extend_returns(&mut self, roots: Vec<HashSet<VariableId>>)

fn storage_roots_for_output( &self, expression: &Expr<'_>, index: usize, outputs: usize, ) -> HashSet<VariableId>

Storage roots flowing into output index of outputs from expression.

fn store_call_returns( &mut self, expression_id: ExprId, returns: Vec<HashSet<VariableId>>, )

fn ordered_call_arguments( &self, declared_id: FunctionId, arguments: CallArgs<'gcx>, receiver: Option<&'gcx Expr<'gcx>>, ) -> Vec<&'gcx Expr<'gcx>>

Call arguments in declaration order of declared_id’s parameters, the attached receiver first.

fn resolved_internal_call( &self, callee: &'gcx Expr<'gcx>, ) -> Option<(FunctionId, FunctionId, Option<&'gcx Expr<'gcx>>)>

(declared, dispatched, attached receiver) for a call that executes contract code in this storage context: bare identifiers, using for attached calls, library calls and super./Base./Lib. qualified calls.

fn is_library_function(&self, function_id: FunctionId) -> bool

fn dispatch_function(&self, function_id: FunctionId) -> FunctionId

The most-derived override of a virtual function or modifier in the analyzed hierarchy.

fn storage_roots(&self, expression: &Expr<'_>) -> HashSet<VariableId>

State variables an lvalue may write: state roots, aliased storage pointers and storage-returning calls.

fn collect_storage_roots( &self, expression: &Expr<'_>, roots: &mut HashSet<VariableId>, )

fn slot_roots(&self, expression: &Expr<'_>) -> HashSet<VariableId>

State variables whose slot a Yul expression may evaluate to.

fn collect_slot_roots( &self, expression: &Expr<'_>, roots: &mut HashSet<VariableId>, )

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: 536 bytes