bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #139753 - folkertdev:naked-function-unsafe-attribute, r=tgross35,traviscross

Browse source 
Make `#[naked]` an unsafe attribute

tracking issue: https://github.com/rust-lang/rust/issues/138997

Per https://github.com/rust-lang/rust/pull/134213#issuecomment-2755984503, the `#[naked]` attribute is now an unsafe attribute (in any edition).

This can only be merged when the above PRs are merged, I'd just like to see if there are any CI surprises here, and maybe there is early review feedback too.

r? ``@traviscross``
This commit is contained in:
Chris Denton 2025-04-19 15:09:34 +00:00 • committed by GitHub
commit 1a5e486068
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
46 changed files with 375 additions and 403 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_builtin_macros/messages.ftl
View file

@ -247,9 +247,9 @@ builtin_macros_multiple_defaults = multiple declared defaults
.suggestion = make `{$ident}` default .suggestion = make `{$ident}` default
builtin_macros_naked_functions_testing_attribute = builtin_macros_naked_functions_testing_attribute =
cannot use `#[naked]` with testing attributes cannot use `#[unsafe(naked)]` with testing attributes
.label = function marked with testing attribute here .label = function marked with testing attribute here
.naked_attribute = `#[naked]` is incompatible with testing attributes .naked_attribute = `#[unsafe(naked)]` is incompatible with testing attributes
builtin_macros_no_default_variant = `#[derive(Default)]` on enum with no `#[default]` builtin_macros_no_default_variant = `#[derive(Default)]` on enum with no `#[default]`
.label = this enum needs a unit variant marked with `#[default]` .label = this enum needs a unit variant marked with `#[default]`

6
compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
View file

@ -387,11 +387,9 @@ global_asm! {
} }
#[cfg(all(not(jit), target_arch = "x86_64"))] #[cfg(all(not(jit), target_arch = "x86_64"))]
#[naked] #[unsafe(naked)]
extern "C" fn naked_test() { extern "C" fn naked_test() {
unsafe { naked_asm!("ret")
naked_asm!("ret");
}
} }
#[repr(C)] #[repr(C)]

2
compiler/rustc_error_codes/src/error_codes/E0736.md
View file

@ -11,7 +11,7 @@ Erroneous code example:
```compile_fail,E0736 ```compile_fail,E0736
#[inline] #[inline]
#[naked] #[unsafe(naked)]
fn foo() {} fn foo() {}
``` ```

2
compiler/rustc_error_codes/src/error_codes/E0787.md
View file

@ -5,7 +5,7 @@ Erroneous code example:
```compile_fail,E0787 ```compile_fail,E0787
#![feature(naked_functions)] #![feature(naked_functions)]
#[naked] #[unsafe(naked)]
pub extern "C" fn f() -> u32 { pub extern "C" fn f() -> u32 {
42 42
} }

2
compiler/rustc_feature/src/builtin_attrs.rs
View file

@ -517,7 +517,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
// Linking: // Linking:
gated!( gated!(
naked, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No, unsafe naked, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No,
naked_functions, experimental!(naked) naked_functions, experimental!(naked)
), ),

6
compiler/rustc_mir_build/src/check_unsafety.rs
View file

