Support clang compiling under windows-gnu and windows-msvc

[SquallATF]

Summary

compiling under mingw still need masm because z_Windows_NT-586_asm.asm need masm to build, but can use uasm replace masm.

I have build both x86_64 and i686 versions under mingw without OMPT, and pass all tests.
i686 version have 2 tests need run with administrator privileges.

clang-cl can build, but can not pass tests, because most tests not support clang-cl.

[mstorsjo]

I don't know whom to add as reviewer here unfortunately. Most of the changes look pretty straightforward, but there's quite a lot of them. Would it make sense to split some of it into separate reviews/commits, to allow more explanations for each kind of change?

[SquallATF]

Support clang compiling under windows-gnu and windows-msvc

[SquallATF]

• misc fix, forget commit -mrtm flag handle.

[jlpeyton]

Add two lines in kmp_config.h.cmake:

#cmakedefine01 MSVC
#define KMP_MSVC_COMPAT MSVC

And instead of having the !defined(__MINGW32__) or #ifndef __MINGW32__ guard, use KMP_MSVC_COMPAT instead.

runtime/cmake/config-ix.cmake

85–87

I don't think the if(CMAKE_C_COMPILER_ID STREQUAL "Clang") condition is necessary here.

runtime/src/kmp_affinity.h

378–397

Change all size_t i to int i instead of adding the static_cast<size_t>

runtime/src/kmp_dispatch.cpp

27

It would be nice if you could add another macro to kmp_os.h like this:

#define KMP_USE_X87CONTROL (KMP_OS_WINDOWS && KMP_ARCH_X86 && !KMP_COMPILER_CLANG)

and use it here and below in this file.

What was the problem with clang-cl? Why did it fail with _control87()?

runtime/src/kmp_os.h

249

This use of __MINGW32__ is ok.

299

Will using KMP_MSVC_COMPAT work here as well instead of __GNUC__?

runtime/src/kmp_settings.cpp

5516–5520

Change num_bits_in_mask from int to DWORD instead of static_cast<>

[SquallATF]

• update patch

[jlpeyton]

Sorry for late reply, this looks good to me.

[SquallATF]

@jlpeyton Please help me commit this patch and depend, I did not have permission to commit it

runtime/cmake/config-ix.cmake

 check_c_compiler_flag(-Wvla-extension LIBOMP_HAVE_WNO_VLA_EXTENSION_FLAG)
 check_c_compiler_flag(-Wformat-pedantic LIBOMP_HAVE_WNO_FORMAT_PEDANTIC_FLAG)
 check_c_compiler_flag(-Wstringop-overflow=0 LIBOMP_HAVE_WSTRINGOP_OVERFLOW_FLAG)
 check_c_compiler_flag(-msse2 LIBOMP_HAVE_MSSE2_FLAG)
 check_c_compiler_flag(-ftls-model=initial-exec LIBOMP_HAVE_FTLS_MODEL_FLAG)
 libomp_check_architecture_flag(-mmic LIBOMP_HAVE_MMIC_FLAG)
 libomp_check_architecture_flag(-m32 LIBOMP_HAVE_M32_FLAG)
 if(WIN32)
+  if(MSVC)
     # Check Windows MSVC style flags.
     check_c_compiler_flag(/TP LIBOMP_HAVE_TP_FLAG)
     check_cxx_compiler_flag(/EHsc LIBOMP_HAVE_EHSC_FLAG)
     check_cxx_compiler_flag(/GS LIBOMP_HAVE_GS_FLAG)
     check_cxx_compiler_flag(/Oy- LIBOMP_HAVE_Oy__FLAG)
     check_cxx_compiler_flag(/arch:SSE2 LIBOMP_HAVE_ARCH_SSE2_FLAG)
     check_cxx_compiler_flag(/Qsafeseh LIBOMP_HAVE_QSAFESEH_FLAG)
+  endif()
+  if(CMAKE_C_COMPILER_ID STREQUAL "Clang")
+    check_c_compiler_flag(-mrtm LIBOMP_HAVE_MRTM_FLAG)
+  endif()
   # It is difficult to create a dummy masm assembly file
   # and then check the MASM assembler to see if these flags exist and work,
   # so we assume they do for Windows.
   set(LIBOMP_HAVE_SAFESEH_MASM_FLAG TRUE)
   set(LIBOMP_HAVE_COFF_MASM_FLAG TRUE)
   # Change Windows flags /MDx to /MTx
   foreach(libomp_lang IN ITEMS C CXX)
     foreach(libomp_btype IN ITEMS DEBUG RELWITHDEBINFO RELEASE MINSIZEREL)

