llvm-project

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
/// Common implementation of SEH-style handler functions used by Itanium-
55
/// style frames.  Depending on how and why it was called, it may do one of:
56
///  a) Delegate to the given Itanium-style personality function; or
57
///  b) Initiate a collided unwind to halt unwinding.
58
_LIBUNWIND_EXPORT EXCEPTION_DISPOSITION
59
_GCC_specific_handler(PEXCEPTION_RECORD ms_exc, PVOID frame, PCONTEXT ms_ctx,
60
                      DISPATCHER_CONTEXT *disp, _Unwind_Personality_Fn pers) {
61
  unw_cursor_t cursor;
62
  _Unwind_Exception *exc;
63
  _Unwind_Action action;
64
  struct _Unwind_Context *ctx = nullptr;
65
  _Unwind_Reason_Code urc;
66
  uintptr_t retval, target;
67
  bool ours = false;
68

69
  _LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler(%#010lx(%lx), %p)",
70
                             ms_exc->ExceptionCode, ms_exc->ExceptionFlags,
71
                             (void *)frame);
72
  if (ms_exc->ExceptionCode == STATUS_GCC_UNWIND) {
73
    if (IS_TARGET_UNWIND(ms_exc->ExceptionFlags)) {
74
      // Set up the upper return value (the lower one and the target PC
75
      // were set in the call to RtlUnwindEx()) for the landing pad.
76
#ifdef __x86_64__
77
      disp->ContextRecord->Rdx = ms_exc->ExceptionInformation[3];
78
#elif defined(__arm__)
79
      disp->ContextRecord->R1 = ms_exc->ExceptionInformation[3];
80
#elif defined(__aarch64__)
81
      disp->ContextRecord->X1 = ms_exc->ExceptionInformation[3];
82
#endif
83
    }
84
    // This is the collided unwind to the landing pad. Nothing to do.
85
    return ExceptionContinueSearch;
86
  }
87

88
  if (ms_exc->ExceptionCode == STATUS_GCC_THROW) {
89
    // This is (probably) a libunwind-controlled exception/unwind. Recover the
90
    // parameters which we set below, and pass them to the personality function.
91
    ours = true;
92
    exc = (_Unwind_Exception *)ms_exc->ExceptionInformation[0];
93
    if (!IS_UNWINDING(ms_exc->ExceptionFlags) && ms_exc->NumberParameters > 1) {
94
      ctx = (struct _Unwind_Context *)ms_exc->ExceptionInformation[1];
95
      action = (_Unwind_Action)ms_exc->ExceptionInformation[2];
96
    }
97
  } else {
98
    // Foreign exception.
99
    // We can't interact with them (we don't know the original target frame
100
    // that we should pass on to RtlUnwindEx in _Unwind_Resume), so just
101
    // pass without calling our destructors here.
102
    return ExceptionContinueSearch;
103
  }
104
  if (!ctx) {
105
    __unw_init_seh(&cursor, disp->ContextRecord);
106
    __unw_seh_set_disp_ctx(&cursor, disp);
107
    __unw_set_reg(&cursor, UNW_REG_IP, disp->ControlPc);
108
    ctx = (struct _Unwind_Context *)&cursor;
109

110
    if (!IS_UNWINDING(ms_exc->ExceptionFlags)) {
111
      if (ours && ms_exc->NumberParameters > 1)
112
        action =  (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_FORCE_UNWIND);
113
      else
114
        action = _UA_SEARCH_PHASE;
115
    } else {
116
      if (ours && ms_exc->ExceptionInformation[1] == (ULONG_PTR)frame)
117
        action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME);
118
      else
119
        action = _UA_CLEANUP_PHASE;
120
    }
121
  }
122

123
  _LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler() calling personality "
124
                             "function %p(1, %d, %llx, %p, %p)",
125
                             (void *)pers, action, exc->exception_class,
126
                             (void *)exc, (void *)ctx);
127
  urc = pers(1, action, exc->exception_class, exc, ctx);
