Merge branch 'master' into ptr-offset

Cargo.toml

@@ -32,7 +32,7 @@ env_logger = "0.5"
 log = "0.4"
 
 [build-dependencies]
-vergen = "2"
+vergen = "3"
 
 [features]
 cargo_miri = ["cargo_metadata"]

build.rs

@@ -8,17 +8,6 @@ fn main() {
     // Don't rebuild miri even if nothing changed
     println!("cargo:rerun-if-changed=build.rs");
     // vergen
-    vergen().expect("Unable to generate vergen constants!");
-}
-
-fn vergen() -> vergen::Result<()> {
-    use vergen::{ConstantsFlags, Vergen};
-
-    let vergen = Vergen::new(ConstantsFlags::all())?;
-
-    for (k, v) in vergen.build_info() {
-        println!("cargo:rustc-env={}={}", k.name(), v);
-    }
-
-    Ok(())
+    vergen::generate_cargo_keys(vergen::ConstantsFlags::all())
+        .expect("Unable to generate vergen keys!");
 }

rust-toolchain

@@ -1 +1 @@
-nightly-2018-10-01
+nightly-2018-10-10

src/lib.rs

@@ -233,6 +233,7 @@ impl<'a, 'mir, 'tcx> Machine<'a, 'mir, 'tcx> for Evaluator<'tcx> {
     type MemoryKinds = MiriMemoryKind;
 
     const MUT_STATIC_KIND: Option<MiriMemoryKind> = Some(MiriMemoryKind::MutStatic);
+    const ENFORCE_VALIDITY: bool = false; // this is still WIP
 
     /// Returns Ok() when the function was handled, fail otherwise
     fn find_fn(

src/operator.rs

@@ -142,8 +142,8 @@ fn ptr_eq(
                     // allocations sit right next to each other.  The C/C++ standards are
                     // somewhat fuzzy about this case, so I think for now this check is
                     // "good enough".
-                    self.memory.check_bounds(left, false)?;
-                    self.memory.check_bounds(right, false)?;
+                    self.memory.check_bounds_ptr(left, false)?;
+                    self.memory.check_bounds_ptr(right, false)?;
                     // Two live in-bounds pointers, we can compare across allocations
                     left == right
                 }
@@ -153,7 +153,7 @@ fn ptr_eq(
             (Scalar::Bits { bits, size }, Scalar::Ptr(ptr)) => {
                 assert_eq!(size as u64, self.pointer_size().bytes());
                 let bits = bits as u64;
-                let (alloc_size, alloc_align) = self.memory.get_size_and_align(ptr.alloc_id)?;
+                let (alloc_size, alloc_align) = self.memory.get_size_and_align(ptr.alloc_id);
 
                 // Case I: Comparing with NULL
                 if bits == 0 {
@@ -288,9 +288,9 @@ fn pointer_offset_inbounds(
         if let Scalar::Ptr(ptr) = ptr {
             // Both old and new pointer must be in-bounds.
             // (Of the same allocation, but that part is trivial with our representation.)
-            self.memory.check_bounds(ptr, false)?;
+            self.memory.check_bounds_ptr(ptr, false)?;
             let ptr = ptr.signed_offset(offset, self)?;
-            self.memory.check_bounds(ptr, false)?;
+            self.memory.check_bounds_ptr(ptr, false)?;
             Ok(Scalar::Ptr(ptr))
         } else {
             // An integer pointer. They can only be offset by 0, and we pretend there

tests/compile-fail/cast_fn_ptr5.rs

@@ -0,0 +1,9 @@
+fn main() {
+    fn f() -> u32 { 42 }
+
+    let g = unsafe {
+        std::mem::transmute::<fn() -> u32, fn()>(f)
+    };
+
+    g() //~ ERROR tried to call a function with return type u32 passing return place of type ()
+}

tests/compile-fail/deref_fn_ptr.rs

@@ -1,8 +1,8 @@
 fn f() {}
 
 fn main() {
-    let x: i32 = unsafe {
-        *std::mem::transmute::<fn(), *const i32>(f) //~ ERROR constant evaluation error: tried to dereference a function pointer
+    let x: u8 = unsafe {
+        *std::mem::transmute::<fn(), *const u8>(f) //~ ERROR constant evaluation error: tried to dereference a function pointer
     };
     panic!("this should never print: {}", x);
 }