Cleanup version symbol macros and attributes/declspecs

[jlpeyton]

Summary

Cleanup version symbol macros and attributes/declspecs

1. Get rid of xaliasify, xexpand and xversionify for KMP_EXPAND_NAME and KMP_VERSION_SYMBOL. KMP_VERSION_SYMBOL is a combination of xaliasify and xversionify.
2. Put all attribute and __declspec definitions in kmp_os.h

[AndreyChurbanov]

LGTM

openmp/trunk/CREDITS.txt

 This file is a partial list of people who have contributed to the LLVM/openmp
 project.  If you have contributed a patch or made some other contribution to
 LLVM/openmp, please submit a patch to this file to add yourself, and it will be
 done!
 
 The list is sorted by surname and formatted to allow easy grepping and
 beautification by scripts.  The fields are: name (N), email (E), web-address
 (W), PGP key ID and fingerprint (P), description (D), and snail-mail address
 (S).
 
+N: Adam Azarchs
+W: 10xgenomics.com
+D: Bug fix for lock code
+
 N: Carlo Bertolli
 W: http://ibm.com
 D: IBM contributor to PowerPC support in CMake files and elsewhere.
 
 N: Diego Caballero
 E: [e-mail]
 D: Fork performance improvements
 

openmp/trunk/runtime/src/kmp.h

extern int __kmp_gtid_mode; /* Method of getting gtid, values:
                                1 - using stack search
                                2 - dynamic TLS (pthread_getspecific(Linux* OS/OS
                                    X*) or TlsGetValue(Windows* OS))
                                3 - static TLS (__declspec(thread) __kmp_gtid),
                                    Linux* OS .so only.  */
 extern int
     __kmp_adjust_gtid_mode; /* If true, adjust method based on #threads */
 #ifdef KMP_TDATA_GTID
-#if KMP_OS_WINDOWS
-extern __declspec(
-    thread) int __kmp_gtid; /* This thread's gtid, if __kmp_gtid_mode == 3 */
-#else
-extern __thread int __kmp_gtid;
-#endif /* KMP_OS_WINDOWS - workaround because Intel(R) Many Integrated Core    \
-          compiler 20110316 doesn't accept __declspec */
+extern KMP_THREAD_LOCAL int __kmp_gtid;
 #endif
 extern int __kmp_tls_gtid_min; /* #threads below which use sp search for gtid */
 extern int __kmp_foreign_tp; // If true, separate TP var for each foreign thread
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 extern int __kmp_inherit_fp_control; // copy fp creg(s) parent->workers at fork
 extern kmp_int16 __kmp_init_x87_fpu_control_word; // init thread's FP ctrl reg
 extern kmp_uint32 __kmp_init_mxcsr; /* init thread's mxscr */
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */

openmp/trunk/runtime/src/kmp_ftn_entry.h

#else
   }
   return __kmp_aux_get_affinity_mask_proc(KMP_DEREF proc, mask);
 #endif
 }
 
 /* ------------------------------------------------------------------------ */
 
 /* sets the requested number of threads for the next parallel region */
-void FTN_STDCALL xexpand(FTN_SET_NUM_THREADS)(int KMP_DEREF arg) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_SET_NUM_THREADS)(int KMP_DEREF arg) {
 #ifdef KMP_STUB
 // Nothing.
 #else
   __kmp_set_num_threads(KMP_DEREF arg, __kmp_entry_gtid());
 #endif
 }
 
 /* returns the number of threads in current team */
-int FTN_STDCALL xexpand(FTN_GET_NUM_THREADS)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_THREADS)(void) {
 #ifdef KMP_STUB
   return 1;
 #else
   // __kmpc_bound_num_threads initializes the library if needed
   return __kmpc_bound_num_threads(NULL);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_MAX_THREADS)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_MAX_THREADS)(void) {
 #ifdef KMP_STUB
   return 1;
 #else
   int gtid;
   kmp_info_t *thread;
   if (!TCR_4(__kmp_init_middle)) {
     __kmp_middle_initialize();
   }
#else
   parent_task_info->frame.enter_frame = OMPT_GET_FRAME_ADDRESS(1);
   int ret = __kmp_control_tool(command, modifier, arg);
   parent_task_info->frame.enter_frame = 0;
   return ret;
 #endif
 }
 #endif
 
-int FTN_STDCALL xexpand(FTN_GET_THREAD_NUM)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_THREAD_NUM)(void) {
 #ifdef KMP_STUB
   return 0;
 #else
   int gtid;
 
 #if KMP_OS_DARWIN || KMP_OS_FREEBSD || KMP_OS_NETBSD
   gtid = __kmp_entry_gtid();
 #elif KMP_OS_WINDOWS
if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   /* NOTE: this is not syncronized, so it can change at any moment */
   /* NOTE: this number also includes threads preallocated in hot-teams */
   return TCR_4(__kmp_nth);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_NUM_PROCS)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_PROCS)(void) {
 #ifdef KMP_STUB
   return 1;
 #else
   if (!TCR_4(__kmp_init_middle)) {
     __kmp_middle_initialize();
   }
   return __kmp_avail_proc;
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_SET_NESTED)(int KMP_DEREF flag) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_SET_NESTED)(int KMP_DEREF flag) {
 #ifdef KMP_STUB
   __kmps_set_nested(KMP_DEREF flag);
 #else
   kmp_info_t *thread;
   /* For the thread-private internal controls implementation */
   thread = __kmp_entry_thread();
   __kmp_save_internal_controls(thread);
   set__nested(thread, ((KMP_DEREF flag) ? TRUE : FALSE));
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_NESTED)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NESTED)(void) {
 #ifdef KMP_STUB
   return __kmps_get_nested();
 #else
   kmp_info_t *thread;
   thread = __kmp_entry_thread();
   return get__nested(thread);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_SET_DYNAMIC)(int KMP_DEREF flag) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_SET_DYNAMIC)(int KMP_DEREF flag) {
 #ifdef KMP_STUB
   __kmps_set_dynamic(KMP_DEREF flag ? TRUE : FALSE);
 #else
   kmp_info_t *thread;
   /* For the thread-private implementation of the internal controls */
   thread = __kmp_entry_thread();
   // !!! What if foreign thread calls it?
   __kmp_save_internal_controls(thread);
   set__dynamic(thread, KMP_DEREF flag ? TRUE : FALSE);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_DYNAMIC)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_DYNAMIC)(void) {
 #ifdef KMP_STUB
   return __kmps_get_dynamic();
 #else
   kmp_info_t *thread;
   thread = __kmp_entry_thread();
   return get__dynamic(thread);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_IN_PARALLEL)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_IN_PARALLEL)(void) {
 #ifdef KMP_STUB
   return 0;
 #else
   kmp_info_t *th = __kmp_entry_thread();
 #if OMP_40_ENABLED
   if (th->th.th_teams_microtask) {
     // AC: r_in_parallel does not work inside teams construct where real
     // parallel is inactive, but all threads have same root, so setting it in
     // one team affects other teams.
     // The solution is to use per-team nesting level
     return (th->th.th_team->t.t_active_level ? 1 : 0);
   } else
 #endif /* OMP_40_ENABLED */
     return (th->th.th_root->r.r_in_parallel ? FTN_TRUE : FTN_FALSE);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_SET_SCHEDULE)(kmp_sched_t KMP_DEREF kind,
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_SET_SCHEDULE)(kmp_sched_t KMP_DEREF kind,
                                                    int KMP_DEREF modifier) {
 #ifdef KMP_STUB
   __kmps_set_schedule(KMP_DEREF kind, KMP_DEREF modifier);
 #else
   /* TO DO: For the per-task implementation of the internal controls */
   __kmp_set_schedule(__kmp_entry_gtid(), KMP_DEREF kind, KMP_DEREF modifier);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_GET_SCHEDULE)(kmp_sched_t *kind, int *modifier) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_SCHEDULE)(kmp_sched_t *kind,
+                                                   int *modifier) {
 #ifdef KMP_STUB
   __kmps_get_schedule(kind, modifier);
 #else
   /* TO DO: For the per-task implementation of the internal controls */
   __kmp_get_schedule(__kmp_entry_gtid(), kind, modifier);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_SET_MAX_ACTIVE_LEVELS)(int KMP_DEREF arg) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_SET_MAX_ACTIVE_LEVELS)(int KMP_DEREF arg) {
 #ifdef KMP_STUB
 // Nothing.
 #else
   /* TO DO: We want per-task implementation of this internal control */
   __kmp_set_max_active_levels(__kmp_entry_gtid(), KMP_DEREF arg);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_MAX_ACTIVE_LEVELS)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_MAX_ACTIVE_LEVELS)(void) {
 #ifdef KMP_STUB
   return 0;
 #else
   /* TO DO: We want per-task implementation of this internal control */
   return __kmp_get_max_active_levels(__kmp_entry_gtid());
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_ACTIVE_LEVEL)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_ACTIVE_LEVEL)(void) {
 #ifdef KMP_STUB
   return 0; // returns 0 if it is called from the sequential part of the program
 #else
   /* TO DO: For the per-task implementation of the internal controls */
   return __kmp_entry_thread()->th.th_team->t.t_active_level;
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_LEVEL)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_LEVEL)(void) {
 #ifdef KMP_STUB
   return 0; // returns 0 if it is called from the sequential part of the program
 #else
   /* TO DO: For the per-task implementation of the internal controls */
   return __kmp_entry_thread()->th.th_team->t.t_level;
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_ANCESTOR_THREAD_NUM)(int KMP_DEREF level) {
+int FTN_STDCALL
+    KMP_EXPAND_NAME(FTN_GET_ANCESTOR_THREAD_NUM)(int KMP_DEREF level) {
 #ifdef KMP_STUB
   return (KMP_DEREF level) ? (-1) : (0);
 #else
   return __kmp_get_ancestor_thread_num(__kmp_entry_gtid(), KMP_DEREF level);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_TEAM_SIZE)(int KMP_DEREF level) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_TEAM_SIZE)(int KMP_DEREF level) {
 #ifdef KMP_STUB
   return (KMP_DEREF level) ? (-1) : (1);
 #else
   return __kmp_get_team_size(__kmp_entry_gtid(), KMP_DEREF level);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_THREAD_LIMIT)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_THREAD_LIMIT)(void) {
 #ifdef KMP_STUB
   return 1; // TO DO: clarify whether it returns 1 or 0?
 #else
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   /* global ICV */
   return __kmp_cg_max_nth;
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_IN_FINAL)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_IN_FINAL)(void) {
 #ifdef KMP_STUB
   return 0; // TO DO: clarify whether it returns 1 or 0?
 #else
   if (!TCR_4(__kmp_init_parallel)) {
     return 0;
   }
   return __kmp_entry_thread()->th.th_current_task->td_flags.final;
 #endif
 }
 
 #if OMP_40_ENABLED
 
