Reorganize MemoryExtra and AllocExtra structures

pvdrz · pvdrz · commit 84cfbb01b7ad · 2019-06-24T17:18:25.000-05:00
diff --git a/src/intptrcast.rs b/src/intptrcast.rs
@@ -1,13 +1,26 @@
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 
-use rustc::mir::interpret::AllocId;
+use rustc::mir::interpret::{AllocId, Pointer, InterpResult};
+use rustc_mir::interpret::Memory;
+use rustc_target::abi::Size;
 
-pub type MemoryState = RefCell<GlobalState>;
+use crate::stacked_borrows::Tag;
+use crate::Evaluator;
+
+pub type MemoryExtra = RefCell<GlobalState>;
+
+#[derive(Clone, Debug, Default)]
+pub struct AllocExtra {
+    base_addr: Cell<Option<u64>>
+}
 
 #[derive(Clone, Debug)]
 pub struct GlobalState {
-    /// This field is used as a map between the address of each allocation and its `AllocId`
+    /// This is used as a map between the address of each allocation and its `AllocId`.
+    /// It is always sorted
     pub int_to_ptr_map: Vec<(u64, AllocId)>,
+    /// This is used as a memory address when a new pointer is casted to an integer. It
+    /// is always larger than any address that was previously made part of a block.
     pub next_base_addr: u64,
 }
 
@@ -20,3 +33,65 @@ impl Default for GlobalState {
         }
     }
 }
+
+impl<'mir, 'tcx> GlobalState {
+    pub fn int_to_ptr(
+        base_addr: u64,
+        memory: &Memory<'mir, 'tcx, Evaluator<'tcx>>,
+    ) -> InterpResult<'tcx, Pointer<Tag>> {
+        let global_state = memory.extra.intptrcast.borrow();
+        
+        match global_state.int_to_ptr_map.binary_search_by_key(&base_addr, |(addr, _)| *addr) {
+            Ok(pos) => {
+                let (_, alloc_id) = global_state.int_to_ptr_map[pos];
+                // `base_addr` is the starting address for an allocation, the offset should be
+                // zero. The pointer is untagged because it was created from a cast
+                Ok(Pointer::new_with_tag(alloc_id, Size::from_bytes(0), Tag::Untagged))
+            },
+            Err(0) => err!(DanglingPointerDeref), 
+            Err(pos) => {
+                // This is the gargest of the adresses smaller than `base_addr`,
+                // i.e. the greatest lower bound (glb)
+                let (glb, alloc_id) = global_state.int_to_ptr_map[pos - 1];
+                // This never overflows because `base_addr >= glb`
+                let offset = base_addr - glb;
+                // If the offset exceeds the size of the allocation, this access is illegal
+                if offset <= memory.get(alloc_id)?.bytes.len() as u64 {
+                    // This pointer is untagged because it was created from a cast
+                    Ok(Pointer::new_with_tag(alloc_id, Size::from_bytes(offset), Tag::Untagged))
+                } else {
+                    err!(DanglingPointerDeref)
+                } 
+            }
+        }
+    }
+
+    pub fn ptr_to_int(
+        ptr: Pointer<Tag>,
+        memory: &Memory<'mir, 'tcx, Evaluator<'tcx>>,
+    ) -> InterpResult<'tcx, u64> {
+        let mut global_state = memory.extra.intptrcast.borrow_mut();
+
+        let alloc = memory.get(ptr.alloc_id)?;
+
+        let base_addr = match alloc.extra.intptrcast.base_addr.get() { 
+            Some(base_addr) => base_addr,
+            None => {
+                let base_addr = global_state.next_base_addr;
+                global_state.next_base_addr += alloc.bytes.len() as u64;
+
+                alloc.extra.intptrcast.base_addr.set(Some(base_addr));
+
+                let elem = (base_addr, ptr.alloc_id);
+
+                // Given that `next_base_addr` increases in each allocation, pushing the
+                // corresponding tuple keeps `int_to_ptr_map` sorted
+                global_state.int_to_ptr_map.push(elem); 
+
+                base_addr
+            }
+        };
+
+        Ok(base_addr + ptr.offset.bytes())
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -25,7 +25,6 @@ mod memory;
 
 use std::collections::HashMap;
 use std::borrow::Cow;
-use std::cell::Cell;
 use std::rc::Rc;
 
 use rand::rngs::StdRng;
@@ -387,7 +386,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
     type MemoryKinds = MiriMemoryKind;
 
     type FrameExtra = stacked_borrows::CallId;
-    type MemoryExtra = memory::MemoryState;
+    type MemoryExtra = memory::MemoryExtra;
     type AllocExtra = memory::AllocExtra;
     type PointerTag = Tag;
 
