[OpenMP] Cleanup code

[jlpeyton]

Summary

This patch cleans up unused functions, variables, sign compare issues, and addresses some -Warning flags which are now enabled including -Wcast-qual. Not all the warning flags in LibompHandleFlags.cmake are enabled, but some are with this patch.

Some __kmp_gtid_from_* macros in kmp.h are switched to static inline functions which allows us to remove the awkward definition of KMP_DEBUG_ASSERT() and KMP_ASSERT() macros which used the comma operator. This had to be done for the innumerable -Wunused-value warnings related to KMP_DEBUG_ASSERT() (at least for gcc)

[jlpeyton]

Forgot to merge in the CCAST() update from earlier today.

[jlpeyton]

Updated patch so that -Warning flags are only included in stand alone builds since the LLVM in-tree builds already include the warning flags.

[jlpeyton]

Removing switch statement changes as they would need a closer look in a future patch.

[tlwilmar]

LGTM

runtime/cmake/LibompHandleFlags.cmake

macro(libomp_setup_flags flags)
   endif()
 endmacro()
 
 # Gets flags common to both the C and C++ compiler
 function(libomp_get_c_and_cxxflags_common flags)
   set(flags_local)
   libomp_append(flags_local -fno-exceptions LIBOMP_HAVE_FNO_EXCEPTIONS_FLAG)
   libomp_append(flags_local -fno-rtti LIBOMP_HAVE_FNO_RTTI_FLAG)
