rustup; test for return type mismatch

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 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
                     // 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 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
             (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 {
@@ -296,9 +296,9 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
         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 move around freely, as long as they do not overflow

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);
 }