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
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 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.
50static const uint64_t kSEHExceptionClass = 0x434C4E4753454800; // CLNGSEH\0
51
52/// Exception cleanup routine used by \c _GCC_specific_handler to
53/// free foreign exceptions.
54static 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
61static int __unw_init_seh(unw_cursor_t *cursor, CONTEXT *ctx);
62static DISPATCHER_CONTEXT *__unw_seh_get_disp_ctx(unw_cursor_t *cursor);
63static 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()).
211extern "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
240static _Unwind_Reason_Code
241unwind_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
451static 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
478static 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
490static 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)
502