OpenMP RTL cleanup: eliminated warnings with -Wcast-qual

[AndreyChurbanov]

Summary

• Main change is the usage of const_cast and reinterpret_cast instead of C-style type casts.
• A lot of minor formatting changes done by clang-format (used version 3.8.1).
• Changed type of several counters from unsigned to signed, as this is logical and also reduces the amount of needed casts.
• Changed type of 32- and 64-bit bitwise intrinsics parameters from signed to unsigned.

Though the patch is big I tried to not change any functionality, just did the cleanup.
Any comments are welcome.

[lebedev.ri]

Thank you!
I can confirm that with this + D33102, clang can finally fully self-host with no -Wcast-qual warnings.

Do note that i did not review the code!

openmp/trunk/runtime/src/kmp.h

typedef enum kmp_cancel_kind_t {
   cancel_loop = 2,
   cancel_sections = 3,
   cancel_taskgroup = 4
 } kmp_cancel_kind_t;
 #endif // OMP_40_ENABLED
 
 // KMP_HW_SUBSET support:
 typedef struct kmp_hws_item {
-    int num;
-    int offset;
 } kmp_hws_item_t;
 
 extern kmp_hws_item_t __kmp_hws_socket;
 extern kmp_hws_item_t __kmp_hws_node;
 extern kmp_hws_item_t __kmp_hws_tile;
 extern kmp_hws_item_t __kmp_hws_core;
 extern kmp_hws_item_t __kmp_hws_proc;
 extern int __kmp_hws_requested;
