also fix and test fastcall

Author: RalfJung

compiler/rustc_target/src/callconv/mod.rs

@@ -667,10 +667,10 @@ impl<'a, Ty> FnAbi<'a, Ty> {
             }
             "x86_64" => match abi {
                 spec::abi::Abi::SysV64 { .. } => x86_64::compute_abi_info(cx, self),
-                spec::abi::Abi::Win64 { .. } => x86_win64::compute_abi_info(cx, self),
+                spec::abi::Abi::Win64 { .. } => x86_win64::compute_abi_info(cx, self, abi),
                 _ => {
                     if cx.target_spec().is_like_windows {
-                        x86_win64::compute_abi_info(cx, self)
+                        x86_win64::compute_abi_info(cx, self, abi)
                     } else {
                         x86_64::compute_abi_info(cx, self)
                     }

compiler/rustc_target/src/callconv/x86_win64.rs

@@ -1,12 +1,15 @@
-use rustc_abi::{BackendRepr, Float, Primitive};
+use rustc_abi::{BackendRepr, ExternAbi, Float, Primitive};
 
-use super::Conv;
 use crate::abi::call::{ArgAbi, FnAbi, Reg};
 use crate::spec::HasTargetSpec;
 
 // Win64 ABI: https://docs.microsoft.com/en-us/cpp/build/parameter-passing
 
-pub(crate) fn compute_abi_info<Ty>(cx: &impl HasTargetSpec, fn_abi: &mut FnAbi<'_, Ty>) {
+pub(crate) fn compute_abi_info<Ty>(
+    cx: &impl HasTargetSpec,
+    fn_abi: &mut FnAbi<'_, Ty>,
+    abi: ExternAbi,
+) {
     let fixup = |a: &mut ArgAbi<'_, Ty>| {
         match a.layout.backend_repr {
             BackendRepr::Uninhabited | BackendRepr::Memory { sized: false } => {}
@@ -47,7 +50,7 @@ pub(crate) fn compute_abi_info<Ty>(cx: &impl HasTargetSpec, fn_abi: &mut FnAbi<'
             if cx.target_spec().os == "windows"
                 && cx.target_spec().env == "gnu"
                 && arg.layout.is_zst()
-                && fn_abi.conv == Conv::C
+                && matches!(abi, ExternAbi::C { .. })
             {
                 arg.make_indirect_from_ignore();
             }

compiler/rustc_target/src/spec/mod.rs

@@ -2813,12 +2813,17 @@ impl Target {
             Abi::EfiApi if self.arch == "x86_64" => Abi::Win64 { unwind: false },
             Abi::EfiApi => Abi::C { unwind: false },
 
-            // See commentary in `is_abi_supported`.
-            Abi::Stdcall { .. } | Abi::Thiscall { .. } if self.arch == "x86" => abi,
-            Abi::Stdcall { unwind } | Abi::Thiscall { unwind } => Abi::C { unwind },
-            Abi::Fastcall { .. } if self.arch == "x86" => abi,
+            // See commentary in `is_abi_supported`: we map these ABIs to "C" when they do not make sense.
+            Abi::Stdcall { .. } | Abi::Thiscall { .. } | Abi::Fastcall { .. }
+                if self.arch == "x86" =>
+            {
+                abi
+            }
             Abi::Vectorcall { .. } if ["x86", "x86_64"].contains(&&self.arch[..]) => abi,
-            Abi::Fastcall { unwind } | Abi::Vectorcall { unwind } => Abi::C { unwind },
+            Abi::Stdcall { unwind }
+            | Abi::Thiscall { unwind }
+            | Abi::Fastcall { unwind }
+            | Abi::Vectorcall { unwind } => Abi::C { unwind },
 
             // The Windows x64 calling convention we use for `extern "Rust"`
             // <https://learn.microsoft.com/en-us/cpp/build/x64-software-conventions#register-volatility-and-preservation>

compiler/rustc_ty_utils/src/abi.rs

@@ -267,8 +267,10 @@ fn fn_sig_for_fn_abi<'tcx>(
 
 #[inline]
 fn conv_from_spec_abi(tcx: TyCtxt<'_>, abi: ExternAbi, c_variadic: bool) -> Conv {
+    let target = &tcx.sess.target;
+
     use rustc_abi::ExternAbi::*;
-    match tcx.sess.target.adjust_abi(abi, c_variadic) {
+    match target.adjust_abi(abi, c_variadic) {
         RustIntrinsic | Rust | RustCall => Conv::Rust,
 
         // This is intentionally not using `Conv::Cold`, as that has to preserve
@@ -279,10 +281,37 @@ fn conv_from_spec_abi(tcx: TyCtxt<'_>, abi: ExternAbi, c_variadic: bool) -> Conv
         System { .. } => bug!("system abi should be selected elsewhere"),
         EfiApi => bug!("eficall abi should be selected elsewhere"),
 
-        Stdcall { .. } => Conv::X86Stdcall,
-        Fastcall { .. } => Conv::X86Fastcall,
-        Vectorcall { .. } => Conv::X86VectorCall,
-        Thiscall { .. } => Conv::X86ThisCall,
+        // See commentary in `is_abi_supported`: we map these to "C" on targets
+        // where they do not make sense.
+        Stdcall { .. } => {
+            if target.arch == "x86" {
+                Conv::X86Stdcall
+            } else {
+                Conv::C
+            }
+        }
+        Fastcall { .. } => {
+            if target.arch == "x86" {
+                Conv::X86Fastcall
+            } else {
+                Conv::C
+            }
+        }
+        Vectorcall { .. } => {
+            if ["x86", "x86_64"].contains(&&target.arch[..]) {
+                Conv::X86VectorCall
+            } else {
+                Conv::C
+            }
+        }
+        Thiscall { .. } => {
+            if target.arch == "x86" {
+                Conv::X86ThisCall
+            } else {
+                Conv::C
+            }
+        }
+
         C { .. } => Conv::C,
         Unadjusted => Conv::C,
         Win64 { .. } => Conv::X86_64Win64,

tests/codegen/abi-win64-zst.rs

@@ -1,3 +1,5 @@
+//@ compile-flags: -Z merge-functions=disabled
+
 //@ revisions: linux
 //@[linux] compile-flags: --target x86_64-unknown-linux-gnu
 //@[linux] needs-llvm-components: x86
@@ -31,6 +33,12 @@ extern "sysv64" fn pass_zst_sysv64(_: ()) {}
 #[no_mangle]
 extern "vectorcall" fn pass_zst_vectorcall(_: ()) {}
 
+// windows-gnu: define void @pass_zst_fastcall()
+// windows-msvc: define void @pass_zst_fastcall()
+#[no_mangle]
+#[cfg(windows)] // "fastcall" is not valid on 64bit Linux
+extern "fastcall" fn pass_zst_fastcall(_: ()) {}
+
 // For `extern "C"` functions, ZST are *not* ignored on windows-gnu.
 // That's likely an accident on their side but the ABI is what it is.