-kmp_proc_bind_t FTN_STDCALL xexpand(FTN_GET_PROC_BIND)(void) {
+kmp_proc_bind_t FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_PROC_BIND)(void) {
 #ifdef KMP_STUB
   return __kmps_get_proc_bind();
 #else
   return get__proc_bind(__kmp_entry_thread());
 #endif
 }
 
 #if OMP_45_ENABLED
#else
   }
   for (i = 0, place_num = start; place_num <= end; ++place_num, ++i) {
     place_nums[i] = place_num;
   }
 #endif
 }
 #endif
 
-int FTN_STDCALL xexpand(FTN_GET_NUM_TEAMS)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_TEAMS)(void) {
 #ifdef KMP_STUB
   return 1;
 #else
   kmp_info_t *thr = __kmp_entry_thread();
   if (thr->th.th_teams_microtask) {
     kmp_team_t *team = thr->th.th_team;
     int tlevel = thr->th.th_teams_level;
     int ii = team->t.t_level; // the level of the teams construct
if (dd > 1) {
       return team->t.t_parent->t.t_nproc;
     }
   } else {
     return 1;
   }
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_TEAM_NUM)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_TEAM_NUM)(void) {
 #ifdef KMP_STUB
   return 0;
 #else
   kmp_info_t *thr = __kmp_entry_thread();
   if (thr->th.th_teams_microtask) {
     kmp_team_t *team = thr->th.th_team;
     int tlevel = thr->th.th_teams_level; // the level of the teams construct
     int ii = team->t.t_level;
if (dd > 1) {
       return team->t.t_master_tid;
     }
   } else {
     return 0;
   }
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_GET_DEFAULT_DEVICE)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_DEFAULT_DEVICE)(void) {
 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
   return 0;
 #else
   return __kmp_entry_thread()->th.th_current_task->td_icvs.default_device;
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_SET_DEFAULT_DEVICE)(int KMP_DEREF arg) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_SET_DEFAULT_DEVICE)(int KMP_DEREF arg) {
 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 // Nothing.
 #else
   __kmp_entry_thread()->th.th_current_task->td_icvs.default_device =
       KMP_DEREF arg;
 #endif
 }
 
 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 
 int FTN_STDCALL FTN_GET_NUM_DEVICES(void) { return 0; }
 
 #endif // KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 
 #if !KMP_OS_LINUX
 
-int FTN_STDCALL xexpand(FTN_IS_INITIAL_DEVICE)(void) { return 1; }
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) { return 1; }
 
 #else
 
 // This internal function is used when the entry from the offload library
 // is not found.
-int _Offload_get_device_number(void) __attribute__((weak));
+int _Offload_get_device_number(void) KMP_WEAK_ATTRIBUTE;
 
-int FTN_STDCALL xexpand(FTN_IS_INITIAL_DEVICE)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) {
   if (_Offload_get_device_number) {
     return _Offload_get_device_number() == -1;
   } else {
     return 1;
   }
 }
 
 #endif // ! KMP_OS_LINUX
#if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_init_nest_lock_with_hint(NULL, gtid, user_lock, KMP_DEREF hint);
 #endif
 }
 #endif
 
 /* initialize the lock */
-void FTN_STDCALL xexpand(FTN_INIT_LOCK)(void **user_lock) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_INIT_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   *((kmp_stub_lock_t *)user_lock) = UNLOCKED;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_init_lock(NULL, gtid, user_lock);
 #endif
 }
 
 /* initialize the lock */
-void FTN_STDCALL xexpand(FTN_INIT_NEST_LOCK)(void **user_lock) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_INIT_NEST_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   *((kmp_stub_lock_t *)user_lock) = UNLOCKED;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_init_nest_lock(NULL, gtid, user_lock);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_DESTROY_LOCK)(void **user_lock) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_DESTROY_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   *((kmp_stub_lock_t *)user_lock) = UNINIT;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_destroy_lock(NULL, gtid, user_lock);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_DESTROY_NEST_LOCK)(void **user_lock) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_DESTROY_NEST_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   *((kmp_stub_lock_t *)user_lock) = UNINIT;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_destroy_nest_lock(NULL, gtid, user_lock);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_SET_LOCK)(void **user_lock) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_SET_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
     // TODO: Issue an error.
   }
   if (*((kmp_stub_lock_t *)user_lock) != UNLOCKED) {
     // TODO: Issue an error.
   }
   *((kmp_stub_lock_t *)user_lock) = LOCKED;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_set_lock(NULL, gtid, user_lock);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_SET_NEST_LOCK)(void **user_lock) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_SET_NEST_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
     // TODO: Issue an error.
   }
   (*((int *)user_lock))++;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_set_nest_lock(NULL, gtid, user_lock);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_UNSET_LOCK)(void **user_lock) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_UNSET_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
     // TODO: Issue an error.
   }
   if (*((kmp_stub_lock_t *)user_lock) == UNLOCKED) {
     // TODO: Issue an error.
   }
   *((kmp_stub_lock_t *)user_lock) = UNLOCKED;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_unset_lock(NULL, gtid, user_lock);
 #endif
 }
 
-void FTN_STDCALL xexpand(FTN_UNSET_NEST_LOCK)(void **user_lock) {
+void FTN_STDCALL KMP_EXPAND_NAME(FTN_UNSET_NEST_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
     // TODO: Issue an error.
   }
   if (*((kmp_stub_lock_t *)user_lock) == UNLOCKED) {
     // TODO: Issue an error.
   }
   (*((int *)user_lock))--;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_unset_nest_lock(NULL, gtid, user_lock);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_TEST_LOCK)(void **user_lock) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_TEST_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
     // TODO: Issue an error.
   }
   if (*((kmp_stub_lock_t *)user_lock) == LOCKED) {
     return 0;
   }
   *((kmp_stub_lock_t *)user_lock) = LOCKED;
   return 1;
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   return __kmpc_test_lock(NULL, gtid, user_lock);
 #endif
 }
 
-int FTN_STDCALL xexpand(FTN_TEST_NEST_LOCK)(void **user_lock) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_TEST_NEST_LOCK)(void **user_lock) {
 #ifdef KMP_STUB
   if (*((kmp_stub_lock_t *)user_lock) == UNINIT) {
     // TODO: Issue an error.
   }
   return ++(*((int *)user_lock));
 #else
   int gtid = __kmp_entry_gtid();
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   return __kmpc_test_nest_lock(NULL, gtid, user_lock);
 #endif
 }
 
-double FTN_STDCALL xexpand(FTN_GET_WTIME)(void) {
+double FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_WTIME)(void) {
 #ifdef KMP_STUB
   return __kmps_get_wtime();
 #else
   double data;
 #if !KMP_OS_LINUX
   // We don't need library initialization to get the time on Linux* OS. The
   // routine can be used to measure library initialization time on Linux* OS now
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
 #endif
   __kmp_elapsed(&data);
   return data;
 #endif
 }
 
-double FTN_STDCALL xexpand(FTN_GET_WTICK)(void) {
+double FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_WTICK)(void) {
 #ifdef KMP_STUB
   return __kmps_get_wtick();
 #else
   double data;
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   __kmp_elapsed_tick(&data);
#endif
   __kmp_aux_set_defaults(str, len);
 #endif
 }
 
 /* ------------------------------------------------------------------------ */
 
 #if OMP_40_ENABLED
 /* returns the status of cancellation */
-int FTN_STDCALL xexpand(FTN_GET_CANCELLATION)(void) {
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_CANCELLATION)(void) {
 #ifdef KMP_STUB
   return 0 /* false */;
 #else
   // initialize the library if needed
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   return __kmp_omp_cancellation;
#else
   return __kmp_max_task_priority;
 #endif
 }
 #endif
 
 // GCC compatibility (versioned symbols)
 #ifdef KMP_USE_VERSION_SYMBOLS
 
-/* These following sections create function aliases (dummy symbols) for the
-   omp_* routines. These aliases will then be versioned according to how
+/* These following sections create versioned symbols for the
+   omp_* routines. The KMP_VERSION_SYMBOL macro expands the API name and
+   then maps it to a versioned symbol.
    libgomp ``versions'' its symbols (OMP_1.0, OMP_2.0, OMP_3.0, ...) while also
    retaining the default version which libomp uses: VERSION (defined in
    exports_so.txt). If you want to see the versioned symbols for libgomp.so.1
    then just type:
 
    objdump -T /path/to/libgomp.so.1 | grep omp_
 
    Example:
    Step 1) Create __kmp_api_omp_set_num_threads_10_alias which is alias of
      __kmp_api_omp_set_num_threads
    Step 2) Set __kmp_api_omp_set_num_threads_10_alias to version:
      omp_set_num_threads@OMP_1.0
    Step 2B) Set __kmp_api_omp_set_num_threads to default version:
      omp_set_num_threads@@VERSION
 */
 
