[Arm][Unwind][libc++abi] Add _Unwind_ForcedUnwind to EHABI.

[danielkiss]

Summary

_Unwind_ForcedUnwind is not mandated by the EHABI but for compatibilty
reasons adding so the interface to higher layers would be the same.
Dropping EHABI specific _Unwind_Stop_Fn definition since it is not defined by EHABI.

[danielkiss]

_Unwind_Stop_Fn shall not have different signature for EHABI.

[danielkiss]

Add a simple test and fixes.
This version passes on arm32 - armv7l-unknown-linux-gnueabihf -

[danielkiss]

https://bugs.llvm.org/show_bug.cgi?id=47142 this effects this. the missing unwind info make forceunwind fragile.

[manojgupta]

Hi Daniel,

We tested this patch in Chrome OS and it resolved our build issues :) . We do have issues on ARM32 with some crashes but we believe that is a separate problem. And we'll continue to look into those.
But I feel it should be ok for you to submit this or request a review from more qualified folks.

[danielkiss]

@manojgupta Thanks for the feedback, let me know if you have updates.

libunwind/src/Unwind-EHABI.cpp

722

Because there was no forceunwind and only in that case the reserved1 is written.

libunwind/test/forceunwind.pass.cpp

41

typo.

libunwind/test/libunwind/test/config.py

46 ↗

(On Diff #298857)

done already in upstream.

[danielkiss]

rebased, fixed my own comments.

[MaskRay]

I think ARMEH _Unwind_ForcedUnwind can probably just reuse the generic implementation.

[MaskRay]

@danielkiss Hi, I've added libc++abi forced unwinding tests in D95200. Does this implementation make the tests pass?

(Why does ARMEH uses a typedef so that struct _Unwind_Exception* does not compile? )

[danielkiss]

@MaskRay Thanks for the test case.

In D89570#2513948, @MaskRay wrote:

I think ARMEH _Unwind_ForcedUnwind can probably just reuse the generic implementation.

The personality handling is a bit different. Might not be much nicer with that many ifdefs.

In D89570#2538521, @MaskRay wrote:

@danielkiss Hi, I've added libc++abi forced unwinding tests in D95200. Does this implementation make the tests pass?

It passes now.

(Why does ARMEH uses a typedef so that struct _Unwind_Exception* does not compile? )

I think the original typedef struct _Unwind_Control_Block comes from the spec:
https://github.com/ARM-software/abi-aa/blob/f52e1ad3f81254497a83578dc102f6aac89e52d0/ehabi32/ehabi32.rst#82language-independent-unwinding-types-and-functions
_Unwind_Control_Block could be just _Unwind_Exception.
IMHO there is no nice way to achieve the struct _Unwind_Exception* compile.

[danielkiss]

libunwind/include/unwind.h

58–59

this is not nice, but right know I don't see any other way around. please let me know if you have any better idea.

[danielkiss]

Reenables tests ( revert of a4fa667dee60 )

[jroelofs]

libunwind/include/unwind.h

58–59

What's the issue that this solves?

libunwind/src/Unwind-EHABI.cpp

727

splitting hairs, but should long here be intptr_t?

libunwind/src/UnwindLevel1-gcc-ext.c

33

might be more clear to combine with if/else chain below and not rely on the PRIVATE_1 => private_1 => private_[0] expansion.

libunwind/test/forceunwind.pass.cpp

41

IIRC this needs special handling on baremetal, since there is no dladdr there.

[danielkiss]

Rebased, retested on ToT.

In D89570#2449901, @manojgupta wrote:

Hi Daniel,

We tested this patch in Chrome OS and it resolved our build issues :) . We do have issues on ARM32 with some crashes but we believe that is a separate problem. And we'll continue to look into those.
But I feel it should be ok for you to submit this or request a review from more qualified folks.

Now we are confirmed the crash is a separate, unrelated problem.

[MaskRay]

ARM EHABI is very different from the Itanium implementation. Someone should move the implementation to a separate file.

[danielkiss]

In D89570#2740272, @MaskRay wrote:

ARM EHABI is very different from the Itanium implementation. Someone should move the implementation to a separate file.

Sorry, do you mean the content of the libunwind/include/unwind.h ?

libunwind/include/unwind.h