@ -564,13 +564,17 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
} }
} }
ExprKind::InlineAsm(box InlineAsmExpr { ExprKind::InlineAsm(box InlineAsmExpr {
asm_macro: AsmMacro::Asm | AsmMacro::NakedAsm, asm_macro: asm_macro @ (AsmMacro::Asm | AsmMacro::NakedAsm),
ref operands, ref operands,
template: _, template: _,
options: _, options: _,
line_spans: _, line_spans: _,
}) => { }) => {
// The `naked` attribute and the `naked_asm!` block form one atomic unit of
// unsafety, and `naked_asm!` does not itself need to be wrapped in an unsafe block.
if let AsmMacro::Asm = asm_macro {
self.requires_unsafe(expr.span, UseOfInlineAssembly); self.requires_unsafe(expr.span, UseOfInlineAssembly);
}
// For inline asm, do not use `walk_expr`, since we want to handle the label block // For inline asm, do not use `walk_expr`, since we want to handle the label block
// specially. // specially.

6
compiler/rustc_parse/src/validate_attr.rs
View file

@ -194,12 +194,6 @@ pub fn check_attribute_safety(psess: &ParseSess, safety: AttributeSafety, attr:
} }
} }
} else if let Safety::Unsafe(unsafe_span) = attr_item.unsafety { } else if let Safety::Unsafe(unsafe_span) = attr_item.unsafety {
// Allow (but don't require) `#[unsafe(naked)]` so that compiler-builtins can upgrade to it.
// FIXME(#139797): remove this special case when compiler-builtins has upgraded.
if attr.has_name(sym::naked) {
return;
}
psess.dcx().emit_err(errors::InvalidAttrUnsafe { psess.dcx().emit_err(errors::InvalidAttrUnsafe {
span: unsafe_span, span: unsafe_span,
name: attr_item.path.clone(), name: attr_item.path.clone(),

8
compiler/rustc_passes/messages.ftl
View file

@ -508,7 +508,7 @@ passes_must_use_no_effect =
`#[must_use]` has no effect when applied to {$article} {$target} `#[must_use]` has no effect when applied to {$article} {$target}
passes_naked_asm_outside_naked_fn = passes_naked_asm_outside_naked_fn =
the `naked_asm!` macro can only be used in functions marked with `#[naked]` the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
passes_naked_functions_asm_block = passes_naked_functions_asm_block =
naked functions must contain a single `naked_asm!` invocation naked functions must contain a single `naked_asm!` invocation
@ -516,9 +516,9 @@ passes_naked_functions_asm_block =
.label_non_asm = not allowed in naked functions .label_non_asm = not allowed in naked functions
passes_naked_functions_incompatible_attribute = passes_naked_functions_incompatible_attribute =
attribute incompatible with `#[naked]` attribute incompatible with `#[unsafe(naked)]`
.label = the `{$attr}` attribute is incompatible with `#[naked]` .label = the `{$attr}` attribute is incompatible with `#[unsafe(naked)]`
.naked_attribute = function marked with `#[naked]` here .naked_attribute = function marked with `#[unsafe(naked)]` here
passes_naked_functions_must_naked_asm = passes_naked_functions_must_naked_asm =
the `asm!` macro is not allowed in naked functions the `asm!` macro is not allowed in naked functions

11
src/doc/unstable-book/src/compiler-flags/sanitizer.md
View file

@ -247,18 +247,17 @@ See the [Clang ControlFlowIntegrity documentation][clang-cfi] for more details.
```rust,ignore (making doc tests pass cross-platform is hard) ```rust,ignore (making doc tests pass cross-platform is hard)
#![feature(naked_functions)] #![feature(naked_functions)]
use std::arch::asm; use std::arch::naked_asm;
use std::mem; use std::mem;
fn add_one(x: i32) -> i32 { fn add_one(x: i32) -> i32 {
x + 1 x + 1
} }
#[naked] #[unsafe(naked)]
pub extern "C" fn add_two(x: i32) { pub extern "C" fn add_two(x: i32) {
// x + 2 preceded by a landing pad/nop block // x + 2 preceded by a landing pad/nop block
unsafe { naked_asm!(
asm!(
" "
nop nop
nop nop
@ -271,11 +270,9 @@ pub extern "C" fn add_two(x: i32) {
nop nop
lea eax, [rdi+2] lea eax, [rdi+2]
ret ret
", "
options(noreturn)
); );
} }
}
fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 { fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
f(arg) + f(arg) f(arg) + f(arg)

4
tests/assembly/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
View file

@ -13,8 +13,8 @@ use std::arch::naked_asm;
// LLVM implements this via making sure of that, even for functions with the naked attribute. // LLVM implements this via making sure of that, even for functions with the naked attribute.
// So, we must emit an appropriate instruction instead! // So, we must emit an appropriate instruction instead!
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn _hlt() -> ! { pub extern "C" fn _hlt() -> ! {
// CHECK-NOT: hint #34 // CHECK-NOT: hint #34
// CHECK: hlt #0x1 // CHECK: hlt #0x1
naked_asm!("hlt #1") naked_asm!("hlt #1")

4
tests/assembly/naked-functions/aix.rs
View file

@ -29,7 +29,7 @@ use minicore::*;
// CHECK-LABEL: blr: // CHECK-LABEL: blr:
// CHECK: blr // CHECK: blr
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn blr() { extern "C" fn blr() {
naked_asm!("blr") naked_asm!("blr")
} }

60
tests/assembly/naked-functions/wasm32.rs
View file

@ -22,8 +22,8 @@ use minicore::*;
// CHECK-NOT: .size // CHECK-NOT: .size
// CHECK: end_function // CHECK: end_function
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn nop() { extern "C" fn nop() {
naked_asm!("nop") naked_asm!("nop")
} }
@ -34,11 +34,11 @@ unsafe extern "C" fn nop() {
// CHECK-NOT: .size // CHECK-NOT: .size
// CHECK: end_function // CHECK: end_function
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
#[linkage = "weak"] #[linkage = "weak"]
// wasm functions cannot be aligned, so this has no effect // wasm functions cannot be aligned, so this has no effect
#[repr(align(32))] #[repr(align(32))]
unsafe extern "C" fn weak_aligned_nop() { extern "C" fn weak_aligned_nop() {
naked_asm!("nop") naked_asm!("nop")
} }
@ -51,48 +51,48 @@ unsafe extern "C" fn weak_aligned_nop() {
// //
// CHECK-NEXT: end_function // CHECK-NEXT: end_function
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_i8_i8(num: i8) -> i8 { extern "C" fn fn_i8_i8(num: i8) -> i8 {
naked_asm!("local.get 0", "local.get 0", "i32.mul") naked_asm!("local.get 0", "local.get 0", "i32.mul")
} }
// CHECK-LABEL: fn_i8_i8_i8: // CHECK-LABEL: fn_i8_i8_i8:
// CHECK: .functype fn_i8_i8_i8 (i32, i32) -> (i32) // CHECK: .functype fn_i8_i8_i8 (i32, i32) -> (i32)
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_i8_i8_i8(a: i8, b: i8) -> i8 { extern "C" fn fn_i8_i8_i8(a: i8, b: i8) -> i8 {
naked_asm!("local.get 1", "local.get 0", "i32.mul") naked_asm!("local.get 1", "local.get 0", "i32.mul")
} }
// CHECK-LABEL: fn_unit_i8: // CHECK-LABEL: fn_unit_i8:
// CHECK: .functype fn_unit_i8 () -> (i32) // CHECK: .functype fn_unit_i8 () -> (i32)
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_unit_i8() -> i8 { extern "C" fn fn_unit_i8() -> i8 {
naked_asm!("i32.const 42") naked_asm!("i32.const 42")
} }
// CHECK-LABEL: fn_i8_unit: // CHECK-LABEL: fn_i8_unit:
// CHECK: .functype fn_i8_unit (i32) -> () // CHECK: .functype fn_i8_unit (i32) -> ()
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_i8_unit(_: i8) { extern "C" fn fn_i8_unit(_: i8) {
naked_asm!("nop") naked_asm!("nop")
} }
// CHECK-LABEL: fn_i32_i32: // CHECK-LABEL: fn_i32_i32:
// CHECK: .functype fn_i32_i32 (i32) -> (i32) // CHECK: .functype fn_i32_i32 (i32) -> (i32)
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_i32_i32(num: i32) -> i32 { extern "C" fn fn_i32_i32(num: i32) -> i32 {
naked_asm!("local.get 0", "local.get 0", "i32.mul") naked_asm!("local.get 0", "local.get 0", "i32.mul")
} }
// CHECK-LABEL: fn_i64_i64: // CHECK-LABEL: fn_i64_i64:
// CHECK: .functype fn_i64_i64 (i64) -> (i64) // CHECK: .functype fn_i64_i64 (i64) -> (i64)
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_i64_i64(num: i64) -> i64 { extern "C" fn fn_i64_i64(num: i64) -> i64 {
naked_asm!("local.get 0", "local.get 0", "i64.mul") naked_asm!("local.get 0", "local.get 0", "i64.mul")
} }
@ -101,8 +101,8 @@ unsafe extern "C" fn fn_i64_i64(num: i64) -> i64 {
// wasm64-unknown: .functype fn_i128_i128 (i64, i64, i64) -> () // wasm64-unknown: .functype fn_i128_i128 (i64, i64, i64) -> ()
#[allow(improper_ctypes_definitions)] #[allow(improper_ctypes_definitions)]
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_i128_i128(num: i128) -> i128 { extern "C" fn fn_i128_i128(num: i128) -> i128 {
naked_asm!( naked_asm!(
"local.get 0", "local.get 0",
"local.get 2", "local.get 2",
@ -117,8 +117,8 @@ unsafe extern "C" fn fn_i128_i128(num: i128) -> i128 {
// wasm32-wasip1: .functype fn_f128_f128 (i32, i64, i64) -> () // wasm32-wasip1: .functype fn_f128_f128 (i32, i64, i64) -> ()
// wasm64-unknown: .functype fn_f128_f128 (i64, i64, i64) -> () // wasm64-unknown: .functype fn_f128_f128 (i64, i64, i64) -> ()
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_f128_f128(num: f128) -> f128 { extern "C" fn fn_f128_f128(num: f128) -> f128 {
naked_asm!( naked_asm!(
"local.get 0", "local.get 0",
"local.get 2", "local.get 2",
@ -139,8 +139,8 @@ struct Compound {
// wasm32-wasip1: .functype fn_compound_compound (i32, i32) -> () // wasm32-wasip1: .functype fn_compound_compound (i32, i32) -> ()
// wasm64-unknown: .functype fn_compound_compound (i64, i64) -> () // wasm64-unknown: .functype fn_compound_compound (i64, i64) -> ()
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_compound_compound(_: Compound) -> Compound { extern "C" fn fn_compound_compound(_: Compound) -> Compound {
// this is the wasm32-wasip1 assembly // this is the wasm32-wasip1 assembly
naked_asm!( naked_asm!(
"local.get 0", "local.get 0",
@ -160,8 +160,8 @@ struct WrapperI32(i32);
// CHECK-LABEL: fn_wrapperi32_wrapperi32: // CHECK-LABEL: fn_wrapperi32_wrapperi32:
// CHECK: .functype fn_wrapperi32_wrapperi32 (i32) -> (i32) // CHECK: .functype fn_wrapperi32_wrapperi32 (i32) -> (i32)
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_wrapperi32_wrapperi32(_: WrapperI32) -> WrapperI32 { extern "C" fn fn_wrapperi32_wrapperi32(_: WrapperI32) -> WrapperI32 {
naked_asm!("local.get 0") naked_asm!("local.get 0")
} }
@ -171,8 +171,8 @@ struct WrapperI64(i64);
// CHECK-LABEL: fn_wrapperi64_wrapperi64: // CHECK-LABEL: fn_wrapperi64_wrapperi64:
// CHECK: .functype fn_wrapperi64_wrapperi64 (i64) -> (i64) // CHECK: .functype fn_wrapperi64_wrapperi64 (i64) -> (i64)
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_wrapperi64_wrapperi64(_: WrapperI64) -> WrapperI64 { extern "C" fn fn_wrapperi64_wrapperi64(_: WrapperI64) -> WrapperI64 {
naked_asm!("local.get 0") naked_asm!("local.get 0")
} }
@ -182,8 +182,8 @@ struct WrapperF32(f32);
// CHECK-LABEL: fn_wrapperf32_wrapperf32: // CHECK-LABEL: fn_wrapperf32_wrapperf32:
// CHECK: .functype fn_wrapperf32_wrapperf32 (f32) -> (f32) // CHECK: .functype fn_wrapperf32_wrapperf32 (f32) -> (f32)
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_wrapperf32_wrapperf32(_: WrapperF32) -> WrapperF32 { extern "C" fn fn_wrapperf32_wrapperf32(_: WrapperF32) -> WrapperF32 {
naked_asm!("local.get 0") naked_asm!("local.get 0")
} }
@ -193,7 +193,7 @@ struct WrapperF64(f64);
// CHECK-LABEL: fn_wrapperf64_wrapperf64: // CHECK-LABEL: fn_wrapperf64_wrapperf64:
// CHECK: .functype fn_wrapperf64_wrapperf64 (f64) -> (f64) // CHECK: .functype fn_wrapperf64_wrapperf64 (f64) -> (f64)
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn fn_wrapperf64_wrapperf64(_: WrapperF64) -> WrapperF64 { extern "C" fn fn_wrapperf64_wrapperf64(_: WrapperF64) -> WrapperF64 {
naked_asm!("local.get 0") naked_asm!("local.get 0")
} }

4
tests/assembly/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
View file

@ -13,8 +13,8 @@ use std::arch::naked_asm;
// works by using an instruction for each possible landing site, // works by using an instruction for each possible landing site,
// and LLVM implements this via making sure of that. // and LLVM implements this via making sure of that.
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
pub unsafe extern "sysv64" fn will_halt() -> ! { pub extern "sysv64" fn will_halt() -> ! {
// CHECK-NOT: endbr{{32|64}} // CHECK-NOT: endbr{{32|64}}
// CHECK: hlt // CHECK: hlt
naked_asm!("hlt") naked_asm!("hlt")

6
tests/codegen/cffi/c-variadic-naked.rs
View file

@ -8,11 +8,9 @@
#![feature(naked_functions)] #![feature(naked_functions)]
#![no_std] #![no_std]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn c_variadic(_: usize, _: ...) { pub unsafe extern "C" fn c_variadic(_: usize, _: ...) {
// CHECK-NOT: va_start // CHECK-NOT: va_start
// CHECK-NOT: alloca // CHECK-NOT: alloca
core::arch::naked_asm! { core::arch::naked_asm!("ret")
"ret",
}
} }

4
tests/codegen/naked-asan.rs
View file

@ -13,10 +13,10 @@ pub fn caller() {
} }
// CHECK: declare x86_intrcc void @page_fault_handler(ptr {{.*}}, i64{{.*}}){{.*}}#[[ATTRS:[0-9]+]] // CHECK: declare x86_intrcc void @page_fault_handler(ptr {{.*}}, i64{{.*}}){{.*}}#[[ATTRS:[0-9]+]]
#[naked] #[unsafe(naked)]
#[no_mangle] #[no_mangle]
pub extern "x86-interrupt" fn page_fault_handler(_: u64, _: u64) { pub extern "x86-interrupt" fn page_fault_handler(_: u64, _: u64) {
unsafe { core::arch::naked_asm!("ud2") }; core::arch::naked_asm!("ud2")
} }
// CHECK: #[[ATTRS]] = // CHECK: #[[ATTRS]] =

6
tests/codegen/naked-fn/aligned.rs
View file

@ -10,8 +10,8 @@ use std::arch::naked_asm;
// CHECK-LABEL: naked_empty: // CHECK-LABEL: naked_empty:
#[repr(align(16))] #[repr(align(16))]
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn naked_empty() { pub extern "C" fn naked_empty() {
// CHECK: ret // CHECK: ret
naked_asm!("ret"); naked_asm!("ret")
} }

18
tests/codegen/naked-fn/generics.rs
View file

@ -28,11 +28,10 @@ fn test(x: u64) {
// CHECK: add rax, 1 // CHECK: add rax, 1
// CHECK: add rax, 42 // CHECK: add rax, 42
#[naked] #[unsafe(naked)]
pub extern "C" fn using_const_generics<const N: u64>(x: u64) -> u64 { pub extern "C" fn using_const_generics<const N: u64>(x: u64) -> u64 {
const M: u64 = 42; const M: u64 = 42;
unsafe {
naked_asm!( naked_asm!(
"xor rax, rax", "xor rax, rax",
"add rax, rdi", "add rax, rdi",
@ -43,7 +42,6 @@ pub extern "C" fn using_const_generics<const N: u64>(x: u64) -> u64 {
const M, const M,
) )
} }
}
trait Invert { trait Invert {
fn invert(self) -> Self; fn invert(self) -> Self;
@ -60,17 +58,15 @@ impl Invert for i64 {
// CHECK: call // CHECK: call
// CHECK: ret // CHECK: ret
#[naked] #[unsafe(naked)]
#[no_mangle] #[no_mangle]
pub extern "C" fn generic_function<T: Invert>(x: i64) -> i64 { pub extern "C" fn generic_function<T: Invert>(x: i64) -> i64 {
unsafe {
naked_asm!( naked_asm!(
"call {}", "call {}",
"ret", "ret",
sym <T as Invert>::invert, sym <T as Invert>::invert,
) )
} }
}
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
#[repr(transparent)] #[repr(transparent)]
@ -81,10 +77,10 @@ struct Foo(u64);
// CHECK: mov rax, rdi // CHECK: mov rax, rdi
impl Foo { impl Foo {
#[naked] #[unsafe(naked)]
#[no_mangle] #[no_mangle]
extern "C" fn method(self) -> u64 { extern "C" fn method(self) -> u64 {
unsafe { naked_asm!("mov rax, rdi", "ret") } naked_asm!("mov rax, rdi", "ret")
} }
} }
@ -97,10 +93,10 @@ trait Bar {
} }
impl Bar for Foo { impl Bar for Foo {
#[naked] #[unsafe(naked)]
#[no_mangle] #[no_mangle]
extern "C" fn trait_method(self) -> u64 { extern "C" fn trait_method(self) -> u64 {
unsafe { naked_asm!("mov rax, rdi", "ret") } naked_asm!("mov rax, rdi", "ret")
} }
} }
@ -109,7 +105,7 @@ impl Bar for Foo {
// CHECK: lea rax, [rdi + rsi] // CHECK: lea rax, [rdi + rsi]
// this previously ICE'd, see https://github.com/rust-lang/rust/issues/124375 // this previously ICE'd, see https://github.com/rust-lang/rust/issues/124375
#[naked] #[unsafe(naked)]
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize { pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
naked_asm!("lea rax, [rdi + rsi]", "ret"); naked_asm!("lea rax, [rdi + rsi]", "ret");

12
tests/codegen/naked-fn/instruction-set.rs
View file

@ -20,8 +20,8 @@ use minicore::*;
// arm-mode: .arm // arm-mode: .arm
// thumb-mode: .thumb // thumb-mode: .thumb
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
unsafe extern "C" fn test_unspecified() { extern "C" fn test_unspecified() {
naked_asm!("bx lr"); naked_asm!("bx lr");
} }
@ -33,9 +33,9 @@ unsafe extern "C" fn test_unspecified() {
// arm-mode: .arm // arm-mode: .arm
// thumb-mode: .thumb // thumb-mode: .thumb
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
#[instruction_set(arm::t32)] #[instruction_set(arm::t32)]
unsafe extern "C" fn test_thumb() { extern "C" fn test_thumb() {
naked_asm!("bx lr"); naked_asm!("bx lr");
} }
@ -46,8 +46,8 @@ unsafe extern "C" fn test_thumb() {
// arm-mode: .arm // arm-mode: .arm
// thumb-mode: .thumb // thumb-mode: .thumb
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
#[instruction_set(arm::a32)] #[instruction_set(arm::a32)]
unsafe extern "C" fn test_arm() { extern "C" fn test_arm() {
naked_asm!("bx lr"); naked_asm!("bx lr");
} }

16
tests/codegen/naked-fn/min-function-alignment.rs
View file

@ -9,24 +9,24 @@
// //
// CHECK: .balign 16 // CHECK: .balign 16
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn naked_no_explicit_align() { pub extern "C" fn naked_no_explicit_align() {
core::arch::naked_asm!("ret") core::arch::naked_asm!("ret")
} }
// CHECK: .balign 16 // CHECK: .balign 16
#[no_mangle] #[no_mangle]
#[repr(align(8))] #[repr(align(8))]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn naked_lower_align() { pub extern "C" fn naked_lower_align() {
core::arch::naked_asm!("ret") core::arch::naked_asm!("ret")
} }
// CHECK: .balign 32 // CHECK: .balign 32
#[no_mangle] #[no_mangle]
#[repr(align(32))] #[repr(align(32))]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn naked_higher_align() { pub extern "C" fn naked_higher_align() {
core::arch::naked_asm!("ret") core::arch::naked_asm!("ret")
} }
@ -38,7 +38,7 @@ pub unsafe extern "C" fn naked_higher_align() {
// CHECK: .balign 16 // CHECK: .balign 16
#[no_mangle] #[no_mangle]
#[cold] #[cold]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn no_explicit_align_cold() { pub extern "C" fn no_explicit_align_cold() {
core::arch::naked_asm!("ret") core::arch::naked_asm!("ret")
} }

16
tests/codegen/naked-fn/naked-functions.rs
View file

@ -60,8 +60,8 @@ use minicore::*;
// linux,win: .att_syntax // linux,win: .att_syntax
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn naked_empty() { pub extern "C" fn naked_empty() {
#[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))] #[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))]
naked_asm!("ret"); naked_asm!("ret");
@ -114,8 +114,8 @@ pub unsafe extern "C" fn naked_empty() {
// linux,win: .att_syntax // linux,win: .att_syntax
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize { pub extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
#[cfg(any(target_os = "windows", target_os = "linux"))] #[cfg(any(target_os = "windows", target_os = "linux"))]
{ {
naked_asm!("lea rax, [rdi + rsi]", "ret") naked_asm!("lea rax, [rdi + rsi]", "ret")
@ -138,9 +138,9 @@ pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize
// thumb: .pushsection .text.some_different_name,\22ax\22, %progbits // thumb: .pushsection .text.some_different_name,\22ax\22, %progbits
// CHECK-LABEL: test_link_section: // CHECK-LABEL: test_link_section:
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
#[link_section = ".text.some_different_name"] #[link_section = ".text.some_different_name"]
pub unsafe extern "C" fn test_link_section() { pub extern "C" fn test_link_section() {
#[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))] #[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))]
naked_asm!("ret"); naked_asm!("ret");
@ -159,7 +159,7 @@ pub unsafe extern "C" fn test_link_section() {
// win_i686-LABEL: @fastcall_cc@4: // win_i686-LABEL: @fastcall_cc@4:
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
pub unsafe extern "fastcall" fn fastcall_cc(x: i32) -> i32 { pub extern "fastcall" fn fastcall_cc(x: i32) -> i32 {
naked_asm!("ret"); naked_asm!("ret");
} }

20
tests/run-make/naked-symbol-visibility/a_rust_dylib.rs
View file

@ -26,9 +26,9 @@ extern "C" fn private_vanilla() -> u32 {
42 42
} }
#[naked] #[unsafe(naked)]
extern "C" fn private_naked() -> u32 { extern "C" fn private_naked() -> u32 {
unsafe { naked_asm!("mov rax, 42", "ret") } naked_asm!("mov rax, 42", "ret")
} }
#[no_mangle] #[no_mangle]
@ -36,19 +36,19 @@ pub extern "C" fn public_vanilla() -> u32 {
42 42
} }
#[naked] #[unsafe(naked)]
#[no_mangle] #[no_mangle]
pub extern "C" fn public_naked_nongeneric() -> u32 { pub extern "C" fn public_naked_nongeneric() -> u32 {
unsafe { naked_asm!("mov rax, 42", "ret") } naked_asm!("mov rax, 42", "ret")
} }
pub extern "C" fn public_vanilla_generic<T: TraitWithConst>() -> u32 { pub extern "C" fn public_vanilla_generic<T: TraitWithConst>() -> u32 {
T::COUNT T::COUNT
} }
#[naked] #[unsafe(naked)]
pub extern "C" fn public_naked_generic<T: TraitWithConst>() -> u32 { pub extern "C" fn public_naked_generic<T: TraitWithConst>() -> u32 {
unsafe { naked_asm!("mov rax, {}", "ret", const T::COUNT) } naked_asm!("mov rax, {}", "ret", const T::COUNT)
} }
#[linkage = "external"] #[linkage = "external"]
@ -56,10 +56,10 @@ extern "C" fn vanilla_external_linkage() -> u32 {
42 42
} }
#[naked] #[unsafe(naked)]
#[linkage = "external"] #[linkage = "external"]
extern "C" fn naked_external_linkage() -> u32 { extern "C" fn naked_external_linkage() -> u32 {
unsafe { naked_asm!("mov rax, 42", "ret") } naked_asm!("mov rax, 42", "ret")
} }
#[cfg(not(windows))] #[cfg(not(windows))]
@ -68,11 +68,11 @@ extern "C" fn vanilla_weak_linkage() -> u32 {
42 42
} }
#[naked] #[unsafe(naked)]
#[cfg(not(windows))] #[cfg(not(windows))]
#[linkage = "weak"] #[linkage = "weak"]
extern "C" fn naked_weak_linkage() -> u32 { extern "C" fn naked_weak_linkage() -> u32 {
unsafe { naked_asm!("mov rax, 42", "ret") } naked_asm!("mov rax, 42", "ret")
} }
// functions that are declared in an `extern "C"` block are currently not exported // functions that are declared in an `extern "C"` block are currently not exported

16
tests/ui/asm/naked-asm-outside-naked-fn.rs
View file

@ -12,24 +12,24 @@ fn main() {
test1(); test1();
} }
#[naked] #[unsafe(naked)]
extern "C" fn test1() { extern "C" fn test1() {
unsafe { naked_asm!("") } naked_asm!("")
} }
extern "C" fn test2() { extern "C" fn test2() {
unsafe { naked_asm!("") } naked_asm!("")
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[naked]` //~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
} }
extern "C" fn test3() { extern "C" fn test3() {
unsafe { (|| naked_asm!(""))() } (|| naked_asm!(""))()
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[naked]` //~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
} }
fn test4() { fn test4() {
async move { async move {
unsafe { naked_asm!("") } ; naked_asm!("");
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[naked]` //~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
}; };
} }

18
tests/ui/asm/naked-asm-outside-naked-fn.stderr
View file

@ -1,19 +1,19 @@
error: the `naked_asm!` macro can only be used in functions marked with `#[naked]` error: the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
--> $DIR/naked-asm-outside-naked-fn.rs:21:14 --> $DIR/naked-asm-outside-naked-fn.rs:21:5
| |
LL | unsafe { naked_asm!("") } LL | naked_asm!("")
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
error: the `naked_asm!` macro can only be used in functions marked with `#[naked]` error: the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
--> $DIR/naked-asm-outside-naked-fn.rs:26:18 --> $DIR/naked-asm-outside-naked-fn.rs:26:9
| |
LL | unsafe { (|| naked_asm!(""))() } LL | (|| naked_asm!(""))()
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
error: the `naked_asm!` macro can only be used in functions marked with `#[naked]` error: the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
--> $DIR/naked-asm-outside-naked-fn.rs:32:19 --> $DIR/naked-asm-outside-naked-fn.rs:32:9
| |
LL | unsafe { naked_asm!("") } ; LL | naked_asm!("");
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
error: aborting due to 3 previous errors error: aborting due to 3 previous errors

6
tests/ui/asm/naked-functions-ffi.rs
View file

@ -5,11 +5,9 @@
use std::arch::naked_asm; use std::arch::naked_asm;
#[naked] #[unsafe(naked)]
pub extern "C" fn naked(p: char) -> u128 { pub extern "C" fn naked(p: char) -> u128 {
//~^ WARN uses type `char` //~^ WARN uses type `char`
//~| WARN uses type `u128` //~| WARN uses type `u128`
unsafe { naked_asm!("")
naked_asm!("");
}
} }

20
tests/ui/asm/naked-functions-inline.rs
View file

@ -4,35 +4,35 @@
use std::arch::naked_asm; use std::arch::naked_asm;
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn inline_none() { pub extern "C" fn inline_none() {
naked_asm!(""); naked_asm!("");
} }
#[naked] #[unsafe(naked)]
#[inline] #[inline]
//~^ ERROR [E0736] //~^ ERROR [E0736]
pub unsafe extern "C" fn inline_hint() { pub extern "C" fn inline_hint() {
naked_asm!(""); naked_asm!("");
} }
#[naked] #[unsafe(naked)]
#[inline(always)] #[inline(always)]
//~^ ERROR [E0736] //~^ ERROR [E0736]
pub unsafe extern "C" fn inline_always() { pub extern "C" fn inline_always() {
naked_asm!(""); naked_asm!("");
} }
#[naked] #[unsafe(naked)]
#[inline(never)] #[inline(never)]
//~^ ERROR [E0736] //~^ ERROR [E0736]
pub unsafe extern "C" fn inline_never() { pub extern "C" fn inline_never() {
naked_asm!(""); naked_asm!("");
} }
#[naked] #[unsafe(naked)]
#[cfg_attr(all(), inline(never))] #[cfg_attr(all(), inline(never))]
//~^ ERROR [E0736] //~^ ERROR [E0736]
pub unsafe extern "C" fn conditional_inline_never() { pub extern "C" fn conditional_inline_never() {
naked_asm!(""); naked_asm!("");
} }

32
tests/ui/asm/naked-functions-inline.stderr
View file

@ -1,34 +1,34 @@
error[E0736]: attribute incompatible with `#[naked]` error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-functions-inline.rs:13:1 --> $DIR/naked-functions-inline.rs:13:1
| |
LL | #[naked] LL | #[unsafe(naked)]
| -------- function marked with `#[naked]` here | ---------------- function marked with `#[unsafe(naked)]` here
LL | #[inline] LL | #[inline]
| ^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]` | ^^^^^^^^^ the `inline` attribute is incompatible with `#[unsafe(naked)]`
error[E0736]: attribute incompatible with `#[naked]` error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-functions-inline.rs:20:1 --> $DIR/naked-functions-inline.rs:20:1
| |
LL | #[naked] LL | #[unsafe(naked)]
| -------- function marked with `#[naked]` here | ---------------- function marked with `#[unsafe(naked)]` here
LL | #[inline(always)] LL | #[inline(always)]
| ^^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]` | ^^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[unsafe(naked)]`
error[E0736]: attribute incompatible with `#[naked]` error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-functions-inline.rs:27:1 --> $DIR/naked-functions-inline.rs:27:1
| |
LL | #[naked] LL | #[unsafe(naked)]
| -------- function marked with `#[naked]` here | ---------------- function marked with `#[unsafe(naked)]` here
LL | #[inline(never)] LL | #[inline(never)]
| ^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]` | ^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[unsafe(naked)]`
error[E0736]: attribute incompatible with `#[naked]` error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-functions-inline.rs:34:19 --> $DIR/naked-functions-inline.rs:34:19
| |
LL | #[naked] LL | #[unsafe(naked)]
| -------- function marked with `#[naked]` here | ---------------- function marked with `#[unsafe(naked)]` here
LL | #[cfg_attr(all(), inline(never))] LL | #[cfg_attr(all(), inline(never))]
| ^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]` | ^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[unsafe(naked)]`
error: aborting due to 4 previous errors error: aborting due to 4 previous errors

8
tests/ui/asm/naked-functions-instruction-set.rs
View file

@ -12,15 +12,15 @@ extern crate minicore;
use minicore::*; use minicore::*;
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
#[instruction_set(arm::t32)] #[instruction_set(arm::t32)]
unsafe extern "C" fn test_thumb() { extern "C" fn test_thumb() {
naked_asm!("bx lr"); naked_asm!("bx lr");
} }
#[no_mangle] #[no_mangle]
#[naked] #[unsafe(naked)]
#[instruction_set(arm::a32)] #[instruction_set(arm::a32)]
unsafe extern "C" fn test_arm() { extern "C" fn test_arm() {
naked_asm!("bx lr"); naked_asm!("bx lr");
} }

12
tests/ui/asm/naked-functions-rustic-abi.rs
View file

@ -11,17 +11,17 @@
use std::arch::{asm, naked_asm}; use std::arch::{asm, naked_asm};
#[naked] #[unsafe(naked)]
pub unsafe fn rust_implicit() { pub fn rust_implicit() {
naked_asm!("ret"); naked_asm!("ret");
} }
#[naked] #[unsafe(naked)]
pub unsafe extern "Rust" fn rust_explicit() { pub extern "Rust" fn rust_explicit() {
naked_asm!("ret"); naked_asm!("ret");
} }
#[naked] #[unsafe(naked)]
pub unsafe extern "rust-cold" fn rust_cold() { pub extern "rust-cold" fn rust_cold() {
naked_asm!("ret"); naked_asm!("ret");
} }

12
tests/ui/asm/naked-functions-target-feature.rs
View file

@ -8,14 +8,14 @@ use std::arch::{asm, naked_asm};
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
#[target_feature(enable = "sse2")] #[target_feature(enable = "sse2")]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_target_feature() { pub extern "C" fn compatible_target_feature() {
naked_asm!(""); naked_asm!("ret");
} }
#[cfg(target_arch = "aarch64")] #[cfg(target_arch = "aarch64")]
#[target_feature(enable = "neon")] #[target_feature(enable = "neon")]
#[naked] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_target_feature() { pub extern "C" fn compatible_target_feature() {
naked_asm!(""); naked_asm!("ret");
} }

16
tests/ui/asm/naked-functions-testattrs.rs
View file

@ -8,31 +8,31 @@
use std::arch::naked_asm; use std::arch::naked_asm;
#[test] #[test]
#[naked] #[unsafe(naked)]
//~^ ERROR [E0736] //~^ ERROR [E0736]
extern "C" fn test_naked() { extern "C" fn test_naked() {
unsafe { naked_asm!("") }; naked_asm!("")
} }
#[should_panic] #[should_panic]
#[test] #[test]
#[naked] #[unsafe(naked)]
//~^ ERROR [E0736] //~^ ERROR [E0736]
extern "C" fn test_naked_should_panic() { extern "C" fn test_naked_should_panic() {
unsafe { naked_asm!("") }; naked_asm!("")
} }
#[ignore] #[ignore]
#[test] #[test]
#[naked] #[unsafe(naked)]
//~^ ERROR [E0736] //~^ ERROR [E0736]
extern "C" fn test_naked_ignore() { extern "C" fn test_naked_ignore() {
unsafe { naked_asm!("") }; naked_asm!("")
} }
#[bench] #[bench]
#[naked] #[unsafe(naked)]
//~^ ERROR [E0736] //~^ ERROR [E0736]
extern "C" fn bench_naked() { extern "C" fn bench_naked() {
unsafe { naked_asm!("") }; naked_asm!("")
} }

24
tests/ui/asm/naked-functions-testattrs.stderr
View file

@ -1,34 +1,34 @@
error[E0736]: cannot use `#[naked]` with testing attributes error[E0736]: cannot use `#[unsafe(naked)]` with testing attributes
--> $DIR/naked-functions-testattrs.rs:11:1 --> $DIR/naked-functions-testattrs.rs:11:1
| |
LL | #[test] LL | #[test]
| ------- function marked with testing attribute here | ------- function marked with testing attribute here
LL | #[naked] LL | #[unsafe(naked)]
| ^^^^^^^^ `#[naked]` is incompatible with testing attributes | ^^^^^^^^^^^^^^^^ `#[unsafe(naked)]` is incompatible with testing attributes
error[E0736]: cannot use `#[naked]` with testing attributes error[E0736]: cannot use `#[unsafe(naked)]` with testing attributes
--> $DIR/naked-functions-testattrs.rs:19:1 --> $DIR/naked-functions-testattrs.rs:19:1
| |
LL | #[test] LL | #[test]
| ------- function marked with testing attribute here | ------- function marked with testing attribute here
LL | #[naked] LL | #[unsafe(naked)]
| ^^^^^^^^ `#[naked]` is incompatible with testing attributes | ^^^^^^^^^^^^^^^^ `#[unsafe(naked)]` is incompatible with testing attributes
error[E0736]: cannot use `#[naked]` with testing attributes error[E0736]: cannot use `#[unsafe(naked)]` with testing attributes
--> $DIR/naked-functions-testattrs.rs:27:1 --> $DIR/naked-functions-testattrs.rs:27:1
| |
LL | #[test] LL | #[test]
| ------- function marked with testing attribute here | ------- function marked with testing attribute here
LL | #[naked] LL | #[unsafe(naked)]
| ^^^^^^^^ `#[naked]` is incompatible with testing attributes | ^^^^^^^^^^^^^^^^ `#[unsafe(naked)]` is incompatible with testing attributes
error[E0736]: cannot use `#[naked]` with testing attributes error[E0736]: cannot use `#[unsafe(naked)]` with testing attributes
--> $DIR/naked-functions-testattrs.rs:34:1 --> $DIR/naked-functions-testattrs.rs:34:1
| |
LL | #[bench] LL | #[bench]
| -------- function marked with testing attribute here | -------- function marked with testing attribute here
LL | #[naked] LL | #[unsafe(naked)]
| ^^^^^^^^ `#[naked]` is incompatible with testing attributes | ^^^^^^^^^^^^^^^^ `#[unsafe(naked)]` is incompatible with testing attributes
error: aborting due to 4 previous errors error: aborting due to 4 previous errors

30
tests/ui/asm/naked-functions-unused.rs
View file

@ -64,44 +64,34 @@ pub mod normal {
pub mod naked { pub mod naked {
use std::arch::naked_asm; use std::arch::naked_asm;
#[naked] #[unsafe(naked)]
pub extern "C" fn function(a: usize, b: usize) -> usize { pub extern "C" fn function(a: usize, b: usize) -> usize {
unsafe { naked_asm!("")
naked_asm!("");
}
} }
pub struct Naked; pub struct Naked;
impl Naked { impl Naked {
#[naked] #[unsafe(naked)]
pub extern "C" fn associated(a: usize, b: usize) -> usize { pub extern "C" fn associated(a: usize, b: usize) -> usize {
unsafe { naked_asm!("")
naked_asm!("");
}
} }
#[naked] #[unsafe(naked)]
pub extern "C" fn method(&self, a: usize, b: usize) -> usize { pub extern "C" fn method(&self, a: usize, b: usize) -> usize {
unsafe { naked_asm!("")
naked_asm!("");
}
} }
} }
impl super::Trait for Naked { impl super::Trait for Naked {
#[naked] #[unsafe(naked)]
extern "C" fn trait_associated(a: usize, b: usize) -> usize { extern "C" fn trait_associated(a: usize, b: usize) -> usize {
unsafe { naked_asm!("")
naked_asm!("");
}
} }
#[naked] #[unsafe(naked)]
extern "C" fn trait_method(&self, a: usize, b: usize) -> usize { extern "C" fn trait_method(&self, a: usize, b: usize) -> usize {
unsafe { naked_asm!("")
naked_asm!("");
}
} }
} }
} }

48
tests/ui/asm/naked-functions.rs
View file

@ -9,8 +9,8 @@
use std::arch::{asm, naked_asm}; use std::arch::{asm, naked_asm};
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn inline_asm_macro() { pub extern "C" fn inline_asm_macro() {
asm!("", options(raw)); unsafe { asm!("", options(raw)) };
//~^ERROR the `asm!` macro is not allowed in naked functions //~^ERROR the `asm!` macro is not allowed in naked functions
} }
@ -21,7 +21,7 @@ pub struct P {
} }
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn patterns( pub extern "C" fn patterns(
mut a: u32, mut a: u32,
//~^ ERROR patterns not allowed in naked function parameters //~^ ERROR patterns not allowed in naked function parameters
&b: &i32, &b: &i32,
@ -35,7 +35,7 @@ pub unsafe extern "C" fn patterns(
} }
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn inc(a: u32) -> u32 { pub extern "C" fn inc(a: u32) -> u32 {
//~^ ERROR naked functions must contain a single `naked_asm!` invocation //~^ ERROR naked functions must contain a single `naked_asm!` invocation
a + 1 a + 1
//~^ ERROR referencing function parameters is not allowed in naked functions //~^ ERROR referencing function parameters is not allowed in naked functions
@ -43,19 +43,19 @@ pub unsafe extern "C" fn inc(a: u32) -> u32 {
#[unsafe(naked)] #[unsafe(naked)]
#[allow(asm_sub_register)] #[allow(asm_sub_register)]
pub unsafe extern "C" fn inc_asm(a: u32) -> u32 { pub extern "C" fn inc_asm(a: u32) -> u32 {
naked_asm!("/* {0} */", in(reg) a) naked_asm!("/* {0} */", in(reg) a)
//~^ ERROR the `in` operand cannot be used with `naked_asm!` //~^ ERROR the `in` operand cannot be used with `naked_asm!`
} }
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn inc_closure(a: u32) -> u32 { pub extern "C" fn inc_closure(a: u32) -> u32 {
//~^ ERROR naked functions must contain a single `naked_asm!` invocation //~^ ERROR naked functions must contain a single `naked_asm!` invocation
(|| a + 1)() (|| a + 1)()
} }
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn unsupported_operands() { pub extern "C" fn unsupported_operands() {
//~^ ERROR naked functions must contain a single `naked_asm!` invocation //~^ ERROR naked functions must contain a single `naked_asm!` invocation
let mut a = 0usize; let mut a = 0usize;
let mut b = 0usize; let mut b = 0usize;
@ -84,12 +84,11 @@ pub extern "C" fn missing_assembly() {
#[unsafe(naked)] #[unsafe(naked)]
pub extern "C" fn too_many_asm_blocks() { pub extern "C" fn too_many_asm_blocks() {
//~^ ERROR naked functions must contain a single `naked_asm!` invocation //~^ ERROR naked functions must contain a single `naked_asm!` invocation
unsafe {
naked_asm!("", options(noreturn)); naked_asm!("", options(noreturn));
//~^ ERROR the `noreturn` option cannot be used with `naked_asm!` //~^ ERROR the `noreturn` option cannot be used with `naked_asm!`
naked_asm!(""); naked_asm!("");
} }
}
pub fn outer(x: u32) -> extern "C" fn(usize) -> usize { pub fn outer(x: u32) -> extern "C" fn(usize) -> usize {
#[unsafe(naked)] #[unsafe(naked)]
@ -124,49 +123,44 @@ unsafe extern "C" fn invalid_may_unwind() {
#[unsafe(naked)] #[unsafe(naked)]
pub extern "C" fn valid_a<T>() -> T { pub extern "C" fn valid_a<T>() -> T {
unsafe {
naked_asm!(""); naked_asm!("");
} }
}
#[unsafe(naked)] #[unsafe(naked)]
pub extern "C" fn valid_b() { pub extern "C" fn valid_b() {
unsafe {
{ {
{ {
naked_asm!(""); naked_asm!("");
}; };
}; };
} }
}
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn valid_c() { pub extern "C" fn valid_c() {
naked_asm!(""); naked_asm!("");
} }
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn valid_att_syntax() { pub extern "C" fn valid_att_syntax() {
naked_asm!("", options(att_syntax)); naked_asm!("", options(att_syntax));
} }
#[unsafe(naked)] #[unsafe(naked)]
#[unsafe(naked)] pub extern "C" fn allow_compile_error(a: u32) -> u32 {
pub unsafe extern "C" fn allow_compile_error(a: u32) -> u32 {
compile_error!("this is a user specified error") compile_error!("this is a user specified error")
//~^ ERROR this is a user specified error //~^ ERROR this is a user specified error
} }
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn allow_compile_error_and_asm(a: u32) -> u32 { pub extern "C" fn allow_compile_error_and_asm(a: u32) -> u32 {
compile_error!("this is a user specified error"); compile_error!("this is a user specified error");
//~^ ERROR this is a user specified error //~^ ERROR this is a user specified error
naked_asm!("") naked_asm!("")
} }
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn invalid_asm_syntax(a: u32) -> u32 { pub extern "C" fn invalid_asm_syntax(a: u32) -> u32 {
naked_asm!(invalid_syntax) naked_asm!(invalid_syntax)
//~^ ERROR asm template must be a string literal //~^ ERROR asm template must be a string literal
} }
@ -174,7 +168,7 @@ pub unsafe extern "C" fn invalid_asm_syntax(a: u32) -> u32 {
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
#[cfg_attr(target_pointer_width = "64", no_mangle)] #[cfg_attr(target_pointer_width = "64", no_mangle)]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_cfg_attributes() { pub extern "C" fn compatible_cfg_attributes() {
naked_asm!("", options(att_syntax)); naked_asm!("", options(att_syntax));
} }
@ -183,20 +177,20 @@ pub unsafe extern "C" fn compatible_cfg_attributes() {
#[deny(dead_code)] #[deny(dead_code)]
#[forbid(dead_code)] #[forbid(dead_code)]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_diagnostic_attributes() { pub extern "C" fn compatible_diagnostic_attributes() {
naked_asm!("", options(raw)); naked_asm!("", options(raw));
} }
#[deprecated = "test"] #[deprecated = "test"]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_deprecated_attributes() { pub extern "C" fn compatible_deprecated_attributes() {
naked_asm!("", options(raw)); naked_asm!("", options(raw));
} }
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
#[must_use] #[must_use]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_must_use_attributes() -> u64 { pub extern "C" fn compatible_must_use_attributes() -> u64 {
naked_asm!( naked_asm!(
" "
mov rax, 42 mov rax, 42
@ -208,13 +202,13 @@ pub unsafe extern "C" fn compatible_must_use_attributes() -> u64 {
#[export_name = "exported_function_name"] #[export_name = "exported_function_name"]
#[link_section = ".custom_section"] #[link_section = ".custom_section"]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_ffi_attributes_1() { pub extern "C" fn compatible_ffi_attributes_1() {
naked_asm!("", options(raw)); naked_asm!("", options(raw));
} }
#[cold] #[cold]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_codegen_attributes() { pub extern "C" fn compatible_codegen_attributes() {
naked_asm!("", options(raw)); naked_asm!("", options(raw));
} }
@ -223,12 +217,12 @@ pub unsafe extern "C" fn compatible_codegen_attributes() {
// a normal comment // a normal comment
#[doc(alias = "ADocAlias")] #[doc(alias = "ADocAlias")]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_doc_attributes() { pub extern "C" fn compatible_doc_attributes() {
naked_asm!("", options(raw)); naked_asm!("", options(raw));
} }
#[linkage = "external"] #[linkage = "external"]
#[unsafe(naked)] #[unsafe(naked)]
pub unsafe extern "C" fn compatible_linkage() { pub extern "C" fn compatible_linkage() {
naked_asm!("", options(raw)); naked_asm!("", options(raw));
} }

40
tests/ui/asm/naked-functions.stderr
View file

@ -11,69 +11,69 @@ LL | in(reg) a,
| ^^ the `in` operand is not meaningful for global-scoped inline assembly, remove it | ^^ the `in` operand is not meaningful for global-scoped inline assembly, remove it
error: the `noreturn` option cannot be used with `naked_asm!` error: the `noreturn` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:88:32 --> $DIR/naked-functions.rs:88:28
| |
LL | naked_asm!("", options(noreturn)); LL | naked_asm!("", options(noreturn));
| ^^^^^^^^ the `noreturn` option is not meaningful for global-scoped inline assembly | ^^^^^^^^ the `noreturn` option is not meaningful for global-scoped inline assembly
error: the `nomem` option cannot be used with `naked_asm!` error: the `nomem` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:106:28 --> $DIR/naked-functions.rs:105:28
| |
LL | naked_asm!("", options(nomem, preserves_flags)); LL | naked_asm!("", options(nomem, preserves_flags));
| ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly | ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
error: the `preserves_flags` option cannot be used with `naked_asm!` error: the `preserves_flags` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:106:35 --> $DIR/naked-functions.rs:105:35
| |
LL | naked_asm!("", options(nomem, preserves_flags)); LL | naked_asm!("", options(nomem, preserves_flags));
| ^^^^^^^^^^^^^^^ the `preserves_flags` option is not meaningful for global-scoped inline assembly | ^^^^^^^^^^^^^^^ the `preserves_flags` option is not meaningful for global-scoped inline assembly
error: the `readonly` option cannot be used with `naked_asm!` error: the `readonly` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:113:28 --> $DIR/naked-functions.rs:112:28
| |
LL | naked_asm!("", options(readonly, nostack), options(pure)); LL | naked_asm!("", options(readonly, nostack), options(pure));
| ^^^^^^^^ the `readonly` option is not meaningful for global-scoped inline assembly | ^^^^^^^^ the `readonly` option is not meaningful for global-scoped inline assembly
error: the `nostack` option cannot be used with `naked_asm!` error: the `nostack` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:113:38 --> $DIR/naked-functions.rs:112:38
| |
LL | naked_asm!("", options(readonly, nostack), options(pure)); LL | naked_asm!("", options(readonly, nostack), options(pure));
| ^^^^^^^ the `nostack` option is not meaningful for global-scoped inline assembly | ^^^^^^^ the `nostack` option is not meaningful for global-scoped inline assembly
error: the `pure` option cannot be used with `naked_asm!` error: the `pure` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:113:56 --> $DIR/naked-functions.rs:112:56
| |
LL | naked_asm!("", options(readonly, nostack), options(pure)); LL | naked_asm!("", options(readonly, nostack), options(pure));
| ^^^^ the `pure` option is not meaningful for global-scoped inline assembly | ^^^^ the `pure` option is not meaningful for global-scoped inline assembly
error: the `may_unwind` option cannot be used with `naked_asm!` error: the `may_unwind` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:121:28 --> $DIR/naked-functions.rs:120:28
| |
LL | naked_asm!("", options(may_unwind)); LL | naked_asm!("", options(may_unwind));
| ^^^^^^^^^^ the `may_unwind` option is not meaningful for global-scoped inline assembly | ^^^^^^^^^^ the `may_unwind` option is not meaningful for global-scoped inline assembly
error: this is a user specified error error: this is a user specified error
--> $DIR/naked-functions.rs:157:5 --> $DIR/naked-functions.rs:151:5
| |
LL | compile_error!("this is a user specified error") LL | compile_error!("this is a user specified error")
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this is a user specified error error: this is a user specified error
--> $DIR/naked-functions.rs:163:5 --> $DIR/naked-functions.rs:157:5
| |
LL | compile_error!("this is a user specified error"); LL | compile_error!("this is a user specified error");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: asm template must be a string literal error: asm template must be a string literal
--> $DIR/naked-functions.rs:170:16 --> $DIR/naked-functions.rs:164:16
| |
LL | naked_asm!(invalid_syntax) LL | naked_asm!(invalid_syntax)
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
error[E0787]: the `asm!` macro is not allowed in naked functions error[E0787]: the `asm!` macro is not allowed in naked functions
--> $DIR/naked-functions.rs:13:5 --> $DIR/naked-functions.rs:13:14
| |
LL | asm!("", options(raw)); LL | unsafe { asm!("", options(raw)) };
| ^^^^^^^^^^^^^^^^^^^^^^ consider using the `naked_asm!` macro instead | ^^^^^^^^^^^^^^^^^^^^^^ consider using the `naked_asm!` macro instead
error: patterns not allowed in naked function parameters error: patterns not allowed in naked function parameters
@ -111,8 +111,8 @@ LL | a + 1
error[E0787]: naked functions must contain a single `naked_asm!` invocation error[E0787]: naked functions must contain a single `naked_asm!` invocation
--> $DIR/naked-functions.rs:38:1 --> $DIR/naked-functions.rs:38:1
| |
LL | pub unsafe extern "C" fn inc(a: u32) -> u32 { LL | pub extern "C" fn inc(a: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | LL |
LL | a + 1 LL | a + 1
| ----- not allowed in naked functions | ----- not allowed in naked functions
@ -120,8 +120,8 @@ LL | a + 1
error[E0787]: naked functions must contain a single `naked_asm!` invocation error[E0787]: naked functions must contain a single `naked_asm!` invocation
--> $DIR/naked-functions.rs:52:1 --> $DIR/naked-functions.rs:52:1
| |
LL | pub unsafe extern "C" fn inc_closure(a: u32) -> u32 { LL | pub extern "C" fn inc_closure(a: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | LL |
LL | (|| a + 1)() LL | (|| a + 1)()
| ------------ not allowed in naked functions | ------------ not allowed in naked functions
@ -129,8 +129,8 @@ LL | (|| a + 1)()
error[E0787]: naked functions must contain a single `naked_asm!` invocation error[E0787]: naked functions must contain a single `naked_asm!` invocation
--> $DIR/naked-functions.rs:58:1 --> $DIR/naked-functions.rs:58:1
| |
LL | pub unsafe extern "C" fn unsupported_operands() { LL | pub extern "C" fn unsupported_operands() {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | LL |
LL | let mut a = 0usize; LL | let mut a = 0usize;
| ------------------- not allowed in naked functions | ------------------- not allowed in naked functions
@ -159,7 +159,7 @@ LL | naked_asm!("");
| -------------- multiple `naked_asm!` invocations are not allowed in naked functions | -------------- multiple `naked_asm!` invocations are not allowed in naked functions
error: referencing function parameters is not allowed in naked functions error: referencing function parameters is not allowed in naked functions
--> $DIR/naked-functions.rs:98:11 --> $DIR/naked-functions.rs:97:11
| |
LL | *&y LL | *&y
| ^ | ^
@ -167,7 +167,7 @@ LL | *&y
= help: follow the calling convention in asm block to use parameters = help: follow the calling convention in asm block to use parameters
error[E0787]: naked functions must contain a single `naked_asm!` invocation error[E0787]: naked functions must contain a single `naked_asm!` invocation
--> $DIR/naked-functions.rs:96:5 --> $DIR/naked-functions.rs:95:5
| |
LL | pub extern "C" fn inner(y: usize) -> usize { LL | pub extern "C" fn inner(y: usize) -> usize {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

28
tests/ui/asm/naked-invalid-attr.rs
View file

@ -1,17 +1,17 @@
// Checks that #[naked] attribute can be placed on function definitions only. // Checks that #[unsafe(naked)] attribute can be placed on function definitions only.
// //
//@ needs-asm-support //@ needs-asm-support
#![feature(naked_functions)] #![feature(naked_functions)]
#![naked] //~ ERROR should be applied to a function definition #![unsafe(naked)] //~ ERROR should be applied to a function definition
use std::arch::naked_asm; use std::arch::naked_asm;
extern "C" { extern "C" {
#[naked] //~ ERROR should be applied to a function definition #[unsafe(naked)] //~ ERROR should be applied to a function definition
fn f(); fn f();
} }
#[naked] //~ ERROR should be applied to a function definition #[unsafe(naked)] //~ ERROR should be applied to a function definition
#[repr(C)] #[repr(C)]
struct S { struct S {
a: u32, a: u32,
@ -19,35 +19,35 @@ struct S {
} }
trait Invoke { trait Invoke {
#[naked] //~ ERROR should be applied to a function definition #[unsafe(naked)] //~ ERROR should be applied to a function definition
extern "C" fn invoke(&self); extern "C" fn invoke(&self);
} }
impl Invoke for S { impl Invoke for S {
#[naked] #[unsafe(naked)]
extern "C" fn invoke(&self) { extern "C" fn invoke(&self) {
unsafe { naked_asm!("") } naked_asm!("")
} }
} }
#[naked] #[unsafe(naked)]
extern "C" fn ok() { extern "C" fn ok() {
unsafe { naked_asm!("") } naked_asm!("")
} }
impl S { impl S {
#[naked] #[unsafe(naked)]
extern "C" fn g() { extern "C" fn g() {
unsafe { naked_asm!("") } naked_asm!("")
} }
#[naked] #[unsafe(naked)]
extern "C" fn h(&self) { extern "C" fn h(&self) {
unsafe { naked_asm!("") } naked_asm!("")
} }
} }
fn main() { fn main() {
#[naked] //~ ERROR should be applied to a function definition #[unsafe(naked)] //~ ERROR should be applied to a function definition
|| {}; || {};
} }

20
tests/ui/asm/naked-invalid-attr.stderr
View file

@ -1,8 +1,8 @@
error: attribute should be applied to a function definition error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:14:1 --> $DIR/naked-invalid-attr.rs:14:1
| |
LL | #[naked] LL | #[unsafe(naked)]
| ^^^^^^^^ | ^^^^^^^^^^^^^^^^
LL | #[repr(C)] LL | #[repr(C)]
LL | / struct S { LL | / struct S {
LL | | a: u32, LL | | a: u32,
@ -13,32 +13,32 @@ LL | | }
error: attribute should be applied to a function definition error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:51:5 --> $DIR/naked-invalid-attr.rs:51:5
| |
LL | #[naked] LL | #[unsafe(naked)]
| ^^^^^^^^ | ^^^^^^^^^^^^^^^^
LL | || {}; LL | || {};
| ----- not a function definition | ----- not a function definition
error: attribute should be applied to a function definition error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:22:5 --> $DIR/naked-invalid-attr.rs:22:5
| |
LL | #[naked] LL | #[unsafe(naked)]
| ^^^^^^^^ | ^^^^^^^^^^^^^^^^
LL | extern "C" fn invoke(&self); LL | extern "C" fn invoke(&self);
| ---------------------------- not a function definition | ---------------------------- not a function definition
error: attribute should be applied to a function definition error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:10:5 --> $DIR/naked-invalid-attr.rs:10:5
| |
LL | #[naked] LL | #[unsafe(naked)]
| ^^^^^^^^ | ^^^^^^^^^^^^^^^^
LL | fn f(); LL | fn f();
| ------- not a function definition | ------- not a function definition
error: attribute should be applied to a function definition error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:5:1 --> $DIR/naked-invalid-attr.rs:5:1
| |
LL | #![naked] LL | #![unsafe(naked)]
| ^^^^^^^^^ cannot be applied to crates | ^^^^^^^^^^^^^^^^^ cannot be applied to crates
error: aborting due to 5 previous errors error: aborting due to 5 previous errors

20
tests/ui/asm/naked-with-invalid-repr-attr.rs
View file

@ -6,43 +6,43 @@ use std::arch::naked_asm;
#[repr(C)] #[repr(C)]
//~^ ERROR attribute should be applied to a struct, enum, or union [E0517] //~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
#[naked] #[unsafe(naked)]
extern "C" fn example1() { extern "C" fn example1() {
//~^ NOTE not a struct, enum, or union //~^ NOTE not a struct, enum, or union
unsafe { naked_asm!("") } naked_asm!("")
} }
#[repr(transparent)] #[repr(transparent)]
//~^ ERROR attribute should be applied to a struct, enum, or union [E0517] //~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
#[naked] #[unsafe(naked)]
extern "C" fn example2() { extern "C" fn example2() {
//~^ NOTE not a struct, enum, or union //~^ NOTE not a struct, enum, or union
unsafe { naked_asm!("") } naked_asm!("")
} }
#[repr(align(16), C)] #[repr(align(16), C)]
//~^ ERROR attribute should be applied to a struct, enum, or union [E0517] //~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
#[naked] #[unsafe(naked)]
extern "C" fn example3() { extern "C" fn example3() {
//~^ NOTE not a struct, enum, or union //~^ NOTE not a struct, enum, or union
unsafe { naked_asm!("") } naked_asm!("")
} }
// note: two errors because of packed and C // note: two errors because of packed and C
#[repr(C, packed)] #[repr(C, packed)]
//~^ ERROR attribute should be applied to a struct or union [E0517] //~^ ERROR attribute should be applied to a struct or union [E0517]
//~| ERROR attribute should be applied to a struct, enum, or union [E0517] //~| ERROR attribute should be applied to a struct, enum, or union [E0517]
#[naked] #[unsafe(naked)]
extern "C" fn example4() { extern "C" fn example4() {
//~^ NOTE not a struct, enum, or union //~^ NOTE not a struct, enum, or union
//~| NOTE not a struct or union //~| NOTE not a struct or union
unsafe { naked_asm!("") } naked_asm!("")
} }
#[repr(u8)] #[repr(u8)]
//~^ ERROR attribute should be applied to an enum [E0517] //~^ ERROR attribute should be applied to an enum [E0517]
#[naked] #[unsafe(naked)]
extern "C" fn example5() { extern "C" fn example5() {
//~^ NOTE not an enum //~^ NOTE not an enum
unsafe { naked_asm!("") } naked_asm!("")
} }

12
tests/ui/asm/naked-with-invalid-repr-attr.stderr
View file

@ -6,7 +6,7 @@ LL | #[repr(C)]
... ...
LL | / extern "C" fn example1() { LL | / extern "C" fn example1() {
LL | | LL | |
LL | | unsafe { naked_asm!("") } LL | | naked_asm!("")
LL | | } LL | | }
| |_- not a struct, enum, or union | |_- not a struct, enum, or union
@ -18,7 +18,7 @@ LL | #[repr(transparent)]
... ...
LL | / extern "C" fn example2() { LL | / extern "C" fn example2() {
LL | | LL | |
LL | | unsafe { naked_asm!("") } LL | | naked_asm!("")
LL | | } LL | | }
| |_- not a struct, enum, or union | |_- not a struct, enum, or union
@ -30,7 +30,7 @@ LL | #[repr(align(16), C)]
... ...
LL | / extern "C" fn example3() { LL | / extern "C" fn example3() {
LL | | LL | |
LL | | unsafe { naked_asm!("") } LL | | naked_asm!("")
LL | | } LL | | }
| |_- not a struct, enum, or union | |_- not a struct, enum, or union
@ -43,7 +43,7 @@ LL | #[repr(C, packed)]
LL | / extern "C" fn example4() { LL | / extern "C" fn example4() {
LL | | LL | |
LL | | LL | |
LL | | unsafe { naked_asm!("") } LL | | naked_asm!("")
LL | | } LL | | }
| |_- not a struct, enum, or union | |_- not a struct, enum, or union
@ -56,7 +56,7 @@ LL | #[repr(C, packed)]
LL | / extern "C" fn example4() { LL | / extern "C" fn example4() {
LL | | LL | |
LL | | LL | |
LL | | unsafe { naked_asm!("") } LL | | naked_asm!("")
LL | | } LL | | }
| |_- not a struct or union | |_- not a struct or union
@ -68,7 +68,7 @@ LL | #[repr(u8)]
... ...
LL | / extern "C" fn example5() { LL | / extern "C" fn example5() {
LL | | LL | |
LL | | unsafe { naked_asm!("") } LL | | naked_asm!("")
LL | | } LL | | }
| |_- not an enum | |_- not an enum

16
tests/ui/asm/named-asm-labels.rs
View file

@ -175,9 +175,9 @@ fn main() {
// Trigger on naked fns too, even though they can't be inlined, reusing a // Trigger on naked fns too, even though they can't be inlined, reusing a
// label or LTO can cause labels to break // label or LTO can cause labels to break
#[naked] #[unsafe(naked)]
pub extern "C" fn foo() -> i32 { pub extern "C" fn foo() -> i32 {
unsafe { naked_asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1) } naked_asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1)
//~^ ERROR avoid using named labels //~^ ERROR avoid using named labels
} }
@ -188,21 +188,21 @@ pub extern "C" fn bar() {
//~^ ERROR avoid using named labels //~^ ERROR avoid using named labels
} }
#[naked] #[unsafe(naked)]
pub extern "C" fn aaa() { pub extern "C" fn aaa() {
fn _local() {} fn _local() {}
unsafe { naked_asm!(".Laaa: nop; ret;") } //~ ERROR avoid using named labels naked_asm!(".Laaa: nop; ret;") //~ ERROR avoid using named labels
} }
pub fn normal() { pub fn normal() {
fn _local1() {} fn _local1() {}
#[naked] #[unsafe(naked)]
pub extern "C" fn bbb() { pub extern "C" fn bbb() {
fn _very_local() {} fn _very_local() {}
unsafe { naked_asm!(".Lbbb: nop; ret;") } //~ ERROR avoid using named labels naked_asm!(".Lbbb: nop; ret;") //~ ERROR avoid using named labels
} }
fn _local2() {} fn _local2() {}
@ -219,8 +219,8 @@ fn closures() {
}; };
|| { || {
#[naked] #[unsafe(naked)]
unsafe extern "C" fn _nested() { extern "C" fn _nested() {
naked_asm!("ret;"); naked_asm!("ret;");
} }

12
tests/ui/asm/named-asm-labels.stderr
View file

@ -475,9 +475,9 @@ LL | #[warn(named_asm_labels)]
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
error: avoid using named labels in inline assembly error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:180:26 --> $DIR/named-asm-labels.rs:180:17
| |
LL | unsafe { naked_asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1) } LL | naked_asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1)
| ^^^^^ | ^^^^^
| |
= help: only local labels of the form `<number>:` should be used in inline asm = help: only local labels of the form `<number>:` should be used in inline asm
@ -493,18 +493,18 @@ LL | unsafe { asm!(".Lbar: mov rax, {}; ret;", "nop", const 1, options(noret
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:195:26 --> $DIR/named-asm-labels.rs:195:17
| |
LL | unsafe { naked_asm!(".Laaa: nop; ret;") } LL | naked_asm!(".Laaa: nop; ret;")
| ^^^^^ | ^^^^^
| |
= help: only local labels of the form `<number>:` should be used in inline asm = help: only local labels of the form `<number>:` should be used in inline asm
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:205:30 --> $DIR/named-asm-labels.rs:205:21
| |
LL | unsafe { naked_asm!(".Lbbb: nop; ret;") } LL | naked_asm!(".Lbbb: nop; ret;")
| ^^^^^ | ^^^^^
| |
= help: only local labels of the form `<number>:` should be used in inline asm = help: only local labels of the form `<number>:` should be used in inline asm

6
tests/ui/feature-gates/feature-gate-naked_functions.rs
View file

@ -3,20 +3,18 @@
use std::arch::naked_asm; use std::arch::naked_asm;
//~^ ERROR use of unstable library feature `naked_functions` //~^ ERROR use of unstable library feature `naked_functions`
#[naked] #[naked] //~ ERROR unsafe attribute used without unsafe
//~^ ERROR the `#[naked]` attribute is an experimental feature //~^ ERROR the `#[naked]` attribute is an experimental feature
extern "C" fn naked() { extern "C" fn naked() {
naked_asm!("") naked_asm!("")
//~^ ERROR use of unstable library feature `naked_functions` //~^ ERROR use of unstable library feature `naked_functions`
//~| ERROR: requires unsafe
} }
#[naked] #[naked] //~ ERROR unsafe attribute used without unsafe
//~^ ERROR the `#[naked]` attribute is an experimental feature //~^ ERROR the `#[naked]` attribute is an experimental feature
extern "C" fn naked_2() -> isize { extern "C" fn naked_2() -> isize {
naked_asm!("") naked_asm!("")
//~^ ERROR use of unstable library feature `naked_functions` //~^ ERROR use of unstable library feature `naked_functions`
//~| ERROR: requires unsafe
} }
fn main() {} fn main() {}

45
tests/ui/feature-gates/feature-gate-naked_functions.stderr
View file

@ -9,7 +9,7 @@ LL | naked_asm!("")
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: use of unstable library feature `naked_functions` error[E0658]: use of unstable library feature `naked_functions`
--> $DIR/feature-gate-naked_functions.rs:17:5 --> $DIR/feature-gate-naked_functions.rs:16:5
| |
LL | naked_asm!("") LL | naked_asm!("")
| ^^^^^^^^^ | ^^^^^^^^^
@ -18,6 +18,28 @@ LL | naked_asm!("")
= help: add `#![feature(naked_functions)]` to the crate attributes to enable = help: add `#![feature(naked_functions)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: unsafe attribute used without unsafe
--> $DIR/feature-gate-naked_functions.rs:6:3
|
LL | #[naked]
| ^^^^^ usage of unsafe attribute
|
help: wrap the attribute in `unsafe(...)`
|
LL | #[unsafe(naked)]
| +++++++ +
error: unsafe attribute used without unsafe
--> $DIR/feature-gate-naked_functions.rs:13:3
|
LL | #[naked]
| ^^^^^ usage of unsafe attribute
|
help: wrap the attribute in `unsafe(...)`
|
LL | #[unsafe(naked)]
| +++++++ +
error[E0658]: the `#[naked]` attribute is an experimental feature error[E0658]: the `#[naked]` attribute is an experimental feature
--> $DIR/feature-gate-naked_functions.rs:6:1 --> $DIR/feature-gate-naked_functions.rs:6:1
| |
@ -29,7 +51,7 @@ LL | #[naked]
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: the `#[naked]` attribute is an experimental feature error[E0658]: the `#[naked]` attribute is an experimental feature
--> $DIR/feature-gate-naked_functions.rs:14:1 --> $DIR/feature-gate-naked_functions.rs:13:1
| |
LL | #[naked] LL | #[naked]
| ^^^^^^^^ | ^^^^^^^^
@ -48,23 +70,6 @@ LL | use std::arch::naked_asm;
= help: add `#![feature(naked_functions)]` to the crate attributes to enable = help: add `#![feature(naked_functions)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0133]: use of inline assembly is unsafe and requires unsafe function or block
--> $DIR/feature-gate-naked_functions.rs:9:5
|
LL | naked_asm!("")
| ^^^^^^^^^^^^^^ use of inline assembly
|
= note: inline assembly is entirely unchecked and can cause undefined behavior
error[E0133]: use of inline assembly is unsafe and requires unsafe function or block
--> $DIR/feature-gate-naked_functions.rs:17:5
|
LL | naked_asm!("")
| ^^^^^^^^^^^^^^ use of inline assembly
|
= note: inline assembly is entirely unchecked and can cause undefined behavior
error: aborting due to 7 previous errors error: aborting due to 7 previous errors
Some errors have detailed explanations: E0133, E0658. For more information about this error, try `rustc --explain E0658`.
For more information about an error, try `rustc --explain E0133`.

6
tests/ui/feature-gates/feature-gate-naked_functions_rustic_abi.rs
View file

@ -5,19 +5,19 @@
use std::arch::naked_asm; use std::arch::naked_asm;
#[naked] #[unsafe(naked)]
pub unsafe fn rust_implicit() { pub unsafe fn rust_implicit() {
//~^ ERROR `#[naked]` is currently unstable on `extern "Rust"` functions //~^ ERROR `#[naked]` is currently unstable on `extern "Rust"` functions
naked_asm!("ret"); naked_asm!("ret");
} }
#[naked] #[unsafe(naked)]
pub unsafe extern "Rust" fn rust_explicit() { pub unsafe extern "Rust" fn rust_explicit() {
//~^ ERROR `#[naked]` is currently unstable on `extern "Rust"` functions //~^ ERROR `#[naked]` is currently unstable on `extern "Rust"` functions
naked_asm!("ret"); naked_asm!("ret");
} }
#[naked] #[unsafe(naked)]
pub unsafe extern "rust-cold" fn rust_cold() { pub unsafe extern "rust-cold" fn rust_cold() {
//~^ ERROR `#[naked]` is currently unstable on `extern "rust-cold"` functions //~^ ERROR `#[naked]` is currently unstable on `extern "rust-cold"` functions
naked_asm!("ret"); naked_asm!("ret");

2
tests/ui/feature-gates/feature-gate-naked_functions_target_feature.rs
View file

@ -5,7 +5,7 @@
use std::arch::naked_asm; use std::arch::naked_asm;
#[naked] #[unsafe(naked)]
#[target_feature(enable = "avx2")] #[target_feature(enable = "avx2")]
//~^ ERROR: `#[target_feature(/* ... */)]` is currently unstable on `#[naked]` functions //~^ ERROR: `#[target_feature(/* ... */)]` is currently unstable on `#[naked]` functions
extern "C" fn naked() { extern "C" fn naked() {

4
tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.rs
View file

@ -5,7 +5,7 @@ use std::arch::naked_asm;
#[track_caller] //~ ERROR [E0736] #[track_caller] //~ ERROR [E0736]
//~^ ERROR `#[track_caller]` requires Rust ABI //~^ ERROR `#[track_caller]` requires Rust ABI
#[naked] #[unsafe(naked)]
extern "C" fn f() { extern "C" fn f() {
unsafe { unsafe {
naked_asm!(""); naked_asm!("");
@ -17,7 +17,7 @@ struct S;
impl S { impl S {
#[track_caller] //~ ERROR [E0736] #[track_caller] //~ ERROR [E0736]
//~^ ERROR `#[track_caller]` requires Rust ABI //~^ ERROR `#[track_caller]` requires Rust ABI
#[naked] #[unsafe(naked)]
extern "C" fn g() { extern "C" fn g() {
unsafe { unsafe {
naked_asm!(""); naked_asm!("");

16
tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.stderr
View file

@ -1,20 +1,20 @@
error[E0736]: attribute incompatible with `#[naked]` error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/error-with-naked.rs:6:1 --> $DIR/error-with-naked.rs:6:1
| |
LL | #[track_caller] LL | #[track_caller]
| ^^^^^^^^^^^^^^^ the `track_caller` attribute is incompatible with `#[naked]` | ^^^^^^^^^^^^^^^ the `track_caller` attribute is incompatible with `#[unsafe(naked)]`
LL | LL |
LL | #[naked] LL | #[unsafe(naked)]
| -------- function marked with `#[naked]` here | ---------------- function marked with `#[unsafe(naked)]` here
error[E0736]: attribute incompatible with `#[naked]` error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/error-with-naked.rs:18:5 --> $DIR/error-with-naked.rs:18:5
| |
LL | #[track_caller] LL | #[track_caller]
| ^^^^^^^^^^^^^^^ the `track_caller` attribute is incompatible with `#[naked]` | ^^^^^^^^^^^^^^^ the `track_caller` attribute is incompatible with `#[unsafe(naked)]`
LL | LL |
LL | #[naked] LL | #[unsafe(naked)]
| -------- function marked with `#[naked]` here | ---------------- function marked with `#[unsafe(naked)]` here
error[E0737]: `#[track_caller]` requires Rust ABI error[E0737]: `#[track_caller]` requires Rust ABI
--> $DIR/error-with-naked.rs:6:1 --> $DIR/error-with-naked.rs:6:1