128
  _LIBUNWIND_TRACE_UNWINDING("_GCC_specific_handler() personality returned %d", urc);
129
  switch (urc) {
130
  case _URC_CONTINUE_UNWIND:
131
    // If we're in phase 2, and the personality routine said to continue
132
    // at the target frame, we're in real trouble.
133
    if (action & _UA_HANDLER_FRAME)
134
      _LIBUNWIND_ABORT("Personality continued unwind at the target frame!");
135
    return ExceptionContinueSearch;
136
  case _URC_HANDLER_FOUND:
137
    // If we were called by __libunwind_seh_personality(), indicate that
138
    // a handler was found; otherwise, initiate phase 2 by unwinding.
139
    if (ours && ms_exc->NumberParameters > 1)
140
      return 4 /* ExceptionExecuteHandler in mingw */;
141
    // This should never happen in phase 2.
142
    if (IS_UNWINDING(ms_exc->ExceptionFlags))
143
      _LIBUNWIND_ABORT("Personality indicated exception handler in phase 2!");
144
    exc->private_[1] = (ULONG_PTR)frame;
145
    if (ours) {
146
      ms_exc->NumberParameters = 4;
147
      ms_exc->ExceptionInformation[1] = (ULONG_PTR)frame;
148
    }
149
    // FIXME: Indicate target frame in foreign case!
150
    // phase 2: the clean up phase
151
    RtlUnwindEx(frame, (PVOID)disp->ControlPc, ms_exc, exc, ms_ctx, disp->HistoryTable);
152
    _LIBUNWIND_ABORT("RtlUnwindEx() failed");
153
  case _URC_INSTALL_CONTEXT: {
154
    // If we were called by __libunwind_seh_personality(), indicate that
155
    // a handler was found; otherwise, it's time to initiate a collided
156
    // unwind to the target.
157
    if (ours && !IS_UNWINDING(ms_exc->ExceptionFlags) && ms_exc->NumberParameters > 1)
158
      return 4 /* ExceptionExecuteHandler in mingw */;
159
    // This should never happen in phase 1.
160
    if (!IS_UNWINDING(ms_exc->ExceptionFlags))
161
      _LIBUNWIND_ABORT("Personality installed context during phase 1!");
162
#ifdef __x86_64__
163
    exc->private_[2] = disp->TargetIp;
164
    __unw_get_reg(&cursor, UNW_X86_64_RAX, &retval);
165
    __unw_get_reg(&cursor, UNW_X86_64_RDX, &exc->private_[3]);
166
#elif defined(__arm__)
167
    exc->private_[2] = disp->TargetPc;
168
    __unw_get_reg(&cursor, UNW_ARM_R0, &retval);
169
    __unw_get_reg(&cursor, UNW_ARM_R1, &exc->private_[3]);
170
#elif defined(__aarch64__)
171
    exc->private_[2] = disp->TargetPc;
172
    __unw_get_reg(&cursor, UNW_AARCH64_X0, &retval);
173
    __unw_get_reg(&cursor, UNW_AARCH64_X1, &exc->private_[3]);
174
#endif
175
    __unw_get_reg(&cursor, UNW_REG_IP, &target);
176
    ms_exc->ExceptionCode = STATUS_GCC_UNWIND;
177
#ifdef __x86_64__
178
    ms_exc->ExceptionInformation[2] = disp->TargetIp;
179
#elif defined(__arm__) || defined(__aarch64__)
180
    ms_exc->ExceptionInformation[2] = disp->TargetPc;
181
#endif
182
    ms_exc->ExceptionInformation[3] = exc->private_[3];
183
    // Give NTRTL some scratch space to keep track of the collided unwind.
184
    // Don't use the one that was passed in; we don't want to overwrite the
185
    // context in the DISPATCHER_CONTEXT.
186
    CONTEXT new_ctx;
187
    RtlUnwindEx(frame, (PVOID)target, ms_exc, (PVOID)retval, &new_ctx, disp->HistoryTable);
188
    _LIBUNWIND_ABORT("RtlUnwindEx() failed");
189
  }
190
  // Anything else indicates a serious problem.
191
  default: return ExceptionContinueExecution;
192
  }
