Add a shim that lets us manually run the GC

src/machine.rs

@@ -1358,7 +1358,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
  // where it mistakenly removes an important tag become visible.
  if ecx.machine.gc_interval > 0 && ecx.machine.since_gc >= ecx.machine.gc_interval {
  ecx.machine.since_gc = 0;
- ecx.garbage_collect_tags()?;
+ ecx.run_provenance_gc();
  }
 
  // These are our preemption points.

src/provenance_gc.rs

@@ -149,12 +149,8 @@ impl VisitTags for crate::MiriInterpCx<'_, '_> {
 
 impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriInterpCx<'mir, 'tcx> {}
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriInterpCxExt<'mir, 'tcx> {
- fn garbage_collect_tags(&mut self) -> InterpResult<'tcx> {
+ fn run_provenance_gc(&mut self) {
  let this = self.eval_context_mut();
- // No reason to do anything at all if stacked borrows is off.
- if this.machine.borrow_tracker.is_none() {
- return Ok(());
- }
 
  let mut tags = FxHashSet::default();
  let mut alloc_ids = FxHashSet::default();
@@ -168,8 +164,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriInterpCxExt<'mir, 'tcx> {
  });
  self.remove_unreachable_tags(tags);
  self.remove_unreachable_allocs(alloc_ids);
-
- Ok(())
  }
 
  fn remove_unreachable_tags(&mut self, tags: FxHashSet<BorTag>) {

src/shims/foreign_items.rs

@@ -459,6 +459,10 @@ trait EvalContextExtPriv<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
  // shim, add it to the corresponding submodule.
  match link_name.as_str() {
  // Miri-specific extern functions
+ "miri_run_provenance_gc" => {
+ let [] = this.check_shim(abi, Abi::Rust, link_name, args)?;
+ this.run_provenance_gc();
+ }
  "miri_get_alloc_id" => {
  let [ptr] = this.check_shim(abi, Abi::Rust, link_name, args)?;
  let ptr = this.read_pointer(ptr)?;

tests/pass/ptr_int_casts.rs

@@ -4,6 +4,10 @@
 use std::mem;
 use std::ptr;
 
+extern "Rust" {
+ fn miri_run_provenance_gc();
+}
+
 fn eq_ref<T>(x: &T, y: &T) -> bool {
  x as *const _ == y as *const _
 }
@@ -47,25 +51,19 @@ fn ptr_int_casts() {
  // involving types other than usize
  assert_eq!((-1i32) as usize as *const i32 as usize, (-1i32) as usize);
 
- // Stress-test that the GC doesn't delete context that would prevent us from casting from int
+ // Check that the GC doesn't delete context that would prevent us from casting from int
  // to pointer correctly after the allocation is dead.
- let mut ptrs: Vec<*const u8> = Vec::new();
- let mut ints: Vec<usize> = Vec::new();
-
- for _ in 0..100 {
+ let (ptr, int) = {
  let local = 0u8;
  let ptr = &local as *const u8;
- ptrs.push(ptr);
- ints.push(ptr as usize);
-
- let b = Box::new(0u8);
- let ptr = &*b as *const u8;
- ptrs.push(ptr);
- ints.push(ptr as usize);
- }
-
- let later_ints: Vec<usize> = ptrs.iter().map(|p| *p as usize).collect();
- assert_eq!(ints, later_ints);
+ (ptr, ptr as usize)
+ };
+ // Manually run the GC, instead of just hoping that it runs at the right time.
+ unsafe { miri_run_provenance_gc() }
+ let later_int = ptr as usize;
+ assert_eq!(int, later_int);
+ let later_ptr = int as *const u8;
+ assert_eq!(ptr, later_ptr);
 }
 
 fn ptr_int_ops() {