58–59

struct _Unwind_Exception* is used mostly but the definition of _Unwind_Control_Block comes from the Arm EHABI. with the typedef struct _Unwind_Exception* won't work.

libunwind/src/Unwind-EHABI.cpp

727

right, will fix.

libunwind/src/UnwindLevel1-gcc-ext.c

33

agree, I'll update it.

libunwind/test/forceunwind.pass.cpp

41

for now I add a filter for the test it should run only on linux as other tests here.

[jroelofs]

libunwind/test/forceunwind.pass.cpp

41

sounds good

[danielkiss]

@jroelofs Thanks for the review, all addressed.

[MaskRay]

In D89570#2744598, @danielkiss wrote:

In D89570#2740272, @MaskRay wrote:

ARM EHABI is very different from the Itanium implementation. Someone should move the implementation to a separate file.

Sorry, do you mean the content of the libunwind/include/unwind.h ?

I mean all the #if defined(_LIBCXXABI_ARM_EHABI) branches make the file difficult to read. reduce sharing and move the implementation to a separate file.
Many sanitizer files are organized this way.

[danielkiss]

In D89570#2749259, @MaskRay wrote:

In D89570#2744598, @danielkiss wrote:

In D89570#2740272, @MaskRay wrote:

ARM EHABI is very different from the Itanium implementation. Someone should move the implementation to a separate file.

Sorry, do you mean the content of the libunwind/include/unwind.h ?

I mean all the #if defined(_LIBCXXABI_ARM_EHABI) branches make the file difficult to read. reduce sharing and move the implementation to a separate file.
Many sanitizer files are organized this way.

I will create another patch for the that without functional changes.

[MaskRay]

Thanks for the libunwind split D106461 :)

[danielkiss]

In D89570#2893801, @MaskRay wrote:

Thanks for the libunwind split D106461 :)

No problem, I'm going to rebase this one.

[danielkiss]

Rebase

[danielkiss]

ping?

[MaskRay]

I understand Itanium _Unwind_ForcedUnwind. The ARM EH impl has a similar structure. LG

libunwind/include/unwind.h

70

delete excess space

libunwind/src/Unwind-EHABI.cpp

700

This can trigger clang -Wunused-but-set-variable (from 2021-04 onwards)

Don't define functionName in the #ifdef NDEBUG branch

713

C++ doesn't need the elaborated type specifier struct

1096

Delete the comment

libunwind/test/forceunwind.pass.cpp

27

Not needed

[danielkiss]

Thanks for the review, comments are addressed.

libunwind/src/Unwind-EHABI.cpp

700

This pattern need to be fixed all over libunwind. I'll patch it separately.

libunwind/test/forceunwind.pass.cpp

27

line 38 won't compile without it.

[danielkiss]

libunwind/src/Unwind-EHABI.cpp

700

fix is here: D107835

[manojgupta]

@danielkiss

We have been trying to debug 1 issue on ARM32 Chrome OS devices related to pthread_cancel.
After some debugging, I found that glibc uses char[8] for the exception class [1] but libunwind is using uin64_t.
This causes crashes because of ABI mismatch when pthread_cancel calls Unwind routines.

e.g. look at the following code in libunwind which calls unwind_stop from glibc:

(*stop)(1, action, exception_object->exception_class, exception_object,
       (_Unwind_Context *)(cursor), stop_parameter);

This mismatches the glibc's expected prototype for for unwind_stop [2] in argument 3 (exception class should be char * vs uint64_t).

Here is some data I got from a sample program.

(gdb) bt
#0  unwind_stop (version=1, actions=10, exc_class=0x0, exc_obj=0x0, context=0xf74ff628, stop_parameter=0xf74fe648)
    at unwind.c:44
#1  0xf7f77bdc in unwind_phase2_forced (uc=0xf74fe7d0, cursor=0xf74fe648, exception_object=0xf74ff628, 
    stop=0xf7fab3f1 <unwind_stop>, stop_parameter=0xf74fed78)
    at /build/elm/tmp/portage/sys-libs/llvm-libunwind-13.0_pre428724-r2/work/llvm-libunwind-13.0_pre428724/libunwind/src/Unwind-EHABI.cpp:716
