Struct SsaLocals

pub(crate) struct SsaLocals {
    assignments: IndexVec<Local, Set1<DefLocation>>,
    assignment_order: Vec<Local>,
    copy_classes: IndexVec<Local, Local>,
    direct_uses: IndexVec<Local, u32>,
    borrowed_locals: BitSet<Local>,
}

Fields

assignments: IndexVec<Local, Set1<DefLocation>>

Assignments to each local. This defines whether the local is SSA.

assignment_order: Vec<Local>

We visit the body in reverse postorder, to ensure each local is assigned before it is used. We remember the order in which we saw the assignments to compute the SSA values in a single pass.

copy_classes: IndexVec<Local, Local>

Copy equivalence classes between locals. See copy_classes for documentation.

direct_uses: IndexVec<Local, u32>

Number of “direct” uses of each local, ie. uses that are not dereferences. We ignore non-uses (Storage statements, debuginfo).

borrowed_locals: BitSet<Local>

Set of SSA locals that are immutably borrowed.

Implementations

impl SsaLocals

pub(crate) fn new<'tcx>( tcx: TyCtxt<'tcx>, body: &Body<'tcx>, param_env: ParamEnv<'tcx>, ) -> SsaLocals

pub(crate) fn num_locals(&self) -> usize

pub(crate) fn locals(&self) -> impl Iterator<Item = Local>

pub(crate) fn is_ssa(&self, local: Local) -> bool

pub(crate) fn num_direct_uses(&self, local: Local) -> u32

Return the number of uses if a local that are not “Deref”.

pub(crate) fn assignment_dominates( &self, dominators: &Dominators<BasicBlock>, local: Local, location: Location, ) -> bool

pub(crate) fn assignments<'a, 'tcx>( &'a self, body: &'a Body<'tcx>, ) -> impl Iterator<Item = (Local, &'a Rvalue<'tcx>, Location)> + 'a

pub(crate) fn for_each_assignment_mut<'tcx>( &self, basic_blocks: &mut IndexSlice<BasicBlock, BasicBlockData<'tcx>>, f: impl FnMut(Local, AssignedValue<'_, 'tcx>, Location), )

pub(crate) fn copy_classes(&self) -> &IndexSlice<Local, Local>

Compute the equivalence classes for locals, based on copy statements.

The returned vector maps each local to the one it copies. In the following case: _a = &mut _0 _b = move? _a _c = move? _a _d = move? _c We return the mapping _a => _a // not a copy so, represented by itself _b => _a _c => _a _d => _a // transitively through _c

Exception: we do not see through the return place, as it cannot be instantiated.

pub(crate) fn borrowed_locals(&self) -> &BitSet<Local>

Set of SSA locals that are immutably borrowed.

pub(crate) fn meet_copy_equivalence(&self, property: &mut BitSet<Local>)

Make a property uniform on a copy equivalence class by removing elements.

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