1 //===-- Implementation of crt for aarch64 ---------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "config/linux/app.h" 10 #include "src/__support/OSUtil/syscall.h" 11 #include "src/__support/threads/thread.h" 12 #include "src/string/memory_utils/memcpy_implementations.h" 13 14 #include <arm_acle.h> 15 16 #include <linux/auxvec.h> 17 #include <linux/elf.h> 18 #include <stdint.h> 19 #include <sys/mman.h> 20 #include <sys/syscall.h> 21 22 extern "C" int main(int, char **, char **); 23 24 // Source documentation: 25 // https://github.com/ARM-software/abi-aa/tree/main/sysvabi64 26 27 namespace __llvm_libc { 28 29 #ifdef SYS_mmap2 30 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap2; 31 #elif SYS_mmap 32 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap; 33 #else 34 #error "Target platform does not have SYS_mmap or SYS_mmap2 defined" 35 #endif 36 37 AppProperties app; 38 39 static ThreadAttributes main_thread_attrib; 40 41 void init_tls(TLSDescriptor &tls_descriptor) { 42 if (app.tls.size == 0) { 43 tls_descriptor.size = 0; 44 tls_descriptor.tp = 0; 45 return; 46 } 47 48 // aarch64 follows the variant 1 TLS layout: 49 // 50 // 1. First entry is the dynamic thread vector pointer 51 // 2. Second entry is a 8-byte reserved word. 52 // 3. Padding for alignment. 53 // 4. The TLS data from the ELF image. 54 // 55 // The thread pointer points to the first entry. 56 57 const uintptr_t size_of_pointers = 2 * sizeof(uintptr_t); 58 uintptr_t padding = 0; 59 const uintptr_t ALIGNMENT_MASK = app.tls.align - 1; 60 uintptr_t diff = size_of_pointers & ALIGNMENT_MASK; 61 if (diff != 0) 62 padding += (ALIGNMENT_MASK - diff) + 1; 63 64 uintptr_t alloc_size = size_of_pointers + padding + app.tls.size; 65 66 // We cannot call the mmap function here as the functions set errno on 67 // failure. Since errno is implemented via a thread local variable, we cannot 68 // use errno before TLS is setup. 69 long mmap_ret_val = __llvm_libc::syscall(MMAP_SYSCALL_NUMBER, nullptr, 70 alloc_size, PROT_READ | PROT_WRITE, 71 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); 72 // We cannot check the return value with MAP_FAILED as that is the return 73 // of the mmap function and not the mmap syscall. 74 if (mmap_ret_val < 0 && static_cast<uintptr_t>(mmap_ret_val) > -app.pageSize) 75 __llvm_libc::syscall(SYS_exit, 1); 76 uintptr_t thread_ptr = uintptr_t(reinterpret_cast<uintptr_t *>(mmap_ret_val)); 77 uintptr_t tls_addr = thread_ptr + size_of_pointers + padding; 78 __llvm_libc::inline_memcpy(reinterpret_cast<char *>(tls_addr), 79 reinterpret_cast<const char *>(app.tls.address), 80 app.tls.init_size); 81 tls_descriptor.size = alloc_size; 82 tls_descriptor.addr = thread_ptr; 83 tls_descriptor.tp = thread_ptr; 84 } 85 86 void cleanup_tls(uintptr_t addr, uintptr_t size) { 87 if (size == 0) 88 return; 89 __llvm_libc::syscall(SYS_munmap, addr, size); 90 } 91 92 static void set_thread_ptr(uintptr_t val) { __arm_wsr64("tpidr_el0", val); } 93 94 } // namespace __llvm_libc 95 96 using __llvm_libc::app; 97 98 // TODO: Would be nice to use the aux entry structure from elf.h when available. 99 struct AuxEntry { 100 uint64_t type; 101 uint64_t value; 102 }; 103 104 extern "C" void _start() { 105 // Skip the Frame Pointer and the Link Register 106 // https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst 107 // Section 6.2.3 108 app.args = reinterpret_cast<__llvm_libc::Args *>( 109 reinterpret_cast<uintptr_t *>(__builtin_frame_address(0)) + 2); 110 111 auto tid = __llvm_libc::syscall(SYS_gettid); 112 if (tid <= 0) 113 __llvm_libc::syscall(SYS_exit, 1); 114 __llvm_libc::main_thread_attrib.tid = tid; 115 116 // After the argv array, is a 8-byte long NULL value before the array of env 117 // values. The end of the env values is marked by another 8-byte long NULL 118 // value. We step over it (the "+ 1" below) to get to the env values. 119 uint64_t *env_ptr = app.args->argv + app.args->argc + 1; 120 uint64_t *env_end_marker = env_ptr; 121 while (*env_end_marker) 122 ++env_end_marker; 123 124 // After the env array, is the aux-vector. The end of the aux-vector is 125 // denoted by an AT_NULL entry. 126 Elf64_Phdr *programHdrTable = nullptr; 127 uintptr_t programHdrCount; 128 for (AuxEntry *aux_entry = reinterpret_cast<AuxEntry *>(env_end_marker + 1); 129 aux_entry->type != AT_NULL; ++aux_entry) { 130 switch (aux_entry->type) { 131 case AT_PHDR: 132 programHdrTable = reinterpret_cast<Elf64_Phdr *>(aux_entry->value); 133 break; 134 case AT_PHNUM: 135 programHdrCount = aux_entry->value; 136 break; 137 case AT_PAGESZ: 138 app.pageSize = aux_entry->value; 139 break; 140 default: 141 break; // TODO: Read other useful entries from the aux vector. 142 } 143 } 144 145 app.tls.size = 0; 146 for (uintptr_t i = 0; i < programHdrCount; ++i) { 147 Elf64_Phdr *phdr = programHdrTable + i; 148 if (phdr->p_type != PT_TLS) 149 continue; 150 // TODO: p_vaddr value has to be adjusted for static-pie executables. 151 app.tls.address = phdr->p_vaddr; 152 app.tls.size = phdr->p_memsz; 153 app.tls.init_size = phdr->p_filesz; 154 app.tls.align = phdr->p_align; 155 } 156 157 __llvm_libc::TLSDescriptor tls; 158 __llvm_libc::init_tls(tls); 159 if (tls.size != 0) 160 __llvm_libc::set_thread_ptr(tls.tp); 161 162 __llvm_libc::self.attrib = &__llvm_libc::main_thread_attrib; 163 164 int retval = main(app.args->argc, reinterpret_cast<char **>(app.args->argv), 165 reinterpret_cast<char **>(env_ptr)); 166 __llvm_libc::cleanup_tls(tls.addr, tls.size); 167 __llvm_libc::syscall(SYS_exit, retval); 168 } 169