#2  0xf7f77df2 in _Unwind_ForcedUnwind (exception_object=0xf74ff628, stop=0xf7fab3f1 <unwind_stop>, 
    stop_parameter=0xf74fed78)
    at /build/elm/tmp/portage/sys-libs/llvm-libunwind-13.0_pre428724-r2/work/llvm-libunwind-13.0_pre428724/libunwind/src/Unwind-EHABI.cpp:1100
#3  0xf7fab4d4 in __GI___pthread_unwind (buf=<optimized out>) at unwind.c:121
#4  0xf7fa22b0 in __do_cancel () at ./pthreadP.h:313

unwind_stop parameters show context=0xf74ff628, it should be the next value shown for stop_parameter instead i.e. 0xf74fe648.

(gdb) ptype exc_class
type = char *

this shows char * was expected in glibc instead of uint64_t.

[1] https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/arm/unwind.h;h=ffdea8047d5c6202bdc775548c27b640c36430ae;hb=HEAD#l194
[2] https://sourceware.org/git/?p=glibc.git;a=blob;f=nptl/unwind.c;h=8f157e49f4a088ac64722e85ff24514fff7f3c71;hb=HEAD#l40

[danielkiss]

In D89570#2963171, @manojgupta wrote:

@danielkiss

We have been trying to debug 1 issue on ARM32 Chrome OS devices related to pthread_cancel.
After some debugging, I found that glibc uses char[8] for the exception class [1] but libunwind is using uin64_t.
This causes crashes because of ABI mismatch when pthread_cancel calls Unwind routines.

Thanks for the report, I submitted a patch to fix the type D109047

libcxxabi/src/cxa_personality.cpp

case _US_UNWIND_FRAME_STARTING:
             // Install the context for the catching handler
             set_registers(unwind_exception, context, results);
             return _URC_INSTALL_CONTEXT;
         }
 
         // Either we didn't do a phase 1 search (due to forced unwinding), or
         //  phase 1 reported no catching-handlers.
         // Search for a (non-catching) cleanup
-        scan_eh_tab(results, _UA_CLEANUP_PHASE, native_exception, unwind_exception, context);
+        if (is_force_unwinding)
+          scan_eh_tab(
+              results,
+              static_cast<_Unwind_Action>(_UA_CLEANUP_PHASE | _UA_FORCE_UNWIND),
+              native_exception, unwind_exception, context);
+        else
+          scan_eh_tab(results, _UA_CLEANUP_PHASE, native_exception,
+                      unwind_exception, context);
         if (results.reason == _URC_HANDLER_FOUND)
         {
             // Found a non-catching handler
 
             // ARM EHABI 8.4.2: Before we can jump to the cleanup handler, we have to setup some
             // internal data structures, so that __cxa_end_cleanup() can get unwind_exception from
             // __cxa_get_globals().
             __cxa_begin_cleanup(unwind_exception);

libcxxabi/test/forced_unwind1.pass.cpp

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 #include <stdlib.h>
 #include <string.h>
 #include <unwind.h>
 #include <tuple>
 #include <__cxxabi_config.h>
 
-#if defined(_LIBCXXABI_ARM_EHABI)
-int main(int, char**) {
-  return 0;
-}
-#else
 static int bits = 0;
 
 struct C {
   int bit;
   C(int b) : bit(b) {}
   ~C() { bits |= bit; }
 };
 
try {
     // __cxa_end_catch calls cleanup.
   }
 }
 
 int main(int, char**) {
   test();
   return bits != 15;
 }
-#endif

libcxxabi/test/forced_unwind2.pass.cpp

 #include <exception>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <unwind.h>
 #include <tuple>
 #include <__cxxabi_config.h>
 
