Replace terminator-based const eval limit

- Remove logic that limits const eval based on terminators, and use the
  stable metric instead (back edges + fn calls)
- Add unstable flag `tiny-const-eval-limit` to add UI tests that do not
  have to go up to the regular 2M step limit

Author: bryangarza

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -561,8 +561,8 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
         throw_unsup_format!("pointer arithmetic or comparison is not supported at compile-time");
     }
 
-    fn before_terminator(ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> {
-        // The step limit has already been hit in a previous call to `before_terminator`.
+    fn increment_const_eval_counter(ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> {
+        // The step limit has already been hit in a previous call to `increment_const_eval_counter`.
         if ecx.machine.steps_remaining == 0 {
             return Ok(());
         }

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -46,9 +46,6 @@ pub struct InterpCx<'mir, 'tcx, M: Machine<'mir, 'tcx>> {
 
     /// The recursion limit (cached from `tcx.recursion_limit(())`)
     pub recursion_limit: Limit,
-
-    pub const_eval_limit: u32,
-    pub const_eval_counter: u32,
 }
 
 // The Phantomdata exists to prevent this type from being `Send`. If it were sent across a thread
@@ -411,8 +408,6 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             param_env,
             memory: Memory::new(),
             recursion_limit: tcx.recursion_limit(),
-            const_eval_limit: 20,
-            const_eval_counter: 0,
         }
     }
 

compiler/rustc_const_eval/src/interpret/machine.rs

@@ -243,10 +243,10 @@ pub trait Machine<'mir, 'tcx>: Sized {
         ecx.stack_mut()[frame].locals[local].access_mut()
     }
 
-    /// Called before a basic block terminator is executed.
-    /// You can use this to detect endlessly running programs.
+    /// Called when the interpreter encounters a `StatementKind::ConstEvalCounter` instruction.
+    /// You can use this to detect long or endlessly running programs.
     #[inline]
-    fn before_terminator(_ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> {
+    fn increment_const_eval_counter(_ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> {
         Ok(())
     }
 

compiler/rustc_const_eval/src/interpret/place.rs

@@ -293,17 +293,6 @@ where
     Prov: Provenance + 'static,
     M: Machine<'mir, 'tcx, Provenance = Prov>,
 {
-    pub fn increment_const_eval_counter(&mut self) {
-        self.const_eval_counter = self.const_eval_counter + 1;
-        if self.const_eval_counter == self.const_eval_limit {
-            let mut warn = self.tcx.sess.struct_warn(format!(
-                "Const eval counter limit ({}) has been crossed",
-                self.const_eval_limit
-            ));
-            warn.emit();
-        }
-    }
-
     /// Take a value, which represents a (thin or wide) reference, and make it a place.
     /// Alignment is just based on the type. This is the inverse of `MemPlace::to_ref()`.
     ///

compiler/rustc_const_eval/src/interpret/step.rs

@@ -62,8 +62,6 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             return Ok(true);
         }
 
-        M::before_terminator(self)?;
-
         let terminator = basic_block.terminator();
         self.terminator(terminator)?;
         Ok(true)
@@ -130,7 +128,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             Coverage(..) => {}
 
             ConstEvalCounter => {
-                self.increment_const_eval_counter();
+                M::increment_const_eval_counter(self)?;
             }
 
             // Defined to do nothing. These are added by optimization passes, to avoid changing the

compiler/rustc_interface/src/tests.rs

@@ -802,6 +802,7 @@ fn test_unstable_options_tracking_hash() {
     tracked!(teach, true);
     tracked!(thinlto, Some(true));
     tracked!(thir_unsafeck, true);
+    tracked!(tiny_const_eval_limit, true);
     tracked!(tls_model, Some(TlsModel::GeneralDynamic));
     tracked!(trait_solver, TraitSolver::Chalk);
     tracked!(translate_remapped_path_to_local_path, false);

compiler/rustc_middle/src/ty/context.rs

@@ -75,6 +75,8 @@ use std::iter;
 use std::mem;
 use std::ops::{Bound, Deref};
 
+const TINY_CONST_EVAL_LIMIT: Limit = Limit(20);
+
 pub trait OnDiskCache<'tcx>: rustc_data_structures::sync::Sync {
     /// Creates a new `OnDiskCache` instance from the serialized data in `data`.
     fn new(sess: &'tcx Session, data: Mmap, start_pos: usize) -> Self
@@ -1078,7 +1080,11 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn const_eval_limit(self) -> Limit {
-        self.limits(()).const_eval_limit
+        if self.sess.opts.unstable_opts.tiny_const_eval_limit {
+            TINY_CONST_EVAL_LIMIT
+        } else {
+            self.limits(()).const_eval_limit
+        }
     }
 
     pub fn all_traits(self) -> impl Iterator<Item = DefId> + 'tcx {

compiler/rustc_session/src/options.rs

@@ -1616,6 +1616,8 @@ options! {
         "measure time of each LLVM pass (default: no)"),
     time_passes: bool = (false, parse_bool, [UNTRACKED],
         "measure time of each rustc pass (default: no)"),
+    tiny_const_eval_limit: bool = (false, parse_bool, [TRACKED],
+        "sets a tiny, non-configurable limit for const eval; useful for compiler tests"),
     #[rustc_lint_opt_deny_field_access("use `Session::tls_model` instead of this field")]
     tls_model: Option<TlsModel> = (None, parse_tls_model, [TRACKED],
         "choose the TLS model to use (`rustc --print tls-models` for details)"),

src/doc/unstable-book/src/compiler-flags/tiny-const-eval-limit.md

@@ -0,0 +1,6 @@
+# `tiny-const-eval-limit`
+
+--------------------
+
+The `-Ztiny-const-eval-limit` compiler flag sets a tiny, non-configurable limit for const eval.
+This flag should only be used by const eval tests in the rustc test suite.

src/test/ui/consts/const-eval/stable-metric/ctfe-fn-call.rs

@@ -1,4 +1,5 @@
-// check-pass
+// check-fail
+// compile-flags: -Z tiny-const-eval-limit
 
 const fn foo() {}
 
@@ -8,21 +9,23 @@ const fn call_foo() -> u32 {
     foo();
     foo();
     foo();
+
     foo();
     foo();
     foo();
     foo();
     foo();
+
     foo();
     foo();
     foo();
     foo();
     foo();
+
     foo();
     foo();
     foo();
-    foo();
-    foo();
+    foo(); //~ ERROR evaluation of constant value failed [E0080]
     0
 }