193
}
194

195
/// Personality function returned by \c __unw_get_proc_info() in SEH contexts.
196
/// This is a wrapper that calls the real SEH handler function, which in
197
/// turn (at least, for Itanium-style frames) calls the real Itanium
198
/// personality function (see \c _GCC_specific_handler()).
199
extern "C" _Unwind_Reason_Code
200
__libunwind_seh_personality(int version, _Unwind_Action state,
201
                            uint64_t klass, _Unwind_Exception *exc,
202
                            struct _Unwind_Context *context) {
203
  (void)version;
204
  (void)klass;
205
  EXCEPTION_RECORD ms_exc;
206
  bool phase2 = (state & (_UA_SEARCH_PHASE|_UA_CLEANUP_PHASE)) == _UA_CLEANUP_PHASE;
207
  ms_exc.ExceptionCode = STATUS_GCC_THROW;
208
  ms_exc.ExceptionFlags = 0;
209
  ms_exc.NumberParameters = 3;
210
  ms_exc.ExceptionInformation[0] = (ULONG_PTR)exc;
211
  ms_exc.ExceptionInformation[1] = (ULONG_PTR)context;
212
  ms_exc.ExceptionInformation[2] = state;
213
  DISPATCHER_CONTEXT *disp_ctx =
214
      __unw_seh_get_disp_ctx((unw_cursor_t *)context);
215
  _LIBUNWIND_TRACE_UNWINDING("__libunwind_seh_personality() calling "
216
                             "LanguageHandler %p(%p, %p, %p, %p)",
217
                             (void *)disp_ctx->LanguageHandler, (void *)&ms_exc,
218
                             (void *)disp_ctx->EstablisherFrame,
219
                             (void *)disp_ctx->ContextRecord, (void *)disp_ctx);
220
  EXCEPTION_DISPOSITION ms_act = disp_ctx->LanguageHandler(&ms_exc,
221
                                                           (PVOID)disp_ctx->EstablisherFrame,
222
                                                           disp_ctx->ContextRecord,
223
                                                           disp_ctx);
224
  _LIBUNWIND_TRACE_UNWINDING("__libunwind_seh_personality() LanguageHandler "
225
                             "returned %d",
226
                             (int)ms_act);
227
  switch (ms_act) {
228
  case ExceptionContinueExecution: return _URC_END_OF_STACK;
229
  case ExceptionContinueSearch: return _URC_CONTINUE_UNWIND;
230
  case 4 /*ExceptionExecuteHandler*/:
231
    return phase2 ? _URC_INSTALL_CONTEXT : _URC_HANDLER_FOUND;
232
  default:
233
    return phase2 ? _URC_FATAL_PHASE2_ERROR : _URC_FATAL_PHASE1_ERROR;
234
  }
235
}
236

237
static _Unwind_Reason_Code
238
unwind_phase2_forced(unw_context_t *uc,
239
                     _Unwind_Exception *exception_object,
240
                     _Unwind_Stop_Fn stop, void *stop_parameter) {
241
  unw_cursor_t cursor2;
242
  __unw_init_local(&cursor2, uc);
243

244
  // Walk each frame until we reach where search phase said to stop
245
  while (__unw_step(&cursor2) > 0) {
246

247
    // Update info about this frame.
248
    unw_proc_info_t frameInfo;
249
    if (__unw_get_proc_info(&cursor2, &frameInfo) != UNW_ESUCCESS) {
250
      _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): __unw_get_proc_info "
251
                                 "failed => _URC_END_OF_STACK",
252
                                 (void *)exception_object);
253
      return _URC_FATAL_PHASE2_ERROR;
254
    }
255

256
#ifndef NDEBUG
257
    // When tracing, print state information.
