Merge branch 'master' into hack_branch_for_miri_do_not_delete_until_merged

Author: RalfJung

README.md

@@ -40,25 +40,6 @@ how to fix it, you could send a PR. :smile:
 cargo run --bin miri tests/run-pass-fullmir/vecs.rs # Or whatever test you like.
 ```
 
-## Debugging
-
-Since the heart of miri (the main interpreter engine) lives in rustc, tracing
-the interpreter requires a version of rustc compiled with tracing.  To this
-end, you will have to compile your own rustc:
-```
-git clone https://github.com/rust-lang/rust/ rustc
-cd rustc
-cp config.toml.example config.toml
-# Now edit `config.toml` and set `debug-assertions = true`
-./x.py build src/rustc
-rustup toolchain link custom build/x86_64-unknown-linux-gnu/stage2
-```
-The `build` step can take 30 to 60 minutes.
-
-Now, in the miri directory, you can `rustup override set custom` and re-build
-everything.  Finally, if you now set `RUST_LOG=rustc_mir::interpret=trace` as
-environment variable, you will get detailed step-by-step tracing information.
-
 ## Running miri on your own project('s test suite)
 
 Install miri as a cargo subcommand with `cargo install --debug`.
@@ -68,8 +49,8 @@ through miri.
 
 ## Running miri with full libstd
 
-Per default libstd does not contain the MIR of non-polymorphic functions.  When
-miri hits a call to such a function, execution terminates.  To fix this, it is
+Per default libstd does not contain the MIR of non-polymorphic functions. When
+miri hits a call to such a function, execution terminates. To fix this, it is
 possible to compile libstd with full MIR:
 
 ```sh
@@ -91,6 +72,37 @@ your toolchain changes (e.g., when you update the nightly).
 You can also set `-Zmiri-start-fn` to make miri start evaluation with the
 `start_fn` lang item, instead of starting at the `main` function.
 
+## Development and Debugging
+
+Since the heart of miri (the main interpreter engine) lives in rustc, working on
+miri will often require using a locally built rustc. This includes getting a
+trace of the execution, as distributed rustc has `trace!` disabled.
+
+The first-time setup for a local rustc looks as follows:
+```
+git clone https://github.com/rust-lang/rust/ rustc
+cd rustc
+cp config.toml.example config.toml
+# Now edit `config.toml` and set `debug-assertions = true`
+./x.py build src/rustc
+# You may have to change the architecture in the next command
+rustup toolchain link custom build/x86_64-unknown-linux-gnu/stage2
+# Now cd to your miri directory
+rustup override set custom
+```
+The `build` step can take 30 minutes and more.
+
+Now you can `cargo build` miri, and you can `cargo test --tests`.  (`--tests`
+is needed to skip doctests because we have not built rustdoc for your custom
+toolchain.) You can also set `RUST_LOG=rustc_mir::interpret=trace` as
+environment variable to get a step-by-step trace.
+
+If you changed something in rustc and want to re-build, run
+```
+./x.py build src/rustc --keep-stage 0
+```
+This avoids rebuilding the entire stage 0, which can save a lot of time.
+
 ## Contributing and getting help
 
 Check out the issues on this GitHub repository for some ideas. There's lots that

src/operator.rs

@@ -34,6 +34,8 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
         right: Scalar,
         right_ty: ty::Ty<'tcx>,
     ) -> EvalResult<'tcx, Option<(Scalar, bool)>> {
