instance: polymorphize shims

davidtwco · davidtwco · commit 22409f0297fa · 2021-01-13T22:30:46.000Z
This commit removes the restriction of `InstanceDef::Item` on
polymorphization, so that shims can now be polymorphized. In addition,
`unused_generic_params` now takes a `ty::InstanceDef` so that
`instance_mir` can be invoked and actual shim MIR can be fetched (rather
than whatever you get from the `instance.def_id()`'s MIR).

Signed-off-by: David Wood &lt;david@davidtw.co&gt;
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -86,6 +86,12 @@ impl IntoArgs for (CrateNum, DefId) {
     }
 }
 
+impl IntoArgs for ty::InstanceDef<'tcx> {
+    fn into_args(self) -> (DefId, DefId) {
+        (self.def_id(), self.def_id())
+    }
+}
+
 provide! { <'tcx> tcx, def_id, other, cdata,
     type_of => { cdata.get_type(def_id.index, tcx) }
     generics_of => { cdata.get_generics(def_id.index, tcx.sess) }
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1138,7 +1138,8 @@ impl EncodeContext<'a, 'tcx> {
         debug!("EntryBuilder::encode_mir_for_ctfe({:?})", def_id);
         record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- self.tcx.mir_for_ctfe(def_id));
 
-        let unused = self.tcx.unused_generic_params(def_id);
+        let instance = ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id.to_def_id()));
+        let unused = self.tcx.unused_generic_params(instance);
         if !unused.is_empty() {
             record!(self.tables.unused_generic_params[def_id.to_def_id()] <- unused);
         }
