Create lints for deprecated and invalid intrinsics

sayantn · sayantn · commit 666f92ed2ca1 · 2025-09-02T13:13:44.000+05:30
diff --git a/compiler/rustc_codegen_llvm/messages.ftl b/compiler/rustc_codegen_llvm/messages.ftl
@@ -2,12 +2,6 @@ codegen_llvm_autodiff_without_enable = using the autodiff feature requires -Z au
 
 codegen_llvm_copy_bitcode = failed to copy bitcode to object file: {$err}
 
-codegen_llvm_deprecated_intrinsic =
-    Using deprecated intrinsic `{$name}`, consider using other intrinsics/instructions
-
-codegen_llvm_deprecated_intrinsic_with_replacement =
-    Using deprecated intrinsic `{$name}`, `{$replacement}` can be used instead
-
 
 
 codegen_llvm_fixed_x18_invalid_arch = the `-Zfixed-x18` flag is not supported on the `{$arch}` architecture
@@ -22,9 +16,6 @@ codegen_llvm_intrinsic_signature_mismatch =
 codegen_llvm_intrinsic_wrong_arch =
     Intrinsic `{$name}` cannot be used with target arch `{$target_arch}`
 
-codegen_llvm_invalid_intrinsic =
-    Invalid LLVM Intrinsic `{$name}`
-
 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}
 
diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -375,8 +375,8 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
             return true;
         }
 
-        // Some LLVM intrinsics return **non-packed** structs, but they can't be mimicked from Rust 
-        // due to auto field-alignment in non-packed structs (packed structs are represented in LLVM 
+        // Some LLVM intrinsics return **non-packed** structs, but they can't be mimicked from Rust
+        // due to auto field-alignment in non-packed structs (packed structs are represented in LLVM
         // as, well, packed structs, so they won't match with those either)
         if self.type_kind(llvm_ty) == TypeKind::Struct
             && self.type_kind(rust_ty) == TypeKind::Struct
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -18,6 +18,7 @@ use rustc_codegen_ssa::traits::TypeMembershipCodegenMethods;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_middle::ty::{Instance, Ty};
 use rustc_sanitizers::{cfi, kcfi};
+use rustc_session::lint::builtin::{DEPRECATED_LLVM_INTRINSIC, UNKNOWN_LLVM_INTRINSIC};
 use rustc_target::callconv::FnAbi;
 use smallvec::SmallVec;
 use tracing::debug;
@@ -216,22 +217,32 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
             let can_upgrade =
                 unsafe { llvm::LLVMRustUpgradeIntrinsicFunction(llfn, &mut new_llfn, false) };
 
