Deduce param attrs from codegen MIR

Author: saethlin

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

@@ -282,20 +282,6 @@ provide! { tcx, def_id, other, cdata,
             .unwrap_or_else(|| panic!("{def_id:?} does not have eval_static_initializer")))
     }
     trait_def => { table }
-    deduced_param_attrs => {
-        // FIXME: `deduced_param_attrs` has some sketchy encoding settings,
-        // where we don't encode unless we're optimizing, doing codegen,
-        // and not incremental (see `encoder.rs`). I don't think this is right!
-        cdata
-            .root
-            .tables
-            .deduced_param_attrs
-            .get(cdata, def_id.index)
-            .map(|lazy| {
-                &*tcx.arena.alloc_from_iter(lazy.decode((cdata, tcx)))
-            })
-            .unwrap_or_default()
-    }
     opaque_ty_origin => { table }
     assumed_wf_types_for_rpitit => { table }
     collect_return_position_impl_trait_in_trait_tys => {

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -27,7 +27,7 @@ use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::fast_reject::{self, TreatParams};
 use rustc_middle::{bug, span_bug};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque};
-use rustc_session::config::{CrateType, OptLevel, TargetModifier};
+use rustc_session::config::{CrateType, TargetModifier};
 use rustc_span::hygiene::HygieneEncodeContext;
 use rustc_span::{
     ByteSymbol, ExternalSource, FileName, SourceFile, SpanData, SpanEncoder, StableSourceFileId,
@@ -1822,21 +1822,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses);
             }
         }
-
-        // Encode all the deduced parameter attributes for everything that has MIR, even for items
-        // that can't be inlined. But don't if we aren't optimizing in non-incremental mode, to
-        // save the query traffic.
-        if tcx.sess.opts.output_types.should_codegen()
-            && tcx.sess.opts.optimize != OptLevel::No
-            && tcx.sess.opts.incremental.is_none()
-        {
-            for &local_def_id in tcx.mir_keys(()) {
-                if let DefKind::AssocFn | DefKind::Fn = tcx.def_kind(local_def_id) {
-                    record_array!(self.tables.deduced_param_attrs[local_def_id.to_def_id()] <-
-                        self.tcx.deduced_param_attrs(local_def_id.to_def_id()));
-                }
-            }
-        }
     }
 
     #[instrument(level = "debug", skip(self))]

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -29,7 +29,7 @@ use rustc_middle::middle::lib_features::FeatureStability;
 use rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault;
 use rustc_middle::mir;
 use rustc_middle::ty::fast_reject::SimplifiedType;
-use rustc_middle::ty::{self, DeducedParamAttrs, Ty, TyCtxt, UnusedGenericParams};
+use rustc_middle::ty::{self, Ty, TyCtxt, UnusedGenericParams};
 use rustc_middle::util::Providers;
 use rustc_serialize::opaque::FileEncoder;
 use rustc_session::config::{SymbolManglingVersion, TargetModifier};