258
    if (_LIBUNWIND_TRACING_UNWINDING) {
259
      char functionBuf[512];
260
      const char *functionName = functionBuf;
261
      unw_word_t offset;
262
      if ((__unw_get_proc_name(&cursor2, functionBuf, sizeof(functionBuf),
263
                               &offset) != UNW_ESUCCESS) ||
264
          (frameInfo.start_ip + offset > frameInfo.end_ip))
265
        functionName = ".anonymous.";
266
      _LIBUNWIND_TRACE_UNWINDING(
267
          "unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIxPTR
268
          ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
269
          (void *)exception_object, frameInfo.start_ip, functionName,
270
          frameInfo.lsda, frameInfo.handler);
271
    }
272
#endif
273

274
    // Call stop function at each frame.
275
    _Unwind_Action action =
276
        (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE);
277
    _Unwind_Reason_Code stopResult =
278
        (*stop)(1, action, exception_object->exception_class, exception_object,
279
                (struct _Unwind_Context *)(&cursor2), stop_parameter);
280
    _LIBUNWIND_TRACE_UNWINDING(
281
        "unwind_phase2_forced(ex_ojb=%p): stop function returned %d",
282
        (void *)exception_object, stopResult);
283
    if (stopResult != _URC_NO_REASON) {
284
      _LIBUNWIND_TRACE_UNWINDING(
285
          "unwind_phase2_forced(ex_ojb=%p): stopped by stop function",
286
          (void *)exception_object);
287
      return _URC_FATAL_PHASE2_ERROR;
288
    }
289

290
    // If there is a personality routine, tell it we are unwinding.
291
    if (frameInfo.handler != 0) {
292
      _Unwind_Personality_Fn p =
293
          (_Unwind_Personality_Fn)(intptr_t)(frameInfo.handler);
294
      _LIBUNWIND_TRACE_UNWINDING(
295
          "unwind_phase2_forced(ex_ojb=%p): calling personality function %p",
296
          (void *)exception_object, (void *)(uintptr_t)p);
297
      _Unwind_Reason_Code personalityResult =
298
          (*p)(1, action, exception_object->exception_class, exception_object,
299
               (struct _Unwind_Context *)(&cursor2));
300
      switch (personalityResult) {
301
      case _URC_CONTINUE_UNWIND:
302
        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
303
                                   "personality returned "
304
                                   "_URC_CONTINUE_UNWIND",
305
                                   (void *)exception_object);
306
        // Destructors called, continue unwinding
307
        break;
308
      case _URC_INSTALL_CONTEXT:
309
        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
310
                                   "personality returned "
311
                                   "_URC_INSTALL_CONTEXT",
312
                                   (void *)exception_object);
313
        // We may get control back if landing pad calls _Unwind_Resume().
314
        __unw_resume(&cursor2);
315
        break;
316
      case _URC_END_OF_STACK:
317
        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
318
                                   "personality returned "
319
                                   "_URC_END_OF_STACK",
320
                                   (void *)exception_object);
321
        break;
322
      default:
323
        // Personality routine returned an unknown result code.
324
        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
325
                                   "personality returned %d, "
326
                                   "_URC_FATAL_PHASE2_ERROR",
327
                                   (void *)exception_object, personalityResult);
328
        return _URC_FATAL_PHASE2_ERROR;
329
      }
330
      if (personalityResult == _URC_END_OF_STACK)
331
        break;
332
    }
333
  }
334

335
  // Call stop function one last time and tell it we've reached the end
336
  // of the stack.
337
  _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop "
338
                             "function with _UA_END_OF_STACK",
339
                             (void *)exception_object);
340
  _Unwind_Action lastAction =
341
      (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK);
342
  (*stop)(1, lastAction, exception_object->exception_class, exception_object,
343
          (struct _Unwind_Context *)(&cursor2), stop_parameter);
344

345
  // Clean up phase did not resume at the frame that the search phase said it
346
  // would.
347
  return _URC_FATAL_PHASE2_ERROR;
348
}
349

