Second part of -Wcast-qual option enabling for OpenMP RTL code

[AndreyChurbanov]

Summary

Previous patch r307020 has broken Windows build, mostly because changes were done in places of Linux compilers warnings without paying attention to Windows specific code.

This patch adds more consistency and also fixes the Windows build of the library.

• all atomics now accept volatile pointer parameter; this allows to simplify a lot of type conversions.
• NULL pointer value changed to nullptr in sensible places.
• all 32-bit and 64-bit AND/OR atomics accept unsigned parameters (not only Unix specific that initial patch did).

Tried to build the library on Windows, and on Linux.

[jlpeyton]

LGTM

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 *)CCAST(void *, a))->first);
-  const Address *bb =
-      (const Address *)&(((AddrUnsPair *)CCAST(void *, b))->first);
+  const Address *aa = &(((const AddrUnsPair *)a)->first);
+  const Address *bb = &(((const AddrUnsPair *)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;

openmp/trunk/runtime/src/kmp_affinity.cpp

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 = *(RCAST(unsigned **, CCAST(void *, a)));
-  const unsigned *bb = *(RCAST(unsigned **, CCAST(void *, b)));
+  const unsigned *aa = *(unsigned *const *)a;
+  const unsigned *bb = *(unsigned *const *)b;
   for (i = maxIndex;; i--) {
     if (aa[i] < bb[i])
       return -1;
     if (aa[i] > bb[i])
       return 1;
     if (i == osIdIndex)
       break;
   }
while (!feof(f)) {
     char s1[] = "processor";
     if (strncmp(buf, s1, sizeof(s1) - 1) == 0) {
       num_records++;
       continue;
     }
 
     // FIXME - this will match "node_<n> <garbage>"
     unsigned level;
-    if (KMP_SSCANF(buf, "node_%d id", &level) == 1) {
+    if (KMP_SSCANF(buf, "node_%u id", &level) == 1) {
       if (nodeIdIndex + level >= maxIndex) {
         maxIndex = nodeIdIndex + level;
       }
       continue;
     }
   }
 
   // Check for empty file / no valid processor records, or too many. The number

 
 #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 *)CCAST(void *, a))->first);
-  const Address *bb =
-      (const Address *)&(((AddrUnsPair *)CCAST(void *, b))->first);
+  const Address *aa = &(((const AddrUnsPair *)a)->first);
+  const Address *bb = &(((const AddrUnsPair *)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

 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,
-                                        CCAST(void *, old_value), NULL)) {
+                                        CCAST(void *, old_value), nullptr)) {
         KMP_CPU_PAUSE();
         old_value = TCR_SYNC_PTR(th->th.th_local.bget_list);
       }
       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));
