#ifndef LLVM_TOOLS_LLVM_BOLT_SYS_X86_64 #define LLVM_TOOLS_LLVM_BOLT_SYS_X86_64 // Save all registers while keeping 16B stack alignment #define SAVE_ALL \ "push %%rax\n" \ "push %%rbx\n" \ "push %%rcx\n" \ "push %%rdx\n" \ "push %%rdi\n" \ "push %%rsi\n" \ "push %%rbp\n" \ "push %%r8\n" \ "push %%r9\n" \ "push %%r10\n" \ "push %%r11\n" \ "push %%r12\n" \ "push %%r13\n" \ "push %%r14\n" \ "push %%r15\n" \ "sub $8, %%rsp\n" // Mirrors SAVE_ALL #define RESTORE_ALL \ "add $8, %%rsp\n" \ "pop %%r15\n" \ "pop %%r14\n" \ "pop %%r13\n" \ "pop %%r12\n" \ "pop %%r11\n" \ "pop %%r10\n" \ "pop %%r9\n" \ "pop %%r8\n" \ "pop %%rbp\n" \ "pop %%rsi\n" \ "pop %%rdi\n" \ "pop %%rdx\n" \ "pop %%rcx\n" \ "pop %%rbx\n" \ "pop %%rax\n" 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("leaq __hot_end(%%rip), %0\n\t" "movabsq $__hot_end, %1\n\t" : "=r"(DynAddr), "=r"(StaticAddr)); return DynAddr - StaticAddr; } #define _STRINGIFY(x) #x #define STRINGIFY(x) _STRINGIFY(x) uint64_t __read(uint64_t fd, const void *buf, uint64_t count) { uint64_t ret; #if defined(__APPLE__) #define READ_SYSCALL 0x2000003 #else #define READ_SYSCALL 0 #endif __asm__ __volatile__("movq $" STRINGIFY(READ_SYSCALL) ", %%rax\n" "syscall\n" : "=a"(ret) : "D"(fd), "S"(buf), "d"(count) : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __write(uint64_t fd, const void *buf, uint64_t count) { uint64_t ret; #if defined(__APPLE__) #define WRITE_SYSCALL 0x2000004 #else #define WRITE_SYSCALL 1 #endif __asm__ __volatile__("movq $" STRINGIFY(WRITE_SYSCALL) ", %%rax\n" "syscall\n" : "=a"(ret) : "D"(fd), "S"(buf), "d"(count) : "cc", "rcx", "r11", "memory"); return ret; } void *__mmap(uint64_t addr, uint64_t size, uint64_t prot, uint64_t flags, uint64_t fd, uint64_t offset) { #if defined(__APPLE__) #define MMAP_SYSCALL 0x20000c5 #else #define MMAP_SYSCALL 9 #endif void *ret; register uint64_t r8 asm("r8") = fd; register uint64_t r9 asm("r9") = offset; register uint64_t r10 asm("r10") = flags; __asm__ __volatile__("movq $" STRINGIFY(MMAP_SYSCALL) ", %%rax\n" "syscall\n" : "=a"(ret) : "D"(addr), "S"(size), "d"(prot), "r"(r10), "r"(r8), "r"(r9) : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __munmap(void *addr, uint64_t size) { #if defined(__APPLE__) #define MUNMAP_SYSCALL 0x2000049 #else #define MUNMAP_SYSCALL 11 #endif uint64_t ret; __asm__ __volatile__("movq $" STRINGIFY(MUNMAP_SYSCALL) ", %%rax\n" "syscall\n" : "=a"(ret) : "D"(addr), "S"(size) : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __sigprocmask(int how, const void *set, void *oldset) { #if defined(__APPLE__) #define SIGPROCMASK_SYSCALL 0x2000030 #else #define SIGPROCMASK_SYSCALL 14 #endif uint64_t ret; register long r10 asm("r10") = sizeof(uint64_t); __asm__ __volatile__("movq $" STRINGIFY(SIGPROCMASK_SYSCALL) ", %%rax\n" "syscall\n" : "=a"(ret) : "D"(how), "S"(set), "d"(oldset), "r"(r10) : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __getpid() { uint64_t ret; #if defined(__APPLE__) #define GETPID_SYSCALL 20 #else #define GETPID_SYSCALL 39 #endif __asm__ __volatile__("movq $" STRINGIFY(GETPID_SYSCALL) ", %%rax\n" "syscall\n" : "=a"(ret) : : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __exit(uint64_t code) { #if defined(__APPLE__) #define EXIT_SYSCALL 0x2000001 #else #define EXIT_SYSCALL 231 #endif uint64_t ret; __asm__ __volatile__("movq $" STRINGIFY(EXIT_SYSCALL) ", %%rax\n" "syscall\n" : "=a"(ret) : "D"(code) : "cc", "rcx", "r11", "memory"); return ret; } #if !defined(__APPLE__) // We use a stack-allocated buffer for string manipulation in many pieces of // this code, including the code that prints each line of the fdata file. This // buffer needs to accomodate large function names, but shouldn't be arbitrarily // large (dynamically allocated) for simplicity of our memory space usage. // Declare some syscall wrappers we use throughout this code to avoid linking // against system libc. uint64_t __open(const char *pathname, uint64_t flags, uint64_t mode) { uint64_t ret; __asm__ __volatile__("movq $2, %%rax\n" "syscall" : "=a"(ret) : "D"(pathname), "S"(flags), "d"(mode) : "cc", "rcx", "r11", "memory"); return ret; } long __getdents64(unsigned int fd, dirent64 *dirp, size_t count) { long ret; __asm__ __volatile__("movq $217, %%rax\n" "syscall" : "=a"(ret) : "D"(fd), "S"(dirp), "d"(count) : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __readlink(const char *pathname, char *buf, size_t bufsize) { uint64_t ret; __asm__ __volatile__("movq $89, %%rax\n" "syscall" : "=a"(ret) : "D"(pathname), "S"(buf), "d"(bufsize) : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __lseek(uint64_t fd, uint64_t pos, uint64_t whence) { uint64_t ret; __asm__ __volatile__("movq $8, %%rax\n" "syscall\n" : "=a"(ret) : "D"(fd), "S"(pos), "d"(whence) : "cc", "rcx", "r11", "memory"); return ret; } int __ftruncate(uint64_t fd, uint64_t length) { int ret; __asm__ __volatile__("movq $77, %%rax\n" "syscall\n" : "=a"(ret) : "D"(fd), "S"(length) : "cc", "rcx", "r11", "memory"); return ret; } int __close(uint64_t fd) { uint64_t ret; __asm__ __volatile__("movq $3, %%rax\n" "syscall\n" : "=a"(ret) : "D"(fd) : "cc", "rcx", "r11", "memory"); return ret; } int __madvise(void *addr, size_t length, int advice) { int ret; __asm__ __volatile__("movq $28, %%rax\n" "syscall\n" : "=a"(ret) : "D"(addr), "S"(length), "d"(advice) : "cc", "rcx", "r11", "memory"); return ret; } int __uname(struct UtsNameTy *Buf) { int Ret; __asm__ __volatile__("movq $63, %%rax\n" "syscall\n" : "=a"(Ret) : "D"(Buf) : "cc", "rcx", "r11", "memory"); return Ret; } uint64_t __nanosleep(const timespec *req, timespec *rem) { uint64_t ret; __asm__ __volatile__("movq $35, %%rax\n" "syscall\n" : "=a"(ret) : "D"(req), "S"(rem) : "cc", "rcx", "r11", "memory"); return ret; } int64_t __fork() { uint64_t ret; __asm__ __volatile__("movq $57, %%rax\n" "syscall\n" : "=a"(ret) : : "cc", "rcx", "r11", "memory"); return ret; } int __mprotect(void *addr, size_t len, int prot) { int ret; __asm__ __volatile__("movq $10, %%rax\n" "syscall\n" : "=a"(ret) : "D"(addr), "S"(len), "d"(prot) : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __getppid() { uint64_t ret; __asm__ __volatile__("movq $110, %%rax\n" "syscall\n" : "=a"(ret) : : "cc", "rcx", "r11", "memory"); return ret; } int __setpgid(uint64_t pid, uint64_t pgid) { int ret; __asm__ __volatile__("movq $109, %%rax\n" "syscall\n" : "=a"(ret) : "D"(pid), "S"(pgid) : "cc", "rcx", "r11", "memory"); return ret; } uint64_t __getpgid(uint64_t pid) { uint64_t ret; __asm__ __volatile__("movq $121, %%rax\n" "syscall\n" : "=a"(ret) : "D"(pid) : "cc", "rcx", "r11", "memory"); return ret; } int __kill(uint64_t pid, int sig) { int ret; __asm__ __volatile__("movq $62, %%rax\n" "syscall\n" : "=a"(ret) : "D"(pid), "S"(sig) : "cc", "rcx", "r11", "memory"); return ret; } int __fsync(int fd) { int ret; __asm__ __volatile__("movq $74, %%rax\n" "syscall\n" : "=a"(ret) : "D"(fd) : "cc", "rcx", "r11", "memory"); return ret; } // %rdi %rsi %rdx %r10 %r8 // sys_prctl int option unsigned unsigned unsigned unsigned // long arg2 long arg3 long arg4 long arg5 int __prctl(int Option, unsigned long Arg2, unsigned long Arg3, unsigned long Arg4, unsigned long Arg5) { int Ret; register long rdx asm("rdx") = Arg3; register long r8 asm("r8") = Arg5; register long r10 asm("r10") = Arg4; __asm__ __volatile__("movq $157, %%rax\n" "syscall\n" : "=a"(Ret) : "D"(Option), "S"(Arg2), "d"(rdx), "r"(r10), "r"(r8) :); return Ret; } #endif } // anonymous namespace #endif