Fully use miri in trans

1 files changed, 7 insertions, 234 deletions

diff --git a/src/librustc_mir/interpret/step.rs b/src/librustc_mir/interpret/step.rs
index 2b0f9041d5..21e81ff668 100644
--- a/src/librustc_mir/interpret/step.rs
+++ b/src/librustc_mir/interpret/step.rs
@@ -2,21 +2,12 @@
 //!
 //! The main entry point is the `step` method.
 
-use rustc::hir;
-use rustc::mir::visit::{Visitor, PlaceContext};
 use rustc::mir;
-use rustc::ty::{self, Instance};
-use rustc::ty::layout::LayoutOf;
-use rustc::middle::const_val::ConstVal;
-use rustc::mir::interpret::GlobalId;
 
-use rustc::mir::interpret::{EvalResult, EvalErrorKind};
-use super::{EvalContext, StackPopCleanup, Place, Machine};
+use rustc::mir::interpret::EvalResult;
+use super::{EvalContext, Machine};
 
-use syntax::codemap::Span;
-use syntax::ast::Mutability;
-
-impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
+impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
     pub fn inc_step_counter_and_check_limit(&mut self, n: u64) -> EvalResult<'tcx> {
         self.steps_remaining = self.steps_remaining.saturating_sub(n);
         if self.steps_remaining > 0 {
@@ -41,52 +32,14 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
         let old_frames = self.cur_frame();
 
         if let Some(stmt) = basic_block.statements.get(stmt_id) {
-            let mut new = Ok(false);
-            ConstantExtractor {
-                span: stmt.source_info.span,
-                instance: self.frame().instance,
-                ecx: self,
-                mir,
-                new_constant: &mut new,
-            }.visit_statement(
-                block,
-                stmt,
-                mir::Location {
-                    block,
-                    statement_index: stmt_id,
-                },
-            );
-            // if ConstantExtractor added a new frame, we don't execute anything here
-            // but await the next call to step
-            if !new? {
-                assert_eq!(old_frames, self.cur_frame());
-                self.statement(stmt)?;
-            }
+            assert_eq!(old_frames, self.cur_frame());
+            self.statement(stmt)?;
             return Ok(true);
         }
 
         let terminator = basic_block.terminator();
-        let mut new = Ok(false);
-        ConstantExtractor {
-            span: terminator.source_info.span,
-            instance: self.frame().instance,
-            ecx: self,
-            mir,
-            new_constant: &mut new,
-        }.visit_terminator(
-            block,
-            terminator,
-            mir::Location {
-                block,
-                statement_index: stmt_id,
-            },
-        );
-        // if ConstantExtractor added a new frame, we don't execute anything here
-        // but await the next call to step
-        if !new? {
-            assert_eq!(old_frames, self.cur_frame());
-            self.terminator(terminator)?;
-        }
+        assert_eq!(old_frames, self.cur_frame());
+        self.terminator(terminator)?;
         Ok(true)
     }
 
@@ -152,184 +105,4 @@ impl<'a, 'tcx, M: Machine<'tcx>> EvalContext<'a, 'tcx, M> {
         }
         Ok(())
     }