-#if defined(_LIBCXXABI_ARM_EHABI)
-int main(int, char**) {
-  return 0;
-}
-#else
 template <typename T>
 struct Stop;
 
 template <typename R, typename... Args>
 struct Stop<R (*)(Args...)> {
   // The third argument of _Unwind_Stop_Fn is uint64_t in Itanium C++ ABI/LLVM
   // libunwind while _Unwind_Exception_Class in libgcc.
   typedef typename std::tuple_element<2, std::tuple<Args...>>::type type;

 int main(int, char**) {
   std::set_terminate(terminate);
   try {
     test();
   } catch (...) {
   }
   abort();
 }
-#endif

libunwind/include/unwind.h

typedef enum {
   _UA_CLEANUP_PHASE = 2,
   _UA_HANDLER_FRAME = 4,
   _UA_FORCE_UNWIND = 8,
   _UA_END_OF_STACK = 16 // gcc extension to C++ ABI
 } _Unwind_Action;
 
 typedef struct _Unwind_Context _Unwind_Context;   // opaque
 
 #if defined(_LIBUNWIND_ARM_EHABI)
 #include "unwind_arm_ehabi.h"
 #else
 #include "unwind_itanium.h"
 #endif
 
+typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)
+    (int version,
+     _Unwind_Action actions,
+     uint64_t exceptionClass,
+     _Unwind_Exception* exceptionObject,
+     struct _Unwind_Context* context,
+     void* stop_parameter);
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 extern uintptr_t _Unwind_GetRegionStart(struct _Unwind_Context *context);
 extern uintptr_t
     _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context);
 #ifdef __USING_SJLJ_EXCEPTIONS__

libunwind/include/unwind_arm_ehabi.h

 static const _Unwind_State _US_ACTION_MASK            = 3;
 /* Undocumented flag for force unwinding. */
 static const _Unwind_State _US_FORCE_UNWIND           = 8;
 
 typedef uint32_t _Unwind_EHT_Header;
 
 struct _Unwind_Control_Block;
 typedef struct _Unwind_Control_Block _Unwind_Control_Block;
-typedef struct _Unwind_Control_Block _Unwind_Exception; /* Alias */
+#define _Unwind_Exception _Unwind_Control_Block /* Alias */
 
 struct _Unwind_Control_Block {
   uint64_t exception_class;
   void (*exception_cleanup)(_Unwind_Reason_Code, _Unwind_Control_Block*);
 
   /* Unwinder cache, private fields for the unwinder's use */
   struct {
     uint32_t reserved1; /* init reserved1 to 0, then don't touch */
struct {
     _Unwind_EHT_Header* ehtp; /* pointer to EHT entry header word */
     uint32_t additional;
     uint32_t reserved1;
   } pr_cache;
 
   long long int :0; /* Enforce the 8-byte alignment */
 } __attribute__((__aligned__(8)));
 
-typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)
-      (_Unwind_State state,
-       _Unwind_Exception* exceptionObject,
-       struct _Unwind_Context* context);
-
 typedef _Unwind_Reason_Code (*_Unwind_Personality_Fn)(
     _Unwind_State state, _Unwind_Exception *exceptionObject,
     struct _Unwind_Context *context);
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 

libunwind/include/unwind_itanium.h

#if __SIZEOF_POINTER__ == 4
   // pad fields added for binary compatibility.
   uint32_t reserved[3];
 #endif
   // The Itanium ABI requires that _Unwind_Exception objects are "double-word
   // aligned".  GCC has interpreted this to mean "use the maximum useful
   // alignment for the target"; so do we.
 } __attribute__((__aligned__));
 
-typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)
-    (int version,
-     _Unwind_Action actions,
-     uint64_t exceptionClass,
-     _Unwind_Exception* exceptionObject,
-     struct _Unwind_Context* context,
-     void* stop_parameter );
-
 typedef _Unwind_Reason_Code (*_Unwind_Personality_Fn)(
     int version, _Unwind_Action actions, uint64_t exceptionClass,
     _Unwind_Exception *exceptionObject, struct _Unwind_Context *context);
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 

libunwind/src/Unwind-EHABI.cpp

if (_LIBUNWIND_TRACING_UNWINDING) {
           static_cast<void *>(exception_object), frameInfo.start_ip,
           functionName, sp, frameInfo.lsda,
           frameInfo.handler);
     }
 
     // If there is a personality routine, tell it we are unwinding.
     if (frameInfo.handler != 0) {
       _Unwind_Personality_Fn p =
-          (_Unwind_Personality_Fn)(long)(frameInfo.handler);
+          (_Unwind_Personality_Fn)(intptr_t)(frameInfo.handler);
       struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
       // EHABI #7.2
       exception_object->pr_cache.fnstart = frameInfo.start_ip;
       exception_object->pr_cache.ehtp =
           (_Unwind_EHT_Header *)frameInfo.unwind_info;
       exception_object->pr_cache.additional = frameInfo.flags;
       _Unwind_Reason_Code personalityResult =
           (*p)(state, exception_object, context);
while (true) {
     frame_count++;
   }
 
   // Clean up phase did not resume at the frame that the search phase
   // said it would...
   return _URC_FATAL_PHASE2_ERROR;
 }
 