350
/// Called by \c __cxa_throw().  Only returns if there is a fatal error.
351
_LIBUNWIND_EXPORT _Unwind_Reason_Code
352
_Unwind_RaiseException(_Unwind_Exception *exception_object) {
353
  _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)",
354
                       (void *)exception_object);
355

356
  // Mark that this is a non-forced unwind, so _Unwind_Resume()
357
  // can do the right thing.
358
  memset(exception_object->private_, 0, sizeof(exception_object->private_));
359

360
  // phase 1: the search phase
361
  // We'll let the system do that for us.
362
  RaiseException(STATUS_GCC_THROW, 0, 1, (ULONG_PTR *)&exception_object);
363

364
  // If we get here, either something went horribly wrong or we reached the
365
  // top of the stack. Either way, let libc++abi call std::terminate().
366
  return _URC_END_OF_STACK;
367
}
368

369
/// When \c _Unwind_RaiseException() is in phase2, it hands control
370
/// to the personality function at each frame.  The personality
371
/// may force a jump to a landing pad in that function; the landing
372
/// pad code may then call \c _Unwind_Resume() to continue with the
373
/// unwinding.  Note: the call to \c _Unwind_Resume() is from compiler
374
/// generated user code.  All other \c _Unwind_* routines are called
375
/// by the C++ runtime \c __cxa_* routines.
376
///
377
/// Note: re-throwing an exception (as opposed to continuing the unwind)
378
/// is implemented by having the code call \c __cxa_rethrow() which
379
/// in turn calls \c _Unwind_Resume_or_Rethrow().
380
_LIBUNWIND_EXPORT void
381
_Unwind_Resume(_Unwind_Exception *exception_object) {
382
  _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object);
383

384
  if (exception_object->private_[0] != 0) {
385
    unw_context_t uc;
386

387
    __unw_getcontext(&uc);
388
    unwind_phase2_forced(&uc, exception_object,
389
                         (_Unwind_Stop_Fn) exception_object->private_[0],
390
                         (void *)exception_object->private_[4]);
391
  } else {
392
    // Recover the parameters for the unwind from the exception object
393
    // so we can start unwinding again.
394
    EXCEPTION_RECORD ms_exc;
395
    CONTEXT ms_ctx;
396
    UNWIND_HISTORY_TABLE hist;
397

398
    memset(&ms_exc, 0, sizeof(ms_exc));
399
    memset(&hist, 0, sizeof(hist));
400
    ms_exc.ExceptionCode = STATUS_GCC_THROW;
401
    ms_exc.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
402
    ms_exc.NumberParameters = 4;
403
    ms_exc.ExceptionInformation[0] = (ULONG_PTR)exception_object;
404
    ms_exc.ExceptionInformation[1] = exception_object->private_[1];
405
    ms_exc.ExceptionInformation[2] = exception_object->private_[2];
406
    ms_exc.ExceptionInformation[3] = exception_object->private_[3];
407
    RtlUnwindEx((PVOID)exception_object->private_[1],
408
                (PVOID)exception_object->private_[2], &ms_exc,
409
                exception_object, &ms_ctx, &hist);
410
  }
411

412
  // Clients assume _Unwind_Resume() does not return, so all we can do is abort.
413
  _LIBUNWIND_ABORT("_Unwind_Resume() can't return");
414
}
415

416
/// Not used by C++.
417
/// Unwinds stack, calling "stop" function at each frame.
418
/// Could be used to implement \c longjmp().
419
_LIBUNWIND_EXPORT _Unwind_Reason_Code
420
_Unwind_ForcedUnwind(_Unwind_Exception *exception_object,
421
                     _Unwind_Stop_Fn stop, void *stop_parameter) {
422
  _LIBUNWIND_TRACE_API("_Unwind_ForcedUnwind(ex_obj=%p, stop=%p)",
423
                       (void *)exception_object, (void *)(uintptr_t)stop);
424
  unw_context_t uc;
425
  __unw_getcontext(&uc);
426

427
  // Mark that this is a forced unwind, so _Unwind_Resume() can do
428
  // the right thing.
429
  exception_object->private_[0] = (uintptr_t) stop;
430
  exception_object->private_[4] = (uintptr_t) stop_parameter;
431

432
  // do it
433
  return unwind_phase2_forced(&uc, exception_object, stop, stop_parameter);
434
}
435

