551 lines · cpp
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-exception6//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 31using 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 calls43/// \c _Unwind_RaiseException.44#define STATUS_GCC_THROW MAKE_GCC_EXCEPTION(0) // 0x2047434345/// SEH exception raised by libunwind to initiate phase 2 of exception46/// handling.47#define STATUS_GCC_UNWIND MAKE_GCC_EXCEPTION(1) // 0x2147434348 49static int __unw_init_seh(unw_cursor_t *cursor, CONTEXT *ctx);50static DISPATCHER_CONTEXT *__unw_seh_get_disp_ctx(unw_cursor_t *cursor);51static void __unw_seh_set_disp_ctx(unw_cursor_t *cursor,52 DISPATCHER_CONTEXT *disp);53 54#pragma clang diagnostic push55#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"56// Local redefinition of this type; mingw-w64 headers lack the57// DISPATCHER_CONTEXT_NONVOLREG_ARM64 type as of May 2025, so locally redefine58// it and use that definition, to avoid needing to test/guess whether the real59// type is available of not.60union 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.70union 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 pop79 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; or83/// b) Initiate a collided unwind to halt unwinding.84_LIBUNWIND_EXPORT EXCEPTION_DISPOSITION85_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 PC101 // 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#endif109 }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 the116 // 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 frame126 // that we should pass on to RtlUnwindEx in _Unwind_Resume), so just127 // 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 else140 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 else145 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 continue158 // 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 that164 // 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 phase177 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 that182 // a handler was found; otherwise, it's time to initiate a collided183 // 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#endif202 __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#endif209 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 the212 // 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 in224/// turn (at least, for Itanium-style frames) calls the real Itanium225/// personality function (see \c _GCC_specific_handler()).226extern "C" _Unwind_Reason_Code227__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#endif257 _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 279static _Unwind_Reason_Code280unwind_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 stop287 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 NDEBUG299 // 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%" PRIxPTR310 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,311 (void *)exception_object, frameInfo.start_ip, functionName,312 frameInfo.lsda, frameInfo.handler);313 }314#endif315 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 unwinding349 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 end378 // 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 it388 // 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_Code394_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 phase403 // 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 the407 // 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 control412/// to the personality function at each frame. The personality413/// may force a jump to a landing pad in that function; the landing414/// pad code may then call \c _Unwind_Resume() to continue with the415/// unwinding. Note: the call to \c _Unwind_Resume() is from compiler416/// generated user code. All other \c _Unwind_* routines are called417/// 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() which421/// in turn calls \c _Unwind_Resume_or_Rethrow().422_LIBUNWIND_EXPORT void423_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 object435 // 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_Code462_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 do470 // the right thing.471 exception_object->private_[0] = (uintptr_t) stop;472 exception_object->private_[4] = (uintptr_t) stop_parameter;473 474 // do it475 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_t480_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 the490/// function.491_LIBUNWIND_EXPORT uintptr_t492_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 500static int __unw_init_seh(unw_cursor_t *cursor, CONTEXT *context) {501#ifdef _LIBUNWIND_TARGET_X86_64502 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#else523 return UNW_EINVAL;524#endif525}526 527static DISPATCHER_CONTEXT *__unw_seh_get_disp_ctx(unw_cursor_t *cursor) {528#ifdef _LIBUNWIND_TARGET_X86_64529 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#else535 return nullptr;536#endif537}538 539static void __unw_seh_set_disp_ctx(unw_cursor_t *cursor,540 DISPATCHER_CONTEXT *disp) {541#ifdef _LIBUNWIND_TARGET_X86_64542 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#endif548}549 550#endif // defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)551