[libunwind] Improve unwinder stack usage

[rmaprath]

Summary

This patch is generalization of D19920.

A new native-only libunwind variant (selectable through the -DLIBUNWIND_ENABLE_CROSS_UNWINDING=OFF cmake option) is introduced.

The sizes of Registers_xxx and the associated UnwindCursor<A, R> types are strictly matched against the sizes of unw_context_t and unw_cursor_t types defined in libunwind.h. This improves the stack usage of the unwinder as only just enough memory is reserved on the stack to hold the virtual register set on each architecture.

I've locally tested ARM, AArch64, x86 (compile-only) and x86_64 builds of the new variant. Could not perform any testing of PPC or OpenRISK as I couldn't get the cross compiling to work properly. Ideally, we'll have to switch the buildbots to use this new build option so that these strict limits will be validated (and will continue to be validated). This should be fine I think - if the library works for these restricted limits, the general case (which supports cross-unwinding) should follow.

If the patch is accepted, I will start a discussion on cfe-dev about switching the buildbot configurations (I'm assuming we don't have any cross-unwinding buildbot setups).

[rengolin]

include/libunwind.h

49

Wouldn't it be a lot simpler to just define a macro _LIBUNWIND_DATA_SIZE or something and have just one line here?

[rmaprath]

include/libunwind.h

49

Yes (*facepalm*). Will fix.

[rmaprath]

Address review comments by @rengolin:

• Define and use _LIBUNWIND_CONTEXT_SIZE and _LIBUNWIND_CURSOR_SIZE macros

[rmaprath]

Gentle ping.

[rmaprath]

Ping.

[jroelofs]

Just one question, otherwise LGTM:

src/UnwindCursor.hpp

580

Is there a good reason to move this static assert out to libunwind.cpp? ISTM it serves its purpose better here.

[rmaprath]

src/UnwindCursor.hpp

580

I removed this thinking there is already an assert in libunwind.cpp checking the same constraint. Didn't realize the latter assert was something I introduced in the patch!

Will fix.

[rmaprath]

Addressing review comments from @jroelofs:

• Moved the assertion in libunwind.cpp back to UnwindCursor.cpp where it really belogs.

@jroelofs: I just realized that, with this new native-only build of libunwind, users of libunwind.h would have to explicitly #define the flag _LIBUNWIND_IS_NATIVE_ONLY in order to get the header in-sync with the library. I can't see an immediate problem if they don't define that flag though, it's just that they'll end up passing larger buffers than the library needs. Do you see a problem here?

'libc++' uses a __config_site mechanism to wire the cmake build options into the __config header. We can implement a similar mechanism in libunwind, not sure if that's necessary here.

WDYT?

Thanks.

/ Asiri

[rmaprath]

@jroelofs: OK to commit?

Thanks.

/ Asiri

[jroelofs]

In D20119#431997, @rmaprath wrote:

Addressing review comments from @jroelofs:

• Moved the assertion in libunwind.cpp back to UnwindCursor.cpp where it really belogs.

@jroelofs: I just realized that, with this new native-only build of libunwind, users of libunwind.h would have to explicitly #define the flag _LIBUNWIND_IS_NATIVE_ONLY in order to get the header in-sync with the library. I can't see an immediate problem if they don't define that flag though, it's just that they'll end up passing larger buffers than the library needs. Do you see a problem here?

I'm not convinced it's a problem, (though possibly performance left on the table)...

'libc++' uses a __config_site mechanism to wire the cmake build options into the __config header. We can implement a similar mechanism in libunwind, not sure if that's necessary here.

I think that's the right way to go.

Jon

WDYT?

Thanks.

/ Asiri

[rmaprath]

In D20119#436849, @jroelofs wrote:

In D20119#431997, @rmaprath wrote:

Addressing review comments from @jroelofs:

• Moved the assertion in libunwind.cpp back to UnwindCursor.cpp where it really belogs.

@jroelofs: I just realized that, with this new native-only build of libunwind, users of libunwind.h would have to explicitly #define the flag _LIBUNWIND_IS_NATIVE_ONLY in order to get the header in-sync with the library. I can't see an immediate problem if they don't define that flag though, it's just that they'll end up passing larger buffers than the library needs. Do you see a problem here?

