Revert "add LinkageInfo to keep track of how we figured out the linkage"

This reverts commit 9142cae.

Author: folkertdev

compiler/rustc_codegen_cranelift/src/driver/mod.rs

@@ -30,7 +30,7 @@ fn predefine_mono_items<'tcx>(
                         get_function_sig(tcx, module.target_config().default_call_conv, instance);
                     let linkage = crate::linkage::get_clif_linkage(
                         mono_item,
-                        data.linkage_info.into_linkage(),
+                        data.linkage,
                         data.visibility,
                         is_compiler_builtins,
                     );

compiler/rustc_codegen_gcc/src/base.rs

@@ -213,7 +213,7 @@ pub fn compile_codegen_unit(
 
             let mono_items = cgu.items_in_deterministic_order(tcx);
             for &(mono_item, data) in &mono_items {
-                mono_item.predefine::<Builder<'_, '_, '_>>(&cx, data.linkage_info, data.visibility);
+                mono_item.predefine::<Builder<'_, '_, '_>>(&cx, data.linkage, data.visibility);
             }
 
             // ... and now that we have everything pre-defined, fill out those definitions.

compiler/rustc_codegen_llvm/src/base.rs

@@ -86,7 +86,7 @@ pub(crate) fn compile_codegen_unit(
             let cx = CodegenCx::new(tcx, cgu, &llvm_module);
             let mono_items = cx.codegen_unit.items_in_deterministic_order(cx.tcx);
             for &(mono_item, data) in &mono_items {
-                mono_item.predefine::<Builder<'_, '_, '_>>(&cx, data.linkage_info, data.visibility);
+                mono_item.predefine::<Builder<'_, '_, '_>>(&cx, data.linkage, data.visibility);
             }
 
             // ... and now that we have everything pre-defined, fill out those definitions.

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -283,7 +283,7 @@ fn exported_symbols_provider_local(
     }
 
     if tcx.local_crate_exports_generics() {
-        use rustc_middle::mir::mono::{MonoItem, Visibility};
+        use rustc_middle::mir::mono::{Linkage, MonoItem, Visibility};
         use rustc_middle::ty::InstanceKind;
 
         // Normally, we require that shared monomorphizations are not hidden,
@@ -298,7 +298,7 @@ fn exported_symbols_provider_local(
         // The symbols created in this loop are sorted below it
         #[allow(rustc::potential_query_instability)]
         for (mono_item, data) in cgus.iter().flat_map(|cgu| cgu.items().iter()) {
-            if !data.linkage_info.is_external() {
+            if data.linkage != Linkage::External {
                 // We can only re-use things with external linkage, otherwise
                 // we'll get a linker error
                 continue;

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -207,8 +207,6 @@ fn prefix_and_suffix<'tcx>(
             }
             writeln!(begin, "{asm_name}:").unwrap();
 
-            eprintln!("{}", &begin);
-
             writeln!(end).unwrap();
             writeln!(end, ".size {asm_name}, . - {asm_name}").unwrap();
             writeln!(end, ".popsection").unwrap();

compiler/rustc_codegen_ssa/src/mono_item.rs

@@ -1,7 +1,7 @@
 use rustc_hir as hir;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::interpret::ErrorHandled;
-use rustc_middle::mir::mono::{LinkageInfo, MonoItem, Visibility};
+use rustc_middle::mir::mono::{Linkage, MonoItem, Visibility};
 use rustc_middle::ty::Instance;
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
 use rustc_middle::{span_bug, ty};
@@ -15,7 +15,7 @@ pub trait MonoItemExt<'a, 'tcx> {
     fn predefine<Bx: BuilderMethods<'a, 'tcx>>(
         &self,
         cx: &'a Bx::CodegenCx,
-        linkage_info: LinkageInfo,
+        linkage: Linkage,
         visibility: Visibility,
     );
     fn to_raw_string(&self) -> String;
@@ -117,7 +117,7 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
     fn predefine<Bx: BuilderMethods<'a, 'tcx>>(
         &self,
         cx: &'a Bx::CodegenCx,
-        linkage_info: LinkageInfo,
+        linkage: Linkage,
         visibility: Visibility,
     ) {
         debug!(
@@ -133,15 +133,15 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
 
         match *self {
             MonoItem::Static(def_id) => {
-                cx.predefine_static(def_id, linkage_info.into_linkage(), visibility, symbol_name);
+                cx.predefine_static(def_id, linkage, visibility, symbol_name);
             }
             MonoItem::Fn(instance) => {
                 let attrs = cx.tcx().codegen_fn_attrs(instance.def_id());
 
                 if attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
                     // do not define this function; it will become a global assembly block
                 } else {
-                    cx.predefine_fn(instance, linkage_info.into_linkage(), visibility, symbol_name);
+                    cx.predefine_fn(instance, linkage, visibility, symbol_name);
                 };
             }
             MonoItem::GlobalAsm(..) => {}

compiler/rustc_middle/src/mir/mono.rs

@@ -269,38 +269,13 @@ pub struct MonoItemData {
     /// `GloballyShared` maps to `false` and `LocalCopy` maps to `true`.
     pub inlined: bool,
 
-    pub linkage_info: LinkageInfo,
+    pub linkage: Linkage,
     pub visibility: Visibility,
 
     /// A cached copy of the result of `MonoItem::size_estimate`.
     pub size_estimate: usize,
 }
 
-/// Stores how we know what linkage to use
-#[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable)]
-pub enum LinkageInfo {
-    /// The linkage was specified explicitly (e.g. using #[linkage = "..."])
-    Explicit(Linkage),
-    /// Assume the symbol may be used from other CGUs, a safe default
-    ImplicitExternal,
-    /// We did not find any uses from other CGUs, so it's fine to make this internal
-    ImplicitInternal,
-}
-
-impl LinkageInfo {
-    pub const fn is_external(self) -> bool {
-        matches!(self.into_linkage(), Linkage::External)
-    }
-
-    pub const fn into_linkage(self) -> Linkage {
-        match self {
-            Self::Explicit(linkage) => linkage,
-            Self::ImplicitExternal => Linkage::External,
-            Self::ImplicitInternal => Linkage::Internal,
-        }
-    }
-}
-
 /// Specifies the linkage type for a `MonoItem`.
 ///
 /// See <https://llvm.org/docs/LangRef.html#linkage-types> for more details about these variants.

compiler/rustc_monomorphize/src/partitioning.rs

@@ -109,8 +109,8 @@ use rustc_middle::bug;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::exported_symbols::{SymbolExportInfo, SymbolExportLevel};
 use rustc_middle::mir::mono::{
-    CodegenUnit, CodegenUnitNameBuilder, InstantiationMode, Linkage, LinkageInfo, MonoItem,
-    MonoItemData, Visibility,
+    CodegenUnit, CodegenUnitNameBuilder, InstantiationMode, Linkage, MonoItem, MonoItemData,
+    Visibility,
 };
 use rustc_middle::ty::print::{characteristic_def_id_of_type, with_no_trimmed_paths};
 use rustc_middle::ty::visit::TypeVisitableExt;
@@ -245,7 +245,7 @@ where
         let cgu = codegen_units.entry(cgu_name).or_insert_with(|| CodegenUnit::new(cgu_name));
 
         let mut can_be_internalized = true;
-        let (linkage_info, visibility) = mono_item_linkage_info_and_visibility(
+        let (linkage, visibility) = mono_item_linkage_and_visibility(
             cx.tcx,
             &mono_item,
             &mut can_be_internalized,
@@ -259,7 +259,7 @@ where
 
         cgu.items_mut().insert(mono_item, MonoItemData {
             inlined: false,
-            linkage_info,
+            linkage,
             visibility,
             size_estimate,
         });
@@ -278,7 +278,7 @@ where
             // This is a CGU-private copy.
             cgu.items_mut().entry(inlined_item).or_insert_with(|| MonoItemData {
                 inlined: true,
-                linkage_info: LinkageInfo::ImplicitInternal,
+                linkage: Linkage::Internal,
                 visibility: Visibility::Default,
                 size_estimate: inlined_item.size_estimate(cx.tcx),
             });
@@ -589,8 +589,7 @@ fn internalize_symbols<'tcx>(
 
             // If we got here, we did not find any uses from other CGUs, so
             // it's fine to make this monomorphization internal.
-            debug_assert_eq!(data.linkage_info, LinkageInfo::ImplicitExternal);
-            data.linkage_info = LinkageInfo::ImplicitInternal;
+            data.linkage = Linkage::Internal;
             data.visibility = Visibility::Default;
         }
     }
@@ -608,7 +607,7 @@ fn mark_code_coverage_dead_code_cgu<'tcx>(codegen_units: &mut [CodegenUnit<'tcx>
     // function symbols to be included via `-u` or `/include` linker args.
     let dead_code_cgu = codegen_units
         .iter_mut()
-        .filter(|cgu| cgu.items().iter().any(|(_, data)| data.linkage_info.is_external()))
+        .filter(|cgu| cgu.items().iter().any(|(_, data)| data.linkage == Linkage::External))
         .min_by_key(|cgu| cgu.size_estimate());
 
     // If there are no CGUs that have externally linked items, then we just
@@ -737,26 +736,24 @@ fn fallback_cgu_name(name_builder: &mut CodegenUnitNameBuilder<'_>) -> Symbol {
     name_builder.build_cgu_name(LOCAL_CRATE, &["fallback"], Some("cgu"))
 }
 
-fn mono_item_linkage_info_and_visibility<'tcx>(
+fn mono_item_linkage_and_visibility<'tcx>(
     tcx: TyCtxt<'tcx>,
     mono_item: &MonoItem<'tcx>,
     can_be_internalized: &mut bool,
     can_export_generics: bool,
     always_export_generics: bool,
-) -> (LinkageInfo, Visibility) {
+) -> (Linkage, Visibility) {
     if let Some(explicit_linkage) = mono_item.explicit_linkage(tcx) {
-        (LinkageInfo::Explicit(explicit_linkage), Visibility::Default)
-    } else {
-        let vis = mono_item_visibility(
-            tcx,
-            mono_item,
-            can_be_internalized,
-            can_export_generics,
-            always_export_generics,
-        );
-
-        (LinkageInfo::ImplicitExternal, vis)
+        return (explicit_linkage, Visibility::Default);
     }
+    let vis = mono_item_visibility(
+        tcx,
+        mono_item,
+        can_be_internalized,
+        can_export_generics,
+        always_export_generics,
+    );
+    (Linkage::External, vis)
 }
 
 type CguNameCache = UnordMap<(DefId, bool), Symbol>;
@@ -1036,15 +1033,15 @@ fn debug_dump<'a, 'tcx: 'a>(tcx: TyCtxt<'tcx>, label: &str, cgus: &[CodegenUnit<
                 writeln!(s, "  - items: {num_items}, mean size: {mean_size:.1}, sizes: {sizes}",);
 
             for (item, data) in cgu.items_in_deterministic_order(tcx) {
-                let linkage_info = data.linkage_info;
+                let linkage = data.linkage;
                 let symbol_name = item.symbol_name(tcx).name;
                 let symbol_hash_start = symbol_name.rfind('h');
                 let symbol_hash = symbol_hash_start.map_or("<no hash>", |i| &symbol_name[i..]);
                 let kind = if !data.inlined { "root" } else { "inlined" };
                 let size = data.size_estimate;
                 let _ = with_no_trimmed_paths!(writeln!(
                     s,
-                    "  - {item} [{linkage_info:?}] [{symbol_hash}] ({kind}, size: {size})"
+                    "  - {item} [{linkage:?}] [{symbol_hash}] ({kind}, size: {size})"
                 ));
             }
 
@@ -1197,7 +1194,7 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[Co
 
         for cgu in codegen_units {
             for (&mono_item, &data) in cgu.items() {
-                item_to_cgus.entry(mono_item).or_default().push((cgu.name(), data.linkage_info));
+                item_to_cgus.entry(mono_item).or_default().push((cgu.name(), data.linkage));
             }
         }
 
@@ -1210,11 +1207,11 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> (&DefIdSet, &[Co
                 let cgus = item_to_cgus.get_mut(i).unwrap_or(&mut empty);
                 cgus.sort_by_key(|(name, _)| *name);
                 cgus.dedup();
-                for &(ref cgu_name, linkage_info) in cgus.iter() {
+                for &(ref cgu_name, linkage) in cgus.iter() {
                     output.push(' ');
                     output.push_str(cgu_name.as_str());
 
-                    let linkage_abbrev = match linkage_info.into_linkage() {
+                    let linkage_abbrev = match linkage {
                         Linkage::External => "External",
                         Linkage::AvailableExternally => "Available",
                         Linkage::LinkOnceAny => "OnceAny",