Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 76b0553

Browse files
davidtwcodavidtwco
committed
polymorphize: polymorphize shims
This commit removes the restriction of `InstanceDef::Item` on polymorphization, so that shims can now be polymorphized. Signed-off-by: David Wood <david.wood@huawei.com>
1 parent 4528b8e commit 76b0553

File tree

7 files changed

+112
-61
lines changed

7 files changed

+112
-61
lines changed

‎compiler/rustc_const_eval/src/interpret/util.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,8 @@ where
3535
ty::Closure(def_id, substs)
3636
| ty::Generator(def_id, substs, ..)
3737
| ty::FnDef(def_id, substs) => {
38-
let unused_params = self.tcx.unused_generic_params(def_id);
38+
let instance = ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id));
39+
let unused_params = self.tcx.unused_generic_params(instance);
3940
for (index, subst) in substs.into_iter().enumerate() {
4041
let index = index
4142
.try_into()

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

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,12 @@ impl IntoArgs for (CrateNum, DefId) {
8484
}
8585
}
8686

87+
impl IntoArgs for ty::InstanceDef<'tcx> {
88+
fn into_args(self) -> (DefId, DefId) {
89+
(self.def_id(), self.def_id())
90+
}
91+
}
92+
8793
provide! { <'tcx> tcx, def_id, other, cdata,
8894
type_of => { cdata.get_type(def_id.index, tcx) }
8995
generics_of => { cdata.get_generics(def_id.index, tcx.sess) }

‎compiler/rustc_metadata/src/rmeta/encoder.rs

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1320,7 +1320,9 @@ impl EncodeContext<'a, 'tcx> {
13201320
}
13211321
record!(self.tables.promoted_mir[def_id.to_def_id()] <- self.tcx.promoted_mir(def_id));
13221322

1323-
let unused = self.tcx.unused_generic_params(def_id);
1323+
let instance =
1324+
ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id.to_def_id()));
1325+
let unused = self.tcx.unused_generic_params(instance);
13241326
if !unused.is_empty() {
13251327
record!(self.tables.unused_generic_params[def_id.to_def_id()] <- unused);
13261328
}

‎compiler/rustc_middle/src/query/mod.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1551,11 +1551,11 @@ rustc_queries! {
15511551
query codegen_unit(_: Symbol) -> &'tcx CodegenUnit<'tcx> {
15521552
desc { "codegen_unit" }
15531553
}
1554-
query unused_generic_params(key: DefId) -> FiniteBitSet<u32> {
1555-
cache_on_disk_if { key.is_local() }
1554+
query unused_generic_params(key: ty::InstanceDef<'tcx>) -> FiniteBitSet<u32> {
1555+
cache_on_disk_if { key.def_id().is_local() }
15561556
desc {
15571557
|tcx| "determining which generic parameters are unused by `{}`",
1558-
tcx.def_path_str(key)
1558+
tcx.def_path_str(key.def_id())
15591559
}
15601560
}
15611561
query backend_optimization_level(_: ()) -> OptLevel {

‎compiler/rustc_middle/src/ty/instance.rs

Lines changed: 33 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -152,6 +152,22 @@ impl<'tcx> InstanceDef<'tcx> {
152152
}
153153
}
154154

155+
/// Returns the `DefId` of instances which might not require codegen locally.
156+
pub fn def_id_if_not_guaranteed_local_codegen(self) -> Option<DefId> {
157+
match self {
158+
ty::InstanceDef::Item(def) => Some(def.did),
159+
ty::InstanceDef::DropGlue(def_id, Some(_)) => Some(def_id),
160+
InstanceDef::VtableShim(..)
161+
| InstanceDef::ReifyShim(..)
162+
| InstanceDef::FnPtrShim(..)
163+
| InstanceDef::Virtual(..)
164+
| InstanceDef::Intrinsic(..)
165+
| InstanceDef::ClosureOnceShim { .. }
166+
| InstanceDef::DropGlue(..)
167+
| InstanceDef::CloneShim(..) => None,
168+
}
169+
}
170+
155171
#[inline]
156172
pub fn with_opt_param(self) -> ty::WithOptConstParam<DefId> {
157173
match self {
@@ -567,29 +583,26 @@ impl<'tcx> Instance<'tcx> {
567583
return self;
568584
}
569585

570-
if let InstanceDef::Item(def) = self.def {
571-
let polymorphized_substs = polymorphize(tcx, def.did, self.substs);
572-
debug!("polymorphize: self={:?} polymorphized_substs={:?}", self, polymorphized_substs);
573-
Self { def: self.def, substs: polymorphized_substs }
574-
} else {
575-
self
576-
}
586+
let polymorphized_substs = polymorphize(tcx, self.def, self.substs);
587+
debug!("polymorphize: self={:?} polymorphized_substs={:?}", self, polymorphized_substs);
588+
Self { def: self.def, substs: polymorphized_substs }
577589
}
578590
}
579591

580592
fn polymorphize<'tcx>(
581593
tcx: TyCtxt<'tcx>,
582-
def_id: DefId,
594+
instance: ty::InstanceDef<'tcx>,
583595
substs: SubstsRef<'tcx>,
584596
) -> SubstsRef<'tcx> {
585-
debug!("polymorphize({:?}, {:?})", def_id, substs);
586-
let unused = tcx.unused_generic_params(def_id);
597+
debug!("polymorphize({:?}, {:?})", instance, substs);
598+
let unused = tcx.unused_generic_params(instance);
587599
debug!("polymorphize: unused={:?}", unused);
588600

589601
// If this is a closure or generator then we need to handle the case where another closure
590602
// from the function is captured as an upvar and hasn't been polymorphized. In this case,
591603
// the unpolymorphized upvar closure would result in a polymorphized closure producing
592604
// multiple mono items (and eventually symbol clashes).
605+
let def_id = instance.def_id();
593606
let upvars_ty = if tcx.is_closure(def_id) {
594607
Some(substs.as_closure().tupled_upvars_ty())
595608
} else if tcx.type_of(def_id).is_generator() {
@@ -613,15 +626,23 @@ fn polymorphize<'tcx>(
613626
debug!("fold_ty: ty={:?}", ty);
614627
match ty.kind {
615628
ty::Closure(def_id, substs) => {
616-
let polymorphized_substs = polymorphize(self.tcx, def_id, substs);
629+
let polymorphized_substs = polymorphize(
630+
self.tcx,
631+
ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id)),
632+
substs,
633+
);
617634
if substs == polymorphized_substs {
618635
ty
619636
} else {
620637
self.tcx.mk_closure(def_id, polymorphized_substs)
621638
}
622639
}
623640
ty::Generator(def_id, substs, movability) => {
624-
let polymorphized_substs = polymorphize(self.tcx, def_id, substs);
641+
let polymorphized_substs = polymorphize(
642+
self.tcx,
643+
ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id)),
644+
substs,
645+
);
625646
if substs == polymorphized_substs {
626647
ty
627648
} else {

‎compiler/rustc_monomorphize/src/collector.rs

Lines changed: 6 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -936,21 +936,13 @@ fn visit_instance_use<'tcx>(
936936
}
937937
}
938938

