Struct InitializedBeforeUse 

struct InitializedBeforeUse;

Backward dataflow analysis which answers the question: from this point, is there a path whose first access to a local is an initialization?

This is used when a local is dead in a predecessor but maybe-live in its successor. A StorageLive is inserted on that edge only if some continuation initializes the local before reading it. If every continuation instead reads the local first or never accesses it, StorageLive would be unnecessary: it only allocates uninitialized storage and cannot make the read valid.

For example:

             bb1                              bb2
    StorageLive(_1); _1 = ...             // _1 is dead
             _flag = true                  _flag = false
                      \                     /
                       \                   /
                              bb3
                        switchInt(_flag)
                          /          \
                 bb4: use(_1)     bb5: no use

Liveness is path-insensitive, so _1 is maybe-live in bb3: it is live in bb1 and bb4, but dead in bb2 and bb5. Nevertheless, no StorageLive is needed on bb2 -> bb3. The continuation to bb5 never accesses _1, while the continuation to bb4 reads _1 without initializing it first and is therefore already UB. (The _flag assignments make that latter continuation dynamically impossible, but this analysis does not need to prove the correlation.)

Live ranges which start in the middle of a block do not need this analysis: such ranges always start at an initialization, so a StorageLive is unconditionally required there.

This analysis deliberately ignores the reconstructed StorageDead boundaries. This can cause an initialization from a later allocation range to propagate into an earlier range and result in an unnecessary StorageLive, but cannot cause a required StorageLive to be omitted.

Implementations

impl InitializedBeforeUse

fn compute<'tcx>( tcx: TyCtxt<'tcx>, body: &Body<'tcx>, ) -> IndexVec<BasicBlock, DenseBitSet<Local>>

Computes the analysis state at the start of each block.

Trait Implementations

impl<'tcx> Analysis<'tcx> for InitializedBeforeUse

const NAME: &'static str = "initialized-before-use"

A descriptive name for this analysis. Used only for debugging.

type Domain = DenseBitSet<Local>

The type that holds the dataflow state at any given point in the program.

type Direction = Backward

The direction of this analysis. Either Forward or Backward.

fn bottom_value(&self, body: &Body<'tcx>) -> Self::Domain

Returns the initial value of the dataflow state upon entry to each basic block.

fn initialize_start_block(&self, _body: &Body<'tcx>, _state: &mut Self::Domain)

Mutates the initial value of the dataflow state upon entry to the START_BLOCK.

fn apply_primary_statement_effect( &self, state: &mut Self::Domain, statement: &Statement<'tcx>, location: Location, )

Updates the current dataflow state with the effect of evaluating a statement.

fn apply_primary_terminator_effect( &self, state: &mut Self::Domain, terminator: &Terminator<'tcx>, location: Location, )

Updates the current dataflow state with the effect of evaluating a terminator.

type SwitchIntData = !

Auxiliary data used for analyzing SwitchInt terminators, if necessary.

fn apply_effect<'mir>( &self, state: &mut Self::Domain, block: BasicBlock, block_data: &'mir BasicBlockData<'tcx>, idx: EffectIndex, )

Given an EffectIndex, calls the appropriate apply_* method in the {early,primary} x {statement,terminator} space.

fn apply_early_statement_effect( &self, _state: &mut Self::Domain, _statement: &Statement<'tcx>, _location: Location, )

Updates the current dataflow state with an “early” effect, i.e. one that occurs immediately before the given statement.

fn apply_early_terminator_effect( &self, _state: &mut Self::Domain, _terminator: &Terminator<'tcx>, _location: Location, )

Updates the current dataflow state with an effect that occurs immediately before the given terminator.

fn get_terminator_edges<'mir>( &self, _state: &Self::Domain, terminator: &'mir Terminator<'tcx>, _location: Location, ) -> TerminatorEdges<'mir, 'tcx>

Gets the terminator edges. Used by forward analyses only. Called before apply_primary_terminator_effect is applied; this might seem strange but in practice MaybeInitializedPlaces needs that ordering and other analyses work with either ordering.

fn apply_call_return_effect( &self, _state: &mut Self::Domain, _block: BasicBlock, _return_places: CallReturnPlaces<'_, 'tcx>, )

Updates the current dataflow state with the effect of a successful return from a Call terminator.

fn get_switch_int_data( &self, _block: BasicBlock, _targets: &SwitchTargets, _discr: &Operand<'tcx>, ) -> Option<Self::SwitchIntData>

Used to update the current dataflow state with the effect of taking a particular branch in a SwitchInt terminator.

fn apply_switch_int_edge_effect( &self, _state: &mut Self::Domain, _data: &Self::SwitchIntData, _target_idx: SwitchTargetIndex, )

See comments on get_switch_int_data.

fn iterate_to_fixpoint<'mir>( self, tcx: TyCtxt<'tcx>, body: &'mir Body<'tcx>, pass_name: Option<&'static str>, ) -> Results<'tcx, Self>

where Self: Sized, Self::Domain: DebugWithContext<Self>,

Finds the fixpoint for this dataflow problem.

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