-// OMP_1.0 aliases
-xaliasify(FTN_SET_NUM_THREADS, 10);
-xaliasify(FTN_GET_NUM_THREADS, 10);
-xaliasify(FTN_GET_MAX_THREADS, 10);
-xaliasify(FTN_GET_THREAD_NUM, 10);
-xaliasify(FTN_GET_NUM_PROCS, 10);
-xaliasify(FTN_IN_PARALLEL, 10);
-xaliasify(FTN_SET_DYNAMIC, 10);
-xaliasify(FTN_GET_DYNAMIC, 10);
-xaliasify(FTN_SET_NESTED, 10);
-xaliasify(FTN_GET_NESTED, 10);
-xaliasify(FTN_INIT_LOCK, 10);
-xaliasify(FTN_INIT_NEST_LOCK, 10);
-xaliasify(FTN_DESTROY_LOCK, 10);
-xaliasify(FTN_DESTROY_NEST_LOCK, 10);
-xaliasify(FTN_SET_LOCK, 10);
-xaliasify(FTN_SET_NEST_LOCK, 10);
-xaliasify(FTN_UNSET_LOCK, 10);
-xaliasify(FTN_UNSET_NEST_LOCK, 10);
-xaliasify(FTN_TEST_LOCK, 10);
-xaliasify(FTN_TEST_NEST_LOCK, 10);
-
-// OMP_2.0 aliases
-xaliasify(FTN_GET_WTICK, 20);
-xaliasify(FTN_GET_WTIME, 20);
-
-// OMP_3.0 aliases
-xaliasify(FTN_SET_SCHEDULE, 30);
-xaliasify(FTN_GET_SCHEDULE, 30);
-xaliasify(FTN_GET_THREAD_LIMIT, 30);
-xaliasify(FTN_SET_MAX_ACTIVE_LEVELS, 30);
-xaliasify(FTN_GET_MAX_ACTIVE_LEVELS, 30);
-xaliasify(FTN_GET_LEVEL, 30);
-xaliasify(FTN_GET_ANCESTOR_THREAD_NUM, 30);
-xaliasify(FTN_GET_TEAM_SIZE, 30);
-xaliasify(FTN_GET_ACTIVE_LEVEL, 30);
-xaliasify(FTN_INIT_LOCK, 30);
-xaliasify(FTN_INIT_NEST_LOCK, 30);
-xaliasify(FTN_DESTROY_LOCK, 30);
-xaliasify(FTN_DESTROY_NEST_LOCK, 30);
-xaliasify(FTN_SET_LOCK, 30);
-xaliasify(FTN_SET_NEST_LOCK, 30);
-xaliasify(FTN_UNSET_LOCK, 30);
-xaliasify(FTN_UNSET_NEST_LOCK, 30);
-xaliasify(FTN_TEST_LOCK, 30);
-xaliasify(FTN_TEST_NEST_LOCK, 30);
-
-// OMP_3.1 aliases
-xaliasify(FTN_IN_FINAL, 31);
-
-#if OMP_40_ENABLED
-// OMP_4.0 aliases
-xaliasify(FTN_GET_PROC_BIND, 40);
-xaliasify(FTN_GET_NUM_TEAMS, 40);
-xaliasify(FTN_GET_TEAM_NUM, 40);
-xaliasify(FTN_GET_CANCELLATION, 40);
-xaliasify(FTN_GET_DEFAULT_DEVICE, 40);
-xaliasify(FTN_SET_DEFAULT_DEVICE, 40);
-xaliasify(FTN_IS_INITIAL_DEVICE, 40);
-#endif /* OMP_40_ENABLED */
-
-#if OMP_45_ENABLED
-// OMP_4.5 aliases
-#endif
-
-#if OMP_50_ENABLED
-// OMP_5.0 aliases
-#endif
-
 // OMP_1.0 versioned symbols
-xversionify(FTN_SET_NUM_THREADS, 10, "OMP_1.0");
-xversionify(FTN_GET_NUM_THREADS, 10, "OMP_1.0");
-xversionify(FTN_GET_MAX_THREADS, 10, "OMP_1.0");
-xversionify(FTN_GET_THREAD_NUM, 10, "OMP_1.0");
-xversionify(FTN_GET_NUM_PROCS, 10, "OMP_1.0");
-xversionify(FTN_IN_PARALLEL, 10, "OMP_1.0");
-xversionify(FTN_SET_DYNAMIC, 10, "OMP_1.0");
-xversionify(FTN_GET_DYNAMIC, 10, "OMP_1.0");
-xversionify(FTN_SET_NESTED, 10, "OMP_1.0");
-xversionify(FTN_GET_NESTED, 10, "OMP_1.0");
-xversionify(FTN_INIT_LOCK, 10, "OMP_1.0");
-xversionify(FTN_INIT_NEST_LOCK, 10, "OMP_1.0");
-xversionify(FTN_DESTROY_LOCK, 10, "OMP_1.0");
-xversionify(FTN_DESTROY_NEST_LOCK, 10, "OMP_1.0");
-xversionify(FTN_SET_LOCK, 10, "OMP_1.0");
-xversionify(FTN_SET_NEST_LOCK, 10, "OMP_1.0");
-xversionify(FTN_UNSET_LOCK, 10, "OMP_1.0");
-xversionify(FTN_UNSET_NEST_LOCK, 10, "OMP_1.0");
-xversionify(FTN_TEST_LOCK, 10, "OMP_1.0");
-xversionify(FTN_TEST_NEST_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_SET_NUM_THREADS, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_GET_NUM_THREADS, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_GET_MAX_THREADS, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_GET_THREAD_NUM, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_GET_NUM_PROCS, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_IN_PARALLEL, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_SET_DYNAMIC, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_GET_DYNAMIC, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_SET_NESTED, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_GET_NESTED, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_INIT_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_INIT_NEST_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_DESTROY_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_DESTROY_NEST_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_SET_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_SET_NEST_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_UNSET_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_UNSET_NEST_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_TEST_LOCK, 10, "OMP_1.0");
+KMP_VERSION_SYMBOL(FTN_TEST_NEST_LOCK, 10, "OMP_1.0");
 
 // OMP_2.0 versioned symbols
-xversionify(FTN_GET_WTICK, 20, "OMP_2.0");
-xversionify(FTN_GET_WTIME, 20, "OMP_2.0");
+KMP_VERSION_SYMBOL(FTN_GET_WTICK, 20, "OMP_2.0");
+KMP_VERSION_SYMBOL(FTN_GET_WTIME, 20, "OMP_2.0");
 
 // OMP_3.0 versioned symbols
-xversionify(FTN_SET_SCHEDULE, 30, "OMP_3.0");
-xversionify(FTN_GET_SCHEDULE, 30, "OMP_3.0");
-xversionify(FTN_GET_THREAD_LIMIT, 30, "OMP_3.0");
-xversionify(FTN_SET_MAX_ACTIVE_LEVELS, 30, "OMP_3.0");
-xversionify(FTN_GET_MAX_ACTIVE_LEVELS, 30, "OMP_3.0");
-xversionify(FTN_GET_ANCESTOR_THREAD_NUM, 30, "OMP_3.0");
-xversionify(FTN_GET_LEVEL, 30, "OMP_3.0");
-xversionify(FTN_GET_TEAM_SIZE, 30, "OMP_3.0");
-xversionify(FTN_GET_ACTIVE_LEVEL, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_SET_SCHEDULE, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_GET_SCHEDULE, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_GET_THREAD_LIMIT, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_SET_MAX_ACTIVE_LEVELS, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_GET_MAX_ACTIVE_LEVELS, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_GET_ANCESTOR_THREAD_NUM, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_GET_LEVEL, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_GET_TEAM_SIZE, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_GET_ACTIVE_LEVEL, 30, "OMP_3.0");
 
 // the lock routines have a 1.0 and 3.0 version
-xversionify(FTN_INIT_LOCK, 30, "OMP_3.0");
-xversionify(FTN_INIT_NEST_LOCK, 30, "OMP_3.0");
-xversionify(FTN_DESTROY_LOCK, 30, "OMP_3.0");
-xversionify(FTN_DESTROY_NEST_LOCK, 30, "OMP_3.0");
-xversionify(FTN_SET_LOCK, 30, "OMP_3.0");
-xversionify(FTN_SET_NEST_LOCK, 30, "OMP_3.0");
-xversionify(FTN_UNSET_LOCK, 30, "OMP_3.0");
-xversionify(FTN_UNSET_NEST_LOCK, 30, "OMP_3.0");
-xversionify(FTN_TEST_LOCK, 30, "OMP_3.0");
-xversionify(FTN_TEST_NEST_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_INIT_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_INIT_NEST_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_DESTROY_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_DESTROY_NEST_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_SET_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_SET_NEST_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_UNSET_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_UNSET_NEST_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_TEST_LOCK, 30, "OMP_3.0");
+KMP_VERSION_SYMBOL(FTN_TEST_NEST_LOCK, 30, "OMP_3.0");
 
 // OMP_3.1 versioned symbol
-xversionify(FTN_IN_FINAL, 31, "OMP_3.1");
+KMP_VERSION_SYMBOL(FTN_IN_FINAL, 31, "OMP_3.1");
 
 #if OMP_40_ENABLED
 // OMP_4.0 versioned symbols
