Fix merge conflicts

Author: pvdrz

.appveyor.yml

@@ -28,11 +28,12 @@ install:
     - set PATH=%USERPROFILE%\.cargo\bin;%PATH%
     - rustup default stable
     - rustup uninstall beta
-    - rustup component remove rust-docs & exit 0
     - rustup update
     # Install "master" toolchain
     - cargo install rustup-toolchain-install-master & exit 0
-    - rustup-toolchain-install-master -f -n master %RUSTC_HASH% -c cargo -c rust-src
+    # We need to install cargo here as well or else the DLL search path inside `cargo run`
+    # will be for the wrong toolchain. (On Unix, `./miri` takes care of this, but not here.)
+    - rustup-toolchain-install-master -f -n master %RUSTC_HASH% -c rust-src -c rustc-dev -c cargo
     - rustup default master
     - rustc --version
     - cargo --version

.travis.yml

@@ -35,11 +35,10 @@ before_script:
 - export PATH=$HOME/.cargo/bin:$PATH
 - rustup default stable
 - rustup uninstall beta
-- rustup component remove rust-docs || echo "rust-docs already gone"
 - rustup update
 # Install "master" toolchain
 - cargo install rustup-toolchain-install-master || echo "rustup-toolchain-install-master already installed"
-- travis_retry rustup-toolchain-install-master -f -n master $RUSTC_HASH -c rust-src
+- travis_retry rustup-toolchain-install-master -f -n master $RUSTC_HASH -c rust-src -c rustc-dev
 - rustup default master
 - rustc --version
 - cargo --version

CONTRIBUTING.md

@@ -31,8 +31,10 @@ Miri heavily relies on internal rustc interfaces to execute MIR.  Still, some
 things (like adding support for a new intrinsic or a shim for an external
 function being called) can be done by working just on the Miri side.
 
-To prepare, make sure you are using a nightly Rust compiler.  Then you should be
-able to just `cargo build` Miri.
+To prepare, make sure you are using a nightly Rust compiler.  You also need to
+have the `rust-src` and `rustc-dev` components installed, which you can add via
+`rustup component add rust-src rustc-dev`.  Then you should be able to just
+`cargo build` Miri.
 
 In case this fails, your nightly might be incompatible with Miri master.  The
 `rust-version` file contains the commit hash of rustc that Miri is currently
