]> git.lizzy.rs Git - rust.git/blob - src/test/ui/asm/naked-functions.rs
Rollup merge of #89869 - kpreid:from-doc, r=yaahc
[rust.git] / src / test / ui / asm / naked-functions.rs
1 // needs-asm-support
2 // ignore-nvptx64
3 // ignore-spirv
4 // ignore-wasm32
5
6 #![feature(naked_functions)]
7 #![feature(or_patterns)]
8 #![feature(asm_const, asm_sym, asm_unwind)]
9 #![crate_type = "lib"]
10
11 use std::arch::asm;
12
13 #[repr(C)]
14 pub struct P {
15     x: u8,
16     y: u16,
17 }
18
19 #[naked]
20 pub unsafe extern "C" fn patterns(
21     mut a: u32,
22     //~^ ERROR patterns not allowed in naked function parameters
23     &b: &i32,
24     //~^ ERROR patterns not allowed in naked function parameters
25     (None | Some(_)): Option<std::ptr::NonNull<u8>>,
26     //~^ ERROR patterns not allowed in naked function parameters
27     P { x, y }: P,
28     //~^ ERROR patterns not allowed in naked function parameters
29 ) {
30     asm!("", options(noreturn))
31 }
32
33 #[naked]
34 pub unsafe extern "C" fn inc(a: u32) -> u32 {
35     //~^ ERROR naked functions must contain a single asm block
36     a + 1
37     //~^ ERROR referencing function parameters is not allowed in naked functions
38 }
39
40 #[naked]
41 pub unsafe extern "C" fn inc_asm(a: u32) -> u32 {
42     asm!("/* {0} */", in(reg) a, options(noreturn));
43     //~^ ERROR referencing function parameters is not allowed in naked functions
44     //~| ERROR only `const` and `sym` operands are supported in naked functions
45 }
46
47 #[naked]
48 pub unsafe extern "C" fn inc_closure(a: u32) -> u32 {
49     //~^ ERROR naked functions must contain a single asm block
50     (|| a + 1)()
51 }
52
53 #[naked]
54 pub unsafe extern "C" fn unsupported_operands() {
55     //~^ ERROR naked functions must contain a single asm block
56     let mut a = 0usize;
57     let mut b = 0usize;
58     let mut c = 0usize;
59     let mut d = 0usize;
60     let mut e = 0usize;
61     const F: usize = 0usize;
62     static G: usize = 0usize;
63     asm!("/* {0} {1} {2} {3} {4} {5} {6} */",
64          //~^ ERROR asm in naked functions must use `noreturn` option
65          in(reg) a,
66          //~^ ERROR only `const` and `sym` operands are supported in naked functions
67          inlateout(reg) b,
68          inout(reg) c,
69          lateout(reg) d,
70          out(reg) e,
71          const F,
72          sym G,
73     );
74 }
75
76 #[naked]
77 pub extern "C" fn missing_assembly() {
78     //~^ ERROR naked functions must contain a single asm block
79 }
80
81 #[naked]
82 pub extern "C" fn too_many_asm_blocks() {
83     //~^ ERROR naked functions must contain a single asm block
84     asm!("");
85     //~^ ERROR asm in naked functions must use `noreturn` option
86     asm!("");
87     //~^ ERROR asm in naked functions must use `noreturn` option
88     asm!("");
89     //~^ ERROR asm in naked functions must use `noreturn` option
90     asm!("", options(noreturn));
91 }
92
93 pub fn outer(x: u32) -> extern "C" fn(usize) -> usize {
94     #[naked]
95     pub extern "C" fn inner(y: usize) -> usize {
96         //~^ ERROR naked functions must contain a single asm block
97         *&y
98         //~^ ERROR referencing function parameters is not allowed in naked functions
99     }
100     inner
101 }
102
103 #[naked]
104 unsafe extern "C" fn invalid_options() {
105     asm!("", options(nomem, preserves_flags, noreturn));
106     //~^ ERROR asm options unsupported in naked functions: `nomem`, `preserves_flags`
107 }
108
109 #[naked]
110 unsafe extern "C" fn invalid_options_continued() {
111     asm!("", options(readonly, nostack), options(pure));
112     //~^ ERROR asm with the `pure` option must have at least one output
113     //~| ERROR asm options unsupported in naked functions: `nostack`, `pure`, `readonly`
114     //~| ERROR asm in naked functions must use `noreturn` option
115 }
116
117 #[naked]
118 unsafe extern "C" fn invalid_may_unwind() {
119     asm!("", options(noreturn, may_unwind));
120     //~^ ERROR asm options unsupported in naked functions: `may_unwind`
121 }
122
123 #[naked]
124 pub unsafe fn default_abi() {
125     //~^ WARN Rust ABI is unsupported in naked functions
126     asm!("", options(noreturn));
127 }
128
129 #[naked]
130 pub unsafe fn rust_abi() {
131     //~^ WARN Rust ABI is unsupported in naked functions
132     asm!("", options(noreturn));
133 }
134
135 #[naked]
136 pub extern "C" fn valid_a<T>() -> T {
137     unsafe {
138         asm!("", options(noreturn));
139     }
140 }
141
142 #[naked]
143 pub extern "C" fn valid_b() {
144     unsafe {
145         {
146             {
147                 asm!("", options(noreturn));
148             };
149         };
150     }
151 }
152
153 #[naked]
154 pub unsafe extern "C" fn valid_c() {
155     asm!("", options(noreturn));
156 }
157
158 #[cfg(target_arch = "x86_64")]
159 #[naked]
160 pub unsafe extern "C" fn valid_att_syntax() {
161     asm!("", options(noreturn, att_syntax));
162 }
163
164 #[naked]
165 pub unsafe extern "C" fn inline_none() {
166     asm!("", options(noreturn));
167 }
168
169 #[naked]
170 #[inline]
171 //~^ ERROR naked functions cannot be inlined
172 pub unsafe extern "C" fn inline_hint() {
173     asm!("", options(noreturn));
174 }
175
176 #[naked]
177 #[inline(always)]
178 //~^ ERROR naked functions cannot be inlined
179 pub unsafe extern "C" fn inline_always() {
180     asm!("", options(noreturn));
181 }
182
183 #[naked]
184 #[inline(never)]
185 //~^ ERROR naked functions cannot be inlined
186 pub unsafe extern "C" fn inline_never() {
187     asm!("", options(noreturn));
188 }
189
190 #[naked]
191 #[inline]
192 //~^ ERROR naked functions cannot be inlined
193 #[inline(always)]
194 //~^ ERROR naked functions cannot be inlined
195 #[inline(never)]
196 //~^ ERROR naked functions cannot be inlined
197 pub unsafe extern "C" fn inline_all() {
198     asm!("", options(noreturn));
199 }