|
236
|
1 //===----------------------------------------------------------------------===//
|
|
150
|
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.
|
|
221
|
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;
|
|
150
|
103 }
|
|
|
104 if (!ctx) {
|
|
|
105 __unw_init_seh(&cursor, disp->ContextRecord);
|
|
|
106 __unw_seh_set_disp_ctx(&cursor, disp);
|
|
236
|
107 __unw_set_reg(&cursor, UNW_REG_IP, disp->ControlPc);
|
|
150
|
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)
|
|
236
|
140 return 4 /* ExceptionExecuteHandler in mingw */;
|
|
150
|
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)
|
|
236
|
158 return 4 /* ExceptionExecuteHandler in mingw */;
|
|
150
|
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;
|
|
236
|
172 __unw_get_reg(&cursor, UNW_AARCH64_X0, &retval);
|
|
|
173 __unw_get_reg(&cursor, UNW_AARCH64_X1, &exc->private_[3]);
|
|
150
|
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);
|
|
252
|
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);
|
|
150
|
220 EXCEPTION_DISPOSITION ms_act = disp_ctx->LanguageHandler(&ms_exc,
|
|
|
221 (PVOID)disp_ctx->EstablisherFrame,
|
|
|
222 disp_ctx->ContextRecord,
|
|
|
223 disp_ctx);
|
|
252
|
224 _LIBUNWIND_TRACE_UNWINDING("__libunwind_seh_personality() LanguageHandler "
|
|
|
225 "returned %d",
|
|
|
226 (int)ms_act);
|
|
150
|
227 switch (ms_act) {
|
|
252
|
228 case ExceptionContinueExecution: return _URC_END_OF_STACK;
|
|
150
|
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) {
|
|
252
|
250 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): __unw_get_proc_info "
|
|
150
|
251 "failed => _URC_END_OF_STACK",
|
|
|
252 (void *)exception_object);
|
|
|
253 return _URC_FATAL_PHASE2_ERROR;
|
|
|
254 }
|
|
|
255
|
|
236
|
256 #ifndef NDEBUG
|
|
150
|
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(
|
|
236
|
267 "unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIxPTR
|
|
|
268 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
|
|
150
|
269 (void *)exception_object, frameInfo.start_ip, functionName,
|
|
|
270 frameInfo.lsda, frameInfo.handler);
|
|
|
271 }
|
|
236
|
272 #endif
|
|
150
|
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;
|
|
252
|
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;
|
|
150
|
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 }
|
|
252
|
330 if (personalityResult == _URC_END_OF_STACK)
|
|
|
331 break;
|
|
150
|
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
|
|
236
|
374 /// generated user code. All other \c _Unwind_* routines are called
|
|
150
|
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)
|
