vendor/rustix/src/imp/linux_raw/arch/inline/arm.rs

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