+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) {
+  // See comment at the start of unwind_phase1 regarding VRS integrity.
+  __unw_init_local(cursor, uc);
+  _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_force(ex_ojb=%p)",
+                             static_cast<void *>(exception_object));
+  // Walk each frame until we reach where search phase said to stop
+  while (true) {
+    // Update info about this frame.
+    unw_proc_info_t frameInfo;
+    if (__unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
+      _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): __unw_step "
+                                 "failed => _URC_END_OF_STACK",
+                                 (void *)exception_object);
+      return _URC_FATAL_PHASE2_ERROR;
+    }
+
+    // When tracing, print state information.
+    if (_LIBUNWIND_TRACING_UNWINDING) {
+      char functionBuf[512];
+      const char *functionName = functionBuf;
+      unw_word_t offset;
+      if ((__unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
+                               &offset) != UNW_ESUCCESS) ||
+          (frameInfo.start_ip + offset > frameInfo.end_ip))
+        functionName = ".anonymous.";
+      _LIBUNWIND_TRACE_UNWINDING(
+          "unwind_phase2_forced(ex_ojb=%p): start_ip=0x%" PRIxPTR
+          ", func=%s, lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
+          (void *)exception_object, frameInfo.start_ip, functionName,
+          frameInfo.lsda, frameInfo.handler);
+    }
+
+    // Call stop function at each frame.
+    _Unwind_Action action =
+        (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE);
+    _Unwind_Reason_Code stopResult =
+        (*stop)(1, action, exception_object->exception_class, exception_object,
+                (_Unwind_Context *)(cursor), stop_parameter);
+    _LIBUNWIND_TRACE_UNWINDING(
+        "unwind_phase2_forced(ex_ojb=%p): stop function returned %d",
+        (void *)exception_object, stopResult);
+    if (stopResult != _URC_NO_REASON) {
+      _LIBUNWIND_TRACE_UNWINDING(
+          "unwind_phase2_forced(ex_ojb=%p): stopped by stop function",
+          (void *)exception_object);
+      return _URC_FATAL_PHASE2_ERROR;
+    }
+
+    // If there is a personality routine, tell it we are unwinding.
+    if (frameInfo.handler != 0) {
+      _Unwind_Personality_Fn p =
+          (_Unwind_Personality_Fn)(uintptr_t)(frameInfo.handler);
+      struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
+      // EHABI #7.2
+      exception_object->pr_cache.fnstart = frameInfo.start_ip;
+      exception_object->pr_cache.ehtp =
+          (_Unwind_EHT_Header *)frameInfo.unwind_info;
+      exception_object->pr_cache.additional = frameInfo.flags;
+      _Unwind_Reason_Code personalityResult =
+          (*p)(_US_FORCE_UNWIND | _US_UNWIND_FRAME_STARTING, exception_object,
+               context);
+      switch (personalityResult) {
+      case _URC_CONTINUE_UNWIND:
+        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
+                                   "personality returned "
+                                   "_URC_CONTINUE_UNWIND",
+                                   (void *)exception_object);
+        // Destructors called, continue unwinding
+        break;
+      case _URC_INSTALL_CONTEXT:
+        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
+                                   "personality returned "
+                                   "_URC_INSTALL_CONTEXT",
+                                   (void *)exception_object);
+        // We may get control back if landing pad calls _Unwind_Resume().
+        __unw_resume(cursor);
+        break;
+      default:
+        // Personality routine returned an unknown result code.
+        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
+                                   "personality returned %d, "
+                                   "_URC_FATAL_PHASE2_ERROR",
+                                   (void *)exception_object, personalityResult);
+        return _URC_FATAL_PHASE2_ERROR;
+      }
+    }
+  }
+
+  // Call stop function one last time and tell it we've reached the end
+  // of the stack.
+  _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop "
+                             "function with _UA_END_OF_STACK",
+                             (void *)exception_object);
+  _Unwind_Action lastAction =
+      (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK);
+  (*stop)(1, lastAction, exception_object->exception_class, exception_object,
+          (struct _Unwind_Context *)(cursor), stop_parameter);
+
+  // Clean up phase did not resume at the frame that the search phase said it
+  // would.
+  return _URC_FATAL_PHASE2_ERROR;
+}
+
 /// Called by __cxa_throw.  Only returns if there is a fatal error.
 _LIBUNWIND_EXPORT _Unwind_Reason_Code
 _Unwind_RaiseException(_Unwind_Exception *exception_object) {
   _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)",
                        static_cast<void *>(exception_object));
   unw_context_t uc;
   unw_cursor_t cursor;
   __unw_getcontext(&uc);

 _LIBUNWIND_EXPORT void
 _Unwind_Resume(_Unwind_Exception *exception_object) {
   _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)",
                        static_cast<void *>(exception_object));
   unw_context_t uc;
   unw_cursor_t cursor;
   __unw_getcontext(&uc);
 
-  // _Unwind_RaiseException on EHABI will always set the reserved1 field to 0,
-  // which is in the same position as private_1 below.
-  // TODO(ajwong): Who wronte the above? Why is it true?
+  if (exception_object->unwinder_cache.reserved1)
+    unwind_phase2_forced(
+        &uc, &cursor, exception_object,
+        (_Unwind_Stop_Fn)exception_object->unwinder_cache.reserved1,
+        (void *)exception_object->unwinder_cache.reserved3);
+  else
     unwind_phase2(&uc, &cursor, exception_object, true);
 
   // Clients assume _Unwind_Resume() does not return, so all we can do is abort.
   _LIBUNWIND_ABORT("_Unwind_Resume() can't return");
 }
 
 /// Called by personality handler during phase 2 to get LSDA for current frame.
 _LIBUNWIND_EXPORT uintptr_t
 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
#endif
         ++sp;
       return _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
                              &sp);
     }
   }
   _LIBUNWIND_ABORT("unsupported register class");
 }
 
+/// Not used by C++.
+/// Unwinds stack, calling "stop" function at each frame.
+/// Could be used to implement longjmp().
+_LIBUNWIND_EXPORT _Unwind_Reason_Code
+_Unwind_ForcedUnwind(_Unwind_Exception *exception_object, _Unwind_Stop_Fn stop,
+                     void *stop_parameter) {
+  _LIBUNWIND_TRACE_API("_Unwind_ForcedUnwind(ex_obj=%p, stop=%p)",
+                       (void *)exception_object, (void *)(uintptr_t)stop);
+  unw_context_t uc;
+  unw_cursor_t cursor;
+  __unw_getcontext(&uc);
+
+  // Mark that this is a forced unwind, so _Unwind_Resume() can do
+  // the right thing.
+  exception_object->unwinder_cache.reserved1 = (uintptr_t)stop;
+  exception_object->unwinder_cache.reserved3 = (uintptr_t)stop_parameter;
+
+  return unwind_phase2_forced(&uc, &cursor, exception_object, stop,
+                              stop_parameter);
+}
+
 /// Called by personality handler during phase 2 to find the start of the
 /// function.
 _LIBUNWIND_EXPORT uintptr_t
 _Unwind_GetRegionStart(struct _Unwind_Context *context) {
   unw_cursor_t *cursor = (unw_cursor_t *)context;
   unw_proc_info_t frameInfo;
   uintptr_t result = 0;
   if (__unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)

libunwind/src/UnwindLevel1-gcc-ext.c

 #include "libunwind_ext.h"
 #include "libunwind.h"
 #include "Unwind-EHABI.h"
 #include "unwind.h"
 
 #if defined(_LIBUNWIND_BUILD_ZERO_COST_APIS)
 
 #if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
-#define private_1 private_[0]
+#define PRIVATE_1 private_[0]
+#elif defined(_LIBUNWIND_ARM_EHABI)
+#define PRIVATE_1 unwinder_cache.reserved1
+#else
+#define PRIVATE_1 private_1
 #endif
 
 ///  Called by __cxa_rethrow().
 _LIBUNWIND_EXPORT _Unwind_Reason_Code
 _Unwind_Resume_or_Rethrow(_Unwind_Exception *exception_object) {
-#if defined(_LIBUNWIND_ARM_EHABI)
-  _LIBUNWIND_TRACE_API("_Unwind_Resume_or_Rethrow(ex_obj=%p), private_1=%ld",
-                       (void *)exception_object,
-                       (long)exception_object->unwinder_cache.reserved1);
-#else
-  _LIBUNWIND_TRACE_API("_Unwind_Resume_or_Rethrow(ex_obj=%p), private_1=%" PRIdPTR,
-                       (void *)exception_object,
-                       (intptr_t)exception_object->private_1);
-#endif
+  _LIBUNWIND_TRACE_API(
+      "_Unwind_Resume_or_Rethrow(ex_obj=%p), private_1=%" PRIdPTR,
+      (void *)exception_object, (intptr_t)exception_object->PRIVATE_1);
 
-#if defined(_LIBUNWIND_ARM_EHABI)
-  // _Unwind_RaiseException on EHABI will always set the reserved1 field to 0,
-  // which is in the same position as private_1 below.
-  return _Unwind_RaiseException(exception_object);
-#else
   // If this is non-forced and a stopping place was found, then this is a
   // re-throw.
   // Call _Unwind_RaiseException() as if this was a new exception
-  if (exception_object->private_1 == 0) {
+  if (exception_object->PRIVATE_1 == 0) {
     return _Unwind_RaiseException(exception_object);
     // Will return if there is no catch clause, so that __cxa_rethrow can call
     // std::terminate().
   }
 
   // Call through to _Unwind_Resume() which distiguishes between forced and
   // regular exceptions.
   _Unwind_Resume(exception_object);
   _LIBUNWIND_ABORT("_Unwind_Resume_or_Rethrow() called _Unwind_RaiseException()"
                    " which unexpectedly returned");
-#endif
 }
 
-
 /// Called by personality handler during phase 2 to get base address for data
 /// relative encodings.
 _LIBUNWIND_EXPORT uintptr_t
 _Unwind_GetDataRelBase(struct _Unwind_Context *context) {
   (void)context;
   _LIBUNWIND_TRACE_API("_Unwind_GetDataRelBase(context=%p)", (void *)context);
   _LIBUNWIND_ABORT("_Unwind_GetDataRelBase() not implemented");
 }

libunwind/test/forceunwind.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: linux
+
+// Basic test for _Unwind_ForcedUnwind.
+// See libcxxabi/test/forced_unwind* tests too.
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <unwind.h>
+
+void foo();
+_Unwind_Exception ex;
+
+_Unwind_Reason_Code stop(int version, _Unwind_Action actions,
+                         uint64_t exceptionClass,
+                         _Unwind_Exception *exceptionObject,
+                         struct _Unwind_Context *context,
+                         void *stop_parameter) {
+  assert(version == 1);
+  assert((actions & _UA_FORCE_UNWIND) != 0);
+  (void)exceptionClass;
+  assert(exceptionObject == &ex);
+  assert(stop_parameter == &foo);
+
+  Dl_info info = {0, 0, 0, 0};
+
+  // Unwind util the main is reached, above frames depend on the platform and
+  // architecture.
+  if (dladdr(reinterpret_cast<void *>(_Unwind_GetIP(context)), &info) &&
+      info.dli_sname && !strcmp("main", info.dli_sname)) {
+    _Exit(0);
+  }
+  return _URC_NO_REASON;
+}
+
+__attribute__((noinline)) void foo() {
+
+  // Arm EHABI defines struct _Unwind_Control_Block as exception
+  // object. Ensure struct _Unwind_Exception* work there too,
+  // because _Unwind_Exception in this case is just an alias.
+  struct _Unwind_Exception *e = &ex;
+#if defined(_LIBUNWIND_ARM_EHABI)
+  // Create a mock exception object.
+  memset(e, '\0', sizeof(*e));
+  e->exception_class = 0x434C4E47554E5700; // CLNGUNW\0
+#endif
+  _Unwind_ForcedUnwind(e, stop, (void *)&foo);
+}
+
+int main() {
+  foo();
+  return -2;
+}