| #ifndef LLVM_TOOLS_LLVM_BOLT_SYS_RISCV |
| #define LLVM_TOOLS_LLVM_BOLT_SYS_RISCV |
| |
| // Save all registers while keeping 16B stack alignment |
| #define SAVE_ALL \ |
| "addi sp, sp, -16\n" \ |
| "sd x0, 0(sp)\n" \ |
| "sd x1, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x2, 0(sp)\n" \ |
| "sd x3, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x4, 0(sp)\n" \ |
| "sd x5, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x6, 0(sp)\n" \ |
| "sd x7, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x8, 0(sp)\n" \ |
| "sd x9, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x10, 0(sp)\n" \ |
| "sd x11, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x12, 0(sp)\n" \ |
| "sd x13, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x14, 0(sp)\n" \ |
| "sd x15, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x16, 0(sp)\n" \ |
| "sd x17, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x18, 0(sp)\n" \ |
| "sd x19, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x20, 0(sp)\n" \ |
| "sd x21, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x22, 0(sp)\n" \ |
| "sd x23, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x24, 0(sp)\n" \ |
| "sd x25, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x26, 0(sp)\n" \ |
| "sd x27, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x28, 0(sp)\n" \ |
| "sd x29, 8(sp)\n" \ |
| "addi sp, sp, -16\n" \ |
| "sd x30, 0(sp)\n" \ |
| "sd x31, 8(sp)\n" |
| // Mirrors SAVE_ALL |
| #define RESTORE_ALL \ |
| "ld x30, 0(sp)\n" \ |
| "ld x31, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x28, 0(sp)\n" \ |
| "ld x29, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x26, 0(sp)\n" \ |
| "ld x27, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x24, 0(sp)\n" \ |
| "ld x25, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x22, 0(sp)\n" \ |
| "ld x23, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x20, 0(sp)\n" \ |
| "ld x21, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x18, 0(sp)\n" \ |
| "ld x19, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x16, 0(sp)\n" \ |
| "ld x17, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x14, 0(sp)\n" \ |
| "ld x15, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x12, 0(sp)\n" \ |
| "ld x13, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x10, 0(sp)\n" \ |
| "ld x11, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x8, 0(sp)\n" \ |
| "ld x9, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x6, 0(sp)\n" \ |
| "ld x7, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x4, 0(sp)\n" \ |
| "ld x5, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x2, 0(sp)\n" \ |
| "ld x3, 8(sp)\n" \ |
| "addi sp, sp, 16\n" \ |
| "ld x0, 0(sp)\n" \ |
| "ld x1, 8(sp)\n" \ |
| "addi sp, sp, 16\n" |
| |
| // Anonymous namespace covering everything but our library entry point |
| namespace { |
| |
| // Get the difference between runtime addrress of .text section and |
| // static address in section header table. Can be extracted from arbitrary |
| // pc value recorded at runtime to get the corresponding static address, which |
| // in turn can be used to search for indirect call description. Needed because |
| // indirect call descriptions are read-only non-relocatable data. |
| uint64_t getTextBaseAddress() { |
| uint64_t DynAddr; |
| uint64_t StaticAddr; |
| __asm__ volatile("lla %0, __hot_end\n\t" |
| "lui %1, %%hi(__hot_end)\n\t" |
| "addi %1, %1, %%lo(__hot_end)\n\t" |
| : "=r"(DynAddr), "=r"(StaticAddr)); |
| return DynAddr - StaticAddr; |
| } |
| |
| uint64_t __read(uint64_t fd, const void *buf, uint64_t count) { |
| uint64_t ret; |
| register uint64_t a0 __asm__("a0") = fd; |
| register const void *a1 __asm__("a1") = buf; |
| register uint64_t a2 __asm__("a2") = count; |
| register uint64_t a7 __asm__("a7") = |
| 63; // Assuming 63 is the syscall number for read |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret) |
| : "r"(a0), "r"(a1), "r"(a2), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __write(uint64_t fd, const void *buf, uint64_t count) { |
| uint64_t ret; |
| register uint64_t a0 __asm__("a0") = fd; |
| register const void *a1 __asm__("a1") = buf; |
| register uint64_t a2 __asm__("a2") = count; |
| register uint32_t a7 __asm__("a7") = |
| 64; // Assuming 64 is the syscall number for write |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret) |
| : "r"(a0), "r"(a1), "r"(a2), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| void *__mmap(uint64_t addr, uint64_t size, uint64_t prot, uint64_t flags, |
| uint64_t fd, uint64_t offset) { |
| void *ret; |
| register uint64_t a0 __asm__("a0") = addr; |
| register uint64_t a1 __asm__("a1") = size; |
| register uint64_t a2 __asm__("a2") = prot; |
| register uint64_t a3 __asm__("a3") = flags; |
| register uint64_t a4 __asm__("a4") = fd; |
| register uint64_t a5 __asm__("a5") = offset; |
| register uint32_t a7 __asm__("a7") = |
| 222; // Assuming 222 is the syscall number for mmap |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret) |
| : "r"(a0), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5), |
| "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __munmap(void *addr, uint64_t size) { |
| uint64_t ret; |
| register void *a0 __asm__("a0") = addr; |
| register uint64_t a1 __asm__("a1") = size; |
| register uint32_t a7 __asm__("a7") = 215; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __exit(uint64_t code) { |
| uint64_t ret; |
| register uint64_t a0 __asm__("a0") = code; |
| register uint32_t a7 __asm__("a7") = 94; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __open(const char *pathname, uint64_t flags, uint64_t mode) { |
| uint64_t ret; |
| register int a0 __asm__("a0") = |
| -100; // Assuming -100 is an invalid file descriptor |
| register const char *a1 __asm__("a1") = pathname; |
| register uint64_t a2 __asm__("a2") = flags; |
| register uint64_t a3 __asm__("a3") = mode; |
| register uint64_t a7 __asm__("a7") = |
| 56; // Assuming 56 is the syscall number for open |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret) |
| : "r"(a0), "r"(a1), "r"(a2), "r"(a3), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| long __getdents64(unsigned int fd, dirent64 *dirp, size_t count) { |
| long ret; |
| register unsigned int a0 __asm__("a0") = fd; |
| register dirent64 *a1 __asm__("a1") = dirp; |
| register size_t a2 __asm__("a2") = count; |
| register uint32_t a7 __asm__("a7") = 61; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a2), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __readlink(const char *pathname, char *buf, size_t bufsize) { |
| uint64_t ret; |
| register int a0 __asm__("a0") = -100; |
| register const char *a1 __asm__("a1") = pathname; |
| register char *a2 __asm__("a2") = buf; |
| register size_t a3 __asm__("a3") = bufsize; |
| register uint32_t a7 __asm__("a7") = 78; // readlinkat |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a2), "r"(a3), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __lseek(uint64_t fd, uint64_t pos, uint64_t whence) { |
| uint64_t ret; |
| register uint64_t a0 __asm__("a0") = fd; |
| register uint64_t a1 __asm__("a1") = pos; |
| register uint64_t a2 __asm__("a2") = whence; |
| register uint32_t a7 __asm__("a7") = 62; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a2), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __ftruncate(uint64_t fd, uint64_t length) { |
| int ret; |
| register uint64_t a0 __asm__("a0") = fd; |
| register uint64_t a1 __asm__("a1") = length; |
| register uint32_t a7 __asm__("a7") = 46; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __close(uint64_t fd) { |
| int ret; |
| register uint64_t a0 __asm__("a0") = fd; |
| register uint32_t a7 __asm__("a7") = |
| 57; // Assuming 57 is the syscall number for close |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret) |
| : "r"(a0), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __madvise(void *addr, size_t length, int advice) { |
| int ret; |
| register void *a0 __asm__("a0") = addr; |
| register size_t a1 __asm__("a1") = length; |
| register int a2 __asm__("a2") = advice; |
| register uint32_t a7 __asm__("a7") = 233; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a2), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __uname(struct UtsNameTy *buf) { |
| int ret; |
| register UtsNameTy *a0 __asm__("a0") = buf; |
| register uint32_t a7 __asm__("a7") = 160; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __nanosleep(const timespec *req, timespec *rem) { |
| uint64_t ret; |
| register const timespec *a0 __asm__("a0") = req; |
| register timespec *a1 __asm__("a1") = rem; |
| register uint32_t a7 __asm__("a7") = 101; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int64_t __fork() { |
| uint64_t ret; |
| // clone instead of fork with flags |
| // "CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD" |
| register uint64_t a0 __asm__("a0") = 0x1200011; |
| register uint64_t a1 __asm__("a1") = 0; |
| register uint64_t a2 __asm__("a2") = 0; |
| register uint64_t a3 __asm__("a3") = 0; |
| register uint64_t a4 __asm__("a4") = 0; |
| register uint32_t a7 __asm__("a7") = 220; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a2), "r"(a3), "r"(a4), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __mprotect(void *addr, size_t len, int prot) { |
| int ret; |
| register void *a0 __asm__("a0") = addr; |
| register size_t a1 __asm__("a1") = len; |
| register int a2 __asm__("a2") = prot; |
| register uint32_t a7 __asm__("a7") = 226; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a2), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __getpid() { |
| uint64_t ret; |
| register uint32_t a7 __asm__("a7") = 172; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __getppid() { |
| uint64_t ret; |
| register uint32_t a7 __asm__("a7") = 173; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __setpgid(uint64_t pid, uint64_t pgid) { |
| int ret; |
| register uint64_t a0 __asm__("a0") = pid; |
| register uint64_t a1 __asm__("a1") = pgid; |
| register uint32_t a7 __asm__("a7") = 154; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __getpgid(uint64_t pid) { |
| uint64_t ret; |
| register uint64_t a0 __asm__("a0") = pid; |
| register uint32_t a7 __asm__("a7") = 155; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __kill(uint64_t pid, int sig) { |
| int ret; |
| register uint64_t a0 __asm__("a0") = pid; |
| register int a1 __asm__("a1") = sig; |
| register uint32_t a7 __asm__("a7") = 129; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __fsync(int fd) { |
| int ret; |
| register int a0 __asm__("a0") = fd; |
| register uint32_t a7 __asm__("a7") = 82; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0) |
| : "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| uint64_t __sigprocmask(int how, const void *set, void *oldset) { |
| uint64_t ret; |
| register int a0 __asm__("a0") = how; |
| register const void *a1 __asm__("a1") = set; |
| register void *a2 __asm__("a2") = oldset; |
| register long a3 asm("a3") = 8; |
| register uint32_t a7 __asm__("a7") = 135; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a2), "r"(a3), "r"(a7) |
| : "memory"); |
| return ret; |
| } |
| |
| int __prctl(int option, unsigned long arg2, unsigned long arg3, |
| unsigned long arg4, unsigned long arg5) { |
| int ret; |
| register int a0 __asm__("a0") = option; |
| register unsigned long a1 __asm__("a1") = arg2; |
| register unsigned long a2 __asm__("a2") = arg3; |
| register unsigned long a3 __asm__("a3") = arg4; |
| register unsigned long a4 __asm__("a4") = arg5; |
| register uint32_t a7 __asm__("a7") = 167; |
| __asm__ __volatile__("ecall\n\t" |
| "mv %0, a0" |
| : "=r"(ret), "+r"(a0), "+r"(a1) |
| : "r"(a2), "r"(a3), "r"(a4), "r"(a7) |
| : "cc", "memory"); |
| return ret; |
| } |
| } // anonymous namespace |
| |
| #endif |
