2016-06-11 14:10:25 -05:00
|
|
|
#![feature(rustc_private)]
|
2015-11-12 15:50:58 -06:00
|
|
|
|
2016-05-09 16:30:47 -05:00
|
|
|
extern crate getopts;
|
2015-11-21 21:20:06 -06:00
|
|
|
extern crate miri;
|
2015-11-12 15:50:58 -06:00
|
|
|
extern crate rustc;
|
|
|
|
extern crate rustc_driver;
|
2016-07-05 06:04:46 -05:00
|
|
|
extern crate rustc_plugin;
|
2016-05-30 11:09:52 -05:00
|
|
|
extern crate env_logger;
|
|
|
|
extern crate log_settings;
|
2016-06-10 06:01:51 -05:00
|
|
|
extern crate syntax;
|
|
|
|
#[macro_use] extern crate log;
|
2015-11-12 15:50:58 -06:00
|
|
|
|
2016-06-30 22:33:24 -05:00
|
|
|
use miri::{eval_main, run_mir_passes};
|
2015-11-12 15:50:58 -06:00
|
|
|
use rustc::session::Session;
|
2016-06-30 22:33:24 -05:00
|
|
|
use rustc::mir::mir_map::MirMap;
|
2016-06-15 06:18:35 -05:00
|
|
|
use rustc_driver::{driver, CompilerCalls, Compilation};
|
2016-07-05 06:04:46 -05:00
|
|
|
use syntax::ast::MetaItemKind;
|
2015-11-12 15:50:58 -06:00
|
|
|
|
|
|
|
struct MiriCompilerCalls;
|
|
|
|
|
|
|
|
impl<'a> CompilerCalls<'a> for MiriCompilerCalls {
|
2016-05-09 16:30:47 -05:00
|
|
|
fn build_controller(
|
|
|
|
&mut self,
|
|
|
|
_: &Session,
|
|
|
|
_: &getopts::Matches
|
|
|
|
) -> driver::CompileController<'a> {
|
2015-11-12 15:50:58 -06:00
|
|
|
let mut control = driver::CompileController::basic();
|
2016-07-05 06:04:46 -05:00
|
|
|
control.after_hir_lowering.callback = Box::new(|state| {
|
|
|
|
state.session.plugin_attributes.borrow_mut().push(("miri".to_owned(), syntax::feature_gate::AttributeType::Whitelisted));
|
|
|
|
});
|
2016-06-15 06:18:35 -05:00
|
|
|
control.after_analysis.stop = Compilation::Stop;
|
2015-11-12 15:50:58 -06:00
|
|
|
control.after_analysis.callback = Box::new(|state| {
|
2016-03-21 03:54:20 -05:00
|
|
|
state.session.abort_if_errors();
|
2016-06-13 07:27:05 -05:00
|
|
|
|
|
|
|
let tcx = state.tcx.unwrap();
|
|
|
|
let mir_map = state.mir_map.unwrap();
|
2016-06-17 22:35:37 -05:00
|
|
|
let (node_id, _) = state.session.entry_fn.borrow()
|
|
|
|
.expect("no main or start function found");
|
2016-06-30 22:33:24 -05:00
|
|
|
|
2016-07-05 06:04:46 -05:00
|
|
|
let krate = state.hir_crate.as_ref().unwrap();
|
|
|
|
let mut memory_size = 100*1024*1024; // 100MB
|
|
|
|
fn extract_str(lit: &syntax::ast::Lit) -> syntax::parse::token::InternedString {
|
|
|
|
match lit.node {
|
|
|
|
syntax::ast::LitKind::Str(ref s, _) => s.clone(),
|
|
|
|
_ => panic!("attribute values need to be strings"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for attr in krate.attrs.iter() {
|
|
|
|
match attr.node.value.node {
|
|
|
|
MetaItemKind::List(ref name, _) if name != "miri" => {}
|
|
|
|
MetaItemKind::List(_, ref items) => for item in items {
|
|
|
|
match item.node {
|
|
|
|
MetaItemKind::NameValue(ref name, ref value) => {
|
|
|
|
match &**name {
|
|
|
|
"memory_size" => memory_size = extract_str(value).parse::<u64>().expect("not a number"),
|
|
|
|
_ => state.session.span_err(item.span, "unknown miri attribute"),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => state.session.span_err(item.span, "miri attributes need to be of key = value kind"),
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_ => {},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-30 22:33:24 -05:00
|
|
|
let mut mir_map = MirMap { map: mir_map.map.clone() };
|
|
|
|
run_mir_passes(tcx, &mut mir_map);
|
2016-07-05 06:04:46 -05:00
|
|
|
eval_main(tcx, &mir_map, node_id, memory_size);
|
2016-06-14 04:52:45 -05:00
|
|
|
|
2016-06-15 06:18:35 -05:00
|
|
|
state.session.abort_if_errors();
|
2015-11-12 15:50:58 -06:00
|
|
|
});
|
|
|
|
|
|
|
|
control
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-30 11:09:52 -05:00
|
|
|
fn init_logger() {
|
2016-06-17 20:55:24 -05:00
|
|
|
const MAX_INDENT: usize = 40;
|
|
|
|
|
2016-05-30 11:09:52 -05:00
|
|
|
let format = |record: &log::LogRecord| {
|
2016-06-17 20:48:45 -05:00
|
|
|
if record.level() == log::LogLevel::Trace {
|
|
|
|
// prepend spaces to indent the final string
|
|
|
|
let indentation = log_settings::settings().indentation;
|
|
|
|
format!("{lvl}:{module}{depth:2}{indent:<indentation$} {text}",
|
|
|
|
lvl = record.level(),
|
|
|
|
module = record.location().module_path(),
|
2016-06-17 20:55:24 -05:00
|
|
|
depth = indentation / MAX_INDENT,
|
|
|
|
indentation = indentation % MAX_INDENT,
|
2016-06-17 20:48:45 -05:00
|
|
|
indent = "",
|
|
|
|
text = record.args())
|
|
|
|
} else {
|
|
|
|
format!("{lvl}:{module}: {text}",
|
|
|
|
lvl = record.level(),
|
|
|
|
module = record.location().module_path(),
|
|
|
|
text = record.args())
|
|
|
|
}
|
2016-05-30 11:09:52 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
let mut builder = env_logger::LogBuilder::new();
|
|
|
|
builder.format(format).filter(None, log::LogLevelFilter::Info);
|
|
|
|
|
2016-06-01 10:32:57 -05:00
|
|
|
if std::env::var("MIRI_LOG").is_ok() {
|
|
|
|
builder.parse(&std::env::var("MIRI_LOG").unwrap());
|
2016-05-30 11:09:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
builder.init().unwrap();
|
|
|
|
}
|
2016-06-14 20:30:59 -05:00
|
|
|
|
|
|
|
fn find_sysroot() -> String {
|
|
|
|
// Taken from https://github.com/Manishearth/rust-clippy/pull/911.
|
|
|
|
let home = option_env!("RUSTUP_HOME").or(option_env!("MULTIRUST_HOME"));
|
|
|
|
let toolchain = option_env!("RUSTUP_TOOLCHAIN").or(option_env!("MULTIRUST_TOOLCHAIN"));
|
|
|
|
match (home, toolchain) {
|
|
|
|
(Some(home), Some(toolchain)) => format!("{}/toolchains/{}", home, toolchain),
|
|
|
|
_ => option_env!("RUST_SYSROOT")
|
|
|
|
.expect("need to specify RUST_SYSROOT env var or use rustup or multirust")
|
|
|
|
.to_owned(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
init_logger();
|
|
|
|
let mut args: Vec<String> = std::env::args().collect();
|
|
|
|
|
|
|
|
let sysroot_flag = String::from("--sysroot");
|
|
|
|
if !args.contains(&sysroot_flag) {
|
|
|
|
args.push(sysroot_flag);
|
|
|
|
args.push(find_sysroot());
|
|
|
|
}
|
|
|
|
|
|
|
|
rustc_driver::run_compiler(&args, &mut MiriCompilerCalls);
|
|
|
|
}
|