Account for new maybe_sideeffect helper that requires predecessors

Author: Nashenas88

src/librustc/mir/cache.rs

@@ -47,8 +47,7 @@ impl Cache {
     }
 
     #[inline]
-    /// This will recompute the predecessors cache if it is not available
-    pub fn predecessors(&mut self, body: &Body<'_>) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
+    pub fn ensure_predecessors(&mut self, body: &Body<'_>) {
         if self.predecessors.is_none() {
             let mut result = IndexVec::from_elem(vec![], body.basic_blocks());
             for (bb, data) in body.basic_blocks().iter_enumerated() {
@@ -61,7 +60,12 @@ impl Cache {
 
             self.predecessors = Some(result)
         }
+    }
 
+    #[inline]
+    /// This will recompute the predecessors cache if it is not available
+    pub fn predecessors(&mut self, body: &Body<'_>) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
+        self.ensure_predecessors(body);
         self.predecessors.as_ref().unwrap()
     }
 
@@ -70,6 +74,11 @@ impl Cache {
         &self.predecessors(body)[bb]
     }
 
+    #[inline]
+    fn unwrap_predecessors_for(&self, bb: BasicBlock) -> &[BasicBlock] {
+        &self.predecessors.as_ref().unwrap()[bb]
+    }
+
     #[inline]
     pub fn predecessor_locations<'a>(&'a mut self, loc: Location, body: &'a Body<'a>) -> impl Iterator<Item = Location> + 'a {
         let if_zero_locations = if loc.statement_index == 0 {
@@ -137,13 +146,17 @@ impl<'a, 'tcx> BodyCache<&'a Body<'tcx>> {
     }
 
     #[inline]
-    pub fn basic_blocks(&self) -> &IndexVec<BasicBlock, BasicBlockData<'tcx>> {
-        &self.body.basic_blocks
+    pub fn read_only(mut self) -> ReadOnlyBodyCache<'a, 'tcx> {
+        self.cache.ensure_predecessors(self.body);
+        ReadOnlyBodyCache {
+            cache: self.cache,
+            body: self.body,
+        }
     }
 
     #[inline]
-    pub fn dominators(&mut self) -> Dominators<BasicBlock> {
-        dominators(self)
+    pub fn basic_blocks(&self) -> &IndexVec<BasicBlock, BasicBlockData<'tcx>> {
+        &self.body.basic_blocks
     }
 }
 
@@ -164,50 +177,6 @@ impl<'a, 'tcx> Index<BasicBlock> for BodyCache<&'a Body<'tcx>> {
     }
 }
 
-impl<'a, 'tcx> graph::DirectedGraph for BodyCache<&'a Body<'tcx>> {
-    type Node = BasicBlock;
-}
-
-impl<'a, 'graph, 'tcx> graph::GraphPredecessors<'graph> for BodyCache<&'a Body<'tcx>> {
-    type Item = BasicBlock;
-    type Iter = IntoIter<BasicBlock>;
-}
-
-impl<'a, 'tcx> graph::WithPredecessors for BodyCache<&'a Body<'tcx>> {
-    fn predecessors(
-        &mut self,
-        node: Self::Node,
-    ) -> <Self as GraphPredecessors<'_>>::Iter {
-        self.predecessors_for(node).to_vec().into_iter()
-    }
-}
-
-impl<'a, 'tcx> graph::WithNumNodes for BodyCache<&'a Body<'tcx>> {
-    fn num_nodes(&self) -> usize {
-        self.body.num_nodes()
-    }
-}
-
-impl<'a, 'tcx> graph::WithStartNode for BodyCache<&'a Body<'tcx>> {
-    fn start_node(&self) -> Self::Node {
-        self.body.start_node()
-    }
-}
-
-impl<'a, 'tcx> graph::WithSuccessors for BodyCache<&'a Body<'tcx>> {
-    fn successors(
-        &self,
-        node: Self::Node,
-    ) -> <Self as GraphSuccessors<'_>>::Iter {
-        self.body.successors(node)
-    }
-}
-
-impl<'a, 'b, 'tcx> graph::GraphSuccessors<'b> for BodyCache<&'a Body<'tcx>> {
-    type Item = BasicBlock;
-    type Iter = iter::Cloned<Successors<'b>>;
-}
-
 impl<'a, 'tcx> BodyCache<&'a mut Body<'tcx>> {
     #[inline]
     pub fn body(&self) -> &Body<'tcx> {
@@ -259,3 +228,99 @@ impl<'a, 'tcx> IndexMut<BasicBlock> for BodyCache<&'a mut Body<'tcx>> {
         &mut self.body.basic_blocks[index]
     }
 }
