remove register storage class specifier.

[emaste]

Summary

Found while importing libomp into the FreeBSD base system (https://reviews.freebsd.org/D11507). Use of register produced warnings like:

register.cc:5:2: warning: 'register' storage class specifier is deprecated and
      incompatible with C++1z [-Wdeprecated-register]
        register int i;
        ^~~~~~~~~

The proposed FreeBSD import currently uses a hack (adding -Dregister= to CFLAGS). Here, just remove the deprecated keyword.

[AndreyChurbanov]

LGTM

openmp/trunk/runtime/src/kmp_alloc.cpp

#endif
 
   /* If the back link is nonzero, the previous buffer is free.  */
 
   if (b->bh.bb.prevfree != 0) {
     /* The previous buffer is free. Consolidate this buffer with it by adding
        the length of this buffer to the previous free buffer. Note that we
        subtract the size in the buffer being released, since it's negative to
        indicate that the buffer is allocated. */
-    register bufsize size = b->bh.bb.bsize;
+    bufsize size = b->bh.bb.bsize;
 
     /* Make the previous buffer the one we're working on. */
     KMP_DEBUG_ASSERT(BH((char *)b - b->bh.bb.prevfree)->bb.bsize ==
                      b->bh.bb.prevfree);
     b = BFH(((char *)b) - b->bh.bb.prevfree);
     b->bh.bb.bsize -= size;
 
     /* unlink the buffer from the old freelist */

openmp/trunk/runtime/src/kmp_barrier.cpp

 
 // ---------------------------- Barrier Algorithms ----------------------------
 
 // Linear Barrier
 static void __kmp_linear_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_linear_gather);
-  register kmp_team_t *team = this_thr->th.th_team;
-  register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
-  register kmp_info_t **other_threads = team->t.t_threads;
+  kmp_team_t *team = this_thr->th.th_team;
+  kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
+  kmp_info_t **other_threads = team->t.t_threads;
 
   KA_TRACE(
       20,
       ("__kmp_linear_barrier_gather: T#%d(%d:%d) enter for barrier type %d\n",
        gtid, team->t.t_id, tid, bt));
   KMP_DEBUG_ASSERT(this_thr == other_threads[this_thr->th.th_info.ds.ds_tid]);
 
 #if USE_ITT_BUILD && USE_ITT_NOTIFY
if (!KMP_MASTER_TID(tid)) {
     // Mark arrival to master thread
     /* After performing this write, a worker thread may not assume that the team
        is valid any more - it could be deallocated by the master thread at any
        time. */
     ANNOTATE_BARRIER_BEGIN(this_thr);
     kmp_flag_64 flag(&thr_bar->b_arrived, other_threads[0]);
     flag.release();
   } else {
-    register kmp_balign_team_t *team_bar = &team->t.t_bar[bt];
-    register int nproc = this_thr->th.th_team_nproc;
-    register int i;
+    kmp_balign_team_t *team_bar = &team->t.t_bar[bt];
+    int nproc = this_thr->th.th_team_nproc;
+    int i;
     // Don't have to worry about sleep bit here or atomic since team setting
-    register kmp_uint64 new_state =
+    kmp_uint64 new_state =
         team_bar->b_arrived + KMP_BARRIER_STATE_BUMP;
 
     // Collect all the worker team member threads.
     for (i = 1; i < nproc; ++i) {
 #if KMP_CACHE_MANAGE
       // Prefetch next thread's arrived count
       if (i + 1 < nproc)
         KMP_CACHE_PREFETCH(&other_threads[i + 1]->th.th_bar[bt].bb.b_arrived);
KA_TRACE(
       ("__kmp_linear_barrier_gather: T#%d(%d:%d) exit for barrier type %d\n",
        gtid, team->t.t_id, tid, bt));
 }
 
 static void __kmp_linear_barrier_release(
     enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
     int propagate_icvs USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_linear_release);
-  register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
-  register kmp_team_t *team;
+  kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
+  kmp_team_t *team;
 
   if (KMP_MASTER_TID(tid)) {
-    register unsigned int i;
-    register kmp_uint32 nproc = this_thr->th.th_team_nproc;
-    register kmp_info_t **other_threads;
+    unsigned int i;
+    kmp_uint32 nproc = this_thr->th.th_team_nproc;
+    kmp_info_t **other_threads;
 
     team = __kmp_threads[gtid]->th.th_team;
     KMP_DEBUG_ASSERT(team != NULL);
     other_threads = team->t.t_threads;
 
     KA_TRACE(20, ("__kmp_linear_barrier_release: T#%d(%d:%d) master enter for "
                   "barrier type %d\n",
                   gtid, team->t.t_id, tid, bt));

 }
 
 // Tree barrier
 static void
 __kmp_tree_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_tree_gather);
-  register kmp_team_t *team = this_thr->th.th_team;
-  register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
-  register kmp_info_t **other_threads = team->t.t_threads;
-  register kmp_uint32 nproc = this_thr->th.th_team_nproc;
-  register kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
-  register kmp_uint32 branch_factor = 1 << branch_bits;
-  register kmp_uint32 child;
-  register kmp_uint32 child_tid;
-  register kmp_uint64 new_state;
+  kmp_team_t *team = this_thr->th.th_team;
+  kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
+  kmp_info_t **other_threads = team->t.t_threads;
+  kmp_uint32 nproc = this_thr->th.th_team_nproc;
+  kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
+  kmp_uint32 branch_factor = 1 << branch_bits;
+  kmp_uint32 child;
+  kmp_uint32 child_tid;
+  kmp_uint64 new_state;
 
   KA_TRACE(
       20, ("__kmp_tree_barrier_gather: T#%d(%d:%d) enter for barrier type %d\n",
            gtid, team->t.t_id, tid, bt));
   KMP_DEBUG_ASSERT(this_thr == other_threads[this_thr->th.th_info.ds.ds_tid]);
 
 #if USE_ITT_BUILD && USE_ITT_NOTIFY
   // Barrier imbalance - save arrive time to the thread
   if (__kmp_forkjoin_frames_mode == 3 || __kmp_forkjoin_frames_mode == 2) {
     this_thr->th.th_bar_arrive_time = this_thr->th.th_bar_min_time =
         __itt_get_timestamp();
   }
 #endif
   // Perform tree gather to wait until all threads have arrived; reduce any
   // required data as we go
   child_tid = (tid << branch_bits) + 1;
   if (child_tid < nproc) {
     // Parent threads wait for all their children to arrive
     new_state = team->t.t_bar[bt].b_arrived + KMP_BARRIER_STATE_BUMP;
     child = 1;
     do {
-      register kmp_info_t *child_thr = other_threads[child_tid];
-      register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
+      kmp_info_t *child_thr = other_threads[child_tid];
+      kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
 #if KMP_CACHE_MANAGE
       // Prefetch next thread's arrived count
       if (child + 1 <= branch_factor && child_tid + 1 < nproc)
         KMP_CACHE_PREFETCH(
             &other_threads[child_tid + 1]->th.th_bar[bt].bb.b_arrived);
 #endif /* KMP_CACHE_MANAGE */
       KA_TRACE(20,
                ("__kmp_tree_barrier_gather: T#%d(%d:%d) wait T#%d(%d:%u) "
#endif
         ANNOTATE_REDUCE_BEFORE(&team->t.t_bar);
       }
       child++;
       child_tid++;
     } while (child <= branch_factor && child_tid < nproc);
   }
 
   if (!KMP_MASTER_TID(tid)) { // Worker threads
-    register kmp_int32 parent_tid = (tid - 1) >> branch_bits;
+    kmp_int32 parent_tid = (tid - 1) >> branch_bits;
 
     KA_TRACE(20,
              ("__kmp_tree_barrier_gather: T#%d(%d:%d) releasing T#%d(%d:%d) "
               "arrived(%p): %llu => %llu\n",
               gtid, team->t.t_id, tid, __kmp_gtid_from_tid(parent_tid, team),
               team->t.t_id, parent_tid, &thr_bar->b_arrived, thr_bar->b_arrived,
               thr_bar->b_arrived + KMP_BARRIER_STATE_BUMP));
 
KA_TRACE(20,
            ("__kmp_tree_barrier_gather: T#%d(%d:%d) exit for barrier type %d\n",
             gtid, team->t.t_id, tid, bt));
 }
 
 static void __kmp_tree_barrier_release(
     enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
     int propagate_icvs USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_tree_release);
-  register kmp_team_t *team;
-  register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
-  register kmp_uint32 nproc;
-  register kmp_uint32 branch_bits = __kmp_barrier_release_branch_bits[bt];
-  register kmp_uint32 branch_factor = 1 << branch_bits;
-  register kmp_uint32 child;
-  register kmp_uint32 child_tid;
+  kmp_team_t *team;
+  kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
+  kmp_uint32 nproc;
+  kmp_uint32 branch_bits = __kmp_barrier_release_branch_bits[bt];
+  kmp_uint32 branch_factor = 1 << branch_bits;
+  kmp_uint32 child;
+  kmp_uint32 child_tid;
 
   // Perform a tree release for all of the threads that have been gathered
   if (!KMP_MASTER_TID(
           tid)) { // Handle fork barrier workers who aren't part of a team yet
     KA_TRACE(20, ("__kmp_tree_barrier_release: T#%d wait go(%p) == %u\n", gtid,
                   &thr_bar->b_go, KMP_BARRIER_STATE_BUMP));
     // Wait for parent thread to release us
     kmp_flag_64 flag(&thr_bar->b_go, KMP_BARRIER_STATE_BUMP);
#endif /* USE_ITT_BUILD && USE_ITT_NOTIFY */
     KA_TRACE(20, ("__kmp_tree_barrier_release: T#%d(%d:%d) master enter for "
                   "barrier type %d\n",
                   gtid, team->t.t_id, tid, bt));
   }
   nproc = this_thr->th.th_team_nproc;
   child_tid = (tid << branch_bits) + 1;
 
   if (child_tid < nproc) {
-    register kmp_info_t **other_threads = team->t.t_threads;
+    kmp_info_t **other_threads = team->t.t_threads;
     child = 1;
     // Parent threads release all their children
     do {
-      register kmp_info_t *child_thr = other_threads[child_tid];
-      register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
+      kmp_info_t *child_thr = other_threads[child_tid];
+      kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
 #if KMP_CACHE_MANAGE
       // Prefetch next thread's go count
       if (child + 1 <= branch_factor && child_tid + 1 < nproc)
         KMP_CACHE_PREFETCH(
             &other_threads[child_tid + 1]->th.th_bar[bt].bb.b_go);
 #endif /* KMP_CACHE_MANAGE */
 
 #if KMP_BARRIER_ICV_PUSH

 }
 
 // Hyper Barrier
 static void
 __kmp_hyper_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_hyper_gather);
-  register kmp_team_t *team = this_thr->th.th_team;
-  register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
-  register kmp_info_t **other_threads = team->t.t_threads;
-  register kmp_uint64 new_state = KMP_BARRIER_UNUSED_STATE;
-  register kmp_uint32 num_threads = this_thr->th.th_team_nproc;
-  register kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
-  register kmp_uint32 branch_factor = 1 << branch_bits;
-  register kmp_uint32 offset;
-  register kmp_uint32 level;
+  kmp_team_t *team = this_thr->th.th_team;
+  kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
+  kmp_info_t **other_threads = team->t.t_threads;
+  kmp_uint64 new_state = KMP_BARRIER_UNUSED_STATE;
+  kmp_uint32 num_threads = this_thr->th.th_team_nproc;
+  kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
+  kmp_uint32 branch_factor = 1 << branch_bits;
+  kmp_uint32 offset;
+  kmp_uint32 level;
 
   KA_TRACE(
       20,
       ("__kmp_hyper_barrier_gather: T#%d(%d:%d) enter for barrier type %d\n",
        gtid, team->t.t_id, tid, bt));
   KMP_DEBUG_ASSERT(this_thr == other_threads[this_thr->th.th_info.ds.ds_tid]);
 
 #if USE_ITT_BUILD && USE_ITT_NOTIFY
   // Barrier imbalance - save arrive time to the thread
   if (__kmp_forkjoin_frames_mode == 3 || __kmp_forkjoin_frames_mode == 2) {
     this_thr->th.th_bar_arrive_time = this_thr->th.th_bar_min_time =
         __itt_get_timestamp();
   }
 #endif
   /* Perform a hypercube-embedded tree gather to wait until all of the threads
      have arrived, and reduce any required data as we go.  */
   kmp_flag_64 p_flag(&thr_bar->b_arrived);
   for (level = 0, offset = 1; offset < num_threads;
        level += branch_bits, offset <<= branch_bits) {
-    register kmp_uint32 child;
-    register kmp_uint32 child_tid;
+    kmp_uint32 child;
+    kmp_uint32 child_tid;
 
     if (((tid >> level) & (branch_factor - 1)) != 0) {
-      register kmp_int32 parent_tid = tid & ~((1 << (level + branch_bits)) - 1);
+      kmp_int32 parent_tid = tid & ~((1 << (level + branch_bits)) - 1);
 
       KA_TRACE(20,
                ("__kmp_hyper_barrier_gather: T#%d(%d:%d) releasing T#%d(%d:%d) "
                 "arrived(%p): %llu => %llu\n",
                 gtid, team->t.t_id, tid, __kmp_gtid_from_tid(parent_tid, team),
                 team->t.t_id, parent_tid, &thr_bar->b_arrived,
                 thr_bar->b_arrived,
                 thr_bar->b_arrived + KMP_BARRIER_STATE_BUMP));
       // Mark arrival to parent thread
       /* After performing this write (in the last iteration of the enclosing for
          loop), a worker thread may not assume that the team is valid any more
          - it could be deallocated by the master thread at any time.  */
       ANNOTATE_BARRIER_BEGIN(this_thr);
       p_flag.set_waiter(other_threads[parent_tid]);
       p_flag.release();
       break;
     }
 
     // Parent threads wait for children to arrive
     if (new_state == KMP_BARRIER_UNUSED_STATE)
       new_state = team->t.t_bar[bt].b_arrived + KMP_BARRIER_STATE_BUMP;
     for (child = 1, child_tid = tid + (1 << level);
          child < branch_factor && child_tid < num_threads;
          child++, child_tid += (1 << level)) {
-      register kmp_info_t *child_thr = other_threads[child_tid];
-      register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
+      kmp_info_t *child_thr = other_threads[child_tid];
+      kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
 #if KMP_CACHE_MANAGE
-      register kmp_uint32 next_child_tid = child_tid + (1 << level);
+      kmp_uint32 next_child_tid = child_tid + (1 << level);
       // Prefetch next thread's arrived count
       if (child + 1 < branch_factor && next_child_tid < num_threads)
         KMP_CACHE_PREFETCH(
             &other_threads[next_child_tid]->th.th_bar[bt].bb.b_arrived);
 #endif /* KMP_CACHE_MANAGE */
       KA_TRACE(20,
                ("__kmp_hyper_barrier_gather: T#%d(%d:%d) wait T#%d(%d:%u) "
                 "arrived(%p) == %llu\n",

 }
 
 // The reverse versions seem to beat the forward versions overall
 #define KMP_REVERSE_HYPER_BAR
 static void __kmp_hyper_barrier_release(
     enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
     int propagate_icvs USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_hyper_release);
-  register kmp_team_t *team;
-  register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
-  register kmp_info_t **other_threads;
-  register kmp_uint32 num_threads;
-  register kmp_uint32 branch_bits = __kmp_barrier_release_branch_bits[bt];
-  register kmp_uint32 branch_factor = 1 << branch_bits;
-  register kmp_uint32 child;
-  register kmp_uint32 child_tid;
-  register kmp_uint32 offset;
-  register kmp_uint32 level;
+  kmp_team_t *team;
+  kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
+  kmp_info_t **other_threads;
+  kmp_uint32 num_threads;
+  kmp_uint32 branch_bits = __kmp_barrier_release_branch_bits[bt];
+  kmp_uint32 branch_factor = 1 << branch_bits;
+  kmp_uint32 child;
+  kmp_uint32 child_tid;
+  kmp_uint32 offset;
+  kmp_uint32 level;
 
   /* Perform a hypercube-embedded tree release for all of the threads that have
      been gathered. If KMP_REVERSE_HYPER_BAR is defined (default) the threads
      are released in the reverse order of the corresponding gather, otherwise
      threads are released in the same order. */
   if (KMP_MASTER_TID(tid)) { // master
     team = __kmp_threads[gtid]->th.th_team;
     KMP_DEBUG_ASSERT(team != NULL);
#else
     for (child = 1, child_tid = tid + (1 << level);
          child < branch_factor && child_tid < num_threads;
          child++, child_tid += (1 << level))
 #endif // KMP_REVERSE_HYPER_BAR
     {
       if (child_tid >= num_threads)
         continue; // Child doesn't exist so keep going
       else {
-        register kmp_info_t *child_thr = other_threads[child_tid];
-        register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
+        kmp_info_t *child_thr = other_threads[child_tid];
+        kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
 #if KMP_CACHE_MANAGE
-        register kmp_uint32 next_child_tid = child_tid - (1 << level);
+        kmp_uint32 next_child_tid = child_tid - (1 << level);
 // Prefetch next thread's go count
 #ifdef KMP_REVERSE_HYPER_BAR
         if (child - 1 >= 1 && next_child_tid < num_threads)
 #else
         if (child + 1 < branch_factor && next_child_tid < num_threads)
 #endif // KMP_REVERSE_HYPER_BAR
           KMP_CACHE_PREFETCH(
               &other_threads[next_child_tid]->th.th_bar[bt].bb.b_go);
static bool __kmp_init_hierarchical_barrier_thread(enum barrier_type bt,
   }
   return retval;
 }
 
 static void __kmp_hierarchical_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_hier_gather);
-  register kmp_team_t *team = this_thr->th.th_team;
-  register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
-  register kmp_uint32 nproc = this_thr->th.th_team_nproc;
-  register kmp_info_t **other_threads = team->t.t_threads;
-  register kmp_uint64 new_state;
+  kmp_team_t *team = this_thr->th.th_team;
+  kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
+  kmp_uint32 nproc = this_thr->th.th_team_nproc;
+  kmp_info_t **other_threads = team->t.t_threads;
+  kmp_uint64 new_state;
 
   int level = team->t.t_level;
 #if OMP_40_ENABLED
   if (other_threads[0]
           ->th.th_teams_microtask) // are we inside the teams construct?
     if (this_thr->th.th_teams_size.nteams > 1)
       ++level; // level was not increased in teams construct for team_of_masters
 #endif
if (__kmp_forkjoin_frames_mode == 3 || __kmp_forkjoin_frames_mode == 2) {
     this_thr->th.th_bar_arrive_time = __itt_get_timestamp();
   }
 #endif
 
   (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)
-    register kmp_int32 child_tid;
+    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
         kmp_uint64 leaf_state =
             KMP_MASTER_TID(tid)
if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
       // 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;
         for (child_tid = tid + skip; child_tid < (int)last; child_tid += skip) {
-          register kmp_info_t *child_thr = other_threads[child_tid];
-          register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
+          kmp_info_t *child_thr = other_threads[child_tid];
+          kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
           KA_TRACE(20, ("__kmp_hierarchical_barrier_gather: T#%d(%d:%d) wait "
                         "T#%d(%d:%d) "
                         "arrived(%p) == %llu\n",
                         gtid, team->t.t_id, tid,
                         __kmp_gtid_from_tid(child_tid, team), team->t.t_id,
                         child_tid, &child_bar->b_arrived, new_state));
           kmp_flag_64 flag(&child_bar->b_arrived, new_state);
           flag.wait(this_thr, FALSE USE_ITT_BUILD_ARG(itt_sync_obj));
if (thr_bar->my_level) { // not a leaf (my_level==0 means leaf)
     } else { // Blocktime is not infinite
       for (kmp_uint32 d = 0; d < thr_bar->my_level;
            ++d) { // Gather lowest level threads first
         kmp_uint32 last = tid + thr_bar->skip_per_level[d + 1],
                    skip = thr_bar->skip_per_level[d];
         if (last > nproc)
           last = nproc;
         for (child_tid = tid + skip; child_tid < (int)last; child_tid += skip) {
-          register kmp_info_t *child_thr = other_threads[child_tid];
-          register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
+          kmp_info_t *child_thr = other_threads[child_tid];
+          kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
           KA_TRACE(20, ("__kmp_hierarchical_barrier_gather: T#%d(%d:%d) wait "
                         "T#%d(%d:%d) "
                         "arrived(%p) == %llu\n",
                         gtid, team->t.t_id, tid,
                         __kmp_gtid_from_tid(child_tid, team), team->t.t_id,
                         child_tid, &child_bar->b_arrived, new_state));
           kmp_flag_64 flag(&child_bar->b_arrived, new_state);
           flag.wait(this_thr, FALSE USE_ITT_BUILD_ARG(itt_sync_obj));
KA_TRACE(20, ("__kmp_hierarchical_barrier_gather: T#%d(%d:%d) exit for "
                 "barrier type %d\n",
                 gtid, team->t.t_id, tid, bt));
 }
 
 static void __kmp_hierarchical_barrier_release(
     enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
     int propagate_icvs USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_hier_release);
-  register kmp_team_t *team;
-  register kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
-  register kmp_uint32 nproc;
+  kmp_team_t *team;
+  kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
+  kmp_uint32 nproc;
   bool team_change = false; // indicates on-core barrier shouldn't be used
 
   if (KMP_MASTER_TID(tid)) {
     team = __kmp_threads[gtid]->th.th_team;
     KMP_DEBUG_ASSERT(team != NULL);
     KA_TRACE(20, ("__kmp_hierarchical_barrier_release: T#%d(%d:%d) master "
                   "entered barrier type %d\n",
                   gtid, team->t.t_id, tid, bt));
if (KMP_MASTER_TID(
         copy_icvs(&team->t.t_implicit_task_taskdata[tid].td_icvs,
                   &thr_bar->parent_bar->th_fixed_icvs);
     }
   }
 #endif // KMP_BARRIER_ICV_PUSH
 
   // Now, release my children
   if (thr_bar->my_level) { // not a leaf
-    register kmp_int32 child_tid;
+    kmp_int32 child_tid;
     kmp_uint32 last;
     if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
         thr_bar->use_oncore_barrier) {
       if (KMP_MASTER_TID(tid)) { // do a flat release
         // Set local b_go to bump children via NGO store of the cache line
         // containing IVCs and b_go.
         thr_bar->b_go = KMP_BARRIER_STATE_BUMP;
         // Use ngo stores if available; b_go piggybacks in the last 8 bytes of
         // the cache line
         ngo_load(&thr_bar->th_fixed_icvs);
         // This loops over all the threads skipping only the leaf nodes in the
         // hierarchy
         for (child_tid = thr_bar->skip_per_level[1]; child_tid < (int)nproc;
              child_tid += thr_bar->skip_per_level[1]) {
-          register kmp_bstate_t *child_bar =
+          kmp_bstate_t *child_bar =
               &team->t.t_threads[child_tid]->th.th_bar[bt].bb;
           KA_TRACE(20, ("__kmp_hierarchical_barrier_release: T#%d(%d:%d) "
                         "releasing T#%d(%d:%d)"
                         " go(%p): %u => %u\n",
                         gtid, team->t.t_id, tid,
                         __kmp_gtid_from_tid(child_tid, team), team->t.t_id,
                         child_tid, &child_bar->b_go, child_bar->b_go,
                         child_bar->b_go + KMP_BARRIER_STATE_BUMP));
if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME &&
             thr_bar->b_go |= old_leaf_state;
           }
           // Release new leaf kids
           last = tid + thr_bar->skip_per_level[1];
           if (last > nproc)
             last = nproc;
           for (child_tid = tid + 1 + old_leaf_kids; child_tid < (int)last;
                ++child_tid) { // skip_per_level[0]=1
-            register kmp_info_t *child_thr = team->t.t_threads[child_tid];
-            register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
+            kmp_info_t *child_thr = team->t.t_threads[child_tid];
+            kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
             KA_TRACE(
                 20,
                 ("__kmp_hierarchical_barrier_release: T#%d(%d:%d) releasing"
                  " T#%d(%d:%d) go(%p): %u => %u\n",
                  gtid, team->t.t_id, tid, __kmp_gtid_from_tid(child_tid, team),
                  team->t.t_id, child_tid, &child_bar->b_go, child_bar->b_go,
                  child_bar->b_go + KMP_BARRIER_STATE_BUMP));
             // Release child using child's b_go flag
if (thr_bar->my_level) { // not a leaf
     } else { // Blocktime is not infinite; do a simple hierarchical release
       for (int d = thr_bar->my_level - 1; d >= 0;
            --d) { // Release highest level threads first
         last = tid + thr_bar->skip_per_level[d + 1];
         kmp_uint32 skip = thr_bar->skip_per_level[d];
         if (last > nproc)
           last = nproc;
         for (child_tid = tid + skip; child_tid < (int)last; child_tid += skip) {
-          register kmp_info_t *child_thr = team->t.t_threads[child_tid];
-          register kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
+          kmp_info_t *child_thr = team->t.t_threads[child_tid];
+          kmp_bstate_t *child_bar = &child_thr->th.th_bar[bt].bb;
           KA_TRACE(20, ("__kmp_hierarchical_barrier_release: T#%d(%d:%d) "
                         "releasing T#%d(%d:%d) go(%p): %u => %u\n",
                         gtid, team->t.t_id, tid,
                         __kmp_gtid_from_tid(child_tid, team), team->t.t_id,
                         child_tid, &child_bar->b_go, child_bar->b_go,
                         child_bar->b_go + KMP_BARRIER_STATE_BUMP));
           // Release child using child's b_go flag
           ANNOTATE_BARRIER_BEGIN(child_thr);
/* 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,
                   size_t reduce_size, void *reduce_data,
                   void (*reduce)(void *, void *)) {
   KMP_TIME_PARTITIONED_BLOCK(OMP_plain_barrier);
   KMP_SET_THREAD_STATE_BLOCK(PLAIN_BARRIER);
-  register int tid = __kmp_tid_from_gtid(gtid);
-  register kmp_info_t *this_thr = __kmp_threads[gtid];
-  register kmp_team_t *team = this_thr->th.th_team;
-  register int status = 0;
+  int tid = __kmp_tid_from_gtid(gtid);
+  kmp_info_t *this_thr = __kmp_threads[gtid];
+  kmp_team_t *team = this_thr->th.th_team;
+  int status = 0;
   ident_t *loc = __kmp_threads[gtid]->th.th_ident;
 #if OMPT_SUPPORT
   ompt_task_id_t my_task_id;
   ompt_parallel_id_t my_parallel_id;
 #endif
 
   KA_TRACE(15, ("__kmp_barrier: T#%d(%d:%d) has arrived\n", gtid,
                 __kmp_team_from_gtid(gtid)->t.t_id, __kmp_tid_from_gtid(gtid)));
if (!team->t.t_serialized) {
     }
   }
   ANNOTATE_BARRIER_END(&team->t.t_bar);
 }
 
 void __kmp_join_barrier(int gtid) {
   KMP_TIME_PARTITIONED_BLOCK(OMP_join_barrier);
   KMP_SET_THREAD_STATE_BLOCK(FORK_JOIN_BARRIER);
-  register kmp_info_t *this_thr = __kmp_threads[gtid];
-  register kmp_team_t *team;
-  register kmp_uint nproc;
+  kmp_info_t *this_thr = __kmp_threads[gtid];
+  kmp_team_t *team;
+  kmp_uint nproc;
   kmp_info_t *master_thread;
   int tid;
 #ifdef KMP_DEBUG
   int team_id;
 #endif /* KMP_DEBUG */
 #if USE_ITT_BUILD
   void *itt_sync_obj = NULL;
 #if USE_ITT_NOTIFY
#if USE_ITT_BUILD && USE_ITT_NOTIFY
     if (__itt_sync_create_ptr || KMP_ITT_DEBUG) {
       // Create itt barrier object
       itt_sync_obj = __kmp_itt_barrier_object(gtid, bs_forkjoin_barrier, 1);
       __kmp_itt_barrier_middle(gtid, itt_sync_obj); // Call acquired/releasing
     }
 #endif /* USE_ITT_BUILD && USE_ITT_NOTIFY */
 
 #ifdef KMP_DEBUG
-    register kmp_info_t **other_threads = team->t.t_threads;
-    register int i;
+    kmp_info_t **other_threads = team->t.t_threads;
+    int i;
 
     // Verify state
     KMP_MB();
 
     for (i = 1; i < team->t.t_nproc; ++i) {
       KA_TRACE(500,
                ("__kmp_fork_barrier: T#%d(%d:0) checking T#%d(%d:%d) fork go "
                 "== %u.\n",

openmp/trunk/runtime/src/kmp_dispatch.cpp

 // ToDo: make inline function (move to header file for icl)
 static UT // unsigned 4- or 8-byte type
     __kmp_wait_yield(
         volatile UT *spinner, UT checker,
         kmp_uint32 (*pred)(UT, UT) USE_ITT_BUILD_ARG(
             void *obj) // Higher-level synchronization object, or NULL.
         ) {
   // 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;
+  volatile UT *spin = spinner;
+  UT check = checker;
+  kmp_uint32 spins;
+  kmp_uint32 (*f)(UT, UT) = pred;
+  UT r;
 
   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 */

 }
 
 template <typename T>
 static void __kmp_dist_get_bounds(ident_t *loc, kmp_int32 gtid,
                                   kmp_int32 *plastiter, T *plower, T *pupper,
                                   typename traits_t<T>::signed_t incr) {
   typedef typename traits_t<T>::unsigned_t UT;
   typedef typename traits_t<T>::signed_t ST;
-  register kmp_uint32 team_id;
-  register kmp_uint32 nteams;
-  register UT trip_count;
-  register kmp_team_t *team;
+  kmp_uint32 team_id;
+  kmp_uint32 nteams;
+  UT trip_count;
+  kmp_team_t *team;
   kmp_info_t *th;
 
   KMP_DEBUG_ASSERT(plastiter && plower && pupper);
   KE_TRACE(10, ("__kmpc_dist_get_bounds called (%d)\n", gtid));
 #ifdef KMP_DEBUG
   {
     const char *buff;
     // create format specifiers before the debug output
if (team_id < trip_count) {
       *pupper = *plower = *plower + team_id * incr;
     } else {
       *plower = *pupper + incr; // zero-trip loop
     }
     if (plastiter != NULL)
       *plastiter = (team_id == trip_count - 1);
   } else {
     if (__kmp_static == kmp_sch_static_balanced) {
-      register UT chunk = trip_count / nteams;
-      register UT extras = trip_count % nteams;
+      UT chunk = trip_count / nteams;
+      UT extras = trip_count % nteams;
       *plower +=
           incr * (team_id * chunk + (team_id < extras ? team_id : extras));
       *pupper = *plower + chunk * incr - (team_id < extras ? 0 : incr);
       if (plastiter != NULL)
         *plastiter = (team_id == nteams - 1);
     } else {
-      register T chunk_inc_count =
+      T chunk_inc_count =
           (trip_count / nteams + ((trip_count % nteams) ? 1 : 0)) * incr;
-      register T upper = *pupper;
+      T upper = *pupper;
       KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
       // Unknown static scheduling type.
       *plower += team_id * chunk_inc_count;
       *pupper = *plower + chunk_inc_count - incr;
       // Check/correct bounds if needed
       if (incr > 0) {
         if (*pupper < *plower)
           *pupper = traits_t<T>::max_value;

 }
 
 kmp_uint32
 __kmp_wait_yield_4(volatile kmp_uint32 *spinner, kmp_uint32 checker,
                    kmp_uint32 (*pred)(kmp_uint32, kmp_uint32),
                    void *obj // Higher-level synchronization object, or NULL.
                    ) {
   // 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;
+  volatile kmp_uint32 *spin = spinner;
+  kmp_uint32 check = checker;
+  kmp_uint32 spins;
+  kmp_uint32 (*f)(kmp_uint32, kmp_uint32) = pred;
+  kmp_uint32 r;
 
   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 */
__kmp_wait_yield_4(volatile kmp_uint32 *spinner, kmp_uint32 checker,
   return r;
 }
 
 void __kmp_wait_yield_4_ptr(
     void *spinner, kmp_uint32 checker, kmp_uint32 (*pred)(void *, kmp_uint32),
     void *obj // Higher-level synchronization object, or NULL.
     ) {
   // note: we may not belong to a team at this point
-  register void *spin = spinner;
-  register kmp_uint32 check = checker;
-  register kmp_uint32 spins;
-  register kmp_uint32 (*f)(void *, kmp_uint32) = pred;
+  void *spin = spinner;
+  kmp_uint32 check = checker;
+  kmp_uint32 spins;
+  kmp_uint32 (*f)(void *, kmp_uint32) = pred;
 
   KMP_FSYNC_SPIN_INIT(obj, spin);
   KMP_INIT_YIELD(spins);
   // main wait spin loop
   while (!f(spin, check)) {
     KMP_FSYNC_SPIN_PREPARE(obj);
     /* if we have waited a bit, or are oversubscribed, yield */
     /* pause is in the following code */

openmp/trunk/runtime/src/kmp_lock.cpp

 
 /* Acquire a lock using a the queuing lock implementation */
 template <bool takeTime>
 /* [TLW] The unused template above is left behind because of what BEB believes
    is a potential compiler problem with __forceinline. */
 __forceinline static int
 __kmp_acquire_queuing_lock_timed_template(kmp_queuing_lock_t *lck,
                                           kmp_int32 gtid) {
-  register kmp_info_t *this_thr = __kmp_thread_from_gtid(gtid);
+  kmp_info_t *this_thr = __kmp_thread_from_gtid(gtid);
   volatile kmp_int32 *head_id_p = &lck->lk.head_id;
   volatile kmp_int32 *tail_id_p = &lck->lk.tail_id;
   volatile kmp_uint32 *spin_here_p;
   kmp_int32 need_mf = 1;
 
 #if OMPT_SUPPORT
   ompt_state_t prev_state = ompt_state_undefined;
 #endif
static int __kmp_test_queuing_lock_with_checks(kmp_queuing_lock_t *lck,
 
   if (retval) {
     lck->lk.owner_id = gtid + 1;
   }
   return retval;
 }
 
 int __kmp_release_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid) {
-  register kmp_info_t *this_thr;
+  kmp_info_t *this_thr;
   volatile kmp_int32 *head_id_p = &lck->lk.head_id;
   volatile kmp_int32 *tail_id_p = &lck->lk.tail_id;
 
   KA_TRACE(1000,
            ("__kmp_release_queuing_lock: lck:%p, T#%d entering\n", lck, gtid));
   KMP_DEBUG_ASSERT(gtid >= 0);
   this_thr = __kmp_thread_from_gtid(gtid);
   KMP_DEBUG_ASSERT(this_thr != NULL);

openmp/trunk/runtime/src/kmp_sched.cpp

static void __kmp_for_static_init(ident_t *loc, kmp_int32 global_tid,
                                   typename traits_t<T>::signed_t incr,
                                   typename traits_t<T>::signed_t chunk) {
   KMP_COUNT_BLOCK(OMP_FOR_static);
   KMP_TIME_PARTITIONED_BLOCK(FOR_static_scheduling);
 
   typedef typename traits_t<T>::unsigned_t UT;
   typedef typename traits_t<T>::signed_t ST;
   /*  this all has to be changed back to TID and such.. */
-  register kmp_int32 gtid = global_tid;
-  register kmp_uint32 tid;
-  register kmp_uint32 nth;
-  register UT trip_count;
-  register kmp_team_t *team;
-  register kmp_info_t *th = __kmp_threads[gtid];
+  kmp_int32 gtid = global_tid;
+  kmp_uint32 tid;
+  kmp_uint32 nth;
+  UT trip_count;
+  kmp_team_t *team;
+  kmp_info_t *th = __kmp_threads[gtid];
 
 #if OMPT_SUPPORT && OMPT_TRACE
   ompt_team_info_t *team_info = NULL;
   ompt_task_info_t *task_info = NULL;
 
   if (ompt_enabled) {
     // Only fully initialize variables needed by OMPT if OMPT is enabled.
     team_info = __ompt_get_teaminfo(0, NULL);
if (trip_count < nth) {
         *pupper = *plower = *plower + tid * incr;
       } else {
         *plower = *pupper + incr;
       }
       if (plastiter != NULL)
         *plastiter = (tid == trip_count - 1);
     } else {
       if (__kmp_static == kmp_sch_static_balanced) {
-        register UT small_chunk = trip_count / nth;
-        register UT extras = trip_count % nth;
+        UT small_chunk = trip_count / nth;
+        UT extras = trip_count % nth;
         *plower += incr * (tid * small_chunk + (tid < extras ? tid : extras));
         *pupper = *plower + small_chunk * incr - (tid < extras ? 0 : incr);
         if (plastiter != NULL)
           *plastiter = (tid == nth - 1);
       } else {
-        register T big_chunk_inc_count =
+        T big_chunk_inc_count =
             (trip_count / nth + ((trip_count % nth) ? 1 : 0)) * incr;
-        register T old_upper = *pupper;
+        T old_upper = *pupper;
 
         KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
         // Unknown static scheduling type.
 
         *plower += tid * big_chunk_inc_count;
         *pupper = *plower + big_chunk_inc_count - incr;
         if (incr > 0) {
           if (*pupper < *plower)
if (trip_count < nth) {
             *pupper = old_upper; // tracker C73258
         }
       }
     }
     *pstride = trip_count;
     break;
   }
   case kmp_sch_static_chunked: {
-    register ST span;
+    ST span;
     if (chunk < 1) {
       chunk = 1;
     }
     span = chunk * incr;
     *pstride = span * nth;
     *plower = *plower + (span * tid);
     *pupper = *plower + span - incr;
     if (plastiter != NULL)
       *plastiter = (tid == ((trip_count - 1) / (UT)chunk) % nth);
     break;
   }
 #if OMP_45_ENABLED
   case kmp_sch_static_balanced_chunked: {
-    register T old_upper = *pupper;
+    T old_upper = *pupper;
     // round up to make sure the chunk is enough to cover all iterations
-    register UT span = (trip_count + nth - 1) / nth;
+    UT span = (trip_count + nth - 1) / nth;
 
     // perform chunk adjustment
     chunk = (span + chunk - 1) & ~(chunk - 1);
 
     span = chunk * incr;
     *plower = *plower + (span * tid);
     *pupper = *plower + span - incr;
     if (incr > 0) {
static void __kmp_dist_for_static_init(ident_t *loc, kmp_int32 gtid,
                                        kmp_int32 schedule, kmp_int32 *plastiter,
                                        T *plower, T *pupper, T *pupperDist,
                                        typename traits_t<T>::signed_t *pstride,
                                        typename traits_t<T>::signed_t incr,
                                        typename traits_t<T>::signed_t chunk) {
   KMP_COUNT_BLOCK(OMP_DISTRIBUTE);
   typedef typename traits_t<T>::unsigned_t UT;
   typedef typename traits_t<T>::signed_t ST;
-  register kmp_uint32 tid;
-  register kmp_uint32 nth;
-  register kmp_uint32 team_id;
-  register kmp_uint32 nteams;
-  register UT trip_count;
-  register kmp_team_t *team;
+  kmp_uint32 tid;
+  kmp_uint32 nth;
+  kmp_uint32 team_id;
+  kmp_uint32 nteams;
+  UT trip_count;
+  kmp_team_t *team;
   kmp_info_t *th;
 
   KMP_DEBUG_ASSERT(plastiter && plower && pupper && pupperDist && pstride);
   KE_TRACE(10, ("__kmpc_dist_for_static_init called (%d)\n", gtid));
 #ifdef KMP_DEBUG
   {
     const char *buff;
     // create format specifiers before the debug output
if (team_id < trip_count && tid == 0) {
       *pupperDist = *pupper;
       *plower = *pupper + incr; // compiler should skip loop body
     }
     if (plastiter != NULL)
       *plastiter = (tid == 0 && team_id == trip_count - 1);
   } else {
     // Get the team's chunk first (each team gets at most one chunk)
     if (__kmp_static == kmp_sch_static_balanced) {
-      register UT chunkD = trip_count / nteams;
-      register UT extras = trip_count % nteams;
+      UT chunkD = trip_count / nteams;
+      UT extras = trip_count % nteams;
       *plower +=
           incr * (team_id * chunkD + (team_id < extras ? team_id : extras));
       *pupperDist = *plower + chunkD * incr - (team_id < extras ? 0 : incr);
       if (plastiter != NULL)
         *plastiter = (team_id == nteams - 1);
     } else {
-      register T chunk_inc_count =
+      T chunk_inc_count =
           (trip_count / nteams + ((trip_count % nteams) ? 1 : 0)) * incr;
-      register T upper = *pupper;
+      T upper = *pupper;
       KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
       // Unknown static scheduling type.
       *plower += team_id * chunk_inc_count;
       *pupperDist = *plower + chunk_inc_count - incr;
       // Check/correct bounds if needed
       if (incr > 0) {
         if (*pupperDist < *plower)
           *pupperDist = traits_t<T>::max_value;
case kmp_sch_static: {
           *pupper = *plower = *plower + tid * incr;
         else
           *plower = *pupper + incr; // no iterations available
         if (plastiter != NULL)
           if (*plastiter != 0 && !(tid == trip_count - 1))
             *plastiter = 0;
       } else {
         if (__kmp_static == kmp_sch_static_balanced) {
-          register UT chunkL = trip_count / nth;
-          register UT extras = trip_count % nth;
+          UT chunkL = trip_count / nth;
+          UT extras = trip_count % nth;
           *plower += incr * (tid * chunkL + (tid < extras ? tid : extras));
           *pupper = *plower + chunkL * incr - (tid < extras ? 0 : incr);
           if (plastiter != NULL)
             if (*plastiter != 0 && !(tid == nth - 1))
               *plastiter = 0;
         } else {
-          register T chunk_inc_count =
+          T chunk_inc_count =
               (trip_count / nth + ((trip_count % nth) ? 1 : 0)) * incr;
-          register T upper = *pupperDist;
+          T upper = *pupperDist;
           KMP_DEBUG_ASSERT(__kmp_static == kmp_sch_static_greedy);
           // Unknown static scheduling type.
           *plower += tid * chunk_inc_count;
           *pupper = *plower + chunk_inc_count - incr;
           if (incr > 0) {
             if (*pupper < *plower)
               *pupper = traits_t<T>::max_value;
             if (plastiter != NULL)
case kmp_sch_static: {
             if (*pupper < upper)
               *pupper = upper; // tracker C73258
           }
         }
       }
       break;
     }
     case kmp_sch_static_chunked: {
-      register ST span;
+      ST span;
       if (chunk < 1)
         chunk = 1;
       span = chunk * incr;
       *pstride = span * nth;
       *plower = *plower + (span * tid);
       *pupper = *plower + span - incr;
       if (plastiter != NULL)
         if (*plastiter != 0 && !(tid == ((trip_count - 1) / (UT)chunk) % nth))

openmp/trunk/runtime/src/thirdparty/ittnotify/ittnotify_static.c

 }
 
 #ifndef min
 #define min(a,b) (a) < (b) ? (a) : (b)
 #endif /* min */
 
 static __itt_group_id __itt_get_groups(void)
 {
-    register int i;
+    int i;
     __itt_group_id res = __itt_group_none;
     const char* var_name  = "INTEL_ITTNOTIFY_GROUPS";
     const char* group_str = __itt_get_env_var(var_name);
 
     if (group_str != NULL)
     {
         int len;
         char gr[255];
static int __itt_lib_version(lib_t lib)
     if (__itt_get_proc(lib, "__itt_api_version"))
         return 1;
     return 0;
 }
 
 /* It's not used right now! Comment it out to avoid warnings.
 static void __itt_reinit_all_pointers(void)
 {
-    register int i;
+    int i;
     // Fill all pointers with initial stubs
     for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
         *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].init_func;
 }
 */
 
 static void __itt_nullify_all_pointers(void)
 {
-    register int i;
+    int i;
     /* Nulify all pointers except domain_create and string_handle_create */
     for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
         *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func;
 }
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 #pragma warning(push)
 #pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function pointer 'XXX' to data pointer 'void *' */
*/
             }
         }
         __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
     }
 }
 
 ITT_EXTERN_C int _N_(init_ittlib)(const char* lib_name, __itt_group_id init_groups)
 {
-    register int i;
+    int i;
     __itt_group_id groups;
 #ifdef ITT_COMPLETE_GROUP
     __itt_group_id zero_group = __itt_group_none;
 #endif /* ITT_COMPLETE_GROUP */
     static volatile TIDT current_thread = 0;
 
     if (!_N_(_ittapi_global).api_initialized)
     {

openmp/trunk/runtime/src/z_Windows_NT_util.cpp

/* 2006-10-19:
      2. Windows* OS may kill thread before it resets ds_alive flag.
 
      Right solution seems to be waiting for *either* thread termination *or*
      ds_alive resetting. */
   {
     // TODO: This code is very similar to KMP_WAIT_YIELD. Need to generalize
     // KMP_WAIT_YIELD to cover this usage also.
     void *obj = NULL;
-    register kmp_uint32 spins;
+    kmp_uint32 spins;
 #if USE_ITT_BUILD
     KMP_FSYNC_SPIN_INIT(obj, (void *)&th->th.th_info.ds.ds_alive);
 #endif /* USE_ITT_BUILD */
     KMP_INIT_YIELD(spins);
     do {
 #if USE_ITT_BUILD
       KMP_FSYNC_SPIN_PREPARE(obj);
 #endif /* USE_ITT_BUILD */