Sigh, actually make sure it builds, also address warnings

Author: ojhunt

libunwind/src/DwarfInstructions.hpp

@@ -33,7 +33,7 @@ class DwarfInstructions {
   typedef typename A::pint_t pint_t;
   typedef typename A::sint_t sint_t;
 
-  static int stepWithDwarf(A &addressSpace, typename R::link_reg_t &pc,
+  static int stepWithDwarf(A &addressSpace, const typename R::link_reg_t &pc,
                            pint_t fdeStart, R &registers, bool &isSignalFrame,
                            bool stage2);
 

libunwind/src/DwarfParser.hpp

@@ -409,13 +409,14 @@ const char *CFI_Parser<A>::parseCIE(A &addressSpace, pint_t cie,
           const auto oldDiscriminator = resultAddr;
 #else
           const auto oldDiscriminator = ptrauth_blend_discriminator(
-              (void*)resultAddr, __ptrauth_unwind_pacret_personality_disc);
+              (void *)resultAddr, __ptrauth_unwind_pacret_personality_disc);
 #endif
           const auto discriminator = ptrauth_blend_discriminator(
-              &cieInfo->personality, __ptrauth_unwind_cie_info_personality_disc);
+              &cieInfo->personality,
+              __ptrauth_unwind_cie_info_personality_disc);
           void *signedPtr = ptrauth_auth_and_resign(
-              (void *)personality, ptrauth_key_function_pointer, resultAddr,
-              ptrauth_key_function_pointer, discriminator);
+              (void *)personality, ptrauth_key_function_pointer,
+              oldDiscriminator, ptrauth_key_function_pointer, discriminator);
           personality = (pint_t)signedPtr;
         }
 #endif

libunwind/src/Registers.hpp

@@ -17,8 +17,8 @@
 
 #include "config.h"
 #include "libunwind.h"
-#include "shadow_stack_unwind.h"
 #include "libunwind_ext.h"
