1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
//! # Tables of possibly supported platforms. //! //! ## Syscall and ret instructions and registers //! //! ``` //! Arch/ABI Instruction System# Ret1 Ret2 //! arm/OABI swi NR - r0 - //! arm/EABI swi 0x0 r7 r0 r1 //! arm64 svc #0 w8 x0 x1 //! i386 int $0x80 eax eax edx //! riscv ecall a7 a0 a1 //! x86-64 syscall rax rax rdx //! x32 syscall rax rax rdx //! ``` //! //! ## Argument registers //! //! ``` //! Arch/ABI arg1 arg2 arg3 arg4 arg5 arg6 arg7 Notes //! arm/OABI r0 r1 r2 r3 r4 r5 r6 //! arm/EABI r0 r1 r2 r3 r4 r5 r6 //! arm64 x0 x1 x2 x3 x4 x5 - //! i386 ebx ecx edx esi edi ebp - //! riscv a0 a1 a2 a3 a4 a5 - //! x86-64 rdi rsi rdx r10 r8 r9 - //! x32 rdi rsi rdx r10 r8 r9 - //! ``` //! //! ## C-abi registers //! //! ``` //! Arch/ABI a0 a1 a2 a3 a4 a5 ret1 ret2 caller //! x86-64 rdi rsi rdx rcx r8 r9 rax rdx rbx,rsp,rbp //! ``` // Prepare for the future, we might want to justify our inner translation. #![allow(unused_unsafe)] #![no_std] #[cfg(target_arch = "x86_64")] #[path = "x86_64.rs"] mod impl_; /* These are not yet supported by the assembler. Compiling them would yield invalid * instructions on their platforms. #[cfg(target_arch = "x86")] #[path = "x86.rs"] mod impl_; #[cfg(target_arch = "aarch64")] #[path = "aarch64.rs"] mod impl_; */ /// A helper to distinguish the syscall number from other parameters. /// /// We can't really help you with others but this one is somewhat important. Furthermore it's a /// great help internally where it ensure we've placed the parameter at the right location. The /// type is a transparent wrapper. /// /// This further enables a namespaced access to constants and call numbers that are conditionally /// available per system ABI. #[repr(transparent)] pub struct SysNr(pub isize); #[cfg(target_os = "linux")] pub unsafe fn syscall0(nr: SysNr) -> isize { // Translate to the inner abi unsafe { impl_::call0(nr) } } #[cfg(target_os = "linux")] pub unsafe fn syscall1(nr: SysNr, a: isize) -> isize { // Translate to the inner abi unsafe { impl_::call1(a, nr) } } #[cfg(target_os = "linux")] pub unsafe fn syscall2(nr: SysNr, a: isize, b: isize) -> isize { // Translate to the inner abi unsafe { impl_::call2(a, b, nr) } } #[cfg(target_os = "linux")] pub unsafe fn syscall3(nr: SysNr, a: isize, b: isize, c: isize) -> isize { // Translate to the inner abi unsafe { impl_::call3(a, b, c, nr) } } #[cfg(target_os = "linux")] pub unsafe fn syscall4(nr: SysNr, a: isize, b: isize, c: isize, d: isize) -> isize { // Translate to the inner abi unsafe { impl_::call4(a, b, c, d, nr) } } #[cfg(target_os = "linux")] pub unsafe fn syscall5(nr: SysNr, a: isize, b: isize, c: isize, d: isize, e: isize) -> isize { // Translate to the inner abi unsafe { impl_::call5(a, b, c, d, e, nr) } }