-xversionify(FTN_GET_PROC_BIND, 40, "OMP_4.0");
-xversionify(FTN_GET_NUM_TEAMS, 40, "OMP_4.0");
-xversionify(FTN_GET_TEAM_NUM, 40, "OMP_4.0");
-xversionify(FTN_GET_CANCELLATION, 40, "OMP_4.0");
-xversionify(FTN_GET_DEFAULT_DEVICE, 40, "OMP_4.0");
-xversionify(FTN_SET_DEFAULT_DEVICE, 40, "OMP_4.0");
-xversionify(FTN_IS_INITIAL_DEVICE, 40, "OMP_4.0");
+KMP_VERSION_SYMBOL(FTN_GET_PROC_BIND, 40, "OMP_4.0");
+KMP_VERSION_SYMBOL(FTN_GET_NUM_TEAMS, 40, "OMP_4.0");
+KMP_VERSION_SYMBOL(FTN_GET_TEAM_NUM, 40, "OMP_4.0");
+KMP_VERSION_SYMBOL(FTN_GET_CANCELLATION, 40, "OMP_4.0");
+KMP_VERSION_SYMBOL(FTN_GET_DEFAULT_DEVICE, 40, "OMP_4.0");
+KMP_VERSION_SYMBOL(FTN_SET_DEFAULT_DEVICE, 40, "OMP_4.0");
+KMP_VERSION_SYMBOL(FTN_IS_INITIAL_DEVICE, 40, "OMP_4.0");
 #endif /* OMP_40_ENABLED */
 
 #if OMP_45_ENABLED
 // OMP_4.5 versioned symbols
 #endif
 
 #if OMP_50_ENABLED
 // OMP_5.0 versioned symbols

openmp/trunk/runtime/src/kmp_ftn_os.h

 #define KMP_API_NAME_GOMP_TASKGROUP_END GOMP_taskgroup_end
 /* Target functions should be taken care of by liboffload */
 #define KMP_API_NAME_GOMP_TARGET GOMP_target
 #define KMP_API_NAME_GOMP_TARGET_DATA GOMP_target_data
 #define KMP_API_NAME_GOMP_TARGET_END_DATA GOMP_target_end_data
 #define KMP_API_NAME_GOMP_TARGET_UPDATE GOMP_target_update
 #define KMP_API_NAME_GOMP_TEAMS GOMP_teams
 
-#ifdef KMP_USE_VERSION_SYMBOLS
-#define xstr(x) str(x)
-#define str(x) #x
-
-// If Linux, xexpand prepends __kmp_api_ to the real API name
-#define xexpand(api_name) expand(api_name)
-#define expand(api_name) __kmp_api_##api_name
-
-#define xaliasify(api_name, ver) aliasify(api_name, ver)
-#define aliasify(api_name, ver)                                                \
-  __typeof__(__kmp_api_##api_name) __kmp_api_##api_name##_##ver##_alias        \
-      __attribute__((alias(xstr(__kmp_api_##api_name))))
-
-#define xversionify(api_name, version_num, version_str)                        \
-  versionify(api_name, version_num, version_str, "VERSION")
-#define versionify(api_name, version_num, version_str, default_ver)            \
-  __asm__(                                                                     \
-      ".symver " xstr(__kmp_api_##api_name##_##version_num##_alias) "," xstr(  \
-          api_name) "@" version_str "\n\t");                                   \
-  __asm__(".symver " xstr(__kmp_api_##api_name) "," xstr(                      \
-      api_name) "@@" default_ver "\n\t")
-
-#else // KMP_USE_VERSION_SYMBOLS
-#define xstr(x) /* Nothing */
-#define str(x) /* Nothing */
-
-// if Windows or Mac, xexpand does no name transformation
-#define xexpand(api_name) expand(api_name)
-#define expand(api_name) api_name
-
-#define xaliasify(api_name, ver) /* Nothing */
-#define aliasify(api_name, ver) /* Nothing */
-
-#define xversionify(api_name, version_num, version_str) /* Nothing */
-#define versionify(api_name, version_num, version_str,                         \
-                   default_ver) /* Nothing */
-
-#endif // KMP_USE_VERSION_SYMBOLS
-
 #endif /* KMP_FTN_OS_H */

openmp/trunk/runtime/src/kmp_global.cpp

 // lock for modifying the global __kmp_stats_list
 kmp_tas_lock_t __kmp_stats_lock;
 
 // global list of per thread stats, the head is a sentinel node which
 // accumulates all stats produced before __kmp_create_worker is called.
 kmp_stats_list *__kmp_stats_list;
 
 // thread local pointer to stats node within list
-__thread kmp_stats_list *__kmp_stats_thread_ptr = NULL;
+KMP_THREAD_LOCAL kmp_stats_list *__kmp_stats_thread_ptr = NULL;
 
 // gives reference tick for all events (considered the 0 tick)
 tsc_tick_count __kmp_stats_start_time;
 #endif
 
 /* ----------------------------------------------------- */
 /* INITIALIZATION VARIABLES */
 /* they are syncronized to write during init, but read anytime */

 #elif KMP_OS_WINDOWS
 int __kmp_gtid_mode = 2; /* use TLS functions to store gtid */
 int __kmp_adjust_gtid_mode = FALSE;
 #else
 int __kmp_gtid_mode = 0; /* select method to get gtid based on #threads */
 int __kmp_adjust_gtid_mode = TRUE;
 #endif /* KMP_OS_LINUX && defined(KMP_TDATA_GTID) */
 #ifdef KMP_TDATA_GTID
-#if KMP_OS_WINDOWS
-__declspec(thread) int __kmp_gtid = KMP_GTID_DNE;
-#else
-__thread int __kmp_gtid = KMP_GTID_DNE;
-#endif /* KMP_OS_WINDOWS - workaround because Intel(R) Many Integrated Core    \
-          compiler 20110316 doesn't accept __declspec */
+KMP_THREAD_LOCAL int __kmp_gtid = KMP_GTID_DNE;
 #endif /* KMP_TDATA_GTID */
 int __kmp_tls_gtid_min = INT_MAX;
 int __kmp_foreign_tp = TRUE;
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 int __kmp_inherit_fp_control = TRUE;
 kmp_int16 __kmp_init_x87_fpu_control_word = 0;
 kmp_uint32 __kmp_init_mxcsr = 0;
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */

openmp/trunk/runtime/src/kmp_gsupport.cpp

 extern "C" {
 #endif // __cplusplus
 
 #define MKLOC(loc, routine)                                                    \
   static ident_t(loc) = {0, KMP_IDENT_KMPC, 0, 0, ";unknown;unknown;0;0;;"};
 
 #include "kmp_ftn_os.h"
 
-void xexpand(KMP_API_NAME_GOMP_BARRIER)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_BARRIER)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_barrier");
   KA_TRACE(20, ("GOMP_barrier: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);

 // - .gomp_critical_user_ - is defined using .comm in any objects reference it.
 // We can't reference it directly here in C code, as the symbol contains a ".".
 //
 // The RTL contains an assembly language definition of .gomp_critical_user_
 // with another symbol __kmp_unnamed_critical_addr initialized with it's
 // address.
 extern kmp_critical_name *__kmp_unnamed_critical_addr;
 
-void xexpand(KMP_API_NAME_GOMP_CRITICAL_START)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CRITICAL_START)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_critical_start");
   KA_TRACE(20, ("GOMP_critical_start: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_critical(&loc, gtid, __kmp_unnamed_critical_addr);
 }
 
-void xexpand(KMP_API_NAME_GOMP_CRITICAL_END)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CRITICAL_END)(void) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_critical_end");
   KA_TRACE(20, ("GOMP_critical_end: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_end_critical(&loc, gtid, __kmp_unnamed_critical_addr);
 }
 
-void xexpand(KMP_API_NAME_GOMP_CRITICAL_NAME_START)(void **pptr) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CRITICAL_NAME_START)(void **pptr) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_critical_name_start");
   KA_TRACE(20, ("GOMP_critical_name_start: T#%d\n", gtid));
   __kmpc_critical(&loc, gtid, (kmp_critical_name *)pptr);
 }
 
-void xexpand(KMP_API_NAME_GOMP_CRITICAL_NAME_END)(void **pptr) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CRITICAL_NAME_END)(void **pptr) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_critical_name_end");
   KA_TRACE(20, ("GOMP_critical_name_end: T#%d\n", gtid));
   __kmpc_end_critical(&loc, gtid, (kmp_critical_name *)pptr);
 }
 
 // The Gnu codegen tries to use locked operations to perform atomic updates
 // inline.  If it can't, then it calls GOMP_atomic_start() before performing
 // the update and GOMP_atomic_end() afterward, regardless of the data type.
-void xexpand(KMP_API_NAME_GOMP_ATOMIC_START)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_ATOMIC_START)(void) {
   int gtid = __kmp_entry_gtid();
   KA_TRACE(20, ("GOMP_atomic_start: T#%d\n", gtid));
 
 #if OMPT_SUPPORT
   __ompt_thread_assign_wait_id(0);
 #endif
 
   __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
 }
 
-void xexpand(KMP_API_NAME_GOMP_ATOMIC_END)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_ATOMIC_END)(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_atomic_start: T#%d\n", gtid));
   __kmp_release_atomic_lock(&__kmp_atomic_lock, gtid);
 }
 
-int xexpand(KMP_API_NAME_GOMP_SINGLE_START)(void) {
+int KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_START)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_single_start");
   KA_TRACE(20, ("GOMP_single_start: T#%d\n", gtid));
 
   if (!TCR_4(__kmp_init_parallel))
     __kmp_parallel_initialize();
 
   // 3rd parameter == FALSE prevents kmp_enter_single from pushing a
if (rc) {
       }
     }
   }
 #endif
 
   return rc;
 }
 
-void *xexpand(KMP_API_NAME_GOMP_SINGLE_COPY_START)(void) {
+void *KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_COPY_START)(void) {
   void *retval;
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_single_copy_start");
   KA_TRACE(20, ("GOMP_single_copy_start: T#%d\n", gtid));
 
   if (!TCR_4(__kmp_init_parallel))
     __kmp_parallel_initialize();
 

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     ompt_frame->enter_frame = NULL;
   }
 #endif
   return retval;
 }
 