@@ -513,17 +512,17 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
     ) -> (Cow<'b, Allocation<Self::PointerTag, Self::AllocExtra>>, Self::PointerTag) {
         let kind = kind.expect("we set our STATIC_KIND so this cannot be None");
         let alloc = alloc.into_owned();
-        let (extra, base_tag) = Stacks::new_allocation(
+        let (stacks, base_tag) = Stacks::new_allocation(
             id,
             Size::from_bytes(alloc.bytes.len() as u64),
-            Rc::clone(&memory.extra.stacked),
+            Rc::clone(&memory.extra.stacked_borrows),
             kind,
         );
         if kind != MiriMemoryKind::Static.into() {
             assert!(alloc.relocations.is_empty(), "Only statics can come initialized with inner pointers");
             // Now we can rely on the inner pointers being static, too.
         }
-        let mut memory_extra = memory.extra.stacked.borrow_mut();
+        let mut memory_extra = memory.extra.stacked_borrows.borrow_mut();
         let alloc: Allocation<Tag, Self::AllocExtra> = Allocation {
             bytes: alloc.bytes,
             relocations: Relocations::from_presorted(
@@ -537,8 +536,8 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
             align: alloc.align,
             mutability: alloc.mutability,
             extra: AllocExtra {
-                stacks: extra,
-                base_addr: Cell::new(None),
+                stacked_borrows: stacks,
+                intptrcast: Default::default(),
             },
         };
         (Cow::Owned(alloc), base_tag)
@@ -549,7 +548,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
         id: AllocId,
         memory: &Memory<'mir, 'tcx, Self>,
     ) -> Self::PointerTag {
-        memory.extra.stacked.borrow_mut().static_base_ptr(id)
+        memory.extra.stacked_borrows.borrow_mut().static_base_ptr(id)
     }
 
     #[inline(always)]
@@ -574,49 +573,27 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
     fn stack_push(
         ecx: &mut InterpretCx<'mir, 'tcx, Self>,
     ) -> InterpResult<'tcx, stacked_borrows::CallId> {
-        Ok(ecx.memory().extra.stacked.borrow_mut().new_call())
+        Ok(ecx.memory().extra.stacked_borrows.borrow_mut().new_call())
     }
 
     #[inline(always)]
     fn stack_pop(
         ecx: &mut InterpretCx<'mir, 'tcx, Self>,
         extra: stacked_borrows::CallId,
     ) -> InterpResult<'tcx> {
-        Ok(ecx.memory().extra.stacked.borrow_mut().end_call(extra))
+        Ok(ecx.memory().extra.stacked_borrows.borrow_mut().end_call(extra))
     }
 
     fn int_to_ptr(
         int: u64,
         memory: &Memory<'mir, 'tcx, Self>,
     ) -> InterpResult<'tcx, Pointer<Self::PointerTag>> {
         if int == 0 {
-            return err!(InvalidNullPointerUsage);
-        }
-        
-        if memory.extra.rng.is_none() {
-            return err!(ReadBytesAsPointer);
-        }
-
-        let extra = memory.extra.intptrcast.borrow();
-        
-        match extra.int_to_ptr_map.binary_search_by_key(&int, |(int, _)| *int) {
-            Ok(pos) => {
-                let (_, alloc_id) = extra.int_to_ptr_map[pos];
-                Ok(Pointer::new_with_tag(alloc_id, Size::from_bytes(0), Tag::Untagged))
-            }
-            Err(pos) => {
-                if pos > 0 {
-                    let (glb, alloc_id) = extra.int_to_ptr_map[pos - 1];
-                    let offset = int - glb;
-                    if offset <= memory.get(alloc_id)?.bytes.len() as u64 {
-                        Ok(Pointer::new_with_tag(alloc_id, Size::from_bytes(offset), Tag::Untagged))
-                    } else {
-                        return err!(DanglingPointerDeref);
-                    }
-                } else {
-                    return err!(DanglingPointerDeref);
-                }
-            }
+            err!(InvalidNullPointerUsage)
+        } else if memory.extra.rng.is_none() {
+            err!(ReadBytesAsPointer)
+        } else {
+           intptrcast::GlobalState::int_to_ptr(int, memory)
         }
     }
  
@@ -625,31 +602,9 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
         memory: &Memory<'mir, 'tcx, Self>,
     ) -> InterpResult<'tcx, u64> {
         if memory.extra.rng.is_none() {
-            return err!(ReadPointerAsBytes);
+            err!(ReadPointerAsBytes)
+        } else {
+            intptrcast::GlobalState::ptr_to_int(ptr, memory)
         }
