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 // 9 // Implements SEH-based Itanium C++ exceptions. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "config.h" 14 15 #if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) 16 17 #include <unwind.h> 18 19 #include <stdint.h> 20 #include <stdbool.h> 21 #include <stdlib.h> 22 23 #include <windef.h> 24 #include <excpt.h> 25 #include <winnt.h> 26 #include <ntstatus.h> 27 28 #include "libunwind_ext.h" 29 #include "UnwindCursor.hpp" 30 31 using namespace libunwind; 32 33 #define STATUS_USER_DEFINED (1u << 29) 34 35 #define STATUS_GCC_MAGIC (('G' << 16) | ('C' << 8) | 'C') 36 37 #define MAKE_CUSTOM_STATUS(s, c) \ 38 ((NTSTATUS)(((s) << 30) | STATUS_USER_DEFINED | (c))) 39 #define MAKE_GCC_EXCEPTION(c) \ 40 MAKE_CUSTOM_STATUS(STATUS_SEVERITY_SUCCESS, STATUS_GCC_MAGIC | ((c) << 24)) 41 42 /// SEH exception raised by libunwind when the program calls 43 /// \c _Unwind_RaiseException. 44 #define STATUS_GCC_THROW MAKE_GCC_EXCEPTION(0) // 0x20474343 45 /// SEH exception raised by libunwind to initiate phase 2 of exception 46 /// handling. 47 #define STATUS_GCC_UNWIND MAKE_GCC_EXCEPTION(1) // 0x21474343 48 49 static int __unw_init_seh(unw_cursor_t *cursor, CONTEXT *ctx); 50 static DISPATCHER_CONTEXT *__unw_seh_get_disp_ctx(unw_cursor_t *cursor); 51 static void __unw_seh_set_disp_ctx(unw_cursor_t *cursor, 52 DISPATCHER_CONTEXT *disp); 53 54 #pragma clang diagnostic push 55 #pragma clang diagnostic ignored "-Wgnu-anonymous-struct" 56 // Local redefinition of this type; mingw-w64 headers lack the 57 // DISPATCHER_CONTEXT_NONVOLREG_ARM64 type as of May 2025, so locally redefine 58 // it and use that definition, to avoid needing to test/guess whether the real 59 // type is available of not. 60 union LOCAL_DISPATCHER_CONTEXT_NONVOLREG_ARM64 { 61 BYTE Buffer[11 * sizeof(DWORD64) + 8 * sizeof(double)]; 62 63 struct { 64 DWORD64 GpNvRegs[11]; 65 double FpNvRegs[8]; 66 }; 67 }; 68 69 // Custom data type definition; this type is not defined in WinSDK. 70 union LOCAL_DISPATCHER_CONTEXT_NONVOLREG_ARM { 71 BYTE Buffer[8 * sizeof(DWORD) + 8 * sizeof(double)]; 72 73 struct { 74 DWORD GpNvRegs[8]; 75 double FpNvRegs[8]; 76 }; 77 }; 78 #pragma clang diagnostic pop 79 80 /// Common implementation of SEH-style handler functions used by Itanium- 81 /// style frames. Depending on how and why it was called, it may do one of: 82 /// a) Delegate to the given Itanium-style personality function; or 83 /// b) Initiate a collided unwind to halt unwinding. 84 _LIBUNWIND_EXPORT EXCEPTION_DISPOSITION 85 _GCC_specific_handler(PEXCEPTION_RECORD ms_exc, PVOID frame, PCONTEXT ms_ctx, 86 DISPATCHER_CONTEXT *disp, _Unwind_Personality_Fn pers) { 87 unw_cursor_t cursor; 88 _Unwind_Exception *exc; 89 _Unwind_Action action; 90 struct _Unwind_Context *ctx = nullptr; 91 _Unwind_Reason_Code urc; 92 uintptr_t retval, target; 93 bool ours = false; 94 95 _LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler(%#010lx(%lx), %p)", 96 ms_exc->ExceptionCode, ms_exc->ExceptionFlags, 97 (void *)frame); 98 if (ms_exc->ExceptionCode == STATUS_GCC_UNWIND) { 99 if (IS_TARGET_UNWIND(ms_exc->ExceptionFlags)) { 100 // Set up the upper return value (the lower one and the target PC 101 // were set in the call to RtlUnwindEx()) for the landing pad. 102 #ifdef __x86_64__ 103 disp->ContextRecord->Rdx = ms_exc->ExceptionInformation[3]; 104 #elif defined(__arm__) 105 disp->ContextRecord->R1 = ms_exc->ExceptionInformation[3]; 106 #elif defined(__aarch64__) 107 disp->ContextRecord->X1 = ms_exc->ExceptionInformation[3]; 108 #endif 109 } 110 // This is the collided unwind to the landing pad. Nothing to do. 111 return ExceptionContinueSearch; 112 } 113 114 if (ms_exc->ExceptionCode == STATUS_GCC_THROW) { 115 // This is (probably) a libunwind-controlled exception/unwind. Recover the 116 // parameters which we set below, and pass them to the personality function. 117 ours = true; 118 exc = (_Unwind_Exception *)ms_exc->ExceptionInformation[0]; 119 if (!IS_UNWINDING(ms_exc->ExceptionFlags) && ms_exc->NumberParameters > 1) { 120 ctx = (struct _Unwind_Context *)ms_exc->ExceptionInformation[1]; 121 action = (_Unwind_Action)ms_exc->ExceptionInformation[2]; 122 } 123 } else { 124 // Foreign exception. 125 // We can't interact with them (we don't know the original target frame 126 // that we should pass on to RtlUnwindEx in _Unwind_Resume), so just 127 // pass without calling our destructors here. 128 return ExceptionContinueSearch; 129 } 130 if (!ctx) { 131 __unw_init_seh(&cursor, disp->ContextRecord); 132 __unw_seh_set_disp_ctx(&cursor, disp); 133 __unw_set_reg(&cursor, UNW_REG_IP, disp->ControlPc); 134 ctx = (struct _Unwind_Context *)&cursor; 135 136 if (!IS_UNWINDING(ms_exc->ExceptionFlags)) { 137 if (ours && ms_exc->NumberParameters > 1) 138 action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_FORCE_UNWIND); 139 else 140 action = _UA_SEARCH_PHASE; 141 } else { 142 if (ours && ms_exc->ExceptionInformation[1] == (ULONG_PTR)frame) 143 action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME); 144 else 145 action = _UA_CLEANUP_PHASE; 146 } 147 } 148 149 _LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler() calling personality " 150 "function %p(1, %d, %llx, %p, %p)", 151 (void *)pers, action, exc->exception_class, 152 (void *)exc, (void *)ctx); 153 urc = pers(1, action, exc->exception_class, exc, ctx); 154 _LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler() personality returned %d", urc); 155 switch (urc) { 156 case _URC_CONTINUE_UNWIND: 157 // If we're in phase 2, and the personality routine said to continue 158 // at the target frame, we're in real trouble. 159 if (action & _UA_HANDLER_FRAME) 160 _LIBUNWIND_ABORT("Personality continued unwind at the target frame!"); 161 return ExceptionContinueSearch; 162 case _URC_HANDLER_FOUND: 163 // If we were called by __libunwind_seh_personality(), indicate that 164 // a handler was found; otherwise, initiate phase 2 by unwinding. 165 if (ours && ms_exc->NumberParameters > 1) 166 return 4 /* ExceptionExecuteHandler in mingw */; 167 // This should never happen in phase 2. 168 if (IS_UNWINDING(ms_exc->ExceptionFlags)) 169 _LIBUNWIND_ABORT("Personality indicated exception handler in phase 2!"); 170 exc->private_[1] = (ULONG_PTR)frame; 171 if (ours) { 172 ms_exc->NumberParameters = 4; 173 ms_exc->ExceptionInformation[1] = (ULONG_PTR)frame; 174 } 175 // FIXME: Indicate target frame in foreign case! 176 // phase 2: the clean up phase 177 RtlUnwindEx(frame, (PVOID)disp->ControlPc, ms_exc, exc, disp->ContextRecord, 178 disp->HistoryTable); 179 _LIBUNWIND_ABORT("RtlUnwindEx() failed"); 180 case _URC_INSTALL_CONTEXT: { 181 // If we were called by __libunwind_seh_personality(), indicate that 182 // a handler was found; otherwise, it's time to initiate a collided 183 // unwind to the target. 184 if (ours && !IS_UNWINDING(ms_exc->ExceptionFlags) && ms_exc->NumberParameters > 1) 185 return 4 /* ExceptionExecuteHandler in mingw */; 186 // This should never happen in phase 1. 187 if (!IS_UNWINDING(ms_exc->ExceptionFlags)) 188 _LIBUNWIND_ABORT("Personality installed context during phase 1!"); 189 #ifdef __x86_64__ 190 exc->private_[2] = disp->TargetIp; 191 __unw_get_reg(&cursor, UNW_X86_64_RAX, &retval); 192 __unw_get_reg(&cursor, UNW_X86_64_RDX, &exc->private_[3]); 193 #elif defined(__arm__) 194 exc->private_[2] = disp->TargetPc; 195 __unw_get_reg(&cursor, UNW_ARM_R0, &retval); 196 __unw_get_reg(&cursor, UNW_ARM_R1, &exc->private_[3]); 197 #elif defined(__aarch64__) 198 exc->private_[2] = disp->TargetPc; 199 __unw_get_reg(&cursor, UNW_AARCH64_X0, &retval); 200 __unw_get_reg(&cursor, UNW_AARCH64_X1, &exc->private_[3]); 201 #endif 202 __unw_get_reg(&cursor, UNW_REG_IP, &target); 203 ms_exc->ExceptionCode = STATUS_GCC_UNWIND; 204 #ifdef __x86_64__ 205 ms_exc->ExceptionInformation[2] = disp->TargetIp; 206 #elif defined(__arm__) || defined(__aarch64__) 207 ms_exc->ExceptionInformation[2] = disp->TargetPc; 208 #endif 209 ms_exc->ExceptionInformation[3] = exc->private_[3]; 210 // Give NTRTL some scratch space to keep track of the collided unwind. 211 // Don't use the one that was passed in; we don't want to overwrite the 212 // context in the DISPATCHER_CONTEXT. 213 CONTEXT new_ctx; 214 RtlUnwindEx(frame, (PVOID)target, ms_exc, (PVOID)retval, &new_ctx, disp->HistoryTable); 215 _LIBUNWIND_ABORT("RtlUnwindEx() failed"); 216 } 217 // Anything else indicates a serious problem. 218 default: return ExceptionContinueExecution; 219 } 220 } 221 222 /// Personality function returned by \c __unw_get_proc_info() in SEH contexts. 223 /// This is a wrapper that calls the real SEH handler function, which in 224 /// turn (at least, for Itanium-style frames) calls the real Itanium 225 /// personality function (see \c _GCC_specific_handler()). 226 extern "C" _Unwind_Reason_Code 227 __libunwind_seh_personality(int version, _Unwind_Action state, 228 uint64_t klass, _Unwind_Exception *exc, 229 struct _Unwind_Context *context) { 230 (void)version; 231 (void)klass; 232 EXCEPTION_RECORD ms_exc; 233 bool phase2 = (state & (_UA_SEARCH_PHASE|_UA_CLEANUP_PHASE)) == _UA_CLEANUP_PHASE; 234 ms_exc.ExceptionCode = STATUS_GCC_THROW; 235 ms_exc.ExceptionFlags = 0; 236 ms_exc.NumberParameters = 3; 237 ms_exc.ExceptionInformation[0] = (ULONG_PTR)exc; 238 ms_exc.ExceptionInformation[1] = (ULONG_PTR)context; 239 ms_exc.ExceptionInformation[2] = state; 240 DISPATCHER_CONTEXT *disp_ctx = 241 __unw_seh_get_disp_ctx((unw_cursor_t *)context); 242 #if defined(__aarch64__) 243 LOCAL_DISPATCHER_CONTEXT_NONVOLREG_ARM64 nonvol; 244 memcpy(&nonvol.GpNvRegs, &disp_ctx->ContextRecord->X19, 245 sizeof(nonvol.GpNvRegs)); 246 for (int i = 0; i < 8; i++) 247 nonvol.FpNvRegs[i] = disp_ctx->ContextRecord->V[i + 8].D[0]; 248 disp_ctx->NonVolatileRegisters = nonvol.Buffer; 249 #elif defined(__arm__) 250 LOCAL_DISPATCHER_CONTEXT_NONVOLREG_ARM nonvol; 251 memcpy(&nonvol.GpNvRegs, &disp_ctx->ContextRecord->R4, 252 sizeof(nonvol.GpNvRegs)); 253 memcpy(&nonvol.FpNvRegs, &disp_ctx->ContextRecord->D[8], 254 sizeof(nonvol.FpNvRegs)); 255 disp_ctx->NonVolatileRegisters = nonvol.Buffer; 256 #endif 257 _LIBUNWIND_TRACE_UNWINDING("__libunwind_seh_personality() calling " 258 "LanguageHandler %p(%p, %p, %p, %p)", 259 (void *)disp_ctx->LanguageHandler, (void *)&ms_exc, 260 (void *)disp_ctx->EstablisherFrame, 261 (void *)disp_ctx->ContextRecord, (void *)disp_ctx); 262 EXCEPTION_DISPOSITION ms_act = disp_ctx->LanguageHandler(&ms_exc, 263 (PVOID)disp_ctx->EstablisherFrame, 264 disp_ctx->ContextRecord, 265 disp_ctx); 266 _LIBUNWIND_TRACE_UNWINDING("__libunwind_seh_personality() LanguageHandler " 267 "returned %d", 268 (int)ms_act); 269 switch (ms_act) { 270 case ExceptionContinueExecution: return _URC_END_OF_STACK; 271 case ExceptionContinueSearch: return _URC_CONTINUE_UNWIND; 272 case 4 /*ExceptionExecuteHandler*/: 273 return phase2 ? _URC_INSTALL_CONTEXT : _URC_HANDLER_FOUND; 274 default: 275 return phase2 ? _URC_FATAL_PHASE2_ERROR : _URC_FATAL_PHASE1_ERROR; 276 } 277 } 278 279 static _Unwind_Reason_Code 280 unwind_phase2_forced(unw_context_t *uc, 281 _Unwind_Exception *exception_object, 282 _Unwind_Stop_Fn stop, void *stop_parameter) { 283 unw_cursor_t cursor2; 284 __unw_init_local(&cursor2, uc); 285 286 // Walk each frame until we reach where search phase said to stop 287 while (__unw_step(&cursor2) > 0) { 288 289 // Update info about this frame. 290 unw_proc_info_t frameInfo; 291 if (__unw_get_proc_info(&cursor2, &frameInfo) != UNW_ESUCCESS) { 292 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): __unw_get_proc_info " 293 "failed => _URC_END_OF_STACK", 294 (void *)exception_object); 295 return _URC_FATAL_PHASE2_ERROR; 296 } 297 298 #ifndef NDEBUG 299 // When tracing, print state information. 300 if (_LIBUNWIND_TRACING_UNWINDING) { 301 char functionBuf[512]; 302 const char *functionName = functionBuf; 303 unw_word_t offset; 304 if ((__unw_get_proc_name(&cursor2, functionBuf, sizeof(functionBuf), 305 &offset) != UNW_ESUCCESS) || 306 (frameInfo.start_ip + offset > frameInfo.end_ip)) 307 functionName = ".anonymous."; 308 _LIBUNWIND_TRACE_UNWINDING( 309 "unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIxPTR 310 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR, 311 (void *)exception_object, frameInfo.start_ip, functionName, 312 frameInfo.lsda, frameInfo.handler); 313 } 314 #endif 315 316 // Call stop function at each frame. 317 _Unwind_Action action = 318 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE); 319 _Unwind_Reason_Code stopResult = 320 (*stop)(1, action, exception_object->exception_class, exception_object, 321 (struct _Unwind_Context *)(&cursor2), stop_parameter); 322 _LIBUNWIND_TRACE_UNWINDING( 323 "unwind_phase2_forced(ex_ojb=%p): stop function returned %d", 324 (void *)exception_object, stopResult); 325 if (stopResult != _URC_NO_REASON) { 326 _LIBUNWIND_TRACE_UNWINDING( 327 "unwind_phase2_forced(ex_ojb=%p): stopped by stop function", 328 (void *)exception_object); 329 return _URC_FATAL_PHASE2_ERROR; 330 } 331 332 // If there is a personality routine, tell it we are unwinding. 333 if (frameInfo.handler != 0) { 334 _Unwind_Personality_Fn p = 335 (_Unwind_Personality_Fn)(intptr_t)(frameInfo.handler); 336 _LIBUNWIND_TRACE_UNWINDING( 337 "unwind_phase2_forced(ex_ojb=%p): calling personality function %p", 338 (void *)exception_object, (void *)(uintptr_t)p); 339 _Unwind_Reason_Code personalityResult = 340 (*p)(1, action, exception_object->exception_class, exception_object, 341 (struct _Unwind_Context *)(&cursor2)); 342 switch (personalityResult) { 343 case _URC_CONTINUE_UNWIND: 344 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): " 345 "personality returned " 346 "_URC_CONTINUE_UNWIND", 347 (void *)exception_object); 348 // Destructors called, continue unwinding 349 break; 350 case _URC_INSTALL_CONTEXT: 351 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): " 352 "personality returned " 353 "_URC_INSTALL_CONTEXT", 354 (void *)exception_object); 355 // We may get control back if landing pad calls _Unwind_Resume(). 356 __unw_resume(&cursor2); 357 break; 358 case _URC_END_OF_STACK: 359 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): " 360 "personality returned " 361 "_URC_END_OF_STACK", 362 (void *)exception_object); 363 break; 364 default: 365 // Personality routine returned an unknown result code. 366 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): " 367 "personality returned %d, " 368 "_URC_FATAL_PHASE2_ERROR", 369 (void *)exception_object, personalityResult); 370 return _URC_FATAL_PHASE2_ERROR; 371 } 372 if (personalityResult == _URC_END_OF_STACK) 373 break; 374 } 375 } 376 377 // Call stop function one last time and tell it we've reached the end 378 // of the stack. 379 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop " 380 "function with _UA_END_OF_STACK", 381 (void *)exception_object); 382 _Unwind_Action lastAction = 383 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK); 384 (*stop)(1, lastAction, exception_object->exception_class, exception_object, 385 (struct _Unwind_Context *)(&cursor2), stop_parameter); 386 387 // Clean up phase did not resume at the frame that the search phase said it 388 // would. 389 return _URC_FATAL_PHASE2_ERROR; 390 } 391 392 /// Called by \c __cxa_throw(). Only returns if there is a fatal error. 393 _LIBUNWIND_EXPORT _Unwind_Reason_Code 394 _Unwind_RaiseException(_Unwind_Exception *exception_object) { 395 _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)", 396 (void *)exception_object); 397 398 // Mark that this is a non-forced unwind, so _Unwind_Resume() 399 // can do the right thing. 400 memset(exception_object->private_, 0, sizeof(exception_object->private_)); 401 402 // phase 1: the search phase 403 // We'll let the system do that for us. 404 RaiseException(STATUS_GCC_THROW, 0, 1, (ULONG_PTR *)&exception_object); 405 406 // If we get here, either something went horribly wrong or we reached the 407 // top of the stack. Either way, let libc++abi call std::terminate(). 408 return _URC_END_OF_STACK; 409 } 410 411 /// When \c _Unwind_RaiseException() is in phase2, it hands control 412 /// to the personality function at each frame. The personality 413 /// may force a jump to a landing pad in that function; the landing 414 /// pad code may then call \c _Unwind_Resume() to continue with the 415 /// unwinding. Note: the call to \c _Unwind_Resume() is from compiler 416 /// generated user code. All other \c _Unwind_* routines are called 417 /// by the C++ runtime \c __cxa_* routines. 418 /// 419 /// Note: re-throwing an exception (as opposed to continuing the unwind) 420 /// is implemented by having the code call \c __cxa_rethrow() which 421 /// in turn calls \c _Unwind_Resume_or_Rethrow(). 422 _LIBUNWIND_EXPORT void 423 _Unwind_Resume(_Unwind_Exception *exception_object) { 424 _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object); 425 426 if (exception_object->private_[0] != 0) { 427 unw_context_t uc; 428 429 __unw_getcontext(&uc); 430 unwind_phase2_forced(&uc, exception_object, 431 (_Unwind_Stop_Fn) exception_object->private_[0], 432 (void *)exception_object->private_[4]); 433 } else { 434 // Recover the parameters for the unwind from the exception object 435 // so we can start unwinding again. 436 EXCEPTION_RECORD ms_exc; 437 CONTEXT ms_ctx; 438 UNWIND_HISTORY_TABLE hist; 439 440 memset(&ms_exc, 0, sizeof(ms_exc)); 441 memset(&hist, 0, sizeof(hist)); 442 ms_exc.ExceptionCode = STATUS_GCC_THROW; 443 ms_exc.ExceptionFlags = EXCEPTION_NONCONTINUABLE; 444 ms_exc.NumberParameters = 4; 445 ms_exc.ExceptionInformation[0] = (ULONG_PTR)exception_object; 446 ms_exc.ExceptionInformation[1] = exception_object->private_[1]; 447 ms_exc.ExceptionInformation[2] = exception_object->private_[2]; 448 ms_exc.ExceptionInformation[3] = exception_object->private_[3]; 449 RtlUnwindEx((PVOID)exception_object->private_[1], 450 (PVOID)exception_object->private_[2], &ms_exc, 451 exception_object, &ms_ctx, &hist); 452 } 453 454 // Clients assume _Unwind_Resume() does not return, so all we can do is abort. 455 _LIBUNWIND_ABORT("_Unwind_Resume() can't return"); 456 } 457 458 /// Not used by C++. 459 /// Unwinds stack, calling "stop" function at each frame. 460 /// Could be used to implement \c longjmp(). 461 _LIBUNWIND_EXPORT _Unwind_Reason_Code 462 _Unwind_ForcedUnwind(_Unwind_Exception *exception_object, 463 _Unwind_Stop_Fn stop, void *stop_parameter) { 464 _LIBUNWIND_TRACE_API("_Unwind_ForcedUnwind(ex_obj=%p, stop=%p)", 465 (void *)exception_object, (void *)(uintptr_t)stop); 466 unw_context_t uc; 467 __unw_getcontext(&uc); 468 469 // Mark that this is a forced unwind, so _Unwind_Resume() can do 470 // the right thing. 471 exception_object->private_[0] = (uintptr_t) stop; 472 exception_object->private_[4] = (uintptr_t) stop_parameter; 473 474 // do it 475 return unwind_phase2_forced(&uc, exception_object, stop, stop_parameter); 476 } 477 478 /// Called by personality handler during phase 2 to get LSDA for current frame. 479 _LIBUNWIND_EXPORT uintptr_t 480 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) { 481 uintptr_t result = 482 (uintptr_t)__unw_seh_get_disp_ctx((unw_cursor_t *)context)->HandlerData; 483 _LIBUNWIND_TRACE_API( 484 "_Unwind_GetLanguageSpecificData(context=%p) => 0x%" PRIxPTR, 485 (void *)context, result); 486 return result; 487 } 488 489 /// Called by personality handler during phase 2 to find the start of the 490 /// function. 491 _LIBUNWIND_EXPORT uintptr_t 492 _Unwind_GetRegionStart(struct _Unwind_Context *context) { 493 DISPATCHER_CONTEXT *disp = __unw_seh_get_disp_ctx((unw_cursor_t *)context); 494 uintptr_t result = (uintptr_t)disp->FunctionEntry->BeginAddress + disp->ImageBase; 495 _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%" PRIxPTR, 496 (void *)context, result); 497 return result; 498 } 499 500 static int __unw_init_seh(unw_cursor_t *cursor, CONTEXT *context) { 501 #ifdef _LIBUNWIND_TARGET_X86_64 502 new (reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)) 503 UnwindCursor<LocalAddressSpace, Registers_x86_64>( 504 context, LocalAddressSpace::sThisAddressSpace); 505 auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor); 506 co->setInfoBasedOnIPRegister(); 507 return UNW_ESUCCESS; 508 #elif defined(_LIBUNWIND_TARGET_ARM) 509 new (reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)) 510 UnwindCursor<LocalAddressSpace, Registers_arm>( 511 context, LocalAddressSpace::sThisAddressSpace); 512 auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor); 513 co->setInfoBasedOnIPRegister(); 514 return UNW_ESUCCESS; 515 #elif defined(_LIBUNWIND_TARGET_AARCH64) 516 new (reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm64> *>(cursor)) 517 UnwindCursor<LocalAddressSpace, Registers_arm64>( 518 context, LocalAddressSpace::sThisAddressSpace); 519 auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor); 520 co->setInfoBasedOnIPRegister(); 521 return UNW_ESUCCESS; 522 #else 523 return UNW_EINVAL; 524 #endif 525 } 526 527 static DISPATCHER_CONTEXT *__unw_seh_get_disp_ctx(unw_cursor_t *cursor) { 528 #ifdef _LIBUNWIND_TARGET_X86_64 529 return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)->getDispatcherContext(); 530 #elif defined(_LIBUNWIND_TARGET_ARM) 531 return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)->getDispatcherContext(); 532 #elif defined(_LIBUNWIND_TARGET_AARCH64) 533 return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm64> *>(cursor)->getDispatcherContext(); 534 #else 535 return nullptr; 536 #endif 537 } 538 539 static void __unw_seh_set_disp_ctx(unw_cursor_t *cursor, 540 DISPATCHER_CONTEXT *disp) { 541 #ifdef _LIBUNWIND_TARGET_X86_64 542 reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)->setDispatcherContext(disp); 543 #elif defined(_LIBUNWIND_TARGET_ARM) 544 reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)->setDispatcherContext(disp); 545 #elif defined(_LIBUNWIND_TARGET_AARCH64) 546 reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm64> *>(cursor)->setDispatcherContext(disp); 547 #endif 548 } 549 550 #endif // defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) 551