[libunwind] Silence warnings about unused parameters

[ldionne]

LGTM, but would it make sense to have a macro like _LIBUNWIND_MAYBE_UNUSED(var) instead?

[mstorsjo]

In D56984#1366297, @ldionne wrote:

LGTM, but would it make sense to have a macro like _LIBUNWIND_MAYBE_UNUSED(var) instead?

I guess some macro like that could be ok as well, although I think the (void)var is a rather well-known pattern in itself.

src/AddressSpace.hpp

for (unsigned j = 0; j < pifh->NumberOfSections; j++, pish++) {
       if (found_obj && found_hdr)
         return true;
     }
   }
   return false;
 #elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) && defined(_WIN32)
   // Don't even bother, since Windows has functions that do all this stuff
   // for us.
+  (void)targetAddr;
+  (void)info;
   return true;
 #elif defined(_LIBUNWIND_ARM_EHABI) && defined(__BIONIC__) &&                  \
     (__ANDROID_API__ < 21)
   int length = 0;
   info.arm_section =
       (uintptr_t)dl_unwind_find_exidx((_Unwind_Ptr)targetAddr, &length);
   info.arm_section_length = (uintptr_t)length;
   if (info.arm_section && info.arm_section_length)
#if _LIBUNWIND_USE_DLADDR
   Dl_info dyldInfo;
   if (dladdr((void *)addr, &dyldInfo)) {
     if (dyldInfo.dli_sname != NULL) {
       snprintf(buf, bufLen, "%s", dyldInfo.dli_sname);
       *offset = (addr - (pint_t) dyldInfo.dli_saddr);
       return true;
     }
   }
+#else
+  (void)addr;
+  (void)buf;
+  (void)bufLen;
+  (void)offset;
 #endif
   return false;
 }
 
 
 
 #ifdef UNW_REMOTE
 

src/Unwind-seh.cpp

 #define STATUS_GCC_UNWIND MAKE_GCC_EXCEPTION(1) // 0x21474343
 
 /// Class of foreign exceptions based on unrecognized SEH exceptions.
 static const uint64_t kSEHExceptionClass = 0x434C4E4753454800; // CLNGSEH\0
 
 /// Exception cleanup routine used by \c _GCC_specific_handler to
 /// free foreign exceptions.
 static void seh_exc_cleanup(_Unwind_Reason_Code urc, _Unwind_Exception *exc) {
+  (void)urc;
   if (exc->exception_class != kSEHExceptionClass)
     _LIBUNWIND_ABORT("SEH cleanup called on non-SEH exception");
   free(exc);
 }
 
 static int _unw_init_seh(unw_cursor_t *cursor, CONTEXT *ctx);
 static DISPATCHER_CONTEXT *_unw_seh_get_disp_ctx(unw_cursor_t *cursor);
 static void _unw_seh_set_disp_ctx(unw_cursor_t *cursor, DISPATCHER_CONTEXT *disp);

 /// Personality function returned by \c unw_get_proc_info() in SEH contexts.
 /// This is a wrapper that calls the real SEH handler function, which in
 /// turn (at least, for Itanium-style frames) calls the real Itanium
 /// personality function (see \c _GCC_specific_handler()).
 extern "C" _Unwind_Reason_Code
 __libunwind_seh_personality(int version, _Unwind_Action state,
                             uint64_t klass, _Unwind_Exception *exc,
                             struct _Unwind_Context *context) {
+  (void)version;
+  (void)klass;
   EXCEPTION_RECORD ms_exc;
   bool phase2 = (state & (_UA_SEARCH_PHASE|_UA_CLEANUP_PHASE)) == _UA_CLEANUP_PHASE;
   ms_exc.ExceptionCode = STATUS_GCC_THROW;
   ms_exc.ExceptionFlags = 0;
   ms_exc.NumberParameters = 3;
   ms_exc.ExceptionInformation[0] = (ULONG_PTR)exc;
   ms_exc.ExceptionInformation[1] = (ULONG_PTR)context;
   ms_exc.ExceptionInformation[2] = state;

src/UnwindCursor.hpp

 
 template <typename A, typename R>
 bool UnwindCursor<A, R>::validFloatReg(int regNum) {
 #if defined(_LIBUNWIND_TARGET_ARM)
   if (regNum >= UNW_ARM_S0 && regNum <= UNW_ARM_S31) return true;
   if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) return true;
 #elif defined(_LIBUNWIND_TARGET_AARCH64)
   if (regNum >= UNW_ARM64_D0 && regNum <= UNW_ARM64_D31) return true;
+#else
+  (void)regNum;
 #endif
   return false;
 }
 
 template <typename A, typename R>
 unw_fpreg_t UnwindCursor<A, R>::getFloatReg(int regNum) {
 #if defined(_LIBUNWIND_TARGET_ARM)
   if (regNum >= UNW_ARM_S0 && regNum <= UNW_ARM_S31) {
if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) {
     } d;
     d.w = _msContext.D[regNum - UNW_ARM_D0];
     return d.d;
   }
   _LIBUNWIND_ABORT("unsupported float register");
 #elif defined(_LIBUNWIND_TARGET_AARCH64)
   return _msContext.V[regNum - UNW_ARM64_D0].D[0];
 #else
+  (void)regNum;
   _LIBUNWIND_ABORT("float registers unimplemented");
 #endif
 }
 
 template <typename A, typename R>
 void UnwindCursor<A, R>::setFloatReg(int regNum, unw_fpreg_t value) {
 #if defined(_LIBUNWIND_TARGET_ARM)
   if (regNum >= UNW_ARM_S0 && regNum <= UNW_ARM_S31) {
if (regNum >= UNW_ARM_D0 && regNum <= UNW_ARM_D31) {
     } d;
     d.d = value;
     _msContext.D[regNum - UNW_ARM_D0] = d.w;
   }
   _LIBUNWIND_ABORT("unsupported float register");
 #elif defined(_LIBUNWIND_TARGET_AARCH64)
   _msContext.V[regNum - UNW_ARM64_D0].D[0] = value;
 #else
+  (void)regNum;
+  (void)value;
   _LIBUNWIND_ABORT("float registers unimplemented");
 #endif
 }
 
 template <typename A, typename R> void UnwindCursor<A, R>::jumpto() {
   RtlRestoreContext(&_msContext, nullptr);
 }