Ban getting mir_for_ctfe of trivial consts

Author: saethlin

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -292,10 +292,8 @@ pub fn eval_to_const_value_raw_provider<'tcx>(
     tcx: TyCtxt<'tcx>,
     key: ty::PseudoCanonicalInput<'tcx, GlobalId<'tcx>>,
 ) -> ::rustc_middle::mir::interpret::EvalToConstValueResult<'tcx> {
-    if let Some(def) = key.value.instance.def_id().as_local() {
-        if let Some(value) = tcx.is_trivial_const(def) {
-            return Ok(value);
-        }
+    if let Some((value, _ty)) = tcx.is_trivial_const(key.value.instance.def_id()) {
+        return Ok(value);
     }
     tcx.eval_to_allocation_raw(key).map(|val| turn_into_const_value(tcx, val, key))
 }
@@ -361,6 +359,7 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
     typing_env: ty::TypingEnv<'tcx>,
 ) -> Result<R, ErrorHandled> {
     let def = cid.instance.def.def_id();
+
     let is_static = tcx.is_static(def);
 
     let mut ecx = InterpCx::new(
@@ -373,6 +372,18 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
         // so we have to reject reading mutable global memory.
         CompileTimeMachine::new(CanAccessMutGlobal::from(is_static), CheckAlignment::Error),
     );
+
+    if let Some((value, ty)) = tcx.is_trivial_const(def) {
+        let layout = ecx.layout_of(ty).unwrap();
+        let opty = ecx.const_val_to_op(value, ty, Some(layout)).unwrap();
+        let res = ecx.allocate(layout, MemoryKind::Stack).unwrap();
+        ecx.copy_op(&opty, &res).unwrap();
+
+        intern_const_alloc_recursive(&mut ecx, InternKind::Constant, &res).unwrap();
+
+        return Ok(R::make_result(res, &mut ecx));
+    }
+
     let res = ecx.load_mir(cid.instance.def, cid.promoted);
     res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, body))
         .report_err()

compiler/rustc_interface/src/passes.rs

@@ -1198,7 +1198,9 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) {
     if tcx.sess.opts.unstable_opts.validate_mir {
         sess.time("ensuring_final_MIR_is_computable", || {
             tcx.par_hir_body_owners(|def_id| {
-                tcx.instance_mir(ty::InstanceKind::Item(def_id.into()));
+                if tcx.is_trivial_const(def_id).is_none() {
+                    tcx.instance_mir(ty::InstanceKind::Item(def_id.into()));
+                }
             });
         });
     }

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -240,6 +240,7 @@ provide! { tcx, def_id, other, cdata,
     thir_abstract_const => { table }
     optimized_mir => { table }
     mir_for_ctfe => { table }
+    is_trivial_const => { table }
     closure_saved_names_of_captured_variables => { table }
     mir_coroutine_witnesses => { table }
     promoted_mir => { table }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1792,7 +1792,11 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 }
             }
             if encode_const {
-                record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id));
+                if let Some((val, ty)) = tcx.is_trivial_const(def_id) {
+                    record!(self.tables.is_trivial_const[def_id.to_def_id()] <- (val, ty));
+                } else {
+                    record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id));
+                }
 
                 // FIXME(generic_const_exprs): this feels wrong to have in `encode_mir`
                 let abstract_const = tcx.thir_abstract_const(def_id);

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -29,6 +29,7 @@ use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use rustc_middle::middle::lib_features::FeatureStability;
 use rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault;
 use rustc_middle::mir;
+use rustc_middle::mir::ConstValue;
 use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::{self, Ty, TyCtxt, UnusedGenericParams};
 use rustc_middle::util::Providers;
@@ -426,6 +427,7 @@ define_tables! {
     object_lifetime_default: Table<DefIndex, LazyValue<ObjectLifetimeDefault>>,
     optimized_mir: Table<DefIndex, LazyValue<mir::Body<'static>>>,
     mir_for_ctfe: Table<DefIndex, LazyValue<mir::Body<'static>>>,
+    is_trivial_const: Table<DefIndex, LazyValue<(ConstValue, Ty<'static>)>>,
     closure_saved_names_of_captured_variables: Table<DefIndex, LazyValue<IndexVec<FieldIdx, Symbol>>>,
     mir_coroutine_witnesses: Table<DefIndex, LazyValue<mir::CoroutineLayout<'static>>>,
     promoted_mir: Table<DefIndex, LazyValue<IndexVec<mir::Promoted, mir::Body<'static>>>>,

compiler/rustc_metadata/src/rmeta/parameterized.rs

@@ -102,6 +102,7 @@ trivially_parameterized_over_tcx! {
     rustc_middle::middle::lib_features::FeatureStability,
     rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault,
     rustc_middle::mir::ConstQualifs,
+    rustc_middle::mir::ConstValue,
     rustc_middle::ty::AnonConstKind,
     rustc_middle::ty::AssocContainer,
     rustc_middle::ty::AsyncDestructor,

compiler/rustc_middle/src/mir/graphviz.rs

@@ -16,6 +16,7 @@ where
 
     let mirs = def_ids
         .iter()
+        .filter(|def_id| tcx.is_trivial_const(*def_id).is_none())
         .flat_map(|def_id| {
             if tcx.is_const_fn(*def_id) {
                 vec![tcx.optimized_mir(*def_id), tcx.mir_for_ctfe(*def_id)]

compiler/rustc_middle/src/mir/pretty.rs

@@ -353,8 +353,10 @@ pub fn write_mir_pretty<'tcx>(
             // are shared between mir_for_ctfe and optimized_mir
             writer.write_mir_fn(tcx.mir_for_ctfe(def_id), w)?;
         } else {
-            let instance_mir = tcx.instance_mir(ty::InstanceKind::Item(def_id));
-            render_body(w, instance_mir)?;
+            if tcx.is_trivial_const(def_id).is_none() {
+                let instance_mir = tcx.instance_mir(ty::InstanceKind::Item(def_id));
+                render_body(w, instance_mir)?;
+            }
         }
     }
     Ok(())

compiler/rustc_middle/src/query/erase.rs

@@ -164,6 +164,10 @@ impl EraseType for Option<mir::ConstValue> {
     type Result = [u8; size_of::<Option<mir::ConstValue>>()];
 }
 
+impl EraseType for Option<(mir::ConstValue, Ty<'_>)> {
+    type Result = [u8; size_of::<Option<(mir::ConstValue, Ty<'_>)>>()];
+}
+
 impl EraseType for EvalToValTreeResult<'_> {
     type Result = [u8; size_of::<EvalToValTreeResult<'static>>()];
 }

compiler/rustc_middle/src/query/mod.rs

@@ -2719,8 +2719,10 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    query is_trivial_const(def_id: LocalDefId) -> Option<mir::ConstValue> {
+    query is_trivial_const(def_id: DefId) -> Option<(mir::ConstValue, Ty<'tcx>)> {
         desc { |tcx| "checking if `{}` is a trivial const", tcx.def_path_str(def_id) }
+        cache_on_disk_if { def_id.is_local() }
+        separate_provide_extern
     }
 
     /// Checks for the nearest `#[sanitize(xyz = "off")]` or