Split const prop into its own pass

src/librustc_mir/transform/const_prop.rs

@@ -0,0 +1,513 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <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.
+
+//! Propagates constants for early reporting of statically known
+//! assertion failures
+
+
+
+use rustc::mir::{Constant, Literal, Location, Place, Mir, Operand, Rvalue, Local};
+use rustc::mir::{NullOp, StatementKind, Statement, BasicBlock, LocalKind};
+use rustc::mir::TerminatorKind;
+use rustc::mir::visit::{MutVisitor, Visitor};
+use rustc::middle::const_val::ConstVal;
+use rustc::ty::{TyCtxt, self, Instance};
+use rustc::mir::interpret::{Value, PrimVal, GlobalId};
+use interpret::{eval_body_with_mir, eval_body, mk_borrowck_eval_cx, unary_op, ValTy};
+use rustc::util::nodemap::FxHashMap;
+use transform::{MirPass, MirSource};
+use syntax::codemap::Span;
+use rustc::ty::subst::Substs;
+
+pub struct ConstProp;
+
+impl MirPass for ConstProp {
+    fn run_pass<'a, 'tcx>(&self,
+                          tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                          source: MirSource,
+                          mir: &mut Mir<'tcx>) {
+        trace!("ConstProp starting for {:?}", source.def_id);
+
+        // First, find optimization opportunities. This is done in a pre-pass to keep the MIR
+        // read-only so that we can do global analyses on the MIR in the process (e.g.
+        // `Place::ty()`).
+        let optimizations = {
+            let mut optimization_finder = OptimizationFinder::new(mir, tcx, source);
+            optimization_finder.visit_mir(mir);
+            optimization_finder.optimizations
+        };
+
+        // Then carry out those optimizations.
+        MutVisitor::visit_mir(&mut ConstPropVisitor { optimizations, tcx }, mir);
+        trace!("ConstProp done for {:?}", source.def_id);
+    }
+}
+
+type Const<'tcx> = (Value, ty::Ty<'tcx>, Span);
+
+pub struct ConstPropVisitor<'a, 'tcx: 'a> {
+    optimizations: OptimizationList<'tcx>,
+    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+}
+
+impl<'a, 'tcx> MutVisitor<'tcx> for ConstPropVisitor<'a, 'tcx> {
+    fn visit_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>, location: Location) {
+        if let Some((value, ty, span)) = self.optimizations.const_prop.remove(&location) {
+            let value = self.tcx.mk_const(ty::Const {
+                val: ConstVal::Value(value),
+                ty,
+            });
+            debug!("Replacing `{:?}` with {:?}", rvalue, value);
+            let constant = Constant {
+                ty,
+                literal: Literal::Value { value },
+                span,
+            };
+            *rvalue = Rvalue::Use(Operand::Constant(box constant));
+        }
+
+        self.super_rvalue(rvalue, location)
+    }
+
+    fn visit_constant(
+        &mut self,
+        constant: &mut Constant<'tcx>,
+        location: Location,
+    ) {
+        self.super_constant(constant, location);
+        if let Some(&(val, ty, _)) = self.optimizations.constants.get(constant) {
+            debug!("Replacing `{:?}` with {:?}:{:?}", constant.literal, val, ty);
+            constant.literal = Literal::Value {
+                value: self.tcx.mk_const(ty::Const {
+                    val: ConstVal::Value(val),
+                    ty,
+                }),
+            };
+        }
+    }
+
+    fn visit_operand(
+        &mut self,
+        operand: &mut Operand<'tcx>,
+        location: Location,
+    ) {
+        self.super_operand(operand, location);
+        let new = match operand {
+            Operand::Move(Place::Local(local)) |
+            Operand::Copy(Place::Local(local)) => {
+                trace!("trying to read {:?}", local);
+                self.optimizations.places.get(&local).cloned()
+            },
+            _ => return,
+        };
+        if let Some((value, ty, span)) = new {
+            let value = self.tcx.mk_const(ty::Const {
+                val: ConstVal::Value(value),
+                ty,
+            });
+            debug!("Replacing `{:?}` with {:?}", operand, value);
+            let constant = Constant {
+                ty,
+                literal: Literal::Value { value },
+                span,
+            };
+            *operand = Operand::Constant(box constant);
+        }
+    }
+
+    fn visit_terminator_kind(
+        &mut self,
+        block: BasicBlock,
+        kind: &mut TerminatorKind<'tcx>,
+        location: Location,
+    ) {
+        match kind {
+            TerminatorKind::SwitchInt { discr: value, .. } |
+            TerminatorKind::Yield { value, .. } |
+            TerminatorKind::Assert { cond: value, .. } => {
+                if let Some((new, ty, span)) = self.optimizations.terminators.remove(&block) {
+                    let new = self.tcx.mk_const(ty::Const {
+                        val: ConstVal::Value(new),
+                        ty,
+                    });
+                    debug!("Replacing `{:?}` with {:?}", value, new);
+                    let constant = Constant {
+                        ty,
+                        literal: Literal::Value { value: new },
+                        span,
+                    };
+                    *value = Operand::Constant(box constant);
+                }
+            }
+            // FIXME: do this optimization for function calls
+            _ => {},
+        }
+        self.super_terminator_kind(block, kind, location)
+    }
+}
+
+/// Finds optimization opportunities on the MIR.
+struct OptimizationFinder<'b, 'a, 'tcx:'a+'b> {
+    mir: &'b Mir<'tcx>,
+    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    source: MirSource,
+    optimizations: OptimizationList<'tcx>,
+}
+
+impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
+    fn new(
+        mir: &'b Mir<'tcx>,
+        tcx: TyCtxt<'a, 'tcx, 'tcx>,
+        source: MirSource,
+    ) -> OptimizationFinder<'b, 'a, 'tcx> {
+        OptimizationFinder {
+            mir,
+            tcx,
+            source,
+            optimizations: OptimizationList::default(),
+        }
+    }
+
+    fn eval_constant(&mut self, c: &Constant<'tcx>) -> Option<Const<'tcx>> {
+        if let Some(&val) = self.optimizations.constants.get(c) {
+            return Some(val);
+        }
+        match c.literal {
+            Literal::Value { value } => match value.val {
+                ConstVal::Value(v) => Some((v, value.ty, c.span)),
+                ConstVal::Unevaluated(did, substs) => {
+                    let param_env = self.tcx.param_env(self.source.def_id);
+                    let instance = Instance::resolve(
+                        self.tcx,
+                        param_env,
+                        did,
+                        substs,
+                    )?;
+                    let cid = GlobalId {
+                        instance,
+                        promoted: None,
+                    };
+                    let (value, _, ty) = eval_body(self.tcx, cid, param_env)?;
+                    let val = (value, ty, c.span);
+                    trace!("evaluated {:?} to {:?}", c, val);
+                    self.optimizations.constants.insert(c.clone(), val);
+                    Some(val)
+                },
+            },
+            // evaluate the promoted and replace the constant with the evaluated result
+            Literal::Promoted { index } => {
+                let generics = self.tcx.generics_of(self.source.def_id);
+                if generics.parent_types as usize + generics.types.len() > 0 {
+                    // FIXME: can't handle code with generics
+                    return None;
+                }
+                let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
+                let instance = Instance::new(self.source.def_id, substs);
+                let cid = GlobalId {
+                    instance,
+                    promoted: Some(index),
+                };
+                let param_env = self.tcx.param_env(self.source.def_id);
+                let (value, _, ty) = eval_body_with_mir(self.tcx, cid, self.mir, param_env)?;
+                let val = (value, ty, c.span);
+                trace!("evaluated {:?} to {:?}", c, val);
+                self.optimizations.constants.insert(c.clone(), val);
+                Some(val)
+            }
+        }
+    }
+
+    fn eval_operand(&mut self, op: &Operand<'tcx>) -> Option<Const<'tcx>> {
+        match *op {
+            Operand::Constant(ref c) => self.eval_constant(c),
+            Operand::Move(ref place) | Operand::Copy(ref place) => match *place {
+                Place::Local(loc) => self.optimizations.places.get(&loc).cloned(),
+                // FIXME(oli-obk): field and index projections
+                Place::Projection(_) => None,
+                _ => None,
+            },
+        }
+    }
+
+    fn simplify_operand(&mut self, op: &Operand<'tcx>) -> Option<Const<'tcx>> {
+        match *op {
+            Operand::Constant(ref c) => match c.literal {
+                Literal::Value { .. } => None,
+                _ => self.eval_operand(op),
+            },
+            _ => self.eval_operand(op),
+        }
+    }
+
+    fn const_prop(
+        &mut self,
+        rvalue: &Rvalue<'tcx>,
+        place_ty: ty::Ty<'tcx>,
+        span: Span,
+    ) -> Option<Const<'tcx>> {
+        match *rvalue {
+            // No need to overwrite an already evaluated constant
+            Rvalue::Use(Operand::Constant(box Constant {
+                literal: Literal::Value {
+                    value: &ty::Const {
+                        val: ConstVal::Value(_),
+                        ..
+                    },
+                },
+                ..
+            })) => None,
+            // This branch exists for the sanity type check
+            Rvalue::Use(Operand::Constant(ref c)) => {
+                assert_eq!(c.ty, place_ty);
+                self.eval_constant(c)
+            },
+            Rvalue::Use(ref op) => {
+                self.eval_operand(op)
+            },
+            Rvalue::Repeat(..) |
+            Rvalue::Ref(..) |
+            Rvalue::Cast(..) |
+            Rvalue::Aggregate(..) |
+            Rvalue::NullaryOp(NullOp::Box, _) |
+            Rvalue::Discriminant(..) => None,
+            // FIXME(oli-obk): evaluate static/constant slice lengths
+            Rvalue::Len(_) => None,
+            Rvalue::NullaryOp(NullOp::SizeOf, ty) => {
+                let param_env = self.tcx.param_env(self.source.def_id);
+                type_size_of(self.tcx, param_env, ty).map(|n| (
+                    Value::ByVal(PrimVal::Bytes(n as u128)),
+                    self.tcx.types.usize,
+                    span,
+                ))
+            }
+            Rvalue::UnaryOp(op, ref arg) => {
+                let def_id = if self.tcx.is_closure(self.source.def_id) {
+                    self.tcx.closure_base_def_id(self.source.def_id)
+                } else {
+                    self.source.def_id
+                };
+                let generics = self.tcx.generics_of(def_id);
+                if generics.parent_types as usize + generics.types.len() > 0 {
+                    // FIXME: can't handle code with generics
+                    return None;
+                }
+                let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
+                let instance = Instance::new(self.source.def_id, substs);
+                let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir, span).unwrap();
+
+                let val = self.eval_operand(arg)?;
+                let prim = ecx.value_to_primval(ValTy { value: val.0, ty: val.1 }).ok()?;
+                let kind = ecx.ty_to_primval_kind(val.1).ok()?;
+                match unary_op(op, prim, kind) {
+                    Ok(val) => Some((Value::ByVal(val), place_ty, span)),
+                    Err(mut err) => {
+                        ecx.report(&mut err, false, Some(span));
+                        None
+                    },
+                }
+            }
+            Rvalue::CheckedBinaryOp(op, ref left, ref right) |
+            Rvalue::BinaryOp(op, ref left, ref right) => {
+                trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right);
+                let left = self.eval_operand(left)?;
+                let right = self.eval_operand(right)?;
+                let def_id = if self.tcx.is_closure(self.source.def_id) {
+                    self.tcx.closure_base_def_id(self.source.def_id)
+                } else {
+                    self.source.def_id
+                };
+                let generics = self.tcx.generics_of(def_id);
+                let has_generics = generics.parent_types as usize + generics.types.len() > 0;
+                if has_generics {
+                    // FIXME: can't handle code with generics
+                    return None;
+                }
+                let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
+                let instance = Instance::new(self.source.def_id, substs);
+                let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir, span).unwrap();
+
+                let l = ecx.value_to_primval(ValTy { value: left.0, ty: left.1 }).ok()?;
+                let r = ecx.value_to_primval(ValTy { value: right.0, ty: right.1 }).ok()?;
+                trace!("const evaluating {:?} for {:?} and {:?}", op, left, right);
+                match ecx.binary_op(op, l, left.1, r, right.1) {
+                    Ok((val, overflow)) => {
+                        let val = if let Rvalue::CheckedBinaryOp(..) = *rvalue {
+                            Value::ByValPair(
+                                val,
+                                PrimVal::from_bool(overflow),
+                            )
+                        } else {
+                            if overflow {
+                                use rustc::mir::interpret::EvalErrorKind;
+                                let mut err = EvalErrorKind::OverflowingMath.into();
+                                ecx.report(&mut err, false, Some(span));
+                                return None;
+                            }
+                            Value::ByVal(val)
+                        };
+                        Some((val, place_ty, span))
+                    },
+                    Err(mut err) => {
+                        ecx.report(&mut err, false, Some(span));
+                        None
+                    },
+                }
+            },
+        }
+    }
+}
+
+fn type_size_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                          param_env: ty::ParamEnv<'tcx>,
+                          ty: ty::Ty<'tcx>) -> Option<u64> {
+    use rustc::ty::layout::LayoutOf;
+    (tcx, param_env).layout_of(ty).ok().map(|layout| layout.size.bytes())
+}
+
+struct CanConstProp {
+    local: Local,
+    can_const_prop: bool,
+    // false at the beginning, once set, there are not allowed to be any more assignments
+    found_assignment: bool,
+}
+
+impl CanConstProp {
+    /// returns true if `local` can be propagated
+    fn check<'tcx>(local: Local, mir: &Mir<'tcx>) -> bool {
+        let mut cpv = CanConstProp {
+            local,
+            can_const_prop: true,
+            found_assignment: false,
+        };
+        cpv.visit_mir(mir);
+        cpv.can_const_prop
+    }
+
+    fn is_our_local(&mut self, mut place: &Place) -> bool {
+        while let Place::Projection(ref proj) = place {
+            place = &proj.base;
+        }
+        if let Place::Local(local) = *place {
+            local == self.local
+        } else {
+            false
+        }
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for CanConstProp {
+    fn visit_statement(
+        &mut self,
+        block: BasicBlock,
+        statement: &Statement<'tcx>,
+        location: Location,
+    ) {
+        self.super_statement(block, statement, location);
+        match statement.kind {
+            StatementKind::SetDiscriminant { ref place, .. } |
+            StatementKind::Assign(ref place, _) => {
+                if self.is_our_local(place) {
+                    if self.found_assignment {
+                        self.can_const_prop = false;
+                    } else {
+                        self.found_assignment = true
+                    }
+                }
+            },
+            StatementKind::InlineAsm { ref outputs, .. } => {
+                for place in outputs {
+                    if self.is_our_local(place) {
+                        if self.found_assignment {
+                            self.can_const_prop = false;
+                        } else {
+                            self.found_assignment = true
+                        }
+                        return;
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
+        self.super_rvalue(rvalue, location);
+        if let Rvalue::Ref(_, _, ref place) = *rvalue {
+            if self.is_our_local(place) {
+                self.can_const_prop = false;
+            }
+        }
+    }
+}
+
+impl<'b, 'a, 'tcx> Visitor<'tcx> for OptimizationFinder<'b, 'a, 'tcx> {
+    fn visit_constant(
+        &mut self,
+        constant: &Constant<'tcx>,
+        location: Location,
+    ) {
+        trace!("visit_constant: {:?}", constant);
+        self.super_constant(constant, location);
+        self.eval_constant(constant);
+    }
+
+    fn visit_statement(
+        &mut self,
+        block: BasicBlock,
+        statement: &Statement<'tcx>,
+        location: Location,
+    ) {
+        trace!("visit_statement: {:?}", statement);
+        if let StatementKind::Assign(ref place, ref rval) = statement.kind {
+            let place_ty = place
+                .ty(&self.mir.local_decls, self.tcx)
+                .to_ty(self.tcx);
+            let span = statement.source_info.span;
+            if let Some(value) = self.const_prop(rval, place_ty, span) {
+                self.optimizations.const_prop.insert(location, value);
+                if let Place::Local(local) = *place {
+                    if self.mir.local_kind(local) == LocalKind::Temp
+                        && CanConstProp::check(local, self.mir) {
+                        trace!("storing {:?} to {:?}", value, local);
+                        assert!(self.optimizations.places.insert(local, value).is_none());
+                    }
+                }
+            }
+        }
+        self.super_statement(block, statement, location);
+    }
+
+    fn visit_terminator_kind(
+        &mut self,
+        block: BasicBlock,
+        kind: &TerminatorKind<'tcx>,
+        _location: Location,
+    ) {
+        match kind {
+            TerminatorKind::SwitchInt { discr: value, .. } |
+            TerminatorKind::Yield { value, .. } |
+            TerminatorKind::Assert { cond: value, .. } => {
+                if let Some(value) = self.simplify_operand(value) {
+                    self.optimizations.terminators.insert(block, value);
+                }
+            }
+            // FIXME: do this optimization for function calls
+            _ => {},
+        }
+    }
+}
+
+#[derive(Default)]
+struct OptimizationList<'tcx> {
+    const_prop: FxHashMap<Location, Const<'tcx>>,
+    /// Terminators that get their Operand(s) turned into constants.
+    terminators: FxHashMap<BasicBlock, Const<'tcx>>,
+    places: FxHashMap<Local, Const<'tcx>>,
+    constants: FxHashMap<Constant<'tcx>, Const<'tcx>>,
+}

src/librustc_mir/transform/instcombine.rs

@@ -11,19 +11,12 @@
 //! Performs various peephole optimizations.
 
 use rustc::mir::{Constant, Literal, Location, Place, Mir, Operand, ProjectionElem, Rvalue, Local};
-use rustc::mir::{NullOp, StatementKind, Statement, BasicBlock, LocalKind};
-use rustc::mir::TerminatorKind;
 use rustc::mir::visit::{MutVisitor, Visitor};
-use rustc::middle::const_val::ConstVal;
-use rustc::ty::{TyCtxt, TypeVariants, self, Instance};
-use rustc::mir::interpret::{Value, PrimVal, GlobalId};
-use interpret::{eval_body_with_mir, eval_body, mk_borrowck_eval_cx, unary_op, ValTy};
+use rustc::ty::{TyCtxt, TypeVariants};
 use rustc::util::nodemap::{FxHashMap, FxHashSet};
 use rustc_data_structures::indexed_vec::Idx;
 use std::mem;
 use transform::{MirPass, MirSource};
-use syntax::codemap::Span;
-use rustc::ty::subst::Substs;
 
 pub struct InstCombine;
 
@@ -38,25 +31,22 @@ impl MirPass for InstCombine {
         // read-only so that we can do global analyses on the MIR in the process (e.g.
         // `Place::ty()`).
         let optimizations = {
-            let mut optimization_finder = OptimizationFinder::new(mir, tcx, source);
+            let mut optimization_finder = OptimizationFinder::new(mir, tcx);
             optimization_finder.visit_mir(mir);
             optimization_finder.optimizations
         };
 
         // Then carry out those optimizations.
-        MutVisitor::visit_mir(&mut InstCombineVisitor { optimizations, tcx }, mir);
+        MutVisitor::visit_mir(&mut InstCombineVisitor { optimizations }, mir);
         trace!("InstCombine done for {:?}", source.def_id);
     }
 }
 
-type Const<'tcx> = (Value, ty::Ty<'tcx>, Span);
-
-pub struct InstCombineVisitor<'a, 'tcx: 'a> {
+pub struct InstCombineVisitor<'tcx> {
     optimizations: OptimizationList<'tcx>,
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
 
-impl<'a, 'tcx> MutVisitor<'tcx> for InstCombineVisitor<'a, 'tcx> {
+impl<'tcx> MutVisitor<'tcx> for InstCombineVisitor<'tcx> {
     fn visit_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>, location: Location) {
         if self.optimizations.and_stars.remove(&location) {
             debug!("Replacing `&*`: {:?}", rvalue);
@@ -75,105 +65,14 @@ impl<'a, 'tcx> MutVisitor<'tcx> for InstCombineVisitor<'a, 'tcx> {
             *rvalue = Rvalue::Use(Operand::Constant(box constant));
         }
 
-        if let Some((value, ty, span)) = self.optimizations.const_prop.remove(&location) {
-            let value = self.tcx.mk_const(ty::Const {
-                val: ConstVal::Value(value),
-                ty,
-            });
-            debug!("Replacing `{:?}` with {:?}", rvalue, value);
-            let constant = Constant {
-                ty,
-                literal: Literal::Value { value },
-                span,
-            };
-            *rvalue = Rvalue::Use(Operand::Constant(box constant));
-        }
-
         self.super_rvalue(rvalue, location)
     }
