Ensure predecessors are recomputed at critical points, fixes panics

Author: Nashenas88

src/librustc/mir/mod.rs

@@ -210,12 +210,14 @@ impl<'tcx> Body<'tcx> {
         &mut self, bb: BasicBlock
     ) -> &mut Option<Terminator<'tcx>> {
         // FIXME we should look into improving the cache invalidation
+        debug!("Invalidating predecessors cache through opt terminator for block at : {:?}", self.span.data());
         self.predecessors_cache = None;
         &mut self.basic_blocks[bb].terminator
     }
 
     pub fn basic_block_terminator_mut(&mut self, bb: BasicBlock) -> &mut Terminator<'tcx> {
         // FIXME we should look into improving the cache invalidation
+        debug!("Invalidating predecessors cache through terminator for block at : {:?}", self.span.data());
         self.predecessors_cache = None;
         self.basic_blocks[bb].terminator_mut()
     }
@@ -229,36 +231,35 @@ impl<'tcx> Body<'tcx> {
 
     #[inline]
     pub fn unwrap_predecessors(&self) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
-        assert!(self.predecessors_cache.is_some());
+        assert!(self.predecessors_cache.is_some(), "Expected predecessors_cache to be `Some(...)` for block at: {:?}", self.span.data());
         self.predecessors_cache.as_ref().unwrap()
     }
 
     #[inline]
-    /// This will recompute the predecessors cache if it is not available
-    pub fn predecessors(&mut self) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
+    pub fn ensure_predecessors(&mut self) {
         if self.predecessors_cache.is_none() {
-            self.predecessors_cache = Some(self.calculate_predecessors())
-        }
-
-        self.predecessors_cache.as_ref().unwrap()
-    }
-
-    fn calculate_predecessors(&self) -> IndexVec<BasicBlock, Vec<BasicBlock>> {
-        let mut result = IndexVec::from_elem(vec![], self.basic_blocks());
-        for (bb, data) in self.basic_blocks().iter_enumerated() {
-            if let Some(ref term) = data.terminator {
-                for &tgt in term.successors() {
-                    result[tgt].push(bb);
+            let mut result = IndexVec::from_elem(vec![], self.basic_blocks());
+            for (bb, data) in self.basic_blocks().iter_enumerated() {
+                if let Some(ref term) = data.terminator {
+                    for &tgt in term.successors() {
+                        result[tgt].push(bb);
+                    }
                 }
             }
+
+            self.predecessors_cache = Some(result)
         }
+    }
 
-        result
+    #[inline]
+    /// This will recompute the predecessors cache if it is not available
+    pub fn predecessors(&mut self) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
+        self.ensure_predecessors();
+        self.predecessors_cache.as_ref().unwrap()
     }
 
     #[inline]
     pub fn predecessors_for(&self, bb: BasicBlock) -> &[BasicBlock] {
-        // FIXME(nashenas88) could this be predecessors sometimes too?
         &self.unwrap_predecessors()[bb]
     }
 

src/librustc_mir/shim.rs

@@ -123,6 +123,8 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceDef<'tcx>) -> &'tcx
         &add_call_guards::CriticalCallEdges,
     ]);
 
+    result.ensure_predecessors();
+
     debug!("make_shim({:?}) = {:?}", instance, result);
 
     tcx.arena.alloc(result)
@@ -909,12 +911,13 @@ pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> &Body<'_> {
         is_cleanup: false
     };
 
-    let body = new_body(
+    let mut body = new_body(
         IndexVec::from_elem_n(start_block, 1),
         local_decls,
         sig.inputs().len(),
         span,
     );
+    body.ensure_predecessors();
 
     crate::util::dump_mir(
         tcx,

src/librustc_mir/transform/ensure_predecessors_cache.rs

@@ -2,14 +2,25 @@ use rustc::mir::Body;
 use rustc::ty::TyCtxt;
 use crate::transform::{MirPass, MirSource};
 
-pub struct EnsurePredecessorsCache;
+pub struct EnsurePredecessorsCache {
+    label: String,
+}
+
+impl EnsurePredecessorsCache {
+    pub fn new<S: Into<String>>(label: S) -> Self {
+        Self {
+            label: label.into(),
+        }
+    }
+}
 
 impl<'tcx> MirPass<'tcx> for EnsurePredecessorsCache {
     fn run_pass(&self, _: TyCtxt<'tcx>, _: MirSource<'tcx>, body: &mut Body<'tcx>) {
+        debug!("{}: Ensure predecessors cache: {:?}", self.label, body.span.data());
         // predecessors is lazily calculated. We want to ensure that the cache is properly filled
-        // before the next stages of compilation, since thise following stages will only be allowed
+        // before the next stages of compilation, since these following stages will only be allowed
         // to read the cache and not generate it. If the cache is already up to date, this line is
         // a nop.
-        let _predecessors = body.predecessors();
+        body.ensure_predecessors();
     }
 }

src/librustc_mir/transform/mod.rs

@@ -249,6 +249,7 @@ fn mir_validated(
         // What we need to run borrowck etc.
         &promote_pass,
         &simplify::SimplifyCfg::new("qualify-consts"),
+        &ensure_predecessors_cache::EnsurePredecessorsCache::new("qualify-consts"),
     ]);
     let promoted = promote_pass.promoted_fragments.into_inner();
     (tcx.alloc_steal_mir(body), tcx.alloc_steal_promoted(promoted))
@@ -296,6 +297,8 @@ fn run_optimization_passes<'tcx>(
         &uniform_array_move_out::RestoreSubsliceArrayMoveOut::new(tcx),
         &inline::Inline,
 
+        // State transform requires that predecessors have been predefined
+        &ensure_predecessors_cache::EnsurePredecessorsCache::new("pre-state-transform"),
         // Lowering generator control-flow and variables
         // has to happen before we do anything else to them.
         &generator::StateTransform,
@@ -314,7 +317,7 @@ fn run_optimization_passes<'tcx>(
         &simplify::SimplifyLocals,
 
         &add_call_guards::CriticalCallEdges,
-        &ensure_predecessors_cache::EnsurePredecessorsCache,
+        &ensure_predecessors_cache::EnsurePredecessorsCache::new("before-opt-dump"),
         &dump_mir::Marker("PreCodegen"),
     ]);
 }