Add target arch verification for LLVM intrinsics

Author: sayantn

compiler/rustc_codegen_llvm/messages.ftl

@@ -12,6 +12,9 @@ codegen_llvm_from_llvm_optimization_diag = {$filename}:{$line}:{$column} {$pass_
 codegen_llvm_intrinsic_signature_mismatch =
     intrinsic signature mismatch for `{$name}`: expected signature `{$llvm_fn_ty}`, found `{$rust_fn_ty}`
 
+codegen_llvm_intrinsic_wrong_arch =
+    intrinsic `{$name}` cannot be used with target arch `{$target_arch}`
+
 
 codegen_llvm_load_bitcode = failed to load bitcode of module "{$name}"
 codegen_llvm_load_bitcode_with_llvm_err = failed to load bitcode of module "{$name}": {$llvm_err}

compiler/rustc_codegen_llvm/src/declare.rs

@@ -176,7 +176,36 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
             signature.fn_ty(),
         );
 
-        if signature.intrinsic().is_none() {
+        if let Some(intrinsic) = signature.intrinsic() {
+            if intrinsic.is_target_specific() {
+                let (llvm_arch, _) = name[5..].split_once('.').unwrap();
+                let target_arch = self.tcx.sess.target.arch.as_ref();
+
+                let is_correct_arch = match llvm_arch {
+                    "aarch64" => matches!(target_arch, "aarch64" | "arm64ec"),
+                    "amdgcn" => target_arch == "amdgpu",
+                    "arm" | "bpf" | "hexagon" => target_arch == llvm_arch,
+                    "loongarch" => matches!(target_arch, "loongarch32" | "loongarch64"),
+                    "mips" => target_arch.starts_with("mips"),
+                    "nvvm" => target_arch == "nvptx64",
+                    "ppc" => matches!(target_arch, "powerpc" | "powerpc64"),
+                    "riscv" => matches!(target_arch, "riscv32" | "riscv64"),
+                    "s390" => target_arch == "s390x",
+                    "spv" => target_arch == "spirv",
+                    "wasm" => matches!(target_arch, "wasm32" | "wasm64"),
+                    "x86" => matches!(target_arch, "x86" | "x86_64"),
+                    _ => true, // fallback for unknown archs
+                };
+
+                if !is_correct_arch {
+                    self.tcx.dcx().emit_fatal(errors::IntrinsicWrongArch {
+                        name,
+                        target_arch,
+                        span: span(),
+                    });
+                }
+            }
+        } else {
             // Don't apply any attributes to intrinsics, they will be applied by AutoUpgrade
             fn_abi.apply_attrs_llfn(self, llfn, instance);
         }

compiler/rustc_codegen_llvm/src/errors.rs

@@ -157,3 +157,12 @@ pub(crate) struct IntrinsicSignatureMismatch<'a> {
     #[primary_span]
     pub span: Option<Span>,
 }
+
+#[derive(Diagnostic)]
+#[diag(codegen_llvm_intrinsic_wrong_arch)]
+pub(crate) struct IntrinsicWrongArch<'a> {
+    pub name: &'a str,
+    pub target_arch: &'a str,
+    #[primary_span]
+    pub span: Option<Span>,
+}

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1139,6 +1139,7 @@ unsafe extern "C" {
         NewFn: &mut Option<&'a Value>,
         CanUpgradeDebugIntrinsicsToRecords: bool,
     ) -> bool;
+    pub(crate) fn LLVMRustIsTargetIntrinsic(ID: NonZero<c_uint>) -> bool;
 
     // Operations on parameters
     pub(crate) fn LLVMIsAArgument(Val: &Value) -> Option<&Value>;

compiler/rustc_codegen_llvm/src/llvm/mod.rs

@@ -315,6 +315,10 @@ impl Intrinsic {
         unsafe { LLVMIntrinsicIsOverloaded(self.id).is_true() }
     }
 
+    pub(crate) fn is_target_specific(self) -> bool {
+        unsafe { LLVMRustIsTargetIntrinsic(self.id) }
+    }
+
     pub(crate) fn get_type<'ll>(self, llcx: &'ll Context, type_params: &[&'ll Type]) -> &'ll Type {
         unsafe { LLVMIntrinsicGetType(llcx, self.id, type_params.as_ptr(), type_params.len()) }
     }

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -1777,6 +1777,14 @@ LLVMRustUpgradeIntrinsicFunction(LLVMValueRef Fn, LLVMValueRef *NewFn,
   return CanUpgrade;
 }
 
+extern "C" bool LLVMRustIsTargetIntrinsic(unsigned ID) {
+#if LLVM_VERSION_GE(20, 1)
+  return Intrinsic::isTargetIntrinsic(ID);
+#else
+  return Function::isTargetIntrinsic(ID);
+#endif
+}
+
 extern "C" int32_t LLVMRustGetElementTypeArgIndex(LLVMValueRef CallSite) {
   auto *CB = unwrap<CallBase>(CallSite);
   switch (CB->getIntrinsicID()) {

tests/ui/codegen/incorrect-arch-intrinsic.rs

@@ -0,0 +1,17 @@
+//@ build-fail
+//@ ignore-s390x
+//@ normalize-stderr: "target arch `(.*)`" -> "target arch `TARGET_ARCH`"
+
+#![feature(link_llvm_intrinsics, abi_unadjusted)]
+
+extern "unadjusted" {
+    #[link_name = "llvm.s390.sfpc"]
+    fn foo(a: i32);
+    //~^ ERROR: intrinsic `llvm.s390.sfpc` cannot be used with target arch
+}
+
+pub fn main() {
+    unsafe {
+        foo(0);
+    }
+}

tests/ui/codegen/incorrect-arch-intrinsic.stderr

@@ -0,0 +1,8 @@
+error: intrinsic `llvm.s390.sfpc` cannot be used with target arch `TARGET_ARCH`
+  --> $DIR/incorrect-arch-intrinsic.rs:9:5
+   |
+LL |     fn foo(a: i32);
+   |     ^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+