+#include "shadow_stack_unwind.h"
 
 namespace libunwind {
 
@@ -1839,8 +1839,8 @@ class _LIBUNWIND_HIDDEN Registers_arm64 {
 public:
   Registers_arm64();
   Registers_arm64(const void *registers);
-  Registers_arm64(const Registers_arm64&);
-  Registers_arm64& operator=(const Registers_arm64&);
+  Registers_arm64(const Registers_arm64 &);
+  Registers_arm64 &operator=(const Registers_arm64 &);
 
   typedef uint64_t reg_t;
   typedef uint64_t __ptrauth_unwind_registers_arm64_link_reg link_reg_t;
@@ -1863,7 +1863,7 @@ class _LIBUNWIND_HIDDEN Registers_arm64 {
 
   uint64_t  getSP() const         { return _registers.__sp; }
   void      setSP(uint64_t value) { _registers.__sp = value; }
-  uint64_t  getIP() const         {
+  uint64_t  getIP() const {
     uint64_t value = _registers.__pc;
 #if __has_feature(ptrauth_calls)
     // Note the value of the PC was signed to its address in the register state
@@ -1956,11 +1956,12 @@ inline Registers_arm64::Registers_arm64(const void *registers) {
 #endif
 }
 
-inline Registers_arm64::Registers_arm64(const Registers_arm64& other) {
+inline Registers_arm64::Registers_arm64(const Registers_arm64 &other) {
   *this = other;
 }
 
-inline Registers_arm64& Registers_arm64::operator=(const Registers_arm64& other) {
+inline Registers_arm64 &
+Registers_arm64::operator=(const Registers_arm64 &other) {
   memcpy(&_registers, &other._registers, sizeof(_registers));
   memcpy(_vectorHalfRegisters, &other._vectorHalfRegisters,
          sizeof(_vectorHalfRegisters));

libunwind/src/UnwindCursor.hpp

@@ -1367,13 +1367,13 @@ UnwindCursor<A, R>::UnwindCursor(unw_context_t *context, A &as)
                 "UnwindCursor<> does not fit in unw_cursor_t");
   static_assert((alignof(UnwindCursor<A, R>) <= alignof(unw_cursor_t)),
                 "UnwindCursor<> requires more alignment than unw_cursor_t");
-  memset(&_info, 0, sizeof(_info));
+  memset(static_cast<void *>(&_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));
+  memset(static_cast<void *>(&_info), 0, sizeof(_info));
   // FIXME
   // fill in _registers from thread arg
 }
@@ -1998,13 +1998,11 @@ bool UnwindCursor<A, R>::getInfoFromCompactEncodingSection(
 #if __has_feature(ptrauth_calls)
     // The GOT for the personality function was signed address authenticated.
     // Resign it as a regular function pointer.
-    const auto discriminator =
-      ptrauth_blend_discriminator(&_info.handler,
-                                  __ptrauth_unwind_upi_handler_disc);
-    void *signedPtr =
-      ptrauth_auth_and_resign((void *)personality, ptrauth_key_function_pointer,
-                              personalityPointer, ptrauth_key_function_pointer,
-                              discriminator);
+    const auto discriminator = ptrauth_blend_discriminator(
+        &_info.handler, __ptrauth_unwind_upi_handler_disc);
+    void *signedPtr = ptrauth_auth_and_resign(
+        (void *)personality, ptrauth_key_function_pointer, personalityPointer,
+        ptrauth_key_function_pointer, discriminator);
     personality = (__typeof(personality))signedPtr;
 #endif
     if (log)
@@ -3229,7 +3227,7 @@ template <typename A, typename R> int UnwindCursor<A, R>::step(bool stage2) {
 template <typename A, typename R>
 void UnwindCursor<A, R>::getInfo(unw_proc_info_t *info) {
   if (_unwindInfoMissing)
-    memset(info, 0, sizeof(*info));
+    memset(static_cast<void *>(info), 0, sizeof(*info));
   else
     *info = _info;
 }

libunwind/src/UnwindLevel1.c

@@ -96,8 +96,7 @@
 static _Unwind_Personality_Fn get_handler_function(unw_proc_info_t *frameInfo) {
   union {
     void *opaque_handler;
-    _Unwind_Personality_Fn __ptrauth_unwind_upi_handler *
-        handler;
+    _Unwind_Personality_Fn __ptrauth_unwind_upi_handler *handler;
   } u;
   u.opaque_handler = (void *)&frameInfo->handler;
   return *u.handler;
@@ -608,7 +607,7 @@ _LIBUNWIND_EXPORT uintptr_t _Unwind_GetIP(struct _Unwind_Context *context) {
   unw_word_t result;
   __unw_get_reg(cursor, UNW_REG_IP, &result);
 
-#if __has_feature(ptrauth_calls)
+#if defined(__ARM64E__)
   // If we are in an arm64e frame, then the PC should have been signed with the
   // sp
   {

libunwind/src/libunwind.cpp

@@ -15,7 +15,6 @@
 #include "libunwind_ext.h"
 
 #include <stdlib.h>
-#include <sys/types.h>
 
 // Define the __has_feature extension for compilers that do not support it so
 // that we can later check for the presence of ASan in a compiler-neutral way.
@@ -137,15 +136,12 @@ _LIBUNWIND_HIDDEN int __unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
         union {
           unw_word_t opaque_value;
           unw_word_t
-            __unwind_ptrauth_restricted_intptr(ptrauth_key_return_address, 1, 0)
-            authenticated_value;
+              __unwind_ptrauth_restricted_intptr(ptrauth_key_return_address, 1,
+                                                 0) authenticated_value;
         } u;
         u.opaque_value = (uint64_t)ptrauth_auth_and_resign(
-          (void *)value,
-          ptrauth_key_return_address,
-          getSP(),
-          ptrauth_key_return_address,
-          &u.opaque_value);
+            (void *)value, ptrauth_key_return_address, sp,
+            ptrauth_key_return_address, &u.opaque_value);
 
         if (u.authenticated_value < info.start_ip ||
             u.authenticated_value > info.end_ip)
@@ -157,7 +153,7 @@ _LIBUNWIND_HIDDEN int __unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
         if (ptrauth_auth_and_resign((void *)pc, ptrauth_key_return_address, sp,
                                     ptrauth_key_return_address,
                                     sp) != (void *)pc) {
-          _LIBUNWIND_LOG("Bad unwind through arm64e (0x%llX, 0x%llX)->0x%llX\n",
+          _LIBUNWIND_LOG("Bad unwind through arm64e (0x%zX, 0x%zX)->0x%zX\n",
                          pc, sp,
                          (pint_t)ptrauth_auth_data(
                              (void *)pc, ptrauth_key_return_address, sp));