Factor the Stacked Borrows FrameExtra fields

Author: saethlin

src/machine.rs

@@ -44,7 +44,7 @@ pub const NUM_CPUS: u64 = 1;
 /// Extra data stored with each stack frame
 pub struct FrameData<'tcx> {
     /// Extra data for Stacked Borrows.
-    pub call_id: stacked_borrows::CallId,
+    pub stacked_borrows: stacked_borrows::FrameExtra,
 
     /// If this is Some(), then this is a special "catch unwind" frame (the frame of `try_fn`
     /// called by `try`). When this frame is popped during unwinding a panic,
@@ -55,26 +55,15 @@ pub struct FrameData<'tcx> {
     /// for the start of this frame. When we finish executing this frame,
     /// we use this to register a completed event with `measureme`.
     pub timing: Option<measureme::DetachedTiming>,
-
-    /// If this frame is protecting any tags, they are listed here. We use this list to do
-    /// incremental updates of the global list of protected tags stored in the
-    /// `stacked_borrows::GlobalState` upon function return, and if we attempt to pop a protected
-    /// tag, to identify which call is responsible for protecting the tag.
-    /// See `Stack::item_popped` for more explanation.
-    ///
-    /// This will contain one tag per reference passed to the function, so
-    /// a size of 2 is enough for the vast majority of functions.
-    pub protected_tags: SmallVec<[SbTag; 2]>,
 }
 
 impl<'tcx> std::fmt::Debug for FrameData<'tcx> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // Omitting `timing`, it does not support `Debug`.
-        let FrameData { call_id, catch_unwind, timing: _, protected_tags } = self;
+        let FrameData { stacked_borrows, catch_unwind, timing: _ } = self;
         f.debug_struct("FrameData")
-            .field("call_id", call_id)
+            .field("stacked_borrows", stacked_borrows)
             .field("catch_unwind", catch_unwind)
-            .field("protected_tags", protected_tags)
             .finish()
     }
 }
@@ -907,8 +896,14 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
             stacked_borrows.borrow_mut().new_call()
         });
 
-        let extra =
-            FrameData { call_id, catch_unwind: None, timing, protected_tags: SmallVec::new() };
+        let extra = FrameData {
+            stacked_borrows: stacked_borrows::FrameExtra {
+                call_id,
+                protected_tags: SmallVec::new(),
+            },
+            catch_unwind: None,
+            timing,
+        };
         Ok(frame.with_extra(extra))
     }
 

src/stacked_borrows.rs

@@ -16,6 +16,7 @@ use rustc_middle::ty::{
 };
 use rustc_span::DUMMY_SP;
 use rustc_target::abi::Size;
+use smallvec::SmallVec;
 use std::collections::HashSet;
 
 use crate::*;
@@ -80,6 +81,22 @@ impl SbTagExtra {
     }
 }
 
+#[derive(Debug)]
+pub struct FrameExtra {
+    /// The ID of the call this frame corresponds to.
+    pub call_id: CallId,
+
+    /// If this frame is protecting any tags, they are listed here. We use this list to do
+    /// incremental updates of the global list of protected tags stored in the
+    /// `stacked_borrows::GlobalState` upon function return, and if we attempt to pop a protected
+    /// tag, to identify which call is responsible for protecting the tag.
+    /// See `Stack::item_popped` for more explanation.
+    ///
+    /// This will contain one tag per reference passed to the function, so
+    /// a size of 2 is enough for the vast majority of functions.
+    pub protected_tags: SmallVec<[SbTag; 2]>,
+}
+
 /// Extra per-allocation state.
 #[derive(Clone, Debug)]
 pub struct Stacks {
@@ -196,7 +213,7 @@ impl GlobalStateInner {
     }
 
     pub fn end_call(&mut self, frame: &machine::FrameData<'_>) {
-        for tag in &frame.protected_tags {
+        for tag in &frame.stacked_borrows.protected_tags {
             self.protected_tags.remove(tag);
         }
     }
@@ -325,8 +342,8 @@ impl<'tcx> Stack {
             let call_id = threads
                 .all_stacks()
                 .flatten()
-                .find(|t| t.extra.protected_tags.contains(&item.tag()))
-                .map(|frame| frame.extra.call_id)
+                .find(|t| t.extra.stacked_borrows.protected_tags.contains(&item.tag()))
+                .map(|frame| frame.extra.stacked_borrows.call_id)
                 .unwrap(); // FIXME: Surely we should find something, but a panic seems wrong here?
             if let Some((tag, _alloc_range, _offset, _access)) = provoking_access {
                 Err(err_sb_ub(
@@ -818,7 +835,7 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         );
 
         if protect {
-            this.frame_mut().extra.protected_tags.push(new_tag);
+            this.frame_mut().extra.stacked_borrows.protected_tags.push(new_tag);
             this.machine.stacked_borrows.as_mut().unwrap().get_mut().protected_tags.insert(new_tag);
         }
         // FIXME: can't hold the current span handle across the borrows of self above

src/stacked_borrows/stack.rs

@@ -304,6 +304,7 @@ impl<'tcx> Stack {
                     log::trace!("access: disabling item {:?}", item);
                     visitor(*item)?;
                     item.set_permission(Permission::Disabled);
+                    // Also update all copies of this item in the cache.
                     for it in &mut self.cache.items {
                         if it.tag() == item.tag() {
                             it.set_permission(Permission::Disabled);