contrib/llvm/projects/libunwind/src/UnwindLevel1.c

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