stabilize naked_functions

folkertdev · folkertdev · commit 168774358bda · 2025-03-13T18:33:05.000+01:00
diff --git a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
@@ -1,13 +1,4 @@
-#![feature(
-    no_core,
-    lang_items,
-    never_type,
-    linkage,
-    extern_types,
-    naked_functions,
-    thread_local,
-    repr_simd
-)]
+#![feature(no_core, lang_items, never_type, linkage, extern_types, thread_local, repr_simd)]
 #![no_core]
 #![allow(dead_code, non_camel_case_types, internal_features)]
 
diff --git a/compiler/rustc_error_codes/src/error_codes/E0787.md b/compiler/rustc_error_codes/src/error_codes/E0787.md
@@ -3,8 +3,6 @@ An unsupported naked function definition.
 Erroneous code example:
 
 ```compile_fail,E0787
-#![feature(naked_functions)]
-
 #[naked]
 pub extern "C" fn f() -> u32 {
     42
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
@@ -296,6 +296,8 @@ declare_features! (
     /// Allows patterns with concurrent by-move and by-ref bindings.
     /// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref.
     (accepted, move_ref_pattern, "1.49.0", Some(68354)),
+    /// Allows using `#[naked]` on functions.
+    (accepted, naked_functions, "CURRENT_RUSTC_VERSION", Some(90957)),
     /// Allows specifying modifiers in the link attribute: `#[link(modifiers = "...")]`
     (accepted, native_link_modifiers, "1.61.0", Some(81490)),
     /// Allows specifying the bundle link modifier
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -428,6 +428,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ungated!(unsafe no_mangle, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No),
     ungated!(used, Normal, template!(Word, List: "compiler|linker"), WarnFollowing, EncodeCrossCrate::No),
     ungated!(link_ordinal, Normal, template!(List: "ordinal"), ErrorPreceding, EncodeCrossCrate::Yes),
