[omp] Fix build without ITT after D103121 changes

[AndreyChurbanov]

LGTM

[jdoerfert]

Reverted as D103121 got reverted (this patch is fine as far as I can tell).

Could be merged into D103121 if nobody disagrees, together with a fix for non-x86 targets.

[AndreyChurbanov]

This patch can be abandoned, as it became part of https://reviews.llvm.org/D103121 (commit https://reviews.llvm.org/rGd8e4cb912180ce0a35d31b616e6f4c0c3d64abb7).

openmp/runtime/src/kmp_barrier.cpp

void __kmp_dist_barrier_wakeup(enum barrier_type bt, kmp_team_t *team,
   for (size_t thr = start; thr < stop; thr += inc) {
     KMP_DEBUG_ASSERT(other_threads[thr]);
     int gtid = other_threads[thr]->th.th_info.ds.ds_gtid;
     // Wake up worker regardless of if it appears to be sleeping or not
     __kmp_atomic_resume_64(gtid, (kmp_atomic_flag_64<> *)NULL);
   }
 }
 
-static void
-__kmp_dist_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr, int gtid,
-                          int tid, void (*reduce)(void *, void *)
-                                       USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
+static void __kmp_dist_barrier_gather(
+    enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
+    void (*reduce)(void *, void *) USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_dist_gather);
   kmp_team_t *team;
   distributedBarrier *b;
   kmp_info_t **other_threads;
   kmp_uint64 my_current_iter, my_next_iter;
   kmp_uint32 nproc;
   bool group_leader;
 
do {
         // Thread is not in use in a team. Wait on location in tid's thread
         // struct. The 0 value tells anyone looking that this thread is spinning
         // or sleeping until this location becomes 3 again; 3 is the transition
         // state to get to 1 which is waiting on go and being in the team
         kmp_flag_32<false, false> my_flag(&(this_thr->th.th_used_in_team), 3);
         if (KMP_COMPARE_AND_STORE_ACQ32(&(this_thr->th.th_used_in_team), 2,
                                         0) ||
             this_thr->th.th_used_in_team.load() == 0) {
-          my_flag.wait(this_thr, true, itt_sync_obj);
+          my_flag.wait(this_thr, true USE_ITT_BUILD_ARG(itt_sync_obj));
         }
 #if USE_ITT_BUILD && USE_ITT_NOTIFY
         if ((__itt_sync_create_ptr && itt_sync_obj == NULL) || KMP_ITT_DEBUG) {
           // In fork barrier where we could not get the object reliably
           itt_sync_obj =
               __kmp_itt_barrier_object(gtid, bs_forkjoin_barrier, 0, -1);
           // Cancel wait on previous parallel region...
           __kmp_itt_task_starting(itt_sync_obj);
#endif /* USE_ITT_BUILD && USE_ITT_NOTIFY */
       if (this_thr->th.th_used_in_team.load() == 3) {
         KMP_COMPARE_AND_STORE_ACQ32(&(this_thr->th.th_used_in_team), 3, 1);
       }
       // Check if go flag is set
       if (b->go[my_go_index].go.load() != next_go) {
         // Wait on go flag on team
         kmp_atomic_flag_64<false, true> my_flag(
             &(b->go[my_go_index].go), next_go, &(b->sleep[tid].sleep));
-        my_flag.wait(this_thr, true, itt_sync_obj);
+        my_flag.wait(this_thr, true USE_ITT_BUILD_ARG(itt_sync_obj));
         KMP_DEBUG_ASSERT(my_current_iter == b->iter[tid].iter ||
                          b->iter[tid].iter == 0);
         KMP_DEBUG_ASSERT(b->sleep[tid].sleep == false);
       }
 
       if (bt == bs_forkjoin_barrier && TCR_4(__kmp_global.g.g_done))
         return;
       // At this point, the thread's go location was set. This means the primary

openmp/runtime/src/kmp_wait_release.h

#endif
   }
 
 public:
   kmp_flag_oncore(volatile kmp_uint64 *p)
       : kmp_flag_native<kmp_uint64, flag_oncore, false>(p), flag_switch(false) {
   }
   kmp_flag_oncore(volatile kmp_uint64 *p, kmp_uint32 idx)
       : kmp_flag_native<kmp_uint64, flag_oncore, false>(p), offset(idx),
-        flag_switch(false), bt(bs_last_barrier), itt_sync_obj(nullptr) {}
+        flag_switch(false),
+        bt(bs_last_barrier) USE_ITT_BUILD_ARG(itt_sync_obj(nullptr)) {}
   kmp_flag_oncore(volatile kmp_uint64 *p, kmp_uint64 c, kmp_uint32 idx,
                   enum barrier_type bar_t,
                   kmp_info_t *thr USE_ITT_BUILD_ARG(void *itt))
       : kmp_flag_native<kmp_uint64, flag_oncore, false>(p, c), offset(idx),
         flag_switch(false), bt(bar_t),
         this_thr(thr) USE_ITT_BUILD_ARG(itt_sync_obj(itt)) {}
   bool done_check_val(kmp_uint64 old_loc) {
     return byteref(&old_loc, offset) == checker;