Reserve fides for stdio and fix merge issues

Author: pvdrz

.appveyor.yml

@@ -17,16 +17,21 @@ cache:
     - '%USERPROFILE%\.rustup'
 
 install:
+    # Compute the rust version we use
+    - set /p RUSTC_HASH=<rust-version
     # Install Rust
     - curl -sSf --retry 3 -o rustup-init.exe https://win.rustup.rs/
     - rustup-init.exe -y --default-host %TARGET% --default-toolchain stable
     - set PATH=%USERPROFILE%\.cargo\bin;%PATH%
+    - rustup default stable
+    - rustup uninstall beta
+    - rustup update
     # Install "master" toolchain
     - cargo install rustup-toolchain-install-master & exit 0
-    - set /p RUSTC_HASH=<rust-version
     - rustup-toolchain-install-master -f -n master %RUSTC_HASH% -c cargo -c rust-src
     - rustup default master
     - rustc --version
+    - cargo --version
 
 build_script:
     - set RUSTFLAGS=-C debug-assertions

.travis.yml

@@ -33,12 +33,15 @@ before_script:
 # Install Rust ("stable" toolchain for better caching, it is just used to build rustup-toolchain-install-master)
 - curl https://build.travis-ci.org/files/rustup-init.sh -sSf | sh -s -- -y --default-toolchain stable
 - export PATH=$HOME/.cargo/bin:$PATH
+- rustup default stable
+- rustup uninstall beta
 - 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
 - rustup default master
 - rustc --version
+- cargo --version
 
 script:
 - ./travis.sh

Cargo.toml

@@ -59,5 +59,5 @@ cargo_miri = ["cargo_metadata", "directories", "rustc_version"]
 rustc_tests = []
 
 [dev-dependencies]
-compiletest_rs = { version = "0.3.22", features = ["tmp", "stable"] }
+compiletest_rs = { version = "0.3.23", features = ["tmp"] }
 colored = "1.6"

rust-version

@@ -1 +1 @@
-ea3ba36f3f4b7f0168a27d23c499efeb2304e2d5
+084beb83e0e87d673d5fabc844d28e8e8ae2ab4c

src/bin/miri-rustc-tests.rs

