Skip to content

Commit 05eae08

Browse files
oli-obkoli-obk
committed
Remove const eval limit and implement an exponential backoff lint instead
1 parent 578bcbc commit 05eae08

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

41 files changed

+325
-261
lines changed

‎compiler/rustc_const_eval/messages.ftl

+6
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,12 @@ const_eval_interior_mutable_data_refer =
1010
This would make multiple uses of a constant to be able to see different values and allow circumventing
1111
the `Send` and `Sync` requirements for shared mutable data, which is unsound.
1212
13+
const_eval_long_running =
14+
constant evaluation is taking a long time
15+
.note = this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval.
16+
If your compilation actually takes a long time, you can safely allow the lint.
17+
.label = the const evaluator is currently interpreting this expression
18+
.help = the constant being evaluated
1319
const_eval_max_num_nodes_in_const = maximum number of nodes exceeded in constant {$global_const_id}
1420
1521
const_eval_mut_deref =

‎compiler/rustc_const_eval/src/const_eval/eval_queries.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,7 @@ pub(super) fn mk_eval_cx<'mir, 'tcx>(
103103
tcx,
104104
root_span,
105105
param_env,
106-
CompileTimeInterpreter::new(tcx.const_eval_limit(), can_access_statics, CheckAlignment::No),
106+
CompileTimeInterpreter::new(can_access_statics, CheckAlignment::No),
107107
)
108108
}
109109

