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) |
502 | |