Add a MIR dataflow framework (again)

This time I opted for scaling back the list of features I intend to implement in order to get this
stuff land at all (or at least before 2020). Namely the list of features which got cut:

* Rewrites with arbitrary subgraphs. Instead this only implements a way to either remove a
  statement/terminator or replace it with another (or same) statement/terminator.
* Fueled rewriters, deep rewriters, a bunch of combinators;
* … I feel like there were many more, but 2AM does not blend well with trying to remember stuff.

Also includes a nicely working liveness pass. This pass removes all moves into unused variables and
thus allows to not translate a lot of unnecessary variables. This, even without move propagation of
some sort, should help a bit with translation times and maybe stack usage (esp. in debug builds).

This liveness pass is also a viable option for cleanup after other passes which would like to leave
stuff behind them (such as the move propagation pass).

Finally, the pass demonstrates the *backward* analysis, and also the bruteforce-ish algorithm to
discover all graph exits from MIR :)

Author: nagisa

src/librustc/mir/repr.rs

@@ -36,7 +36,7 @@ use super::cache::Cache;
 macro_rules! newtype_index {
     ($name:ident, $debug_name:expr) => (
         #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord,
-         RustcEncodable, RustcDecodable)]
+                 RustcEncodable, RustcDecodable)]
         pub struct $name(u32);
 
         impl Idx for $name {
@@ -725,7 +725,7 @@ newtype_index!(Local, "local");
 
 /// A path to a value; something that can be evaluated without
 /// changing or disturbing program state.
-#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable)]
+#[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
 pub enum Lvalue<'tcx> {
     /// local variable declared by the user
     Var(Var),
@@ -893,7 +893,7 @@ pub struct VisibilityScopeData {
 /// These are values that can appear inside an rvalue (or an index
 /// lvalue). They are intentionally limited to prevent rvalues from
 /// being nested in one another.
-#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable)]
+#[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
 pub enum Operand<'tcx> {
     Consume(Lvalue<'tcx>),
     Constant(Constant<'tcx>),

src/librustc/mir/tcx.rs

@@ -83,7 +83,7 @@ impl<'a, 'gcx, 'tcx> LvalueTy<'tcx> {
                                              variant_index: index }
                     }
                     _ => {
-                        bug!("cannot downcast non-enum type: `{:?}`", self)
+                        bug!("cannot downcast non-enum type: `{:?}` as `{:?}`", self, elem)
                     }
                 },
             ProjectionElem::Field(_, fty) => LvalueTy::Ty { ty: fty }

src/librustc/mir/visit.rs

@@ -7,6 +7,69 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
+//! # The MIR Visitor
+//!
+//! ## Overview
+//!
+//! There are two visitors, one for immutable and one for mutable references,
+//! but both are generated by the following macro. The code is written according
+//! to the following conventions:
+//!
+//! - introduce a `visit_foo` and a `super_foo` method for every MIR type
+//! - `visit_foo`, by default, calls `super_foo`
+//! - `super_foo`, by default, destructures the `foo` and calls `visit_foo`
+//!
+//! This allows you as a user to override `visit_foo` for types are
+//! interested in, and invoke (within that method) call
+//! `self.super_foo` to get the default behavior. Just as in an OO
+//! language, you should never call `super` methods ordinarily except
+//! in that circumstance.
+//!
+//! For the most part, we do not destructure things external to the
+//! MIR, e.g. types, spans, etc, but simply visit them and stop. This
+//! avoids duplication with other visitors like `TypeFoldable`. But
+//! there is one exception: we do destructure the `FnOutput` to reach
+//! the type within. Just because.
+//!
+//! ## Updating
+//!
+//! The code is written in a very deliberate style intended to minimize
+//! the chance of things being overlooked. You'll notice that we always
+//! use pattern matching to reference fields and we ensure that all
+//! matches are exhaustive.
+//!
+//! For example, the `super_basic_block_data` method begins like this:
+//!
+//! ```rust
+//! fn super_basic_block_data(&mut self,
+//!                           block: BasicBlock,
+//!                           data: & $($mutability)* BasicBlockData<'tcx>) {
+//!     let BasicBlockData {
+//!         ref $($mutability)* statements,
+//!         ref $($mutability)* terminator,
+//!         is_cleanup: _
+//!     } = *data;
+//!
+//!     for statement in statements {
+//!         self.visit_statement(block, statement);
+//!     }
+//!
+//!     ...
+//! }
+//! ```
+//!
+//! Here we used `let BasicBlockData { <fields> } = *data` deliberately,
+//! rather than writing `data.statements` in the body. This is because if one
+//! adds a new field to `BasicBlockData`, one will be forced to revise this code,
+//! and hence one will (hopefully) invoke the correct visit methods (if any).
+//!
+//! For this to work, ALL MATCHES MUST BE EXHAUSTIVE IN FIELDS AND VARIANTS.
+//! That means you never write `..` to skip over fields, nor do you write `_`
+//! to skip over variants in a `match`.
+//!
+//! The only place that `_` is acceptable is to match a field (or
+//! variant argument) that does not require visiting, as in
+//! `is_cleanup` above.
 
 use middle::const_val::ConstVal;
 use hir::def_id::DefId;
@@ -18,68 +81,6 @@ use rustc_data_structures::tuple_slice::TupleSlice;
 use rustc_data_structures::indexed_vec::Idx;
 use syntax_pos::Span;
 
-// # The MIR Visitor
-//
-// ## Overview
-//
-// There are two visitors, one for immutable and one for mutable references,
-// but both are generated by the following macro. The code is written according
-// to the following conventions:
-//
-// - introduce a `visit_foo` and a `super_foo` method for every MIR type
-// - `visit_foo`, by default, calls `super_foo`
-// - `super_foo`, by default, destructures the `foo` and calls `visit_foo`
-//
-// This allows you as a user to override `visit_foo` for types are
-// interested in, and invoke (within that method) call
-// `self.super_foo` to get the default behavior. Just as in an OO
-// language, you should never call `super` methods ordinarily except
-// in that circumstance.
-//
-// For the most part, we do not destructure things external to the
-// MIR, e.g. types, spans, etc, but simply visit them and stop. This
-// avoids duplication with other visitors like `TypeFoldable`.
-//
-// ## Updating
-//
-// The code is written in a very deliberate style intended to minimize
-// the chance of things being overlooked. You'll notice that we always
-// use pattern matching to reference fields and we ensure that all
-// matches are exhaustive.
-//
-// For example, the `super_basic_block_data` method begins like this:
-//
-// ```rust
-// fn super_basic_block_data(&mut self,
-//                           block: BasicBlock,
-//                           data: & $($mutability)* BasicBlockData<'tcx>) {
-//     let BasicBlockData {
-//         ref $($mutability)* statements,
-//         ref $($mutability)* terminator,
-//         is_cleanup: _
-//     } = *data;
-//
-//     for statement in statements {
-//         self.visit_statement(block, statement);
-//     }
-//
-//     ...
-// }
-// ```
-//
-// Here we used `let BasicBlockData { <fields> } = *data` deliberately,
-// rather than writing `data.statements` in the body. This is because if one
-// adds a new field to `BasicBlockData`, one will be forced to revise this code,
-// and hence one will (hopefully) invoke the correct visit methods (if any).
-//
-// For this to work, ALL MATCHES MUST BE EXHAUSTIVE IN FIELDS AND VARIANTS.
-// That means you never write `..` to skip over fields, nor do you write `_`
-// to skip over variants in a `match`.
-//
-// The only place that `_` is acceptable is to match a field (or
-// variant argument) that does not require visiting, as in
-// `is_cleanup` above.
-
 macro_rules! make_mir_visitor {
     ($visitor_trait_name:ident, $($mutability:ident)*) => {
         pub trait $visitor_trait_name<'tcx> {
@@ -419,7 +420,7 @@ macro_rules! make_mir_visitor {
                             self.visit_operand(arg);
                         }
                         if let Some((ref $($mutability)* destination, target)) = *destination {
-                            self.visit_lvalue(destination, LvalueContext::Call);
+                            self.visit_lvalue(destination, LvalueContext::CallStore);
                             self.visit_branch(block, target);
                         }
                         cleanup.map(|t| self.visit_branch(block, t));
@@ -529,7 +530,7 @@ macro_rules! make_mir_visitor {
                                         ref $($mutability)* inputs,
                                         asm: _ } => {
                         for output in & $($mutability)* outputs[..] {
-                            self.visit_lvalue(output, LvalueContext::Store);
+                            self.visit_lvalue(output, LvalueContext::AsmOutput);
                         }
                         for input in & $($mutability)* inputs[..] {
                             self.visit_operand(input);
@@ -723,33 +724,38 @@ macro_rules! make_mir_visitor {
 make_mir_visitor!(Visitor,);
 make_mir_visitor!(MutVisitor,mut);
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum LvalueContext {
-    // Appears as LHS of an assignment
+    /// Appears as LHS of an assignment
     Store,
 
-    // Dest of a call
-    Call,
+    /// Dest of a call
+    CallStore,
 
-    // Being dropped
+    /// Being dropped
     Drop,
 
-    // Being inspected in some way, like loading a len
+    /// Being inspected in some way, like loading a len
     Inspect,
 
-    // Being borrowed
+    /// Being borrowed
     Borrow { region: Region, kind: BorrowKind },
 
-    // Being sliced -- this should be same as being borrowed, probably
+    /// Being sliced -- this should be same as being borrowed, probably
     Slice { from_start: usize, from_end: usize },
 
-    // Used as base for another lvalue, e.g. `x` in `x.y`
+    /// Used as base for another lvalue, e.g. `x` in `x.y`
     Projection,
 
-    // Consumed as part of an operand
+    /// Consumed as part of an operand
     Consume,
 
-    // Starting and ending a storage live range
+    /// Starting and ending a storage live range
     StorageLive,
     StorageDead,
+
+    /// “output” from inline asm.
+    ///
+    /// Cannot be interpreted as a store, because assembly may choose to ignore it.
+    AsmOutput
 }

src/librustc_data_structures/bitvec.rs

@@ -62,12 +62,12 @@ impl BitVector {
         }
     }
 
-    /// Return and unset first bit set.
+    /// Return and unset last bit set.
     pub fn pop(&mut self) -> Option<usize> {
-        for (idx, el) in self.data.iter_mut().enumerate() {
+        for (idx, el) in self.data.iter_mut().enumerate().rev() {
             if *el != 0 {
-                let bit = el.trailing_zeros() as usize;
-                *el &= !word_mask(bit).1;
+                let bit = 63 - el.leading_zeros() as usize;
+                *el &= !(1 << bit);
                 return Some(idx * 64 + bit);
             }
         }
@@ -77,11 +77,12 @@ impl BitVector {
     /// Returns true if the bit has changed.
     pub fn remove(&mut self, bit: usize) -> bool {
         let (word, mask) = word_mask(bit);
-        let data = &mut self.data[word];
-        let value = *data;
-        let new_value = value & !mask;
-        *data = new_value;
-        new_value != value
+        self.data.get_mut(word).map(|data| {
+            let value = *data;
+            let new_value = value & !mask;
+            *data = new_value;
+            new_value != value
+        }).unwrap_or(false)
     }
 
     /// Clear the bitvector.
@@ -417,3 +418,19 @@ fn matrix_iter() {
     }
     assert!(iter.next().is_none());
 }
+
+fn bitvec_pop() {
+    let mut bitvec = BitVector::new(100);
+    bitvec.insert(1);
+    bitvec.insert(10);
+    bitvec.insert(19);
+    bitvec.insert(62);
+    bitvec.insert(63);
+    bitvec.insert(64);
+    bitvec.insert(65);
+    bitvec.insert(66);
+    bitvec.insert(99);
+    let idxs = vec![];
+    while let Some(idx) = bitvec.pop() { idxs.push(idx); }
+    assert_eq!(idxs, [99, 66, 65, 64, 63, 62, 19, 10, 1]);
+}

src/librustc_data_structures/indexed_vec.rs

@@ -102,6 +102,11 @@ impl<I: Idx, T> IndexVec<I, T> {
         self.raw.len()
     }
 
+    #[inline]
+    pub unsafe fn set_len(&mut self, len: usize) {
+        self.raw.set_len(len)
+    }
+
     #[inline]
     pub fn is_empty(&self) -> bool {
         self.raw.is_empty()
@@ -149,6 +154,16 @@ impl<I: Idx, T> IndexVec<I, T> {
     pub fn last(&self) -> Option<I> {
         self.len().checked_sub(1).map(I::new)
     }
+
+    #[inline]
+    pub unsafe fn as_ptr(&mut self) -> *const T {
+        self.raw.as_ptr()
+    }
+
+    #[inline]
+    pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
+        self.raw.as_mut_ptr()
+    }
 }
 
 impl<I: Idx, T> Index<I> for IndexVec<I, T> {

src/librustc_driver/driver.rs

@@ -990,6 +990,7 @@ pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         passes.push_pass(box mir::transform::simplify_cfg::SimplifyCfg::new("no-landing-pads"));
 
         passes.push_pass(box mir::transform::erase_regions::EraseRegions);
+        passes.push_pass(box mir::transform::liveness::LocalLivenessAnalysis);
 
         passes.push_pass(box mir::transform::add_call_guards::AddCallGuards);
         passes.push_pass(box borrowck::ElaborateDrops);

src/librustc_mir/transform/dataflow/combinators.rs

@@ -0,0 +1,38 @@
+use rustc::mir::repr as mir;
+
+use std::marker::PhantomData;
+use super::*;
+
+/// This combinator has the following behaviour:
+///
+/// * Rewrite the node with the first rewriter.
+///   * if the first rewriter replaced the node, 2nd rewriter is used to rewrite the replacement.
+///   * otherwise 2nd rewriter is used to rewrite the original node.
+pub struct RewriteAndThen<'tcx, T, R1, R2>(R1, R2, PhantomData<(&'tcx (), T)>)
+where T: Transfer<'tcx>, R1: Rewrite<'tcx, T>, R2: Rewrite<'tcx, T>;
+
+impl<'tcx, T, R1, R2> RewriteAndThen<'tcx, T, R1, R2>
+where T: Transfer<'tcx>, R1: Rewrite<'tcx, T>, R2: Rewrite<'tcx, T>
+{
+    pub fn new(r1: R1, r2: R2) -> RewriteAndThen<'tcx, T, R1, R2> {
+        RewriteAndThen(r1, r2, PhantomData)
+    }
+}
+
+impl<'tcx, T, R1, R2> Rewrite<'tcx, T> for RewriteAndThen<'tcx, T, R1, R2>
+where T: Transfer<'tcx>, R1: Rewrite<'tcx, T>, R2: Rewrite<'tcx, T> {
+    fn stmt(&self, stmt: &mir::Statement<'tcx>, fact: &T::Lattice) -> StatementChange<'tcx> {
+        let rs = self.0.stmt(stmt, fact);
+        match rs {
+            StatementChange::Remove => StatementChange::Remove,
+            StatementChange::Statement(ns) => self.1.stmt(&ns, fact),
+        }
+    }
+
+    fn term(&self, term: &mir::Terminator<'tcx>, fact: &T::Lattice) -> TerminatorChange<'tcx> {
+        let rt = self.0.term(term, fact);
+        match rt {
+            TerminatorChange::Terminator(nt) => self.1.term(&nt, fact)
+        }
+    }
+}