src/tools/miri/src/machine.rs

   1 //! Global machine state as well as implementation of the interpreter engine
   2 //! `Machine` trait.
   3
   4 use std::borrow::Cow;
   5 use std::cell::RefCell;
   6 use std::fmt;
   7
   8 use rand::rngs::StdRng;
   9 use rand::SeedableRng;
  10
  11 use rustc_ast::ast::Mutability;
  12 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  13 #[allow(unused)]
  14 use rustc_data_structures::static_assert_size;
  15 use rustc_middle::{
  16     mir,
  17     ty::{
  18         self,
  19         layout::{LayoutCx, LayoutError, LayoutOf, TyAndLayout},
  20         Instance, Ty, TyCtxt, TypeAndMut,
  21     },
  22 };
  23 use rustc_span::def_id::{CrateNum, DefId};
  24 use rustc_span::Symbol;
  25 use rustc_target::abi::Size;
  26 use rustc_target::spec::abi::Abi;
  27
  28 use crate::{
  29     concurrency::{data_race, weak_memory},
  30     shims::unix::FileHandler,
  31     *,
  32 };
  33
  34 // Some global facts about the emulated machine.
  35 pub const PAGE_SIZE: u64 = 4 * 1024; // FIXME: adjust to target architecture
  36 pub const STACK_ADDR: u64 = 32 * PAGE_SIZE; // not really about the "stack", but where we start assigning integer addresses to allocations
  37 pub const STACK_SIZE: u64 = 16 * PAGE_SIZE; // whatever
  38
  39 /// Extra data stored with each stack frame
  40 pub struct FrameData<'tcx> {
  41     /// Extra data for Stacked Borrows.
  42     pub stacked_borrows: Option<stacked_borrows::FrameExtra>,
  43
  44     /// If this is Some(), then this is a special "catch unwind" frame (the frame of `try_fn`
  45     /// called by `try`). When this frame is popped during unwinding a panic,
  46     /// we stop unwinding, use the `CatchUnwindData` to handle catching.
  47     pub catch_unwind: Option<CatchUnwindData<'tcx>>,
  48
  49     /// If `measureme` profiling is enabled, holds timing information
  50     /// for the start of this frame. When we finish executing this frame,
  51     /// we use this to register a completed event with `measureme`.
  52     pub timing: Option<measureme::DetachedTiming>,
  53 }
  54
  55 impl<'tcx> std::fmt::Debug for FrameData<'tcx> {
  56     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  57         // Omitting `timing`, it does not support `Debug`.
  58         let FrameData { stacked_borrows, catch_unwind, timing: _ } = self;
  59         f.debug_struct("FrameData")
  60             .field("stacked_borrows", stacked_borrows)
  61             .field("catch_unwind", catch_unwind)
  62             .finish()
  63     }
  64 }
  65
  66 impl VisitTags for FrameData<'_> {
  67     fn visit_tags(&self, visit: &mut dyn FnMut(SbTag)) {
  68         let FrameData { catch_unwind, stacked_borrows, timing: _ } = self;
  69
  70         catch_unwind.visit_tags(visit);
  71         stacked_borrows.visit_tags(visit);
  72     }
  73 }
  74
  75 /// Extra memory kinds
  76 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
  77 pub enum MiriMemoryKind {
  78     /// `__rust_alloc` memory.
  79     Rust,
  80     /// `malloc` memory.
  81     C,
  82     /// Windows `HeapAlloc` memory.
  83     WinHeap,
  84     /// Memory for args, errno, and other parts of the machine-managed environment.
  85     /// This memory may leak.
  86     Machine,
  87     /// Memory allocated by the runtime (e.g. env vars). Separate from `Machine`
  88     /// because we clean it up and leak-check it.
  89     Runtime,
  90     /// Globals copied from `tcx`.
  91     /// This memory may leak.
  92     Global,
  93     /// Memory for extern statics.
  94     /// This memory may leak.
  95     ExternStatic,
  96     /// Memory for thread-local statics.
  97     /// This memory may leak.
  98     Tls,
  99 }
 100
 101 impl From<MiriMemoryKind> for MemoryKind<MiriMemoryKind> {
 102     #[inline(always)]
 103     fn from(kind: MiriMemoryKind) -> MemoryKind<MiriMemoryKind> {
 104         MemoryKind::Machine(kind)
 105     }
 106 }
 107
 108 impl MayLeak for MiriMemoryKind {
 109     #[inline(always)]
 110     fn may_leak(self) -> bool {
 111         use self::MiriMemoryKind::*;
 112         match self {
 113             Rust | C | WinHeap | Runtime => false,
 114             Machine | Global | ExternStatic | Tls => true,
 115         }
 116     }
 117 }
 118
 119 impl fmt::Display for MiriMemoryKind {
 120     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 121         use self::MiriMemoryKind::*;
 122         match self {
 123             Rust => write!(f, "Rust heap"),
 124             C => write!(f, "C heap"),
 125             WinHeap => write!(f, "Windows heap"),
 126             Machine => write!(f, "machine-managed memory"),
 127             Runtime => write!(f, "language runtime memory"),
 128             Global => write!(f, "global (static or const)"),
 129             ExternStatic => write!(f, "extern static"),
 130             Tls => write!(f, "thread-local static"),
 131         }
 132     }
 133 }
 134
 135 /// Pointer provenance.
 136 #[derive(Debug, Clone, Copy)]
 137 pub enum Provenance {
 138     Concrete {
 139         alloc_id: AllocId,
 140         /// Stacked Borrows tag.
 141         sb: SbTag,
 142     },
 143     Wildcard,
 144 }
 145
 146 // This needs to be `Eq`+`Hash` because the `Machine` trait needs that because validity checking
 147 // *might* be recursive and then it has to track which places have already been visited.
 148 // However, comparing provenance is meaningless, since `Wildcard` might be any provenance -- and of
 149 // course we don't actually do recursive checking.
 150 // We could change `RefTracking` to strip provenance for its `seen` set but that type is generic so that is quite annoying.
 151 // Instead owe add the required instances but make them panic.
 152 impl PartialEq for Provenance {
 153     fn eq(&self, _other: &Self) -> bool {
 154         panic!("Provenance must not be compared")
 155     }
 156 }
 157 impl Eq for Provenance {}
 158 impl std::hash::Hash for Provenance {
 159     fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {
 160         panic!("Provenance must not be hashed")
 161     }
 162 }
 163
 164 /// The "extra" information a pointer has over a regular AllocId.
 165 #[derive(Copy, Clone, PartialEq)]
 166 pub enum ProvenanceExtra {
 167     Concrete(SbTag),
 168     Wildcard,
 169 }
 170
 171 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 172 static_assert_size!(Pointer<Provenance>, 24);
 173 // FIXME: this would with in 24bytes but layout optimizations are not smart enough
 174 // #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 175 //static_assert_size!(Pointer<Option<Provenance>>, 24);
 176 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 177 static_assert_size!(Scalar<Provenance>, 32);
 178
 179 impl interpret::Provenance for Provenance {
 180     /// We use absolute addresses in the `offset` of a `Pointer<Provenance>`.
 181     const OFFSET_IS_ADDR: bool = true;
 182
 183     /// We cannot err on partial overwrites, it happens too often in practice (due to unions).
 184     const ERR_ON_PARTIAL_PTR_OVERWRITE: bool = false;
 185
 186     fn fmt(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 187         let (prov, addr) = ptr.into_parts(); // address is absolute
 188         write!(f, "{:#x}", addr.bytes())?;
 189
 190         match prov {
 191             Provenance::Concrete { alloc_id, sb } => {
 192                 // Forward `alternate` flag to `alloc_id` printing.
 193                 if f.alternate() {
 194                     write!(f, "[{:#?}]", alloc_id)?;
 195                 } else {
 196                     write!(f, "[{:?}]", alloc_id)?;
 197                 }
 198                 // Print Stacked Borrows tag.
 199                 write!(f, "{:?}", sb)?;
 200             }
 201             Provenance::Wildcard => {
 202                 write!(f, "[wildcard]")?;
 203             }
 204         }
 205
 206         Ok(())
 207     }
 208
 209     fn get_alloc_id(self) -> Option<AllocId> {
 210         match self {
 211             Provenance::Concrete { alloc_id, .. } => Some(alloc_id),
 212             Provenance::Wildcard => None,
 213         }
 214     }
 215
 216     fn join(left: Option<Self>, right: Option<Self>) -> Option<Self> {
 217         match (left, right) {
 218             // If both are the *same* concrete tag, that is the result.
 219             (
 220                 Some(Provenance::Concrete { alloc_id: left_alloc, sb: left_sb }),
 221                 Some(Provenance::Concrete { alloc_id: right_alloc, sb: right_sb }),
 222             ) if left_alloc == right_alloc && left_sb == right_sb => left,
 223             // If one side is a wildcard, the best possible outcome is that it is equal to the other
 224             // one, and we use that.
 225             (Some(Provenance::Wildcard), o) | (o, Some(Provenance::Wildcard)) => o,
 226             // Otherwise, fall back to `None`.
 227             _ => None,
 228         }
 229     }
 230 }
 231
 232 impl fmt::Debug for ProvenanceExtra {
 233     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 234         match self {
 235             ProvenanceExtra::Concrete(pid) => write!(f, "{pid:?}"),
 236             ProvenanceExtra::Wildcard => write!(f, "<wildcard>"),
 237         }
 238     }
 239 }
 240
 241 impl ProvenanceExtra {
 242     pub fn and_then<T>(self, f: impl FnOnce(SbTag) -> Option<T>) -> Option<T> {
 243         match self {
 244             ProvenanceExtra::Concrete(pid) => f(pid),
 245             ProvenanceExtra::Wildcard => None,
 246         }
 247     }
 248 }
 249
 250 /// Extra per-allocation data
 251 #[derive(Debug, Clone)]
 252 pub struct AllocExtra {
 253     /// Stacked Borrows state is only added if it is enabled.
 254     pub stacked_borrows: Option<stacked_borrows::AllocExtra>,
 255     /// Data race detection via the use of a vector-clock,
 256     ///  this is only added if it is enabled.
 257     pub data_race: Option<data_race::AllocExtra>,
 258     /// Weak memory emulation via the use of store buffers,
 259     ///  this is only added if it is enabled.
 260     pub weak_memory: Option<weak_memory::AllocExtra>,
 261 }
 262
 263 impl VisitTags for AllocExtra {
 264     fn visit_tags(&self, visit: &mut dyn FnMut(SbTag)) {
 265         let AllocExtra { stacked_borrows, data_race, weak_memory } = self;
 266
 267         stacked_borrows.visit_tags(visit);
 268         data_race.visit_tags(visit);
 269         weak_memory.visit_tags(visit);
 270     }
 271 }
 272
 273 /// Precomputed layouts of primitive types
 274 pub struct PrimitiveLayouts<'tcx> {
 275     pub unit: TyAndLayout<'tcx>,
 276     pub i8: TyAndLayout<'tcx>,
 277     pub i16: TyAndLayout<'tcx>,
 278     pub i32: TyAndLayout<'tcx>,
 279     pub isize: TyAndLayout<'tcx>,
 280     pub u8: TyAndLayout<'tcx>,
 281     pub u16: TyAndLayout<'tcx>,
 282     pub u32: TyAndLayout<'tcx>,
 283     pub usize: TyAndLayout<'tcx>,
 284     pub bool: TyAndLayout<'tcx>,
 285     pub mut_raw_ptr: TyAndLayout<'tcx>,   // *mut ()
 286     pub const_raw_ptr: TyAndLayout<'tcx>, // *const ()
 287 }
 288
 289 impl<'mir, 'tcx: 'mir> PrimitiveLayouts<'tcx> {
 290     fn new(layout_cx: LayoutCx<'tcx, TyCtxt<'tcx>>) -> Result<Self, LayoutError<'tcx>> {
 291         let tcx = layout_cx.tcx;
 292         let mut_raw_ptr = tcx.mk_ptr(TypeAndMut { ty: tcx.types.unit, mutbl: Mutability::Mut });
 293         let const_raw_ptr = tcx.mk_ptr(TypeAndMut { ty: tcx.types.unit, mutbl: Mutability::Not });
 294         Ok(Self {
 295             unit: layout_cx.layout_of(tcx.mk_unit())?,
 296             i8: layout_cx.layout_of(tcx.types.i8)?,
 297             i16: layout_cx.layout_of(tcx.types.i16)?,
 298             i32: layout_cx.layout_of(tcx.types.i32)?,
 299             isize: layout_cx.layout_of(tcx.types.isize)?,
 300             u8: layout_cx.layout_of(tcx.types.u8)?,
 301             u16: layout_cx.layout_of(tcx.types.u16)?,
 302             u32: layout_cx.layout_of(tcx.types.u32)?,
 303             usize: layout_cx.layout_of(tcx.types.usize)?,
 304             bool: layout_cx.layout_of(tcx.types.bool)?,
 305             mut_raw_ptr: layout_cx.layout_of(mut_raw_ptr)?,
 306             const_raw_ptr: layout_cx.layout_of(const_raw_ptr)?,
 307         })
 308     }
 309 }
 310
 311 /// The machine itself.
 312 ///
 313 /// If you add anything here that stores machine values, remember to update
 314 /// `visit_all_machine_values`!
 315 pub struct MiriMachine<'mir, 'tcx> {
 316     // We carry a copy of the global `TyCtxt` for convenience, so methods taking just `&Evaluator` have `tcx` access.
 317     pub tcx: TyCtxt<'tcx>,
 318
 319     /// Stacked Borrows global data.
 320     pub stacked_borrows: Option<stacked_borrows::GlobalState>,
 321
 322     /// Data race detector global data.
 323     pub data_race: Option<data_race::GlobalState>,
 324
 325     /// Ptr-int-cast module global data.
 326     pub intptrcast: intptrcast::GlobalState,
 327
 328     /// Environment variables set by `setenv`.
 329     /// Miri does not expose env vars from the host to the emulated program.
 330     pub(crate) env_vars: EnvVars<'tcx>,
 331
 332     /// Program arguments (`Option` because we can only initialize them after creating the ecx).
 333     /// These are *pointers* to argc/argv because macOS.
 334     /// We also need the full command line as one string because of Windows.
 335     pub(crate) argc: Option<MemPlace<Provenance>>,
 336     pub(crate) argv: Option<MemPlace<Provenance>>,
 337     pub(crate) cmd_line: Option<MemPlace<Provenance>>,
 338
 339     /// TLS state.
 340     pub(crate) tls: TlsData<'tcx>,
 341
 342     /// What should Miri do when an op requires communicating with the host,
 343     /// such as accessing host env vars, random number generation, and
 344     /// file system access.
 345     pub(crate) isolated_op: IsolatedOp,
 346
 347     /// Whether to enforce the validity invariant.
 348     pub(crate) validate: bool,
 349
 350     /// Whether to enforce [ABI](Abi) of function calls.
 351     pub(crate) enforce_abi: bool,
 352
 353     /// The table of file descriptors.
 354     pub(crate) file_handler: shims::unix::FileHandler,
 355     /// The table of directory descriptors.
 356     pub(crate) dir_handler: shims::unix::DirHandler,
 357
 358     /// This machine's monotone clock.
 359     pub(crate) clock: Clock,
 360
 361     /// The set of threads.
 362     pub(crate) threads: ThreadManager<'mir, 'tcx>,
 363
 364     /// Precomputed `TyLayout`s for primitive data types that are commonly used inside Miri.
 365     pub(crate) layouts: PrimitiveLayouts<'tcx>,
 366
 367     /// Allocations that are considered roots of static memory (that may leak).
 368     pub(crate) static_roots: Vec<AllocId>,
 369
 370     /// The `measureme` profiler used to record timing information about
 371     /// the emulated program.
 372     profiler: Option<measureme::Profiler>,
 373     /// Used with `profiler` to cache the `StringId`s for event names
 374     /// uesd with `measureme`.
 375     string_cache: FxHashMap<String, measureme::StringId>,
 376
 377     /// Cache of `Instance` exported under the given `Symbol` name.
 378     /// `None` means no `Instance` exported under the given name is found.
 379     pub(crate) exported_symbols_cache: FxHashMap<Symbol, Option<Instance<'tcx>>>,
 380
 381     /// Whether to raise a panic in the context of the evaluated process when unsupported
 382     /// functionality is encountered. If `false`, an error is propagated in the Miri application context
 383     /// instead (default behavior)
 384     pub(crate) panic_on_unsupported: bool,
 385
 386     /// Equivalent setting as RUST_BACKTRACE on encountering an error.
 387     pub(crate) backtrace_style: BacktraceStyle,
 388
 389     /// Crates which are considered local for the purposes of error reporting.
 390     pub(crate) local_crates: Vec<CrateNum>,
 391
 392     /// Mapping extern static names to their base pointer.
 393     extern_statics: FxHashMap<Symbol, Pointer<Provenance>>,
 394
 395     /// The random number generator used for resolving non-determinism.
 396     /// Needs to be queried by ptr_to_int, hence needs interior mutability.
 397     pub(crate) rng: RefCell<StdRng>,
 398
 399     /// The allocation IDs to report when they are being allocated
 400     /// (helps for debugging memory leaks and use after free bugs).
 401     tracked_alloc_ids: FxHashSet<AllocId>,
 402
 403     /// Controls whether alignment of memory accesses is being checked.
 404     pub(crate) check_alignment: AlignmentCheck,
 405
 406     /// Failure rate of compare_exchange_weak, between 0.0 and 1.0
 407     pub(crate) cmpxchg_weak_failure_rate: f64,
 408
 409     /// Corresponds to -Zmiri-mute-stdout-stderr and doesn't write the output but acts as if it succeeded.
 410     pub(crate) mute_stdout_stderr: bool,
 411
 412     /// Whether weak memory emulation is enabled
 413     pub(crate) weak_memory: bool,
 414
 415     /// The probability of the active thread being preempted at the end of each basic block.
 416     pub(crate) preemption_rate: f64,
 417
 418     /// If `Some`, we will report the current stack every N basic blocks.
 419     pub(crate) report_progress: Option<u32>,
 420     // The total number of blocks that have been executed.
 421     pub(crate) basic_block_count: u64,
 422
 423     /// Handle of the optional shared object file for external functions.
 424     #[cfg(unix)]
 425     pub external_so_lib: Option<(libloading::Library, std::path::PathBuf)>,
 426
 427     /// Run a garbage collector for SbTags every N basic blocks.
 428     pub(crate) gc_interval: u32,
 429     /// The number of blocks that passed since the last SbTag GC pass.
 430     pub(crate) since_gc: u32,
 431     /// The number of CPUs to be reported by miri.
 432     pub(crate) num_cpus: u32,
 433 }
 434
 435 impl<'mir, 'tcx> MiriMachine<'mir, 'tcx> {
 436     pub(crate) fn new(config: &MiriConfig, layout_cx: LayoutCx<'tcx, TyCtxt<'tcx>>) -> Self {
 437         let local_crates = helpers::get_local_crates(layout_cx.tcx);
 438         let layouts =
 439             PrimitiveLayouts::new(layout_cx).expect("Couldn't get layouts of primitive types");
 440         let profiler = config.measureme_out.as_ref().map(|out| {
 441             measureme::Profiler::new(out).expect("Couldn't create `measureme` profiler")
 442         });
 443         let rng = StdRng::seed_from_u64(config.seed.unwrap_or(0));
 444         let stacked_borrows = config.stacked_borrows.then(|| {
 445             RefCell::new(stacked_borrows::GlobalStateInner::new(
 446                 config.tracked_pointer_tags.clone(),
 447                 config.tracked_call_ids.clone(),
 448                 config.retag_fields,
 449             ))
 450         });
 451         let data_race = config.data_race_detector.then(|| data_race::GlobalState::new(config));
 452         MiriMachine {
 453             tcx: layout_cx.tcx,
 454             stacked_borrows,
 455             data_race,
 456             intptrcast: RefCell::new(intptrcast::GlobalStateInner::new(config)),
 457             // `env_vars` depends on a full interpreter so we cannot properly initialize it yet.
 458             env_vars: EnvVars::default(),
 459             argc: None,
 460             argv: None,
 461             cmd_line: None,
 462             tls: TlsData::default(),
 463             isolated_op: config.isolated_op,
 464             validate: config.validate,
 465             enforce_abi: config.check_abi,
 466             file_handler: FileHandler::new(config.mute_stdout_stderr),
 467             dir_handler: Default::default(),
 468             layouts,
 469             threads: ThreadManager::default(),
 470             static_roots: Vec::new(),
 471             profiler,
 472             string_cache: Default::default(),
 473             exported_symbols_cache: FxHashMap::default(),
 474             panic_on_unsupported: config.panic_on_unsupported,
 475             backtrace_style: config.backtrace_style,
 476             local_crates,
 477             extern_statics: FxHashMap::default(),
 478             rng: RefCell::new(rng),
 479             tracked_alloc_ids: config.tracked_alloc_ids.clone(),
 480             check_alignment: config.check_alignment,
 481             cmpxchg_weak_failure_rate: config.cmpxchg_weak_failure_rate,
 482             mute_stdout_stderr: config.mute_stdout_stderr,
 483             weak_memory: config.weak_memory_emulation,
 484             preemption_rate: config.preemption_rate,
 485             report_progress: config.report_progress,
 486             basic_block_count: 0,
 487             clock: Clock::new(config.isolated_op == IsolatedOp::Allow),
 488             #[cfg(unix)]
 489             external_so_lib: config.external_so_file.as_ref().map(|lib_file_path| {
 490                 let target_triple = layout_cx.tcx.sess.opts.target_triple.triple();
 491                 // Check if host target == the session target.
 492                 if env!("TARGET") != target_triple {
 493                     panic!(
 494                         "calling external C functions in linked .so file requires host and target to be the same: host={}, target={}",
 495                         env!("TARGET"),
 496                         target_triple,
 497                     );
 498                 }
 499                 // Note: it is the user's responsibility to provide a correct SO file.
 500                 // WATCH OUT: If an invalid/incorrect SO file is specified, this can cause
 501                 // undefined behaviour in Miri itself!
 502                 (
 503                     unsafe {
 504                         libloading::Library::new(lib_file_path)
 505                             .expect("failed to read specified extern shared object file")
 506                     },
 507                     lib_file_path.clone(),
 508                 )
 509             }),
 510             gc_interval: config.gc_interval,
 511             since_gc: 0,
 512             num_cpus: config.num_cpus,
 513         }
 514     }
 515
 516     pub(crate) fn late_init(
 517         this: &mut MiriInterpCx<'mir, 'tcx>,
 518         config: &MiriConfig,
 519     ) -> InterpResult<'tcx> {
 520         EnvVars::init(this, config)?;
 521         MiriMachine::init_extern_statics(this)?;
 522         ThreadManager::init(this);
 523         Ok(())
 524     }
 525
 526     fn add_extern_static(
 527         this: &mut MiriInterpCx<'mir, 'tcx>,
 528         name: &str,
 529         ptr: Pointer<Option<Provenance>>,
 530     ) {
 531         // This got just allocated, so there definitely is a pointer here.
 532         let ptr = ptr.into_pointer_or_addr().unwrap();
 533         this.machine.extern_statics.try_insert(Symbol::intern(name), ptr).unwrap();
 534     }
 535
 536     fn alloc_extern_static(
 537         this: &mut MiriInterpCx<'mir, 'tcx>,
 538         name: &str,
 539         val: ImmTy<'tcx, Provenance>,
 540     ) -> InterpResult<'tcx> {
 541         let place = this.allocate(val.layout, MiriMemoryKind::ExternStatic.into())?;
 542         this.write_immediate(*val, &place.into())?;
 543         Self::add_extern_static(this, name, place.ptr);
 544         Ok(())
 545     }
 546
 547     /// Sets up the "extern statics" for this machine.
 548     fn init_extern_statics(this: &mut MiriInterpCx<'mir, 'tcx>) -> InterpResult<'tcx> {
 549         match this.tcx.sess.target.os.as_ref() {
 550             "linux" => {
 551                 // "environ"
 552                 Self::add_extern_static(
 553                     this,
 554                     "environ",
 555                     this.machine.env_vars.environ.unwrap().ptr,
 556                 );
 557                 // A couple zero-initialized pointer-sized extern statics.
 558                 // Most of them are for weak symbols, which we all set to null (indicating that the
 559                 // symbol is not supported, and triggering fallback code which ends up calling a
 560                 // syscall that we do support).
 561                 for name in &["__cxa_thread_atexit_impl", "getrandom", "statx", "__clock_gettime64"]
 562                 {
 563                     let val = ImmTy::from_int(0, this.machine.layouts.usize);
 564                     Self::alloc_extern_static(this, name, val)?;
 565                 }
 566             }
 567             "freebsd" => {
 568                 // "environ"
 569                 Self::add_extern_static(
 570                     this,
 571                     "environ",
 572                     this.machine.env_vars.environ.unwrap().ptr,
 573                 );
 574             }
 575             "android" => {
 576                 // "signal"
 577                 let layout = this.machine.layouts.const_raw_ptr;
 578                 let dlsym = Dlsym::from_str("signal".as_bytes(), &this.tcx.sess.target.os)?
 579                     .expect("`signal` must be an actual dlsym on android");
 580                 let ptr = this.create_fn_alloc_ptr(FnVal::Other(dlsym));
 581                 let val = ImmTy::from_scalar(Scalar::from_pointer(ptr, this), layout);
 582                 Self::alloc_extern_static(this, "signal", val)?;
 583                 // A couple zero-initialized pointer-sized extern statics.
 584                 // Most of them are for weak symbols, which we all set to null (indicating that the
 585                 // symbol is not supported, and triggering fallback code.)
 586                 for name in &["bsd_signal"] {
 587                     let val = ImmTy::from_int(0, this.machine.layouts.usize);
 588                     Self::alloc_extern_static(this, name, val)?;
 589                 }
 590             }
 591             "windows" => {
 592                 // "_tls_used"
 593                 // This is some obscure hack that is part of the Windows TLS story. It's a `u8`.
 594                 let val = ImmTy::from_int(0, this.machine.layouts.u8);
 595                 Self::alloc_extern_static(this, "_tls_used", val)?;
 596             }
 597             _ => {} // No "extern statics" supported on this target
 598         }
 599         Ok(())
 600     }
 601
 602     pub(crate) fn communicate(&self) -> bool {
 603         self.isolated_op == IsolatedOp::Allow
 604     }
 605
 606     /// Check whether the stack frame that this `FrameInfo` refers to is part of a local crate.
 607     pub(crate) fn is_local(&self, frame: &FrameInfo<'_>) -> bool {
 608         let def_id = frame.instance.def_id();
 609         def_id.is_local() || self.local_crates.contains(&def_id.krate)
 610     }
 611 }
 612
 613 impl VisitTags for MiriMachine<'_, '_> {
 614     fn visit_tags(&self, visit: &mut dyn FnMut(SbTag)) {
 615         #[rustfmt::skip]
 616         let MiriMachine {
 617             threads,
 618             tls,
 619             env_vars,
 620             argc,
 621             argv,
 622             cmd_line,
 623             extern_statics,
 624             dir_handler,
 625             stacked_borrows,
 626             data_race,
 627             intptrcast,
 628             file_handler,
 629             tcx: _,
 630             isolated_op: _,
 631             validate: _,
 632             enforce_abi: _,
 633             clock: _,
 634             layouts: _,
 635             static_roots: _,
 636             profiler: _,
 637             string_cache: _,
 638             exported_symbols_cache: _,
 639             panic_on_unsupported: _,
 640             backtrace_style: _,
 641             local_crates: _,
 642             rng: _,
 643             tracked_alloc_ids: _,
 644             check_alignment: _,
 645             cmpxchg_weak_failure_rate: _,
 646             mute_stdout_stderr: _,
 647             weak_memory: _,
 648             preemption_rate: _,
 649             report_progress: _,
 650             basic_block_count: _,
 651             #[cfg(unix)]
 652             external_so_lib: _,
 653             gc_interval: _,
 654             since_gc: _,
 655             num_cpus: _,
 656         } = self;
 657
 658         threads.visit_tags(visit);
 659         tls.visit_tags(visit);
 660         env_vars.visit_tags(visit);
 661         dir_handler.visit_tags(visit);
 662         file_handler.visit_tags(visit);
 663         data_race.visit_tags(visit);
 664         stacked_borrows.visit_tags(visit);
 665         intptrcast.visit_tags(visit);
 666         argc.visit_tags(visit);
 667         argv.visit_tags(visit);
 668         cmd_line.visit_tags(visit);
 669         for ptr in extern_statics.values() {
 670             ptr.visit_tags(visit);
 671         }
 672     }
 673 }
 674
 675 /// A rustc InterpCx for Miri.
 676 pub type MiriInterpCx<'mir, 'tcx> = InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>;
 677
 678 /// A little trait that's useful to be inherited by extension traits.
 679 pub trait MiriInterpCxExt<'mir, 'tcx> {
 680     fn eval_context_ref<'a>(&'a self) -> &'a MiriInterpCx<'mir, 'tcx>;
 681     fn eval_context_mut<'a>(&'a mut self) -> &'a mut MiriInterpCx<'mir, 'tcx>;
 682 }
 683 impl<'mir, 'tcx> MiriInterpCxExt<'mir, 'tcx> for MiriInterpCx<'mir, 'tcx> {
 684     #[inline(always)]
 685     fn eval_context_ref(&self) -> &MiriInterpCx<'mir, 'tcx> {
 686         self
 687     }
 688     #[inline(always)]
 689     fn eval_context_mut(&mut self) -> &mut MiriInterpCx<'mir, 'tcx> {
 690         self
 691     }
 692 }
 693
 694 /// Machine hook implementations.
 695 impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
 696     type MemoryKind = MiriMemoryKind;
 697     type ExtraFnVal = Dlsym;
 698
 699     type FrameExtra = FrameData<'tcx>;
 700     type AllocExtra = AllocExtra;
 701
 702     type Provenance = Provenance;
 703     type ProvenanceExtra = ProvenanceExtra;
 704
 705     type MemoryMap = MonoHashMap<
 706         AllocId,
 707         (MemoryKind<MiriMemoryKind>, Allocation<Provenance, Self::AllocExtra>),
 708     >;
 709
 710     const GLOBAL_KIND: Option<MiriMemoryKind> = Some(MiriMemoryKind::Global);
 711
 712     const PANIC_ON_ALLOC_FAIL: bool = false;
 713
 714     #[inline(always)]
 715     fn enforce_alignment(ecx: &MiriInterpCx<'mir, 'tcx>) -> bool {
 716         ecx.machine.check_alignment != AlignmentCheck::None
 717     }
 718
 719     #[inline(always)]
 720     fn use_addr_for_alignment_check(ecx: &MiriInterpCx<'mir, 'tcx>) -> bool {
 721         ecx.machine.check_alignment == AlignmentCheck::Int
 722     }
 723
 724     #[inline(always)]
 725     fn enforce_validity(ecx: &MiriInterpCx<'mir, 'tcx>) -> bool {
 726         ecx.machine.validate
 727     }
 728
 729     #[inline(always)]
 730     fn enforce_abi(ecx: &MiriInterpCx<'mir, 'tcx>) -> bool {
 731         ecx.machine.enforce_abi
 732     }
 733
 734     #[inline(always)]
 735     fn checked_binop_checks_overflow(ecx: &MiriInterpCx<'mir, 'tcx>) -> bool {
 736         ecx.tcx.sess.overflow_checks()
 737     }
 738
 739     #[inline(always)]
 740     fn find_mir_or_eval_fn(
 741         ecx: &mut MiriInterpCx<'mir, 'tcx>,
 742         instance: ty::Instance<'tcx>,
 743         abi: Abi,
 744         args: &[OpTy<'tcx, Provenance>],
 745         dest: &PlaceTy<'tcx, Provenance>,
 746         ret: Option<mir::BasicBlock>,
 747         unwind: StackPopUnwind,
 748     ) -> InterpResult<'tcx, Option<(&'mir mir::Body<'tcx>, ty::Instance<'tcx>)>> {
 749         ecx.find_mir_or_eval_fn(instance, abi, args, dest, ret, unwind)
 750     }
 751
 752     #[inline(always)]
 753     fn call_extra_fn(
 754         ecx: &mut MiriInterpCx<'mir, 'tcx>,
 755         fn_val: Dlsym,
 756         abi: Abi,
 757         args: &[OpTy<'tcx, Provenance>],
 758         dest: &PlaceTy<'tcx, Provenance>,
 759         ret: Option<mir::BasicBlock>,
 760         _unwind: StackPopUnwind,
 761     ) -> InterpResult<'tcx> {
 762         ecx.call_dlsym(fn_val, abi, args, dest, ret)
 763     }
 764
 765     #[inline(always)]
 766     fn call_intrinsic(
 767         ecx: &mut MiriInterpCx<'mir, 'tcx>,
 768         instance: ty::Instance<'tcx>,
 769         args: &[OpTy<'tcx, Provenance>],
 770         dest: &PlaceTy<'tcx, Provenance>,
 771         ret: Option<mir::BasicBlock>,
 772         unwind: StackPopUnwind,
 773     ) -> InterpResult<'tcx> {
 774         ecx.call_intrinsic(instance, args, dest, ret, unwind)
 775     }
 776
 777     #[inline(always)]
 778     fn assert_panic(
 779         ecx: &mut MiriInterpCx<'mir, 'tcx>,
 780         msg: &mir::AssertMessage<'tcx>,
 781         unwind: Option<mir::BasicBlock>,
 782     ) -> InterpResult<'tcx> {
 783         ecx.assert_panic(msg, unwind)
 784     }
 785
 786     #[inline(always)]
 787     fn abort(_ecx: &mut MiriInterpCx<'mir, 'tcx>, msg: String) -> InterpResult<'tcx, !> {
 788         throw_machine_stop!(TerminationInfo::Abort(msg))
 789     }
 790
 791     #[inline(always)]
 792     fn binary_ptr_op(
 793         ecx: &MiriInterpCx<'mir, 'tcx>,
 794         bin_op: mir::BinOp,
 795         left: &ImmTy<'tcx, Provenance>,
 796         right: &ImmTy<'tcx, Provenance>,
 797     ) -> InterpResult<'tcx, (Scalar<Provenance>, bool, Ty<'tcx>)> {
 798         ecx.binary_ptr_op(bin_op, left, right)
 799     }
 800
 801     fn thread_local_static_base_pointer(
 802         ecx: &mut MiriInterpCx<'mir, 'tcx>,
 803         def_id: DefId,
 804     ) -> InterpResult<'tcx, Pointer<Provenance>> {
 805         ecx.get_or_create_thread_local_alloc(def_id)
 806     }
 807
 808     fn extern_static_base_pointer(
 809         ecx: &MiriInterpCx<'mir, 'tcx>,
 810         def_id: DefId,
 811     ) -> InterpResult<'tcx, Pointer<Provenance>> {
 812         let link_name = ecx.item_link_name(def_id);
 813         if let Some(&ptr) = ecx.machine.extern_statics.get(&link_name) {
 814             // Various parts of the engine rely on `get_alloc_info` for size and alignment
 815             // information. That uses the type information of this static.
 816             // Make sure it matches the Miri allocation for this.
 817             let Provenance::Concrete { alloc_id, .. } = ptr.provenance else {
 818                 panic!("extern_statics cannot contain wildcards")
 819             };
 820             let (shim_size, shim_align, _kind) = ecx.get_alloc_info(alloc_id);
 821             let extern_decl_layout =
 822                 ecx.tcx.layout_of(ty::ParamEnv::empty().and(ecx.tcx.type_of(def_id))).unwrap();
 823             if extern_decl_layout.size != shim_size || extern_decl_layout.align.abi != shim_align {
 824                 throw_unsup_format!(
 825                     "`extern` static `{name}` from crate `{krate}` has been declared \
 826                     with a size of {decl_size} bytes and alignment of {decl_align} bytes, \
 827                     but Miri emulates it via an extern static shim \
 828                     with a size of {shim_size} bytes and alignment of {shim_align} bytes",
 829                     name = ecx.tcx.def_path_str(def_id),
 830                     krate = ecx.tcx.crate_name(def_id.krate),
 831                     decl_size = extern_decl_layout.size.bytes(),
 832                     decl_align = extern_decl_layout.align.abi.bytes(),
 833                     shim_size = shim_size.bytes(),
 834                     shim_align = shim_align.bytes(),
 835                 )
 836             }
 837             Ok(ptr)
 838         } else {
 839             throw_unsup_format!(
 840                 "`extern` static `{name}` from crate `{krate}` is not supported by Miri",
 841                 name = ecx.tcx.def_path_str(def_id),
 842                 krate = ecx.tcx.crate_name(def_id.krate),
 843             )
 844         }
 845     }
 846
 847     fn adjust_allocation<'b>(
 848         ecx: &MiriInterpCx<'mir, 'tcx>,
 849         id: AllocId,
 850         alloc: Cow<'b, Allocation>,
 851         kind: Option<MemoryKind<Self::MemoryKind>>,
 852     ) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance, Self::AllocExtra>>> {
 853         let kind = kind.expect("we set our STATIC_KIND so this cannot be None");
 854         if ecx.machine.tracked_alloc_ids.contains(&id) {
 855             ecx.emit_diagnostic(NonHaltingDiagnostic::CreatedAlloc(
 856                 id,
 857                 alloc.size(),
 858                 alloc.align,
 859                 kind,
 860             ));
 861         }
 862
 863         let alloc = alloc.into_owned();
 864         let stacks = ecx.machine.stacked_borrows.as_ref().map(|stacked_borrows| {
 865             Stacks::new_allocation(
 866                 id,
 867                 alloc.size(),
 868                 stacked_borrows,
 869                 kind,
 870                 ecx.machine.current_span(),
 871             )
 872         });
 873         let race_alloc = ecx.machine.data_race.as_ref().map(|data_race| {
 874             data_race::AllocExtra::new_allocation(
 875                 data_race,
 876                 &ecx.machine.threads,
 877                 alloc.size(),
 878                 kind,
 879             )
 880         });
 881         let buffer_alloc = ecx.machine.weak_memory.then(weak_memory::AllocExtra::new_allocation);
 882         let alloc: Allocation<Provenance, Self::AllocExtra> = alloc.adjust_from_tcx(
 883             &ecx.tcx,
 884             AllocExtra {
 885                 stacked_borrows: stacks.map(RefCell::new),
 886                 data_race: race_alloc,
 887                 weak_memory: buffer_alloc,
 888             },
 889             |ptr| ecx.global_base_pointer(ptr),
 890         )?;
 891         Ok(Cow::Owned(alloc))
 892     }
 893
 894     fn adjust_alloc_base_pointer(
 895         ecx: &MiriInterpCx<'mir, 'tcx>,
 896         ptr: Pointer<AllocId>,
 897     ) -> Pointer<Provenance> {
 898         if cfg!(debug_assertions) {
 899             // The machine promises to never call us on thread-local or extern statics.
 900             let alloc_id = ptr.provenance;
 901             match ecx.tcx.try_get_global_alloc(alloc_id) {
 902                 Some(GlobalAlloc::Static(def_id)) if ecx.tcx.is_thread_local_static(def_id) => {
 903                     panic!("adjust_alloc_base_pointer called on thread-local static")
 904                 }
 905                 Some(GlobalAlloc::Static(def_id)) if ecx.tcx.is_foreign_item(def_id) => {
 906                     panic!("adjust_alloc_base_pointer called on extern static")
 907                 }
 908                 _ => {}
 909             }
 910         }
 911         let absolute_addr = intptrcast::GlobalStateInner::rel_ptr_to_addr(ecx, ptr);
 912         let sb_tag = if let Some(stacked_borrows) = &ecx.machine.stacked_borrows {
 913             stacked_borrows.borrow_mut().base_ptr_tag(ptr.provenance, &ecx.machine)
 914         } else {
 915             // Value does not matter, SB is disabled
 916             SbTag::default()
 917         };
 918         Pointer::new(
 919             Provenance::Concrete { alloc_id: ptr.provenance, sb: sb_tag },
 920             Size::from_bytes(absolute_addr),
 921         )
 922     }
 923
 924     #[inline(always)]
 925     fn ptr_from_addr_cast(
 926         ecx: &MiriInterpCx<'mir, 'tcx>,
 927         addr: u64,
 928     ) -> InterpResult<'tcx, Pointer<Option<Self::Provenance>>> {
 929         intptrcast::GlobalStateInner::ptr_from_addr_cast(ecx, addr)
 930     }
 931
 932     fn expose_ptr(
 933         ecx: &mut InterpCx<'mir, 'tcx, Self>,
 934         ptr: Pointer<Self::Provenance>,
 935     ) -> InterpResult<'tcx> {
 936         match ptr.provenance {
 937             Provenance::Concrete { alloc_id, sb } =>
 938                 intptrcast::GlobalStateInner::expose_ptr(ecx, alloc_id, sb),
 939             Provenance::Wildcard => {
 940                 // No need to do anything for wildcard pointers as
 941                 // their provenances have already been previously exposed.
 942                 Ok(())
 943             }
 944         }
 945     }
 946
 947     /// Convert a pointer with provenance into an allocation-offset pair,
 948     /// or a `None` with an absolute address if that conversion is not possible.
 949     fn ptr_get_alloc(
 950         ecx: &MiriInterpCx<'mir, 'tcx>,
 951         ptr: Pointer<Self::Provenance>,
 952     ) -> Option<(AllocId, Size, Self::ProvenanceExtra)> {
 953         let rel = intptrcast::GlobalStateInner::abs_ptr_to_rel(ecx, ptr);
 954
 955         rel.map(|(alloc_id, size)| {
 956             let sb = match ptr.provenance {
 957                 Provenance::Concrete { sb, .. } => ProvenanceExtra::Concrete(sb),
 958                 Provenance::Wildcard => ProvenanceExtra::Wildcard,
 959             };
 960             (alloc_id, size, sb)
 961         })
 962     }
 963
 964     #[inline(always)]
 965     fn before_memory_read(
 966         _tcx: TyCtxt<'tcx>,
 967         machine: &Self,
 968         alloc_extra: &AllocExtra,
 969         (alloc_id, prov_extra): (AllocId, Self::ProvenanceExtra),
 970         range: AllocRange,
 971     ) -> InterpResult<'tcx> {
 972         if let Some(data_race) = &alloc_extra.data_race {
 973             data_race.read(
 974                 alloc_id,
 975                 range,
 976                 machine.data_race.as_ref().unwrap(),
 977                 &machine.threads,
 978             )?;
 979         }
 980         if let Some(stacked_borrows) = &alloc_extra.stacked_borrows {
 981             stacked_borrows.borrow_mut().before_memory_read(
 982                 alloc_id,
 983                 prov_extra,
 984                 range,
 985                 machine.stacked_borrows.as_ref().unwrap(),
 986                 machine.current_span(),
 987                 &machine.threads,
 988             )?;
 989         }
 990         if let Some(weak_memory) = &alloc_extra.weak_memory {
 991             weak_memory.memory_accessed(range, machine.data_race.as_ref().unwrap());
 992         }
 993         Ok(())
 994     }
 995
 996     #[inline(always)]
 997     fn before_memory_write(
 998         _tcx: TyCtxt<'tcx>,
 999         machine: &mut Self,
1000         alloc_extra: &mut AllocExtra,
1001         (alloc_id, prov_extra): (AllocId, Self::ProvenanceExtra),
1002         range: AllocRange,
1003     ) -> InterpResult<'tcx> {
1004         if let Some(data_race) = &mut alloc_extra.data_race {
1005             data_race.write(
1006                 alloc_id,
1007                 range,
1008                 machine.data_race.as_mut().unwrap(),
1009                 &machine.threads,
1010             )?;
1011         }
1012         if let Some(stacked_borrows) = &mut alloc_extra.stacked_borrows {
1013             stacked_borrows.get_mut().before_memory_write(
1014                 alloc_id,
1015                 prov_extra,
1016                 range,
1017                 machine.stacked_borrows.as_ref().unwrap(),
1018                 machine.current_span(),
1019                 &machine.threads,
1020             )?;
1021         }
1022         if let Some(weak_memory) = &alloc_extra.weak_memory {
1023             weak_memory.memory_accessed(range, machine.data_race.as_ref().unwrap());
1024         }
1025         Ok(())
1026     }
1027
1028     #[inline(always)]
1029     fn before_memory_deallocation(
1030         _tcx: TyCtxt<'tcx>,
1031         machine: &mut Self,
1032         alloc_extra: &mut AllocExtra,
1033         (alloc_id, prove_extra): (AllocId, Self::ProvenanceExtra),
1034         range: AllocRange,
1035     ) -> InterpResult<'tcx> {
1036         if machine.tracked_alloc_ids.contains(&alloc_id) {
1037             machine.emit_diagnostic(NonHaltingDiagnostic::FreedAlloc(alloc_id));
1038         }
1039         if let Some(data_race) = &mut alloc_extra.data_race {
1040             data_race.deallocate(
1041                 alloc_id,
1042                 range,
1043                 machine.data_race.as_mut().unwrap(),
1044                 &machine.threads,
1045             )?;
1046         }
1047         if let Some(stacked_borrows) = &mut alloc_extra.stacked_borrows {
1048             stacked_borrows.get_mut().before_memory_deallocation(
1049                 alloc_id,
1050                 prove_extra,
1051                 range,
1052                 machine.stacked_borrows.as_ref().unwrap(),
1053                 machine.current_span(),
1054                 &machine.threads,
1055             )
1056         } else {
1057             Ok(())
1058         }
1059     }
1060
1061     #[inline(always)]
1062     fn retag(
1063         ecx: &mut InterpCx<'mir, 'tcx, Self>,
1064         kind: mir::RetagKind,
1065         place: &PlaceTy<'tcx, Provenance>,
1066     ) -> InterpResult<'tcx> {
1067         if ecx.machine.stacked_borrows.is_some() { ecx.retag(kind, place) } else { Ok(()) }
1068     }
1069
1070     #[inline(always)]
1071     fn init_frame_extra(
1072         ecx: &mut InterpCx<'mir, 'tcx, Self>,
1073         frame: Frame<'mir, 'tcx, Provenance>,
1074     ) -> InterpResult<'tcx, Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>> {
1075         // Start recording our event before doing anything else
1076         let timing = if let Some(profiler) = ecx.machine.profiler.as_ref() {
1077             let fn_name = frame.instance.to_string();
1078             let entry = ecx.machine.string_cache.entry(fn_name.clone());
1079             let name = entry.or_insert_with(|| profiler.alloc_string(&*fn_name));
1080
1081             Some(profiler.start_recording_interval_event_detached(
1082                 *name,
1083                 measureme::EventId::from_label(*name),
1084                 ecx.get_active_thread().to_u32(),
1085             ))
1086         } else {
1087             None
1088         };
1089
1090         let stacked_borrows = ecx.machine.stacked_borrows.as_ref();
1091
1092         let extra = FrameData {
1093             stacked_borrows: stacked_borrows.map(|sb| sb.borrow_mut().new_frame(&ecx.machine)),
1094             catch_unwind: None,
1095             timing,
1096         };
1097         Ok(frame.with_extra(extra))
1098     }
1099
1100     fn stack<'a>(
1101         ecx: &'a InterpCx<'mir, 'tcx, Self>,
1102     ) -> &'a [Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>] {
1103         ecx.active_thread_stack()
1104     }
1105
1106     fn stack_mut<'a>(
1107         ecx: &'a mut InterpCx<'mir, 'tcx, Self>,
1108     ) -> &'a mut Vec<Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>> {
1109         ecx.active_thread_stack_mut()
1110     }
1111
1112     fn before_terminator(ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> {
1113         ecx.machine.basic_block_count += 1u64; // a u64 that is only incremented by 1 will "never" overflow
1114         ecx.machine.since_gc += 1;
1115         // Possibly report our progress.
1116         if let Some(report_progress) = ecx.machine.report_progress {
1117             if ecx.machine.basic_block_count % u64::from(report_progress) == 0 {
1118                 ecx.emit_diagnostic(NonHaltingDiagnostic::ProgressReport {
1119                     block_count: ecx.machine.basic_block_count,
1120                 });
1121             }
1122         }
1123
1124         // Search for SbTags to find all live pointers, then remove all other tags from borrow
1125         // stacks.
1126         // When debug assertions are enabled, run the GC as often as possible so that any cases
1127         // where it mistakenly removes an important tag become visible.
1128         if ecx.machine.gc_interval > 0 && ecx.machine.since_gc >= ecx.machine.gc_interval {
1129             ecx.machine.since_gc = 0;
1130             ecx.garbage_collect_tags()?;
1131         }
1132
1133         // These are our preemption points.
1134         ecx.maybe_preempt_active_thread();
1135
1136         // Make sure some time passes.
1137         ecx.machine.clock.tick();
1138
1139         Ok(())
1140     }
1141
1142     #[inline(always)]
1143     fn after_stack_push(ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> {
1144         if ecx.machine.stacked_borrows.is_some() { ecx.retag_return_place() } else { Ok(()) }
1145     }
1146
1147     #[inline(always)]
1148     fn after_stack_pop(
1149         ecx: &mut InterpCx<'mir, 'tcx, Self>,
1150         mut frame: Frame<'mir, 'tcx, Provenance, FrameData<'tcx>>,
1151         unwinding: bool,
1152     ) -> InterpResult<'tcx, StackPopJump> {
1153         let timing = frame.extra.timing.take();
1154         if let Some(stacked_borrows) = &ecx.machine.stacked_borrows {
1155             stacked_borrows.borrow_mut().end_call(&frame.extra);
1156         }
1157         let res = ecx.handle_stack_pop_unwind(frame.extra, unwinding);
1158         if let Some(profiler) = ecx.machine.profiler.as_ref() {
1159             profiler.finish_recording_interval_event(timing.unwrap());
1160         }
1161         res
1162     }
1163 }