-
-    fn visit_constant(
-        &mut self,
-        constant: &mut Constant<'tcx>,
-        location: Location,
-    ) {
-        self.super_constant(constant, location);
-        if let Some(&(val, ty, _)) = self.optimizations.constants.get(constant) {
-            debug!("Replacing `{:?}` with {:?}:{:?}", constant.literal, val, ty);
-            constant.literal = Literal::Value {
-                value: self.tcx.mk_const(ty::Const {
-                    val: ConstVal::Value(val),
-                    ty,
-                }),
-            };
-        }
-    }
-
-    fn visit_operand(
-        &mut self,
-        operand: &mut Operand<'tcx>,
-        location: Location,
-    ) {
-        self.super_operand(operand, location);
-        let new = match operand {
-            Operand::Move(Place::Local(local)) |
-            Operand::Copy(Place::Local(local)) => {
-                trace!("trying to read {:?}", local);
-                self.optimizations.places.get(&local).cloned()
-            },
-            _ => return,
-        };
-        if let Some((value, ty, span)) = new {
-            let value = self.tcx.mk_const(ty::Const {
-                val: ConstVal::Value(value),
-                ty,
-            });
-            debug!("Replacing `{:?}` with {:?}", operand, value);
-            let constant = Constant {
-                ty,
-                literal: Literal::Value { value },
-                span,
-            };
-            *operand = Operand::Constant(box constant);
-        }
-    }
-
-    fn visit_terminator_kind(
-        &mut self,
-        block: BasicBlock,
-        kind: &mut TerminatorKind<'tcx>,
-        location: Location,
-    ) {
-        match kind {
-            TerminatorKind::SwitchInt { discr: value, .. } |
-            TerminatorKind::Yield { value, .. } |
-            TerminatorKind::Assert { cond: value, .. } => {
-                if let Some((new, ty, span)) = self.optimizations.terminators.remove(&block) {
-                    let new = self.tcx.mk_const(ty::Const {
-                        val: ConstVal::Value(new),
-                        ty,
-                    });
-                    debug!("Replacing `{:?}` with {:?}", value, new);
-                    let constant = Constant {
-                        ty,
-                        literal: Literal::Value { value: new },
-                        span,
-                    };
-                    *value = Operand::Constant(box constant);
-                }
-            }
-            // FIXME: do this optimization for function calls
-            _ => {},
-        }
-        self.super_terminator_kind(block, kind, location)
-    }
 }
 
 /// Finds optimization opportunities on the MIR.
 struct OptimizationFinder<'b, 'a, 'tcx:'a+'b> {
     mir: &'b Mir<'tcx>,
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
-    source: MirSource,
     optimizations: OptimizationList<'tcx>,
 }
 
