Merge branch 'dominator-cache3' of github.com:scottcarr/rust into dominator-cache

Author: scottcarr

src/librustc/mir/cache.rs

@@ -10,8 +10,6 @@
 
 use std::cell::{Ref, RefCell};
 use rustc_data_structures::indexed_vec::IndexVec;
-use rustc_data_structures::graph_algorithms::dominators::{Dominators, dominators};
-use mir::mir_cfg::MirCfg;
 
 use mir::repr::{Mir, BasicBlock};
 
@@ -20,7 +18,6 @@ use rustc_serialize as serialize;
 #[derive(Clone)]
 pub struct Cache {
     predecessors: RefCell<Option<IndexVec<BasicBlock, Vec<BasicBlock>>>>,
-    dominators: RefCell<Option<Dominators<MirCfg>>>,
 }
 
 
@@ -40,7 +37,6 @@ impl Cache {
     pub fn new() -> Self {
         Cache {
             predecessors: RefCell::new(None),
-            dominators: RefCell::new(None),
         }
     }
 
@@ -56,14 +52,6 @@ impl Cache {
 
         Ref::map(self.predecessors.borrow(), |p| p.as_ref().unwrap())
     }
-
-    pub fn dominators(&self, mir: &Mir) -> Ref<Dominators<MirCfg>> {
-        if self.dominators.borrow().is_none() {
-            *self.dominators.borrow_mut() = Some(calculate_dominators(mir, self));
-        }
-
-        Ref::map(self.dominators.borrow(), |p| p.as_ref().unwrap())
-    }
 }
 
 fn calculate_predecessors(mir: &Mir) -> IndexVec<BasicBlock, Vec<BasicBlock>> {
@@ -78,8 +66,3 @@ fn calculate_predecessors(mir: &Mir) -> IndexVec<BasicBlock, Vec<BasicBlock>> {
 
     result
 }
-
-fn calculate_dominators(mir: &Mir, cache: &Cache) -> Dominators<MirCfg> {
-    let m = MirCfg::new(mir, cache);
-    dominators(&m)
-}

src/librustc/mir/repr.rs

@@ -12,6 +12,8 @@ use graphviz::IntoCow;
 use middle::const_val::ConstVal;
 use rustc_const_math::{ConstUsize, ConstInt, ConstMathErr};
 use rustc_data_structures::indexed_vec::{IndexVec, Idx};
+use rustc_data_structures::graph_algorithms::dominators::{Dominators, dominators};
+use rustc_data_structures::graph_algorithms::{Graph, GraphPredecessors, GraphSuccessors};
 use hir::def_id::DefId;
 use ty::subst::Substs;
 use ty::{self, AdtDef, ClosureSubsts, FnOutput, Region, Ty};
@@ -144,6 +146,16 @@ impl<'tcx> Mir<'tcx> {
     pub fn predecessors_for(&self, bb: BasicBlock) -> Ref<Vec<BasicBlock>> {
         Ref::map(self.predecessors(), |p| &p[bb])
     }
+<<<<<<< HEAD
+=======
+
+    #[inline]
+    //pub fn dominators(&'tcx self) -> Ref<Dominators<Self>> {
+    pub fn dominators(&self) -> Dominators<Self> {
+        //self.cache.dominators(self)
+        dominators(self)
+    }
+>>>>>>> 1cc95c9c198110db2840e76e0a00015ac39785f8
 }
 
 impl<'tcx> Index<BasicBlock> for Mir<'tcx> {
@@ -1167,3 +1179,32 @@ fn node_to_string(node_id: ast::NodeId) -> String {
 fn item_path_str(def_id: DefId) -> String {
     ty::tls::with(|tcx| tcx.item_path_str(def_id))
 }
+impl<'tcx> Graph for Mir<'tcx> {
+
+    type Node = BasicBlock;
+
+    fn num_nodes(&self) -> usize { self.basic_blocks.len() }
+
+    fn start_node(&self) -> Self::Node { START_BLOCK }
+
+    fn predecessors<'graph>(&'graph self, node: Self::Node)
+                            -> <Self as GraphPredecessors<'graph>>::Iter
+    {
+        self.predecessors_for(node).clone().into_iter()
+    }
+    fn successors<'graph>(&'graph self, node: Self::Node)
+                          -> <Self as GraphSuccessors<'graph>>::Iter
+    {
+        self.basic_blocks[node].terminator().successors().into_owned().into_iter()
+    }
+}
+
+impl<'a, 'b> GraphPredecessors<'b> for Mir<'a> {
+    type Item = BasicBlock;
+    type Iter = std::vec::IntoIter<BasicBlock>;
+}
+
+impl<'a, 'b>  GraphSuccessors<'b> for Mir<'a> {
+    type Item = BasicBlock;
+    type Iter = std::vec::IntoIter<BasicBlock>;
+}

src/librustc_data_structures/graph_algorithms/mod.rs

@@ -9,6 +9,11 @@
 // except according to those terms.
 
 use super::indexed_vec::Idx;
+use core::marker::{PhantomData};
+pub use std::slice::Iter;
+use std::ops::{Index, IndexMut};
+use std::clone::Clone;
+use std;
 
 //pub mod bit_set;
 pub mod dominators;
@@ -24,15 +29,20 @@ mod test;
 pub trait Graph
     where Self: for<'graph> GraphPredecessors<'graph, Item=<Self as Graph>::Node>,
           Self: for<'graph> GraphSuccessors<'graph, Item=<Self as Graph>::Node>
+    //where Self: Sized
 {
     type Node: Idx;
 
     fn num_nodes(&self) -> usize;
     fn start_node(&self) -> Self::Node;
     fn predecessors<'graph>(&'graph self, node: Self::Node)
                             -> <Self as GraphPredecessors<'graph>>::Iter;
+                            // why is returning an iterator so complicated?
+                            //-> NodeVec<Self, Self::Node>;
     fn successors<'graph>(&'graph self, node: Self::Node)
                             -> <Self as GraphSuccessors<'graph>>::Iter;