struct KMP_ALIGN(32) { // AC: changed 16 to 32 in order to simplify template
     kmp_int32 parm2; //     make no real change at least while padding is off.
     kmp_int32 parm3;
     kmp_int32 parm4;
   };
 
   kmp_uint32 ordered_lower;
   kmp_uint32 ordered_upper;
 #if KMP_OS_WINDOWS
   // This var can be placed in the hole between 'tc' and 'parm1', instead of
   // 'static_steal_counter'. It would be nice to measure execution times.
   // Conditional if/endif can be removed at all.
   kmp_int32 last_upper;
 #endif /* KMP_OS_WINDOWS */
 } dispatch_private_info32_t;
 
 typedef struct KMP_ALIGN_CACHE dispatch_private_info64 {
   kmp_int64 count; // current chunk number for static & static-steal scheduling
   kmp_int64 ub; /* upper-bound */
   /* Adding KMP_ALIGN_CACHE here doesn't help / can hurt performance */
struct KMP_ALIGN(32) {
     kmp_int64 parm2;
     kmp_int64 parm3;
     kmp_int64 parm4;
   };
 
   kmp_uint64 ordered_lower;
   kmp_uint64 ordered_upper;
 #if KMP_OS_WINDOWS
   // This var can be placed in the hole between 'tc' and 'parm1', instead of
   // 'static_steal_counter'. It would be nice to measure execution times.
   // Conditional if/endif can be removed at all.
   kmp_int64 last_upper;
 #endif /* KMP_OS_WINDOWS */
 } dispatch_private_info64_t;
 #else /* KMP_STATIC_STEAL_ENABLED */
 typedef struct KMP_ALIGN_CACHE dispatch_private_info32 {
   kmp_int32 lb;
   kmp_int32 ub;
   kmp_int32 st;

 } kmp_task_t;
 
 /*!
 @}
 */
 
 #if OMP_40_ENABLED
 typedef struct kmp_taskgroup {
-  kmp_uint32 count; // number of allocated and not yet complete tasks
+  kmp_int32 count; // number of allocated and not yet complete tasks
   kmp_int32 cancel_request; // request for cancellation of this taskgroup
   struct kmp_taskgroup *parent; // parent taskgroup
 // TODO: change to OMP_50_ENABLED, need to change build tools for this to work
 #if OMP_45_ENABLED
   // Block of data to perform task reduction
   void *reduce_data; // reduction related info
   kmp_int32 reduce_num_data; // number of data items to reduce
 #endif
struct kmp_taskdata { /* aligned during dynamic allocation       */
   kmp_int32 td_untied_count; /* untied task active parts counter        */
   ident_t *td_ident; /* task identifier                         */
   // Taskwait data.
   ident_t *td_taskwait_ident;
   kmp_uint32 td_taskwait_counter;
   kmp_int32 td_taskwait_thread; /* gtid + 1 of thread encountered taskwait */
   KMP_ALIGN_CACHE kmp_internal_control_t
       td_icvs; /* Internal control variables for the task */
-  KMP_ALIGN_CACHE volatile kmp_uint32
+  KMP_ALIGN_CACHE volatile kmp_int32
       td_allocated_child_tasks; /* Child tasks (+ current task) not yet
                                    deallocated */
-  volatile kmp_uint32
+  volatile kmp_int32
       td_incomplete_child_tasks; /* Child tasks not yet complete */
 #if OMP_40_ENABLED
   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
typedef struct kmp_base_task_team {
   kmp_int32
       tt_max_threads; /* number of entries allocated for threads_data array */
 #if OMP_45_ENABLED
   kmp_int32
       tt_found_proxy_tasks; /* Have we found proxy tasks since last barrier */
 #endif
 
   KMP_ALIGN_CACHE
-  volatile kmp_uint32 tt_unfinished_threads; /* #threads still active      */
+  volatile kmp_int32 tt_unfinished_threads; /* #threads still active      */
 
   KMP_ALIGN_CACHE
   volatile kmp_uint32
       tt_active; /* is the team still actively executing tasks */
 } kmp_base_task_team_t;
 
 union KMP_ALIGN_CACHE kmp_task_team {
   kmp_base_task_team_t tt;

 /* to exist (from the POV of worker threads).                            */
 #if KMP_USE_MONITOR
   int th_team_bt_intervals;
   int th_team_bt_set;
 #else
   kmp_uint64 th_team_bt_intervals;
 #endif
 
-
 #if KMP_AFFINITY_SUPPORTED
   kmp_affin_mask_t *th_affin_mask; /* thread's current affinity mask */
 #endif
 
   /* The data set by the master at reinit, then R/W by the worker */
   KMP_ALIGN_CACHE int
       th_set_nproc; /* if > 0, then only use this request for the next fork */
 #if KMP_NESTED_HOT_TEAMS

 
 // Symbols for MS mutual detection.
 extern int _You_must_link_with_exactly_one_OpenMP_library;
 extern int _You_must_link_with_Intel_OpenMP_library;
 #if KMP_OS_WINDOWS && (KMP_VERSION_MAJOR > 4)
 extern int _You_must_link_with_Microsoft_OpenMP_library;
 #endif
 
-
 // The routines below are not exported.
 // Consider making them 'static' in corresponding source files.
 void kmp_threadprivate_insert_private_data(int gtid, void *pc_addr,
                                            void *data_addr, size_t pc_size);
 struct private_common *kmp_threadprivate_insert(int gtid, void *pc_addr,
                                                 void *data_addr,
                                                 size_t pc_size);
 

openmp/trunk/runtime/src/kmp_affinity.h

bool operator==(const AddrUnsPair &b) const {
     if (second != b.second)
       return false;
     return true;
   }
   bool operator!=(const AddrUnsPair &b) const { return !operator==(b); }
 };
 
 static int __kmp_affinity_cmp_Address_labels(const void *a, const void *b) {
-  const Address *aa = (const Address *)&(((AddrUnsPair *)a)->first);
-  const Address *bb = (const Address *)&(((AddrUnsPair *)b)->first);
+  const Address *aa =
+      (const Address *)&(((AddrUnsPair *)CCAST(void *, a))->first);
+  const Address *bb =
+      (const Address *)&(((AddrUnsPair *)CCAST(void *, b))->first);
   unsigned depth = aa->depth;
   unsigned i;
   KMP_DEBUG_ASSERT(depth == bb->depth);
   for (i = 0; i < depth; i++) {
     if (aa->labels[i] < bb->labels[i])
       return -1;
     if (aa->labels[i] > bb->labels[i])
       return 1;
void init(AddrUnsPair *adr2os, int num_addrs) {
 
     for (kmp_uint32 i = 1; i < depth; ++i)
       skipPerLevel[i] = numPerLevel[i - 1] * skipPerLevel[i - 1];
     // Fill in hierarchy in the case of oversubscription
     for (kmp_uint32 i = depth; i < maxLevels; ++i)
       skipPerLevel[i] = 2 * skipPerLevel[i - 1];
 
     uninitialized = initialized; // One writer
-
   }
 
   // Resize the hierarchy if nproc changes to something larger than before
   void resize(kmp_uint32 nproc) {
     kmp_int8 bool_result = KMP_COMPARE_AND_STORE_ACQ8(&resizing, 0, 1);
     while (bool_result == 0) { // someone else is trying to resize
       KMP_CPU_PAUSE();
       if (nproc <= base_num_threads) // happy with other thread's resize
void resize(kmp_uint32 nproc) {
     }
 
     // Fill in oversubscription levels of hierarchy
     for (kmp_uint32 i = old_maxLevels; i < maxLevels; ++i)
       skipPerLevel[i] = 2 * skipPerLevel[i - 1];
 
     base_num_threads = nproc;
     resizing = 0; // One writer
-
   }
 };
 #endif // KMP_AFFINITY_H

openmp/trunk/runtime/src/kmp_affinity.cpp

static int __kmp_affinity_create_hwloc_map(AddrUnsPair **address2os,
   hwloc_obj_t core;
   hwloc_obj_t socket;
   int nActiveThreads = 0;
   int socket_identifier = 0;
   // re-calculate globals to count only accessible resources
   __kmp_ncores = nPackages = nCoresPerPkg = __kmp_nThreadsPerCore = 0;
   for (socket =
            hwloc_get_obj_by_type(__kmp_hwloc_topology, HWLOC_OBJ_PACKAGE, 0);
-       socket != NULL;
-       socket = hwloc_get_next_obj_by_type(__kmp_hwloc_topology,
-                                           HWLOC_OBJ_PACKAGE, socket),
-         socket_identifier++) {
+       socket != NULL; socket = hwloc_get_next_obj_by_type(
+                           __kmp_hwloc_topology, HWLOC_OBJ_PACKAGE, socket),
     int core_identifier = 0;
     int num_active_cores = 0;
     for (core = hwloc_get_obj_below_by_type(__kmp_hwloc_topology, socket->type,
                                             socket->logical_index,
                                             HWLOC_OBJ_CORE, 0);
          core != NULL &&
          hwloc_get_ancestor_obj_by_type(__kmp_hwloc_topology, socket->type,
                                         core) == socket;
          core = hwloc_get_next_obj_by_type(__kmp_hwloc_topology, HWLOC_OBJ_CORE,
                                            core),
-         core_identifier++) {
       int pu_identifier = 0;
       int num_active_threads = 0;
       for (pu = hwloc_get_obj_below_by_type(__kmp_hwloc_topology, core->type,
                                             core->logical_index, HWLOC_OBJ_PU,
                                             0);
            pu != NULL &&
            hwloc_get_ancestor_obj_by_type(__kmp_hwloc_topology, core->type,
                                           pu) == core;
            pu = hwloc_get_next_obj_by_type(__kmp_hwloc_topology, HWLOC_OBJ_PU,
                                            pu),
-           pu_identifier++) {
         Address addr(3);
-        if(!KMP_CPU_ISSET(pu->os_index, __kmp_affin_fullMask))
+        if (!KMP_CPU_ISSET(pu->os_index, __kmp_affin_fullMask))
           continue; // skip inactive (inaccessible) unit
         KA_TRACE(20,
                  ("Hwloc inserting %d (%d) %d (%d) %d (%d) into address2os\n",
                   socket->os_index, socket->logical_index, core->os_index,
-                  core->logical_index, pu->os_index,pu->logical_index));
+                  core->logical_index, pu->os_index, pu->logical_index));
         addr.labels[0] = socket_identifier; // package
         addr.labels[1] = core_identifier; // core
         addr.labels[2] = pu_identifier; // pu
         retval[nActiveThreads] = AddrUnsPair(addr, pu->os_index);
         __kmp_pu_os_idx[nActiveThreads] =
             pu->os_index; // keep os index for each active pu
         nActiveThreads++;
         ++num_active_threads; // count active threads per core
static int __kmp_affinity_cmp_ProcCpuInfo_os_id(const void *a, const void *b) {
   if (aa[osIdIndex] > bb[osIdIndex])
     return 1;
   return 0;
 };
 
 static int __kmp_affinity_cmp_ProcCpuInfo_phys_id(const void *a,
                                                   const void *b) {
   unsigned i;
-  const unsigned *aa = *((const unsigned **)a);
-  const unsigned *bb = *((const unsigned **)b);
+  const unsigned *aa = *(RCAST(unsigned **, CCAST(void *, a)));
+  const unsigned *bb = *(RCAST(unsigned **, CCAST(void *, b)));
   for (i = maxIndex;; i--) {
     if (aa[i] < bb[i])
       return -1;
     if (aa[i] > bb[i])
       return 1;
     if (i == osIdIndex)
       break;
   }

 #endif /* OMP_40_ENABLED */
 
 #undef ADD_MASK
 #undef ADD_MASK_OSID
 
 #if KMP_USE_HWLOC
 static int __kmp_hwloc_count_children_by_type(hwloc_topology_t t, hwloc_obj_t o,
                                               hwloc_obj_type_t type,
-                                              hwloc_obj_t* f) {
+                                              hwloc_obj_t *f) {
   if (!hwloc_compare_types(o->type, type)) {
     if (*f == NULL)
       *f = o; // output first descendant found
     return 1;
   }
   int sum = 0;
   for (unsigned i = 0; i < o->arity; i++)
     sum += __kmp_hwloc_count_children_by_type(t, o->children[i], type, f);
   return sum; // will be 0 if no one found (as PU arity is 0)
 }
 
 static int __kmp_hwloc_count_children_by_depth(hwloc_topology_t t,
                                                hwloc_obj_t o, unsigned depth,
-                                               hwloc_obj_t* f) {
+                                               hwloc_obj_t *f) {
   if (o->depth == depth) {
     if (*f == NULL)
       *f = o; // output first descendant found
     return 1;
   }
   int sum = 0;
   for (unsigned i = 0; i < o->arity; i++)
     sum += __kmp_hwloc_count_children_by_depth(t, o->children[i], depth, f);
static int __kmp_hwloc_obj_has_PUs(hwloc_topology_t t, hwloc_obj_t o) {
   }
   return 0; // no PUs found
 }
 #endif // KMP_USE_HWLOC
 
 static void __kmp_apply_thread_places(AddrUnsPair **pAddr, int depth) {
   AddrUnsPair *newAddr;
   if (__kmp_hws_requested == 0)
-    goto _exit;   // no topology limiting actions requested, exit
+    goto _exit; // no topology limiting actions requested, exit
 #if KMP_USE_HWLOC
   if (__kmp_affinity_dispatch->get_api_type() == KMPAffinity::HWLOC) {
     // Number of subobjects calculated dynamically, this works fine for
     // any non-uniform topology.
     // L2 cache objects are determined by depth, other objects - by type.
     hwloc_topology_t tp = __kmp_hwloc_topology;
-    int nS=0, nN=0, nL=0, nC=0, nT=0; // logical index including skipped
-    int nCr=0, nTr=0; // number of requested units
-    int nPkg=0, nCo=0, n_new=0, n_old = 0, nCpP=0, nTpC=0; // counters
+    int nS = 0, nN = 0, nL = 0, nC = 0,
+        nT = 0; // logical index including skipped
+    int nCr = 0, nTr = 0; // number of requested units
+    int nPkg = 0, nCo = 0, n_new = 0, n_old = 0, nCpP = 0, nTpC = 0; // counters
     hwloc_obj_t hT, hC, hL, hN, hS; // hwloc objects (pointers to)
     int L2depth, idx;
 
     // check support of extensions ----------------------------------
     int numa_support = 0, tile_support = 0;
     if (__kmp_pu_os_idx)
       hT = hwloc_get_pu_obj_by_os_index(tp,
                                         __kmp_pu_os_idx[__kmp_avail_proc - 1]);
if (__kmp_affinity_dispatch->get_api_type() == KMPAffinity::HWLOC) {
     } else if (__kmp_hws_node.num > 0) {
       // don't support sockets inside NUMA node (no such HW found for testing)
       KMP_WARNING(AffHWSubsetUnsupported);
       goto _exit;
     }
     // check L2 cahce, get object by depth because of multiple caches
     L2depth = hwloc_get_cache_type_depth(tp, 2, HWLOC_OBJ_CACHE_UNIFIED);
     hL = hwloc_get_ancestor_obj_by_depth(tp, L2depth, hT);
-    if (hL != NULL && __kmp_hwloc_count_children_by_type(tp, hL, HWLOC_OBJ_CORE,
-                                                         &hC) > 1) {
+    if (hL != NULL &&
+        __kmp_hwloc_count_children_by_type(tp, hL, HWLOC_OBJ_CORE, &hC) > 1) {
       tile_support = 1; // no sense to count L2 if it includes single core
     } else if (__kmp_hws_tile.num > 0) {
       if (__kmp_hws_core.num == 0) {
         __kmp_hws_core = __kmp_hws_tile; // replace L2 with core
         __kmp_hws_tile.num = 0;
       } else {
         // L2 and core are both requested, but represent same object
         KMP_WARNING(AffHWSubsetInvalid);
         goto _exit;
       }
     }
     // end of check of extensions -----------------------------------
 
     // fill in unset items, validate settings -----------------------
     if (__kmp_hws_socket.num == 0)
-      __kmp_hws_socket.num = nPackages;    // use all available sockets
+      __kmp_hws_socket.num = nPackages; // use all available sockets
     if (__kmp_hws_socket.offset >= nPackages) {
       KMP_WARNING(AffHWSubsetManySockets);
       goto _exit;
     }
     if (numa_support) {
       int NN = __kmp_hwloc_count_children_by_type(tp, hS, HWLOC_OBJ_NUMANODE,
                                                   &hN); // num nodes in socket
       if (__kmp_hws_node.num == 0)
if (numa_support) {
         } // use all available tiles, some node may have more tiles, thus +1
         if (__kmp_hws_tile.offset >= NL) {
           KMP_WARNING(AffHWSubsetManyTiles);
           goto _exit;
         }
         int NC = __kmp_hwloc_count_children_by_type(tp, hL, HWLOC_OBJ_CORE,
                                                     &hC); // num cores in tile
         if (__kmp_hws_core.num == 0)
-          __kmp_hws_core.num = NC;   // use all available cores
+          __kmp_hws_core.num = NC; // use all available cores
         if (__kmp_hws_core.offset >= NC) {
           KMP_WARNING(AffHWSubsetManyCores);
           goto _exit;
         }
       } else { // tile_support
         int NC = __kmp_hwloc_count_children_by_type(tp, hN, HWLOC_OBJ_CORE,
                                                     &hC); // num cores in node
         if (__kmp_hws_core.num == 0)
-          __kmp_hws_core.num = NC;   // use all available cores
+          __kmp_hws_core.num = NC; // use all available cores
         if (__kmp_hws_core.offset >= NC) {
           KMP_WARNING(AffHWSubsetManyCores);
           goto _exit;
         }
       } // tile_support
     } else { // numa_support
       if (tile_support) {
         // get num tiles in socket
         int NL = __kmp_hwloc_count_children_by_depth(tp, hS, L2depth, &hL);
         if (__kmp_hws_tile.num == 0)
           __kmp_hws_tile.num = NL; // use all available tiles
         if (__kmp_hws_tile.offset >= NL) {
           KMP_WARNING(AffHWSubsetManyTiles);
           goto _exit;
         }
         int NC = __kmp_hwloc_count_children_by_type(tp, hL, HWLOC_OBJ_CORE,
                                                     &hC); // num cores in tile
         if (__kmp_hws_core.num == 0)
-          __kmp_hws_core.num = NC;   // use all available cores
+          __kmp_hws_core.num = NC; // use all available cores
         if (__kmp_hws_core.offset >= NC) {
           KMP_WARNING(AffHWSubsetManyCores);
           goto _exit;
         }
       } else { // tile_support
         int NC = __kmp_hwloc_count_children_by_type(tp, hS, HWLOC_OBJ_CORE,
                                                     &hC); // num cores in socket
         if (__kmp_hws_core.num == 0)
-          __kmp_hws_core.num = NC;   // use all available cores
+          __kmp_hws_core.num = NC; // use all available cores
         if (__kmp_hws_core.offset >= NC) {
           KMP_WARNING(AffHWSubsetManyCores);
           goto _exit;
         }
       } // tile_support
     }
     if (__kmp_hws_proc.num == 0)
       __kmp_hws_proc.num = __kmp_nThreadsPerCore; // use all available procs
for (int s = 0; s < NP; ++s) {
       }
       nCr = 0; // count number of cores per socket
       // socket requested, go down the topology tree
       // check 4 cases: (+NUMA+Tile), (+NUMA-Tile), (-NUMA+Tile), (-NUMA-Tile)
       if (numa_support) {
         nN = 0;
         hN = NULL;
         // num nodes in current socket
-        int NN = __kmp_hwloc_count_children_by_type(tp, hS, HWLOC_OBJ_NUMANODE,
-                                                    &hN);
+        int NN =
+            __kmp_hwloc_count_children_by_type(tp, hS, HWLOC_OBJ_NUMANODE, &hN);
         for (int n = 0; n < NN; ++n) {
           // Check NUMA Node ----------------------------------------
           if (!__kmp_hwloc_obj_has_PUs(tp, hN)) {
             hN = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_NUMANODE, hN);
             continue; // skip node if all PUs are out of fullMask
           }
           ++nN;
           if (nN <= __kmp_hws_node.offset ||
for (int s = 0; s < NP; ++s) {
               } // cores loop
               hL = hwloc_get_next_obj_by_depth(tp, L2depth, hL);
             } // tiles loop
           } else { // tile_support
             // no tiles, check cores
             nC = 0;
             hC = NULL;
             // num cores in current node
-            int NC = __kmp_hwloc_count_children_by_type(tp, hN, HWLOC_OBJ_CORE,
-                                                        &hC);
+            int NC =
+                __kmp_hwloc_count_children_by_type(tp, hN, HWLOC_OBJ_CORE, &hC);
             for (int c = 0; c < NC; ++c) {
               // Check Core ---------------------------------------
               if (!__kmp_hwloc_obj_has_PUs(tp, hC)) {
                 hC = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_CORE, hC);
                 continue; // skip core if all PUs are out of fullMask
               }
               ++nC;
               if (nC <= __kmp_hws_core.offset ||
                   nC > __kmp_hws_core.num + __kmp_hws_core.offset) {
                 // skip node as not requested
                 n_old += __kmp_hwloc_skip_PUs_obj(tp, hC); // skip core
                 hC = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_CORE, hC);
                 continue; // move to next node
               }
               // core requested, go down to PUs
               nT = 0;
               nTr = 0;
               hT = NULL;
-              int NT = __kmp_hwloc_count_children_by_type(tp, hC, HWLOC_OBJ_PU,
-                                                          &hT);
+              int NT =
+                  __kmp_hwloc_count_children_by_type(tp, hC, HWLOC_OBJ_PU, &hT);
               for (int t = 0; t < NT; ++t) {
                 // Check PU ---------------------------------------
                 idx = hT->os_index;
                 if (!KMP_CPU_ISSET(idx, __kmp_affin_fullMask)) {
                   hT = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_PU, hT);
                   continue; // skip PU if not in fullMask
                 }
                 ++nT;
for (int s = 0; s < NP; ++s) {
               n_old += __kmp_hwloc_skip_PUs_obj(tp, hL); // skip tile
               hL = hwloc_get_next_obj_by_depth(tp, L2depth, hL);
               continue; // move to next tile
             }
             // tile requested, go down the topology tree
             nC = 0;
             hC = NULL;
             // num cores per tile
-            int NC = __kmp_hwloc_count_children_by_type(tp, hL, HWLOC_OBJ_CORE,
-                                                        &hC);
+            int NC =
+                __kmp_hwloc_count_children_by_type(tp, hL, HWLOC_OBJ_CORE, &hC);
             for (int c = 0; c < NC; ++c) {
               // Check Core ---------------------------------------
               if (!__kmp_hwloc_obj_has_PUs(tp, hC)) {
                 hC = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_CORE, hC);
                 continue; // skip core if all PUs are out of fullMask
               }
               ++nC;
               if (nC <= __kmp_hws_core.offset ||
                   nC > __kmp_hws_core.num + __kmp_hws_core.offset) {
                 // skip node as not requested
                 n_old += __kmp_hwloc_skip_PUs_obj(tp, hC); // skip core
                 hC = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_CORE, hC);
                 continue; // move to next node
               }
               // core requested, go down to PUs
               nT = 0;
               nTr = 0;
               hT = NULL;
               // num procs per core
-              int NT = __kmp_hwloc_count_children_by_type(tp, hC, HWLOC_OBJ_PU,
-                                                          &hT);
+              int NT =
+                  __kmp_hwloc_count_children_by_type(tp, hC, HWLOC_OBJ_PU, &hT);
               for (int t = 0; t < NT; ++t) {
                 // Check PU ---------------------------------------
                 idx = hT->os_index;
                 if (!KMP_CPU_ISSET(idx, __kmp_affin_fullMask)) {
                   hT = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_PU, hT);
                   continue; // skip PU if not in fullMask
                 }
                 ++nT;
for (int s = 0; s < NP; ++s) {
             } // cores loop
             hL = hwloc_get_next_obj_by_depth(tp, L2depth, hL);
           } // tiles loop
         } else { // tile_support
           // no tiles, check cores
           nC = 0;
           hC = NULL;
           // num cores in socket
-          int NC = __kmp_hwloc_count_children_by_type(tp, hS, HWLOC_OBJ_CORE,
-                                                      &hC);
+          int NC =
+              __kmp_hwloc_count_children_by_type(tp, hS, HWLOC_OBJ_CORE, &hC);
           for (int c = 0; c < NC; ++c) {
             // Check Core -------------------------------------------
             if (!__kmp_hwloc_obj_has_PUs(tp, hC)) {
               hC = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_CORE, hC);
               continue; // skip core if all PUs are out of fullMask
             }
             ++nC;
             if (nC <= __kmp_hws_core.offset ||
                 nC > __kmp_hws_core.num + __kmp_hws_core.offset) {
               // skip node as not requested
               n_old += __kmp_hwloc_skip_PUs_obj(tp, hC); // skip core
               hC = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_CORE, hC);
               continue; // move to next node
             }
             // core requested, go down to PUs
             nT = 0;
             nTr = 0;
             hT = NULL;
             // num procs per core
-            int NT = __kmp_hwloc_count_children_by_type(tp, hC, HWLOC_OBJ_PU,
-                                                        &hT);
+            int NT =
+                __kmp_hwloc_count_children_by_type(tp, hC, HWLOC_OBJ_PU, &hT);
             for (int t = 0; t < NT; ++t) {
               // Check PU ---------------------------------------
               idx = hT->os_index;
               if (!KMP_CPU_ISSET(idx, __kmp_affin_fullMask)) {
                 hT = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_PU, hT);
                 continue; // skip PU if not in fullMask
               }
               ++nT;
if (__kmp_affinity_dispatch->get_api_type() == KMPAffinity::HWLOC) {
     KMP_DEBUG_ASSERT(nCpP > 0);
     KMP_DEBUG_ASSERT(nTpC > 0);
     KMP_DEBUG_ASSERT(nCo > 0);
     KMP_DEBUG_ASSERT(nPkg <= nPackages);
     KMP_DEBUG_ASSERT(nCpP <= nCoresPerPkg);
     KMP_DEBUG_ASSERT(nTpC <= __kmp_nThreadsPerCore);
     KMP_DEBUG_ASSERT(nCo <= __kmp_ncores);
 
-    nPackages = nPkg;             // correct num sockets
-    nCoresPerPkg = nCpP;          // correct num cores per socket
+    nPackages = nPkg; // correct num sockets
+    nCoresPerPkg = nCpP; // correct num cores per socket
     __kmp_nThreadsPerCore = nTpC; // correct num threads per core
-    __kmp_avail_proc = n_new;     // correct num procs
-    __kmp_ncores = nCo;           // correct num cores
+    __kmp_avail_proc = n_new; // correct num procs
+    __kmp_ncores = nCo; // correct num cores
     // hwloc topology method end
   } else
 #endif // KMP_USE_HWLOC
   {
     int n_old = 0, n_new = 0, proc_num = 0;
     if (__kmp_hws_node.num > 0 || __kmp_hws_tile.num > 0) {
       KMP_WARNING(AffHWSubsetNoHWLOC);
       goto _exit;
     }
     if (__kmp_hws_socket.num == 0)
-      __kmp_hws_socket.num = nPackages;    // use all available sockets
+      __kmp_hws_socket.num = nPackages; // use all available sockets
     if (__kmp_hws_core.num == 0)
-      __kmp_hws_core.num = nCoresPerPkg;   // use all available cores
-    if (__kmp_hws_proc.num == 0 ||
-        __kmp_hws_proc.num > __kmp_nThreadsPerCore)
+      __kmp_hws_core.num = nCoresPerPkg; // use all available cores
+    if (__kmp_hws_proc.num == 0 || __kmp_hws_proc.num > __kmp_nThreadsPerCore)
       __kmp_hws_proc.num = __kmp_nThreadsPerCore; // use all HW contexts
-    if ( !__kmp_affinity_uniform_topology() ) {
-      KMP_WARNING( AffHWSubsetNonUniform );
+    if (!__kmp_affinity_uniform_topology()) {
+      KMP_WARNING(AffHWSubsetNonUniform);
       goto _exit; // don't support non-uniform topology
     }
-    if ( depth > 3 ) {
-      KMP_WARNING( AffHWSubsetNonThreeLevel );
+    if (depth > 3) {
+      KMP_WARNING(AffHWSubsetNonThreeLevel);
       goto _exit; // don't support not-3-level topology
     }
     if (__kmp_hws_socket.offset + __kmp_hws_socket.num > nPackages) {
       KMP_WARNING(AffHWSubsetManySockets);
       goto _exit;
     }
-    if ( __kmp_hws_core.offset + __kmp_hws_core.num > nCoresPerPkg ) {
-      KMP_WARNING( AffHWSubsetManyCores );
+    if (__kmp_hws_core.offset + __kmp_hws_core.num > nCoresPerPkg) {
+      KMP_WARNING(AffHWSubsetManyCores);
       goto _exit;
     }
     // Form the requested subset
     if (pAddr) // pAddr is NULL in case of affinity_none
-      newAddr = (AddrUnsPair *)__kmp_allocate(sizeof(AddrUnsPair) *
-                                              __kmp_hws_socket.num *
-                                              __kmp_hws_core.num *
-                                              __kmp_hws_proc.num);
+      newAddr = (AddrUnsPair *)__kmp_allocate(
+          sizeof(AddrUnsPair) * __kmp_hws_socket.num * __kmp_hws_core.num *
     for (int i = 0; i < nPackages; ++i) {
       if (i < __kmp_hws_socket.offset ||
           i >= __kmp_hws_socket.offset + __kmp_hws_socket.num) {
         // skip not-requested socket
         n_old += nCoresPerPkg * __kmp_nThreadsPerCore;
         if (__kmp_pu_os_idx != NULL) {
           // walk through skipped socket
           for (int j = 0; j < nCoresPerPkg; ++j) {
             for (int k = 0; k < __kmp_nThreadsPerCore; ++k) {
               KMP_CPU_CLR(__kmp_pu_os_idx[proc_num], __kmp_affin_fullMask);
               ++proc_num;
             }
           }
         }
       } else {
         // walk through requested socket
         for (int j = 0; j < nCoresPerPkg; ++j) {
           if (j < __kmp_hws_core.offset ||
-              j >= __kmp_hws_core.offset + __kmp_hws_core.num)
-            { // skip not-requested core
-              n_old += __kmp_nThreadsPerCore;
-              if (__kmp_pu_os_idx != NULL) {
-                for (int k = 0; k < __kmp_nThreadsPerCore; ++k) {
-                  KMP_CPU_CLR(__kmp_pu_os_idx[proc_num], __kmp_affin_fullMask);
-                  ++proc_num;
-                }
-              }
-            } else {
+              j >= __kmp_hws_core.offset +
+                       __kmp_hws_core.num) { // skip not-requested core
             // walk through requested core
             for (int k = 0; k < __kmp_nThreadsPerCore; ++k) {
               if (k < __kmp_hws_proc.num) {
                 if (pAddr) // collect requested thread's data
                   newAddr[n_new] = (*pAddr)[n_old];
                 n_new++;
               } else {
                 if (__kmp_pu_os_idx != NULL)
                   KMP_CPU_CLR(__kmp_pu_os_idx[proc_num], __kmp_affin_fullMask);
               }
               n_old++;
               ++proc_num;
             }
           }
         }
       }
     }
     KMP_DEBUG_ASSERT(n_old == nPackages * nCoresPerPkg * __kmp_nThreadsPerCore);
-    KMP_DEBUG_ASSERT(n_new == __kmp_hws_socket.num * __kmp_hws_core.num *
+    KMP_DEBUG_ASSERT(n_new ==
+                     __kmp_hws_socket.num * __kmp_hws_core.num *
                          __kmp_hws_proc.num);
-    nPackages = __kmp_hws_socket.num;           // correct nPackages
-    nCoresPerPkg = __kmp_hws_core.num;          // correct nCoresPerPkg
+    nPackages = __kmp_hws_socket.num; // correct nPackages
+    nCoresPerPkg = __kmp_hws_core.num; // correct nCoresPerPkg
     __kmp_nThreadsPerCore = __kmp_hws_proc.num; // correct __kmp_nThreadsPerCore
-    __kmp_avail_proc = n_new;                   // correct avail_proc
+    __kmp_avail_proc = n_new; // correct avail_proc
     __kmp_ncores = nPackages * __kmp_hws_core.num; // correct ncores
   } // non-hwloc topology method
   if (pAddr) {
-    __kmp_free( *pAddr );
-    *pAddr = newAddr;      // replace old topology with new one
+    __kmp_free(*pAddr);
+    *pAddr = newAddr; // replace old topology with new one
   }
   if (__kmp_affinity_verbose) {
     char m[KMP_AFFIN_MASK_PRINT_LEN];
-    __kmp_affinity_print_mask(m,KMP_AFFIN_MASK_PRINT_LEN,__kmp_affin_fullMask);
+    __kmp_affinity_print_mask(m, KMP_AFFIN_MASK_PRINT_LEN,
+                              __kmp_affin_fullMask);
     if (__kmp_affinity_respect_mask) {
       KMP_INFORM(InitOSProcSetRespect, "KMP_HW_SUBSET", m);
     } else {
       KMP_INFORM(InitOSProcSetNotRespect, "KMP_HW_SUBSET", m);
     }
     KMP_INFORM(AvailableOSProc, "KMP_HW_SUBSET", __kmp_avail_proc);
     kmp_str_buf_t buf;
     __kmp_str_buf_init(&buf);
     __kmp_str_buf_print(&buf, "%d", nPackages);
     KMP_INFORM(TopologyExtra, "KMP_HW_SUBSET", buf.str, nCoresPerPkg,
                __kmp_nThreadsPerCore, __kmp_ncores);
     __kmp_str_buf_free(&buf);
   }
- _exit:
   if (__kmp_pu_os_idx != NULL) {
     __kmp_free(__kmp_pu_os_idx);
     __kmp_pu_os_idx = NULL;
   }
 }
 
 // This function figures out the deepest level at which there is at least one
 // cluster/core with more than one processing unit bound to it.
static int __kmp_affinity_compute_ncores(const AddrUnsPair *address2os,
   }
   return ncores;
 }
 
 // This function finds to which cluster/core given processing unit is bound.
 static int __kmp_affinity_find_core(const AddrUnsPair *address2os, int proc,
                                     int bottom_level, int core_level) {
   return __kmp_affinity_compute_ncores(address2os, proc + 1, bottom_level,
-                                       core_level) - 1;
+                                       core_level) -
+         1;
 }
 
 // This function finds maximal number of processing units bound to a
 // cluster/core at given level.
 static int __kmp_affinity_max_proc_per_core(const AddrUnsPair *address2os,
                                             int nprocs, int bottom_level,
                                             int core_level) {
   int maxprocpercore = 0;

 
 #define KMP_EXIT_AFF_NONE                                                      \
   KMP_ASSERT(__kmp_affinity_type == affinity_none);                            \
   KMP_ASSERT(address2os == NULL);                                              \
   __kmp_apply_thread_places(NULL, 0);                                          \
   return;
 
 static int __kmp_affinity_cmp_Address_child_num(const void *a, const void *b) {
-  const Address *aa = (const Address *)&(((AddrUnsPair *)a)->first);
-  const Address *bb = (const Address *)&(((AddrUnsPair *)b)->first);
+  const Address *aa =
+      (const Address *)&(((AddrUnsPair *)CCAST(void *, a))->first);
+  const Address *bb =
+      (const Address *)&(((AddrUnsPair *)CCAST(void *, b))->first);
   unsigned depth = aa->depth;
   unsigned i;
   KMP_DEBUG_ASSERT(depth == bb->depth);
   KMP_DEBUG_ASSERT((unsigned)__kmp_affinity_compact <= depth);
   KMP_DEBUG_ASSERT(__kmp_affinity_compact >= 0);
   for (i = 0; i < (unsigned)__kmp_affinity_compact; i++) {
     int j = depth - i - 1;
     if (aa->childNums[j] < bb->childNums[j])

openmp/trunk/runtime/src/kmp_alloc.cpp

 /* Walk the free list and release the enqueued buffers */
 static void __kmp_bget_dequeue(kmp_info_t *th) {
   void *p = TCR_SYNC_PTR(th->th.th_local.bget_list);
 
   if (p != 0) {
 #if USE_CMP_XCHG_FOR_BGET
     {
       volatile void *old_value = TCR_SYNC_PTR(th->th.th_local.bget_list);
-      while (!KMP_COMPARE_AND_STORE_PTR(&th->th.th_local.bget_list, old_value,
-                                        NULL)) {
+      while (!KMP_COMPARE_AND_STORE_PTR(&th->th.th_local.bget_list,
+                                        CCAST(void *, old_value), NULL)) {
         KMP_CPU_PAUSE();
         old_value = TCR_SYNC_PTR(th->th.th_local.bget_list);
       }
-      p = (void *)old_value;
+      p = CCAST(void *, old_value);
     }
 #else /* ! USE_CMP_XCHG_FOR_BGET */
 #ifdef USE_QUEUING_LOCK_FOR_BGET
     __kmp_acquire_lock(&th->th.th_local.bget_lock, __kmp_gtid_from_thread(th));
 #else
     __kmp_acquire_bootstrap_lock(&th->th.th_local.bget_lock);
 #endif /* USE_QUEUING_LOCK_FOR_BGET */
 
#endif
   KC_TRACE(10, ("__kmp_bget_enqueue: moving buffer to T#%d list\n",
                 __kmp_gtid_from_thread(th)));
 
 #if USE_CMP_XCHG_FOR_BGET
   {
     volatile void *old_value = TCR_PTR(th->th.th_local.bget_list);
     /* the next pointer must be set before setting bget_list to buf to avoid
        exposing a broken list to other threads, even for an instant. */
-    b->ql.flink = BFH(old_value);
+    b->ql.flink = BFH(CCAST(void *, old_value));
 
-    while (!KMP_COMPARE_AND_STORE_PTR(&th->th.th_local.bget_list, old_value,
-                                      buf)) {
+    while (!KMP_COMPARE_AND_STORE_PTR(&th->th.th_local.bget_list,
+                                      CCAST(void *, old_value), buf)) {
       KMP_CPU_PAUSE();
       old_value = TCR_PTR(th->th.th_local.bget_list);
       /* the next pointer must be set before setting bget_list to buf to avoid
          exposing a broken list to other threads, even for an instant. */
-      b->ql.flink = BFH(old_value);
+      b->ql.flink = BFH(CCAST(void *, old_value));
     }
   }
 #else /* ! USE_CMP_XCHG_FOR_BGET */
 #ifdef USE_QUEUING_LOCK_FOR_BGET
   __kmp_acquire_lock(&th->th.th_local.bget_lock, rel_gtid);
 #else
   __kmp_acquire_bootstrap_lock(&th->th.th_local.bget_lock);
 #endif
#endif
   }
 
   /* No buffer available with requested size free. */
 
   /* Don't give up yet -- look in the reserve supply. */
   if (thr->acqfcn != 0) {
     if (size > (bufsize)(thr->exp_incr - sizeof(bhead_t))) {
       /* Request is too large to fit in a single expansion block.
-   Try to satisy it by a direct buffer acquisition. */
+         Try to satisy it by a direct buffer acquisition. */
       bdhead_t *bdh;
 
       size += sizeof(bdhead_t) - sizeof(bhead_t);
 
       KE_TRACE(10, ("%%%%%% MALLOC( %d )\n", (int)size));
 
       /* richryan */
       bdh = BDH((*thr->acqfcn)((bufsize)size));

openmp/trunk/runtime/src/kmp_barrier.cpp

if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
                            child_tid));
             ANNOTATE_BARRIER_END(other_threads[child_tid]);
             (*reduce)(this_thr->th.th_local.reduce_data,
                       other_threads[child_tid]->th.th_local.reduce_data);
           }
           ANNOTATE_REDUCE_BEFORE(reduce);
           ANNOTATE_REDUCE_BEFORE(&team->t.t_bar);
         }
-        (void)KMP_TEST_THEN_AND64(
-            (volatile kmp_int64 *)&thr_bar->b_arrived,
-            ~(thr_bar->leaf_state)); // clear leaf_state bits
+        // clear leaf_state bits
+        KMP_TEST_THEN_AND64(CCAST(kmp_uint64 *, &thr_bar->b_arrived),
+                            ~(thr_bar->leaf_state));
       }
       // Next, wait for higher level children on each child's b_arrived flag
       for (kmp_uint32 d = 1; d < thr_bar->my_level;
            ++d) { // gather lowest level threads first, but skip 0
         kmp_uint32 last = tid + thr_bar->skip_per_level[d + 1],
                    skip = thr_bar->skip_per_level[d];
         if (last > nproc)
           last = nproc;
if (!thr_bar->use_oncore_barrier ||
                            thr_bar->offset, bt,
                            this_thr USE_ITT_BUILD_ARG(itt_sync_obj));
       flag.wait(this_thr, TRUE);
       if (thr_bar->wait_flag ==
           KMP_BARRIER_SWITCHING) { // Thread was switched to own b_go
         TCW_8(thr_bar->b_go,
               KMP_INIT_BARRIER_STATE); // Reset my b_go flag for next time
       } else { // Reset my bits on parent's b_go flag
-        ((char *)&(thr_bar->parent_bar->b_go))[thr_bar->offset] = 0;
+        (RCAST(volatile char *,
+               &(thr_bar->parent_bar->b_go)))[thr_bar->offset] = 0;
       }
     }
     thr_bar->wait_flag = KMP_BARRIER_NOT_WAITING;
     // Early exit for reaping threads releasing forkjoin barrier
     if (bt == bs_forkjoin_barrier && TCR_4(__kmp_global.g.g_done))
       return;
     // The worker thread may now assume that the team is valid.
     team = __kmp_threads[gtid]->th.th_team;
if (propagate_icvs && !KMP_MASTER_TID(tid))
                 &thr_bar->th_fixed_icvs);
 #endif // KMP_BARRIER_ICV_PUSH
   }
   KA_TRACE(20, ("__kmp_hierarchical_barrier_release: T#%d(%d:%d) exit for "
                 "barrier type %d\n",
                 gtid, team->t.t_id, tid, bt));
 }
 
-
 // End of Barrier Algorithms
 
 // Internal function to do a barrier.
 /* If is_split is true, do a split barrier, otherwise, do a plain barrier
    If reduce is non-NULL, do a split reduction barrier, otherwise, do a split
    barrier
    Returns 0 if master thread, 1 if worker thread.  */
 int __kmp_barrier(enum barrier_type bt, int gtid, int is_split,
#endif /* USE_DEBUGGER */
     }
     }
 
     KMP_MB();
 
     if (KMP_MASTER_TID(tid)) {
       status = 0;
       if (__kmp_tasking_mode != tskm_immediate_exec) {
-          __kmp_task_team_wait(this_thr, team USE_ITT_BUILD_ARG(itt_sync_obj));
       }
 #if USE_DEBUGGER
       // Let the debugger know: All threads are arrived and starting leaving the
       // barrier.
       team->t.t_bar[bt].b_team_arrived += 1;
 #endif
 
 #if OMP_40_ENABLED

openmp/trunk/runtime/src/kmp_csupport.cpp

for (j = 1; j < num_dims; ++j) {
     trace_count *= pr_buf->th_doacross_info[4 * j + 1]; // use kept ranges
   }
   KMP_DEBUG_ASSERT(trace_count > 0);
 
   // Check if shared buffer is not occupied by other loop (idx -
   // __kmp_dispatch_num_buffers)
   if (idx != sh_buf->doacross_buf_idx) {
     // Shared buffer is occupied, wait for it to be free
-    __kmp_wait_yield_4((kmp_uint32 *)&sh_buf->doacross_buf_idx, idx, __kmp_eq_4,
-                       NULL);
+    __kmp_wait_yield_4((volatile kmp_uint32 *)&sh_buf->doacross_buf_idx, idx,
+                       __kmp_eq_4, NULL);
   }
   // Check if we are the first thread. After the CAS the first thread gets 0,
   // others get 1 if initialization is in progress, allocated pointer otherwise.
   flags = (kmp_uint32 *)KMP_COMPARE_AND_STORE_RET64(
       (kmp_int64 *)&sh_buf->doacross_flags, NULL, (kmp_int64)1);
   if (flags == NULL) {
     // we are the first thread, allocate the array of flags
     kmp_int64 size =
if (st == 1) {
       iter = (kmp_uint64)(lo - vec[i]) / (-st);
     }
     iter_number = iter + ln * iter_number;
   }
   shft = iter_number % 32; // use 32-bit granularity
   iter_number >>= 5; // divided by 32
   flag = 1 << shft;
   if ((flag & pr_buf->th_doacross_flags[iter_number]) == 0)
-    KMP_TEST_THEN_OR32((kmp_int32 *)&pr_buf->th_doacross_flags[iter_number],
-                       (kmp_int32)flag);
+    KMP_TEST_THEN_OR32(
+        CCAST(kmp_uint32 *, &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_int64 num_done;
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
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 == (kmp_int64)sh_buf->doacross_num_done);
     KMP_DEBUG_ASSERT(idx == sh_buf->doacross_buf_idx);
-    __kmp_thread_free(th, (void *)sh_buf->doacross_flags);
+    __kmp_thread_free(th, CCAST(kmp_uint32 *, sh_buf->doacross_flags));
     sh_buf->doacross_flags = NULL;
     sh_buf->doacross_num_done = 0;
     sh_buf->doacross_buf_idx +=
         __kmp_dispatch_num_buffers; // free buffer for future re-use
   }
   // free private resources (need to keep buffer index forever)
   __kmp_thread_free(th, (void *)pr_buf->th_doacross_info);
   pr_buf->th_doacross_info = NULL;
   KA_TRACE(20, ("__kmpc_doacross_fini() exit: T#%d\n", gtid));
 }
 #endif
 
 // end of file //

openmp/trunk/runtime/src/kmp_dispatch.cpp

 
 // test_then_add template (general template should NOT be used)
 template <typename T> static __forceinline T test_then_add(volatile T *p, T d);
 
 template <>
 __forceinline kmp_int32 test_then_add<kmp_int32>(volatile kmp_int32 *p,
                                                  kmp_int32 d) {
   kmp_int32 r;
-  r = KMP_TEST_THEN_ADD32(p, d);
+  r = KMP_TEST_THEN_ADD32(CCAST(kmp_int32 *, p), d);
   return r;
 }
 
 template <>
 __forceinline kmp_int64 test_then_add<kmp_int64>(volatile kmp_int64 *p,
                                                  kmp_int64 d) {
   kmp_int64 r;
-  r = KMP_TEST_THEN_ADD64(p, d);
+  r = KMP_TEST_THEN_ADD64(CCAST(kmp_int64 *, p), d);
   return r;
 }
 
 // test_then_inc_acq template (general template should NOT be used)
 template <typename T> static __forceinline T test_then_inc_acq(volatile T *p);
 
 template <>
 __forceinline kmp_int32 test_then_inc_acq<kmp_int32>(volatile kmp_int32 *p) {
   kmp_int32 r;
-  r = KMP_TEST_THEN_INC_ACQ32(p);
+  r = KMP_TEST_THEN_INC_ACQ32(CCAST(kmp_int32 *, p));
   return r;
 }
 
 template <>
 __forceinline kmp_int64 test_then_inc_acq<kmp_int64>(volatile kmp_int64 *p) {
   kmp_int64 r;
-  r = KMP_TEST_THEN_INC_ACQ64(p);
+  r = KMP_TEST_THEN_INC_ACQ64(CCAST(kmp_int64 *, p));
   return r;
 }
 
 // test_then_inc template (general template should NOT be used)
 template <typename T> static __forceinline T test_then_inc(volatile T *p);
 
 template <>
 __forceinline kmp_int32 test_then_inc<kmp_int32>(volatile kmp_int32 *p) {
   kmp_int32 r;
-  r = KMP_TEST_THEN_INC32(p);
+  r = KMP_TEST_THEN_INC32(CCAST(kmp_int32 *, p));
   return r;
 }
 
 template <>
 __forceinline kmp_int64 test_then_inc<kmp_int64>(volatile kmp_int64 *p) {
   kmp_int64 r;
-  r = KMP_TEST_THEN_INC64(p);
+  r = KMP_TEST_THEN_INC64(CCAST(kmp_int64 *, p));
   return r;
 }
 
 // compare_and_swap template (general template should NOT be used)
 template <typename T>
 static __forceinline kmp_int32 compare_and_swap(volatile T *p, T c, T s);
 
 template <>
__kmp_wait_yield(
         ) {
   // note: we may not belong to a team at this point
   register volatile UT *spin = spinner;
   register UT check = checker;
   register kmp_uint32 spins;
   register kmp_uint32 (*f)(UT, UT) = pred;
   register UT r;
 
-  KMP_FSYNC_SPIN_INIT(obj, (void *)spin);
+  KMP_FSYNC_SPIN_INIT(obj, CCAST(UT *, spin));
   KMP_INIT_YIELD(spins);
   // main wait spin loop
   while (!f(r = *spin, check)) {
     KMP_FSYNC_SPIN_PREPARE(obj);
     /* GEH - remove this since it was accidentally introduced when kmp_wait was
        split. It causes problems with infinite recursion because of exit lock */
     /* if ( TCR_4(__kmp_global.g.g_done) && __kmp_global.g.g_abort)
         __kmp_abort_thread(); */
dispatch_shared_info_template<UT> *sh =
         reinterpret_cast<dispatch_shared_info_template<UT> *>(
             th->th.th_dispatch->th_dispatch_sh_current);
 
     if (!__kmp_env_consistency_check) {
       pr = reinterpret_cast<dispatch_private_info_template<UT> *>(
           th->th.th_dispatch->th_dispatch_pr_current);
     }
 
-    KMP_FSYNC_RELEASING(&sh->u.s.ordered_iteration);
+    KMP_FSYNC_RELEASING(CCAST(UT *, &sh->u.s.ordered_iteration));
 #if !defined(KMP_GOMP_COMPAT)
     if (__kmp_env_consistency_check) {
       if (pr->ordered_bumped != 0) {
         struct cons_header *p = __kmp_threads[gtid]->th.th_cons;
         /* How to test it? - OM */
         __kmp_error_construct2(kmp_i18n_msg_CnsMultipleNesting,
                                ct_ordered_in_pdo, loc_ref,
                                &p->stack_data[p->w_top]);
if (active) {
     // Note: KMP_WAIT_YIELD() cannot be used there: buffer index and
     // my_buffer_index are *always* 32-bit integers.
     KMP_MB(); /* is this necessary? */
     KD_TRACE(100, ("__kmp_dispatch_init: T#%d after wait: my_buffer_index:%d "
                    "sh->buffer_index:%d\n",
                    gtid, my_buffer_index, sh->buffer_index));
 
     th->th.th_dispatch->th_dispatch_pr_current = (dispatch_private_info_t *)pr;
-    th->th.th_dispatch->th_dispatch_sh_current = (dispatch_shared_info_t *)sh;
+    th->th.th_dispatch->th_dispatch_sh_current =
+        RCAST(dispatch_shared_info_t *,
+              CCAST(dispatch_shared_info_template<UT> *, sh));
 #if USE_ITT_BUILD
     if (pr->ordered) {
       __kmp_itt_ordered_init(gtid);
     }; // if
     // Report loop metadata
     if (itt_need_metadata_reporting) {
       // Only report metadata by master of active team at level 1
       kmp_uint64 schedtype = 0;
#endif
             // nothing to do, don't try atomic op
             status = 0;
             break;
           }
           if ((T)remaining <
               pr->u.p.parm2) { // compare with K*nproc*(chunk+1), K=2 by default
             // use dynamic-style shcedule
             // atomically inrement iterations, get old value
-            init = test_then_add<ST>((ST *)&sh->u.s.iteration, (ST)chunkspec);
+            init = test_then_add<ST>(
+                RCAST(ST *, CCAST(UT *, &sh->u.s.iteration)), (ST)chunkspec);
             remaining = trip - init;
             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
                 limit = init + remaining - 1;
               } // if
             } // if
             break;
           } // if
           limit = init + (UT)(remaining *
                               *(double *)&pr->u.p.parm3); // divide by K*nproc
-          if (compare_and_swap<ST>((ST *)&sh->u.s.iteration, (ST)init,
-                                   (ST)limit)) {
+          if (compare_and_swap<ST>(RCAST(ST *, CCAST(UT *, &sh->u.s.iteration)),
+                                   (ST)init, (ST)limit)) {
             // CAS was successful, chunk obtained
             status = 1;
             --limit;
             break;
           } // if
         } // while
         if (status != 0) {
           start = pr->u.p.lb;
#endif
             status = 0; // nothing to do, don't try atomic op
             break;
           }
           KMP_DEBUG_ASSERT(init % chunk == 0);
           // compare with K*nproc*(chunk+1), K=2 by default
           if ((T)remaining < pr->u.p.parm2) {
             // use dynamic-style shcedule
             // atomically inrement iterations, get old value
-            init = test_then_add<ST>((ST *)&sh->u.s.iteration, (ST)chunk);
+            init = test_then_add<ST>(
+                RCAST(ST *, CCAST(UT *, &sh->u.s.iteration)), (ST)chunk);
             remaining = trip - init;
             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
                 limit = init + remaining - 1;
               } // if
             } // if
             break;
           } // if
           // divide by K*nproc
           UT span = remaining * (*(double *)&pr->u.p.parm3);
           UT rem = span % chunk;
           if (rem) // adjust so that span%chunk == 0
             span += chunk - rem;
           limit = init + span;
-          if (compare_and_swap<ST>((ST *)&sh->u.s.iteration, (ST)init,
-                                   (ST)limit)) {
+          if (compare_and_swap<ST>(RCAST(ST *, CCAST(UT *, &sh->u.s.iteration)),
+                                   (ST)init, (ST)limit)) {
             // CAS was successful, chunk obtained
             status = 1;
             --limit;
             break;
           } // if
         } // while
         if (status != 0) {
           start = pr->u.p.lb;
__kmp_wait_yield_4(volatile kmp_uint32 *spinner, kmp_uint32 checker,
                    ) {
   // note: we may not belong to a team at this point
   register volatile kmp_uint32 *spin = spinner;
   register kmp_uint32 check = checker;
   register kmp_uint32 spins;
   register kmp_uint32 (*f)(kmp_uint32, kmp_uint32) = pred;
   register kmp_uint32 r;
 
-  KMP_FSYNC_SPIN_INIT(obj, (void *)spin);
+  KMP_FSYNC_SPIN_INIT(obj, CCAST(kmp_uint32 *, spin));
   KMP_INIT_YIELD(spins);
   // main wait spin loop
   while (!f(r = TCR_4(*spin), check)) {
     KMP_FSYNC_SPIN_PREPARE(obj);
     /* GEH - remove this since it was accidentally introduced when kmp_wait was
        split. It causes problems with infinite recursion because of exit lock */
     /* if ( TCR_4(__kmp_global.g.g_done) && __kmp_global.g.g_abort)
         __kmp_abort_thread(); */

openmp/trunk/runtime/src/kmp_environment.cpp

 
 } // func __kmp_env_get
 
 // TODO: Find and replace all regular free() with __kmp_env_free().
 
 void __kmp_env_free(char const **value) {
 
   KMP_DEBUG_ASSERT(value != NULL);
-  KMP_INTERNAL_FREE((void *)*value);
+  KMP_INTERNAL_FREE(CCAST(char *, *value));
   *value = NULL;
 
 } // func __kmp_env_free
 
 int __kmp_env_exists(char const *name) {
 
 #if KMP_OS_UNIX
   char const *value = getenv(name);
static int ___kmp_env_var_cmp( // Comparison function for qsort().
     kmp_env_var_t const *lhs, kmp_env_var_t const *rhs) {
   return strcmp(lhs->name, rhs->name);
 }
 
 void __kmp_env_blk_sort(
     kmp_env_blk_t *block // M: Block of environment variables to sort.
     ) {
 
-  qsort((void *)block->vars, block->count, sizeof(kmp_env_var_t),
+  qsort(CCAST(kmp_env_var_t *, block->vars), block->count,
+        sizeof(kmp_env_var_t),
         (int (*)(void const *, void const *)) & ___kmp_env_var_cmp);
 
 } // __kmp_env_block_sort
 
 void __kmp_env_blk_free(
     kmp_env_blk_t *block // M: Block of environment variables to free.
     ) {
 
-  KMP_INTERNAL_FREE((void *)block->vars);
+  KMP_INTERNAL_FREE(CCAST(kmp_env_var_t *, block->vars));
   __kmp_str_free(&(block->bulk));
 
   block->count = 0;
   block->vars = NULL;
 
 } // __kmp_env_blk_free
 
 char const * // R: Value of variable or NULL if variable does not exist.

openmp/trunk/runtime/src/kmp_error.cpp

 /* ----------------- END OF STATIC LOCAL ROUTINES ------------------------- */
 
 void __kmp_error_construct(kmp_i18n_id_t id, // Message identifier.
                            enum cons_type ct, // Construct type.
                            ident_t const *ident // Construct ident.
                            ) {
   char const *construct = __kmp_pragma(ct, ident);
   __kmp_msg(kmp_ms_fatal, __kmp_msg_format(id, construct), __kmp_msg_null);
-  KMP_INTERNAL_FREE((void *)construct);
+  KMP_INTERNAL_FREE(CCAST(char *, construct));
 }
 
 void __kmp_error_construct2(kmp_i18n_id_t id, // Message identifier.
                             enum cons_type ct, // First construct type.
                             ident_t const *ident, // First construct ident.
                             struct cons_data const *cons // Second construct.
                             ) {
   char const *construct1 = __kmp_pragma(ct, ident);
   char const *construct2 = __kmp_pragma(cons->type, cons->ident);
   __kmp_msg(kmp_ms_fatal, __kmp_msg_format(id, construct1, construct2),
             __kmp_msg_null);
-  KMP_INTERNAL_FREE((void *)construct1);
-  KMP_INTERNAL_FREE((void *)construct2);
+  KMP_INTERNAL_FREE(CCAST(char *, construct1));
+  KMP_INTERNAL_FREE(CCAST(char *, construct2));
 }
 
 struct cons_header *__kmp_allocate_cons_stack(int gtid) {
   struct cons_header *p;
 
   /* TODO for monitor perhaps? */
   if (gtid < 0) {
     __kmp_check_null_func();

openmp/trunk/runtime/src/kmp_i18n.cpp

if (strcmp(version.str, expected) != 0) {
         // AC: only issue warning in case explicitly asked to
         // And now print a warning using default messages.
         char const *name = "NLSPATH";
         char const *nlspath = __kmp_env_get(name);
         __kmp_msg(kmp_ms_warning,
                   KMP_MSG(WrongMessageCatalog, name, version.str, expected),
                   KMP_HNT(CheckEnvVar, name, nlspath), __kmp_msg_null);
         KMP_INFORM(WillUseDefaultMessages);
-        KMP_INTERNAL_FREE((void *)nlspath);
+        KMP_INTERNAL_FREE(CCAST(char *, nlspath));
       } // __kmp_generate_warnings
     }; // if
     __kmp_str_buf_free(&version);
   }; // if
 } // func __kmp_i18n_do_catopen
 
 void __kmp_i18n_catclose() {
   if (status == KMP_I18N_OPENED) {

openmp/trunk/runtime/src/kmp_itt.inl

if (metadata_domain == NULL) {
     __kmp_release_bootstrap_lock(&metadata_lock);
   }
 
   // Parse line and column from psource string: ";file;func;line;col;;"
   char *s_line;
   char *s_col;
   KMP_DEBUG_ASSERT(loc->psource);
 #ifdef __cplusplus
-  s_line = strchr((char *)loc->psource, ';');
+  s_line = strchr(CCAST(char *, loc->psource), ';');
 #else
   s_line = strchr(loc->psource, ';');
 #endif
   KMP_DEBUG_ASSERT(s_line);
   s_line = strchr(s_line + 1, ';'); // 2-nd semicolon
   KMP_DEBUG_ASSERT(s_line);
   s_line = strchr(s_line + 1, ';'); // 3-rd semicolon
   KMP_DEBUG_ASSERT(s_line);

openmp/trunk/runtime/src/kmp_lock.cpp

if (__kmp_get_ticket_lock_owner(lck) != gtid) {
     KMP_FATAL(LockUnsettingSetByAnother, func);
   }
   return __kmp_release_nested_ticket_lock(lck, gtid);
 }
 
 void __kmp_init_nested_ticket_lock(kmp_ticket_lock_t *lck) {
   __kmp_init_ticket_lock(lck);
   std::atomic_store_explicit(&lck->lk.depth_locked, 0,
-                             std::memory_order_relaxed); // >= 0 for nestable
-                                                         // locks, -1 for simple
-                                                         // locks
+                             std::memory_order_relaxed);
+  // >= 0 for nestable locks, -1 for simple locks
 }
 
 static void __kmp_init_nested_ticket_lock_with_checks(kmp_ticket_lock_t *lck) {
   __kmp_init_nested_ticket_lock(lck);
 }
 
 void __kmp_destroy_nested_ticket_lock(kmp_ticket_lock_t *lck) {
   __kmp_destroy_ticket_lock(lck);
#endif
       if (head == tail) { /* only one thread on the queue */
 #ifdef DEBUG_QUEUING_LOCKS
         if (head <= 0)
           __kmp_dump_queuing_lock(this_thr, gtid, lck, head, tail);
 #endif
         KMP_DEBUG_ASSERT(head > 0);
 
         /* try (h,h)->(-1,0) */
-        dequeued = KMP_COMPARE_AND_STORE_REL64((kmp_int64 *)tail_id_p,
-                                               KMP_PACK_64(head, head),
-                                               KMP_PACK_64(-1, 0));
+        dequeued = KMP_COMPARE_AND_STORE_REL64(
+            RCAST(kmp_int64 *, CCAST(kmp_int32 *, tail_id_p)),
+            KMP_PACK_64(head, head), KMP_PACK_64(-1, 0));
 #ifdef DEBUG_QUEUING_LOCKS
         TRACE_LOCK(gtid + 1, "rel deq: (h,h)->(-1,0)");
 #endif
 
       } else {
         volatile kmp_int32 *waiting_id_p;
         kmp_info_t *head_thr = __kmp_thread_from_gtid(head - 1);
         KMP_DEBUG_ASSERT(head_thr != NULL);

 }
 
 static inline bool __kmp_is_drdpa_lock_nestable(kmp_drdpa_lock_t *lck) {
   return lck->lk.depth_locked != -1;
 }
 
 __forceinline static int
 __kmp_acquire_drdpa_lock_timed_template(kmp_drdpa_lock_t *lck, kmp_int32 gtid) {
-  kmp_uint64 ticket = KMP_TEST_THEN_INC64((kmp_int64 *)&lck->lk.next_ticket);
+  kmp_uint64 ticket = KMP_TEST_THEN_INC64(
+      RCAST(kmp_int64 *, CCAST(kmp_uint64 *, &lck->lk.next_ticket)));
   kmp_uint64 mask = TCR_8(lck->lk.mask); // volatile load
-  volatile struct kmp_base_drdpa_lock::kmp_lock_poll *polls =
-      (volatile struct kmp_base_drdpa_lock::kmp_lock_poll *)TCR_PTR(
-          lck->lk.polls); // volatile load
+  volatile struct kmp_base_drdpa_lock::kmp_lock_poll *polls = lck->lk.polls;
 
 #ifdef USE_LOCK_PROFILE
   if (TCR_8(polls[ticket & mask].poll) != ticket)
     __kmp_printf("LOCK CONTENTION: %p\n", lck);
 /* else __kmp_printf( "." );*/
 #endif /* USE_LOCK_PROFILE */
 
   // Now spin-wait, but reload the polls pointer and mask, in case the
while (TCR_8(polls[ticket & mask].poll) < ticket) { // volatile load
     // Re-read the mask and the poll pointer from the lock structure.
     //
     // Make certain that "mask" is read before "polls" !!!
     //
     // If another thread picks reconfigures the polling area and updates their
     // values, and we get the new value of mask and the old polls pointer, we
     // could access memory beyond the end of the old polling area.
     mask = TCR_8(lck->lk.mask); // volatile load
-    polls = (volatile struct kmp_base_drdpa_lock::kmp_lock_poll *)TCR_PTR(
-        lck->lk.polls); // volatile load
+    polls = lck->lk.polls; // volatile load
   }
 
   // Critical section starts here
   KMP_FSYNC_ACQUIRED(lck);
   KA_TRACE(1000, ("__kmp_acquire_drdpa_lock: ticket #%lld acquired lock %p\n",
                   ticket, lck));
   lck->lk.now_serving = ticket; // non-volatile store
 
   // Deallocate a garbage polling area if we know that we are the last
   // thread that could possibly access it.
   //
   // The >= check is in case __kmp_test_drdpa_lock() allocated the cleanup
   // ticket.
   if ((lck->lk.old_polls != NULL) && (ticket >= lck->lk.cleanup_ticket)) {
-    __kmp_free((void *)lck->lk.old_polls);
+    __kmp_free(CCAST(kmp_base_drdpa_lock::kmp_lock_poll *, lck->lk.old_polls));
     lck->lk.old_polls = NULL;
     lck->lk.cleanup_ticket = 0;
   }
 
   // Check to see if we should reconfigure the polling area.
   // If there is still a garbage polling area to be deallocated from a
   // previous reconfiguration, let a later thread reconfigure it.
   if (lck->lk.old_polls == NULL) {
static int __kmp_acquire_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck,
   lck->lk.owner_id = gtid + 1;
   return KMP_LOCK_ACQUIRED_FIRST;
 }
 
 int __kmp_test_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid) {
   // First get a ticket, then read the polls pointer and the mask.
   // The polls pointer must be read before the mask!!! (See above)
   kmp_uint64 ticket = TCR_8(lck->lk.next_ticket); // volatile load
-  volatile struct kmp_base_drdpa_lock::kmp_lock_poll *polls =
-      (volatile struct kmp_base_drdpa_lock::kmp_lock_poll *)TCR_PTR(
-          lck->lk.polls); // volatile load
+  volatile struct kmp_base_drdpa_lock::kmp_lock_poll *polls = lck->lk.polls;
   kmp_uint64 mask = TCR_8(lck->lk.mask); // volatile load
   if (TCR_8(polls[ticket & mask].poll) == ticket) {
     kmp_uint64 next_ticket = ticket + 1;
-    if (KMP_COMPARE_AND_STORE_ACQ64((kmp_int64 *)&lck->lk.next_ticket, ticket,
+    if (KMP_COMPARE_AND_STORE_ACQ64(&lck->lk.next_ticket, ticket,
                                     next_ticket)) {
       KMP_FSYNC_ACQUIRED(lck);
       KA_TRACE(1000, ("__kmp_test_drdpa_lock: ticket #%lld acquired lock %p\n",
                       ticket, lck));
       lck->lk.now_serving = ticket; // non-volatile store
 
       // Since no threads are waiting, there is no possibility that we would
       // want to reconfigure the polling area.  We might have the cleanup ticket
static int __kmp_test_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck,
   }
   return retval;
 }
 
 int __kmp_release_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid) {
   // Read the ticket value from the lock data struct, then the polls pointer and
   // the mask.  The polls pointer must be read before the mask!!! (See above)
   kmp_uint64 ticket = lck->lk.now_serving + 1; // non-volatile load
-  volatile struct kmp_base_drdpa_lock::kmp_lock_poll *polls =
-      (volatile struct kmp_base_drdpa_lock::kmp_lock_poll *)TCR_PTR(
-          lck->lk.polls); // volatile load
+  volatile struct kmp_base_drdpa_lock::kmp_lock_poll *polls = lck->lk.polls;
   kmp_uint64 mask = TCR_8(lck->lk.mask); // volatile load
   KA_TRACE(1000, ("__kmp_release_drdpa_lock: ticket #%lld released lock %p\n",
                   ticket - 1, lck));
   KMP_FSYNC_RELEASING(lck);
   ANNOTATE_DRDPA_RELEASED(lck);
   KMP_ST_REL64(&(polls[ticket & mask].poll), ticket); // volatile store
   return KMP_LOCK_RELEASED;
 }

 static void __kmp_init_drdpa_lock_with_checks(kmp_drdpa_lock_t *lck) {
   __kmp_init_drdpa_lock(lck);
 }
 
 void __kmp_destroy_drdpa_lock(kmp_drdpa_lock_t *lck) {
   lck->lk.initialized = NULL;
   lck->lk.location = NULL;
   if (lck->lk.polls != NULL) {
-    __kmp_free((void *)lck->lk.polls);
+    __kmp_free(CCAST(kmp_base_drdpa_lock::kmp_lock_poll *, lck->lk.polls));
     lck->lk.polls = NULL;
   }
   if (lck->lk.old_polls != NULL) {
-    __kmp_free((void *)lck->lk.old_polls);
+    __kmp_free(CCAST(kmp_base_drdpa_lock::kmp_lock_poll *, lck->lk.old_polls));
     lck->lk.old_polls = NULL;
   }
   lck->lk.mask = 0;
   lck->lk.num_polls = 0;
   lck->lk.cleanup_ticket = 0;
   lck->lk.next_ticket = 0;
   lck->lk.now_serving = 0;
   lck->lk.owner_id = 0;

openmp/trunk/runtime/src/kmp_os.h

 #else
 typedef kmp_int32 kmp_int;
 typedef kmp_uint32 kmp_uint;
 #endif /* BUILD_I8 */
 #define KMP_INT_MAX ((kmp_int32)0x7FFFFFFF)
 #define KMP_INT_MIN ((kmp_int32)0x80000000)
 
 #ifdef __cplusplus
+#define CAST_FLT_INT(a)                                                        \
+  reinterpret_cast<kmp_int32 *>(const_cast<kmp_real32 *>(a))
+#define CAST_DBL_INT(a)                                                        \
+  reinterpret_cast<kmp_int64 *>(const_cast<kmp_real64 *>(a))
+#define CCAST(type, var) const_cast<type>(var)
+#define RCAST(type, var) reinterpret_cast<type>(var)
 //-------------------------------------------------------------------------
 // template for debug prints specification ( d, u, lld, llu ), and to obtain
 // signed/unsigned flavors of a type
 template <typename T> struct traits_t {};
 // int
 template <> struct traits_t<signed int> {
   typedef signed int signed_t;
   typedef unsigned int unsigned_t;
template <> struct traits_t<unsigned long long> {
   typedef unsigned long long unsigned_t;
   typedef long double floating_t;
   static char const *spec;
   static const unsigned_t max_value = 0xffffffffffffffffLL;
   static const unsigned_t min_value = 0x0000000000000000LL;
   static const int type_size = sizeof(unsigned_t);
 };
 //-------------------------------------------------------------------------
+#else
+#define CAST_FLT_INT(a) (kmp_int32 *)(a)
+#define CAST_DBL_INT(a) (kmp_int64 *)(a)
+#define CCAST(type, var) (type)(var)
+#define RCAST(type, var) (type)(var)
 #endif // __cplusplus
 
 #define KMP_EXPORT extern /* export declaration in guide libraries */
 
 #if __GNUC__ >= 4
 #define __forceinline __inline
 #endif
 
#define KMP_COMPARE_AND_STORE_REL32(p, cv, sv)                                 \
   __kmp_compare_and_store32((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
   __kmp_compare_and_store64((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
   __kmp_compare_and_store64((p), (cv), (sv))
 
 #if KMP_ARCH_X86
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
-                            (kmp_int32)(sv))
+  __kmp_compare_and_store32(RCAST(volatile kmp_int32 *, p),                    \
+                            RCAST(kmp_int32, cv), RCAST(kmp_int32, sv))
 #else /* 64 bit pointers */
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
-                            (kmp_int64)(sv))
+  __kmp_compare_and_store64(RCAST(volatile kmp_int64 *, p),                    \
+                            RCAST(kmp_int64, cv), RCAST(kmp_int64, sv))
 #endif /* KMP_ARCH_X86 */
 
 #define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)                                  \
   __kmp_compare_and_store_ret8((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_RET16(p, cv, sv)                                 \
   __kmp_compare_and_store_ret16((p), (cv), (sv))
 //# define KMP_COMPARE_AND_STORE_RET32(p, cv, sv) __kmp_compare_and_store_ret32(
 //(p), (cv), (sv) )
 #define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \
   __kmp_compare_and_store_ret64((p), (cv), (sv))
 
 #define KMP_XCHG_FIXED8(p, v)                                                  \
   __kmp_xchg_fixed8((volatile kmp_int8 *)(p), (kmp_int8)(v));
 #define KMP_XCHG_FIXED16(p, v) __kmp_xchg_fixed16((p), (v));
-//# define KMP_XCHG_FIXED32(p, v)                 __kmp_xchg_fixed32( (p), (v)
-//);
-//# define KMP_XCHG_FIXED64(p, v)                 __kmp_xchg_fixed64( (p), (v)
-//);
-//# define KMP_XCHG_REAL32(p, v)                  __kmp_xchg_real32( (p), (v) );
+//#define KMP_XCHG_FIXED32(p, v) __kmp_xchg_fixed32((p), (v));
+//#define KMP_XCHG_FIXED64(p, v) __kmp_xchg_fixed64((p), (v));
+//#define KMP_XCHG_REAL32(p, v) __kmp_xchg_real32((p), (v));
 #define KMP_XCHG_REAL64(p, v) __kmp_xchg_real64((p), (v));
 
 #elif (KMP_ASM_INTRINS && KMP_OS_UNIX) || !(KMP_ARCH_X86 || KMP_ARCH_X86_64)
 #define KMP_TEST_THEN_ADD8(p, v) __sync_fetch_and_add((kmp_int8 *)(p), (v))
 
 /* cast p to correct type so that proper intrinsic will be used */
 #define KMP_TEST_THEN_INC32(p) __sync_fetch_and_add((kmp_int32 *)(p), 1)
 #define KMP_TEST_THEN_OR8(p, v) __sync_fetch_and_or((kmp_int8 *)(p), (v))
 #define KMP_TEST_THEN_AND8(p, v) __sync_fetch_and_and((kmp_int8 *)(p), (v))
 #define KMP_TEST_THEN_INC_ACQ32(p) __sync_fetch_and_add((kmp_int32 *)(p), 1)
 #define KMP_TEST_THEN_INC64(p) __sync_fetch_and_add((kmp_int64 *)(p), 1LL)
 #define KMP_TEST_THEN_INC_ACQ64(p) __sync_fetch_and_add((kmp_int64 *)(p), 1LL)
 #define KMP_TEST_THEN_ADD4_32(p) __sync_fetch_and_add((kmp_int32 *)(p), 4)
 #define KMP_TEST_THEN_ADD4_ACQ32(p) __sync_fetch_and_add((kmp_int32 *)(p), 4)
 #define KMP_TEST_THEN_ADD4_64(p) __sync_fetch_and_add((kmp_int64 *)(p), 4LL)
 #define KMP_TEST_THEN_ADD4_ACQ64(p) __sync_fetch_and_add((kmp_int64 *)(p), 4LL)
 #define KMP_TEST_THEN_DEC32(p) __sync_fetch_and_sub((kmp_int32 *)(p), 1)
 #define KMP_TEST_THEN_DEC_ACQ32(p) __sync_fetch_and_sub((kmp_int32 *)(p), 1)
 #define KMP_TEST_THEN_DEC64(p) __sync_fetch_and_sub((kmp_int64 *)(p), 1LL)
 #define KMP_TEST_THEN_DEC_ACQ64(p) __sync_fetch_and_sub((kmp_int64 *)(p), 1LL)
 #define KMP_TEST_THEN_ADD32(p, v) __sync_fetch_and_add((kmp_int32 *)(p), (v))
 #define KMP_TEST_THEN_ADD64(p, v) __sync_fetch_and_add((kmp_int64 *)(p), (v))
 
-#define KMP_TEST_THEN_OR32(p, v) __sync_fetch_and_or((kmp_int32 *)(p), (v))
-#define KMP_TEST_THEN_AND32(p, v) __sync_fetch_and_and((kmp_int32 *)(p), (v))
-#define KMP_TEST_THEN_OR64(p, v) __sync_fetch_and_or((kmp_int64 *)(p), (v))
-#define KMP_TEST_THEN_AND64(p, v) __sync_fetch_and_and((kmp_int64 *)(p), (v))
+#define KMP_TEST_THEN_OR32(p, v) __sync_fetch_and_or((kmp_uint32 *)(p), (v))
+#define KMP_TEST_THEN_AND32(p, v) __sync_fetch_and_and((kmp_uint32 *)(p), (v))
+#define KMP_TEST_THEN_OR64(p, v) __sync_fetch_and_or((kmp_uint64 *)(p), (v))
+#define KMP_TEST_THEN_AND64(p, v) __sync_fetch_and_and((kmp_uint64 *)(p), (v))
 
 #define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)                                  \
   __sync_bool_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8)(cv),     \
                                (kmp_uint8)(sv))
 #define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)                                  \
   __sync_bool_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8)(cv),     \
                                (kmp_uint8)(sv))
 #define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv)                                 \
__sync_bool_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32)(cv),   \
                                (kmp_uint32)(sv))
 #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
   __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),   \
                                (kmp_uint64)(sv))
 #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
   __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),   \
                                (kmp_uint64)(sv))
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __sync_bool_compare_and_swap((volatile void **)(p), (void *)(cv),            \
+  __sync_bool_compare_and_swap((void *volatile *)(p), (void *)(cv),            \
                                (void *)(sv))
 
 #define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)                                  \
   __sync_val_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8)(cv),      \
                               (kmp_uint8)(sv))
 #define KMP_COMPARE_AND_STORE_RET16(p, cv, sv)                                 \
   __sync_val_compare_and_swap((volatile kmp_uint16 *)(p), (kmp_uint16)(cv),    \
                               (kmp_uint16)(sv))
#define KMP_XCHG_FIXED32(p, v)                                                 \
   __sync_lock_test_and_set((volatile kmp_uint32 *)(p), (kmp_uint32)(v))
 #define KMP_XCHG_FIXED64(p, v)                                                 \
   __sync_lock_test_and_set((volatile kmp_uint64 *)(p), (kmp_uint64)(v))
 
 extern kmp_int8 __kmp_test_then_add8(volatile kmp_int8 *p, kmp_int8 v);
 extern kmp_int8 __kmp_test_then_or8(volatile kmp_int8 *p, kmp_int8 v);
 extern kmp_int8 __kmp_test_then_and8(volatile kmp_int8 *p, kmp_int8 v);
 inline kmp_real32 KMP_XCHG_REAL32(volatile kmp_real32 *p, kmp_real32 v) {
-  kmp_int32 tmp = __sync_lock_test_and_set((kmp_int32 *)p, *(kmp_int32 *)&v);
+  kmp_int32 tmp = __sync_lock_test_and_set(CAST_FLT_INT(p), *(kmp_int32 *)&v);
   return *(kmp_real32 *)&tmp;
 }
 
 inline kmp_real64 KMP_XCHG_REAL64(volatile kmp_real64 *p, kmp_real64 v) {
-  kmp_int64 tmp = __sync_lock_test_and_set((kmp_int64 *)p, *(kmp_int64 *)&v);
+  kmp_int64 tmp = __sync_lock_test_and_set(CAST_DBL_INT(p), *(kmp_int64 *)&v);
   return *(kmp_real64 *)&tmp;
 }
 
 #else
 
 extern kmp_int32 __kmp_test_then_add32(volatile kmp_int32 *p, kmp_int32 v);
 extern kmp_int32 __kmp_test_then_or32(volatile kmp_int32 *p, kmp_int32 v);
 extern kmp_int32 __kmp_test_then_and32(volatile kmp_int32 *p, kmp_int32 v);
#define KMP_COMPARE_AND_STORE_REL32(p, cv, sv)                                 \
   __kmp_compare_and_store32((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
   __kmp_compare_and_store64((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
   __kmp_compare_and_store64((p), (cv), (sv))
 
 #if KMP_ARCH_X86
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
-                            (kmp_int32)(sv))
+  __kmp_compare_and_store32(RCAST(volatile kmp_int32 *, p),                    \
+                            RCAST(kmp_int32, cv), RCAST(kmp_int32, sv))
 #else /* 64 bit pointers */
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
-                            (kmp_int64)(sv))
+  __kmp_compare_and_store64(RCAST(volatile kmp_int64 *, p),                    \
+                            RCAST(kmp_int64, cv), RCAST(kmp_int64, sv))
 #endif /* KMP_ARCH_X86 */
 
 #define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)                                  \
   __kmp_compare_and_store_ret8((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_RET16(p, cv, sv)                                 \
   __kmp_compare_and_store_ret16((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_RET32(p, cv, sv)                                 \
   __kmp_compare_and_store_ret32((p), (cv), (sv))

openmp/trunk/runtime/src/kmp_runtime.cpp

#if OMPT_SUPPORT
         lwt->ompt_task_info.task_id = __ompt_task_id_new(gtid);
         lwt->ompt_task_info.frame.exit_runtime_frame = NULL;
         __ompt_lw_taskteam_link(lwt, master_th);
 #endif
 
         // we were called from GNU native code
         KA_TRACE(20, ("__kmp_fork_call: T#%d serial exit\n", gtid));
         return FALSE;
-      }
-      else {
+      } else {
         KMP_ASSERT2(call_context < fork_context_last,
                     "__kmp_fork_call: unknown fork_context parameter");
       }
 
       KA_TRACE(20, ("__kmp_fork_call: T#%d serial exit\n", gtid));
       KMP_MB();
       return FALSE;
     }
while (list->next != NULL) {
     __kmp_printf("\n");
     list = list->next;
   }; // while
 
   // Print out __kmp_thread_pool and __kmp_team_pool.
   __kmp_printf("\n------------------------------\nPools\n----------------------"
                "--------\n");
   __kmp_print_structure_thread("Thread pool:          ",
-                               (kmp_info_t *)__kmp_thread_pool);
+                               CCAST(kmp_info_t *, __kmp_thread_pool));
   __kmp_print_structure_team("Team pool:            ",
-                             (kmp_team_t *)__kmp_team_pool);
+                             CCAST(kmp_team_t *, __kmp_team_pool));
   __kmp_printf("\n");
 
   // Free team list.
   while (list != NULL) {
     kmp_team_list_item_t *item = list;
     list = list->next;
     KMP_INTERNAL_FREE(item);
   }; // while

 #if !KMP_NESTED_HOT_TEAMS
   KMP_DEBUG_ASSERT(KMP_MASTER_GTID(__kmp_get_gtid()));
 #endif
   KMP_MB();
 
   /* first, try to get one from the thread pool */
   if (__kmp_thread_pool) {
 
-    new_thr = (kmp_info_t *)__kmp_thread_pool;
+    new_thr = CCAST(kmp_info_t *, __kmp_thread_pool);
     __kmp_thread_pool = (volatile kmp_info_t *)new_thr->th.th_next_pool;
     if (new_thr == __kmp_thread_pool_insert_pt) {
       __kmp_thread_pool_insert_pt = NULL;
     }
     TCW_4(new_thr->th.th_in_pool, FALSE);
     // Don't touch th_active_in_pool or th_active.
     // The worker thread adjusts those flags as it sleeps/awakens.
     __kmp_thread_pool_nth--;
#endif
 
     KMP_MB();
 
     return team;
   }
 
   /* next, let's try to take one from the team pool */
   KMP_MB();
-  for (team = (kmp_team_t *)__kmp_team_pool; (team);) {
+  for (team = CCAST(kmp_team_t *, __kmp_team_pool); (team);) {
     /* TODO: consider resizing undersized teams instead of reaping them, now
        that we have a resizing mechanism */
     if (team->t.t_max_nproc >= max_nproc) {
       /* take this team from the team pool */
       __kmp_team_pool = team->t.t_next_pool;
 
       /* setup the team for fresh use */
       __kmp_initialize_team(team, new_nproc, new_icvs, NULL);
#endif
     for (f = 1; f < team->t.t_nproc; ++f) {
       KMP_DEBUG_ASSERT(team->t.t_threads[f]);
       __kmp_free_thread(team->t.t_threads[f]);
       team->t.t_threads[f] = NULL;
     }
 
     /* put the team back in the team pool */
     /* TODO limit size of team pool, call reap_team if pool too large */
-    team->t.t_next_pool = (kmp_team_t *)__kmp_team_pool;
+    team->t.t_next_pool = CCAST(kmp_team_t *, __kmp_team_pool);
     __kmp_team_pool = (volatile kmp_team_t *)team;
   }
 
   KMP_MB();
 }
 
 /* reap the team.  destroy it, reclaim all its resources and free its memory */
 kmp_team_t *__kmp_reap_team(kmp_team_t *team) {
void __kmp_free_thread(kmp_info_t *this_th) {
   // Scan down the list to find the place to insert the thread.
   // scan is the address of a link in the list, possibly the address of
   // __kmp_thread_pool itself.
   //
   // In the absence of nested parallism, the for loop will have 0 iterations.
   if (__kmp_thread_pool_insert_pt != NULL) {
     scan = &(__kmp_thread_pool_insert_pt->th.th_next_pool);
   } else {
-    scan = (kmp_info_t **)&__kmp_thread_pool;
+    scan = CCAST(kmp_info_t **, &__kmp_thread_pool);
   }
   for (; (*scan != NULL) && ((*scan)->th.th_info.ds.ds_gtid < gtid);
        scan = &((*scan)->th.th_next_pool))
     ;
 
   // Insert the new element on the list, and set __kmp_thread_pool_insert_pt
   // to its address.
   TCW_PTR(this_th->th.th_next_pool, *scan);
if (!is_root) {
     // up after sleeping in the pool, had reset it's th_active_in_pool flag but
     // not decremented the global counter __kmp_thread_pool_active_nth yet, then
     // the global counter might not get updated.
     //
     // Currently, this can only happen as the library is unloaded,
     // so there are no harmful side effects.
     if (thread->th.th_active_in_pool) {
       thread->th.th_active_in_pool = FALSE;
-      KMP_TEST_THEN_DEC32((kmp_int32 *)&__kmp_thread_pool_active_nth);
+      KMP_TEST_THEN_DEC32(CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
       KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) >= 0);
     }
 
     // Decrement # of [worker] threads in the pool.
     KMP_DEBUG_ASSERT(__kmp_thread_pool_nth > 0);
     --__kmp_thread_pool_nth;
   }; // if
 

 #endif
 
     KMP_MB();
 
     // Reap the worker threads.
     // This is valid for now, but be careful if threads are reaped sooner.
     while (__kmp_thread_pool != NULL) { // Loop thru all the thread in the pool.
       // Get the next thread from the pool.
-      kmp_info_t *thread = (kmp_info_t *)__kmp_thread_pool;
+      kmp_info_t *thread = CCAST(kmp_info_t *, __kmp_thread_pool);
       __kmp_thread_pool = thread->th.th_next_pool;
       // Reap it.
       KMP_DEBUG_ASSERT(thread->th.th_reap_state == KMP_SAFE_TO_REAP);
       thread->th.th_next_pool = NULL;
       thread->th.th_in_pool = FALSE;
       __kmp_reap_thread(thread, 0);
     }; // while
     __kmp_thread_pool_insert_pt = NULL;
 
     // Reap teams.
     while (__kmp_team_pool != NULL) { // Loop thru all the teams in the pool.
       // Get the next team from the pool.
-      kmp_team_t *team = (kmp_team_t *)__kmp_team_pool;
+      kmp_team_t *team = CCAST(kmp_team_t *, __kmp_team_pool);
       __kmp_team_pool = team->t.t_next_pool;
       // Reap it.
       team->t.t_next_pool = NULL;
       __kmp_reap_team(team);
     }; // while
 
     __kmp_reap_task_teams();
 

 
 #if KMP_USE_DYNAMIC_LOCK
   __kmp_cleanup_indirect_user_locks();
 #else
   __kmp_cleanup_user_locks();
 #endif
 
 #if KMP_AFFINITY_SUPPORTED
-  KMP_INTERNAL_FREE((void *)__kmp_cpuinfo_file);
+  KMP_INTERNAL_FREE(CCAST(char *, __kmp_cpuinfo_file));
   __kmp_cpuinfo_file = NULL;
 #endif /* KMP_AFFINITY_SUPPORTED */
 
 #if KMP_USE_ADAPTIVE_LOCKS
 #if KMP_DEBUG_ADAPTIVE_LOCKS
   __kmp_print_speculative_stats();
 #endif
 #endif

openmp/trunk/runtime/src/kmp_settings.cpp

 static void __kmp_stg_parse_warnings(char const *name, char const *value,
                                      void *data) {
   __kmp_stg_parse_bool(name, value, &__kmp_generate_warnings);
   if (__kmp_generate_warnings != kmp_warnings_off) {
     // AC: only 0/1 values documented, so reset to explicit to distinguish from
     // default setting
     __kmp_generate_warnings = kmp_warnings_explicit;
   }
-} // __kmp_env_parse_warnings
+} // __kmp_stg_parse_warnings
 
 static void __kmp_stg_print_warnings(kmp_str_buf_t *buffer, char const *name,
                                      void *data) {
-  __kmp_stg_print_bool(
-      buffer, name, __kmp_generate_warnings); // AC: TODO: change to print_int?
-} // __kmp_env_print_warnings                                      //     (needs
-  // documentation change)...
+  // AC: TODO: change to print_int? (needs documentation change)
+  __kmp_stg_print_bool(buffer, name, __kmp_generate_warnings);
+} // __kmp_stg_print_warnings
 
 // -----------------------------------------------------------------------------
 // OMP_NESTED, OMP_NUM_THREADS
 
 static void __kmp_stg_parse_nested(char const *name, char const *value,
                                    void *data) {
   __kmp_stg_parse_bool(name, value, &__kmp_dflt_nested);
 } // __kmp_stg_parse_nested
static void __kmp_stg_parse_barrier_branch_bit(char const *name,
   const char *var;
 
   /* ---------- Barrier branch bit control ------------ */
   for (int i = bs_plain_barrier; i < bs_last_barrier; i++) {
     var = __kmp_barrier_branch_bit_env_name[i];
     if ((strcmp(var, name) == 0) && (value != 0)) {
       char *comma;
 
-      comma = (char *)strchr(value, ',');
+      comma = CCAST(char *, strchr(value, ','));
       __kmp_barrier_gather_branch_bits[i] =
           (kmp_uint32)__kmp_str_to_int(value, ',');
       /* is there a specified release parameter? */
       if (comma == NULL) {
         __kmp_barrier_release_branch_bits[i] = __kmp_barrier_release_bb_dflt;
       } else {
         __kmp_barrier_release_branch_bits[i] =
             (kmp_uint32)__kmp_str_to_int(comma + 1, 0);
static void __kmp_stg_parse_barrier_pattern(char const *name, char const *value,
   const char *var;
   /* ---------- Barrier method control ------------ */
 
   for (int i = bs_plain_barrier; i < bs_last_barrier; i++) {
     var = __kmp_barrier_pattern_env_name[i];
 
     if ((strcmp(var, name) == 0) && (value != 0)) {
       int j;
-      char *comma = (char *)strchr(value, ',');
+      char *comma = CCAST(char *, strchr(value, ','));
 
       /* handle first parameter: gather pattern */
       for (j = bp_linear_bar; j < bp_last_bar; j++) {
         if (__kmp_match_with_sentinel(__kmp_barrier_pattern_name[j], value, 1,
                                       ',')) {
           __kmp_barrier_gather_pattern[i] = (kmp_bar_pat_e)j;
           break;
         }

 #if OMP_40_ENABLED
   KMP_DEBUG_ASSERT((__kmp_nested_proc_bind.bind_types != NULL) &&
                    (__kmp_nested_proc_bind.used > 0));
 #endif
 
   while (*buf != '\0') {
     start = next = buf;
 
-    if (__kmp_match_str("none", buf, (const char **)&next)) {
+    if (__kmp_match_str("none", buf, CCAST(const char **, &next))) {
       set_type(affinity_none);
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
 #endif
       buf = next;
-    } else if (__kmp_match_str("scatter", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("scatter", buf, CCAST(const char **, &next))) {
       set_type(affinity_scatter);
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
 #endif
       buf = next;
-    } else if (__kmp_match_str("compact", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("compact", buf, CCAST(const char **, &next))) {
       set_type(affinity_compact);
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
 #endif
       buf = next;
-    } else if (__kmp_match_str("logical", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("logical", buf, CCAST(const char **, &next))) {
       set_type(affinity_logical);
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
 #endif
       buf = next;
-    } else if (__kmp_match_str("physical", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("physical", buf, CCAST(const char **, &next))) {
       set_type(affinity_physical);
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
 #endif
       buf = next;
-    } else if (__kmp_match_str("explicit", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("explicit", buf, CCAST(const char **, &next))) {
       set_type(affinity_explicit);
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
 #endif
       buf = next;
-    } else if (__kmp_match_str("balanced", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("balanced", buf, CCAST(const char **, &next))) {
       set_type(affinity_balanced);
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
 #endif
       buf = next;
-    } else if (__kmp_match_str("disabled", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("disabled", buf, CCAST(const char **, &next))) {
       set_type(affinity_disabled);
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_false;
 #endif
       buf = next;
-    } else if (__kmp_match_str("verbose", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("verbose", buf, CCAST(const char **, &next))) {
       set_verbose(TRUE);
       buf = next;
-    } else if (__kmp_match_str("noverbose", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("noverbose", buf, CCAST(const char **, &next))) {
       set_verbose(FALSE);
       buf = next;
-    } else if (__kmp_match_str("warnings", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("warnings", buf, CCAST(const char **, &next))) {
       set_warnings(TRUE);
       buf = next;
-    } else if (__kmp_match_str("nowarnings", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("nowarnings", buf,
+                               CCAST(const char **, &next))) {
       set_warnings(FALSE);
       buf = next;
-    } else if (__kmp_match_str("respect", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("respect", buf, CCAST(const char **, &next))) {
       set_respect(TRUE);
       buf = next;
-    } else if (__kmp_match_str("norespect", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("norespect", buf, CCAST(const char **, &next))) {
       set_respect(FALSE);
       buf = next;
-    } else if (__kmp_match_str("duplicates", buf, (const char **)&next) ||
-               __kmp_match_str("dups", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("duplicates", buf,
+                               CCAST(const char **, &next)) ||
+               __kmp_match_str("dups", buf, CCAST(const char **, &next))) {
       set_dups(TRUE);
       buf = next;
-    } else if (__kmp_match_str("noduplicates", buf, (const char **)&next) ||
-               __kmp_match_str("nodups", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("noduplicates", buf,
+                               CCAST(const char **, &next)) ||
+               __kmp_match_str("nodups", buf, CCAST(const char **, &next))) {
       set_dups(FALSE);
       buf = next;
-    } else if (__kmp_match_str("granularity", buf, (const char **)&next) ||
-               __kmp_match_str("gran", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("granularity", buf,
+                               CCAST(const char **, &next)) ||
+               __kmp_match_str("gran", buf, CCAST(const char **, &next))) {
       SKIP_WS(next);
       if (*next != '=') {
         EMIT_WARN(TRUE, (AffInvalidParam, name, start));
         continue;
       }
       next++; // skip '='
       SKIP_WS(next);
 
       buf = next;
-      if (__kmp_match_str("fine", buf, (const char **)&next)) {
+      if (__kmp_match_str("fine", buf, CCAST(const char **, &next))) {
         set_gran(affinity_gran_fine, -1);
         buf = next;
-      } else if (__kmp_match_str("thread", buf, (const char **)&next)) {
+      } else if (__kmp_match_str("thread", buf, CCAST(const char **, &next))) {
         set_gran(affinity_gran_thread, -1);
         buf = next;
-      } else if (__kmp_match_str("core", buf, (const char **)&next)) {
+      } else if (__kmp_match_str("core", buf, CCAST(const char **, &next))) {
         set_gran(affinity_gran_core, -1);
         buf = next;
-      } else if (__kmp_match_str("package", buf, (const char **)&next)) {
+      } else if (__kmp_match_str("package", buf, CCAST(const char **, &next))) {
         set_gran(affinity_gran_package, -1);
         buf = next;
-      } else if (__kmp_match_str("node", buf, (const char **)&next)) {
+      } else if (__kmp_match_str("node", buf, CCAST(const char **, &next))) {
         set_gran(affinity_gran_node, -1);
         buf = next;
 #if KMP_GROUP_AFFINITY
-      } else if (__kmp_match_str("group", buf, (const char **)&next)) {
+      } else if (__kmp_match_str("group", buf, CCAST(const char **, &next))) {
         set_gran(affinity_gran_group, -1);
         buf = next;
 #endif /* KMP_GROUP AFFINITY */
       } else if ((*buf >= '0') && (*buf <= '9')) {
         int n;
         next = buf;
         SKIP_DIGITS(next);
         n = __kmp_str_to_int(buf, *next);
         KMP_ASSERT(n >= 0);
         buf = next;
         set_gran(affinity_gran_default, n);
       } else {
         EMIT_WARN(TRUE, (AffInvalidParam, name, start));
         continue;
       }
-    } else if (__kmp_match_str("proclist", buf, (const char **)&next)) {
+    } else if (__kmp_match_str("proclist", buf, CCAST(const char **, &next))) {
       char *temp_proclist;
 
       SKIP_WS(next);
       if (*next != '=') {
         EMIT_WARN(TRUE, (AffInvalidParam, name, start));
         continue;
       }
       next++; // skip '='
       SKIP_WS(next);
       if (*next != '[') {
         EMIT_WARN(TRUE, (AffInvalidParam, name, start));
         continue;
       }
       next++; // skip '['
       buf = next;
-      if (!__kmp_parse_affinity_proc_id_list(name, buf, (const char **)&next,
-                                             &temp_proclist)) {
+      if (!__kmp_parse_affinity_proc_id_list(
+              name, buf, CCAST(const char **, &next), &temp_proclist)) {
         // warning already emitted.
         SKIP_TO(next, ']');
         if (*next == ']')
           next++;
         SKIP_TO(next, ',');
         if (*next == ',')
           next++;
         buf = next;

 #undef EMIT_WARN
 #undef _set_param
 #undef set_type
 #undef set_verbose
 #undef set_warnings
 #undef set_respect
 #undef set_granularity
 
-  __kmp_str_free((const char **)&buffer);
+  __kmp_str_free(CCAST(const char **, &buffer));
 
   if (proclist) {
     if (!type) {
       KMP_WARNING(AffProcListNoType, name);
       *out_type = affinity_explicit;
 #if OMP_40_ENABLED
       __kmp_nested_proc_bind.bind_types[0] = proc_bind_intel;
 #endif
case affinity_top_method_x2apicid:
     value = "x2APIC id";
     break;
 
   case affinity_top_method_apicid:
     value = "APIC id";
     break;
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
-# if KMP_USE_HWLOC
+#if KMP_USE_HWLOC
   case affinity_top_method_hwloc:
     value = "hwloc";
     break;
-# endif
+#endif
 
   case affinity_top_method_cpuinfo:
     value = "cpuinfo";
     break;
 
 #if KMP_GROUP_AFFINITY
   case affinity_top_method_group:
     value = "group";
if (length > INT_MAX) {
       KMP_WARNING(LongValue, name);
     } else {
       char *semicolon;
       if (value[length - 1] == '"' || value[length - 1] == '\'')
         KMP_WARNING(UnbalancedQuotes, name);
       do {
         char sentinel;
 
-        semicolon = (char *)strchr(value, ';');
+        semicolon = CCAST(char *, strchr(value, ';'));
         if (*value && semicolon != value) {
-          char *comma = (char *)strchr(value, ',');
+          char *comma = CCAST(char *, strchr(value, ','));
 
           if (comma) {
             ++comma;
             sentinel = ',';
           } else
             sentinel = ';';
           if (!__kmp_strcasecmp_with_sentinel("static", value, sentinel)) {
             if (!__kmp_strcasecmp_with_sentinel("greedy", comma, ';')) {

 // OMP_SCHEDULE
 
 static void __kmp_stg_parse_omp_schedule(char const *name, char const *value,
                                          void *data) {
   size_t length;
   if (value) {
     length = KMP_STRLEN(value);
     if (length) {
-      char *comma = (char *)strchr(value, ',');
+      char *comma = CCAST(char *, strchr(value, ','));
       if (value[length - 1] == '"' || value[length - 1] == '\'')
         KMP_WARNING(UnbalancedQuotes, name);
       /* get the specified scheduling style */
       if (!__kmp_strcasecmp_with_sentinel("dynamic", value, ',')) /* DYNAMIC */
         __kmp_sched = kmp_sch_dynamic_chunked;
       else if (!__kmp_strcasecmp_with_sentinel("guided", value,
                                                ',')) /* GUIDED */
         __kmp_sched = kmp_sch_guided_chunked;

 // The input string is usually short enough, let's use 512 limit for now
 #define MAX_T_LEVEL 5
 #define MAX_STR_LEN 512
 static void __kmp_stg_parse_hw_subset(char const *name, char const *value,
                                       void *data) {
   // Value example: 1s,5c@3,2T
   // Which means "use 1 socket, 5 cores with offset 3, 2 threads per core"
   static int parsed = 0;
-  if( strcmp(name, "KMP_PLACE_THREADS") == 0 ) {
-    KMP_INFORM(EnvVarDeprecated,name,"KMP_HW_SUBSET");
-    if( parsed == 1 ) {
+  if (strcmp(name, "KMP_PLACE_THREADS") == 0) {
+    KMP_INFORM(EnvVarDeprecated, name, "KMP_HW_SUBSET");
+    if (parsed == 1) {
       return; // already parsed KMP_HW_SUBSET
     }
   }
   parsed = 1;
 
   char *components[MAX_T_LEVEL];
   char const *digits = "0123456789";
   char input[MAX_STR_LEN];
   size_t len = 0, mlen = MAX_STR_LEN;
   int level = 0;
   // Canonize the string (remove spaces, unify delimiters, etc.)
-  char *pos = (char *)value;
+  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);
         if (input[len] == 'X')
           input[len] = ','; // unify delimiters of levels
static void __kmp_stg_parse_hw_subset(char const *name, char const *value,
   return;
 err:
   KMP_WARNING(AffHWSubsetInvalid, name, value);
   __kmp_hws_requested = 0; // mark that subset not requested
   return;
 }
 
 static void __kmp_stg_print_hw_subset(kmp_str_buf_t *buffer, char const *name,
-                                      void *data ) {
+                                      void *data) {
   if (__kmp_hws_requested) {
     int comma = 0;
     kmp_str_buf_t buf;
     __kmp_str_buf_init(&buf);
     if (__kmp_env_format)
       KMP_STR_BUF_PRINT_NAME_EX(name);
     else
       __kmp_str_buf_print(buffer, "   %s='", name);
     if (__kmp_hws_socket.num) {
       __kmp_str_buf_print(&buf, "%ds", __kmp_hws_socket.num);
       if (__kmp_hws_socket.offset)
         __kmp_str_buf_print(&buf, "@%d", __kmp_hws_socket.offset);
       comma = 1;
     }
     if (__kmp_hws_node.num) {
-      __kmp_str_buf_print(&buf, "%s%dn", comma?",":"", __kmp_hws_node.num);
+      __kmp_str_buf_print(&buf, "%s%dn", comma ? "," : "", __kmp_hws_node.num);
       if (__kmp_hws_node.offset)
         __kmp_str_buf_print(&buf, "@%d", __kmp_hws_node.offset);
       comma = 1;
     }
     if (__kmp_hws_tile.num) {
-      __kmp_str_buf_print(&buf, "%s%dL2", comma?",":"", __kmp_hws_tile.num);
+      __kmp_str_buf_print(&buf, "%s%dL2", comma ? "," : "", __kmp_hws_tile.num);
       if (__kmp_hws_tile.offset)
         __kmp_str_buf_print(&buf, "@%d", __kmp_hws_tile.offset);
       comma = 1;
     }
     if (__kmp_hws_core.num) {
-      __kmp_str_buf_print(&buf, "%s%dc", comma?",":"", __kmp_hws_core.num);
+      __kmp_str_buf_print(&buf, "%s%dc", comma ? "," : "", __kmp_hws_core.num);
       if (__kmp_hws_core.offset)
         __kmp_str_buf_print(&buf, "@%d", __kmp_hws_core.offset);
       comma = 1;
     }
     if (__kmp_hws_proc.num)
-      __kmp_str_buf_print(&buf, "%s%dt", comma?",":"", __kmp_hws_proc.num);
-    __kmp_str_buf_print(buffer, "%s'\n", buf.str );
+      __kmp_str_buf_print(&buf, "%s%dt", comma ? "," : "", __kmp_hws_proc.num);
+    __kmp_str_buf_print(buffer, "%s'\n", buf.str);
     __kmp_str_buf_free(&buf);
   }
 }
 
 #if USE_ITT_BUILD
 // -----------------------------------------------------------------------------
 // KMP_FORKJOIN_FRAMES
 
for (i = 0; i < __kmp_stg_count; ++i) {
       }; // if
     }; // for
   }; // if
   return NULL;
 
 } // __kmp_stg_find
 
 static int __kmp_stg_cmp(void const *_a, void const *_b) {
-  kmp_setting_t *a = (kmp_setting_t *)_a;
-  kmp_setting_t *b = (kmp_setting_t *)_b;
+  kmp_setting_t *a = RCAST(kmp_setting_t *, CCAST(void *, _a));
+  kmp_setting_t *b = RCAST(kmp_setting_t *, CCAST(void *, _b));
 
   // Process KMP_AFFINITY last.
   // It needs to come after OMP_PLACES and GOMP_CPU_AFFINITY.
   if (strcmp(a->name, "KMP_AFFINITY") == 0) {
     if (strcmp(b->name, "KMP_AFFINITY") == 0) {
       return 0;
     }
     return 1;
#endif
       kmp_setting_t *omp_stacksize =
           __kmp_stg_find("OMP_STACKSIZE"); // 3rd priority.
 
       // !!! volatile keyword is Intel (R) C Compiler bug CQ49908 workaround.
       // !!! Compiler does not understand rivals is used and optimizes out
       // assignments
       // !!!     rivals[ i ++ ] = ...;
       static kmp_setting_t *volatile rivals[4];
-      static kmp_stg_ss_data_t kmp_data = {1, (kmp_setting_t **)rivals};
+      static kmp_stg_ss_data_t kmp_data = {1, CCAST(kmp_setting_t **, rivals)};
 #ifdef KMP_GOMP_COMPAT
-      static kmp_stg_ss_data_t gomp_data = {1024, (kmp_setting_t **)rivals};
+      static kmp_stg_ss_data_t gomp_data = {1024,
+                                            CCAST(kmp_setting_t **, rivals)};
 #endif
-      static kmp_stg_ss_data_t omp_data = {1024, (kmp_setting_t **)rivals};
+      static kmp_stg_ss_data_t omp_data = {1024,
+                                           CCAST(kmp_setting_t **, rivals)};
       int i = 0;
 
       rivals[i++] = kmp_stacksize;
 #ifdef KMP_GOMP_COMPAT
       if (gomp_stacksize != NULL) {
         rivals[i++] = gomp_stacksize;
       }; // if
 #endif
#endif
     { // Initialize KMP_LIBRARY and OMP_WAIT_POLICY data.
       kmp_setting_t *kmp_library =
           __kmp_stg_find("KMP_LIBRARY"); // 1st priority.
       kmp_setting_t *omp_wait_policy =
           __kmp_stg_find("OMP_WAIT_POLICY"); // 2nd priority.
 
       // !!! volatile keyword is Intel (R) C Compiler bug CQ49908 workaround.
       static kmp_setting_t *volatile rivals[3];
-      static kmp_stg_wp_data_t kmp_data = {0, (kmp_setting_t **)rivals};
-      static kmp_stg_wp_data_t omp_data = {1, (kmp_setting_t **)rivals};
+      static kmp_stg_wp_data_t kmp_data = {0, CCAST(kmp_setting_t **, rivals)};
+      static kmp_stg_wp_data_t omp_data = {1, CCAST(kmp_setting_t **, rivals)};
       int i = 0;
 
       rivals[i++] = kmp_library;
       if (omp_wait_policy != NULL) {
         rivals[i++] = omp_wait_policy;
       }; // if
       rivals[i++] = NULL;
 
#endif
       int i = 0;
 
       rivals[i++] = kmp_all_threads;
       rivals[i++] = kmp_max_threads;
       if (omp_thread_limit != NULL) {
         rivals[i++] = omp_thread_limit;
       }; // if
       rivals[i++] = NULL;
-
-      kmp_all_threads->data = (void *)&rivals;
-      kmp_max_threads->data = (void *)&rivals;
+      kmp_all_threads->data = CCAST(kmp_setting_t **, rivals);
+      kmp_max_threads->data = CCAST(kmp_setting_t **, rivals);
       if (omp_thread_limit != NULL) {
-        omp_thread_limit->data = (void *)&rivals;
+        omp_thread_limit->data = CCAST(kmp_setting_t **, rivals);
       }; // if
     }
 
 #if KMP_AFFINITY_SUPPORTED
     { // Initialize KMP_AFFINITY, GOMP_CPU_AFFINITY, and OMP_PROC_BIND data.
       kmp_setting_t *kmp_affinity =
           __kmp_stg_find("KMP_AFFINITY"); // 1st priority.
       KMP_DEBUG_ASSERT(kmp_affinity != NULL);
#endif
       // !!! volatile keyword is Intel (R) C Compiler bug CQ49908 workaround.
       static kmp_setting_t *volatile rivals[4];
       int i = 0;
 
       rivals[i++] = kmp_affinity;
 
 #ifdef KMP_GOMP_COMPAT
       rivals[i++] = gomp_cpu_affinity;
-      gomp_cpu_affinity->data = (void *)&rivals;
+      gomp_cpu_affinity->data = CCAST(kmp_setting_t **, rivals);
 #endif
 
       rivals[i++] = omp_proc_bind;
-      omp_proc_bind->data = (void *)&rivals;
+      omp_proc_bind->data = CCAST(kmp_setting_t **, rivals);
       rivals[i++] = NULL;
 
 #if OMP_40_ENABLED
       static kmp_setting_t *volatile places_rivals[4];
       i = 0;
 
       kmp_setting_t *omp_places = __kmp_stg_find("OMP_PLACES"); // 3rd priority.
       KMP_DEBUG_ASSERT(omp_places != NULL);
 
       places_rivals[i++] = kmp_affinity;
 #ifdef KMP_GOMP_COMPAT
       places_rivals[i++] = gomp_cpu_affinity;
 #endif
       places_rivals[i++] = omp_places;
-      omp_places->data = (void *)&places_rivals;
+      omp_places->data = CCAST(kmp_setting_t **, places_rivals);
       places_rivals[i++] = NULL;
 #endif
     }
 #else
 // KMP_AFFINITY not supported, so OMP_PROC_BIND has no rivals.
 // OMP_PLACES not supported yet.
 #endif // KMP_AFFINITY_SUPPORTED
 
     { // Initialize KMP_DETERMINISTIC_REDUCTION and KMP_FORCE_REDUCTION data.
       kmp_setting_t *kmp_force_red =
           __kmp_stg_find("KMP_FORCE_REDUCTION"); // 1st priority.
       kmp_setting_t *kmp_determ_red =
           __kmp_stg_find("KMP_DETERMINISTIC_REDUCTION"); // 2nd priority.
 
       // !!! volatile keyword is Intel (R) C Compiler bug CQ49908 workaround.
       static kmp_setting_t *volatile rivals[3];
-      static kmp_stg_fr_data_t force_data = {1, (kmp_setting_t **)rivals};
-      static kmp_stg_fr_data_t determ_data = {0, (kmp_setting_t **)rivals};
+      static kmp_stg_fr_data_t force_data = {1,
+                                             CCAST(kmp_setting_t **, rivals)};
+      static kmp_stg_fr_data_t determ_data = {0,
+                                              CCAST(kmp_setting_t **, rivals)};
       int i = 0;
 
       rivals[i++] = kmp_force_red;
       if (kmp_determ_red != NULL) {
         rivals[i++] = kmp_determ_red;
       }; // if
       rivals[i++] = NULL;
 

openmp/trunk/runtime/src/kmp_str.cpp

if (path != NULL) {
     base = (slash == NULL ? fname->dir : slash + 1);
     fname->base = __kmp_str_format("%s", base); // Copy basename
     *base = 0; // and truncate dir.
   }; // if
 
 } // kmp_str_fname_init
 
 void __kmp_str_fname_free(kmp_str_fname_t *fname) {
-  __kmp_str_free((char const **)(&fname->path));
-  __kmp_str_free((char const **)(&fname->dir));
-  __kmp_str_free((char const **)(&fname->base));
+  __kmp_str_free(CCAST(char const **, &fname->path));
+  __kmp_str_free(CCAST(char const **, &fname->dir));
+  __kmp_str_free(CCAST(char const **, &fname->base));
 } // kmp_str_fname_free
 
 int __kmp_str_fname_match(kmp_str_fname_t const *fname, char const *pattern) {
   int dir_match = 1;
   int base_match = 1;
 
   if (pattern != NULL) {
     kmp_str_fname_t ptrn;
kmp_str_loc_t __kmp_str_loc_init(char const *psource, int init_fname) {
 
   __kmp_str_fname_init(&loc.fname, init_fname ? loc.file : NULL);
 
   return loc;
 } // kmp_str_loc_init
 
 void __kmp_str_loc_free(kmp_str_loc_t *loc) {
   __kmp_str_fname_free(&loc->fname);
-  __kmp_str_free((const char **)&(loc->_bulk));
+  __kmp_str_free(CCAST(const char **, &(loc->_bulk)));
   loc->file = NULL;
   loc->func = NULL;
 } // kmp_str_loc_free
 
 /* This function is intended to compare file names. On Windows* OS file names
    are case-insensitive, so functions performs case-insensitive comparison. On
    Linux* OS it performs case-sensitive comparison. Note: The function returns
    *true* if strings are *equal*. */
for (;;) {
     }; // if
   }; // forever
 
   return buffer;
 } // func __kmp_str_format
 
 void __kmp_str_free(char const **str) {
   KMP_DEBUG_ASSERT(str != NULL);
-  KMP_INTERNAL_FREE((void *)*str);
+  KMP_INTERNAL_FREE(CCAST(char *, *str));
   *str = NULL;
 } // func __kmp_str_free
 
 /* If len is zero, returns true iff target and data have exact case-insensitive
    match. If len is negative, returns true iff target is a case-insensitive
    substring of data. If len is positive, returns true iff target is a
    case-insensitive substring of data or vice versa, and neither is shorter than
    len. */

openmp/trunk/runtime/src/kmp_taskdeps.cpp

static void __kmp_init_node(kmp_depnode_t *node) {
   __kmp_init_lock(&node->dn.lock);
   node->dn.nrefs = 1; // init creates the first reference to the node
 #ifdef KMP_SUPPORT_GRAPH_OUTPUT
   node->dn.id = KMP_TEST_THEN_INC32(&kmp_node_id_seed);
 #endif
 }
 
 static inline kmp_depnode_t *__kmp_node_ref(kmp_depnode_t *node) {
-  KMP_TEST_THEN_INC32(&node->dn.nrefs);
+  KMP_TEST_THEN_INC32(CCAST(kmp_int32 *, &node->dn.nrefs));
   return node;
 }
 
 static inline void __kmp_node_deref(kmp_info_t *thread, kmp_depnode_t *node) {
   if (!node)
     return;
 
-  kmp_int32 n = KMP_TEST_THEN_DEC32(&node->dn.nrefs) - 1;
+  kmp_int32 n = KMP_TEST_THEN_DEC32(CCAST(kmp_int32 *, &node->dn.nrefs)) - 1;
   if (n == 0) {
     KMP_ASSERT(node->dn.nrefs == 0);
 #if USE_FAST_MEMORY
     __kmp_fast_free(thread, node);
 #else
     __kmp_thread_free(thread, node);
 #endif
   }
#endif
   KMP_MB();
 
   // Account for our initial fake value
   npredecessors++;
 
   // Update predecessors and obtain current value to check if there are still
   // any outstandig dependences (some tasks may have finished while we processed
   // the dependences)
-  npredecessors = KMP_TEST_THEN_ADD32(&node->dn.npredecessors, npredecessors) +
-                  npredecessors;
+  npredecessors =
+      KMP_TEST_THEN_ADD32(CCAST(kmp_int32 *, &node->dn.npredecessors),
+                          npredecessors) +
 
   KA_TRACE(20, ("__kmp_check_deps: T#%d found %d predecessors for task %p \n",
                 gtid, npredecessors, taskdata));
 
   // beyond this point the task could be queued (and executed) by a releasing
   // task...
   return npredecessors > 0 ? true : false;
 }
void __kmp_release_deps(kmp_int32 gtid, kmp_taskdata_t *task) {
   node->dn.task =
       NULL; // mark this task as finished, so no new dependencies are generated
   KMP_RELEASE_DEPNODE(gtid, node);
 
   kmp_depnode_list_t *next;
   for (kmp_depnode_list_t *p = node->dn.successors; p; p = next) {
     kmp_depnode_t *successor = p->node;
     kmp_int32 npredecessors =
-        KMP_TEST_THEN_DEC32(&successor->dn.npredecessors) - 1;
-
+        KMP_TEST_THEN_DEC32(CCAST(kmp_int32 *, &successor->dn.npredecessors)) -
+        1;
     // successor task can be NULL for wait_depends or because deps are still
     // being processed
     if (npredecessors == 0) {
       KMP_MB();
       if (successor->dn.task) {
         KA_TRACE(20, ("__kmp_release_deps: T#%d successor %p of %p scheduled "
                       "for execution.\n",
                       gtid, successor->dn.task, task));

openmp/trunk/runtime/src/kmp_tasking.cpp

kmp_int32 team_serial =
       (taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser) &&
       !taskdata->td_flags.proxy;
 #else
   kmp_int32 team_serial =
       taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser;
 #endif
   KMP_DEBUG_ASSERT(taskdata->td_flags.tasktype == TASK_EXPLICIT);
 
-  kmp_int32 children =
-      KMP_TEST_THEN_DEC32((kmp_int32 *)(&taskdata->td_allocated_child_tasks)) -
+  kmp_int32 children = KMP_TEST_THEN_DEC32(CCAST(
+                           kmp_int32 *, &taskdata->td_allocated_child_tasks)) -
                        1;
   KMP_DEBUG_ASSERT(children >= 0);
 
   // Now, go up the ancestor tree to see if any ancestors can now be freed.
   while (children == 0) {
     kmp_taskdata_t *parent_taskdata = taskdata->td_parent;
 
     KA_TRACE(20, ("__kmp_free_task_and_ancestors(enter): T#%d task %p complete "
                   "and freeing itself\n",
                   gtid, taskdata));
 
     // --- Deallocate my ancestor task ---
     __kmp_free_task(gtid, taskdata, thread);
 
     taskdata = parent_taskdata;
 
     // Stop checking ancestors at implicit task instead of walking up ancestor
     // tree to avoid premature deallocation of ancestors.
     if (team_serial || taskdata->td_flags.tasktype == TASK_IMPLICIT)
       return;
 
     // Predecrement simulated by "- 1" calculation
     children = KMP_TEST_THEN_DEC32(
-                   (kmp_int32 *)(&taskdata->td_allocated_child_tasks)) -
+                   CCAST(kmp_int32 *, &taskdata->td_allocated_child_tasks)) -
                1;
     KMP_DEBUG_ASSERT(children >= 0);
   }
 
   KA_TRACE(
       20, ("__kmp_free_task_and_ancestors(exit): T#%d task %p has %d children; "
            "not freeing it yet\n",
            gtid, taskdata, children));
#endif /* BUILD_TIED_TASK_STACK */
   KMP_DEBUG_ASSERT(taskdata->td_flags.started == 1);
   KMP_DEBUG_ASSERT(taskdata->td_flags.freed == 0);
 
   // Only need to keep track of count if team parallel and tasking not
   // serialized
   if (!(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser)) {
     // Predecrement simulated by "- 1" calculation
     children =
-        KMP_TEST_THEN_DEC32(
-            (kmp_int32 *)(&taskdata->td_parent->td_incomplete_child_tasks)) -
+        KMP_TEST_THEN_DEC32(CCAST(
+            kmp_int32 *, &taskdata->td_parent->td_incomplete_child_tasks)) -
         1;
     KMP_DEBUG_ASSERT(children >= 0);
 #if OMP_40_ENABLED
     if (taskdata->td_taskgroup)
       KMP_TEST_THEN_DEC32((kmp_int32 *)(&taskdata->td_taskgroup->count));
 #if OMP_45_ENABLED
   }
   // if we found proxy tasks there could exist a dependency chain

 // serialized or if it is a proxy task
 #if OMP_45_ENABLED
   if (flags->proxy == TASK_PROXY ||
       !(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser))
 #else
   if (!(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser))
 #endif
   {
-    KMP_TEST_THEN_INC32((kmp_int32 *)(&parent_task->td_incomplete_child_tasks));
+    KMP_TEST_THEN_INC32(
+        CCAST(kmp_int32 *, &parent_task->td_incomplete_child_tasks));
 #if OMP_40_ENABLED
     if (parent_task->td_taskgroup)
       KMP_TEST_THEN_INC32((kmp_int32 *)(&parent_task->td_taskgroup->count));
 #endif
     // Only need to keep track of allocated child tasks for explicit tasks since
     // implicit not deallocated
     if (taskdata->td_parent->td_flags.tasktype == TASK_EXPLICIT) {
       KMP_TEST_THEN_INC32(
-          (kmp_int32 *)(&taskdata->td_parent->td_allocated_child_tasks));
+          CCAST(kmp_int32 *, &taskdata->td_parent->td_allocated_child_tasks));
     }
   }
 
   KA_TRACE(20, ("__kmp_task_alloc(exit): T#%d created task %p parent=%p\n",
                 gtid, taskdata, taskdata->td_parent));
   ANNOTATE_HAPPENS_BEFORE(task);
 
 #if OMPT_SUPPORT
#endif /* USE_ITT_BUILD */
     bool must_wait =
         !taskdata->td_flags.team_serial && !taskdata->td_flags.final;
 
 #if OMP_45_ENABLED
     must_wait = must_wait || (thread->th.th_task_team != NULL &&
                               thread->th.th_task_team->tt.tt_found_proxy_tasks);
 #endif
     if (must_wait) {
-      kmp_flag_32 flag(&(taskdata->td_incomplete_child_tasks), 0U);
+      kmp_flag_32 flag(
+          RCAST(volatile kmp_uint32 *, &taskdata->td_incomplete_child_tasks),
+          0U);
       while (TCR_4(taskdata->td_incomplete_child_tasks) != 0) {
         flag.execute_tasks(thread, gtid, FALSE,
                            &thread_finished USE_ITT_BUILD_ARG(itt_sync_obj),
                            __kmp_task_stealing_constraint);
       }
     }
 #if USE_ITT_BUILD
     if (itt_sync_obj != NULL)

 #if OMP_45_ENABLED
     if (!taskdata->td_flags.team_serial ||
         (thread->th.th_task_team != NULL &&
          thread->th.th_task_team->tt.tt_found_proxy_tasks))
 #else
     if (!taskdata->td_flags.team_serial)
 #endif
     {
-      kmp_flag_32 flag(&(taskgroup->count), 0U);
+      kmp_flag_32 flag(RCAST(kmp_uint32 *, &taskgroup->count), 0U);
       while (TCR_4(taskgroup->count) != 0) {
         flag.execute_tasks(thread, gtid, FALSE,
                            &thread_finished USE_ITT_BUILD_ARG(itt_sync_obj),
                            __kmp_task_stealing_constraint);
       }
     }
 
 #if USE_ITT_BUILD
static kmp_task_t *__kmp_remove_my_task(kmp_info_t *thread, kmp_int32 gtid,
 
   task = KMP_TASKDATA_TO_TASK(taskdata);
   return task;
 }
 
 // __kmp_steal_task: remove a task from another thread's deque
 // Assume that calling thread has already checked existence of
 // task_team thread_data before calling this routine.
-static kmp_task_t *
-__kmp_steal_task(kmp_info_t *victim, kmp_int32 gtid, kmp_task_team_t *task_team,
-                 volatile kmp_uint32 *unfinished_threads, int *thread_finished,
-                 kmp_int32 is_constrained)
-{
+static kmp_task_t *__kmp_steal_task(kmp_info_t *victim, kmp_int32 gtid,
+                                    kmp_task_team_t *task_team,
+                                    volatile kmp_int32 *unfinished_threads,
+                                    int *thread_finished,
+                                    kmp_int32 is_constrained) {
   kmp_task_t *task;
   kmp_taskdata_t *taskdata;
   kmp_thread_data_t *victim_td, *threads_data;
   kmp_int32 victim_tid;
 
   KMP_DEBUG_ASSERT(__kmp_tasking_mode != tskm_immediate_exec);
 
   threads_data = task_team->tt.tt_threads_data;
static kmp_task_t *__kmp_steal_task(kmp_info_t *victim, kmp_int32 gtid,
   }
   // Bump head pointer and Wrap.
   victim_td->td.td_deque_head =
       (victim_td->td.td_deque_head + 1) & TASK_DEQUE_MASK(victim_td->td);
   if (*thread_finished) {
     // We need to un-mark this victim as a finished victim.  This must be done
     // before releasing the lock, or else other threads (starting with the
     // master victim) might be prematurely released from the barrier!!!
-    kmp_uint32 count;
+    kmp_int32 count;
 
-    count = KMP_TEST_THEN_INC32((kmp_int32 *)unfinished_threads);
+    count = KMP_TEST_THEN_INC32(CCAST(kmp_int32 *, unfinished_threads));
 
     KA_TRACE(
         20,
         ("__kmp_steal_task: T#%d inc unfinished_threads to %d: task_team=%p\n",
          gtid, count + 1, task_team));
 
     *thread_finished = FALSE;
   }
   TCW_4(victim_td->td.td_deque_ntasks,
         TCR_4(victim_td->td.td_deque_ntasks) - 1);
 
-
   __kmp_release_bootstrap_lock(&victim_td->td.td_deque_lock);
 
   KMP_COUNT_BLOCK(TASK_stolen);
   KA_TRACE(
       10,
       ("__kmp_steal_task(exit #3): T#%d stole task %p from T#%d: task_team=%p "
        "ntasks=%d head=%u tail=%u\n",
        gtid, taskdata, __kmp_gtid_from_thread(victim), task_team,
        victim_td->td.td_deque_ntasks, victim_td->td.td_deque_head,
        victim_td->td.td_deque_tail));
 
   task = KMP_TASKDATA_TO_TASK(taskdata);
   return task;
 }
 
-
 // __kmp_execute_tasks_template: Choose and execute tasks until either the
 // condition is statisfied (return true) or there are none left (return false).
 //
 // final_spin is TRUE if this is the spin at the release barrier.
 // thread_finished indicates whether the thread is finished executing all
 // the tasks it has on its deque, and is at the release barrier.
 // spinner is the location on which to spin.
 // spinner == NULL means only execute a single task and return.
 // checker is the value to check to terminate the spin.
 template <class C>
 static inline int __kmp_execute_tasks_template(
     kmp_info_t *thread, kmp_int32 gtid, C *flag, int final_spin,
     int *thread_finished USE_ITT_BUILD_ARG(void *itt_sync_obj),
     kmp_int32 is_constrained) {
   kmp_task_team_t *task_team = thread->th.th_task_team;
   kmp_thread_data_t *threads_data;
   kmp_task_t *task;
   kmp_info_t *other_thread;
   kmp_taskdata_t *current_task = thread->th.th_current_task;
-  volatile kmp_uint32 *unfinished_threads;
+  volatile kmp_int32 *unfinished_threads;
   kmp_int32 nthreads, victim = -2, use_own_tasks = 1, new_victim = 0,
                       tid = thread->th.th_info.ds.ds_tid;
 
   KMP_DEBUG_ASSERT(__kmp_tasking_mode != tskm_immediate_exec);
   KMP_DEBUG_ASSERT(thread == __kmp_threads[gtid]);
 
   if (task_team == NULL)
     return FALSE;
 
   KA_TRACE(15, ("__kmp_execute_tasks_template(enter): T#%d final_spin=%d "
                 "*thread_finished=%d\n",
                 gtid, final_spin, *thread_finished));
 
   thread->th.th_reap_state = KMP_NOT_SAFE_TO_REAP;
   threads_data = (kmp_thread_data_t *)TCR_PTR(task_team->tt.tt_threads_data);
   KMP_DEBUG_ASSERT(threads_data != NULL);
 
   nthreads = task_team->tt.tt_nproc;
   unfinished_threads = &(task_team->tt.tt_unfinished_threads);
 #if OMP_45_ENABLED
   KMP_DEBUG_ASSERT(nthreads > 1 || task_team->tt.tt_found_proxy_tasks);
 #else
   KMP_DEBUG_ASSERT(nthreads > 1);
 #endif
-  KMP_DEBUG_ASSERT((int)(TCR_4(*unfinished_threads)) >= 0);
+  KMP_DEBUG_ASSERT(TCR_4(*unfinished_threads) >= 0);
 
   while (1) { // Outer loop keeps trying to find tasks in case of single thread
     // getting tasks from target constructs
     while (1) { // Inner loop to find a task and execute it
       task = NULL;
       if (use_own_tasks) { // check on own queue first
         task = __kmp_remove_my_task(thread, gtid, task_team, is_constrained);
       }
while (1) { // Inner loop to find a task and execute it
             // penalty for referencing another thread's kmp_info_t struct
             // anyway,
             // the check shouldn't cost too much performance at this point. In
             // extra barrier mode, tasks do not sleep at the separate tasking
             // barrier, so this isn't a problem.
             asleep = 0;
             if ((__kmp_tasking_mode == tskm_task_teams) &&
                 (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) &&
-                (TCR_PTR(other_thread->th.th_sleep_loc) != NULL)) {
+                (TCR_PTR(CCAST(void *, other_thread->th.th_sleep_loc)) !=
+                 NULL)) {
               asleep = 1;
               __kmp_null_resume_wrapper(__kmp_gtid_from_thread(other_thread),
                                         other_thread->th.th_sleep_loc);
               // A sleeping thread should not have any tasks on it's queue.
               // There is a slight possibility that it resumes, steals a task
               // from another thread, which spawns more tasks, all in the time
               // that it takes this thread to check => don't write an assertion
               // that the victim's queue is empty.  Try stealing from a

 #else
     if (final_spin)
 #endif
     {
       // First, decrement the #unfinished threads, if that has not already been
       // done.  This decrement might be to the spin location, and result in the
       // termination condition being satisfied.
       if (!*thread_finished) {
-        kmp_uint32 count;
+        kmp_int32 count;
 
-        count = KMP_TEST_THEN_DEC32((kmp_int32 *)unfinished_threads) - 1;
+        count = KMP_TEST_THEN_DEC32(CCAST(kmp_int32 *, unfinished_threads)) - 1;
         KA_TRACE(20, ("__kmp_execute_tasks_template: T#%d dec "
                       "unfinished_threads to %d task_team=%p\n",
                       gtid, count, task_team));
         *thread_finished = TRUE;
       }
 
       // It is now unsafe to reference thread->th.th_team !!!
       // Decrementing task_team->tt.tt_unfinished_threads can allow the master
for (i = 0; i < nthreads; i++) {
         continue;
       }
       // Since we haven't locked the thread's suspend mutex lock at this
       // point, there is a small window where a thread might be putting
       // itself to sleep, but hasn't set the th_sleep_loc field yet.
       // To work around this, __kmp_execute_tasks_template() periodically checks
       // see if other threads are sleeping (using the same random mechanism that
       // is used for task stealing) and awakens them if they are.
-      if ((sleep_loc = TCR_PTR(thread->th.th_sleep_loc)) != NULL) {
+      if ((sleep_loc = TCR_PTR(CCAST(void *, thread->th.th_sleep_loc))) !=
+          NULL) {
         KF_TRACE(50, ("__kmp_enable_tasking: T#%d waking up thread T#%d\n",
                       __kmp_gtid_from_thread(this_thr),
                       __kmp_gtid_from_thread(thread)));
         __kmp_null_resume_wrapper(__kmp_gtid_from_thread(thread), sleep_loc);
       } else {
         KF_TRACE(50, ("__kmp_enable_tasking: T#%d don't wake up thread T#%d\n",
                       __kmp_gtid_from_thread(this_thr),
                       __kmp_gtid_from_thread(thread)));
void __kmp_wait_to_unref_task_teams(void) {
   KMP_INIT_YIELD(spins);
 
   for (;;) {
     done = TRUE;
 
     // TODO: GEH - this may be is wrong because some sync would be necessary
     // in case threads are added to the pool during the traversal. Need to
     // verify that lock for thread pool is held when calling this routine.
-    for (thread = (kmp_info_t *)__kmp_thread_pool; thread != NULL;
+    for (thread = CCAST(kmp_info_t *, __kmp_thread_pool); thread != NULL;
          thread = thread->th.th_next_pool) {
 #if KMP_OS_WINDOWS
       DWORD exit_val;
 #endif
       if (TCR_PTR(thread->th.th_task_team) == NULL) {
         KA_TRACE(10, ("__kmp_wait_to_unref_task_team: T#%d task_team == NULL\n",
                       __kmp_gtid_from_thread(thread)));
         continue;
#endif
 
       KA_TRACE(10, ("__kmp_wait_to_unref_task_team: Waiting for T#%d to "
                     "unreference task_team\n",
                     __kmp_gtid_from_thread(thread)));
 
       if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) {
         volatile void *sleep_loc;
         // If the thread is sleeping, awaken it.
-        if ((sleep_loc = TCR_PTR(thread->th.th_sleep_loc)) != NULL) {
+        if ((sleep_loc = TCR_PTR(CCAST(void *, thread->th.th_sleep_loc))) !=
+            NULL) {
           KA_TRACE(
               10,
               ("__kmp_wait_to_unref_task_team: T#%d waking up thread T#%d\n",
                __kmp_gtid_from_thread(thread), __kmp_gtid_from_thread(thread)));
           __kmp_null_resume_wrapper(__kmp_gtid_from_thread(thread), sleep_loc);
         }
       }
     }
void __kmp_task_team_wait(
   if ((task_team != NULL) && KMP_TASKING_ENABLED(task_team)) {
     if (wait) {
       KA_TRACE(20, ("__kmp_task_team_wait: Master T#%d waiting for all tasks "
                     "(for unfinished_threads to reach 0) on task_team = %p\n",
                     __kmp_gtid_from_thread(this_thr), task_team));
       // Worker threads may have dropped through to release phase, but could
       // still be executing tasks. Wait here for tasks to complete. To avoid
       // memory contention, only master thread checks termination condition.
-      kmp_flag_32 flag(&task_team->tt.tt_unfinished_threads, 0U);
+      kmp_flag_32 flag(
+          RCAST(volatile kmp_uint32 *, &task_team->tt.tt_unfinished_threads),
+          0U);
       flag.wait(this_thr, TRUE USE_ITT_BUILD_ARG(itt_sync_obj));
     }
     // Deactivate the old task team, so that the worker threads will stop
     // referencing it while spinning.
     KA_TRACE(
         20,
         ("__kmp_task_team_wait: Master T#%d deactivating task_team %p: "
          "setting active to false, setting local and team's pointer to NULL\n",

 }
 
 // __kmp_tasking_barrier:
 // This routine may only called when __kmp_tasking_mode == tskm_extra_barrier.
 // Internal function to execute all tasks prior to a regular barrier or a join
 // barrier. It is a full barrier itself, which unfortunately turns regular
 // barriers into double barriers and join barriers into 1 1/2 barriers.
 void __kmp_tasking_barrier(kmp_team_t *team, kmp_info_t *thread, int gtid) {
-  volatile kmp_uint32 *spin =
-      &team->t.t_task_team[thread->th.th_task_state]->tt.tt_unfinished_threads;
+  volatile kmp_uint32 *spin = RCAST(
+      volatile kmp_uint32 *,
+      &team->t.t_task_team[thread->th.th_task_state]->tt.tt_unfinished_threads);
   int flag = FALSE;
   KMP_DEBUG_ASSERT(__kmp_tasking_mode == tskm_extra_barrier);
 
 #if USE_ITT_BUILD
   KMP_FSYNC_SPIN_INIT(spin, (kmp_uint32 *)NULL);
 #endif /* USE_ITT_BUILD */
   kmp_flag_32 spin_flag(spin, 0U);
   while (!spin_flag.execute_tasks(thread, gtid, TRUE,
                                   &flag USE_ITT_BUILD_ARG(NULL), 0)) {
 #if USE_ITT_BUILD
     // TODO: What about itt_sync_obj??
-    KMP_FSYNC_SPIN_PREPARE(spin);
+    KMP_FSYNC_SPIN_PREPARE(CCAST(void *, RCAST(volatile void *, spin)));
 #endif /* USE_ITT_BUILD */
 
     if (TCR_4(__kmp_global.g.g_done)) {
       if (__kmp_global.g.g_abort)
         __kmp_abort_thread();
       break;
     }
     KMP_YIELD(TRUE); // GH: We always yield here
   }
 #if USE_ITT_BUILD
-  KMP_FSYNC_SPIN_ACQUIRED((void *)spin);
+  KMP_FSYNC_SPIN_ACQUIRED(CCAST(void *, RCAST(volatile void *, spin)));
 #endif /* USE_ITT_BUILD */
 }
 
 #if OMP_45_ENABLED
 
 // __kmp_give_task puts a task into a given thread queue if:
 //  - the queue for that thread was created
 //  - there's space in that queue
static void __kmp_first_top_half_finish_proxy(kmp_taskdata_t *taskdata) {
   KMP_DEBUG_ASSERT(taskdata->td_flags.tasktype == TASK_EXPLICIT);
   KMP_DEBUG_ASSERT(taskdata->td_flags.proxy == TASK_PROXY);
   KMP_DEBUG_ASSERT(taskdata->td_flags.complete == 0);
   KMP_DEBUG_ASSERT(taskdata->td_flags.freed == 0);
 
   taskdata->td_flags.complete = 1; // mark the task as completed
 
   if (taskdata->td_taskgroup)
-    KMP_TEST_THEN_DEC32((kmp_int32 *)(&taskdata->td_taskgroup->count));
+    KMP_TEST_THEN_DEC32(&taskdata->td_taskgroup->count);
 
   // Create an imaginary children for this task so the bottom half cannot
   // release the task before we have completed the second top half
   TCI_4(taskdata->td_incomplete_child_tasks);
 }
 
 static void __kmp_second_top_half_finish_proxy(kmp_taskdata_t *taskdata) {
   kmp_int32 children = 0;
 
   // Predecrement simulated by "- 1" calculation
   children =
       KMP_TEST_THEN_DEC32(
-          (kmp_int32 *)(&taskdata->td_parent->td_incomplete_child_tasks)) -
+          CCAST(kmp_int32 *, &taskdata->td_parent->td_incomplete_child_tasks)) -
       1;
   KMP_DEBUG_ASSERT(children >= 0);
 
   // Remove the imaginary children
   TCD_4(taskdata->td_incomplete_child_tasks);
 }
 
 static void __kmp_bottom_half_finish_proxy(kmp_int32 gtid, kmp_task_t *ptask) {
#endif /* USE_FAST_MEMORY */
   taskdata->td_alloc_thread = thread;
   taskdata->td_taskgroup =
       parent_task
           ->td_taskgroup; // task inherits the taskgroup from the parent task
 
   // Only need to keep track of child task counts if team parallel and tasking
   // not serialized
   if (!(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser)) {
-    KMP_TEST_THEN_INC32((kmp_int32 *)(&parent_task->td_incomplete_child_tasks));
+    KMP_TEST_THEN_INC32(
+        CCAST(kmp_int32 *, &parent_task->td_incomplete_child_tasks));
     if (parent_task->td_taskgroup)
-      KMP_TEST_THEN_INC32((kmp_int32 *)(&parent_task->td_taskgroup->count));
+      KMP_TEST_THEN_INC32(&parent_task->td_taskgroup->count);
     // Only need to keep track of allocated child tasks for explicit tasks since
     // implicit not deallocated
     if (taskdata->td_parent->td_flags.tasktype == TASK_EXPLICIT)
       KMP_TEST_THEN_INC32(
-          (kmp_int32 *)(&taskdata->td_parent->td_allocated_child_tasks));
+          CCAST(kmp_int32 *, &taskdata->td_parent->td_allocated_child_tasks));
   }
 
   KA_TRACE(20,
            ("__kmp_task_dup_alloc(exit): Th %p, created task %p, parent=%p\n",
             thread, taskdata, taskdata->td_parent));
 #if OMPT_SUPPORT
   __kmp_task_init_ompt(taskdata, thread->th.th_info.ds.ds_gtid,
                        (void *)task->routine);

openmp/trunk/runtime/src/kmp_taskq.cpp

for (count = 0; count < queue->tq_nfull; ++count) {
       qs = (qs + 1) % queue->tq_nslots;
     }
 
     __kmp_printf("\n");
 
     if (in_parallel) {
       if (queue->tq_taskq_slot != NULL) {
         __kmp_printf("    TaskQ slot:\n");
-        __kmp_dump_thunk(tq, (kmpc_thunk_t *)queue->tq_taskq_slot, global_tid);
+        __kmp_dump_thunk(tq, CCAST(kmpc_thunk_t *, queue->tq_taskq_slot),
+                         global_tid);
         __kmp_printf("\n");
       }
       //__kmp_release_lock(& queue->tq_queue_lck, global_tid);
       //__kmp_release_lock(& queue->tq_free_thunks_lck, global_tid);
     }
   }
 
   __kmp_printf("    Taskq freelist: ");
static void __kmp_aux_dump_task_queue_tree(kmp_taskq_t *tq,
   if (curr_queue->tq_first_child) {
     //__kmp_acquire_lock(& curr_queue->tq_link_lck, global_tid);
 
     // Make sure data structures are in consistent state before querying them
     // Seems to work without this call for digital/alpha, needed for IBM/RS6000
     KMP_MB();
 
     if (curr_queue->tq_first_child) {
-      for (queue = (kmpc_task_queue_t *)curr_queue->tq_first_child;
+      for (queue = CCAST(kmpc_task_queue_t *, curr_queue->tq_first_child);
            queue != NULL; queue = queue->tq_next_child) {
         __kmp_aux_dump_task_queue_tree(tq, queue, level + 1, global_tid);
       }
     }
 
     //__kmp_release_lock(& curr_queue->tq_link_lck, global_tid);
   }
 }

 }
 
 static void __kmp_free_taskq(kmp_taskq_t *tq, kmpc_task_queue_t *p,
                              int in_parallel, kmp_int32 global_tid) {
   __kmpc_taskq_free(p->tq_thunk_space, global_tid);
   __kmpc_taskq_free(p->tq_queue, global_tid);
 
   /* free shared var structure storage */
-  __kmpc_taskq_free((void *)p->tq_shareds[0].ai_data, global_tid);
-
+  __kmpc_taskq_free(CCAST(kmpc_shared_vars_t *, p->tq_shareds[0].ai_data),
+                    global_tid);
   /* free array of pointers to shared vars storage */
   __kmpc_taskq_free(p->tq_shareds, global_tid);
 
 #ifdef KMP_DEBUG
   p->tq_first_child = NULL;
   p->tq_next_child = NULL;
   p->tq_prev_child = NULL;
   p->tq_ref_count = -10;
if (!(queue->tq_flags & TQF_DEALLOCATED)) {
       // Make sure data structures are in consistent state before querying them
       // Seems to work without this for digital/alpha, needed for IBM/RS6000
       KMP_MB();
 
       if ((queue->tq_taskq_slot != NULL) &&
           (queue->tq_nfull <= queue->tq_hiwat)) {
         /* if there's enough room in the queue and the dispatcher */
         /* (taskq task) is available, schedule more tasks         */
-        pt = (kmpc_thunk_t *)queue->tq_taskq_slot;
+        pt = CCAST(kmpc_thunk_t *, queue->tq_taskq_slot);
         queue->tq_taskq_slot = NULL;
       } else if (queue->tq_nfull == 0 ||
                  queue->tq_th_thunks[tid].ai_data >=
                      __KMP_TASKQ_THUNKS_PER_TH) {
         /* do nothing if no thunks available or this thread can't */
         /* run any because it already is executing too many       */
         pt = NULL;
       } else if (queue->tq_nfull > 1) {
__kmp_find_task_in_descendant_queue(kmp_int32 global_tid,
   kmpc_task_queue_t *queue = curr_queue;
 
   if (curr_queue->tq_first_child != NULL) {
     __kmp_acquire_lock(&curr_queue->tq_link_lck, global_tid);
     // Make sure data structures are in consistent state before querying them
     // Seems to work without this call for digital/alpha, needed for IBM/RS6000
     KMP_MB();
 
-    queue = (kmpc_task_queue_t *)curr_queue->tq_first_child;
+    queue = CCAST(kmpc_task_queue_t *, curr_queue->tq_first_child);
     if (queue == NULL) {
       __kmp_release_lock(&curr_queue->tq_link_lck, global_tid);
       return NULL;
     }
 
     while (queue != NULL) {
       int ct;
       kmpc_task_queue_t *next;
static void __kmp_find_and_remove_finished_child_taskq(
   kmpc_task_queue_t *queue = curr_queue;
 
   if (curr_queue->tq_first_child != NULL) {
     __kmp_acquire_lock(&curr_queue->tq_link_lck, global_tid);
     // Make sure data structures are in consistent state before querying them
     // Seems to work without this call for digital/alpha, needed for IBM/RS6000
     KMP_MB();
 
-    queue = (kmpc_task_queue_t *)curr_queue->tq_first_child;
+    queue = CCAST(kmpc_task_queue_t *, curr_queue->tq_first_child);
     if (queue != NULL) {
       __kmp_release_lock(&curr_queue->tq_link_lck, global_tid);
       return;
     }
 
     while (queue != NULL) {
       kmpc_task_queue_t *next;
       int ct = ++(queue->tq_ref_count);

 
 /* Starting from indicated queue, proceed downward through tree and remove all
    taskq's assuming all are finished and assuming NO other threads are executing
    at this point. */
 static void __kmp_remove_all_child_taskq(kmp_taskq_t *tq, kmp_int32 global_tid,
                                          kmpc_task_queue_t *queue) {
   kmpc_task_queue_t *next_child;
 
-  queue = (kmpc_task_queue_t *)queue->tq_first_child;
+  queue = CCAST(kmpc_task_queue_t *, queue->tq_first_child);
 
   while (queue != NULL) {
     __kmp_remove_all_child_taskq(tq, global_tid, queue);
 
     next_child = queue->tq_next_child;
     queue->tq_flags |= TQF_DEALLOCATED;
     __kmp_remove_queue_from_tree(tq, global_tid, queue, FALSE);
     queue = next_child;
static void __kmp_execute_task_from_queue(kmp_taskq_t *tq, ident_t *loc,
    * 3) __kmp_execute_task_from_queue  : push
    *
    * execution ordering:  1,(2,3)*,4
    */
 
   if (!(thunk->th_flags & TQF_TASKQ_TASK)) {
     kmp_int32 index = (queue == tq->tq_root) ? tid : 0;
     thunk->th.th_shareds =
-        (kmpc_shared_vars_t *)queue->tq_shareds[index].ai_data;
+        CCAST(kmpc_shared_vars_t *, queue->tq_shareds[index].ai_data);
 
     if (__kmp_env_consistency_check) {
       __kmp_push_workshare(global_tid,
                            (queue->tq_flags & TQF_IS_ORDERED) ? ct_task_ordered
                                                               : ct_task,
                            queue->tq_loc);
     }
   } else {
if (in_parallel) {
       // This shouldn't be a barrier region boundary, it will confuse the user.
       /* Need the boundary to be at the end taskq instead. */
       if (__kmp_barrier(bs_plain_barrier, global_tid, TRUE, 0, NULL, NULL)) {
         /* Creating the active root queue, and we are not the master thread. */
         /* The master thread below created the queue and tasks have been     */
         /* enqueued, and the master thread released this barrier.  This      */
         /* worker thread can now proceed and execute tasks.  See also the    */
         /* TQF_RELEASE_WORKERS which is used to handle this case.            */
-        *shareds = (kmpc_shared_vars_t *)tq->tq_root->tq_shareds[tid].ai_data;
-
+        *shareds =
+            CCAST(kmpc_shared_vars_t *, tq->tq_root->tq_shareds[tid].ai_data);
         KE_TRACE(10, ("__kmpc_taskq return (%d)\n", global_tid));
 
         return NULL;
       }
     }
 
     /* master thread only executes this code */
     if (tq->tq_curr_thunk_capacity < nproc) {
if ((new_queue->tq_flags & TQF_IS_ORDERED) && in_parallel) {
     /* Vector ORDERED SECTION to taskq version */
     th->th.th_dispatch->th_deo_fcn = __kmp_taskq_eo;
 
     /* Vector ORDERED SECTION to taskq version */
     th->th.th_dispatch->th_dxo_fcn = __kmp_taskq_xo;
   }
 
   /*  create a new thunk for the taskq_task in the new_queue  */
-  *shareds = (kmpc_shared_vars_t *)new_queue->tq_shareds[0].ai_data;
+  *shareds = CCAST(kmpc_shared_vars_t *, new_queue->tq_shareds[0].ai_data);
 
   new_taskq_thunk->th.th_shareds = *shareds;
   new_taskq_thunk->th_task = taskq_task;
   new_taskq_thunk->th_flags = new_queue->tq_flags | TQF_TASKQ_TASK;
   new_taskq_thunk->th_status = 0;
 
   KMP_DEBUG_ASSERT(new_taskq_thunk->th_flags & TQF_TASKQ_TASK);
 
if (!tq->tq_root) {
 
       __kmp_acquire_lock(&curr_queue->tq_link_lck, global_tid);
 
       // Make sure data structures are in consistent state before querying them
       // Seems to work without this for digital/alpha, needed for IBM/RS6000
       KMP_MB();
 
       new_queue->tq_next_child =
-          (struct kmpc_task_queue_t *)curr_queue->tq_first_child;
+          CCAST(struct kmpc_task_queue_t *, curr_queue->tq_first_child);
 
       if (curr_queue->tq_first_child != NULL)
         curr_queue->tq_first_child->tq_prev_child = new_queue;
 
       curr_queue->tq_first_child = new_queue;
 
       __kmp_release_lock(&curr_queue->tq_link_lck, global_tid);
     }
void __kmpc_end_taskq_task(ident_t *loc, kmp_int32 global_tid,
   in_parallel = (queue->tq_flags & TQF_PARALLEL_CONTEXT);
   tid = __kmp_tid_from_gtid(global_tid);
 
   if (__kmp_env_consistency_check)
     __kmp_pop_workshare(global_tid, ct_taskq, loc);
 
   if (in_parallel) {
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-
-    KMP_TEST_THEN_OR32(&queue->tq_flags, (kmp_int32)TQF_ALL_TASKS_QUEUED);
+    KMP_TEST_THEN_OR32(CCAST(kmp_int32 *, &queue->tq_flags),
+                       (kmp_int32)TQF_ALL_TASKS_QUEUED);
 #else
     {
       __kmp_acquire_lock(&queue->tq_queue_lck, global_tid);
 
       // Make sure data structures are in consistent state before querying them
       // Seems to work without this for digital/alpha, needed for IBM/RS6000
       KMP_MB();
 
/* Normally, __kmp_find_task_in_queue() refuses to schedule the last task in
        TQF_IS_LAST_TASK; when that task actually executes mark it via th_flags &
        TQF_IS_LAST_TASK (this th_flags bit signals the instrumented code to do
        copy-outs after execution). */
     if (!in_parallel) {
       /* No synchronization needed for serial context */
       queue->tq_flags |= TQF_IS_LAST_TASK;
     } else {
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-
-      KMP_TEST_THEN_OR32(&queue->tq_flags, (kmp_int32)TQF_IS_LAST_TASK);
+      KMP_TEST_THEN_OR32(CCAST(kmp_int32 *, &queue->tq_flags),
+                         (kmp_int32)TQF_IS_LAST_TASK);
 #else
       {
         __kmp_acquire_lock(&queue->tq_queue_lck, global_tid);
 
         // Make sure data structures in consistent state before querying them
         // Seems to work without this for digital/alpha, needed for IBM/RS6000
         KMP_MB();
 
kmpc_thunk_t *__kmpc_task_buffer(ident_t *loc, kmp_int32 global_tid,
 
   /* The instrumentation sequence is:  __kmpc_task_buffer(), initialize private
      variables, __kmpc_task().  The __kmpc_task_buffer routine checks that the
      task queue is not full and allocates a thunk (which is then passed to
      __kmpc_task()).  So, we can pre-allocate a thunk here assuming it will be
      the next to be enqueued in __kmpc_task(). */
 
   new_thunk = __kmp_alloc_thunk(queue, in_parallel, global_tid);
-  new_thunk->th.th_shareds = (kmpc_shared_vars_t *)queue->tq_shareds[0].ai_data;
+  new_thunk->th.th_shareds =
+      CCAST(kmpc_shared_vars_t *, queue->tq_shareds[0].ai_data);
   new_thunk->th_encl_thunk = NULL;
   new_thunk->th_task = task;
 
   /* GEH - shouldn't need to lock the read of tq_flags here */
   new_thunk->th_flags = queue->tq_flags & TQF_INTERFACE_FLAGS;
 
   new_thunk->th_status = 0;
 

openmp/trunk/runtime/src/kmp_utility.cpp

static kmp_uint64 __kmp_parse_frequency( // R: Frequency in Hz.
   double value = 0.0;
   char const *unit = NULL;
   kmp_uint64 result = 0; /* Zero is a better unknown value than all ones. */
 
   if (frequency == NULL) {
     return result;
   }; // if
   value = strtod(frequency,
-                 (char **)&unit); // strtod() does not like "char const *".
+                 CCAST(char **, &unit)); // strtod() does not like "const"
   if (0 < value &&
       value <= DBL_MAX) { // Good value (not overflow, underflow, etc).
     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;

openmp/trunk/runtime/src/kmp_wait_release.h

__kmp_wait_template(kmp_info_t *this_thr, C *flag,
   int oversubscribed;
 #if !KMP_USE_MONITOR
   kmp_uint64 poll_count;
   kmp_uint64 hibernate_goal;
 #endif
 
   KMP_FSYNC_SPIN_INIT(spin, NULL);
   if (flag->done_check()) {
-    KMP_FSYNC_SPIN_ACQUIRED(spin);
+    KMP_FSYNC_SPIN_ACQUIRED(CCAST(typename C::flag_t *, spin));
     return;
   }
   th_gtid = this_thr->th.th_info.ds.ds_gtid;
   KA_TRACE(20,
            ("__kmp_wait_sleep: T#%d waiting for flag(%p)\n", th_gtid, flag));
 #if KMP_STATS_ENABLED
   stats_state_e thread_state = KMP_GET_THREAD_STATE();
 #endif
if (__kmp_tasking_mode != tskm_immediate_exec) {
           this_thr->th.th_task_team = NULL;
           this_thr->th.th_reap_state = KMP_SAFE_TO_REAP;
         }
       } else {
         this_thr->th.th_reap_state = KMP_SAFE_TO_REAP;
       } // if
     } // if
 
-    KMP_FSYNC_SPIN_PREPARE(spin);
+    KMP_FSYNC_SPIN_PREPARE(CCAST(typename C::flag_t *, spin));
     if (TCR_4(__kmp_global.g.g_done)) {
       if (__kmp_global.g.g_abort)
         __kmp_abort_thread();
       break;
     }
 
     // If we are oversubscribed, or have waited a bit (and
     // KMP_LIBRARY=throughput), then yield
     KMP_YIELD(oversubscribed);
     // TODO: Should it be number of cores instead of thread contexts? Like:
     // KMP_YIELD(TCR_4(__kmp_nth) > __kmp_ncores);
     // Need performance improvement data to make the change...
     KMP_YIELD_SPIN(spins);
     // Check if this thread was transferred from a team
     // to the thread pool (or vice-versa) while spinning.
     in_pool = !!TCR_4(this_thr->th.th_in_pool);
     if (in_pool != !!this_thr->th.th_active_in_pool) {
       if (in_pool) { // Recently transferred from team to pool
-        KMP_TEST_THEN_INC32((kmp_int32 *)&__kmp_thread_pool_active_nth);
+        KMP_TEST_THEN_INC32(CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
         this_thr->th.th_active_in_pool = TRUE;
         /* Here, we cannot assert that:
            KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) <=
            __kmp_thread_pool_nth);
            __kmp_thread_pool_nth is inc/dec'd by the master thread while the
            fork/join lock is held, whereas __kmp_thread_pool_active_nth is
            inc/dec'd asynchronously by the workers. The two can get out of sync
            for brief periods of time.  */
       } else { // Recently transferred from pool to team
-        KMP_TEST_THEN_DEC32((kmp_int32 *)&__kmp_thread_pool_active_nth);
+        KMP_TEST_THEN_DEC32(CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
         KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) >= 0);
         this_thr->th.th_active_in_pool = FALSE;
       }
     }
 
 #if KMP_STATS_ENABLED
     // Check if thread has been signalled to idle state
     // This indicates that the logical "join-barrier" has finished
#if KMP_STATS_ENABLED
   // If we were put into idle state, pop that off the state stack
   if (KMP_GET_THREAD_STATE() == IDLE) {
     KMP_POP_PARTITIONED_TIMER();
     KMP_SET_THREAD_STATE(thread_state);
     this_thr->th.th_stats->resetIdleFlag();
   }
 #endif
 
-  KMP_FSYNC_SPIN_ACQUIRED(spin);
+  KMP_FSYNC_SPIN_ACQUIRED(CCAST(typename C::flag_t *, spin));
 }
 
 /* Release any threads specified as waiting on the flag by releasing the flag
    and resume the waiting thread if indicated by the sleep bit(s). A thread that
    calls __kmp_wait_template must call this function to wake up the potentially
    sleeping thread and prevent deadlocks!  */
 template <class C> static inline void __kmp_release_template(C *flag) {
 #ifdef KMP_DEBUG
   int gtid = TCR_4(__kmp_init_gtid) ? __kmp_get_gtid() : -1;
 #endif
   KF_TRACE(20, ("__kmp_release: T#%d releasing flag(%x)\n", gtid, flag->get()));
   KMP_DEBUG_ASSERT(flag->get());
-  KMP_FSYNC_RELEASING(flag->get());
+  KMP_FSYNC_RELEASING(CCAST(typename C::flag_t *, flag->get()));
 
   flag->internal_release();
 
   KF_TRACE(100, ("__kmp_release: T#%d set new spin=%d\n", gtid, flag->get(),
                  *(flag->get())));
 
   if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) {
     // Only need to check sleep stuff if infinite block time not set.

 
 template <typename FlagType> struct flag_traits {};
 
 template <> struct flag_traits<kmp_uint32> {
   typedef kmp_uint32 flag_t;
   static const flag_type t = flag32;
   static inline flag_t tcr(flag_t f) { return TCR_4(f); }
   static inline flag_t test_then_add4(volatile flag_t *f) {
-    return KMP_TEST_THEN_ADD4_32((volatile kmp_int32 *)f);
+    return KMP_TEST_THEN_ADD4_32(RCAST(kmp_int32 *, CCAST(flag_t *, f)));
   }
   static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
-    return KMP_TEST_THEN_OR32((volatile kmp_int32 *)f, v);
+    return KMP_TEST_THEN_OR32(CCAST(flag_t *, f), v);
   }
   static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
-    return KMP_TEST_THEN_AND32((volatile kmp_int32 *)f, v);
+    return KMP_TEST_THEN_AND32(CCAST(flag_t *, f), v);
   }
 };
 
 template <> struct flag_traits<kmp_uint64> {
   typedef kmp_uint64 flag_t;
   static const flag_type t = flag64;
   static inline flag_t tcr(flag_t f) { return TCR_8(f); }
   static inline flag_t test_then_add4(volatile flag_t *f) {
-    return KMP_TEST_THEN_ADD4_64((volatile kmp_int64 *)f);
+    return KMP_TEST_THEN_ADD4_64(RCAST(kmp_int64 *, CCAST(flag_t *, f)));
   }
   static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
-    return KMP_TEST_THEN_OR64((volatile kmp_int64 *)f, v);
+    return KMP_TEST_THEN_OR64(CCAST(flag_t *, f), v);
   }
   static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
-    return KMP_TEST_THEN_AND64((volatile kmp_int64 *)f, v);
+    return KMP_TEST_THEN_AND64(CCAST(flag_t *, f), v);
   }
 };
 
 template <typename FlagType> class kmp_basic_flag : public kmp_flag<FlagType> {
   typedef flag_traits<FlagType> traits_type;
   FlagType checker; /**< Value to compare flag to to check if flag has been
                        released. */
   kmp_info_t
class kmp_flag_oncore : public kmp_flag<kmp_uint64> {
   enum barrier_type bt; /**< Barrier type. */
   kmp_info_t *this_thr; /**< Thread that may be redirected to different flag
                            location. */
 #if USE_ITT_BUILD
   void *
       itt_sync_obj; /**< ITT object that must be passed to new flag location. */
 #endif
   unsigned char &byteref(volatile kmp_uint64 *loc, size_t offset) {
-    return ((unsigned char *)loc)[offset];
+    return RCAST(unsigned char *, CCAST(kmp_uint64 *, loc))[offset];
   }
 
 public:
   kmp_flag_oncore(volatile kmp_uint64 *p)
       : kmp_flag<kmp_uint64>(p, flag_oncore), num_waiting_threads(0),
         flag_switch(false) {}
   kmp_flag_oncore(volatile kmp_uint64 *p, kmp_uint32 idx)
       : kmp_flag<kmp_uint64>(p, flag_oncore), num_waiting_threads(0),
#endif
     return false;
   }
   void internal_release() {
     if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME) {
       byteref(get(), offset) = 1;
     } else {
       kmp_uint64 mask = 0;
       byteref(&mask, offset) = 1;
-      (void)KMP_TEST_THEN_OR64((volatile kmp_int64 *)get(), mask);
+      KMP_TEST_THEN_OR64(CCAST(kmp_uint64 *, get()), mask);
     }
   }
   kmp_uint64 set_sleeping() {
-    return KMP_TEST_THEN_OR64((kmp_int64 volatile *)get(),
+    return KMP_TEST_THEN_OR64(CCAST(kmp_uint64 *, get()),
                               KMP_BARRIER_SLEEP_STATE);
   }
   kmp_uint64 unset_sleeping() {
-    return KMP_TEST_THEN_AND64((kmp_int64 volatile *)get(),
+    return KMP_TEST_THEN_AND64(CCAST(kmp_uint64 *, get()),
                                ~KMP_BARRIER_SLEEP_STATE);
   }
   bool is_sleeping_val(kmp_uint64 old_loc) {
     return old_loc & KMP_BARRIER_SLEEP_STATE;
   }
   bool is_sleeping() { return is_sleeping_val(*get()); }
   bool is_any_sleeping() { return is_sleeping_val(*get()); }
   void wait(kmp_info_t *this_thr, int final_spin) {

 };
 
 // Used to wake up threads, volatile void* flag is usually the th_sleep_loc
 // associated with int gtid.
 static inline void __kmp_null_resume_wrapper(int gtid, volatile void *flag) {
   if (!flag)
     return;
 
-  switch (((kmp_flag_64 *)flag)->get_type()) {
+  switch (RCAST(kmp_flag_64 *, CCAST(void *, flag))->get_type()) {
   case flag32:
     __kmp_resume_32(gtid, NULL);
     break;
   case flag64:
     __kmp_resume_64(gtid, NULL);
     break;
   case flag_oncore:
     __kmp_resume_oncore(gtid, NULL);

openmp/trunk/runtime/src/z_Linux_util.cpp

#ifdef DEBUG_SUSPEND
                    buffer);
 #endif
       // Mark the thread as no longer active (only in the first iteration of the
       // loop).
       if (!deactivated) {
         th->th.th_active = FALSE;
         if (th->th.th_active_in_pool) {
           th->th.th_active_in_pool = FALSE;
-          KMP_TEST_THEN_DEC32((kmp_int32 *)&__kmp_thread_pool_active_nth);
+          KMP_TEST_THEN_DEC32(
+              CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
           KMP_DEBUG_ASSERT(TCR_4(__kmp_thread_pool_active_nth) >= 0);
         }
         deactivated = TRUE;
       }
 
 #if USE_SUSPEND_TIMEOUT
       struct timespec now;
       struct timeval tval;
#ifdef KMP_DEBUG
       }
 #endif
     } // while
 
     // Mark the thread as active again (if it was previous marked as inactive)
     if (deactivated) {
       th->th.th_active = TRUE;
       if (TCR_4(th->th.th_in_pool)) {
-        KMP_TEST_THEN_INC32((kmp_int32 *)&__kmp_thread_pool_active_nth);
+        KMP_TEST_THEN_INC32(CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
         th->th.th_active_in_pool = TRUE;
       }
     }
   }
 #ifdef DEBUG_SUSPEND
   {
     char buffer[128];
     __kmp_print_cond(buffer, &th->th.th_suspend_cv);
#endif
   KMP_DEBUG_ASSERT(gtid != target_gtid);
 
   __kmp_suspend_initialize_thread(th);
 
   status = pthread_mutex_lock(&th->th.th_suspend_mx.m_mutex);
   KMP_CHECK_SYSFAIL("pthread_mutex_lock", status);
 
   if (!flag) { // coming from __kmp_null_resume_wrapper
-    flag = (C *)th->th.th_sleep_loc;
+    flag = (C *)CCAST(void *, th->th.th_sleep_loc);
   }
 
   // First, check if the flag is null or its type has changed. If so, someone
   // else woke it up.
   if (!flag || flag->get_type() != flag->get_ptr_type()) { // get_ptr_type
     // simply shows what
     // flag was cast to
     KF_TRACE(5, ("__kmp_resume_template: T#%d exiting, thread T#%d already "
#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;
   mach_msg_type_number_t num = HOST_BASIC_INFO_COUNT;
   rc = host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&info, &num);
   if (rc == 0 && num == HOST_BASIC_INFO_COUNT) {
-// Cannot use KA_TRACE() here because this code works before trace support is
-// initialized.
+    // Cannot use KA_TRACE() here because this code works before trace support
+    // is initialized.
     r = info.avail_cpus;
   } else {
     KMP_WARNING(CantGetNumAvailCPU);
     KMP_INFORM(AssumedNumCPU);
   }; // if
 
 #else
 
finish: // Clean up and exit.
   return running_threads;
 
 } // __kmp_get_load_balance
 
 #endif // KMP_OS_DARWIN
 
 #endif // USE_LOAD_BALANCE
 
-#if !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_MIC || ((KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64) || KMP_ARCH_PPC64)
+#if !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_MIC ||                            \
+      ((KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64) || KMP_ARCH_PPC64)
 
 // we really only need the case with 1 argument, because CLANG always build
 // a struct of pointers to shared variables referenced in the outlined function
 int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int tid, int argc,
                            void *p_argv[]
 #if OMPT_SUPPORT
                            ,
                            void **exit_frame_ptr