squashed changes:

- codegen tests: change `windows` to `win`
- cleanup
- fix review comments
    - better way of checking for thumb
    - get the mangled name from the codegen backend
- propagate function alignment
- fix gcc backend
- fix asan test
- check that assembler mode restored

Author: folkertdev

compiler/rustc_codegen_gcc/src/asm.rs

@@ -865,6 +865,13 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         template_str.push_str("\n.popsection");
         self.context.add_top_level_asm(None, &template_str);
     }
+
+    fn mangled_name(&self, instance: Instance<'tcx>) -> String {
+        // TODO(@Amanieu): Additional mangling is needed on
+        // some targets to add a leading underscore (Mach-O)
+        // or byte count suffixes (x86 Windows).
+        self.tcx.symbol_name(instance).name.to_string()
+    }
 }
 
 fn modifier_to_gcc(

compiler/rustc_codegen_llvm/src/asm.rs

@@ -442,6 +442,14 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
             );
         }
     }
+
+    fn mangled_name(&self, instance: Instance<'tcx>) -> String {
+        let llval = self.get_fn(instance);
+        llvm::build_string(|s| unsafe {
+            llvm::LLVMRustGetMangledName(llval, s);
+        })
+        .expect("symbol is not valid UTF-8")
+    }
 }
 
 pub(crate) fn inline_asm_call<'ll>(

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -4,7 +4,7 @@ use rustc_middle::mir::{Body, InlineAsmOperand};
 use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{Instance, TyCtxt};
 use rustc_middle::{bug, ty};
-use rustc_target::asm::InlineAsmArch;
+use rustc_span::sym;
 
 use crate::common;
 use crate::traits::{AsmCodegenMethods, BuilderMethods, GlobalAsmOperandRef, MiscCodegenMethods};
@@ -31,7 +31,8 @@ pub(crate) fn codegen_naked_asm<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         operands.iter().map(|op| inline_to_global_operand::<Bx>(cx, instance, op)).collect();
 
     let item_data = cx.codegen_unit().items().get(&MonoItem::Fn(instance)).unwrap();
-    let (begin, end) = crate::mir::naked_asm::prefix_and_suffix(cx.tcx(), instance, item_data);
+    let name = cx.mangled_name(instance);
+    let (begin, end) = prefix_and_suffix(cx.tcx(), instance, &name, item_data);
 
     let mut template_vec = Vec::new();
     template_vec.push(rustc_ast::ast::InlineAsmTemplatePiece::String(begin.into()));