+        trace!("ptr_op: {:?} {:?} {:?}", left, bin_op, right);
+
         use rustc::mir::BinOp::*;
         use rustc::ty::layout::Integer::*;
         let usize = Primitive::Int(match self.memory.pointer_size().bytes() {
@@ -81,7 +83,9 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
                     (Scalar::Bits { .. }, Scalar::Bits { .. }) => {
                         left.to_bits(left_layout.size)? == right.to_bits(right_layout.size)?
                     },
+                    // FIXME: Test if both allocations are still live *or* if they are in the same allocation? (same for Ne below)
                     (Scalar::Ptr(left), Scalar::Ptr(right)) => left == right,
+                    // FIXME: We should probably error out when comparing anything but NULL with a pointer (same for Ne below)
                     _ => false,
                 };
                 Ok(Some((Scalar::from_bool(result), false)))

tests/compile-fail-fullmir/reallocate-bad-size.rs

@@ -10,6 +10,6 @@ use std::alloc::*;
 fn main() {
     unsafe {
         let x = Global.alloc(Layout::from_size_align_unchecked(1, 1)).unwrap();
-        let _y = Global.realloc(x, Layout::from_size_align_unchecked(2, 1), 1).unwrap();
+        Global.realloc(x, Layout::from_size_align_unchecked(2, 1), 1).unwrap();
     }
 }

tests/compile-fail-fullmir/reallocate-change-alloc.rs

@@ -8,7 +8,7 @@ use std::alloc::*;
 fn main() {
     unsafe {
         let x = Global.alloc(Layout::from_size_align_unchecked(1, 1)).unwrap();
-        let _y = Global.realloc(x, Layout::from_size_align_unchecked(1, 1), 1).unwrap();
+        Global.realloc(x, Layout::from_size_align_unchecked(1, 1), 1).unwrap();
         let _z = *(x.as_ptr() as *mut u8); //~ ERROR constant evaluation error
         //~^ NOTE dangling pointer was dereferenced
     }

tests/compiletest.rs

@@ -62,6 +62,7 @@ fn compile_fail(sysroot: &Path, path: &str, target: &str, host: &str, need_fullm
         config.compile_lib_path = rustc_lib_path();
     }
     flags.push(format!("--sysroot {}", sysroot.display()));
+    flags.push("-Dwarnings -Dunused".to_owned()); // overwrite the -Aunused in compiletest-rs
     config.src_base = PathBuf::from(path.to_string());
     flags.push("-Zmir-emit-validate=1".to_owned());
     config.target_rustcflags = Some(flags.join(" "));
@@ -70,23 +71,6 @@ fn compile_fail(sysroot: &Path, path: &str, target: &str, host: &str, need_fullm
     compiletest::run_tests(&config);
 }
 
-fn rustc_pass(sysroot: &Path, path: &str) {
-    eprintln!("{}", format!("## Running run-pass tests in {} against rustc", path).green().bold());
-    let mut config = compiletest::Config::default().tempdir();
-    config.mode = "run-pass".parse().expect("Invalid mode");
-    config.src_base = PathBuf::from(path);
-    if let Some(rustc_path) = rustc_test_suite() {
-        config.rustc_path = rustc_path;
-        config.run_lib_path = rustc_lib_path();
-        config.compile_lib_path = rustc_lib_path();
-        config.target_rustcflags = Some(format!("-Dwarnings --sysroot {}", sysroot.display()));
-    } else {
-        config.target_rustcflags = Some("-Dwarnings".to_owned());
-    }
-    config.host_rustcflags = Some("-Dwarnings".to_string());
-    compiletest::run_tests(&config);
-}
-
 fn miri_pass(sysroot: &Path, path: &str, target: &str, host: &str, need_fullmir: bool, opt: bool) {
     if need_fullmir && !have_fullmir() {
         eprintln!("{}", format!(
@@ -116,6 +100,7 @@ fn miri_pass(sysroot: &Path, path: &str, target: &str, host: &str, need_fullmir:
     }
     let mut flags = Vec::new();
     flags.push(format!("--sysroot {}", sysroot.display()));
+    flags.push("-Dwarnings -Dunused".to_owned()); // overwrite the -Aunused in compiletest-rs
     if have_fullmir() {
         flags.push("-Zmiri-start-fn".to_owned());
     }
@@ -190,12 +175,6 @@ fn run_pass_miri(opt: bool) {
     miri_pass(&sysroot, "tests/run-pass-fullmir", &host, &host, true, opt);
 }
 
-fn run_pass_rustc() {
-    let sysroot = get_sysroot();
-    rustc_pass(&sysroot, "tests/run-pass");
-    rustc_pass(&sysroot, "tests/run-pass-fullmir");
-}
-
 fn compile_fail_miri() {
     let sysroot = get_sysroot();
     let host = get_host();
@@ -211,10 +190,7 @@ fn test() {
     // introduces.  We still get parallelism within our tests because `compiletest`
     // uses `libtest` which runs jobs in parallel.
 
-    run_pass_rustc();
-
     run_pass_miri(false);
-
     // FIXME: Disabled for now, as the optimizer is pretty broken and crashes...
     // See https://github.com/rust-lang/rust/issues/50411
     //run_pass_miri(true);

tests/run-pass/box_box_trait.rs

@@ -13,7 +13,9 @@ impl Drop for DroppableStruct {
 trait MyTrait { fn dummy(&self) { } }
 impl MyTrait for Box<DroppableStruct> {}
 
+#[allow(dead_code)]
 struct Whatever { w: Box<MyTrait+'static> }
+
 impl  Whatever {
     fn new(w: Box<MyTrait+'static>) -> Whatever {
         Whatever { w: w }

tests/run-pass/pointers.rs

@@ -57,4 +57,5 @@ fn main() {
     assert_eq!(match_ref_mut(), 42);
     // FIXME: improve this test... how?
     assert!(dangling_pointer() != std::ptr::null());
+    assert!(match dangling_pointer() as usize { 0 => false, _ => true });
 }