@@ -181,325 +80,16 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
     fn new(
         mir: &'b Mir<'tcx>,
         tcx: TyCtxt<'a, 'tcx, 'tcx>,
-        source: MirSource,
     ) -> OptimizationFinder<'b, 'a, 'tcx> {
         OptimizationFinder {
             mir,
             tcx,
-            source,
             optimizations: OptimizationList::default(),
         }
     }
-
-    fn eval_constant(&mut self, c: &Constant<'tcx>) -> Option<Const<'tcx>> {
-        if let Some(&val) = self.optimizations.constants.get(c) {
-            return Some(val);
-        }
-        match c.literal {
-            Literal::Value { value } => match value.val {
-                ConstVal::Value(v) => Some((v, value.ty, c.span)),
-                ConstVal::Unevaluated(did, substs) => {
-                    let param_env = self.tcx.param_env(self.source.def_id);
-                    let instance = Instance::resolve(
-                        self.tcx,
-                        param_env,
-                        did,
-                        substs,
-                    )?;
-                    let cid = GlobalId {
-                        instance,
-                        promoted: None,
-                    };
-                    let (value, _, ty) = eval_body(self.tcx, cid, param_env)?;
-                    let val = (value, ty, c.span);
-                    trace!("evaluated {:?} to {:?}", c, val);
-                    self.optimizations.constants.insert(c.clone(), val);
-                    Some(val)
-                },
-            },
-            // evaluate the promoted and replace the constant with the evaluated result
-            Literal::Promoted { index } => {
-                let generics = self.tcx.generics_of(self.source.def_id);
-                if generics.parent_types as usize + generics.types.len() > 0 {
-                    // FIXME: can't handle code with generics
-                    return None;
-                }
-                let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
-                let instance = Instance::new(self.source.def_id, substs);
-                let cid = GlobalId {
-                    instance,
-                    promoted: Some(index),
-                };
-                let param_env = self.tcx.param_env(self.source.def_id);
-                let (value, _, ty) = eval_body_with_mir(self.tcx, cid, self.mir, param_env)?;
-                let val = (value, ty, c.span);
-                trace!("evaluated {:?} to {:?}", c, val);
-                self.optimizations.constants.insert(c.clone(), val);
-                Some(val)
-            }
-        }
-    }
-
-    fn eval_operand(&mut self, op: &Operand<'tcx>) -> Option<Const<'tcx>> {
-        match *op {
-            Operand::Constant(ref c) => self.eval_constant(c),
-            Operand::Move(ref place) | Operand::Copy(ref place) => match *place {
-                Place::Local(loc) => self.optimizations.places.get(&loc).cloned(),
-                // FIXME(oli-obk): field and index projections
-                Place::Projection(_) => None,
-                _ => None,
-            },
-        }
-    }
-
-    fn simplify_operand(&mut self, op: &Operand<'tcx>) -> Option<Const<'tcx>> {
-        match *op {
-            Operand::Constant(ref c) => match c.literal {
-                Literal::Value { .. } => None,
-                _ => self.eval_operand(op),
-            },
-            _ => self.eval_operand(op),
-        }
-    }
-
-    fn const_prop(
-        &mut self,
-        rvalue: &Rvalue<'tcx>,
-        place_ty: ty::Ty<'tcx>,
-        span: Span,
-    ) -> Option<Const<'tcx>> {
-        match *rvalue {
-            // No need to overwrite an already evaluated constant
-            Rvalue::Use(Operand::Constant(box Constant {
-                literal: Literal::Value {
-                    value: &ty::Const {
-                        val: ConstVal::Value(_),
-                        ..
-                    },
-                },
-                ..
-            })) => None,
-            // This branch exists for the sanity type check
-            Rvalue::Use(Operand::Constant(ref c)) => {
-                assert_eq!(c.ty, place_ty);
-                self.eval_constant(c)
-            },
-            Rvalue::Use(ref op) => {
-                self.eval_operand(op)
-            },
-            Rvalue::Repeat(..) |
-            Rvalue::Ref(..) |
-            Rvalue::Cast(..) |
-            Rvalue::Aggregate(..) |
-            Rvalue::NullaryOp(NullOp::Box, _) |
-            Rvalue::Discriminant(..) => None,
-            // FIXME(oli-obk): evaluate static/constant slice lengths
-            Rvalue::Len(_) => None,
-            Rvalue::NullaryOp(NullOp::SizeOf, ty) => {
-                let param_env = self.tcx.param_env(self.source.def_id);
-                type_size_of(self.tcx, param_env, ty).map(|n| (
-                    Value::ByVal(PrimVal::Bytes(n as u128)),
-                    self.tcx.types.usize,
-                    span,
-                ))
-            }
-            Rvalue::UnaryOp(op, ref arg) => {
-                let def_id = if self.tcx.is_closure(self.source.def_id) {
-                    self.tcx.closure_base_def_id(self.source.def_id)
-                } else {
-                    self.source.def_id
-                };
-                let generics = self.tcx.generics_of(def_id);
-                if generics.parent_types as usize + generics.types.len() > 0 {
-                    // FIXME: can't handle code with generics
-                    return None;
-                }
-                let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
-                let instance = Instance::new(self.source.def_id, substs);
-                let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir, span).unwrap();
-
-                let val = self.eval_operand(arg)?;
-                let prim = ecx.value_to_primval(ValTy { value: val.0, ty: val.1 }).ok()?;
-                let kind = ecx.ty_to_primval_kind(val.1).ok()?;
-                match unary_op(op, prim, kind) {
-                    Ok(val) => Some((Value::ByVal(val), place_ty, span)),
-                    Err(mut err) => {
-                        ecx.report(&mut err, false, Some(span));
-                        None
-                    },
-                }
-            }
-            Rvalue::CheckedBinaryOp(op, ref left, ref right) |
-            Rvalue::BinaryOp(op, ref left, ref right) => {
-                trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right);
-                let left = self.eval_operand(left)?;
-                let right = self.eval_operand(right)?;
-                let def_id = if self.tcx.is_closure(self.source.def_id) {
-                    self.tcx.closure_base_def_id(self.source.def_id)
-                } else {
-                    self.source.def_id
-                };
-                let generics = self.tcx.generics_of(def_id);
-                let has_generics = generics.parent_types as usize + generics.types.len() > 0;
-                if has_generics {
-                    // FIXME: can't handle code with generics
-                    return None;
-                }
-                let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
-                let instance = Instance::new(self.source.def_id, substs);
-                let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir, span).unwrap();
-
-                let l = ecx.value_to_primval(ValTy { value: left.0, ty: left.1 }).ok()?;
-                let r = ecx.value_to_primval(ValTy { value: right.0, ty: right.1 }).ok()?;
-                trace!("const evaluating {:?} for {:?} and {:?}", op, left, right);
-                match ecx.binary_op(op, l, left.1, r, right.1) {
-                    Ok((val, overflow)) => {
-                        let val = if let Rvalue::CheckedBinaryOp(..) = *rvalue {
-                            Value::ByValPair(
-                                val,
-                                PrimVal::from_bool(overflow),
-                            )
-                        } else {
-                            if overflow {
-                                use rustc::mir::interpret::EvalErrorKind;
-                                let mut err = EvalErrorKind::OverflowingMath.into();
-                                ecx.report(&mut err, false, Some(span));
-                                return None;
-                            }
-                            Value::ByVal(val)
-                        };
-                        Some((val, place_ty, span))
-                    },
-                    Err(mut err) => {
-                        ecx.report(&mut err, false, Some(span));
-                        None
-                    },
-                }
-            },
-        }
-    }
-}
-
-fn type_size_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                          param_env: ty::ParamEnv<'tcx>,
-                          ty: ty::Ty<'tcx>) -> Option<u64> {
-    use rustc::ty::layout::LayoutOf;
-    (tcx, param_env).layout_of(ty).ok().map(|layout| layout.size.bytes())
-}
-
-struct ConstPropVisitor {
-    local: Local,
-    can_const_prop: bool,
-    // false at the beginning, once set, there are not allowed to be any more assignments
-    found_assignment: bool,
-}
-
-impl ConstPropVisitor {
-    /// returns true if `local` can be propagated
-    fn check<'tcx>(local: Local, mir: &Mir<'tcx>) -> bool {
-        let mut cpv = ConstPropVisitor {
-            local,
-            can_const_prop: true,
-            found_assignment: false,
-        };
-        cpv.visit_mir(mir);
-        cpv.can_const_prop
-    }
-
-    fn is_our_local(&mut self, mut place: &Place) -> bool {
-        while let Place::Projection(ref proj) = place {
-            place = &proj.base;
-        }
-        if let Place::Local(local) = *place {
-            local == self.local
-        } else {
-            false
-        }
-    }
-}
-
-impl<'tcx> Visitor<'tcx> for ConstPropVisitor {
-    fn visit_statement(
-        &mut self,
-        block: BasicBlock,
-        statement: &Statement<'tcx>,
-        location: Location,
-    ) {
-        self.super_statement(block, statement, location);
-        match statement.kind {
-            StatementKind::SetDiscriminant { ref place, .. } |
-            StatementKind::Assign(ref place, _) => {
-                if self.is_our_local(place) {
-                    if self.found_assignment {
-                        self.can_const_prop = false;
-                    } else {
-                        self.found_assignment = true
-                    }
-                }
-            },
-            StatementKind::InlineAsm { ref outputs, .. } => {
-                for place in outputs {
-                    if self.is_our_local(place) {
-                        if self.found_assignment {
-                            self.can_const_prop = false;
-                        } else {
-                            self.found_assignment = true
-                        }
-                        return;
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-    fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
-        self.super_rvalue(rvalue, location);
-        if let Rvalue::Ref(_, _, ref place) = *rvalue {
-            if self.is_our_local(place) {
-                self.can_const_prop = false;
-            }
-        }
-    }
 }
 
 impl<'b, 'a, 'tcx> Visitor<'tcx> for OptimizationFinder<'b, 'a, 'tcx> {
-    fn visit_constant(
-        &mut self,
-        constant: &Constant<'tcx>,
-        location: Location,
-    ) {
-        trace!("visit_constant: {:?}", constant);
-        self.super_constant(constant, location);
-        self.eval_constant(constant);
-    }
-
-    fn visit_statement(
-        &mut self,
-        block: BasicBlock,
-        statement: &Statement<'tcx>,
-        location: Location,
-    ) {
-        trace!("visit_statement: {:?}", statement);
-        if let StatementKind::Assign(ref place, ref rval) = statement.kind {
-            let place_ty = place
-                .ty(&self.mir.local_decls, self.tcx)
-                .to_ty(self.tcx);
-            let span = statement.source_info.span;
-            if let Some(value) = self.const_prop(rval, place_ty, span) {
-                self.optimizations.const_prop.insert(location, value);
-                if let Place::Local(local) = *place {
-                    if self.mir.local_kind(local) == LocalKind::Temp
-                        && ConstPropVisitor::check(local, self.mir) {
-                        trace!("storing {:?} to {:?}", value, local);
-                        assert!(self.optimizations.places.insert(local, value).is_none());
-                    }
-                }
-                return;
-            }
-        }
-        self.super_statement(block, statement, location);
-    }
-
     fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
         if let Rvalue::Ref(_, _, Place::Projection(ref projection)) = *rvalue {
             if let ProjectionElem::Deref = projection.elem {
@@ -522,34 +112,10 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for OptimizationFinder<'b, 'a, 'tcx> {
 
         self.super_rvalue(rvalue, location)
     }
-
-    fn visit_terminator_kind(
-        &mut self,
-        block: BasicBlock,
-        kind: &TerminatorKind<'tcx>,
-        _location: Location,
-    ) {
-        match kind {
-            TerminatorKind::SwitchInt { discr: value, .. } |
-            TerminatorKind::Yield { value, .. } |
-            TerminatorKind::Assert { cond: value, .. } => {
-                if let Some(value) = self.simplify_operand(value) {
-                    self.optimizations.terminators.insert(block, value);
-                }
-            }
-            // FIXME: do this optimization for function calls
-            _ => {},
-        }
-    }
 }
 
 #[derive(Default)]
 struct OptimizationList<'tcx> {
     and_stars: FxHashSet<Location>,
     arrays_lengths: FxHashMap<Location, Constant<'tcx>>,
-    const_prop: FxHashMap<Location, Const<'tcx>>,
-    /// Terminators that get their Operand(s) turned into constants.
-    terminators: FxHashMap<BasicBlock, Const<'tcx>>,
-    places: FxHashMap<Local, Const<'tcx>>,
-    constants: FxHashMap<Constant<'tcx>, Const<'tcx>>,
 }

src/librustc_mir/transform/mod.rs

@@ -41,6 +41,7 @@ pub mod dump_mir;
 pub mod deaggregator;
 pub mod instcombine;
 pub mod copy_prop;
+pub mod const_prop;
 pub mod generator;
 pub mod inline;
 pub mod lower_128bit;
@@ -265,6 +266,7 @@ fn optimized_mir<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx
         generator::StateTransform,
 
         instcombine::InstCombine,
+        const_prop::ConstProp,
         simplify_branches::SimplifyBranches::new("after-const-prop"),
         deaggregator::Deaggregator,
         copy_prop::CopyPropagation,