-  libomp_append(flags_local -Wno-sign-compare LIBOMP_HAVE_WNO_SIGN_COMPARE_FLAG)
-  libomp_append(flags_local -Wno-unused-function LIBOMP_HAVE_WNO_UNUSED_FUNCTION_FLAG)
-  libomp_append(flags_local -Wno-unused-local-typedef LIBOMP_HAVE_WNO_UNUSED_LOCAL_TYPEDEF_FLAG)
-  libomp_append(flags_local -Wno-unused-value LIBOMP_HAVE_WNO_UNUSED_VALUE_FLAG)
-  libomp_append(flags_local -Wno-unused-variable LIBOMP_HAVE_WNO_UNUSED_VARIABLE_FLAG)
+  if(${OPENMP_STANDALONE_BUILD})
+    libomp_append(flags_local -Wsign-compare LIBOMP_HAVE_WNO_SIGN_COMPARE_FLAG)
+    libomp_append(flags_local -Wunused-function LIBOMP_HAVE_WNO_UNUSED_FUNCTION_FLAG)
+    libomp_append(flags_local -Wunused-local-typedef LIBOMP_HAVE_WNO_UNUSED_LOCAL_TYPEDEF_FLAG)
+    libomp_append(flags_local -Wunused-value LIBOMP_HAVE_WNO_UNUSED_VALUE_FLAG)
+    libomp_append(flags_local -Wunused-variable LIBOMP_HAVE_WNO_UNUSED_VARIABLE_FLAG)
+    libomp_append(flags_local -Wdeprecated-register LIBOMP_HAVE_WNO_DEPRECATED_REGISTER_FLAG)
+    libomp_append(flags_local -Wunknown-pragmas LIBOMP_HAVE_WNO_UNKNOWN_PRAGMAS_FLAG)
+    libomp_append(flags_local -Wcomment LIBOMP_HAVE_WNO_COMMENT_FLAG)
+    libomp_append(flags_local -Wself-assign LIBOMP_HAVE_WNO_SELF_ASSIGN_FLAG)
+    libomp_append(flags_local -Wformat-pedantic LIBOMP_HAVE_WNO_FORMAT_PEDANTIC_FLAG)
+  endif()
   libomp_append(flags_local -Wno-switch LIBOMP_HAVE_WNO_SWITCH_FLAG)
   libomp_append(flags_local -Wno-covered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
-  libomp_append(flags_local -Wno-deprecated-register LIBOMP_HAVE_WNO_DEPRECATED_REGISTER_FLAG)
   libomp_append(flags_local -Wno-gnu-anonymous-struct LIBOMP_HAVE_WNO_GNU_ANONYMOUS_STRUCT_FLAG)
-  libomp_append(flags_local -Wno-unknown-pragmas LIBOMP_HAVE_WNO_UNKNOWN_PRAGMAS_FLAG)
   libomp_append(flags_local -Wno-missing-field-initializers LIBOMP_HAVE_WNO_MISSING_FIELD_INITIALIZERS_FLAG)
   libomp_append(flags_local -Wno-missing-braces LIBOMP_HAVE_WNO_MISSING_BRACES_FLAG)
-  libomp_append(flags_local -Wno-comment LIBOMP_HAVE_WNO_COMMENT_FLAG)
-  libomp_append(flags_local -Wno-self-assign LIBOMP_HAVE_WNO_SELF_ASSIGN_FLAG)
   libomp_append(flags_local -Wno-vla-extension LIBOMP_HAVE_WNO_VLA_EXTENSION_FLAG)
-  libomp_append(flags_local -Wno-format-pedantic LIBOMP_HAVE_WNO_FORMAT_PEDANTIC_FLAG)
   libomp_append(flags_local /GS LIBOMP_HAVE_GS_FLAG)
   libomp_append(flags_local /EHsc LIBOMP_HAVE_EHSC_FLAG)
   libomp_append(flags_local /Oy- LIBOMP_HAVE_OY__FLAG)
   # Intel(R) C Compiler flags
   libomp_append(flags_local /Qsafeseh LIBOMP_HAVE_QSAFESEH_FLAG)
   libomp_append(flags_local -Qoption,cpp,--extended_float_types LIBOMP_HAVE_EXTENDED_FLOAT_TYPES_FLAG)
   libomp_append(flags_local -Qlong_double LIBOMP_HAVE_LONG_DOUBLE_FLAG)
   libomp_append(flags_local -Qdiag-disable:177 LIBOMP_HAVE_DIAG_DISABLE_177_FLAG)
function(libomp_get_cflags cflags)
   libomp_setup_flags(cflags_local)
   set(${cflags} ${cflags_local} PARENT_SCOPE)
 endfunction()
 
 # C++ compiler flags
 function(libomp_get_cxxflags cxxflags)
   set(cxxflags_local)
   libomp_get_c_and_cxxflags_common(cxxflags_local)
+  if(${OPENMP_STANDALONE_BUILD})
+      libomp_append(cxxflags_local -Wcast-qual LIBOMP_HAVE_WCAST_QUAL_FLAG)
+  endif()
   set(cxxflags_local ${cxxflags_local} ${LIBOMP_CXXFLAGS})
   libomp_setup_flags(cxxflags_local)
   set(${cxxflags} ${cxxflags_local} PARENT_SCOPE)
 endfunction()
 
 # Assembler flags
 function(libomp_get_asmflags asmflags)
   set(asmflags_local)

runtime/cmake/config-ix.cmake

function(libomp_check_architecture_flag flag retval)
   check_c_compiler_flag("${flag}" ${retval})
   set(${retval} ${${retval}} PARENT_SCOPE)
 endfunction()
 
 # Checking C, CXX, Linker Flags
 check_cxx_compiler_flag(-fno-exceptions LIBOMP_HAVE_FNO_EXCEPTIONS_FLAG)
 check_cxx_compiler_flag(-fno-rtti LIBOMP_HAVE_FNO_RTTI_FLAG)
 check_c_compiler_flag("-x c++" LIBOMP_HAVE_X_CPP_FLAG)
+check_cxx_compiler_flag(-Wcast-qual LIBOMP_HAVE_WCAST_QUAL_FLAG)
 check_c_compiler_flag(-Wunused-function LIBOMP_HAVE_WNO_UNUSED_FUNCTION_FLAG)
 check_c_compiler_flag(-Wunused-local-typedef LIBOMP_HAVE_WNO_UNUSED_LOCAL_TYPEDEF_FLAG)
 check_c_compiler_flag(-Wunused-value LIBOMP_HAVE_WNO_UNUSED_VALUE_FLAG)
 check_c_compiler_flag(-Wunused-variable LIBOMP_HAVE_WNO_UNUSED_VARIABLE_FLAG)
 check_c_compiler_flag(-Wswitch LIBOMP_HAVE_WNO_SWITCH_FLAG)
 check_c_compiler_flag(-Wcovered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
 check_c_compiler_flag(-Wdeprecated-register LIBOMP_HAVE_WNO_DEPRECATED_REGISTER_FLAG)
 check_c_compiler_flag(-Wsign-compare LIBOMP_HAVE_WNO_SIGN_COMPARE_FLAG)

runtime/src/kmp.h

 extern int __kmp_tile_depth;
 #endif
 
 extern size_t __kmp_affin_mask_size;
 #define KMP_AFFINITY_CAPABLE() (__kmp_affin_mask_size > 0)
 #define KMP_AFFINITY_DISABLE() (__kmp_affin_mask_size = 0)
 #define KMP_AFFINITY_ENABLE(mask_size) (__kmp_affin_mask_size = mask_size)
 #define KMP_CPU_SET_ITERATE(i, mask)                                           \
-  for (i = (mask)->begin(); i != (mask)->end(); i = (mask)->next(i))
+  for (i = (mask)->begin(); (int)i != (mask)->end(); i = (mask)->next(i))
 #define KMP_CPU_SET(i, mask) (mask)->set(i)
 #define KMP_CPU_ISSET(i, mask) (mask)->is_set(i)
 #define KMP_CPU_CLR(i, mask) (mask)->clear(i)
 #define KMP_CPU_ZERO(mask) (mask)->zero()
 #define KMP_CPU_COPY(dest, src) (dest)->copy(src)
 #define KMP_CPU_AND(dest, src) (dest)->bitwise_and(src)
 #define KMP_CPU_COMPLEMENT(max_bit_number, mask) (mask)->bitwise_not()
 #define KMP_CPU_UNION(dest, src) (dest)->bitwise_or(src)

 // We need to avoid using -1 as a GTID as +1 is added to the gtid
 // when storing it in a lock, and the value 0 is reserved.
 #define KMP_GTID_DNE (-2) /* Does not exist */
 #define KMP_GTID_SHUTDOWN (-3) /* Library is shutting down */
 #define KMP_GTID_MONITOR (-4) /* Monitor thread ID */
 #define KMP_GTID_UNKNOWN (-5) /* Is not known */
 #define KMP_GTID_MIN (-6) /* Minimal gtid for low bound check in DEBUG */
 
-#define __kmp_get_gtid() __kmp_get_global_thread_id()
-#define __kmp_entry_gtid() __kmp_get_global_thread_id_reg()
-
-#define __kmp_tid_from_gtid(gtid)                                              \
-  (KMP_DEBUG_ASSERT((gtid) >= 0), __kmp_threads[(gtid)]->th.th_info.ds.ds_tid)
-
-#define __kmp_get_tid() (__kmp_tid_from_gtid(__kmp_get_gtid()))
-#define __kmp_gtid_from_tid(tid, team)                                         \
-  (KMP_DEBUG_ASSERT((tid) >= 0 && (team) != NULL),                             \
-   team->t.t_threads[(tid)]->th.th_info.ds.ds_gtid)
-
-#define __kmp_get_team() (__kmp_threads[(__kmp_get_gtid())]->th.th_team)
-#define __kmp_team_from_gtid(gtid)                                             \
-  (KMP_DEBUG_ASSERT((gtid) >= 0), __kmp_threads[(gtid)]->th.th_team)
-
-#define __kmp_thread_from_gtid(gtid)                                           \
-  (KMP_DEBUG_ASSERT((gtid) >= 0), __kmp_threads[(gtid)])
-#define __kmp_get_thread() (__kmp_thread_from_gtid(__kmp_get_gtid()))
-
-// Returns current thread (pointer to kmp_info_t). In contrast to
-// __kmp_get_thread(), it works with registered and not-yet-registered threads.
-#define __kmp_gtid_from_thread(thr)                                            \
-  (KMP_DEBUG_ASSERT((thr) != NULL), (thr)->th.th_info.ds.ds_gtid)
-
-// AT: Which way is correct?
-// AT: 1. nproc = __kmp_threads[ ( gtid ) ] -> th.th_team -> t.t_nproc;
-// AT: 2. nproc = __kmp_threads[ ( gtid ) ] -> th.th_team_nproc;
-#define __kmp_get_team_num_threads(gtid)                                       \
-  (__kmp_threads[(gtid)]->th.th_team->t.t_nproc)
-
 /* ------------------------------------------------------------------------ */
 
 #define KMP_UINT64_MAX                                                         \
   (~((kmp_uint64)1 << ((sizeof(kmp_uint64) * (1 << 3)) - 1)))
 
 #define KMP_MIN_NTH 1
 
 #ifndef KMP_MAX_NTH

 #define KMP_TLS_GTID_MIN INT_MAX
 #endif
 
 #define KMP_MASTER_TID(tid) ((tid) == 0)
 #define KMP_WORKER_TID(tid) ((tid) != 0)
 
 #define KMP_MASTER_GTID(gtid) (__kmp_tid_from_gtid((gtid)) == 0)
 #define KMP_WORKER_GTID(gtid) (__kmp_tid_from_gtid((gtid)) != 0)
-#define KMP_UBER_GTID(gtid)                                                    \
-  (KMP_DEBUG_ASSERT((gtid) >= KMP_GTID_MIN),                                   \
-   KMP_DEBUG_ASSERT((gtid) < __kmp_threads_capacity),                          \
-   (gtid) >= 0 && __kmp_root[(gtid)] && __kmp_threads[(gtid)] &&               \
-       (__kmp_threads[(gtid)] == __kmp_root[(gtid)]->r.r_uber_thread))
 #define KMP_INITIAL_GTID(gtid) ((gtid) == 0)
 
 #ifndef TRUE
 #define FALSE 0
 #define TRUE (!FALSE)
 #endif
 
 /* NOTE: all of the following constants must be even */

 extern void __kmp_x86_cpuid(int mode, int mode2, struct kmp_cpuid *p);
 #if KMP_ARCH_X86
 extern void __kmp_x86_pause(void);
 #elif KMP_MIC
 // Performance testing on KNC (C0QS-7120 P/A/X/D, 61-core, 16 GB Memory) showed
 // regression after removal of extra PAUSE from KMP_YIELD_SPIN(). Changing
 // the delay from 100 to 300 showed even better performance than double PAUSE
 // on Spec OMP2001 and LCPC tasking tests, no regressions on EPCC.
-static void __kmp_x86_pause(void) { _mm_delay_32(300); }
+static inline void __kmp_x86_pause(void) { _mm_delay_32(300); }
 #else
-static void __kmp_x86_pause(void) { _mm_pause(); }
+static inline void __kmp_x86_pause(void) { _mm_pause(); }
 #endif
 #define KMP_CPU_PAUSE() __kmp_x86_pause()
 #elif KMP_ARCH_PPC64
 #define KMP_PPC64_PRI_LOW() __asm__ volatile("or 1, 1, 1")
 #define KMP_PPC64_PRI_MED() __asm__ volatile("or 2, 2, 2")
 #define KMP_PPC64_PRI_LOC_MB() __asm__ volatile("" : : : "memory")
 #define KMP_CPU_PAUSE()                                                        \
   do {                                                                         \

 extern volatile int __kmp_all_nth;
 extern int __kmp_thread_pool_nth;
 extern std::atomic<int> __kmp_thread_pool_active_nth;
 
 extern kmp_root_t **__kmp_root; /* root of thread hierarchy */
 /* end data protected by fork/join lock */
 /* ------------------------------------------------------------------------- */
 
+#define __kmp_get_gtid() __kmp_get_global_thread_id()
+#define __kmp_entry_gtid() __kmp_get_global_thread_id_reg()
+#define __kmp_get_tid() (__kmp_tid_from_gtid(__kmp_get_gtid()))
+#define __kmp_get_team() (__kmp_threads[(__kmp_get_gtid())]->th.th_team)
+#define __kmp_get_thread() (__kmp_thread_from_gtid(__kmp_get_gtid()))
+
+// AT: Which way is correct?
+// AT: 1. nproc = __kmp_threads[ ( gtid ) ] -> th.th_team -> t.t_nproc;
+// AT: 2. nproc = __kmp_threads[ ( gtid ) ] -> th.th_team_nproc;
+#define __kmp_get_team_num_threads(gtid)                                       \
+  (__kmp_threads[(gtid)]->th.th_team->t.t_nproc)
+
+static inline bool KMP_UBER_GTID(int gtid) {
+  KMP_DEBUG_ASSERT(gtid >= KMP_GTID_MIN);
+  KMP_DEBUG_ASSERT(gtid < __kmp_threads_capacity);
+  return (gtid >= 0 && __kmp_root[gtid] && __kmp_threads[gtid] &&
+          __kmp_threads[gtid] == __kmp_root[gtid]->r.r_uber_thread);
+}
+
+static inline int __kmp_tid_from_gtid(int gtid) {
+  KMP_DEBUG_ASSERT(gtid >= 0);
+  return __kmp_threads[gtid]->th.th_info.ds.ds_tid;
+}
+
+static inline int __kmp_gtid_from_tid(int tid, const kmp_team_t *team) {
+  KMP_DEBUG_ASSERT(tid >= 0 && team);
+  return team->t.t_threads[tid]->th.th_info.ds.ds_gtid;
+}
+
+static inline int __kmp_gtid_from_thread(const kmp_info_t *thr) {
+  KMP_DEBUG_ASSERT(thr);
+  return thr->th.th_info.ds.ds_gtid;
+}
+
+static inline kmp_info_t *__kmp_thread_from_gtid(int gtid) {
+  KMP_DEBUG_ASSERT(gtid >= 0);
+  return __kmp_threads[gtid];
+}
+
+static inline kmp_team_t *__kmp_team_from_gtid(int gtid) {
+  KMP_DEBUG_ASSERT(gtid >= 0);
+  return __kmp_threads[gtid]->th.th_team;
+}
+
+/* ------------------------------------------------------------------------- */
+
 extern kmp_global_t __kmp_global; /* global status */
 
 extern kmp_info_t __kmp_monitor;
 // For Debugging Support Library
 extern std::atomic<kmp_uint32> __kmp_team_counter;
 // For Debugging Support Library
 extern std::atomic<kmp_uint32> __kmp_task_counter;
 

runtime/src/kmp_affinity.h

int set_system_affinity(bool abort_on_error) const override {
       }
       int error = errno;
       if (abort_on_error) {
         __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
     int get_proc_group() const override {
-      int i;
       int group = -1;
 #if KMP_OS_WINDOWS
       if (__kmp_num_proc_groups == 1) {
         return 1;
       }
-      for (i = 0; i < __kmp_num_proc_groups; i++) {
+      for (int i = 0; i < __kmp_num_proc_groups; i++) {
         // On windows, the long type is always 32 bits
         unsigned long first_32_bits = hwloc_bitmap_to_ith_ulong(mask, i * 2);
         unsigned long second_32_bits =
             hwloc_bitmap_to_ith_ulong(mask, i * 2 + 1);
         if (first_32_bits == 0 && second_32_bits == 0) {
           continue;
         }
         if (group >= 0) {
class KMPNativeAffinity : public KMPAffinity {
   void bind_thread(int which) override { __kmp_affinity_bind_thread(which); }
   KMPAffinity::Mask *allocate_mask() override {
     KMPNativeAffinity::Mask *retval = new Mask();
     return retval;
   }
   void deallocate_mask(KMPAffinity::Mask *m) override {
     KMPNativeAffinity::Mask *native_mask =
         static_cast<KMPNativeAffinity::Mask *>(m);
-    delete m;
+    delete native_mask;
   }
   KMPAffinity::Mask *allocate_mask_array(int num) override {
     return new Mask[num];
   }
   void deallocate_mask_array(KMPAffinity::Mask *array) override {
     Mask *linux_array = static_cast<Mask *>(array);
     delete[] linux_array;
   }

runtime/src/kmp_affinity.cpp

 // Print the affinity mask to the character array in a pretty format.
 char *__kmp_affinity_print_mask(char *buf, int buf_len,
                                 kmp_affin_mask_t *mask) {
   KMP_ASSERT(buf_len >= 40);
   char *scan = buf;
   char *end = buf + buf_len - 1;
 
   // Find first element / check for empty set.
-  size_t i;
+  int i;
   i = mask->begin();
   if (i == mask->end()) {
     KMP_SNPRINTF(scan, end - scan + 1, "{<empty>}");
     while (*scan != '\0')
       scan++;
     KMP_ASSERT(scan <= end);
     return buf;
   }
 
-  KMP_SNPRINTF(scan, end - scan + 1, "{%ld", (long)i);
+  KMP_SNPRINTF(scan, end - scan + 1, "{%d", i);
   while (*scan != '\0')
     scan++;
   i++;
   for (; i != mask->end(); i = mask->next(i)) {
     if (!KMP_CPU_ISSET(i, mask)) {
       continue;
     }
 
     // Check for buffer overflow.  A string of the form ",<n>" will have at most
     // 10 characters, plus we want to leave room to print ",...}" if the set is
     // too large to print for a total of 15 characters. We already left room for
     // '\0' in setting end.
     if (end - scan < 15) {
       break;
     }
-    KMP_SNPRINTF(scan, end - scan + 1, ",%-ld", (long)i);
+    KMP_SNPRINTF(scan, end - scan + 1, ",%-d", i);
     while (*scan != '\0')
       scan++;
   }
   if (i != mask->end()) {
     KMP_SNPRINTF(scan, end - scan + 1, ",...");
     while (*scan != '\0')
       scan++;
   }
if (__kmp_affinity_type == affinity_none) {
     }
     return 0;
   }
 
   // Contruct the data structure to be returned.
   *address2os =
       (AddrUnsPair *)__kmp_allocate(sizeof(**address2os) * __kmp_avail_proc);
   int avail_ct = 0;
-  unsigned int i;
+  int i;
   KMP_CPU_SET_ITERATE(i, __kmp_affin_fullMask) {
     // Skip this proc if it is not included in the machine model.
     if (!KMP_CPU_ISSET(i, __kmp_affin_fullMask)) {
       continue;
     }
     __kmp_pu_os_idx[avail_ct] = i; // suppose indices are flat
     Address addr(1);
     addr.labels[0] = i;
public:
   unsigned apicId; // from cpuid after binding
   unsigned maxCoresPerPkg; //      ""
   unsigned maxThreadsPerPkg; //      ""
   unsigned pkgId; // inferred from above values
   unsigned coreId; //      ""
   unsigned threadId; //      ""
 };
 
-static int __kmp_affinity_cmp_apicThreadInfo_os_id(const void *a,
-                                                   const void *b) {
-  const apicThreadInfo *aa = (const apicThreadInfo *)a;
-  const apicThreadInfo *bb = (const apicThreadInfo *)b;
-  if (aa->osId < bb->osId)
-    return -1;
-  if (aa->osId > bb->osId)
-    return 1;
-  return 0;
-}
-
 static int __kmp_affinity_cmp_apicThreadInfo_phys_id(const void *a,
                                                      const void *b) {
   const apicThreadInfo *aa = (const apicThreadInfo *)a;
   const apicThreadInfo *bb = (const apicThreadInfo *)b;
   if (aa->pkgId < bb->pkgId)
     return -1;
   if (aa->pkgId > bb->pkgId)
     return 1;

 
 // On IA-32 architecture and Intel(R) 64 architecture, we attempt to use
 // an algorithm which cycles through the available os threads, setting
 // the current thread's affinity mask to that thread, and then retrieves
 // the Apic Id for each thread context using the cpuid instruction.
 static int __kmp_affinity_create_apicid_map(AddrUnsPair **address2os,
                                             kmp_i18n_id_t *const msg_id) {
   kmp_cpuid buf;
-  int rc;
   *address2os = NULL;
   *msg_id = kmp_i18n_null;
 
   // Check if cpuid leaf 4 is supported.
   __kmp_x86_cpuid(0, 0, &buf);
   if (buf.eax < 4) {
     *msg_id = kmp_i18n_str_NoLeaf4Support;
     return -1;
if (__kmp_affinity_uniform_topology()) {
       KMP_INFORM(Uniform, "KMP_AFFINITY");
     } else {
       KMP_INFORM(NonUniform, "KMP_AFFINITY");
     }
     KMP_INFORM(Topology, "KMP_AFFINITY", nPackages, nCoresPerPkg,
                __kmp_nThreadsPerCore, __kmp_ncores);
   }
   KMP_DEBUG_ASSERT(__kmp_pu_os_idx == NULL);
-  KMP_DEBUG_ASSERT(nApics == __kmp_avail_proc);
+  KMP_DEBUG_ASSERT(nApics == (unsigned)__kmp_avail_proc);
   __kmp_pu_os_idx = (int *)__kmp_allocate(sizeof(int) * __kmp_avail_proc);
   for (i = 0; i < nApics; ++i) {
     __kmp_pu_os_idx[i] = threadInfo[i].osId;
   }
   if (__kmp_affinity_type == affinity_none) {
     __kmp_free(threadInfo);
     KMP_CPU_FREE(oldMask);
     return 0;
if (new_depth != depth) {
     for (proc = 0; (int)proc < nApics; proc++) {
       Address addr(new_depth);
       new_retval[proc] = AddrUnsPair(addr, retval[proc].second);
     }
     int new_level = 0;
     int newPkgLevel = -1;
     int newCoreLevel = -1;
     int newThreadLevel = -1;
-    int i;
     for (level = 0; level < depth; level++) {
       if ((maxCt[level] == 1) && (level != pkgLevel)) {
         // Remove this level. Never remove the package level
         continue;
       }
       if (level == pkgLevel) {
         newPkgLevel = new_level;
       }

 #define threadIdIndex 1
 #define coreIdIndex 2
 #define pkgIdIndex 3
 #define nodeIdIndex 4
 
 typedef unsigned *ProcCpuInfo;
 static unsigned maxIndex = pkgIdIndex;
 
-static int __kmp_affinity_cmp_ProcCpuInfo_os_id(const void *a, const void *b) {
-  const unsigned *aa = (const unsigned *)a;
-  const unsigned *bb = (const unsigned *)b;
-  if (aa[osIdIndex] < bb[osIdIndex])
-    return -1;
-  if (aa[osIdIndex] > bb[osIdIndex])
-    return 1;
-  return 0;
-}
-
 static int __kmp_affinity_cmp_ProcCpuInfo_phys_id(const void *a,
                                                   const void *b) {
   unsigned i;
   const unsigned *aa = *(unsigned *const *)a;
   const unsigned *bb = *(unsigned *const *)b;
   for (i = maxIndex;; i--) {
     if (aa[i] < bb[i])
       return -1;
if ((__kmp_dflt_team_nth == 0) && (teamSize > 0)) {
     __kmp_dflt_team_nth = teamSize;
     KA_TRACE(20, ("__kmp_affinity_create_cpuinfo_map: setting "
                   "__kmp_dflt_team_nth = %d\n",
                   __kmp_dflt_team_nth));
   }
 #endif // KMP_MIC && REDUCE_TEAM_SIZE
 
   KMP_DEBUG_ASSERT(__kmp_pu_os_idx == NULL);
-  KMP_DEBUG_ASSERT(num_avail == __kmp_avail_proc);
+  KMP_DEBUG_ASSERT(num_avail == (unsigned)__kmp_avail_proc);
   __kmp_pu_os_idx = (int *)__kmp_allocate(sizeof(int) * __kmp_avail_proc);
   for (i = 0; i < num_avail; ++i) { // fill the os indices
     __kmp_pu_os_idx[i] = threadInfo[i][osIdIndex];
   }
 
   if (__kmp_affinity_type == affinity_none) {
     __kmp_free(lastId);
     __kmp_free(totals);
     __kmp_free(maxCt);
     __kmp_free(counts);
     CLEANUP_THREAD_INFO;
     return 0;
   }
 
   // Count the number of levels which have more nodes at that level than at the
   // parent's level (with there being an implicit root node of the top level).
   // This is equivalent to saying that there is at least one node at this level
   // which has a sibling. These levels are in the map, and the package level is
   // always in the map.
   bool *inMap = (bool *)__kmp_allocate((maxIndex + 1) * sizeof(bool));
-  int level = 0;
   for (index = threadIdIndex; index < maxIndex; index++) {
     KMP_ASSERT(totals[index] >= totals[index + 1]);
     inMap[index] = (totals[index] > totals[index + 1]);
   }
   inMap[maxIndex] = (totals[maxIndex] > 1);
   inMap[pkgIdIndex] = true;
 
   int depth = 0;
#if KMP_OS_WINDOWS
   } else
 #endif
     __kmp_set_system_affinity(th->th.th_affin_mask, TRUE);
 }
 
 #if OMP_40_ENABLED
 
 void __kmp_affinity_set_place(int gtid) {
-  int retval;
-
   if (!KMP_AFFINITY_CAPABLE()) {
     return;
   }
 
   kmp_info_t *th = (kmp_info_t *)TCR_SYNC_PTR(__kmp_threads[gtid]);
 
   KA_TRACE(100, ("__kmp_affinity_set_place: binding T#%d to place %d (current "
                  "place = %d)\n",
#if KMP_GROUP_AFFINITY
   if (__kmp_num_proc_groups > 1) {
     return (int)(__kmp_num_proc_groups * sizeof(DWORD_PTR) * CHAR_BIT);
   }
 #endif
   return __kmp_xproc;
 }
 
 int __kmp_aux_set_affinity_mask_proc(int proc, void **mask) {
-  int retval;
-
   if (!KMP_AFFINITY_CAPABLE()) {
     return -1;
   }
 
   KA_TRACE(1000, ; {
     int gtid = __kmp_entry_gtid();
     char buf[KMP_AFFIN_MASK_PRINT_LEN];
     __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
if (!KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
     return -2;
   }
 
   KMP_CPU_SET(proc, (kmp_affin_mask_t *)(*mask));
   return 0;
 }
 
 int __kmp_aux_unset_affinity_mask_proc(int proc, void **mask) {
-  int retval;
-
   if (!KMP_AFFINITY_CAPABLE()) {
     return -1;
   }
 
   KA_TRACE(1000, ; {
     int gtid = __kmp_entry_gtid();
     char buf[KMP_AFFIN_MASK_PRINT_LEN];
     __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
if (!KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
     return -2;
   }
 
   KMP_CPU_CLR(proc, (kmp_affin_mask_t *)(*mask));
   return 0;
 }
 
 int __kmp_aux_get_affinity_mask_proc(int proc, void **mask) {
-  int retval;
-
   if (!KMP_AFFINITY_CAPABLE()) {
     return -1;
   }
 
   KA_TRACE(1000, ; {
     int gtid = __kmp_entry_gtid();
     char buf[KMP_AFFIN_MASK_PRINT_LEN];
     __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,

runtime/src/kmp_alloc.cpp

 static void *bget(kmp_info_t *th, bufsize size);
 static void *bgetz(kmp_info_t *th, bufsize size);
 static void *bgetr(kmp_info_t *th, void *buffer, bufsize newsize);
 static void brel(kmp_info_t *th, void *buf);
 static void bectl(kmp_info_t *th, bget_compact_t compact,
                   bget_acquire_t acquire, bget_release_t release,
                   bufsize pool_incr);
 
-#ifdef KMP_DEBUG
-static void bstats(kmp_info_t *th, bufsize *curalloc, bufsize *totfree,
-                   bufsize *maxfree, long *nget, long *nrel);
-static void bstatse(kmp_info_t *th, bufsize *pool_incr, long *npool,
-                    long *npget, long *nprel, long *ndget, long *ndrel);
-static void bufdump(kmp_info_t *th, void *buf);
-static void bpoold(kmp_info_t *th, void *pool, int dumpalloc, int dumpfree);
-static int bpoolv(kmp_info_t *th, void *pool);
-#endif
-
 /* BGET CONFIGURATION */
 /* Buffer allocation size quantum: all buffers allocated are a
    multiple of this size.  This MUST be a power of two. */
 
 /* On IA-32 architecture with  Linux* OS, malloc() does not
    ensure 16 byte alignmnent */
 
 #if KMP_ARCH_X86 || !KMP_HAVE_QUAD
static thr_data_t *get_thr_data(kmp_info_t *th) {
 
   data = (thr_data_t *)th->th.th_local.bget_data;
 
   KMP_DEBUG_ASSERT(data != 0);
 
   return data;
 }
 
-#ifdef KMP_DEBUG
-
-static void __kmp_bget_validate_queue(kmp_info_t *th) {
-  /* NOTE: assume that the global_lock is held */
-
-  void *p = (void *)th->th.th_local.bget_list;
-
-  while (p != 0) {
-    bfhead_t *b = BFH(((char *)p) - sizeof(bhead_t));
-
-    KMP_DEBUG_ASSERT(b->bh.bb.bsize != 0);
-    p = (void *)b->ql.flink;
-  }
-}
-
-#endif
-
 /* Walk the free list and release the enqueued buffers */
 static void __kmp_bget_dequeue(kmp_info_t *th) {
   void *p = TCR_SYNC_PTR(th->th.th_local.bget_list);
 
   if (p != 0) {
 #if USE_CMP_XCHG_FOR_BGET
     {
       volatile void *old_value = TCR_SYNC_PTR(th->th.th_local.bget_list);

 #endif
     }
   }
 
   if (count == 0)
     __kmp_printf_no_lock("__kmp_printpool: T#%d No free blocks\n", gtid);
 }
 
-#ifdef KMP_DEBUG
-
-#if BufStats
-
-/*  BSTATS  --  Return buffer allocation free space statistics.  */
-static void bstats(kmp_info_t *th, bufsize *curalloc, bufsize *totfree,
-                   bufsize *maxfree, long *nget, long *nrel) {
-  int bin = 0;
-  thr_data_t *thr = get_thr_data(th);
-
-  *nget = thr->numget;
-  *nrel = thr->numrel;
-  *curalloc = (bufsize)thr->totalloc;
-  *totfree = 0;
-  *maxfree = -1;
-
-  for (bin = 0; bin < MAX_BGET_BINS; ++bin) {
-    bfhead_t *b = thr->freelist[bin].ql.flink;
-
-    while (b != &thr->freelist[bin]) {
-      KMP_DEBUG_ASSERT(b->bh.bb.bsize > 0);
-      *totfree += b->bh.bb.bsize;
-      if (b->bh.bb.bsize > *maxfree) {
-        *maxfree = b->bh.bb.bsize;
-      }
-      b = b->ql.flink; /* Link to next buffer */
-    }
-  }
-}
-
-/*  BSTATSE  --  Return extended statistics  */
-static void bstatse(kmp_info_t *th, bufsize *pool_incr, long *npool,
-                    long *npget, long *nprel, long *ndget, long *ndrel) {
-  thr_data_t *thr = get_thr_data(th);
-
-  *pool_incr = (thr->pool_len < 0) ? -thr->exp_incr : thr->exp_incr;
-  *npool = thr->numpblk;
-  *npget = thr->numpget;
-  *nprel = thr->numprel;
-  *ndget = thr->numdget;
-  *ndrel = thr->numdrel;
-}
-
-#endif /* BufStats */
-
-/*  BUFDUMP  --  Dump the data in a buffer.  This is called with the  user
-                 data pointer, and backs up to the buffer header.  It will
-                 dump either a free block or an allocated one.  */
-static void bufdump(kmp_info_t *th, void *buf) {
-  bfhead_t *b;
-  unsigned char *bdump;
-  bufsize bdlen;
-
-  b = BFH(((char *)buf) - sizeof(bhead_t));
-  KMP_DEBUG_ASSERT(b->bh.bb.bsize != 0);
-  if (b->bh.bb.bsize < 0) {
-    bdump = (unsigned char *)buf;
-    bdlen = (-b->bh.bb.bsize) - (bufsize)sizeof(bhead_t);
-  } else {
-    bdump = (unsigned char *)(((char *)b) + sizeof(bfhead_t));
-    bdlen = b->bh.bb.bsize - (bufsize)sizeof(bfhead_t);
-  }
-
-  while (bdlen > 0) {
-    int i, dupes = 0;
-    bufsize l = bdlen;
-    char bhex[50], bascii[20];
-
-    if (l > 16) {
-      l = 16;
-    }
-
-    for (i = 0; i < l; i++) {
-      (void)KMP_SNPRINTF(bhex + i * 3, sizeof(bhex) - i * 3, "%02X ", bdump[i]);
-      if (bdump[i] > 0x20 && bdump[i] < 0x7F)
-        bascii[i] = bdump[i];
-      else
-        bascii[i] = ' ';
-    }
-    bascii[i] = 0;
-    (void)__kmp_printf_no_lock("%-48s   %s\n", bhex, bascii);
-    bdump += l;
-    bdlen -= l;
-    while ((bdlen > 16) &&
-           (memcmp((char *)(bdump - 16), (char *)bdump, 16) == 0)) {
-      dupes++;
-      bdump += 16;
-      bdlen -= 16;
-    }
-    if (dupes > 1) {
-      (void)__kmp_printf_no_lock(
-          "     (%d lines [%d bytes] identical to above line skipped)\n", dupes,
-          dupes * 16);
-    } else if (dupes == 1) {
-      bdump -= 16;
-      bdlen += 16;
-    }
-  }
-}
-
-/*  BPOOLD  --  Dump a buffer pool.  The buffer headers are always listed.
-                If DUMPALLOC is nonzero, the contents of allocated buffers
-                are  dumped.   If  DUMPFREE  is  nonzero,  free blocks are
-                dumped as well.  If FreeWipe  checking  is  enabled,  free
-                blocks  which  have  been clobbered will always be dumped. */
-static void bpoold(kmp_info_t *th, void *buf, int dumpalloc, int dumpfree) {
-  bfhead_t *b = BFH((char *)buf - sizeof(bhead_t));
-
-  while (b->bh.bb.bsize != ESent) {
-    bufsize bs = b->bh.bb.bsize;
-
-    if (bs < 0) {
-      bs = -bs;
-      (void)__kmp_printf_no_lock("Allocated buffer: size %6ld bytes.\n",
-                                 (long)bs);
-      if (dumpalloc) {
-        bufdump(th, (void *)(((char *)b) + sizeof(bhead_t)));
-      }
-    } else {
-      const char *lerr = "";
-
-      KMP_DEBUG_ASSERT(bs > 0);
-      if ((b->ql.blink->ql.flink != b) || (b->ql.flink->ql.blink != b)) {
-        lerr = "  (Bad free list links)";
-      }
-      (void)__kmp_printf_no_lock("Free block:       size %6ld bytes.%s\n",
-                                 (long)bs, lerr);
-#ifdef FreeWipe
-      lerr = ((char *)b) + sizeof(bfhead_t);
-      if ((bs > sizeof(bfhead_t)) &&
-          ((*lerr != 0x55) ||
-           (memcmp(lerr, lerr + 1, (size_t)(bs - (sizeof(bfhead_t) + 1))) !=
-            0))) {
-        (void)__kmp_printf_no_lock(
-            "(Contents of above free block have been overstored.)\n");
-        bufdump(th, (void *)(((char *)b) + sizeof(bhead_t)));
-      } else
-#endif
-          if (dumpfree) {
-        bufdump(th, (void *)(((char *)b) + sizeof(bhead_t)));
-      }
-    }
-    b = BFH(((char *)b) + bs);
-  }
-}
-
-/*  BPOOLV  --  Validate a buffer pool. */
-static int bpoolv(kmp_info_t *th, void *buf) {
-  bfhead_t *b = BFH(buf);
-
-  while (b->bh.bb.bsize != ESent) {
-    bufsize bs = b->bh.bb.bsize;
-
-    if (bs < 0) {
-      bs = -bs;
-    } else {
-#ifdef FreeWipe
-      char *lerr = "";
-#endif
-
-      KMP_DEBUG_ASSERT(bs > 0);
-      if (bs <= 0) {
-        return 0;
-      }
-      if ((b->ql.blink->ql.flink != b) || (b->ql.flink->ql.blink != b)) {
-        (void)__kmp_printf_no_lock(
-            "Free block: size %6ld bytes.  (Bad free list links)\n", (long)bs);
-        KMP_DEBUG_ASSERT(0);
-        return 0;
-      }
-#ifdef FreeWipe
-      lerr = ((char *)b) + sizeof(bfhead_t);
-      if ((bs > sizeof(bfhead_t)) &&
-          ((*lerr != 0x55) ||
-           (memcmp(lerr, lerr + 1, (size_t)(bs - (sizeof(bfhead_t) + 1))) !=
-            0))) {
-        (void)__kmp_printf_no_lock(
-            "(Contents of above free block have been overstored.)\n");
-        bufdump(th, (void *)(((char *)b) + sizeof(bhead_t)));
-        KMP_DEBUG_ASSERT(0);
-        return 0;
-      }
-#endif /* FreeWipe */
-    }
-    b = BFH(((char *)b) + bs);
-  }
-  return 1;
-}
-
-#endif /* KMP_DEBUG */
-
 void __kmp_initialize_bget(kmp_info_t *th) {
   KMP_DEBUG_ASSERT(SizeQuant >= sizeof(void *) && (th != 0));
 
   set_thr_data(th);
 
   bectl(th, (bget_compact_t)0, (bget_acquire_t)malloc, (bget_release_t)free,
         (bufsize)__kmp_malloc_pool_incr);
 }

runtime/src/kmp_atomic.cpp

#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;                                                              \
-  TYPE KMP_ATOMIC_VOLATILE temp_val;                                           \
   OP_GOMP_CRITICAL_CPT_REV(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

 // Routines for Extended types: long double, _Quad, complex flavours (use
 // critical section)
 //     TYPE_ID, OP_ID, TYPE - detailed above
 //     OP      - operator
 //     LCK_ID  - lock identifier, used to possibly distinguish lock variable
 #define ATOMIC_CRITICAL_CPT_REV(TYPE_ID, OP_ID, TYPE, OP, LCK_ID, GOMP_FLAG)   \
   ATOMIC_BEGIN_CPT(TYPE_ID, OP_ID, TYPE, TYPE)                                 \
   TYPE new_value;                                                              \
-  TYPE KMP_ATOMIC_VOLATILE temp_val;                                           \
   /*printf("__kmp_atomic_mode = %d\n", __kmp_atomic_mode);*/                   \
   OP_GOMP_CRITICAL_CPT_REV(OP, GOMP_FLAG)                                      \
   OP_CRITICAL_CPT_REV(OP, LCK_ID)                                              \
   }
 
 /* ------------------------------------------------------------------------- */
 // routines for long double type
 ATOMIC_CRITICAL_CPT_REV(float10, sub_cpt_rev, long double, -, 10r,

runtime/src/kmp_barrier.cpp

int __kmp_barrier(enum barrier_type bt, int gtid, int is_split,
                   size_t reduce_size, void *reduce_data,
                   void (*reduce)(void *, void *)) {
   KMP_TIME_PARTITIONED_BLOCK(OMP_plain_barrier);
   KMP_SET_THREAD_STATE_BLOCK(PLAIN_BARRIER);
   int tid = __kmp_tid_from_gtid(gtid);
   kmp_info_t *this_thr = __kmp_threads[gtid];
   kmp_team_t *team = this_thr->th.th_team;
   int status = 0;
-  ident_t *loc = __kmp_threads[gtid]->th.th_ident;
 #if OMPT_SUPPORT
   ompt_data_t *my_task_data;
   ompt_data_t *my_parallel_data;
   void *return_address;
 #endif
 
   KA_TRACE(15, ("__kmp_barrier: T#%d(%d:%d) has arrived\n", gtid,
                 __kmp_team_from_gtid(gtid)->t.t_id, __kmp_tid_from_gtid(gtid)));

 #if USE_ITT_BUILD && USE_ITT_NOTIFY
       // Barrier - report frame end (only if active_level == 1)
       if ((__itt_frame_submit_v3_ptr || KMP_ITT_DEBUG) &&
           __kmp_forkjoin_frames_mode &&
 #if OMP_40_ENABLED
           this_thr->th.th_teams_microtask == NULL &&
 #endif
           team->t.t_active_level == 1) {
+        ident_t *loc = __kmp_threads[gtid]->th.th_ident;
         kmp_uint64 cur_time = __itt_get_timestamp();
         kmp_info_t **other_threads = team->t.t_threads;
         int nproc = this_thr->th.th_team_nproc;
         int i;
         switch (__kmp_forkjoin_frames_mode) {
         case 1:
           __kmp_itt_frame_submit(gtid, this_thr->th.th_frame_time, cur_time, 0,
                                  loc, nproc);

runtime/src/kmp_csupport.cpp

#endif
   // HLE lock for speculation
   if (hint & omp_lock_hint_speculative)
     return KMP_TSX_LOCK(hle);
 
   return __kmp_user_lock_seq;
 }
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
+#if KMP_USE_DYNAMIC_LOCK
 static kmp_mutex_impl_t
 __ompt_get_mutex_impl_type(void *user_lock, kmp_indirect_lock_t *ilock = 0) {
   if (user_lock) {
     switch (KMP_EXTRACT_D_TAG(user_lock)) {
     case 0:
       break;
 #if KMP_USE_FUTEX
     case locktag_futex:
#endif
   case locktag_nested_ticket:
   case locktag_nested_queuing:
   case locktag_nested_drdpa:
     return kmp_mutex_impl_queuing;
   default:
     return ompt_mutex_impl_unknown;
   }
 }
-
+#else
 // For locks without dynamic binding
 static kmp_mutex_impl_t __ompt_get_mutex_impl_type() {
   switch (__kmp_user_lock_kind) {
   case lk_tas:
     return kmp_mutex_impl_spin;
 #if KMP_USE_FUTEX
   case lk_futex:
 #endif
   case lk_ticket:
   case lk_queuing:
   case lk_drdpa:
     return kmp_mutex_impl_queuing;
 #if KMP_USE_TSX
   case lk_hle:
   case lk_rtm:
   case lk_adaptive:
     return kmp_mutex_impl_speculative;
 #endif
   default:
     return ompt_mutex_impl_unknown;
   }
 }
-#endif
+#endif // KMP_USE_DYNAMIC_LOCK
+#endif // OMPT_SUPPORT && OMPT_OPTIONAL
 
 /*!
 @ingroup WORK_SHARING
 @param loc  source location information.
 @param global_tid  global thread number.
 @param crit identity of the critical section. This could be a pointer to a lock
 associated with the critical section, or some other suitably unique value.
 @param hint the lock hint.

runtime/src/kmp_debug.h

 // Run-time assertions.
 
 extern void __kmp_dump_debug_buffer(void);
 
 #ifdef KMP_USE_ASSERT
 extern int __kmp_debug_assert(char const *expr, char const *file, int line);
 #ifdef KMP_DEBUG
 #define KMP_ASSERT(cond)                                                       \
-  ((cond) ? 0 : __kmp_debug_assert(#cond, __FILE__, __LINE__))
+  if (!(cond)) {                                                               \
+    __kmp_debug_assert(#cond, __FILE__, __LINE__);                             \
+  }
 #define KMP_ASSERT2(cond, msg)                                                 \
-  ((cond) ? 0 : __kmp_debug_assert((msg), __FILE__, __LINE__))
+  if (!(cond)) {                                                               \
+    __kmp_debug_assert((msg), __FILE__, __LINE__);                             \
+  }
 #define KMP_DEBUG_ASSERT(cond) KMP_ASSERT(cond)
 #define KMP_DEBUG_ASSERT2(cond, msg) KMP_ASSERT2(cond, msg)
+#define KMP_DEBUG_USE_VAR(x) /* Nothing (it is used!) */
 #else
 // Do not expose condition in release build. Use "assertion failure".
 #define KMP_ASSERT(cond)                                                       \
-  ((cond) ? 0 : __kmp_debug_assert("assertion failure", __FILE__, __LINE__))
+  if (!(cond)) {                                                               \
+    __kmp_debug_assert("assertion failure", __FILE__, __LINE__);               \
+  }
 #define KMP_ASSERT2(cond, msg) KMP_ASSERT(cond)
-#define KMP_DEBUG_ASSERT(cond) 0
-#define KMP_DEBUG_ASSERT2(cond, msg) 0
+#define KMP_DEBUG_ASSERT(cond) /* Nothing */
+#define KMP_DEBUG_ASSERT2(cond, msg) /* Nothing */
+#define KMP_DEBUG_USE_VAR(x) ((void)(x))
 #endif // KMP_DEBUG
 #else
-#define KMP_ASSERT(cond) 0
-#define KMP_ASSERT2(cond, msg) 0
-#define KMP_DEBUG_ASSERT(cond) 0
-#define KMP_DEBUG_ASSERT2(cond, msg) 0
+#define KMP_ASSERT(cond) /* Nothing */
+#define KMP_ASSERT2(cond, msg) /* Nothing */
+#define KMP_DEBUG_ASSERT(cond) /* Nothing */
+#define KMP_DEBUG_ASSERT2(cond, msg) /* Nothing */
+#define KMP_DEBUG_USE_VAR(x) ((void)(x))
 #endif // KMP_USE_ASSERT
 
 #ifdef KMP_DEBUG
 extern void __kmp_debug_printf_stdout(char const *format, ...);
 #endif
 extern void __kmp_debug_printf(char const *format, ...);
 
 #ifdef KMP_DEBUG

runtime/src/kmp_dispatch.h

static UT __kmp_wait_yield(volatile UT *spinner, UT checker,
   return r;
 }
 
 /* ------------------------------------------------------------------------ */
 /* ------------------------------------------------------------------------ */
 
 template <typename UT>
 void __kmp_dispatch_deo(int *gtid_ref, int *cid_ref, ident_t *loc_ref) {
-  typedef typename traits_t<UT>::signed_t ST;
   dispatch_private_info_template<UT> *pr;
 
   int gtid = *gtid_ref;
   //    int  cid = *cid_ref;
   kmp_info_t *th = __kmp_threads[gtid];
   KMP_DEBUG_ASSERT(th->th.th_dispatch);
 
   KD_TRACE(100, ("__kmp_dispatch_deo: T#%d called\n", gtid));

runtime/src/kmp_dispatch.cpp

void __kmp_dispatch_init_algorithm(ident_t *loc, int gtid,
                                    enum sched_type schedule, T lb, T ub,
                                    typename traits_t<T>::signed_t st,
 #if USE_ITT_BUILD
                                    kmp_uint64 *cur_chunk,
 #endif
                                    typename traits_t<T>::signed_t chunk,
                                    T nproc, T tid) {
   typedef typename traits_t<T>::unsigned_t UT;
-  typedef typename traits_t<T>::signed_t ST;
   typedef typename traits_t<T>::floating_t DBL;
 
   int active;
   T tc;
   kmp_info_t *th;
   kmp_team_t *team;
 
 #ifdef KMP_DEBUG
+  typedef typename traits_t<T>::signed_t ST;
   {
     char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format("__kmp_dispatch_init_algorithm: T#%%d called "
                             "pr:%%p lb:%%%s ub:%%%s st:%%%s "
                             "schedule:%%d chunk:%%%s nproc:%%%s tid:%%%s\n",
                             traits_t<T>::spec, traits_t<T>::spec,
                             traits_t<ST>::spec, traits_t<ST>::spec,

 // UT - unsigned flavor of T, ST - signed flavor of T,
 // DBL - double if sizeof(T)==4, or long double if sizeof(T)==8
 template <typename T>
 static void
 __kmp_dispatch_init(ident_t *loc, int gtid, enum sched_type schedule, T lb,
                     T ub, typename traits_t<T>::signed_t st,
                     typename traits_t<T>::signed_t chunk, int push_ws) {
   typedef typename traits_t<T>::unsigned_t UT;
-  typedef typename traits_t<T>::signed_t ST;
-  typedef typename traits_t<T>::floating_t DBL;
 
   int active;
   kmp_info_t *th;
   kmp_team_t *team;
   kmp_uint32 my_buffer_index;
   dispatch_private_info_template<T> *pr;
   dispatch_shared_info_template<T> volatile *sh;
 
   KMP_BUILD_ASSERT(sizeof(dispatch_private_info_template<T>) ==
                    sizeof(dispatch_private_info));
   KMP_BUILD_ASSERT(sizeof(dispatch_shared_info_template<UT>) ==
                    sizeof(dispatch_shared_info));
 
   if (!TCR_4(__kmp_init_parallel))
     __kmp_parallel_initialize();
 
 #if INCLUDE_SSC_MARKS
   SSC_MARK_DISPATCH_INIT();
 #endif
 #ifdef KMP_DEBUG
+  typedef typename traits_t<T>::signed_t ST;
   {
     char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format("__kmp_dispatch_init: T#%%d called: schedule:%%d "
                             "chunk:%%%s lb:%%%s ub:%%%s st:%%%s\n",
                             traits_t<ST>::spec, traits_t<T>::spec,
                             traits_t<T>::spec, traits_t<ST>::spec);
     KD_TRACE(10, (buff, gtid, schedule, chunk, lb, ub, st));

 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                ,
                                void *codeptr
 #endif
                                ) {
 
   typedef typename traits_t<T>::unsigned_t UT;
   typedef typename traits_t<T>::signed_t ST;
-  typedef typename traits_t<T>::floating_t DBL;
   // This is potentially slightly misleading, schedule(runtime) will appear here
   // even if the actual runtme schedule is static. (Which points out a
   // disadavantage of schedule(runtime): even when static scheduling is used it
   // costs more than a compile time choice to use static scheduling would.)
   KMP_TIME_PARTITIONED_BLOCK(FOR_dynamic_scheduling);
 
   int status;
   dispatch_private_info_template<T> *pr;
#endif
   return status;
 }
 
 template <typename T>
 static void __kmp_dist_get_bounds(ident_t *loc, kmp_int32 gtid,
                                   kmp_int32 *plastiter, T *plower, T *pupper,
                                   typename traits_t<T>::signed_t incr) {
   typedef typename traits_t<T>::unsigned_t UT;
-  typedef typename traits_t<T>::signed_t ST;
   kmp_uint32 team_id;
   kmp_uint32 nteams;
   UT trip_count;
   kmp_team_t *team;
   kmp_info_t *th;
 
   KMP_DEBUG_ASSERT(plastiter && plower && pupper);
   KE_TRACE(10, ("__kmpc_dist_get_bounds called (%d)\n", gtid));
 #ifdef KMP_DEBUG
+  typedef typename traits_t<T>::signed_t ST;
   {
     char *buff;
     // create format specifiers before the debug output
     buff = __kmp_str_format("__kmpc_dist_get_bounds: T#%%d liter=%%d "
                             "iter=(%%%s, %%%s, %%%s) signed?<%s>\n",
                             traits_t<T>::spec, traits_t<T>::spec,
                             traits_t<ST>::spec, traits_t<T>::spec);
     KD_TRACE(100, (buff, gtid, *plastiter, *plower, *pupper, incr));
#endif
   }
   th = __kmp_threads[gtid];
   team = th->th.th_team;
 #if OMP_40_ENABLED
   KMP_DEBUG_ASSERT(th->th.th_teams_microtask); // we are in the teams construct
   nteams = th->th.th_teams_size.nteams;
 #endif
   team_id = team->t.t_master_tid;
-  KMP_DEBUG_ASSERT(nteams == team->t.t_parent->t.t_nproc);
+  KMP_DEBUG_ASSERT(nteams == (kmp_uint32)team->t.t_parent->t.t_nproc);
 
   // compute global trip count
   if (incr == 1) {
     trip_count = *pupper - *plower + 1;
   } else if (incr == -1) {
     trip_count = *plower - *pupper + 1;
   } else if (incr > 0) {
     // upper-lower can exceed the limit of signed type

runtime/src/kmp_gsupport.cpp

if (ompt_enabled.enabled) {
     frame->exit_frame = OMPT_GET_FRAME_ADDRESS(1);
   }
 #endif
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)(void) {
   int gtid = __kmp_get_gtid();
   kmp_info_t *thr;
-  int ompt_team_size = __kmp_team_from_gtid(gtid)->t.t_nproc;
 
   thr = __kmp_threads[gtid];
 
   MKLOC(loc, "GOMP_parallel_end");
   KA_TRACE(20, ("GOMP_parallel_end: T#%d\n", gtid));
 
   if (!thr->th.th_team->t.t_serialized) {
     __kmp_run_after_invoked_task(gtid, __kmp_tid_from_gtid(gtid), thr,

 #endif
       __kmpc_omp_task(&loc, gtid, task);
     }
   } else {
 #if OMPT_SUPPORT
     ompt_thread_info_t oldInfo;
     kmp_info_t *thread;
     kmp_taskdata_t *taskdata;
-    kmp_taskdata_t *current_task;
     if (ompt_enabled.enabled) {
       // Store the threads states and restore them after the task
       thread = __kmp_threads[gtid];
       taskdata = KMP_TASK_TO_TASKDATA(task);
       oldInfo = thread->th.ompt_thread_info;
       thread->th.ompt_thread_info.wait_id = 0;
       thread->th.ompt_thread_info.state = omp_state_work_parallel;
       taskdata->ompt_task_info.frame.exit_frame = OMPT_GET_FRAME_ADDRESS(0);

runtime/src/kmp_lock.h

 typedef struct {
   kmp_user_lock_p lock;
   kmp_indirect_locktag_t type;
 } kmp_indirect_lock_t;
 
 // Function tables for direct locks. Set/unset/test differentiate functions
 // with/without consistency checking.
 extern void (*__kmp_direct_init[])(kmp_dyna_lock_t *, kmp_dyna_lockseq_t);
-extern void (*__kmp_direct_destroy[])(kmp_dyna_lock_t *);
+extern void (*(*__kmp_direct_destroy))(kmp_dyna_lock_t *);
 extern int (*(*__kmp_direct_set))(kmp_dyna_lock_t *, kmp_int32);
 extern int (*(*__kmp_direct_unset))(kmp_dyna_lock_t *, kmp_int32);
 extern int (*(*__kmp_direct_test))(kmp_dyna_lock_t *, kmp_int32);
 
 // Function tables for indirect locks. Set/unset/test differentiate functions
 // with/withuot consistency checking.
 extern void (*__kmp_indirect_init[])(kmp_user_lock_p);
-extern void (*__kmp_indirect_destroy[])(kmp_user_lock_p);
+extern void (*(*__kmp_indirect_destroy))(kmp_user_lock_p);
 extern int (*(*__kmp_indirect_set))(kmp_user_lock_p, kmp_int32);
 extern int (*(*__kmp_indirect_unset))(kmp_user_lock_p, kmp_int32);
 extern int (*(*__kmp_indirect_test))(kmp_user_lock_p, kmp_int32);
 
 // Extracts direct lock tag from a user lock pointer
 #define KMP_EXTRACT_D_TAG(l)                                                   \
   (*((kmp_dyna_lock_t *)(l)) & ((1 << KMP_LOCK_SHIFT) - 1) &                   \
    -(*((kmp_dyna_lock_t *)(l)) & 1))

runtime/src/kmp_lock.cpp

static int __kmp_release_tas_lock_with_checks(kmp_tas_lock_t *lck,
   }
   return __kmp_release_tas_lock(lck, gtid);
 }
 
 void __kmp_init_tas_lock(kmp_tas_lock_t *lck) {
   lck->lk.poll = KMP_LOCK_FREE(tas);
 }
 
-static void __kmp_init_tas_lock_with_checks(kmp_tas_lock_t *lck) {
-  __kmp_init_tas_lock(lck);
-}
-
 void __kmp_destroy_tas_lock(kmp_tas_lock_t *lck) { lck->lk.poll = 0; }
 
 static void __kmp_destroy_tas_lock_with_checks(kmp_tas_lock_t *lck) {
   char const *const func = "omp_destroy_lock";
   if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) &&
       __kmp_is_tas_lock_nestable(lck)) {
     KMP_FATAL(LockNestableUsedAsSimple, func);
   }
static int __kmp_release_nested_tas_lock_with_checks(kmp_tas_lock_t *lck,
   return __kmp_release_nested_tas_lock(lck, gtid);
 }
 
 void __kmp_init_nested_tas_lock(kmp_tas_lock_t *lck) {
   __kmp_init_tas_lock(lck);
   lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }
 
-static void __kmp_init_nested_tas_lock_with_checks(kmp_tas_lock_t *lck) {
-  __kmp_init_nested_tas_lock(lck);
-}
-
 void __kmp_destroy_nested_tas_lock(kmp_tas_lock_t *lck) {
   __kmp_destroy_tas_lock(lck);
   lck->lk.depth_locked = 0;
 }
 
 static void __kmp_destroy_nested_tas_lock_with_checks(kmp_tas_lock_t *lck) {
   char const *const func = "omp_destroy_nest_lock";
   if (!__kmp_is_tas_lock_nestable(lck)) {
static int __kmp_release_futex_lock_with_checks(kmp_futex_lock_t *lck,
   }
   return __kmp_release_futex_lock(lck, gtid);
 }
 
 void __kmp_init_futex_lock(kmp_futex_lock_t *lck) {
   TCW_4(lck->lk.poll, KMP_LOCK_FREE(futex));
 }
 
-static void __kmp_init_futex_lock_with_checks(kmp_futex_lock_t *lck) {
-  __kmp_init_futex_lock(lck);
-}
-
 void __kmp_destroy_futex_lock(kmp_futex_lock_t *lck) { lck->lk.poll = 0; }
 
 static void __kmp_destroy_futex_lock_with_checks(kmp_futex_lock_t *lck) {
   char const *const func = "omp_destroy_lock";
   if ((sizeof(kmp_futex_lock_t) <= OMP_LOCK_T_SIZE) &&
       __kmp_is_futex_lock_nestable(lck)) {
     KMP_FATAL(LockNestableUsedAsSimple, func);
   }
static int __kmp_release_nested_futex_lock_with_checks(kmp_futex_lock_t *lck,
   return __kmp_release_nested_futex_lock(lck, gtid);
 }
 
 void __kmp_init_nested_futex_lock(kmp_futex_lock_t *lck) {
   __kmp_init_futex_lock(lck);
   lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }
 
-static void __kmp_init_nested_futex_lock_with_checks(kmp_futex_lock_t *lck) {
-  __kmp_init_nested_futex_lock(lck);
-}
-
 void __kmp_destroy_nested_futex_lock(kmp_futex_lock_t *lck) {
   __kmp_destroy_futex_lock(lck);
   lck->lk.depth_locked = 0;
 }
 
 static void __kmp_destroy_nested_futex_lock_with_checks(kmp_futex_lock_t *lck) {
   char const *const func = "omp_destroy_nest_lock";
   if (!__kmp_is_futex_lock_nestable(lck)) {
std::atomic_store_explicit(
       std::memory_order_relaxed); // no thread owns the lock.
   std::atomic_store_explicit(
       &lck->lk.depth_locked, -1,
       std::memory_order_relaxed); // -1 => not a nested lock.
   std::atomic_store_explicit(&lck->lk.initialized, true,
                              std::memory_order_release);
 }
 
-static void __kmp_init_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
-  __kmp_init_ticket_lock(lck);
-}
-
 void __kmp_destroy_ticket_lock(kmp_ticket_lock_t *lck) {
   std::atomic_store_explicit(&lck->lk.initialized, false,
                              std::memory_order_release);
   lck->lk.self = NULL;
   lck->lk.location = NULL;
   std::atomic_store_explicit(&lck->lk.next_ticket, 0U,
                              std::memory_order_relaxed);
   std::atomic_store_explicit(&lck->lk.now_serving, 0U,

 
 void __kmp_init_nested_ticket_lock(kmp_ticket_lock_t *lck) {
   __kmp_init_ticket_lock(lck);
   std::atomic_store_explicit(&lck->lk.depth_locked, 0,
                              std::memory_order_relaxed);
   // >= 0 for nestable locks, -1 for simple locks
 }
 
-static void __kmp_init_nested_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
-  __kmp_init_nested_ticket_lock(lck);
-}
-
 void __kmp_destroy_nested_ticket_lock(kmp_ticket_lock_t *lck) {
   __kmp_destroy_ticket_lock(lck);
   std::atomic_store_explicit(&lck->lk.depth_locked, 0,
                              std::memory_order_relaxed);
 }
 
 static void
 __kmp_destroy_nested_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
__kmp_destroy_nested_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
   if (__kmp_get_ticket_lock_owner(lck) != -1) {
     KMP_FATAL(LockStillOwned, func);
   }
   __kmp_destroy_nested_ticket_lock(lck);
 }
 
 // access functions to fields which don't exist for all lock kinds.
 
-static int __kmp_is_ticket_lock_initialized(kmp_ticket_lock_t *lck) {
-  return std::atomic_load_explicit(&lck->lk.initialized,
-                                   std::memory_order_relaxed) &&
-         (lck->lk.self == lck);
-}
-
 static const ident_t *__kmp_get_ticket_lock_location(kmp_ticket_lock_t *lck) {
   return lck->lk.location;
 }
 
 static void __kmp_set_ticket_lock_location(kmp_ticket_lock_t *lck,
                                            const ident_t *loc) {
   lck->lk.location = loc;
 }
void __kmp_init_queuing_lock(kmp_queuing_lock_t *lck) {
   lck->lk.now_serving = 0;
   lck->lk.owner_id = 0; // no thread owns the lock.
   lck->lk.depth_locked = -1; // >= 0 for nestable locks, -1 for simple locks.
   lck->lk.initialized = lck;
 
   KA_TRACE(1000, ("__kmp_init_queuing_lock: lock %p initialized\n", lck));
 }
 
-static void __kmp_init_queuing_lock_with_checks(kmp_queuing_lock_t *lck) {
-  __kmp_init_queuing_lock(lck);
-}
-
 void __kmp_destroy_queuing_lock(kmp_queuing_lock_t *lck) {
   lck->lk.initialized = NULL;
   lck->lk.location = NULL;
   lck->lk.head_id = 0;
   lck->lk.tail_id = 0;
   lck->lk.next_ticket = 0;
   lck->lk.now_serving = 0;
   lck->lk.owner_id = 0;
__kmp_release_nested_queuing_lock_with_checks(kmp_queuing_lock_t *lck,
   return __kmp_release_nested_queuing_lock(lck, gtid);
 }
 
 void __kmp_init_nested_queuing_lock(kmp_queuing_lock_t *lck) {
   __kmp_init_queuing_lock(lck);
   lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }
 
-static void
-__kmp_init_nested_queuing_lock_with_checks(kmp_queuing_lock_t *lck) {
-  __kmp_init_nested_queuing_lock(lck);
-}
-
 void __kmp_destroy_nested_queuing_lock(kmp_queuing_lock_t *lck) {
   __kmp_destroy_queuing_lock(lck);
   lck->lk.depth_locked = 0;
 }
 
 static void
 __kmp_destroy_nested_queuing_lock_with_checks(kmp_queuing_lock_t *lck) {
   char const *const func = "omp_destroy_nest_lock";
   if (lck->lk.initialized != lck) {
     KMP_FATAL(LockIsUninitialized, func);
   }
   if (!__kmp_is_queuing_lock_nestable(lck)) {
     KMP_FATAL(LockSimpleUsedAsNestable, func);
   }
   if (__kmp_get_queuing_lock_owner(lck) != -1) {
     KMP_FATAL(LockStillOwned, func);
   }
   __kmp_destroy_nested_queuing_lock(lck);
 }
 
 // access functions to fields which don't exist for all lock kinds.
 
-static int __kmp_is_queuing_lock_initialized(kmp_queuing_lock_t *lck) {
-  return lck == lck->lk.initialized;
-}
-
 static const ident_t *__kmp_get_queuing_lock_location(kmp_queuing_lock_t *lck) {
   return lck->lk.location;
 }
 
 static void __kmp_set_queuing_lock_location(kmp_queuing_lock_t *lck,
                                             const ident_t *loc) {
   lck->lk.location = loc;
 }
lck->lk.adaptive.max_soft_retries =
       __kmp_adaptive_backoff_params.max_soft_retries;
   lck->lk.adaptive.max_badness = __kmp_adaptive_backoff_params.max_badness;
 #if KMP_DEBUG_ADAPTIVE_LOCKS
   __kmp_zero_speculative_stats(&lck->lk.adaptive);
 #endif
   KA_TRACE(1000, ("__kmp_init_adaptive_lock: lock %p initialized\n", lck));
 }
 
-static void __kmp_init_adaptive_lock_with_checks(kmp_adaptive_lock_t *lck) {
-  __kmp_init_adaptive_lock(lck);
-}
-
 static void __kmp_destroy_adaptive_lock(kmp_adaptive_lock_t *lck) {
 #if KMP_DEBUG_ADAPTIVE_LOCKS
   __kmp_accumulate_speculative_stats(&lck->lk.adaptive);
 #endif
   __kmp_destroy_queuing_lock(GET_QLK_PTR(lck));
   // Nothing needed for the speculative part.
 }
 
void __kmp_init_drdpa_lock(kmp_drdpa_lock_t *lck) {
   lck->lk.now_serving = 0;
   lck->lk.owner_id = 0; // no thread owns the lock.
   lck->lk.depth_locked = -1; // >= 0 for nestable locks, -1 for simple locks.
   lck->lk.initialized = lck;
 
   KA_TRACE(1000, ("__kmp_init_drdpa_lock: lock %p initialized\n", lck));
 }
 
-static void __kmp_init_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck) {
-  __kmp_init_drdpa_lock(lck);
-}
-
 void __kmp_destroy_drdpa_lock(kmp_drdpa_lock_t *lck) {
   lck->lk.initialized = NULL;
   lck->lk.location = NULL;
   if (lck->lk.polls.load() != NULL) {
     __kmp_free(lck->lk.polls.load());
     lck->lk.polls = NULL;
   }
   if (lck->lk.old_polls != NULL) {
static int __kmp_release_nested_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck,
   return __kmp_release_nested_drdpa_lock(lck, gtid);
 }
 
 void __kmp_init_nested_drdpa_lock(kmp_drdpa_lock_t *lck) {
   __kmp_init_drdpa_lock(lck);
   lck->lk.depth_locked = 0; // >= 0 for nestable locks, -1 for simple locks
 }
 
-static void __kmp_init_nested_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck) {
-  __kmp_init_nested_drdpa_lock(lck);
-}
-
 void __kmp_destroy_nested_drdpa_lock(kmp_drdpa_lock_t *lck) {
   __kmp_destroy_drdpa_lock(lck);
   lck->lk.depth_locked = 0;
 }
 
 static void __kmp_destroy_nested_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck) {
   char const *const func = "omp_destroy_nest_lock";
   if (lck->lk.initialized != lck) {
     KMP_FATAL(LockIsUninitialized, func);
   }
   if (!__kmp_is_drdpa_lock_nestable(lck)) {
     KMP_FATAL(LockSimpleUsedAsNestable, func);
   }
   if (__kmp_get_drdpa_lock_owner(lck) != -1) {
     KMP_FATAL(LockStillOwned, func);
   }
   __kmp_destroy_nested_drdpa_lock(lck);
 }
 
 // access functions to fields which don't exist for all lock kinds.
 
-static int __kmp_is_drdpa_lock_initialized(kmp_drdpa_lock_t *lck) {
-  return lck == lck->lk.initialized;
-}
-
 static const ident_t *__kmp_get_drdpa_lock_location(kmp_drdpa_lock_t *lck) {
   return lck->lk.location;
 }
 
 static void __kmp_set_drdpa_lock_location(kmp_drdpa_lock_t *lck,
                                           const ident_t *loc) {
   lck->lk.location = loc;
 }

 
 static inline kmp_uint32 swap4(kmp_uint32 volatile *p, kmp_uint32 v) {
   __asm__ volatile(HLE_ACQUIRE "xchg %1,%0" : "+r"(v), "+m"(*p) : : "memory");
   return v;
 }
 
 static void __kmp_destroy_hle_lock(kmp_dyna_lock_t *lck) { TCW_4(*lck, 0); }
 
+static void __kmp_destroy_hle_lock_with_checks(kmp_dyna_lock_t *lck) {
+  TCW_4(*lck, 0);
+}
+
 static void __kmp_acquire_hle_lock(kmp_dyna_lock_t *lck, kmp_int32 gtid) {
   // Use gtid for KMP_LOCK_BUSY if necessary
   if (swap4(lck, KMP_LOCK_BUSY(1, hle)) != KMP_LOCK_FREE(hle)) {
     int delay = 1;
     do {
       while (*(kmp_uint32 volatile *)lck != KMP_LOCK_FREE(hle)) {
         for (int i = delay; i != 0; --i)
           KMP_CPU_PAUSE();

 static void __kmp_init_rtm_lock(kmp_queuing_lock_t *lck) {
   __kmp_init_queuing_lock(lck);
 }
 
 static void __kmp_destroy_rtm_lock(kmp_queuing_lock_t *lck) {
   __kmp_destroy_queuing_lock(lck);
 }
 
+static void __kmp_destroy_rtm_lock_with_checks(kmp_queuing_lock_t *lck) {
+  __kmp_destroy_queuing_lock_with_checks(lck);
+}
+
 static void __kmp_acquire_rtm_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid) {
   unsigned retries = 3, status;
   do {
     status = _xbegin();
     if (status == _XBEGIN_STARTED) {
       if (__kmp_is_unlocked_queuing_lock(lck))
         return;
       _xabort(0xff);

 // init functions
 #define expand(l, op) 0, __kmp_init_direct_lock,
 void (*__kmp_direct_init[])(kmp_dyna_lock_t *, kmp_dyna_lockseq_t) = {
     __kmp_init_indirect_lock, 0, KMP_FOREACH_D_LOCK(expand, init)};
 #undef expand
 
 // destroy functions
 #define expand(l, op) 0, (void (*)(kmp_dyna_lock_t *))__kmp_##op##_##l##_lock,
-void (*__kmp_direct_destroy[])(kmp_dyna_lock_t *) = {
+static void (*direct_destroy[])(kmp_dyna_lock_t *) = {
+    __kmp_destroy_indirect_lock, 0, KMP_FOREACH_D_LOCK(expand, destroy)};
+#undef expand
+#define expand(l, op)                                                          \
+  0, (void (*)(kmp_dyna_lock_t *))__kmp_destroy_##l##_lock_with_checks,
+static void (*direct_destroy_check[])(kmp_dyna_lock_t *) = {
     __kmp_destroy_indirect_lock, 0, KMP_FOREACH_D_LOCK(expand, destroy)};
 #undef expand
 
 // set/acquire functions
 #define expand(l, op)                                                          \
   0, (int (*)(kmp_dyna_lock_t *, kmp_int32))__kmp_##op##_##l##_lock,
 static int (*direct_set[])(kmp_dyna_lock_t *, kmp_int32) = {
     __kmp_set_indirect_lock, 0, KMP_FOREACH_D_LOCK(expand, acquire)};

 static int (*direct_unset_check[])(kmp_dyna_lock_t *, kmp_int32) = {
     __kmp_unset_indirect_lock_with_checks, 0,
     KMP_FOREACH_D_LOCK(expand, release)};
 static int (*direct_test_check[])(kmp_dyna_lock_t *, kmp_int32) = {
     __kmp_test_indirect_lock_with_checks, 0, KMP_FOREACH_D_LOCK(expand, test)};
 #undef expand
 
 // Exposes only one set of jump tables (*lock or *lock_with_checks).
+void (*(*__kmp_direct_destroy))(kmp_dyna_lock_t *) = 0;
 int (*(*__kmp_direct_set))(kmp_dyna_lock_t *, kmp_int32) = 0;
 int (*(*__kmp_direct_unset))(kmp_dyna_lock_t *, kmp_int32) = 0;
 int (*(*__kmp_direct_test))(kmp_dyna_lock_t *, kmp_int32) = 0;
 
 // Jump tables for the indirect lock functions
 #define expand(l, op) (void (*)(kmp_user_lock_p)) __kmp_##op##_##l##_##lock,
 void (*__kmp_indirect_init[])(kmp_user_lock_p) = {
     KMP_FOREACH_I_LOCK(expand, init)};
-void (*__kmp_indirect_destroy[])(kmp_user_lock_p) = {
+#undef expand
+
+#define expand(l, op) (void (*)(kmp_user_lock_p)) __kmp_##op##_##l##_##lock,
+static void (*indirect_destroy[])(kmp_user_lock_p) = {
+    KMP_FOREACH_I_LOCK(expand, destroy)};
+#undef expand
+#define expand(l, op)                                                          \
+  (void (*)(kmp_user_lock_p)) __kmp_##op##_##l##_##lock_with_checks,
+static void (*indirect_destroy_check[])(kmp_user_lock_p) = {
     KMP_FOREACH_I_LOCK(expand, destroy)};
 #undef expand
 
 // set/acquire functions
 #define expand(l, op)                                                          \
   (int (*)(kmp_user_lock_p, kmp_int32)) __kmp_##op##_##l##_##lock,
 static int (*indirect_set[])(kmp_user_lock_p,
                              kmp_int32) = {KMP_FOREACH_I_LOCK(expand, acquire)};
#define expand(l, op)                                                          \
   (int (*)(kmp_user_lock_p, kmp_int32)) __kmp_##op##_##l##_##lock_with_checks,
 static int (*indirect_unset_check[])(kmp_user_lock_p, kmp_int32) = {
     KMP_FOREACH_I_LOCK(expand, release)};
 static int (*indirect_test_check[])(kmp_user_lock_p, kmp_int32) = {
     KMP_FOREACH_I_LOCK(expand, test)};
 #undef expand
 
 // Exposes only one jump tables (*lock or *lock_with_checks).
+void (*(*__kmp_indirect_destroy))(kmp_user_lock_p) = 0;
 int (*(*__kmp_indirect_set))(kmp_user_lock_p, kmp_int32) = 0;
 int (*(*__kmp_indirect_unset))(kmp_user_lock_p, kmp_int32) = 0;
 int (*(*__kmp_indirect_test))(kmp_user_lock_p, kmp_int32) = 0;
 
 // Lock index table.
 kmp_indirect_lock_table_t __kmp_i_lock_table;
 
 // Size of indirect locks.

 
 // Initializes data for dynamic user locks.
 void __kmp_init_dynamic_user_locks() {
   // Initialize jump table for the lock functions
   if (__kmp_env_consistency_check) {
     __kmp_direct_set = direct_set_check;
     __kmp_direct_unset = direct_unset_check;
     __kmp_direct_test = direct_test_check;
+    __kmp_direct_destroy = direct_destroy_check;
     __kmp_indirect_set = indirect_set_check;
     __kmp_indirect_unset = indirect_unset_check;
     __kmp_indirect_test = indirect_test_check;
+    __kmp_indirect_destroy = indirect_destroy_check;
   } else {
     __kmp_direct_set = direct_set;
     __kmp_direct_unset = direct_unset;
     __kmp_direct_test = direct_test;
+    __kmp_direct_destroy = direct_destroy;
     __kmp_indirect_set = indirect_set;
     __kmp_indirect_unset = indirect_unset;
     __kmp_indirect_test = indirect_test;
+    __kmp_indirect_destroy = indirect_destroy;
   }
   // If the user locks have already been initialized, then return. Allow the
   // switch between different KMP_CONSISTENCY_CHECK values, but do not allocate
   // new lock tables if they have already been allocated.
   if (__kmp_init_user_locks)
     return;
 
   // Initialize lock index table
void __kmp_cleanup_indirect_user_locks() {
   __kmp_init_user_locks = FALSE;
 }
 
 enum kmp_lock_kind __kmp_user_lock_kind = lk_default;
 int __kmp_num_locks_in_block = 1; // FIXME - tune this value
 
 #else // KMP_USE_DYNAMIC_LOCK
 
+static void __kmp_init_tas_lock_with_checks(kmp_tas_lock_t *lck) {
+  __kmp_init_tas_lock(lck);
+}
+
+static void __kmp_init_nested_tas_lock_with_checks(kmp_tas_lock_t *lck) {
+  __kmp_init_nested_tas_lock(lck);
+}
+
+#if KMP_USE_FUTEX
+static void __kmp_init_futex_lock_with_checks(kmp_futex_lock_t *lck) {
+  __kmp_init_futex_lock(lck);
+}
+
+static void __kmp_init_nested_futex_lock_with_checks(kmp_futex_lock_t *lck) {
+  __kmp_init_nested_futex_lock(lck);
+}
+#endif
+
+static int __kmp_is_ticket_lock_initialized(kmp_ticket_lock_t *lck) {
+  return lck == lck->lk.initialized;
+}
+
+static void __kmp_init_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
+  __kmp_init_ticket_lock(lck);
+}
+
+static void __kmp_init_nested_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
+  __kmp_init_nested_ticket_lock(lck);
+}
+
+static int __kmp_is_queuing_lock_initialized(kmp_queuing_lock_t *lck) {
+  return lck == lck->lk.initialized;
+}
+
+static void __kmp_init_queuing_lock_with_checks(kmp_queuing_lock_t *lck) {
+  __kmp_init_queuing_lock(lck);
+}
+
+static void
+__kmp_init_nested_queuing_lock_with_checks(kmp_queuing_lock_t *lck) {
+  __kmp_init_nested_queuing_lock(lck);
+}
+
+#if KMP_USE_ADAPTIVE_LOCKS
+static void __kmp_init_adaptive_lock_with_checks(kmp_adaptive_lock_t *lck) {
+  __kmp_init_adaptive_lock(lck);
+}
+#endif
+
+static int __kmp_is_drdpa_lock_initialized(kmp_drdpa_lock_t *lck) {
+  return lck == lck->lk.initialized;
+}
+
+static void __kmp_init_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck) {
+  __kmp_init_drdpa_lock(lck);
+}
+
+static void __kmp_init_nested_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck) {
+  __kmp_init_nested_drdpa_lock(lck);
+}
+
 /* user locks
  * They are implemented as a table of function pointers which are set to the
  * lock functions of the appropriate kind, once that has been determined. */
 
 enum kmp_lock_kind __kmp_user_lock_kind = lk_default;
 
 size_t __kmp_base_user_lock_size = 0;
 size_t __kmp_user_lock_size = 0;

runtime/src/kmp_runtime.cpp

 void __kmp_task_info() {
 
   kmp_int32 gtid = __kmp_entry_gtid();
   kmp_int32 tid = __kmp_tid_from_gtid(gtid);
   kmp_info_t *this_thr = __kmp_threads[gtid];
   kmp_team_t *steam = this_thr->th.th_serial_team;
   kmp_team_t *team = this_thr->th.th_team;
 
-  __kmp_printf("__kmp_task_info: gtid=%d tid=%d t_thread=%p team=%p curtask=%p "
-               "ptask=%p\n",
-               gtid, tid, this_thr, team, this_thr->th.th_current_task,
-               team->t.t_implicit_task_taskdata[tid].td_parent);
+  __kmp_printf(
+      "__kmp_task_info: gtid=%d tid=%d t_thread=%p team=%p steam=%p curtask=%p "
+      gtid, tid, this_thr, team, steam, this_thr->th.th_current_task,
 }
 #endif // KMP_DEBUG
 
 /* TODO optimize with one big memclr, take out what isn't needed, split
    responsibility to workers as much as possible, and delay initialization of
    features as much as possible  */
 static void __kmp_initialize_info(kmp_info_t *this_thr, kmp_team_t *team,
                                   int tid, int gtid) {
if (value != NULL && strcmp(value, __kmp_registration_str) == 0) {
       char *flag_val_str = NULL;
       char const *file_name = NULL;
       __kmp_str_split(tail, '-', &flag_addr_str, &tail);
       __kmp_str_split(tail, '-', &flag_val_str, &tail);
       file_name = tail;
       if (tail != NULL) {
         long *flag_addr = 0;
         long flag_val = 0;
-        KMP_SSCANF(flag_addr_str, "%p", &flag_addr);
+        KMP_SSCANF(flag_addr_str, "%p", RCAST(void**, &flag_addr));
         KMP_SSCANF(flag_val_str, "%lx", &flag_val);
         if (flag_addr != 0 && flag_val != 0 && strcmp(file_name, "") != 0) {
           // First, check whether environment-encoded address is mapped into
           // addr space.
           // If so, dereference it to see if it still has the right value.
           if (__kmp_is_address_mapped(flag_addr) && *flag_addr == flag_val) {
             neighbor = 1;
           } else {
#define FAST_REDUCTION_TREE_METHOD_GENERATED ((reduce_data) && (reduce_func))
   team_size = __kmp_get_team_num_threads(global_tid);
   if (team_size == 1) {
 
     retval = empty_reduce_block;
 
   } else {
 
     int atomic_available = FAST_REDUCTION_ATOMIC_METHOD_GENERATED;
-    int tree_available = FAST_REDUCTION_TREE_METHOD_GENERATED;
 
 #if KMP_ARCH_X86_64 || KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64
 
 #if KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_NETBSD || KMP_OS_WINDOWS ||       \
     KMP_OS_DARWIN
 
     int teamsize_cutoff = 4;
 
 #if KMP_MIC_SUPPORTED
     if (__kmp_mic_type != non_mic) {
       teamsize_cutoff = 8;
     }
 #endif
+    int tree_available = FAST_REDUCTION_TREE_METHOD_GENERATED;
     if (tree_available) {
       if (team_size <= teamsize_cutoff) {
         if (atomic_available) {
           retval = atomic_reduce_block;
         }
       } else {
         retval = TREE_REDUCE_BLOCK_WITH_REDUCTION_BARRIER;
       }
#if KMP_OS_LINUX || KMP_OS_WINDOWS
     if (atomic_available) {
       if (num_vars <= 2) { // && ( team_size <= 8 ) due to false-sharing ???
         retval = atomic_reduce_block;
       }
     } // otherwise: use critical section
 
 #elif KMP_OS_DARWIN
 
+    int tree_available = FAST_REDUCTION_TREE_METHOD_GENERATED;
     if (atomic_available && (num_vars <= 3)) {
       retval = atomic_reduce_block;
     } else if (tree_available) {
       if ((reduce_size > (9 * sizeof(kmp_real64))) &&
           (reduce_size < (2000 * sizeof(kmp_real64)))) {
         retval = TREE_REDUCE_BLOCK_WITH_PLAIN_BARRIER;
       }
     } // otherwise: use critical section

runtime/src/kmp_sched.cpp

#endif
   th = __kmp_threads[gtid];
   nth = th->th.th_team_nproc;
   team = th->th.th_team;
 #if OMP_40_ENABLED
   KMP_DEBUG_ASSERT(th->th.th_teams_microtask); // we are in the teams construct
   nteams = th->th.th_teams_size.nteams;
 #endif
   team_id = team->t.t_master_tid;
-  KMP_DEBUG_ASSERT(nteams == team->t.t_parent->t.t_nproc);
+  KMP_DEBUG_ASSERT(nteams == (kmp_uint32)team->t.t_parent->t.t_nproc);
 
   // compute global trip count
   if (incr == 1) {
     trip_count = *pupper - *plower + 1;
   } else if (incr == -1) {
     trip_count = *plower - *pupper + 1;
   } else if (incr > 0) {
     // upper-lower can exceed the limit of signed type
#endif
   }
   th = __kmp_threads[gtid];
   team = th->th.th_team;
 #if OMP_40_ENABLED
   KMP_DEBUG_ASSERT(th->th.th_teams_microtask); // we are in the teams construct
   nteams = th->th.th_teams_size.nteams;
 #endif
   team_id = team->t.t_master_tid;
-  KMP_DEBUG_ASSERT(nteams == team->t.t_parent->t.t_nproc);
+  KMP_DEBUG_ASSERT(nteams == (kmp_uint32)team->t.t_parent->t.t_nproc);
 
   // compute trip count
   if (incr == 1) {
     trip_count = upper - lower + 1;
   } else if (incr == -1) {
     trip_count = lower - upper + 1;
   } else if (incr > 0) {
     // upper-lower can exceed the limit of signed type

runtime/src/kmp_settings.cpp

 
 static int __kmp_env_toPrint(char const *name, int flag);
 
 bool __kmp_env_format = 0; // 0 - old format; 1 - new format
 
 // -----------------------------------------------------------------------------
 // Helper string functions. Subject to move to kmp_str.
 
+#ifdef USE_LOAD_BALANCE
 static double __kmp_convert_to_double(char const *s) {
   double result;
 
   if (KMP_SSCANF(s, "%lf", &result) < 1) {
     result = 0.0;
   }
 
   return result;
 }
+#endif
 
 #ifdef KMP_DEBUG
 static unsigned int __kmp_readstr_with_sentinel(char *dest, char const *src,
                                                 size_t len, char sentinel) {
   unsigned int i;
   for (i = 0; i < len; i++) {
     if ((*src == '\0') || (*src == sentinel)) {
       break;
static int __kmp_match_str(char const *token, char const *buf,
   }
   if (*token) {
     return FALSE;
   }
   *end = buf;
   return TRUE;
 }
 
+#if KMP_OS_DARWIN
 static size_t __kmp_round4k(size_t size) {
   size_t _4k = 4 * 1024;
   if (size & (_4k - 1)) {
     size &= ~(_4k - 1);
     if (size <= KMP_SIZE_T_MAX - _4k) {
       size += _4k; // Round up if there is no overflow.
     }
   }
   return size;
 } // __kmp_round4k
+#endif
 
 /* Here, multipliers are like __kmp_convert_to_seconds, but floating-point
    values are allowed, and the return value is in milliseconds.  The default
    multiplier is milliseconds.  Returns INT_MAX only if the value specified
    matches "infinit*".  Returns -1 if specified string is invalid. */
 int __kmp_convert_to_milliseconds(char const *data) {
   int ret, nvalues, factor;
   char mult, extra;
static void __kmp_stg_print_int(kmp_str_buf_t *buffer, char const *name,
                                 int value) {
   if (__kmp_env_format) {
     KMP_STR_BUF_PRINT_INT;
   } else {
     __kmp_str_buf_print(buffer, "   %s=%d\n", name, value);
   }
 } // __kmp_stg_print_int
 
+#if USE_ITT_BUILD && USE_ITT_NOTIFY
 static void __kmp_stg_print_uint64(kmp_str_buf_t *buffer, char const *name,
                                    kmp_uint64 value) {
   if (__kmp_env_format) {
     KMP_STR_BUF_PRINT_UINT64;
   } else {
     __kmp_str_buf_print(buffer, "   %s=%" KMP_UINT64_SPEC "\n", name, value);
   }
 } // __kmp_stg_print_uint64
+#endif
 
 static void __kmp_stg_print_str(kmp_str_buf_t *buffer, char const *name,
                                 char const *value) {
   if (__kmp_env_format) {
     KMP_STR_BUF_PRINT_STR;
   } else {
     __kmp_str_buf_print(buffer, "   %s=%s\n", name, value);
   }
static void __kmp_parse_affinity_env(char const *name, char const *value,
   char *next = NULL; // end of token / start of next.
   const char *start; // start of current token (for err msgs)
   int count = 0; // Counter of parsed integer numbers.
   int number[2]; // Parsed numbers.
 
   // Guards.
   int type = 0;
   int proclist = 0;
-  int max_proclist = 0;
   int verbose = 0;
   int warnings = 0;
   int respect = 0;
   int gran = 0;
   int dups = 0;
 
   KMP_ASSERT(value != NULL);
 

 }
 
 static int __kmp_parse_place_list(const char *var, const char *env,
                                   char **place_list) {
   const char *scan = env;
   const char *next = scan;
 
   for (;;) {
-    int start, count, stride;
+    int count, stride;
 
     if (!__kmp_parse_place(var, &scan)) {
       return FALSE;
     }
 
     // valid follow sets are ',' ':' and EOL
     SKIP_WS(scan);
     if (*scan == '\0') {

runtime/src/kmp_stats.h

 
 // Where all you need is to time a block, this is enough.
 // (It avoids the need to have an explicit end, leaving the scope suffices.)
 class blockTimer : public explicitTimer {
   timer_e timerEnumValue;
 
 public:
   blockTimer(timeStat *s, timer_e newTimerEnumValue)
-      : timerEnumValue(newTimerEnumValue), explicitTimer(s) {
+      : explicitTimer(s), timerEnumValue(newTimerEnumValue) {
     start(timerEnumValue);
   }
   ~blockTimer() { stop(timerEnumValue); }
 };
 
 // Where you need to partition a threads clock ticks into separate states
 // e.g., a partitionedTimers class with two timers of EXECUTING_TASK, and
 // DOING_NOTHING would render these conditions:

runtime/src/kmp_stats.cpp

void kmp_stats_event_vector::deallocate() {
   events = NULL;
 }
 
 // This function is for qsort() which requires the compare function to return
 // either a negative number if event1 < event2, a positive number if event1 >
 // event2 or zero if event1 == event2. This sorts by start time (lowest to
 // highest).
 int compare_two_events(const void *event1, const void *event2) {
-  kmp_stats_event *ev1 = (kmp_stats_event *)event1;
-  kmp_stats_event *ev2 = (kmp_stats_event *)event2;
+  const kmp_stats_event *ev1 = RCAST(const kmp_stats_event *, event1);
+  const kmp_stats_event *ev2 = RCAST(const kmp_stats_event *, event2);
 
   if (ev1->getStart() < ev2->getStart())
     return -1;
   else if (ev1->getStart() > ev2->getStart())
     return 1;
   else
     return 0;
 }

runtime/src/kmp_stub.cpp

 #define kmp_set_defaults kmpc_set_defaults
 #define kmp_set_disp_num_buffers kmpc_set_disp_num_buffers
 #define kmp_malloc kmpc_malloc
 #define kmp_aligned_malloc kmpc_aligned_malloc
 #define kmp_calloc kmpc_calloc
 #define kmp_realloc kmpc_realloc
 #define kmp_free kmpc_free
 
+#if KMP_OS_WINDOWS
 static double frequency = 0.0;
+#endif
 
 // Helper functions.
 static size_t __kmps_init() {
   static int initialized = 0;
   static size_t dummy = 0;
   if (!initialized) {
     // TODO: Analyze KMP_VERSION environment variable, print
     // __kmp_version_copyright and __kmp_version_build_time.

runtime/src/kmp_tasking.cpp

static kmp_int32 __kmp_push_task(kmp_int32 gtid, kmp_task_t *task) {
 
   KA_TRACE(20,
            ("__kmp_push_task: T#%d trying to push task %p.\n", gtid, taskdata));
 
   if (taskdata->td_flags.tiedness == TASK_UNTIED) {
     // untied task needs to increment counter so that the task structure is not
     // freed prematurely
     kmp_int32 counter = 1 + KMP_ATOMIC_INC(&taskdata->td_untied_count);
+    KMP_DEBUG_USE_VAR(counter);
     KA_TRACE(
         20,
         ("__kmp_push_task: T#%d untied_count (%d) incremented for task %p\n",
          gtid, counter, taskdata));
   }
 
   // The first check avoids building task_team thread data if serialized
   if (taskdata->td_flags.task_serial) {
static void __kmpc_omp_task_begin_if0_template(ident_t *loc_ref, kmp_int32 gtid,
   KA_TRACE(10, ("__kmpc_omp_task_begin_if0(enter): T#%d loc=%p task=%p "
                 "current_task=%p\n",
                 gtid, loc_ref, taskdata, current_task));
 
   if (taskdata->td_flags.tiedness == TASK_UNTIED) {
     // untied task needs to increment counter so that the task structure is not
     // freed prematurely
     kmp_int32 counter = 1 + KMP_ATOMIC_INC(&taskdata->td_untied_count);
+    KMP_DEBUG_USE_VAR(counter);
     KA_TRACE(20, ("__kmpc_omp_task_begin_if0: T#%d untied_count (%d) "
                   "incremented for task %p\n",
                   gtid, counter, taskdata));
   }
 
   taskdata->td_flags.task_serial =
       1; // Execute this task immediately, not deferred.
   __kmp_task_start(gtid, task, current_task);

 //  __kmp_invoke_task: invoke the specified task
 //
 // gtid: global thread ID of caller
 // task: the task to invoke
 // current_task: the task to resume after task invokation
 static void __kmp_invoke_task(kmp_int32 gtid, kmp_task_t *task,
                               kmp_taskdata_t *current_task) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
-  kmp_uint64 cur_time;
 #if OMP_40_ENABLED
   int discard = 0 /* false */;
 #endif
   KA_TRACE(
       30, ("__kmp_invoke_task(enter): T#%d invoking task %p, current_task=%p\n",
            gtid, taskdata, current_task));
   KMP_DEBUG_ASSERT(task);
 #if OMP_45_ENABLED
KA_TRACE(30, ("__kmp_invoke_task(exit): T#%d completed bottom finish for "
                   "proxy task %p, resuming task %p\n",
                   gtid, taskdata, current_task));
 
     return;
   }
 #endif
 
 #if USE_ITT_BUILD && USE_ITT_NOTIFY
+  kmp_uint64 cur_time;
   if (__kmp_forkjoin_frames_mode == 3) {
     // Get the current time stamp to measure task execution time to correct
     // barrier imbalance time
     cur_time = __itt_get_timestamp();
   }
 #endif
 
 #if OMPT_SUPPORT
if (taskdata != NULL) {
     }
     int prev = target;
     for (i = i + 1; i < ntasks; ++i) {
       // shift remaining tasks in the deque left by 1
       target = (target + 1) & TASK_DEQUE_MASK(victim_td->td);
       victim_td->td.td_deque[prev] = victim_td->td.td_deque[target];
       prev = target;
     }
-    KMP_DEBUG_ASSERT(victim_td->td.td_deque_tail ==
-                     ((target + 1) & TASK_DEQUE_MASK(victim_td->td)));
+    KMP_DEBUG_ASSERT(
+        victim_td->td.td_deque_tail ==
+        (kmp_uint32)((target + 1) & TASK_DEQUE_MASK(victim_td->td)));
     victim_td->td.td_deque_tail = target; // tail -= 1 (wrapped))
   }
   if (*thread_finished) {
     // We need to un-mark this victim as a finished victim.  This must be done
     // before releasing the lock, or else other threads (starting with the
     // master victim) might be prematurely released from the barrier!!!
     kmp_int32 count;
 
#if KMP_DEBUG
   KMP_DEBUG_ASSERT(num_tasks > num_t_min);
   KA_TRACE(20, ("__kmp_taskloop_recur: T#%d, task %p: %lld tasks, grainsize"
                 " %lld, extras %lld, i=%lld,%lld(%d), dup %p\n",
                 gtid, taskdata, num_tasks, grainsize, extras, *lb, *ub, st,
                 task_dup));
 #endif
   p_task_dup_t ptask_dup = (p_task_dup_t)task_dup;
   kmp_uint64 lower = *lb;
-  kmp_uint64 upper = *ub;
   kmp_info_t *thread = __kmp_threads[gtid];
   //  kmp_taskdata_t *current_task = thread->th.th_current_task;
   kmp_task_t *next_task;
-  kmp_int32 lastpriv = 0;
   size_t lower_offset =
       (char *)lb - (char *)task; // remember offset of lb in the task structure
   size_t upper_offset =
       (char *)ub - (char *)task; // remember offset of ub in the task structure
 
   KMP_DEBUG_ASSERT(tc == num_tasks * grainsize + extras);
   KMP_DEBUG_ASSERT(num_tasks > extras);
   KMP_DEBUG_ASSERT(num_tasks > 0);

runtime/src/kmp_wait_release.h

 template <typename P> class kmp_flag_native {
   volatile P *loc;
   flag_type t;
 
 public:
   typedef P flag_t;
   kmp_flag_native(volatile P *p, flag_type ft) : loc(p), t(ft) {}
   volatile P *get() { return loc; }
+  void *get_void_p() { return RCAST(void *, CCAST(P *, loc)); }
   void set(volatile P *new_loc) { loc = new_loc; }
   flag_type get_type() { return t; }
   P load() { return *loc; }
   void store(P val) { *loc = val; }
 };
 
 /*!
  * Base class for wait/release atomic flag
  */
 template <typename P> class kmp_flag {
   std::atomic<P>
       *loc; /**< Pointer to the flag storage that is modified by another thread
              */
   flag_type t; /**< "Type" of the flag in loc */
 public:
   typedef P flag_t;
   kmp_flag(std::atomic<P> *p, flag_type ft) : loc(p), t(ft) {}
   /*!
    * @result the pointer to the actual flag
    */
   std::atomic<P> *get() { return loc; }
   /*!
+   * @result void* pointer to the actual flag
+   */
+  void *get_void_p() { return RCAST(void *, loc); }
+  /*!
    * @param new_loc in   set loc to point at new_loc
    */
   void set(std::atomic<P> *new_loc) { loc = new_loc; }
   /*!
    * @result the flag_type
    */
   flag_type get_type() { return t; }
   /*!
#endif
       this_thr->th.ompt_thread_info.state = omp_state_overhead;
     }
   }
 }
 #endif
 
 /* Spin wait loop that first does pause, then yield, then sleep. A thread that
    calls __kmp_wait_*  must make certain that another thread calls __kmp_release
-   to wake it back up to prevent deadlocks!  */
+   to wake it back up to prevent deadlocks!
+
+   NOTE: We may not belong to a team at this point.  */
 template <class C, int final_spin>
 static inline void
 __kmp_wait_template(kmp_info_t *this_thr,
                     C *flag USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
-  // NOTE: We may not belong to a team at this point.
+#if USE_ITT_BUILD && USE_ITT_NOTIFY
   volatile void *spin = flag->get();
+#endif
   kmp_uint32 spins;
-  kmp_uint32 hibernate;
   int th_gtid;
   int tasks_completed = FALSE;
   int oversubscribed;
 #if !KMP_USE_MONITOR
   kmp_uint64 poll_count;
   kmp_uint64 hibernate_goal;
+#else
+  kmp_uint32 hibernate;
 #endif
 
   KMP_FSYNC_SPIN_INIT(spin, NULL);
   if (flag->done_check()) {
     KMP_FSYNC_SPIN_ACQUIRED(CCAST(void *, spin));
     return;
   }
   th_gtid = this_thr->th.th_info.ds.ds_gtid;
/* Release any threads specified as waiting on the flag by releasing the flag
    calls __kmp_wait_template must call this function to wake up the potentially
    sleeping thread and prevent deadlocks!  */
 template <class C> static inline void __kmp_release_template(C *flag) {
 #ifdef KMP_DEBUG
   int gtid = TCR_4(__kmp_init_gtid) ? __kmp_get_gtid() : -1;
 #endif
   KF_TRACE(20, ("__kmp_release: T#%d releasing flag(%x)\n", gtid, flag->get()));
   KMP_DEBUG_ASSERT(flag->get());
-  KMP_FSYNC_RELEASING(flag->get());
+  KMP_FSYNC_RELEASING(flag->get_void_p());
 
   flag->internal_release();
 
   KF_TRACE(100, ("__kmp_release: T#%d set new spin=%d\n", gtid, flag->get(),
                  flag->load()));
 
   if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) {
     // Only need to check sleep stuff if infinite block time not set.

runtime/src/ompt-general.cpp

#else
   return -1;
 #endif
 }
 
 /*****************************************************************************
  * compatability
  ****************************************************************************/
 
+/*
+ * Currently unused function
 OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; }
+*/
 
 /*****************************************************************************
 * application-facing API
  ****************************************************************************/
 
 /*----------------------------------------------------------------------------
  | control
  ---------------------------------------------------------------------------*/

runtime/src/ompt-specific.h

 
 int __ompt_get_task_info_internal(int ancestor_level, int *type,
                                   ompt_data_t **task_data,
                                   omp_frame_t **task_frame,
                                   ompt_data_t **parallel_data, int *thread_num);
 
 ompt_data_t *__ompt_get_thread_data_internal();
 
+/*
+ * Unused currently
 static uint64_t __ompt_get_get_unique_id_internal();
+*/
 
 /*****************************************************************************
  * macros
  ****************************************************************************/
 
 #define OMPT_CUR_TASK_INFO(thr) (&(thr->th.th_current_task->ompt_task_info))
 #define OMPT_CUR_TASK_DATA(thr)                                                \
   (&(thr->th.th_current_task->ompt_task_info.task_data))

runtime/src/thirdparty/ittnotify/ittnotify_static.c

#define ITT_MUTEX_INIT_AND_LOCK(p) {                                 \
             }                                                        \
             else                                                     \
                 while (!p.mutex_initialized)                         \
                     __itt_thread_yield();                            \
         }                                                            \
         __itt_mutex_lock(&p.mutex);                                  \
 }
 
-const int _N_(err) = 0;
-
 typedef int (__itt_init_ittlib_t)(const char*, __itt_group_id);
 
 /* this define used to control initialization function name. */
 #ifndef __itt_init_ittlib_name
 ITT_EXTERN_C int _N_(init_ittlib)(const char*, __itt_group_id);
 static __itt_init_ittlib_t* __itt_init_ittlib_ptr = _N_(init_ittlib);
 #define __itt_init_ittlib_name __itt_init_ittlib_ptr
 #endif /* __itt_init_ittlib_name */
static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init))(const wchar_t* name)
     {
         h->nameW = name ? _wcsdup(name) : NULL;
     }
     __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 }
 
 static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setW),_init))(const wchar_t* name, int namelen)
 {
-    namelen = namelen;
+    (void)namelen;
     ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init))(name);
     return 0;
 }
 
 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init))(const char* name)
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),_init))(const char* name)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
else
         h->nameA = name ? __itt_fstrdup(name) : NULL;
     }
     __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 }
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setA),_init))(const char* name, int namelen)
 {
-    namelen = namelen;
+    (void)namelen;
     ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init))(name);
     return 0;
 }
 #else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_set),_init))(const char* name, int namelen)
 {
-    namelen = namelen;
+    (void)namelen;
     ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),_init))(name);
     return 0;
 }
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore),_init))(void)
 {
     TIDT tid = __itt_thread_id();