runtime/src/kmp.h

 #endif
 
 typedef int PACKED_REDUCTION_METHOD_T;
 
 /* -- end of fast reduction stuff ----------------------------------------- */
 
 #if KMP_OS_WINDOWS
 #define USE_CBLKDATA
+#if !defined(__MINGW32__)
 #pragma warning(push)
 #pragma warning(disable : 271 310)
+#endif
 #include <windows.h>
+#if !defined(__MINGW32__)
 #pragma warning(pop)
 #endif
+#endif
 
 #if KMP_OS_UNIX
 #include <dlfcn.h>
 #include <pthread.h>
 #endif
 
 /* Only Linux* OS and Windows* OS support thread affinity. */
 #if KMP_AFFINITY_SUPPORTED
 
 // GROUP_AFFINITY is already defined for _MSC_VER>=1600 (VS2010 and later).
 #if KMP_OS_WINDOWS
-#if _MSC_VER < 1600
+#if _MSC_VER < 1600 && !defined(__MINGW32__)
 typedef struct GROUP_AFFINITY {
   KAFFINITY Mask;
   WORD Group;
   WORD Reserved[3];
 } GROUP_AFFINITY;
 #endif /* _MSC_VER < 1600 */
 #if KMP_GROUP_AFFINITY
 extern int __kmp_num_proc_groups;

runtime/src/kmp_affinity.h

public:
     }
     bool is_set(int i) const override {
       return (mask[i / BITS_PER_MASK_T] & ((mask_t)1 << (i % BITS_PER_MASK_T)));
     }
     void clear(int i) override {
       mask[i / BITS_PER_MASK_T] &= ~((mask_t)1 << (i % BITS_PER_MASK_T));
     }
     void zero() override {
-      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+      for (size_t i = 0; i < static_cast<size_t>(__kmp_num_proc_groups); ++i)
         mask[i] = 0;
     }
     void copy(const KMPAffinity::Mask *src) override {
       const Mask *convert = static_cast<const Mask *>(src);
-      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+      for (size_t i = 0; i < static_cast<size_t>(__kmp_num_proc_groups); ++i)
         mask[i] = convert->mask[i];
     }
     void bitwise_and(const KMPAffinity::Mask *rhs) override {
       const Mask *convert = static_cast<const Mask *>(rhs);
-      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+      for (size_t i = 0; i < static_cast<size_t>(__kmp_num_proc_groups); ++i)
         mask[i] &= convert->mask[i];
     }
     void bitwise_or(const KMPAffinity::Mask *rhs) override {
       const Mask *convert = static_cast<const Mask *>(rhs);
-      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+      for (size_t i = 0; i < static_cast<size_t>(__kmp_num_proc_groups); ++i)
         mask[i] |= convert->mask[i];
     }
     void bitwise_not() override {
-      for (size_t i = 0; i < __kmp_num_proc_groups; ++i)
+      for (size_t i = 0; i < static_cast<size_t>(__kmp_num_proc_groups); ++i)
         mask[i] = ~(mask[i]);
     }
     int begin() const override {
       int retval = 0;
       while (retval < end() && !is_set(retval))
         ++retval;
       return retval;
     }

runtime/src/kmp_dispatch.cpp

  */
 
 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_stats.h"
 #include "kmp_str.h"
-#if KMP_OS_WINDOWS && KMP_ARCH_X86
+#if KMP_OS_WINDOWS && KMP_ARCH_X86 && !KMP_COMPILER_CLANG
 #include <float.h>
 #endif
 #include "kmp_lock.h"
 #include "kmp_dispatch.h"
 #if KMP_USE_HIER_SCHED
 #include "kmp_dispatch_hier.h"
 #endif
 
