Introduce MIR summary to avoid loading large bodies without inlining them

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

@@ -201,6 +201,7 @@ provide! { <'tcx> tcx, def_id, other, cdata,
     const_param_default => { table }
     thir_abstract_const => { table }
     optimized_mir => { table }
+    optimized_mir_summary => { table }
     mir_for_ctfe => { table }
     promoted_mir => { table }
     def_span => { table }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1352,6 +1352,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             debug!("EntryBuilder::encode_mir({:?})", def_id);
             if encode_opt {
                 record!(self.tables.optimized_mir[def_id.to_def_id()] <- self.tcx.optimized_mir(def_id));
+                record!(self.tables.optimized_mir_summary[def_id.to_def_id()] <- self.tcx.optimized_mir_summary(def_id));
             }
             if encode_const {
                 record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- self.tcx.mir_for_ctfe(def_id));

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -360,6 +360,7 @@ define_tables! {
     optimized_mir: Table<DefIndex, LazyValue<mir::Body<'static>>>,
     mir_for_ctfe: Table<DefIndex, LazyValue<mir::Body<'static>>>,
     promoted_mir: Table<DefIndex, LazyValue<IndexVec<mir::Promoted, mir::Body<'static>>>>,
+    optimized_mir_summary: Table<DefIndex, LazyValue<mir::Summary>>,
     // FIXME(compiler-errors): Why isn't this a LazyArray?
     thir_abstract_const: Table<DefIndex, LazyValue<&'static [ty::abstract_const::Node<'static>]>>,
     impl_parent: Table<DefIndex, RawDefId>,

compiler/rustc_middle/src/mir/mod.rs

@@ -2900,3 +2900,10 @@ impl Location {
         }
     }
 }
+
+#[derive(Debug, Copy, Clone, HashStable, Encodable, Decodable)]
+pub struct Summary {
+    pub inlining_cost: usize,
+    pub bbcount: usize,
+    pub diverges: bool,
+}

compiler/rustc_middle/src/query/mod.rs

@@ -431,6 +431,13 @@ rustc_queries! {
         separate_provide_extern
     }
 
+    /// Summary of `optimized_mir` to avoid decoding it when we are not planning to use it.
+    query optimized_mir_summary(key: DefId) -> mir::Summary {
+        desc { |tcx| "summarizing MIR for `{}`", tcx.def_path_str(key) }
+        cache_on_disk_if { key.is_local() }
+        separate_provide_extern
+    }
+
     /// Returns coverage summary info for a function, after executing the `InstrumentCoverage`
     /// MIR pass (assuming the -Cinstrument-coverage option is enabled).
     query coverageinfo(key: ty::InstanceDef<'tcx>) -> mir::CoverageInfo {

compiler/rustc_middle/src/ty/mod.rs

@@ -17,7 +17,7 @@ pub use self::IntVarValue::*;
 pub use self::Variance::*;
 use crate::metadata::ModChild;
 use crate::middle::privacy::AccessLevels;
-use crate::mir::{Body, GeneratorLayout};
+use crate::mir::{self, Body, GeneratorLayout};
 use crate::traits::{self, Reveal};
 use crate::ty;
 use crate::ty::fast_reject::SimplifiedType;
@@ -2160,6 +2160,38 @@ impl<'tcx> TyCtxt<'tcx> {
         }
     }
 
+    /// Returns the possibly-auto-generated MIR of a `(DefId, Subst)` pair.
+    pub fn instance_mir_summary(self, instance: ty::InstanceDef<'tcx>) -> mir::Summary {
+        match instance {
+            ty::InstanceDef::Item(def) => match self.def_kind(def.did) {
+                DefKind::Const
+                | DefKind::Static(..)
+                | DefKind::AssocConst
+                | DefKind::Ctor(..)
+                | DefKind::AnonConst
+                | DefKind::InlineConst => {
+                    mir::Summary { inlining_cost: 0, bbcount: 0, diverges: false }
+                }
+                // If the caller wants `mir_for_ctfe` of a function they should not be using
+                // `instance_mir`, so we'll assume const fn also wants the optimized version.
+                _ => {
+                    assert_eq!(def.const_param_did, None);
+                    self.optimized_mir_summary(def.did)
+                }
+            },
+            ty::InstanceDef::VTableShim(..)
+            | ty::InstanceDef::ReifyShim(..)
+            | ty::InstanceDef::Intrinsic(..)
+            | ty::InstanceDef::FnPtrShim(..)
+            | ty::InstanceDef::Virtual(..)
+            | ty::InstanceDef::ClosureOnceShim { .. }
+            | ty::InstanceDef::DropGlue(..)
+            | ty::InstanceDef::CloneShim(..) => {
+                mir::Summary { inlining_cost: 0, bbcount: 0, diverges: false }
+            }
+        }
+    }
+
     // FIXME(@lcnr): Remove this function.
     pub fn get_attrs_unchecked(self, did: DefId) -> &'tcx [ast::Attribute] {
         if let Some(did) = did.as_local() {

compiler/rustc_middle/src/ty/parameterized.rs

@@ -54,6 +54,7 @@ trivially_parameterized_over_tcx! {
     crate::middle::codegen_fn_attrs::CodegenFnAttrs,
     crate::middle::exported_symbols::SymbolExportInfo,
     crate::mir::ConstQualifs,
+    crate::mir::Summary,
     ty::Generics,
     ty::ImplPolarity,
     ty::ReprOptions,