vendor/rustix/src/backend/linux_raw/arch/asm/arm.rs

   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]
   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]
  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]
  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]
  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]
  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]
  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]
  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]
 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]
 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]
 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]
 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]
 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]
 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]
 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 }