contrib/libunwind/src/Unwind-seh.cpp

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