Move the memory_accessed hook onto the Extra value

Author: oli-obk

src/librustc/mir/interpret/allocation.rs

@@ -27,6 +27,13 @@ use std::ptr;
 use ty::layout::{self, Size, Align};
 use syntax::ast::Mutability;
 
+/// Classifying memory accesses
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum MemoryAccess {
+    Read,
+    Write,
+}
+
 #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 pub struct Allocation<Tag=(),Extra=()> {
     /// The actual bytes of the allocation.
@@ -49,6 +56,22 @@ pub struct Allocation<Tag=(),Extra=()> {
     pub extra: Extra,
 }
 
+trait AllocationExtra<Tag> {
+    /// Hook for performing extra checks on a memory access.
+    ///
+    /// Takes read-only access to the allocation so we can keep all the memory read
+    /// operations take `&self`.  Use a `RefCell` in `AllocExtra` if you
+    /// need to mutate.
+    fn memory_accessed(
+        &self,
+        ptr: Pointer<Tag>,
+        size: Size,
+        access: MemoryAccess,
+    ) -> EvalResult<'tcx> {
+        Ok(())
+    }
+}
+
 impl<Tag, Extra: Default> Allocation<Tag, Extra> {
     /// Creates a read-only allocation initialized by the given bytes
     pub fn from_bytes(slice: &[u8], align: Align) -> Self {
@@ -84,7 +107,7 @@ impl<Tag, Extra: Default> Allocation<Tag, Extra> {
 impl<'tcx> ::serialize::UseSpecializedDecodable for &'tcx Allocation {}
 
 /// Byte accessors
-impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {
+impl<'tcx, Tag, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
     /// The last argument controls whether we error out when there are undefined
     /// or pointer bytes.  You should never call this, call `get_bytes` or
     /// `get_bytes_with_undef_and_ptr` instead,
@@ -112,7 +135,7 @@ impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {
         }
 
         let alloc = self.get(ptr.alloc_id)?;
-        M::memory_accessed(alloc, ptr, size, MemoryAccess::Read)?;
+        Extra::memory_accessed(&self.extra, ptr, size, MemoryAccess::Read)?;
 
         assert_eq!(ptr.offset.bytes() as usize as u64, ptr.offset.bytes());
         assert_eq!(size.bytes() as usize as u64, size.bytes());
@@ -158,7 +181,7 @@ impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {
         self.clear_relocations(ptr, size)?;
 
         let alloc = self.get_mut(ptr.alloc_id)?;
-        M::memory_accessed(alloc, ptr, size, MemoryAccess::Write)?;
+        Extra::memory_accessed(alloc, ptr, size, MemoryAccess::Write)?;
 
         assert_eq!(ptr.offset.bytes() as usize as u64, ptr.offset.bytes());
         assert_eq!(size.bytes() as usize as u64, size.bytes());

src/librustc/mir/interpret/mod.rs

@@ -26,7 +26,7 @@ pub use self::error::{
 
 pub use self::value::{Scalar, ConstValue};
 
-pub use self::allocation::Allocation;
+pub use self::allocation::{Allocation, MemoryAccess};
 
 use std::fmt;
 use mir;

src/librustc_mir/interpret/machine.rs

@@ -24,13 +24,6 @@ use super::{
     EvalContext, PlaceTy, OpTy, Pointer, MemPlace, MemoryKind,
 };
 
-/// Classifying memory accesses
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum MemoryAccess {
-    Read,
-    Write,
-}
-
 /// Whether this kind of memory is allowed to leak
 pub trait MayLeak: Copy {
     fn may_leak(self) -> bool;
@@ -181,21 +174,6 @@ pub trait Machine<'a, 'mir, 'tcx>: Sized {
         dest: PlaceTy<'tcx, Self::PointerTag>,
     ) -> EvalResult<'tcx>;
 
-    /// Hook for performing extra checks on a memory access.
-    ///
-    /// Takes read-only access to the allocation so we can keep all the memory read
-    /// operations take `&self`.  Use a `RefCell` in `AllocExtra` if you
-    /// need to mutate.
-    #[inline]
-    fn memory_accessed(
-        _alloc: &Allocation<Self::PointerTag, Self::AllocExtra>,
-        _ptr: Pointer<Self::PointerTag>,
-        _size: Size,
-        _access: MemoryAccess,
-    ) -> EvalResult<'tcx> {
-        Ok(())
-    }
-
     /// Hook for performing extra checks when memory gets deallocated.
     #[inline]
     fn memory_deallocated(