+
+pub struct ReadOnlyBodyCache<'a, 'tcx> {
+    cache: Cache,
+    body: &'a Body<'tcx>,
+}
+
+impl ReadOnlyBodyCache<'a, 'tcx> {
+    #[inline]
+    pub fn predecessors_for(&self, bb: BasicBlock) -> &[BasicBlock] {
+        self.cache.unwrap_predecessors_for(bb)
+    }
+
+    #[inline]
+    pub fn body(&self) -> &'a Body<'tcx> {
+        self.body
+    }
+
+    #[inline]
+    pub fn basic_blocks(&self) -> &IndexVec<BasicBlock, BasicBlockData<'tcx>> {
+        &self.body.basic_blocks
+    }
+
+    #[inline]
+    pub fn dominators(&self) -> Dominators<BasicBlock> {
+        dominators(self)
+    }
+
+    pub fn to_owned(self) -> BodyCache<&'a Body<'tcx>> {
+        BodyCache {
+            cache: self.cache,
+            body: self.body,
+        }
+    }
+}
+
+impl graph::DirectedGraph for ReadOnlyBodyCache<'a, 'tcx> {
+    type Node = BasicBlock;
+}
+
+impl graph::GraphPredecessors<'graph> for ReadOnlyBodyCache<'a, 'tcx> {
+    type Item = BasicBlock;
+    type Iter = IntoIter<BasicBlock>;
+}
+
+impl graph::WithPredecessors for ReadOnlyBodyCache<'a, 'tcx> {
+    fn predecessors(
+        &self,
+        node: Self::Node,
+    ) -> <Self as GraphPredecessors<'_>>::Iter {
+        self.cache.unwrap_predecessors_for(node).to_vec().into_iter()
+    }
+}
+
+impl graph::WithNumNodes for ReadOnlyBodyCache<'a, 'tcx> {
+    fn num_nodes(&self) -> usize {
+        self.body.num_nodes()
+    }
+}
+
+impl graph::WithStartNode for ReadOnlyBodyCache<'a, 'tcx> {
+    fn start_node(&self) -> Self::Node {
+        self.body.start_node()
+    }
+}
+
+impl graph::WithSuccessors for ReadOnlyBodyCache<'a, 'tcx> {
+    fn successors(
+        &self,
+        node: Self::Node,
+    ) -> <Self as GraphSuccessors<'_>>::Iter {
+        self.body.successors(node)
+    }
+}
+
+impl<'a, 'b, 'tcx> graph::GraphSuccessors<'b> for ReadOnlyBodyCache<'a, 'tcx> {
+    type Item = BasicBlock;
+    type Iter = iter::Cloned<Successors<'b>>;
+}
+
+
+impl Deref for ReadOnlyBodyCache<'a, 'tcx> {
+    type Target = Body<'tcx>;
+
+    fn deref(&self) -> &Self::Target {
+        self.body
+    }
+}
+
+impl Index<BasicBlock> for ReadOnlyBodyCache<'a, 'tcx> {
+    type Output = BasicBlockData<'tcx>;
+
+    #[inline]
+    fn index(&self, index: BasicBlock) -> &BasicBlockData<'tcx> {
+        &self.body[index]
+    }
+}

src/librustc/mir/mod.rs

@@ -38,7 +38,7 @@ use syntax::symbol::Symbol;
 use syntax_pos::{Span, DUMMY_SP};
 
 pub use crate::mir::interpret::AssertMessage;
-pub use crate::mir::cache::BodyCache;
+pub use crate::mir::cache::{BodyCache, ReadOnlyBodyCache};
 
 pub mod cache;
 pub mod interpret;
