diff --git a/benches/helpers/miri_helper.rs b/benches/helpers/miri_helper.rs index 3725df24cd..441c35f551 100644 --- a/benches/helpers/miri_helper.rs +++ b/benches/helpers/miri_helper.rs @@ -4,7 +4,7 @@ extern crate rustc; extern crate rustc_driver; extern crate test; -use self::miri::{eval_main, run_mir_passes}; +use self::miri::eval_main; use self::rustc::session::Session; use self::rustc_driver::{driver, CompilerCalls, Compilation}; use std::cell::RefCell; @@ -55,7 +55,6 @@ impl<'a> CompilerCalls<'a> for MiriCompilerCalls<'a> { .expect("no main or start function found"); let entry_def_id = tcx.map.local_def_id(entry_node_id); - run_mir_passes(tcx); let memory_size = 100*1024*1024; // 100MB let step_limit = 1000_000; let stack_limit = 100; diff --git a/src/bin/miri.rs b/src/bin/miri.rs index 04b11ff607..3f0a6f778b 100644 --- a/src/bin/miri.rs +++ b/src/bin/miri.rs @@ -74,7 +74,6 @@ fn after_analysis<'a, 'tcx>(state: &mut CompileState<'a, 'tcx>) { state.session.abort_if_errors(); let tcx = state.tcx.unwrap(); - miri::run_mir_passes(tcx); let limits = resource_limits_from_attributes(state); if std::env::args().any(|arg| arg == "--test") { @@ -94,15 +93,13 @@ fn after_analysis<'a, 'tcx>(state: &mut CompileState<'a, 'tcx>) { fn visit_impl_item(&mut self, _impl_item: &'hir hir::ImplItem) {} } state.hir_crate.unwrap().visit_all_item_likes(&mut Visitor(limits, tcx, state)); - } else { - if let Some((entry_node_id, _)) = *state.session.entry_fn.borrow() { - let entry_def_id = tcx.hir.local_def_id(entry_node_id); - miri::eval_main(tcx, entry_def_id, limits); + } else if let Some((entry_node_id, _)) = *state.session.entry_fn.borrow() { + let entry_def_id = tcx.hir.local_def_id(entry_node_id); + miri::eval_main(tcx, entry_def_id, limits); - state.session.abort_if_errors(); - } else { - println!("no main function found, assuming auxiliary build"); - } + state.session.abort_if_errors(); + } else { + println!("no main function found, assuming auxiliary build"); } } diff --git a/src/eval_context.rs b/src/eval_context.rs index f2e4a3d780..b9aa499015 100644 --- a/src/eval_context.rs +++ b/src/eval_context.rs @@ -1,4 +1,3 @@ -use std::cell::Ref; use std::collections::HashMap; use std::fmt::Write; @@ -24,8 +23,6 @@ use memory::{Memory, Pointer}; use operator; use value::{PrimVal, PrimValKind, Value}; -pub type MirRef<'tcx> = Ref<'tcx, mir::Mir<'tcx>>; - pub struct EvalContext<'a, 'tcx: 'a> { /// The results of the type checker, from rustc. pub(crate) tcx: TyCtxt<'a, 'tcx, 'tcx>, @@ -48,7 +45,7 @@ pub struct EvalContext<'a, 'tcx: 'a> { pub(crate) steps_remaining: u64, /// Drop glue for arrays and slices - pub(crate) seq_drop_glue: MirRef<'tcx>, + pub(crate) seq_drop_glue: &'tcx mir::Mir<'tcx>, } /// A stack frame. @@ -58,7 +55,7 @@ pub struct Frame<'tcx> { //////////////////////////////////////////////////////////////////////////////// /// The MIR for the function called on this frame. - pub mir: MirRef<'tcx>, + pub mir: &'tcx mir::Mir<'tcx>, /// The def_id and substs of the current function pub instance: ty::Instance<'tcx>, @@ -302,8 +299,6 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { DUMMY_SP, ); let seq_drop_glue = tcx.alloc_mir(seq_drop_glue); - // Perma-borrow MIR from shims to prevent mutation. - ::std::mem::forget(seq_drop_glue.borrow()); EvalContext { tcx, memory: Memory::new(&tcx.data_layout, limits.memory_size), @@ -311,7 +306,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { stack: Vec::new(), stack_limit: limits.stack_limit, steps_remaining: limits.step_limit, - seq_drop_glue: seq_drop_glue.borrow(), + seq_drop_glue: seq_drop_glue, } } @@ -385,10 +380,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { ty.is_sized(self.tcx, &self.tcx.empty_parameter_environment(), DUMMY_SP) } - pub fn load_mir(&self, instance: ty::InstanceDef<'tcx>) -> EvalResult<'tcx, MirRef<'tcx>> { + pub fn load_mir(&self, instance: ty::InstanceDef<'tcx>) -> EvalResult<'tcx, &'tcx mir::Mir<'tcx>> { trace!("load mir {:?}", instance); match instance { - ty::InstanceDef::Item(def_id) => self.tcx.maybe_item_mir(def_id).ok_or_else(|| EvalError::NoMirFor(self.tcx.item_path_str(def_id))), + ty::InstanceDef::Item(def_id) => self.tcx.maybe_optimized_mir(def_id).ok_or_else(|| EvalError::NoMirFor(self.tcx.item_path_str(def_id))), _ => Ok(self.tcx.instance_mir(instance)), } } @@ -450,7 +445,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { &mut self, instance: ty::Instance<'tcx>, span: codemap::Span, - mir: MirRef<'tcx>, + mir: &'tcx mir::Mir<'tcx>, return_lvalue: Lvalue<'tcx>, return_to_block: StackPopCleanup, ) -> EvalResult<'tcx> { @@ -1028,7 +1023,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } pub(super) fn operand_ty(&self, operand: &mir::Operand<'tcx>) -> Ty<'tcx> { - self.monomorphize(operand.ty(&self.mir(), self.tcx), self.substs()) + self.monomorphize(operand.ty(self.mir(), self.tcx), self.substs()) } fn copy(&mut self, src: Pointer, dest: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx> { @@ -1445,8 +1440,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { self.stack.last_mut().expect("no call frames exist") } - pub(super) fn mir(&self) -> MirRef<'tcx> { - Ref::clone(&self.frame().mir) + pub(super) fn mir(&self) -> &'tcx mir::Mir<'tcx> { + self.frame().mir } pub(super) fn substs(&self) -> &'tcx Substs<'tcx> { @@ -1734,32 +1729,6 @@ fn report(tcx: TyCtxt, ecx: &EvalContext, e: EvalError) { err.emit(); } -pub fn run_mir_passes<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { - let mut passes = ::rustc::mir::transform::Passes::new(); - passes.push_hook(Box::new(::rustc_mir::transform::dump_mir::DumpMir)); - passes.push_pass(Box::new(::rustc_mir::transform::no_landing_pads::NoLandingPads)); - passes.push_pass(Box::new(::rustc_mir::transform::simplify::SimplifyCfg::new("no-landing-pads"))); - - // From here on out, regions are gone. - passes.push_pass(Box::new(::rustc_mir::transform::erase_regions::EraseRegions)); - - passes.push_pass(Box::new(::rustc_mir::transform::add_call_guards::AddCallGuards)); - passes.push_pass(Box::new(::rustc_borrowck::ElaborateDrops)); - passes.push_pass(Box::new(::rustc_mir::transform::no_landing_pads::NoLandingPads)); - passes.push_pass(Box::new(::rustc_mir::transform::simplify::SimplifyCfg::new("elaborate-drops"))); - - // No lifetime analysis based on borrowing can be done from here on out. - passes.push_pass(Box::new(::rustc_mir::transform::instcombine::InstCombine::new())); - passes.push_pass(Box::new(::rustc_mir::transform::deaggregator::Deaggregator)); - passes.push_pass(Box::new(::rustc_mir::transform::copy_prop::CopyPropagation)); - - passes.push_pass(Box::new(::rustc_mir::transform::simplify::SimplifyLocals)); - passes.push_pass(Box::new(::rustc_mir::transform::add_call_guards::AddCallGuards)); - passes.push_pass(Box::new(::rustc_mir::transform::dump_mir::Marker("PreMiri"))); - - passes.run_passes(tcx); -} - // TODO(solson): Upstream these methods into rustc::ty::layout. pub(super) trait IntegerExt { diff --git a/src/lib.rs b/src/lib.rs index c55b453800..f373606218 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -9,10 +9,8 @@ extern crate log; extern crate log_settings; #[macro_use] extern crate rustc; -extern crate rustc_borrowck; extern crate rustc_const_math; extern crate rustc_data_structures; -extern crate rustc_mir; extern crate syntax; // From crates.io. @@ -40,7 +38,6 @@ pub use eval_context::{ ResourceLimits, StackPopCleanup, eval_main, - run_mir_passes, }; pub use lvalue::{ diff --git a/src/lvalue.rs b/src/lvalue.rs index 0f1ce103b0..9660b8f4ee 100644 --- a/src/lvalue.rs +++ b/src/lvalue.rs @@ -399,6 +399,6 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { } pub(super) fn lvalue_ty(&self, lvalue: &mir::Lvalue<'tcx>) -> Ty<'tcx> { - self.monomorphize(lvalue.ty(&self.mir(), self.tcx).to_ty(self.tcx), self.substs()) + self.monomorphize(lvalue.ty(self.mir(), self.tcx).to_ty(self.tcx), self.substs()) } } diff --git a/src/step.rs b/src/step.rs index 11db048f78..4f599f8ba1 100644 --- a/src/step.rs +++ b/src/step.rs @@ -2,8 +2,6 @@ //! //! The main entry point is the `step` method. -use std::cell::Ref; - use rustc::hir::def_id::DefId; use rustc::hir; use rustc::mir::visit::{Visitor, LvalueContext}; @@ -12,7 +10,7 @@ use rustc::ty::layout::Layout; use rustc::ty::{subst, self}; use error::{EvalResult, EvalError}; -use eval_context::{EvalContext, StackPopCleanup, MirRef}; +use eval_context::{EvalContext, StackPopCleanup}; use lvalue::{Global, GlobalId, Lvalue}; use value::{Value, PrimVal}; use syntax::codemap::Span; @@ -47,7 +45,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { span: stmt.source_info.span, instance: self.frame().instance, ecx: self, - mir: Ref::clone(&mir), + mir, new_constants: &mut new, }.visit_statement(block, stmt, mir::Location { block, statement_index: stmt_id }); if new? == 0 { @@ -64,7 +62,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { span: terminator.source_info.span, instance: self.frame().instance, ecx: self, - mir: Ref::clone(&mir), + mir, new_constants: &mut new, }.visit_terminator(block, terminator, mir::Location { block, statement_index: stmt_id }); if new? == 0 { @@ -142,7 +140,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { struct ConstantExtractor<'a, 'b: 'a, 'tcx: 'b> { span: Span, ecx: &'a mut EvalContext<'b, 'tcx>, - mir: MirRef<'tcx>, + mir: &'tcx mir::Mir<'tcx>, instance: ty::Instance<'tcx>, new_constants: &'a mut EvalResult<'tcx, u64>, } @@ -209,8 +207,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ConstantExtractor<'a, 'b, 'tcx> { if self.ecx.globals.contains_key(&cid) { return; } - let mir = Ref::clone(&self.mir); - let mir = Ref::map(mir, |mir| &mir.promoted[index]); + let mir = &self.mir.promoted[index]; self.try(|this| { let ty = this.ecx.monomorphize(mir.return_ty, this.instance.substs); this.ecx.globals.insert(cid, Global::uninitialized(ty)); diff --git a/src/terminator/drop.rs b/src/terminator/drop.rs index bc37730b71..93dfe408e3 100644 --- a/src/terminator/drop.rs +++ b/src/terminator/drop.rs @@ -53,13 +53,13 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> { _ => bug!("expected thin ptr, got {:?}", arg), }; arg = Value::ByValPair(PrimVal::Ptr(ptr), PrimVal::Bytes(n as u128)); - ::eval_context::MirRef::clone(&self.seq_drop_glue) + self.seq_drop_glue }, ty::TySlice(elem) => { instance.substs = self.tcx.mk_substs([ Kind::from(elem), ].iter().cloned()); - ::eval_context::MirRef::clone(&self.seq_drop_glue) + self.seq_drop_glue }, _ => self.load_mir(instance.def)?, }; diff --git a/tests/compiletest.rs b/tests/compiletest.rs index 6e5890d6ad..78b2a2f3ce 100644 --- a/tests/compiletest.rs +++ b/tests/compiletest.rs @@ -5,7 +5,7 @@ use std::io::Write; fn compile_fail(sysroot: &Path) { let flags = format!("--sysroot {} -Dwarnings", sysroot.to_str().expect("non utf8 path")); - for_all_targets(&sysroot, |target| { + for_all_targets(sysroot, |target| { let mut config = compiletest::default_config(); config.host_rustcflags = Some(flags.clone()); config.mode = "compile-fail".parse().expect("Invalid mode"); @@ -79,8 +79,8 @@ fn compile_test() { .expect("rustc not found for -vV") .stdout; let host = std::str::from_utf8(&host).expect("sysroot is not utf8"); - let host = host.split("\nhost: ").skip(1).next().expect("no host: part in rustc -vV"); - let host = host.split("\n").next().expect("no \n after host"); + let host = host.split("\nhost: ").nth(1).expect("no host: part in rustc -vV"); + let host = host.split('\n').next().expect("no \n after host"); if let Ok(path) = std::env::var("MIRI_RUSTC_TEST") { let mut mir_not_found = Vec::new(); @@ -148,10 +148,8 @@ fn compile_test() { abi.push(text[abi_s.len()..end].to_string()); } else if text.starts_with(limit_s) { limits.push(text[limit_s.len()..end].to_string()); - } else { - if text.find("aborting").is_none() { - failed.push(text[..end].to_string()); - } + } else if text.find("aborting").is_none() { + failed.push(text[..end].to_string()); } } writeln!(stderr.lock(), "FAILED with exit code {:?}", output.status.code()).unwrap(); @@ -196,10 +194,10 @@ fn compile_test() { panic!("ran miri on rustc test suite. Test failing for convenience"); } else { run_pass(); - for_all_targets(&sysroot, |target| { + for_all_targets(sysroot, |target| { miri_pass("tests/run-pass", &target, host); }); - compile_fail(&sysroot); + compile_fail(sysroot); } } @@ -218,7 +216,7 @@ fn vec_to_hist(mut v: Vec) -> Vec<(usize, T)> { let mut current = v.next(); 'outer: while let Some(current_val) = current { let mut n = 1; - while let Some(next) = v.next() { + for next in &mut v { if next == current_val { n += 1; } else {