1 use rustc_ast::ast::{self, MetaItem};
2 use rustc_ast_pretty::pprust;
3 use rustc_span::symbol::{sym, Symbol};
5 use rustc_data_structures::work_queue::WorkQueue;
6 use rustc_index::bit_set::{BitSet, HybridBitSet};
7 use rustc_index::vec::Idx;
9 use rustc::mir::traversal;
10 use rustc::mir::{self, BasicBlock, BasicBlockData, Body, Location, Statement, Terminator};
11 use rustc::session::Session;
12 use rustc::ty::{self, TyCtxt};
13 use rustc_hir::def_id::DefId;
15 use std::borrow::Borrow;
18 use std::path::PathBuf;
21 pub use self::at_location::{FlowAtLocation, FlowsAtLocation};
22 pub(crate) use self::drop_flag_effects::*;
23 pub use self::impls::borrows::Borrows;
24 pub use self::impls::DefinitelyInitializedPlaces;
25 pub use self::impls::EverInitializedPlaces;
26 pub use self::impls::{MaybeBorrowedLocals, MaybeMutBorrowedLocals};
27 pub use self::impls::{MaybeInitializedPlaces, MaybeUninitializedPlaces};
28 pub use self::impls::{MaybeRequiresStorage, MaybeStorageLive};
30 use self::move_paths::MoveData;
33 pub mod drop_flag_effects;
39 pub(crate) mod indexes {
40 pub(crate) use super::{
41 impls::borrows::BorrowIndex,
42 move_paths::{InitIndex, MoveOutIndex, MovePathIndex},
46 pub(crate) struct DataflowBuilder<'a, 'tcx, BD>
48 BD: BitDenotation<'tcx>,
51 flow_state: DataflowAnalysis<'a, 'tcx, BD>,
52 print_preflow_to: Option<String>,
53 print_postflow_to: Option<String>,
56 /// `DebugFormatted` encapsulates the "{:?}" rendering of some
57 /// arbitrary value. This way: you pay cost of allocating an extra
58 /// string (as well as that of rendering up-front); in exchange, you
59 /// don't have to hand over ownership of your value or deal with
61 pub struct DebugFormatted(String);
64 pub fn new(input: &dyn fmt::Debug) -> DebugFormatted {
65 DebugFormatted(format!("{:?}", input))
69 impl fmt::Debug for DebugFormatted {
70 fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
71 write!(w, "{}", self.0)
75 pub trait Dataflow<'tcx, BD: BitDenotation<'tcx>> {
76 /// Sets up and runs the dataflow problem, using `p` to render results if
77 /// implementation so chooses.
78 fn dataflow<P>(&mut self, p: P)
80 P: Fn(&BD, BD::Idx) -> DebugFormatted,
82 let _ = p; // default implementation does not instrument process.
87 /// Sets up the entry, gen, and kill sets for this instance of a dataflow problem.
88 fn build_sets(&mut self);
90 /// Finds a fixed-point solution to this instance of a dataflow problem.
91 fn propagate(&mut self);
94 impl<'a, 'tcx, BD> Dataflow<'tcx, BD> for DataflowBuilder<'a, 'tcx, BD>
96 BD: BitDenotation<'tcx>,
98 fn dataflow<P>(&mut self, p: P)
100 P: Fn(&BD, BD::Idx) -> DebugFormatted,
102 self.flow_state.build_sets();
103 self.pre_dataflow_instrumentation(|c, i| p(c, i)).unwrap();
104 self.flow_state.propagate();
105 self.post_dataflow_instrumentation(|c, i| p(c, i)).unwrap();
108 fn build_sets(&mut self) {
109 self.flow_state.build_sets();
111 fn propagate(&mut self) {
112 self.flow_state.propagate();
116 pub(crate) fn has_rustc_mir_with(attrs: &[ast::Attribute], name: Symbol) -> Option<MetaItem> {
118 if attr.check_name(sym::rustc_mir) {
119 let items = attr.meta_item_list();
120 for item in items.iter().flat_map(|l| l.iter()) {
121 match item.meta_item() {
122 Some(mi) if mi.check_name(name) => return Some(mi.clone()),
131 pub struct MoveDataParamEnv<'tcx> {
132 pub(crate) move_data: MoveData<'tcx>,
133 pub(crate) param_env: ty::ParamEnv<'tcx>,
136 pub fn do_dataflow<'a, 'tcx, BD, P>(
138 body: &'a Body<'tcx>,
140 attributes: &[ast::Attribute],
141 dead_unwinds: &BitSet<BasicBlock>,
144 ) -> DataflowResults<'tcx, BD>
146 BD: BitDenotation<'tcx>,
147 P: Fn(&BD, BD::Idx) -> DebugFormatted,
149 let flow_state = DataflowAnalysis::new(body, dead_unwinds, bd);
150 flow_state.run(tcx, def_id, attributes, p)
153 impl<'a, 'tcx, BD> DataflowAnalysis<'a, 'tcx, BD>
155 BD: BitDenotation<'tcx>,
157 pub(crate) fn run<P>(
161 attributes: &[ast::Attribute],
163 ) -> DataflowResults<'tcx, BD>
165 P: Fn(&BD, BD::Idx) -> DebugFormatted,
167 let name_found = |sess: &Session, attrs: &[ast::Attribute], name| -> Option<String> {
168 if let Some(item) = has_rustc_mir_with(attrs, name) {
169 if let Some(s) = item.value_str() {
170 return Some(s.to_string());
172 let path = pprust::path_to_string(&item.path);
173 sess.span_err(item.span, &format!("{} attribute requires a path", path));
180 let print_preflow_to = name_found(tcx.sess, attributes, sym::borrowck_graphviz_preflow);
181 let print_postflow_to = name_found(tcx.sess, attributes, sym::borrowck_graphviz_postflow);
184 DataflowBuilder { def_id, print_preflow_to, print_postflow_to, flow_state: self };
187 mbcx.flow_state.results()
191 struct PropagationContext<'b, 'a, 'tcx, O>
193 O: BitDenotation<'tcx>,
195 builder: &'b mut DataflowAnalysis<'a, 'tcx, O>,
198 impl<'a, 'tcx, BD> DataflowAnalysis<'a, 'tcx, BD>
200 BD: BitDenotation<'tcx>,
202 fn propagate(&mut self) {
203 let mut temp = BitSet::new_empty(self.flow_state.sets.bits_per_block);
204 let mut propcx = PropagationContext { builder: self };
205 propcx.walk_cfg(&mut temp);
208 fn build_sets(&mut self) {
209 // Build the transfer function for each block.
210 for (bb, data) in self.body.basic_blocks().iter_enumerated() {
211 let &mir::BasicBlockData { ref statements, ref terminator, is_cleanup: _ } = data;
213 let trans = self.flow_state.sets.trans_mut_for(bb.index());
214 for j_stmt in 0..statements.len() {
215 let location = Location { block: bb, statement_index: j_stmt };
216 self.flow_state.operator.before_statement_effect(trans, location);
217 self.flow_state.operator.statement_effect(trans, location);
220 if terminator.is_some() {
221 let location = Location { block: bb, statement_index: statements.len() };
222 self.flow_state.operator.before_terminator_effect(trans, location);
223 self.flow_state.operator.terminator_effect(trans, location);
227 // Initialize the flow state at entry to the start block.
228 let on_entry = self.flow_state.sets.entry_set_mut_for(mir::START_BLOCK.index());
229 self.flow_state.operator.start_block_effect(on_entry);
233 impl<'b, 'a, 'tcx, BD> PropagationContext<'b, 'a, 'tcx, BD>
235 BD: BitDenotation<'tcx>,
237 fn walk_cfg(&mut self, in_out: &mut BitSet<BD::Idx>) {
238 let body = self.builder.body;
240 // Initialize the dirty queue in reverse post-order. This makes it more likely that the
241 // entry state for each basic block will have the effects of its predecessors applied
242 // before it is processed. In fact, for CFGs without back edges, this guarantees that
243 // dataflow will converge in exactly `N` iterations, where `N` is the number of basic
245 let mut dirty_queue: WorkQueue<mir::BasicBlock> =
246 WorkQueue::with_none(body.basic_blocks().len());
247 for (bb, _) in traversal::reverse_postorder(body) {
248 dirty_queue.insert(bb);
251 // Add blocks which are not reachable from START_BLOCK to the work queue. These blocks will
252 // be processed after the ones added above.
253 for bb in body.basic_blocks().indices() {
254 dirty_queue.insert(bb);
257 while let Some(bb) = dirty_queue.pop() {
258 let (on_entry, trans) = self.builder.flow_state.sets.get_mut(bb.index());
259 debug_assert!(in_out.words().len() == on_entry.words().len());
260 in_out.overwrite(on_entry);
263 let bb_data = &body[bb];
264 self.builder.propagate_bits_into_graph_successors_of(
273 fn dataflow_path(context: &str, path: &str) -> PathBuf {
274 let mut path = PathBuf::from(path);
275 let new_file_name = {
276 let orig_file_name = path.file_name().unwrap().to_str().unwrap();
277 format!("{}_{}", context, orig_file_name)
279 path.set_file_name(new_file_name);
283 impl<'a, 'tcx, BD> DataflowBuilder<'a, 'tcx, BD>
285 BD: BitDenotation<'tcx>,
287 fn pre_dataflow_instrumentation<P>(&self, p: P) -> io::Result<()>
289 P: Fn(&BD, BD::Idx) -> DebugFormatted,
291 if let Some(ref path_str) = self.print_preflow_to {
292 let path = dataflow_path(BD::name(), path_str);
293 graphviz::print_borrowck_graph_to(self, &path, p)
299 fn post_dataflow_instrumentation<P>(&self, p: P) -> io::Result<()>
301 P: Fn(&BD, BD::Idx) -> DebugFormatted,
303 if let Some(ref path_str) = self.print_postflow_to {
304 let path = dataflow_path(BD::name(), path_str);
305 graphviz::print_borrowck_graph_to(self, &path, p)
312 /// DataflowResultsConsumer abstracts over walking the MIR with some
313 /// already constructed dataflow results.
315 /// It abstracts over the FlowState and also completely hides the
316 /// underlying flow analysis results, because it needs to handle cases
317 /// where we are combining the results of *multiple* flow analyses
318 /// (e.g., borrows + inits + uninits).
319 pub(crate) trait DataflowResultsConsumer<'a, 'tcx: 'a> {
320 type FlowState: FlowsAtLocation;
322 // Observation Hooks: override (at least one of) these to get analysis feedback.
323 fn visit_block_entry(&mut self, _bb: BasicBlock, _flow_state: &Self::FlowState) {}
325 fn visit_statement_entry(
328 _stmt: &'a Statement<'tcx>,
329 _flow_state: &Self::FlowState,
333 fn visit_terminator_entry(
336 _term: &'a Terminator<'tcx>,
337 _flow_state: &Self::FlowState,
341 // Main entry point: this drives the processing of results.
343 fn analyze_results(&mut self, flow_uninit: &mut Self::FlowState) {
344 let flow = flow_uninit;
345 for (bb, _) in traversal::reverse_postorder(self.body()) {
346 flow.reset_to_entry_of(bb);
347 self.process_basic_block(bb, flow);
351 fn process_basic_block(&mut self, bb: BasicBlock, flow_state: &mut Self::FlowState) {
352 self.visit_block_entry(bb, flow_state);
354 let BasicBlockData { ref statements, ref terminator, is_cleanup: _ } = self.body()[bb];
355 let mut location = Location { block: bb, statement_index: 0 };
356 for stmt in statements.iter() {
357 flow_state.reconstruct_statement_effect(location);
358 self.visit_statement_entry(location, stmt, flow_state);
359 flow_state.apply_local_effect(location);
360 location.statement_index += 1;
363 if let Some(ref term) = *terminator {
364 flow_state.reconstruct_terminator_effect(location);
365 self.visit_terminator_entry(location, term, flow_state);
367 // We don't need to apply the effect of the terminator,
368 // since we are only visiting dataflow state on control
369 // flow entry to the various nodes. (But we still need to
370 // reconstruct the effect, because the visit method might
375 // Delegated Hooks: Provide access to the MIR and process the flow state.
377 fn body(&self) -> &'a Body<'tcx>;
380 /// Allows iterating dataflow results in a flexible and reasonably fast way.
381 pub struct DataflowResultsCursor<'mir, 'tcx, BD, DR = DataflowResults<'tcx, BD>>
383 BD: BitDenotation<'tcx>,
384 DR: Borrow<DataflowResults<'tcx, BD>>,
386 flow_state: FlowAtLocation<'tcx, BD, DR>,
388 // The statement (or terminator) whose effect has been reconstructed in
390 curr_loc: Option<Location>,
392 body: &'mir Body<'tcx>,
395 pub type DataflowResultsRefCursor<'mir, 'tcx, BD> =
396 DataflowResultsCursor<'mir, 'tcx, BD, &'mir DataflowResults<'tcx, BD>>;
398 impl<'mir, 'tcx, BD, DR> DataflowResultsCursor<'mir, 'tcx, BD, DR>
400 BD: BitDenotation<'tcx>,
401 DR: Borrow<DataflowResults<'tcx, BD>>,
403 pub fn new(result: DR, body: &'mir Body<'tcx>) -> Self {
404 DataflowResultsCursor { flow_state: FlowAtLocation::new(result), curr_loc: None, body }
407 /// Seek to the given location in MIR. This method is fast if you are
408 /// traversing your MIR statements in order.
410 /// After calling `seek`, the current state will reflect all effects up to
411 /// and including the `before_statement_effect` of the statement at location
412 /// `loc`. The `statement_effect` of the statement at `loc` will be
413 /// available as the current effect (see e.g. `each_gen_bit`).
415 /// If `loc.statement_index` equals the number of statements in the block,
416 /// we will reconstruct the terminator effect in the same way as described
418 pub fn seek(&mut self, loc: Location) {
419 if self.curr_loc.map(|cur| loc == cur).unwrap_or(false) {
424 let should_reset = match self.curr_loc {
426 Some(cur) if loc.block != cur.block || loc.statement_index < cur.statement_index => {
432 self.flow_state.reset_to_entry_of(loc.block);
435 let curr_loc = self.curr_loc.unwrap();
436 start_index = curr_loc.statement_index;
437 // Apply the effect from the last seek to the current state.
438 self.flow_state.apply_local_effect(curr_loc);
441 for stmt in start_index..loc.statement_index {
442 let mut stmt_loc = loc;
443 stmt_loc.statement_index = stmt;
444 self.flow_state.reconstruct_statement_effect(stmt_loc);
445 self.flow_state.apply_local_effect(stmt_loc);
448 if loc.statement_index == self.body[loc.block].statements.len() {
449 self.flow_state.reconstruct_terminator_effect(loc);
451 self.flow_state.reconstruct_statement_effect(loc);
453 self.curr_loc = Some(loc);
456 /// Return whether the current state contains bit `x`.
457 pub fn contains(&self, x: BD::Idx) -> bool {
458 self.flow_state.contains(x)
461 /// Iterate over each `gen` bit in the current effect (invoke `seek` first).
462 pub fn each_gen_bit<F>(&self, f: F)
466 self.flow_state.each_gen_bit(f)
469 pub fn get(&self) -> &BitSet<BD::Idx> {
470 self.flow_state.as_dense()
474 pub struct DataflowAnalysis<'a, 'tcx, O>
476 O: BitDenotation<'tcx>,
478 flow_state: DataflowState<'tcx, O>,
479 dead_unwinds: &'a BitSet<mir::BasicBlock>,
480 body: &'a Body<'tcx>,
483 impl<'a, 'tcx, O> DataflowAnalysis<'a, 'tcx, O>
485 O: BitDenotation<'tcx>,
487 pub fn results(self) -> DataflowResults<'tcx, O> {
488 DataflowResults(self.flow_state)
491 pub fn body(&self) -> &'a Body<'tcx> {
496 pub struct DataflowResults<'tcx, O>(pub(crate) DataflowState<'tcx, O>)
498 O: BitDenotation<'tcx>;
500 impl<'tcx, O: BitDenotation<'tcx>> DataflowResults<'tcx, O> {
501 pub fn sets(&self) -> &AllSets<O::Idx> {
505 pub fn operator(&self) -> &O {
510 /// State of a dataflow analysis; couples a collection of bit sets
511 /// with operator used to initialize and merge bits during analysis.
512 pub struct DataflowState<'tcx, O: BitDenotation<'tcx>> {
513 /// All the sets for the analysis. (Factored into its
514 /// own structure so that we can borrow it mutably
515 /// on its own separate from other fields.)
516 pub sets: AllSets<O::Idx>,
518 /// operator used to initialize, combine, and interpret bits.
519 pub(crate) operator: O,
522 impl<'tcx, O: BitDenotation<'tcx>> DataflowState<'tcx, O> {
523 pub(crate) fn interpret_set<'c, P>(
526 set: &BitSet<O::Idx>,
528 ) -> Vec<DebugFormatted>
530 P: Fn(&O, O::Idx) -> DebugFormatted,
532 set.iter().map(|i| render_idx(o, i)).collect()
535 pub(crate) fn interpret_hybrid_set<'c, P>(
538 set: &HybridBitSet<O::Idx>,
540 ) -> Vec<DebugFormatted>
542 P: Fn(&O, O::Idx) -> DebugFormatted,
544 set.iter().map(|i| render_idx(o, i)).collect()
548 /// A 2-tuple representing the "gen" and "kill" bitsets during
549 /// dataflow analysis.
551 /// It is best to ensure that the intersection of `gen_set` and
552 /// `kill_set` is empty; otherwise the results of the dataflow will
553 /// have a hidden dependency on what order the bits are generated and
554 /// killed during the iteration. (This is such a good idea that the
555 /// `fn gen` and `fn kill` methods that set their state enforce this
557 #[derive(Debug, Clone, Copy)]
558 pub struct GenKill<T> {
559 pub(crate) gen_set: T,
560 pub(crate) kill_set: T,
563 pub type GenKillSet<T> = GenKill<HybridBitSet<T>>;
566 /// Creates a new tuple where `gen_set == kill_set == elem`.
567 pub(crate) fn from_elem(elem: T) -> Self
571 GenKill { gen_set: elem.clone(), kill_set: elem }
575 impl<E: Idx> GenKillSet<E> {
576 pub fn clear(&mut self) {
577 self.gen_set.clear();
578 self.kill_set.clear();
581 pub fn gen(&mut self, e: E) {
582 self.gen_set.insert(e);
583 self.kill_set.remove(e);
586 pub fn gen_all(&mut self, i: impl IntoIterator<Item: Borrow<E>>) {
588 self.gen(*j.borrow());
592 pub fn kill(&mut self, e: E) {
593 self.gen_set.remove(e);
594 self.kill_set.insert(e);
597 pub fn kill_all(&mut self, i: impl IntoIterator<Item: Borrow<E>>) {
599 self.kill(*j.borrow());
603 /// Computes `(set ∪ gen) - kill` and assigns the result to `set`.
604 pub(crate) fn apply(&self, set: &mut BitSet<E>) {
605 set.union(&self.gen_set);
606 set.subtract(&self.kill_set);
611 pub struct AllSets<E: Idx> {
612 /// Analysis bitwidth for each block.
613 bits_per_block: usize,
615 /// For each block, bits valid on entry to the block.
616 on_entry: Vec<BitSet<E>>,
618 /// The transfer function of each block expressed as the set of bits
619 /// generated and killed by executing the statements + terminator in the
620 /// block -- with one caveat. In particular, for *call terminators*, the
621 /// effect of storing the destination is not included, since that only takes
622 /// effect on the **success** edge (and not the unwind edge).
623 trans: Vec<GenKillSet<E>>,
626 impl<E: Idx> AllSets<E> {
627 pub fn bits_per_block(&self) -> usize {
631 pub fn get_mut(&mut self, block_idx: usize) -> (&mut BitSet<E>, &mut GenKillSet<E>) {
632 (&mut self.on_entry[block_idx], &mut self.trans[block_idx])
635 pub fn trans_for(&self, block_idx: usize) -> &GenKillSet<E> {
636 &self.trans[block_idx]
638 pub fn trans_mut_for(&mut self, block_idx: usize) -> &mut GenKillSet<E> {
639 &mut self.trans[block_idx]
641 pub fn entry_set_for(&self, block_idx: usize) -> &BitSet<E> {
642 &self.on_entry[block_idx]
644 pub fn entry_set_mut_for(&mut self, block_idx: usize) -> &mut BitSet<E> {
645 &mut self.on_entry[block_idx]
647 pub fn gen_set_for(&self, block_idx: usize) -> &HybridBitSet<E> {
648 &self.trans_for(block_idx).gen_set
650 pub fn kill_set_for(&self, block_idx: usize) -> &HybridBitSet<E> {
651 &self.trans_for(block_idx).kill_set
655 /// Parameterization for the precise form of data flow that is used.
657 /// `BottomValue` determines whether the initial entry set for each basic block is empty or full.
658 /// This also determines the semantics of the lattice `join` operator used to merge dataflow
659 /// results, since dataflow works by starting at the bottom and moving monotonically to a fixed
662 /// This means, for propagation across the graph, that you either want to start at all-zeroes and
663 /// then use Union as your merge when propagating, or you start at all-ones and then use Intersect
664 /// as your merge when propagating.
665 pub trait BottomValue {
666 /// Specifies the initial value for each bit in the entry set for each basic block.
667 const BOTTOM_VALUE: bool;
669 /// Merges `in_set` into `inout_set`, returning `true` if `inout_set` changed.
671 /// It is almost certainly wrong to override this, since it automatically applies
672 /// * `inout_set & in_set` if `BOTTOM_VALUE == true`
673 /// * `inout_set | in_set` if `BOTTOM_VALUE == false`
675 /// This means that if a bit is not `BOTTOM_VALUE`, it is propagated into all target blocks.
676 /// For clarity, the above statement again from a different perspective:
677 /// A bit in the block's entry set is `!BOTTOM_VALUE` if *any* predecessor block's bit value is
680 /// There are situations where you want the opposite behaviour: propagate only if *all*
681 /// predecessor blocks's value is `!BOTTOM_VALUE`.
682 /// E.g. if you want to know whether a bit is *definitely* set at a specific location. This
683 /// means that all code paths leading to the location must have set the bit, instead of any
684 /// code path leading there.
686 /// If you want this kind of "definitely set" analysis, you need to
687 /// 1. Invert `BOTTOM_VALUE`
688 /// 2. Reset the `entry_set` in `start_block_effect` to `!BOTTOM_VALUE`
689 /// 3. Override `join` to do the opposite from what it's doing now.
691 fn join<T: Idx>(&self, inout_set: &mut BitSet<T>, in_set: &BitSet<T>) -> bool {
692 if !Self::BOTTOM_VALUE { inout_set.union(in_set) } else { inout_set.intersect(in_set) }
696 /// A specific flavor of dataflow analysis.
698 /// To run a dataflow analysis, one sets up an initial state for the
699 /// `START_BLOCK` via `start_block_effect` and a transfer function (`trans`)
700 /// for each block individually. The entry set for all other basic blocks is
701 /// initialized to `Self::BOTTOM_VALUE`. The dataflow analysis then
702 /// iteratively modifies the various entry sets (but leaves the the transfer
703 /// function unchanged). `BottomValue::join` is used to merge the bitsets from
704 /// two blocks (e.g. when two blocks' terminator jumps to a single block, that
705 /// target block's state is the merged state of both incoming blocks).
706 pub trait BitDenotation<'tcx>: BottomValue {
707 /// Specifies what index type is used to access the bitvector.
710 /// A name describing the dataflow analysis that this
711 /// `BitDenotation` is supporting. The name should be something
712 /// suitable for plugging in as part of a filename (i.e., avoid
713 /// space-characters or other things that tend to look bad on a
714 /// file system, like slashes or periods). It is also better for
715 /// the name to be reasonably short, again because it will be
716 /// plugged into a filename.
717 fn name() -> &'static str;
719 /// Size of each bitvector allocated for each block in the analysis.
720 fn bits_per_block(&self) -> usize;
722 /// Mutates the entry set according to the effects that
723 /// have been established *prior* to entering the start
724 /// block. This can't access the gen/kill sets, because
725 /// these won't be accounted for correctly.
727 /// (For example, establishing the call arguments.)
728 fn start_block_effect(&self, entry_set: &mut BitSet<Self::Idx>);
730 /// Similar to `statement_effect`, except it applies
731 /// *just before* the statement rather than *just after* it.
733 /// This matters for "dataflow at location" APIs, because the
734 /// before-statement effect is visible while visiting the
735 /// statement, while the after-statement effect only becomes
736 /// visible at the next statement.
738 /// Both the before-statement and after-statement effects are
739 /// applied, in that order, before moving for the next
741 fn before_statement_effect(&self, _trans: &mut GenKillSet<Self::Idx>, _location: Location) {}
743 /// Mutates the block-sets (the flow sets for the given
744 /// basic block) according to the effects of evaluating statement.
746 /// This is used, in particular, for building up the
747 /// "transfer-function" representing the overall-effect of the
748 /// block, represented via GEN and KILL sets.
750 /// The statement is identified as `bb_data[idx_stmt]`, where
751 /// `bb_data` is the sequence of statements identified by `bb` in
753 fn statement_effect(&self, trans: &mut GenKillSet<Self::Idx>, location: Location);
755 /// Similar to `terminator_effect`, except it applies
756 /// *just before* the terminator rather than *just after* it.
758 /// This matters for "dataflow at location" APIs, because the
759 /// before-terminator effect is visible while visiting the
760 /// terminator, while the after-terminator effect only becomes
761 /// visible at the terminator's successors.
763 /// Both the before-terminator and after-terminator effects are
764 /// applied, in that order, before moving for the next
766 fn before_terminator_effect(&self, _trans: &mut GenKillSet<Self::Idx>, _location: Location) {}
768 /// Mutates the block-sets (the flow sets for the given
769 /// basic block) according to the effects of evaluating
772 /// This is used, in particular, for building up the
773 /// "transfer-function" representing the overall-effect of the
774 /// block, represented via GEN and KILL sets.
776 /// The effects applied here cannot depend on which branch the
778 fn terminator_effect(&self, trans: &mut GenKillSet<Self::Idx>, location: Location);
780 /// Mutates the block-sets according to the (flow-dependent)
781 /// effect of a successful return from a Call terminator.
783 /// If basic-block BB_x ends with a call-instruction that, upon
784 /// successful return, flows to BB_y, then this method will be
785 /// called on the exit flow-state of BB_x in order to set up the
786 /// entry flow-state of BB_y.
788 /// This is used, in particular, as a special case during the
789 /// "propagate" loop where all of the basic blocks are repeatedly
790 /// visited. Since the effects of a Call terminator are
791 /// flow-dependent, the current MIR cannot encode them via just
792 /// GEN and KILL sets attached to the block, and so instead we add
793 /// this extra machinery to represent the flow-dependent effect.
795 // FIXME: right now this is a bit of a wart in the API. It might
796 // be better to represent this as an additional gen- and
797 // kill-sets associated with each edge coming out of the basic
799 fn propagate_call_return(
801 in_out: &mut BitSet<Self::Idx>,
802 call_bb: mir::BasicBlock,
803 dest_bb: mir::BasicBlock,
804 dest_place: &mir::Place<'tcx>,
808 impl<'a, 'tcx, D> DataflowAnalysis<'a, 'tcx, D>
810 D: BitDenotation<'tcx>,
813 body: &'a Body<'tcx>,
814 dead_unwinds: &'a BitSet<mir::BasicBlock>,
817 let bits_per_block = denotation.bits_per_block();
818 let num_blocks = body.basic_blocks().len();
820 let on_entry = if D::BOTTOM_VALUE {
821 vec![BitSet::new_filled(bits_per_block); num_blocks]
823 vec![BitSet::new_empty(bits_per_block); num_blocks]
825 let nop = GenKill::from_elem(HybridBitSet::new_empty(bits_per_block));
830 flow_state: DataflowState {
831 sets: AllSets { bits_per_block, on_entry, trans: vec![nop; num_blocks] },
832 operator: denotation,
838 impl<'a, 'tcx, D> DataflowAnalysis<'a, 'tcx, D>
840 D: BitDenotation<'tcx>,
842 /// Propagates the bits of `in_out` into all the successors of `bb`,
843 /// using bitwise operator denoted by `self.operator`.
845 /// For most blocks, this is entirely uniform. However, for blocks
846 /// that end with a call terminator, the effect of the call on the
847 /// dataflow state may depend on whether the call returned
848 /// successfully or unwound.
850 /// To reflect this, the `propagate_call_return` method of the
851 /// `BitDenotation` mutates `in_out` when propagating `in_out` via
852 /// a call terminator; such mutation is performed *last*, to
853 /// ensure its side-effects do not leak elsewhere (e.g., into
855 fn propagate_bits_into_graph_successors_of(
857 in_out: &mut BitSet<D::Idx>,
858 (bb, bb_data): (mir::BasicBlock, &mir::BasicBlockData<'tcx>),
859 dirty_list: &mut WorkQueue<mir::BasicBlock>,
861 match bb_data.terminator().kind {
862 mir::TerminatorKind::Return
863 | mir::TerminatorKind::Resume
864 | mir::TerminatorKind::Abort
865 | mir::TerminatorKind::GeneratorDrop
866 | mir::TerminatorKind::Unreachable => {}
867 mir::TerminatorKind::Goto { target }
868 | mir::TerminatorKind::Assert { target, cleanup: None, .. }
869 | mir::TerminatorKind::Yield { resume: target, drop: None, .. }
870 | mir::TerminatorKind::Drop { target, location: _, unwind: None }
871 | mir::TerminatorKind::DropAndReplace { target, value: _, location: _, unwind: None } =>
873 self.propagate_bits_into_entry_set_for(in_out, target, dirty_list);
875 mir::TerminatorKind::Yield { resume: target, drop: Some(drop), .. } => {
876 self.propagate_bits_into_entry_set_for(in_out, target, dirty_list);
877 self.propagate_bits_into_entry_set_for(in_out, drop, dirty_list);
879 mir::TerminatorKind::Assert { target, cleanup: Some(unwind), .. }
880 | mir::TerminatorKind::Drop { target, location: _, unwind: Some(unwind) }
881 | mir::TerminatorKind::DropAndReplace {
885 unwind: Some(unwind),
887 self.propagate_bits_into_entry_set_for(in_out, target, dirty_list);
888 if !self.dead_unwinds.contains(bb) {
889 self.propagate_bits_into_entry_set_for(in_out, unwind, dirty_list);
892 mir::TerminatorKind::SwitchInt { ref targets, .. } => {
893 for target in targets {
894 self.propagate_bits_into_entry_set_for(in_out, *target, dirty_list);
897 mir::TerminatorKind::Call { cleanup, ref destination, .. } => {
898 if let Some(unwind) = cleanup {
899 if !self.dead_unwinds.contains(bb) {
900 self.propagate_bits_into_entry_set_for(in_out, unwind, dirty_list);
903 if let Some((ref dest_place, dest_bb)) = *destination {
904 // N.B.: This must be done *last*, after all other
905 // propagation, as documented in comment above.
906 self.flow_state.operator.propagate_call_return(in_out, bb, dest_bb, dest_place);
907 self.propagate_bits_into_entry_set_for(in_out, dest_bb, dirty_list);
910 mir::TerminatorKind::FalseEdges { real_target, imaginary_target } => {
911 self.propagate_bits_into_entry_set_for(in_out, real_target, dirty_list);
912 self.propagate_bits_into_entry_set_for(in_out, imaginary_target, dirty_list);
914 mir::TerminatorKind::FalseUnwind { real_target, unwind } => {
915 self.propagate_bits_into_entry_set_for(in_out, real_target, dirty_list);
916 if let Some(unwind) = unwind {
917 if !self.dead_unwinds.contains(bb) {
918 self.propagate_bits_into_entry_set_for(in_out, unwind, dirty_list);
925 fn propagate_bits_into_entry_set_for(
927 in_out: &BitSet<D::Idx>,
929 dirty_queue: &mut WorkQueue<mir::BasicBlock>,
931 let entry_set = self.flow_state.sets.entry_set_mut_for(bb.index());
932 let set_changed = self.flow_state.operator.join(entry_set, &in_out);
934 dirty_queue.insert(bb);