Auto merge of rust-lang#2711 - RalfJung:btrack, r=RalfJung

bors · bors · commit 4a64902a9d35 · 2022-12-02T13:48:14.000Z
slight simplifications for borrow tracking

and some renaming for consistency
diff --git a/src/tools/miri/src/borrow_tracker/mod.rs b/src/tools/miri/src/borrow_tracker/mod.rs
@@ -55,9 +55,9 @@ impl fmt::Debug for BorTag {
     }
 }
 
-/// Per-frame data for borrow tracking
+/// Per-call-stack-frame data for borrow tracking
 #[derive(Debug)]
-pub struct FrameExtra {
+pub struct FrameState {
     /// The ID of the call this frame corresponds to.
     pub call_id: CallId,
 
@@ -72,7 +72,7 @@ pub struct FrameExtra {
     pub protected_tags: SmallVec<[BorTag; 2]>,
 }
 
-impl VisitTags for FrameExtra {
+impl VisitTags for FrameState {
     fn visit_tags(&self, _visit: &mut dyn FnMut(BorTag)) {
         // `protected_tags` are fine to GC.
     }
@@ -190,17 +190,17 @@ impl GlobalStateInner {
         id
     }
 
-    pub fn new_frame(&mut self, machine: &MiriMachine<'_, '_>) -> FrameExtra {
+    pub fn new_frame(&mut self, machine: &MiriMachine<'_, '_>) -> FrameState {
         let call_id = self.next_call_id;
         trace!("new_frame: Assigning call ID {}", call_id);
         if self.tracked_call_ids.contains(&call_id) {
             machine.emit_diagnostic(NonHaltingDiagnostic::CreatedCallId(call_id));
         }
         self.next_call_id = NonZeroU64::new(call_id.get() + 1).unwrap();
-        FrameExtra { call_id, protected_tags: SmallVec::new() }
+        FrameState { call_id, protected_tags: SmallVec::new() }
     }
 
-    pub fn end_call(&mut self, frame: &machine::FrameData<'_>) {
+    pub fn end_call(&mut self, frame: &machine::FrameExtra<'_>) {
         for tag in &frame
             .borrow_tracker
             .as_ref()
@@ -253,10 +253,10 @@ impl GlobalStateInner {
         alloc_size: Size,
         kind: MemoryKind<machine::MiriMemoryKind>,
         machine: &MiriMachine<'_, '_>,
-    ) -> AllocExtra {
+    ) -> AllocState {
         match self.borrow_tracker_method {
             BorrowTrackerMethod::StackedBorrows =>
-                AllocExtra::StackedBorrows(Box::new(RefCell::new(Stacks::new_allocation(
+                AllocState::StackedBorrows(Box::new(RefCell::new(Stacks::new_allocation(
                     id, alloc_size, self, kind, machine,
                 )))),
         }
@@ -292,24 +292,30 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 
 /// Extra per-allocation data for borrow tracking
 #[derive(Debug, Clone)]
-pub enum AllocExtra {
+pub enum AllocState {
     /// Data corresponding to Stacked Borrows
-    StackedBorrows(Box<RefCell<stacked_borrows::AllocExtra>>),
+    StackedBorrows(Box<RefCell<stacked_borrows::AllocState>>),
 }
 
-impl AllocExtra {
-    pub fn assert_sb(&self) -> &RefCell<stacked_borrows::AllocExtra> {
-        match self {
-            AllocExtra::StackedBorrows(ref sb) => sb,
+impl machine::AllocExtra {
+    #[track_caller]
+    pub fn borrow_tracker_sb(&self) -> &RefCell<stacked_borrows::AllocState> {
+        match self.borrow_tracker {
+            Some(AllocState::StackedBorrows(ref sb)) => sb,
+            _ => panic!("expected Stacked Borrows borrow tracking, got something else"),
         }
     }
 
-    pub fn assert_sb_mut(&mut self) -> &mut RefCell<stacked_borrows::AllocExtra> {
-        match self {
-            AllocExtra::StackedBorrows(ref mut sb) => sb,
+    #[track_caller]
+    pub fn borrow_tracker_sb_mut(&mut self) -> &mut RefCell<stacked_borrows::AllocState> {
+        match self.borrow_tracker {
+            Some(AllocState::StackedBorrows(ref mut sb)) => sb,
+            _ => panic!("expected Stacked Borrows borrow tracking, got something else"),
         }
     }
+}
 
+impl AllocState {
     pub fn before_memory_read<'tcx>(
         &self,
         alloc_id: AllocId,
@@ -318,7 +324,7 @@ impl AllocExtra {
         machine: &MiriMachine<'_, 'tcx>,
     ) -> InterpResult<'tcx> {
         match self {
-            AllocExtra::StackedBorrows(sb) =>
+            AllocState::StackedBorrows(sb) =>
                 sb.borrow_mut().before_memory_read(alloc_id, prov_extra, range, machine),
         }
     }
@@ -331,7 +337,7 @@ impl AllocExtra {
         machine: &mut MiriMachine<'_, 'tcx>,
     ) -> InterpResult<'tcx> {
         match self {
-            AllocExtra::StackedBorrows(sb) =>
+            AllocState::StackedBorrows(sb) =>
                 sb.get_mut().before_memory_write(alloc_id, prov_extra, range, machine),
         }
     }
@@ -344,22 +350,22 @@ impl AllocExtra {
         machine: &mut MiriMachine<'_, 'tcx>,
     ) -> InterpResult<'tcx> {
         match self {
-            AllocExtra::StackedBorrows(sb) =>
+            AllocState::StackedBorrows(sb) =>
                 sb.get_mut().before_memory_deallocation(alloc_id, prov_extra, range, machine),
         }
     }
 
     pub fn remove_unreachable_tags(&self, tags: &FxHashSet<BorTag>) {
         match self {
-            AllocExtra::StackedBorrows(sb) => sb.borrow_mut().remove_unreachable_tags(tags),
+            AllocState::StackedBorrows(sb) => sb.borrow_mut().remove_unreachable_tags(tags),
         }
     }
 }
 
-impl VisitTags for AllocExtra {
+impl VisitTags for AllocState {
     fn visit_tags(&self, visit: &mut dyn FnMut(BorTag)) {
         match self {
-            AllocExtra::StackedBorrows(sb) => sb.visit_tags(visit),
+            AllocState::StackedBorrows(sb) => sb.visit_tags(visit),
         }
     }
 }
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -25,7 +25,7 @@ mod stack;
 pub use stack::Stack;
 pub mod diagnostics;
 
-pub type AllocExtra = Stacks;
+pub type AllocState = Stacks;
 
 /// Extra per-allocation state.
 #[derive(Clone, Debug)]
@@ -500,10 +500,6 @@ impl Stacks {
         })?;
         Ok(())
     }
-
-    fn expose_tag(&mut self, tag: BorTag) {
-        self.exposed_tags.insert(tag);
-    }
 }
 
 /// Retagging/reborrowing.  There is some policy in here, such as which permissions
@@ -567,10 +563,7 @@ trait EvalContextPrivExt<'mir: 'ecx, 'tcx: 'mir, 'ecx>: crate::MiriInterpCxExt<'
                     // uncovers a non-supported `extern static`.
                     let extra = this.get_alloc_extra(alloc_id)?;
                     let mut stacked_borrows = extra
-                        .borrow_tracker
-                        .as_ref()
-                        .expect("We should have borrow tracking data")
-                        .assert_sb()
+                        .borrow_tracker_sb()
                         .borrow_mut();
                     // Note that we create a *second* `DiagnosticCxBuilder` below for the actual retag.
                     // FIXME: can this be done cleaner?
@@ -681,12 +674,7 @@ trait EvalContextPrivExt<'mir: 'ecx, 'tcx: 'mir, 'ecx>: crate::MiriInterpCxExt<'
                 // We have to use shared references to alloc/memory_extra here since
                 // `visit_freeze_sensitive` needs to access the global state.
                 let alloc_extra = this.get_alloc_extra(alloc_id)?;
-                let mut stacked_borrows = alloc_extra
-                    .borrow_tracker
-                    .as_ref()
-                    .expect("We should have borrow tracking data")
-                    .assert_sb()
-                    .borrow_mut();
+                let mut stacked_borrows = alloc_extra.borrow_tracker_sb().borrow_mut();
                 this.visit_freeze_sensitive(place, size, |mut range, frozen| {
                     // Adjust range.
                     range.start += base_offset;
@@ -736,12 +724,7 @@ trait EvalContextPrivExt<'mir: 'ecx, 'tcx: 'mir, 'ecx>: crate::MiriInterpCxExt<'
         // Note that this asserts that the allocation is mutable -- but since we are creating a
         // mutable pointer, that seems reasonable.
         let (alloc_extra, machine) = this.get_alloc_extra_mut(alloc_id)?;
-        let stacked_borrows = alloc_extra
-            .borrow_tracker
-            .as_mut()
-            .expect("We should have borrow tracking data")
-            .assert_sb_mut()
-            .get_mut();
+        let stacked_borrows = alloc_extra.borrow_tracker_sb_mut().get_mut();
         let item = Item::new(new_tag, perm, protect.is_some());
         let range = alloc_range(base_offset, size);
         let global = machine.borrow_tracker.as_ref().unwrap().borrow();
@@ -993,13 +976,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                 // uncovers a non-supported `extern static`.
                 let alloc_extra = this.get_alloc_extra(alloc_id)?;
                 trace!("Stacked Borrows tag {tag:?} exposed in {alloc_id:?}");
-                alloc_extra
-                    .borrow_tracker
-                    .as_ref()
-                    .expect("We should have borrow tracking data")
-                    .assert_sb()
-                    .borrow_mut()
-                    .expose_tag(tag);
+                alloc_extra.borrow_tracker_sb().borrow_mut().exposed_tags.insert(tag);
             }
             AllocKind::Function | AllocKind::VTable | AllocKind::Dead => {
                 // No stacked borrows on these allocations.
@@ -1011,12 +988,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     fn print_stacks(&mut self, alloc_id: AllocId) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let alloc_extra = this.get_alloc_extra(alloc_id)?;
-        let stacks = alloc_extra
-            .borrow_tracker
-            .as_ref()
-            .expect("We should have borrow tracking data")
-            .assert_sb()
-            .borrow();
+        let stacks = alloc_extra.borrow_tracker_sb().borrow();
         for (range, stack) in stacks.stacks.iter_all() {
             print!("{range:?}: [");
             if let Some(bottom) = stack.unknown_bottom() {
diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
@@ -59,7 +59,7 @@ use super::{
     weak_memory::EvalContextExt as _,
 };
 
-pub type AllocExtra = VClockAlloc;
+pub type AllocState = VClockAlloc;
 
 /// Valid atomic read-write orderings, alias of atomic::Ordering (not non-exhaustive).
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs
@@ -113,7 +113,7 @@ pub struct Thread<'mir, 'tcx> {
     thread_name: Option<Vec<u8>>,
 
     /// The virtual call stack.
-    stack: Vec<Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>>,
+    stack: Vec<Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>>,
 
     /// The function to call when the stack ran empty, to figure out what to do next.
     /// Conceptually, this is the interpreter implementation of the things that happen 'after' the
@@ -232,7 +232,7 @@ impl VisitTags for Thread<'_, '_> {
     }
 }
 
-impl VisitTags for Frame<'_, '_, Provenance, FrameData<'_>> {
+impl VisitTags for Frame<'_, '_, Provenance, FrameExtra<'_>> {
     fn visit_tags(&self, visit: &mut dyn FnMut(BorTag)) {
         let Frame {
             return_place,
@@ -385,20 +385,20 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {
     }
 
     /// Borrow the stack of the active thread.
-    pub fn active_thread_stack(&self) -> &[Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>] {
+    pub fn active_thread_stack(&self) -> &[Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>] {
         &self.threads[self.active_thread].stack
     }
 
     /// Mutably borrow the stack of the active thread.
     fn active_thread_stack_mut(
         &mut self,
-    ) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>> {
+    ) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>> {
         &mut self.threads[self.active_thread].stack
     }
 
     pub fn all_stacks(
         &self,
-    ) -> impl Iterator<Item = &[Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>]> {
+    ) -> impl Iterator<Item = &[Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>]> {
         self.threads.iter().map(|t| &t.stack[..])
     }
 
@@ -921,15 +921,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
     }
 
     #[inline]
-    fn active_thread_stack(&self) -> &[Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>] {
+    fn active_thread_stack(&self) -> &[Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>] {
         let this = self.eval_context_ref();
         this.machine.threads.active_thread_stack()
     }
 
     #[inline]
     fn active_thread_stack_mut(
         &mut self,
-    ) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>> {
+    ) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>> {
         let this = self.eval_context_mut();
         this.machine.threads.active_thread_stack_mut()
     }
diff --git a/src/tools/miri/src/concurrency/weak_memory.rs b/src/tools/miri/src/concurrency/weak_memory.rs
@@ -93,7 +93,7 @@ use super::{
     vector_clock::{VClock, VTimestamp, VectorIdx},
 };
 
-pub type AllocExtra = StoreBufferAlloc;
+pub type AllocState = StoreBufferAlloc;
 
 // Each store buffer must be bounded otherwise it will grow indefinitely.
 // However, bounding the store buffer means restricting the amount of weak
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
@@ -988,7 +988,7 @@ impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {
         self.stack()[frame_idx].current_span()
     }
 
-    fn stack(&self) -> &[Frame<'mir, 'tcx, Provenance, machine::FrameData<'tcx>>] {
+    fn stack(&self) -> &[Frame<'mir, 'tcx, Provenance, machine::FrameExtra<'tcx>>] {
         self.threads.active_thread_stack()
     }
 
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
@@ -106,7 +106,7 @@ pub use crate::eval::{
 pub use crate::helpers::EvalContextExt as _;
 pub use crate::intptrcast::ProvenanceMode;
 pub use crate::machine::{
-    AllocExtra, FrameData, MiriInterpCx, MiriInterpCxExt, MiriMachine, MiriMemoryKind,
+    AllocExtra, FrameExtra, MiriInterpCx, MiriInterpCxExt, MiriMachine, MiriMemoryKind,
     PrimitiveLayouts, Provenance, ProvenanceExtra, PAGE_SIZE, STACK_ADDR, STACK_SIZE,
 };
 pub use crate::mono_hash_map::MonoHashMap;
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
diff --git a/src/tools/miri/src/shims/panic.rs b/src/tools/miri/src/shims/panic.rs

Original file line number	Diff line number	Diff line change
`@@ -55,9 +55,9 @@ impl fmt::Debug for BorTag {`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`		`-/// Per-frame data for borrow tracking`
	`58`	`+/// Per-call-stack-frame data for borrow tracking`
`59`	`59`	`#[derive(Debug)]`
`60`		`-pub struct FrameExtra {`
	`60`	`+pub struct FrameState {`
`61`	`61`	`/// The ID of the call this frame corresponds to.`
`62`	`62`	`pub call_id: CallId,`
`63`	`63`
`@@ -72,7 +72,7 @@ pub struct FrameExtra {`
`72`	`72`	`pub protected_tags: SmallVec<[BorTag; 2]>,`
`73`	`73`	`}`
`74`	`74`
`75`		`-impl VisitTags for FrameExtra {`
	`75`	`+impl VisitTags for FrameState {`
`76`	`76`	`fn visit_tags(&self, _visit: &mut dyn FnMut(BorTag)) {`
`77`	`77`	// `protected_tags` are fine to GC.
`78`	`78`	`}`
`@@ -190,17 +190,17 @@ impl GlobalStateInner {`
`190`	`190`	`id`
`191`	`191`	`}`
`192`	`192`
`193`		`- pub fn new_frame(&mut self, machine: &MiriMachine<'_, '_>) -> FrameExtra {`
	`193`	`+ pub fn new_frame(&mut self, machine: &MiriMachine<'_, '_>) -> FrameState {`
`194`	`194`	`let call_id = self.next_call_id;`
`195`	`195`	`trace!("new_frame: Assigning call ID {}", call_id);`
`196`	`196`	`if self.tracked_call_ids.contains(&call_id) {`
`197`	`197`	`machine.emit_diagnostic(NonHaltingDiagnostic::CreatedCallId(call_id));`
`198`	`198`	`}`
`199`	`199`	`self.next_call_id = NonZeroU64::new(call_id.get() + 1).unwrap();`
`200`		`- FrameExtra { call_id, protected_tags: SmallVec::new() }`
	`200`	`+ FrameState { call_id, protected_tags: SmallVec::new() }`
`201`	`201`	`}`
`202`	`202`
`203`		`- pub fn end_call(&mut self, frame: &machine::FrameData<'_>) {`
	`203`	`+ pub fn end_call(&mut self, frame: &machine::FrameExtra<'_>) {`
`204`	`204`	`for tag in &frame`
`205`	`205`	`.borrow_tracker`
`206`	`206`	`.as_ref()`
`@@ -253,10 +253,10 @@ impl GlobalStateInner {`
`253`	`253`	`alloc_size: Size,`
`254`	`254`	`kind: MemoryKind<machine::MiriMemoryKind>,`
`255`	`255`	`machine: &MiriMachine<'_, '_>,`
`256`		`- ) -> AllocExtra {`
	`256`	`+ ) -> AllocState {`
`257`	`257`	`match self.borrow_tracker_method {`
`258`	`258`	`BorrowTrackerMethod::StackedBorrows =>`
`259`		`- AllocExtra::StackedBorrows(Box::new(RefCell::new(Stacks::new_allocation(`
	`259`	`+ AllocState::StackedBorrows(Box::new(RefCell::new(Stacks::new_allocation(`
`260`	`260`	`id, alloc_size, self, kind, machine,`
`261`	`261`	`)))),`
`262`	`262`	`}`
`@@ -292,24 +292,30 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {`
`292`	`292`
`293`	`293`	`/// Extra per-allocation data for borrow tracking`
`294`	`294`	`#[derive(Debug, Clone)]`
`295`		`-pub enum AllocExtra {`
	`295`	`+pub enum AllocState {`
`296`	`296`	`/// Data corresponding to Stacked Borrows`
`297`		`- StackedBorrows(Box<RefCell<stacked_borrows::AllocExtra>>),`
	`297`	`+ StackedBorrows(Box<RefCell<stacked_borrows::AllocState>>),`
`298`	`298`	`}`
`299`	`299`
`300`		`-impl AllocExtra {`
`301`		`- pub fn assert_sb(&self) -> &RefCell<stacked_borrows::AllocExtra> {`
`302`		`- match self {`
`303`		`- AllocExtra::StackedBorrows(ref sb) => sb,`
	`300`	`+impl machine::AllocExtra {`
	`301`	`+ #[track_caller]`
	`302`	`+ pub fn borrow_tracker_sb(&self) -> &RefCell<stacked_borrows::AllocState> {`
	`303`	`+ match self.borrow_tracker {`
	`304`	`+ Some(AllocState::StackedBorrows(ref sb)) => sb,`
	`305`	`+ _ => panic!("expected Stacked Borrows borrow tracking, got something else"),`
`304`	`306`	`}`
`305`	`307`	`}`
`306`	`308`
`307`		`- pub fn assert_sb_mut(&mut self) -> &mut RefCell<stacked_borrows::AllocExtra> {`
`308`		`- match self {`
`309`		`- AllocExtra::StackedBorrows(ref mut sb) => sb,`
	`309`	`+ #[track_caller]`
	`310`	`+ pub fn borrow_tracker_sb_mut(&mut self) -> &mut RefCell<stacked_borrows::AllocState> {`
	`311`	`+ match self.borrow_tracker {`
	`312`	`+ Some(AllocState::StackedBorrows(ref mut sb)) => sb,`
	`313`	`+ _ => panic!("expected Stacked Borrows borrow tracking, got something else"),`
`310`	`314`	`}`
`311`	`315`	`}`
	`316`	`+}`
`312`	`317`
	`318`	`+impl AllocState {`
`313`	`319`	`pub fn before_memory_read<'tcx>(`
`314`	`320`	`&self,`
`315`	`321`	`alloc_id: AllocId,`
`@@ -318,7 +324,7 @@ impl AllocExtra {`
`318`	`324`	`machine: &MiriMachine<'_, 'tcx>,`
`319`	`325`	`) -> InterpResult<'tcx> {`
`320`	`326`	`match self {`
`321`		`- AllocExtra::StackedBorrows(sb) =>`
	`327`	`+ AllocState::StackedBorrows(sb) =>`
`322`	`328`	`sb.borrow_mut().before_memory_read(alloc_id, prov_extra, range, machine),`
`323`	`329`	`}`
`324`	`330`	`}`
`@@ -331,7 +337,7 @@ impl AllocExtra {`
`331`	`337`	`machine: &mut MiriMachine<'_, 'tcx>,`
`332`	`338`	`) -> InterpResult<'tcx> {`
`333`	`339`	`match self {`
`334`		`- AllocExtra::StackedBorrows(sb) =>`
	`340`	`+ AllocState::StackedBorrows(sb) =>`
`335`	`341`	`sb.get_mut().before_memory_write(alloc_id, prov_extra, range, machine),`
`336`	`342`	`}`
`337`	`343`	`}`
`@@ -344,22 +350,22 @@ impl AllocExtra {`
`344`	`350`	`machine: &mut MiriMachine<'_, 'tcx>,`
`345`	`351`	`) -> InterpResult<'tcx> {`
`346`	`352`	`match self {`
`347`		`- AllocExtra::StackedBorrows(sb) =>`
	`353`	`+ AllocState::StackedBorrows(sb) =>`
`348`	`354`	`sb.get_mut().before_memory_deallocation(alloc_id, prov_extra, range, machine),`
`349`	`355`	`}`
`350`	`356`	`}`
`351`	`357`
`352`	`358`	`pub fn remove_unreachable_tags(&self, tags: &FxHashSet<BorTag>) {`
`353`	`359`	`match self {`
`354`		`- AllocExtra::StackedBorrows(sb) => sb.borrow_mut().remove_unreachable_tags(tags),`
	`360`	`+ AllocState::StackedBorrows(sb) => sb.borrow_mut().remove_unreachable_tags(tags),`
`355`	`361`	`}`
`356`	`362`	`}`
`357`	`363`	`}`
`358`	`364`
`359`		`-impl VisitTags for AllocExtra {`
	`365`	`+impl VisitTags for AllocState {`
`360`	`366`	`fn visit_tags(&self, visit: &mut dyn FnMut(BorTag)) {`
`361`	`367`	`match self {`
`362`		`- AllocExtra::StackedBorrows(sb) => sb.visit_tags(visit),`
	`368`	`+ AllocState::StackedBorrows(sb) => sb.visit_tags(visit),`
`363`	`369`	`}`
`364`	`370`	`}`
`365`	`371`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ pub struct Thread<'mir, 'tcx> {`
`113`	`113`	`thread_name: Option<Vec<u8>>,`
`114`	`114`
`115`	`115`	`/// The virtual call stack.`
`116`		`- stack: Vec<Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>>,`
	`116`	`+ stack: Vec<Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>>,`
`117`	`117`
`118`	`118`	`/// The function to call when the stack ran empty, to figure out what to do next.`
`119`	`119`	`/// Conceptually, this is the interpreter implementation of the things that happen 'after' the`
`@@ -232,7 +232,7 @@ impl VisitTags for Thread<'_, '_> {`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`235`		`-impl VisitTags for Frame<'_, '_, Provenance, FrameData<'_>> {`
	`235`	`+impl VisitTags for Frame<'_, '_, Provenance, FrameExtra<'_>> {`
`236`	`236`	`fn visit_tags(&self, visit: &mut dyn FnMut(BorTag)) {`
`237`	`237`	`let Frame {`
`238`	`238`	`return_place,`
`@@ -385,20 +385,20 @@ impl<'mir, 'tcx: 'mir> ThreadManager<'mir, 'tcx> {`
`385`	`385`	`}`
`386`	`386`
`387`	`387`	`/// Borrow the stack of the active thread.`
`388`		`- pub fn active_thread_stack(&self) -> &[Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>] {`
	`388`	`+ pub fn active_thread_stack(&self) -> &[Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>] {`
`389`	`389`	`&self.threads[self.active_thread].stack`
`390`	`390`	`}`
`391`	`391`
`392`	`392`	`/// Mutably borrow the stack of the active thread.`
`393`	`393`	`fn active_thread_stack_mut(`
`394`	`394`	`&mut self,`
`395`		`- ) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>> {`
	`395`	`+ ) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>> {`
`396`	`396`	`&mut self.threads[self.active_thread].stack`
`397`	`397`	`}`
`398`	`398`
`399`	`399`	`pub fn all_stacks(`
`400`	`400`	`&self,`
`401`		`- ) -> impl Iterator<Item = &[Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>]> {`
	`401`	`+ ) -> impl Iterator<Item = &[Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>]> {`
`402`	`402`	`self.threads.iter().map(\|t\| &t.stack[..])`
`403`	`403`	`}`
`404`	`404`
`@@ -921,15 +921,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {`
`921`	`921`	`}`
`922`	`922`
`923`	`923`	`#[inline]`
`924`		`- fn active_thread_stack(&self) -> &[Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>] {`
	`924`	`+ fn active_thread_stack(&self) -> &[Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>] {`
`925`	`925`	`let this = self.eval_context_ref();`
`926`	`926`	`this.machine.threads.active_thread_stack()`
`927`	`927`	`}`
`928`	`928`
`929`	`929`	`#[inline]`
`930`	`930`	`fn active_thread_stack_mut(`
`931`	`931`	`&mut self,`
`932`		`- ) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>> {`
	`932`	`+ ) -> &mut Vec<Frame<'mir, 'tcx, Provenance, FrameExtra<'tcx>>> {`
`933`	`933`	`let this = self.eval_context_mut();`
`934`	`934`	`this.machine.threads.active_thread_stack_mut()`
`935`	`935`	`}`
Original file line number	Diff line number	Diff line change
`@@ -988,7 +988,7 @@ impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {`
`988`	`988`	`self.stack()[frame_idx].current_span()`
`989`	`989`	`}`
`990`	`990`
`991`		`- fn stack(&self) -> &[Frame<'mir, 'tcx, Provenance, machine::FrameData<'tcx>>] {`
	`991`	`+ fn stack(&self) -> &[Frame<'mir, 'tcx, Provenance, machine::FrameExtra<'tcx>>] {`
`992`	`992`	`self.threads.active_thread_stack()`
`993`	`993`	`}`
`994`	`994`