[OpenMP] libomp: fix clang-cl build for vs2019

[AndreyChurbanov]

Summary

Joseph Shen <[e-mail]> reported build failure on Windows because of poor code with atomic variable.
The patch fixes 3 offending cases.
Also two formatting changes suggested by clang-format.

[jdoerfert]

LG

openmp/runtime/src/z_Windows_NT_util.cpp

 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_wait_release.h"
 
 /* This code is related to NtQuerySystemInformation() function. This function
    is used in the Load balance algorithm for OMP_DYNAMIC=true to find the
    number of running threads in the system. */
 
 #include <ntsecapi.h> // UNICODE_STRING
 #include <ntstatus.h>
 
 enum SYSTEM_INFORMATION_CLASS {
   SystemProcessInformation = 5
 }; // SYSTEM_INFORMATION_CLASS
 
 struct CLIENT_ID {
   HANDLE UniqueProcess;
if (res == WAIT_OBJECT_0) {
       if (!flag->done_check_val(old_f & ~KMP_BARRIER_SLEEP_STATE)) {
         __kmp_win32_mutex_unlock(mx);
         continue;
       }
       // condition fulfilled, exiting
       old_f = flag->unset_sleeping();
       KMP_DEBUG_ASSERT(old_f & KMP_BARRIER_SLEEP_STATE);
       TCW_PTR(th->th.th_sleep_loc, NULL);
-      KF_TRACE(50, ("__kmp_win32_cond_wait: exiting, condition "
-                    "fulfilled: flag's loc(%p): %u => %u\n",
-                    flag->get(), old_f, *(flag->get())));
+      KF_TRACE(50,
+               ("__kmp_win32_cond_wait: exiting, condition "
+                flag->get(), (unsigned int)old_f, (unsigned int)flag->load()));
 
       __kmp_win32_mutex_lock(&cv->waiters_count_lock_);
       KMP_DEBUG_ASSERT(cv->waiters_count_ > 0);
       cv->release_count_ = cv->waiters_count_;
       cv->wait_generation_count_++;
       wait_done = 1;
       __kmp_win32_mutex_unlock(&cv->waiters_count_lock_);
 
static inline void __kmp_suspend_template(int th_gtid, C *flag) {
   if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
       __kmp_pause_status != kmp_soft_paused) {
     flag->unset_sleeping();
     __kmp_unlock_suspend_mx(th);
     return;
   }
 
   KF_TRACE(5, ("__kmp_suspend_template: T#%d set sleep bit for flag's"
-               " loc(%p)==%d\n",
-               th_gtid, flag->get(), *(flag->get())));
+               " loc(%p)==%u\n",
+               th_gtid, flag->get(), (unsigned int)flag->load()));
 
   if (flag->done_check_val(old_spin)) {
     old_spin = flag->unset_sleeping();
     KF_TRACE(5, ("__kmp_suspend_template: T#%d false alarm, reset sleep bit "
                  "for flag's loc(%p)\n",
                  th_gtid, flag->get()));
   } else {
 #ifdef DEBUG_SUSPEND
KF_TRACE(5, ("__kmp_resume_template: T#%d exiting, thread T#%d already "
                  gtid, target_gtid, NULL));
     __kmp_unlock_suspend_mx(th);
     return;
   } else {
     typename C::flag_t old_spin = flag->unset_sleeping();
     if (!flag->is_sleeping_val(old_spin)) {
       KF_TRACE(5, ("__kmp_resume_template: T#%d exiting, thread T#%d already "
                    "awake: flag's loc(%p): %u => %u\n",
-                   gtid, target_gtid, flag->get(), old_spin, *(flag->get())));
+                   gtid, target_gtid, flag->get(), (unsigned int)old_spin,
+                   (unsigned int)flag->load()));
       __kmp_unlock_suspend_mx(th);
       return;
     }
   }
   TCW_PTR(th->th.th_sleep_loc, NULL);
   KF_TRACE(5, ("__kmp_resume_template: T#%d about to wakeup T#%d, reset sleep "
                "bit for flag's loc(%p)\n",
                gtid, target_gtid, flag->get()));
if (__kmp_num_proc_groups > 1) {
     KMP_CPU_ZERO(mask);
     KMP_CPU_SET(proc, mask);
     __kmp_set_system_affinity(mask, TRUE);
     KMP_CPU_FREE_FROM_STACK(mask);
   }
 }
 
 void __kmp_affinity_determine_capable(const char *env_var) {
-// All versions of Windows* OS (since Win '95) support SetThreadAffinityMask().
+  // All versions of Windows* OS (since Win '95) support
+  // SetThreadAffinityMask().
 
 #if KMP_GROUP_AFFINITY
   KMP_AFFINITY_ENABLE(__kmp_num_proc_groups * sizeof(DWORD_PTR));
 #else
   KMP_AFFINITY_ENABLE(sizeof(DWORD_PTR));
 #endif
 
   KA_TRACE(10, ("__kmp_affinity_determine_capable: "

 
 /* Return the current time stamp in nsec */
 kmp_uint64 __kmp_now_nsec() {
   LARGE_INTEGER now;
   QueryPerformanceCounter(&now);
   return 1e9 * __kmp_win32_tick * now.QuadPart;
 }
 
-extern "C"
-void *__stdcall __kmp_launch_worker(void *arg) {
+extern "C" void *__stdcall __kmp_launch_worker(void *arg) {
   volatile void *stack_data;
   void *exit_val;
   void *padding = 0;
   kmp_info_t *this_thr = (kmp_info_t *)arg;
   int gtid;
 
   gtid = this_thr->th.th_info.ds.ds_gtid;
   __kmp_gtid_set_specific(gtid);