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