From 6ec3d65068cbcbb606b62da8a53744d6844b6cfc Mon Sep 17 00:00:00 2001 From: Scott Olson Date: Fri, 16 Dec 2016 17:10:16 -0800 Subject: [PATCH] Revert "Revert "rustup to rustc 1.15.0-dev (ace092f56 2016-12-13)"" --- src/bin/miri.rs | 22 ++++++----- src/error.rs | 3 ++ src/memory.rs | 16 ++++++++ src/terminator/intrinsic.rs | 1 + src/terminator/mod.rs | 55 +++++++++++++++++++++----- tests/compiletest.rs | 70 ++++++--------------------------- tests/run-pass/aux_test.rs | 7 ++++ tests/run-pass/auxiliary/dep.rs | 1 + 8 files changed, 97 insertions(+), 78 deletions(-) create mode 100644 tests/run-pass/aux_test.rs create mode 100644 tests/run-pass/auxiliary/dep.rs diff --git a/src/bin/miri.rs b/src/bin/miri.rs index 6c0161ef075..9e1d6235d4c 100644 --- a/src/bin/miri.rs +++ b/src/bin/miri.rs @@ -10,7 +10,7 @@ #[macro_use] extern crate log; use rustc::session::Session; -use rustc_driver::{CompilerCalls, Compilation}; +use rustc_driver::CompilerCalls; use rustc_driver::driver::{CompileState, CompileController}; use syntax::ast::{MetaItemKind, NestedMetaItemKind}; @@ -21,7 +21,6 @@ fn build_controller(&mut self, _: &Session, _: &getopts::Matches) -> CompileCont let mut control = CompileController::basic(); control.after_hir_lowering.callback = Box::new(after_hir_lowering); control.after_analysis.callback = Box::new(after_analysis); - control.after_analysis.stop = Compilation::Stop; control } } @@ -35,14 +34,16 @@ fn after_analysis(state: &mut CompileState) { state.session.abort_if_errors(); let tcx = state.tcx.unwrap(); - let (entry_node_id, _) = state.session.entry_fn.borrow() - .expect("no main or start function found"); - let entry_def_id = tcx.map.local_def_id(entry_node_id); - let limits = resource_limits_from_attributes(state); - miri::run_mir_passes(tcx); - miri::eval_main(tcx, entry_def_id, limits); - - state.session.abort_if_errors(); + if let Some((entry_node_id, _)) = *state.session.entry_fn.borrow() { + let entry_def_id = tcx.map.local_def_id(entry_node_id); + let limits = resource_limits_from_attributes(state); + miri::run_mir_passes(tcx); + miri::eval_main(tcx, entry_def_id, limits); + + state.session.abort_if_errors(); + } else { + println!("no main function found, assuming auxiliary build"); + } } fn resource_limits_from_attributes(state: &CompileState) -> miri::ResourceLimits { @@ -134,6 +135,7 @@ fn main() { args.push(sysroot_flag); args.push(find_sysroot()); } + args.push("-Zalways-encode-mir".to_owned()); rustc_driver::run_compiler(&args, &mut MiriCompilerCalls, None, None); } diff --git a/src/error.rs b/src/error.rs index afc1855e8e7..9b532e01375 100644 --- a/src/error.rs +++ b/src/error.rs @@ -11,6 +11,7 @@ pub enum EvalError<'tcx> { FunctionPointerTyMismatch(Abi, &'tcx FnSig<'tcx>, &'tcx BareFnTy<'tcx>), NoMirFor(String), + UnterminatedCString(Pointer), DanglingPointerDeref, InvalidMemoryAccess, InvalidFunctionPointer, @@ -119,6 +120,8 @@ fn description(&self) -> &str { "tried to deallocate frozen memory", EvalError::Layout(_) => "rustc layout computation failed", + EvalError::UnterminatedCString(_) => + "attempted to get length of a null terminated string, but no null found before end of allocation", } } diff --git a/src/memory.rs b/src/memory.rs index 671174fd756..babd9bcb783 100644 --- a/src/memory.rs +++ b/src/memory.rs @@ -530,6 +530,22 @@ pub fn copy(&mut self, src: Pointer, dest: Pointer, size: u64, align: u64) -> Ev Ok(()) } + pub fn read_c_str(&self, ptr: Pointer) -> EvalResult<'tcx, &[u8]> { + let alloc = self.get(ptr.alloc_id)?; + assert_eq!(ptr.offset as usize as u64, ptr.offset); + let offset = ptr.offset as usize; + match alloc.bytes[offset..].iter().position(|&c| c == 0) { + Some(size) => { + if self.relocations(ptr, (size + 1) as u64)?.count() != 0 { + return Err(EvalError::ReadPointerAsBytes); + } + self.check_defined(ptr, (size + 1) as u64)?; + Ok(&alloc.bytes[offset..offset + size]) + }, + None => Err(EvalError::UnterminatedCString(ptr)), + } + } + pub fn read_bytes(&self, ptr: Pointer, size: u64) -> EvalResult<'tcx, &[u8]> { self.get_bytes(ptr, size, 1) } diff --git a/src/terminator/intrinsic.rs b/src/terminator/intrinsic.rs index 9be094d9bd9..443696edb12 100644 --- a/src/terminator/intrinsic.rs +++ b/src/terminator/intrinsic.rs @@ -57,6 +57,7 @@ pub(super) fn call_intrinsic( } "atomic_load" | + "atomic_load_relaxed" | "atomic_load_acq" | "volatile_load" => { let ty = substs.type_at(0); diff --git a/src/terminator/mod.rs b/src/terminator/mod.rs index fdc7c1db6fa..23d59e3fc3e 100644 --- a/src/terminator/mod.rs +++ b/src/terminator/mod.rs @@ -90,7 +90,16 @@ pub(super) fn eval_terminator( ty::TyFnPtr(bare_fn_ty) => { let fn_ptr = self.eval_operand_to_primval(func)?.to_ptr(); let (def_id, substs, abi, sig) = self.memory.get_fn(fn_ptr.alloc_id)?; - if abi != bare_fn_ty.abi || sig != bare_fn_ty.sig.skip_binder() { + let bare_sig = self.tcx.erase_late_bound_regions_and_normalize(&bare_fn_ty.sig); + let bare_sig = self.tcx.erase_regions(&bare_sig); + // transmuting function pointers in miri is fine as long as the number of + // arguments and the abi don't change. + // FIXME: also check the size of the arguments' type and the return type + // Didn't get it to work, since that triggers an assertion in rustc which + // checks whether the type has escaping regions + if abi != bare_fn_ty.abi || + sig.variadic != bare_sig.variadic || + sig.inputs().len() != bare_sig.inputs().len() { return Err(EvalError::FunctionPointerTyMismatch(abi, sig, bare_fn_ty)); } self.eval_fn_call(def_id, substs, bare_fn_ty, destination, args, @@ -189,7 +198,7 @@ fn eval_fn_call( use syntax::abi::Abi; match fn_ty.abi { Abi::RustIntrinsic => { - let ty = fn_ty.sig.0.output; + let ty = fn_ty.sig.0.output(); let layout = self.type_layout(ty)?; let (ret, target) = destination.unwrap(); self.call_intrinsic(def_id, substs, arg_operands, ret, ty, layout, target)?; @@ -197,7 +206,7 @@ fn eval_fn_call( } Abi::C => { - let ty = fn_ty.sig.0.output; + let ty = fn_ty.sig.0.output(); let (ret, target) = destination.unwrap(); self.call_c_abi(def_id, arg_operands, ret, ty)?; self.goto_block(target); @@ -320,11 +329,6 @@ fn call_c_abi( .collect(); let args = args_res?; - if link_name.starts_with("pthread_") { - warn!("ignoring C ABI call: {}", link_name); - return Ok(()); - } - let usize = self.tcx.types.usize; match &link_name[..] { @@ -371,6 +375,37 @@ fn call_c_abi( self.write_primval(dest, PrimVal::new(result as u64), dest_ty)?; } + "memchr" => { + let ptr = args[0].read_ptr(&self.memory)?; + let val = self.value_to_primval(args[1], usize)?.to_u64() as u8; + let num = self.value_to_primval(args[2], usize)?.to_u64(); + if let Some(idx) = self.memory.read_bytes(ptr, num)?.iter().position(|&c| c == val) { + let new_ptr = ptr.offset(idx as u64); + self.write_value(Value::ByVal(PrimVal::from_ptr(new_ptr)), dest, dest_ty)?; + } else { + self.write_value(Value::ByVal(PrimVal::new(0)), dest, dest_ty)?; + } + } + + "getenv" => { + { + let name_ptr = args[0].read_ptr(&self.memory)?; + let name = self.memory.read_c_str(name_ptr)?; + info!("ignored env var request for `{:?}`", ::std::str::from_utf8(name)); + } + self.write_value(Value::ByVal(PrimVal::new(0)), dest, dest_ty)?; + } + + // unix panic code inside libstd will read the return value of this function + "pthread_rwlock_rdlock" => { + self.write_primval(dest, PrimVal::new(0), dest_ty)?; + } + + link_name if link_name.starts_with("pthread_") => { + warn!("ignoring C ABI call: {}", link_name); + return Ok(()); + }, + _ => { return Err(EvalError::Unimplemented(format!("can't call C ABI function: {}", link_name))); } @@ -520,7 +555,7 @@ fn trait_method( let offset = idx * self.memory.pointer_size(); let fn_ptr = self.memory.read_ptr(vtable.offset(offset))?; let (def_id, substs, _abi, sig) = self.memory.get_fn(fn_ptr.alloc_id)?; - *first_ty = sig.inputs[0]; + *first_ty = sig.inputs()[0]; Ok((def_id, substs, Vec::new())) } else { Err(EvalError::VtableForArgumentlessMethod) @@ -664,7 +699,7 @@ pub fn drop( // some values don't need to call a drop impl, so the value is null if drop_fn != Pointer::from_int(0) { let (def_id, substs, _abi, sig) = self.memory.get_fn(drop_fn.alloc_id)?; - let real_ty = sig.inputs[0]; + let real_ty = sig.inputs()[0]; self.drop(Lvalue::from_ptr(ptr), real_ty, drop)?; drop.push((def_id, Value::ByVal(PrimVal::from_ptr(ptr)), substs)); } else { diff --git a/tests/compiletest.rs b/tests/compiletest.rs index 1ee86a07b22..f7bf16926ba 100644 --- a/tests/compiletest.rs +++ b/tests/compiletest.rs @@ -27,6 +27,15 @@ fn run_pass() { compiletest::run_tests(&config); } +fn miri_pass(path: &str, target: &str) { + let mut config = compiletest::default_config(); + config.mode = "mir-opt".parse().expect("Invalid mode"); + config.src_base = PathBuf::from(path); + config.target = target.to_owned(); + config.rustc_path = PathBuf::from("target/debug/miri"); + compiletest::run_tests(&config); +} + fn for_all_targets(sysroot: &str, mut f: F) { for target in std::fs::read_dir(format!("{}/lib/rustlib/", sysroot)).unwrap() { let target = target.unwrap(); @@ -57,65 +66,10 @@ fn compile_test() { }; run_pass(); for_all_targets(&sysroot, |target| { - let files = std::fs::read_dir("tests/run-pass").unwrap(); - let files: Box> = if let Ok(path) = std::env::var("MIRI_RUSTC_TEST") { - Box::new(files.chain(std::fs::read_dir(path).unwrap())) - } else { - Box::new(files) - }; - let mut mir_not_found = 0; - let mut crate_not_found = 0; - let mut success = 0; - let mut failed = 0; - for file in files { - let file = file.unwrap(); - let path = file.path(); - - if !file.metadata().unwrap().is_file() || !path.to_str().unwrap().ends_with(".rs") { - continue; - } - - let stderr = std::io::stderr(); - write!(stderr.lock(), "test [miri-pass] {} ... ", path.display()).unwrap(); - let mut cmd = std::process::Command::new("target/debug/miri"); - cmd.arg(path); - cmd.arg(format!("--target={}", target)); - let libs = Path::new(&sysroot).join("lib"); - let sysroot = libs.join("rustlib").join(&target).join("lib"); - let paths = std::env::join_paths(&[libs, sysroot]).unwrap(); - cmd.env(compiletest::procsrv::dylib_env_var(), paths); - - match cmd.output() { - Ok(ref output) if output.status.success() => { - success += 1; - writeln!(stderr.lock(), "ok").unwrap() - }, - Ok(output) => { - let output_err = std::str::from_utf8(&output.stderr).unwrap(); - if let Some(text) = output_err.splitn(2, "no mir for `").nth(1) { - mir_not_found += 1; - let end = text.find('`').unwrap(); - writeln!(stderr.lock(), "NO MIR FOR `{}`", &text[..end]).unwrap(); - } else if let Some(text) = output_err.splitn(2, "can't find crate for `").nth(1) { - crate_not_found += 1; - let end = text.find('`').unwrap(); - writeln!(stderr.lock(), "CAN'T FIND CRATE FOR `{}`", &text[..end]).unwrap(); - } else { - failed += 1; - writeln!(stderr.lock(), "FAILED with exit code {:?}", output.status.code()).unwrap(); - writeln!(stderr.lock(), "stdout: \n {}", std::str::from_utf8(&output.stdout).unwrap()).unwrap(); - writeln!(stderr.lock(), "stderr: \n {}", output_err).unwrap(); - } - } - Err(e) => { - writeln!(stderr.lock(), "FAILED: {}", e).unwrap(); - panic!("failed to execute miri"); - }, - } + miri_pass("tests/run-pass", &target); + if let Ok(path) = std::env::var("MIRI_RUSTC_TEST") { + miri_pass(&path, &target); } - let stderr = std::io::stderr(); - writeln!(stderr.lock(), "{} success, {} mir not found, {} crate not found, {} failed", success, mir_not_found, crate_not_found, failed).unwrap(); - assert_eq!(failed, 0, "some tests failed"); }); compile_fail(&sysroot); } diff --git a/tests/run-pass/aux_test.rs b/tests/run-pass/aux_test.rs new file mode 100644 index 00000000000..aa471f6cf8f --- /dev/null +++ b/tests/run-pass/aux_test.rs @@ -0,0 +1,7 @@ +// aux-build:dep.rs + +extern crate dep; + +fn main() { + dep::foo(); +} diff --git a/tests/run-pass/auxiliary/dep.rs b/tests/run-pass/auxiliary/dep.rs new file mode 100644 index 00000000000..b76b4321d62 --- /dev/null +++ b/tests/run-pass/auxiliary/dep.rs @@ -0,0 +1 @@ +pub fn foo() {} -- GitLab