skip predefine_fn for naked functions

compiler/rustc_codegen_llvm/src/mono_item.rs

@@ -58,8 +58,8 @@ impl<'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
 
         let fn_abi = self.fn_abi_of_instance(instance, ty::List::empty());
         let lldecl = self.declare_fn(symbol_name, fn_abi, Some(instance));
-        let attrs = self.tcx.codegen_fn_attrs(instance.def_id());
         llvm::set_linkage(lldecl, base::linkage_to_llvm(linkage));
+        let attrs = self.tcx.codegen_fn_attrs(instance.def_id());
         base::set_link_section(lldecl, attrs);
         if (linkage == Linkage::LinkOnceODR || linkage == Linkage::WeakODR)
             && self.tcx.sess.target.supports_comdat()

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -1,5 +1,5 @@
 use rustc_attr::InstructionSetAttr;
-use rustc_middle::mir::mono::{MonoItem, MonoItemData, Visibility};
+use rustc_middle::mir::mono::{Linkage, MonoItem, MonoItemData, Visibility};
 use rustc_middle::mir::{Body, InlineAsmOperand};
 use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{Instance, TyCtxt};
@@ -153,6 +153,30 @@ fn prefix_and_suffix<'tcx>(
         ("", "")
     };
 
+    let emit_fatal = |msg| tcx.dcx().span_fatal(tcx.def_span(instance.def_id()), msg);
+
+    // see https://godbolt.org/z/cPK4sxKor.
+    // None means the default, which corresponds to internal linkage
+    let linkage = match item_data.linkage {
+        Linkage::External => Some(".globl"),
+        Linkage::LinkOnceAny => Some(".weak"),
+        Linkage::LinkOnceODR => Some(".weak"),
+        Linkage::WeakAny => Some(".weak"),
+        Linkage::WeakODR => Some(".weak"),
+        Linkage::Internal => None,
+        Linkage::Private => None,
+        Linkage::Appending => emit_fatal("Only global variables can have appending linkage!"),
+        Linkage::Common => emit_fatal("Functions may not have common linkage"),
+        Linkage::AvailableExternally => {
+            // this would make the function equal an extern definition
+            emit_fatal("Functions may not have available_externally linkage")
+        }
+        Linkage::ExternalWeak => {
+            // FIXME: actually this causes a SIGILL in LLVM
+            emit_fatal("Functions may not have external weak linkage")
+        }
+    };
+
     let mut begin = String::new();
     let mut end = String::new();
     match AsmBinaryFormat::from_target(&tcx.sess.target) {
@@ -171,7 +195,9 @@ fn prefix_and_suffix<'tcx>(
 
             writeln!(begin, ".pushsection {section},\"ax\", {progbits}").unwrap();
             writeln!(begin, ".balign {align}").unwrap();
-            writeln!(begin, ".globl {asm_name}").unwrap();
+            if let Some(linkage) = linkage {
+                writeln!(begin, "{linkage} {asm_name}").unwrap();
+            }
             if let Visibility::Hidden = item_data.visibility {
                 writeln!(begin, ".hidden {asm_name}").unwrap();
             }
@@ -181,6 +207,8 @@ 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();
@@ -192,7 +220,9 @@ fn prefix_and_suffix<'tcx>(
             let section = link_section.unwrap_or("__TEXT,__text".to_string());
             writeln!(begin, ".pushsection {},regular,pure_instructions", section).unwrap();
             writeln!(begin, ".balign {align}").unwrap();
-            writeln!(begin, ".globl {asm_name}").unwrap();
+            if let Some(linkage) = linkage {
+                writeln!(begin, "{linkage} {asm_name}").unwrap();
+            }
             if let Visibility::Hidden = item_data.visibility {
                 writeln!(begin, ".private_extern {asm_name}").unwrap();
             }
@@ -208,7 +238,9 @@ fn prefix_and_suffix<'tcx>(
             let section = link_section.unwrap_or(format!(".text.{asm_name}"));
             writeln!(begin, ".pushsection {},\"xr\"", section).unwrap();
             writeln!(begin, ".balign {align}").unwrap();
-            writeln!(begin, ".globl {asm_name}").unwrap();
+            if let Some(linkage) = linkage {
+                writeln!(begin, "{linkage} {asm_name}").unwrap();
+            }
             writeln!(begin, ".def {asm_name}").unwrap();
             writeln!(begin, ".scl 2").unwrap();
             writeln!(begin, ".type 32").unwrap();

compiler/rustc_codegen_ssa/src/mono_item.rs

@@ -137,13 +137,12 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
             }
             MonoItem::Fn(instance) => {
                 let attrs = cx.tcx().codegen_fn_attrs(instance.def_id());
-                let linkage = if attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
-                    linkage_info.into_naked_linkage()
+
+                if attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
+                    // do not define this function; it will become a global assembly block
                 } else {
-                    linkage_info.into_linkage()
+                    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

@@ -299,28 +299,6 @@ impl LinkageInfo {
             Self::ImplicitInternal => Linkage::Internal,
         }
     }
-
-    /// Linkage when the MonoItem is a naked function
-    ///
-    /// Naked functions are generated as a separate declaration (effectively an extern fn) and
-    /// definition (using global assembly). To link them together, some flavor of external linkage
-    /// must be used.
-    ///
-    /// This should be just an implementation detail of the backend, which is why this translation
-    /// is made at the final moment.
-    pub const fn into_naked_linkage(self) -> Linkage {
-        match self {
-            // promote Weak linkage to ExternalWeak
-            Self::Explicit(Linkage::WeakAny | Linkage::WeakODR) => Linkage::ExternalWeak,
-            Self::Explicit(linkage) => linkage,
-
-            // the "implicit" means that linkage is picked by the partitioning algorithm.
-            // picking external should always be valid (given that we are in fact linking
-            // to the global assembly in the same CGU)
-            Self::ImplicitExternal => Linkage::External,
-            Self::ImplicitInternal => Linkage::External,
-        }
-    }
 }
 
 /// Specifies the linkage type for a `MonoItem`.