-void xexpand(KMP_API_NAME_GOMP_SINGLE_COPY_END)(void *data) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_COPY_END)(void *data) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_single_copy_end: T#%d\n", gtid));
 
   // Set the copyprivate data pointer fo the team, then hit the barrier so that
   // the other threads will continue on and read it.  Hit another barrier before
   // continuing, so that the know that the copyprivate data pointer has been
   // propagated to all threads before trying to reuse the t_copypriv_data field.
   __kmp_team_from_gtid(gtid)->t.t_copypriv_data = data;
#endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     ompt_frame->enter_frame = NULL;
   }
 #endif
 }
 
-void xexpand(KMP_API_NAME_GOMP_ORDERED_START)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_ORDERED_START)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_ordered_start");
   KA_TRACE(20, ("GOMP_ordered_start: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_ordered(&loc, gtid);
 }
 
-void xexpand(KMP_API_NAME_GOMP_ORDERED_END)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_ORDERED_END)(void) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_ordered_end");
   KA_TRACE(20, ("GOMP_ordered_start: T#%d\n", gtid));
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmpc_end_ordered(&loc, gtid);
 }

 static void __kmp_GOMP_serialized_parallel(ident_t *loc, kmp_int32 gtid,
                                            void (*task)(void *)) {
 #if OMPT_SUPPORT
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   __kmp_serialized_parallel(loc, gtid);
 }
 
-void xexpand(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *), void *data,
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *),
+                                                       void *data,
                                                        unsigned num_threads) {
   int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
   ompt_frame_t *parent_frame, *frame;
 
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &parent_frame, NULL, NULL);
     parent_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);

 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &frame, NULL, NULL);
     frame->exit_frame = OMPT_GET_FRAME_ADDRESS(1);
   }
 #endif
 }
 
-void xexpand(KMP_API_NAME_GOMP_PARALLEL_END)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)(void) {
   int gtid = __kmp_get_gtid();
   kmp_info_t *thr;
   int ompt_team_size = __kmp_team_from_gtid(gtid)->t.t_nproc;
 
   thr = __kmp_threads[gtid];
 
   MKLOC(loc, "GOMP_parallel_end");
   KA_TRACE(20, ("GOMP_parallel_end: T#%d\n", gtid));
if (status) {                                                              \
                                                                                \
     KA_TRACE(20,                                                               \
              (#func " exit: T#%d, *p_lb 0x%lx, *p_ub 0x%lx, stride 0x%lx, "    \
                     "returning %d\n",                                          \
               gtid, *p_lb, *p_ub, stride, status));                            \
     return status;                                                             \
   }
 
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_STATIC_START), kmp_sch_static)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_STATIC_NEXT), {})
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_DYNAMIC_START),
+LOOP_START(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_STATIC_START), kmp_sch_static)
+LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_STATIC_NEXT), {})
+LOOP_START(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_DYNAMIC_START),
            kmp_sch_dynamic_chunked)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_DYNAMIC_NEXT), {})
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_GUIDED_START), kmp_sch_guided_chunked)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_GUIDED_NEXT), {})
-LOOP_RUNTIME_START(xexpand(KMP_API_NAME_GOMP_LOOP_RUNTIME_START),
+LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_DYNAMIC_NEXT), {})
+LOOP_START(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_GUIDED_START),
+           kmp_sch_guided_chunked)
+LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_GUIDED_NEXT), {})
+LOOP_RUNTIME_START(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_RUNTIME_START),
                    kmp_sch_runtime)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_RUNTIME_NEXT), {})
+LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_RUNTIME_NEXT), {})
 
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_START), kmp_ord_static)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT),
+LOOP_START(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_START),
+           kmp_ord_static)
+LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START),
+LOOP_START(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START),
            kmp_ord_dynamic_chunked)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT),
+LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
-LOOP_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START),
+LOOP_START(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START),
            kmp_ord_guided_chunked)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT),
+LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
-LOOP_RUNTIME_START(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START),
-                   kmp_ord_runtime)
-LOOP_NEXT(xexpand(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT),
+LOOP_RUNTIME_START(
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START),
+LOOP_NEXT(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT),
           { KMP_DISPATCH_FINI_CHUNK(&loc, gtid); })
 
-void xexpand(KMP_API_NAME_GOMP_LOOP_END)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_END)(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_loop_end: T#%d\n", gtid))
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     ompt_frame->enter_frame = NULL;
   }
 #endif
 
   KA_TRACE(20, ("GOMP_loop_end exit: T#%d\n", gtid))
 }
 
-void xexpand(KMP_API_NAME_GOMP_LOOP_END_NOWAIT)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_END_NOWAIT)(void) {
   KA_TRACE(20, ("GOMP_loop_end_nowait: T#%d\n", __kmp_get_gtid()))
 }
 
 // Unsigned long long loop worksharing constructs
 //
 // These are new with gcc 4.4
 
 #define LOOP_START_ULL(func, schedule)                                         \
if (status) {                                                              \
                                                                                \
     KA_TRACE(20,                                                               \
              (#func " exit: T#%d, *p_lb 0x%llx, *p_ub 0x%llx, stride 0x%llx, " \
                     "returning %d\n",                                          \
               gtid, *p_lb, *p_ub, stride, status));                            \
     return status;                                                             \
   }
 
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_START), kmp_sch_static)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_NEXT), {})
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START),
+LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_START),
+               kmp_sch_static)
+LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_NEXT), {})
+LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START),
                kmp_sch_dynamic_chunked)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT), {})
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START),
+LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT), {})
+LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START),
                kmp_sch_guided_chunked)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT), {})
-LOOP_RUNTIME_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START),
-                       kmp_sch_runtime)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT), {})
+LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT), {})
+LOOP_RUNTIME_START_ULL(
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START), kmp_sch_runtime)
+LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT), {})
 
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START),
+LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START),
                kmp_ord_static)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT),
+LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT),
               { KMP_DISPATCH_FINI_CHUNK_ULL(&loc, gtid); })
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START),
-               kmp_ord_dynamic_chunked)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT),
+LOOP_START_ULL(
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START),
+LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT),
               { KMP_DISPATCH_FINI_CHUNK_ULL(&loc, gtid); })
-LOOP_START_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START),
+LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START),
                kmp_ord_guided_chunked)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT),
+LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT),
               { KMP_DISPATCH_FINI_CHUNK_ULL(&loc, gtid); })
 LOOP_RUNTIME_START_ULL(
-    xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START), kmp_ord_runtime)
-LOOP_NEXT_ULL(xexpand(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT),
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START),
+    kmp_ord_runtime)
+LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT),
               { KMP_DISPATCH_FINI_CHUNK_ULL(&loc, gtid); })
 
 // Combined parallel / loop worksharing constructs
 //
 // There are no ull versions (yet).
 
 #define PARALLEL_LOOP_START(func, schedule, ompt_pre, ompt_post)               \
   void func(void (*task)(void *), void *data, unsigned num_threads, long lb,   \

 #else
 
 #define OMPT_LOOP_PRE()
 
 #define OMPT_LOOP_POST()
 
 #endif
 
-PARALLEL_LOOP_START(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC_START),
-                    kmp_sch_static, OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP_START(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC_START),
-                    kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP_START(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED_START),
-                    kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP_START(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME_START),
-                    kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST)
+PARALLEL_LOOP_START(
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC_START),
+PARALLEL_LOOP_START(
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC_START),
+PARALLEL_LOOP_START(
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED_START),
+PARALLEL_LOOP_START(
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME_START),
 
 // Tasking constructs
 
-void xexpand(KMP_API_NAME_GOMP_TASK)(void (*func)(void *), void *data,
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASK)(void (*func)(void *), void *data,
                                              void (*copy_func)(void *, void *),
                                              long arg_size, long arg_align,
                                              bool if_cond, unsigned gomp_flags
 #if OMP_40_ENABLED
                                              ,
                                              void **depend
 #endif
                                              ) {
   MKLOC(loc, "GOMP_task");
   int gtid = __kmp_entry_gtid();
   kmp_int32 flags = 0;
   kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *)&flags;
 
   KA_TRACE(20, ("GOMP_task: T#%d\n", gtid));
 
   // The low-order bit is the "untied" flag
#if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
     current_task->ompt_task_info.frame.enter_frame = NULL;
   }
 #endif
 
   KA_TRACE(20, ("GOMP_task exit: T#%d\n", gtid));
 }
 
-void xexpand(KMP_API_NAME_GOMP_TASKWAIT)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKWAIT)(void) {
   MKLOC(loc, "GOMP_taskwait");
   int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled)
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
   KA_TRACE(20, ("GOMP_taskwait: T#%d\n", gtid));
 
   __kmpc_omp_taskwait(&loc, gtid);
 
   KA_TRACE(20, ("GOMP_taskwait exit: T#%d\n", gtid));
 }
 
 // Sections worksharing constructs
 //
 // For the sections construct, we initialize a dynamically scheduled loop
 // worksharing construct with lb 1 and stride 1, and use the iteration #'s
 // that its returns as sections ids.
 //
 // There are no special entry points for ordered sections, so we always use
 // the dynamically scheduled workshare, even if the sections aren't ordered.
 
-unsigned xexpand(KMP_API_NAME_GOMP_SECTIONS_START)(unsigned count) {
+unsigned KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SECTIONS_START)(unsigned count) {
   int status;
   kmp_int lb, ub, stride;
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_sections_start");
   KA_TRACE(20, ("GOMP_sections_start: T#%d\n", gtid));
 
   KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
   status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, &lb, &ub, &stride);
   if (status) {
     KMP_DEBUG_ASSERT(stride == 1);
     KMP_DEBUG_ASSERT(lb > 0);
     KMP_ASSERT(lb == ub);
   } else {
     lb = 0;
   }
 
   KA_TRACE(20, ("GOMP_sections_start exit: T#%d returning %u\n", gtid,
                 (unsigned)lb));
   return (unsigned)lb;
 }
 
