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 C++ ABI Exception Handling Level 1 as documented at: 9 // https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html 10 // using libunwind 11 // 12 //===----------------------------------------------------------------------===// 13 14 // ARM EHABI does not specify _Unwind_{Get,Set}{GR,IP}(). Thus, we are 15 // defining inline functions to delegate the function calls to 16 // _Unwind_VRS_{Get,Set}(). However, some applications might declare the 17 // function protetype directly (instead of including <unwind.h>), thus we need 18 // to export these functions from libunwind.so as well. 19 #define _LIBUNWIND_UNWIND_LEVEL1_EXTERNAL_LINKAGE 1 20 21 #include <inttypes.h> 22 #include <stdint.h> 23 #include <stdbool.h> 24 #include <stdlib.h> 25 #include <stdio.h> 26 #include <string.h> 27 28 #include "config.h" 29 #include "libunwind.h" 30 #include "libunwind_ext.h" 31 #include "shadow_stack_unwind.h" 32 #include "unwind.h" 33 34 #if !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__) && \ 35 !defined(__wasm__) 36 37 #ifndef _LIBUNWIND_SUPPORT_SEH_UNWIND 38 39 // When shadow stack is enabled, a separate stack containing only return 40 // addresses would be maintained. On function return, the return address would 41 // be compared to the popped address from shadow stack to ensure the return 42 // target is not tempered with. When unwinding, we're skipping the normal return 43 // procedure for multiple frames and thus need to pop the return addresses of 44 // the skipped frames from shadow stack to avoid triggering an exception (using 45 // `_LIBUNWIND_POP_SHSTK_SSP()`). Also, some architectures, like the x86-family 46 // CET, push the return adddresses onto shadow stack with common call 47 // instructions, so for these architectures, normal function calls should be 48 // avoided when invoking the `jumpto()` function. To do this, we use inline 49 // assemblies to "goto" the `jumpto()` for these architectures. 50 #if !defined(_LIBUNWIND_USE_CET) && !defined(_LIBUNWIND_USE_GCS) 51 #define __unw_phase2_resume(cursor, fn) \ 52 do { \ 53 (void)fn; \ 54 __unw_resume((cursor)); \ 55 } while (0) 56 #elif defined(_LIBUNWIND_TARGET_I386) 57 #define __shstk_step_size (4) 58 #define __unw_phase2_resume(cursor, fn) \ 59 do { \ 60 _LIBUNWIND_POP_SHSTK_SSP((fn)); \ 61 void *shstkRegContext = __libunwind_shstk_get_registers((cursor)); \ 62 void *shstkJumpAddress = __libunwind_shstk_get_jump_target(); \ 63 __asm__ volatile("push %%edi\n\t" \ 64 "sub $4, %%esp\n\t" \ 65 "jmp *%%edx\n\t" ::"D"(shstkRegContext), \ 66 "d"(shstkJumpAddress)); \ 67 } while (0) 68 #elif defined(_LIBUNWIND_TARGET_X86_64) 69 #define __shstk_step_size (8) 70 #define __unw_phase2_resume(cursor, fn) \ 71 do { \ 72 _LIBUNWIND_POP_SHSTK_SSP((fn)); \ 73 void *shstkRegContext = __libunwind_shstk_get_registers((cursor)); \ 74 void *shstkJumpAddress = __libunwind_shstk_get_jump_target(); \ 75 __asm__ volatile("jmpq *%%rdx\n\t" ::"D"(shstkRegContext), \ 76 "d"(shstkJumpAddress)); \ 77 } while (0) 78 #elif defined(_LIBUNWIND_TARGET_AARCH64) 79 #define __shstk_step_size (8) 80 #define __unw_phase2_resume(cursor, fn) \ 81 do { \ 82 _LIBUNWIND_POP_SHSTK_SSP((fn)); \ 83 void *shstkRegContext = __libunwind_shstk_get_registers((cursor)); \ 84 void *shstkJumpAddress = __libunwind_shstk_get_jump_target(); \ 85 __asm__ volatile("mov x0, %0\n\t" \ 86 "br %1\n\t" \ 87 : \ 88 : "r"(shstkRegContext), "r"(shstkJumpAddress) \ 89 : "x0"); \ 90 } while (0) 91 #endif 92 93 static _Unwind_Reason_Code 94 unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) { 95 __unw_init_local(cursor, uc); 96 97 // Walk each frame looking for a place to stop. 98 while (true) { 99 // Ask libunwind to get next frame (skip over first which is 100 // _Unwind_RaiseException). 101 int stepResult = __unw_step(cursor); 102 if (stepResult == 0) { 103 _LIBUNWIND_TRACE_UNWINDING( 104 "unwind_phase1(ex_obj=%p): __unw_step() reached " 105 "bottom => _URC_END_OF_STACK", 106 (void *)exception_object); 107 return _URC_END_OF_STACK; 108 } else if (stepResult < 0) { 109 _LIBUNWIND_TRACE_UNWINDING( 110 "unwind_phase1(ex_obj=%p): __unw_step failed => " 111 "_URC_FATAL_PHASE1_ERROR", 112 (void *)exception_object); 113 return _URC_FATAL_PHASE1_ERROR; 114 } 115 116 // See if frame has code to run (has personality routine). 117 unw_proc_info_t frameInfo; 118 unw_word_t sp; 119 if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) { 120 _LIBUNWIND_TRACE_UNWINDING( 121 "unwind_phase1(ex_obj=%p): __unw_get_proc_info " 122 "failed => _URC_FATAL_PHASE1_ERROR", 123 (void *)exception_object); 124 return _URC_FATAL_PHASE1_ERROR; 125 } 126 127 #ifndef NDEBUG 128 // When tracing, print state information. 129 if (_LIBUNWIND_TRACING_UNWINDING) { 130 char functionBuf[512]; 131 const char *functionName = functionBuf; 132 unw_word_t offset; 133 if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf), 134 &offset) != UNW_ESUCCESS) || 135 (frameInfo.start_ip + offset > frameInfo.end_ip)) 136 functionName = ".anonymous."; 137 unw_word_t pc; 138 __unw_get_reg(cursor, UNW_REG_IP, &pc); 139 _LIBUNWIND_TRACE_UNWINDING( 140 "unwind_phase1(ex_obj=%p): pc=0x%" PRIxPTR ", start_ip=0x%" PRIxPTR 141 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR "", 142 (void *)exception_object, pc, frameInfo.start_ip, functionName, 143 frameInfo.lsda, frameInfo.handler); 144 } 145 #endif 146 147 // If there is a personality routine, ask it if it will want to stop at 148 // this frame. 149 if (frameInfo.handler != 0) { 150 _Unwind_Personality_Fn p = 151 (_Unwind_Personality_Fn)(uintptr_t)(frameInfo.handler); 152 _LIBUNWIND_TRACE_UNWINDING( 153 "unwind_phase1(ex_obj=%p): calling personality function %p", 154 (void *)exception_object, (void *)(uintptr_t)p); 155 _Unwind_Reason_Code personalityResult = 156 (*p)(1, _UA_SEARCH_PHASE, exception_object->exception_class, 157 exception_object, (struct _Unwind_Context *)(cursor)); 158 switch (personalityResult) { 159 case _URC_HANDLER_FOUND: 160 // found a catch clause or locals that need destructing in this frame 161 // stop search and remember stack pointer at the frame 162 __unw_get_reg(cursor, UNW_REG_SP, &sp); 163 exception_object->private_2 = (uintptr_t)sp; 164 _LIBUNWIND_TRACE_UNWINDING( 165 "unwind_phase1(ex_obj=%p): _URC_HANDLER_FOUND", 166 (void *)exception_object); 167 return _URC_NO_REASON; 168 169 case _URC_CONTINUE_UNWIND: 170 _LIBUNWIND_TRACE_UNWINDING( 171 "unwind_phase1(ex_obj=%p): _URC_CONTINUE_UNWIND", 172 (void *)exception_object); 173 // continue unwinding 174 break; 175 176 default: 177 // something went wrong 178 _LIBUNWIND_TRACE_UNWINDING( 179 "unwind_phase1(ex_obj=%p): _URC_FATAL_PHASE1_ERROR", 180 (void *)exception_object); 181 return _URC_FATAL_PHASE1_ERROR; 182 } 183 } 184 } 185 return _URC_NO_REASON; 186 } 187 extern int __unw_step_stage2(unw_cursor_t *); 188 189 #if defined(_LIBUNWIND_USE_GCS) 190 // Enable the GCS target feature to permit gcspop instructions to be used. 191 __attribute__((target("+gcs"))) 192 #endif 193 static _Unwind_Reason_Code 194 unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor, 195 _Unwind_Exception *exception_object) { 196 __unw_init_local(cursor, uc); 197 198 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_obj=%p)", 199 (void *)exception_object); 200 201 // uc is initialized by __unw_getcontext in the parent frame. The first stack 202 // frame walked is unwind_phase2. 203 unsigned framesWalked = 1; 204 #if defined(_LIBUNWIND_USE_CET) 205 unsigned long shadowStackTop = _get_ssp(); 206 #elif defined(_LIBUNWIND_USE_GCS) 207 unsigned long shadowStackTop = 0; 208 if (__chkfeat(_CHKFEAT_GCS)) 209 shadowStackTop = (unsigned long)__gcspr(); 210 #endif 211 // Walk each frame until we reach where search phase said to stop. 212 while (true) { 213 214 // Ask libunwind to get next frame (skip over first which is 215 // _Unwind_RaiseException). 216 int stepResult = __unw_step_stage2(cursor); 217 if (stepResult == 0) { 218 _LIBUNWIND_TRACE_UNWINDING( 219 "unwind_phase2(ex_obj=%p): __unw_step_stage2() reached " 220 "bottom => _URC_END_OF_STACK", 221 (void *)exception_object); 222 return _URC_END_OF_STACK; 223 } else if (stepResult < 0) { 224 _LIBUNWIND_TRACE_UNWINDING( 225 "unwind_phase2(ex_obj=%p): __unw_step_stage2 failed => " 226 "_URC_FATAL_PHASE1_ERROR", 227 (void *)exception_object); 228 return _URC_FATAL_PHASE2_ERROR; 229 } 230 231 // Get info about this frame. 232 unw_word_t sp; 233 unw_proc_info_t frameInfo; 234 __unw_get_reg(cursor, UNW_REG_SP, &sp); 235 if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) { 236 _LIBUNWIND_TRACE_UNWINDING( 237 "unwind_phase2(ex_obj=%p): __unw_get_proc_info " 238 "failed => _URC_FATAL_PHASE1_ERROR", 239 (void *)exception_object); 240 return _URC_FATAL_PHASE2_ERROR; 241 } 242 243 #ifndef NDEBUG 244 // When tracing, print state information. 245 if (_LIBUNWIND_TRACING_UNWINDING) { 246 char functionBuf[512]; 247 const char *functionName = functionBuf; 248 unw_word_t offset; 249 if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf), 250 &offset) != UNW_ESUCCESS) || 251 (frameInfo.start_ip + offset > frameInfo.end_ip)) 252 functionName = ".anonymous."; 253 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_obj=%p): start_ip=0x%" PRIxPTR 254 ", func=%s, sp=0x%" PRIxPTR ", lsda=0x%" PRIxPTR 255 ", personality=0x%" PRIxPTR, 256 (void *)exception_object, frameInfo.start_ip, 257 functionName, sp, frameInfo.lsda, 258 frameInfo.handler); 259 } 260 #endif 261 262 // In shadow stack enabled environment, we check return address stored in normal 263 // stack against return address stored in shadow stack, if the 2 addresses don't 264 // match, it means return address in normal stack has been corrupted, we return 265 // _URC_FATAL_PHASE2_ERROR. 266 #if defined(_LIBUNWIND_USE_CET) || defined(_LIBUNWIND_USE_GCS) 267 if (shadowStackTop != 0) { 268 unw_word_t retInNormalStack; 269 __unw_get_reg(cursor, UNW_REG_IP, &retInNormalStack); 270 unsigned long retInShadowStack = 271 *(unsigned long *)(shadowStackTop + __shstk_step_size * framesWalked); 272 if (retInNormalStack != retInShadowStack) 273 return _URC_FATAL_PHASE2_ERROR; 274 } 275 #endif 276 ++framesWalked; 277 // If there is a personality routine, tell it we are unwinding. 278 if (frameInfo.handler != 0) { 279 _Unwind_Personality_Fn p = 280 (_Unwind_Personality_Fn)(uintptr_t)(frameInfo.handler); 281 _Unwind_Action action = _UA_CLEANUP_PHASE; 282 if (sp == exception_object->private_2) { 283 // Tell personality this was the frame it marked in phase 1. 284 action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME); 285 } 286 _Unwind_Reason_Code personalityResult = 287 (*p)(1, action, exception_object->exception_class, exception_object, 288 (struct _Unwind_Context *)(cursor)); 289 switch (personalityResult) { 290 case _URC_CONTINUE_UNWIND: 291 // Continue unwinding 292 _LIBUNWIND_TRACE_UNWINDING( 293 "unwind_phase2(ex_obj=%p): _URC_CONTINUE_UNWIND", 294 (void *)exception_object); 295 if (sp == exception_object->private_2) { 296 // Phase 1 said we would stop at this frame, but we did not... 297 _LIBUNWIND_ABORT("during phase1 personality function said it would " 298 "stop here, but now in phase2 it did not stop here"); 299 } 300 break; 301 case _URC_INSTALL_CONTEXT: 302 _LIBUNWIND_TRACE_UNWINDING( 303 "unwind_phase2(ex_obj=%p): _URC_INSTALL_CONTEXT", 304 (void *)exception_object); 305 // Personality routine says to transfer control to landing pad. 306 // We may get control back if landing pad calls _Unwind_Resume(). 307 if (_LIBUNWIND_TRACING_UNWINDING) { 308 unw_word_t pc; 309 __unw_get_reg(cursor, UNW_REG_IP, &pc); 310 __unw_get_reg(cursor, UNW_REG_SP, &sp); 311 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_obj=%p): re-entering " 312 "user code with ip=0x%" PRIxPTR 313 ", sp=0x%" PRIxPTR, 314 (void *)exception_object, pc, sp); 315 } 316 317 __unw_phase2_resume(cursor, framesWalked); 318 // __unw_phase2_resume() only returns if there was an error. 319 return _URC_FATAL_PHASE2_ERROR; 320 default: 321 // Personality routine returned an unknown result code. 322 _LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d", 323 personalityResult); 324 return _URC_FATAL_PHASE2_ERROR; 325 } 326 } 327 } 328 329 // Clean up phase did not resume at the frame that the search phase 330 // said it would... 331 return _URC_FATAL_PHASE2_ERROR; 332 } 333 334 #if defined(_LIBUNWIND_USE_GCS) 335 // Enable the GCS target feature to permit gcspop instructions to be used. 336 __attribute__((target("+gcs"))) 337 #endif 338 static _Unwind_Reason_Code 339 unwind_phase2_forced(unw_context_t *uc, unw_cursor_t *cursor, 340 _Unwind_Exception *exception_object, _Unwind_Stop_Fn stop, 341 void *stop_parameter) { 342 __unw_init_local(cursor, uc); 343 344 // uc is initialized by __unw_getcontext in the parent frame. The first stack 345 // frame walked is unwind_phase2_forced. 346 unsigned framesWalked = 1; 347 // Walk each frame until we reach where search phase said to stop 348 while (__unw_step_stage2(cursor) > 0) { 349 350 // Update info about this frame. 351 unw_proc_info_t frameInfo; 352 if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) { 353 _LIBUNWIND_TRACE_UNWINDING( 354 "unwind_phase2_forced(ex_obj=%p): __unw_get_proc_info " 355 "failed => _URC_END_OF_STACK", 356 (void *)exception_object); 357 return _URC_FATAL_PHASE2_ERROR; 358 } 359 360 #ifndef NDEBUG 361 // When tracing, print state information. 362 if (_LIBUNWIND_TRACING_UNWINDING) { 363 char functionBuf[512]; 364 const char *functionName = functionBuf; 365 unw_word_t offset; 366 if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf), 367 &offset) != UNW_ESUCCESS) || 368 (frameInfo.start_ip + offset > frameInfo.end_ip)) 369 functionName = ".anonymous."; 370 _LIBUNWIND_TRACE_UNWINDING( 371 "unwind_phase2_forced(ex_obj=%p): start_ip=0x%" PRIxPTR 372 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR, 373 (void *)exception_object, frameInfo.start_ip, functionName, 374 frameInfo.lsda, frameInfo.handler); 375 } 376 #endif 377 378 // Call stop function at each frame. 379 _Unwind_Action action = 380 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE); 381 _Unwind_Reason_Code stopResult = 382 (*stop)(1, action, exception_object->exception_class, exception_object, 383 (struct _Unwind_Context *)(cursor), stop_parameter); 384 _LIBUNWIND_TRACE_UNWINDING( 385 "unwind_phase2_forced(ex_obj=%p): stop function returned %d", 386 (void *)exception_object, stopResult); 387 if (stopResult != _URC_NO_REASON) { 388 _LIBUNWIND_TRACE_UNWINDING( 389 "unwind_phase2_forced(ex_obj=%p): stopped by stop function", 390 (void *)exception_object); 391 return _URC_FATAL_PHASE2_ERROR; 392 } 393 394 ++framesWalked; 395 // If there is a personality routine, tell it we are unwinding. 396 if (frameInfo.handler != 0) { 397 _Unwind_Personality_Fn p = 398 (_Unwind_Personality_Fn)(intptr_t)(frameInfo.handler); 399 _LIBUNWIND_TRACE_UNWINDING( 400 "unwind_phase2_forced(ex_obj=%p): calling personality function %p", 401 (void *)exception_object, (void *)(uintptr_t)p); 402 _Unwind_Reason_Code personalityResult = 403 (*p)(1, action, exception_object->exception_class, exception_object, 404 (struct _Unwind_Context *)(cursor)); 405 switch (personalityResult) { 406 case _URC_CONTINUE_UNWIND: 407 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_obj=%p): " 408 "personality returned " 409 "_URC_CONTINUE_UNWIND", 410 (void *)exception_object); 411 // Destructors called, continue unwinding 412 break; 413 case _URC_INSTALL_CONTEXT: 414 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_obj=%p): " 415 "personality returned " 416 "_URC_INSTALL_CONTEXT", 417 (void *)exception_object); 418 // We may get control back if landing pad calls _Unwind_Resume(). 419 __unw_phase2_resume(cursor, framesWalked); 420 break; 421 default: 422 // Personality routine returned an unknown result code. 423 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_obj=%p): " 424 "personality returned %d, " 425 "_URC_FATAL_PHASE2_ERROR", 426 (void *)exception_object, personalityResult); 427 return _URC_FATAL_PHASE2_ERROR; 428 } 429 } 430 } 431 432 // Call stop function one last time and tell it we've reached the end 433 // of the stack. 434 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_obj=%p): calling stop " 435 "function with _UA_END_OF_STACK", 436 (void *)exception_object); 437 _Unwind_Action lastAction = 438 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK); 439 (*stop)(1, lastAction, exception_object->exception_class, exception_object, 440 (struct _Unwind_Context *)(cursor), stop_parameter); 441 442 // Clean up phase did not resume at the frame that the search phase said it 443 // would. 444 return _URC_FATAL_PHASE2_ERROR; 445 } 446 447 /// Called by __cxa_throw. Only returns if there is a fatal error. 448 _LIBUNWIND_EXPORT _Unwind_Reason_Code 449 _Unwind_RaiseException(_Unwind_Exception *exception_object) { 450 _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)", 451 (void *)exception_object); 452 unw_context_t uc; 453 unw_cursor_t cursor; 454 __unw_getcontext(&uc); 455 456 // Mark that this is a non-forced unwind, so _Unwind_Resume() 457 // can do the right thing. 458 exception_object->private_1 = 0; 459 exception_object->private_2 = 0; 460 461 // phase 1: the search phase 462 _Unwind_Reason_Code phase1 = unwind_phase1(&uc, &cursor, exception_object); 463 if (phase1 != _URC_NO_REASON) 464 return phase1; 465 466 // phase 2: the clean up phase 467 return unwind_phase2(&uc, &cursor, exception_object); 468 } 469 470 471 472 /// When _Unwind_RaiseException() is in phase2, it hands control 473 /// to the personality function at each frame. The personality 474 /// may force a jump to a landing pad in that function, the landing 475 /// pad code may then call _Unwind_Resume() to continue with the 476 /// unwinding. Note: the call to _Unwind_Resume() is from compiler 477 /// generated user code. All other _Unwind_* routines are called 478 /// by the C++ runtime __cxa_* routines. 479 /// 480 /// Note: re-throwing an exception (as opposed to continuing the unwind) 481 /// is implemented by having the code call __cxa_rethrow() which 482 /// in turn calls _Unwind_Resume_or_Rethrow(). 483 _LIBUNWIND_EXPORT void 484 _Unwind_Resume(_Unwind_Exception *exception_object) { 485 _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object); 486 unw_context_t uc; 487 unw_cursor_t cursor; 488 __unw_getcontext(&uc); 489 490 if (exception_object->private_1 != 0) 491 unwind_phase2_forced(&uc, &cursor, exception_object, 492 (_Unwind_Stop_Fn) exception_object->private_1, 493 (void *)exception_object->private_2); 494 else 495 unwind_phase2(&uc, &cursor, exception_object); 496 497 // Clients assume _Unwind_Resume() does not return, so all we can do is abort. 498 _LIBUNWIND_ABORT("_Unwind_Resume() can't return"); 499 } 500 501 502 503 /// Not used by C++. 504 /// Unwinds stack, calling "stop" function at each frame. 505 /// Could be used to implement longjmp(). 506 _LIBUNWIND_EXPORT _Unwind_Reason_Code 507 _Unwind_ForcedUnwind(_Unwind_Exception *exception_object, 508 _Unwind_Stop_Fn stop, void *stop_parameter) { 509 _LIBUNWIND_TRACE_API("_Unwind_ForcedUnwind(ex_obj=%p, stop=%p)", 510 (void *)exception_object, (void *)(uintptr_t)stop); 511 unw_context_t uc; 512 unw_cursor_t cursor; 513 __unw_getcontext(&uc); 514 515 // Mark that this is a forced unwind, so _Unwind_Resume() can do 516 // the right thing. 517 exception_object->private_1 = (uintptr_t) stop; 518 exception_object->private_2 = (uintptr_t) stop_parameter; 519 520 // do it 521 return unwind_phase2_forced(&uc, &cursor, exception_object, stop, stop_parameter); 522 } 523 524 525 /// Called by personality handler during phase 2 to get LSDA for current frame. 526 _LIBUNWIND_EXPORT uintptr_t 527 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) { 528 unw_cursor_t *cursor = (unw_cursor_t *)context; 529 unw_proc_info_t frameInfo; 530 uintptr_t result = 0; 531 if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS) 532 result = (uintptr_t)frameInfo.lsda; 533 _LIBUNWIND_TRACE_API( 534 "_Unwind_GetLanguageSpecificData(context=%p) => 0x%" PRIxPTR, 535 (void *)context, result); 536 #if !defined(_LIBUNWIND_SUPPORT_TBTAB_UNWIND) 537 if (result != 0) { 538 if (*((uint8_t *)result) != 0xFF) 539 _LIBUNWIND_DEBUG_LOG("lsda at 0x%" PRIxPTR " does not start with 0xFF", 540 result); 541 } 542 #endif 543 return result; 544 } 545 546 547 /// Called by personality handler during phase 2 to find the start of the 548 /// function. 549 _LIBUNWIND_EXPORT uintptr_t 550 _Unwind_GetRegionStart(struct _Unwind_Context *context) { 551 unw_cursor_t *cursor = (unw_cursor_t *)context; 552 unw_proc_info_t frameInfo; 553 uintptr_t result = 0; 554 if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS) 555 result = (uintptr_t)frameInfo.start_ip; 556 _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%" PRIxPTR, 557 (void *)context, result); 558 return result; 559 } 560 561 #endif // !_LIBUNWIND_SUPPORT_SEH_UNWIND 562 563 /// Called by personality handler during phase 2 if a foreign exception 564 // is caught. 565 _LIBUNWIND_EXPORT void 566 _Unwind_DeleteException(_Unwind_Exception *exception_object) { 567 _LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)", 568 (void *)exception_object); 569 if (exception_object->exception_cleanup != NULL) 570 (*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT, 571 exception_object); 572 } 573 574 /// Called by personality handler during phase 2 to get register values. 575 _LIBUNWIND_EXPORT uintptr_t 576 _Unwind_GetGR(struct _Unwind_Context *context, int index) { 577 unw_cursor_t *cursor = (unw_cursor_t *)context; 578 unw_word_t result; 579 __unw_get_reg(cursor, index, &result); 580 _LIBUNWIND_TRACE_API("_Unwind_GetGR(context=%p, reg=%d) => 0x%" PRIxPTR, 581 (void *)context, index, result); 582 return (uintptr_t)result; 583 } 584 585 /// Called by personality handler during phase 2 to alter register values. 586 _LIBUNWIND_EXPORT void _Unwind_SetGR(struct _Unwind_Context *context, int index, 587 uintptr_t value) { 588 _LIBUNWIND_TRACE_API("_Unwind_SetGR(context=%p, reg=%d, value=0x%0" PRIxPTR 589 ")", 590 (void *)context, index, value); 591 unw_cursor_t *cursor = (unw_cursor_t *)context; 592 __unw_set_reg(cursor, index, value); 593 } 594 595 /// Called by personality handler during phase 2 to get instruction pointer. 596 _LIBUNWIND_EXPORT uintptr_t _Unwind_GetIP(struct _Unwind_Context *context) { 597 unw_cursor_t *cursor = (unw_cursor_t *)context; 598 unw_word_t result; 599 __unw_get_reg(cursor, UNW_REG_IP, &result); 600 _LIBUNWIND_TRACE_API("_Unwind_GetIP(context=%p) => 0x%" PRIxPTR, 601 (void *)context, result); 602 return (uintptr_t)result; 603 } 604 605 /// Called by personality handler during phase 2 to alter instruction pointer, 606 /// such as setting where the landing pad is, so _Unwind_Resume() will 607 /// start executing in the landing pad. 608 _LIBUNWIND_EXPORT void _Unwind_SetIP(struct _Unwind_Context *context, 609 uintptr_t value) { 610 _LIBUNWIND_TRACE_API("_Unwind_SetIP(context=%p, value=0x%0" PRIxPTR ")", 611 (void *)context, value); 612 unw_cursor_t *cursor = (unw_cursor_t *)context; 613 __unw_set_reg(cursor, UNW_REG_IP, value); 614 } 615 616 #endif // !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__) 617