939-
// Returns `true` if we should codegen an instance in the local crate.
940-
// Returns `false` if we can just link to the upstream crate and therefore don't
941-
// need a mono item.
939+
/// Returns `true` if we should codegen an instance in the local crate, or returns `false` if we
940+
/// can just link to the upstream crate and therefore don't need a mono item.
942941
fn should_codegen_locally<'tcx>(tcx: TyCtxt<'tcx>, instance: &Instance<'tcx>) -> bool {
943-
let def_id = match instance.def {
944-
ty::InstanceDef::Item(def) => def.did,
945-
ty::InstanceDef::DropGlue(def_id, Some(_)) => def_id,
946-
ty::InstanceDef::VtableShim(..)
947-
| ty::InstanceDef::ReifyShim(..)
948-
| ty::InstanceDef::ClosureOnceShim { .. }
949-
| ty::InstanceDef::Virtual(..)
950-
| ty::InstanceDef::FnPtrShim(..)
951-
| ty::InstanceDef::DropGlue(..)
952-
| ty::InstanceDef::Intrinsic(_)
953-
| ty::InstanceDef::CloneShim(..) => return true,
942+
let def_id = if let Some(def_id) = instance.def.def_id_if_not_guaranteed_local_codegen() {
943+
def_id
944+
} else {
945+
return true;
954946
};
955947

956948
if tcx.is_foreign_item(def_id) {

‎compiler/rustc_monomorphize/src/polymorphize.rs

Lines changed: 59 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -27,20 +27,23 @@ pub fn provide(providers: &mut Providers) {
2727
providers.unused_generic_params = unused_generic_params;
2828
}
2929

30-
/// Determine which generic parameters are used by the function/method/closure represented by
31-
/// `def_id`. Returns a bitset where bits representing unused parameters are set (`is_empty`
32-
/// indicates all parameters are used).
30+
/// Determine which generic parameters are used by the instance.
31+
///
32+
/// Returns a bitset where bits representing unused parameters are set (`is_empty` indicates all
33+
/// parameters are used).
3334
#[instrument(level = "debug", skip(tcx))]
34-
fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> FiniteBitSet<u32> {
35+
fn unused_generic_params<'tcx>(
36+
tcx: TyCtxt<'tcx>,
37+
instance: ty::InstanceDef<'tcx>,
38+
) -> FiniteBitSet<u32> {
3539
if !tcx.sess.opts.debugging_opts.polymorphize {
3640
// If polymorphization disabled, then all parameters are used.
3741
return FiniteBitSet::new_empty();
3842
}
3943

40-
// Polymorphization results are stored in cross-crate metadata only when there are unused
41-
// parameters, so assume that non-local items must have only used parameters (else this query
42-
// would not be invoked, and the cross-crate metadata used instead).
43-
if !def_id.is_local() {
44+
let def_id = instance.def_id();
45+
// Exit early if this instance should not be polymorphized.
46+
if !should_polymorphize(tcx, def_id, instance) {
4447
return FiniteBitSet::new_empty();
4548
}
4649

@@ -52,38 +55,20 @@ fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> FiniteBitSet<u32> {
5255
return FiniteBitSet::new_empty();
5356
}
5457

55-
// Exit early for foreign items, these have no bodies to analyze.
56-
if tcx.is_foreign_item(def_id) {
57-
return FiniteBitSet::new_empty();
58-
}
59-
60-
// Exit early when there is no MIR available.
61-
let context = tcx.hir().body_const_context(def_id.expect_local());
62-
match context {
63-
Some(ConstContext::ConstFn) | None if !tcx.is_mir_available(def_id) => {
64-
debug!("no mir available");
65-
return FiniteBitSet::new_empty();
66-
}
67-
Some(_) if !tcx.is_ctfe_mir_available(def_id) => {
68-
debug!("no ctfe mir available");
69-
return FiniteBitSet::new_empty();
70-
}
71-
_ => {}
72-
}
73-
7458
// Create a bitset with N rightmost ones for each parameter.
7559
let generics_count: u32 =
7660
generics.count().try_into().expect("more generic parameters than can fit into a `u32`");
7761
let mut unused_parameters = FiniteBitSet::<u32>::new_empty();
7862
unused_parameters.set_range(0..generics_count);
7963
debug!(?unused_parameters, "(start)");
64+
8065
mark_used_by_default_parameters(tcx, def_id, generics, &mut unused_parameters);
8166
debug!(?unused_parameters, "(after default)");
8267

8368
// Visit MIR and accumululate used generic parameters.
84-
let body = match context {
69+
let body = match tcx.hir().body_const_context(def_id.expect_local()) {
8570
// Const functions are actually called and should thus be considered for polymorphization
86-
// via their runtime MIR
71+
// via their runtime MIR.
8772
Some(ConstContext::ConstFn) | None => tcx.optimized_mir(def_id),
8873
Some(_) => tcx.mir_for_ctfe(def_id),
8974
};
@@ -99,6 +84,49 @@ fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> FiniteBitSet<u32> {
9984
unused_parameters
10085
}
10186

87+
/// Returns `true` if the instance should be polymorphized.
88+
fn should_polymorphize<'tcx>(
89+
tcx: TyCtxt<'tcx>,
90+
def_id: DefId,
91+
instance: ty::InstanceDef<'tcx>,
92+
) -> bool {
93+
// If an instance's MIR body is not polymorphic then the modified substitutions that are
94+
// derived from polymorphization's result won't make any difference.
95+
if !instance.has_polymorphic_mir_body() {
96+
return false;
97+
}
98+
99+
// Don't polymorphize intrinsics or virtual calls - calling `instance_mir` will panic.
100+
if matches!(instance, ty::InstanceDef::Intrinsic(..) | ty::InstanceDef::Virtual(..)) {
101+
return false;
102+
}
103+
104+
// Polymorphization results are stored in cross-crate metadata only when there are unused
105+
// parameters, so assume that non-local items must have only used parameters (else this query
106+
// would not be invoked, and the cross-crate metadata used instead).
107+
if !def_id.is_local() {
108+
return false;
109+
}
110+
111+
// Foreign items have no bodies to analyze.
112+
if tcx.is_foreign_item(def_id) {
113+
return false;
114+
}
115+
116+
// Make sure there is MIR available.
117+
match tcx.hir().body_const_context(def_id.expect_local()) {
118+
Some(ConstContext::ConstFn) | None if !tcx.is_mir_available(def_id) => {
119+
debug!("no mir available");
120+
return false;
121+
}
122+
Some(_) if !tcx.is_ctfe_mir_available(def_id) => {
123+
debug!("no ctfe mir available");
124+
return false;
125+
}
126+
_ => true,
127+
}
128+
}
129+
102130
/// Some parameters are considered used-by-default, such as non-generic parameters and the dummy
103131
/// generic parameters from closures, this function marks them as used. `leaf_is_closure` should
104132
/// be `true` if the item that `unused_generic_params` was invoked on is a closure.
@@ -207,7 +235,8 @@ impl<'a, 'tcx> MarkUsedGenericParams<'a, 'tcx> {
207235
/// a closure, generator or constant).
208236
#[instrument(level = "debug", skip(self, def_id, substs))]
209237
fn visit_child_body(&mut self, def_id: DefId, substs: SubstsRef<'tcx>) {
210-
let unused = self.tcx.unused_generic_params(def_id);
238+
let instance = ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id));
239+
let unused = self.tcx.unused_generic_params(instance);
211240
debug!(?self.unused_parameters, ?unused);
212241
for (i, arg) in substs.iter().enumerate() {
213242
let i = i.try_into().unwrap();

0 commit comments

Comments
 (0)