-
-        let mut extra = memory.extra.intptrcast.borrow_mut();
-
-        let alloc = memory.get(ptr.alloc_id)?;
-
-        let base_addr = match alloc.extra.base_addr.get() { 
-            Some(base_addr) => base_addr,
-            None => {
-                let base_addr = extra.next_base_addr;
-                extra.next_base_addr += alloc.bytes.len() as u64;
-
-                alloc.extra.base_addr.set(Some(base_addr));
-
-                let elem = (base_addr, ptr.alloc_id);
-
-                // Given that `next_base_addr` increases in each allocation, pushing the
-                // corresponding tuple keeps `int_to_ptr_map` sorted
-                extra.int_to_ptr_map.push(elem); 
-
-                base_addr
-            }
-        };
-
-        Ok(base_addr + ptr.offset.bytes())
     }
 }
diff --git a/src/memory.rs b/src/memory.rs
@@ -1,25 +1,24 @@
-use std::cell::Cell;
 use rand::rngs::StdRng;
 
 use rustc_mir::interpret::{Pointer, Allocation, AllocationExtra, InterpResult};
 use rustc_target::abi::Size;
 
 use crate::{stacked_borrows, intptrcast};
-use crate::stacked_borrows::{Tag, AccessKind};
+use crate::stacked_borrows::Tag;
 
 #[derive(Default, Clone, Debug)]
-pub struct MemoryState {
-    pub stacked: stacked_borrows::MemoryState,
-    pub intptrcast: intptrcast::MemoryState,
-    /// The random number generator to use if Miri
-    /// is running in non-deterministic mode
+pub struct MemoryExtra {
+    pub stacked_borrows: stacked_borrows::MemoryExtra,
+    pub intptrcast: intptrcast::MemoryExtra,
+    /// The random number generator to use if Miri is running in non-deterministic mode and to
+    /// enable intptrcast
     pub(crate) rng: Option<StdRng>
 }
 
-#[derive(Debug, Clone,)]
+#[derive(Debug, Clone)]
 pub struct AllocExtra {
-    pub stacks: stacked_borrows::Stacks,
-    pub base_addr: Cell<Option<u64>>,
+    pub stacked_borrows: stacked_borrows::AllocExtra,
+    pub intptrcast: intptrcast::AllocExtra,
 }
 
 impl AllocationExtra<Tag> for AllocExtra {
@@ -29,11 +28,7 @@ impl AllocationExtra<Tag> for AllocExtra {
         ptr: Pointer<Tag>,
         size: Size,
     ) -> InterpResult<'tcx> {
-        trace!("read access with tag {:?}: {:?}, size {}", ptr.tag, ptr.erase_tag(), size.bytes());
-        alloc.extra.stacks.for_each(ptr, size, |stack, global| {
-            stack.access(AccessKind::Read, ptr.tag, global)?;
-            Ok(())
-        })
+        alloc.extra.stacked_borrows.memory_read(ptr, size)
     }
 
     #[inline(always)]
@@ -42,11 +37,7 @@ impl AllocationExtra<Tag> for AllocExtra {
         ptr: Pointer<Tag>,
         size: Size,
     ) -> InterpResult<'tcx> {
-        trace!("write access with tag {:?}: {:?}, size {}", ptr.tag, ptr.erase_tag(), size.bytes());
-        alloc.extra.stacks.for_each(ptr, size, |stack, global| {
-            stack.access(AccessKind::Write, ptr.tag, global)?;
-            Ok(())
-        })
+        alloc.extra.stacked_borrows.memory_written(ptr, size)
     }
 
     #[inline(always)]
@@ -55,9 +46,6 @@ impl AllocationExtra<Tag> for AllocExtra {
         ptr: Pointer<Tag>,
         size: Size,
     ) -> InterpResult<'tcx> {
-        trace!("deallocation with tag {:?}: {:?}, size {}", ptr.tag, ptr.erase_tag(), size.bytes());
-        alloc.extra.stacks.for_each(ptr, size, |stack, global| {
-            stack.dealloc(ptr.tag, global)
-        })
+        alloc.extra.stacked_borrows.memory_deallocated(ptr, size)
     }
 }
diff --git a/src/operator.rs b/src/operator.rs
@@ -44,6 +44,9 @@ impl<'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'mir, 'tcx> {
 
         trace!("ptr_op: {:?} {:?} {:?}", *left, bin_op, *right);
 
+        // If intptrcast is enabled and the operation is not an offset
+        // we can force the cast from pointers to integer addresses and
+        // then dispatch to rustc binary operation method
         if self.memory().extra.rng.is_some() && bin_op != Offset {
             let l_bits = self.force_bits(left.imm.to_scalar()?, left.layout.size)?;
             let r_bits = self.force_bits(right.imm.to_scalar()?, right.layout.size)?;
diff --git a/src/stacked_borrows.rs b/src/stacked_borrows.rs