@@ -1153,7 +1154,8 @@ impl EncodeContext<'a, 'tcx> {
         debug!("EntryBuilder::encode_optimized_mir({:?})", def_id);
         record!(self.tables.mir[def_id.to_def_id()] <- self.tcx.optimized_mir(def_id));
 
-        let unused = self.tcx.unused_generic_params(def_id);
+        let instance = ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id.to_def_id()));
+        let unused = self.tcx.unused_generic_params(instance);
         if !unused.is_empty() {
             record!(self.tables.unused_generic_params[def_id.to_def_id()] <- unused);
         }
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
@@ -1469,11 +1469,11 @@ rustc_queries! {
         query codegen_unit(_: Symbol) -> &'tcx CodegenUnit<'tcx> {
             desc { "codegen_unit" }
         }
-        query unused_generic_params(key: DefId) -> FiniteBitSet<u32> {
-            cache_on_disk_if { key.is_local() }
+        query unused_generic_params(key: ty::InstanceDef<'tcx>) -> FiniteBitSet<u32> {
+            cache_on_disk_if { key.def_id().is_local() }
             desc {
                 |tcx| "determining which generic parameters are unused by `{}`",
-                    tcx.def_path_str(key)
+                    tcx.def_path_str(key.def_id())
             }
         }
         query backend_optimization_level(_: CrateNum) -> OptLevel {
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
@@ -152,6 +152,22 @@ impl<'tcx> InstanceDef<'tcx> {
         }
     }
 
+    /// Returns the `DefId` of instances which might not require codegen locally.
+    pub fn def_id_if_not_guaranteed_local_codegen(self) -> Option<DefId> {
+        match self {
+            ty::InstanceDef::Item(def) => Some(def.did),
+            ty::InstanceDef::DropGlue(def_id, Some(_)) => Some(def_id),
+            ty::InstanceDef::VtableShim(..)
+            | ty::InstanceDef::ReifyShim(..)
+            | ty::InstanceDef::ClosureOnceShim { .. }
+            | ty::InstanceDef::Virtual(..)
+            | ty::InstanceDef::FnPtrShim(..)
+            | ty::InstanceDef::DropGlue(..)
+            | ty::InstanceDef::Intrinsic(_)
+            | ty::InstanceDef::CloneShim(..) => None,
+        }
+    }
+
     #[inline]
     pub fn with_opt_param(self) -> ty::WithOptConstParam<DefId> {
         match self {
@@ -505,29 +521,26 @@ impl<'tcx> Instance<'tcx> {
             return self;
         }
 
-        if let InstanceDef::Item(def) = self.def {
-            let polymorphized_substs = polymorphize(tcx, def.did, self.substs);
-            debug!("polymorphize: self={:?} polymorphized_substs={:?}", self, polymorphized_substs);
-            Self { def: self.def, substs: polymorphized_substs }
-        } else {
-            self
-        }
+        let polymorphized_substs = polymorphize(tcx, self.def, self.substs);
+        debug!("polymorphize: self={:?} polymorphized_substs={:?}", self, polymorphized_substs);
+        Self { def: self.def, substs: polymorphized_substs }
     }
 }
 
 fn polymorphize<'tcx>(
     tcx: TyCtxt<'tcx>,
-    def_id: DefId,
+    instance: ty::InstanceDef<'tcx>,
     substs: SubstsRef<'tcx>,
 ) -> SubstsRef<'tcx> {
-    debug!("polymorphize({:?}, {:?})", def_id, substs);
-    let unused = tcx.unused_generic_params(def_id);
+    debug!("polymorphize({:?}, {:?})", instance, substs);
+    let unused = tcx.unused_generic_params(instance);
     debug!("polymorphize: unused={:?}", unused);
 
     // If this is a closure or generator then we need to handle the case where another closure
     // from the function is captured as an upvar and hasn't been polymorphized. In this case,
     // the unpolymorphized upvar closure would result in a polymorphized closure producing
     // multiple mono items (and eventually symbol clashes).
+    let def_id = instance.def_id();
     let upvars_ty = if tcx.is_closure(def_id) {
         Some(substs.as_closure().tupled_upvars_ty())
     } else if tcx.type_of(def_id).is_generator() {
@@ -551,15 +564,25 @@ fn polymorphize<'tcx>(
             debug!("fold_ty: ty={:?}", ty);
             match ty.kind {
                 ty::Closure(def_id, substs) => {
-                    let polymorphized_substs = polymorphize(self.tcx, def_id, substs);
+                    let polymorphized_substs = polymorphize(
+                        self.tcx,
+                        ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id)),
+                        substs,
+                    );
+
                     if substs == polymorphized_substs {
                         ty
                     } else {
                         self.tcx.mk_closure(def_id, polymorphized_substs)
                     }
                 }
                 ty::Generator(def_id, substs, movability) => {
-                    let polymorphized_substs = polymorphize(self.tcx, def_id, substs);
+                    let polymorphized_substs = polymorphize(
+                        self.tcx,
+                        ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id)),
+                        substs,
+                    );
+
                     if substs == polymorphized_substs {
                         ty
                     } else {
diff --git a/compiler/rustc_mir/src/interpret/util.rs b/compiler/rustc_mir/src/interpret/util.rs
@@ -42,7 +42,8 @@ where
                 ty::Closure(def_id, substs)
                 | ty::Generator(def_id, substs, ..)
                 | ty::FnDef(def_id, substs) => {
-                    let unused_params = self.tcx.unused_generic_params(def_id);
+                    let instance = ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id));
+                    let unused_params = self.tcx.unused_generic_params(instance);
                     for (index, subst) in substs.into_iter().enumerate() {
                         let index = index
                             .try_into()
diff --git a/compiler/rustc_mir/src/monomorphize/collector.rs b/compiler/rustc_mir/src/monomorphize/collector.rs
@@ -788,21 +788,13 @@ fn visit_instance_use<'tcx>(
     }
 }
 
-// Returns `true` if we should codegen an instance in the local crate.
-// Returns `false` if we can just link to the upstream crate and therefore don't
-// need a mono item.
+/// Returns `true` if we should codegen an instance in the local crate, or returns `false` if we
+/// can just link to the upstream crate and therefore don't need a mono item.
 fn should_codegen_locally<'tcx>(tcx: TyCtxt<'tcx>, instance: &Instance<'tcx>) -> bool {
