Change macro GUIDEDLL_EXPORTS to KMP_DYNAMIC_LIB

[jlpeyton]

Summary

A while back, Hal suggested updating the GUIDEDLL_EXPORTS macro guard to a more descriptive name. It represents a dynamic library build so KMP_DYNAMIC_LIB is a more suitable name.

[hfinkel]

LGTM, thanks!

openmp/trunk/runtime/cmake/Definitions.cmake

function(append_cpp_flags input_cpp_flags)
     # Unix definitions
     if(${LINUX})
         append_definitions("-D KMP_TDATA_GTID")
     endif()
 
     ##################################
     # Other conditional definitions
     append_definitions("-D KMP_USE_ASSERT")
-    append_definitions("-D GUIDEDLL_EXPORTS") 
+    append_definitions("-D KMP_DYNAMIC_LIB") 
     if(${STUBS_LIBRARY}) 
         append_definitions("-D KMP_STUB") 
     endif()
     if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD}) 
         append_definitions("-D KMP_DEBUG") 
     endif()
     if(${DEBUG_BUILD})
         append_definitions("-D _DEBUG")

openmp/trunk/runtime/src/kmp_ftn_cdecl.c

 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "kmp.h"
 
 #if KMP_OS_WINDOWS
-#   if defined  KMP_WIN_CDECL ||  !defined GUIDEDLL_EXPORTS
+#   if defined  KMP_WIN_CDECL ||  !defined KMP_DYNAMIC_LIB
 #       define KMP_FTN_ENTRIES      KMP_FTN_UPPER
 #   endif
 #elif KMP_OS_UNIX
 #   define KMP_FTN_ENTRIES  KMP_FTN_PLAIN
 #endif
 
 // Note: This string is not printed when KMP_VERSION=1.
 char const __kmp_version_ftncdecl[] = KMP_VERSION_PREFIX "Fortran __cdecl OMP support: "
 #ifdef KMP_FTN_ENTRIES
     "yes";
 #   define FTN_STDCALL  /* no stdcall */
 #   include "kmp_ftn_os.h"
 #   include "kmp_ftn_entry.h"
 #else
     "no";
 #endif /* KMP_FTN_ENTRIES */

openmp/trunk/runtime/src/kmp_runtime.c

 }
 
 static void __kmp_init_allocator() {}
 static void __kmp_fini_allocator() {}
 static void __kmp_fini_allocator_thread() {}
 
 /* ------------------------------------------------------------------------ */
 
-#ifdef GUIDEDLL_EXPORTS
+#ifdef KMP_DYNAMIC_LIB
 # if KMP_OS_WINDOWS
 
 
 static void
 __kmp_reset_lock( kmp_bootstrap_lock_t* lck ) {
     // TODO: Change to __kmp_break_bootstrap_lock().
     __kmp_init_bootstrap_lock( lck ); // make the lock released
 }
switch( fdwReason ) {
             __kmp_internal_end_thread( __kmp_gtid_get_specific() );
             return TRUE;
     }
 
     return TRUE;
 }
 
 # endif /* KMP_OS_WINDOWS */
-#endif /* GUIDEDLL_EXPORTS */
+#endif /* KMP_DYNAMIC_LIB */
 
 
 /* ------------------------------------------------------------------------ */
 
 /* Change the library type to "status" and return the old type */
 /* called from within initialization routines where __kmp_initz_lock is held */
 int
 __kmp_change_library( int status )

 static int
 __kmp_expand_threads(int nWish, int nNeed) {
     int added = 0;
     int old_tp_cached;
     int __kmp_actual_max_nth;
 
     if(nNeed > nWish) /* normalize the arguments */
         nWish = nNeed;
-#if KMP_OS_WINDOWS && !defined GUIDEDLL_EXPORTS
+#if KMP_OS_WINDOWS && !defined KMP_DYNAMIC_LIB
 /* only for Windows static library */
     /* reclaim array entries for root threads that are already dead */
     added = __kmp_reclaim_dead_roots();
 
     if(nNeed) {
         nNeed -= added;
         if(nNeed < 0)
             nNeed = 0;
__kmp_internal_end_dest( void *specific_gtid )
     if(gtid >= 0 && KMP_UBER_GTID(gtid))
         __kmp_gtid_set_specific( gtid );
     #ifdef KMP_TDATA_GTID
         __kmp_gtid = gtid;
     #endif
     __kmp_internal_end_thread( gtid );
 }
 
-#if KMP_OS_UNIX && GUIDEDLL_EXPORTS
+#if KMP_OS_UNIX && KMP_DYNAMIC_LIB
 
 // 2009-09-08 (lev): It looks the destructor does not work. In simple test cases destructors work
 // perfectly, but in real libiomp5.so I have no evidence it is ever called. However, -fini linker
 // option in makefile.mk works fine.
 
 __attribute__(( destructor ))
 void
 __kmp_internal_end_dtor( void )
/* find out who we are and what we should do */
                     __kmp_unref_task_team(this_thr->th.th_task_team, this_thr);
                 }
             }
 
             KA_TRACE( 10, ("__kmp_internal_end_thread: worker thread done, exiting T#%d\n", gtid ));
             return;
         }
     }
