Auto merge of #161398 - bjorn3:rename_unadjusted_abi, r=tgross35

Rename extern "unadjusted" to extern "llvm-intrinsic"

This makes it clear that it is only meant for LLVM intrinsics and not for defining or calling arbitrary user functions.

Follow up to #160077

Author: bors

compiler/rustc_abi/src/extern_abi.rs

@@ -54,9 +54,8 @@ pub enum ExternAbi {
     /// This ABI is not stable, and relies on LLVM implementation details.
     RustTail,
 
-    /// Unstable impl detail that directly uses Rust types to describe the ABI to LLVM.
-    /// Even normally-compatible Rust types can become ABI-incompatible with this ABI!
-    Unadjusted,
+    /// Unstable ABI used to call LLVM intrinsics.
+    LlvmIntrinsic,
 
     /// An ABI that rustc does not know how to call or define. Functions with this ABI can
     /// only be created using `#[naked]` functions or `extern "custom"` blocks, and can only
@@ -196,6 +195,7 @@ abi_impls! {
             Fastcall { unwind: false } =><= "fastcall",
             Fastcall { unwind: true } =><= "fastcall-unwind",
             GpuKernel =><= "gpu-kernel",
+            LlvmIntrinsic =><= "llvm-intrinsic",
             Msp430Interrupt =><= "msp430-interrupt",
             PtxKernel =><= "ptx-kernel",
             RiscvInterruptM =><= "riscv-interrupt-m",
@@ -213,7 +213,6 @@ abi_impls! {
             RustTail =><= "tail",
             Thiscall { unwind: false } =><= "thiscall",
             Thiscall { unwind: true } =><= "thiscall-unwind",
-            Unadjusted =><= "unadjusted",
             Vectorcall { unwind: false } =><= "vectorcall",
             Vectorcall { unwind: true } =><= "vectorcall-unwind",
             Win64 { unwind: false } =><= "win64",
@@ -355,7 +354,7 @@ impl ExternAbi {
             | Self::Rust
             | Self::RustCold
             | Self::RustInvalid
-            | Self::Unadjusted
+            | Self::LlvmIntrinsic
             | Self::EfiApi
             | Self::Aapcs { .. }
             | Self::Cdecl { .. }

compiler/rustc_ast_lowering/src/stability.rs

@@ -79,9 +79,11 @@ pub fn extern_abi_stability(abi: ExternAbi) -> Result<(), UnstableAbi> {
         | ExternAbi::SysV64 { .. }
         | ExternAbi::System { .. }
         | ExternAbi::EfiApi => Ok(()),
-        ExternAbi::Unadjusted => {
-            Err(UnstableAbi { abi, feature: sym::abi_unadjusted, explain: GateReason::ImplDetail })
-        }
+        ExternAbi::LlvmIntrinsic => Err(UnstableAbi {
+            abi,
+            feature: sym::link_llvm_intrinsics,
+            explain: GateReason::ImplDetail,
+        }),
         // experimental
         ExternAbi::Vectorcall { .. } => Err(UnstableAbi {
             abi,

compiler/rustc_feature/src/removed.rs

@@ -55,6 +55,7 @@ declare_features! (
     /// Allows using the `amdgpu-kernel` ABI.
     (removed, abi_amdgpu_kernel, "1.77.0", Some(51575), None, 120495),
     (removed, abi_c_cmse_nonsecure_call, "1.90.0", Some(81391), Some("renamed to abi_cmse_nonsecure_call"), 142146),
+    (removed, abi_unadjusted, "CURRENT_RUSTC_VERSION", None, Some("merged into link_llvm_intrinsics"), 161398),
     (removed, advanced_slice_patterns, "1.42.0", Some(62254),
      Some("merged into `#![feature(slice_patterns)]`"), 67712),
     (removed, allocator, "1.0.0", None, None),

compiler/rustc_feature/src/unstable.rs

@@ -236,8 +236,6 @@ declare_features! (
     // -------------------------------------------------------------------------
     // no-tracking-issue-start
 
-    /// Allows using the `unadjusted` ABI; perma-unstable.
-    (internal, abi_unadjusted, "1.16.0", None),
     /// Allows using `#![needs_allocator]`, an implementation detail of `#[global_allocator]`.
     (internal, allocator_internals, "1.20.0", None),
     /// Allows using `#[allow_internal_unsafe]`. This is an

compiler/rustc_lint_defs/src/builtin.rs

@@ -5533,10 +5533,10 @@ declare_lint! {
     ///
     /// ```rust,ignore (requires x86)
     /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    /// #![feature(link_llvm_intrinsics, abi_unadjusted)]
+    /// #![feature(link_llvm_intrinsics)]
     /// #![deny(deprecated_llvm_intrinsic)]
     ///
-    /// unsafe extern "unadjusted" {
+    /// unsafe extern "llvm-intrinsic" {
     ///     #[link_name = "llvm.x86.addcarryx.u32"]
     ///     fn foo(a: u8, b: u32, c: u32, d: &mut u32) -> u8;
     /// }

compiler/rustc_middle/src/ty/instance.rs

@@ -75,7 +75,7 @@ pub enum InstanceKind<'tcx> {
     /// "magically" evaluate calls to intrinsics purely in the caller.
     Intrinsic(DefId),
 
-    /// An LLVM intrinsic `fn` item (with `extern "unadjusted"`).
+    /// An LLVM intrinsic `fn` item (with `extern "llvm-intrinsic"`).
     ///
     /// Alongside `Intrinsic` and `Virtual`, this is the only `InstanceKind`
     /// that does not have its own callable MIR. Instead, codegen and const eval

compiler/rustc_middle/src/ty/layout.rs

@@ -1329,7 +1329,7 @@ pub fn fn_can_unwind(tcx: TyCtxt<'_>, fn_def_id: Option<DefId>, abi: ExternAbi)
         | RiscvInterruptS
         | RustInvalid
         | Swift
-        | Unadjusted => false,
+        | LlvmIntrinsic => false,
         Rust | RustCall | RustCold | RustPreserveNone | RustTail => {
             tcx.sess.panic_strategy().unwinds()
         }

compiler/rustc_monomorphize/src/mono_checks/abi_check.rs

@@ -160,9 +160,9 @@ fn do_check_unsized_params<'tcx>(
 fn check_instance_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
     let typing_env = ty::TypingEnv::fully_monomorphized();
     let ty = instance.ty(tcx, typing_env);
-    if ty.is_fn() && ty.fn_sig(tcx).abi() == ExternAbi::Unadjusted {
-        // We disable all checks for the unadjusted ABI to allow linking to arbitrary LLVM
-        // intrinsics
+    if ty.is_fn() && ty.fn_sig(tcx).abi() == ExternAbi::LlvmIntrinsic {
+        // We disable all checks for the llvm-intrinsic ABI to allow linking to arbitrary
+        // LLVM intrinsics
         return;
     }
     let Ok(abi) = tcx.fn_abi_of_instance(typing_env.as_query_input((instance, ty::List::empty())))
@@ -196,11 +196,11 @@ fn check_call_site_abi<'tcx>(
     loc: impl Fn() -> (Span, HirId) + Copy,
 ) {
     let extern_abi = callee.fn_sig(tcx).abi();
-    if extern_abi.is_rustic_abi() || extern_abi == ExternAbi::Unadjusted {
+    if extern_abi.is_rustic_abi() || extern_abi == ExternAbi::LlvmIntrinsic {
         // We directly handle the soundness of Rust ABIs -- so let's skip the majority of
         // call sites to avoid a perf regression.
-        // We disable all checks for the unadjusted ABI to allow linking to arbitrary LLVM
-        // intrinsics
+        // We disable all checks for the llvm-intrinsic ABI to allow linking to arbitrary
+        // LLVM intrinsics
         return;
     }
     let typing_env = ty::TypingEnv::fully_monomorphized();

compiler/rustc_public/src/ty/tys.rs

@@ -867,7 +867,7 @@ pub enum Abi {
     CCmseNonSecureEntry,
     System { unwind: bool },
     RustCall,
-    Unadjusted,
+    LlvmIntrinsic,
     RustCold,
     RiscvInterruptM,
     RiscvInterruptS,

compiler/rustc_public/src/unstable/convert/internal.rs

@@ -614,7 +614,7 @@ impl RustcInternal for Abi {
             Abi::AvrNonBlockingInterrupt => rustc_abi::ExternAbi::AvrNonBlockingInterrupt,
             Abi::System { unwind } => rustc_abi::ExternAbi::System { unwind },
             Abi::RustCall => rustc_abi::ExternAbi::RustCall,
-            Abi::Unadjusted => rustc_abi::ExternAbi::Unadjusted,
+            Abi::LlvmIntrinsic => rustc_abi::ExternAbi::LlvmIntrinsic,
             Abi::RustCold => rustc_abi::ExternAbi::RustCold,
             Abi::RustInvalid => rustc_abi::ExternAbi::RustInvalid,
             Abi::RiscvInterruptM => rustc_abi::ExternAbi::RiscvInterruptM,