+                            //-> NodeVec<Self, Self::Node>;
+                            //-> std::slice::Iter<'graph, Self::Node>;
 }
 
 pub trait GraphPredecessors<'graph> {
@@ -51,3 +61,80 @@ pub trait GraphSuccessors<'graph> {
 //    }
 //}
 
+//#[derive(Clone, Debug)]
+//pub struct NodeVec<G: Graph, T> {
+//    pub vec: Vec<T>,
+//    graph: PhantomData<G>,
+//}
+//
+//impl<G: Graph, T: Clone> NodeVec<G, T> {
+//    pub fn from_elem(graph: &G, default: &T) -> Self {
+//        NodeVec::from_fn(graph, |_| default.clone())
+//    }
+//
+//    pub fn from_elem_with_len(num_nodes: usize, default: &T) -> Self {
+//        NodeVec::from_fn_with_len(num_nodes, |_| default.clone())
+//    }
+//}
+//
+//impl<G: Graph, T: Default> NodeVec<G, T> {
+//    pub fn from_default(graph: &G) -> Self {
+//        NodeVec::from_fn(graph, |_| T::default())
+//    }
+//
+//    pub fn from_default_with_len(num_nodes: usize) -> Self {
+//        NodeVec::from_fn_with_len(num_nodes, |_| T::default())
+//    }
+//}
+//
+//impl<G: Graph, T> NodeVec<G, T> {
+//    pub fn from_vec(v: Vec<T>) -> Self 
+//        where T: Clone
+//    {
+//
+//        NodeVec {
+//            vec: v.clone(),
+//            graph: PhantomData,
+//        }
+//    }
+//
+//    pub fn from_fn<F>(graph: &G, f: F) -> Self
+//        where F: FnMut(G::Node) -> T
+//    {
+//        Self::from_fn_with_len(graph.num_nodes(), f)
+//    }
+//
+//    pub fn from_fn_with_len<F>(num_nodes: usize, f: F) -> Self
+//        where F: FnMut(G::Node) -> T
+//    {
+//        NodeVec {
+//            vec: (0..num_nodes).map(G::Node::new).map(f).collect(),
+//            graph: PhantomData,
+//        }
+//    }
+//
+//    pub fn iter(&self) -> Iter<T> {
+//        self.vec.iter()
+//    }
+//
+//    pub fn len(&self) -> usize {
+//        self.vec.len()
+//    }
+//}
+//
+//impl<G: Graph, T> Index<G::Node> for NodeVec<G, T> {
+//    type Output = T;
+//
+//    fn index(&self, index: G::Node) -> &T {
+//        let index: usize = index.index();
+//        &self.vec[index]
+//    }
+//}
+//
+//impl<G: Graph, T> IndexMut<G::Node> for NodeVec<G, T> {
+//    fn index_mut(&mut self, index: G::Node) -> &mut T {
+//        let index: usize = index.index();
+//        &mut self.vec[index]
+//    }
+//}
+