@@ -306,7 +306,6 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
306306
// Statics (and promoteds inside statics) may access other statics, because unlike consts
307307
// they do not have to behave "as if" they were evaluated at runtime.
308308
CompileTimeInterpreter::new(
309-
tcx.const_eval_limit(),
310309
/*can_access_statics:*/ is_static,
311310
if tcx.sess.opts.unstable_opts.extra_const_ub_checks {
312311
CheckAlignment::Error

‎compiler/rustc_const_eval/src/const_eval/machine.rs

+65-17
Original file line numberDiff line numberDiff line change
@@ -16,25 +16,36 @@ use std::fmt;
1616
use rustc_ast::Mutability;
1717
use rustc_hir::def_id::DefId;
1818
use rustc_middle::mir::AssertMessage;
19-
use rustc_session::Limit;
2019
use rustc_span::symbol::{sym, Symbol};
2120
use rustc_target::abi::{Align, Size};
2221
use rustc_target::spec::abi::Abi as CallAbi;
2322

23+
use crate::errors::{LongRunning, LongRunningWarn};
2424
use crate::interpret::{
2525
self, compile_time_machine, AllocId, ConstAllocation, FnVal, Frame, ImmTy, InterpCx,
2626
InterpResult, OpTy, PlaceTy, Pointer, Scalar,
2727
};
2828

2929
use super::error::*;
3030

31+
/// When hitting this many interpreted terminators we emit a deny by default lint
32+
/// that notfies the user that their constant takes a long time to evaluate. If that's
33+
/// what they intended, they can just allow the lint.
34+
const LINT_TERMINATOR_LIMIT: usize = 2_000_000;
35+
/// The limit used by `-Z tiny-const-eval-limit`. This smaller limit is useful for internal
36+
/// tests not needing to run 30s or more to show some behaviour.
37+
const TINY_LINT_TERMINATOR_LIMIT: usize = 20;
38+
/// After this many interpreted terminators, we start emitting progress indicators at every
39+
/// power of two of interpreted terminators.
40+
const PROGRESS_INDICATOR_START: usize = 4_000_000;
41+
3142
/// Extra machine state for CTFE, and the Machine instance
3243
pub struct CompileTimeInterpreter<'mir, 'tcx> {
33-
/// For now, the number of terminators that can be evaluated before we throw a resource
34-
/// exhaustion error.
44+
/// The number of terminators that have been evaluated.
3545
///
36-
/// Setting this to `0` disables the limit and allows the interpreter to run forever.
37-
pub(super) steps_remaining: usize,
46+
/// This is used to produce lints informing the user that the compiler is not stuck.
47+
/// Set to `usize::MAX` to never report anything.
48+
pub(super) num_evaluated_steps: usize,
3849

3950
/// The virtual call stack.
4051
pub(super) stack: Vec<Frame<'mir, 'tcx, AllocId, ()>>,
@@ -72,13 +83,9 @@ impl CheckAlignment {
7283
}
7384

7485
impl<'mir, 'tcx> CompileTimeInterpreter<'mir, 'tcx> {
75-
pub(crate) fn new(
76-
const_eval_limit: Limit,
77-
can_access_statics: bool,
78-
check_alignment: CheckAlignment,
79-
) -> Self {
86+
pub(crate) fn new(can_access_statics: bool, check_alignment: CheckAlignment) -> Self {
8087
CompileTimeInterpreter {
81-
steps_remaining: const_eval_limit.0,
88+
num_evaluated_steps: 0,
8289
stack: Vec::new(),
8390
can_access_statics,
8491
check_alignment,
@@ -569,13 +576,54 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
569576

570577
fn increment_const_eval_counter(ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> {
571578
// The step limit has already been hit in a previous call to `increment_const_eval_counter`.
572-
if ecx.machine.steps_remaining == 0 {
573-
return Ok(());
574-
}
575579

576-
ecx.machine.steps_remaining -= 1;
577-
if ecx.machine.steps_remaining == 0 {
578-
throw_exhaust!(StepLimitReached)
580+
if let Some(new_steps) = ecx.machine.num_evaluated_steps.checked_add(1) {
581+
let (limit, start) = if ecx.tcx.sess.opts.unstable_opts.tiny_const_eval_limit {
582+
(TINY_LINT_TERMINATOR_LIMIT, TINY_LINT_TERMINATOR_LIMIT)
583+
} else {
584+
(LINT_TERMINATOR_LIMIT, PROGRESS_INDICATOR_START)
585+
};
586+
587+
ecx.machine.num_evaluated_steps = new_steps;
588+
// By default, we have a *deny* lint kicking in after some time
589+
// to ensure `loop {}` doesn't just go forever.
590+
// In case that lint got reduced, in particular for `--cap-lint` situations, we also
591+
// have a hard warning shown every now and then for really long executions.
592+
if new_steps == limit {
593+
// By default, we stop after a million steps, but the user can disable this lint
594+
// to be able to run until the heat death of the universe or power loss, whichever
595+
// comes first.
596+
let hir_id = ecx.best_lint_scope();
597+
let is_error = ecx
598+
.tcx
599+
.lint_level_at_node(
600+
rustc_session::lint::builtin::LONG_RUNNING_CONST_EVAL,
601+
hir_id,
602+
)
603+
.0
604+
.is_error();
605+
let span = ecx.cur_span();
606+
ecx.tcx.emit_spanned_lint(
607+
rustc_session::lint::builtin::LONG_RUNNING_CONST_EVAL,
608+
hir_id,
609+
span,
610+
LongRunning { item_span: ecx.tcx.span },
611+
);
612+
// If this was a hard error, don't bother continuing evaluation.
613+
if is_error {
614+
let guard = ecx
615+
.tcx
616+
.sess
617+
.delay_span_bug(span, "The deny lint should have already errored");
618+
throw_inval!(AlreadyReported(guard.into()));
619+
}
620+
} else if new_steps > start && new_steps.is_power_of_two() {
621+
// Only report after a certain number of terminators have been evaluated and the
622+
// current number of evaluated terminators is a power of 2. The latter gives us a cheap
623+
// way to implement exponential backoff.
624+
let span = ecx.cur_span();
625+
ecx.tcx.sess.emit_warning(LongRunningWarn { span, item_span: ecx.tcx.span });
626+
}
579627
}
580628

581629
Ok(())

‎compiler/rustc_const_eval/src/errors.rs

+19-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
use rustc_hir::ConstContext;
2-
use rustc_macros::Diagnostic;
2+
use rustc_macros::{Diagnostic, LintDiagnostic};
33
use rustc_span::Span;
44

55
#[derive(Diagnostic)]
@@ -194,3 +194,21 @@ pub(crate) struct InteriorMutabilityBorrow {
194194
#[primary_span]
195195
pub span: Span,
196196
}
197+
198+
#[derive(LintDiagnostic)]
199+
#[diag(const_eval_long_running)]
200+
#[note]
201+
pub struct LongRunning {
202+
#[help]
203+
pub item_span: Span,
204+
}
205+
206+
#[derive(Diagnostic)]
207+
#[diag(const_eval_long_running)]
208+
pub struct LongRunningWarn {
209+
#[primary_span]
210+
#[label]
211+
pub span: Span,
212+
#[help]
213+
pub item_span: Span,
214+
}

‎compiler/rustc_const_eval/src/interpret/eval_context.rs

+10
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ use std::mem;
44

55
use either::{Either, Left, Right};
66

7+
use hir::CRATE_HIR_ID;
78
use rustc_hir::{self as hir, def_id::DefId, definitions::DefPathData};
89
use rustc_index::IndexVec;
910
use rustc_middle::mir;
@@ -405,6 +406,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
405406
self.stack().last().map_or(self.tcx.span, |f| f.current_span())
406407
}
407408

409+
#[inline(always)]
410+
/// Find the first stack frame that is within the current crate, if any, otherwise return the crate's HirId
411+
pub fn best_lint_scope(&self) -> hir::HirId {
412+
self.stack()
413+
.iter()
414+
.find_map(|frame| frame.body.source.def_id().as_local())
415+
.map_or(CRATE_HIR_ID, |def_id| self.tcx.hir().local_def_id_to_hir_id(def_id))
416+
}
417+
408418
#[inline(always)]
409419
pub(crate) fn stack(&self) -> &[Frame<'mir, 'tcx, M::Provenance, M::FrameExtra>] {
410420
M::stack(self)

‎compiler/rustc_const_eval/src/util/check_validity_requirement.rs

+2-6
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
use rustc_middle::ty::layout::{LayoutCx, LayoutError, LayoutOf, TyAndLayout, ValidityRequirement};
22
use rustc_middle::ty::{ParamEnv, ParamEnvAnd, Ty, TyCtxt};
3-
use rustc_session::Limit;
43
use rustc_target::abi::{Abi, FieldsShape, Scalar, Variants};
54

65
use crate::const_eval::{CheckAlignment, CompileTimeInterpreter};
@@ -45,11 +44,8 @@ fn might_permit_raw_init_strict<'tcx>(
4544
tcx: TyCtxt<'tcx>,
4645
kind: ValidityRequirement,
4746
) -> Result<bool, LayoutError<'tcx>> {
48-
let machine = CompileTimeInterpreter::new(
49-
Limit::new(0),
50-
/*can_access_statics:*/ false,
51-
CheckAlignment::Error,
52-
);
47+
let machine =
48+
CompileTimeInterpreter::new(/*can_access_statics:*/ false, CheckAlignment::Error);
5349

5450
let mut cx = InterpCx::new(tcx, rustc_span::DUMMY_SP, ParamEnv::reveal_all(), machine);
5551

‎compiler/rustc_feature/src/active.rs

-2
Original file line numberDiff line numberDiff line change
@@ -351,8 +351,6 @@ declare_features! (
351351
(active, const_async_blocks, "1.53.0", Some(85368), None),
352352
/// Allows `const || {}` closures in const contexts.
353353
(incomplete, const_closures, "1.68.0", Some(106003), None),
354-
/// Allows limiting the evaluation steps of const expressions
355-
(active, const_eval_limit, "1.43.0", Some(67217), None),
356354
/// Allows the definition of `const extern fn` and `const unsafe extern fn`.
357355
(active, const_extern_fn, "1.40.0", Some(64926), None),
358356
/// Allows basic arithmetic on floating point types in a `const fn`.

‎compiler/rustc_feature/src/builtin_attrs.rs

-4
Original file line numberDiff line numberDiff line change
@@ -355,10 +355,6 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
355355
// Limits:
356356
ungated!(recursion_limit, CrateLevel, template!(NameValueStr: "N"), FutureWarnFollowing),
357357
ungated!(type_length_limit, CrateLevel, template!(NameValueStr: "N"), FutureWarnFollowing),
358-
gated!(
359-
const_eval_limit, CrateLevel, template!(NameValueStr: "N"), ErrorFollowing,
360-
const_eval_limit, experimental!(const_eval_limit)
361-
),
362358
gated!(
363359
move_size_limit, CrateLevel, template!(NameValueStr: "N"), ErrorFollowing,
364360
large_assignments, experimental!(move_size_limit)

‎compiler/rustc_feature/src/removed.rs

+3-1
Original file line numberDiff line numberDiff line change
@@ -59,8 +59,10 @@ declare_features! (
5959
/// Allows comparing raw pointers during const eval.
6060
(removed, const_compare_raw_pointers, "1.46.0", Some(53020), None,
6161
Some("cannot be allowed in const eval in any meaningful way")),
62+
/// Allows limiting the evaluation steps of const expressions
63+
(removed, const_eval_limit, "1.43.0", Some(67217), None, Some("removed the limit entirely")),
6264
/// Allows non-trivial generic constants which have to be manually propagated upwards.
63-
(removed, const_evaluatable_checked, "1.48.0", Some(76560), None, Some("renamed to `generic_const_exprs`")),
65+
(removed, const_evaluatable_checked, "1.48.0", Some(76560), None, Some("renamed to `generic_const_exprs`")),
6466
/// Allows the definition of `const` functions with some advanced features.
6567
(removed, const_fn, "1.54.0", Some(57563), None,
6668
Some("split into finer-grained feature gates")),

‎compiler/rustc_lint_defs/src/builtin.rs

+38
Original file line numberDiff line numberDiff line change
@@ -3357,6 +3357,7 @@ declare_lint_pass! {
33573357
LARGE_ASSIGNMENTS,
33583358
LATE_BOUND_LIFETIME_ARGUMENTS,
33593359
LEGACY_DERIVE_HELPERS,
3360+
LONG_RUNNING_CONST_EVAL,
33603361
LOSSY_PROVENANCE_CASTS,
33613362
MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
33623363
MACRO_USE_EXTERN_CRATE,
@@ -3426,6 +3427,43 @@ declare_lint_pass! {
34263427
]
34273428
}
34283429

3430+
declare_lint! {
3431+
/// The `long_running_const_eval` lint is emitted when const
3432+
/// eval is running for a long time to ensure rustc terminates
3433+
/// even if you accidentally wrote an infinite loop.
3434+
///
3435+
/// ### Example
3436+
///
3437+
/// ```rust,compile_fail
3438+
/// const FOO: () = loop {};
3439+
/// ```
3440+
///
3441+
/// {{produces}}
3442+
///
3443+
/// ### Explanation
3444+
///
3445+
/// Loops allow const evaluation to compute arbitrary code, but may also
3446+
/// cause infinite loops or just very long running computations.
3447+
/// Users can enable long running computations by allowing the lint
3448+
/// on individual constants or for entire crates.
3449+
///
3450+
/// ### Unconditional warnings
3451+
///
3452+
/// Note that regardless of whether the lint is allowed or set to warn,
3453+
/// the compiler will issue warnings if constant evaluation runs significantly
3454+
/// longer than this lint's limit. These warnings are also shown to downstream
3455+
/// users from crates.io or similar registries. If you are above the lint's limit,
3456+
/// both you and downstream users might be exposed to these warnings.
3457+
/// They might also appear on compiler updates, as the compiler makes minor changes
3458+
/// about how complexity is measured: staying below the limit ensures that there
3459+
/// is enough room, and given that the lint is disabled for people who use your
3460+
/// dependency it means you will be the only one to get the warning and can put
3461+
/// out an update in your own time.
3462+
pub LONG_RUNNING_CONST_EVAL,
3463+
Deny,
3464+
"detects long const eval operations"
3465+
}
3466+
34293467
declare_lint! {
34303468
/// The `unused_doc_comments` lint detects doc comments that aren't used
34313469
/// by `rustdoc`.

‎compiler/rustc_middle/src/middle/limits.rs

+2-9
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
11
//! Registering limits:
22
//! * recursion_limit,
3-
//! * move_size_limit,
4-
//! * type_length_limit, and
5-
//! * const_eval_limit
3+
//! * move_size_limit, and
4+
//! * type_length_limit
65
//!
76
//! There are various parts of the compiler that must impose arbitrary limits
87
//! on how deeply they recurse to prevent stack overflow. Users can override
@@ -34,12 +33,6 @@ pub fn provide(providers: &mut Providers) {
3433
sym::type_length_limit,
3534
1048576,
3635
),
37-
const_eval_limit: get_limit(
38-
tcx.hir().krate_attrs(),
39-
tcx.sess,
40-
sym::const_eval_limit,
41-
2_000_000,
42-
),
4336
}
4437
}
4538

‎compiler/rustc_middle/src/mir/interpret/error.rs

-7
Original file line numberDiff line numberDiff line change
@@ -465,10 +465,6 @@ impl fmt::Display for UnsupportedOpInfo {
465465
pub enum ResourceExhaustionInfo {
466466
/// The stack grew too big.
467467
StackFrameLimitReached,
468-
/// The program ran for too long.
469-
///
470-
/// The exact limit is set by the `const_eval_limit` attribute.
471-
StepLimitReached,
472468
/// There is not enough memory (on the host) to perform an allocation.
473469
MemoryExhausted,
474470
/// The address space (of the target) is full.
@@ -482,9 +478,6 @@ impl fmt::Display for ResourceExhaustionInfo {
482478
StackFrameLimitReached => {
483479
write!(f, "reached the configured maximum number of stack frames")
484480
}
485-
StepLimitReached => {
486-
write!(f, "exceeded interpreter step limit (see `#[const_eval_limit]`)")
487-
}
488481
MemoryExhausted => {
489482
write!(f, "tried to allocate more memory than available to compiler")
490483
}

‎compiler/rustc_middle/src/ty/context.rs

-10
Original file line numberDiff line numberDiff line change
@@ -82,8 +82,6 @@ use std::iter;
8282
use std::mem;
8383
use std::ops::{Bound, Deref};
8484

85-
const TINY_CONST_EVAL_LIMIT: Limit = Limit(20);
86-
8785
#[allow(rustc::usage_of_ty_tykind)]
8886
impl<'tcx> Interner for TyCtxt<'tcx> {
8987
type AdtDef = ty::AdtDef<'tcx>;
@@ -1178,14 +1176,6 @@ impl<'tcx> TyCtxt<'tcx> {
11781176
self.limits(()).move_size_limit
11791177
}
11801178

1181-
pub fn const_eval_limit(self) -> Limit {
1182-
if self.sess.opts.unstable_opts.tiny_const_eval_limit {
1183-
TINY_CONST_EVAL_LIMIT
1184-
} else {
1185-
self.limits(()).const_eval_limit
1186-
}
1187-
}
1188-
11891179
pub fn all_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
11901180
iter::once(LOCAL_CRATE)
11911181
.chain(self.crates(()).iter().copied())

‎compiler/rustc_session/src/session.rs

-2
Original file line numberDiff line numberDiff line change
@@ -128,8 +128,6 @@ pub struct Limits {
128128
pub move_size_limit: Limit,
129129
/// The maximum length of types during monomorphization.
130130
pub type_length_limit: Limit,
131-
/// The maximum blocks a const expression can evaluate.
132-
pub const_eval_limit: Limit,
133131
}
134132

135133
pub struct CompilerIO {

‎src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile

+1-1
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ RUN ./build-clang.sh
5555
ENV CC=clang CXX=clang++
5656

5757
# rustc-perf version from 2023-03-15
58-
ENV PERF_COMMIT 9dfaa35193154b690922347ee1141a06ec87a199
58+
ENV PERF_COMMIT 8b2ac3042e1ff2c0074455a0a3618adef97156b1
5959
RUN curl -LS -o perf.zip https://github.com/rust-lang/rustc-perf/archive/$PERF_COMMIT.zip && \
6060
unzip perf.zip && \
6161
mv rustc-perf-$PERF_COMMIT rustc-perf && \

0 commit comments

Comments
 (0)