[OpenMP] Add void casts to silence unused variable warnings

[mstorsjo]

Summary

These variables are used only in certain build configurations, or marked with a todo comment indicating that they should be used/checked/reported.

[jdoerfert]

LG

openmp/runtime/src/kmp_affinity.cpp

KA_TRACE(1000, (""); {
     __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
                               (kmp_affin_mask_t *)(*mask));
     __kmp_printf("kmp_get_affinity: system affinity mask for thread %d = %s\n",
                  gtid, buf);
   });
   return retval;
 
 #else
+  (void)retval;
 
   KMP_CPU_COPY((kmp_affin_mask_t *)(*mask), th->th.th_affin_mask);
   return 0;
 
 #endif /* KMP_OS_WINDOWS */
 }
 
 int __kmp_aux_get_affinity_max_proc() {

openmp/runtime/src/kmp_atomic.cpp

#define OP_CMPXCHG_CPT(TYPE, BITS, OP)                                         \
     } else                                                                     \
       return old_value;                                                        \
   }
 
 // -------------------------------------------------------------------------
 #define ATOMIC_CMPXCHG_CPT(TYPE_ID, OP_ID, TYPE, BITS, OP, GOMP_FLAG)          \
   ATOMIC_BEGIN_CPT(TYPE_ID, OP_ID, TYPE, TYPE)                                 \
   TYPE new_value;                                                              \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_CPT(TYPE, OP, GOMP_FLAG)                                    \
   OP_CMPXCHG_CPT(TYPE, BITS, OP)                                               \
   }
 
 // -------------------------------------------------------------------------
 #define ATOMIC_FIXED_ADD_CPT(TYPE_ID, OP_ID, TYPE, BITS, OP, GOMP_FLAG)        \
   ATOMIC_BEGIN_CPT(TYPE_ID, OP_ID, TYPE, TYPE)                                 \
   TYPE old_value, new_value;                                                   \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_CPT(TYPE, OP, GOMP_FLAG)                                    \
   /* OP used as a sign for subtraction: (lhs-rhs) --> (lhs+-rhs) */            \
   old_value = KMP_TEST_THEN_ADD##BITS(lhs, OP rhs);                            \
   if (flag) {                                                                  \
     return old_value OP rhs;                                                   \
   } else                                                                       \
     return old_value;                                                          \
   }

 #define OP_GOMP_CRITICAL_L_CPT(OP, FLAG)
 #endif /* KMP_GOMP_COMPAT */
 
 // ------------------------------------------------------------------------
 // Need separate macros for &&, || because there is no combined assignment
 #define ATOMIC_CMPX_L_CPT(TYPE_ID, OP_ID, TYPE, BITS, OP, GOMP_FLAG)           \
   ATOMIC_BEGIN_CPT(TYPE_ID, OP_ID, TYPE, TYPE)                                 \
   TYPE new_value;                                                              \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_L_CPT(= *lhs OP, GOMP_FLAG)                                 \
   OP_CMPXCHG_CPT(TYPE, BITS, OP)                                               \
   }
 
 ATOMIC_CMPX_L_CPT(fixed1, andl_cpt, char, 8, &&,
                   KMP_ARCH_X86) // __kmpc_atomic_fixed1_andl_cpt
 ATOMIC_CMPX_L_CPT(fixed1, orl_cpt, char, 8, ||,
                   KMP_ARCH_X86) // __kmpc_atomic_fixed1_orl_cpt
if (*lhs OP rhs) { /* need actions? */                                       \
     MIN_MAX_CRITSECT_CPT(OP, LCK_ID)                                           \
   }                                                                            \
   return *lhs;                                                                 \
   }
 
 #define MIN_MAX_COMPXCHG_CPT(TYPE_ID, OP_ID, TYPE, BITS, OP, GOMP_FLAG)        \
   ATOMIC_BEGIN_CPT(TYPE_ID, OP_ID, TYPE, TYPE)                                 \
   TYPE new_value, old_value;                                                   \
+  (void)new_value;                                                             \
   if (*lhs OP rhs) {                                                           \
     GOMP_MIN_MAX_CRITSECT_CPT(OP, GOMP_FLAG)                                   \
     MIN_MAX_CMPXCHG_CPT(TYPE, BITS, OP)                                        \
   }                                                                            \
   return *lhs;                                                                 \
   }
 
 MIN_MAX_COMPXCHG_CPT(fixed1, max_cpt, char, 8, <,
#define OP_GOMP_CRITICAL_EQV_CPT(OP, FLAG)                                     \
   }
 #else
 #define OP_GOMP_CRITICAL_EQV_CPT(OP, FLAG)
 #endif /* KMP_GOMP_COMPAT */
 // ------------------------------------------------------------------------
 #define ATOMIC_CMPX_EQV_CPT(TYPE_ID, OP_ID, TYPE, BITS, OP, GOMP_FLAG)         \
   ATOMIC_BEGIN_CPT(TYPE_ID, OP_ID, TYPE, TYPE)                                 \
   TYPE new_value;                                                              \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_EQV_CPT(^= (TYPE) ~, GOMP_FLAG) /* send assignment */       \
   OP_CMPXCHG_CPT(TYPE, BITS, OP)                                               \
   }
 
 // ------------------------------------------------------------------------
 
 ATOMIC_CMPXCHG_CPT(fixed1, neqv_cpt, kmp_int8, 8, ^,
                    KMP_ARCH_X86) // __kmpc_atomic_fixed1_neqv_cpt
