rustc_const_eval/interpret/
stack.rs

1//! Manages the low-level pushing and popping of stack frames and the (de)allocation of local variables.
2//! For handling of argument passing and return values, see the `call` module.
3use std::cell::Cell;
4use std::{fmt, mem};
5
6use either::{Either, Left, Right};
7use rustc_hir as hir;
8use rustc_hir::definitions::DefPathData;
9use rustc_index::IndexVec;
10use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
11use rustc_middle::ty::{self, Ty, TyCtxt};
12use rustc_middle::{bug, mir};
13use rustc_mir_dataflow::impls::always_storage_live_locals;
14use rustc_span::Span;
15use tracing::{info_span, instrument, trace};
16
17use super::{
18    AllocId, CtfeProvenance, Immediate, InterpCx, InterpResult, MPlaceTy, Machine, MemPlace,
19    MemPlaceMeta, MemoryKind, Operand, Pointer, Provenance, ReturnAction, Scalar,
20    from_known_layout, interp_ok, throw_ub, throw_unsup,
21};
22use crate::errors;
23
24// The Phantomdata exists to prevent this type from being `Send`. If it were sent across a thread
25// boundary and dropped in the other thread, it would exit the span in the other thread.
26struct SpanGuard(tracing::Span, std::marker::PhantomData<*const u8>);
27
28impl SpanGuard {
29    /// By default a `SpanGuard` does nothing.
30    fn new() -> Self {
31        Self(tracing::Span::none(), std::marker::PhantomData)
32    }
33
34    /// If a span is entered, we exit the previous span (if any, normally none) and enter the
35    /// new span. This is mainly so we don't have to use `Option` for the `tracing_span` field of
36    /// `Frame` by creating a dummy span to being with and then entering it once the frame has
37    /// been pushed.
38    fn enter(&mut self, span: tracing::Span) {
39        // This executes the destructor on the previous instance of `SpanGuard`, ensuring that
40        // we never enter or exit more spans than vice versa. Unless you `mem::leak`, then we
41        // can't protect the tracing stack, but that'll just lead to weird logging, no actual
42        // problems.
43        *self = Self(span, std::marker::PhantomData);
44        self.0.with_subscriber(|(id, dispatch)| {
45            dispatch.enter(id);
46        });
47    }
48}
49
50impl Drop for SpanGuard {
51    fn drop(&mut self) {
52        self.0.with_subscriber(|(id, dispatch)| {
53            dispatch.exit(id);
54        });
55    }
56}
57
58/// A stack frame.
59pub struct Frame<'tcx, Prov: Provenance = CtfeProvenance, Extra = ()> {
60    ////////////////////////////////////////////////////////////////////////////////
61    // Function and callsite information
62    ////////////////////////////////////////////////////////////////////////////////
63    /// The MIR for the function called on this frame.
64    pub(super) body: &'tcx mir::Body<'tcx>,
65
66    /// The def_id and args of the current function.
67    pub(super) instance: ty::Instance<'tcx>,
68
69    /// Extra data for the machine.
70    pub extra: Extra,
71
72    ////////////////////////////////////////////////////////////////////////////////
73    // Return place and locals
74    ////////////////////////////////////////////////////////////////////////////////
75    /// Work to perform when returning from this function.
76    return_to_block: StackPopCleanup,
77
78    /// The location where the result of the current stack frame should be written to,
79    /// and its layout in the caller.
80    pub return_place: MPlaceTy<'tcx, Prov>,
81
82    /// The list of locals for this stack frame, stored in order as
83    /// `[return_ptr, arguments..., variables..., temporaries...]`.
84    /// The locals are stored as `Option<Value>`s.
85    /// `None` represents a local that is currently dead, while a live local
86    /// can either directly contain `Scalar` or refer to some part of an `Allocation`.
87    ///
88    /// Do *not* access this directly; always go through the machine hook!
89    pub locals: IndexVec<mir::Local, LocalState<'tcx, Prov>>,
90
91    /// The span of the `tracing` crate is stored here.
92    /// When the guard is dropped, the span is exited. This gives us
93    /// a full stack trace on all tracing statements.
94    tracing_span: SpanGuard,
95
96    ////////////////////////////////////////////////////////////////////////////////
97    // Current position within the function
98    ////////////////////////////////////////////////////////////////////////////////
99    /// If this is `Right`, we are not currently executing any particular statement in
100    /// this frame (can happen e.g. during frame initialization, and during unwinding on
101    /// frames without cleanup code).
102    ///
103    /// Needs to be public because ConstProp does unspeakable things to it.
104    pub(super) loc: Either<mir::Location, Span>,
105}
106
107#[derive(Clone, Copy, Eq, PartialEq, Debug)] // Miri debug-prints these
108pub enum StackPopCleanup {
109    /// Jump to the next block in the caller, or cause UB if None (that's a function
110    /// that may never return). Also store layout of return place so
111    /// we can validate it at that layout.
112    /// `ret` stores the block we jump to on a normal return, while `unwind`
113    /// stores the block used for cleanup during unwinding.
114    Goto { ret: Option<mir::BasicBlock>, unwind: mir::UnwindAction },
115    /// The root frame of the stack: nowhere else to jump to.
116    /// `cleanup` says whether locals are deallocated. Static computation
117    /// wants them leaked to intern what they need (and just throw away
118    /// the entire `ecx` when it is done).
119    Root { cleanup: bool },
120}
121
122/// Return type of [`InterpCx::pop_stack_frame_raw`].
123pub struct StackPopInfo<'tcx, Prov: Provenance> {
124    /// Additional information about the action to be performed when returning from the popped
125    /// stack frame.
126    pub return_action: ReturnAction,
127
128    /// [`return_to_block`](Frame::return_to_block) of the popped stack frame.
129    pub return_to_block: StackPopCleanup,
130
131    /// [`return_place`](Frame::return_place) of the popped stack frame.
132    pub return_place: MPlaceTy<'tcx, Prov>,
133}
134
135/// State of a local variable including a memoized layout
136#[derive(Clone)]
137pub struct LocalState<'tcx, Prov: Provenance = CtfeProvenance> {
138    value: LocalValue<Prov>,
139    /// Don't modify if `Some`, this is only used to prevent computing the layout twice.
140    /// Avoids computing the layout of locals that are never actually initialized.
141    layout: Cell<Option<TyAndLayout<'tcx>>>,
142}
143
144impl<Prov: Provenance> std::fmt::Debug for LocalState<'_, Prov> {
145    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
146        f.debug_struct("LocalState")
147            .field("value", &self.value)
148            .field("ty", &self.layout.get().map(|l| l.ty))
149            .finish()
150    }
151}
152
153/// Current value of a local variable
154///
155/// This does not store the type of the local; the type is given by `body.local_decls` and can never
156/// change, so by not storing here we avoid having to maintain that as an invariant.
157#[derive(Copy, Clone, Debug)] // Miri debug-prints these
158pub(super) enum LocalValue<Prov: Provenance = CtfeProvenance> {
159    /// This local is not currently alive, and cannot be used at all.
160    Dead,
161    /// A normal, live local.
162    /// Mostly for convenience, we re-use the `Operand` type here.
163    /// This is an optimization over just always having a pointer here;
164    /// we can thus avoid doing an allocation when the local just stores
165    /// immediate values *and* never has its address taken.
166    Live(Operand<Prov>),
167}
168
169impl<'tcx, Prov: Provenance> LocalState<'tcx, Prov> {
170    pub fn make_live_uninit(&mut self) {
171        self.value = LocalValue::Live(Operand::Immediate(Immediate::Uninit));
172    }
173
174    /// This is a hack because Miri needs a way to visit all the provenance in a `LocalState`
175    /// without having a layout or `TyCtxt` available, and we want to keep the `Operand` type
176    /// private.
177    pub fn as_mplace_or_imm(
178        &self,
179    ) -> Option<Either<(Pointer<Option<Prov>>, MemPlaceMeta<Prov>), Immediate<Prov>>> {
180        match self.value {
181            LocalValue::Dead => None,
182            LocalValue::Live(Operand::Indirect(mplace)) => Some(Left((mplace.ptr, mplace.meta))),
183            LocalValue::Live(Operand::Immediate(imm)) => Some(Right(imm)),
184        }
185    }
186
187    /// Read the local's value or error if the local is not yet live or not live anymore.
188    #[inline(always)]
189    pub(super) fn access(&self) -> InterpResult<'tcx, &Operand<Prov>> {
190        match &self.value {
191            LocalValue::Dead => throw_ub!(DeadLocal), // could even be "invalid program"?
192            LocalValue::Live(val) => interp_ok(val),
193        }
194    }
195
196    /// Overwrite the local. If the local can be overwritten in place, return a reference
197    /// to do so; otherwise return the `MemPlace` to consult instead.
198    #[inline(always)]
199    pub(super) fn access_mut(&mut self) -> InterpResult<'tcx, &mut Operand<Prov>> {
200        match &mut self.value {
201            LocalValue::Dead => throw_ub!(DeadLocal), // could even be "invalid program"?
202            LocalValue::Live(val) => interp_ok(val),
203        }
204    }
205}
206
207/// What we store about a frame in an interpreter backtrace.
208#[derive(Clone, Debug)]
209pub struct FrameInfo<'tcx> {
210    pub instance: ty::Instance<'tcx>,
211    pub span: Span,
212}
213
214// FIXME: only used by miri, should be removed once translatable.
215impl<'tcx> fmt::Display for FrameInfo<'tcx> {
216    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
217        ty::tls::with(|tcx| {
218            if tcx.def_key(self.instance.def_id()).disambiguated_data.data == DefPathData::Closure {
219                write!(f, "inside closure")
220            } else {
221                // Note: this triggers a `must_produce_diag` state, which means that if we ever
222                // get here we must emit a diagnostic. We should never display a `FrameInfo` unless
223                // we actually want to emit a warning or error to the user.
224                write!(f, "inside `{}`", self.instance)
225            }
226        })
227    }
228}
229
230impl<'tcx> FrameInfo<'tcx> {
231    pub fn as_note(&self, tcx: TyCtxt<'tcx>) -> errors::FrameNote {
232        let span = self.span;
233        if tcx.def_key(self.instance.def_id()).disambiguated_data.data == DefPathData::Closure {
234            errors::FrameNote { where_: "closure", span, instance: String::new(), times: 0 }
235        } else {
236            let instance = format!("{}", self.instance);
237            // Note: this triggers a `must_produce_diag` state, which means that if we ever get
238            // here we must emit a diagnostic. We should never display a `FrameInfo` unless we
239            // actually want to emit a warning or error to the user.
240            errors::FrameNote { where_: "instance", span, instance, times: 0 }
241        }
242    }
243}
244
245impl<'tcx, Prov: Provenance> Frame<'tcx, Prov> {
246    pub fn with_extra<Extra>(self, extra: Extra) -> Frame<'tcx, Prov, Extra> {
247        Frame {
248            body: self.body,
249            instance: self.instance,
250            return_to_block: self.return_to_block,
251            return_place: self.return_place,
252            locals: self.locals,
253            loc: self.loc,
254            extra,
255            tracing_span: self.tracing_span,
256        }
257    }
258}
259
260impl<'tcx, Prov: Provenance, Extra> Frame<'tcx, Prov, Extra> {
261    /// Get the current location within the Frame.
262    ///
263    /// If this is `Right`, we are not currently executing any particular statement in
264    /// this frame (can happen e.g. during frame initialization, and during unwinding on
265    /// frames without cleanup code).
266    ///
267    /// Used by [priroda](https://github.com/oli-obk/priroda).
268    pub fn current_loc(&self) -> Either<mir::Location, Span> {
269        self.loc
270    }
271
272    pub fn body(&self) -> &'tcx mir::Body<'tcx> {
273        self.body
274    }
275
276    pub fn instance(&self) -> ty::Instance<'tcx> {
277        self.instance
278    }
279
280    /// Return the `SourceInfo` of the current instruction.
281    pub fn current_source_info(&self) -> Option<&mir::SourceInfo> {
282        self.loc.left().map(|loc| self.body.source_info(loc))
283    }
284
285    pub fn current_span(&self) -> Span {
286        match self.loc {
287            Left(loc) => self.body.source_info(loc).span,
288            Right(span) => span,
289        }
290    }
291
292    pub fn lint_root(&self, tcx: TyCtxt<'tcx>) -> Option<hir::HirId> {
293        // We first try to get a HirId via the current source scope,
294        // and fall back to `body.source`.
295        self.current_source_info()
296            .and_then(|source_info| match &self.body.source_scopes[source_info.scope].local_data {
297                mir::ClearCrossCrate::Set(data) => Some(data.lint_root),
298                mir::ClearCrossCrate::Clear => None,
299            })
300            .or_else(|| {
301                let def_id = self.body.source.def_id().as_local();
302                def_id.map(|def_id| tcx.local_def_id_to_hir_id(def_id))
303            })
304    }
305
306    /// Returns the address of the buffer where the locals are stored. This is used by `Place` as a
307    /// sanity check to detect bugs where we mix up which stack frame a place refers to.
308    #[inline(always)]
309    pub(super) fn locals_addr(&self) -> usize {
310        self.locals.raw.as_ptr().addr()
311    }
312
313    #[must_use]
314    pub fn generate_stacktrace_from_stack(stack: &[Self]) -> Vec<FrameInfo<'tcx>> {
315        let mut frames = Vec::new();
316        // This deliberately does *not* honor `requires_caller_location` since it is used for much
317        // more than just panics.
318        for frame in stack.iter().rev() {
319            let span = match frame.loc {
320                Left(loc) => {
321                    // If the stacktrace passes through MIR-inlined source scopes, add them.
322                    let mir::SourceInfo { mut span, scope } = *frame.body.source_info(loc);
323                    let mut scope_data = &frame.body.source_scopes[scope];
324                    while let Some((instance, call_span)) = scope_data.inlined {
325                        frames.push(FrameInfo { span, instance });
326                        span = call_span;
327                        scope_data = &frame.body.source_scopes[scope_data.parent_scope.unwrap()];
328                    }
329                    span
330                }
331                Right(span) => span,
332            };
333            frames.push(FrameInfo { span, instance: frame.instance });
334        }
335        trace!("generate stacktrace: {:#?}", frames);
336        frames
337    }
338}
339
340impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
341    /// Very low-level helper that pushes a stack frame without initializing
342    /// the arguments or local variables.
343    ///
344    /// The high-level version of this is `init_stack_frame`.
345    #[instrument(skip(self, body, return_place, return_to_block), level = "debug")]
346    pub(crate) fn push_stack_frame_raw(
347        &mut self,
348        instance: ty::Instance<'tcx>,
349        body: &'tcx mir::Body<'tcx>,
350        return_place: &MPlaceTy<'tcx, M::Provenance>,
351        return_to_block: StackPopCleanup,
352    ) -> InterpResult<'tcx> {
353        trace!("body: {:#?}", body);
354
355        // We can push a `Root` frame if and only if the stack is empty.
356        debug_assert_eq!(
357            self.stack().is_empty(),
358            matches!(return_to_block, StackPopCleanup::Root { .. })
359        );
360
361        // First push a stack frame so we have access to `instantiate_from_current_frame` and other
362        // `self.frame()`-based functions.
363        let dead_local = LocalState { value: LocalValue::Dead, layout: Cell::new(None) };
364        let locals = IndexVec::from_elem(dead_local, &body.local_decls);
365        let pre_frame = Frame {
366            body,
367            loc: Right(body.span), // Span used for errors caused during preamble.
368            return_to_block,
369            return_place: return_place.clone(),
370            locals,
371            instance,
372            tracing_span: SpanGuard::new(),
373            extra: (),
374        };
375        let frame = M::init_frame(self, pre_frame)?;
376        self.stack_mut().push(frame);
377
378        // Make sure all the constants required by this frame evaluate successfully (post-monomorphization check).
379        for &const_ in body.required_consts() {
380            let c =
381                self.instantiate_from_current_frame_and_normalize_erasing_regions(const_.const_)?;
382            c.eval(*self.tcx, self.typing_env, const_.span).map_err(|err| {
383                err.emit_note(*self.tcx);
384                err
385            })?;
386        }
387
388        // Finish things up.
389        M::after_stack_push(self)?;
390        self.frame_mut().loc = Left(mir::Location::START);
391        let span = info_span!("frame", "{}", instance);
392        self.frame_mut().tracing_span.enter(span);
393
394        interp_ok(())
395    }
396
397    /// Low-level helper that pops a stack frame from the stack and returns some information about
398    /// it.
399    ///
400    /// This also deallocates locals, if necessary.
401    ///
402    /// [`M::before_stack_pop`] should be called before calling this function.
403    /// [`M::after_stack_pop`] is called by this function automatically.
404    ///
405    /// The high-level version of this is `return_from_current_stack_frame`.
406    ///
407    /// [`M::before_stack_pop`]: Machine::before_stack_pop
408    /// [`M::after_stack_pop`]: Machine::after_stack_pop
409    pub(super) fn pop_stack_frame_raw(
410        &mut self,
411        unwinding: bool,
412    ) -> InterpResult<'tcx, StackPopInfo<'tcx, M::Provenance>> {
413        let cleanup = self.cleanup_current_frame_locals()?;
414
415        let frame =
416            self.stack_mut().pop().expect("tried to pop a stack frame, but there were none");
417
418        let return_to_block = frame.return_to_block;
419        let return_place = frame.return_place.clone();
420
421        let return_action;
422        if cleanup {
423            return_action = M::after_stack_pop(self, frame, unwinding)?;
424            assert_ne!(return_action, ReturnAction::NoCleanup);
425        } else {
426            return_action = ReturnAction::NoCleanup;
427        };
428
429        interp_ok(StackPopInfo { return_action, return_to_block, return_place })
430    }
431
432    /// A private helper for [`pop_stack_frame_raw`](InterpCx::pop_stack_frame_raw).
433    /// Returns `true` if cleanup has been done, `false` otherwise.
434    fn cleanup_current_frame_locals(&mut self) -> InterpResult<'tcx, bool> {
435        // Cleanup: deallocate locals.
436        // Usually we want to clean up (deallocate locals), but in a few rare cases we don't.
437        // We do this while the frame is still on the stack, so errors point to the callee.
438        let return_to_block = self.frame().return_to_block;
439        let cleanup = match return_to_block {
440            StackPopCleanup::Goto { .. } => true,
441            StackPopCleanup::Root { cleanup, .. } => cleanup,
442        };
443
444        if cleanup {
445            // We need to take the locals out, since we need to mutate while iterating.
446            let locals = mem::take(&mut self.frame_mut().locals);
447            for local in &locals {
448                self.deallocate_local(local.value)?;
449            }
450        }
451
452        interp_ok(cleanup)
453    }
454
455    /// In the current stack frame, mark all locals as live that are not arguments and don't have
456    /// `Storage*` annotations (this includes the return place).
457    pub(crate) fn storage_live_for_always_live_locals(&mut self) -> InterpResult<'tcx> {
458        self.storage_live(mir::RETURN_PLACE)?;
459
460        let body = self.body();
461        let always_live = always_storage_live_locals(body);
462        for local in body.vars_and_temps_iter() {
463            if always_live.contains(local) {
464                self.storage_live(local)?;
465            }
466        }
467        interp_ok(())
468    }
469
470    pub fn storage_live_dyn(
471        &mut self,
472        local: mir::Local,
473        meta: MemPlaceMeta<M::Provenance>,
474    ) -> InterpResult<'tcx> {
475        trace!("{:?} is now live", local);
476
477        // We avoid `ty.is_trivially_sized` since that does something expensive for ADTs.
478        fn is_very_trivially_sized(ty: Ty<'_>) -> bool {
479            match ty.kind() {
480                ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
481                | ty::Uint(_)
482                | ty::Int(_)
483                | ty::Bool
484                | ty::Float(_)
485                | ty::FnDef(..)
486                | ty::FnPtr(..)
487                | ty::RawPtr(..)
488                | ty::Char
489                | ty::Ref(..)
490                | ty::Coroutine(..)
491                | ty::CoroutineWitness(..)
492                | ty::Array(..)
493                | ty::Closure(..)
494                | ty::CoroutineClosure(..)
495                | ty::Never
496                | ty::Error(_)
497                | ty::Dynamic(_, _, ty::DynStar) => true,
498
499                ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => false,
500
501                ty::Tuple(tys) => tys.last().is_none_or(|ty| is_very_trivially_sized(*ty)),
502
503                ty::Pat(ty, ..) => is_very_trivially_sized(*ty),
504
505                // We don't want to do any queries, so there is not much we can do with ADTs.
506                ty::Adt(..) => false,
507
508                ty::UnsafeBinder(ty) => is_very_trivially_sized(ty.skip_binder()),
509
510                ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) => false,
511
512                ty::Infer(ty::TyVar(_)) => false,
513
514                ty::Bound(..)
515                | ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
516                    bug!("`is_very_trivially_sized` applied to unexpected type: {}", ty)
517                }
518            }
519        }
520
521        // This is a hot function, we avoid computing the layout when possible.
522        // `unsized_` will be `None` for sized types and `Some(layout)` for unsized types.
523        let unsized_ = if is_very_trivially_sized(self.body().local_decls[local].ty) {
524            None
525        } else {
526            // We need the layout.
527            let layout = self.layout_of_local(self.frame(), local, None)?;
528            if layout.is_sized() { None } else { Some(layout) }
529        };
530
531        let local_val = LocalValue::Live(if let Some(layout) = unsized_ {
532            if !meta.has_meta() {
533                throw_unsup!(UnsizedLocal);
534            }
535            // Need to allocate some memory, since `Immediate::Uninit` cannot be unsized.
536            let dest_place = self.allocate_dyn(layout, MemoryKind::Stack, meta)?;
537            Operand::Indirect(*dest_place.mplace())
538        } else {
539            // Just make this an efficient immediate.
540            assert!(!meta.has_meta()); // we're dropping the metadata
541            // Make sure the machine knows this "write" is happening. (This is important so that
542            // races involving local variable allocation can be detected by Miri.)
543            M::after_local_write(self, local, /*storage_live*/ true)?;
544            // Note that not calling `layout_of` here does have one real consequence:
545            // if the type is too big, we'll only notice this when the local is actually initialized,
546            // which is a bit too late -- we should ideally notice this already here, when the memory
547            // is conceptually allocated. But given how rare that error is and that this is a hot function,
548            // we accept this downside for now.
549            Operand::Immediate(Immediate::Uninit)
550        });
551
552        // If the local is already live, deallocate its old memory.
553        let old = mem::replace(&mut self.frame_mut().locals[local].value, local_val);
554        self.deallocate_local(old)?;
555        interp_ok(())
556    }
557
558    /// Mark a storage as live, killing the previous content.
559    #[inline(always)]
560    pub fn storage_live(&mut self, local: mir::Local) -> InterpResult<'tcx> {
561        self.storage_live_dyn(local, MemPlaceMeta::None)
562    }
563
564    pub fn storage_dead(&mut self, local: mir::Local) -> InterpResult<'tcx> {
565        assert!(local != mir::RETURN_PLACE, "Cannot make return place dead");
566        trace!("{:?} is now dead", local);
567
568        // If the local is already dead, this is a NOP.
569        let old = mem::replace(&mut self.frame_mut().locals[local].value, LocalValue::Dead);
570        self.deallocate_local(old)?;
571        interp_ok(())
572    }
573
574    fn deallocate_local(&mut self, local: LocalValue<M::Provenance>) -> InterpResult<'tcx> {
575        if let LocalValue::Live(Operand::Indirect(MemPlace { ptr, .. })) = local {
576            // All locals have a backing allocation, even if the allocation is empty
577            // due to the local having ZST type. Hence we can `unwrap`.
578            trace!(
579                "deallocating local {:?}: {:?}",
580                local,
581                // Locals always have a `alloc_id` (they are never the result of a int2ptr).
582                self.dump_alloc(ptr.provenance.unwrap().get_alloc_id().unwrap())
583            );
584            self.deallocate_ptr(ptr, None, MemoryKind::Stack)?;
585        };
586        interp_ok(())
587    }
588
589    /// This is public because it is used by [Aquascope](https://github.com/cognitive-engineering-lab/aquascope/)
590    /// to analyze all the locals in a stack frame.
591    #[inline(always)]
592    pub fn layout_of_local(
593        &self,
594        frame: &Frame<'tcx, M::Provenance, M::FrameExtra>,
595        local: mir::Local,
596        layout: Option<TyAndLayout<'tcx>>,
597    ) -> InterpResult<'tcx, TyAndLayout<'tcx>> {
598        let state = &frame.locals[local];
599        if let Some(layout) = state.layout.get() {
600            return interp_ok(layout);
601        }
602
603        let layout = from_known_layout(self.tcx, self.typing_env, layout, || {
604            let local_ty = frame.body.local_decls[local].ty;
605            let local_ty =
606                self.instantiate_from_frame_and_normalize_erasing_regions(frame, local_ty)?;
607            self.layout_of(local_ty).into()
608        })?;
609
610        // Layouts of locals are requested a lot, so we cache them.
611        state.layout.set(Some(layout));
612        interp_ok(layout)
613    }
614}
615
616impl<'tcx, Prov: Provenance> LocalState<'tcx, Prov> {
617    pub(super) fn print(
618        &self,
619        allocs: &mut Vec<Option<AllocId>>,
620        fmt: &mut std::fmt::Formatter<'_>,
621    ) -> std::fmt::Result {
622        match self.value {
623            LocalValue::Dead => write!(fmt, " is dead")?,
624            LocalValue::Live(Operand::Immediate(Immediate::Uninit)) => {
625                write!(fmt, " is uninitialized")?
626            }
627            LocalValue::Live(Operand::Indirect(mplace)) => {
628                write!(
629                    fmt,
630                    " by {} ref {:?}:",
631                    match mplace.meta {
632                        MemPlaceMeta::Meta(meta) => format!(" meta({meta:?})"),
633                        MemPlaceMeta::None => String::new(),
634                    },
635                    mplace.ptr,
636                )?;
637                allocs.extend(mplace.ptr.provenance.map(Provenance::get_alloc_id));
638            }
639            LocalValue::Live(Operand::Immediate(Immediate::Scalar(val))) => {
640                write!(fmt, " {val:?}")?;
641                if let Scalar::Ptr(ptr, _size) = val {
642                    allocs.push(ptr.provenance.get_alloc_id());
643                }
644            }
645            LocalValue::Live(Operand::Immediate(Immediate::ScalarPair(val1, val2))) => {
646                write!(fmt, " ({val1:?}, {val2:?})")?;
647                if let Scalar::Ptr(ptr, _size) = val1 {
648                    allocs.push(ptr.provenance.get_alloc_id());
649                }
650                if let Scalar::Ptr(ptr, _size) = val2 {
651                    allocs.push(ptr.provenance.get_alloc_id());
652                }
653            }
654        }
655
656        Ok(())
657    }
658}