case kmp_sch_guided_analytical_chunked: {
     if (nproc > 1) {
       if ((2L * chunk + 1) * nproc >= tc) {
         /* chunk size too large, switch to dynamic */
         schedule = kmp_sch_dynamic_chunked;
       } else {
         /* commonly used term: (2 nproc - 1)/(2 nproc) */
         DBL x;
 
-#if KMP_OS_WINDOWS && KMP_ARCH_X86
+#if KMP_OS_WINDOWS && KMP_ARCH_X86 && !KMP_COMPILER_CLANG
         /* Linux* OS already has 64-bit computation by default for long double,
            and on Windows* OS on Intel(R) 64, /Qlong_double doesn't work. On
            Windows* OS on IA-32 architecture, we need to set precision to 64-bit
            instead of the default 53-bit. Even though long double doesn't work
            on Windows* OS on Intel(R) 64, the resulting lack of precision is not
            expected to impact the correctness of the algorithm, but this has not
            been mathematically proven. */
         // save original FPCW and set precision to 64-bit, as

 #define GUIDED_ANALYTICAL_WORKAROUND (*(DBL *)&pr->u.p.parm3)
 #else
 #define GUIDED_ANALYTICAL_WORKAROUND (x)
 #endif
         /* dynamic-style scheduling offset */
         pr->u.p.count = tc - __kmp_dispatch_guided_remaining(
                                  tc, GUIDED_ANALYTICAL_WORKAROUND, cross) -
                         cross * chunk;
-#if KMP_OS_WINDOWS && KMP_ARCH_X86
+#if KMP_OS_WINDOWS && KMP_ARCH_X86 && !KMP_COMPILER_CLANG
         // restore FPCW
         _control87(oldFpcw, _MCW_PC);
 #endif
       } // if
     } else {
       KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d falling-through to "
                      "kmp_sch_static_greedy\n",
                      gtid));
case kmp_sch_guided_simd: {
     } // if
   } // case
   break;
 #endif // OMP_45_ENABLED
 
   case kmp_sch_guided_analytical_chunked: {
     T chunkspec = pr->u.p.parm1;
     UT chunkIdx;
-#if KMP_OS_WINDOWS && KMP_ARCH_X86
+#if KMP_OS_WINDOWS && KMP_ARCH_X86 && !KMP_COMPILER_CLANG
     /* for storing original FPCW value for Windows* OS on
        IA-32 architecture 8-byte version */
     unsigned int oldFpcw;
     unsigned int fpcwSet = 0;
 #endif
     KD_TRACE(100, ("__kmp_dispatch_next_algorithm: T#%d "
                    "kmp_sch_guided_analytical_chunked case\n",
                    gtid));
while (1) { /* this while loop is a safeguard against unexpected zero
         }
         break;
       } else {
 /* use exponential-style scheduling */
 /* The following check is to workaround the lack of long double precision on
    Windows* OS.
    This check works around the possible effect that init != 0 for chunkIdx == 0.
  */
-#if KMP_OS_WINDOWS && KMP_ARCH_X86
+#if KMP_OS_WINDOWS && KMP_ARCH_X86 && !KMP_COMPILER_CLANG
         /* If we haven't already done so, save original
            FPCW and set precision to 64-bit, as Windows* OS
            on IA-32 architecture defaults to 53-bit */
         if (!fpcwSet) {
           oldFpcw = _control87(0, 0);
           _control87(_PC_64, _MCW_PC);
           fpcwSet = 0x30000;
         }
#endif
         if (init < limit) {
           KMP_DEBUG_ASSERT(limit <= trip);
           --limit;
           status = 1;
           break;
         } // if
       } // if
     } // while (1)
-#if KMP_OS_WINDOWS && KMP_ARCH_X86
+#if KMP_OS_WINDOWS && KMP_ARCH_X86 && !KMP_COMPILER_CLANG
     /* restore FPCW if necessary
        AC: check fpcwSet flag first because oldFpcw can be uninitialized here
     */
     if (fpcwSet && (oldFpcw & fpcwSet))
       _control87(oldFpcw, _MCW_PC);
 #endif
     if (status != 0) {
       start = pr->u.p.lb;

runtime/src/kmp_io.cpp

 
 #include "kmp.h" // KMP_GTID_DNE, __kmp_debug_buf, etc
 #include "kmp_io.h"
 #include "kmp_lock.h"
 #include "kmp_os.h"
 #include "kmp_str.h"
 
 #if KMP_OS_WINDOWS
+#if !defined(__MINGW32__)
 #pragma warning(push)
 #pragma warning(disable : 271 310)
+#endif
 #include <windows.h>
+#if !defined(__MINGW32__)
 #pragma warning(pop)
 #endif
+#endif
 
 /* ------------------------------------------------------------------------ */
 
 kmp_bootstrap_lock_t __kmp_stdio_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
     __kmp_stdio_lock); /* Control stdio functions */
 kmp_bootstrap_lock_t __kmp_console_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
     __kmp_console_lock); /* Control console initialization */
 

runtime/src/kmp_lock.cpp