@@ -2600,7 +2600,7 @@ impl Location {
     pub fn is_predecessor_of<'tcx>(
         &self,
         other: Location,
-        mut body_cache: BodyCache<&'_ Body<'tcx>>
+        body_cache: &ReadOnlyBodyCache<'_, 'tcx>
     ) -> bool {
         // If we are in the same block as the other location and are an earlier statement
         // then we are a predecessor of `other`.

src/librustc/mir/visit.rs

@@ -65,6 +65,15 @@ use syntax_pos::Span;
 // variant argument) that does not require visiting, as in
 // `is_cleanup` above.
 
+macro_rules! body_cache_type {
+    (mut $a:lifetime, $tcx:lifetime) => {
+        &mut BodyCache<& $a mut Body<$tcx>>
+    };
+    ($a:lifetime, $tcx:lifetime) => {
+        &ReadOnlyBodyCache<$a, $tcx>
+    };
+}
+
 macro_rules! make_mir_visitor {
     ($visitor_trait_name:ident, $($mutability:ident)?) => {
         pub trait $visitor_trait_name<'tcx> {
@@ -73,7 +82,7 @@ macro_rules! make_mir_visitor {
 
             fn visit_body(
                 &mut self,
-                body_cache: & $($mutability)? BodyCache<&'_ $($mutability)? Body<'tcx>>
+                body_cache: body_cache_type!($($mutability)? '_, 'tcx)
             ) {
                 self.super_body(body_cache);
             }
@@ -245,7 +254,7 @@ macro_rules! make_mir_visitor {
 
             fn super_body(
                 &mut self,
-                body_cache: & $($mutability)? BodyCache<&'_ $($mutability)? Body<'tcx>>
+                body_cache: body_cache_type!($($mutability)? '_, 'tcx)
             ) {
                 macro_rules! body {
                     (mut) => (body_cache.body_mut());

src/librustc_codegen_ssa/mir/analyze.rs

@@ -4,7 +4,7 @@
 use rustc_index::bit_set::BitSet;
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_index::vec::{Idx, IndexVec};
-use rustc::mir::{self, Body, BodyCache, Location, TerminatorKind};
+use rustc::mir::{self, Location, TerminatorKind};
 use rustc::mir::visit::{
     Visitor, PlaceContext, MutatingUseContext, NonMutatingUseContext, NonUseContext,
 };
@@ -16,15 +16,14 @@ use syntax_pos::DUMMY_SP;
 use super::FunctionCx;
 use crate::traits::*;
 
-pub fn non_ssa_locals<'a, 'b, 'c, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
-    fx: &FunctionCx<'a, 'b, 'tcx, Bx>,
-    mir: &'c mut BodyCache<&'b Body<'tcx>>,
+pub fn non_ssa_locals<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
+    fx: &FunctionCx<'a, 'b, 'tcx, Bx>
 ) -> BitSet<mir::Local> {
-    let mut analyzer = LocalAnalyzer::new(fx, mir);
+    let mut analyzer = LocalAnalyzer::new(fx);
 
-    analyzer.visit_body(mir);
+    analyzer.visit_body(fx.mir);
 
-    for (local, decl) in mir.local_decls.iter_enumerated()
+    for (local, decl) in fx.mir.local_decls.iter_enumerated()
     {
         // FIXME(eddyb): We should figure out how to use llvm.dbg.value instead
         // of putting everything in allocas just so we can use llvm.dbg.declare.
@@ -66,20 +65,20 @@ struct LocalAnalyzer<'mir, 'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {
     first_assignment: IndexVec<mir::Local, Location>,
 }
 
-impl<'mir, 'a, 'b, 'c, 'tcx, Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'b, 'tcx, Bx> {
-    fn new(fx: &'mir FunctionCx<'a, 'b, 'tcx, Bx>, mir: &'c mut BodyCache<&'b Body<'tcx>>) -> Self {
+impl<'mir, 'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'b, 'tcx, Bx> {
+    fn new(fx: &'mir FunctionCx<'a, 'b, 'tcx, Bx>) -> Self {
         let invalid_location =
-            mir::BasicBlock::new(mir.basic_blocks().len()).start_location();
-        let dominators = mir.dominators();
+            mir::BasicBlock::new(fx.mir.basic_blocks().len()).start_location();
+        let dominators = fx.mir.dominators();
         let mut analyzer = LocalAnalyzer {
             fx,
             dominators,
-            non_ssa_locals: BitSet::new_empty(mir.local_decls.len()),
-            first_assignment: IndexVec::from_elem(invalid_location, &mir.local_decls)
+            non_ssa_locals: BitSet::new_empty(fx.mir.local_decls.len()),
+            first_assignment: IndexVec::from_elem(invalid_location, &fx.mir.local_decls)
         };
 
         // Arguments get assigned to by means of the function being called
-        for arg in mir.args_iter() {
+        for arg in fx.mir.args_iter() {
             analyzer.first_assignment[arg] = mir::START_BLOCK.start_location();
         }
 
@@ -131,7 +130,7 @@ impl<'mir, 'a, 'b, 'c, 'tcx, Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, '
             };
             if is_consume {
                 let base_ty =
-                    mir::Place::ty_from(place_ref.base, proj_base, self.fx.mir, cx.tcx());
+                    mir::Place::ty_from(place_ref.base, proj_base, self.fx.mir.body(), cx.tcx());
                 let base_ty = self.fx.monomorphize(&base_ty);
 
                 // ZSTs don't require any actual memory access.