Rustup

.travis.yml

@@ -1,4 +1,5 @@
 language: rust
+cache: cargo
 rust:
 - nightly
 before_script:

Cargo.toml

@@ -23,12 +23,14 @@ path = "miri/lib.rs"
 
 [dependencies]
 byteorder = { version = "1.1", features = ["i128"]}
-cargo_metadata = { version = "0.2", optional = true }
+cargo_metadata = { version = "0.5", optional = true }
 regex = "0.2.2"
 lazy_static = "1.0"
+env_logger = "0.5.0-rc.1"
+log = "0.4"
 
 [features]
 cargo_miri = ["cargo_metadata"]
 
 [dev-dependencies]
-compiletest_rs = { version = "0.3.3", features = ["tmp"] }
+compiletest_rs = { version = "0.3.4", features = ["tmp"] }

miri/bin/cargo-miri.rs

@@ -121,7 +121,9 @@ fn main() {
 
         let home = option_env!("RUSTUP_HOME").or(option_env!("MULTIRUST_HOME"));
         let toolchain = option_env!("RUSTUP_TOOLCHAIN").or(option_env!("MULTIRUST_TOOLCHAIN"));
-        let sys_root = if let (Some(home), Some(toolchain)) = (home, toolchain) {
+        let sys_root = if let Ok(sysroot) = ::std::env::var("MIRI_SYSROOT") {
+            sysroot
+        } else if let (Some(home), Some(toolchain)) = (home, toolchain) {
             format!("{}/toolchains/{}", home, toolchain)
         } else {
             option_env!("RUST_SYSROOT")

miri/bin/miri.rs

@@ -1,10 +1,11 @@
-#![feature(rustc_private, i128_type)]
+#![feature(rustc_private)]
 
 extern crate getopts;
 extern crate miri;
 extern crate rustc;
 extern crate rustc_driver;
 extern crate rustc_errors;
+extern crate rustc_trans_utils;
 extern crate env_logger;
 extern crate log_settings;
 extern crate syntax;
@@ -17,7 +18,8 @@ use rustc_driver::driver::{CompileState, CompileController};
 use rustc::session::config::{self, Input, ErrorOutputType};
 use rustc::hir::{self, itemlikevisit};
 use rustc::ty::TyCtxt;
-use syntax::ast::{self, MetaItemKind, NestedMetaItemKind};
+use rustc_trans_utils::trans_crate::TransCrate;
+use syntax::ast;
 use std::path::PathBuf;
 
 struct MiriCompilerCalls {
@@ -61,14 +63,15 @@ impl<'a> CompilerCalls<'a> for MiriCompilerCalls {
     }
     fn late_callback(
         &mut self,
+        trans: &TransCrate,
         matches: &getopts::Matches,
         sess: &Session,
         cstore: &CrateStore,
         input: &Input,
         odir: &Option<PathBuf>,
         ofile: &Option<PathBuf>,
     ) -> Compilation {
-        self.default.late_callback(matches, sess, cstore, input, odir, ofile)
+        self.default.late_callback(trans, matches, sess, cstore, input, odir, ofile)
     }
     fn build_controller(
         &mut self,
@@ -98,11 +101,9 @@ fn after_analysis<'a, 'tcx>(state: &mut CompileState<'a, 'tcx>) {
     state.session.abort_if_errors();
 
     let tcx = state.tcx.unwrap();
-    let limits = resource_limits_from_attributes(state);
 
     if std::env::args().any(|arg| arg == "--test") {
         struct Visitor<'a, 'tcx: 'a>(
-            miri::ResourceLimits,
             TyCtxt<'a, 'tcx, 'tcx>,
             &'a CompileState<'a, 'tcx>
         );
@@ -113,21 +114,21 @@ fn after_analysis<'a, 'tcx>(state: &mut CompileState<'a, 'tcx>) {
                         attr.name().map_or(false, |n| n == "test")
                     })
                     {
-                        let did = self.1.hir.body_owner_def_id(body_id);
+                        let did = self.0.hir.body_owner_def_id(body_id);
                         println!(
                             "running test: {}",
-                            self.1.def_path_debug_str(did),
+                            self.0.def_path_debug_str(did),
                         );
-                        miri::eval_main(self.1, did, None, self.0);
-                        self.2.session.abort_if_errors();
+                        miri::eval_main(self.0, did, None);
+                        self.1.session.abort_if_errors();
                     }
                 }
             }
             fn visit_trait_item(&mut self, _trait_item: &'hir hir::TraitItem) {}
             fn visit_impl_item(&mut self, _impl_item: &'hir hir::ImplItem) {}
         }
         state.hir_crate.unwrap().visit_all_item_likes(
-            &mut Visitor(limits, tcx, state),
+            &mut Visitor(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);
@@ -138,91 +139,50 @@ fn after_analysis<'a, 'tcx>(state: &mut CompileState<'a, 'tcx>) {
                 None
             }
         });
-        miri::eval_main(tcx, entry_def_id, start_wrapper, limits);
+        miri::eval_main(tcx, entry_def_id, start_wrapper);
 
         state.session.abort_if_errors();
     } else {
         println!("no main function found, assuming auxiliary build");
     }
 }
 
-fn resource_limits_from_attributes(state: &CompileState) -> miri::ResourceLimits {
-    let mut limits = miri::ResourceLimits::default();
-    let krate = state.hir_crate.as_ref().unwrap();
-    let err_msg = "miri attributes need to be in the form `miri(key = value)`";
-    let extract_int = |lit: &syntax::ast::Lit| -> u128 {
-        match lit.node {
-            syntax::ast::LitKind::Int(i, _) => i,
-            _ => {
-                state.session.span_fatal(
-                    lit.span,
-                    "expected an integer literal",
-                )
-            }
-        }
-    };
-
-    for attr in krate.attrs.iter().filter(|a| {
-        a.name().map_or(false, |n| n == "miri")
-    })
-    {
-        if let Some(items) = attr.meta_item_list() {
-            for item in items {
-                if let NestedMetaItemKind::MetaItem(ref inner) = item.node {
-                    if let MetaItemKind::NameValue(ref value) = inner.node {
-                        match &inner.name().as_str()[..] {
-                            "memory_size" => limits.memory_size = extract_int(value) as u64,
-                            "step_limit" => limits.step_limit = extract_int(value) as u64,
-                            "stack_limit" => limits.stack_limit = extract_int(value) as usize,
-                            _ => state.session.span_err(item.span, "unknown miri attribute"),
-                        }
-                    } else {
-                        state.session.span_err(inner.span, err_msg);
-                    }
-                } else {
-                    state.session.span_err(item.span, err_msg);
-                }
-            }
-        } else {
-            state.session.span_err(attr.span, err_msg);
-        }
-    }
-    limits
-}
-
 fn init_logger() {
-    let format = |record: &log::LogRecord| {
-        if record.level() == log::LogLevel::Trace {
+    let format = |formatter: &mut env_logger::fmt::Formatter, record: &log::Record| {
+        use std::io::Write;
+        if record.level() == log::Level::Trace {
             // prepend frame number
             let indentation = log_settings::settings().indentation;
-            format!(
+            writeln!(
+                formatter,
                 "{indentation}:{lvl}:{module}: {text}",
                 lvl = record.level(),
-                module = record.location().module_path(),
+                module = record.module_path().unwrap_or("<unknown module>"),
                 indentation = indentation,
                 text = record.args(),
             )
         } else {
-            format!(
+            writeln!(
+                formatter,
                 "{lvl}:{module}: {text}",
                 lvl = record.level(),
-                module = record.location().module_path(),
+                module = record.module_path().unwrap_or("<unknown_module>"),
                 text = record.args(),
             )
         }
     };
 
-    let mut builder = env_logger::LogBuilder::new();
+    let mut builder = env_logger::Builder::new();
     builder.format(format).filter(
         None,
-        log::LogLevelFilter::Info,
+        log::LevelFilter::Info,
     );
 
     if std::env::var("MIRI_LOG").is_ok() {
         builder.parse(&std::env::var("MIRI_LOG").unwrap());
     }
 
-    builder.init().unwrap();
+    builder.init();
 }
 
 fn find_sysroot() -> String {