libunwind: Introduce __libunwind_config.h.

[logan]

Summary

Introduce __libunwind_config.h to avoid cross repository circular
dependency with libcxxabi.

[danalbert]

Hmm. Looks like there will need to be some cleanup in libcxx/cmake/Modules/HandleLibCXXABI.cmake before this can happen.

Right now the C++ ABI headers get installed as part of the libc++ build, and we adjust that as necessary for each ABI library we support, but there isn't any support to vary it by unwinder (and really the whole thing is a hack).

[logan]

@danalbert:

May you further elaborate your idea? I don't quite understand why should we install the headers of libunwind for libcxx?

[rengolin]

Hi Logan,

Is this replacing or complementing the libc++abi definitions?

I was expecting some changes in the CMake files of the projects describing the lack of dependency, or is that done automatically?

cheers,
--renato

[danalbert]

Actually, I don't think there's an issue here from the libc++ side of things; we already don't install any of the libunwind headers (though libcxxrt does, so maybe we should?).

My concern was: https://github.com/llvm-mirror/libcxx/blob/master/cmake/Modules/HandleLibCXXABI.cmake#L92

We install libc++abi headers there, and for libcxxrt we also install the unwind headers there. Since this isn't already broken, presumably libunwind is already properly separated to not need them there.

Still, as Renato says, we should be installing the libunwind headers somewhere. Since we don't do any of that yet though, I think it's reasonable to save that for a different patch.

[rengolin]

In D11230#206527, @danalbert wrote:

Since we don't do any of that yet though, I think it's reasonable to save that for a different patch.

Agreed. LGTM.

[asl]

+1

[logan]

Thanks for reviewing!

Committed as rL242642.

include/__libunwind_config.h

+//===------------------------- __libunwind_config.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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ____LIBUNWIND_CONFIG_H__
+#define ____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
+
+#endif // ____LIBUNWIND_CONFIG_H__

include/libunwind.h

 //===---------------------------- libunwind.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.
 //
 //
 // Compatible with libuwind API documented at:
 //   http://www.nongnu.org/libunwind/man/libunwind(3).html
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __LIBUNWIND__
 #define __LIBUNWIND__
 
+#include <__libunwind_config.h>
+
 #include <stdint.h>
 #include <stddef.h>
 