static void __kmp_set_queuing_lock_flags(kmp_queuing_lock_t *lck,
                                          kmp_lock_flags_t flags) {
   lck->lk.flags = flags;
 }
 
 #if KMP_USE_ADAPTIVE_LOCKS
 
 /* RTM Adaptive locks */
 
-#if KMP_COMPILER_ICC && __INTEL_COMPILER >= 1300
+#if (KMP_COMPILER_ICC && __INTEL_COMPILER >= 1300) || KMP_COMPILER_CLANG
 
 #include <immintrin.h>
 #define SOFT_ABORT_MASK (_XABORT_RETRY | _XABORT_CONFLICT | _XABORT_EXPLICIT)
 
 #else
 
 // Values from the status register after failed speculation.
 #define _XBEGIN_STARTED (~0u)

runtime/src/kmp_os.h

 //-------------------------------------------------------------------------
 #else
 #define CCAST(type, var) (type)(var)
 #define RCAST(type, var) (type)(var)
 #endif // __cplusplus
 
 #define KMP_EXPORT extern /* export declaration in guide libraries */
 
-#if __GNUC__ >= 4
+#if __GNUC__ >= 4 && !defined(__MINGW32__)
 #define __forceinline __inline
 #endif
 
 #if KMP_OS_WINDOWS
 #include <windows.h>
 
 static inline int KMP_GET_PAGE_SIZE(void) {
   SYSTEM_INFO si;

 #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
+#if KMP_OS_WINDOWS && !defined(__GNUC__)
 #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
enum kmp_mem_fence_type {
   kmp_release_fence, /* Release (write) memory fence */
   kmp_full_fence /* Full (read+write) memory fence */
 };
 
 // Synchronization primitives
 
 #if KMP_ASM_INTRINS && KMP_OS_WINDOWS
 
+#if !defined(__MINGW32__)
 #pragma intrinsic(InterlockedExchangeAdd)
 #pragma intrinsic(InterlockedCompareExchange)
 #pragma intrinsic(InterlockedExchange)
 #pragma intrinsic(InterlockedExchange64)
+#endif
 
 // Using InterlockedIncrement / InterlockedDecrement causes a library loading
 // ordering problem, so we use InterlockedExchangeAdd instead.
 #define KMP_TEST_THEN_INC32(p) InterlockedExchangeAdd((volatile long *)(p), 1)
 #define KMP_TEST_THEN_INC_ACQ32(p)                                             \
   InterlockedExchangeAdd((volatile long *)(p), 1)
 #define KMP_TEST_THEN_ADD4_32(p) InterlockedExchangeAdd((volatile long *)(p), 4)
 #define KMP_TEST_THEN_ADD4_ACQ32(p)                                            \

runtime/src/kmp_platform.h

 #define KMP_ARCH_AARCH64 0
 #define KMP_ARCH_PPC64_BE 0
 #define KMP_ARCH_PPC64_LE 0
 #define KMP_ARCH_PPC64 (KMP_ARCH_PPC64_LE || KMP_ARCH_PPC64_BE)
 #define KMP_ARCH_MIPS 0
 #define KMP_ARCH_MIPS64 0
 
 #if KMP_OS_WINDOWS
-#if defined _M_AMD64
+#if defined(_M_AMD64) || defined(__x86_64)
 #undef KMP_ARCH_X86_64
 #define KMP_ARCH_X86_64 1
 #else
 #undef KMP_ARCH_X86
 #define KMP_ARCH_X86 1
 #endif
 #endif
 

runtime/src/kmp_safe_c_api.h

 
 #ifndef KMP_SAFE_C_API_H
 #define KMP_SAFE_C_API_H
 
 // Replacement for banned C API
 
 // Not every unsafe call listed here is handled now, but keeping everything
 // in one place should be handy for future maintenance.
-#if KMP_OS_WINDOWS
+#if KMP_OS_WINDOWS && !defined(__MINGW32__)
 
 #define RSIZE_MAX_STR (4UL << 10) // 4KB
 
 // _malloca was suggested, but it is not a drop-in replacement for _alloca
 #define KMP_ALLOCA _alloca
 
 #define KMP_MEMCPY_S memcpy_s
 #define KMP_SNPRINTF sprintf_s

runtime/src/kmp_settings.cpp

#if KMP_GROUP_AFFINITY
         KMP_CPU_ALLOC(init_mask);
         __kmp_get_system_affinity(init_mask, TRUE);
         group = __kmp_get_proc_group(init_mask);
         within_one_group = (group >= 0);
         // If the initial affinity is within a single group,
         // then determine if it is equal to that single group.
         if (within_one_group) {
           DWORD num_bits_in_group = __kmp_GetActiveProcessorCount(group);
           int num_bits_in_mask = 0;
           for (int bit = init_mask->begin(); bit != init_mask->end();
                bit = init_mask->next(bit))
             num_bits_in_mask++;
-          exactly_one_group = (num_bits_in_group == num_bits_in_mask);
+          exactly_one_group = (num_bits_in_group == static_cast<DWORD>(num_bits_in_mask));
         }
         KMP_CPU_FREE(init_mask);
       }
 
       // Handle the Win 64 group affinity stuff if there are multiple
       // processor groups, or if the user requested it, and OMP 4.0
       // affinity is not in effect.
       if (((__kmp_num_proc_groups > 1) &&

runtime/src/kmp_utility.cpp

while (*pattern != '\0' && pos < end) {
               ++pos;
             ++pattern;
           } else
             pos = end;
         } break;
         case 'I':
         case 'i': {
           pid_t id = getpid();
+#if KMP_ARCH_X86_64 && defined(__MINGW32__)
+          snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*lld", width, id);
+#else
           snp_result = KMP_SNPRINTF(pos, end - pos + 1, "%0*d", width, id);
+#endif
           if (snp_result >= 0 && snp_result <= end - pos) {
             while (*pos)
               ++pos;
             ++pattern;
           } else
             pos = end;
           break;
         }

runtime/src/kmp_wrapper_getpid.h

 #endif
 
 #elif KMP_OS_WINDOWS
 
 // On Windows* OS _getpid() returns int (not pid_t) and is declared in
 // "process.h".
 #include <process.h>
 // Let us simulate Unix.
+#ifndef __MINGW32__
 typedef int pid_t;
+#endif
 #define getpid _getpid
 #define __kmp_gettid() GetCurrentThreadId()
 
 #else
 
 #error Unknown or unsupported OS.
 
 #endif

runtime/src/kmp_wrapper_malloc.h

 
 #include <stdlib.h>
 
 #include "kmp_os.h"
 
 // Include alloca() declaration.
 #if KMP_OS_WINDOWS
 #include <malloc.h> // Windows* OS: _alloca() declared in "malloc.h".
+#ifndef __MINGW32__
 #define alloca _alloca // Allow to use alloca() with no underscore.
+#endif
 #elif KMP_OS_FREEBSD || KMP_OS_NETBSD
 // Declared in "stdlib.h".
 #elif KMP_OS_UNIX
 #include <alloca.h> // Linux* OS and OS X*: alloc() declared in "alloca".
 #else
 #error Unknown or unsupported OS.
 #endif
 

runtime/src/libomp.rc.var

 // libomp.rc.var
 
 //
 ////===----------------------------------------------------------------------===//
 ////
 ////                     The LLVM Compiler Infrastructure
 ////
 //// This file is dual licensed under the MIT and the University of Illinois Open
 //// Source Licenses. See LICENSE.txt for details.
 ////
 ////===----------------------------------------------------------------------===//
 //
 
-#include "winres.h"
+#include "winresrc.h"
 #include "kmp_config.h"
 
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US    // English (U.S.) resources
 #pragma code_page(1252)
 
 VS_VERSION_INFO VERSIONINFO
     // Parts of FILEVERSION and PRODUCTVERSION are 16-bit fields, entire build date yyyymmdd
     // does not fit into one version part, so we need to split it into yyyy and mmdd:

runtime/src/thirdparty/ittnotify/ittnotify_static.c

 
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "kmp_config.h"
 #include "ittnotify_config.h"
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if defined(__MINGW32__)
+#include <limits.h>
+#else
 #define PATH_MAX 512
+#endif
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 #include <limits.h>
 #include <dlfcn.h>
 #include <errno.h>
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 
 #define INTEL_NO_MACRO_BODY
 #define INTEL_ITTNOTIFY_API_PRIVATE
 #include "ittnotify.h"
 #include "legacy/ittnotify.h"
 
+#if !defined(__MINGW32__)
 #include "disable_warnings.h"
+#endif
 
 static const char api_version[] = API_VERSION "\0\n@(#) $Revision: 481659 $\n";
 
 #define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
 
 #if ITT_OS==ITT_OS_WIN
 static const char* ittnotify_lib_name = "libittnotify.dll";
 #elif ITT_OS==ITT_OS_LINUX || ITT_OS==ITT_OS_FREEBSD
static __itt_group_alias group_alias[] = {
     { "KMP_FOR_TPROFILE", (__itt_group_id)(__itt_group_control | __itt_group_thread | __itt_group_sync  | __itt_group_mark) },
     { "KMP_FOR_TCHECK",   (__itt_group_id)(__itt_group_control | __itt_group_thread | __itt_group_sync  | __itt_group_fsync | __itt_group_mark | __itt_group_suppress) },
     { NULL,               (__itt_group_none) },
     { api_version,        (__itt_group_none) } /* !!! Just to avoid unused code elimination !!! */
 };
 
 #pragma pack(pop)
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM==ITT_PLATFORM_WIN && !defined(__MINGW32__)
 #pragma warning(push)
 #pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function pointer 'XXX' to data pointer 'void *' */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 static __itt_api_info api_list[] = {
 /* Define functions with static implementation */
 #undef ITT_STUB
 #undef ITT_STUBV
 #define ITT_STUB(api,type,name,args,params,nameindll,group,format) { ITT_TO_STR(ITT_JOIN(__itt_,nameindll)), (void**)(void*)&ITTNOTIFY_NAME(name), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), (__itt_group_id)(group)},
 #define ITT_STUBV ITT_STUB
 #define __ITT_INTERNAL_INIT
 #include "ittnotify_static.h"
 #undef __ITT_INTERNAL_INIT
 /* Define functions without static implementation */
 #undef ITT_STUB
 #undef ITT_STUBV
 #define ITT_STUB(api,type,name,args,params,nameindll,group,format) {ITT_TO_STR(ITT_JOIN(__itt_,nameindll)), (void**)(void*)&ITTNOTIFY_NAME(name), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), NULL, (__itt_group_id)(group)},
 #define ITT_STUBV ITT_STUB
 #include "ittnotify_static.h"
     {NULL, NULL, NULL, NULL, __itt_group_none}
 };
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM==ITT_PLATFORM_WIN && !defined(__MINGW32__)
 #pragma warning(pop)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 static const char dll_path[PATH_MAX] = { 0 };
 
 /* static part descriptor which handles. all notification api attributes. */
 __itt_global _N_(_ittapi_global) = {
     ITT_MAGIC,                                     /* identification info */

 typedef void (__itt_api_fini_t)(__itt_global*);
 
 /* ========================================================================= */
 
 #ifdef ITT_NOTIFY_EXT_REPORT
 ITT_EXTERN_C void _N_(error_handler)(__itt_error_code, va_list args);
 #endif /* ITT_NOTIFY_EXT_REPORT */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM==ITT_PLATFORM_WIN && !defined(__MINGW32__)
 #pragma warning(push)
 #pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer 'void *' to function pointer 'XXX' */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 static void __itt_report_error(unsigned code_arg, ...)
 {
     va_list args;
     va_start(args, code_arg);
if (_N_(_ittapi_global).error_handler != NULL)
         handler(code, args);
     }
 #ifdef ITT_NOTIFY_EXT_REPORT
     _N_(error_handler)(code, args);
 #endif /* ITT_NOTIFY_EXT_REPORT */
     va_end(args);
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM==ITT_PLATFORM_WIN && !defined(__MINGW32__)
 #pragma warning(pop)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
 static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW),_init))(const wchar_t* name)
 {
     __itt_domain *h_tail = NULL, *h = NULL;
 

 static void __itt_nullify_all_pointers(void)
 {
     int i;
     /* Nulify all pointers except domain_create, string_handle_create  and counter_create */
     for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
         *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func;
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM==ITT_PLATFORM_WIN && !defined(__MINGW32__)
 #pragma warning(push)
 #pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function pointer 'XXX' to data pointer 'void *' */
 #pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer 'void *' to function pointer 'XXX' */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 ITT_EXTERN_C void _N_(fini_ittlib)(void)
 {
     __itt_api_fini_t* __itt_api_fini_ptr = NULL;

 
 ITT_EXTERN_C __itt_error_handler_t* _N_(set_error_handler)(__itt_error_handler_t* handler)
 {
     __itt_error_handler_t* prev = (__itt_error_handler_t*)(size_t)_N_(_ittapi_global).error_handler;
     _N_(_ittapi_global).error_handler = (void*)(size_t)handler;
     return prev;
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM==ITT_PLATFORM_WIN && !defined(__MINGW32__)
 #pragma warning(pop)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 

runtime/src/z_Windows_NT_util.cpp

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