1 //===----------------------------------------------------------------------===// 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 // Implements unw_* functions from <libunwind.h> 9 // 10 //===----------------------------------------------------------------------===// 11 12 #include <libunwind.h> 13 14 #include "config.h" 15 #include "libunwind_ext.h" 16 17 #include <stdlib.h> 18 19 // Define the __has_feature extension for compilers that do not support it so 20 // that we can later check for the presence of ASan in a compiler-neutral way. 21 #if !defined(__has_feature) 22 #define __has_feature(feature) 0 23 #endif 24 25 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) 26 #include <sanitizer/asan_interface.h> 27 #endif 28 29 #if !defined(__USING_SJLJ_EXCEPTIONS__) 30 #include "AddressSpace.hpp" 31 #include "UnwindCursor.hpp" 32 33 using namespace libunwind; 34 35 /// internal object to represent this processes address space 36 LocalAddressSpace LocalAddressSpace::sThisAddressSpace; 37 38 _LIBUNWIND_EXPORT unw_addr_space_t unw_local_addr_space = 39 (unw_addr_space_t)&LocalAddressSpace::sThisAddressSpace; 40 41 /// Create a cursor of a thread in this process given 'context' recorded by 42 /// __unw_getcontext(). 43 _LIBUNWIND_HIDDEN int __unw_init_local(unw_cursor_t *cursor, 44 unw_context_t *context) { 45 _LIBUNWIND_TRACE_API("__unw_init_local(cursor=%p, context=%p)", 46 static_cast<void *>(cursor), 47 static_cast<void *>(context)); 48 #if defined(__i386__) 49 # define REGISTER_KIND Registers_x86 50 #elif defined(__x86_64__) 51 # define REGISTER_KIND Registers_x86_64 52 #elif defined(__powerpc64__) 53 # define REGISTER_KIND Registers_ppc64 54 #elif defined(__powerpc__) 55 # define REGISTER_KIND Registers_ppc 56 #elif defined(__aarch64__) 57 # define REGISTER_KIND Registers_arm64 58 #elif defined(__arm__) 59 # define REGISTER_KIND Registers_arm 60 #elif defined(__or1k__) 61 # define REGISTER_KIND Registers_or1k 62 #elif defined(__hexagon__) 63 # define REGISTER_KIND Registers_hexagon 64 #elif defined(__mips__) && defined(_ABIO32) && _MIPS_SIM == _ABIO32 65 # define REGISTER_KIND Registers_mips_o32 66 #elif defined(__mips64) 67 # define REGISTER_KIND Registers_mips_newabi 68 #elif defined(__mips__) 69 # warning The MIPS architecture is not supported with this ABI and environment! 70 #elif defined(__sparc__) && defined(__arch64__) 71 #define REGISTER_KIND Registers_sparc64 72 #elif defined(__sparc__) 73 # define REGISTER_KIND Registers_sparc 74 #elif defined(__riscv) 75 # define REGISTER_KIND Registers_riscv 76 #elif defined(__ve__) 77 # define REGISTER_KIND Registers_ve 78 #elif defined(__s390x__) 79 # define REGISTER_KIND Registers_s390x 80 #else 81 # error Architecture not supported 82 #endif 83 // Use "placement new" to allocate UnwindCursor in the cursor buffer. 84 new (reinterpret_cast<UnwindCursor<LocalAddressSpace, REGISTER_KIND> *>(cursor)) 85 UnwindCursor<LocalAddressSpace, REGISTER_KIND>( 86 context, LocalAddressSpace::sThisAddressSpace); 87 #undef REGISTER_KIND 88 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 89 co->setInfoBasedOnIPRegister(); 90 91 return UNW_ESUCCESS; 92 } 93 _LIBUNWIND_WEAK_ALIAS(__unw_init_local, unw_init_local) 94 95 /// Get value of specified register at cursor position in stack frame. 96 _LIBUNWIND_HIDDEN int __unw_get_reg(unw_cursor_t *cursor, unw_regnum_t regNum, 97 unw_word_t *value) { 98 _LIBUNWIND_TRACE_API("__unw_get_reg(cursor=%p, regNum=%d, &value=%p)", 99 static_cast<void *>(cursor), regNum, 100 static_cast<void *>(value)); 101 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 102 if (co->validReg(regNum)) { 103 *value = co->getReg(regNum); 104 return UNW_ESUCCESS; 105 } 106 return UNW_EBADREG; 107 } 108 _LIBUNWIND_WEAK_ALIAS(__unw_get_reg, unw_get_reg) 109 110 /// Set value of specified register at cursor position in stack frame. 111 _LIBUNWIND_HIDDEN int __unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum, 112 unw_word_t value) { 113 _LIBUNWIND_TRACE_API("__unw_set_reg(cursor=%p, regNum=%d, value=0x%" PRIxPTR 114 ")", 115 static_cast<void *>(cursor), regNum, value); 116 typedef LocalAddressSpace::pint_t pint_t; 117 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 118 if (co->validReg(regNum)) { 119 co->setReg(regNum, (pint_t)value); 120 // specical case altering IP to re-find info (being called by personality 121 // function) 122 if (regNum == UNW_REG_IP) { 123 unw_proc_info_t info; 124 // First, get the FDE for the old location and then update it. 125 co->getInfo(&info); 126 co->setInfoBasedOnIPRegister(false); 127 // If the original call expects stack adjustment, perform this now. 128 // Normal frame unwinding would have included the offset already in the 129 // CFA computation. 130 // Note: for PA-RISC and other platforms where the stack grows up, 131 // this should actually be - info.gp. LLVM doesn't currently support 132 // any such platforms and Clang doesn't export a macro for them. 133 if (info.gp) 134 co->setReg(UNW_REG_SP, co->getReg(UNW_REG_SP) + info.gp); 135 } 136 return UNW_ESUCCESS; 137 } 138 return UNW_EBADREG; 139 } 140 _LIBUNWIND_WEAK_ALIAS(__unw_set_reg, unw_set_reg) 141 142 /// Get value of specified float register at cursor position in stack frame. 143 _LIBUNWIND_HIDDEN int __unw_get_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum, 144 unw_fpreg_t *value) { 145 _LIBUNWIND_TRACE_API("__unw_get_fpreg(cursor=%p, regNum=%d, &value=%p)", 146 static_cast<void *>(cursor), regNum, 147 static_cast<void *>(value)); 148 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 149 if (co->validFloatReg(regNum)) { 150 *value = co->getFloatReg(regNum); 151 return UNW_ESUCCESS; 152 } 153 return UNW_EBADREG; 154 } 155 _LIBUNWIND_WEAK_ALIAS(__unw_get_fpreg, unw_get_fpreg) 156 157 /// Set value of specified float register at cursor position in stack frame. 158 _LIBUNWIND_HIDDEN int __unw_set_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum, 159 unw_fpreg_t value) { 160 #if defined(_LIBUNWIND_ARM_EHABI) 161 _LIBUNWIND_TRACE_API("__unw_set_fpreg(cursor=%p, regNum=%d, value=%llX)", 162 static_cast<void *>(cursor), regNum, value); 163 #else 164 _LIBUNWIND_TRACE_API("__unw_set_fpreg(cursor=%p, regNum=%d, value=%g)", 165 static_cast<void *>(cursor), regNum, value); 166 #endif 167 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 168 if (co->validFloatReg(regNum)) { 169 co->setFloatReg(regNum, value); 170 return UNW_ESUCCESS; 171 } 172 return UNW_EBADREG; 173 } 174 _LIBUNWIND_WEAK_ALIAS(__unw_set_fpreg, unw_set_fpreg) 175 176 /// Move cursor to next frame. 177 _LIBUNWIND_HIDDEN int __unw_step(unw_cursor_t *cursor) { 178 _LIBUNWIND_TRACE_API("__unw_step(cursor=%p)", static_cast<void *>(cursor)); 179 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 180 return co->step(); 181 } 182 _LIBUNWIND_WEAK_ALIAS(__unw_step, unw_step) 183 184 /// Get unwind info at cursor position in stack frame. 185 _LIBUNWIND_HIDDEN int __unw_get_proc_info(unw_cursor_t *cursor, 186 unw_proc_info_t *info) { 187 _LIBUNWIND_TRACE_API("__unw_get_proc_info(cursor=%p, &info=%p)", 188 static_cast<void *>(cursor), static_cast<void *>(info)); 189 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 190 co->getInfo(info); 191 if (info->end_ip == 0) 192 return UNW_ENOINFO; 193 return UNW_ESUCCESS; 194 } 195 _LIBUNWIND_WEAK_ALIAS(__unw_get_proc_info, unw_get_proc_info) 196 197 /// Resume execution at cursor position (aka longjump). 198 _LIBUNWIND_HIDDEN int __unw_resume(unw_cursor_t *cursor) { 199 _LIBUNWIND_TRACE_API("__unw_resume(cursor=%p)", static_cast<void *>(cursor)); 200 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) 201 // Inform the ASan runtime that now might be a good time to clean stuff up. 202 __asan_handle_no_return(); 203 #endif 204 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 205 co->jumpto(); 206 return UNW_EUNSPEC; 207 } 208 _LIBUNWIND_WEAK_ALIAS(__unw_resume, unw_resume) 209 210 /// Get name of function at cursor position in stack frame. 211 _LIBUNWIND_HIDDEN int __unw_get_proc_name(unw_cursor_t *cursor, char *buf, 212 size_t bufLen, unw_word_t *offset) { 213 _LIBUNWIND_TRACE_API("__unw_get_proc_name(cursor=%p, &buf=%p, bufLen=%lu)", 214 static_cast<void *>(cursor), static_cast<void *>(buf), 215 static_cast<unsigned long>(bufLen)); 216 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 217 if (co->getFunctionName(buf, bufLen, offset)) 218 return UNW_ESUCCESS; 219 return UNW_EUNSPEC; 220 } 221 _LIBUNWIND_WEAK_ALIAS(__unw_get_proc_name, unw_get_proc_name) 222 223 /// Checks if a register is a floating-point register. 224 _LIBUNWIND_HIDDEN int __unw_is_fpreg(unw_cursor_t *cursor, 225 unw_regnum_t regNum) { 226 _LIBUNWIND_TRACE_API("__unw_is_fpreg(cursor=%p, regNum=%d)", 227 static_cast<void *>(cursor), regNum); 228 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 229 return co->validFloatReg(regNum); 230 } 231 _LIBUNWIND_WEAK_ALIAS(__unw_is_fpreg, unw_is_fpreg) 232 233 /// Checks if a register is a floating-point register. 234 _LIBUNWIND_HIDDEN const char *__unw_regname(unw_cursor_t *cursor, 235 unw_regnum_t regNum) { 236 _LIBUNWIND_TRACE_API("__unw_regname(cursor=%p, regNum=%d)", 237 static_cast<void *>(cursor), regNum); 238 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 239 return co->getRegisterName(regNum); 240 } 241 _LIBUNWIND_WEAK_ALIAS(__unw_regname, unw_regname) 242 243 /// Checks if current frame is signal trampoline. 244 _LIBUNWIND_HIDDEN int __unw_is_signal_frame(unw_cursor_t *cursor) { 245 _LIBUNWIND_TRACE_API("__unw_is_signal_frame(cursor=%p)", 246 static_cast<void *>(cursor)); 247 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 248 return co->isSignalFrame(); 249 } 250 _LIBUNWIND_WEAK_ALIAS(__unw_is_signal_frame, unw_is_signal_frame) 251 252 #ifdef _AIX 253 _LIBUNWIND_EXPORT uintptr_t __unw_get_data_rel_base(unw_cursor_t *cursor) { 254 _LIBUNWIND_TRACE_API("unw_get_data_rel_base(cursor=%p)", 255 static_cast<void *>(cursor)); 256 AbstractUnwindCursor *co = reinterpret_cast<AbstractUnwindCursor *>(cursor); 257 return co->getDataRelBase(); 258 } 259 _LIBUNWIND_WEAK_ALIAS(__unw_get_data_rel_base, unw_get_data_rel_base) 260 #endif 261 262 #ifdef __arm__ 263 // Save VFP registers d0-d15 using FSTMIADX instead of FSTMIADD 264 _LIBUNWIND_HIDDEN void __unw_save_vfp_as_X(unw_cursor_t *cursor) { 265 _LIBUNWIND_TRACE_API("__unw_get_fpreg_save_vfp_as_X(cursor=%p)", 266 static_cast<void *>(cursor)); 267 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor; 268 return co->saveVFPAsX(); 269 } 270 _LIBUNWIND_WEAK_ALIAS(__unw_save_vfp_as_X, unw_save_vfp_as_X) 271 #endif 272 273 274 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 275 /// SPI: walks cached DWARF entries 276 _LIBUNWIND_HIDDEN void __unw_iterate_dwarf_unwind_cache(void (*func)( 277 unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) { 278 _LIBUNWIND_TRACE_API("__unw_iterate_dwarf_unwind_cache(func=%p)", 279 reinterpret_cast<void *>(func)); 280 DwarfFDECache<LocalAddressSpace>::iterateCacheEntries(func); 281 } 282 _LIBUNWIND_WEAK_ALIAS(__unw_iterate_dwarf_unwind_cache, 283 unw_iterate_dwarf_unwind_cache) 284 285 /// IPI: for __register_frame() 286 void __unw_add_dynamic_fde(unw_word_t fde) { 287 CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo; 288 CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo; 289 const char *message = CFI_Parser<LocalAddressSpace>::decodeFDE( 290 LocalAddressSpace::sThisAddressSpace, 291 (LocalAddressSpace::pint_t) fde, &fdeInfo, &cieInfo); 292 if (message == NULL) { 293 // dynamically registered FDEs don't have a mach_header group they are in. 294 // Use fde as mh_group 295 unw_word_t mh_group = fdeInfo.fdeStart; 296 DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group, 297 fdeInfo.pcStart, fdeInfo.pcEnd, 298 fdeInfo.fdeStart); 299 } else { 300 _LIBUNWIND_DEBUG_LOG("__unw_add_dynamic_fde: bad fde: %s", message); 301 } 302 } 303 304 /// IPI: for __deregister_frame() 305 void __unw_remove_dynamic_fde(unw_word_t fde) { 306 // fde is own mh_group 307 DwarfFDECache<LocalAddressSpace>::removeAllIn((LocalAddressSpace::pint_t)fde); 308 } 309 310 void __unw_add_dynamic_eh_frame_section(unw_word_t eh_frame_start) { 311 // The eh_frame section start serves as the mh_group 312 unw_word_t mh_group = eh_frame_start; 313 CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo; 314 CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo; 315 auto p = (LocalAddressSpace::pint_t)eh_frame_start; 316 while (true) { 317 if (CFI_Parser<LocalAddressSpace>::decodeFDE( 318 LocalAddressSpace::sThisAddressSpace, p, &fdeInfo, &cieInfo, 319 true) == NULL) { 320 DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group, 321 fdeInfo.pcStart, fdeInfo.pcEnd, 322 fdeInfo.fdeStart); 323 p += fdeInfo.fdeLength; 324 } else if (CFI_Parser<LocalAddressSpace>::parseCIE( 325 LocalAddressSpace::sThisAddressSpace, p, &cieInfo) == NULL) { 326 p += cieInfo.cieLength; 327 } else 328 return; 329 } 330 } 331 332 void __unw_remove_dynamic_eh_frame_section(unw_word_t eh_frame_start) { 333 // The eh_frame section start serves as the mh_group 334 DwarfFDECache<LocalAddressSpace>::removeAllIn( 335 (LocalAddressSpace::pint_t)eh_frame_start); 336 } 337 338 #endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 339 #endif // !defined(__USING_SJLJ_EXCEPTIONS__) 340 341 342 343 // Add logging hooks in Debug builds only 344 #ifndef NDEBUG 345 #include <stdlib.h> 346 347 _LIBUNWIND_HIDDEN 348 bool logAPIs() { 349 // do manual lock to avoid use of _cxa_guard_acquire or initializers 350 static bool checked = false; 351 static bool log = false; 352 if (!checked) { 353 log = (getenv("LIBUNWIND_PRINT_APIS") != NULL); 354 checked = true; 355 } 356 return log; 357 } 358 359 _LIBUNWIND_HIDDEN 360 bool logUnwinding() { 361 // do manual lock to avoid use of _cxa_guard_acquire or initializers 362 static bool checked = false; 363 static bool log = false; 364 if (!checked) { 365 log = (getenv("LIBUNWIND_PRINT_UNWINDING") != NULL); 366 checked = true; 367 } 368 return log; 369 } 370 371 _LIBUNWIND_HIDDEN 372 bool logDWARF() { 373 // do manual lock to avoid use of _cxa_guard_acquire or initializers 374 static bool checked = false; 375 static bool log = false; 376 if (!checked) { 377 log = (getenv("LIBUNWIND_PRINT_DWARF") != NULL); 378 checked = true; 379 } 380 return log; 381 } 382 383 #endif // NDEBUG 384 385