-#include <__cxxabi_config.h>
-
 #ifdef __APPLE__
   #include <Availability.h>
     #ifdef __arm__
        #define LIBUNWIND_AVAIL __attribute__((unavailable))
     #else
       #define LIBUNWIND_AVAIL __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_5_0)
     #endif
 #else

 struct unw_cursor_t {
   uint64_t data[140];
 };
 typedef struct unw_cursor_t unw_cursor_t;
 
 typedef struct unw_addr_space *unw_addr_space_t;
 
 typedef int unw_regnum_t;
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
 typedef uint32_t unw_word_t;
 typedef uint64_t unw_fpreg_t;
 #else
 typedef uint64_t unw_word_t;
 typedef double unw_fpreg_t;
 #endif
 
 struct unw_proc_info_t {

include/unwind.h

 //===------------------------------- unwind.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.
 //
 //
 // C++ ABI Level 1 ABI documented at:
 //   http://mentorembedded.github.io/cxx-abi/abi-eh.html
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __UNWIND_H__
 #define __UNWIND_H__
 
+#include <__libunwind_config.h>
+
 #include <stdint.h>
 #include <stddef.h>
 
 #if defined(__APPLE__)
 #define LIBUNWIND_UNAVAIL __attribute__ (( unavailable ))
 #else
 #define LIBUNWIND_UNAVAIL
 #endif
 
-#include <__cxxabi_config.h>
-
 typedef enum {
   _URC_NO_REASON = 0,
   _URC_OK = 0,
   _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
   _URC_FATAL_PHASE2_ERROR = 2,
   _URC_FATAL_PHASE1_ERROR = 3,
   _URC_NORMAL_STOP = 4,
   _URC_END_OF_STACK = 5,
   _URC_HANDLER_FOUND = 6,
   _URC_INSTALL_CONTEXT = 7,
   _URC_CONTINUE_UNWIND = 8,
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
   _URC_FAILURE = 9
 #endif
 } _Unwind_Reason_Code;
 
 typedef enum {
   _UA_SEARCH_PHASE = 1,
   _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 LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
 typedef uint32_t _Unwind_State;
 
 static const _Unwind_State _US_VIRTUAL_UNWIND_FRAME   = 0;
 static const _Unwind_State _US_UNWIND_FRAME_STARTING  = 1;
 static const _Unwind_State _US_UNWIND_FRAME_RESUME    = 2;
 /* Undocumented flag for force unwinding. */
 static const _Unwind_State _US_FORCE_UNWIND           = 8;
 

 extern void _Unwind_SjLj_Resume(_Unwind_Exception *exception_object);
 #else
 extern _Unwind_Reason_Code
     _Unwind_RaiseException(_Unwind_Exception *exception_object);
 extern void _Unwind_Resume(_Unwind_Exception *exception_object);
 #endif
 extern void _Unwind_DeleteException(_Unwind_Exception *exception_object);
 
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
 typedef enum {
   _UVRSC_CORE = 0, /* integer register */
   _UVRSC_VFP = 1, /* vfp */
   _UVRSC_WMMXD = 3, /* Intel WMMX data register */
   _UVRSC_WMMXC = 4 /* Intel WMMX control register */
 } _Unwind_VRS_RegClass;
 
 typedef enum {

src/AddressSpace.hpp

 }
 #endif
 
 #include "libunwind.h"
 #include "config.h"
 #include "dwarf2.h"
 #include "Registers.hpp"
 
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
 #ifdef __linux__
 
 typedef long unsigned int *_Unwind_Ptr;
 extern "C" _Unwind_Ptr __gnu_Unwind_Find_exidx(_Unwind_Ptr addr, int *len);
 
 // Emulate the BSD dl_unwind_find_exidx API when on a GNU libdl system.
 #define dl_unwind_find_exidx __gnu_Unwind_Find_exidx
 
 #elif !defined(_LIBUNWIND_IS_BAREMETAL)
 #include <link.h>
 #else // !defined(_LIBUNWIND_IS_BAREMETAL)
 // When statically linked on bare-metal, the symbols for the EH table are looked
 // up without going through the dynamic loader.
 struct EHTEntry {
   uint32_t functionOffset;
   uint32_t unwindOpcodes;
 };
 extern EHTEntry __exidx_start;
 extern EHTEntry __exidx_end;
 #endif // !defined(_LIBUNWIND_IS_BAREMETAL)
-#endif  // LIBCXXABI_ARM_EHABI
+#endif // _LIBUNWIND_ARM_EHABI
 
 #if defined(__CloudABI__) || defined(__FreeBSD__) || defined(__linux__)
 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND && _LIBUNWIND_SUPPORT_DWARF_INDEX
 #include <link.h>
 // Macro for machine-independent access to the ELF program headers. This
 // macro is not available on some systems (e.g., FreeBSD). On these
 // systems the data structures are just called Elf_XXX. Define ElfW()
 // locally.

 #if _LIBUNWIND_SUPPORT_DWARF_INDEX
   uintptr_t       dwarf_index_section;
   uintptr_t       dwarf_index_section_length;
 #endif
 #if _LIBUNWIND_SUPPORT_COMPACT_UNWIND
   uintptr_t       compact_unwind_section;
   uintptr_t       compact_unwind_section_length;
 #endif
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
   uintptr_t       arm_section;
   uintptr_t       arm_section_length;
 #endif
 };
 
 
 /// LocalAddressSpace is used as a template parameter to UnwindCursor when
 /// unwinding a thread in the same process.  The wrappers compile away,

  #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
     info.dwarf_section                 = (uintptr_t)dyldInfo.dwarf_section;
     info.dwarf_section_length          = dyldInfo.dwarf_section_length;
  #endif
     info.compact_unwind_section        = (uintptr_t)dyldInfo.compact_unwind_section;
     info.compact_unwind_section_length = dyldInfo.compact_unwind_section_length;
     return true;
   }