-unsigned xexpand(KMP_API_NAME_GOMP_SECTIONS_NEXT)(void) {
+unsigned KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SECTIONS_NEXT)(void) {
   int status;
   kmp_int lb, ub, stride;
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_sections_next");
   KA_TRACE(20, ("GOMP_sections_next: T#%d\n", gtid));
 
   status = KMP_DISPATCH_NEXT(&loc, gtid, NULL, &lb, &ub, &stride);
   if (status) {
     KMP_DEBUG_ASSERT(stride == 1);
     KMP_DEBUG_ASSERT(lb > 0);
     KMP_ASSERT(lb == ub);
   } else {
     lb = 0;
   }
 
   KA_TRACE(
       20, ("GOMP_sections_next exit: T#%d returning %u\n", gtid, (unsigned)lb));
   return (unsigned)lb;
 }
 
-void xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START)(void (*task)(void *),
-                                                        void *data,
-                                                        unsigned num_threads,
-                                                        unsigned count) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START)(
+    void (*task)(void *), void *data, unsigned num_threads, unsigned count) {
   int gtid = __kmp_entry_gtid();
 
 #if OMPT_SUPPORT
   ompt_frame_t *parent_frame;
 
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &parent_frame, NULL, NULL);
     parent_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
#if OMPT_SUPPORT
   }
 #endif
 
   KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
   KA_TRACE(20, ("GOMP_parallel_sections_start exit: T#%d\n", gtid));
 }
 
-void xexpand(KMP_API_NAME_GOMP_SECTIONS_END)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SECTIONS_END)(void) {
   int gtid = __kmp_get_gtid();
   KA_TRACE(20, ("GOMP_sections_end: T#%d\n", gtid))
 
 #if OMPT_SUPPORT
   ompt_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = OMPT_GET_FRAME_ADDRESS(1);
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
     ompt_frame->enter_frame = NULL;
   }
 #endif
 
   KA_TRACE(20, ("GOMP_sections_end exit: T#%d\n", gtid))
 }
 
-void xexpand(KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT)(void) {
   KA_TRACE(20, ("GOMP_sections_end_nowait: T#%d\n", __kmp_get_gtid()))
 }
 
 // libgomp has an empty function for GOMP_taskyield as of 2013-10-10
-void xexpand(KMP_API_NAME_GOMP_TASKYIELD)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKYIELD)(void) {
   KA_TRACE(20, ("GOMP_taskyield: T#%d\n", __kmp_get_gtid()))
   return;
 }
 
 #if OMP_40_ENABLED // these are new GOMP_4.0 entry points
 
-void xexpand(KMP_API_NAME_GOMP_PARALLEL)(void (*task)(void *), void *data,
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL)(void (*task)(void *),
+                                                 void *data,
                                                  unsigned num_threads,
                                                  unsigned int flags) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_parallel");
   KA_TRACE(20, ("GOMP_parallel: T#%d\n", gtid));
 
 #if OMPT_SUPPORT
   ompt_task_info_t *parent_task_info, *task_info;
   if (ompt_enabled.enabled) {
     parent_task_info = __ompt_get_task_info_object(0);
#if OMPT_SUPPORT
   }
 #endif
   task(data);
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
     OMPT_STORE_RETURN_ADDRESS(gtid);
   }
 #endif
-  xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();
+  KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)();
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
     task_info->frame.exit_frame = NULL;
     parent_task_info->frame.enter_frame = NULL;
   }
 #endif
 }
 
-void xexpand(KMP_API_NAME_GOMP_PARALLEL_SECTIONS)(void (*task)(void *),
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_SECTIONS)(void (*task)(void *),
                                                           void *data,
                                                           unsigned num_threads,
                                                           unsigned count,
                                                           unsigned flags) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_parallel_sections");
   KA_TRACE(20, ("GOMP_parallel_sections: T#%d\n", gtid));
 
 #if OMPT_SUPPORT
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
__kmp_GOMP_fork_call(&loc, gtid, task,
                          (kmp_int)1, (kmp_int)count, (kmp_int)1, (kmp_int)1);
   } else {
     __kmp_GOMP_serialized_parallel(&loc, gtid, task);
   }
 
   KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
 
   task(data);
-  xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();
+  KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)();
   KA_TRACE(20, ("GOMP_parallel_sections exit: T#%d\n", gtid));
 }
 
 #define PARALLEL_LOOP(func, schedule, ompt_pre, ompt_post)                     \
   void func(void (*task)(void *), void *data, unsigned num_threads, long lb,   \
             long ub, long str, long chunk_sz, unsigned flags) {                \
     int gtid = __kmp_entry_gtid();                                             \
     MKLOC(loc, #func);                                                         \
if (__kmpc_ok_to_fork(&loc) && (num_threads != 1)) {                       \
       __kmp_GOMP_serialized_parallel(&loc, gtid, task);                        \
     }                                                                          \
                                                                                \
     IF_OMPT_SUPPORT(OMPT_STORE_RETURN_ADDRESS(gtid);)                          \
     KMP_DISPATCH_INIT(&loc, gtid, (schedule), lb,                              \
                       (str > 0) ? (ub - 1) : (ub + 1), str, chunk_sz,          \
                       (schedule) != kmp_sch_static);                           \
     task(data);                                                                \
-    xexpand(KMP_API_NAME_GOMP_PARALLEL_END)();                                 \
+    KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)();                         \
     ompt_post();                                                               \
                                                                                \
     KA_TRACE(20, (#func " exit: T#%d\n", gtid));                               \
   }
 
-PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC), kmp_sch_static,
-              OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC),
+PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC),
+              kmp_sch_static, OMPT_LOOP_PRE, OMPT_LOOP_POST)
+PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC),
               kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED),
+PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED),
               kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
-PARALLEL_LOOP(xexpand(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME), kmp_sch_runtime,
-              OMPT_LOOP_PRE, OMPT_LOOP_POST)
+PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME),
+              kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 
-void xexpand(KMP_API_NAME_GOMP_TASKGROUP_START)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKGROUP_START)(void) {
   int gtid = __kmp_entry_gtid();
   MKLOC(loc, "GOMP_taskgroup_start");
   KA_TRACE(20, ("GOMP_taskgroup_start: T#%d\n", gtid));
 
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled)
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
   __kmpc_taskgroup(&loc, gtid);
 
   return;
 }
 
-void xexpand(KMP_API_NAME_GOMP_TASKGROUP_END)(void) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASKGROUP_END)(void) {
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_taskgroup_end");
   KA_TRACE(20, ("GOMP_taskgroup_end: T#%d\n", gtid));
 
 #if OMPT_SUPPORT
   if (ompt_enabled.enabled)
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
case 4:
     break;
   case 8:
     cncl_kind = cancel_taskgroup;
     break;
   }
   return cncl_kind;
 }
 
-bool xexpand(KMP_API_NAME_GOMP_CANCELLATION_POINT)(int which) {
+bool KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CANCELLATION_POINT)(int which) {
   if (__kmp_omp_cancellation) {
     KMP_FATAL(NoGompCancellation);
   }
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_cancellation_point");
   KA_TRACE(20, ("GOMP_cancellation_point: T#%d\n", gtid));
 
   kmp_int32 cncl_kind = __kmp_gomp_to_omp_cancellation_kind(which);
 
   return __kmpc_cancellationpoint(&loc, gtid, cncl_kind);
 }
 
-bool xexpand(KMP_API_NAME_GOMP_BARRIER_CANCEL)(void) {
+bool KMP_EXPAND_NAME(KMP_API_NAME_GOMP_BARRIER_CANCEL)(void) {
   if (__kmp_omp_cancellation) {
     KMP_FATAL(NoGompCancellation);
   }
   KMP_FATAL(NoGompCancellation);
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_barrier_cancel");
   KA_TRACE(20, ("GOMP_barrier_cancel: T#%d\n", gtid));
 
   return __kmpc_cancel_barrier(&loc, gtid);
 }
 
-bool xexpand(KMP_API_NAME_GOMP_CANCEL)(int which, bool do_cancel) {
+bool KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CANCEL)(int which, bool do_cancel) {
   if (__kmp_omp_cancellation) {
     KMP_FATAL(NoGompCancellation);
   } else {
     return FALSE;
   }
 
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_cancel");
   KA_TRACE(20, ("GOMP_cancel: T#%d\n", gtid));
 
   kmp_int32 cncl_kind = __kmp_gomp_to_omp_cancellation_kind(which);
 
   if (do_cancel == FALSE) {
-    return xexpand(KMP_API_NAME_GOMP_CANCELLATION_POINT)(which);
+    return KMP_EXPAND_NAME(KMP_API_NAME_GOMP_CANCELLATION_POINT)(which);
   } else {
     return __kmpc_cancel(&loc, gtid, cncl_kind);
   }
 }
 
-bool xexpand(KMP_API_NAME_GOMP_SECTIONS_END_CANCEL)(void) {
+bool KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SECTIONS_END_CANCEL)(void) {
   if (__kmp_omp_cancellation) {
     KMP_FATAL(NoGompCancellation);
   }
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_sections_end_cancel");
   KA_TRACE(20, ("GOMP_sections_end_cancel: T#%d\n", gtid));
 
   return __kmpc_cancel_barrier(&loc, gtid);
 }
 
-bool xexpand(KMP_API_NAME_GOMP_LOOP_END_CANCEL)(void) {
+bool KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_END_CANCEL)(void) {
   if (__kmp_omp_cancellation) {
     KMP_FATAL(NoGompCancellation);
   }
   int gtid = __kmp_get_gtid();
   MKLOC(loc, "GOMP_loop_end_cancel");
   KA_TRACE(20, ("GOMP_loop_end_cancel: T#%d\n", gtid));
 
   return __kmpc_cancel_barrier(&loc, gtid);
 }
 
 // All target functions are empty as of 2014-05-29
-void xexpand(KMP_API_NAME_GOMP_TARGET)(int device, void (*fn)(void *),
-                                       const void *openmp_target, size_t mapnum,
-                                       void **hostaddrs, size_t *sizes,
-                                       unsigned char *kinds) {
-  return;
-}
-
-void xexpand(KMP_API_NAME_GOMP_TARGET_DATA)(int device,
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TARGET)(int device, void (*fn)(void *),
                                                const void *openmp_target,
                                                size_t mapnum, void **hostaddrs,
                                                size_t *sizes,
                                                unsigned char *kinds) {
   return;
 }
 
-void xexpand(KMP_API_NAME_GOMP_TARGET_END_DATA)(void) { return; }
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TARGET_DATA)(
+    int device, const void *openmp_target, size_t mapnum, void **hostaddrs,
+    size_t *sizes, unsigned char *kinds) {
+  return;
+}
 
