Steal another bit in PackedItem to indicate if it is protected

Author: saethlin

src/stacked_borrows.rs

@@ -99,6 +99,8 @@ pub struct Item {
     perm: Permission,
     /// The pointers the permission is granted to.
     tag: SbTag,
+    /// Whether or not there is a protector for this tag
+    protected: bool,
 }
 
 impl fmt::Debug for Item {
@@ -325,7 +327,7 @@ impl<'tcx> Stack {
             ));
         }
 
-        if global.protected_tags.contains(&item.tag) {
+        if item.protected && global.protected_tags.contains(&item.tag) {
             if let Some((tag, _alloc_range, _offset, _access)) = provoking_access {
                 Err(err_sb_ub(
                     format!(
@@ -568,7 +570,7 @@ impl<'tcx> Stack {
 impl<'tcx> Stacks {
     /// Creates new stack with initial tag.
     fn new(size: Size, perm: Permission, tag: SbTag) -> Self {
-        let item = Item { perm, tag };
+        let item = Item { perm, tag, protected: false };
         let stack = Stack::new(item);
 
         Stacks {
@@ -853,7 +855,14 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     } else {
                         Permission::SharedReadWrite
                     };
-                    let item = Item { perm, tag: new_tag };
+                    let protected = if frozen {
+                        protect
+                    } else {
+                        // We do not protect inside UnsafeCell.
+                        // This fixes https://github.com/rust-lang/rust/issues/55005.
+                        false
+                    };
+                    let item = Item { perm, tag: new_tag, protected };
                     let mut global = this.machine.stacked_borrows.as_ref().unwrap().borrow_mut();
                     stacked_borrows.for_each(range, |offset, stack, history, exposed_tags| {
                         stack.grant(
@@ -879,7 +888,7 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             .as_mut()
             .expect("we should have Stacked Borrows data")
             .borrow_mut();
-        let item = Item { perm, tag: new_tag };
+        let item = Item { perm, tag: new_tag, protected: protect };
         let range = alloc_range(base_offset, size);
         let mut global = machine.stacked_borrows.as_ref().unwrap().borrow_mut();
         let current_span = &mut machine.current_span(); // `get_alloc_extra_mut` invalidated our old `current_span`

src/stacked_borrows/stack.rs

@@ -17,35 +17,16 @@ const CACHE_LEN: usize = 32;
 struct PackedItem(u64);
 
 impl PackedItem {
-    const TAG_MASK: u64 = u64::MAX << 2;
-    const PERM_MASK: u64 = !Self::TAG_MASK;
-
-    fn new(tag: SbTag, perm: Permission) -> Self {
-        let packed_perm = match perm {
-            Permission::Unique => 0,
-            Permission::SharedReadWrite => 1,
-            Permission::SharedReadOnly => 2,
-            Permission::Disabled => 3,
-        };
-        debug_assert!(packed_perm & Self::TAG_MASK == 0);
-
-        let packed_tag = tag.0.get() << 2;
-        debug_assert!(packed_tag & Self::PERM_MASK == 0);
-
-        let new = Self(packed_tag + packed_perm);
-
-        debug_assert!(new.tag() == tag);
-        debug_assert!(new.perm() == perm);
-
-        new
-    }
+    const TAG_MASK: u64 = u64::MAX >> 3;
+    const PERM_MASK: u64 = 0x3 << 61;
+    const PROTECTED_MASK: u64 = 0x1 << 63;
 
     fn tag(self) -> SbTag {
-        unsafe { SbTag(std::num::NonZeroU64::new_unchecked((self.0 & Self::TAG_MASK) >> 2)) }
+        unsafe { SbTag(std::num::NonZeroU64::new_unchecked(self.0 & Self::TAG_MASK)) }
     }
 
     fn perm(self) -> Permission {
-        match self.0 & Self::PERM_MASK {
+        match (self.0 & Self::PERM_MASK) >> 61 {
             0 => Permission::Unique,
             1 => Permission::SharedReadWrite,
             2 => Permission::SharedReadOnly,
@@ -54,20 +35,40 @@ impl PackedItem {
         }
     }
 
+    fn protected(self) -> bool {
+        self.0 & Self::PROTECTED_MASK > 0
+    }
+
     fn set_disabled(&mut self) {
-        self.0 |= 0x3;
+        self.0 |= Self::PERM_MASK;
     }
 }
 
 impl From<Item> for PackedItem {
     fn from(item: Item) -> Self {
-        Self::new(item.tag, item.perm)
+        assert!(item.tag.0.get() <= Self::TAG_MASK);
+        let perm = match item.perm {
+            Permission::Unique => 0,
+            Permission::SharedReadWrite => 1,
+            Permission::SharedReadOnly => 2,
+            Permission::Disabled => 3,
+        } << 61;
+        let tag = item.tag.0.get();
+        let protected = (item.protected as u64) << 63;
+
+        let new = Self(tag + perm + protected);
+
+        debug_assert!(new.tag() == item.tag);
+        debug_assert!(new.perm() == item.perm);
+        debug_assert!(new.protected() == item.protected);
+
+        new
     }
 }
 
 impl From<PackedItem> for Item {
     fn from(item: PackedItem) -> Item {
-        let new = Item { tag: item.tag(), perm: item.perm() };
+        let new = Item { tag: item.tag(), perm: item.perm(), protected: item.protected() };
 
         debug_assert!(new.tag == item.tag());
         debug_assert!(new.perm == item.perm());
@@ -310,7 +311,7 @@ impl<'tcx> Stack {
         }
 
         // This primes the cache for the next access, which is almost always the just-added tag.
-        self.cache.add(new_idx, PackedItem::new(new.tag, new.perm));
+        self.cache.add(new_idx, PackedItem::from(new));
 
         #[cfg(feature = "expensive-debug-assertions")]
         self.verify_cache_consistency();
@@ -322,10 +323,7 @@ impl<'tcx> Stack {
             borrows: vec![item.into()],
             unknown_bottom: None,
             #[cfg(feature = "stack-cache")]
-            cache: StackCache {
-                idx: [0; CACHE_LEN],
-                tags: [PackedItem::new(item.tag, item.perm); CACHE_LEN],
-            },
+            cache: StackCache { idx: [0; CACHE_LEN], tags: [PackedItem::from(item); CACHE_LEN] },
             #[cfg(feature = "stack-cache")]
             unique_range: if item.perm == Permission::Unique { 0..1 } else { 0..0 },
         }