-#elif LIBCXXABI_ARM_EHABI
+#elif _LIBUNWIND_ARM_EHABI
  #ifdef _LIBUNWIND_IS_BAREMETAL
   // Bare metal is statically linked, so no need to ask the dynamic loader
   info.arm_section =        (uintptr_t)(&__exidx_start);
   info.arm_section_length = (uintptr_t)(&__exidx_end - &__exidx_start);
  #else
   int length = 0;
   info.arm_section = (uintptr_t) dl_unwind_find_exidx(
       (_Unwind_Ptr) targetAddr, &length);

src/Unwind-EHABI.h

 //===------------------------- Unwind-EHABI.hpp ---------------------------===//
 //
 //                     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.
 //
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __UNWIND_EHABI_H__
 #define __UNWIND_EHABI_H__
 
-#include <__cxxabi_config.h>
+#include <__libunwind_config.h>
 
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
 
 #include <stdint.h>
 #include <unwind.h>
 
 // Unable to unwind in the ARM index table (section 5 EHABI).
 #define UNW_EXIDX_CANTUNWIND 0x1
 
 static inline uint32_t signExtendPrel31(uint32_t data) {

 
 extern _Unwind_Reason_Code __aeabi_unwind_cpp_pr2(
     _Unwind_State state, _Unwind_Control_Block *ucbp, _Unwind_Context *context);
 
 #if defined(__cplusplus)
 } // extern "C"
 #endif
 
-#endif // LIBCXXABI_ARM_EHABI
+#endif // _LIBUNWIND_ARM_EHABI
 
 #endif  // __UNWIND_EHABI_H__