#define OP_CMPXCHG_CPT_REV(TYPE, BITS, OP)                                     \
     } else                                                                     \
       return old_value;                                                        \
   }
 
 // -------------------------------------------------------------------------
 #define ATOMIC_CMPXCHG_CPT_REV(TYPE_ID, OP_ID, TYPE, BITS, OP, GOMP_FLAG)      \
   ATOMIC_BEGIN_CPT(TYPE_ID, OP_ID, TYPE, TYPE)                                 \
   TYPE new_value;                                                              \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_CPT_REV(TYPE, OP, GOMP_FLAG)                                \
   OP_CMPXCHG_CPT_REV(TYPE, BITS, OP)                                           \
   }
 
 ATOMIC_CMPXCHG_CPT_REV(fixed1, div_cpt_rev, kmp_int8, 8, /,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1_div_cpt_rev
 ATOMIC_CMPXCHG_CPT_REV(fixed1u, div_cpt_rev, kmp_uint8, 8, /,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1u_div_cpt_rev
#define CMPXCHG_SWP(TYPE, BITS)                                                \
     }                                                                          \
     return old_value;                                                          \
   }
 
 // -------------------------------------------------------------------------
 #define ATOMIC_CMPXCHG_SWP(TYPE_ID, TYPE, BITS, GOMP_FLAG)                     \
   ATOMIC_BEGIN_SWP(TYPE_ID, TYPE)                                              \
   TYPE old_value;                                                              \
+  (void)old_value;                                                             \
   GOMP_CRITICAL_SWP(GOMP_FLAG)                                                 \
   CMPXCHG_SWP(TYPE, BITS)                                                      \
   }
 
 ATOMIC_XCHG_SWP(fixed1, kmp_int8, 8, KMP_ARCH_X86) // __kmpc_atomic_fixed1_swp
 ATOMIC_XCHG_SWP(fixed2, kmp_int16, 16, KMP_ARCH_X86) // __kmpc_atomic_fixed2_swp
 ATOMIC_XCHG_SWP(fixed4, kmp_int32, 32, KMP_ARCH_X86) // __kmpc_atomic_fixed4_swp
 

openmp/runtime/src/kmp_io.cpp

if (!__kmp_console_exists) {
     //  2. it is not clear how to communicate failue
     //  3. we will detect failure later when we get handle(s)
 
     ho = GetStdHandle(STD_OUTPUT_HANDLE);
     if (ho == INVALID_HANDLE_VALUE || ho == NULL) {
 
       DWORD err = GetLastError();
       // TODO: output error somehow (maybe message box)
+      (void)err;
       __kmp_stdout = NULL;
 
     } else {
 
       __kmp_stdout = ho; // temporary code, need new global for ho
     }
     he = GetStdHandle(STD_ERROR_HANDLE);
     if (he == INVALID_HANDLE_VALUE || he == NULL) {
 
       DWORD err = GetLastError();
       // TODO: output error somehow (maybe message box)
+      (void)err;
       __kmp_stderr = NULL;
 
     } else {
 
       __kmp_stderr = he; // temporary code, need new global
     }
     __kmp_console_exists = TRUE;
   }

openmp/runtime/src/kmp_tasking.cpp

if (!taskdata->td_flags.native) {
         kmp_int32 *lb = RCAST(kmp_int32 *, task->shareds);
         retval = (kmp_int64)*lb;
       } else {
         kmp_int64 *lb = RCAST(kmp_int64 *, task->shareds);
         retval = (kmp_int64)*lb;
       }
     }
 #else
+    (void)taskdata;
     retval = *(kmp_int64 *)((char *)task + lower_offset);
 #endif // defined(KMP_GOMP_COMPAT)
     return retval;
   }
   kmp_uint64 get_ub() const {
     kmp_int64 retval;
 #if defined(KMP_GOMP_COMPAT)
     // Intel task just returns the upper bound normally

openmp/runtime/src/z_Windows_NT_util.cpp

#if KMP_DYNAMIC_LIB
   /* Pin dynamic library for the lifetime of application */
   {
     // First, turn off error message boxes
     UINT err_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
     HMODULE h;
     BOOL ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
                                      GET_MODULE_HANDLE_EX_FLAG_PIN,
                                  (LPCTSTR)&__kmp_serial_initialize, &h);
+    (void)ret;
     KMP_DEBUG_ASSERT2(h && ret, "OpenMP RTL cannot find itself loaded");
     SetErrorMode(err_mode); // Restore error mode
     KA_TRACE(10, ("__kmp_runtime_initialize: dynamic library pinned\n"));
   }
 #endif
 
   InitializeCriticalSection(&__kmp_win32_section);
 #if USE_ITT_BUILD
if (kernel32 != NULL) {
       }
     }
   }
   if (__kmp_num_proc_groups <= 1) {
     GetSystemInfo(&info);
     __kmp_xproc = info.dwNumberOfProcessors;
   }
 #else
+  (void)kernel32;
   GetSystemInfo(&info);
   __kmp_xproc = info.dwNumberOfProcessors;
 #endif /* KMP_GROUP_AFFINITY */
 
   // If the OS said there were 0 procs, take a guess and use a value of 2.
   // This is done for Linux* OS, also.  Do we need error / warning?
   if (__kmp_xproc <= 0) {
     __kmp_xproc = 2;