+    ungated!(naked, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No),
 
     // Limits:
     ungated!(
@@ -500,12 +501,6 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     // Unstable attributes:
     // ==========================================================================
 
-    // Linking:
-    gated!(
-        naked, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No,
-        naked_functions, experimental!(naked)
-    ),
-
     // Testing:
     gated!(
         test_runner, CrateLevel, template!(List: "path"), ErrorFollowing,
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -566,8 +566,6 @@ declare_features! (
     (unstable, must_not_suspend, "1.57.0", Some(83310)),
     /// Allows `mut ref` and `mut ref mut` identifier patterns.
     (incomplete, mut_ref, "1.79.0", Some(123076)),
-    /// Allows using `#[naked]` on functions.
-    (unstable, naked_functions, "1.9.0", Some(90957)),
     /// Allows specifying the as-needed link modifier
     (unstable, native_link_modifiers_as_needed, "1.53.0", Some(81490)),
     /// Allow negative trait implementations.
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
@@ -2836,7 +2836,7 @@ declare_lint! {
     /// ### Example
     ///
     /// ```rust
-    /// #![feature(asm_experimental_arch, naked_functions)]
+    /// #![feature(asm_experimental_arch)]
     ///
     /// use std::arch::naked_asm;
     ///
diff --git a/library/core/src/arch.rs b/library/core/src/arch.rs
@@ -32,7 +32,7 @@ pub macro asm("assembly template", $(operands,)* $(options($(option),*))?) {
 ///
 /// [Rust By Example]: https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html
 /// [reference]: https://doc.rust-lang.org/nightly/reference/inline-assembly.html
-#[unstable(feature = "naked_functions", issue = "90957")]
+#[stable(feature = "naked_functions", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_builtin_macro]
 pub macro naked_asm("assembly template", $(operands,)* $(options($(option),*))?) {
     /* compiler built-in */
diff --git a/src/doc/unstable-book/src/compiler-flags/sanitizer.md b/src/doc/unstable-book/src/compiler-flags/sanitizer.md
@@ -245,9 +245,7 @@ See the [Clang ControlFlowIntegrity documentation][clang-cfi] for more details.
 ## Example 1: Redirecting control flow using an indirect branch/call to an invalid destination
 
 ```rust,ignore (making doc tests pass cross-platform is hard)
-#![feature(naked_functions)]
-
-use std::arch::asm;
+use std::arch::naked_asm;
 use std::mem;
 
 fn add_one(x: i32) -> i32 {
@@ -258,7 +256,7 @@ fn add_one(x: i32) -> i32 {
 pub extern "C" fn add_two(x: i32) {
     // x + 2 preceded by a landing pad/nop block
     unsafe {
-        asm!(
+        naked_asm!(
             "
              nop
              nop
diff --git a/tests/assembly/naked-functions/aarch64-naked-fn-no-bti-prolog.rs b/tests/assembly/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
@@ -4,7 +4,7 @@
 //@ only-aarch64
 
 #![crate_type = "lib"]
-#![feature(naked_functions)]
+
 use std::arch::naked_asm;
 
 // The problem at hand: Rust has adopted a fairly strict meaning for "naked functions",
diff --git a/tests/assembly/naked-functions/x86_64-naked-fn-no-cet-prolog.rs b/tests/assembly/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
@@ -4,7 +4,7 @@
 //@ only-x86_64
 
 #![crate_type = "lib"]
-#![feature(naked_functions)]
+
 use std::arch::naked_asm;
 
 // The problem at hand: Rust has adopted a fairly strict meaning for "naked functions",
diff --git a/tests/codegen/cffi/c-variadic-naked.rs b/tests/codegen/cffi/c-variadic-naked.rs
@@ -5,7 +5,6 @@
 
 #![crate_type = "lib"]
 #![feature(c_variadic)]
-#![feature(naked_functions)]
 #![no_std]
 
 #[naked]
diff --git a/tests/codegen/naked-asan.rs b/tests/codegen/naked-asan.rs
@@ -6,7 +6,7 @@
 
 #![crate_type = "lib"]
 #![no_std]
-#![feature(abi_x86_interrupt, naked_functions)]
+#![feature(abi_x86_interrupt)]
 
 pub fn caller() {
     page_fault_handler(1, 2);
diff --git a/tests/codegen/naked-fn/aligned.rs b/tests/codegen/naked-fn/aligned.rs
@@ -3,7 +3,7 @@
 //@ ignore-arm no "ret" mnemonic
 
 #![crate_type = "lib"]
-#![feature(naked_functions, fn_align)]
+#![feature(fn_align)]
 use std::arch::naked_asm;
 
 // CHECK: .balign 16
diff --git a/tests/codegen/naked-fn/generics.rs b/tests/codegen/naked-fn/generics.rs
@@ -2,7 +2,6 @@
 //@ only-x86_64
 
 #![crate_type = "lib"]
-#![feature(naked_functions, asm_const)]
 
 use std::arch::naked_asm;
 
diff --git a/tests/codegen/naked-fn/instruction-set.rs b/tests/codegen/naked-fn/instruction-set.rs
@@ -6,7 +6,7 @@
 //@ [thumb-mode] needs-llvm-components: arm
 
 #![crate_type = "lib"]
-#![feature(no_core, lang_items, rustc_attrs, naked_functions)]
+#![feature(no_core, lang_items, rustc_attrs)]
 #![no_core]
 
 extern crate minicore;
diff --git a/tests/codegen/naked-fn/naked-functions.rs b/tests/codegen/naked-fn/naked-functions.rs
@@ -13,7 +13,7 @@
 //@[thumb] needs-llvm-components: arm
 
 #![crate_type = "lib"]
-#![feature(no_core, lang_items, rustc_attrs, naked_functions)]
+#![feature(no_core, lang_items, rustc_attrs)]
 #![no_core]
 
 extern crate minicore;
diff --git a/tests/run-make/naked-symbol-visibility/a_rust_dylib.rs b/tests/run-make/naked-symbol-visibility/a_rust_dylib.rs
@@ -1,4 +1,4 @@
-#![feature(naked_functions, linkage)]
+#![feature(linkage)]
 #![crate_type = "dylib"]
 
 use std::arch::naked_asm;
diff --git a/tests/ui/asm/naked-asm-outside-naked-fn.rs b/tests/ui/asm/naked-asm-outside-naked-fn.rs
@@ -3,7 +3,6 @@
 //@ ignore-nvptx64
 //@ ignore-spirv
 
-#![feature(naked_functions)]
 #![crate_type = "lib"]
 
 use std::arch::naked_asm;
diff --git a/tests/ui/asm/naked-asm-outside-naked-fn.stderr b/tests/ui/asm/naked-asm-outside-naked-fn.stderr
@@ -1,17 +1,17 @@
 error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
-  --> $DIR/naked-asm-outside-naked-fn.rs:21:14
+  --> $DIR/naked-asm-outside-naked-fn.rs:20:14
    |
 LL |     unsafe { naked_asm!("") }
    |              ^^^^^^^^^^^^^^
 
 error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
-  --> $DIR/naked-asm-outside-naked-fn.rs:26:18
+  --> $DIR/naked-asm-outside-naked-fn.rs:25:18
    |
 LL |     unsafe { (|| naked_asm!(""))() }
    |                  ^^^^^^^^^^^^^^
 
 error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
-  --> $DIR/naked-asm-outside-naked-fn.rs:32:19
+  --> $DIR/naked-asm-outside-naked-fn.rs:31:19
    |
 LL |         unsafe {  naked_asm!("") } ;
    |                   ^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/naked-functions-ffi.rs b/tests/ui/asm/naked-functions-ffi.rs
@@ -1,6 +1,5 @@
 //@ check-pass
 //@ needs-asm-support
-#![feature(naked_functions)]
 #![crate_type = "lib"]
 
 use std::arch::naked_asm;
diff --git a/tests/ui/asm/naked-functions-ffi.stderr b/tests/ui/asm/naked-functions-ffi.stderr
@@ -1,5 +1,5 @@
 warning: `extern` fn uses type `char`, which is not FFI-safe
-  --> $DIR/naked-functions-ffi.rs:9:28
+  --> $DIR/naked-functions-ffi.rs:8:28
    |
 LL | pub extern "C" fn naked(p: char) -> u128 {
    |                            ^^^^ not FFI-safe
@@ -9,7 +9,7 @@ LL | pub extern "C" fn naked(p: char) -> u128 {
    = note: `#[warn(improper_ctypes_definitions)]` on by default
 
 warning: `extern` fn uses type `u128`, which is not FFI-safe
-  --> $DIR/naked-functions-ffi.rs:9:37
+  --> $DIR/naked-functions-ffi.rs:8:37
    |
 LL | pub extern "C" fn naked(p: char) -> u128 {
    |                                     ^^^^ not FFI-safe
diff --git a/tests/ui/asm/naked-functions-inline.rs b/tests/ui/asm/naked-functions-inline.rs
@@ -1,5 +1,4 @@
 //@ needs-asm-support
-#![feature(naked_functions)]
 #![crate_type = "lib"]
 
 use std::arch::naked_asm;
diff --git a/tests/ui/asm/naked-functions-inline.stderr b/tests/ui/asm/naked-functions-inline.stderr
@@ -1,29 +1,29 @@
 error[E0736]: attribute incompatible with `#[naked]`
-  --> $DIR/naked-functions-inline.rs:13:1
+  --> $DIR/naked-functions-inline.rs:12:1
    |
 LL | #[naked]
    | -------- function marked with `#[naked]` here
 LL | #[inline]
    | ^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]`
 
 error[E0736]: attribute incompatible with `#[naked]`
-  --> $DIR/naked-functions-inline.rs:20:1
+  --> $DIR/naked-functions-inline.rs:19:1
    |
 LL | #[naked]
    | -------- function marked with `#[naked]` here
 LL | #[inline(always)]
    | ^^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]`
 
 error[E0736]: attribute incompatible with `#[naked]`
-  --> $DIR/naked-functions-inline.rs:27:1
+  --> $DIR/naked-functions-inline.rs:26:1
    |
 LL | #[naked]
    | -------- function marked with `#[naked]` here
 LL | #[inline(never)]
    | ^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]`
 
 error[E0736]: attribute incompatible with `#[naked]`
-  --> $DIR/naked-functions-inline.rs:34:19
+  --> $DIR/naked-functions-inline.rs:33:19
    |
 LL | #[naked]
    | -------- function marked with `#[naked]` here
diff --git a/tests/ui/asm/naked-functions-instruction-set.rs b/tests/ui/asm/naked-functions-instruction-set.rs
@@ -5,7 +5,7 @@
 //@ build-pass
 
 #![crate_type = "lib"]
-#![feature(no_core, naked_functions)]
+#![feature(no_core)]
 #![no_core]
 
 extern crate minicore;
diff --git a/tests/ui/asm/naked-functions-testattrs.rs b/tests/ui/asm/naked-functions-testattrs.rs
@@ -2,7 +2,6 @@
 //@ compile-flags: --test
 
 #![allow(undefined_naked_function_abi)]
-#![feature(naked_functions)]
 #![feature(test)]
 #![crate_type = "lib"]
 
diff --git a/tests/ui/asm/naked-functions-testattrs.stderr b/tests/ui/asm/naked-functions-testattrs.stderr
@@ -1,29 +1,29 @@
 error[E0736]: cannot use `#[naked]` with testing attributes
-  --> $DIR/naked-functions-testattrs.rs:12:1
+  --> $DIR/naked-functions-testattrs.rs:11:1
    |
 LL | #[test]
    | ------- function marked with testing attribute here
 LL | #[naked]
    | ^^^^^^^^ `#[naked]` is incompatible with testing attributes
 
 error[E0736]: cannot use `#[naked]` with testing attributes
-  --> $DIR/naked-functions-testattrs.rs:20:1
+  --> $DIR/naked-functions-testattrs.rs:19:1
    |
 LL | #[test]
    | ------- function marked with testing attribute here
 LL | #[naked]
    | ^^^^^^^^ `#[naked]` is incompatible with testing attributes
 
 error[E0736]: cannot use `#[naked]` with testing attributes
-  --> $DIR/naked-functions-testattrs.rs:28:1
+  --> $DIR/naked-functions-testattrs.rs:27:1
    |
 LL | #[test]
    | ------- function marked with testing attribute here
 LL | #[naked]
    | ^^^^^^^^ `#[naked]` is incompatible with testing attributes
 
 error[E0736]: cannot use `#[naked]` with testing attributes
-  --> $DIR/naked-functions-testattrs.rs:35:1
+  --> $DIR/naked-functions-testattrs.rs:34:1
    |
 LL | #[bench]
    | -------- function marked with testing attribute here
diff --git a/tests/ui/asm/naked-functions-unused.aarch64.stderr b/tests/ui/asm/naked-functions-unused.aarch64.stderr
@@ -1,5 +1,5 @@
 error: unused variable: `a`
-  --> $DIR/naked-functions-unused.rs:17:32
+  --> $DIR/naked-functions-unused.rs:16:32
    |
 LL |     pub extern "C" fn function(a: usize, b: usize) -> usize {
    |                                ^ help: if this is intentional, prefix it with an underscore: `_a`
@@ -12,55 +12,55 @@ LL | #![deny(unused)]
    = note: `#[deny(unused_variables)]` implied by `#[deny(unused)]`
 
 error: unused variable: `b`
-  --> $DIR/naked-functions-unused.rs:17:42
+  --> $DIR/naked-functions-unused.rs:16:42
    |
 LL |     pub extern "C" fn function(a: usize, b: usize) -> usize {
    |                                          ^ help: if this is intentional, prefix it with an underscore: `_b`
 
 error: unused variable: `a`
-  --> $DIR/naked-functions-unused.rs:28:38
+  --> $DIR/naked-functions-unused.rs:27:38
    |
 LL |         pub extern "C" fn associated(a: usize, b: usize) -> usize {
    |                                      ^ help: if this is intentional, prefix it with an underscore: `_a`
 
 error: unused variable: `b`
-  --> $DIR/naked-functions-unused.rs:28:48
+  --> $DIR/naked-functions-unused.rs:27:48
    |
 LL |         pub extern "C" fn associated(a: usize, b: usize) -> usize {
    |                                                ^ help: if this is intentional, prefix it with an underscore: `_b`
 
 error: unused variable: `a`
-  --> $DIR/naked-functions-unused.rs:36:41
+  --> $DIR/naked-functions-unused.rs:35:41
    |
 LL |         pub extern "C" fn method(&self, a: usize, b: usize) -> usize {
    |                                         ^ help: if this is intentional, prefix it with an underscore: `_a`
 
 error: unused variable: `b`
-  --> $DIR/naked-functions-unused.rs:36:51
+  --> $DIR/naked-functions-unused.rs:35:51
    |
 LL |         pub extern "C" fn method(&self, a: usize, b: usize) -> usize {
    |                                                   ^ help: if this is intentional, prefix it with an underscore: `_b`
 
 error: unused variable: `a`
-  --> $DIR/naked-functions-unused.rs:46:40
+  --> $DIR/naked-functions-unused.rs:45:40
    |
 LL |         extern "C" fn trait_associated(a: usize, b: usize) -> usize {
    |                                        ^ help: if this is intentional, prefix it with an underscore: `_a`
 
 error: unused variable: `b`
-  --> $DIR/naked-functions-unused.rs:46:50
+  --> $DIR/naked-functions-unused.rs:45:50
    |
 LL |         extern "C" fn trait_associated(a: usize, b: usize) -> usize {
    |                                                  ^ help: if this is intentional, prefix it with an underscore: `_b`
 
 error: unused variable: `a`
-  --> $DIR/naked-functions-unused.rs:54:43
+  --> $DIR/naked-functions-unused.rs:53:43
    |
 LL |         extern "C" fn trait_method(&self, a: usize, b: usize) -> usize {
    |                                           ^ help: if this is intentional, prefix it with an underscore: `_a`
 
 error: unused variable: `b`
-  --> $DIR/naked-functions-unused.rs:54:53
+  --> $DIR/naked-functions-unused.rs:53:53
    |
 LL |         extern "C" fn trait_method(&self, a: usize, b: usize) -> usize {
    |                                                     ^ help: if this is intentional, prefix it with an underscore: `_b`
diff --git a/tests/ui/asm/naked-functions-unused.rs b/tests/ui/asm/naked-functions-unused.rs
@@ -3,7 +3,6 @@
 //@[x86_64] only-x86_64
 //@[aarch64] only-aarch64
 #![deny(unused)]
-#![feature(naked_functions)]
 #![crate_type = "lib"]
 
 pub trait Trait {
diff --git a/tests/ui/asm/naked-functions-unused.x86_64.stderr b/tests/ui/asm/naked-functions-unused.x86_64.stderr
diff --git a/tests/ui/asm/naked-functions.rs b/tests/ui/asm/naked-functions.rs
diff --git a/tests/ui/asm/naked-functions.stderr b/tests/ui/asm/naked-functions.stderr
diff --git a/tests/ui/asm/naked-invalid-attr.rs b/tests/ui/asm/naked-invalid-attr.rs
diff --git a/tests/ui/asm/naked-invalid-attr.stderr b/tests/ui/asm/naked-invalid-attr.stderr
diff --git a/tests/ui/asm/naked-with-invalid-repr-attr.rs b/tests/ui/asm/naked-with-invalid-repr-attr.rs
diff --git a/tests/ui/asm/naked-with-invalid-repr-attr.stderr b/tests/ui/asm/naked-with-invalid-repr-attr.stderr
diff --git a/tests/ui/asm/named-asm-labels.rs b/tests/ui/asm/named-asm-labels.rs
diff --git a/tests/ui/asm/named-asm-labels.stderr b/tests/ui/asm/named-asm-labels.stderr
diff --git a/tests/ui/asm/simple_global_asm.rs b/tests/ui/asm/simple_global_asm.rs
diff --git a/tests/ui/feature-gates/feature-gate-naked_functions.rs b/tests/ui/feature-gates/feature-gate-naked_functions.rs
diff --git a/tests/ui/feature-gates/feature-gate-naked_functions.stderr b/tests/ui/feature-gates/feature-gate-naked_functions.stderr
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.rs b/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.rs
diff --git a/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.stderr b/tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.stderr

Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,6 @@ An unsupported naked function definition.`
`3`	`3`	`Erroneous code example:`
`4`	`4`
`5`	`5`	```compile_fail,E0787
`6`		`-#![feature(naked_functions)]`
`7`		`-`
`8`	`6`	`#[naked]`
`9`	`7`	`pub extern "C" fn f() -> u32 {`
`10`	`8`	`42`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-#![feature(naked_functions, linkage)]`
	`1`	`+#![feature(linkage)]`
`2`	`2`	`#![crate_type = "dylib"]`
`3`	`3`
`4`	`4`	`use std::arch::naked_asm;`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,17 @@`
`1`	`1`	error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
`2`		`- --> $DIR/naked-asm-outside-naked-fn.rs:21:14`
	`2`	`+ --> $DIR/naked-asm-outside-naked-fn.rs:20:14`
`3`	`3`	`\|`
`4`	`4`	`LL \| unsafe { naked_asm!("") }`
`5`	`5`	`\| ^^^^^^^^^^^^^^`
`6`	`6`
`7`	`7`	error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
`8`		`- --> $DIR/naked-asm-outside-naked-fn.rs:26:18`
	`8`	`+ --> $DIR/naked-asm-outside-naked-fn.rs:25:18`
`9`	`9`	`\|`
`10`	`10`	`LL \| unsafe { (\|\| naked_asm!(""))() }`
`11`	`11`	`\| ^^^^^^^^^^^^^^`
`12`	`12`
`13`	`13`	error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
`14`		`- --> $DIR/naked-asm-outside-naked-fn.rs:32:19`
	`14`	`+ --> $DIR/naked-asm-outside-naked-fn.rs:31:19`
`15`	`15`	`\|`
`16`	`16`	`LL \| unsafe { naked_asm!("") } ;`
`17`	`17`	`\| ^^^^^^^^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	warning: `extern` fn uses type `char`, which is not FFI-safe
`2`		`- --> $DIR/naked-functions-ffi.rs:9:28`
	`2`	`+ --> $DIR/naked-functions-ffi.rs:8:28`
`3`	`3`	`\|`
`4`	`4`	`LL \| pub extern "C" fn naked(p: char) -> u128 {`
`5`	`5`	`\| ^^^^ not FFI-safe`
`@@ -9,7 +9,7 @@ LL \| pub extern "C" fn naked(p: char) -> u128 {`
`9`	`9`	= note: `#[warn(improper_ctypes_definitions)]` on by default
`10`	`10`
`11`	`11`	warning: `extern` fn uses type `u128`, which is not FFI-safe
`12`		`- --> $DIR/naked-functions-ffi.rs:9:37`
	`12`	`+ --> $DIR/naked-functions-ffi.rs:8:37`
`13`	`13`	`\|`
`14`	`14`	`LL \| pub extern "C" fn naked(p: char) -> u128 {`
`15`	`15`	`\| ^^^^ not FFI-safe`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`//@ needs-asm-support`
`2`		`-#![feature(naked_functions)]`
`3`	`2`	`#![crate_type = "lib"]`
`4`	`3`
`5`	`4`	`use std::arch::naked_asm;`