436
/// Called by personality handler during phase 2 to get LSDA for current frame.
437
_LIBUNWIND_EXPORT uintptr_t
438
_Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
439
  uintptr_t result =
440
      (uintptr_t)__unw_seh_get_disp_ctx((unw_cursor_t *)context)->HandlerData;
441
  _LIBUNWIND_TRACE_API(
442
      "_Unwind_GetLanguageSpecificData(context=%p) => 0x%" PRIxPTR,
443
      (void *)context, result);
444
  return result;
445
}
446

447
/// Called by personality handler during phase 2 to find the start of the
448
/// function.
449
_LIBUNWIND_EXPORT uintptr_t
450
_Unwind_GetRegionStart(struct _Unwind_Context *context) {
451
  DISPATCHER_CONTEXT *disp = __unw_seh_get_disp_ctx((unw_cursor_t *)context);
452
  uintptr_t result = (uintptr_t)disp->FunctionEntry->BeginAddress + disp->ImageBase;
453
  _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%" PRIxPTR,
454
                       (void *)context, result);
455
  return result;
456
}
457

458
static int __unw_init_seh(unw_cursor_t *cursor, CONTEXT *context) {
459
#ifdef _LIBUNWIND_TARGET_X86_64
460
  new (reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor))
461
      UnwindCursor<LocalAddressSpace, Registers_x86_64>(
462
          context, LocalAddressSpace::sThisAddressSpace);
463
  auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
464
  co->setInfoBasedOnIPRegister();
465
  return UNW_ESUCCESS;
466
#elif defined(_LIBUNWIND_TARGET_ARM)
467
  new (reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor))
468
      UnwindCursor<LocalAddressSpace, Registers_arm>(
469
          context, LocalAddressSpace::sThisAddressSpace);
470
  auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
471
  co->setInfoBasedOnIPRegister();
472
  return UNW_ESUCCESS;
473
#elif defined(_LIBUNWIND_TARGET_AARCH64)
474
  new (reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm64> *>(cursor))
475
      UnwindCursor<LocalAddressSpace, Registers_arm64>(
476
          context, LocalAddressSpace::sThisAddressSpace);
477
  auto *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
478
  co->setInfoBasedOnIPRegister();
479
  return UNW_ESUCCESS;
480
#else
481
  return UNW_EINVAL;
482
#endif
483
}
484

485
static DISPATCHER_CONTEXT *__unw_seh_get_disp_ctx(unw_cursor_t *cursor) {
486
#ifdef _LIBUNWIND_TARGET_X86_64
487
  return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)->getDispatcherContext();
488
#elif defined(_LIBUNWIND_TARGET_ARM)
489
  return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)->getDispatcherContext();
490
#elif defined(_LIBUNWIND_TARGET_AARCH64)
491
  return reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm64> *>(cursor)->getDispatcherContext();
492
#else
493
  return nullptr;
494
#endif
495
}
496

497
static void __unw_seh_set_disp_ctx(unw_cursor_t *cursor,
498
                                   DISPATCHER_CONTEXT *disp) {
499
#ifdef _LIBUNWIND_TARGET_X86_64
500
  reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_x86_64> *>(cursor)->setDispatcherContext(disp);
501
#elif defined(_LIBUNWIND_TARGET_ARM)
502
  reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm> *>(cursor)->setDispatcherContext(disp);
503
#elif defined(_LIBUNWIND_TARGET_AARCH64)
504
  reinterpret_cast<UnwindCursor<LocalAddressSpace, Registers_arm64> *>(cursor)->setDispatcherContext(disp);
505
#endif
506
}
507

508
#endif // defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
509