I'm not convinced it's a problem, (though possibly performance left on the table)...

'libc++' uses a __config_site mechanism to wire the cmake build options into the __config header. We can implement a similar mechanism in libunwind, not sure if that's necessary here.

I think that's the right way to go.

Jon

WDYT?

Thanks.

/ Asiri

Apologies, it looks like we don't have any targets for installing libunwind.h header (or any other headers from libunwind project for that matter). I think this means we use libunwind.h only for building libunwind+libcxxabi libraries, and there's no need to explicitly adjust libunwind.h header as it is not used from outside as-is. Hope this makes sense.

OK to commit? Sorry for the diversion.

/ Asiri

[jroelofs]

In D20119#437191, @rmaprath wrote:

In D20119#436849, @jroelofs wrote:

In D20119#431997, @rmaprath wrote:

Addressing review comments from @jroelofs:

• Moved the assertion in libunwind.cpp back to UnwindCursor.cpp where it really belogs.

@jroelofs: I just realized that, with this new native-only build of libunwind, users of libunwind.h would have to explicitly #define the flag _LIBUNWIND_IS_NATIVE_ONLY in order to get the header in-sync with the library. I can't see an immediate problem if they don't define that flag though, it's just that they'll end up passing larger buffers than the library needs. Do you see a problem here?

I'm not convinced it's a problem, (though possibly performance left on the table)...

'libc++' uses a __config_site mechanism to wire the cmake build options into the __config header. We can implement a similar mechanism in libunwind, not sure if that's necessary here.

I think that's the right way to go.

Jon

WDYT?

Thanks.

/ Asiri

Apologies, it looks like we don't have any targets for installing libunwind.h header (or any other headers from libunwind project for that matter). I think this means we use libunwind.h only for building libunwind+libcxxabi libraries, and there's no need to explicitly adjust libunwind.h header as it is not used from outside as-is. Hope this makes sense.

OK to commit? Sorry for the diversion.

Ah, ok. LGTM then!

Jon

/ Asiri

[rmaprath]

Committed as r270692. But I forgot to mention this phab review in the commit message. Sigh.

[rmaprath]

Accepted + closed. Patch committed as r270692.

[rmaprath]

Looks like this patch breakes gcc builds of libunwind (none of the bots seem to test it though).

The problem is two-fold, in src/config.h we have:

// Define static_assert() unless already defined by compiler.                                                                                                                                                      
#ifndef __has_feature
  #define __has_feature(__x) 0
#endif
#if !(__has_feature(cxx_static_assert)) && !defined(static_assert)
  #define static_assert(__b, __m) \
      extern int compile_time_assert_failed[ ( __b ) ? 1 : -1 ]  \
                                                  __attribute__( ( unused ) );
#endif

This is not optimal for gcc when targeting -std=c++11, !defined(static_assert) will be false even though the static_assert keyword is present. We can easily fix this by checking for the __cplusplus version instead.

But there is still a problem for compilers that do not support the static_assert keyword, which have to resort to using this macro version of static_assert(x,y). The problem here is that statements like:

static_assert(check_fit<Registers_or1k, unw_context_t>::does_fit,
                "or1k registers do not fit into unw_context_t");