@@ -108,7 +109,7 @@ impl AsmBinaryFormat {
     fn from_target(target: &rustc_target::spec::Target) -> Self {
         if target.is_like_windows {
             Self::Coff
-        } else if target.options.vendor == "apple" {
+        } else if target.is_like_osx {
             Self::Macho
         } else {
             Self::Elf
@@ -119,33 +120,29 @@ impl AsmBinaryFormat {
 fn prefix_and_suffix<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
+    asm_name: &str,
     item_data: &MonoItemData,
 ) -> (String, String) {
     use std::fmt::Write;
 
-    let target = &tcx.sess.target;
-    let target_arch = tcx.sess.asm_arch;
-
-    let is_arm = target.arch == "arm";
-    let is_thumb = is_arm && target.llvm_target.contains("thumb");
-
-    let mangle = (target.is_like_windows && matches!(target_arch, Some(InlineAsmArch::X86)))
-        || target.options.vendor == "apple";
-
-    let asm_name = format!("{}{}", if mangle { "_" } else { "" }, tcx.symbol_name(instance).name);
+    let is_arm = tcx.sess.target.arch == "arm";
+    let is_thumb = tcx.sess.unstable_target_features.contains(&sym::thumb_mode);
 
     let attrs = tcx.codegen_fn_attrs(instance.def_id());
     let link_section = attrs.link_section.map(|symbol| symbol.as_str().to_string());
+    let align = attrs.alignment.map(|a| a.bytes()).unwrap_or(4);
 
+    // See https://sourceware.org/binutils/docs/as/ARM-Directives.html for info on these directives.
+    // In particular, `.arm` can also be written `.code 32` and `.thumb` as `.code 16`.
     let (arch_prefix, arch_suffix) = if is_arm {
         (
             match attrs.instruction_set {
                 None => match is_thumb {
                     true => ".thumb\n.thumb_func",
                     false => ".arm",
                 },
-                Some(InstructionSetAttr::ArmA32) => ".arm",
                 Some(InstructionSetAttr::ArmT32) => ".thumb\n.thumb_func",
+                Some(InstructionSetAttr::ArmA32) => ".arm",
             },
             match is_thumb {
                 true => ".thumb",
@@ -173,7 +170,7 @@ fn prefix_and_suffix<'tcx>(
             };
 
             writeln!(begin, ".pushsection {section},\"ax\", {progbits}").unwrap();
-            writeln!(begin, ".balign 4").unwrap();
+            writeln!(begin, ".balign {align}").unwrap();
             writeln!(begin, ".globl {asm_name}").unwrap();
             if let Visibility::Hidden = item_data.visibility {
                 writeln!(begin, ".hidden {asm_name}").unwrap();
@@ -194,7 +191,7 @@ fn prefix_and_suffix<'tcx>(
         AsmBinaryFormat::Macho => {
             let section = link_section.unwrap_or("__TEXT,__text".to_string());
             writeln!(begin, ".pushsection {},regular,pure_instructions", section).unwrap();
-            writeln!(begin, ".balign 4").unwrap();
+            writeln!(begin, ".balign {align}").unwrap();
             writeln!(begin, ".globl {asm_name}").unwrap();
             if let Visibility::Hidden = item_data.visibility {
                 writeln!(begin, ".private_extern {asm_name}").unwrap();
@@ -210,7 +207,7 @@ fn prefix_and_suffix<'tcx>(
         AsmBinaryFormat::Coff => {
             let section = link_section.unwrap_or(format!(".text.{asm_name}"));
             writeln!(begin, ".pushsection {},\"xr\"", section).unwrap();
-            writeln!(begin, ".balign 4").unwrap();
+            writeln!(begin, ".balign {align}").unwrap();
             writeln!(begin, ".globl {asm_name}").unwrap();
             writeln!(begin, ".def {asm_name}").unwrap();
             writeln!(begin, ".scl 2").unwrap();

compiler/rustc_codegen_ssa/src/traits/asm.rs

@@ -68,4 +68,11 @@ pub trait AsmCodegenMethods<'tcx> {
         options: InlineAsmOptions,
         line_spans: &[Span],
     );
+
+    /// The mangled name of this instance
+    ///
+    /// Additional mangling is used on
+    /// some targets to add a leading underscore (Mach-O)
+    /// or byte count suffixes (x86 Windows).
+    fn mangled_name(&self, instance: Instance<'tcx>) -> String;
 }

tests/codegen/naked-asan.rs

@@ -8,7 +8,11 @@
 #![no_std]
 #![feature(abi_x86_interrupt, naked_functions)]
 
-// CHECK: define x86_intrcc void @page_fault_handler(ptr {{.*}}%0, i64 {{.*}}%1){{.*}}#[[ATTRS:[0-9]+]] {
+pub fn caller() {
+    page_fault_handler(1, 2);
+}
+
+// CHECK: declare x86_intrcc void @page_fault_handler(ptr {{.*}}, i64 {{.*}}){{.*}}#[[ATTRS:[0-9]+]]
 // CHECK-NOT: memcpy
 #[naked]
 #[no_mangle]

tests/codegen/naked-fn/aligned.rs

@@ -6,15 +6,12 @@
 #![feature(naked_functions, fn_align)]
 use std::arch::naked_asm;
 
-// CHECK: Function Attrs: naked
-// CHECK-NEXT: define{{.*}}void @naked_empty()
-// CHECK: align 16
+// CHECK: .balign 16
+// CHECK-LABEL: naked_empty:
 #[repr(align(16))]
 #[no_mangle]
 #[naked]
 pub unsafe extern "C" fn naked_empty() {
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: call void asm
-    // CHECK-NEXT: unreachable
+    // CHECK: ret
     naked_asm!("ret");
 }

tests/codegen/naked-fn/generics.rs

@@ -4,7 +4,7 @@
 #![crate_type = "lib"]
 #![feature(naked_functions, asm_const)]
 
-use std::arch::asm;
+use std::arch::naked_asm;
 
 #[no_mangle]
 fn test(x: u64) {
@@ -33,15 +33,14 @@ pub extern "C" fn using_const_generics<const N: u64>(x: u64) -> u64 {
     const M: u64 = 42;
 
     unsafe {
-        asm!(
+        naked_asm!(
             "xor rax, rax",
             "add rax, rdi",
             "add rax, {}",
             "add rax, {}",
             "ret",
             const N,
             const M,
-            options(noreturn),
         )
     }
 }
@@ -64,11 +63,10 @@ impl Invert for i64 {
 #[naked]
 pub extern "C" fn generic_function<T: Invert>(x: i64) -> i64 {
     unsafe {
-        asm!(
+        naked_asm!(
             "call {}",
             "ret",
             sym <T as Invert>::invert,
-            options(noreturn),
         )
     }
 }
@@ -85,7 +83,7 @@ impl Foo {
     #[naked]
     #[no_mangle]
     extern "C" fn method(self) -> u64 {
-        unsafe { asm!("mov rax, rdi", "ret", options(noreturn)) }
+        unsafe { naked_asm!("mov rax, rdi", "ret") }
     }
 }
 
@@ -101,7 +99,7 @@ impl Bar for Foo {
     #[naked]
     #[no_mangle]
     extern "C" fn trait_method(self) -> u64 {
-        unsafe { asm!("mov rax, rdi", "ret", options(noreturn)) }
+        unsafe { naked_asm!("mov rax, rdi", "ret") }
     }
 }
 
@@ -113,5 +111,5 @@ impl Bar for Foo {
 #[naked]
 #[no_mangle]
 pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
-    asm!("lea rax, [rdi + rsi]", "ret", options(noreturn));
+    naked_asm!("lea rax, [rdi + rsi]", "ret");
 }

tests/codegen/naked-fn/instruction-set.rs

@@ -1,12 +1,15 @@
-//@ compile-flags: --target armv5te-none-eabi
-//@ needs-llvm-components: arm
+//@ revisions: arm-mode thumb-mode
+//@ [arm-mode] compile-flags: --target armv5te-none-eabi
+//@ [thumb-mode] compile-flags: --target thumbv5te-none-eabi
+//@ [arm-mode] needs-llvm-components: arm
+//@ [thumb-mode] needs-llvm-components: arm
 
 #![crate_type = "lib"]
 #![feature(no_core, lang_items, rustc_attrs, naked_functions)]
 #![no_core]
 
 #[rustc_builtin_macro]
-macro_rules! asm {
+macro_rules! naked_asm {
     () => {};
 }
 
@@ -15,29 +18,42 @@ trait Sized {}
 #[lang = "copy"]
 trait Copy {}
 
+// arm-mode: .arm
+// thumb-mode: .thumb
 // CHECK-LABEL: test_unspecified:
-// CHECK: .arm
+// CHECK: bx lr
+// CHECK: .popsection
+// arm-mode: .arm
+// thumb-mode: .thumb
 #[no_mangle]
 #[naked]
 unsafe extern "C" fn test_unspecified() {
-    asm!("bx lr", options(noreturn));
+    naked_asm!("bx lr");
 }
 
-// CHECK-LABEL: test_thumb:
 // CHECK: .thumb
 // CHECK: .thumb_func
+// CHECK-LABEL: test_thumb:
+// CHECK: bx lr
+// CHECK: .popsection
+// arm-mode: .arm
+// thumb-mode: .thumb
 #[no_mangle]
 #[naked]
 #[instruction_set(arm::t32)]
 unsafe extern "C" fn test_thumb() {
-    asm!("bx lr", options(noreturn));
+    naked_asm!("bx lr");
 }
 
-// CHECK-LABEL: test_arm:
 // CHECK: .arm
+// CHECK-LABEL: test_arm:
+// CHECK: bx lr
+// CHECK: .popsection
+// arm-mode: .arm
+// thumb-mode: .thumb
 #[no_mangle]
 #[naked]
-#[instruction_set(arm::t32)]
+#[instruction_set(arm::a32)]
 unsafe extern "C" fn test_arm() {
-    asm!("bx lr", options(noreturn));
+    naked_asm!("bx lr");
 }