@@ -46,7 +46,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
                 struct Visitor<'tcx>(TyCtxt<'tcx>);
                 impl<'tcx, 'hir> itemlikevisit::ItemLikeVisitor<'hir> for Visitor<'tcx> {
                     fn visit_item(&mut self, i: &'hir hir::Item) {
-                        if let hir::ItemKind::Fn(.., body_id) = i.node {
+                        if let hir::ItemKind::Fn(.., body_id) = i.kind {
                             if i.attrs.iter().any(|attr| attr.check_name(syntax::symbol::sym::test)) {
                                 let config = MiriConfig {
                                     validate: true,

src/eval.rs

@@ -63,7 +63,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
         ty::ParamEnv::reveal_all(),
         start_id,
         ecx.tcx.mk_substs(
-            ::std::iter::once(ty::subst::Kind::from(main_ret_ty)))
+            ::std::iter::once(ty::subst::GenericArg::from(main_ret_ty)))
         ).unwrap();
     let start_mir = ecx.load_mir(start_instance.def, None)?;
 

src/helpers.rs

@@ -211,7 +211,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             fn visit_value(&mut self, v: MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>
             {
                 trace!("UnsafeCellVisitor: {:?} {:?}", *v, v.layout.ty);
-                let is_unsafe_cell = match v.layout.ty.sty {
+                let is_unsafe_cell = match v.layout.ty.kind {
                     ty::Adt(adt, _) => Some(adt.did) == self.ecx.tcx.lang_items().unsafe_cell_type(),
                     _ => false,
                 };

src/shims/io.rs

@@ -5,13 +5,23 @@ use std::io::Read;
 use crate::stacked_borrows::Tag;
 use crate::*;
 
-#[derive(Default)]
 pub struct FileHandler {
     files: HashMap<i32, File>,
     flags: HashMap<i32, i32>,
     low: i32,
 }
 
+impl Default for FileHandler {
+    fn default() -> Self {
+        FileHandler {
+            files: Default::default(),
+            flags: Default::default(),
+            // 0, 1 and 2 are reserved for stdin, stdout and stderr
+            low: 3,
+        }
+    }
+}
+
 impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
     fn open(

src/shims/mod.rs

@@ -1,11 +1,11 @@
+pub mod dlsym;
+pub mod env;
 pub mod foreign_items;
 pub mod intrinsics;
 pub mod tls;
-pub mod dlsym;
-pub mod env;
 pub mod io;
 
-use rustc::{ty, mir};
+use rustc::{mir, ty};
 
 use crate::*;
 
@@ -19,7 +19,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         ret: Option<mir::BasicBlock>,
     ) -> InterpResult<'tcx, Option<&'mir mir::Body<'tcx>>> {
         let this = self.eval_context_mut();
-        trace!("eval_fn_call: {:#?}, {:?}", instance, dest.map(|place| *place));
+        trace!(
+            "eval_fn_call: {:#?}, {:?}",
+            instance,
+            dest.map(|place| *place)
+        );
 
         // First, run the common hooks also supported by CTFE.
         if this.hook_fn(instance, args, dest)? {
@@ -28,27 +32,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         }
         // There are some more lang items we want to hook that CTFE does not hook (yet).
         if this.tcx.lang_items().align_offset_fn() == Some(instance.def.def_id()) {
-
-            let n = {
-                let ptr = this.force_ptr(this.read_scalar(args[0])?.not_undef()?)?;
-                let align = this.force_bits(
-                    this.read_scalar(args[1])?.not_undef()?,
-                    this.pointer_size()
-                )? as usize;
-
-                let stride = this.memory().get(ptr.alloc_id)?.align.bytes() as usize;
-                // if the allocation alignment is at least the required alignment, we use the
-                // libcore implementation
-                if stride >= align {
-                    ((stride + ptr.offset.bytes() as usize) as *const ())
-                        .align_offset(align) as u128
-                } else {
-                    u128::max_value()
-                }
-            };
-
             let dest = dest.unwrap();
-            let n = this.truncate(n, dest.layout);
+            let n = this
+                .align_offset(args[0], args[1])?
+                .unwrap_or_else(|| this.truncate(u128::max_value(), dest.layout));
             this.write_scalar(Scalar::from_uint(n, dest.layout.size), dest)?;
             this.goto_block(ret)?;
             return Ok(None);
@@ -66,4 +53,39 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         // Otherwise, load the MIR.
         Ok(Some(this.load_mir(instance.def, None)?))
     }
+
+    fn align_offset(
+        &mut self,
+        ptr_op: OpTy<'tcx, Tag>,
+        align_op: OpTy<'tcx, Tag>,
+    ) -> InterpResult<'tcx, Option<u128>> {
+        let this = self.eval_context_mut();
+
+        let req_align = this.force_bits(
+            this.read_scalar(align_op)?.not_undef()?,
+            this.pointer_size(),
+        )? as usize;
+
+        // FIXME: This should actually panic in the interpreted program
+        if !req_align.is_power_of_two() {
+            throw_unsup_format!("Required alignment should always be a power of two")
+        }
+
+        let ptr_scalar = this.read_scalar(ptr_op)?.not_undef()?;
+
+        if let Ok(ptr) = this.force_ptr(ptr_scalar) {
+            let cur_align = this.memory().get(ptr.alloc_id)?.align.bytes() as usize;
+            if cur_align >= req_align {
+                // if the allocation alignment is at least the required alignment we use the
+                // libcore implementation
+                return Ok(Some(
+                    (this.force_bits(ptr_scalar, this.pointer_size())? as *const i8)
+                        .align_offset(req_align) as u128,
+                ));
+            }
+        }
+        // If the allocation alignment is smaller than then required alignment or the pointer was
+        // actually an integer, we return `None`
+        Ok(None)
+    }
 }

src/stacked_borrows.rs

@@ -435,7 +435,7 @@ impl<'tcx> Stacks {
 
         Stacks {
             stacks: RefCell::new(RangeMap::new(size, stack)),
-            global: extra, 
+            global: extra,
         }
     }
 
@@ -460,7 +460,7 @@ impl Stacks {
     pub fn new_allocation(
         id: AllocId,
         size: Size,
-        extra: MemoryExtra, 
+        extra: MemoryExtra,
         kind: MemoryKind<MiriMemoryKind>,
     ) -> (Self, Tag) {
         let (tag, perm) = match kind {
@@ -616,7 +616,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         // Cannot use `builtin_deref` because that reports *immutable* for `Box`,
         // making it useless.
         fn qualify(ty: ty::Ty<'_>, kind: RetagKind) -> Option<(RefKind, bool)> {
-            match ty.sty {
+            match ty.kind {
                 // References are simple.
                 ty::Ref(_, _, MutMutable) =>
                     Some((RefKind::Unique { two_phase: kind == RetagKind::TwoPhase}, kind == RetagKind::FnEntry)),