-void xexpand(KMP_API_NAME_GOMP_TARGET_UPDATE)(int device,
-                                              const void *openmp_target,
-                                              size_t mapnum, void **hostaddrs,
-                                              size_t *sizes,
-                                              unsigned char *kinds) {
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TARGET_END_DATA)(void) { return; }
+
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TARGET_UPDATE)(
+    int device, const void *openmp_target, size_t mapnum, void **hostaddrs,
+    size_t *sizes, unsigned char *kinds) {
   return;
 }
 
-void xexpand(KMP_API_NAME_GOMP_TEAMS)(unsigned int num_teams,
+void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TEAMS)(unsigned int num_teams,
                                               unsigned int thread_limit) {
   return;
 }
 #endif // OMP_40_ENABLED
 
 /* The following sections of code create aliases for the GOMP_* functions, then
    create versioned symbols using the assembler directive .symver. This is only
-   pertinent for ELF .so library xaliasify and xversionify are defined in
-   kmp_ftn_os.h  */
+   pertinent for ELF .so library. The KMP_VERSION_SYMBOL macro is defined in
+   kmp_os.h  */
 
 #ifdef KMP_USE_VERSION_SYMBOLS
-
-// GOMP_1.0 aliases
-xaliasify(KMP_API_NAME_GOMP_ATOMIC_END, 10);
-xaliasify(KMP_API_NAME_GOMP_ATOMIC_START, 10);
-xaliasify(KMP_API_NAME_GOMP_BARRIER, 10);
-xaliasify(KMP_API_NAME_GOMP_CRITICAL_END, 10);
-xaliasify(KMP_API_NAME_GOMP_CRITICAL_NAME_END, 10);
-xaliasify(KMP_API_NAME_GOMP_CRITICAL_NAME_START, 10);
-xaliasify(KMP_API_NAME_GOMP_CRITICAL_START, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_DYNAMIC_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_DYNAMIC_START, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_END, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_END_NOWAIT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_GUIDED_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_GUIDED_START, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_START, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_RUNTIME_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_RUNTIME_START, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_STATIC_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_LOOP_STATIC_START, 10);
-xaliasify(KMP_API_NAME_GOMP_ORDERED_END, 10);
-xaliasify(KMP_API_NAME_GOMP_ORDERED_START, 10);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_END, 10);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC_START, 10);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED_START, 10);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME_START, 10);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC_START, 10);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START, 10);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_START, 10);
-xaliasify(KMP_API_NAME_GOMP_SECTIONS_END, 10);
-xaliasify(KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT, 10);
-xaliasify(KMP_API_NAME_GOMP_SECTIONS_NEXT, 10);
-xaliasify(KMP_API_NAME_GOMP_SECTIONS_START, 10);
-xaliasify(KMP_API_NAME_GOMP_SINGLE_COPY_END, 10);
-xaliasify(KMP_API_NAME_GOMP_SINGLE_COPY_START, 10);
-xaliasify(KMP_API_NAME_GOMP_SINGLE_START, 10);
-
-// GOMP_2.0 aliases
-xaliasify(KMP_API_NAME_GOMP_TASK, 20);
-xaliasify(KMP_API_NAME_GOMP_TASKWAIT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_NEXT, 20);
-xaliasify(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_START, 20);
-
-// GOMP_3.0 aliases
-xaliasify(KMP_API_NAME_GOMP_TASKYIELD, 30);
-
-// GOMP_4.0 aliases
-// The GOMP_parallel* entry points below aren't OpenMP 4.0 related.
-#if OMP_40_ENABLED
-xaliasify(KMP_API_NAME_GOMP_PARALLEL, 40);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_SECTIONS, 40);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC, 40);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED, 40);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME, 40);
-xaliasify(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC, 40);
-xaliasify(KMP_API_NAME_GOMP_TASKGROUP_START, 40);
-xaliasify(KMP_API_NAME_GOMP_TASKGROUP_END, 40);
-xaliasify(KMP_API_NAME_GOMP_BARRIER_CANCEL, 40);
-xaliasify(KMP_API_NAME_GOMP_CANCEL, 40);
-xaliasify(KMP_API_NAME_GOMP_CANCELLATION_POINT, 40);
-xaliasify(KMP_API_NAME_GOMP_LOOP_END_CANCEL, 40);
-xaliasify(KMP_API_NAME_GOMP_SECTIONS_END_CANCEL, 40);
-xaliasify(KMP_API_NAME_GOMP_TARGET, 40);
-xaliasify(KMP_API_NAME_GOMP_TARGET_DATA, 40);
-xaliasify(KMP_API_NAME_GOMP_TARGET_END_DATA, 40);
-xaliasify(KMP_API_NAME_GOMP_TARGET_UPDATE, 40);
-xaliasify(KMP_API_NAME_GOMP_TEAMS, 40);
-#endif
-
 // GOMP_1.0 versioned symbols
-xversionify(KMP_API_NAME_GOMP_ATOMIC_END, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_ATOMIC_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_BARRIER, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_CRITICAL_END, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_CRITICAL_NAME_END, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_CRITICAL_NAME_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_CRITICAL_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_DYNAMIC_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_DYNAMIC_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_END, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_END_NOWAIT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_GUIDED_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_GUIDED_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_RUNTIME_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_RUNTIME_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_STATIC_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_STATIC_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_ORDERED_END, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_ORDERED_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_END, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_SECTIONS_END, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_SECTIONS_NEXT, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_SECTIONS_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_SINGLE_COPY_END, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_SINGLE_COPY_START, 10, "GOMP_1.0");
-xversionify(KMP_API_NAME_GOMP_SINGLE_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_ATOMIC_END, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_ATOMIC_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_BARRIER, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_CRITICAL_END, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_CRITICAL_NAME_END, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_CRITICAL_NAME_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_CRITICAL_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_DYNAMIC_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_DYNAMIC_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_END, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_END_NOWAIT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_GUIDED_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_GUIDED_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ORDERED_DYNAMIC_START, 10,
+                   "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ORDERED_GUIDED_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ORDERED_RUNTIME_START, 10,
+                   "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ORDERED_STATIC_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_RUNTIME_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_RUNTIME_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_STATIC_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_STATIC_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_ORDERED_END, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_ORDERED_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_END, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC_START, 10,
+                   "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED_START, 10,
+                   "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME_START, 10,
+                   "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC_START, 10,
+                   "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_SECTIONS_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_SECTIONS_END, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_SECTIONS_END_NOWAIT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_SECTIONS_NEXT, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_SECTIONS_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_SINGLE_COPY_END, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_SINGLE_COPY_START, 10, "GOMP_1.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_SINGLE_START, 10, "GOMP_1.0");
 
 // GOMP_2.0 versioned symbols
-xversionify(KMP_API_NAME_GOMP_TASK, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_TASKWAIT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_NEXT, 20, "GOMP_2.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_START, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TASK, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TASKWAIT, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_NEXT, 20,
+                   "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_DYNAMIC_START, 20,
+                   "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_NEXT, 20,
+                   "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_GUIDED_START, 20,
+                   "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT, 20,
+                   "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_RUNTIME_START, 20,
+                   "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_NEXT, 20,
+                   "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_ORDERED_STATIC_START, 20,
+                   "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_NEXT, 20, "GOMP_2.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_ULL_STATIC_START, 20, "GOMP_2.0");
 
 // GOMP_3.0 versioned symbols
