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