if (ptr != NULL) {
     goto end;
   };
   ptr = TCR_SYNC_PTR(this_thr->th.th_free_lists[index].th_free_list_sync);
   if (ptr != NULL) {
     // no-sync free list is empty, use sync free list (filled in by other
     // threads only)
     // pop the head of the sync free list, push NULL instead
     while (!KMP_COMPARE_AND_STORE_PTR(
-        &this_thr->th.th_free_lists[index].th_free_list_sync, ptr, NULL)) {
+        &this_thr->th.th_free_lists[index].th_free_list_sync, ptr, nullptr)) {
       KMP_CPU_PAUSE();
       ptr = TCR_SYNC_PTR(this_thr->th.th_free_lists[index].th_free_list_sync);
     }
     // push the rest of chain into no-sync free list (can be NULL if there was
     // the only block)
     this_thr->th.th_free_lists[index].th_free_list_self = *((void **)ptr);
     KMP_DEBUG_ASSERT(
         this_thr ==

openmp/trunk/runtime/src/kmp_barrier.cpp

(void)__kmp_init_hierarchical_barrier_thread(bt, thr_bar, nproc, gtid, tid,
                                                team);
 
   if (thr_bar->my_level) { // not a leaf (my_level==0 means leaf)
     kmp_int32 child_tid;
     new_state =
         (kmp_uint64)team->t.t_bar[bt].b_arrived + KMP_BARRIER_STATE_BUMP;
     if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
         thr_bar->use_oncore_barrier) {
-      if (thr_bar->leaf_kids) { // First, wait for leaf children to check-in on
-        // my b_arrived flag
+      if (thr_bar->leaf_kids) {
+        // First, wait for leaf children to check-in on my b_arrived flag
         kmp_uint64 leaf_state =
             KMP_MASTER_TID(tid)
                 ? thr_bar->b_arrived | thr_bar->leaf_state
                 : team->t.t_bar[bt].b_arrived | thr_bar->leaf_state;
         KA_TRACE(20, ("__kmp_hierarchical_barrier_gather: T#%d(%d:%d) waiting "
                       "for leaf kids\n",
                       gtid, team->t.t_id, tid));
         kmp_flag_64 flag(&thr_bar->b_arrived, leaf_state);
if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
             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);
         }
         // clear leaf_state bits
-        KMP_TEST_THEN_AND64(CCAST(kmp_uint64 *, &thr_bar->b_arrived),
-                            ~(thr_bar->leaf_state));
+        KMP_TEST_THEN_AND64(&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;

openmp/trunk/runtime/src/kmp_csupport.cpp

__kmp_init_indirect_csptr(kmp_critical_name *crit, ident_t const *loc,
   KMP_I_LOCK_FUNC(ilk, init)(ilk->lock);
   KMP_SET_I_LOCK_LOCATION(ilk, loc);
   KMP_SET_I_LOCK_FLAGS(ilk, kmp_lf_critical_section);
   KA_TRACE(20,
            ("__kmp_init_indirect_csptr: initialized indirect lock #%d\n", tag));
 #if USE_ITT_BUILD
   __kmp_itt_critical_creating(ilk->lock, loc);
 #endif
-  int status = KMP_COMPARE_AND_STORE_PTR(lck, 0, ilk);
+  int status = KMP_COMPARE_AND_STORE_PTR(lck, nullptr, ilk);
   if (status == 0) {
 #if USE_ITT_BUILD
     __kmp_itt_critical_destroyed(ilk->lock);
 #endif
     // We don't really need to destroy the unclaimed lock here since it will be
     // cleaned up at program exit.
     // KMP_D_LOCK_FUNC(&idx, destroy)((kmp_dyna_lock_t *)&idx);
   }
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(
-        CCAST(kmp_uint32 *, &pr_buf->th_doacross_flags[iter_number]), flag);
+    KMP_TEST_THEN_OR32(&pr_buf->th_doacross_flags[iter_number], flag);
   KA_TRACE(20, ("__kmpc_doacross_post() exit: T#%d iter %lld posted\n", gtid,
                 (iter_number << 5) + shft));
 }
 
 void __kmpc_doacross_fini(ident_t *loc, int gtid) {
   kmp_int64 num_done;
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;

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(CCAST(kmp_int32 *, p), d);
+  r = KMP_TEST_THEN_ADD32(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(CCAST(kmp_int64 *, p), d);
+  r = KMP_TEST_THEN_ADD64(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(CCAST(kmp_int32 *, p));
+  r = KMP_TEST_THEN_INC_ACQ32(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(CCAST(kmp_int64 *, p));
+  r = KMP_TEST_THEN_INC_ACQ64(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(CCAST(kmp_int32 *, p));
+  r = KMP_TEST_THEN_INC32(p);
   return r;
 }
 
 template <>
 __forceinline kmp_int64 test_then_inc<kmp_int64>(volatile kmp_int64 *p) {
   kmp_int64 r;
-  r = KMP_TEST_THEN_INC64(CCAST(kmp_int64 *, p));
+  r = KMP_TEST_THEN_INC64(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 <>
if (active) {
     // 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 =
-        RCAST(dispatch_shared_info_t *,
-              CCAST(dispatch_shared_info_template<UT> *, sh));
+        CCAST(dispatch_shared_info_t *, (volatile dispatch_shared_info_t *)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
             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>(
-                RCAST(ST *, CCAST(UT *, &sh->u.s.iteration)), (ST)chunkspec);
+                RCAST(volatile ST *, &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>(RCAST(ST *, CCAST(UT *, &sh->u.s.iteration)),
+          if (compare_and_swap<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
                                    (ST)init, (ST)limit)) {
             // CAS was successful, chunk obtained
             status = 1;
             --limit;
             break;
           } // if
         } // while
         if (status != 0) {
#endif
             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>(
-                RCAST(ST *, CCAST(UT *, &sh->u.s.iteration)), (ST)chunk);
+                RCAST(volatile ST *, &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>(RCAST(ST *, CCAST(UT *, &sh->u.s.iteration)),
+          if (compare_and_swap<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
                                    (ST)init, (ST)limit)) {
             // CAS was successful, chunk obtained
             status = 1;
             --limit;
             break;
           } // if
         } // while
         if (status != 0) {

openmp/trunk/runtime/src/kmp_lock.cpp

 #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(
-            RCAST(kmp_int64 *, CCAST(kmp_int32 *, tail_id_p)),
-            KMP_PACK_64(head, head), KMP_PACK_64(-1, 0));
+            RCAST(volatile kmp_int64 *, 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(
-      RCAST(kmp_int64 *, CCAST(kmp_uint64 *, &lck->lk.next_ticket)));
+  kmp_uint64 ticket =
+      KMP_TEST_THEN_INC64(RCAST(volatile kmp_int64 *, &lck->lk.next_ticket));
   kmp_uint64 mask = TCR_8(lck->lk.mask); // 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 */

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))
+// macros to cast out qualifiers and to re-interpret types
 #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> {
template <> struct traits_t<unsigned long long> {
   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

 #define KMP_TEST_THEN_ADD4_ACQ32(p)                                            \
   InterlockedExchangeAdd((volatile long *)(p), 4)
 #define KMP_TEST_THEN_DEC32(p) InterlockedExchangeAdd((volatile long *)(p), -1)
 #define KMP_TEST_THEN_DEC_ACQ32(p)                                             \
   InterlockedExchangeAdd((volatile long *)(p), -1)
 #define KMP_TEST_THEN_ADD32(p, v)                                              \
   InterlockedExchangeAdd((volatile long *)(p), (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);
 #define KMP_COMPARE_AND_STORE_RET32(p, cv, sv)                                 \
   InterlockedCompareExchange((volatile long *)(p), (long)(sv), (long)(cv))
 
 #define KMP_XCHG_FIXED32(p, v)                                                 \
   InterlockedExchange((volatile long *)(p), (long)(v))
 #define KMP_XCHG_FIXED64(p, v)                                                 \
   InterlockedExchange64((volatile kmp_int64 *)(p), (kmp_int64)(v))
 
 inline kmp_real32 KMP_XCHG_REAL32(volatile kmp_real32 *p, kmp_real32 v) {
   kmp_int32 tmp = InterlockedExchange((volatile long *)p, *(long *)&v);
   return *(kmp_real32 *)&tmp;
 }
 
 // Routines that we still need to implement in assembly.
+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);
 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);
+extern kmp_uint32 __kmp_test_then_or32(volatile kmp_uint32 *p, kmp_uint32 v);
+extern kmp_uint32 __kmp_test_then_and32(volatile kmp_uint32 *p, kmp_uint32 v);
 extern kmp_int64 __kmp_test_then_add64(volatile kmp_int64 *p, kmp_int64 v);
-extern kmp_int64 __kmp_test_then_or64(volatile kmp_int64 *p, kmp_int64 v);
-extern kmp_int64 __kmp_test_then_and64(volatile kmp_int64 *p, kmp_int64 v);
+extern kmp_uint64 __kmp_test_then_or64(volatile kmp_uint64 *p, kmp_uint64 v);
+extern kmp_uint64 __kmp_test_then_and64(volatile kmp_uint64 *p, kmp_uint64 v);
 
 extern kmp_int8 __kmp_compare_and_store8(volatile kmp_int8 *p, kmp_int8 cv,
                                          kmp_int8 sv);
 extern kmp_int16 __kmp_compare_and_store16(volatile kmp_int16 *p, kmp_int16 cv,
                                            kmp_int16 sv);
 extern kmp_int32 __kmp_compare_and_store32(volatile kmp_int32 *p, kmp_int32 cv,
                                            kmp_int32 sv);
 extern kmp_int32 __kmp_compare_and_store64(volatile kmp_int64 *p, kmp_int64 cv,
                                            kmp_int64 sv);
 extern kmp_int8 __kmp_compare_and_store_ret8(volatile kmp_int8 *p, kmp_int8 cv,
                                              kmp_int8 sv);
 extern kmp_int16 __kmp_compare_and_store_ret16(volatile kmp_int16 *p,
                                                kmp_int16 cv, kmp_int16 sv);
 extern kmp_int32 __kmp_compare_and_store_ret32(volatile kmp_int32 *p,
                                                kmp_int32 cv, kmp_int32 sv);
 extern kmp_int64 __kmp_compare_and_store_ret64(volatile kmp_int64 *p,
                                                kmp_int64 cv, kmp_int64 sv);
 
 extern kmp_int8 __kmp_xchg_fixed8(volatile kmp_int8 *p, kmp_int8 v);
 extern kmp_int16 __kmp_xchg_fixed16(volatile kmp_int16 *p, kmp_int16 v);
 extern kmp_int32 __kmp_xchg_fixed32(volatile kmp_int32 *p, kmp_int32 v);
 extern kmp_int64 __kmp_xchg_fixed64(volatile kmp_int64 *p, kmp_int64 v);
 extern kmp_real32 __kmp_xchg_real32(volatile kmp_real32 *p, kmp_real32 v);
 extern kmp_real64 __kmp_xchg_real64(volatile kmp_real64 *p, kmp_real64 v);
-#define KMP_TEST_THEN_ADD8(p, v) __kmp_test_then_add8((p), (v))
 
-//# define KMP_TEST_THEN_INC32(p)                 __kmp_test_then_add32( (p), 1
-//)
-#define KMP_TEST_THEN_OR8(p, v) __kmp_test_then_or8((p), (v))
-#define KMP_TEST_THEN_AND8(p, v) __kmp_test_then_and8((p), (v))
-//# define KMP_TEST_THEN_INC_ACQ32(p)             __kmp_test_then_add32( (p), 1
-//)
+//#define KMP_TEST_THEN_INC32(p) __kmp_test_then_add32((p), 1)
+//#define KMP_TEST_THEN_INC_ACQ32(p) __kmp_test_then_add32((p), 1)
 #define KMP_TEST_THEN_INC64(p) __kmp_test_then_add64((p), 1LL)
 #define KMP_TEST_THEN_INC_ACQ64(p) __kmp_test_then_add64((p), 1LL)
-//# define KMP_TEST_THEN_ADD4_32(p)               __kmp_test_then_add32( (p), 4
-//)
-//# define KMP_TEST_THEN_ADD4_ACQ32(p)            __kmp_test_then_add32( (p), 4
-//)
+//#define KMP_TEST_THEN_ADD4_32(p) __kmp_test_then_add32((p), 4)
+//#define KMP_TEST_THEN_ADD4_ACQ32(p) __kmp_test_then_add32((p), 4)
 #define KMP_TEST_THEN_ADD4_64(p) __kmp_test_then_add64((p), 4LL)
 #define KMP_TEST_THEN_ADD4_ACQ64(p) __kmp_test_then_add64((p), 4LL)
-//# define KMP_TEST_THEN_DEC32(p)                 __kmp_test_then_add32( (p), -1
-//)
-//# define KMP_TEST_THEN_DEC_ACQ32(p)             __kmp_test_then_add32( (p), -1
-//)
+//#define KMP_TEST_THEN_DEC32(p) __kmp_test_then_add32((p), -1)
+//#define KMP_TEST_THEN_DEC_ACQ32(p) __kmp_test_then_add32((p), -1)
 #define KMP_TEST_THEN_DEC64(p) __kmp_test_then_add64((p), -1LL)
 #define KMP_TEST_THEN_DEC_ACQ64(p) __kmp_test_then_add64((p), -1LL)
-//# define KMP_TEST_THEN_ADD32(p, v)              __kmp_test_then_add32( (p),
-//(v) )
+//#define KMP_TEST_THEN_ADD32(p, v) __kmp_test_then_add32((p), (v))
+#define KMP_TEST_THEN_ADD8(p, v) __kmp_test_then_add8((p), (v))
 #define KMP_TEST_THEN_ADD64(p, v) __kmp_test_then_add64((p), (v))
 
+#define KMP_TEST_THEN_OR8(p, v) __kmp_test_then_or8((p), (v))
+#define KMP_TEST_THEN_AND8(p, v) __kmp_test_then_and8((p), (v))
 #define KMP_TEST_THEN_OR32(p, v) __kmp_test_then_or32((p), (v))
 #define KMP_TEST_THEN_AND32(p, v) __kmp_test_then_and32((p), (v))
 #define KMP_TEST_THEN_OR64(p, v) __kmp_test_then_or64((p), (v))
 #define KMP_TEST_THEN_AND64(p, v) __kmp_test_then_and64((p), (v))
 
 #define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)                                  \
   __kmp_compare_and_store8((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)                                  \
   __kmp_compare_and_store8((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv)                                 \
   __kmp_compare_and_store16((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_REL16(p, cv, sv)                                 \
   __kmp_compare_and_store16((p), (cv), (sv))
 #define KMP_COMPARE_AND_STORE_ACQ32(p, cv, sv)                                 \
-  __kmp_compare_and_store32((p), (cv), (sv))
+  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
+                            (kmp_int32)(sv))
 #define KMP_COMPARE_AND_STORE_REL32(p, cv, sv)                                 \
-  __kmp_compare_and_store32((p), (cv), (sv))
+  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
+                            (kmp_int32)(sv))
 #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
-  __kmp_compare_and_store64((p), (cv), (sv))
+  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
+                            (kmp_int64)(sv))
 #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
-  __kmp_compare_and_store64((p), (cv), (sv))
+  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
+                            (kmp_int64)(sv))
 
 #if KMP_ARCH_X86
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __kmp_compare_and_store32(RCAST(volatile kmp_int32 *, p),                    \
-                            RCAST(kmp_int32, cv), RCAST(kmp_int32, sv))
+  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
+                            (kmp_int32)(sv))
 #else /* 64 bit pointers */
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __kmp_compare_and_store64(RCAST(volatile kmp_int64 *, p),                    \
-                            RCAST(kmp_int64, cv), RCAST(kmp_int64, sv))
+  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
+                            (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))
+  __kmp_compare_and_store_ret64((volatile kmp_int64 *)(p), (kmp_int64)(cv),    \
+                                (kmp_int64)(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_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_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_TEST_THEN_INC32(p)                                                 \
+  __sync_fetch_and_add((volatile kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_INC_ACQ32(p)                                             \
+  __sync_fetch_and_add((volatile kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_INC64(p)                                                 \
+  __sync_fetch_and_add((volatile kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_INC_ACQ64(p)                                             \
+  __sync_fetch_and_add((volatile kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_ADD4_32(p)                                               \
+  __sync_fetch_and_add((volatile kmp_int32 *)(p), 4)
+#define KMP_TEST_THEN_ADD4_ACQ32(p)                                            \
+  __sync_fetch_and_add((volatile kmp_int32 *)(p), 4)
+#define KMP_TEST_THEN_ADD4_64(p)                                               \
+  __sync_fetch_and_add((volatile kmp_int64 *)(p), 4LL)
+#define KMP_TEST_THEN_ADD4_ACQ64(p)                                            \
+  __sync_fetch_and_add((volatile kmp_int64 *)(p), 4LL)
+#define KMP_TEST_THEN_DEC32(p)                                                 \
+  __sync_fetch_and_sub((volatile kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_DEC_ACQ32(p)                                             \
+  __sync_fetch_and_sub((volatile kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_DEC64(p)                                                 \
+  __sync_fetch_and_sub((volatile kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_DEC_ACQ64(p)                                             \
+  __sync_fetch_and_sub((volatile kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_ADD8(p, v)                                               \
+  __sync_fetch_and_add((volatile kmp_int8 *)(p), (kmp_int8)(v))
+#define KMP_TEST_THEN_ADD32(p, v)                                              \
+  __sync_fetch_and_add((volatile kmp_int32 *)(p), (kmp_int32)(v))
+#define KMP_TEST_THEN_ADD64(p, v)                                              \
+  __sync_fetch_and_add((volatile kmp_int64 *)(p), (kmp_int64)(v))
+
+#define KMP_TEST_THEN_OR8(p, v)                                                \
+  __sync_fetch_and_or((volatile kmp_int8 *)(p), (kmp_int8)(v))
+#define KMP_TEST_THEN_AND8(p, v)                                               \
+  __sync_fetch_and_and((volatile kmp_int8 *)(p), (kmp_int8)(v))
+#define KMP_TEST_THEN_OR32(p, v)                                               \
+  __sync_fetch_and_or((volatile kmp_uint32 *)(p), (kmp_uint32)(v))
+#define KMP_TEST_THEN_AND32(p, v)                                              \
+  __sync_fetch_and_and((volatile kmp_uint32 *)(p), (kmp_uint32)(v))
+#define KMP_TEST_THEN_OR64(p, v)                                               \
+  __sync_fetch_and_or((volatile kmp_uint64 *)(p), (kmp_uint64)(v))
+#define KMP_TEST_THEN_AND64(p, v)                                              \
+  __sync_fetch_and_and((volatile kmp_uint64 *)(p), (kmp_uint64)(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)                                 \
#define KMP_XCHG_FIXED8(p, v)                                                  \
   __sync_lock_test_and_set((volatile kmp_uint8 *)(p), (kmp_uint8)(v))
 #define KMP_XCHG_FIXED16(p, v)                                                 \
   __sync_lock_test_and_set((volatile kmp_uint16 *)(p), (kmp_uint16)(v))
 #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(CAST_FLT_INT(p), *(kmp_int32 *)&v);
+  kmp_int32 tmp =
+      __sync_lock_test_and_set((volatile kmp_uint32 *)(p), *(kmp_uint32 *)&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(CAST_DBL_INT(p), *(kmp_int64 *)&v);
+  kmp_int64 tmp =
+      __sync_lock_test_and_set((volatile kmp_uint64 *)(p), *(kmp_uint64 *)&v);
   return *(kmp_real64 *)&tmp;
 }
 
 #else
 
+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);
 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);
+extern kmp_uint32 __kmp_test_then_or32(volatile kmp_uint32 *p, kmp_uint32 v);
+extern kmp_uint32 __kmp_test_then_and32(volatile kmp_uint32 *p, kmp_uint32 v);
 extern kmp_int64 __kmp_test_then_add64(volatile kmp_int64 *p, kmp_int64 v);
-extern kmp_int64 __kmp_test_then_or64(volatile kmp_int64 *p, kmp_int64 v);
-extern kmp_int64 __kmp_test_then_and64(volatile kmp_int64 *p, kmp_int64 v);
+extern kmp_uint64 __kmp_test_then_or64(volatile kmp_uint64 *p, kmp_uint64 v);
+extern kmp_uint64 __kmp_test_then_and64(volatile kmp_uint64 *p, kmp_uint64 v);
 
 extern kmp_int8 __kmp_compare_and_store8(volatile kmp_int8 *p, kmp_int8 cv,
                                          kmp_int8 sv);
 extern kmp_int16 __kmp_compare_and_store16(volatile kmp_int16 *p, kmp_int16 cv,
                                            kmp_int16 sv);
 extern kmp_int32 __kmp_compare_and_store32(volatile kmp_int32 *p, kmp_int32 cv,
                                            kmp_int32 sv);
 extern kmp_int32 __kmp_compare_and_store64(volatile kmp_int64 *p, kmp_int64 cv,
                                            kmp_int64 sv);
 extern kmp_int8 __kmp_compare_and_store_ret8(volatile kmp_int8 *p, kmp_int8 cv,
                                              kmp_int8 sv);
 extern kmp_int16 __kmp_compare_and_store_ret16(volatile kmp_int16 *p,
                                                kmp_int16 cv, kmp_int16 sv);
 extern kmp_int32 __kmp_compare_and_store_ret32(volatile kmp_int32 *p,
                                                kmp_int32 cv, kmp_int32 sv);
 extern kmp_int64 __kmp_compare_and_store_ret64(volatile kmp_int64 *p,
                                                kmp_int64 cv, kmp_int64 sv);
 
 extern kmp_int8 __kmp_xchg_fixed8(volatile kmp_int8 *p, kmp_int8 v);
 extern kmp_int16 __kmp_xchg_fixed16(volatile kmp_int16 *p, kmp_int16 v);
 extern kmp_int32 __kmp_xchg_fixed32(volatile kmp_int32 *p, kmp_int32 v);
 extern kmp_int64 __kmp_xchg_fixed64(volatile kmp_int64 *p, kmp_int64 v);
 extern kmp_real32 __kmp_xchg_real32(volatile kmp_real32 *p, kmp_real32 v);
-#define KMP_TEST_THEN_ADD8(p, v) __kmp_test_then_add8((p), (v))
 extern kmp_real64 __kmp_xchg_real64(volatile kmp_real64 *p, kmp_real64 v);
 
-#define KMP_TEST_THEN_INC32(p) __kmp_test_then_add32((p), 1)
-#define KMP_TEST_THEN_OR8(p, v) __kmp_test_then_or8((p), (v))
-#define KMP_TEST_THEN_AND8(p, v) __kmp_test_then_and8((p), (v))
-#define KMP_TEST_THEN_INC_ACQ32(p) __kmp_test_then_add32((p), 1)
-#define KMP_TEST_THEN_INC64(p) __kmp_test_then_add64((p), 1LL)
-#define KMP_TEST_THEN_INC_ACQ64(p) __kmp_test_then_add64((p), 1LL)
-#define KMP_TEST_THEN_ADD4_32(p) __kmp_test_then_add32((p), 4)
-#define KMP_TEST_THEN_ADD4_ACQ32(p) __kmp_test_then_add32((p), 4)
-#define KMP_TEST_THEN_ADD4_64(p) __kmp_test_then_add64((p), 4LL)
-#define KMP_TEST_THEN_ADD4_ACQ64(p) __kmp_test_then_add64((p), 4LL)
-#define KMP_TEST_THEN_DEC32(p) __kmp_test_then_add32((p), -1)
-#define KMP_TEST_THEN_DEC_ACQ32(p) __kmp_test_then_add32((p), -1)
-#define KMP_TEST_THEN_DEC64(p) __kmp_test_then_add64((p), -1LL)
-#define KMP_TEST_THEN_DEC_ACQ64(p) __kmp_test_then_add64((p), -1LL)
-#define KMP_TEST_THEN_ADD32(p, v) __kmp_test_then_add32((p), (v))
-#define KMP_TEST_THEN_ADD64(p, v) __kmp_test_then_add64((p), (v))
-
-#define KMP_TEST_THEN_OR32(p, v) __kmp_test_then_or32((p), (v))
-#define KMP_TEST_THEN_AND32(p, v) __kmp_test_then_and32((p), (v))
-#define KMP_TEST_THEN_OR64(p, v) __kmp_test_then_or64((p), (v))
-#define KMP_TEST_THEN_AND64(p, v) __kmp_test_then_and64((p), (v))
+#define KMP_TEST_THEN_INC32(p)                                                 \
+  __kmp_test_then_add32((volatile kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_INC_ACQ32(p)                                             \
+  __kmp_test_then_add32((volatile kmp_int32 *)(p), 1)
+#define KMP_TEST_THEN_INC64(p)                                                 \
+  __kmp_test_then_add64((volatile kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_INC_ACQ64(p)                                             \
+  __kmp_test_then_add64((volatile kmp_int64 *)(p), 1LL)
+#define KMP_TEST_THEN_ADD4_32(p)                                               \
+  __kmp_test_then_add32((volatile kmp_int32 *)(p), 4)
+#define KMP_TEST_THEN_ADD4_ACQ32(p)                                            \
+  __kmp_test_then_add32((volatile kmp_int32 *)(p), 4)
+#define KMP_TEST_THEN_ADD4_64(p)                                               \
+  __kmp_test_then_add64((volatile kmp_int64 *)(p), 4LL)
+#define KMP_TEST_THEN_ADD4_ACQ64(p)                                            \
+  __kmp_test_then_add64((volatile kmp_int64 *)(p), 4LL)
+#define KMP_TEST_THEN_DEC32(p)                                                 \
+  __kmp_test_then_add32((volatile kmp_int32 *)(p), -1)
+#define KMP_TEST_THEN_DEC_ACQ32(p)                                             \
+  __kmp_test_then_add32((volatile kmp_int32 *)(p), -1)
+#define KMP_TEST_THEN_DEC64(p)                                                 \
+  __kmp_test_then_add64((volatile kmp_int64 *)(p), -1LL)
+#define KMP_TEST_THEN_DEC_ACQ64(p)                                             \
+  __kmp_test_then_add64((volatile kmp_int64 *)(p), -1LL)
+#define KMP_TEST_THEN_ADD8(p, v)                                               \
+  __kmp_test_then_add8((volatile kmp_int8 *)(p), (kmp_int8)(v))
+#define KMP_TEST_THEN_ADD32(p, v)                                              \
+  __kmp_test_then_add32((volatile kmp_int32 *)(p), (kmp_int32)(v))
+#define KMP_TEST_THEN_ADD64(p, v)                                              \
+  __kmp_test_then_add64((volatile kmp_int64 *)(p), (kmp_int64)(v))
+
+#define KMP_TEST_THEN_OR8(p, v)                                                \
+  __kmp_test_then_or8((volatile kmp_int8 *)(p), (kmp_int8)(v))
+#define KMP_TEST_THEN_AND8(p, v)                                               \
+  __kmp_test_then_and8((volatile kmp_int8 *)(p), (kmp_int8)(v))
+#define KMP_TEST_THEN_OR32(p, v)                                               \
+  __kmp_test_then_or32((volatile kmp_uint32 *)(p), (kmp_uint32)(v))
+#define KMP_TEST_THEN_AND32(p, v)                                              \
+  __kmp_test_then_and32((volatile kmp_uint32 *)(p), (kmp_uint32)(v))
+#define KMP_TEST_THEN_OR64(p, v)                                               \
+  __kmp_test_then_or64((volatile kmp_uint64 *)(p), (kmp_uint64)(v))
+#define KMP_TEST_THEN_AND64(p, v)                                              \
+  __kmp_test_then_and64((volatile kmp_uint64 *)(p), (kmp_uint64)(v))
 
 #define KMP_COMPARE_AND_STORE_ACQ8(p, cv, sv)                                  \
-  __kmp_compare_and_store8((p), (cv), (sv))
+  __kmp_compare_and_store8((volatile kmp_int8 *)(p), (kmp_int8)(cv),           \
+                           (kmp_int8)(sv))
 #define KMP_COMPARE_AND_STORE_REL8(p, cv, sv)                                  \
-  __kmp_compare_and_store8((p), (cv), (sv))
+  __kmp_compare_and_store8((volatile kmp_int8 *)(p), (kmp_int8)(cv),           \
+                           (kmp_int8)(sv))
 #define KMP_COMPARE_AND_STORE_ACQ16(p, cv, sv)                                 \
-  __kmp_compare_and_store16((p), (cv), (sv))
+  __kmp_compare_and_store16((volatile kmp_int16 *)(p), (kmp_int16)(cv),        \
+                            (kmp_int16)(sv))
 #define KMP_COMPARE_AND_STORE_REL16(p, cv, sv)                                 \
-  __kmp_compare_and_store16((p), (cv), (sv))
+  __kmp_compare_and_store16((volatile kmp_int16 *)(p), (kmp_int16)(cv),        \
+                            (kmp_int16)(sv))
 #define KMP_COMPARE_AND_STORE_ACQ32(p, cv, sv)                                 \
-  __kmp_compare_and_store32((p), (cv), (sv))
+  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
+                            (kmp_int32)(sv))
 #define KMP_COMPARE_AND_STORE_REL32(p, cv, sv)                                 \
-  __kmp_compare_and_store32((p), (cv), (sv))
+  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
+                            (kmp_int32)(sv))
 #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
-  __kmp_compare_and_store64((p), (cv), (sv))
+  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
+                            (kmp_int64)(sv))
 #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
-  __kmp_compare_and_store64((p), (cv), (sv))
+  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
+                            (kmp_int64)(sv))
 
 #if KMP_ARCH_X86
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __kmp_compare_and_store32(RCAST(volatile kmp_int32 *, p),                    \
-                            RCAST(kmp_int32, cv), RCAST(kmp_int32, sv))
+  __kmp_compare_and_store32((volatile kmp_int32 *)(p), (kmp_int32)(cv),        \
+                            (kmp_int32)(sv))
 #else /* 64 bit pointers */
 #define KMP_COMPARE_AND_STORE_PTR(p, cv, sv)                                   \
-  __kmp_compare_and_store64(RCAST(volatile kmp_int64 *, p),                    \
-                            RCAST(kmp_int64, cv), RCAST(kmp_int64, sv))
+  __kmp_compare_and_store64((volatile kmp_int64 *)(p), (kmp_int64)(cv),        \
+                            (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))
+  __kmp_compare_and_store_ret32((volatile kmp_int32 *)(p), (kmp_int32)(cv),    \
+                                (kmp_int32)(sv))
 #define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \
-  __kmp_compare_and_store_ret64((p), (cv), (sv))
+  __kmp_compare_and_store_ret64((volatile kmp_int64 *)(p), (kmp_int64)(cv),    \
+                                (kmp_int64)(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_REAL64(p, v) __kmp_xchg_real64((p), (v));

 #ifndef KMP_LD_ACQ32
 #define KMP_LD_ACQ32(A) (*(A))
 #endif
 
 #ifndef KMP_LD_ACQ64
 #define KMP_LD_ACQ64(A) (*(A))
 #endif
 
-#define TCR_1(a) (a)
-#define TCW_1(a, b) (a) = (b)
 /* ------------------------------------------------------------------------ */
 // FIXME - maybe this should this be
 //
 // #define TCR_4(a)    (*(volatile kmp_int32 *)(&a))
 // #define TCW_4(a,b)  (a) = (*(volatile kmp_int32 *)&(b))
 //
 // #define TCR_8(a)    (*(volatile kmp_int64 *)(a))
 // #define TCW_8(a,b)  (a) = (*(volatile kmp_int64 *)(&b))
 //
 // I'm fairly certain this is the correct thing to do, but I'm afraid
 // of performance regressions.
 
+#define TCR_1(a) (a)
+#define TCW_1(a, b) (a) = (b)
 #define TCR_4(a) (a)
 #define TCW_4(a, b) (a) = (b)
 #define TCI_4(a) (++(a))
 #define TCD_4(a) (--(a))
 #define TCR_8(a) (a)
 #define TCW_8(a, b) (a) = (b)
 #define TCI_8(a) (++(a))
 #define TCD_8(a) (--(a))

openmp/trunk/runtime/src/kmp_runtime.cpp

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(CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
+      KMP_TEST_THEN_DEC32(&__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
 

openmp/trunk/runtime/src/kmp_settings.cpp

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 = RCAST(kmp_setting_t *, CCAST(void *, _a));
-  kmp_setting_t *b = RCAST(kmp_setting_t *, CCAST(void *, _b));
+  const kmp_setting_t *a = RCAST(const kmp_setting_t *, _a);
+  const kmp_setting_t *b = RCAST(const kmp_setting_t *, _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;

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(CCAST(
-                           kmp_int32 *, &taskdata->td_allocated_child_tasks)) -
-                       1;
+  kmp_int32 children =
+      KMP_TEST_THEN_DEC32(&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(
-                   CCAST(kmp_int32 *, &taskdata->td_allocated_child_tasks)) -
-               1;
+    children = KMP_TEST_THEN_DEC32(&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(CCAST(
-            kmp_int32 *, &taskdata->td_parent->td_incomplete_child_tasks)) -
+        KMP_TEST_THEN_DEC32(&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(
-        CCAST(kmp_int32 *, &parent_task->td_incomplete_child_tasks));
+    KMP_TEST_THEN_INC32(&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(
-          CCAST(kmp_int32 *, &taskdata->td_parent->td_allocated_child_tasks));
+      KMP_TEST_THEN_INC32(&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
static kmp_task_t *__kmp_steal_task(kmp_info_t *victim, kmp_int32 gtid,
   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_int32 count;
 
-    count = KMP_TEST_THEN_INC32(CCAST(kmp_int32 *, unfinished_threads));
+    count = KMP_TEST_THEN_INC32(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;
   }

 #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_int32 count;
 
-        count = KMP_TEST_THEN_DEC32(CCAST(kmp_int32 *, unfinished_threads)) - 1;
+        count = KMP_TEST_THEN_DEC32(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

 #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(CCAST(void *, RCAST(volatile void *, spin)));
+    KMP_FSYNC_SPIN_PREPARE(CCAST(kmp_uint32 *, 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(CCAST(void *, RCAST(volatile void *, spin)));
+  KMP_FSYNC_SPIN_ACQUIRED(CCAST(kmp_uint32 *, 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) {
   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(
-          CCAST(kmp_int32 *, &taskdata->td_parent->td_incomplete_child_tasks)) -
-      1;
+      KMP_TEST_THEN_DEC32(&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) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(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(
-        CCAST(kmp_int32 *, &parent_task->td_incomplete_child_tasks));
+    KMP_TEST_THEN_INC32(&parent_task->td_incomplete_child_tasks);
     if (parent_task->td_taskgroup)
       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(
-          CCAST(kmp_int32 *, &taskdata->td_parent->td_allocated_child_tasks));
+      KMP_TEST_THEN_INC32(&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

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(CCAST(kmp_int32 *, &queue->tq_flags),
-                       (kmp_int32)TQF_ALL_TASKS_QUEUED);
+    KMP_TEST_THEN_OR32(RCAST(volatile kmp_uint32 *, &queue->tq_flags),
+                       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(CCAST(kmp_int32 *, &queue->tq_flags),
-                         (kmp_int32)TQF_IS_LAST_TASK);
+      KMP_TEST_THEN_OR32(RCAST(volatile kmp_uint32 *, &queue->tq_flags),
+                         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();
 

openmp/trunk/runtime/src/kmp_wait_release.h

while (flag->notdone_check()) {
     // 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(CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
+        KMP_TEST_THEN_INC32(&__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(CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
+        KMP_TEST_THEN_DEC32(&__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

 
 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(RCAST(kmp_int32 *, CCAST(flag_t *, f)));
+    return KMP_TEST_THEN_ADD4_32(RCAST(volatile kmp_int32 *, f));
   }
   static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
-    return KMP_TEST_THEN_OR32(CCAST(flag_t *, f), v);
+    return KMP_TEST_THEN_OR32(f, v);
   }
   static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
-    return KMP_TEST_THEN_AND32(CCAST(flag_t *, f), v);
+    return KMP_TEST_THEN_AND32(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(RCAST(kmp_int64 *, CCAST(flag_t *, f)));
+    return KMP_TEST_THEN_ADD4_64(RCAST(volatile kmp_int64 *, f));
   }
   static inline flag_t test_then_or(volatile flag_t *f, flag_t v) {
-    return KMP_TEST_THEN_OR64(CCAST(flag_t *, f), v);
+    return KMP_TEST_THEN_OR64(f, v);
   }
   static inline flag_t test_then_and(volatile flag_t *f, flag_t v) {
-    return KMP_TEST_THEN_AND64(CCAST(flag_t *, f), v);
+    return KMP_TEST_THEN_AND64(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 RCAST(unsigned char *, CCAST(kmp_uint64 *, 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;
-      KMP_TEST_THEN_OR64(CCAST(kmp_uint64 *, get()), mask);
+      KMP_TEST_THEN_OR64(get(), mask);
     }
   }
   kmp_uint64 set_sleeping() {
-    return KMP_TEST_THEN_OR64(CCAST(kmp_uint64 *, get()),
-                              KMP_BARRIER_SLEEP_STATE);
+    return KMP_TEST_THEN_OR64(get(), KMP_BARRIER_SLEEP_STATE);
   }
   kmp_uint64 unset_sleeping() {
-    return KMP_TEST_THEN_AND64(CCAST(kmp_uint64 *, get()),
-                               ~KMP_BARRIER_SLEEP_STATE);
+    return KMP_TEST_THEN_AND64(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) {
     __kmp_wait_template<kmp_flag_oncore>(

openmp/trunk/runtime/src/thirdparty/ittnotify/ittnotify_config.h

 #endif /* __INTEL_COMPILER */
 #elif ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_IA32E /* ITT_ARCH!=ITT_ARCH_IA64 */
 ITT_INLINE long
 __TBB_machine_fetchadd4(volatile void* ptr, long addend) ITT_INLINE_ATTRIBUTE;
 ITT_INLINE long __TBB_machine_fetchadd4(volatile void* ptr, long addend)
 {
     long result;
     __asm__ __volatile__("lock\nxadd %0,%1"
-                          : "=r"(result),"=m"(*(int*)ptr)
-                          : "0"(addend), "m"(*(int*)ptr)
+                          : "=r"(result),"=m"(*(volatile int*)ptr)
+                          : "0"(addend), "m"(*(volatile int*)ptr)
                           : "memory");
     return result;
 }
 #elif ITT_ARCH==ITT_ARCH_ARM || ITT_ARCH==ITT_ARCH_PPC64 || ITT_ARCH==ITT_ARCH_AARCH64 || ITT_ARCH==ITT_ARCH_MIPS ||  ITT_ARCH==ITT_ARCH_MIPS64
 #define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val)
 #endif /* ITT_ARCH==ITT_ARCH_IA64 */
 #ifndef ITT_SIMPLE_INIT
 ITT_INLINE long

openmp/trunk/runtime/src/z_Linux_util.cpp

kmp_int8 __kmp_test_then_and8(volatile kmp_int8 *p, kmp_int8 d) {
   while (!KMP_COMPARE_AND_STORE_REL8(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_1(*p);
     new_value = old_value & d;
   }
   return old_value;
 }
 
-kmp_int32 __kmp_test_then_or32(volatile kmp_int32 *p, kmp_int32 d) {
-  kmp_int32 old_value, new_value;
+kmp_uint32 __kmp_test_then_or32(volatile kmp_uint32 *p, kmp_uint32 d) {
+  kmp_uint32 old_value, new_value;
 
   old_value = TCR_4(*p);
   new_value = old_value | d;
 
   while (!KMP_COMPARE_AND_STORE_REL32(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_4(*p);
     new_value = old_value | d;
   }
   return old_value;
 }
 
-kmp_int32 __kmp_test_then_and32(volatile kmp_int32 *p, kmp_int32 d) {
-  kmp_int32 old_value, new_value;
+kmp_uint32 __kmp_test_then_and32(volatile kmp_uint32 *p, kmp_uint32 d) {
+  kmp_uint32 old_value, new_value;
 
   old_value = TCR_4(*p);
   new_value = old_value & d;
 
   while (!KMP_COMPARE_AND_STORE_REL32(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_4(*p);
     new_value = old_value & d;
while (!KMP_COMPARE_AND_STORE_REL64(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_8(*p);
     new_value = old_value + d;
   }
   return old_value;
 }
 #endif /* KMP_ARCH_X86 */
 
-kmp_int64 __kmp_test_then_or64(volatile kmp_int64 *p, kmp_int64 d) {
-  kmp_int64 old_value, new_value;
+kmp_uint64 __kmp_test_then_or64(volatile kmp_uint64 *p, kmp_uint64 d) {
+  kmp_uint64 old_value, new_value;
 
   old_value = TCR_8(*p);
   new_value = old_value | d;
   while (!KMP_COMPARE_AND_STORE_REL64(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_8(*p);
     new_value = old_value | d;
   }
   return old_value;
 }
 
-kmp_int64 __kmp_test_then_and64(volatile kmp_int64 *p, kmp_int64 d) {
-  kmp_int64 old_value, new_value;
+kmp_uint64 __kmp_test_then_and64(volatile kmp_uint64 *p, kmp_uint64 d) {
+  kmp_uint64 old_value, new_value;
 
   old_value = TCR_8(*p);
   new_value = old_value & d;
   while (!KMP_COMPARE_AND_STORE_REL64(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_8(*p);
     new_value = old_value & d;
   }
#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(
-              CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
+          KMP_TEST_THEN_DEC32(&__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(CCAST(kmp_int32 *, &__kmp_thread_pool_active_nth));
+        KMP_TEST_THEN_INC32(&__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);

openmp/trunk/runtime/src/z_Windows_NT-586_util.cpp

kmp_int8 __kmp_test_then_and8(volatile kmp_int8 *p, kmp_int8 d) {
   while (!__kmp_compare_and_store8(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_1(*p);
     new_value = old_value & d;
   }
   return old_value;
 }
 
-kmp_int32 __kmp_test_then_or32(volatile kmp_int32 *p, kmp_int32 d) {
-  kmp_int32 old_value, new_value;
+kmp_uint32 __kmp_test_then_or32(volatile kmp_uint32 *p, kmp_uint32 d) {
+  kmp_uint32 old_value, new_value;
 
   old_value = TCR_4(*p);
   new_value = old_value | d;
 
-  while (!__kmp_compare_and_store32(p, old_value, new_value)) {
+  while (!__kmp_compare_and_store32((volatile kmp_int32 *)p, old_value,
+                                    new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_4(*p);
     new_value = old_value | d;
   }
   return old_value;
 }
 
-kmp_int32 __kmp_test_then_and32(volatile kmp_int32 *p, kmp_int32 d) {
-  kmp_int32 old_value, new_value;
+kmp_uint32 __kmp_test_then_and32(volatile kmp_uint32 *p, kmp_uint32 d) {
+  kmp_uint32 old_value, new_value;
 
   old_value = TCR_4(*p);
   new_value = old_value & d;
 
-  while (!__kmp_compare_and_store32(p, old_value, new_value)) {
+  while (!__kmp_compare_and_store32((volatile kmp_int32 *)p, old_value,
+                                    new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_4(*p);
     new_value = old_value & d;
   }
   return old_value;
 }
 
 kmp_int8 __kmp_test_then_add8(volatile kmp_int8 *p, kmp_int8 d) {
while (!__kmp_compare_and_store64(p, old_value, new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_8(*p);
     new_value = old_value + d;
   }
   return old_value;
 }
 #endif /* KMP_ARCH_X86 */
 
-kmp_int64 __kmp_test_then_or64(volatile kmp_int64 *p, kmp_int64 d) {
-  kmp_int64 old_value, new_value;
+kmp_uint64 __kmp_test_then_or64(volatile kmp_uint64 *p, kmp_uint64 d) {
+  kmp_uint64 old_value, new_value;
 
   old_value = TCR_8(*p);
   new_value = old_value | d;
-  while (!__kmp_compare_and_store64(p, old_value, new_value)) {
+  while (!__kmp_compare_and_store64((volatile kmp_int64 *)p, old_value,
+                                    new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_8(*p);
     new_value = old_value | d;
   }
 
   return old_value;
 }
 
-kmp_int64 __kmp_test_then_and64(volatile kmp_int64 *p, kmp_int64 d) {
-  kmp_int64 old_value, new_value;
+kmp_uint64 __kmp_test_then_and64(volatile kmp_uint64 *p, kmp_uint64 d) {
+  kmp_uint64 old_value, new_value;
 
   old_value = TCR_8(*p);
   new_value = old_value & d;
-  while (!__kmp_compare_and_store64(p, old_value, new_value)) {
+  while (!__kmp_compare_and_store64((volatile kmp_int64 *)p, old_value,
+                                    new_value)) {
     KMP_CPU_PAUSE();
     old_value = TCR_8(*p);
     new_value = old_value & d;
   }
 
   return old_value;
 }
 
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */