[libcxxabi] Make _Unwind_Backtrace() work on ARM.

[danalbert]

Summary

Since the personality functions do the actual unwinding on ARM, and will
also stop unwinding when they encounter a handler, we invoke
_Unwind_VRS_Interpret() directly form _Unwind_Backtrace().

To simplify, the logic for decoding an EHT is moved out of
unwindOneFrame() and into its own function, decode_eht_entry(). Unlike
unwindOneFrame(), which could only handle ARM's compact personality
function entries (section 6.3) decode_eht_entry() can handle the generic
entries (section 6.2).

[jroelofs]

include/unwind.h

210 ↗

(On Diff #13062)

This is an implementation detail, and doesn't belong in the public interface. Can this go in a header in src/Unwind?

src/Unwind/Unwind-EHABI.cpp

171 ↗

(On Diff #13062)

The assert should stay.

241 ↗

(On Diff #13062)

const_cast is icky. can we make this return const uint32_t*?

src/Unwind/UnwindLevel1-gcc-ext.c

145 ↗

(On Diff #13062)

This needs to go before the callback is called, otherwise the first callback would have the context corresponding to the _Unwind_Backtrace function itself. The best place is probably right under the if (unw_step(...)) { block.

[danalbert]

Add test and fix ordering of unwinding in _Unwind_Backtrace() (was
unwinding after calling callback, causing _Unwind_Backtrace() to be
included in backtrace).

[danalbert]

• Address review comments.

[jroelofs]

with the assert added back, LGTM.

I'll think about how to make the asserts tighter, and we can come back & fix up the test case if there ends up being a better way to do that.

src/Unwind/Unwind-EHABI.cpp

174 ↗

(On Diff #13064)

assert((*unwindingData & 0xf0000000) == 0x80000000 && "Must be a compact entry");

[jroelofs]

just saw you posted a new revision... this one LGTM too.

[piman]

src/Unwind/Unwind-EHABI.cpp

223 ↗

(On Diff #13066)

Mmh, this makes assumptions about the personality routine doesn't it?
The generic model is supposed to be compatible with a variety of languages and I'm not sure we can assume the generic data is the same as what the C++ personality routine expects, can we?

[jroelofs]

src/Unwind/Unwind-EHABI.cpp

223 ↗

(On Diff #13066)

In the generic model, the unwind opcodes come first, and then the LSDA comes after... this looks correct to me.

[danalbert]

Closed by commit rL216730 (authored by @danalbert).

libcxxabi/trunk/include/unwind.h

_Unwind_VRS_Set(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
                 uint32_t regno, _Unwind_VRS_DataRepresentation representation,
                 void *valuep);
 
 extern _Unwind_VRS_Result
 _Unwind_VRS_Pop(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
                 uint32_t discriminator,
                 _Unwind_VRS_DataRepresentation representation);
 
-extern _Unwind_Reason_Code _Unwind_VRS_Interpret(_Unwind_Context *context,
-                                                 uint32_t *data, size_t offset,
-                                                 size_t len);
-
 static inline uintptr_t _Unwind_GetGR(struct _Unwind_Context* context,
                                       int index) {
   uintptr_t value = 0;
   _Unwind_VRS_Get(context, _UVRSC_CORE, (uint32_t)index, _UVRSD_UINT32, &value);
   return value;
 }
 
 static inline void _Unwind_SetGR(struct _Unwind_Context* context, int index,

libcxxabi/trunk/src/Unwind/Unwind-EHABI.cpp

 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "config.h"
 #include "libunwind.h"
+#include "libunwind_ext.h"
 #include "unwind.h"
 #include "../private_typeinfo.h"
 
 #if LIBCXXABI_ARM_EHABI
 namespace {
 
 // Strange order: take words in order, but inside word, take from most to least
 // signinficant byte.
-uint8_t getByte(uint32_t* data, size_t offset) {
-  uint8_t* byteData = reinterpret_cast<uint8_t*>(data);
+uint8_t getByte(const uint32_t* data, size_t offset) {
+  const uint8_t* byteData = reinterpret_cast<const uint8_t*>(data);
   return byteData[(offset & ~(size_t)0x03) + (3 - (offset & (size_t)0x03))];
 }
 
 const char* getNextWord(const char* data, uint32_t* out) {
   *out = *reinterpret_cast<const uint32_t*>(data);
   return data + 4;
 }
 
_Unwind_Reason_Code ProcessDescriptors(
   return _URC_CONTINUE_UNWIND;
 }
 
 _Unwind_Reason_Code unwindOneFrame(
     _Unwind_State state,
     _Unwind_Control_Block* ucbp,
     struct _Unwind_Context* context) {
   // Read the compact model EHT entry's header # 6.3
-  uint32_t* unwindingData = ucbp->pr_cache.ehtp;
-  uint32_t unwindInfo = *unwindingData;
-  assert((unwindInfo & 0xf0000000) == 0x80000000 && "Must be a compact entry");
+  const uint32_t* unwindingData = ucbp->pr_cache.ehtp;
+  assert((*unwindingData & 0xf0000000) == 0x80000000 && "Must be a compact entry");
   Descriptor::Format format =
-      static_cast<Descriptor::Format>((unwindInfo & 0x0f000000) >> 24);
+      static_cast<Descriptor::Format>((*unwindingData & 0x0f000000) >> 24);
   size_t len = 0;
-  size_t startOffset = 0;
-  switch (format) {
-    case Descriptor::SU16:
-      len = 4;
-      startOffset = 1;
-      break;
-    case Descriptor::LU16:
-    case Descriptor::LU32:
-      len = 4 + 4 * ((unwindInfo & 0x00ff0000) >> 16);
-      startOffset = 2;
-      break;
-    default:
-      return _URC_FAILURE;
+  size_t off = 0;
+  unwindingData = decode_eht_entry(unwindingData, &off, &len);
+  if (unwindingData == nullptr) {
   }
 
   // Handle descriptors before unwinding so they are processed in the context
   // of the correct stack frame.
   _Unwind_Reason_Code result =
       ProcessDescriptors(
           state, ucbp, context, format,
           reinterpret_cast<const char*>(ucbp->pr_cache.ehtp) + len,
           ucbp->pr_cache.additional);
 
   if (result != _URC_CONTINUE_UNWIND)
     return result;
 
-  return _Unwind_VRS_Interpret(context, unwindingData, startOffset, len);
+  return _Unwind_VRS_Interpret(context, unwindingData, off, len);
 }
 
 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_CORE /
 // _UVRSD_UINT32.
 uint32_t RegisterMask(uint8_t start, uint8_t count_minus_one) {
   return ((1U << (count_minus_one + 1)) - 1) << start;
 }
 
 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_VFP /
 // _UVRSD_DOUBLE.
 uint32_t RegisterRange(uint8_t start, uint8_t count_minus_one) {
   return ((uint32_t)start << 16) | ((uint32_t)count_minus_one + 1);
 }
 
 } // end anonymous namespace
 
+/**
+ * Decodes an EHT entry.
+ *
+ * @param data Pointer to EHT.
+ * @param[out] off Offset from return value (in bytes) to begin interpretation.
+ * @param[out] len Number of bytes in unwind code.
+ * @return Pointer to beginning of unwind code.
+ */
+extern "C" const uint32_t*
+decode_eht_entry(const uint32_t* data, size_t* off, size_t* len) {
+  if ((*data & 0x80000000) == 0) {
+    // 6.2: Generic Model
+    *off = 1; // First byte is size data.
+    *len = (((data[1] >> 24) & 0xff) + 1) * 4;
+    data++; // Skip the first word, which is the prel31 offset.
+  } else {
+    // 6.3: ARM Compact Model
+    Descriptor::Format format =
+        static_cast<Descriptor::Format>((*data & 0x0f000000) >> 24);
+    switch (format) {
+      case Descriptor::SU16:
+        *len = 4;
+        *off = 1;
+        break;
+      case Descriptor::LU16:
+      case Descriptor::LU32:
+        *len = 4 + 4 * ((*data & 0x00ff0000) >> 16);
+        *off = 2;
+        break;
+      default:
+        return nullptr;
+    }
+  }
+
+  return data;
+}
+
 _Unwind_Reason_Code _Unwind_VRS_Interpret(
     _Unwind_Context* context,
-    uint32_t* data,
+    const uint32_t* data,
     size_t offset,
     size_t len) {
   bool wrotePC = false;
   bool finish = false;
   while (offset < len && !finish) {
     uint8_t byte = getByte(data, offset++);
     if ((byte & 0x80) == 0) {
       uint32_t sp;

libcxxabi/trunk/src/Unwind/UnwindLevel1-gcc-ext.c

_Unwind_Backtrace(_Unwind_Trace_Fn callback, void *ref) {
   unw_context_t uc;
   unw_getcontext(&uc);
   unw_init_local(&cursor, &uc);
 
   _LIBUNWIND_TRACE_API("_Unwind_Backtrace(callback=%p)\n", callback);
 
   // walk each frame
   while (true) {
+    _Unwind_Reason_Code result;
 
     // ask libuwind to get next frame (skip over first frame which is
     // _Unwind_Backtrace())
     if (unw_step(&cursor) <= 0) {
       _LIBUNWIND_TRACE_UNWINDING(" _backtrace: ended because cursor reached "
                                  "bottom of stack, returning %d\n",
                                  _URC_END_OF_STACK);
       return _URC_END_OF_STACK;
     }
 
+#if LIBCXXABI_ARM_EHABI
+    // Get the information for this frame.
+    unw_proc_info_t frameInfo;
+    if (unw_get_proc_info(&cursor, &frameInfo) != UNW_ESUCCESS) {
+      return _URC_END_OF_STACK;
+    }
+
+    struct _Unwind_Context *context = (struct _Unwind_Context *)&cursor;
+    size_t off;
+    size_t len;
+    uint32_t* unwindInfo = (uint32_t *) frameInfo.unwind_info;
+    unwindInfo = decode_eht_entry(unwindInfo, &off, &len);
+    if (unwindInfo == NULL) {
+      return _URC_FAILURE;
+    }
+
+    result = _Unwind_VRS_Interpret(context, unwindInfo, off, len);
+    if (result != _URC_CONTINUE_UNWIND) {
+      return _URC_END_OF_STACK;
+    }
+#endif // LIBCXXABI_ARM_EHABI
+
     // debugging
     if (_LIBUNWIND_TRACING_UNWINDING) {
       char functionName[512];
       unw_proc_info_t frameInfo;
       unw_word_t offset;
       unw_get_proc_name(&cursor, functionName, 512, &offset);
       unw_get_proc_info(&cursor, &frameInfo);
       _LIBUNWIND_TRACE_UNWINDING(
           " _backtrace: start_ip=0x%llX, func=%s, lsda=0x%llX, context=%p\n",
           (long long)frameInfo.start_ip, functionName, (long long)frameInfo.lsda,
           &cursor);
     }
 
     // call trace function with this frame
-    _Unwind_Reason_Code result =
-        (*callback)((struct _Unwind_Context *)(&cursor), ref);
+    result = (*callback)((struct _Unwind_Context *)(&cursor), ref);
     if (result != _URC_NO_REASON) {
       _LIBUNWIND_TRACE_UNWINDING(" _backtrace: ended because callback "
                                  "returned %d\n",
                                  result);
       return result;
     }
   }
 }

libcxxabi/trunk/src/Unwind/libunwind_ext.h

 //===------------------------ libunwind_ext.h -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //
 //  Extensions to libunwind API.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __LIBUNWIND_EXT__
 #define __LIBUNWIND_EXT__
 
+#include "config.h"
 #include <libunwind.h>
+#include <unwind.h>
 
 #define UNW_STEP_SUCCESS 1
 #define UNW_STEP_END     0
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 // SPI
 extern void unw_iterate_dwarf_unwind_cache(void (*func)(unw_word_t ip_start,
                                                         unw_word_t ip_end,
                                                         unw_word_t fde,
                                                         unw_word_t mh));
 
 // IPI
 extern void _unw_add_dynamic_fde(unw_word_t fde);
 extern void _unw_remove_dynamic_fde(unw_word_t fde);
 
+#if LIBCXXABI_ARM_EHABI
+extern const uint32_t* decode_eht_entry(const uint32_t*, size_t*, size_t*);
+extern _Unwind_Reason_Code _Unwind_VRS_Interpret(_Unwind_Context *context,
+                                                 const uint32_t *data,
+                                                 size_t offset, size_t len);
+#endif
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // __LIBUNWIND_EXT__

libcxxabi/trunk/src/cxa_personality.cpp

 //===------------------------- cxa_exception.cpp --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //  
 //  This file implements the "Exception Handling APIs"
 //  http://mentorembedded.github.io/cxx-abi/abi-eh.html
 //  http://www.intel.com/design/itanium/downloads/245358.htm
 //  
 //===----------------------------------------------------------------------===//
 
+#include <assert.h>
+#include <stdlib.h>
+#include <typeinfo>
+
 #include "config.h"
-#include "unwind.h"
 #include "cxa_exception.hpp"
 #include "cxa_handlers.hpp"
 #include "private_typeinfo.h"
-#include <typeinfo>
-#include <stdlib.h>
-#include <assert.h>
+#include "unwind.h"
+
+#if LIBCXXABI_ARM_EHABI
+#include "Unwind/libunwind_ext.h"
+#endif
 
 /*
     Exception Header Layout:
 
 +---------------------------+-----------------------------+---------------+
 | __cxa_exception           | _Unwind_Exception CLNGC++\0 | thrown object |
 +---------------------------+-----------------------------+---------------+
                                                           ^

libcxxabi/trunk/test/backtrace_test.cpp

+//===---------------------- backtrace_test.cpp ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <assert.h>
+#include <unwind.h>
+
+extern "C" _Unwind_Reason_Code
+trace_function(struct _Unwind_Context* context, void* ntraced) {
+  (*reinterpret_cast<size_t*>(ntraced))++;
+  // We should never have a call stack this deep...
+  assert(*reinterpret_cast<size_t*>(ntraced) < 20);
+  return _URC_NO_REASON;
+}
+
+void call3_throw(size_t* ntraced) {
+  try {
+    _Unwind_Backtrace(trace_function, ntraced);
+  } catch (...) {
+    assert(false);
+  }
+}
+
+void call3_nothrow(size_t* ntraced) {
+  _Unwind_Backtrace(trace_function, ntraced);
+}
+
+void call2(size_t* ntraced, bool do_throw) {
+  if (do_throw) {
+    call3_throw(ntraced);
+  } else {
+    call3_nothrow(ntraced);
+  }
+}
+
+void call1(size_t* ntraced, bool do_throw) {
+  call2(ntraced, do_throw);
+}
+
+int main() {
+  size_t throw_ntraced = 0;
+  size_t nothrow_ntraced = 0;
+
+  call1(&nothrow_ntraced, false);
+
+  try {
+    call1(&throw_ntraced, true);
+  } catch (...) {
+    assert(false);
+  }
+
+  // Different platforms (and different runtimes) will unwind a different number
+  // of times, so we can't make any better assumptions than this.
+  assert(nothrow_ntraced > 1);
+  assert(throw_ntraced == nothrow_ntraced); // Make sure we unwind through catch
+  return 0;
+}