-            if can_upgrade {
-                // not all intrinsics are upgraded to some other intrinsics, most are upgraded to instruction sequences
-                if let Some(new_llfn) = new_llfn {
-                    self.tcx.dcx().emit_note(errors::DeprecatedIntrinsicWithReplacement {
-                        name,
-                        replacement: str::from_utf8(&llvm::get_value_name(new_llfn)).unwrap(),
-                        span: span(),
+            // we can emit diagnostics for local crates only
+            if let Some(instance) = instance
+                && let Some(local_def_id) = instance.def_id().as_local()
+            {
+                let hir_id = self.tcx.local_def_id_to_hir_id(local_def_id);
+                let span = self.tcx.def_span(local_def_id);
+
+                if can_upgrade {
+                    // not all intrinsics are upgraded to some other intrinsics, most are upgraded to instruction sequences
+                    let msg = if let Some(new_llfn) = new_llfn {
+                        format!(
+                            "Using deprecated intrinsic `{name}`, `{}` can be used instead",
+                            str::from_utf8(&llvm::get_value_name(new_llfn)).unwrap()
+                        )
+                    } else {
+                        format!("Using deprecated intrinsic `{name}`")
+                    };
+                    self.tcx.node_lint(DEPRECATED_LLVM_INTRINSIC, hir_id, |d| {
+                        d.primary_message(msg).span(span);
+                    });
+                } else {
+                    // This is either plain wrong, or this can be caused by incompatible LLVM versions, we let the user decide
+                    self.tcx.node_lint(UNKNOWN_LLVM_INTRINSIC, hir_id, |d| {
+                        d.primary_message(format!("Invalid LLVM Intrinsic `{name}`")).span(span);
                     });
-                } else if self.tcx.sess.opts.verbose {
-                    // At least for now, we are only emitting notes for deprecated intrinsics with no direct replacement
-                    // because they are used quite a lot in stdarch. After the stdarch uses has been removed, we can make
-                    // this always emit a note (or even an warning)
-                    self.tcx.dcx().emit_note(errors::DeprecatedIntrinsic { name, span: span() });
                 }
-            } else {
-                self.tcx.dcx().emit_fatal(errors::InvalidIntrinsic { name, span: span() });
             }
         }
 
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -158,31 +158,6 @@ pub(crate) struct IntrinsicSignatureMismatch<'a> {
     pub span: Option<Span>,
 }
 
-#[derive(Diagnostic)]
-#[diag(codegen_llvm_invalid_intrinsic)]
-pub(crate) struct InvalidIntrinsic<'a> {
-    pub name: &'a str,
-    #[primary_span]
-    pub span: Option<Span>,
-}
-
-#[derive(Diagnostic)]
-#[diag(codegen_llvm_deprecated_intrinsic)]
-pub(crate) struct DeprecatedIntrinsic<'a> {
-    pub name: &'a str,
-    #[primary_span]
-    pub span: Option<Span>,
-}
-
-#[derive(Diagnostic)]
-#[diag(codegen_llvm_deprecated_intrinsic_with_replacement)]
-pub(crate) struct DeprecatedIntrinsicWithReplacement<'a> {
-    pub name: &'a str,
-    pub replacement: &'a str,
-    #[primary_span]
-    pub span: Option<Span>,
-}
-
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_intrinsic_wrong_arch)]
 pub(crate) struct IntrinsicWrongArch<'a> {
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -71,9 +71,7 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
     }
 
     pub(crate) fn get_return_type(&self, ty: &'ll Type) -> &'ll Type {
-        unsafe {
-            llvm::LLVMGetReturnType(ty)
-        }
+        unsafe { llvm::LLVMGetReturnType(ty) }
     }
 
     pub(crate) fn func_params_types(&self, ty: &'ll Type) -> Vec<&'ll Type> {
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
@@ -35,6 +35,7 @@ declare_lint_pass! {
         DEPENDENCY_ON_UNIT_NEVER_TYPE_FALLBACK,
         DEPRECATED,
         DEPRECATED_IN_FUTURE,
+        DEPRECATED_LLVM_INTRINSIC,
         DEPRECATED_SAFE_2024,
         DEPRECATED_WHERE_CLAUSE_LOCATION,
         DUPLICATE_MACRO_ATTRIBUTES,
@@ -117,6 +118,7 @@ declare_lint_pass! {
         UNKNOWN_CRATE_TYPES,
         UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
         UNKNOWN_LINTS,
+        UNKNOWN_LLVM_INTRINSIC,
         UNNAMEABLE_TEST_ITEMS,
         UNNAMEABLE_TYPES,
         UNREACHABLE_CODE,
@@ -5138,3 +5140,83 @@ declare_lint! {
     "detects tail calls of functions marked with `#[track_caller]`",
     @feature_gate = explicit_tail_calls;
 }
+
+declare_lint! {
+    /// The `unknown_llvm_intrinsic` lint detects usage of unknown LLVM intrinsics.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// #![feature(link_llvm_intrinsics, abi_unadjusted)]
+    ///
+    /// unsafe extern "unadjusted" {
+    ///     #[link_name = "llvm.abcde"]
+    ///     fn foo();
+    /// }
+    ///
+    /// # #[inline(never)]
+    /// pub fn bar() {
+    ///     unsafe { foo() }
+    /// }
+    /// #
+    /// # fn main() {
+    /// #     bar();
+    /// # }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Linking to an unknown LLVM intrinsic may cause linker errors (in general it's UB),
+    /// so this lint captures those undesirable scenarios.
+    pub UNKNOWN_LLVM_INTRINSIC,
+    Deny,
+    "detects uses of unknown LLVM intrinsics",
+    @feature_gate = link_llvm_intrinsics;
+}
+
+declare_lint! {
+    /// The `deprecated_llvm_intrinsic` lint detects usage of deprecated LLVM intrinsics.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (fails on non-x86)
+    /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    /// #![feature(link_llvm_intrinsics, abi_unadjusted)]
+    /// #![deny(deprecated_llvm_intrinsic)]
+    ///
+    /// unsafe extern "unadjusted" {
+    ///     #[link_name = "llvm.x86.addcarryx.u32"]
+    ///     fn foo(a: u8, b: u32, c: u32, d: &mut u32) -> u8;
+    /// }
+    ///
+    /// #[inline(never)]
+    /// #[target_feature(enable = "adx")]
+    /// pub fn bar(a: u8, b: u32, c: u32, d: &mut u32) -> u8 {
+    ///     unsafe { foo(a, b, c, d) }
+    /// }
+    /// ```
+    ///
+    /// This will produce:
+    ///
+    /// ```text
+    /// error: Using deprecated intrinsic `llvm.x86.addcarryx.u32`
+    ///  --> example.rs:7:5
+    ///   |
+    /// 7 |     fn foo(a: u8, b: u32, c: u32, d: &mut u32) -> u8;
+    ///   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    ///   |
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// LLVM periodically updates its list of intrinsics. Removed intrinsics are unlikely
+    /// to be removed, but they may optimize less well than their new versions, so it's
+    /// best to use the new version. Also, some deprecated intrinsics might have buggy
+    /// behavior
+    pub DEPRECATED_LLVM_INTRINSIC,
+    Allow,
+    "detects uses of deprecated LLVM intrinsics",
+    @feature_gate = link_llvm_intrinsics;
+}
diff --git a/tests/ui/codegen/deprecated-llvm-intrinsic.rs b/tests/ui/codegen/deprecated-llvm-intrinsic.rs
@@ -16,9 +16,10 @@ use minicore::*;
 pub struct i8x8([i8; 8]);
 
 extern "unadjusted" {
+    #![warn(deprecated_llvm_intrinsic)]
     #[link_name = "llvm.aarch64.neon.rbit.v8i8"]
     fn foo(a: i8x8) -> i8x8;
-    //~^ NOTE: Using deprecated intrinsic `llvm.aarch64.neon.rbit.v8i8`, `llvm.bitreverse.v8i8` can be used instead
+    //~^ WARN: Using deprecated intrinsic `llvm.aarch64.neon.rbit.v8i8`, `llvm.bitreverse.v8i8` can be used instead
 }
 
 #[target_feature(enable = "neon")]
diff --git a/tests/ui/codegen/deprecated-llvm-intrinsic.stderr b/tests/ui/codegen/deprecated-llvm-intrinsic.stderr
@@ -1,6 +1,14 @@
-note: Using deprecated intrinsic `llvm.aarch64.neon.rbit.v8i8`, `llvm.bitreverse.v8i8` can be used instead
-  --> $DIR/deprecated-llvm-intrinsic.rs:20:5
+warning: Using deprecated intrinsic `llvm.aarch64.neon.rbit.v8i8`, `llvm.bitreverse.v8i8` can be used instead
+  --> $DIR/deprecated-llvm-intrinsic.rs:21:5
    |
 LL |     fn foo(a: i8x8) -> i8x8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/deprecated-llvm-intrinsic.rs:19:13
+   |
+LL |     #![warn(deprecated_llvm_intrinsic)]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: 1 warning emitted
 
diff --git a/tests/ui/codegen/invalid-llvm-intrinsic.stderr b/tests/ui/codegen/invalid-llvm-intrinsic.stderr
@@ -3,6 +3,8 @@ error: Invalid LLVM Intrinsic `llvm.abcde`
    |
 LL |     fn foo();
    |     ^^^^^^^^^
+   |
+   = note: `#[deny(unknown_llvm_intrinsic)]` on by default
 
 error: aborting due to 1 previous error
 

Original file line number	Diff line number	Diff line change
`@@ -71,9 +71,7 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`pub(crate) fn get_return_type(&self, ty: &'ll Type) -> &'ll Type {`
`74`		`- unsafe {`
`75`		`- llvm::LLVMGetReturnType(ty)`
`76`		`- }`
	`74`	`+ unsafe { llvm::LLVMGetReturnType(ty) }`
`77`	`75`	`}`
`78`	`76`
`79`	`77`	`pub(crate) fn func_params_types(&self, ty: &'ll Type) -> Vec<&'ll Type> {`
Original file line number	Diff line number	Diff line change
@@ -3,6 +3,8 @@ error: Invalid LLVM Intrinsic `llvm.abcde`
`3`	`3`	`\|`
`4`	`4`	`LL \| fn foo();`
`5`	`5`	`\| ^^^^^^^^^`
	`6`	`+ \|`
	`7`	+ = note: `#[deny(unknown_llvm_intrinsic)]` on by default
`6`	`8`
`7`	`9`	`error: aborting due to 1 previous error`
`8`	`10`