-
-    /// returns `true` if a stackframe was pushed
-    fn global_item(
-        &mut self,
-        instance: Instance<'tcx>,
-        span: Span,
-        mutability: Mutability,
-    ) -> EvalResult<'tcx, bool> {
-        debug!("global_item: {:?}", instance);
-        let cid = GlobalId {
-            instance,
-            promoted: None,
-        };
-        if self.tcx.interpret_interner.borrow().get_cached(cid).is_some() {
-            return Ok(false);
-        }
-        if self.tcx.has_attr(instance.def_id(), "linkage") {
-            M::global_item_with_linkage(self, cid.instance, mutability)?;
-            return Ok(false);
-        }
-        let instance_ty = instance.ty(self.tcx);
-        let layout = self.layout_of(instance_ty)?;
-        assert!(!layout.is_unsized());
-        let ptr = self.memory.allocate(
-            layout.size.bytes(),
-            layout.align,
-            None,
-        )?;
-        self.tcx.interpret_interner.borrow_mut().cache(cid, ptr.alloc_id);
-        let internally_mutable = !layout.ty.is_freeze(self.tcx, self.param_env, span);
-        let mutability = if mutability == Mutability::Mutable || internally_mutable {
-            Mutability::Mutable
-        } else {
-            Mutability::Immutable
-        };
-        let cleanup = StackPopCleanup::MarkStatic(mutability);
-        let name = ty::tls::with(|tcx| tcx.item_path_str(instance.def_id()));
-        trace!("pushing stack frame for global: {}", name);
-        let mir = self.load_mir(instance.def)?;
-        self.push_stack_frame(
-            instance,
-            span,
-            mir,
-            Place::from_ptr(ptr, layout.align),
-            cleanup,
-        )?;
-        Ok(true)
-    }
-}
-
-struct ConstantExtractor<'a, 'b: 'a, 'tcx: 'b, M: Machine<'tcx> + 'a> {
-    span: Span,
-    ecx: &'a mut EvalContext<'b, 'tcx, M>,
-    mir: &'tcx mir::Mir<'tcx>,
-    instance: ty::Instance<'tcx>,
-    // Whether a stackframe for a new constant has been pushed
-    new_constant: &'a mut EvalResult<'tcx, bool>,
-}
-
-impl<'a, 'b, 'tcx, M: Machine<'tcx>> ConstantExtractor<'a, 'b, 'tcx, M> {
-    fn try<F: FnOnce(&mut Self) -> EvalResult<'tcx, bool>>(&mut self, f: F) {
-        match *self.new_constant {
-            // already computed a constant, don't do more than one per iteration
-            Ok(true) => {},
-            // no constants computed yet
-            Ok(false) => *self.new_constant = f(self),
-            // error happened, abort the visitor traversing
-            Err(_) => {},
-        }
-    }
-}
-
-impl<'a, 'b, 'tcx, M: Machine<'tcx>> Visitor<'tcx> for ConstantExtractor<'a, 'b, 'tcx, M> {
-    fn visit_constant(&mut self, constant: &mir::Constant<'tcx>, location: mir::Location) {
-        self.super_constant(constant, location);
-        self.try(|this| {
-            match constant.literal {
-                // already computed by rustc
-                mir::Literal::Value { value: &ty::Const { val: ConstVal::Unevaluated(def_id, substs), .. } } => {
-                    debug!("global_item: {:?}, {:#?}", def_id, substs);
-                    let substs = this.ecx.tcx.trans_apply_param_substs(this.instance.substs, &substs);
-                    debug!("global_item_new_substs: {:#?}", substs);
-                    debug!("global_item_param_env: {:#?}", this.ecx.param_env);
-                    let instance = Instance::resolve(
-                        this.ecx.tcx,
-                        this.ecx.param_env,
-                        def_id,
-                        substs,
-                    ).ok_or(EvalErrorKind::TypeckError)?; // turn error prop into a panic to expose associated type in const issue
-                    this.ecx.global_item(
-                        instance,
-                        constant.span,
-                        Mutability::Immutable,
-                    )
-                }
-                mir::Literal::Value { .. } => Ok(false),
-                mir::Literal::Promoted { index } => {
-                    let cid = GlobalId {
-                        instance: this.instance,
-                        promoted: Some(index),
-                    };
-                    if this.ecx.tcx.interpret_interner.borrow().get_cached(cid).is_some() {
-                        return Ok(false);
-                    }
-                    let mir = &this.mir.promoted[index];
-                    let ty = this.ecx.monomorphize(mir.return_ty(), this.instance.substs);
-                    let layout = this.ecx.layout_of(ty)?;
-                    assert!(!layout.is_unsized());
-                    let ptr = this.ecx.memory.allocate(
-                        layout.size.bytes(),
-                        layout.align,
-                        None,
-                    )?;
-                    this.ecx.tcx.interpret_interner.borrow_mut().cache(cid, ptr.alloc_id);
-                    trace!("pushing stack frame for {:?}", index);
-                    this.ecx.push_stack_frame(
-                        this.instance,
-                        constant.span,
-                        mir,
-                        Place::from_ptr(ptr, layout.align),
-                        StackPopCleanup::MarkStatic(Mutability::Immutable),
-                    )?;
-                    Ok(true)
-                }
-            }
-        });
-    }
-
-    fn visit_place(
-        &mut self,
-        place: &mir::Place<'tcx>,
-        context: PlaceContext<'tcx>,
-        location: mir::Location,
-    ) {
-        self.super_place(place, context, location);
-        self.try(|this| {
-            if let mir::Place::Static(ref static_) = *place {
-                let def_id = static_.def_id;
-                let span = this.span;
-                if let Some(node_item) = this.ecx.tcx.hir.get_if_local(def_id) {
-                    if let hir::map::Node::NodeItem(&hir::Item { ref node, .. }) = node_item {
-                        if let hir::ItemStatic(_, m, _) = *node {
-                            let instance = Instance::mono(this.ecx.tcx, def_id);
-                            this.ecx.global_item(
-                                instance,
-                                span,
-                                if m == hir::MutMutable {
-                                    Mutability::Mutable
-                                } else {
-                                    Mutability::Immutable
-                                },
-                            )
-                        } else {
-                            bug!("static def id doesn't point to static");
-                        }
-                    } else {
-                        bug!("static def id doesn't point to item");
-                    }
-                } else {
-                    let def = this.ecx.tcx.describe_def(def_id).expect("static not found");
-                    if let hir::def::Def::Static(_, mutable) = def {
-                        let instance = Instance::mono(this.ecx.tcx, def_id);
-                        this.ecx.global_item(
-                            instance,
-                            span,
-                            if mutable {
-                                Mutability::Mutable
-                            } else {
-                                Mutability::Immutable
-                            },
-                        )
-                    } else {
-                        bug!("static found but isn't a static: {:?}", def);
-                    }
-                }
-            } else {
-                Ok(false)
-            }
-        });
-    }
 }