1 //! arm Linux system calls.
2
3 use crate::backend::reg::{
4 ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
5 };
6 use core::arch::asm;
7
8 #[inline]
syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0>9 pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0> {
10 let r0;
11 asm!(
12 "svc 0",
13 in("r7") nr.to_asm(),
14 lateout("r0") r0,
15 options(nostack, preserves_flags, readonly)
16 );
17 FromAsm::from_asm(r0)
18 }
19
20 #[inline]
syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0>21 pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
22 let r0;
23 asm!(
24 "svc 0",
25 in("r7") nr.to_asm(),
26 inlateout("r0") a0.to_asm() => r0,
27 options(nostack, preserves_flags)
28 );
29 FromAsm::from_asm(r0)
30 }
31
32 #[inline]
syscall1_readonly( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, ) -> RetReg<R0>33 pub(in crate::backend) unsafe fn syscall1_readonly(
34 nr: SyscallNumber<'_>,
35 a0: ArgReg<'_, A0>,
36 ) -> RetReg<R0> {
37 let r0;
38 asm!(
39 "svc 0",
40 in("r7") nr.to_asm(),
41 inlateout("r0") a0.to_asm() => r0,
42 options(nostack, preserves_flags, readonly)
43 );
44 FromAsm::from_asm(r0)
45 }
46
47 #[inline]
syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> !48 pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
49 asm!(
50 "svc 0",
51 in("r7") nr.to_asm(),
52 in("r0") a0.to_asm(),
53 options(noreturn)
54 )
55 }
56
57 #[inline]
syscall2( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, ) -> RetReg<R0>58 pub(in crate::backend) unsafe fn syscall2(
59 nr: SyscallNumber<'_>,
60 a0: ArgReg<'_, A0>,
61 a1: ArgReg<'_, A1>,
62 ) -> RetReg<R0> {
63 let r0;
64 asm!(
65 "svc 0",
66 in("r7") nr.to_asm(),
67 inlateout("r0") a0.to_asm() => r0,
68 in("r1") a1.to_asm(),
69 options(nostack, preserves_flags)
70 );
71 FromAsm::from_asm(r0)
72 }
73
74 #[inline]
syscall2_readonly( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, ) -> RetReg<R0>75 pub(in crate::backend) unsafe fn syscall2_readonly(
76 nr: SyscallNumber<'_>,
77 a0: ArgReg<'_, A0>,
78 a1: ArgReg<'_, A1>,
79 ) -> RetReg<R0> {
80 let r0;
81 asm!(
82 "svc 0",
83 in("r7") nr.to_asm(),
84 inlateout("r0") a0.to_asm() => r0,
85 in("r1") a1.to_asm(),
86 options(nostack, preserves_flags, readonly)
87 );
88 FromAsm::from_asm(r0)
89 }
90
91 #[inline]
syscall3( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, a2: ArgReg<'_, A2>, ) -> RetReg<R0>92 pub(in crate::backend) unsafe fn syscall3(
93 nr: SyscallNumber<'_>,
94 a0: ArgReg<'_, A0>,
95 a1: ArgReg<'_, A1>,
96 a2: ArgReg<'_, A2>,
97 ) -> RetReg<R0> {
98 let r0;
99 asm!(
100 "svc 0",
101 in("r7") nr.to_asm(),
102 inlateout("r0") a0.to_asm() => r0,
103 in("r1") a1.to_asm(),
104 in("r2") a2.to_asm(),
105 options(nostack, preserves_flags)
106 );
107 FromAsm::from_asm(r0)
108 }
109
110 #[inline]
syscall3_readonly( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, a2: ArgReg<'_, A2>, ) -> RetReg<R0>111 pub(in crate::backend) unsafe fn syscall3_readonly(
112 nr: SyscallNumber<'_>,
113 a0: ArgReg<'_, A0>,
114 a1: ArgReg<'_, A1>,
115 a2: ArgReg<'_, A2>,
116 ) -> RetReg<R0> {
117 let r0;
118 asm!(
119 "svc 0",
120 in("r7") nr.to_asm(),
121 inlateout("r0") a0.to_asm() => r0,
122 in("r1") a1.to_asm(),
123 in("r2") a2.to_asm(),
124 options(nostack, preserves_flags, readonly)
125 );
126 FromAsm::from_asm(r0)
127 }
128
129 #[inline]
syscall4( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, a2: ArgReg<'_, A2>, a3: ArgReg<'_, A3>, ) -> RetReg<R0>130 pub(in crate::backend) unsafe fn syscall4(
131 nr: SyscallNumber<'_>,
132 a0: ArgReg<'_, A0>,
133 a1: ArgReg<'_, A1>,
134 a2: ArgReg<'_, A2>,
135 a3: ArgReg<'_, A3>,
136 ) -> RetReg<R0> {
137 let r0;
138 asm!(
139 "svc 0",
140 in("r7") nr.to_asm(),
141 inlateout("r0") a0.to_asm() => r0,
142 in("r1") a1.to_asm(),
143 in("r2") a2.to_asm(),
144 in("r3") a3.to_asm(),
145 options(nostack, preserves_flags)
146 );
147 FromAsm::from_asm(r0)
148 }
149
150 #[inline]
syscall4_readonly( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, a2: ArgReg<'_, A2>, a3: ArgReg<'_, A3>, ) -> RetReg<R0>151 pub(in crate::backend) unsafe fn syscall4_readonly(
152 nr: SyscallNumber<'_>,
153 a0: ArgReg<'_, A0>,
154 a1: ArgReg<'_, A1>,
155 a2: ArgReg<'_, A2>,
156 a3: ArgReg<'_, A3>,
157 ) -> RetReg<R0> {
158 let r0;
159 asm!(
160 "svc 0",
161 in("r7") nr.to_asm(),
162 inlateout("r0") a0.to_asm() => r0,
163 in("r1") a1.to_asm(),
164 in("r2") a2.to_asm(),
165 in("r3") a3.to_asm(),
166 options(nostack, preserves_flags, readonly)
167 );
168 FromAsm::from_asm(r0)
169 }
170
171 #[inline]
syscall5( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, a2: ArgReg<'_, A2>, a3: ArgReg<'_, A3>, a4: ArgReg<'_, A4>, ) -> RetReg<R0>172 pub(in crate::backend) unsafe fn syscall5(
173 nr: SyscallNumber<'_>,
174 a0: ArgReg<'_, A0>,
175 a1: ArgReg<'_, A1>,
176 a2: ArgReg<'_, A2>,
177 a3: ArgReg<'_, A3>,
178 a4: ArgReg<'_, A4>,
179 ) -> RetReg<R0> {
180 let r0;
181 asm!(
182 "svc 0",
183 in("r7") nr.to_asm(),
184 inlateout("r0") a0.to_asm() => r0,
185 in("r1") a1.to_asm(),
186 in("r2") a2.to_asm(),
187 in("r3") a3.to_asm(),
188 in("r4") a4.to_asm(),
189 options(nostack, preserves_flags)
190 );
191 FromAsm::from_asm(r0)
192 }
193
194 #[inline]
syscall5_readonly( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, a2: ArgReg<'_, A2>, a3: ArgReg<'_, A3>, a4: ArgReg<'_, A4>, ) -> RetReg<R0>195 pub(in crate::backend) unsafe fn syscall5_readonly(
196 nr: SyscallNumber<'_>,
197 a0: ArgReg<'_, A0>,
198 a1: ArgReg<'_, A1>,
199 a2: ArgReg<'_, A2>,
200 a3: ArgReg<'_, A3>,
201 a4: ArgReg<'_, A4>,
202 ) -> RetReg<R0> {
203 let r0;
204 asm!(
205 "svc 0",
206 in("r7") nr.to_asm(),
207 inlateout("r0") a0.to_asm() => r0,
208 in("r1") a1.to_asm(),
209 in("r2") a2.to_asm(),
210 in("r3") a3.to_asm(),
211 in("r4") a4.to_asm(),
212 options(nostack, preserves_flags, readonly)
213 );
214 FromAsm::from_asm(r0)
215 }
216
217 #[inline]
syscall6( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, a2: ArgReg<'_, A2>, a3: ArgReg<'_, A3>, a4: ArgReg<'_, A4>, a5: ArgReg<'_, A5>, ) -> RetReg<R0>218 pub(in crate::backend) unsafe fn syscall6(
219 nr: SyscallNumber<'_>,
220 a0: ArgReg<'_, A0>,
221 a1: ArgReg<'_, A1>,
222 a2: ArgReg<'_, A2>,
223 a3: ArgReg<'_, A3>,
224 a4: ArgReg<'_, A4>,
225 a5: ArgReg<'_, A5>,
226 ) -> RetReg<R0> {
227 let r0;
228 asm!(
229 "svc 0",
230 in("r7") nr.to_asm(),
231 inlateout("r0") a0.to_asm() => r0,
232 in("r1") a1.to_asm(),
233 in("r2") a2.to_asm(),
234 in("r3") a3.to_asm(),
235 in("r4") a4.to_asm(),
236 in("r5") a5.to_asm(),
237 options(nostack, preserves_flags)
238 );
239 FromAsm::from_asm(r0)
240 }
241
242 #[inline]
syscall6_readonly( nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>, a1: ArgReg<'_, A1>, a2: ArgReg<'_, A2>, a3: ArgReg<'_, A3>, a4: ArgReg<'_, A4>, a5: ArgReg<'_, A5>, ) -> RetReg<R0>243 pub(in crate::backend) unsafe fn syscall6_readonly(
244 nr: SyscallNumber<'_>,
245 a0: ArgReg<'_, A0>,
246 a1: ArgReg<'_, A1>,
247 a2: ArgReg<'_, A2>,
248 a3: ArgReg<'_, A3>,
249 a4: ArgReg<'_, A4>,
250 a5: ArgReg<'_, A5>,
251 ) -> RetReg<R0> {
252 let r0;
253 asm!(
254 "svc 0",
255 in("r7") nr.to_asm(),
256 inlateout("r0") a0.to_asm() => r0,
257 in("r1") a1.to_asm(),
258 in("r2") a2.to_asm(),
259 in("r3") a3.to_asm(),
260 in("r4") a4.to_asm(),
261 in("r5") a5.to_asm(),
262 options(nostack, preserves_flags, readonly)
263 );
264 FromAsm::from_asm(r0)
265 }
266