378 lines
11 KiB
C
378 lines
11 KiB
C
#if defined(__aarch64__)
|
|
#include "../int.h"
|
|
|
|
#include "generic.h"
|
|
|
|
void exit(int8_t status){
|
|
asm ( "mov x0, %0\n" // Move the exit status into register x0
|
|
"mov x8, #93\n" // Syscall number for 'exit' is 93 in AArch64
|
|
"svc #0\n" // Make the syscall
|
|
: // No output operands
|
|
: "r" ((long)status) // Input operand: status
|
|
: "x0", "x8" // Clobbered registers
|
|
);
|
|
for (;;);
|
|
}
|
|
|
|
intptr_t write(int32_t fd, const void* buf, intptr_t size){
|
|
intptr_t n_written = 0;
|
|
//register int32_t fd_w asm("w0") = fd;
|
|
asm volatile(
|
|
// Assembly Instructions
|
|
"mov x0, %1\n" // Set x0 to value of fd
|
|
"mov x1, %2\n" // Set x1 to value of buf
|
|
"mov x2, %3\n" // Set x2 to value of size
|
|
"mov x8, #64\n" // Syscall number for 'write' is 64 in AArch64
|
|
"svc #0\n" // Make syscall
|
|
"mov %0, x0\n" // Store return value in n_written
|
|
// Output operands
|
|
: "=r"(n_written)
|
|
// Input operands
|
|
: "r"((int64_t)fd), "r" (buf), "r"(size)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x8"
|
|
);
|
|
return n_written;
|
|
}
|
|
|
|
intptr_t read(int32_t fd, const void* buf, intptr_t size){
|
|
intptr_t n_read = 0;
|
|
asm volatile(
|
|
// Assembly Instructions
|
|
"mov x0, %1\n" // Set x0 to value of fd
|
|
"mov x1, %2\n" // Set x1 to value of buf
|
|
"mov x2, %3\n" // Set x2 to value of size
|
|
"mov x8, #63\n" // Syscall number for 'read' is 63 in AArch64
|
|
"svc #0\n" // Make syscall
|
|
"mov %0, x0\n" // Store return value in n_read
|
|
// Output operands
|
|
: "=r"(n_read)
|
|
// Input operands
|
|
: "r"((int64_t)fd), "r" (buf), "r"(size)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x8", "memory"
|
|
);
|
|
return n_read;
|
|
}
|
|
|
|
#define CLONE_CHILD_SETTID 0x1000000
|
|
#define CLONE_CHILD_CLEARTID 0x200000
|
|
uint32_t fork(){
|
|
long int rtn;
|
|
long int flags = CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #220\n" // Syscall number for 'clone' is 220 in AArch64
|
|
"mov x0, %1\n" // clone flags
|
|
"mov x1, #0\n" // child stack pointer
|
|
"mov x2, #0\n" // parent_tidptr
|
|
"mov x3, #0\n" // tls
|
|
"mov x4, #0\n" // child_tidptr
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" (flags)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x3", "x4", "x8"
|
|
);
|
|
return (uint32_t)rtn;
|
|
}
|
|
|
|
int32_t openat(int32_t fd, const char* filename, uint32_t flags, uint32_t mode) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #56\n" // Syscall number for 'openat' is 56 in AArch64
|
|
"mov x0, %1\n" // dir fd
|
|
"mov x1, %2\n" // file path
|
|
"mov x2, %3\n" // flags
|
|
"mov x3, %4\n" // mode
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)fd), "r"(filename), "r"((int64_t)flags), "r"((int64_t)mode)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x3", "x8"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int close(unsigned int fd){
|
|
long int rtn;
|
|
asm (
|
|
"mov x0, %1\n"
|
|
"mov x8, #57\n"
|
|
"svc #0\n"
|
|
"mov %0, x0\n"
|
|
: "=r"(rtn)
|
|
: "r" ((long)fd)
|
|
: "x0", "x8"
|
|
);
|
|
return (int)rtn;
|
|
}
|
|
|
|
int fsync(unsigned int fd){
|
|
long int rtn;
|
|
asm (
|
|
"mov x0, %1\n"
|
|
"mov x8, #82\n"
|
|
"svc #0\n"
|
|
"mov %0, x0\n"
|
|
: "=r"(rtn)
|
|
: "r" ((long)fd)
|
|
: "x0", "x8"
|
|
);
|
|
return (int)rtn;
|
|
}
|
|
|
|
int socket(int domain, int type, int protocol) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #198\n" // Syscall number for 'socket' is 198 in AArch64
|
|
"mov x0, %1\n" // domain
|
|
"mov x1, %2\n" // type
|
|
"mov x2, %3\n" // protocol
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)domain), "r"((int64_t)type), "r"((int64_t)protocol)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x8"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int setsockopt(int sockfd, int level, int optname, const void* optval, socklen_t optlen) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #208\n" // Syscall number for 'setsockopt' is 208 in AArch64
|
|
"mov x0, %1\n" // sockfd
|
|
"mov x1, %2\n" // level
|
|
"mov x2, %3\n" // optname
|
|
"mov x3, %4\n" // optval
|
|
"mov x4, %5\n" // optlen
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)sockfd), "r"((int64_t)level), "r"((int64_t)optname), "r"(optval), "r"((uint64_t)optlen)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x3", "x4", "x8"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int bind(int sockfd, const void* sockaddr, socklen_t addrlen) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #200\n" // Syscall number for 'bind' is 200 in AArch64
|
|
"mov x0, %1\n" // sockfd
|
|
"mov x1, %2\n" // sockaddr
|
|
"mov x2, %3\n" // addrlen
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)sockfd), "r"(sockaddr), "r"((uint64_t)addrlen)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x8"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int listen(int fd, int backlog) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #201\n" // Syscall number for 'listen' is 201 in AArch64
|
|
"mov x0, %1\n" // fd
|
|
"mov x1, %2\n" // backlog
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)fd), "r"((int64_t)backlog)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x8"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int accept(int sockfd, void* addr, socklen_t* addrlen) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #202\n" // Syscall number for 'accept' is 202 in AArch64
|
|
"mov x0, %1\n" // sockfd
|
|
"mov x1, %2\n" // addr
|
|
"mov x2, %3\n" // addrlen
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)sockfd), "r"(addr), "r"(addrlen)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x8", "memory"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int connect(int sockfd, void* addr, socklen_t addrlen) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #203\n" // Syscall number for 'connect' is 203 in AArch64
|
|
"mov x0, %1\n" // sockfd
|
|
"mov x1, %2\n" // addr
|
|
"mov x2, %3\n" // addrlen
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)sockfd), "r"(addr), "r"((uint64_t)addrlen)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x8"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
ssize_t sendto(int sockfd, const void* buf, size_t size, int flags, const void* sockaddr, socklen_t addrlen) {
|
|
ssize_t rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #206\n" // Syscall number for 'sendto' is 206 in AArch64
|
|
"mov x0, %1\n" //
|
|
"mov x1, %2\n" //
|
|
"mov x2, %3\n" //
|
|
"mov x3, %4\n" //
|
|
"mov x4, %5\n"
|
|
"mov x5, %6\n"
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)sockfd), "r"(buf), "r"(size), "r"((int64_t)flags), "r"(sockaddr), "r"((uint64_t)addrlen)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x3", "x4", "x5", "x8"
|
|
);
|
|
return rtn;
|
|
}
|
|
|
|
ssize_t recvfrom(int sockfd, const void* buf, size_t size, int flags, const void* sockaddr, socklen_t addrlen) {
|
|
ssize_t rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #207\n" // Syscall number for 'recvfrom' is 207 in AArch64
|
|
"mov x0, %1\n" //
|
|
"mov x1, %2\n" //
|
|
"mov x2, %3\n" //
|
|
"mov x3, %4\n" //
|
|
"mov x4, %5\n"
|
|
"mov x5, %6\n"
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)sockfd), "r"(buf), "r"(size), "r"((int64_t)flags), "r"(sockaddr), "r"((uint64_t)addrlen)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x2", "x3", "x4", "x5", "x8", "memory"
|
|
);
|
|
return rtn;
|
|
}
|
|
|
|
|
|
int clock_settime(clockid_t clockid, const struct timespec *tp) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #112\n" // Syscall number for 'listen' is 201 in AArch64
|
|
"mov x0, %1\n" // fd
|
|
"mov x1, %2\n" // backlog
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)clockid), "r"(tp)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x8"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int clock_gettime(clockid_t clockid, struct timespec *tp) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #113\n" // Syscall number for 'listen' is 201 in AArch64
|
|
"mov x0, %1\n" // fd
|
|
"mov x1, %2\n" // backlog
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)clockid), "r"(tp)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x8", "memory"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int clock_getres(clockid_t clockid, struct timespec *res) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #114\n" // Syscall number for 'listen' is 201 in AArch64
|
|
"mov x0, %1\n" // fd
|
|
"mov x1, %2\n" // backlog
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)clockid), "r"(res)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x8", "memory"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *t, struct timespec* remain) {
|
|
long int rtn;
|
|
asm volatile (
|
|
// Assembly Instructions
|
|
"mov x8, #115\n" // Syscall number for 'listen' is 201 in AArch64
|
|
"mov x0, %1\n" // fd
|
|
"mov x1, %2\n" // backlog
|
|
"mov x2, %3\n" // backlog
|
|
"svc #0\n" // Make the syscall
|
|
"mov %0, x0\n" // save return value
|
|
// Output operands
|
|
: "=r" (rtn)
|
|
// Input operand
|
|
: "r" ((int64_t)clockid), "r"((int64_t)flags), "r"(t), "r"(remain)
|
|
// Clobbered registers
|
|
: "x0", "x1", "x8", "memory"
|
|
);
|
|
return (int32_t)rtn;
|
|
}
|
|
|
|
#endif
|