Actually factor out stacked_borrows::FrameExtra

Author: saethlin

src/machine.rs

@@ -5,12 +5,10 @@ use std::borrow::Cow;
 use std::cell::RefCell;
 use std::collections::HashSet;
 use std::fmt;
-use std::num::NonZeroU64;
 use std::time::Instant;
 
 use rand::rngs::StdRng;
 use rand::SeedableRng;
-use smallvec::SmallVec;
 
 use rustc_ast::ast::Mutability;
 use rustc_data_structures::fx::FxHashMap;
@@ -44,7 +42,7 @@ pub const NUM_CPUS: u64 = 1;
 /// Extra data stored with each stack frame
 pub struct FrameData<'tcx> {
     /// Extra data for Stacked Borrows.
-    pub stacked_borrows: stacked_borrows::FrameExtra,
+    pub stacked_borrows: Option<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,
@@ -892,15 +890,9 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         };
 
         let stacked_borrows = ecx.machine.stacked_borrows.as_ref();
-        let call_id = stacked_borrows.map_or(NonZeroU64::new(1).unwrap(), |stacked_borrows| {
-            stacked_borrows.borrow_mut().new_call()
-        });
 
         let extra = FrameData {
-            stacked_borrows: stacked_borrows::FrameExtra {
-                call_id,
-                protected_tags: SmallVec::new(),
-            },
+            stacked_borrows: stacked_borrows.map(|sb| sb.borrow_mut().new_frame()),
             catch_unwind: None,
             timing,
         };

src/stacked_borrows.rs

@@ -84,7 +84,7 @@ impl SbTagExtra {
 #[derive(Debug)]
 pub struct FrameExtra {
     /// The ID of the call this frame corresponds to.
-    pub call_id: CallId,
+    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
@@ -94,7 +94,7 @@ pub struct FrameExtra {
     ///
     /// 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]>,
+    protected_tags: SmallVec<[SbTag; 2]>,
 }
 
 /// Extra per-allocation state.
@@ -202,18 +202,23 @@ impl GlobalStateInner {
         id
     }
 
-    pub fn new_call(&mut self) -> CallId {
-        let id = self.next_call_id;
-        trace!("new_call: Assigning ID {}", id);
-        if self.tracked_call_ids.contains(&id) {
-            register_diagnostic(NonHaltingDiagnostic::CreatedCallId(id));
+    pub fn new_frame(&mut self) -> FrameExtra {
+        let call_id = self.next_call_id;
+        trace!("new_frame: Assigning call ID {}", call_id);
+        if self.tracked_call_ids.contains(&call_id) {
+            register_diagnostic(NonHaltingDiagnostic::CreatedCallId(call_id));
         }
-        self.next_call_id = NonZeroU64::new(id.get() + 1).unwrap();
-        id
+        self.next_call_id = NonZeroU64::new(call_id.get() + 1).unwrap();
+        FrameExtra { call_id, protected_tags: SmallVec::new() }
     }
 
     pub fn end_call(&mut self, frame: &machine::FrameData<'_>) {
-        for tag in &frame.stacked_borrows.protected_tags {
+        for tag in &frame
+            .stacked_borrows
+            .as_ref()
+            .expect("we should have Stacked Borrows data")
+            .protected_tags
+        {
             self.protected_tags.remove(tag);
         }
     }
@@ -342,8 +347,15 @@ impl<'tcx> Stack {
             let call_id = threads
                 .all_stacks()
                 .flatten()
-                .find(|t| t.extra.stacked_borrows.protected_tags.contains(&item.tag()))
-                .map(|frame| frame.extra.stacked_borrows.call_id)
+                .map(|frame| {
+                    frame
+                        .extra
+                        .stacked_borrows
+                        .as_ref()
+                        .expect("we should have Stacked Borrows data")
+                })
+                .find(|frame| frame.protected_tags.contains(&item.tag()))
+                .map(|frame| frame.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(
@@ -835,7 +847,7 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         );
 
         if protect {
-            this.frame_mut().extra.stacked_borrows.protected_tags.push(new_tag);
+            this.frame_mut().extra.stacked_borrows.as_mut().unwrap().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