Handle implicit conversion warnings

[tlwilmar]

Summary

This patch partially prepares the runtime source code to be built with -Wconversion, which should trigger warnings if any implicit conversions can possibly change a value. For builds done with icc or gcc, all such warnings are handled in this patch. clang gives a much longer list of warnings, particularly for sign conversions, which the other compilers don't report. The -Wconversion flag is commented into cmake files, but I'm not going to turn it on. If someone thinks it is important, and wants to fix all the clang warnings, they are welcome to.

Types of changes made here involve either improving the consistency of types used so that no conversion is needed, or else performing careful explicit conversions, when we're sure a problem won't arise.

Patch is a combination of changes by Terry Wilmarth and Johnny Peyton.

[AndreyChurbanov]

LGTM

[protze.joachim]

openmp/runtime/src/kmp.h

69

Might this new include cause the build failure in https://bugs.llvm.org/show_bug.cgi?id=49339 ?

openmp/runtime/cmake/LibompHandleFlags.cmake

function(libomp_get_cxxflags cxxflags)
   libomp_append(flags_local -Wno-covered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
   libomp_append(flags_local -Wno-frame-address LIBOMP_HAVE_WNO_FRAME_ADDRESS_FLAG)
   libomp_append(flags_local -Wno-strict-aliasing LIBOMP_HAVE_WNO_STRICT_ALIASING_FLAG)
   libomp_append(flags_local -Wstringop-overflow=0 LIBOMP_HAVE_WSTRINGOP_OVERFLOW_FLAG)
   libomp_append(flags_local -Wno-stringop-truncation LIBOMP_HAVE_WNO_STRINGOP_TRUNCATION_FLAG)
   libomp_append(flags_local -Wno-switch LIBOMP_HAVE_WNO_SWITCH_FLAG)
   libomp_append(flags_local -Wno-uninitialized LIBOMP_HAVE_WNO_UNINITIALIZED_FLAG)
   libomp_append(flags_local -Wno-unused-but-set-variable LIBOMP_HAVE_WNO_UNUSED_BUT_SET_VARIABLE_FLAG)
+  # libomp_append(flags_local -Wconversion LIBOMP_HAVE_WCONVERSION_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)
   libomp_append(flags_local -mrtm LIBOMP_HAVE_MRTM_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)

openmp/runtime/cmake/config-ix.cmake

 check_cxx_compiler_flag(-Wno-covered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
 check_cxx_compiler_flag(-Wno-frame-address LIBOMP_HAVE_WNO_FRAME_ADDRESS_FLAG)
 check_cxx_compiler_flag(-Wno-strict-aliasing LIBOMP_HAVE_WNO_STRICT_ALIASING_FLAG)
 check_cxx_compiler_flag(-Wstringop-overflow=0 LIBOMP_HAVE_WSTRINGOP_OVERFLOW_FLAG)
 check_cxx_compiler_flag(-Wno-stringop-truncation LIBOMP_HAVE_WNO_STRINGOP_TRUNCATION_FLAG)
 check_cxx_compiler_flag(-Wno-switch LIBOMP_HAVE_WNO_SWITCH_FLAG)
 check_cxx_compiler_flag(-Wno-uninitialized LIBOMP_HAVE_WNO_UNINITIALIZED_FLAG)
 check_cxx_compiler_flag(-Wno-unused-but-set-variable LIBOMP_HAVE_WNO_UNUSED_BUT_SET_VARIABLE_FLAG)
+# check_cxx_compiler_flag(-Wconversion LIBOMP_HAVE_WCONVERSION_FLAG)
 check_cxx_compiler_flag(-msse2 LIBOMP_HAVE_MSSE2_FLAG)
 check_cxx_compiler_flag(-ftls-model=initial-exec LIBOMP_HAVE_FTLS_MODEL_FLAG)
 libomp_check_architecture_flag(-mmic LIBOMP_HAVE_MMIC_FLAG)
 libomp_check_architecture_flag(-m32 LIBOMP_HAVE_M32_FLAG)
 if(WIN32)
   if(MSVC)
     # Check Windows MSVC style flags.
     check_cxx_compiler_flag(/EHsc LIBOMP_HAVE_EHSC_FLAG)

openmp/runtime/src/kmp.h

 #endif
 
 #include <signal.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <limits>
+#include <type_traits>
 /* include <ctype.h> don't use; problems with /MD on Windows* OS NT due to bad
    Microsoft library. Some macros provided below to replace these functions  */
 #ifndef __ABSOFT_WIN
 #include <sys/types.h>
 #endif
 #include <limits.h>
 #include <time.h>
 
std::atomic<kmp_int32>
       td_incomplete_child_tasks; /* Child tasks not yet complete */
   kmp_taskgroup_t
       *td_taskgroup; // Each task keeps pointer to its current taskgroup
   kmp_dephash_t
       *td_dephash; // Dependencies for children tasks are tracked from here
   kmp_depnode_t
       *td_depnode; // Pointer to graph node if this task has dependencies
   kmp_task_team_t *td_task_team;
-  kmp_int32 td_size_alloc; // The size of task structure, including shareds etc.
+  size_t td_size_alloc; // Size of task structure, including shareds etc.
 #if defined(KMP_GOMP_COMPAT)
   // 4 or 8 byte integers for the loop bounds in GOMP_taskloop
   kmp_int32 td_size_loop_bounds;
 #endif
   kmp_taskdata_t *td_last_tied; // keep tied task for task scheduling constraint
 #if defined(KMP_GOMP_COMPAT)
   // GOMP sends in a copy function for copy constructors
   void (*td_copy_func)(void *, void *);

 extern void __kmp_teams_master(int gtid);
 extern int __kmp_aux_get_team_num();
 extern int __kmp_aux_get_num_teams();
 extern void __kmp_save_internal_controls(kmp_info_t *thread);
 extern void __kmp_user_set_library(enum library_type arg);
 extern void __kmp_aux_set_library(enum library_type arg);
 extern void __kmp_aux_set_stacksize(size_t arg);
 extern void __kmp_aux_set_blocktime(int arg, kmp_info_t *thread, int tid);
-extern void __kmp_aux_set_defaults(char const *str, int len);
+extern void __kmp_aux_set_defaults(char const *str, size_t len);
 
 /* Functions called from __kmp_aux_env_initialize() in kmp_settings.cpp */
 void kmpc_set_blocktime(int arg);
 void ompc_set_nested(int flag);
 void ompc_set_dynamic(int flag);
 void ompc_set_num_threads(int arg);
 
 extern void __kmp_push_current_task_to_thread(kmp_info_t *this_thr,

 int __kmp_execute_tasks_oncore(kmp_info_t *thread, kmp_int32 gtid,
                                kmp_flag_oncore *flag, int final_spin,
                                int *thread_finished,
 #if USE_ITT_BUILD
                                void *itt_sync_obj,
 #endif /* USE_ITT_BUILD */
                                kmp_int32 is_constrained);
 
+template <typename SourceType, typename TargetType,
+          bool isSourceSmaller = (sizeof(SourceType) < sizeof(TargetType)),
+          bool isSourceEqual = (sizeof(SourceType) == sizeof(TargetType)),
+          bool isSourceSigned = std::is_signed<SourceType>::value,
+          bool isTargetSigned = std::is_signed<TargetType>::value>
+struct kmp_convert {};
+
+// Both types are signed; Source smaller
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, true, false, true, true> {
+  static TargetType to(SourceType src) { return (TargetType)src; }
+};
+// Source equal
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, false, true, true, true> {
+  static TargetType to(SourceType src) { return src; }
+};
+// Source bigger
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, false, false, true, true> {
+  static TargetType to(SourceType src) {
+    KMP_ASSERT(src <= static_cast<SourceType>(
+                          (std::numeric_limits<TargetType>::max)()));
+    KMP_ASSERT(src >= static_cast<SourceType>(
+                          (std::numeric_limits<TargetType>::min)()));
+    return (TargetType)src;
+  }
+};
+
+// Source signed, Target unsigned
+// Source smaller
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, true, false, true, false> {
+  static TargetType to(SourceType src) {
+    KMP_ASSERT(src >= 0);
+    return (TargetType)src;
+  }
+};
+// Source equal
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, false, true, true, false> {
+  static TargetType to(SourceType src) {
+    KMP_ASSERT(src >= 0);
+    return (TargetType)src;
+  }
+};
+// Source bigger
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, false, false, true, false> {
+  static TargetType to(SourceType src) {
+    KMP_ASSERT(src >= 0);
+    KMP_ASSERT(src <= static_cast<SourceType>(
+                          (std::numeric_limits<TargetType>::max)()));
+    return (TargetType)src;
+  }
+};
+
+// Source unsigned, Target signed
+// Source smaller
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, true, false, false, true> {
+  static TargetType to(SourceType src) { return (TargetType)src; }
+};
+// Source equal
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, false, true, false, true> {
+  static TargetType to(SourceType src) {
+    KMP_ASSERT(src <= static_cast<SourceType>(
+                          (std::numeric_limits<TargetType>::max)()));
+    return (TargetType)src;
+  }
+};
+// Source bigger
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, false, false, false, true> {
+  static TargetType to(SourceType src) {
+    KMP_ASSERT(src <= static_cast<SourceType>(
+                          (std::numeric_limits<TargetType>::max)()));
+    return (TargetType)src;
+  }
+};
+
+// Source unsigned, Target unsigned
+// Source smaller
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, true, false, false, false> {
+  static TargetType to(SourceType src) { return (TargetType)src; }
+};
+// Source equal
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, false, true, false, false> {
+  static TargetType to(SourceType src) { return src; }
+};
+// Source bigger
+template <typename SourceType, typename TargetType>
+struct kmp_convert<SourceType, TargetType, false, false, false, false> {
+  static TargetType to(SourceType src) {
+    KMP_ASSERT(src <= static_cast<SourceType>(
+                          (std::numeric_limits<TargetType>::max)()));
+    return (TargetType)src;
+  }
+};
+
+template <typename T1, typename T2>
+static inline void __kmp_type_convert(T1 src, T2 *dest) {
+  *dest = kmp_convert<T1, T2>::to(src);
+}
+
 #endif /* KMP_H */

openmp/runtime/src/kmp_affinity.h

public:
     int begin() const override { return hwloc_bitmap_first(mask); }
     int end() const override { return -1; }
     int next(int previous) const override {
       return hwloc_bitmap_next(mask, previous);
     }
     int get_system_affinity(bool abort_on_error) override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal get affinity operation when not capable");
-      int retval =
+      long retval =
           hwloc_get_cpubind(__kmp_hwloc_topology, mask, HWLOC_CPUBIND_THREAD);
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
         __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
     int set_system_affinity(bool abort_on_error) const override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal get affinity operation when not capable");
-      int retval =
+      long retval =
           hwloc_set_cpubind(__kmp_hwloc_topology, mask, HWLOC_CPUBIND_THREAD);
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
         __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }

 #error Unknown or unsupported architecture
 #endif /* KMP_ARCH_* */
 #elif KMP_OS_FREEBSD
 #include <pthread.h>
 #include <pthread_np.h>
 #endif
 class KMPNativeAffinity : public KMPAffinity {
   class Mask : public KMPAffinity::Mask {
-    typedef unsigned char mask_t;
-    static const int BITS_PER_MASK_T = sizeof(mask_t) * CHAR_BIT;
+    typedef unsigned long mask_t;
+    typedef decltype(__kmp_affin_mask_size) mask_size_type;
+    static const unsigned int BITS_PER_MASK_T = sizeof(mask_t) * CHAR_BIT;
+    static const mask_t ONE = 1;
+    mask_size_type get_num_mask_types() const {
+      return __kmp_affin_mask_size / sizeof(mask_t);
+    }
 
   public:
     mask_t *mask;
     Mask() { mask = (mask_t *)__kmp_allocate(__kmp_affin_mask_size); }
     ~Mask() {
       if (mask)
         __kmp_free(mask);
     }
     void set(int i) override {
-      mask[i / BITS_PER_MASK_T] |= ((mask_t)1 << (i % BITS_PER_MASK_T));
+      mask[i / BITS_PER_MASK_T] |= (ONE << (i % BITS_PER_MASK_T));
     }
     bool is_set(int i) const override {
-      return (mask[i / BITS_PER_MASK_T] & ((mask_t)1 << (i % BITS_PER_MASK_T)));
+      return (mask[i / BITS_PER_MASK_T] & (ONE << (i % BITS_PER_MASK_T)));
     }
     void clear(int i) override {
-      mask[i / BITS_PER_MASK_T] &= ~((mask_t)1 << (i % BITS_PER_MASK_T));
+      mask[i / BITS_PER_MASK_T] &= ~(ONE << (i % BITS_PER_MASK_T));
     }
     void zero() override {
-      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
-        mask[i] = 0;
+      mask_size_type e = get_num_mask_types();
+      for (mask_size_type i = 0; i < e; ++i)
+        mask[i] = (mask_t)0;
     }
     void copy(const KMPAffinity::Mask *src) override {
       const Mask *convert = static_cast<const Mask *>(src);
-      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+      mask_size_type e = get_num_mask_types();
+      for (mask_size_type i = 0; i < e; ++i)
         mask[i] = convert->mask[i];
     }
     void bitwise_and(const KMPAffinity::Mask *rhs) override {
       const Mask *convert = static_cast<const Mask *>(rhs);
-      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+      mask_size_type e = get_num_mask_types();
+      for (mask_size_type i = 0; i < e; ++i)
         mask[i] &= convert->mask[i];
     }
     void bitwise_or(const KMPAffinity::Mask *rhs) override {
       const Mask *convert = static_cast<const Mask *>(rhs);
-      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+      mask_size_type e = get_num_mask_types();
+      for (mask_size_type i = 0; i < e; ++i)
         mask[i] |= convert->mask[i];
     }
     void bitwise_not() override {
-      for (size_t i = 0; i < __kmp_affin_mask_size; ++i)
+      mask_size_type e = get_num_mask_types();
+      for (mask_size_type i = 0; i < e; ++i)
         mask[i] = ~(mask[i]);
     }
     int begin() const override {
       int retval = 0;
       while (retval < end() && !is_set(retval))
         ++retval;
       return retval;
     }
-    int end() const override { return __kmp_affin_mask_size * BITS_PER_MASK_T; }
+    int end() const override {
+      int e;
+      __kmp_type_convert(get_num_mask_types() * BITS_PER_MASK_T, &e);
+      return e;
+    }
     int next(int previous) const override {
       int retval = previous + 1;
       while (retval < end() && !is_set(retval))
         ++retval;
       return retval;
     }
     int get_system_affinity(bool abort_on_error) override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal get affinity operation when not capable");
 #if KMP_OS_LINUX
-      int retval =
+      long retval =
           syscall(__NR_sched_getaffinity, 0, __kmp_affin_mask_size, mask);
 #elif KMP_OS_FREEBSD
       int r =
           pthread_getaffinity_np(pthread_self(), __kmp_affin_mask_size, reinterpret_cast<cpuset_t *>(mask));
       int retval = (r == 0 ? 0 : -1);
 #endif
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
         __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
     int set_system_affinity(bool abort_on_error) const override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal get affinity operation when not capable");
 #if KMP_OS_LINUX
-      int retval =
+      long retval =
           syscall(__NR_sched_setaffinity, 0, __kmp_affin_mask_size, mask);
 #elif KMP_OS_FREEBSD
       int r =
           pthread_setaffinity_np(pthread_self(), __kmp_affin_mask_size, reinterpret_cast<cpuset_t *>(mask));
       int retval = (r == 0 ? 0 : -1);
 #endif
       if (retval >= 0) {
         return 0;
if (nproc > old_sz) { // Not enough space, need to expand hierarchy
       kmp_uint32 *old_numPerLevel = numPerLevel;
       kmp_uint32 *old_skipPerLevel = skipPerLevel;
       numPerLevel = skipPerLevel = NULL;
       numPerLevel =
           (kmp_uint32 *)__kmp_allocate(maxLevels * 2 * sizeof(kmp_uint32));
       skipPerLevel = &(numPerLevel[maxLevels]);
 
       // Copy old elements from old arrays
-      for (kmp_uint32 i = 0; i < old_maxLevels;
-           ++i) { // init numPerLevel[*] to 1 item per level
+      for (kmp_uint32 i = 0; i < old_maxLevels; ++i) {
+        // init numPerLevel[*] to 1 item per level
         numPerLevel[i] = old_numPerLevel[i];
         skipPerLevel[i] = old_skipPerLevel[i];
       }
 
       // Init new elements in arrays to 1
-      for (kmp_uint32 i = old_maxLevels; i < maxLevels;
-           ++i) { // init numPerLevel[*] to 1 item per level
+      for (kmp_uint32 i = old_maxLevels; i < maxLevels; ++i) {
+        // init numPerLevel[*] to 1 item per level
         numPerLevel[i] = 1;
         skipPerLevel[i] = 1;
       }
 
       // Free old arrays
       __kmp_free(old_numPerLevel);
     }
 

openmp/runtime/src/kmp_affinity.cpp

void __kmp_get_hierarchy(kmp_uint32 nproc, kmp_bstate_t *thr_bar) {
   // Adjust the hierarchy in case num threads exceeds original
   if (nproc > machine_hierarchy.base_num_threads)
     machine_hierarchy.resize(nproc);
 
   depth = machine_hierarchy.depth;
   KMP_DEBUG_ASSERT(depth > 0);
 
   thr_bar->depth = depth;
-  thr_bar->base_leaf_kids = (kmp_uint8)machine_hierarchy.numPerLevel[0] - 1;
+  __kmp_type_convert(machine_hierarchy.numPerLevel[0] - 1,
+                     &(thr_bar->base_leaf_kids));
   thr_bar->skip_per_level = machine_hierarchy.skipPerLevel;
 }
 
 #if KMP_AFFINITY_SUPPORTED
 
 bool KMPAffinity::picked_api = false;
 
 void *KMPAffinity::Mask::operator new(size_t n) { return __kmp_allocate(n); }
while (1) {
     if (!first_range) {
       KMP_SNPRINTF(scan, end - scan + 1, "%s", ",");
       KMP_ADVANCE_SCAN(scan);
     } else {
       first_range = false;
     }
     // Range with three or more contiguous bits in the affinity mask
     if (previous - start > 1) {
-      KMP_SNPRINTF(scan, end - scan + 1, "%d-%d", static_cast<int>(start),
-                   static_cast<int>(previous));
+      KMP_SNPRINTF(scan, end - scan + 1, "%u-%u", start, previous);
     } else {
       // Range with one or two contiguous bits in the affinity mask
-      KMP_SNPRINTF(scan, end - scan + 1, "%d", static_cast<int>(start));
+      KMP_SNPRINTF(scan, end - scan + 1, "%u", start);
       KMP_ADVANCE_SCAN(scan);
       if (previous - start > 0) {
-        KMP_SNPRINTF(scan, end - scan + 1, ",%d", static_cast<int>(previous));
+        KMP_SNPRINTF(scan, end - scan + 1, ",%u", previous);
       }
     }
     KMP_ADVANCE_SCAN(scan);
     // Start over with new start point
     start = finish;
     if (start == mask->end())
       break;
     // Check for overflow
while (1) {
     // of the ranges do need a comma beforehand
     if (!first_range) {
       __kmp_str_buf_print(buf, "%s", ",");
     } else {
       first_range = false;
     }
     // Range with three or more contiguous bits in the affinity mask
     if (previous - start > 1) {
-      __kmp_str_buf_print(buf, "%d-%d", static_cast<int>(start),
-                          static_cast<int>(previous));
+      __kmp_str_buf_print(buf, "%u-%u", start, previous);
     } else {
       // Range with one or two contiguous bits in the affinity mask
-      __kmp_str_buf_print(buf, "%d", static_cast<int>(start));
+      __kmp_str_buf_print(buf, "%u", start);
       if (previous - start > 0) {
-        __kmp_str_buf_print(buf, ",%d", static_cast<int>(previous));
+        __kmp_str_buf_print(buf, ",%u", previous);
       }
     }
     // Start over with new start point
     start = finish;
     if (start == mask->end())
       break;
   }
   return buf;

openmp/runtime/src/kmp_alloc.cpp

omp_allocator_handle_t __kmpc_init_allocator(int gtid, omp_memspace_handle_t ms,
   al->memspace = ms; // not used currently
   for (i = 0; i < ntraits; ++i) {
     switch (traits[i].key) {
     case omp_atk_threadmodel:
     case omp_atk_access:
     case omp_atk_pinned:
       break;
     case omp_atk_alignment:
-      al->alignment = traits[i].value;
+      __kmp_type_convert(traits[i].value, &(al->alignment));
       KMP_ASSERT(IS_POWER_OF_TWO(al->alignment));
       break;
     case omp_atk_pool_size:
       al->pool_size = traits[i].value;
       break;
     case omp_atk_fallback:
       al->fb = (omp_alloctrait_value_t)traits[i].value;
       KMP_DEBUG_ASSERT(

 // AC: How to choose the limit? Just get 16 for now...
 #define KMP_FREE_LIST_LIMIT 16
 
 // Always use 128 bytes for determining buckets for caching memory blocks
 #define DCACHE_LINE 128
 
 void *___kmp_fast_allocate(kmp_info_t *this_thr, size_t size KMP_SRC_LOC_DECL) {
   void *ptr;
-  int num_lines;
-  int idx;
+  size_t num_lines, idx;
   int index;
   void *alloc_ptr;
   size_t alloc_size;
   kmp_mem_descr_t *descr;
 
   KE_TRACE(25, ("-> __kmp_fast_allocate( T#%d, %d ) called from %s:%d\n",
                 __kmp_gtid_from_thread(this_thr), (int)size KMP_SRC_LOC_PARM));
 

openmp/runtime/src/kmp_atomic.cpp

#define OP_CRITICAL(OP, LCK_ID)                                                \
   __kmp_acquire_atomic_lock(&ATOMIC_LOCK##LCK_ID, gtid);                       \
                                                                                \
   (*lhs) OP(rhs);                                                              \
                                                                                \
   __kmp_release_atomic_lock(&ATOMIC_LOCK##LCK_ID, gtid);
 
 #define OP_UPDATE_CRITICAL(TYPE, OP, LCK_ID)                                   \
   __kmp_acquire_atomic_lock(&ATOMIC_LOCK##LCK_ID, gtid);                       \
-  (*lhs) = (TYPE)((*lhs)OP(rhs));                                              \
+  (*lhs) = (TYPE)((*lhs)OP((TYPE)rhs));                                        \
   __kmp_release_atomic_lock(&ATOMIC_LOCK##LCK_ID, gtid);
 
 // ------------------------------------------------------------------------
 // For GNU compatibility, we may need to use a critical section,
 // even though it is not required by the ISA.
 //
 // On IA-32 architecture, all atomic operations except for fixed 4 byte add,
 // sub, and bitwise logical ops, and 1 & 2 byte logical ops use a common

 // Operation on *lhs, rhs using "compare_and_store" routine
 //     TYPE    - operands' type
 //     BITS    - size in bits, used to distinguish low level calls
 //     OP      - operator
 #define OP_CMPXCHG(TYPE, BITS, OP)                                             \
   {                                                                            \
     TYPE old_value, new_value;                                                 \
     old_value = *(TYPE volatile *)lhs;                                         \
-    new_value = (TYPE)(old_value OP rhs);                                      \
+    new_value = (TYPE)(old_value OP((TYPE)rhs));                               \
     while (!KMP_COMPARE_AND_STORE_ACQ##BITS(                                   \
         (kmp_int##BITS *)lhs, *VOLATILE_CAST(kmp_int##BITS *) & old_value,     \
         *VOLATILE_CAST(kmp_int##BITS *) & new_value)) {                        \
       KMP_DO_PAUSE;                                                            \
                                                                                \
       old_value = *(TYPE volatile *)lhs;                                       \
-      new_value = (TYPE)(old_value OP rhs);                                    \
+      new_value = (TYPE)(old_value OP((TYPE)rhs));                             \
     }                                                                          \
   }
 
 #if USE_CMPXCHG_FIX
 // 2007-06-25:
 // workaround for C78287 (complex(kind=4) data type). lin_32, lin_32e, win_32
 // and win_32e are affected (I verified the asm). Compiler ignores the volatile
 // qualifier of the temp_val in the OP_CMPXCHG macro. This is a problem of the

openmp/runtime/src/kmp_barrier.cpp

if (!KMP_MASTER_TID(
           // thread is not a subtree root at next level, so this is max
           thr_bar->parent_tid = tid - rem;
           thr_bar->my_level = d;
           break;
         }
         ++d;
       }
     }
-    thr_bar->offset = 7 - (tid - thr_bar->parent_tid - 1);
+    __kmp_type_convert(7 - (tid - thr_bar->parent_tid - 1), &(thr_bar->offset));
     thr_bar->old_tid = tid;
     thr_bar->wait_flag = KMP_BARRIER_NOT_WAITING;
     thr_bar->team = team;
     thr_bar->parent_bar =
         &team->t.t_threads[thr_bar->parent_tid]->th.th_bar[bt].bb;
   }
   if (uninitialized || team_changed || tid_changed) {
     thr_bar->team = team;
     thr_bar->parent_bar =
         &team->t.t_threads[thr_bar->parent_tid]->th.th_bar[bt].bb;
     retval = true;
   }
   if (uninitialized || team_sz_changed || tid_changed) {
     thr_bar->nproc = nproc;
     thr_bar->leaf_kids = thr_bar->base_leaf_kids;
     if (thr_bar->my_level == 0)
       thr_bar->leaf_kids = 0;
     if (thr_bar->leaf_kids && (kmp_uint32)tid + thr_bar->leaf_kids + 1 > nproc)
-      thr_bar->leaf_kids = nproc - tid - 1;
+      __kmp_type_convert(nproc - tid - 1, &(thr_bar->leaf_kids));
     thr_bar->leaf_state = 0;
     for (int i = 0; i < thr_bar->leaf_kids; ++i)
       ((char *)&(thr_bar->leaf_state))[7 - i] = 1;
   }
   return retval;
 }
 
 static void __kmp_hierarchical_barrier_gather(

openmp/runtime/src/kmp_csupport.cpp

 void ompc_set_dynamic(int flag) {
   kmp_info_t *thread;
 
   /* For the thread-private implementation of the internal controls */
   thread = __kmp_entry_thread();
 
   __kmp_save_internal_controls(thread);
 
-  set__dynamic(thread, flag ? TRUE : FALSE);
+  set__dynamic(thread, flag ? true : false);
 }
 
 void ompc_set_nested(int flag) {
   kmp_info_t *thread;
 
   /* For the thread-private internal controls implementation */
   thread = __kmp_entry_thread();
 

 
 static __forceinline void
 __kmp_restore_swapped_teams(kmp_info_t *th, kmp_team_t *team, int task_state) {
   // Restore thread structure swapped in __kmp_swap_teams_for_teams_reduction.
   th->th.th_info.ds.ds_tid = 0;
   th->th.th_team = team;
   th->th.th_team_nproc = team->t.t_nproc;
   th->th.th_task_team = team->t.t_task_team[task_state];
-  th->th.th_task_state = task_state;
+  __kmp_type_convert(task_state, &(th->th.th_task_state));
 }
 
 /* 2.a.i. Reduce Block without a terminating barrier */
 /*!
 @ingroup SYNCHRONIZATION
 @param loc source location information
 @param global_tid global thread number
 @param num_vars number of items (variables) to be reduced
#if KMP_32_BIT_ARCH
   flags = (kmp_uint32 *)KMP_COMPARE_AND_STORE_RET32(
       (volatile kmp_int32 *)&sh_buf->doacross_flags, NULL, 1);
 #else
   flags = (kmp_uint32 *)KMP_COMPARE_AND_STORE_RET64(
       (volatile kmp_int64 *)&sh_buf->doacross_flags, NULL, 1LL);
 #endif
   if (flags == NULL) {
     // we are the first thread, allocate the array of flags
-    size_t size = trace_count / 8 + 8; // in bytes, use single bit per iteration
+    size_t size =
+        (size_t)trace_count / 8 + 8; // in bytes, use single bit per iteration
     flags = (kmp_uint32 *)__kmp_thread_calloc(th, size, 1);
     KMP_MB();
     sh_buf->doacross_flags = flags;
   } else if (flags == (kmp_uint32 *)1) {
 #if KMP_32_BIT_ARCH
     // initialization is still in progress, need to wait
     while (*(volatile kmp_int32 *)&sh_buf->doacross_flags == 1)
 #else
     while (*(volatile kmp_int64 *)&sh_buf->doacross_flags == 1LL)
 #endif
       KMP_YIELD(TRUE);
     KMP_MB();
   } else {
     KMP_MB();
   }
   KMP_DEBUG_ASSERT(sh_buf->doacross_flags > (kmp_uint32 *)1); // check ptr value
   pr_buf->th_doacross_flags =
       sh_buf->doacross_flags; // save private copy in order to not
   // touch shared buffer on each iteration
   KA_TRACE(20, ("__kmpc_doacross_init() exit: T#%d\n", gtid));
 }
 
 void __kmpc_doacross_wait(ident_t *loc, int gtid, const kmp_int64 *vec) {
   __kmp_assert_valid_gtid(gtid);
-  kmp_int32 shft, num_dims, i;
+  kmp_int64 shft;
+  size_t num_dims, i;
   kmp_uint32 flag;
   kmp_int64 iter_number; // iteration number of "collapsed" loop nest
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
   kmp_disp_t *pr_buf;
   kmp_int64 lo, up, st;
 
   KA_TRACE(20, ("__kmpc_doacross_wait() enter: called T#%d\n", gtid));
   if (team->t.t_serialized) {
     KA_TRACE(20, ("__kmpc_doacross_wait() exit: serialized team\n"));
     return; // no dependencies if team is serialized
   }
 
   // calculate sequential iteration number and check out-of-bounds condition
   pr_buf = th->th.th_dispatch;
   KMP_DEBUG_ASSERT(pr_buf->th_doacross_info != NULL);
-  num_dims = pr_buf->th_doacross_info[0];
+  num_dims = (size_t)pr_buf->th_doacross_info[0];
   lo = pr_buf->th_doacross_info[2];
   up = pr_buf->th_doacross_info[3];
   st = pr_buf->th_doacross_info[4];
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_dependence_t deps[num_dims];
 #endif
   if (st == 1) { // most common case
     if (vec[0] < lo || vec[0] > up) {
if (st == 1) { // most common case
     iter_number = (kmp_uint64)(lo - vec[0]) / (-st);
   }
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   deps[0].variable.value = iter_number;
   deps[0].dependence_type = ompt_dependence_type_sink;
 #endif
   for (i = 1; i < num_dims; ++i) {
     kmp_int64 iter, ln;
-    kmp_int32 j = i * 4;
+    size_t j = i * 4;
     ln = pr_buf->th_doacross_info[j + 1];
     lo = pr_buf->th_doacross_info[j + 2];
     up = pr_buf->th_doacross_info[j + 3];
     st = pr_buf->th_doacross_info[j + 4];
     if (st == 1) {
       if (vec[i] < lo || vec[i] > up) {
         KA_TRACE(20, ("__kmpc_doacross_wait() exit: T#%d iter %lld is out of "
                       "bounds [%lld,%lld]\n",
#endif
   flag = 1 << shft;
   while ((flag & pr_buf->th_doacross_flags[iter_number]) == 0) {
     KMP_YIELD(TRUE);
   }
   KMP_MB();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_dependences) {
     ompt_callbacks.ompt_callback(ompt_callback_dependences)(
-        &(OMPT_CUR_TASK_INFO(th)->task_data), deps, num_dims);
+        &(OMPT_CUR_TASK_INFO(th)->task_data), deps, (kmp_uint32)num_dims);
   }
 #endif
   KA_TRACE(20,
            ("__kmpc_doacross_wait() exit: T#%d wait for iter %lld completed\n",
             gtid, (iter_number << 5) + shft));
 }
 
 void __kmpc_doacross_post(ident_t *loc, int gtid, const kmp_int64 *vec) {
   __kmp_assert_valid_gtid(gtid);
-  kmp_int32 shft, num_dims, i;
+  kmp_int64 shft;
+  size_t num_dims, i;
   kmp_uint32 flag;
   kmp_int64 iter_number; // iteration number of "collapsed" loop nest
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
   kmp_disp_t *pr_buf;
   kmp_int64 lo, st;
 
   KA_TRACE(20, ("__kmpc_doacross_post() enter: called T#%d\n", gtid));
   if (team->t.t_serialized) {
     KA_TRACE(20, ("__kmpc_doacross_post() exit: serialized team\n"));
     return; // no dependencies if team is serialized
   }
 
   // calculate sequential iteration number (same as in "wait" but no
   // out-of-bounds checks)
   pr_buf = th->th.th_dispatch;
   KMP_DEBUG_ASSERT(pr_buf->th_doacross_info != NULL);
-  num_dims = pr_buf->th_doacross_info[0];
+  num_dims = (size_t)pr_buf->th_doacross_info[0];
   lo = pr_buf->th_doacross_info[2];
   st = pr_buf->th_doacross_info[4];
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_dependence_t deps[num_dims];
 #endif
   if (st == 1) { // most common case
     iter_number = vec[0] - lo;
   } else if (st > 0) {
     iter_number = (kmp_uint64)(vec[0] - lo) / st;
   } else { // negative increment
     iter_number = (kmp_uint64)(lo - vec[0]) / (-st);
   }
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   deps[0].variable.value = iter_number;
   deps[0].dependence_type = ompt_dependence_type_source;
 #endif
   for (i = 1; i < num_dims; ++i) {
     kmp_int64 iter, ln;
-    kmp_int32 j = i * 4;
+    size_t j = i * 4;
     ln = pr_buf->th_doacross_info[j + 1];
     lo = pr_buf->th_doacross_info[j + 2];
     st = pr_buf->th_doacross_info[j + 4];
     if (st == 1) {
       iter = vec[i] - lo;
     } else if (st > 0) {
       iter = (kmp_uint64)(vec[i] - lo) / st;
     } else { // st < 0
       iter = (kmp_uint64)(lo - vec[i]) / (-st);
     }
     iter_number = iter + ln * iter_number;
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     deps[i].variable.value = iter;
     deps[i].dependence_type = ompt_dependence_type_source;
 #endif
   }
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_dependences) {
     ompt_callbacks.ompt_callback(ompt_callback_dependences)(
-        &(OMPT_CUR_TASK_INFO(th)->task_data), deps, num_dims);
+        &(OMPT_CUR_TASK_INFO(th)->task_data), deps, (kmp_uint32)num_dims);
   }
 #endif
   shft = iter_number % 32; // use 32-bit granularity
   iter_number >>= 5; // divided by 32
   flag = 1 << shft;
   KMP_MB();
   if ((flag & pr_buf->th_doacross_flags[iter_number]) == 0)
     KMP_TEST_THEN_OR32(&pr_buf->th_doacross_flags[iter_number], flag);
   KA_TRACE(20, ("__kmpc_doacross_post() exit: T#%d iter %lld posted\n", gtid,
                 (iter_number << 5) + shft));
 }
 
 void __kmpc_doacross_fini(ident_t *loc, int gtid) {
   __kmp_assert_valid_gtid(gtid);
   kmp_int32 num_done;
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
   kmp_disp_t *pr_buf = th->th.th_dispatch;
 
   KA_TRACE(20, ("__kmpc_doacross_fini() enter: called T#%d\n", gtid));
   if (team->t.t_serialized) {
     KA_TRACE(20, ("__kmpc_doacross_fini() exit: serialized team %p\n", team));
     return; // nothing to do
   }
-  num_done = KMP_TEST_THEN_INC32((kmp_int32 *)pr_buf->th_doacross_info[1]) + 1;
+  num_done =
+      KMP_TEST_THEN_INC32((kmp_uintptr_t)(pr_buf->th_doacross_info[1])) + 1;
   if (num_done == th->th.th_team_nproc) {
     // we are the last thread, need to free shared resources
     int idx = pr_buf->th_doacross_buf_idx - 1;
     dispatch_shared_info_t *sh_buf =
         &team->t.t_disp_buffer[idx % __kmp_dispatch_num_buffers];
     KMP_DEBUG_ASSERT(pr_buf->th_doacross_info[1] ==
                      (kmp_int64)&sh_buf->doacross_num_done);
     KMP_DEBUG_ASSERT(num_done == sh_buf->doacross_num_done);

openmp/runtime/src/kmp_dispatch.cpp

case kmp_sch_guided_iterative_chunked: {
     if (nproc > 1) {
       if ((2L * chunk + 1) * nproc >= tc) {
         /* chunk size too large, switch to dynamic */
         schedule = kmp_sch_dynamic_chunked;
       } else {
         // when remaining iters become less than parm2 - switch to dynamic
         pr->u.p.parm2 = guided_int_param * nproc * (chunk + 1);
         *(double *)&pr->u.p.parm3 =
-            guided_flt_param / nproc; // may occupy parm3 and parm4
+            guided_flt_param / (double)nproc; // may occupy parm3 and parm4
       }
     } else {
       KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d falling-through to "
                      "kmp_sch_static_greedy\n",
                      gtid));
       schedule = kmp_sch_static_greedy;
       /* team->t.t_nproc == 1: fall-through to kmp_sch_static_greedy */
       KD_TRACE(
#endif
         /* value used for comparison in solver for cross-over point */
         long double target = ((long double)chunk * 2 + 1) * nproc / tc;
 
         /* crossover point--chunk indexes equal to or greater than
            this point switch to dynamic-style scheduling */
         UT cross;
 
         /* commonly used term: (2 nproc - 1)/(2 nproc) */
-        x = (long double)1.0 - (long double)0.5 / nproc;
+        x = 1.0 - 0.5 / (double)nproc;
 
 #ifdef KMP_DEBUG
         { // test natural alignment
           struct _test_a {
             char a;
             union {
               char b;
               DBL d;
int __kmp_dispatch_next_algorithm(int gtid,
                                   dispatch_shared_info_template<T> volatile *sh,
                                   kmp_int32 *p_last, T *p_lb, T *p_ub,
                                   typename traits_t<T>::signed_t *p_st, 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 status = 0;
-  kmp_int32 last = 0;
+  bool last = false;
   T start;
   ST incr;
   UT limit, trip, init;
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
 
   KMP_DEBUG_ASSERT(th->th.th_dispatch ==
                    &th->th.th_team->t.t_dispatch[th->th.th_info.ds.ds_tid]);
if (traits_t<T>::type_size > 4) {
         init = (pr->u.p.count)++;
         status = (init < (UT)pr->u.p.ub);
         __kmp_release_lock(lck, gtid);
       } else {
         status = 0; // no own chunks
       }
       if (!status) { // try to steal
         kmp_info_t **other_threads = team->t.t_threads;
-        int while_limit = pr->u.p.parm3;
-        int while_index = 0;
+        T while_limit = pr->u.p.parm3;
+        T while_index = 0;
         T id = pr->u.p.static_steal_counter; // loop id
         int idx = (th->th.th_dispatch->th_disp_index - 1) %
                   __kmp_dispatch_num_buffers; // current loop index
         // note: victim thread can potentially execute another loop
         // TODO: algorithm of searching for a victim
         // should be cleaned up and measured
         while ((!status) && (while_limit != ++while_index)) {
           dispatch_private_info_template<T> *victim;
if (traits_t<T>::type_size > 4) {
         }
         vnew = vold;
         init = vnew.p.count;
         status = (init < (UT)vnew.p.ub);
       }
 
       if (!status) {
         kmp_info_t **other_threads = team->t.t_threads;
-        int while_limit = pr->u.p.parm3;
-        int while_index = 0;
+        T while_limit = pr->u.p.parm3;
+        T while_index = 0;
         T id = pr->u.p.static_steal_counter; // loop id
         int idx = (th->th.th_dispatch->th_disp_index - 1) %
                   __kmp_dispatch_num_buffers; // current loop index
         // note: victim thread can potentially execute another loop
         // TODO: algorithm of searching for a victim
         // should be cleaned up and measured
         while ((!status) && (while_limit != ++while_index)) {
           dispatch_private_info_template<T> *victim;
           union_i4 vold, vnew;
-          kmp_int32 remaining;
+          T remaining;
           T victimIdx = pr->u.p.parm4;
           T oldVictimIdx = victimIdx ? victimIdx - 1 : nproc - 1;
           victim = reinterpret_cast<dispatch_private_info_template<T> *>(
               &other_threads[victimIdx]->th.th_dispatch->th_disp_buffer[idx]);
           KMP_DEBUG_ASSERT(victim);
           while ((victim == pr || id != victim->u.p.static_steal_counter) &&
                  oldVictimIdx != victimIdx) {
             victimIdx = (victimIdx + 1) % nproc;
if (traits_t<T>::type_size > 4) {
 
             KMP_DEBUG_ASSERT((vnew.p.ub - 1) * (UT)chunk <= trip);
             if (vnew.p.count >= (UT)vnew.p.ub ||
                 (remaining = vnew.p.ub - vnew.p.count) < 2) {
               pr->u.p.parm4 = (victimIdx + 1) % nproc; // shift start victim id
               break; // not enough chunks to steal, goto next victim
             }
             if (remaining > 3) {
-              vnew.p.ub -= (remaining >> 2); // try to steal 1/4 of remaining
+              // try to steal 1/4 of remaining
+              vnew.p.ub -= remaining >> 2;
             } else {
               vnew.p.ub -= 1; // steal 1 chunk of 2 or 3 remaining
             }
             KMP_DEBUG_ASSERT((vnew.p.ub - 1) * (UT)chunk <= trip);
             // TODO: Should this be acquire or release?
             if (KMP_COMPARE_AND_STORE_ACQ64(
                     (volatile kmp_int64 *)&victim->u.p.count,
                     *VOLATILE_CAST(kmp_int64 *) & vold.b,
KD_TRACE(
         10,
         ("__kmp_dispatch_next_algorithm: T#%d kmp_sch_static_balanced case\n",
          gtid));
     /* check if thread has any iteration to do */
     if ((status = !pr->u.p.count) != 0) {
       pr->u.p.count = 1;
       *p_lb = pr->u.p.lb;
       *p_ub = pr->u.p.ub;
-      last = pr->u.p.parm1;
+      last = (pr->u.p.parm1 != 0);
       if (p_st != NULL)
         *p_st = pr->u.p.st;
     } else { /* no iterations to do */
       pr->u.p.lb = pr->u.p.ub + pr->u.p.st;
     }
   } // case
   break;
   case kmp_sch_static_greedy: /* original code for kmp_sch_static_greedy was
while (1) {
         if (remaining <= 0) {
           status = 0; // all iterations got by other threads
         } else {
           // got some iterations to work on
           status = 1;
           if ((T)remaining > chunkspec) {
             limit = init + chunkspec - 1;
           } else {
-            last = 1; // the last chunk
+            last = true; // the last chunk
             limit = init + remaining - 1;
           } // if
         } // if
         break;
       } // if
-      limit = init +
-              (UT)(remaining * *(double *)&pr->u.p.parm3); // divide by K*nproc
+      limit = init + (UT)((double)remaining *
+                          *(double *)&pr->u.p.parm3); // divide by K*nproc
       if (compare_and_swap<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
                                (ST)init, (ST)limit)) {
         // CAS was successful, chunk obtained
         status = 1;
         --limit;
         break;
       } // if
     } // while
while (1) {
         if (remaining <= 0) {
           status = 0; // all iterations got by other threads
         } else {
           // got some iterations to work on
           status = 1;
           if ((T)remaining > chunk) {
             limit = init + chunk - 1;
           } else {
-            last = 1; // the last chunk
+            last = true; // the last chunk
             limit = init + remaining - 1;
           } // if
         } // if
         break;
       } // if
       // divide by K*nproc
-      UT span = remaining * (*(double *)&pr->u.p.parm3);
+      UT span;
+      __kmp_type_convert((double)remaining * (*(double *)&pr->u.p.parm3),
+                         &span);
       UT rem = span % chunk;
       if (rem) // adjust so that span%chunk == 0
         span += chunk - rem;
       limit = init + span;
       if (compare_and_swap<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
                                (ST)init, (ST)limit)) {
         // CAS was successful, chunk obtained
         status = 1;

openmp/runtime/src/kmp_dispatch_hier.h

void core_barrier_impl<T>::barrier(kmp_int32 id,
   kmp_uint64 next_index = 1 - current_index;
   kmp_uint64 current_wait_value = tdata->wait_val[current_index];
   kmp_uint64 next_wait_value =
       (current_wait_value ? 0 : get_wait_val(tdata->num_active));
   KD_TRACE(10, ("core_barrier_impl::barrier(): T#%d current_index:%llu "
                 "next_index:%llu curr_wait:%llu next_wait:%llu\n",
                 __kmp_get_gtid(), current_index, next_index, current_wait_value,
                 next_wait_value));
-  char v = (current_wait_value ? 0x1 : 0x0);
+  char v = (current_wait_value ? '\1' : '\0');
   (RCAST(volatile char *, &(bdata->val[current_index])))[id] = v;
   __kmp_wait<kmp_uint64>(&(bdata->val[current_index]), current_wait_value,
                          __kmp_eq<kmp_uint64> USE_ITT_BUILD_ARG(NULL));
   tdata->wait_val[current_index] = next_wait_value;
   tdata->index = next_index;
 }
 
 // Counter barrier implementation
if (previous_id == 0) {
                                                 &my_st, nproc, hier_id);
       KD_TRACE(
           10,
           ("kmp_hier_t.next_recurse(): T#%d (%d) next_pr_sh() returned %d\n",
            gtid, hier_level, status));
       // When no iterations are found (status == 0) and this is not the last
       // layer, attempt to go up the hierarchy for more iterations
       if (status == 0 && !last_layer) {
+        kmp_int32 hid;
+        __kmp_type_convert(hier_id, &hid);
         status = next_recurse(loc, gtid, parent, &contains_last, &my_lb, &my_ub,
-                              &my_st, hier_id, hier_level + 1);
+                              &my_st, hid, hier_level + 1);
         KD_TRACE(
             10,
             ("kmp_hier_t.next_recurse(): T#%d (%d) hier_next() returned %d\n",
              gtid, hier_level, status));
         if (status == 1) {
           kmp_hier_private_bdata_t *upper_tdata =
               &(th->th.th_hier_bar_data[hier_level + 1]);
           my_sh = parent->get_curr_sh(upper_tdata->index);
if (__kmp_dispatch_hand_threading) {
         auto sh = &(parent->hier_barrier.sh[0]);
         KMP_DEBUG_ASSERT(sh);
         status = __kmp_dispatch_next_algorithm<T>(
             gtid, pr, sh, &contains_last, p_lb, p_ub, p_st, nproc, unit_id);
         if (!status) {
           bool done = false;
           while (!done) {
             done = true;
+            kmp_int32 uid;
+            __kmp_type_convert(unit_id, &uid);
             status = next_recurse(loc, gtid, parent, &contains_last, p_lb, p_ub,
-                                  p_st, unit_id, 0);
+                                  p_st, uid, 0);
             if (status == 1) {
               __kmp_dispatch_init_algorithm(loc, gtid, pr, pr->schedule,
                                             parent->get_next_lb(tdata->index),
                                             parent->get_next_ub(tdata->index),
                                             parent->get_next_st(tdata->index),
 #if USE_ITT_BUILD
                                             NULL,
 #endif
#endif
       KD_TRACE(10,
                ("kmp_hier_t.next(): T#%d THREAD LEVEL next_algorithm status:%d "
                 "contains_last:%d p_lb:%d p_ub:%d p_st:%d\n",
                 gtid, status, contains_last, *p_lb, *p_ub, *p_st));
       if (!status) {
         bool done = false;
         while (!done) {
           done = true;
+          kmp_int32 uid;
+          __kmp_type_convert(unit_id, &uid);
           status = next_recurse(loc, gtid, parent, &contains_last, p_lb, p_ub,
-                                p_st, unit_id, 0);
+                                p_st, uid, 0);
           if (status == 1) {
             sh = parent->get_curr_sh(tdata->index);
             __kmp_dispatch_init_algorithm(loc, gtid, pr, pr->schedule,
                                           parent->get_curr_lb(tdata->index),
                                           parent->get_curr_ub(tdata->index),
                                           parent->get_curr_st(tdata->index),
 #if USE_ITT_BUILD
                                           NULL,

openmp/runtime/src/kmp_environment.cpp

array is NULL:
 
         { "HOME=/home/lev", "TERM=xterm", NULL }
 */
 
 static void
 ___kmp_env_blk_parse_unix(kmp_env_blk_t *block, // M: Env block to fill.
                           char **env // I: Unix environment to parse.
                           ) {
-
   char *bulk = NULL;
   kmp_env_var_t *vars = NULL;
   int count = 0;
-  int size = 0; // Size of bulk.
+  size_t size = 0; // Size of bulk.
 
   // Count number of variables and length of required bulk.
   {
-    count = 0;
-    size = 0;
     while (env[count] != NULL) {
       size += KMP_STRLEN(env[count]) + 1;
       ++count;
     }
   }
 
   // Allocate memory.
   bulk = (char *)allocate(size);
   vars = (kmp_env_var_t *)allocate(count * sizeof(kmp_env_var_t));
 
   // Loop thru all the vars.
   {
     char *var; // Pointer to beginning of var.
     char *name; // Pointer to name of variable.
     char *value; // Pointer to value.
-    int len; // Length of variable.
+    size_t len; // Length of variable.
     int i;
     var = bulk;
     for (i = 0; i < count; ++i) {
       // Copy variable to bulk.
       len = KMP_STRLEN(env[i]);
       KMP_MEMCPY_S(var, size, env[i], len + 1);
       // Save found variable in vars array.
       __kmp_str_split(var, '=', &name, &value);

openmp/runtime/src/kmp_ftn_entry.h

 #else
   // __kmp_aux_set_stacksize initializes the library if needed
   __kmp_aux_set_stacksize(KMP_DEREF arg);
 #endif
 }
 
 int FTN_STDCALL FTN_GET_STACKSIZE(void) {
 #ifdef KMP_STUB
-  return __kmps_get_stacksize();
+  return (int)__kmps_get_stacksize();
 #else
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   return (int)__kmp_stksize;
 #endif
 }
 

 #ifdef KMP_TDATA_GTID
   if (__kmp_gtid_mode >= 3) {
     if ((gtid = __kmp_gtid) == KMP_GTID_DNE) {
       return 0;
     }
   } else {
 #endif
     if (!__kmp_init_parallel ||
-        (gtid = (kmp_intptr_t)(
-             pthread_getspecific(__kmp_gtid_threadprivate_key))) == 0) {
+        (gtid = (int)((kmp_intptr_t)(
+             pthread_getspecific(__kmp_gtid_threadprivate_key)))) == 0) {
       return 0;
     }
     --gtid;
 #ifdef KMP_TDATA_GTID
   }
 #endif
 #else
 #error Unknown or unsupported OS

 #ifdef KMP_STUB
   __kmps_set_dynamic(KMP_DEREF flag ? TRUE : FALSE);
 #else
   kmp_info_t *thread;
   /* For the thread-private implementation of the internal controls */
   thread = __kmp_entry_thread();
   // !!! What if foreign thread calls it?
   __kmp_save_internal_controls(thread);
-  set__dynamic(thread, KMP_DEREF flag ? TRUE : FALSE);
+  set__dynamic(thread, KMP_DEREF flag ? true : false);
 #endif
 }
 
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_DYNAMIC)(void) {
 #ifdef KMP_STUB
   return __kmps_get_dynamic();
 #else
   kmp_info_t *thread;

openmp/runtime/src/kmp_gsupport.cpp

#endif
   if (if_cond) {
     if (gomp_flags & KMP_GOMP_TASK_DEPENDS_FLAG) {
       KMP_ASSERT(depend);
       kmp_gomp_depends_info_t gomp_depends(depend);
       kmp_int32 ndeps = gomp_depends.get_num_deps();
       kmp_depend_info_t dep_list[ndeps];
       for (kmp_int32 i = 0; i < ndeps; i++)
         dep_list[i] = gomp_depends.get_kmp_depend(i);
-      __kmpc_omp_task_with_deps(&loc, gtid, task, ndeps, dep_list, 0, NULL);
+      kmp_int32 ndeps_cnv;
+      __kmp_type_convert(ndeps, &ndeps_cnv);
+      __kmpc_omp_task_with_deps(&loc, gtid, task, ndeps_cnv, dep_list, 0, NULL);
     } else {
       __kmpc_omp_task(&loc, gtid, task);
     }
   } else {
 #if OMPT_SUPPORT
     ompt_thread_info_t oldInfo;
     kmp_info_t *thread;
     kmp_taskdata_t *taskdata;

 template <typename T, bool need_conversion = (sizeof(long) == 4)>
 void __kmp_GOMP_doacross_post(T *count);
 
 template <> void __kmp_GOMP_doacross_post<long, true>(long *count) {
   int gtid = __kmp_entry_gtid();
   kmp_info_t *th = __kmp_threads[gtid];
   MKLOC(loc, "GOMP_doacross_post");
   kmp_int64 num_dims = th->th.th_dispatch->th_doacross_info[0];
-  kmp_int64 *vec =
-      (kmp_int64 *)__kmp_thread_malloc(th, sizeof(kmp_int64) * num_dims);
+  kmp_int64 *vec = (kmp_int64 *)__kmp_thread_malloc(
+      th, (size_t)(sizeof(kmp_int64) * num_dims));
   for (kmp_int64 i = 0; i < num_dims; ++i) {
     vec[i] = (kmp_int64)count[i];
   }
   __kmpc_doacross_post(&loc, gtid, vec);
   __kmp_thread_free(th, vec);
 }
 
 // 8 byte versions of GOMP_doacross_post
 // This version can just pass in the count array directly instead of creating
 // a temporary array
 template <> void __kmp_GOMP_doacross_post<long, false>(long *count) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_doacross_post");
   __kmpc_doacross_post(&loc, gtid, RCAST(kmp_int64 *, count));
 }
 
 template <typename T> void __kmp_GOMP_doacross_wait(T first, va_list args) {
   int gtid = __kmp_entry_gtid();
   kmp_info_t *th = __kmp_threads[gtid];
   MKLOC(loc, "GOMP_doacross_wait");
   kmp_int64 num_dims = th->th.th_dispatch->th_doacross_info[0];
-  kmp_int64 *vec =
-      (kmp_int64 *)__kmp_thread_malloc(th, sizeof(kmp_int64) * num_dims);
+  kmp_int64 *vec = (kmp_int64 *)__kmp_thread_malloc(
+      th, (size_t)(sizeof(kmp_int64) * num_dims));
   vec[0] = (kmp_int64)first;
   for (kmp_int64 i = 1; i < num_dims; ++i) {
     T item = va_arg(args, T);
     vec[i] = (kmp_int64)item;
   }
   __kmpc_doacross_wait(&loc, gtid, vec);
   __kmp_thread_free(th, vec);
   return;

openmp/runtime/src/kmp_i18n.h

enum kmp_msg_type {
   kmp_mt_syserr = -1 // System error message.
 }; // enum kmp_msg_type
 typedef enum kmp_msg_type kmp_msg_type_t;
 
 struct kmp_msg {
   kmp_msg_type_t type;
   int num;
   char *str;
-  int len;
+  size_t len;
 }; // struct kmp_message
 typedef struct kmp_msg kmp_msg_t;
 
 // Special message to denote the end of variadic list of arguments.
 extern kmp_msg_t __kmp_msg_null;
 
 // Helper functions. Creates messages either from message catalog or from
 // system. Note: these functions allocate memory. You should pass created

openmp/runtime/src/kmp_itt.inl

if (team != NULL) {
     // Now form the barrier id. Encode barrier type (bt) in barrier id too, so
     // barriers of different types do not have the same ids.
     KMP_BUILD_ASSERT(sizeof(kmp_team_t) >= bs_last_barrier);
     // This condition is a must (we would have zero divide otherwise).
     KMP_BUILD_ASSERT(sizeof(kmp_team_t) >= 2 * bs_last_barrier);
     // More strong condition: make sure we have room at least for for two
     // different ids (for each barrier type).
     object = reinterpret_cast<void *>(
-        kmp_uintptr_t(team) +
-        counter % (sizeof(kmp_team_t) / bs_last_barrier) * bs_last_barrier +
+        (kmp_uintptr_t)(team) +
+        (kmp_uintptr_t)counter % (sizeof(kmp_team_t) / bs_last_barrier) *
+            bs_last_barrier +
         bt);
     KMP_ITT_DEBUG_LOCK();
     KMP_ITT_DEBUG_PRINT("[bar obj] type=%d, counter=%lld, object=%p\n", bt,
                         counter, object);
 
     if (set_name) {
       ident_t const *loc = NULL;
       char const *src = NULL;

openmp/runtime/src/kmp_lock.cpp

if (!cond) {
                 lck->lk.poll, gtid));
     }
 
     KA_TRACE(
         1000,
         ("__kmp_acquire_futex_lock: lck:%p, T#%d before futex_wait(0x%x)\n",
          lck, gtid, poll_val));
 
-    kmp_int32 rc;
+    long rc;
     if ((rc = syscall(__NR_futex, &(lck->lk.poll), FUTEX_WAIT, poll_val, NULL,
                       NULL, 0)) != 0) {
       KA_TRACE(1000, ("__kmp_acquire_futex_lock: lck:%p, T#%d futex_wait(0x%x) "
-                      "failed (rc=%d errno=%d)\n",
+                      "failed (rc=%ld errno=%d)\n",
                       lck, gtid, poll_val, rc, errno));
       continue;
     }
 
     KA_TRACE(1000,
              ("__kmp_acquire_futex_lock: lck:%p, T#%d after futex_wait(0x%x)\n",
               lck, gtid, poll_val));
     // This thread has now done a successful futex wait call and was entered on

openmp/runtime/src/kmp_runtime.cpp

static const unsigned __kmp_primes[] = {
     0x5ca19031, 0xe6d9293b, 0xf0a9f391, 0x5d2e980b, 0xfc411073, 0xc3749363,
     0xb892d829, 0x3549366b, 0x629750ad, 0xb98294e5, 0x892d9483, 0xc235baf3,
     0x3d2402a3, 0x6bdef3c9, 0xbec333cd, 0x40c9520f};
 
 //---------------------------------------------------------------------------
 //  __kmp_get_random: Get a random number using a linear congruential method.
 unsigned short __kmp_get_random(kmp_info_t *thread) {
   unsigned x = thread->th.th_x;
-  unsigned short r = x >> 16;
+  unsigned short r = (unsigned short)(x >> 16);
 
   thread->th.th_x = x * thread->th.th_a + 1;
 
   KA_TRACE(30, ("__kmp_get_random: THREAD: %d, RETURN: %u\n",
                 thread->th.th_info.ds.ds_tid, r));
 
   return r;
 }
#endif // KMP_NESTED_HOT_TEAMS
         // only need to set the th_task_state for the new threads. th_task_state
         // for master thread will not be accurate until after this in
         // __kmp_fork_call(), so we look to the master's memo_stack to get the
         // correct value.
         for (f = old_nproc; f < team->t.t_nproc; ++f)
           team->t.t_threads[f]->th.th_task_state =
               team->t.t_threads[0]->th.th_task_state_memo_stack[level];
       } else { // set th_task_state for new threads in non-nested hot team
-        int old_state =
+        kmp_uint8 old_state =
             team->t.t_threads[0]->th.th_task_state; // copy master's state
         for (f = old_nproc; f < team->t.t_nproc; ++f)
           team->t.t_threads[f]->th.th_task_state = old_state;
       }
 
 #ifdef KMP_DEBUG
       for (f = 0; f < team->t.t_nproc; ++f) {
         KMP_DEBUG_ASSERT(team->t.t_threads[f] &&
#endif
   KA_TRACE(10, ("__kmp_launch_thread: T#%d done\n", gtid));
   KMP_MB();
   return this_thr;
 }
 
 /* ------------------------------------------------------------------------ */
 
 void __kmp_internal_end_dest(void *specific_gtid) {
-#if KMP_COMPILER_ICC
-#pragma warning(push)
-#pragma warning(disable : 810) // conversion from "void *" to "int" may lose
-// significant bits
-#endif
   // Make sure no significant bits are lost
-  int gtid = (kmp_intptr_t)specific_gtid - 1;
-#if KMP_COMPILER_ICC
-#pragma warning(pop)
-#endif
+  int gtid;
+  __kmp_type_convert((kmp_intptr_t)specific_gtid - 1, &gtid);
 
   KA_TRACE(30, ("__kmp_internal_end_dest: T#%d\n", gtid));
   /* NOTE: the gtid is stored as gitd+1 in the thread-local-storage
    * this is because 0 is reserved for the nothing-stored case */
 
   __kmp_internal_end_thread(gtid);
 }
 
static void __kmp_user_level_mwait_init() {
   KF_TRACE(30, ("__kmp_user_level_mwait_init: __kmp_mic_type = %d, "
                 "__kmp_mwait_enabled = %d\n",
                 __kmp_mic_type, __kmp_mwait_enabled));
 }
 #endif /* KMP_HAVE_UMWAIT */
 
 static void __kmp_do_serial_initialize(void) {
   int i, gtid;
-  int size;
+  size_t size;
 
   KA_TRACE(10, ("__kmp_do_serial_initialize: enter\n"));
 
   KMP_DEBUG_ASSERT(sizeof(kmp_int32) == 4);
   KMP_DEBUG_ASSERT(sizeof(kmp_uint32) == 4);
   KMP_DEBUG_ASSERT(sizeof(kmp_int64) == 8);
   KMP_DEBUG_ASSERT(sizeof(kmp_uint64) == 8);
   KMP_DEBUG_ASSERT(sizeof(kmp_intptr_t) == sizeof(void *));
if (parse_long_name)
     (*ptr)++; // skip initial left brace
   for (size_t i = 0; i < sizeof(__kmp_affinity_format_table) /
                              sizeof(__kmp_affinity_format_table[0]);
        ++i) {
     char short_name = __kmp_affinity_format_table[i].short_name;
     const char *long_name = __kmp_affinity_format_table[i].long_name;
     char field_format = __kmp_affinity_format_table[i].field_format;
     if (parse_long_name) {
-      int length = KMP_STRLEN(long_name);
+      size_t length = KMP_STRLEN(long_name);
       if (strncmp(*ptr, long_name, length) == 0) {
         found_valid_name = true;
         (*ptr) += length; // skip the long name
       }
     } else if (**ptr == short_name) {
       found_valid_name = true;
       (*ptr)++; // skip the short name
     }

 
 /* ------------------------------------------------------------------------ */
 
 void __kmp_aux_set_blocktime(int arg, kmp_info_t *thread, int tid) {
   int blocktime = arg; /* argument is in milliseconds */
 #if KMP_USE_MONITOR
   int bt_intervals;
 #endif
-  int bt_set;
+  kmp_int8 bt_set;
 
   __kmp_save_internal_controls(thread);
 
   /* Normalize and set blocktime for the teams */
   if (blocktime < KMP_MIN_BLOCKTIME)
     blocktime = KMP_MIN_BLOCKTIME;
   else if (blocktime > KMP_MAX_BLOCKTIME)
     blocktime = KMP_MAX_BLOCKTIME;
KF_TRACE(10, ("kmp_set_blocktime: T#%d(%d:%d), blocktime=%d, "
                 __kmp_monitor_wakeups));
 #else
   KF_TRACE(10, ("kmp_set_blocktime: T#%d(%d:%d), blocktime=%d\n",
                 __kmp_gtid_from_tid(tid, thread->th.th_team),
                 thread->th.th_team->t.t_id, tid, blocktime));
 #endif
 }
 
-void __kmp_aux_set_defaults(char const *str, int len) {
+void __kmp_aux_set_defaults(char const *str, size_t len) {
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   __kmp_env_initialize(str);
 
   if (__kmp_settings || __kmp_display_env || __kmp_display_env_verbose) {
     __kmp_env_print();
   }

openmp/runtime/src/kmp_settings.cpp

if (msg != NULL) {
     // Message is not empty. Print warning.
     kmp_str_buf_t buf;
     KMP_WARNING(ParseSizeIntWarn, name, value, msg);
     __kmp_str_buf_init(&buf);
     __kmp_str_buf_print(&buf, "%" KMP_UINT64_SPEC "", uint);
     KMP_INFORM(Using_uint64_Value, name, buf.str);
     __kmp_str_buf_free(&buf);
   }
-  *out = uint;
+  __kmp_type_convert(uint, out);
 } // __kmp_stg_parse_int
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
 static void __kmp_stg_parse_file(char const *name, char const *value,
                                  const char *suffix, char **out) {
   char buffer[256];
   char *t;
   int hasSuffix;
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);
   }
if (!__kmp_dflt_max_active_levels_set) {
     __kmp_str_to_uint(value, &tmp_dflt, &msg);
     if (msg != NULL) { // invalid setting; print warning and ignore
       KMP_WARNING(ParseSizeIntWarn, name, value, msg);
     } else if (tmp_dflt > KMP_MAX_ACTIVE_LEVELS_LIMIT) {
       // invalid setting; print warning and ignore
       msg = KMP_I18N_STR(ValueTooLarge);
       KMP_WARNING(ParseSizeIntWarn, name, value, msg);
     } else { // valid setting
-      __kmp_dflt_max_active_levels = tmp_dflt;
+      __kmp_type_convert(tmp_dflt, &(__kmp_dflt_max_active_levels));
       __kmp_dflt_max_active_levels_set = true;
     }
   }
 } // __kmp_stg_parse_max_active_levels
 
 static void __kmp_stg_print_max_active_levels(kmp_str_buf_t *buffer,
                                               char const *name, void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_dflt_max_active_levels);
static void __kmp_stg_parse_taskloop_min_tasks(char const *name,
                                                char const *value, void *data) {
   int tmp;
   __kmp_stg_parse_int(name, value, 0, INT_MAX, &tmp);
   __kmp_taskloop_min_tasks = tmp;
 } // __kmp_stg_parse_taskloop_min_tasks
 
 static void __kmp_stg_print_taskloop_min_tasks(kmp_str_buf_t *buffer,
                                                char const *name, void *data) {
-  __kmp_stg_print_int(buffer, name, __kmp_taskloop_min_tasks);
+  __kmp_stg_print_uint64(buffer, name, __kmp_taskloop_min_tasks);
 } // __kmp_stg_print_taskloop_min_tasks
 
 // -----------------------------------------------------------------------------
 // KMP_DISP_NUM_BUFFERS
 static void __kmp_stg_parse_disp_buffers(char const *name, char const *value,
                                          void *data) {
   if (TCR_4(__kmp_init_serial)) {
     KMP_WARNING(EnvSerialWarn, name);
if (*next == ',') {
       next++;
     }
     scan = next;
   }
 
   *nextEnv = next;
 
   {
-    int len = next - env;
+    ptrdiff_t len = next - env;
     char *retlist = (char *)__kmp_allocate((len + 1) * sizeof(char));
     KMP_MEMCPY_S(retlist, (len + 1) * sizeof(char), env, len * sizeof(char));
     retlist[len] = '\0';
     *proclist = retlist;
   }
   return TRUE;
 }
 
if (*scan == ',') {
       continue;
     }
 
     KMP_WARNING(SyntaxErrorUsing, var, "\"threads\"");
     return FALSE;
   }
 
   {
-    int len = scan - env;
+    ptrdiff_t len = scan - env;
     char *retlist = (char *)__kmp_allocate((len + 1) * sizeof(char));
     KMP_MEMCPY_S(retlist, (len + 1) * sizeof(char), env, len * sizeof(char));
     retlist[len] = '\0';
     *place_list = retlist;
   }
   return TRUE;
 }
 
static void __kmp_stg_parse_hw_subset(char const *name, char const *value,
   int level = 0;
   // Canonize the string (remove spaces, unify delimiters, etc.)
   char *pos = CCAST(char *, value);
   while (*pos && mlen) {
     if (*pos != ' ') { // skip spaces
       if (len == 0 && *pos == ':') {
         __kmp_hws_abs_flag = 1; // if the first symbol is ":", skip it
       } else {
-        input[len] = toupper(*pos);
+        input[len] = (char)(toupper(*pos));
         if (input[len] == 'X')
           input[len] = ','; // unify delimiters of levels
         if (input[len] == 'O' && strchr(digits, *(pos + 1)))
           input[len] = '@'; // unify delimiters of offset
         len++;
       }
     }
     mlen--;

openmp/runtime/src/kmp_stats.h

  * @param value double precision sample value to add to statistics for the timer
  *
  * \details Use KMP_COUNT_VALUE(name, value) macro to add a particular value to
  * a timer statistics.
  *
  * @ingroup STATS_GATHERING
 */
 #define KMP_COUNT_VALUE(name, value)                                           \
-  __kmp_stats_thread_ptr->getTimer(TIMER_##name)->addSample(value)
+  __kmp_stats_thread_ptr->getTimer(TIMER_##name)->addSample((double)value)
 
 /*!
  * \brief Increments specified counter (name).
  *
  * @param name counter name as specified under the KMP_FOREACH_COUNTER() macro
  *
  * \details Use KMP_COUNT_BLOCK(name, value) macro to increment a statistics
  * counter for the executing thread.

openmp/runtime/src/kmp_stats.cpp

 };
 
 // Ensure that the atexit handler only runs once.
 static uint32_t statsPrinted = 0;
 
 // output interface
 static kmp_stats_output_module *__kmp_stats_global_output = NULL;
 
-double logHistogram::binMax[] = {
-    1.e1l,  1.e2l,  1.e3l,  1.e4l,  1.e5l,  1.e6l,  1.e7l,  1.e8l,
-    1.e9l,  1.e10l, 1.e11l, 1.e12l, 1.e13l, 1.e14l, 1.e15l, 1.e16l,
-    1.e17l, 1.e18l, 1.e19l, 1.e20l, 1.e21l, 1.e22l, 1.e23l, 1.e24l,
-    1.e25l, 1.e26l, 1.e27l, 1.e28l, 1.e29l, 1.e30l};
+double logHistogram::binMax[] = {1.e1l, 1.e2l, 1.e3l, 1.e4l, 1.e5l, 1.e6l,
+                                 1.e7l, 1.e8l, 1.e9l, 1.e10l, 1.e11l, 1.e12l,
+                                 1.e13l, 1.e14l, 1.e15l, 1.e16l, 1.e17l, 1.e18l,
+                                 1.e19l, 1.e20l, 1.e21l, 1.e22l, 1.e23l, 1.e24l,
+                                 1.e25l, 1.e26l, 1.e27l, 1.e28l, 1.e29l, 1.e30l,
+                                 // Always have infinity be the last value
+                                 std::numeric_limits<double>::infinity()};
 
 /* ************* statistic member functions ************* */
 
 void statistic::addSample(double sample) {
   sample -= offset;
   KMP_DEBUG_ASSERT(std::isfinite(sample));
 
   double delta = sample - meanVal;
void statistic::scale(double factor) {
   minVal = minVal * factor;
   maxVal = maxVal * factor;
   meanVal = meanVal * factor;
   m2 = m2 * factor * factor;
   return;
 }
 
 std::string statistic::format(char unit, bool total) const {
-  std::string result = formatSI(sampleCount, 9, ' ');
+  std::string result = formatSI((double)sampleCount, 9, ' ');
 
   if (sampleCount == 0) {
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     if (total)
       result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);

 
 // Which bin does this sample belong in ?
 uint32_t logHistogram::findBin(double sample) {
   double v = std::fabs(sample);
   // Simply loop up looking which bin to put it in.
   // According to a micro-architect this is likely to be faster than a binary
   // search, since
   // it will only have one branch mis-predict
-  for (int b = 0; b < numBins; b++)
+  for (int b = 0; b < numBins - 1; b++)
     if (binMax[b] > v)
       return b;
-  fprintf(stderr,
-          "Trying to add a sample that is too large into a histogram\n");
-  KMP_ASSERT(0);
-  return -1;
+  return numBins - 1;
 }
 
 void logHistogram::addSample(double sample) {
   if (sample == 0.0) {
     zeroCount += 1;
 #ifdef KMP_DEBUG
     _total++;
     check();
std::string logHistogram::format(char unit) const {
   if (zeroCount) {
     result << "0,              " << formatSI(zeroCount, 9, ' ') << ", ",
         formatSI(0.0, 9, unit);
     if (count(minBin()) == 0)
       return result.str();
     result << "\n";
   }
   for (int i = minBin(); i <= maxBin(); i++) {
-    result << "10**" << i << "<=v<10**" << (i + 1) << ", "
-           << formatSI(count(i), 9, ' ') << ", " << formatSI(total(i), 9, unit);
+    result << "10**" << i << "<=v<";
+    if (i + 1 == numBins - 1)
+      result << "infinity, ";
+    else
+      result << "10**" << (i + 1) << ", ";
+    result << formatSI(count(i), 9, ' ') << ", " << formatSI(total(i), 9, unit);
     if (i != maxBin())
       result << "\n";
   }
 
   return result.str();
 }
 
 /* ************* explicitTimer member functions ************* */

 /* *************  kmp_stats_output_module functions ************** */
 
 const char *kmp_stats_output_module::eventsFileName = NULL;
 const char *kmp_stats_output_module::plotFileName = NULL;
 int kmp_stats_output_module::printPerThreadFlag = 0;
 int kmp_stats_output_module::printPerThreadEventsFlag = 0;
 
 static char const *lastName(char *name) {
-  int l = strlen(name);
+  int l = (int)strlen(name);
   for (int i = l - 1; i >= 0; --i) {
     if (name[i] == '.')
       name[i] = '_';
     if (name[i] == '/')
       return name + i + 1;
   }
   return name;
 }

 void kmp_stats_output_module::printCounters(FILE *statsOut,
                                             counter const *theCounters) {
   // We print all the counters even if they are zero.
   // That makes it easier to slice them into a spreadsheet if you need to.
   fprintf(statsOut, "\nCounter,                    Count\n");
   for (int c = 0; c < COUNTER_LAST; c++) {
     counter const *stat = &theCounters[c];
     fprintf(statsOut, "%-25s, %s\n", counter::name(counter_e(c)),
-            formatSI(stat->getValue(), 9, ' ').c_str());
+            formatSI((double)stat->getValue(), 9, ' ').c_str());
   }
 }
 
 void kmp_stats_output_module::printEvents(FILE *eventsOut,
                                           kmp_stats_event_vector *theEvents,
                                           int gtid) {
   // sort by start time before printing
   theEvents->sort();
for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
       if (!timeStat::noTotal(s))
         totalStats[s].addSample(threadStat->getTotal());
     }
 
     // Accumulate counters.
     for (counter_e c = counter_e(0); c < COUNTER_LAST; c = counter_e(c + 1)) {
       if (counter::masterOnly(c) && t != 0)
         continue;
-      allCounters[c].addSample((*it)->getCounter(c)->getValue());
+      allCounters[c].addSample((double)(*it)->getCounter(c)->getValue());
     }
   }
 
   if (eventPrintingEnabled()) {
     printPloticusFile();
     fclose(eventsOut);
   }
 

openmp/runtime/src/kmp_str.h

#define __kmp_str_buf_init(b)                                                  \
   {                                                                            \
     (b)->str = (b)->bulk;                                                      \
     (b)->size = sizeof((b)->bulk);                                             \
     (b)->used = 0;                                                             \
     (b)->bulk[0] = 0;                                                          \
   }
 
 void __kmp_str_buf_clear(kmp_str_buf_t *buffer);
-void __kmp_str_buf_reserve(kmp_str_buf_t *buffer, int size);
+void __kmp_str_buf_reserve(kmp_str_buf_t *buffer, size_t size);
 void __kmp_str_buf_detach(kmp_str_buf_t *buffer);
 void __kmp_str_buf_free(kmp_str_buf_t *buffer);
-void __kmp_str_buf_cat(kmp_str_buf_t *buffer, char const *str, int len);
+void __kmp_str_buf_cat(kmp_str_buf_t *buffer, char const *str, size_t len);
 void __kmp_str_buf_catbuf(kmp_str_buf_t *dest, const kmp_str_buf_t *src);
 int __kmp_str_buf_vprint(kmp_str_buf_t *buffer, char const *format,
                          va_list args);
 int __kmp_str_buf_print(kmp_str_buf_t *buffer, char const *format, ...);
 void __kmp_str_buf_print_size(kmp_str_buf_t *buffer, size_t size);
 
 /* File name parser.
    Usage:

openmp/runtime/src/kmp_str.cpp

void __kmp_str_buf_clear(kmp_str_buf_t *buffer) {
   KMP_STR_BUF_INVARIANT(buffer);
   if (buffer->used > 0) {
     buffer->used = 0;
     buffer->str[0] = 0;
   }
   KMP_STR_BUF_INVARIANT(buffer);
 } // __kmp_str_buf_clear
 
-void __kmp_str_buf_reserve(kmp_str_buf_t *buffer, int size) {
+void __kmp_str_buf_reserve(kmp_str_buf_t *buffer, size_t size) {
   KMP_STR_BUF_INVARIANT(buffer);
   KMP_DEBUG_ASSERT(size >= 0);
 
   if (buffer->size < (unsigned int)size) {
     // Calculate buffer size.
     do {
       buffer->size *= 2;
     } while (buffer->size < (unsigned int)size);
if (buffer->size > sizeof(buffer->bulk)) {
     KMP_INTERNAL_FREE(buffer->str);
   }
   buffer->str = buffer->bulk;
   buffer->size = sizeof(buffer->bulk);
   buffer->used = 0;
   KMP_STR_BUF_INVARIANT(buffer);
 } // __kmp_str_buf_free
 
-void __kmp_str_buf_cat(kmp_str_buf_t *buffer, char const *str, int len) {
+void __kmp_str_buf_cat(kmp_str_buf_t *buffer, char const *str, size_t len) {
   KMP_STR_BUF_INVARIANT(buffer);
   KMP_DEBUG_ASSERT(str != NULL);
   KMP_DEBUG_ASSERT(len >= 0);
+
   __kmp_str_buf_reserve(buffer, buffer->used + len + 1);
   KMP_MEMCPY(buffer->str + buffer->used, str, len);
   buffer->str[buffer->used + len] = 0;
-  buffer->used += len;
+  __kmp_type_convert(buffer->used + len, &(buffer->used));
   KMP_STR_BUF_INVARIANT(buffer);
 } // __kmp_str_buf_cat
 
 void __kmp_str_buf_catbuf(kmp_str_buf_t *dest, const kmp_str_buf_t *src) {
   KMP_DEBUG_ASSERT(dest);
   KMP_DEBUG_ASSERT(src);
   KMP_STR_BUF_INVARIANT(dest);
   KMP_STR_BUF_INVARIANT(src);
if (path != NULL) {
     // strdup with __kmp_str_format().
     if (KMP_OS_WINDOWS) {
       __kmp_str_replace(fname->path, '\\', '/');
     }
     fname->dir = __kmp_str_format("%s", fname->path);
     slash = strrchr(fname->dir, '/');
     if (KMP_OS_WINDOWS &&
         slash == NULL) { // On Windows* OS, if slash not found,
-      char first = TOLOWER(fname->dir[0]); // look for drive.
+      char first = (char)TOLOWER(fname->dir[0]); // look for drive.
       if ('a' <= first && first <= 'z' && fname->dir[1] == ':') {
         slash = &fname->dir[1];
       }
     }
     base = (slash == NULL ? fname->dir : slash + 1);
     fname->base = __kmp_str_format("%s", base); // Copy basename
     *base = 0; // and truncate dir.
   }

openmp/runtime/src/kmp_stub.h

 void __kmps_set_blocktime(int arg);
 int __kmps_get_blocktime(void);
 void __kmps_set_dynamic(int arg);
 int __kmps_get_dynamic(void);
 void __kmps_set_library(int arg);
 int __kmps_get_library(void);
 void __kmps_set_nested(int arg);
 int __kmps_get_nested(void);
-void __kmps_set_stacksize(int arg);
-int __kmps_get_stacksize();
+void __kmps_set_stacksize(size_t arg);
+size_t __kmps_get_stacksize();
 
 #ifndef KMP_SCHED_TYPE_DEFINED
 #define KMP_SCHED_TYPE_DEFINED
 typedef enum kmp_sched {
   kmp_sched_static = 1, // mapped to kmp_sch_static_chunked           (33)
   kmp_sched_dynamic = 2, // mapped to kmp_sch_dynamic_chunked          (35)
   kmp_sched_guided = 3, // mapped to kmp_sch_guided_chunked           (36)
   kmp_sched_auto = 4, // mapped to kmp_sch_auto                     (38)

openmp/runtime/src/kmp_stub.cpp

 int kmpc_get_affinity_mask_proc(int proc, void **mask) {
   i;
   return -1;
 }
 
 /* kmp API functions */
 void kmp_set_stacksize(omp_int_t arg) {
   i;
-  __kmps_set_stacksize(arg);
+  __kmps_set_stacksize((size_t)arg);
 }
 void kmp_set_stacksize_s(size_t arg) {
   i;
   __kmps_set_stacksize(arg);
 }
 void kmp_set_blocktime(omp_int_t arg) {
   i;
   __kmps_set_blocktime(arg);

 
 int __kmps_get_nested(void) {
   i;
   return __kmps_nested;
 } // __kmps_get_nested
 
 static size_t __kmps_stacksize = KMP_DEFAULT_STKSIZE;
 
-void __kmps_set_stacksize(int arg) {
+void __kmps_set_stacksize(size_t arg) {
   i;
   __kmps_stacksize = arg;
 } // __kmps_set_stacksize
 
-int __kmps_get_stacksize(void) {
+size_t __kmps_get_stacksize(void) {
   i;
   return __kmps_stacksize;
 } // __kmps_get_stacksize
 
 static kmp_sched_t __kmps_sched_kind = kmp_sched_default;
 static int __kmps_sched_modifier = 0;
 
 void __kmps_set_schedule(kmp_sched_t kind, int modifier) {

openmp/runtime/src/kmp_taskdeps.cpp

static inline kmp_depnode_t *__kmp_node_ref(kmp_depnode_t *node) {
   return node;
 }
 
 enum { KMP_DEPHASH_OTHER_SIZE = 97, KMP_DEPHASH_MASTER_SIZE = 997 };
 
 size_t sizes[] = { 997, 2003, 4001, 8191, 16001, 32003, 64007, 131071, 270029 };
 const size_t MAX_GEN = 8;
 
-static inline kmp_int32 __kmp_dephash_hash(kmp_intptr_t addr, size_t hsize) {
+static inline size_t __kmp_dephash_hash(kmp_intptr_t addr, size_t hsize) {
   // TODO alternate to try: set = (((Addr64)(addrUsefulBits * 9.618)) %
   // m_num_sets );
   return ((addr >> 6) ^ (addr >> 2)) % hsize;
 }
 
 static kmp_dephash_t *__kmp_dephash_extend(kmp_info_t *thread,
                                            kmp_dephash_t *current_dephash) {
   kmp_dephash_t *h;
 
   size_t gen = current_dephash->generation + 1;
   if (gen >= MAX_GEN)
     return current_dephash;
   size_t new_size = sizes[gen];
 
-  kmp_int32 size_to_allocate =
+  size_t size_to_allocate =
       new_size * sizeof(kmp_dephash_entry_t *) + sizeof(kmp_dephash_t);
 
 #if USE_FAST_MEMORY
   h = (kmp_dephash_t *)__kmp_fast_allocate(thread, size_to_allocate);
 #else
   h = (kmp_dephash_t *)__kmp_thread_malloc(thread, size_to_allocate);
 #endif
 
   h->size = new_size;
   h->nelements = current_dephash->nelements;
   h->buckets = (kmp_dephash_entry **)(h + 1);
   h->generation = gen;
   h->nconflicts = 0;
   // insert existing elements in the new table
   for (size_t i = 0; i < current_dephash->size; i++) {
     kmp_dephash_entry_t *next, *entry;
     for (entry = current_dephash->buckets[i]; entry; entry = next) {
       next = entry->next_in_bucket;
       // Compute the new hash using the new size, and insert the entry in
       // the new bucket.
-      kmp_int32 new_bucket = __kmp_dephash_hash(entry->addr, h->size);
+      size_t new_bucket = __kmp_dephash_hash(entry->addr, h->size);
       entry->next_in_bucket = h->buckets[new_bucket];
       if (entry->next_in_bucket) {
         h->nconflicts++;
       }
       h->buckets[new_bucket] = entry;
     }
   }
 
static kmp_dephash_t *__kmp_dephash_create(kmp_info_t *thread,
 
   size_t h_size;
 
   if (current_task->td_flags.tasktype == TASK_IMPLICIT)
     h_size = KMP_DEPHASH_MASTER_SIZE;
   else
     h_size = KMP_DEPHASH_OTHER_SIZE;
 
-  kmp_int32 size =
-      h_size * sizeof(kmp_dephash_entry_t *) + sizeof(kmp_dephash_t);
+  size_t size = h_size * sizeof(kmp_dephash_entry_t *) + sizeof(kmp_dephash_t);
 
 #if USE_FAST_MEMORY
   h = (kmp_dephash_t *)__kmp_fast_allocate(thread, size);
 #else
   h = (kmp_dephash_t *)__kmp_thread_malloc(thread, size);
 #endif
   h->size = h_size;
 

 static kmp_dephash_entry *
 __kmp_dephash_find(kmp_info_t *thread, kmp_dephash_t **hash, kmp_intptr_t addr) {
   kmp_dephash_t *h = *hash;
   if (h->nelements != 0
       && h->nconflicts/h->size >= 1) {
     *hash = __kmp_dephash_extend(thread, h);
     h = *hash;
   }
-  kmp_int32 bucket = __kmp_dephash_hash(addr, h->size);
+  size_t bucket = __kmp_dephash_hash(addr, h->size);
 
   kmp_dephash_entry_t *entry;
   for (entry = h->buckets[bucket]; entry; entry = entry->next_in_bucket)
     if (entry->addr == addr)
       break;
 
   if (entry == NULL) {
 // create entry. This is only done by one thread so no locking required

openmp/runtime/src/kmp_tasking.cpp

void __kmp_assign_orig<kmp_taskred_input_t>(kmp_taskred_data_t &item,
                                             kmp_taskred_input_t &src) {
   if (src.reduce_orig != NULL) {
     item.reduce_orig = src.reduce_orig;
   } else {
     item.reduce_orig = src.reduce_shar;
   } // non-NULL reduce_orig means new interface used
 }
 
-template <typename T> void __kmp_call_init(kmp_taskred_data_t &item, int j);
+template <typename T> void __kmp_call_init(kmp_taskred_data_t &item, size_t j);
 template <>
 void __kmp_call_init<kmp_task_red_input_t>(kmp_taskred_data_t &item,
-                                           int offset) {
+                                           size_t offset) {
   ((void (*)(void *))item.reduce_init)((char *)(item.reduce_priv) + offset);
 }
 template <>
 void __kmp_call_init<kmp_taskred_input_t>(kmp_taskred_data_t &item,
-                                          int offset) {
+                                          size_t offset) {
   ((void (*)(void *, void *))item.reduce_init)(
       (char *)(item.reduce_priv) + offset, item.reduce_orig);
 }
 
 template <typename T>
 void *__kmp_task_reduction_init(int gtid, int num, T *data) {
   __kmp_assert_valid_gtid(gtid);
   kmp_info_t *thread = __kmp_threads[gtid];
   kmp_taskgroup_t *tg = thread->th.th_current_task->td_taskgroup;
-  kmp_int32 nth = thread->th.th_team_nproc;
+  kmp_uint32 nth = thread->th.th_team_nproc;
   kmp_taskred_data_t *arr;
 
   // check input data just in case
   KMP_ASSERT(tg != NULL);
   KMP_ASSERT(data != NULL);
   KMP_ASSERT(num > 0);
   if (nth == 1) {
     KA_TRACE(10, ("__kmpc_task_reduction_init: T#%d, tg %p, exiting nth=1\n",
for (int i = 0; i < num; ++i) {
     arr[i].reduce_fini = data[i].reduce_fini;
     __kmp_assign_orig<T>(arr[i], data[i]);
     if (!arr[i].flags.lazy_priv) {
       // allocate cache-line aligned block and fill it with zeros
       arr[i].reduce_priv = __kmp_allocate(nth * size);
       arr[i].reduce_pend = (char *)(arr[i].reduce_priv) + nth * size;
       if (arr[i].reduce_init != NULL) {
         // initialize all thread-specific items
-        for (int j = 0; j < nth; ++j) {
+        for (size_t j = 0; j < nth; ++j) {
           __kmp_call_init<T>(arr[i], j * size);
         }
       }
     } else {
       // only allocate space for pointers now,
       // objects will be lazily allocated/initialized if/when requested
       // note that __kmp_allocate zeroes the allocated memory
       arr[i].reduce_priv = __kmp_allocate(nth * sizeof(void *));

 // __kmp_task_team_sync: Propagation of task team data from team to threads
 // which happens just after the release phase of a team barrier.  This may be
 // called by any thread, but only for teams with # threads > 1.
 void __kmp_task_team_sync(kmp_info_t *this_thr, kmp_team_t *team) {
   KMP_DEBUG_ASSERT(__kmp_tasking_mode != tskm_immediate_exec);
 
   // Toggle the th_task_state field, to switch which task_team this thread
   // refers to
-  this_thr->th.th_task_state = 1 - this_thr->th.th_task_state;
+  this_thr->th.th_task_state = (kmp_uint8)(1 - this_thr->th.th_task_state);
+
   // It is now safe to propagate the task team pointer from the team struct to
   // the current thread.
   TCW_PTR(this_thr->th.th_task_team,
           team->t.t_task_team[this_thr->th.th_task_state]);
   KA_TRACE(20,
            ("__kmp_task_team_sync: Thread T#%d task team switched to task_team "
             "%p from Team #%d (parity=%d)\n",
             __kmp_gtid_from_thread(this_thr), this_thr->th.th_task_team,

openmp/runtime/src/kmp_threadprivate.cpp

static struct private_data *__kmp_init_common_data(void *pc_addr,
   }
 
   return d;
 }
 
 // Initialize the data area from the template.
 static void __kmp_copy_common_data(void *pc_addr, struct private_data *d) {
   char *addr = (char *)pc_addr;
-  int i, offset;
 
-  for (offset = 0; d != 0; d = d->next) {
-    for (i = d->more; i > 0; --i) {
+  for (size_t offset = 0; d != 0; d = d->next) {
+    for (int i = d->more; i > 0; --i) {
       if (d->data == 0)
         memset(&addr[offset], '\0', d->size);
       else
         KMP_MEMCPY(&addr[offset], d->data, d->size);
       offset += d->size;
     }
   }
 }

openmp/runtime/src/kmp_utility.cpp

if (strcmp(unit, "MHz") == 0) {
       value = value * 1.0E+6;
     } else if (strcmp(unit, "GHz") == 0) {
       value = value * 1.0E+9;
     } else if (strcmp(unit, "THz") == 0) {
       value = value * 1.0E+12;
     } else { // Wrong unit.
       return result;
     }
-    result = value;
+    result = (kmp_uint64)value; // rounds down
   }
   return result;
 
 } // func __kmp_parse_cpu_frequency
 
 void __kmp_query_cpuid(kmp_cpuinfo_t *p) {
   struct kmp_cpuid buf;
   int max_arg;

openmp/runtime/src/kmp_wait_release.h

  */
 template <typename P> class kmp_flag_native {
   volatile P *loc;
   flag_properties t;
 
 public:
   typedef P flag_t;
   kmp_flag_native(volatile P *p, flag_type ft)
-      : loc(p), t({(unsigned int)ft, 0U}) {}
+      : loc(p), t({(short unsigned int)ft, 0U}) {}
   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 (flag_type)(t.type); }
   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_properties t; /**< "Type" of the flag in loc */
 public:
   typedef P flag_t;
   kmp_flag(std::atomic<P> *p, flag_type ft)
-      : loc(p), t({(unsigned int)ft, 0U}) {}
+      : loc(p), t({(short unsigned int)ft, 0U}) {}
   /*!
    * @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); }
static inline void __kmp_mwait_template(int th_gtid, C *flag) {
 
   // User-level mwait is available
   KMP_DEBUG_ASSERT(__kmp_mwait_enabled || __kmp_umwait_enabled);
 
   __kmp_suspend_initialize_thread(th);
   __kmp_lock_suspend_mx(th);
 
   volatile void *spin = flag->get();
-  void *cacheline = (void *)(kmp_uint64(spin) & ~(CACHE_LINE - 1));
+  void *cacheline = (void *)(kmp_uintptr_t(spin) & ~(CACHE_LINE - 1));
 
   if (!flag->done_check()) {
     // Mark thread as no longer active
     th->th.th_active = FALSE;
     if (th->th.th_active_in_pool) {
       th->th.th_active_in_pool = FALSE;
       KMP_ATOMIC_DEC(&__kmp_thread_pool_active_nth);
       KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) >= 0);

openmp/runtime/src/ompt-specific.cpp

int __ompt_get_task_memory_internal(void **addr, size_t *size, int blocknum) {
   else
     ret_addr = &task->part_id + 1;
 
   ret_size -= (char *)(ret_addr) - (char *)(task);
   if (ret_size < 0)
     return 0;
 
   *addr = ret_addr;
-  *size = ret_size;
+  *size = (size_t)ret_size;
   return 1;
 }
 
 //----------------------------------------------------------
 // team support
 //----------------------------------------------------------
 
 void __ompt_team_assign_id(kmp_team_t *team, ompt_data_t ompt_pid) {

openmp/runtime/src/z_Linux_util.cpp

 
 #include "tsan_annotations.h"
 
 struct kmp_sys_timer {
   struct timespec start;
 };
 
 // Convert timespec to nanoseconds.
-#define TS2NS(timespec) (((timespec).tv_sec * 1e9) + (timespec).tv_nsec)
+#define TS2NS(timespec)                                                        \
+  (((timespec).tv_sec * (long int)1e9) + (timespec).tv_nsec)
 
 static struct kmp_sys_timer __kmp_sys_timer_data;
 
 #if KMP_HANDLE_SIGNALS
 typedef void (*sig_func_t)(int);
 STATIC_EFI2_WORKAROUND struct sigaction __kmp_sighldrs[NSIG];
 static sigset_t __kmp_sigset;
 #endif

 #define KMP_CPU_SET_SIZE_LIMIT (sizeof(cpuset_t))
 #endif
 
 
 #if KMP_OS_LINUX
   // If Linux* OS:
   // If the syscall fails or returns a suggestion for the size,
   // then we don't have to search for an appropriate size.
-  int gCode;
-  int sCode;
+  long gCode;
+  long sCode;
   unsigned char *buf;
   buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT);
   gCode = syscall(__NR_sched_getaffinity, 0, KMP_CPU_SET_SIZE_LIMIT, buf);
   KA_TRACE(30, ("__kmp_affinity_determine_capable: "
-                "initial getaffinity call returned %d errno = %d\n",
+                "initial getaffinity call returned %ld errno = %d\n",
                 gCode, errno));
 
   // if ((gCode < 0) && (errno == ENOSYS))
   if (gCode < 0) {
     // System call not supported
     if (__kmp_affinity_verbose ||
         (__kmp_affinity_warnings && (__kmp_affinity_type != affinity_none) &&
          (__kmp_affinity_type != affinity_default) &&
#if KMP_OS_LINUX
   }
   if (gCode > 0) { // Linux* OS only
     // The optimal situation: the OS returns the size of the buffer it expects.
     //
     // A verification of correct behavior is that setaffinity on a NULL
     // buffer with the same size fails with errno set to EFAULT.
     sCode = syscall(__NR_sched_setaffinity, 0, gCode, NULL);
     KA_TRACE(30, ("__kmp_affinity_determine_capable: "
-                  "setaffinity for mask size %d returned %d errno = %d\n",
+                  "setaffinity for mask size %ld returned %ld errno = %d\n",
                   gCode, sCode, errno));
     if (sCode < 0) {
       if (errno == ENOSYS) {
         if (__kmp_affinity_verbose ||
             (__kmp_affinity_warnings &&
              (__kmp_affinity_type != affinity_none) &&
              (__kmp_affinity_type != affinity_default) &&
              (__kmp_affinity_type != affinity_disabled))) {
#if KMP_OS_LINUX
   // Call the getaffinity system call repeatedly with increasing set sizes
   // until we succeed, or reach an upper bound on the search.
   KA_TRACE(30, ("__kmp_affinity_determine_capable: "
                 "searching for proper set size\n"));
   int size;
   for (size = 1; size <= KMP_CPU_SET_SIZE_LIMIT; size *= 2) {
     gCode = syscall(__NR_sched_getaffinity, 0, size, buf);
     KA_TRACE(30, ("__kmp_affinity_determine_capable: "
-                  "getaffinity for mask size %d returned %d errno = %d\n",
+                  "getaffinity for mask size %ld returned %ld errno = %d\n",
                   size, gCode, errno));
 
     if (gCode < 0) {
       if (errno == ENOSYS) {
         // We shouldn't get here
         KA_TRACE(30, ("__kmp_affinity_determine_capable: "
                       "inconsistent OS call behavior: errno == ENOSYS for mask "
                       "size %d\n",
if (gCode < 0) {
         KMP_INTERNAL_FREE(buf);
         return;
       }
       continue;
     }
 
     sCode = syscall(__NR_sched_setaffinity, 0, gCode, NULL);
     KA_TRACE(30, ("__kmp_affinity_determine_capable: "
-                  "setaffinity for mask size %d returned %d errno = %d\n",
+                  "setaffinity for mask size %ld returned %ld errno = %d\n",
                   gCode, sCode, errno));
     if (sCode < 0) {
       if (errno == ENOSYS) { // Linux* OS only
         // We shouldn't get here
         KA_TRACE(30, ("__kmp_affinity_determine_capable: "
                       "inconsistent OS call behavior: errno == ENOSYS for mask "
                       "size %d\n",
                       size));
if (sCode < 0) {
                       "affinity supported (mask size %d)\n",
                       (int)__kmp_affin_mask_size));
         KMP_INTERNAL_FREE(buf);
         return;
       }
     }
   }
 #elif KMP_OS_FREEBSD
-  int gCode;
+  long gCode;
   unsigned char *buf;
   buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT);
   gCode = pthread_getaffinity_np(pthread_self(), KMP_CPU_SET_SIZE_LIMIT, reinterpret_cast<cpuset_t *>(buf));
   KA_TRACE(30, ("__kmp_affinity_determine_capable: "
                 "initial getaffinity call returned %d errno = %d\n",
                 gCode, errno));
   if (gCode == 0) {
     KMP_AFFINITY_ENABLE(KMP_CPU_SET_SIZE_LIMIT);

 }
 
 #endif // KMP_OS_LINUX && KMP_AFFINITY_SUPPORTED
 
 #if KMP_USE_FUTEX
 
 int __kmp_futex_determine_capable() {
   int loc = 0;
-  int rc = syscall(__NR_futex, &loc, FUTEX_WAKE, 1, NULL, NULL, 0);
+  long rc = syscall(__NR_futex, &loc, FUTEX_WAKE, 1, NULL, NULL, 0);
   int retval = (rc == 0) || (errno != ENOSYS);
 
   KA_TRACE(10,
            ("__kmp_futex_determine_capable: rc = %d errno = %d\n", rc, errno));
   KA_TRACE(10, ("__kmp_futex_determine_capable: futex syscall%s supported\n",
                 retval ? "" : " not"));
 
   return retval;

 }
 
 double __kmp_read_cpu_time(void) {
   /*clock_t   t;*/
   struct tms buffer;
 
   /*t =*/times(&buffer);
 
-  return (buffer.tms_utime + buffer.tms_cutime) / (double)CLOCKS_PER_SEC;
+  return (double)(buffer.tms_utime + buffer.tms_cutime) /
+         (double)CLOCKS_PER_SEC;
 }
 
 int __kmp_read_system_info(struct kmp_sys_info *info) {
   int status;
   struct rusage r_usage;
 
   memset(info, 0, sizeof(*info));
 
void __kmp_read_system_time(double *delta) {
   double t_ns;
   struct timeval tval;
   struct timespec stop;
   int status;
 
   status = gettimeofday(&tval, NULL);
   KMP_CHECK_SYSFAIL_ERRNO("gettimeofday", status);
   TIMEVAL_TO_TIMESPEC(&tval, &stop);
-  t_ns = TS2NS(stop) - TS2NS(__kmp_sys_timer_data.start);
+  t_ns = (double)(TS2NS(stop) - TS2NS(__kmp_sys_timer_data.start));
   *delta = (t_ns * 1e-9);
 }
 
 void __kmp_clear_system_time(void) {
   struct timeval tval;
   int status;
   status = gettimeofday(&tval, NULL);
   KMP_CHECK_SYSFAIL_ERRNO("gettimeofday", status);
   TIMEVAL_TO_TIMESPEC(&tval, &__kmp_sys_timer_data.start);
 }
 
 static int __kmp_get_xproc(void) {
 
   int r = 0;
 
 #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||     \
         KMP_OS_OPENBSD || KMP_OS_HURD
 
-  r = sysconf(_SC_NPROCESSORS_ONLN);
+  __kmp_type_convert(sysconf(_SC_NPROCESSORS_ONLN), &(r));
 
 #elif KMP_OS_DARWIN
 
   // Bug C77011 High "OpenMP Threads and number of active cores".
 
   // Find the number of available CPUs.
   kern_return_t rc;
   host_basic_info_data_t info;
if (status == 0) { // success?
     __kmp_stksize = rlim.rlim_cur;
     __kmp_check_stksize(&__kmp_stksize); // check value and adjust if needed
   }
 #endif /* KMP_32_BIT_ARCH */
 
   if (sysconf(_SC_THREADS)) {
 
     /* Query the maximum number of threads */
-    __kmp_sys_max_nth = sysconf(_SC_THREAD_THREADS_MAX);
+    __kmp_type_convert(sysconf(_SC_THREAD_THREADS_MAX), &(__kmp_sys_max_nth));
     if (__kmp_sys_max_nth == -1) {
       /* Unlimited threads for NPTL */
       __kmp_sys_max_nth = INT_MAX;
     } else if (__kmp_sys_max_nth <= 1) {
       /* Can't tell, just use PTHREAD_THREADS_MAX */
       __kmp_sys_max_nth = KMP_MAX_NTH;
     }
 
void __kmp_initialize_system_tick() {
   kmp_uint64 delay = 100000; // 50~100 usec on most machines.
   kmp_uint64 nsec = __kmp_now_nsec();
   kmp_uint64 goal = __kmp_hardware_timestamp() + delay;
   while ((now = __kmp_hardware_timestamp()) < goal)
     ;
   nsec2 = __kmp_now_nsec();
   diff = nsec2 - nsec;
   if (diff > 0) {
-    kmp_uint64 tpms = (kmp_uint64)(1e6 * (delay + (now - goal)) / diff);
+    kmp_uint64 tpms = ((kmp_uint64)1e6 * (delay + (now - goal)) / diff);
     if (tpms > 0)
       __kmp_ticks_per_msec = tpms;
   }
 }
 #endif
 
 /* Determine whether the given address is mapped into the current address
    space. */
int __kmp_get_load_balance(int max) {
   int ret_avg = 0;
 
   int res = getloadavg(averages, 3);
 
   // Check __kmp_load_balance_interval to determine which of averages to use.
   // getloadavg() may return the number of samples less than requested that is
   // less than 3.
   if (__kmp_load_balance_interval < 180 && (res >= 1)) {
-    ret_avg = averages[0]; // 1 min
+    ret_avg = (int)averages[0]; // 1 min
   } else if ((__kmp_load_balance_interval >= 180 &&
               __kmp_load_balance_interval < 600) &&
              (res >= 2)) {
-    ret_avg = averages[1]; // 5 min
+    ret_avg = (int)averages[1]; // 5 min
   } else if ((__kmp_load_balance_interval >= 600) && (res == 3)) {
-    ret_avg = averages[2]; // 15 min
+    ret_avg = (int)averages[2]; // 15 min
   } else { // Error occurred
     return -1;
   }
 
   return ret_avg;
 }
 
 #else // Linux* OS
if (proc_entry->d_type == DT_DIR && isdigit(proc_entry->d_name[0])) {
                  parsing may fail (report incorrect thread state).
 
                  Parsing "status" file looks more promissing (due to different
                  file structure and escaping special symbols) but reading and
                  parsing of "status" file works slower.
                   -- ln
               */
               char buffer[65];
-              int len;
+              ssize_t len;
               len = read(stat_file, buffer, sizeof(buffer) - 1);
               if (len >= 0) {
                 buffer[len] = 0;
                 // Using scanf:
                 //     sscanf( buffer, "%*d (%*s) %c ", & state );
                 // looks very nice, but searching for a closing parenthesis
                 // works a bit faster.
                 char *close_parent = strstr(buffer, ") ");