src/Unwind-EHABI.cpp

 //===--------------------------- Unwind-EHABI.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.
 //
 //
 //  Implements ARM zero-cost C++ exceptions
 //
 //===----------------------------------------------------------------------===//
 
 #include "Unwind-EHABI.h"
 
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
 
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <type_traits>
unwind_phase1(unw_context_t *uc, _Unwind_Exception *exception_object) {
   // Instead, they are passed the original |uc| and they create a new VRS
   // from scratch thus achieving the same effect.
   unw_cursor_t cursor1;
   unw_init_local(&cursor1, uc);
 
   // Walk each frame looking for a place to stop.
   for (bool handlerNotFound = true; handlerNotFound;) {
 
-#if !LIBCXXABI_ARM_EHABI
+#if !_LIBUNWIND_ARM_EHABI
     // Ask libuwind to get next frame (skip over first which is
     // _Unwind_RaiseException).
     int stepResult = unw_step(&cursor1);
     if (stepResult == 0) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_step() reached "
                                  "bottom => _URC_END_OF_STACK\n",
                                  static_cast<void *>(exception_object));
       return _URC_END_OF_STACK;
if (resume && frame_count == 1) {
       // for. After this, continue unwinding as if normal.
       //
       // See #7.4.6 for details.
       unw_set_reg(&cursor2, UNW_REG_IP,
                   exception_object->unwinder_cache.reserved2);
       resume = false;
     }
 
-#if !LIBCXXABI_ARM_EHABI
+#if !_LIBUNWIND_ARM_EHABI
     int stepResult = unw_step(&cursor2);
     if (stepResult == 0) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_step() reached "
                                  "bottom => _URC_END_OF_STACK\n",
                                  static_cast<void *>(exception_object));
       return _URC_END_OF_STACK;
     } else if (stepResult < 0) {
       _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_step failed => "

 __gnu_unwind_frame(_Unwind_Exception *exception_object,
                    struct _Unwind_Context *context) {
   unw_cursor_t *cursor = (unw_cursor_t *)context;
   if (unw_step(cursor) != UNW_STEP_SUCCESS)
     return _URC_FAILURE;
   return _URC_OK;
 }
 
-#endif  // LIBCXXABI_ARM_EHABI
+#endif  // _LIBUNWIND_ARM_EHABI

src/UnwindCursor.hpp

public:
   virtual void        setInfoBasedOnIPRegister(bool isReturnAddress = false);
   virtual const char *getRegisterName(int num);
 #ifdef __arm__
   virtual void        saveVFPAsX();
 #endif
 
 private:
 
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
   bool getInfoFromEHABISection(pint_t pc, const UnwindInfoSections &sects);
 
   int stepWithEHABI() {
     size_t len = 0;
     size_t off = 0;
     // FIXME: Calling decode_eht_entry() here is violating the libunwind
     // abstraction layer.
     const uint32_t *ehtp =

 const char *UnwindCursor<A, R>::getRegisterName(int regNum) {
   return _registers.getRegisterName(regNum);
 }
 
 template <typename A, typename R> bool UnwindCursor<A, R>::isSignalFrame() {
   return _isSignalFrame;
 }
 
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
 struct EHABIIndexEntry {
   uint32_t functionOffset;
   uint32_t data;
 };
 
 template<typename A>
 struct EHABISectionIterator {
   typedef EHABISectionIterator _Self;
bool UnwindCursor<A, R>::getInfoFromCompactEncodingSection(pint_t pc,
   return true;
 }
 #endif // _LIBUNWIND_SUPPORT_COMPACT_UNWIND
 
 
 template <typename A, typename R>
 void UnwindCursor<A, R>::setInfoBasedOnIPRegister(bool isReturnAddress) {
   pint_t pc = (pint_t)this->getReg(UNW_REG_IP);
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
   // Remove the thumb bit so the IP represents the actual instruction address.
   // This matches the behaviour of _Unwind_GetIP on arm.
   pc &= (pint_t)~0x1;
 #endif
 
   // If the last line of a function is a "throw" the compiler sometimes
   // emits no instructions after the call to __cxa_throw.  This means
   // the return address is actually the start of the next function.
#if _LIBUNWIND_SUPPORT_DWARF_UNWIND
     if (sects.dwarf_section != 0) {
       if (this->getInfoFromDwarfSection(pc, sects)) {
         // found info in dwarf, done
         return;
       }
     }
 #endif
 
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
     // If there is ARM EHABI unwind info, look there next.
     if (sects.arm_section != 0 && this->getInfoFromEHABISection(pc, sects))
       return;
 #endif
   }
 
 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
   // There is no static unwind info for this pc. Look to see if an FDE was
if (_unwindInfoMissing)
     return UNW_STEP_END;
 
   // Use unwinding info to modify register set as if function returned.
   int result;
 #if _LIBUNWIND_SUPPORT_COMPACT_UNWIND
   result = this->stepWithCompactEncoding();
 #elif _LIBUNWIND_SUPPORT_DWARF_UNWIND
   result = this->stepWithDwarfFDE();
-#elif LIBCXXABI_ARM_EHABI
+#elif _LIBUNWIND_ARM_EHABI
   result = this->stepWithEHABI();
 #else
   #error Need _LIBUNWIND_SUPPORT_COMPACT_UNWIND or \
               _LIBUNWIND_SUPPORT_DWARF_UNWIND or \
-              LIBCXXABI_ARM_EHABI
+              _LIBUNWIND_ARM_EHABI
 #endif
 
   // update info based on new PC
   if (result == UNW_STEP_SUCCESS) {
     this->setInfoBasedOnIPRegister(true);
     if (_unwindInfoMissing)
       return UNW_STEP_END;
     if (_info.gp)

src/UnwindLevel1-gcc-ext.c

 #include "Unwind-EHABI.h"
 #include "unwind.h"
 
 #if _LIBUNWIND_BUILD_ZERO_COST_APIS
 
 ///  Called by __cxa_rethrow().
 _LIBUNWIND_EXPORT _Unwind_Reason_Code
 _Unwind_Resume_or_Rethrow(_Unwind_Exception *exception_object) {
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
   _LIBUNWIND_TRACE_API("_Unwind_Resume_or_Rethrow(ex_obj=%p), private_1=%ld\n",
                        (void *)exception_object,
                        (long)exception_object->unwinder_cache.reserved1);
 #else
   _LIBUNWIND_TRACE_API("_Unwind_Resume_or_Rethrow(ex_obj=%p), private_1=%ld\n",
                        (void *)exception_object,
                        (long)exception_object->private_1);
 #endif
 
-#if LIBCXXABI_ARM_EHABI
+#if _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) {
_Unwind_Backtrace(_Unwind_Trace_Fn callback, void *ref) {
   unw_cursor_t cursor;
   unw_context_t uc;
   unw_getcontext(&uc);
   unw_init_local(&cursor, &uc);
 
   _LIBUNWIND_TRACE_API("_Unwind_Backtrace(callback=%p)\n",
                        (void *)(uintptr_t)callback);
 
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
   // Create a mock exception object for force unwinding.
   _Unwind_Exception ex;
   memset(&ex, '\0', sizeof(ex));
   ex.exception_class = 0x434C4E47554E5700; // CLNGUNW\0
 #endif
 
   // walk each frame
   while (true) {
     _Unwind_Reason_Code result;
 
-#if !LIBCXXABI_ARM_EHABI
+#if !_LIBUNWIND_ARM_EHABI
     // 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;
     }
#else
     __personality_routine handler = (__personality_routine) frameInfo.handler;
     if (handler == NULL) {
       return _URC_END_OF_STACK;
     }
     if (handler(_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, &ex, context) !=
             _URC_CONTINUE_UNWIND) {
       return _URC_END_OF_STACK;
     }
-#endif // LIBCXXABI_ARM_EHABI
+#endif // _LIBUNWIND_ARM_EHABI
 
     // debugging
     if (_LIBUNWIND_TRACING_UNWINDING) {
       char functionName[512];
       unw_proc_info_t frame;
       unw_word_t offset;
       unw_get_proc_name(&cursor, functionName, 512, &offset);
       unw_get_proc_info(&cursor, &frame);

src/UnwindLevel1.c

 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "libunwind.h"
 #include "unwind.h"
 #include "config.h"
 
-#if !LIBCXXABI_ARM_EHABI
+#if !_LIBUNWIND_ARM_EHABI
 
 static _Unwind_Reason_Code
 unwind_phase1(unw_context_t *uc, _Unwind_Exception *exception_object) {
   unw_cursor_t cursor1;
   unw_init_local(&cursor1, uc);
 
   // Walk each frame looking for a place to stop.
   bool handlerNotFound = true;

 _LIBUNWIND_EXPORT void _Unwind_SetIP(struct _Unwind_Context *context,
                                      uintptr_t value) {
   _LIBUNWIND_TRACE_API("_Unwind_SetIP(context=%p, value=0x%0" PRIx64 ")\n",
                        (void *)context, (uint64_t)value);
   uintptr_t thumb_bit = _Unwind_GetGR(context, 15) & ((uintptr_t)0x1);
   _Unwind_SetGR(context, 15, value | thumb_bit);
 }
 
-#endif // !LIBCXXABI_ARM_EHABI
+#endif // !_LIBUNWIND_ARM_EHABI
 

src/libunwind.cpp

#elif defined(__x86_64__)
   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_x86_64>(
                                  context, LocalAddressSpace::sThisAddressSpace);
 #elif defined(__ppc__)
   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_ppc>(
                                  context, LocalAddressSpace::sThisAddressSpace);
 #elif defined(__arm64__)
   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm64>(
                                  context, LocalAddressSpace::sThisAddressSpace);
-#elif LIBCXXABI_ARM_EHABI
+#elif _LIBUNWIND_ARM_EHABI
   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm>(
                                  context, LocalAddressSpace::sThisAddressSpace);
 #endif
   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
   co->setInfoBasedOnIPRegister();
 
   return UNW_ESUCCESS;
 }
_LIBUNWIND_EXPORT int unw_get_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
   }
   return UNW_EBADREG;
 }
 
 
 /// Set value of specified float register at cursor position in stack frame.
 _LIBUNWIND_EXPORT int unw_set_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
                                     unw_fpreg_t value) {
-#if LIBCXXABI_ARM_EHABI
+#if _LIBUNWIND_ARM_EHABI
   _LIBUNWIND_TRACE_API("unw_set_fpreg(cursor=%p, regNum=%d, value=%llX)\n",
                        static_cast<void *>(cursor), regNum, value);
 #else
   _LIBUNWIND_TRACE_API("unw_set_fpreg(cursor=%p, regNum=%d, value=%g)\n",
                        static_cast<void *>(cursor), regNum, value);
 #endif
   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
   if (co->validFloatReg(regNum)) {

src/libunwind_ext.h

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
+#if _LIBUNWIND_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__