-    #if defined GUIDEDLL_EXPORTS
+    #if defined KMP_DYNAMIC_LIB
     // AC: lets not shutdown the Linux* OS dynamic library at the exit of uber thread,
     //     because we will better shutdown later in the library destructor.
     //     The reason of this change is performance problem when non-openmp thread
     //     in a loop forks and joins many openmp threads. We can save a lot of time
     //     keeping worker threads alive until the program shutdown.
     // OM: Removed Linux* OS restriction to fix the crash on OS X* (DPD200239966) and
     //     Windows(DPD200287443) that occurs when using critical sections from foreign threads.
         KA_TRACE( 10, ("__kmp_internal_end_thread: exiting T#%d\n", gtid_req) );
#endif
 
     __kmp_common_initialize();
 
     #if KMP_OS_UNIX
         /* invoke the child fork handler */
         __kmp_register_atfork();
     #endif
 
-    #if ! defined GUIDEDLL_EXPORTS
+    #if ! defined KMP_DYNAMIC_LIB
         {
             /* Invoke the exit handler when the program finishes, only for static library.
                For dynamic library, we already have _fini and DllMain.
              */
             int rc = atexit( __kmp_internal_end_atexit );
             if ( rc != 0 ) {
                 __kmp_msg( kmp_ms_fatal, KMP_MSG( FunctionError, "atexit()" ), KMP_ERR( rc ), __kmp_msg_null );
             }; // if

openmp/trunk/runtime/src/kmp_version.c

 // Detect librray type (perf, stub).
 #ifdef KMP_STUB
     #define KMP_LIB_TYPE "stub"
 #else
     #define KMP_LIB_TYPE "performance"
 #endif // KMP_LIB_TYPE
 
 // Detect link type (static, dynamic).
-#ifdef GUIDEDLL_EXPORTS
+#ifdef KMP_DYNAMIC_LIB
     #define KMP_LINK_TYPE "dynamic"
 #else
     #define KMP_LINK_TYPE "static"
 #endif // KMP_LINK_TYPE
 
 // Finally, define strings.
 #define KMP_LIBRARY   KMP_LIB_TYPE " library (" KMP_LINK_TYPE ")"
 #define KMP_COPYRIGHT ""

openmp/trunk/runtime/src/makefile.mk

 ifneq "$(os)" "win"
     cpp-flags += -D USE_CBLKDATA
     # ??? Windows* OS: USE_CBLKDATA defined in kmp.h.
 endif
 ifeq "$(os)" "win"
     cpp-flags += -D KMP_WIN_CDECL
 endif
 ifeq "$(LINK_TYPE)" "dyna"
-    cpp-flags += -D GUIDEDLL_EXPORTS
+    cpp-flags += -D KMP_DYNAMIC_LIB
 endif
 ifeq "$(LIB_TYPE)" "stub"
     cpp-flags += -D KMP_STUB
 endif
 ifeq "$(VERSION)" "4"
 else # 5
     ifeq "$(os)" "win"
     else

openmp/trunk/runtime/src/z_Windows_NT_util.c

__kmp_runtime_initialize( void )
     SYSTEM_INFO info;
     kmp_str_buf_t path;
     UINT path_size;
 
     if ( __kmp_init_runtime ) {
         return;
     };
 
-#if GUIDEDLL_EXPORTS
+#if KMP_DYNAMIC_LIB
     /* Pin dynamic library for the lifetime of application */
     {
         // First, turn off error message boxes
         UINT err_mode = SetErrorMode (SEM_FAILCRITICALERRORS);
         HMODULE h;
         BOOL ret = GetModuleHandleEx( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
                                      |GET_MODULE_HANDLE_EX_FLAG_PIN,
                                      (LPCTSTR)&__kmp_serial_initialize, &h);
#endif /* USE_ITT_BUILD */
 
     #if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
         if ( ! __kmp_cpuinfo.initialized ) {
             __kmp_query_cpuid( & __kmp_cpuinfo );
         }; // if
     #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
     /* Set up minimum number of threads to switch to TLS gtid */
-    #if KMP_OS_WINDOWS && ! defined GUIDEDLL_EXPORTS
+    #if KMP_OS_WINDOWS && ! defined KMP_DYNAMIC_LIB
         // Windows* OS, static library.
         /*
             New thread may use stack space previously used by another thread, currently terminated.
             On Windows* OS, in case of static linking, we do not know the moment of thread termination,
             and our structures (__kmp_threads and __kmp_root arrays) are still keep info about dead
             threads. This leads to problem in __kmp_get_global_thread_id() function: it wrongly
             finds gtid (by searching through stack addresses of all known threads) for unregistered
             foreign tread.