Address some more review comments

Author: carbotaniuman

src/intptrcast.rs

@@ -57,7 +57,7 @@ impl<'mir, 'tcx> GlobalStateInner {
 
         let pos = global_state.int_to_ptr_map.binary_search_by_key(&addr, |(addr, _)| *addr);
 
-        match pos {
+        let alloc_id = match pos {
             Ok(pos) => Some(global_state.int_to_ptr_map[pos].1),
             Err(0) => None,
             Err(pos) => {
@@ -80,14 +80,13 @@ impl<'mir, 'tcx> GlobalStateInner {
                     None
                 }
             }
+        }?;
+        
+        if global_state.permissive_provenance && !global_state.exposed.contains(&alloc_id) {
+            None
+        } else {
+            Some(alloc_id)
         }
-        .and_then(|alloc_id| {
-            if global_state.permissive_provenance && !global_state.exposed.contains(&alloc_id) {
-                None
-            } else {
-                Some(alloc_id)
-            }
-        })
     }
 
     pub fn expose_addr(ecx: &MiriEvalContext<'mir, 'tcx>, alloc_id: AllocId) {
@@ -165,7 +164,7 @@ impl<'mir, 'tcx> GlobalStateInner {
 
     /// Convert a relative (tcx) pointer to an absolute address.
     pub fn rel_ptr_to_addr(ecx: &MiriEvalContext<'mir, 'tcx>, ptr: Pointer<AllocId>) -> u64 {
-        let (alloc_id, offset) = ptr.into_parts(); // offset is relative
+        let (alloc_id, offset) = ptr.into_parts(); // offset is relative (AllocId provenance)
         let base_addr = GlobalStateInner::alloc_base_addr(ecx, alloc_id);
 
         // Add offset with the right kind of pointer-overflowing arithmetic.
@@ -182,10 +181,7 @@ impl<'mir, 'tcx> GlobalStateInner {
         let alloc_id = if let Tag::Concrete(concrete) = tag {
             concrete.alloc_id
         } else {
-            match GlobalStateInner::alloc_id_from_addr(ecx, addr.bytes()) {
-                Some(alloc_id) => alloc_id,
-                None => return None,
-            }
+            GlobalStateInner::alloc_id_from_addr(ecx, addr.bytes())?
         };
 
         let base_addr = GlobalStateInner::alloc_base_addr(ecx, alloc_id);

tests/run-pass/ptr_int_roundtrip.rs

@@ -1,32 +1,48 @@
 // compile-flags: -Zmiri-permissive-provenance -Zmiri-disable-stacked-borrows
 #![feature(strict_provenance)]
 
+use std::ptr;
+
+/// Ensure we can expose the address of a pointer that is out-of-bounds
 fn ptr_roundtrip_out_of_bounds() {
     let x: i32 = 3;
     let x_ptr = &x as *const i32;
 
-    let x_usize = x_ptr.wrapping_offset(128) as usize;
+    let x_usize = x_ptr.wrapping_offset(128).expose_addr();
 
-    let ptr = (x_usize as *const i32).wrapping_offset(-128);
+    let ptr = ptr::from_exposed_addr::<i32>(x_usize).wrapping_offset(-128);
     assert_eq!(unsafe { *ptr }, 3);
 }
 
-fn ptr_roundtrip_out_of_bounds_with_addr() {
+/// Ensure that we can move between allocations using when casting 
+fn ptr_roundtrip_confusion() {
     let x: i32 = 0;
     let y: i32 = 1;
 
-    let x_ptr = &x as *const _;
-    let y_ptr = &y as *const _;
+    let x_ptr = &x as *const i32;
+    let y_ptr = &y as *const i32;
 
-    let x_usize = x_ptr as usize;
-    let y_usize = y_ptr as usize;
+    let x_usize = x_ptr.expose_addr();
+    let y_usize = y_ptr.expose_addr();
 
-    let ptr = y_usize as *const i32;
+    let ptr = ptr::from_exposed_addr::<i32>(y_usize);
     let ptr = ptr.with_addr(x_usize);
     assert_eq!(unsafe { *ptr }, 0);
 }
 
+/// Ensure we can cast back a different integer than the one we got when exposing.
+fn ptr_roundtrip_imperfect() {
+    let x: u8 = 3;
+    let x_ptr = &x as *const u8;
+
+    let x_usize = x_ptr.expose_addr() + 128;
+
+    let ptr = ptr::from_exposed_addr::<u8>(x_usize).wrapping_offset(-128);
+    assert_eq!(unsafe { *ptr }, 3);
+}
+
 fn main() {
     ptr_roundtrip_out_of_bounds();
-    ptr_roundtrip_out_of_bounds_with_addr();
+    ptr_roundtrip_confusion();
+    ptr_roundtrip_imperfect();
 }