@@ -462,7 +462,6 @@ define_tables! {
     assoc_container: Table<DefIndex, ty::AssocItemContainer>,
     macro_definition: Table<DefIndex, LazyValue<ast::DelimArgs>>,
     proc_macro: Table<DefIndex, MacroKind>,
-    deduced_param_attrs: Table<DefIndex, LazyArray<DeducedParamAttrs>>,
     trait_impl_trait_tys: Table<DefIndex, LazyValue<DefIdMap<ty::EarlyBinder<'static, Ty<'static>>>>>,
     doc_link_resolutions: Table<DefIndex, LazyValue<DocLinkResMap>>,
     doc_link_traits_in_scope: Table<DefIndex, LazyArray<DefId>>,

compiler/rustc_middle/src/query/mod.rs

@@ -2632,9 +2632,8 @@ rustc_queries! {
         return_result_from_ensure_ok
     }
 
-    query deduced_param_attrs(def_id: DefId) -> &'tcx [ty::DeducedParamAttrs] {
-        desc { |tcx| "deducing parameter attributes for {}", tcx.def_path_str(def_id) }
-        separate_provide_extern
+    query deduced_param_attrs(instance: ty::Instance<'tcx>) -> &'tcx [ty::DeducedParamAttrs] {
+        desc { |tcx| "deducing parameter attributes for {}", instance }
     }
 
     query doc_link_resolutions(def_id: DefId) -> &'tcx DocLinkResMap {

compiler/rustc_mir_transform/src/deduce_param_attrs.rs

@@ -5,11 +5,10 @@
 //! purposes on a best-effort basis. We compute them here and store them into the crate metadata so
 //! dependent crates can use them.
 
-use rustc_hir::def_id::LocalDefId;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::mir::visit::{NonMutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::{Body, Location, Operand, Place, RETURN_PLACE, Terminator, TerminatorKind};
-use rustc_middle::ty::{self, DeducedParamAttrs, Ty, TyCtxt};
+use rustc_middle::ty::{self, DeducedParamAttrs, Instance, Ty, TyCtxt};
 use rustc_session::config::OptLevel;
 
 /// A visitor that determines which arguments have been mutated. We can't use the mutability field
@@ -123,7 +122,7 @@ fn type_will_always_be_passed_directly(ty: Ty<'_>) -> bool {
 /// dependent crates can use them.
 pub(super) fn deduced_param_attrs<'tcx>(
     tcx: TyCtxt<'tcx>,
-    def_id: LocalDefId,
+    instance: Instance<'tcx>,
 ) -> &'tcx [DeducedParamAttrs] {
     // This computation is unfortunately rather expensive, so don't do it unless we're optimizing.
     // Also skip it in incremental mode.
@@ -138,7 +137,7 @@ pub(super) fn deduced_param_attrs<'tcx>(
 
     // Codegen won't use this information for anything if all the function parameters are passed
     // directly. Detect that and bail, for compilation speed.
-    let fn_ty = tcx.type_of(def_id).instantiate_identity();
+    let fn_ty = tcx.type_of(instance.def_id()).instantiate_identity();
     if matches!(fn_ty.kind(), ty::FnDef(..))
         && fn_ty
             .fn_sig(tcx)
@@ -151,13 +150,8 @@ pub(super) fn deduced_param_attrs<'tcx>(
         return &[];
     }
 
-    // Don't deduce any attributes for functions that have no MIR.
-    if !tcx.is_mir_available(def_id) {
-        return &[];
-    }
-
-    // Grab the optimized MIR. Analyze it to determine which arguments have been mutated.
-    let body: &Body<'tcx> = tcx.optimized_mir(def_id);
+    // Grab the codegen MIR. Analyze it to determine which arguments have been mutated.
+    let body: &Body<'tcx> = tcx.build_codegen_mir(instance);
     let mut deduce_read_only = DeduceReadOnly::new(body.arg_count);
     deduce_read_only.visit_body(body);
 

compiler/rustc_ty_utils/src/abi.rs

@@ -9,10 +9,9 @@ use rustc_middle::query::Providers;
 use rustc_middle::ty::layout::{
     FnAbiError, HasTyCtxt, HasTypingEnv, LayoutCx, LayoutOf, TyAndLayout, fn_can_unwind,
 };
-use rustc_middle::ty::{self, InstanceKind, Ty, TyCtxt};
+use rustc_middle::ty::{self, Instance, InstanceKind, Ty, TyCtxt};
 use rustc_session::config::OptLevel;
 use rustc_span::DUMMY_SP;
-use rustc_span::def_id::DefId;
 use rustc_target::callconv::{
     AbiMap, ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, FnAbi, PassMode,
 };
@@ -573,7 +572,7 @@ fn fn_abi_new_uncached<'tcx>(
         // functions from vtable. And for a tls shim, passing the `fn_def_id` would refer to
         // the underlying static. Internally, `deduced_param_attrs` attempts to infer attributes
         // by visit the function body.
-        determined_fn_def_id,
+        instance,
     );
     debug!("fn_abi_new_uncached = {:?}", fn_abi);
     fn_abi_sanity_check(cx, &fn_abi, sig.abi);
@@ -585,7 +584,7 @@ fn fn_abi_adjust_for_abi<'tcx>(
     cx: &LayoutCx<'tcx>,
     fn_abi: &mut FnAbi<'tcx, Ty<'tcx>>,
     abi: ExternAbi,
-    fn_def_id: Option<DefId>,
+    instance: Option<Instance<'tcx>>,
 ) {
     if abi == ExternAbi::Unadjusted {
         // The "unadjusted" ABI passes aggregates in "direct" mode. That's fragile but needed for
@@ -619,7 +618,7 @@ fn fn_abi_adjust_for_abi<'tcx>(
         // as appropriate.
         let deduced_param_attrs =
             if tcx.sess.opts.optimize != OptLevel::No && tcx.sess.opts.incremental.is_none() {
-                fn_def_id.map(|fn_def_id| tcx.deduced_param_attrs(fn_def_id)).unwrap_or_default()
+                instance.map(|instance| tcx.deduced_param_attrs(instance)).unwrap_or_default()
             } else {
                 &[]
             };