-xversionify(KMP_API_NAME_GOMP_TASKYIELD, 30, "GOMP_3.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TASKYIELD, 30, "GOMP_3.0");
 
 // GOMP_4.0 versioned symbols
 #if OMP_40_ENABLED
-xversionify(KMP_API_NAME_GOMP_PARALLEL, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_SECTIONS, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_TASKGROUP_START, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_TASKGROUP_END, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_BARRIER_CANCEL, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_CANCEL, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_CANCELLATION_POINT, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_LOOP_END_CANCEL, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_SECTIONS_END_CANCEL, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_TARGET, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_TARGET_DATA, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_TARGET_END_DATA, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_TARGET_UPDATE, 40, "GOMP_4.0");
-xversionify(KMP_API_NAME_GOMP_TEAMS, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_SECTIONS, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TASKGROUP_START, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TASKGROUP_END, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_BARRIER_CANCEL, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_CANCEL, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_CANCELLATION_POINT, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_LOOP_END_CANCEL, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_SECTIONS_END_CANCEL, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TARGET, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TARGET_DATA, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TARGET_END_DATA, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TARGET_UPDATE, 40, "GOMP_4.0");
+KMP_VERSION_SYMBOL(KMP_API_NAME_GOMP_TEAMS, 40, "GOMP_4.0");
 #endif
 
 #endif // KMP_USE_VERSION_SYMBOLS
 
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus

openmp/trunk/runtime/src/kmp_os.h

 #if (CACHE_LINE < 64) && !defined(KMP_OS_DARWIN)
 // 2006-02-13: This produces too many warnings on OS X*. Disable for now
 #warning CACHE_LINE is too small.
 #endif
 #endif /* CACHE_LINE */
 
 #define KMP_CACHE_PREFETCH(ADDR) /* nothing */
 
-/* Temporary note: if performance testing of this passes, we can remove
-   all references to KMP_DO_ALIGN and replace with KMP_ALIGN.  */
-#if KMP_OS_UNIX && defined(__GNUC__)
-#define KMP_DO_ALIGN(bytes) __attribute__((aligned(bytes)))
-#define KMP_ALIGN_CACHE __attribute__((aligned(CACHE_LINE)))
-#define KMP_ALIGN_CACHE_INTERNODE __attribute__((aligned(INTERNODE_CACHE_LINE)))
-#define KMP_ALIGN(bytes) __attribute__((aligned(bytes)))
-#else
-#define KMP_DO_ALIGN(bytes) __declspec(align(bytes))
-#define KMP_ALIGN_CACHE __declspec(align(CACHE_LINE))
-#define KMP_ALIGN_CACHE_INTERNODE __declspec(align(INTERNODE_CACHE_LINE))
-#define KMP_ALIGN(bytes) __declspec(align(bytes))
-#endif
-
 // Define attribute that indicates a function does not return
 #if __cplusplus >= 201103L
 #define KMP_NORETURN [[noreturn]]
 #elif KMP_OS_WINDOWS
 #define KMP_NORETURN __declspec(noreturn)
 #else
 #define KMP_NORETURN __attribute__((noreturn))
 #endif
 
+#if KMP_OS_WINDOWS
+#define KMP_ALIGN(bytes) __declspec(align(bytes))
+#define KMP_THREAD_LOCAL __declspec(thread)
+#define KMP_ALIAS /* Nothing */
+#else
+#define KMP_ALIGN(bytes) __attribute__((aligned(bytes)))
+#define KMP_THREAD_LOCAL __thread
+#define KMP_ALIAS(alias_of) __attribute__((alias(alias_of)))
+#endif
+
+#if KMP_HAVE_WEAK_ATTRIBUTE
+#define KMP_WEAK_ATTRIBUTE __attribute__((weak))
+#else
+#define KMP_WEAK_ATTRIBUTE /* Nothing */
+#endif
+
+// Define KMP_VERSION_SYMBOL and KMP_EXPAND_NAME
+#ifdef KMP_USE_VERSION_SYMBOLS
+#define KMP_STR(x) _KMP_STR(x)
+#define _KMP_STR(x) #x
+// If using versioned symbols, KMP_EXPAND_NAME prepends
+// __kmp_api_ to the real API name
+#define KMP_EXPAND_NAME(api_name) _KMP_EXPAND_NAME(api_name)
+#define _KMP_EXPAND_NAME(api_name) __kmp_api_##api_name
+#define KMP_VERSION_SYMBOL(api_name, ver_num, ver_str)                         \
+  _KMP_VERSION_SYMBOL(api_name, ver_num, ver_str, "VERSION")
+#define _KMP_VERSION_SYMBOL(api_name, ver_num, ver_str, default_ver)            \
+  __typeof__(__kmp_api_##api_name) __kmp_api_##api_name##_##ver_num##_alias     \
+      __attribute__((alias(KMP_STR(__kmp_api_##api_name))));                    \
+  __asm__(                                                                      \
+      ".symver " KMP_STR(__kmp_api_##api_name##_##ver_num##_alias) "," KMP_STR( \
+          api_name) "@" ver_str "\n\t");                                        \
+  __asm__(".symver " KMP_STR(__kmp_api_##api_name) "," KMP_STR(                 \
+      api_name) "@@" default_ver "\n\t")
+#else // KMP_USE_VERSION_SYMBOLS
+#define KMP_EXPAND_NAME(api_name) api_name
+#define KMP_VERSION_SYMBOL(api_name, ver_num, ver_str) /* Nothing */
+#endif // KMP_USE_VERSION_SYMBOLS
+
+/* Temporary note: if performance testing of this passes, we can remove
+   all references to KMP_DO_ALIGN and replace with KMP_ALIGN.  */
+#define KMP_DO_ALIGN(bytes) KMP_ALIGN(bytes)
+#define KMP_ALIGN_CACHE KMP_ALIGN(CACHE_LINE)
+#define KMP_ALIGN_CACHE_INTERNODE KMP_ALIGN(INTERNODE_CACHE_LINE)
+
 /* General purpose fence types for memory operations */
 enum kmp_mem_fence_type {
   kmp_no_fence, /* No memory fence */
   kmp_acquire_fence, /* Acquire (read) memory fence */
   kmp_release_fence, /* Release (write) memory fence */
   kmp_full_fence /* Full (read+write) memory fence */
 };
 

openmp/trunk/runtime/src/kmp_stats.h

/* ****************************************************************
     update its statistics at every stop() call. The explicitTimers' pointers are
     set up in the constructor. Each node also has an event vector to hold that
     thread's timing events. The event vector expands as necessary and records
     the start-stop times for each timer.
 
     The nestLevel variable is for plotting events and is related
     to the bar width in the timeline graph.
 
-    Every thread will have a __thread local pointer to its node in
+    Every thread will have a thread local pointer to its node in
     the list.  The sentinel node is used by the master thread to
     store "dummy" statistics before __kmp_create_worker() is called.
 **************************************************************** */
 class kmp_stats_list {
   int gtid;
   timeStat _timers[TIMER_LAST + 1];
   counter _counters[COUNTER_LAST + 1];
   explicitTimer _explicitTimers[EXPLICIT_TIMER_LAST + 1];

 extern "C" {
 #endif
 void __kmp_stats_init();
 void __kmp_stats_fini();
 void __kmp_reset_stats();
 void __kmp_output_stats(const char *);
 void __kmp_accumulate_stats_at_exit(void);
 // thread local pointer to stats node within list
-extern __thread kmp_stats_list *__kmp_stats_thread_ptr;
+extern KMP_THREAD_LOCAL kmp_stats_list *__kmp_stats_thread_ptr;
 // head to stats list.
 extern kmp_stats_list *__kmp_stats_list;
 // lock for __kmp_stats_list
 extern kmp_tas_lock_t __kmp_stats_lock;
 // reference start time
 extern tsc_tick_count __kmp_stats_start_time;
 // interface to output
 extern kmp_stats_output_module __kmp_stats_output;

openmp/trunk/runtime/src/ompt-general.cpp

  * NULL is returned and OMPT won't be enabled */
 
 typedef ompt_start_tool_result_t *(*ompt_start_tool_t)(unsigned int,
                                                        const char *);
 
 #if KMP_OS_UNIX
 
 #if OMPT_HAVE_WEAK_ATTRIBUTE
-_OMP_EXTERN __attribute__((weak))
+_OMP_EXTERN OMPT_WEAK_ATTRIBUTE
 #elif defined KMP_DYNAMIC_LIB
 _OMP_EXTERN
 #warning Activation of OMPT is might fail for tools statically linked into the application.
 #else
 #error Activation of OMPT is not supported on this platform.
 #endif
 ompt_start_tool_result_t *
 ompt_start_tool(unsigned int omp_version, const char *runtime_version) {

openmp/trunk/runtime/src/ompt-specific.cpp

 #endif
 
 #if KMP_OS_WINDOWS
 #define THREAD_LOCAL __declspec(thread)
 #else
 #define THREAD_LOCAL __thread
 #endif
 
+#define OMPT_WEAK_ATTRIBUTE KMP_WEAK_ATTRIBUTE
+
 //******************************************************************************
 // macros
 //******************************************************************************
 
 #define LWT_FROM_TEAM(team) (team)->t.ompt_serialized_team_info
 
 #define OMPT_THREAD_ID_BITS 16
 

openmp/trunk/runtime/src/z_Linux_util.cpp

#endif
   int gtid;
 
   gtid = ((kmp_info_t *)thr)->th.th_info.ds.ds_gtid;
   __kmp_gtid_set_specific(gtid);
 #ifdef KMP_TDATA_GTID
   __kmp_gtid = gtid;
 #endif
 #if KMP_STATS_ENABLED
-  // set __thread local index to point to thread-specific stats
+  // set thread local index to point to thread-specific stats
   __kmp_stats_thread_ptr = ((kmp_info_t *)thr)->th.th_stats;
   KMP_START_EXPLICIT_TIMER(OMP_worker_thread_life);
   KMP_SET_THREAD_STATE(IDLE);
   KMP_INIT_PARTITIONED_TIMERS(OMP_idle);
 #endif
 
 #if USE_ITT_BUILD
   __kmp_itt_thread_name(gtid);
void __kmp_create_worker(int gtid, kmp_info_t *th, size_t stack_size) {
   th->th.th_info.ds.ds_gtid = gtid;
 
 #if KMP_STATS_ENABLED
   // sets up worker thread stats
   __kmp_acquire_tas_lock(&__kmp_stats_lock, gtid);
 
   // th->th.th_stats is used to transfer thread-specific stats-pointer to
   // __kmp_launch_worker. So when thread is created (goes into
-  // __kmp_launch_worker) it will set its __thread local pointer to
+  // __kmp_launch_worker) it will set its thread local pointer to
   // th->th.th_stats
   if (!KMP_UBER_GTID(gtid)) {
     th->th.th_stats = __kmp_stats_list->push_back(gtid);
   } else {
     // For root threads, __kmp_stats_thread_ptr is set in __kmp_register_root(),
     // so set the th->th.th_stats field to it.
     th->th.th_stats = __kmp_stats_thread_ptr;
   }