implement 'delimited' expose tracking so we still detect some UB

Author: RalfJung

src/diagnostics.rs

@@ -8,7 +8,7 @@ use rustc_middle::ty;
 use rustc_span::{source_map::DUMMY_SP, Span, SpanData, Symbol};
 
 use crate::helpers::HexRange;
-use crate::stacked_borrows::{diagnostics::TagHistory, AccessKind, SbTag};
+use crate::stacked_borrows::{diagnostics::TagHistory, AccessKind};
 use crate::*;
 
 /// Details of premature program termination.
@@ -61,9 +61,9 @@ impl MachineStopType for TerminationInfo {}
 /// Miri specific diagnostics
 pub enum NonHaltingDiagnostic {
     CreatedPointerTag(NonZeroU64),
-    /// This `Item` was popped from the borrow stack, either due to a grant of
-    /// `AccessKind` to `SbTag` or a deallocation when the second argument is `None`.
-    PoppedPointerTag(Item, Option<(SbTag, AccessKind)>),
+    /// This `Item` was popped from the borrow stack, either due to an access with the given tag or
+    /// a deallocation when the second argument is `None`.
+    PoppedPointerTag(Item, Option<(SbTagExtra, AccessKind)>),
     CreatedCallId(CallId),
     CreatedAlloc(AllocId),
     FreedAlloc(AllocId),

src/intptrcast.rs

@@ -142,9 +142,7 @@ impl<'mir, 'tcx> GlobalStateInner {
                 // Determine the allocation this points to at cast time.
                 let alloc_id = Self::alloc_id_from_addr(ecx, addr);
                 Pointer::new(
-                    alloc_id.map(|alloc_id| {
-                        Tag::Concrete(ConcreteTag { alloc_id, sb: SbTag::Untagged })
-                    }),
+                    alloc_id.map(|alloc_id| Tag::Concrete { alloc_id, sb: SbTag::Untagged }),
                     Size::from_bytes(addr),
                 )
             }
@@ -222,8 +220,8 @@ impl<'mir, 'tcx> GlobalStateInner {
     ) -> Option<(AllocId, Size)> {
         let (tag, addr) = ptr.into_parts(); // addr is absolute (Tag provenance)
 
-        let alloc_id = if let Tag::Concrete(concrete) = tag {
-            concrete.alloc_id
+        let alloc_id = if let Tag::Concrete { alloc_id, .. } = tag {
+            alloc_id
         } else {
             // A wildcard pointer.
             assert_eq!(ecx.machine.intptrcast.borrow().provenance_mode, ProvenanceMode::Permissive);

src/lib.rs

@@ -7,6 +7,7 @@
 #![feature(io_error_more)]
 #![feature(yeet_expr)]
 #![feature(is_some_with)]
+#![feature(nonzero_ops)]
 #![warn(rust_2018_idioms)]
 #![allow(
     clippy::collapsible_else_if,
@@ -81,15 +82,15 @@ pub use crate::eval::{
 pub use crate::helpers::{CurrentSpan, EvalContextExt as HelpersEvalContextExt};
 pub use crate::intptrcast::ProvenanceMode;
 pub use crate::machine::{
-    AllocExtra, ConcreteTag, Evaluator, FrameData, MiriEvalContext, MiriEvalContextExt,
-    MiriMemoryKind, Tag, NUM_CPUS, PAGE_SIZE, STACK_ADDR, STACK_SIZE,
+    AllocExtra, Evaluator, FrameData, MiriEvalContext, MiriEvalContextExt, MiriMemoryKind, Tag,
+    NUM_CPUS, PAGE_SIZE, STACK_ADDR, STACK_SIZE,
 };
 pub use crate::mono_hash_map::MonoHashMap;
 pub use crate::operator::EvalContextExt as OperatorEvalContextExt;
 pub use crate::range_map::RangeMap;
 pub use crate::stacked_borrows::{
-    CallId, EvalContextExt as StackedBorEvalContextExt, Item, Permission, PtrId, SbTag, Stack,
-    Stacks,
+    CallId, EvalContextExt as StackedBorEvalContextExt, Item, Permission, PtrId, SbTag, SbTagExtra,
+    Stack, Stacks,
 };
 pub use crate::sync::{CondvarId, EvalContextExt as SyncEvalContextExt, MutexId, RwLockId};
 pub use crate::thread::{

src/machine.rs

@@ -130,17 +130,14 @@ impl fmt::Display for MiriMemoryKind {
 /// Pointer provenance (tag).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Tag {
-    Concrete(ConcreteTag),
+    Concrete {
+        alloc_id: AllocId,
+        /// Stacked Borrows tag.
+        sb: SbTag,
+    },
     Wildcard,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ConcreteTag {
-    pub alloc_id: AllocId,
-    /// Stacked Borrows tag.
-    pub sb: SbTag,
-}
-
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 static_assert_size!(Pointer<Tag>, 24);
 // #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
@@ -160,15 +157,15 @@ impl Provenance for Tag {
         write!(f, "0x{:x}", addr.bytes())?;
 
         match tag {
-            Tag::Concrete(tag) => {
+            Tag::Concrete { alloc_id, sb } => {
                 // Forward `alternate` flag to `alloc_id` printing.
                 if f.alternate() {
-                    write!(f, "[{:#?}]", tag.alloc_id)?;
+                    write!(f, "[{:#?}]", alloc_id)?;
                 } else {
-                    write!(f, "[{:?}]", tag.alloc_id)?;
+                    write!(f, "[{:?}]", alloc_id)?;
                 }
                 // Print Stacked Borrows tag.
-                write!(f, "{:?}", tag.sb)?;
+                write!(f, "{:?}", sb)?;
             }
             Tag::Wildcard => {
                 write!(f, "[Wildcard]")?;
@@ -180,7 +177,7 @@ impl Provenance for Tag {
 
     fn get_alloc_id(self) -> Option<AllocId> {
         match self {
-            Tag::Concrete(concrete) => Some(concrete.alloc_id),
+            Tag::Concrete { alloc_id, .. } => Some(alloc_id),
             Tag::Wildcard => None,
         }
     }
@@ -489,8 +486,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
     type AllocExtra = AllocExtra;
 
     type PointerTag = Tag;
-    // `None` represents a wildcard pointer.
-    type TagExtra = Option<SbTag>;
+    type TagExtra = SbTagExtra;
 
     type MemoryMap =
         MonoHashMap<AllocId, (MemoryKind<MiriMemoryKind>, Allocation<Tag, Self::AllocExtra>)>;
@@ -683,7 +679,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
             SbTag::Untagged
         };
         Pointer::new(
-            Tag::Concrete(ConcreteTag { alloc_id: ptr.provenance, sb: sb_tag }),
+            Tag::Concrete { alloc_id: ptr.provenance, sb: sb_tag },
             Size::from_bytes(absolute_addr),
         )
     }
@@ -709,7 +705,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         ptr: Pointer<Self::PointerTag>,
     ) -> InterpResult<'tcx> {
         match ptr.provenance {
-            Tag::Concrete(ConcreteTag { alloc_id, sb }) => {
+            Tag::Concrete { alloc_id, sb } => {
                 intptrcast::GlobalStateInner::expose_ptr(ecx, alloc_id, sb);
             }
             Tag::Wildcard => {
@@ -730,8 +726,8 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
 
         rel.map(|(alloc_id, size)| {
             let sb = match ptr.provenance {
-                Tag::Concrete(ConcreteTag { sb, .. }) => Some(sb),
-                Tag::Wildcard => None,
+                Tag::Concrete { sb, .. } => SbTagExtra::Concrete(sb),
+                Tag::Wildcard => SbTagExtra::Wildcard,
             };
             (alloc_id, size, sb)
         })