1 //===------------------------- UnwindLevel1.c -----------------------------===//
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 // Implements C++ ABI Exception Handling Level 1 as documented at:
9 // https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html
10 // using libunwind
11 //
12 //===----------------------------------------------------------------------===//
13
14 // ARM EHABI does not specify _Unwind_{Get,Set}{GR,IP}(). Thus, we are
15 // defining inline functions to delegate the function calls to
16 // _Unwind_VRS_{Get,Set}(). However, some applications might declare the
17 // function protetype directly (instead of including <unwind.h>), thus we need
18 // to export these functions from libunwind.so as well.
19 #define _LIBUNWIND_UNWIND_LEVEL1_EXTERNAL_LINKAGE 1
20
21 #include <inttypes.h>
22 #include <stdint.h>
23 #include <stdbool.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27
28 #include "config.h"
29 #include "libunwind.h"
30 #include "libunwind_ext.h"
31 #include "unwind.h"
32
33 #if !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__)
34
35 #ifndef _LIBUNWIND_SUPPORT_SEH_UNWIND
36
37 static _Unwind_Reason_Code
unwind_phase1(unw_context_t * uc,unw_cursor_t * cursor,_Unwind_Exception * exception_object)38 unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
39 __unw_init_local(cursor, uc);
40
41 // Walk each frame looking for a place to stop.
42 while (true) {
43 // Ask libunwind to get next frame (skip over first which is
44 // _Unwind_RaiseException).
45 int stepResult = __unw_step(cursor);
46 if (stepResult == 0) {
47 _LIBUNWIND_TRACE_UNWINDING(
48 "unwind_phase1(ex_ojb=%p): __unw_step() reached "
49 "bottom => _URC_END_OF_STACK",
50 (void *)exception_object);
51 return _URC_END_OF_STACK;
52 } else if (stepResult < 0) {
53 _LIBUNWIND_TRACE_UNWINDING(
54 "unwind_phase1(ex_ojb=%p): __unw_step failed => "
55 "_URC_FATAL_PHASE1_ERROR",
56 (void *)exception_object);
57 return _URC_FATAL_PHASE1_ERROR;
58 }
59
60 // See if frame has code to run (has personality routine).
61 unw_proc_info_t frameInfo;
62 unw_word_t sp;
63 if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
64 _LIBUNWIND_TRACE_UNWINDING(
65 "unwind_phase1(ex_ojb=%p): __unw_get_proc_info "
66 "failed => _URC_FATAL_PHASE1_ERROR",
67 (void *)exception_object);
68 return _URC_FATAL_PHASE1_ERROR;
69 }
70
71 // When tracing, print state information.
72 if (_LIBUNWIND_TRACING_UNWINDING) {
73 char functionBuf[512];
74 const char *functionName = functionBuf;
75 unw_word_t offset;
76 if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
77 &offset) != UNW_ESUCCESS) ||
78 (frameInfo.start_ip + offset > frameInfo.end_ip))
79 functionName = ".anonymous.";
80 unw_word_t pc;
81 __unw_get_reg(cursor, UNW_REG_IP, &pc);
82 _LIBUNWIND_TRACE_UNWINDING(
83 "unwind_phase1(ex_ojb=%p): pc=0x%" PRIxPTR ", start_ip=0x%" PRIxPTR
84 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR "",
85 (void *)exception_object, pc, frameInfo.start_ip, functionName,
86 frameInfo.lsda, frameInfo.handler);
87 }
88
89 // If there is a personality routine, ask it if it will want to stop at
90 // this frame.
91 if (frameInfo.handler != 0) {
92 _Unwind_Personality_Fn p =
93 (_Unwind_Personality_Fn)(uintptr_t)(frameInfo.handler);
94 _LIBUNWIND_TRACE_UNWINDING(
95 "unwind_phase1(ex_ojb=%p): calling personality function %p",
96 (void *)exception_object, (void *)(uintptr_t)p);
97 _Unwind_Reason_Code personalityResult =
98 (*p)(1, _UA_SEARCH_PHASE, exception_object->exception_class,
99 exception_object, (struct _Unwind_Context *)(cursor));
100 switch (personalityResult) {
101 case _URC_HANDLER_FOUND:
102 // found a catch clause or locals that need destructing in this frame
103 // stop search and remember stack pointer at the frame
104 __unw_get_reg(cursor, UNW_REG_SP, &sp);
105 exception_object->private_2 = (uintptr_t)sp;
106 _LIBUNWIND_TRACE_UNWINDING(
107 "unwind_phase1(ex_ojb=%p): _URC_HANDLER_FOUND",
108 (void *)exception_object);
109 return _URC_NO_REASON;
110
111 case _URC_CONTINUE_UNWIND:
112 _LIBUNWIND_TRACE_UNWINDING(
113 "unwind_phase1(ex_ojb=%p): _URC_CONTINUE_UNWIND",
114 (void *)exception_object);
115 // continue unwinding
116 break;
117
118 default:
119 // something went wrong
120 _LIBUNWIND_TRACE_UNWINDING(
121 "unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR",
122 (void *)exception_object);
123 return _URC_FATAL_PHASE1_ERROR;
124 }
125 }
126 }
127 return _URC_NO_REASON;
128 }
129
130
131 static _Unwind_Reason_Code
unwind_phase2(unw_context_t * uc,unw_cursor_t * cursor,_Unwind_Exception * exception_object)132 unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
133 __unw_init_local(cursor, uc);
134
135 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)",
136 (void *)exception_object);
137
138 // Walk each frame until we reach where search phase said to stop.
139 while (true) {
140
141 // Ask libunwind to get next frame (skip over first which is
142 // _Unwind_RaiseException).
143 int stepResult = __unw_step(cursor);
144 if (stepResult == 0) {
145 _LIBUNWIND_TRACE_UNWINDING(
146 "unwind_phase2(ex_ojb=%p): __unw_step() reached "
147 "bottom => _URC_END_OF_STACK",
148 (void *)exception_object);
149 return _URC_END_OF_STACK;
150 } else if (stepResult < 0) {
151 _LIBUNWIND_TRACE_UNWINDING(
152 "unwind_phase2(ex_ojb=%p): __unw_step failed => "
153 "_URC_FATAL_PHASE1_ERROR",
154 (void *)exception_object);
155 return _URC_FATAL_PHASE2_ERROR;
156 }
157
158 // Get info about this frame.
159 unw_word_t sp;
160 unw_proc_info_t frameInfo;
161 __unw_get_reg(cursor, UNW_REG_SP, &sp);
162 if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
163 _LIBUNWIND_TRACE_UNWINDING(
164 "unwind_phase2(ex_ojb=%p): __unw_get_proc_info "
165 "failed => _URC_FATAL_PHASE1_ERROR",
166 (void *)exception_object);
167 return _URC_FATAL_PHASE2_ERROR;
168 }
169
170 // When tracing, print state information.
171 if (_LIBUNWIND_TRACING_UNWINDING) {
172 char functionBuf[512];
173 const char *functionName = functionBuf;
174 unw_word_t offset;
175 if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
176 &offset) != UNW_ESUCCESS) ||
177 (frameInfo.start_ip + offset > frameInfo.end_ip))
178 functionName = ".anonymous.";
179 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): start_ip=0x%" PRIxPTR
180 ", func=%s, sp=0x%" PRIxPTR ", lsda=0x%" PRIxPTR
181 ", personality=0x%" PRIxPTR,
182 (void *)exception_object, frameInfo.start_ip,
183 functionName, sp, frameInfo.lsda,
184 frameInfo.handler);
185 }
186
187 // If there is a personality routine, tell it we are unwinding.
188 if (frameInfo.handler != 0) {
189 _Unwind_Personality_Fn p =
190 (_Unwind_Personality_Fn)(uintptr_t)(frameInfo.handler);
191 _Unwind_Action action = _UA_CLEANUP_PHASE;
192 if (sp == exception_object->private_2) {
193 // Tell personality this was the frame it marked in phase 1.
194 action = (_Unwind_Action)(_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME);
195 }
196 _Unwind_Reason_Code personalityResult =
197 (*p)(1, action, exception_object->exception_class, exception_object,
198 (struct _Unwind_Context *)(cursor));
199 switch (personalityResult) {
200 case _URC_CONTINUE_UNWIND:
201 // Continue unwinding
202 _LIBUNWIND_TRACE_UNWINDING(
203 "unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND",
204 (void *)exception_object);
205 if (sp == exception_object->private_2) {
206 // Phase 1 said we would stop at this frame, but we did not...
207 _LIBUNWIND_ABORT("during phase1 personality function said it would "
208 "stop here, but now in phase2 it did not stop here");
209 }
210 break;
211 case _URC_INSTALL_CONTEXT:
212 _LIBUNWIND_TRACE_UNWINDING(
213 "unwind_phase2(ex_ojb=%p): _URC_INSTALL_CONTEXT",
214 (void *)exception_object);
215 // Personality routine says to transfer control to landing pad.
216 // We may get control back if landing pad calls _Unwind_Resume().
217 if (_LIBUNWIND_TRACING_UNWINDING) {
218 unw_word_t pc;
219 __unw_get_reg(cursor, UNW_REG_IP, &pc);
220 __unw_get_reg(cursor, UNW_REG_SP, &sp);
221 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): re-entering "
222 "user code with ip=0x%" PRIxPTR
223 ", sp=0x%" PRIxPTR,
224 (void *)exception_object, pc, sp);
225 }
226 __unw_resume(cursor);
227 // __unw_resume() only returns if there was an error.
228 return _URC_FATAL_PHASE2_ERROR;
229 default:
230 // Personality routine returned an unknown result code.
231 _LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d",
232 personalityResult);
233 return _URC_FATAL_PHASE2_ERROR;
234 }
235 }
236 }
237
238 // Clean up phase did not resume at the frame that the search phase
239 // said it would...
240 return _URC_FATAL_PHASE2_ERROR;
241 }
242
243 static _Unwind_Reason_Code
unwind_phase2_forced(unw_context_t * uc,unw_cursor_t * cursor,_Unwind_Exception * exception_object,_Unwind_Stop_Fn stop,void * stop_parameter)244 unwind_phase2_forced(unw_context_t *uc, unw_cursor_t *cursor,
245 _Unwind_Exception *exception_object,
246 _Unwind_Stop_Fn stop, void *stop_parameter) {
247 __unw_init_local(cursor, uc);
248
249 // Walk each frame until we reach where search phase said to stop
250 while (__unw_step(cursor) > 0) {
251
252 // Update info about this frame.
253 unw_proc_info_t frameInfo;
254 if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
255 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): __unw_step "
256 "failed => _URC_END_OF_STACK",
257 (void *)exception_object);
258 return _URC_FATAL_PHASE2_ERROR;
259 }
260
261 // When tracing, print state information.
262 if (_LIBUNWIND_TRACING_UNWINDING) {
263 char functionBuf[512];
264 const char *functionName = functionBuf;
265 unw_word_t offset;
266 if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
267 &offset) != UNW_ESUCCESS) ||
268 (frameInfo.start_ip + offset > frameInfo.end_ip))
269 functionName = ".anonymous.";
270 _LIBUNWIND_TRACE_UNWINDING(
271 "unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIxPTR
272 ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
273 (void *)exception_object, frameInfo.start_ip, functionName,
274 frameInfo.lsda, frameInfo.handler);
275 }
276
277 // Call stop function at each frame.
278 _Unwind_Action action =
279 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE);
280 _Unwind_Reason_Code stopResult =
281 (*stop)(1, action, exception_object->exception_class, exception_object,
282 (struct _Unwind_Context *)(cursor), stop_parameter);
283 _LIBUNWIND_TRACE_UNWINDING(
284 "unwind_phase2_forced(ex_ojb=%p): stop function returned %d",
285 (void *)exception_object, stopResult);
286 if (stopResult != _URC_NO_REASON) {
287 _LIBUNWIND_TRACE_UNWINDING(
288 "unwind_phase2_forced(ex_ojb=%p): stopped by stop function",
289 (void *)exception_object);
290 return _URC_FATAL_PHASE2_ERROR;
291 }
292
293 // If there is a personality routine, tell it we are unwinding.
294 if (frameInfo.handler != 0) {
295 _Unwind_Personality_Fn p =
296 (_Unwind_Personality_Fn)(intptr_t)(frameInfo.handler);
297 _LIBUNWIND_TRACE_UNWINDING(
298 "unwind_phase2_forced(ex_ojb=%p): calling personality function %p",
299 (void *)exception_object, (void *)(uintptr_t)p);
300 _Unwind_Reason_Code personalityResult =
301 (*p)(1, action, exception_object->exception_class, exception_object,
302 (struct _Unwind_Context *)(cursor));
303 switch (personalityResult) {
304 case _URC_CONTINUE_UNWIND:
305 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
306 "personality returned "
307 "_URC_CONTINUE_UNWIND",
308 (void *)exception_object);
309 // Destructors called, continue unwinding
310 break;
311 case _URC_INSTALL_CONTEXT:
312 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
313 "personality returned "
314 "_URC_INSTALL_CONTEXT",
315 (void *)exception_object);
316 // We may get control back if landing pad calls _Unwind_Resume().
317 __unw_resume(cursor);
318 break;
319 default:
320 // Personality routine returned an unknown result code.
321 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
322 "personality returned %d, "
323 "_URC_FATAL_PHASE2_ERROR",
324 (void *)exception_object, personalityResult);
325 return _URC_FATAL_PHASE2_ERROR;
326 }
327 }
328 }
329
330 // Call stop function one last time and tell it we've reached the end
331 // of the stack.
332 _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop "
333 "function with _UA_END_OF_STACK",
334 (void *)exception_object);
335 _Unwind_Action lastAction =
336 (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK);
337 (*stop)(1, lastAction, exception_object->exception_class, exception_object,
338 (struct _Unwind_Context *)(cursor), stop_parameter);
339
340 // Clean up phase did not resume at the frame that the search phase said it
341 // would.
342 return _URC_FATAL_PHASE2_ERROR;
343 }
344
345
346 /// Called by __cxa_throw. Only returns if there is a fatal error.
347 _LIBUNWIND_EXPORT _Unwind_Reason_Code
_Unwind_RaiseException(_Unwind_Exception * exception_object)348 _Unwind_RaiseException(_Unwind_Exception *exception_object) {
349 _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)",
350 (void *)exception_object);
351 unw_context_t uc;
352 unw_cursor_t cursor;
353 __unw_getcontext(&uc);
354
355 // Mark that this is a non-forced unwind, so _Unwind_Resume()
356 // can do the right thing.
357 exception_object->private_1 = 0;
358 exception_object->private_2 = 0;
359
360 // phase 1: the search phase
361 _Unwind_Reason_Code phase1 = unwind_phase1(&uc, &cursor, exception_object);
362 if (phase1 != _URC_NO_REASON)
363 return phase1;
364
365 // phase 2: the clean up phase
366 return unwind_phase2(&uc, &cursor, exception_object);
367 }
368
369
370
371 /// When _Unwind_RaiseException() is in phase2, it hands control
372 /// to the personality function at each frame. The personality
373 /// may force a jump to a landing pad in that function, the landing
374 /// pad code may then call _Unwind_Resume() to continue with the
375 /// unwinding. Note: the call to _Unwind_Resume() is from compiler
376 /// geneated user code. All other _Unwind_* routines are called
377 /// by the C++ runtime __cxa_* routines.
378 ///
379 /// Note: re-throwing an exception (as opposed to continuing the unwind)
380 /// is implemented by having the code call __cxa_rethrow() which
381 /// in turn calls _Unwind_Resume_or_Rethrow().
382 _LIBUNWIND_EXPORT void
_Unwind_Resume(_Unwind_Exception * exception_object)383 _Unwind_Resume(_Unwind_Exception *exception_object) {
384 _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object);
385 unw_context_t uc;
386 unw_cursor_t cursor;
387 __unw_getcontext(&uc);
388
389 if (exception_object->private_1 != 0)
390 unwind_phase2_forced(&uc, &cursor, exception_object,
391 (_Unwind_Stop_Fn) exception_object->private_1,
392 (void *)exception_object->private_2);
393 else
394 unwind_phase2(&uc, &cursor, exception_object);
395
396 // Clients assume _Unwind_Resume() does not return, so all we can do is abort.
397 _LIBUNWIND_ABORT("_Unwind_Resume() can't return");
398 }
399
400
401
402 /// Not used by C++.
403 /// Unwinds stack, calling "stop" function at each frame.
404 /// Could be used to implement longjmp().
405 _LIBUNWIND_EXPORT _Unwind_Reason_Code
_Unwind_ForcedUnwind(_Unwind_Exception * exception_object,_Unwind_Stop_Fn stop,void * stop_parameter)406 _Unwind_ForcedUnwind(_Unwind_Exception *exception_object,
407 _Unwind_Stop_Fn stop, void *stop_parameter) {
408 _LIBUNWIND_TRACE_API("_Unwind_ForcedUnwind(ex_obj=%p, stop=%p)",
409 (void *)exception_object, (void *)(uintptr_t)stop);
410 unw_context_t uc;
411 unw_cursor_t cursor;
412 __unw_getcontext(&uc);
413
414 // Mark that this is a forced unwind, so _Unwind_Resume() can do
415 // the right thing.
416 exception_object->private_1 = (uintptr_t) stop;
417 exception_object->private_2 = (uintptr_t) stop_parameter;
418
419 // do it
420 return unwind_phase2_forced(&uc, &cursor, exception_object, stop, stop_parameter);
421 }
422
423
424 /// Called by personality handler during phase 2 to get LSDA for current frame.
425 _LIBUNWIND_EXPORT uintptr_t
_Unwind_GetLanguageSpecificData(struct _Unwind_Context * context)426 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
427 unw_cursor_t *cursor = (unw_cursor_t *)context;
428 unw_proc_info_t frameInfo;
429 uintptr_t result = 0;
430 if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
431 result = (uintptr_t)frameInfo.lsda;
432 _LIBUNWIND_TRACE_API(
433 "_Unwind_GetLanguageSpecificData(context=%p) => 0x%" PRIxPTR,
434 (void *)context, result);
435 if (result != 0) {
436 if (*((uint8_t *)result) != 0xFF)
437 _LIBUNWIND_DEBUG_LOG("lsda at 0x%" PRIxPTR " does not start with 0xFF",
438 result);
439 }
440 return result;
441 }
442
443
444 /// Called by personality handler during phase 2 to find the start of the
445 /// function.
446 _LIBUNWIND_EXPORT uintptr_t
_Unwind_GetRegionStart(struct _Unwind_Context * context)447 _Unwind_GetRegionStart(struct _Unwind_Context *context) {
448 unw_cursor_t *cursor = (unw_cursor_t *)context;
449 unw_proc_info_t frameInfo;
450 uintptr_t result = 0;
451 if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
452 result = (uintptr_t)frameInfo.start_ip;
453 _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%" PRIxPTR,
454 (void *)context, result);
455 return result;
456 }
457
458 #endif // !_LIBUNWIND_SUPPORT_SEH_UNWIND
459
460 /// Called by personality handler during phase 2 if a foreign exception
461 // is caught.
462 _LIBUNWIND_EXPORT void
_Unwind_DeleteException(_Unwind_Exception * exception_object)463 _Unwind_DeleteException(_Unwind_Exception *exception_object) {
464 _LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)",
465 (void *)exception_object);
466 if (exception_object->exception_cleanup != NULL)
467 (*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT,
468 exception_object);
469 }
470
471 /// Called by personality handler during phase 2 to get register values.
472 _LIBUNWIND_EXPORT uintptr_t
_Unwind_GetGR(struct _Unwind_Context * context,int index)473 _Unwind_GetGR(struct _Unwind_Context *context, int index) {
474 unw_cursor_t *cursor = (unw_cursor_t *)context;
475 unw_word_t result;
476 __unw_get_reg(cursor, index, &result);
477 _LIBUNWIND_TRACE_API("_Unwind_GetGR(context=%p, reg=%d) => 0x%" PRIxPTR,
478 (void *)context, index, result);
479 return (uintptr_t)result;
480 }
481
482 /// Called by personality handler during phase 2 to alter register values.
_Unwind_SetGR(struct _Unwind_Context * context,int index,uintptr_t value)483 _LIBUNWIND_EXPORT void _Unwind_SetGR(struct _Unwind_Context *context, int index,
484 uintptr_t value) {
485 _LIBUNWIND_TRACE_API("_Unwind_SetGR(context=%p, reg=%d, value=0x%0" PRIxPTR
486 ")",
487 (void *)context, index, value);
488 unw_cursor_t *cursor = (unw_cursor_t *)context;
489 __unw_set_reg(cursor, index, value);
490 }
491
492 /// Called by personality handler during phase 2 to get instruction pointer.
_Unwind_GetIP(struct _Unwind_Context * context)493 _LIBUNWIND_EXPORT uintptr_t _Unwind_GetIP(struct _Unwind_Context *context) {
494 unw_cursor_t *cursor = (unw_cursor_t *)context;
495 unw_word_t result;
496 __unw_get_reg(cursor, UNW_REG_IP, &result);
497 _LIBUNWIND_TRACE_API("_Unwind_GetIP(context=%p) => 0x%" PRIxPTR,
498 (void *)context, result);
499 return (uintptr_t)result;
500 }
501
502 /// Called by personality handler during phase 2 to alter instruction pointer,
503 /// such as setting where the landing pad is, so _Unwind_Resume() will
504 /// start executing in the landing pad.
_Unwind_SetIP(struct _Unwind_Context * context,uintptr_t value)505 _LIBUNWIND_EXPORT void _Unwind_SetIP(struct _Unwind_Context *context,
506 uintptr_t value) {
507 _LIBUNWIND_TRACE_API("_Unwind_SetIP(context=%p, value=0x%0" PRIxPTR ")",
508 (void *)context, value);
509 unw_cursor_t *cursor = (unw_cursor_t *)context;
510 __unw_set_reg(cursor, UNW_REG_IP, value);
511 }
512
513 #endif // !defined(_LIBUNWIND_ARM_EHABI) && !defined(__USING_SJLJ_EXCEPTIONS__)
514