Struct FnAliasAnalyzer 

pub struct FnAliasAnalyzer<'tcx> {
    pub tcx: TyCtxt<'tcx>,
    place_info: PlaceInfo<'tcx>,
    fn_summaries: Rc<RefCell<FnAliasMap>>,
    pub bb_iter_cnt: RefCell<usize>,
}

Intraprocedural alias analyzer

Fields

tcx: TyCtxt<'tcx>

place_info: PlaceInfo<'tcx>

fn_summaries: Rc<RefCell<FnAliasMap>>

Function summaries for interprocedural analysis

bb_iter_cnt: RefCell<usize>

(Debug) Number of BBs we have iterated through

Implementations

impl<'tcx> FnAliasAnalyzer<'tcx>

pub fn new( tcx: TyCtxt<'tcx>, def_id: DefId, body: &'tcx Body<'tcx>, fn_summaries: Rc<RefCell<FnAliasMap>>, ) -> Self

Create a new analyzer for a function

pub fn place_info(&self) -> &PlaceInfo<'tcx>

Get the place info

Trait Implementations

impl<'tcx> Analysis<'tcx> for FnAliasAnalyzer<'tcx>

Available on rapx_ge_100 only.

const NAME: &'static str = "FnAliasAnalyzer"

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

type Domain = AliasDomain

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

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<'mir>( &self, state: &mut Self::Domain, terminator: &'mir Terminator<'tcx>, _location: Location, )

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

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.

type Direction = Forward

The direction of this analysis. Either Forward or Backward.

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 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.

impl DebugWithContext<FnAliasAnalyzer<'_>> for AliasDomain

fn fmt_with(&self, _ctxt: &C, f: &mut Formatter<'_>) -> Result<(), Error>

fn fmt_diff_with( &self, old: &Self, ctxt: &C, f: &mut Formatter<'_>, ) -> Result<(), Error>

Print the difference between self and old.