hard-bounded range

Author: nia-e

src/shims/native_lib/mod.rs

@@ -42,23 +42,21 @@ pub struct MemEvents {
 #[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug)]
 pub enum AccessEvent {
-    /// A read may have occurred on no more than the specified address range.
+    /// A read occurred on this memory range.
     Read(AccessRange),
-    /// A write may have occurred on no more than the specified address range.
+/// A read occurred on this memory range.
     Write(AccessRange),
 }
 
-/// The actual size of a performed access, bounded by size.
+/// The memory touched by a given access.
 #[allow(dead_code)]
 #[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, Debug)]
 pub struct AccessRange {
     /// The base address in memory where an access occurred.
     pub addr: usize,
-    /// The smallest size this access could have been.
-    pub min_size: usize,
-    /// The largest size this access could have been.
-    pub max_size: usize,
+    /// The number of bytes affected from the base.
+    pub size: usize,
 }
 
 impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}

src/shims/native_lib/trace/parent.rs

@@ -410,8 +410,7 @@ fn handle_segfault(
                         arch::x86::X86OperandType::Mem(_) => {
                             let push = AccessRange {
                                 addr,
-                                min_size: x86_operand.size.into(),
-                                max_size: x86_operand.size.into(),
+                                size: x86_operand.size.into(),
                             };
                             // It's called a "RegAccessType" but it also applies to memory
                             let acc_ty = x86_operand.access.unwrap();