Convert MIR BasicBlocks to ExtendedBasicBlocks

src/liballoc/heap.rs

@@ -130,7 +130,7 @@ pub const EMPTY: *mut () = 0x1 as *mut ();
 // This function must not unwind. If it does, MIR trans will fail.
 #[cfg(not(test))]
 #[lang = "exchange_malloc"]
-#[inline]
+#[inline(never)]
 unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
     if size == 0 {
         EMPTY as *mut u8

src/librustc/mir/cache.rs

@@ -11,13 +11,14 @@
 use std::cell::{Ref, RefCell};
 use rustc_data_structures::indexed_vec::IndexVec;
 
-use mir::{Mir, BasicBlock};
+use mir::{Mir, Block};
 
 use rustc_serialize as serialize;
 
 #[derive(Clone, Debug)]
 pub struct Cache {
-    predecessors: RefCell<Option<IndexVec<BasicBlock, Vec<BasicBlock>>>>
+    predecessors: RefCell<Option<IndexVec<Block, Vec<Block>>>>,
+    successors: RefCell<Option<IndexVec<Block, Vec<Block>>>>,
 }
 
 
@@ -37,30 +38,57 @@ impl serialize::Decodable for Cache {
 impl Cache {
     pub fn new() -> Self {
         Cache {
-            predecessors: RefCell::new(None)
+            predecessors: RefCell::new(None),
+            successors: RefCell::new(None)
         }
     }
 
     pub fn invalidate(&self) {
         // FIXME: consider being more fine-grained
         *self.predecessors.borrow_mut() = None;
+        *self.successors.borrow_mut() = None;
     }
 
-    pub fn predecessors(&self, mir: &Mir) -> Ref<IndexVec<BasicBlock, Vec<BasicBlock>>> {
+    pub fn predecessors(&self, mir: &Mir) -> Ref<IndexVec<Block, Vec<Block>>> {
         if self.predecessors.borrow().is_none() {
-            *self.predecessors.borrow_mut() = Some(calculate_predecessors(mir));
+            *self.predecessors.borrow_mut() = Some(self.calculate_predecessors(mir));
         }
 
         Ref::map(self.predecessors.borrow(), |p| p.as_ref().unwrap())
     }
+
+    fn calculate_predecessors(&self, mir: &Mir) -> IndexVec<Block, Vec<Block>> {
+        let mut result = IndexVec::from_elem(vec![], mir.basic_blocks());
+        for (bb, bbs) in self.successors(mir).iter_enumerated() {
+            for &tgt in bbs {
+                result[tgt].push(bb);
+            }
+        }
+
+        result
+    }
+
+    pub fn successors(&self, mir: &Mir) -> Ref<IndexVec<Block, Vec<Block>>> {
+        if self.successors.borrow().is_none() {
+            *self.successors.borrow_mut() = Some(calculate_successors(mir));
+        }
+
+        Ref::map(self.successors.borrow(), |p| p.as_ref().unwrap())
+    }
 }
 
-fn calculate_predecessors(mir: &Mir) -> IndexVec<BasicBlock, Vec<BasicBlock>> {
+fn calculate_successors(mir: &Mir) -> IndexVec<Block, Vec<Block>> {
     let mut result = IndexVec::from_elem(vec![], mir.basic_blocks());
     for (bb, data) in mir.basic_blocks().iter_enumerated() {
+        for stmt in &data.statements {
+            if let Some(cleanup) = stmt.cleanup_target() {
+                result[bb].push(cleanup);
+            }
+        }
+
         if let Some(ref term) = data.terminator {
             for &tgt in term.successors().iter() {
-                result[tgt].push(bb);
+                result[bb].push(tgt);
             }
         }
     }