Remove naked_functions feature usage for x86 (#722)

Given that this function has no generics, it could easily use `global_asm!`
instead.

This is a backport of #722, except without the part that removes
outline asm for x86, as that's still needed on the 0.37 branch. It
fixes compilation errors on the 0.37 when compiled with the latest
nightly, due to `asm!` in `#[naked]` functions needed to be change
to `naked_asm!`.

Fixes #1181.

Author: nbdd0121

build.rs

@@ -87,14 +87,11 @@ fn main() {
         // Rust's inline asm is considered experimental, so only use it if
         // `--cfg=rustix_use_experimental_asm` is given.
         if (feature_rustc_dep_of_std || vendor == "mustang" || can_compile("use std::arch::asm;"))
-            && (arch != "x86" || has_feature("naked_functions"))
+            && (arch != "x86")
             && ((arch != "powerpc64" && arch != "mips" && arch != "mips64")
                 || rustix_use_experimental_asm)
         {
             use_feature("asm");
-            if arch == "x86" {
-                use_feature("naked_functions");
-            }
             if rustix_use_experimental_asm {
                 use_feature("asm_experimental_arch");
             }

src/backend/linux_raw/vdso_wrappers.rs

@@ -16,7 +16,7 @@ use super::time::types::{ClockId, DynamicClockId, Timespec};
 use super::{c, vdso};
 use crate::io;
 #[cfg(all(asm, target_arch = "x86"))]
-use core::arch::asm;
+use core::arch::global_asm;
 use core::mem::{transmute, MaybeUninit};
 use core::ptr::null_mut;
 use core::sync::atomic::AtomicPtr;
@@ -293,21 +293,34 @@ unsafe fn _rustix_clock_gettime_via_syscall(
     ret(syscall!(__NR_clock_gettime, c_int(clockid), res))
 }
 
-/// A symbol pointing to an `int 0x80` instruction. This “function” is only
-/// called from assembly, and only with the x86 syscall calling convention,
-/// so its signature here is not its true signature.
-#[cfg(all(asm, target_arch = "x86"))]
-#[naked]
-unsafe extern "C" fn rustix_int_0x80() {
-    asm!("int $$0x80", "ret", options(noreturn))
-}
-
-// The outline version of the `rustix_int_0x80` above.
-#[cfg(all(not(asm), target_arch = "x86"))]
+#[cfg(target_arch = "x86")]
 extern "C" {
+    /// A symbol pointing to an `int 0x80` instruction. This “function” is only
+    /// called from assembly, and only with the x86 syscall calling convention.
+    /// so its signature here is not its true signature.
+    ///
+    /// This extern block and the `global_asm!` below can be replaced with
+    /// `#[naked]` if it's stabilized.
     fn rustix_int_0x80();
 }
 
+#[cfg(all(asm, target_arch = "x86"))]
+global_asm!(
+    r#"
+    .section    .text.rustix_int_0x80,"ax",@progbits
+    .p2align    4
+    .weak       rustix_int_0x80
+    .hidden     rustix_int_0x80
+    .type       rustix_int_0x80, @function
+rustix_int_0x80:
+    .cfi_startproc
+    int    0x80
+    ret
+    .cfi_endproc
+    .size rustix_int_0x80, .-rustix_int_0x80
+"#
+);
+
 fn minimal_init() {
     // SAFETY: Store default function addresses in static storage so that if we
     // end up making any system calls while we read the vDSO, they'll work.

src/lib.rs

@@ -101,10 +101,6 @@
 #![cfg_attr(rustc_attrs, feature(rustc_attrs))]
 #![cfg_attr(doc_cfg, feature(doc_cfg))]
 #![cfg_attr(all(wasi_ext, target_os = "wasi", feature = "std"), feature(wasi_ext))]
-#![cfg_attr(
-    all(linux_raw, naked_functions, target_arch = "x86"),
-    feature(naked_functions)
-)]
 #![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
 #![cfg_attr(core_ffi_c, feature(core_ffi_c))]
 #![cfg_attr(core_c_str, feature(core_c_str))]