Do not fit into that macro (it thinks we're passing three arguments to a macro that accepts only two - because of the additional comma in the template argument list). I don't see an easy way to address this other than reverting some of the work done in the previous patch.

Do many people care about building libunwind with a compiler that does not support static_assert keyword? If not, I'd prefer to let this slip and get rid of the static_assert macro definition.

Please shout!

[jroelofs]

In D20119#441516, @rmaprath wrote:

Please shout!

Just add some parens:

static_assert((check_fit<Registers_or1k, unw_context_t>::does_fit),
                  "or1k registers do not fit into unw_context_t");

[rmaprath]

In D20119#441548, @jroelofs wrote:

In D20119#441516, @rmaprath wrote:

Please shout!

Just add some parens:

static_assert((check_fit<Registers_or1k, unw_context_t>::does_fit),
                  "or1k registers do not fit into unw_context_t");

Don't know why I didn't try that, works like a charm.

Thanks!

/ Asiri

CMakeLists.txt

 # Setup CMake Options
 #===============================================================================
 
 # Define options.
 option(LIBUNWIND_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)
 option(LIBUNWIND_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LIBUNWIND_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 option(LIBUNWIND_ENABLE_SHARED "Build libunwind as a shared library." ON)
+option(LIBUNWIND_ENABLE_CROSS_UNWINDING "Enable cross-platform unwinding support." ON)
 
 set(LIBUNWIND_GCC_TOOLCHAIN "" CACHE STRING "GCC toolchain for cross compiling.")
 set(LIBUNWIND_SYSROOT "" CACHE STRING "Sysroot for cross compiling.")
 
 #===============================================================================
 # Configure System
 #===============================================================================
 

     list(APPEND LIBUNWIND_COMPILE_FLAGS -UNDEBUG)
   endif ()
 else()
   if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
     list(APPEND LIBUNWIND_COMPILE_FLAGS -DNDEBUG)
   endif ()
 endif ()
 
+# Cross-unwinding
+if (NOT LIBUNWIND_ENABLE_CROSS_UNWINDING)
+  list(APPEND LIBUNWIND_COMPILE_FLAGS -D_LIBUNWIND_IS_NATIVE_ONLY)
+endif ()
+
 # This is the _ONLY_ place where add_definitions is called.
 if (MSVC)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif ()
 
 append_if(LIBUNWIND_COMPILE_FLAGS LIBUNWIND_TARGET_TRIPLE
           "-target ${LIBUNWIND_TARGET_TRIPLE}")
 append_if(LIBUNWIND_COMPILE_FLAGS LIBUNWIND_GCC_TOOLCHAIN

include/__libunwind_config.h

 
 #if defined(__arm__) && !defined(__USING_SJLJ_EXCEPTIONS__) && \
     !defined(__ARM_DWARF_EH__)
 #define _LIBUNWIND_ARM_EHABI 1
 #else
 #define _LIBUNWIND_ARM_EHABI 0
 #endif
 
+#if defined(_LIBUNWIND_IS_NATIVE_ONLY)
+# if defined(__i386__)
+#  define _LIBUNWIND_TARGET_I386 1
+#  define _LIBUNWIND_CONTEXT_SIZE 8
+#  define _LIBUNWIND_CURSOR_SIZE 19
+# elif defined(__x86_64__)
+#  define _LIBUNWIND_TARGET_X86_64 1
+#  define _LIBUNWIND_CONTEXT_SIZE 21
+#  define _LIBUNWIND_CURSOR_SIZE 33
+# elif defined(__ppc__)
+#  define _LIBUNWIND_TARGET_PPC 1
+#  define _LIBUNWIND_CONTEXT_SIZE 117
+#  define _LIBUNWIND_CURSOR_SIZE 128
+# elif defined(__aarch64__)
+#  define _LIBUNWIND_TARGET_AARCH64 1
+#  define _LIBUNWIND_CONTEXT_SIZE 66
+#  define _LIBUNWIND_CURSOR_SIZE 78
+# elif defined(__arm__)
+#  define _LIBUNWIND_TARGET_ARM 1
+#  define _LIBUNWIND_CONTEXT_SIZE 60
+#  define _LIBUNWIND_CURSOR_SIZE 67
+# elif defined(__or1k__)
+#  define _LIBUNWIND_TARGET_OR1K 1
+#  define _LIBUNWIND_CONTEXT_SIZE 16
+#  define _LIBUNWIND_CURSOR_SIZE 28
+# else
+#  error "Unsupported architecture."
+# endif
+#else // !_LIBUNWIND_IS_NATIVE_ONLY
+# define _LIBUNWIND_TARGET_I386 1
+# define _LIBUNWIND_TARGET_X86_64 1
+# define _LIBUNWIND_TARGET_PPC 1
+# define _LIBUNWIND_TARGET_AARCH64 1
+# define _LIBUNWIND_TARGET_ARM 1
+# define _LIBUNWIND_TARGET_OR1K 1
+# define _LIBUNWIND_CONTEXT_SIZE 128
+# define _LIBUNWIND_CURSOR_SIZE 140
+#endif // _LIBUNWIND_IS_NATIVE_ONLY
+
 #endif // ____LIBUNWIND_CONFIG_H__

include/libunwind.h

   UNW_EINVALIDIP    = -6545, /* invalid IP */
   UNW_EBADFRAME     = -6546, /* bad frame */
   UNW_EINVAL        = -6547, /* unsupported operation or bad value */
   UNW_EBADVERSION   = -6548, /* unwind info has unsupported version */
   UNW_ENOINFO       = -6549  /* no unwind info found */
 };
 
 struct unw_context_t {
-  uint64_t data[128];
+  uint64_t data[_LIBUNWIND_CONTEXT_SIZE];
 };
 typedef struct unw_context_t unw_context_t;
 
 struct unw_cursor_t {
-  uint64_t data[140];
+  uint64_t data[_LIBUNWIND_CURSOR_SIZE];
 };
 typedef struct unw_cursor_t unw_cursor_t;
 
 typedef struct unw_addr_space *unw_addr_space_t;
 
 typedef int unw_regnum_t;
 #if _LIBUNWIND_ARM_EHABI
 typedef uint32_t unw_word_t;

src/CompactUnwinder.hpp

 #include "AddressSpace.hpp"
 #include "Registers.hpp"
 
 #define EXTRACT_BITS(value, mask)                                              \
   ((value >> __builtin_ctz(mask)) & (((1 << __builtin_popcount(mask))) - 1))
 
 namespace libunwind {
 
+#if defined(_LIBUNWIND_TARGET_I386)
 /// CompactUnwinder_x86 uses a compact unwind info to virtually "step" (aka
 /// unwind) by modifying a Registers_x86 register set
 template <typename A>
 class CompactUnwinder_x86 {
 public:
 
   static int stepWithCompactEncoding(compact_unwind_encoding_t info,
                                      uint32_t functionStart, A &addressSpace,

 void CompactUnwinder_x86<A>::framelessUnwind(
     A &addressSpace, typename A::pint_t returnAddressLocation,
     Registers_x86 &registers) {
   // return address is on stack after last saved register
   registers.setIP(addressSpace.get32(returnAddressLocation));
   // old esp is before return address
   registers.setSP((uint32_t)returnAddressLocation + 4);
 }
+#endif // _LIBUNWIND_TARGET_I386
 
 
+#if defined(_LIBUNWIND_TARGET_X86_64)
 /// CompactUnwinder_x86_64 uses a compact unwind info to virtually "step" (aka
 /// unwind) by modifying a Registers_x86_64 register set
 template <typename A>
 class CompactUnwinder_x86_64 {
 public:
 
   static int stepWithCompactEncoding(compact_unwind_encoding_t compactEncoding,
                                      uint64_t functionStart, A &addressSpace,

 void CompactUnwinder_x86_64<A>::framelessUnwind(A &addressSpace,
                                                 uint64_t returnAddressLocation,
                                                 Registers_x86_64 &registers) {
   // return address is on stack after last saved register
   registers.setIP(addressSpace.get64(returnAddressLocation));
   // old esp is before return address
   registers.setSP(returnAddressLocation + 8);
 }
+#endif // _LIBUNWIND_TARGET_X86_64
 
 
 
+#if defined(_LIBUNWIND_TARGET_AARCH64)
 /// CompactUnwinder_arm64 uses a compact unwind info to virtually "step" (aka
 /// unwind) by modifying a Registers_arm64 register set
 template <typename A>
 class CompactUnwinder_arm64 {
 public:
 
   static int stepWithCompactEncoding(compact_unwind_encoding_t compactEncoding,
                                      uint64_t functionStart, A &addressSpace,

   registers.setFP(addressSpace.get64(fp));
   // old sp is fp less saved fp and lr
   registers.setSP(fp + 16);
   // pop return address into pc
   registers.setIP(addressSpace.get64(fp + 8));
 
   return UNW_STEP_SUCCESS;
 }
+#endif // _LIBUNWIND_TARGET_AARCH64
 
 
 } // namespace libunwind
 
 #endif // __COMPACT_UNWINDER_HPP__

src/Registers.hpp

 #include "config.h"
 
 namespace libunwind {
 
 // For emulating 128-bit registers
 struct v128 { uint32_t vec[4]; };
 
 
+#if defined(_LIBUNWIND_TARGET_I386)
 /// Registers_x86 holds the register state of a thread in a 32-bit intel
 /// process.
 class _LIBUNWIND_HIDDEN Registers_x86 {
 public:
   Registers_x86();
   Registers_x86(const void *registers);
 
   bool        validRegister(int num) const;

     unsigned int __fs;
     unsigned int __gs;
   };
 
   GPRs _registers;
 };
 
 inline Registers_x86::Registers_x86(const void *registers) {
-  static_assert(sizeof(Registers_x86) < sizeof(unw_context_t),
-                    "x86 registers do not fit into unw_context_t");
+  static_assert(check_fit<Registers_x86, unw_context_t>::does_fit,
   memcpy(&_registers, registers, sizeof(_registers));
 }
 
 inline Registers_x86::Registers_x86() {
   memset(&_registers, 0, sizeof(_registers));
 }
 
 inline bool Registers_x86::validRegister(int regNum) const {

 
 inline v128 Registers_x86::getVectorRegister(int) const {
   _LIBUNWIND_ABORT("no x86 vector registers");
 }
 
 inline void Registers_x86::setVectorRegister(int, v128) {
   _LIBUNWIND_ABORT("no x86 vector registers");
 }
+#endif // _LIBUNWIND_TARGET_I386
 
 
+#if defined(_LIBUNWIND_TARGET_X86_64)
 /// Registers_x86_64  holds the register state of a thread in a 64-bit intel
 /// process.
 class _LIBUNWIND_HIDDEN Registers_x86_64 {
 public:
   Registers_x86_64();
   Registers_x86_64(const void *registers);
 
   bool        validRegister(int num) const;

     uint64_t __cs;
     uint64_t __fs;
     uint64_t __gs;
   };
   GPRs _registers;
 };
 
 inline Registers_x86_64::Registers_x86_64(const void *registers) {
-  static_assert(sizeof(Registers_x86_64) < sizeof(unw_context_t),
-                    "x86_64 registers do not fit into unw_context_t");
+  static_assert(check_fit<Registers_x86_64, unw_context_t>::does_fit,
   memcpy(&_registers, registers, sizeof(_registers));
 }
 
 inline Registers_x86_64::Registers_x86_64() {
   memset(&_registers, 0, sizeof(_registers));
 }
 
 inline bool Registers_x86_64::validRegister(int regNum) const {

 
 inline v128 Registers_x86_64::getVectorRegister(int) const {
   _LIBUNWIND_ABORT("no x86_64 vector registers");
 }
 
 inline void Registers_x86_64::setVectorRegister(int, v128) {
   _LIBUNWIND_ABORT("no x86_64 vector registers");
 }
+#endif // _LIBUNWIND_TARGET_X86_64
 
 
+#if defined(_LIBUNWIND_TARGET_PPC)
 /// Registers_ppc holds the register state of a thread in a 32-bit PowerPC
 /// process.
 class _LIBUNWIND_HIDDEN Registers_ppc {
 public:
   Registers_ppc();
   Registers_ppc(const void *registers);
 
   bool        validRegister(int num) const;

   };
 
   ppc_thread_state_t _registers;
   ppc_float_state_t  _floatRegisters;
   v128               _vectorRegisters[32]; // offset 424
 };
 
 inline Registers_ppc::Registers_ppc(const void *registers) {
-  static_assert(sizeof(Registers_ppc) < sizeof(unw_context_t),
-                    "ppc registers do not fit into unw_context_t");
+  static_assert(check_fit<Registers_ppc, unw_context_t>::does_fit,
   memcpy(&_registers, static_cast<const uint8_t *>(registers),
          sizeof(_registers));
   static_assert(sizeof(ppc_thread_state_t) == 160,
                 "expected float register offset to be 160");
   memcpy(&_floatRegisters,
          static_cast<const uint8_t *>(registers) + sizeof(ppc_thread_state_t),
          sizeof(_floatRegisters));
   static_assert(sizeof(ppc_thread_state_t) + sizeof(ppc_float_state_t) == 424,

     return "fp31";
   case UNW_PPC_LR:
     return "lr";
   default:
     return "unknown register";
   }
 
 }
+#endif // _LIBUNWIND_TARGET_PPC
 
 
+#if defined(_LIBUNWIND_TARGET_AARCH64)
 /// Registers_arm64  holds the register state of a thread in a 64-bit arm
 /// process.
 class _LIBUNWIND_HIDDEN Registers_arm64 {
 public:
   Registers_arm64();
   Registers_arm64(const void *registers);
 
   bool        validRegister(int num) const;

   double  _vectorHalfRegisters[32];
   // Currently only the lower double in 128-bit vectore registers
   // is perserved during unwinding.  We could define new register
   // numbers (> 96) which mean whole vector registers, then this
   // struct would need to change to contain whole vector registers.
 };
 
 inline Registers_arm64::Registers_arm64(const void *registers) {
-  static_assert(sizeof(Registers_arm64) < sizeof(unw_context_t),
-                    "arm64 registers do not fit into unw_context_t");
+  static_assert(check_fit<Registers_arm64, unw_context_t>::does_fit,
   memcpy(&_registers, registers, sizeof(_registers));
   static_assert(sizeof(GPRs) == 0x110,
                 "expected VFP registers to be at offset 272");
   memcpy(_vectorHalfRegisters,
          static_cast<const uint8_t *>(registers) + sizeof(GPRs),
          sizeof(_vectorHalfRegisters));
 }
 

 
 inline v128 Registers_arm64::getVectorRegister(int) const {
   _LIBUNWIND_ABORT("no arm64 vector register support yet");
 }
 
 inline void Registers_arm64::setVectorRegister(int, v128) {
   _LIBUNWIND_ABORT("no arm64 vector register support yet");
 }
+#endif // _LIBUNWIND_TARGET_AARCH64
 
+#if defined(_LIBUNWIND_TARGET_ARM)
 /// Registers_arm holds the register state of a thread in a 32-bit arm
 /// process.
 ///
 /// NOTE: Assumes VFPv3. On ARM processors without a floating point unit,
 /// this uses more memory than required.
 class _LIBUNWIND_HIDDEN Registers_arm {
 public:
   Registers_arm();

 };
 
 inline Registers_arm::Registers_arm(const void *registers)
   : _use_X_for_vfp_save(false),
     _saved_vfp_d0_d15(false),
     _saved_vfp_d16_d31(false),
     _saved_iwmmx(false),
     _saved_iwmmx_control(false) {
-  static_assert(sizeof(Registers_arm) < sizeof(unw_context_t),
-                    "arm registers do not fit into unw_context_t");
+  static_assert(check_fit<Registers_arm, unw_context_t>::does_fit,
   // See unw_getcontext() note about data.
   memcpy(&_registers, registers, sizeof(_registers));
   memset(&_vfp_d0_d15_pad, 0, sizeof(_vfp_d0_d15_pad));
   memset(&_vfp_d16_d31, 0, sizeof(_vfp_d16_d31));
   memset(&_iwmmx, 0, sizeof(_iwmmx));
   memset(&_iwmmx_control, 0, sizeof(_iwmmx_control));
 }
 

 
 inline v128 Registers_arm::getVectorRegister(int) const {
   _LIBUNWIND_ABORT("ARM vector support not implemented");
 }
 
 inline void Registers_arm::setVectorRegister(int, v128) {
   _LIBUNWIND_ABORT("ARM vector support not implemented");
 }
+#endif // _LIBUNWIND_TARGET_ARM
+
+
+#if defined(_LIBUNWIND_TARGET_OR1K)
 /// Registers_or1k holds the register state of a thread in an OpenRISC1000
 /// process.
 class _LIBUNWIND_HIDDEN Registers_or1k {
 public:
   Registers_or1k();
   Registers_or1k(const void *registers);
 
   bool        validRegister(int num) const;

   struct or1k_thread_state_t {
     unsigned int __r[32];
   };
 
   or1k_thread_state_t _registers;
 };
 
 inline Registers_or1k::Registers_or1k(const void *registers) {
-  static_assert(sizeof(Registers_or1k) < sizeof(unw_context_t),
-                    "or1k registers do not fit into unw_context_t");
+  static_assert(check_fit<Registers_or1k, unw_context_t>::does_fit,
   memcpy(&_registers, static_cast<const uint8_t *>(registers),
          sizeof(_registers));
 }
 
 inline Registers_or1k::Registers_or1k() {
   memset(&_registers, 0, sizeof(_registers));
 }
 

     return "r30";
   case UNW_OR1K_R31:
     return "r31";
   default:
     return "unknown register";
   }
 
 }
+#endif // _LIBUNWIND_TARGET_OR1K
 } // namespace libunwind
 
 #endif // __REGISTERS_HPP__

src/UnwindCursor.hpp

   #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
     if ( compactSaysUseDwarf() )
       return stepWithDwarfFDE();
   #endif
     R dummy;
     return stepWithCompactEncoding(dummy);
   }
 
+#if defined(_LIBUNWIND_TARGET_X86_64)
   int stepWithCompactEncoding(Registers_x86_64 &) {
     return CompactUnwinder_x86_64<A>::stepWithCompactEncoding(
         _info.format, _info.start_ip, _addressSpace, _registers);
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_I386)
   int stepWithCompactEncoding(Registers_x86 &) {
     return CompactUnwinder_x86<A>::stepWithCompactEncoding(
         _info.format, (uint32_t)_info.start_ip, _addressSpace, _registers);
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_PPC)
   int stepWithCompactEncoding(Registers_ppc &) {
     return UNW_EINVAL;
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_AARCH64)
   int stepWithCompactEncoding(Registers_arm64 &) {
     return CompactUnwinder_arm64<A>::stepWithCompactEncoding(
         _info.format, _info.start_ip, _addressSpace, _registers);
   }
+#endif
 
   bool compactSaysUseDwarf(uint32_t *offset=NULL) const {
     R dummy;
     return compactSaysUseDwarf(dummy, offset);
   }
 
+#if defined(_LIBUNWIND_TARGET_X86_64)
   bool compactSaysUseDwarf(Registers_x86_64 &, uint32_t *offset) const {
     if ((_info.format & UNWIND_X86_64_MODE_MASK) == UNWIND_X86_64_MODE_DWARF) {
       if (offset)
         *offset = (_info.format & UNWIND_X86_64_DWARF_SECTION_OFFSET);
       return true;
     }
     return false;
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_I386)
   bool compactSaysUseDwarf(Registers_x86 &, uint32_t *offset) const {
     if ((_info.format & UNWIND_X86_MODE_MASK) == UNWIND_X86_MODE_DWARF) {
       if (offset)
         *offset = (_info.format & UNWIND_X86_DWARF_SECTION_OFFSET);
       return true;
     }
     return false;
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_PPC)
   bool compactSaysUseDwarf(Registers_ppc &, uint32_t *) const {
     return true;
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_AARCH64)
   bool compactSaysUseDwarf(Registers_arm64 &, uint32_t *offset) const {
     if ((_info.format & UNWIND_ARM64_MODE_MASK) == UNWIND_ARM64_MODE_DWARF) {
       if (offset)
         *offset = (_info.format & UNWIND_ARM64_DWARF_SECTION_OFFSET);
       return true;
     }
     return false;
   }
+#endif
 #endif // _LIBUNWIND_SUPPORT_COMPACT_UNWIND
 
 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
   compact_unwind_encoding_t dwarfEncoding() const {
     R dummy;
     return dwarfEncoding(dummy);
   }
 
+#if defined(_LIBUNWIND_TARGET_X86_64)
   compact_unwind_encoding_t dwarfEncoding(Registers_x86_64 &) const {
     return UNWIND_X86_64_MODE_DWARF;
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_I386)
   compact_unwind_encoding_t dwarfEncoding(Registers_x86 &) const {
     return UNWIND_X86_MODE_DWARF;
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_PPC)
   compact_unwind_encoding_t dwarfEncoding(Registers_ppc &) const {
     return 0;
   }
+#endif
 
+#if defined(_LIBUNWIND_TARGET_AARCH64)
   compact_unwind_encoding_t dwarfEncoding(Registers_arm64 &) const {
     return UNWIND_ARM64_MODE_DWARF;
   }
+#endif
 
+#if defined (_LIBUNWIND_TARGET_OR1K)
   compact_unwind_encoding_t dwarfEncoding(Registers_or1k &) const {
     return 0;
   }
+#endif
 #endif // _LIBUNWIND_SUPPORT_DWARF_UNWIND
 
 
   A               &_addressSpace;
   R                _registers;
   unw_proc_info_t  _info;
   bool             _unwindInfoMissing;
   bool             _isSignalFrame;
 };
 
 
 template <typename A, typename R>
 UnwindCursor<A, R>::UnwindCursor(unw_context_t *context, A &as)
     : _addressSpace(as), _registers(context), _unwindInfoMissing(false),
       _isSignalFrame(false) {
-  static_assert(sizeof(UnwindCursor<A, R>) < sizeof(unw_cursor_t),
+  static_assert(check_fit<UnwindCursor<A, R>, unw_cursor_t>::does_fit,
                 "UnwindCursor<> does not fit in unw_cursor_t");
   memset(&_info, 0, sizeof(_info));
 }
 
 template <typename A, typename R>
 UnwindCursor<A, R>::UnwindCursor(A &as, void *)
     : _addressSpace(as), _unwindInfoMissing(false), _isSignalFrame(false) {
   memset(&_info, 0, sizeof(_info));

src/config.h

             } while(0)
   #define _LIBUNWIND_TRACE_UNWINDING(msg, ...) \
             do { \
               if ( logUnwinding() ) _LIBUNWIND_LOG(msg, __VA_ARGS__); \
             } while(0)
   #define _LIBUNWIND_TRACING_UNWINDING logUnwinding()
 #endif
 
+#ifdef __cplusplus
+// Used to fit UnwindCursor and Registers_xxx types against unw_context_t /
+// unw_cursor_t sized memory blocks.
+#if defined(_LIBUNWIND_IS_NATIVE_ONLY)
+# define COMP_OP ==
+#else
+# define COMP_OP <
+#endif
+template <typename _Type, typename _Mem>
+struct check_fit {
+  template <typename T>
+  struct blk_count {
+    static const uint32_t count =
+      (sizeof(T) + sizeof(uint64_t) - 1) / sizeof(uint64_t);
+  };
+  static const bool does_fit =
+    (blk_count<_Type>::count COMP_OP blk_count<_Mem>::count);
+};
+#undef COMP_OP
+#endif // __cplusplus
 
 #endif // LIBUNWIND_CONFIG_H

src/libunwind.cpp

 
 /// Create a cursor of a thread in this process given 'context' recorded by
 /// unw_getcontext().
 _LIBUNWIND_EXPORT int unw_init_local(unw_cursor_t *cursor,
                                      unw_context_t *context) {
   _LIBUNWIND_TRACE_API("unw_init_local(cursor=%p, context=%p)\n",
                        static_cast<void *>(cursor),
                        static_cast<void *>(context));
-  // Use "placement new" to allocate UnwindCursor in the cursor buffer.
 #if defined(__i386__)
-  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_x86>(
-                                 context, LocalAddressSpace::sThisAddressSpace);
+# define REGISTER_KIND Registers_x86
 #elif defined(__x86_64__)
-  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_x86_64>(
-                                 context, LocalAddressSpace::sThisAddressSpace);
+# define REGISTER_KIND Registers_x86_64
 #elif defined(__ppc__)
-  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_ppc>(
-                                 context, LocalAddressSpace::sThisAddressSpace);
-#elif defined(__arm64__) || defined(__aarch64__)
-  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm64>(
-                                 context, LocalAddressSpace::sThisAddressSpace);
+# define REGISTER_KIND Registers_ppc
+#elif defined(__aarch64__)
+# define REGISTER_KIND Registers_arm64
 #elif _LIBUNWIND_ARM_EHABI
-  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm>(
-                                 context, LocalAddressSpace::sThisAddressSpace);
+# define REGISTER_KIND Registers_arm
 #elif defined(__or1k__)
-  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_or1k>(
-                                 context, LocalAddressSpace::sThisAddressSpace);
+# define REGISTER_KIND Registers_or1k
 #elif defined(__mips__)
-#warning The MIPS architecture is not supported.
+# warning The MIPS architecture is not supported.
 #else
-#error Architecture not supported
+# error Architecture not supported
 #endif
+  // Use "placement new" to allocate UnwindCursor in the cursor buffer.
+  new ((void *)cursor) UnwindCursor<LocalAddressSpace, REGISTER_KIND>(
+                                 context, LocalAddressSpace::sThisAddressSpace);
+#undef REGISTER_KIND
   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
   co->setInfoBasedOnIPRegister();
 
   return UNW_ESUCCESS;
 }
 
 #ifdef UNW_REMOTE
 /// Create a cursor into a thread in another process.