@@ -41,7 +43,7 @@ to wait for the next nightly to get released. You can also use
 [`rustup-toolchain-install-master`](https://github.com/kennytm/rustup-toolchain-install-master)
 to install that exact version of rustc as a toolchain:
 ```
-rustup-toolchain-install-master $(cat rust-version) -c rust-src
+rustup-toolchain-install-master $(cat rust-version) -c rust-src -c rustc-dev
 ```
 
 Another common problem is outdated dependencies: Miri does not come with a

Cargo.lock

@@ -30,15 +30,15 @@ doctest = false # and no doc tests
 required-features = ["rustc_tests"]
 
 [dependencies]
-cargo_metadata = { version = "0.8", optional = true }
+cargo_metadata = { version = "0.9.0", optional = true }
 directories = { version = "2.0", optional = true }
 rustc_version = { version = "0.2.3", optional = true }
 getrandom = { version = "0.1.8", features = ["std"] }
 byteorder = "1.3"
-env_logger = "0.6"
+env_logger = "0.7.1"
 log = "0.4"
 shell-escape = "0.1.4"
-hex = "0.3.2"
+hex = "0.4.0"
 rand = "0.7"
 
 # A noop dependency that changes in the Rust repository, it's a bit of a hack.

Cargo.toml

@@ -1 +1 @@
-55e00631e5bc5b16d40232914e57deeea197a8e4
+9e346646e93cc243567e27bb0f4e8716d56ad1f1

rust-version

@@ -6,6 +6,8 @@ use std::path::{PathBuf, Path};
 use std::process::Command;
 use std::ops::Not;
 
+const XARGO_MIN_VERSION: (u32, u32, u32) = (0, 3, 17);
+
 const CARGO_MIRI_HELP: &str = r#"Interprets bin crates and tests in Miri
 
 Usage:
@@ -258,7 +260,7 @@ fn setup(ask_user: bool) {
     }
 
     // First, we need xargo.
-    if xargo_version().map_or(true, |v| v < (0, 3, 16)) {
+    if xargo_version().map_or(true, |v| v < XARGO_MIN_VERSION) {
         if std::env::var("XARGO").is_ok() {
             // The user manually gave us a xargo binary; don't do anything automatically.
             show_error(format!("Your xargo is too old; please upgrade to the latest version"))

src/bin/cargo-miri.rs

@@ -4,12 +4,12 @@ use rand::rngs::StdRng;
 use rand::SeedableRng;
 
 use rustc::hir::def_id::DefId;
-use rustc::ty::layout::{Align, LayoutOf, Size};
+use rustc::ty::layout::{LayoutOf, Size};
 use rustc::ty::{self, TyCtxt};
 use syntax::source_map::DUMMY_SP;
 
 use crate::{
-    struct_error, EnvVars, Evaluator, FnVal, HelpersEvalContextExt, InterpCx, InterpError,
+    EnvVars, Evaluator, FnVal, HelpersEvalContextExt, InterpCx, InterpError,
     InterpResult, MemoryExtra, MiriMemoryKind, Pointer, Scalar, StackPopCleanup, Tag,
     TlsEvalContextExt,
 };
@@ -48,7 +48,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     EnvVars::init(&mut ecx, config.excluded_env_vars);
 
     // Setup first stack-frame
-    let main_instance = ty::Instance::mono(ecx.tcx.tcx, main_id);
+    let main_instance = ty::Instance::mono(tcx, main_id);
     let main_mir = ecx.load_mir(main_instance.def, None)?;
 
     if !main_mir.return_ty().is_unit() || main_mir.arg_count != 0 {
@@ -59,11 +59,10 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     let main_ret_ty = tcx.fn_sig(main_id).output();
     let main_ret_ty = main_ret_ty.no_bound_vars().unwrap();
     let start_instance = ty::Instance::resolve(
-        ecx.tcx.tcx,
+        tcx,
         ty::ParamEnv::reveal_all(),
         start_id,
-        ecx.tcx
-            .mk_substs(::std::iter::once(ty::subst::GenericArg::from(main_ret_ty))),
+        tcx.mk_substs(::std::iter::once(ty::subst::GenericArg::from(main_ret_ty))),
     )
     .unwrap();
     let start_mir = ecx.load_mir(start_instance.def, None)?;
@@ -106,7 +105,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     {
         let argc_place = ecx.allocate(dest.layout, MiriMemoryKind::Env.into());
         ecx.write_scalar(argc, argc_place.into())?;
-        ecx.machine.argc = Some(argc_place.ptr.to_ptr()?);
+        ecx.machine.argc = Some(argc_place.ptr);
     }
 
     // Third argument (`argv`): created from `config.args`.
@@ -134,8 +133,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     }
     // Make an array with all these pointers, in the Miri memory.
     let argvs_layout = ecx.layout_of(
-        ecx.tcx
-            .mk_array(ecx.tcx.mk_imm_ptr(ecx.tcx.types.u8), argvs.len() as u64),
+        tcx.mk_array(tcx.mk_imm_ptr(tcx.types.u8), argvs.len() as u64),
     )?;
     let argvs_place = ecx.allocate(argvs_layout, MiriMemoryKind::Env.into());
     for (idx, arg) in argvs.into_iter().enumerate() {
@@ -151,36 +149,26 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     {
         let argv_place = ecx.allocate(dest.layout, MiriMemoryKind::Env.into());
         ecx.write_scalar(argv, argv_place.into())?;
-        ecx.machine.argv = Some(argv_place.ptr.to_ptr()?);
+        ecx.machine.argv = Some(argv_place.ptr);
     }
     // Store command line as UTF-16 for Windows `GetCommandLineW`.
     {
         let cmd_utf16: Vec<u16> = cmd.encode_utf16().collect();
-        let cmd_ptr = ecx.memory.allocate(
-            Size::from_bytes(cmd_utf16.len() as u64 * 2),
-            Align::from_bytes(2).unwrap(),
-            MiriMemoryKind::Env.into(),
-        );
-        ecx.machine.cmd_line = Some(cmd_ptr);
+        let cmd_type = tcx.mk_array(tcx.types.u16, cmd_utf16.len() as u64);
+        let cmd_place = ecx.allocate(ecx.layout_of(cmd_type)?, MiriMemoryKind::Env.into());
+        ecx.machine.cmd_line = Some(cmd_place.ptr);
         // Store the UTF-16 string. We just allocated so we know the bounds are fine.
         let char_size = Size::from_bytes(2);
-        let cmd_alloc = ecx.memory.get_mut(cmd_ptr.alloc_id)?;
-        let mut cur_ptr = cmd_ptr;
-        for &c in cmd_utf16.iter() {
-            cmd_alloc.write_scalar(
-                &*ecx.tcx,
-                cur_ptr,
-                Scalar::from_uint(c, char_size).into(),
-                char_size,
-            )?;
-            cur_ptr = cur_ptr.offset(char_size, &*ecx.tcx)?;
+        for (idx, &c) in cmd_utf16.iter().enumerate() {
+            let place = ecx.mplace_field(cmd_place, idx as u64)?;
+            ecx.write_scalar(Scalar::from_uint(c, char_size), place.into())?;
         }
     }
 
     args.next().expect_none("start lang item has more arguments than expected");
 
     // Set the last_error to 0
-    let errno_layout = ecx.layout_of(ecx.tcx.types.u32)?;
+    let errno_layout = ecx.layout_of(tcx.types.u32)?;
     let errno_place = ecx.allocate(errno_layout, MiriMemoryKind::Static.into());
     ecx.write_scalar(Scalar::from_u32(0), errno_place.into())?;
     ecx.machine.last_error = Some(errno_place);
@@ -233,7 +221,7 @@ pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) {
                 };
 
                 let msg = format!("Miri evaluation error: {}", msg);
-                let mut err = struct_error(ecx.tcx.tcx.at(span), msg.as_str());
+                let mut err = ecx.tcx.sess.struct_span_err(span, msg.as_str());
                 let frames = ecx.generate_stacktrace(None);
                 err.span_label(span, msg);
                 // We iterate with indices because we need to look at the next frame (the caller).

src/eval.rs

@@ -5,6 +5,7 @@ use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX};
 use rustc::mir;
 use rustc::ty::{
     self,
+    List,
     layout::{self, LayoutOf, Size, TyLayout},
 };
 
@@ -75,7 +76,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     /// Get the `Place` for a local
     fn local_place(&mut self, local: mir::Local) -> InterpResult<'tcx, PlaceTy<'tcx, Tag>> {
         let this = self.eval_context_mut();
-        let place = mir::Place { base: mir::PlaceBase::Local(local), projection: Box::new([]) };
+        let place = mir::Place { base: mir::PlaceBase::Local(local), projection: List::empty() };
         this.eval_place(&place)
     }
 

src/helpers.rs

@@ -63,7 +63,7 @@ impl<'mir, 'tcx> GlobalState {
                 // This never overflows because `int >= glb`
                 let offset = int - glb;
                 // If the offset exceeds the size of the allocation, this access is illegal
-                if offset <= memory.get(alloc_id)?.size.bytes() {
+                if offset <= memory.get_size_and_align(alloc_id, AllocCheck::MaybeDead)?.0.bytes() {
                     // This pointer is untagged because it was created from a cast
                     Pointer::new_with_tag(alloc_id, Size::from_bytes(offset), Tag::Untagged)
                 } else {