-    let def_id = match instance.def {
-        ty::InstanceDef::Item(def) => def.did,
-        ty::InstanceDef::DropGlue(def_id, Some(_)) => def_id,
-        ty::InstanceDef::VtableShim(..)
-        | ty::InstanceDef::ReifyShim(..)
-        | ty::InstanceDef::ClosureOnceShim { .. }
-        | ty::InstanceDef::Virtual(..)
-        | ty::InstanceDef::FnPtrShim(..)
-        | ty::InstanceDef::DropGlue(..)
-        | ty::InstanceDef::Intrinsic(_)
-        | ty::InstanceDef::CloneShim(..) => return true,
+    let def_id = if let Some(def_id) = instance.def.def_id_if_not_guaranteed_local_codegen() {
+        def_id
+    } else {
+        return true;
     };
 
     if tcx.is_foreign_item(def_id) {
diff --git a/compiler/rustc_mir/src/monomorphize/polymorphize.rs b/compiler/rustc_mir/src/monomorphize/polymorphize.rs
@@ -16,7 +16,7 @@ use rustc_middle::ty::{
     fold::{TypeFoldable, TypeVisitor},
     query::Providers,
     subst::SubstsRef,
-    Const, Ty, TyCtxt,
+    Const, InstanceDef, Ty, TyCtxt,
 };
 use rustc_span::symbol::sym;
 use std::convert::TryInto;
@@ -27,21 +27,25 @@ pub fn provide(providers: &mut Providers) {
     providers.unused_generic_params = unused_generic_params;
 }
 
-/// Determine which generic parameters are used by the function/method/closure represented by
-/// `def_id`. Returns a bitset where bits representing unused parameters are set (`is_empty`
+/// Determine which generic parameters are used by the `instance`.
+///
+/// Returns a bitset where bits representing unused parameters are set (`is_empty`
 /// indicates all parameters are used).
-fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> FiniteBitSet<u32> {
-    debug!("unused_generic_params({:?})", def_id);
+fn unused_generic_params<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    instance: InstanceDef<'tcx>,
+) -> FiniteBitSet<u32> {
+    debug!("unused_generic_params({:?})", instance);
 
+    // If polymorphization disabled, then all parameters are used.
     if !tcx.sess.opts.debugging_opts.polymorphize {
-        // If polymorphization disabled, then all parameters are used.
         return FiniteBitSet::new_empty();
     }
 
-    // Polymorphization results are stored in cross-crate metadata only when there are unused
-    // parameters, so assume that non-local items must have only used parameters (else this query
-    // would not be invoked, and the cross-crate metadata used instead).
-    if !def_id.is_local() {
+    // Exit early if this instance should not be polymorphized.
+    let def_id = instance.def_id();
+    if !should_polymorphize(tcx, def_id, instance) {
+        debug!("unused_generic_params: skipping");
         return FiniteBitSet::new_empty();
     }
 
@@ -53,36 +57,24 @@ fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> FiniteBitSet<u32> {
         return FiniteBitSet::new_empty();
     }
 
-    // Exit early when there is no MIR available.
-    let context = tcx.hir().body_const_context(def_id.expect_local());
-    match context {
-        Some(ConstContext::ConstFn) | None if !tcx.is_mir_available(def_id) => {
-            debug!("unused_generic_params: (no mir available) def_id={:?}", def_id);
-            return FiniteBitSet::new_empty();
-        }
-        Some(_) if !tcx.is_ctfe_mir_available(def_id) => {
-            debug!("unused_generic_params: (no ctfe mir available) def_id={:?}", def_id);
-            return FiniteBitSet::new_empty();
-        }
-        _ => {}
-    }
-
     // Create a bitset with N rightmost ones for each parameter.
     let generics_count: u32 =
         generics.count().try_into().expect("more generic parameters than can fit into a `u32`");
     let mut unused_parameters = FiniteBitSet::<u32>::new_empty();
     unused_parameters.set_range(0..generics_count);
     debug!("unused_generic_params: (start) unused_parameters={:?}", unused_parameters);
+
     mark_used_by_default_parameters(tcx, def_id, generics, &mut unused_parameters);
     debug!("unused_generic_params: (after default) unused_parameters={:?}", unused_parameters);
 
-    // Visit MIR and accumululate used generic parameters.
-    let body = match context {
+    let body = match tcx.hir().body_const_context(def_id.expect_local()) {
         // Const functions are actually called and should thus be considered for polymorphization
-        // via their runtime MIR
+        // via their runtime MIR.
         Some(ConstContext::ConstFn) | None => tcx.optimized_mir(def_id),
         Some(_) => tcx.mir_for_ctfe(def_id),
     };
+
+    // Visit MIR and accumululate used generic parameters.
     let mut vis = MarkUsedGenericParams { tcx, def_id, unused_parameters: &mut unused_parameters };
     vis.visit_body(body);
     debug!("unused_generic_params: (after visitor) unused_parameters={:?}", unused_parameters);
@@ -98,6 +90,48 @@ fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> FiniteBitSet<u32> {
     unused_parameters
 }
 
+/// Returns `true` if the `InstanceDef` should be polymorphized.
+fn should_polymorphize<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def_id: DefId,
+    instance: ty::InstanceDef<'tcx>,
+) -> bool {
+    // If a instance's MIR body is not polymorphic then the modified substitutions that are derived
+    // from polymorphization's result won't make any difference.
+    if !instance.has_polymorphic_mir_body() {
+        return false;
+    }
+
+    // Don't polymorphize intrinsics or virtual calls - calling `instance_mir` will panic.
+    if matches!(instance, ty::InstanceDef::Intrinsic(..) | ty::InstanceDef::Virtual(..)) {
+        return false;
+    }
+
+    // Polymorphization results are stored in cross-crate metadata only when there are unused
+    // parameters, so assume that non-local items must have only used parameters (else this query
+    // would not be invoked, and the cross-crate metadata used instead).
+    if !def_id.is_local() {
+        return false;
+    }
+
+    // Foreign items don't have a body to analyze.
+    if tcx.is_foreign_item(def_id) {
+        return false;
+    }
+
+    // Without available MIR, polymorphization has nothing to analyze.
+    match tcx.hir().body_const_context(def_id.expect_local()) {
+        // FIXME(davidtwco): Disable polymorphization for any constant functions which, at the time
+        // of writing, can result in an ICE from typeck in one test and a cycle error in another.
+        Some(_) => false,
+        None if !tcx.is_mir_available(def_id) => {
+            debug!("should_polymorphize: (no mir available) def_id={:?}", def_id);
+            false
+        }
+        None => true,
+    }
+}
+
 /// Some parameters are considered used-by-default, such as non-generic parameters and the dummy
 /// generic parameters from closures, this function marks them as used. `leaf_is_closure` should
 /// be `true` if the item that `unused_generic_params` was invoked on is a closure.
@@ -220,7 +254,9 @@ impl<'a, 'tcx> MarkUsedGenericParams<'a, 'tcx> {
     /// Invoke `unused_generic_params` on a body contained within the current item (e.g.
     /// a closure, generator or constant).
     fn visit_child_body(&mut self, def_id: DefId, substs: SubstsRef<'tcx>) {
-        let unused = self.tcx.unused_generic_params(def_id);
+        let unused = self
+            .tcx
+            .unused_generic_params(ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id)));
         debug!(
             "visit_child_body: unused_parameters={:?} unused={:?}",
             self.unused_parameters, unused

Original file line number	Diff line number	Diff line change
`@@ -86,6 +86,12 @@ impl IntoArgs for (CrateNum, DefId) {`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
	`89`	`+impl IntoArgs for ty::InstanceDef<'tcx> {`
	`90`	`+ fn into_args(self) -> (DefId, DefId) {`
	`91`	`+ (self.def_id(), self.def_id())`
	`92`	`+ }`
	`93`	`+}`
	`94`	`+`
`89`	`95`	`provide! { <'tcx> tcx, def_id, other, cdata,`
`90`	`96`	`type_of => { cdata.get_type(def_id.index, tcx) }`
`91`	`97`	`generics_of => { cdata.get_generics(def_id.index, tcx.sess) }`
Original file line number	Diff line number	Diff line change
`@@ -1469,11 +1469,11 @@ rustc_queries! {`
`1469`	`1469`	`query codegen_unit(_: Symbol) -> &'tcx CodegenUnit<'tcx> {`
`1470`	`1470`	`desc { "codegen_unit" }`
`1471`	`1471`	`}`
`1472`		`- query unused_generic_params(key: DefId) -> FiniteBitSet<u32> {`
`1473`		`- cache_on_disk_if { key.is_local() }`
	`1472`	`+ query unused_generic_params(key: ty::InstanceDef<'tcx>) -> FiniteBitSet<u32> {`
	`1473`	`+ cache_on_disk_if { key.def_id().is_local() }`
`1474`	`1474`	`desc {`
`1475`	`1475`	\|tcx\| "determining which generic parameters are unused by `{}`",
`1476`		`- tcx.def_path_str(key)`
	`1476`	`+ tcx.def_path_str(key.def_id())`
`1477`	`1477`	`}`
`1478`	`1478`	`}`
`1479`	`1479`	`query backend_optimization_level(_: CrateNum) -> OptLevel {`