use rustc::middle::exported_symbols::{metadata_symbol_name, ExportedSymbol, SymbolExportLevel};
use rustc::session::config::{self, Sanitizer};
use rustc::ty::query::Providers;
-use rustc::ty::subst::SubstsRef;
+use rustc::ty::subst::{GenericArgKind, SubstsRef};
use rustc::ty::Instance;
use rustc::ty::{SymbolName, TyCtxt};
use rustc_codegen_utils::symbol_names;
continue;
}
- if let &MonoItem::Fn(Instance { def: InstanceDef::Item(def_id), substs }) = mono_item {
- if substs.non_erasable_generics().next().is_some() {
- symbols
- .push((ExportedSymbol::Generic(def_id, substs), SymbolExportLevel::Rust));
+ match *mono_item {
+ MonoItem::Fn(Instance { def: InstanceDef::Item(def_id), substs }) => {
+ if substs.non_erasable_generics().next().is_some() {
+ let symbol = ExportedSymbol::Generic(def_id, substs);
+ symbols.push((symbol, SymbolExportLevel::Rust));
+ }
+ }
+ MonoItem::Fn(Instance { def: InstanceDef::DropGlue(def_id, Some(ty)), substs }) => {
+ // A little sanity-check
+ debug_assert_eq!(
+ substs.non_erasable_generics().next(),
+ Some(GenericArgKind::Type(ty))
+ );
+ let symbol = ExportedSymbol::Generic(def_id, substs);
+ symbols.push((symbol, SymbolExportLevel::Rust));
+ }
+ _ => {
+ // Any other symbols don't qualify for sharing
}
}
}
}
// Sort so we get a stable incr. comp. hash.
- symbols.sort_unstable_by(|&(ref symbol1, ..), &(ref symbol2, ..)| {
- symbol1.compare_stable(tcx, symbol2)
- });
+ symbols.sort_by_cached_key(|s| s.0.symbol_name_for_local_instance(tcx));
Arc::new(symbols)
}
// need a mono item.
fn should_monomorphize_locally<'tcx>(tcx: TyCtxt<'tcx>, instance: &Instance<'tcx>) -> bool {
let def_id = match instance.def {
- ty::InstanceDef::Item(def_id) => def_id,
+ ty::InstanceDef::Item(def_id) | ty::InstanceDef::DropGlue(def_id, Some(_)) => def_id,
+
ty::InstanceDef::VtableShim(..)
| ty::InstanceDef::ReifyShim(..)
| ty::InstanceDef::ClosureOnceShim { .. }
};
if tcx.is_foreign_item(def_id) {
- // We can always link to foreign items.
+ // Foreign items are always linked against, there's no way of
+ // instantiating them.
return false;
}
if def_id.is_local() {
- // Local items cannot be referred to locally without monomorphizing them locally.
+ // Local items cannot be referred to locally without
+ // monomorphizing them locally.
return true;
}
if !tcx.is_mir_available(def_id) {
bug!("cannot create local mono-item for {:?}", def_id)
}
+
return true;
fn is_available_upstream_generic<'tcx>(
};
let def_id = match instance.def {
- InstanceDef::Item(def_id) => def_id,
+ InstanceDef::Item(def_id) | InstanceDef::DropGlue(def_id, Some(_)) => def_id,
// These are all compiler glue and such, never exported, always hidden.
InstanceDef::VtableShim(..)
-// compile-flags:-Zshare-generics=yes
+// NOTE: We always compile this test with -Copt-level=0 because higher opt-levels
+// prevent drop-glue from participating in share-generics.
+// compile-flags:-Zshare-generics=yes -Copt-level=0
// no-prefer-dynamic
#![crate_type="rlib"]
}
pub fn use_generic_fn_f32() -> (f32, f32) {
+ // This line causes drop glue for Foo to be instantiated. We want to make
+ // sure that this crate exports an instance to be re-used by share-generics.
+ let _ = Foo(0);
+
generic_fn(0.0f32, 1.0f32)
}
+
+pub struct Foo(pub u32);
+
+impl Drop for Foo {
+ fn drop(&mut self) {
+ println!("foo");
+ }
+}
// ignore-tidy-linelength
// no-prefer-dynamic
-// compile-flags:-Zprint-mono-items=eager -Zshare-generics=yes -Zincremental=tmp/partitioning-tests/shared-generics-exe
+// NOTE: We always compile this test with -Copt-level=0 because higher opt-levels
+// prevent drop-glue from participating in share-generics.
+// compile-flags:-Zprint-mono-items=eager -Zshare-generics=yes -Zincremental=tmp/partitioning-tests/shared-generics-exe -Copt-level=0
#![crate_type="rlib"]
// This should not generate a monomorphization because it's already
// available in `shared_generics_aux`.
let _ = shared_generics_aux::generic_fn(0.0f32, 3.0f32);
-}
-// MONO_ITEM drop-glue i8
+ // The following line will drop an instance of `Foo`, generating a call to
+ // Foo's drop-glue function. However, share-generics should take care of
+ // reusing the drop-glue from the upstream crate, so we do not expect a
+ // mono item for the drop-glue
+ let _ = shared_generics_aux::Foo(1);
+}