rustc_const_eval/const_eval/
machine.rs

1use std::borrow::{Borrow, Cow};
2use std::fmt;
3use std::hash::Hash;
4
5use rustc_abi::{Align, Size};
6use rustc_ast::Mutability;
7use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
8use rustc_hir::def_id::{DefId, LocalDefId};
9use rustc_hir::{self as hir, CRATE_HIR_ID, LangItem};
10use rustc_middle::mir::AssertMessage;
11use rustc_middle::mir::interpret::ReportedErrorInfo;
12use rustc_middle::query::TyCtxtAt;
13use rustc_middle::ty::layout::{HasTypingEnv, TyAndLayout, ValidityRequirement};
14use rustc_middle::ty::{self, Ty, TyCtxt};
15use rustc_middle::{bug, mir};
16use rustc_span::{Span, Symbol, sym};
17use rustc_target::callconv::FnAbi;
18use tracing::debug;
19
20use super::error::*;
21use crate::errors::{LongRunning, LongRunningWarn};
22use crate::fluent_generated as fluent;
23use crate::interpret::{
24    self, AllocId, AllocInit, AllocRange, ConstAllocation, CtfeProvenance, FnArg, Frame,
25    GlobalAlloc, ImmTy, InterpCx, InterpResult, OpTy, PlaceTy, Pointer, RangeSet, Scalar,
26    compile_time_machine, err_inval, interp_ok, throw_exhaust, throw_inval, throw_ub,
27    throw_ub_custom, throw_unsup, throw_unsup_format,
28};
29
30/// When hitting this many interpreted terminators we emit a deny by default lint
31/// that notfies the user that their constant takes a long time to evaluate. If that's
32/// what they intended, they can just allow the lint.
33const LINT_TERMINATOR_LIMIT: usize = 2_000_000;
34/// The limit used by `-Z tiny-const-eval-limit`. This smaller limit is useful for internal
35/// tests not needing to run 30s or more to show some behaviour.
36const TINY_LINT_TERMINATOR_LIMIT: usize = 20;
37/// After this many interpreted terminators, we start emitting progress indicators at every
38/// power of two of interpreted terminators.
39const PROGRESS_INDICATOR_START: usize = 4_000_000;
40
41/// Extra machine state for CTFE, and the Machine instance.
42//
43// Should be public because out-of-tree rustc consumers need this
44// if they want to interact with constant values.
45pub struct CompileTimeMachine<'tcx> {
46    /// The number of terminators that have been evaluated.
47    ///
48    /// This is used to produce lints informing the user that the compiler is not stuck.
49    /// Set to `usize::MAX` to never report anything.
50    pub(super) num_evaluated_steps: usize,
51
52    /// The virtual call stack.
53    pub(super) stack: Vec<Frame<'tcx>>,
54
55    /// Pattern matching on consts with references would be unsound if those references
56    /// could point to anything mutable. Therefore, when evaluating consts and when constructing valtrees,
57    /// we ensure that only immutable global memory can be accessed.
58    pub(super) can_access_mut_global: CanAccessMutGlobal,
59
60    /// Whether to check alignment during evaluation.
61    pub(super) check_alignment: CheckAlignment,
62
63    /// If `Some`, we are evaluating the initializer of the static with the given `LocalDefId`,
64    /// storing the result in the given `AllocId`.
65    /// Used to prevent accesses to a static's base allocation, as that may allow for self-initialization loops.
66    pub(crate) static_root_ids: Option<(AllocId, LocalDefId)>,
67
68    /// A cache of "data range" computations for unions (i.e., the offsets of non-padding bytes).
69    union_data_ranges: FxHashMap<Ty<'tcx>, RangeSet>,
70}
71
72#[derive(Copy, Clone)]
73pub enum CheckAlignment {
74    /// Ignore all alignment requirements.
75    /// This is mainly used in interning.
76    No,
77    /// Hard error when dereferencing a misaligned pointer.
78    Error,
79}
80
81#[derive(Copy, Clone, PartialEq)]
82pub(crate) enum CanAccessMutGlobal {
83    No,
84    Yes,
85}
86
87impl From<bool> for CanAccessMutGlobal {
88    fn from(value: bool) -> Self {
89        if value { Self::Yes } else { Self::No }
90    }
91}
92
93impl<'tcx> CompileTimeMachine<'tcx> {
94    pub(crate) fn new(
95        can_access_mut_global: CanAccessMutGlobal,
96        check_alignment: CheckAlignment,
97    ) -> Self {
98        CompileTimeMachine {
99            num_evaluated_steps: 0,
100            stack: Vec::new(),
101            can_access_mut_global,
102            check_alignment,
103            static_root_ids: None,
104            union_data_ranges: FxHashMap::default(),
105        }
106    }
107}
108
109impl<K: Hash + Eq, V> interpret::AllocMap<K, V> for FxIndexMap<K, V> {
110    #[inline(always)]
111    fn contains_key<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> bool
112    where
113        K: Borrow<Q>,
114    {
115        FxIndexMap::contains_key(self, k)
116    }
117
118    #[inline(always)]
119    fn contains_key_ref<Q: ?Sized + Hash + Eq>(&self, k: &Q) -> bool
120    where
121        K: Borrow<Q>,
122    {
123        FxIndexMap::contains_key(self, k)
124    }
125
126    #[inline(always)]
127    fn insert(&mut self, k: K, v: V) -> Option<V> {
128        FxIndexMap::insert(self, k, v)
129    }
130
131    #[inline(always)]
132    fn remove<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> Option<V>
133    where
134        K: Borrow<Q>,
135    {
136        // FIXME(#120456) - is `swap_remove` correct?
137        FxIndexMap::swap_remove(self, k)
138    }
139
140    #[inline(always)]
141    fn filter_map_collect<T>(&self, mut f: impl FnMut(&K, &V) -> Option<T>) -> Vec<T> {
142        self.iter().filter_map(move |(k, v)| f(k, v)).collect()
143    }
144
145    #[inline(always)]
146    fn get_or<E>(&self, k: K, vacant: impl FnOnce() -> Result<V, E>) -> Result<&V, E> {
147        match self.get(&k) {
148            Some(v) => Ok(v),
149            None => {
150                vacant()?;
151                bug!("The CTFE machine shouldn't ever need to extend the alloc_map when reading")
152            }
153        }
154    }
155
156    #[inline(always)]
157    fn get_mut_or<E>(&mut self, k: K, vacant: impl FnOnce() -> Result<V, E>) -> Result<&mut V, E> {
158        match self.entry(k) {
159            IndexEntry::Occupied(e) => Ok(e.into_mut()),
160            IndexEntry::Vacant(e) => {
161                let v = vacant()?;
162                Ok(e.insert(v))
163            }
164        }
165    }
166}
167
168pub type CompileTimeInterpCx<'tcx> = InterpCx<'tcx, CompileTimeMachine<'tcx>>;
169
170#[derive(Debug, PartialEq, Eq, Copy, Clone)]
171pub enum MemoryKind {
172    Heap {
173        /// Indicates whether `make_global` was called on this allocation.
174        /// If this is `true`, the allocation must be immutable.
175        was_made_global: bool,
176    },
177}
178
179impl fmt::Display for MemoryKind {
180    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
181        match self {
182            MemoryKind::Heap { was_made_global } => {
183                write!(f, "heap allocation{}", if *was_made_global { " (made global)" } else { "" })
184            }
185        }
186    }
187}
188
189impl interpret::MayLeak for MemoryKind {
190    #[inline(always)]
191    fn may_leak(self) -> bool {
192        match self {
193            MemoryKind::Heap { was_made_global } => was_made_global,
194        }
195    }
196}
197
198impl interpret::MayLeak for ! {
199    #[inline(always)]
200    fn may_leak(self) -> bool {
201        // `self` is uninhabited
202        self
203    }
204}
205
206impl<'tcx> CompileTimeInterpCx<'tcx> {
207    fn location_triple_for_span(&self, span: Span) -> (Symbol, u32, u32) {
208        let topmost = span.ctxt().outer_expn().expansion_cause().unwrap_or(span);
209        let caller = self.tcx.sess.source_map().lookup_char_pos(topmost.lo());
210
211        use rustc_session::RemapFileNameExt;
212        use rustc_session::config::RemapPathScopeComponents;
213        (
214            Symbol::intern(
215                &caller
216                    .file
217                    .name
218                    .for_scope(self.tcx.sess, RemapPathScopeComponents::DIAGNOSTICS)
219                    .to_string_lossy(),
220            ),
221            u32::try_from(caller.line).unwrap(),
222            u32::try_from(caller.col_display).unwrap().checked_add(1).unwrap(),
223        )
224    }
225
226    /// "Intercept" a function call, because we have something special to do for it.
227    /// All `#[rustc_do_not_const_check]` functions MUST be hooked here.
228    /// If this returns `Some` function, which may be `instance` or a different function with
229    /// compatible arguments, then evaluation should continue with that function.
230    /// If this returns `None`, the function call has been handled and the function has returned.
231    fn hook_special_const_fn(
232        &mut self,
233        instance: ty::Instance<'tcx>,
234        args: &[FnArg<'tcx>],
235        _dest: &PlaceTy<'tcx>,
236        _ret: Option<mir::BasicBlock>,
237    ) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>> {
238        let def_id = instance.def_id();
239
240        if self.tcx.has_attr(def_id, sym::rustc_const_panic_str)
241            || self.tcx.is_lang_item(def_id, LangItem::BeginPanic)
242        {
243            let args = self.copy_fn_args(args);
244            // &str or &&str
245            assert!(args.len() == 1);
246
247            let mut msg_place = self.deref_pointer(&args[0])?;
248            while msg_place.layout.ty.is_ref() {
249                msg_place = self.deref_pointer(&msg_place)?;
250            }
251
252            let msg = Symbol::intern(self.read_str(&msg_place)?);
253            let span = self.find_closest_untracked_caller_location();
254            let (file, line, col) = self.location_triple_for_span(span);
255            return Err(ConstEvalErrKind::Panic { msg, file, line, col }).into();
256        } else if self.tcx.is_lang_item(def_id, LangItem::PanicFmt) {
257            // For panic_fmt, call const_panic_fmt instead.
258            let const_def_id = self.tcx.require_lang_item(LangItem::ConstPanicFmt, self.tcx.span);
259            let new_instance = ty::Instance::expect_resolve(
260                *self.tcx,
261                self.typing_env(),
262                const_def_id,
263                instance.args,
264                self.cur_span(),
265            );
266
267            return interp_ok(Some(new_instance));
268        }
269        interp_ok(Some(instance))
270    }
271
272    /// See documentation on the `ptr_guaranteed_cmp` intrinsic.
273    /// Returns `2` if the result is unknown.
274    /// Returns `1` if the pointers are guaranteed equal.
275    /// Returns `0` if the pointers are guaranteed inequal.
276    ///
277    /// Note that this intrinsic is exposed on stable for comparison with null. In other words, any
278    /// change to this function that affects comparison with null is insta-stable!
279    fn guaranteed_cmp(&mut self, a: Scalar, b: Scalar) -> InterpResult<'tcx, u8> {
280        interp_ok(match (a, b) {
281            // Comparisons between integers are always known.
282            (Scalar::Int { .. }, Scalar::Int { .. }) => {
283                if a == b {
284                    1
285                } else {
286                    0
287                }
288            }
289            // Comparisons of abstract pointers with null pointers are known if the pointer
290            // is in bounds, because if they are in bounds, the pointer can't be null.
291            // Inequality with integers other than null can never be known for sure.
292            (Scalar::Int(int), ptr @ Scalar::Ptr(..))
293            | (ptr @ Scalar::Ptr(..), Scalar::Int(int))
294                if int.is_null() && !self.scalar_may_be_null(ptr)? =>
295            {
296                0
297            }
298            // Equality with integers can never be known for sure.
299            (Scalar::Int { .. }, Scalar::Ptr(..)) | (Scalar::Ptr(..), Scalar::Int { .. }) => 2,
300            // FIXME: return a `1` for when both sides are the same pointer, *except* that
301            // some things (like functions and vtables) do not have stable addresses
302            // so we need to be careful around them (see e.g. #73722).
303            // FIXME: return `0` for at least some comparisons where we can reliably
304            // determine the result of runtime inequality tests at compile-time.
305            // Examples include comparison of addresses in different static items.
306            (Scalar::Ptr(..), Scalar::Ptr(..)) => 2,
307        })
308    }
309}
310
311impl<'tcx> CompileTimeMachine<'tcx> {
312    #[inline(always)]
313    /// Find the first stack frame that is within the current crate, if any.
314    /// Otherwise, return the crate's HirId
315    pub fn best_lint_scope(&self, tcx: TyCtxt<'tcx>) -> hir::HirId {
316        self.stack.iter().find_map(|frame| frame.lint_root(tcx)).unwrap_or(CRATE_HIR_ID)
317    }
318}
319
320impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
321    compile_time_machine!(<'tcx>);
322
323    const PANIC_ON_ALLOC_FAIL: bool = false; // will be raised as a proper error
324
325    #[inline(always)]
326    fn enforce_alignment(ecx: &InterpCx<'tcx, Self>) -> bool {
327        matches!(ecx.machine.check_alignment, CheckAlignment::Error)
328    }
329
330    #[inline(always)]
331    fn enforce_validity(ecx: &InterpCx<'tcx, Self>, layout: TyAndLayout<'tcx>) -> bool {
332        ecx.tcx.sess.opts.unstable_opts.extra_const_ub_checks || layout.is_uninhabited()
333    }
334
335    fn load_mir(
336        ecx: &InterpCx<'tcx, Self>,
337        instance: ty::InstanceKind<'tcx>,
338    ) -> &'tcx mir::Body<'tcx> {
339        match instance {
340            ty::InstanceKind::Item(def) => ecx.tcx.mir_for_ctfe(def),
341            _ => ecx.tcx.instance_mir(instance),
342        }
343    }
344
345    fn find_mir_or_eval_fn(
346        ecx: &mut InterpCx<'tcx, Self>,
347        orig_instance: ty::Instance<'tcx>,
348        _abi: &FnAbi<'tcx, Ty<'tcx>>,
349        args: &[FnArg<'tcx>],
350        dest: &PlaceTy<'tcx>,
351        ret: Option<mir::BasicBlock>,
352        _unwind: mir::UnwindAction, // unwinding is not supported in consts
353    ) -> InterpResult<'tcx, Option<(&'tcx mir::Body<'tcx>, ty::Instance<'tcx>)>> {
354        debug!("find_mir_or_eval_fn: {:?}", orig_instance);
355
356        // Replace some functions.
357        let Some(instance) = ecx.hook_special_const_fn(orig_instance, args, dest, ret)? else {
358            // Call has already been handled.
359            return interp_ok(None);
360        };
361
362        // Only check non-glue functions
363        if let ty::InstanceKind::Item(def) = instance.def {
364            // Execution might have wandered off into other crates, so we cannot do a stability-
365            // sensitive check here. But we can at least rule out functions that are not const at
366            // all. That said, we have to allow calling functions inside a `const trait`. These
367            // *are* const-checked!
368            if !ecx.tcx.is_const_fn(def) || ecx.tcx.has_attr(def, sym::rustc_do_not_const_check) {
369                // We certainly do *not* want to actually call the fn
370                // though, so be sure we return here.
371                throw_unsup_format!("calling non-const function `{}`", instance)
372            }
373        }
374
375        // This is a const fn. Call it.
376        // In case of replacement, we return the *original* instance to make backtraces work out
377        // (and we hope this does not confuse the FnAbi checks too much).
378        interp_ok(Some((ecx.load_mir(instance.def, None)?, orig_instance)))
379    }
380
381    fn panic_nounwind(ecx: &mut InterpCx<'tcx, Self>, msg: &str) -> InterpResult<'tcx> {
382        let msg = Symbol::intern(msg);
383        let span = ecx.find_closest_untracked_caller_location();
384        let (file, line, col) = ecx.location_triple_for_span(span);
385        Err(ConstEvalErrKind::Panic { msg, file, line, col }).into()
386    }
387
388    fn call_intrinsic(
389        ecx: &mut InterpCx<'tcx, Self>,
390        instance: ty::Instance<'tcx>,
391        args: &[OpTy<'tcx>],
392        dest: &PlaceTy<'tcx, Self::Provenance>,
393        target: Option<mir::BasicBlock>,
394        _unwind: mir::UnwindAction,
395    ) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>> {
396        // Shared intrinsics.
397        if ecx.eval_intrinsic(instance, args, dest, target)? {
398            return interp_ok(None);
399        }
400        let intrinsic_name = ecx.tcx.item_name(instance.def_id());
401
402        // CTFE-specific intrinsics.
403        match intrinsic_name {
404            sym::ptr_guaranteed_cmp => {
405                let a = ecx.read_scalar(&args[0])?;
406                let b = ecx.read_scalar(&args[1])?;
407                let cmp = ecx.guaranteed_cmp(a, b)?;
408                ecx.write_scalar(Scalar::from_u8(cmp), dest)?;
409            }
410            sym::const_allocate => {
411                let size = ecx.read_scalar(&args[0])?.to_target_usize(ecx)?;
412                let align = ecx.read_scalar(&args[1])?.to_target_usize(ecx)?;
413
414                let align = match Align::from_bytes(align) {
415                    Ok(a) => a,
416                    Err(err) => throw_ub_custom!(
417                        fluent::const_eval_invalid_align_details,
418                        name = "const_allocate",
419                        err_kind = err.diag_ident(),
420                        align = err.align()
421                    ),
422                };
423
424                let ptr = ecx.allocate_ptr(
425                    Size::from_bytes(size),
426                    align,
427                    interpret::MemoryKind::Machine(MemoryKind::Heap { was_made_global: false }),
428                    AllocInit::Uninit,
429                )?;
430                ecx.write_pointer(ptr, dest)?;
431            }
432            sym::const_deallocate => {
433                let ptr = ecx.read_pointer(&args[0])?;
434                let size = ecx.read_scalar(&args[1])?.to_target_usize(ecx)?;
435                let align = ecx.read_scalar(&args[2])?.to_target_usize(ecx)?;
436
437                let size = Size::from_bytes(size);
438                let align = match Align::from_bytes(align) {
439                    Ok(a) => a,
440                    Err(err) => throw_ub_custom!(
441                        fluent::const_eval_invalid_align_details,
442                        name = "const_deallocate",
443                        err_kind = err.diag_ident(),
444                        align = err.align()
445                    ),
446                };
447
448                // If an allocation is created in an another const,
449                // we don't deallocate it.
450                let (alloc_id, _, _) = ecx.ptr_get_alloc_id(ptr, 0)?;
451                let is_allocated_in_another_const = matches!(
452                    ecx.tcx.try_get_global_alloc(alloc_id),
453                    Some(interpret::GlobalAlloc::Memory(_))
454                );
455
456                if !is_allocated_in_another_const {
457                    ecx.deallocate_ptr(
458                        ptr,
459                        Some((size, align)),
460                        interpret::MemoryKind::Machine(MemoryKind::Heap { was_made_global: false }),
461                    )?;
462                }
463            }
464
465            sym::const_make_global => {
466                let ptr = ecx.read_pointer(&args[0])?;
467                ecx.make_const_heap_ptr_global(ptr)?;
468                ecx.write_pointer(ptr, dest)?;
469            }
470
471            // The intrinsic represents whether the value is known to the optimizer (LLVM).
472            // We're not doing any optimizations here, so there is no optimizer that could know the value.
473            // (We know the value here in the machine of course, but this is the runtime of that code,
474            // not the optimization stage.)
475            sym::is_val_statically_known => ecx.write_scalar(Scalar::from_bool(false), dest)?,
476
477            // We handle these here since Miri does not want to have them.
478            sym::assert_inhabited
479            | sym::assert_zero_valid
480            | sym::assert_mem_uninitialized_valid => {
481                let ty = instance.args.type_at(0);
482                let requirement = ValidityRequirement::from_intrinsic(intrinsic_name).unwrap();
483
484                let should_panic = !ecx
485                    .tcx
486                    .check_validity_requirement((requirement, ecx.typing_env().as_query_input(ty)))
487                    .map_err(|_| err_inval!(TooGeneric))?;
488
489                if should_panic {
490                    let layout = ecx.layout_of(ty)?;
491
492                    let msg = match requirement {
493                        // For *all* intrinsics we first check `is_uninhabited` to give a more specific
494                        // error message.
495                        _ if layout.is_uninhabited() => format!(
496                            "aborted execution: attempted to instantiate uninhabited type `{ty}`"
497                        ),
498                        ValidityRequirement::Inhabited => bug!("handled earlier"),
499                        ValidityRequirement::Zero => format!(
500                            "aborted execution: attempted to zero-initialize type `{ty}`, which is invalid"
501                        ),
502                        ValidityRequirement::UninitMitigated0x01Fill => format!(
503                            "aborted execution: attempted to leave type `{ty}` uninitialized, which is invalid"
504                        ),
505                        ValidityRequirement::Uninit => bug!("assert_uninit_valid doesn't exist"),
506                    };
507
508                    Self::panic_nounwind(ecx, &msg)?;
509                    // Skip the `return_to_block` at the end (we panicked, we do not return).
510                    return interp_ok(None);
511                }
512            }
513
514            _ => {
515                // We haven't handled the intrinsic, let's see if we can use a fallback body.
516                if ecx.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
517                    throw_unsup_format!(
518                        "intrinsic `{intrinsic_name}` is not supported at compile-time"
519                    );
520                }
521                return interp_ok(Some(ty::Instance {
522                    def: ty::InstanceKind::Item(instance.def_id()),
523                    args: instance.args,
524                }));
525            }
526        }
527
528        // Intrinsic is done, jump to next block.
529        ecx.return_to_block(target)?;
530        interp_ok(None)
531    }
532
533    fn assert_panic(
534        ecx: &mut InterpCx<'tcx, Self>,
535        msg: &AssertMessage<'tcx>,
536        _unwind: mir::UnwindAction,
537    ) -> InterpResult<'tcx> {
538        use rustc_middle::mir::AssertKind::*;
539        // Convert `AssertKind<Operand>` to `AssertKind<Scalar>`.
540        let eval_to_int =
541            |op| ecx.read_immediate(&ecx.eval_operand(op, None)?).map(|x| x.to_const_int());
542        let err = match msg {
543            BoundsCheck { len, index } => {
544                let len = eval_to_int(len)?;
545                let index = eval_to_int(index)?;
546                BoundsCheck { len, index }
547            }
548            Overflow(op, l, r) => Overflow(*op, eval_to_int(l)?, eval_to_int(r)?),
549            OverflowNeg(op) => OverflowNeg(eval_to_int(op)?),
550            DivisionByZero(op) => DivisionByZero(eval_to_int(op)?),
551            RemainderByZero(op) => RemainderByZero(eval_to_int(op)?),
552            ResumedAfterReturn(coroutine_kind) => ResumedAfterReturn(*coroutine_kind),
553            ResumedAfterPanic(coroutine_kind) => ResumedAfterPanic(*coroutine_kind),
554            ResumedAfterDrop(coroutine_kind) => ResumedAfterDrop(*coroutine_kind),
555            MisalignedPointerDereference { required, found } => MisalignedPointerDereference {
556                required: eval_to_int(required)?,
557                found: eval_to_int(found)?,
558            },
559            NullPointerDereference => NullPointerDereference,
560            InvalidEnumConstruction(source) => InvalidEnumConstruction(eval_to_int(source)?),
561        };
562        Err(ConstEvalErrKind::AssertFailure(err)).into()
563    }
564
565    fn binary_ptr_op(
566        _ecx: &InterpCx<'tcx, Self>,
567        _bin_op: mir::BinOp,
568        _left: &ImmTy<'tcx>,
569        _right: &ImmTy<'tcx>,
570    ) -> InterpResult<'tcx, ImmTy<'tcx>> {
571        throw_unsup_format!("pointer arithmetic or comparison is not supported at compile-time");
572    }
573
574    fn increment_const_eval_counter(ecx: &mut InterpCx<'tcx, Self>) -> InterpResult<'tcx> {
575        // The step limit has already been hit in a previous call to `increment_const_eval_counter`.
576
577        if let Some(new_steps) = ecx.machine.num_evaluated_steps.checked_add(1) {
578            let (limit, start) = if ecx.tcx.sess.opts.unstable_opts.tiny_const_eval_limit {
579                (TINY_LINT_TERMINATOR_LIMIT, TINY_LINT_TERMINATOR_LIMIT)
580            } else {
581                (LINT_TERMINATOR_LIMIT, PROGRESS_INDICATOR_START)
582            };
583
584            ecx.machine.num_evaluated_steps = new_steps;
585            // By default, we have a *deny* lint kicking in after some time
586            // to ensure `loop {}` doesn't just go forever.
587            // In case that lint got reduced, in particular for `--cap-lint` situations, we also
588            // have a hard warning shown every now and then for really long executions.
589            if new_steps == limit {
590                // By default, we stop after a million steps, but the user can disable this lint
591                // to be able to run until the heat death of the universe or power loss, whichever
592                // comes first.
593                let hir_id = ecx.machine.best_lint_scope(*ecx.tcx);
594                let is_error = ecx
595                    .tcx
596                    .lint_level_at_node(
597                        rustc_session::lint::builtin::LONG_RUNNING_CONST_EVAL,
598                        hir_id,
599                    )
600                    .level
601                    .is_error();
602                let span = ecx.cur_span();
603                ecx.tcx.emit_node_span_lint(
604                    rustc_session::lint::builtin::LONG_RUNNING_CONST_EVAL,
605                    hir_id,
606                    span,
607                    LongRunning { item_span: ecx.tcx.span },
608                );
609                // If this was a hard error, don't bother continuing evaluation.
610                if is_error {
611                    let guard = ecx
612                        .tcx
613                        .dcx()
614                        .span_delayed_bug(span, "The deny lint should have already errored");
615                    throw_inval!(AlreadyReported(ReportedErrorInfo::allowed_in_infallible(guard)));
616                }
617            } else if new_steps > start && new_steps.is_power_of_two() {
618                // Only report after a certain number of terminators have been evaluated and the
619                // current number of evaluated terminators is a power of 2. The latter gives us a cheap
620                // way to implement exponential backoff.
621                let span = ecx.cur_span();
622                // We store a unique number in `force_duplicate` to evade `-Z deduplicate-diagnostics`.
623                // `new_steps` is guaranteed to be unique because `ecx.machine.num_evaluated_steps` is
624                // always increasing.
625                ecx.tcx.dcx().emit_warn(LongRunningWarn {
626                    span,
627                    item_span: ecx.tcx.span,
628                    force_duplicate: new_steps,
629                });
630            }
631        }
632
633        interp_ok(())
634    }
635
636    #[inline(always)]
637    fn expose_provenance(
638        _ecx: &InterpCx<'tcx, Self>,
639        _provenance: Self::Provenance,
640    ) -> InterpResult<'tcx> {
641        // This is only reachable with -Zunleash-the-miri-inside-of-you.
642        throw_unsup_format!("exposing pointers is not possible at compile-time")
643    }
644
645    #[inline(always)]
646    fn init_frame(
647        ecx: &mut InterpCx<'tcx, Self>,
648        frame: Frame<'tcx>,
649    ) -> InterpResult<'tcx, Frame<'tcx>> {
650        // Enforce stack size limit. Add 1 because this is run before the new frame is pushed.
651        if !ecx.recursion_limit.value_within_limit(ecx.stack().len() + 1) {
652            throw_exhaust!(StackFrameLimitReached)
653        } else {
654            interp_ok(frame)
655        }
656    }
657
658    #[inline(always)]
659    fn stack<'a>(
660        ecx: &'a InterpCx<'tcx, Self>,
661    ) -> &'a [Frame<'tcx, Self::Provenance, Self::FrameExtra>] {
662        &ecx.machine.stack
663    }
664
665    #[inline(always)]
666    fn stack_mut<'a>(
667        ecx: &'a mut InterpCx<'tcx, Self>,
668    ) -> &'a mut Vec<Frame<'tcx, Self::Provenance, Self::FrameExtra>> {
669        &mut ecx.machine.stack
670    }
671
672    fn before_access_global(
673        _tcx: TyCtxtAt<'tcx>,
674        machine: &Self,
675        alloc_id: AllocId,
676        alloc: ConstAllocation<'tcx>,
677        _static_def_id: Option<DefId>,
678        is_write: bool,
679    ) -> InterpResult<'tcx> {
680        let alloc = alloc.inner();
681        if is_write {
682            // Write access. These are never allowed, but we give a targeted error message.
683            match alloc.mutability {
684                Mutability::Not => throw_ub!(WriteToReadOnly(alloc_id)),
685                Mutability::Mut => Err(ConstEvalErrKind::ModifiedGlobal).into(),
686            }
687        } else {
688            // Read access. These are usually allowed, with some exceptions.
689            if machine.can_access_mut_global == CanAccessMutGlobal::Yes {
690                // Machine configuration allows us read from anything (e.g., `static` initializer).
691                interp_ok(())
692            } else if alloc.mutability == Mutability::Mut {
693                // Machine configuration does not allow us to read statics (e.g., `const`
694                // initializer).
695                Err(ConstEvalErrKind::ConstAccessesMutGlobal).into()
696            } else {
697                // Immutable global, this read is fine.
698                assert_eq!(alloc.mutability, Mutability::Not);
699                interp_ok(())
700            }
701        }
702    }
703
704    fn retag_ptr_value(
705        ecx: &mut InterpCx<'tcx, Self>,
706        _kind: mir::RetagKind,
707        val: &ImmTy<'tcx, CtfeProvenance>,
708    ) -> InterpResult<'tcx, ImmTy<'tcx, CtfeProvenance>> {
709        // If it's a frozen shared reference that's not already immutable, potentially make it immutable.
710        // (Do nothing on `None` provenance, that cannot store immutability anyway.)
711        if let ty::Ref(_, ty, mutbl) = val.layout.ty.kind()
712            && *mutbl == Mutability::Not
713            && val
714                .to_scalar_and_meta()
715                .0
716                .to_pointer(ecx)?
717                .provenance
718                .is_some_and(|p| !p.immutable())
719        {
720            // That next check is expensive, that's why we have all the guards above.
721            let is_immutable = ty.is_freeze(*ecx.tcx, ecx.typing_env());
722            let place = ecx.ref_to_mplace(val)?;
723            let new_place = if is_immutable {
724                place.map_provenance(CtfeProvenance::as_immutable)
725            } else {
726                // Even if it is not immutable, remember that it is a shared reference.
727                // This allows it to become part of the final value of the constant.
728                // (See <https://github.com/rust-lang/rust/pull/128543> for why we allow this
729                // even when there is interior mutability.)
730                place.map_provenance(CtfeProvenance::as_shared_ref)
731            };
732            interp_ok(ImmTy::from_immediate(new_place.to_ref(ecx), val.layout))
733        } else {
734            interp_ok(val.clone())
735        }
736    }
737
738    fn before_memory_write(
739        _tcx: TyCtxtAt<'tcx>,
740        _machine: &mut Self,
741        _alloc_extra: &mut Self::AllocExtra,
742        _ptr: Pointer<Option<Self::Provenance>>,
743        (_alloc_id, immutable): (AllocId, bool),
744        range: AllocRange,
745    ) -> InterpResult<'tcx> {
746        if range.size == Size::ZERO {
747            // Nothing to check.
748            return interp_ok(());
749        }
750        // Reject writes through immutable pointers.
751        if immutable {
752            return Err(ConstEvalErrKind::WriteThroughImmutablePointer).into();
753        }
754        // Everything else is fine.
755        interp_ok(())
756    }
757
758    fn before_alloc_access(
759        tcx: TyCtxtAt<'tcx>,
760        machine: &Self,
761        alloc_id: AllocId,
762    ) -> InterpResult<'tcx> {
763        if machine.stack.is_empty() {
764            // Get out of the way for the final copy.
765            return interp_ok(());
766        }
767        // Check if this is the currently evaluated static.
768        if Some(alloc_id) == machine.static_root_ids.map(|(id, _)| id) {
769            return Err(ConstEvalErrKind::RecursiveStatic).into();
770        }
771        // If this is another static, make sure we fire off the query to detect cycles.
772        // But only do that when checks for static recursion are enabled.
773        if machine.static_root_ids.is_some() {
774            if let Some(GlobalAlloc::Static(def_id)) = tcx.try_get_global_alloc(alloc_id) {
775                if tcx.is_foreign_item(def_id) {
776                    throw_unsup!(ExternStatic(def_id));
777                }
778                tcx.eval_static_initializer(def_id)?;
779            }
780        }
781        interp_ok(())
782    }
783
784    fn cached_union_data_range<'e>(
785        ecx: &'e mut InterpCx<'tcx, Self>,
786        ty: Ty<'tcx>,
787        compute_range: impl FnOnce() -> RangeSet,
788    ) -> Cow<'e, RangeSet> {
789        if ecx.tcx.sess.opts.unstable_opts.extra_const_ub_checks {
790            Cow::Borrowed(ecx.machine.union_data_ranges.entry(ty).or_insert_with(compute_range))
791        } else {
792            // Don't bother caching, we're only doing one validation at the end anyway.
793            Cow::Owned(compute_range())
794        }
795    }
796
797    fn get_default_alloc_params(&self) -> <Self::Bytes as mir::interpret::AllocBytes>::AllocParams {
798    }
799}
800
801// Please do not add any code below the above `Machine` trait impl. I (oli-obk) plan more cleanups
802// so we can end up having a file with just that impl, but for now, let's keep the impl discoverable
803// at the bottom of this file.
rustc_const_eval/const_eval/machine.rs

rustc_const_eval/const_eval/
machine.rs
