summaryrefslogtreecommitdiffstats
path: root/openmp/runtime/cmake
diff options
context:
space:
mode:
Diffstat (limited to 'openmp/runtime/cmake')
-rw-r--r--openmp/runtime/cmake/BuildPLRules.cmake100
-rw-r--r--openmp/runtime/cmake/Clang/AsmFlags.cmake16
-rw-r--r--openmp/runtime/cmake/Clang/CFlags.cmake38
-rw-r--r--openmp/runtime/cmake/CommonFlags.cmake133
-rw-r--r--openmp/runtime/cmake/Definitions.cmake131
-rw-r--r--openmp/runtime/cmake/GNU/AsmFlags.cmake16
-rw-r--r--openmp/runtime/cmake/GNU/CFlags.cmake45
-rw-r--r--openmp/runtime/cmake/GNU/FortranFlags.cmake14
-rw-r--r--openmp/runtime/cmake/HelperFunctions.cmake254
-rw-r--r--openmp/runtime/cmake/Intel/AsmFlags.cmake31
-rw-r--r--openmp/runtime/cmake/Intel/CFlags.cmake148
-rw-r--r--openmp/runtime/cmake/Intel/FortranFlags.cmake29
-rw-r--r--openmp/runtime/cmake/MSVC/AsmFlags.cmake26
-rw-r--r--openmp/runtime/cmake/MSVC/CFlags.cmake64
-rw-r--r--openmp/runtime/cmake/MicroTests.cmake277
-rw-r--r--openmp/runtime/cmake/PerlFlags.cmake90
-rw-r--r--openmp/runtime/cmake/SourceFiles.cmake110
17 files changed, 1522 insertions, 0 deletions
diff --git a/openmp/runtime/cmake/BuildPLRules.cmake b/openmp/runtime/cmake/BuildPLRules.cmake
new file mode 100644
index 00000000000..8db0f2f5576
--- /dev/null
+++ b/openmp/runtime/cmake/BuildPLRules.cmake
@@ -0,0 +1,100 @@
+###############################################################################
+# This file contains additional build rules that correspond to build.pl's rules
+# Building libiomp5.dbg is linux only, Windows will build libiomp5md.dll.pdb
+#
+# ######### BUILD DEPENDENCIES ##########
+#
+# exports/.../libiomp5.so exports/.../libiomp5.dbg
+# [copy] | | [copy]
+# | |
+# ./libiomp5.so ./libiomp5.dbg
+# [copy] / OR \____________ [copy] | [copy]
+# / \ |
+# ./unstripped/libiomp5.so ./stripped/libiomp5.so ./unstripped/libiomp5.dbg
+# / \ /
+# / [linking] \[strip] /[strip and store]
+# / \ /
+# ${objs} (maybe compiled with -g) ./unstripped/libiomp5.so (library with debug info in it)
+# |
+# | [linking]
+# |
+# ${objs} (always compiled with -g)
+#
+# For icc Linux builds, we always include debugging information via -g and create libiomp5.dbg
+# so that Intel(R) Parallel Amplifier can use the .dbg file.
+# For icc Windows builds, we always include debugging information via -Zi and create libiomp5.pdb
+# in a fashion similar to libiomp5.dbg
+# For icc Mac builds, we don't bother with the debug info.
+
+# We build library in unstripped directory
+file(MAKE_DIRECTORY ${build_dir}/unstripped)
+
+# Only build the .dbg file for Release builds
+# Debug and RelWithDebInfo builds should not create a .dbg file.
+# The debug info should remain in the library file.
+if(${LINUX} AND ${RELEASE_BUILD})
+ set(dbg_file ${lib_item}.dbg)
+endif()
+
+################################
+# --- Create $(lib_file).dbg ---
+if(NOT "${dbg_file}" STREQUAL "")
+ # if a ${dbg_file} file is going to be created, then
+ file(MAKE_DIRECTORY ${build_dir}/stripped)
+
+ # ./${lib_file} : stripped/${lib_file}
+ # copy stripped/${lib_file} ./${lib_file}
+ simple_copy_recipe("${lib_file}" "${build_dir}/stripped" "${build_dir}")
+
+ # stripped/${lib_file} : unstripped/${lib_file} ./${dbg_file}
+ # objcopy --strip-debug unstripped/${lib_file} stripped/${lib_file}.tmp
+ # objcopy --add-gnu-debuglink=${dbg_file} stripped/${lib_file}.tmp stripped/${lib_file}
+ add_custom_command(
+ OUTPUT ${build_dir}/stripped/${lib_file}
+ COMMAND ${CMAKE_OBJCOPY} --strip-debug ${build_dir}/unstripped/${lib_file} ${build_dir}/stripped/${lib_file}.tmp
+ COMMAND ${CMAKE_OBJCOPY} --add-gnu-debuglink=${dbg_file} ${build_dir}/stripped/${lib_file}.tmp ${build_dir}/stripped/${lib_file}
+ DEPENDS "${build_dir}/${dbg_file}"
+ )
+
+ # ./${dbg_file} : unstripped/${dbg_file}
+ # copy unstripped/${dbg_file} ./${dbg_file}
+ simple_copy_recipe("${dbg_file}" "${build_dir}/unstripped" "${build_dir}")
+
+ # unstripped/${dbg_file} : unstripped/${lib_file}
+ # objcopy --only-keep-debug unstripped/${lib_file} unstripped/${dbg_file}
+ add_custom_command(
+ OUTPUT ${build_dir}/unstripped/${dbg_file}
+ COMMAND ${CMAKE_OBJCOPY} --only-keep-debug ${build_dir}/unstripped/${lib_file} ${build_dir}/unstripped/${dbg_file}
+ DEPENDS iomp5
+ )
+
+else()
+
+ # ./${lib_file} : unstripped/${lib_file}
+ # copy unstripped/${lib_file} ./${lib_file}
+ simple_copy_recipe("${lib_file}" "${build_dir}/unstripped" "${build_dir}")
+endif()
+
+# Windows specific command to move around debug info files post-build
+if(NOT "${pdb_file}" STREQUAL "" AND ${RELEASE_BUILD})
+ add_custom_command(TARGET iomp5 POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E rename ${pdb_file} ${pdb_file}.nonstripped
+ COMMAND ${CMAKE_COMMAND} -E rename ${pdb_file}.stripped ${pdb_file}
+ )
+endif()
+
+# Have icc build libiomp5 in unstripped directory
+set_target_properties(iomp5 PROPERTIES
+ LIBRARY_OUTPUT_DIRECTORY "${build_dir}/unstripped"
+ RUNTIME_OUTPUT_DIRECTORY "${build_dir}/unstripped"
+ ARCHIVE_OUTPUT_DIRECTORY "${build_dir}"
+)
+
+# Always use RelWithDebInfo flags for Release builds when using the build.pl's build rules (use -g -O2 instead of just -O3)
+# The debug info is then stripped out at the end of the build and put into libiomp5.dbg for Linux
+if(${RELEASE_BUILD} AND NOT ${MAC})
+ set(CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELWITHDEBINFO} )
+ set(CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
+ set(CMAKE_ASM_FLAGS_RELEASE ${CMAKE_ASM_FLAGS_RELWITHDEBINFO})
+endif()
+
diff --git a/openmp/runtime/cmake/Clang/AsmFlags.cmake b/openmp/runtime/cmake/Clang/AsmFlags.cmake
new file mode 100644
index 00000000000..b23e6b9a499
--- /dev/null
+++ b/openmp/runtime/cmake/Clang/AsmFlags.cmake
@@ -0,0 +1,16 @@
+# This file holds Clang (clang/clang++) specific compiler dependent flags
+# The flag types are:
+# 1) Assembly flags
+
+#########################################################
+# Assembly flags
+function(append_assembler_specific_asm_flags input_asm_flags)
+ set(local_asm_flags)
+ append_asm_flags("-x assembler-with-cpp") # Assembly file that needs to be preprocessed
+ if(${IA32})
+ append_asm_flags("-m32") # Generate 32 bit IA-32 architecture code
+ append_asm_flags("-msse2") # Allow use of Streaming SIMD Instructions
+ endif()
+ set(${input_asm_flags} ${${input_asm_flags}} "${local_asm_flags}" PARENT_SCOPE)
+endfunction()
+
diff --git a/openmp/runtime/cmake/Clang/CFlags.cmake b/openmp/runtime/cmake/Clang/CFlags.cmake
new file mode 100644
index 00000000000..54e180972d6
--- /dev/null
+++ b/openmp/runtime/cmake/Clang/CFlags.cmake
@@ -0,0 +1,38 @@
+# This file holds Clang (clang/clang++) specific compiler dependent flags
+# The flag types are:
+# 1) C/C++ Compiler flags
+# 2) Linker flags
+
+#########################################################
+# C/C++ Compiler flags
+function(append_compiler_specific_c_and_cxx_flags input_c_flags input_cxx_flags)
+ set(local_c_flags)
+ set(local_cxx_flags)
+ append_c_and_cxx_flags("-std=c++0x") # Enables support for many C++11 (formerly known as C++0x) features. The following are the most recently added features:
+ append_c_and_cxx_flags("-fno-exceptions") # Exception handling table generation is disabled.
+ append_c_and_cxx_flags("-x c++") # Compile C files as C++ files
+ if(${IA32})
+ append_c_and_cxx_flags("-m32") # Generate 32 bit IA-32 architecture code
+ append_c_and_cxx_flags("-msse2") # Allow use of Streaming SIMD Instructions
+ elseif(${ARM})
+ append_c_and_cxx_flags("-marm") # Target the ARM architecture
+ endif()
+ append_c_and_cxx_flags("-Wno-unused-value") # Don't warn about unused values
+ append_c_and_cxx_flags("-Wno-switch") # Don't warn about switch statements that don't cover entire range of values
+ set(${input_c_flags} ${${input_c_flags}} "${local_c_flags}" PARENT_SCOPE)
+ set(${input_cxx_flags} ${${input_cxx_flags}} "${local_cxx_flags}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Linker flags
+function(append_compiler_specific_linker_flags input_ld_flags input_ld_flags_libs)
+ set(local_ld_flags)
+ set(local_ld_flags_libs)
+ if(${IA32})
+ append_linker_flags("-m32")
+ append_linker_flags("-msse2")
+ endif()
+ set(${input_ld_flags} ${${input_ld_flags}} "${local_ld_flags}" PARENT_SCOPE)
+ set(${input_ld_flags_libs} ${${input_ld_flags_libs}} "${local_ld_flags_libs}" PARENT_SCOPE)
+endfunction()
+
diff --git a/openmp/runtime/cmake/CommonFlags.cmake b/openmp/runtime/cmake/CommonFlags.cmake
new file mode 100644
index 00000000000..301a3c4e742
--- /dev/null
+++ b/openmp/runtime/cmake/CommonFlags.cmake
@@ -0,0 +1,133 @@
+# This file holds the common flags independent of compiler
+# The flag types are:
+# 1) Assembly flags (append_asm_flags_common)
+# 2) C/C++ Compiler flags (append_c_and_cxx_flags_common)
+# 3) Fortran Compiler flags (append_fort_flags_common)
+# 4) Linker flags (append_linker_flags_common)
+# 5) Archiver flags (append_archiver_flags_common)
+
+# These append_* macros all append to the corresponding list variable holding the flags.
+macro(append_c_flags new_flag)
+ list(APPEND local_c_flags "${new_flag}")
+endmacro()
+
+macro(append_cxx_flags new_flag)
+ list(APPEND local_cxx_flags "${new_flag}")
+endmacro()
+
+macro(append_c_and_cxx_flags new_flag)
+ append_c_flags("${new_flag}")
+ append_cxx_flags("${new_flag}")
+endmacro()
+
+macro(append_asm_flags new_flag)
+ list(APPEND local_asm_flags "${new_flag}")
+endmacro()
+
+macro(append_fort_flags new_flag)
+ list(APPEND local_fort_flags "${new_flag}")
+endmacro()
+
+# The difference between linker_flags and linker_flags_libs is linker_flags_libs
+# is put at the end of the linker command where linking libraries should be done.
+macro(append_linker_flags new_flag)
+ list(APPEND local_ld_flags "${new_flag}")
+endmacro()
+
+macro(append_linker_flags_library new_flag)
+ list(APPEND local_ld_flags_libs "${new_flag}")
+endmacro()
+
+macro(append_archiver_flags new_flag)
+ list(APPEND local_ar_flags "${new_flag}")
+endmacro()
+
+#########################################################
+# Global Assembly flags
+function(append_asm_flags_common input_asm_flags)
+ set(local_asm_flags)
+ set(${input_asm_flags} "${${input_asm_flags}}" "${local_asm_flags}" "${USER_ASM_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Global C/C++ Compiler flags
+function(append_c_and_cxx_flags_common input_c_flags input_cxx_flags)
+ set(local_c_flags)
+ set(local_cxx_flags)
+ set(${input_c_flags} "${${input_c_flags}}" "${local_c_flags}" "${USER_C_FLAGS}" PARENT_SCOPE)
+ set(${input_cxx_flags} "${${input_cxx_flags}}" "${local_cxx_flags}" "${USER_CXX_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Global Fortran Compiler flags (for creating .mod files)
+function(append_fort_flags_common input_fort_flags)
+ set(local_fort_flags)
+ set(${input_fort_flags} "${${input_fort_flags}}" "${local_fort_flags}" "${USER_F_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Linker flags
+function(append_linker_flags_common input_ld_flags input_ld_flags_libs)
+ set(local_ld_flags)
+ set(local_ld_flags_libs)
+
+ #################################
+ # Windows linker flags
+ if(${WINDOWS})
+
+ ##################
+ # MAC linker flags
+ elseif(${MAC})
+ if(${USE_PREDEFINED_LINKER_FLAGS})
+ append_linker_flags("-single_module")
+ append_linker_flags("-current_version ${version}.0")
+ append_linker_flags("-compatibility_version ${version}.0")
+ endif()
+ #####################################################################################
+ # Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) linker flags
+ elseif(${MIC})
+ if(${USE_PREDEFINED_LINKER_FLAGS})
+ append_linker_flags("-Wl,-x")
+ append_linker_flags("-Wl,--warn-shared-textrel") # Warn if the linker adds a DT_TEXTREL to a shared object.
+ append_linker_flags("-Wl,--as-needed")
+ append_linker_flags("-Wl,--version-script=${src_dir}/exports_so.txt") # Use exports_so.txt as version script to create versioned symbols for ELF libraries
+ if(NOT ${STUBS_LIBRARY})
+ append_linker_flags_library("-pthread") # link in pthread library
+ append_linker_flags_library("-ldl") # link in libdl (dynamic loader library)
+ endif()
+ if(${STATS_GATHERING})
+ append_linker_flags_library("-Wl,-lstdc++") # link in standard c++ library (stats-gathering needs it)
+ endif()
+ endif()
+ #########################
+ # Unix based linker flags
+ else()
+ # For now, always include --version-script flag on Unix systems.
+ append_linker_flags("-Wl,--version-script=${src_dir}/exports_so.txt") # Use exports_so.txt as version script to create versioned symbols for ELF libraries
+ if(${USE_PREDEFINED_LINKER_FLAGS})
+ append_linker_flags("-Wl,-z,noexecstack") # Marks the object as not requiring executable stack.
+ append_linker_flags("-Wl,--as-needed") # Only adds library dependencies as they are needed. (if libiomp5 actually uses a function from the library, then add it)
+ if(NOT ${STUBS_LIBRARY})
+ append_linker_flags("-Wl,--warn-shared-textrel") # Warn if the linker adds a DT_TEXTREL to a shared object.
+ append_linker_flags("-Wl,-fini=__kmp_internal_end_fini") # When creating an ELF executable or shared object, call NAME when the
+ # executable or shared object is unloaded, by setting DT_FINI to the
+ # address of the function. By default, the linker uses "_fini" as the function to call.
+ append_linker_flags_library("-pthread") # link pthread library
+ if(NOT ${FREEBSD})
+ append_linker_flags_library("-Wl,-ldl") # link in libdl (dynamic loader library)
+ endif()
+ endif()
+ endif() # if(${USE_PREDEFINED_LINKER_FLAGS})
+ endif() # if(${OPERATING_SYSTEM}) ...
+
+ set(${input_ld_flags} "${${input_ld_flags}}" "${local_ld_flags}" "${USER_LD_FLAGS}" PARENT_SCOPE)
+ set(${input_ld_flags_libs} "${${input_ld_flags_libs}}" "${local_ld_flags_libs}" "${USER_LD_LIB_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Archiver Flags
+function(append_archiver_flags_common input_ar_flags)
+ set(local_ar_flags)
+ set(${input_ar_flags} "${${input_ar_flags}}" "${local_ar_flags}" PARENT_SCOPE)
+endfunction()
+
diff --git a/openmp/runtime/cmake/Definitions.cmake b/openmp/runtime/cmake/Definitions.cmake
new file mode 100644
index 00000000000..0d12d48f663
--- /dev/null
+++ b/openmp/runtime/cmake/Definitions.cmake
@@ -0,0 +1,131 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#// 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.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+# void append_definitions(string new_flag);
+# - appends new_flag to cpp_flags list
+macro(append_definitions new_flag)
+ list(APPEND local_cpp_flags "${new_flag}")
+endmacro()
+
+function(append_cpp_flags input_cpp_flags)
+ set(local_cpp_flags)
+
+ append_definitions("-D USE_ITT_BUILD")
+ append_definitions("-D KMP_ARCH_STR=\"\\\\\"${legal_arch}\\\\\"\"")
+ append_definitions("-D BUILD_I8")
+ append_definitions("-D KMP_LIBRARY_FILE=\\\\\"${lib_file}\\\\\"") # yes... you need 5 backslashes...
+ append_definitions("-D KMP_VERSION_MAJOR=${version}")
+ append_definitions("-D CACHE_LINE=64")
+ append_definitions("-D KMP_ADJUST_BLOCKTIME=1")
+ append_definitions("-D BUILD_PARALLEL_ORDERED")
+ append_definitions("-D KMP_ASM_INTRINS")
+ if(${USE_ITT_NOTIFY})
+ append_definitions("-D USE_ITT_NOTIFY=1")
+ else()
+ append_definitions("-D USE_ITT_NOTIFY=0")
+ append_definitions("-D INTEL_NO_ITTNOTIFY_API")
+ endif()
+ append_definitions("-D INTEL_ITTNOTIFY_PREFIX=__kmp_itt_")
+
+ #####################
+ # Windows definitions
+ if(${WINDOWS})
+ append_definitions("-D _CRT_SECURE_NO_WARNINGS")
+ append_definitions("-D _CRT_SECURE_NO_DEPRECATE")
+ append_definitions("-D _WINDOWS")
+ append_definitions("-D _WINNT")
+ append_definitions("-D _WIN32_WINNT=0x0501")
+ append_definitions("-D KMP_WIN_CDECL")
+ append_definitions("-D _USRDLL")
+ if(${DEBUG_BUILD})
+ append_definitions("-D _ITERATOR_DEBUG_LEVEL=0")
+ endif()
+ else() # Other than windows... (Unix based systems, Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture), and Mac)
+ append_definitions("-D _GNU_SOURCE")
+ append_definitions("-D _REENTRANT")
+ append_definitions("-D BUILD_TV")
+ append_definitions("-D USE_CBLKDATA")
+ if(NOT "${version}" STREQUAL "4")
+ append_definitions("-D KMP_GOMP_COMPAT")
+ endif()
+ endif()
+
+ #######################################
+ # Intel(R) MIC Architecture definitions
+ if(${MIC})
+ append_definitions("-D KMP_TDATA_GTID")
+ else() # Other than Intel(R) MIC Architecture...
+ append_definitions("-D USE_LOAD_BALANCE")
+ endif()
+
+ ##################
+ # 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")
+ 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")
+ append_definitions("-D BUILD_DEBUG")
+ endif()
+ if(${STATS_GATHERING})
+ append_definitions("-D KMP_STATS_ENABLED=1")
+ else()
+ append_definitions("-D KMP_STATS_ENABLED=0")
+ endif()
+
+ # OpenMP version flags
+ set(have_omp_50 0)
+ set(have_omp_41 0)
+ set(have_omp_40 0)
+ set(have_omp_30 0)
+ if(${omp_version} EQUAL 50 OR ${omp_version} GREATER 50)
+ set(have_omp_50 1)
+ endif()
+ if(${omp_version} EQUAL 41 OR ${omp_version} GREATER 41)
+ set(have_omp_41 1)
+ endif()
+ if(${omp_version} EQUAL 40 OR ${omp_version} GREATER 40)
+ set(have_omp_40 1)
+ endif()
+ if(${omp_version} EQUAL 30 OR ${omp_version} GREATER 30)
+ set(have_omp_30 1)
+ endif()
+ append_definitions("-D OMP_50_ENABLED=${have_omp_50}")
+ append_definitions("-D OMP_41_ENABLED=${have_omp_41}")
+ append_definitions("-D OMP_40_ENABLED=${have_omp_40}")
+ append_definitions("-D OMP_30_ENABLED=${have_omp_30}")
+
+ # Architectural definitions
+ if(${INTEL64} OR ${IA32})
+ if(${USE_ADAPTIVE_LOCKS})
+ append_definitions("-D KMP_USE_ADAPTIVE_LOCKS=1")
+ else()
+ append_definitions("-D KMP_USE_ADAPTIVE_LOCKS=0")
+ endif()
+ append_definitions("-D KMP_DEBUG_ADAPTIVE_LOCKS=0")
+ else()
+ append_definitions("-D KMP_USE_ADAPTIVE_LOCKS=0")
+ append_definitions("-D KMP_DEBUG_ADAPTIVE_LOCKS=0")
+ endif()
+ set(${input_cpp_flags} "${${input_cpp_flags}}" "${local_cpp_flags}" "${USER_CPP_FLAGS}" "$ENV{CPPFLAGS}" PARENT_SCOPE)
+endfunction()
+
diff --git a/openmp/runtime/cmake/GNU/AsmFlags.cmake b/openmp/runtime/cmake/GNU/AsmFlags.cmake
new file mode 100644
index 00000000000..91fccb07947
--- /dev/null
+++ b/openmp/runtime/cmake/GNU/AsmFlags.cmake
@@ -0,0 +1,16 @@
+# This file holds GNU (gcc/g++) specific compiler dependent flags
+# The flag types are:
+# 1) Assembly flags
+
+#########################################################
+# Assembly flags
+function(append_assembler_specific_asm_flags input_asm_flags)
+ set(local_asm_flags)
+ append_asm_flags("-x assembler-with-cpp") # Assembly file that needs to be preprocessed
+ if(${IA32})
+ append_asm_flags("-m32") # Generate 32 bit IA-32 architecture code
+ append_asm_flags("-msse2") # Allow use of Streaming SIMD Instructions
+ endif()
+ set(${input_asm_flags} ${${input_asm_flags}} "${local_asm_flags}" PARENT_SCOPE)
+endfunction()
+
diff --git a/openmp/runtime/cmake/GNU/CFlags.cmake b/openmp/runtime/cmake/GNU/CFlags.cmake
new file mode 100644
index 00000000000..88654ccc27a
--- /dev/null
+++ b/openmp/runtime/cmake/GNU/CFlags.cmake
@@ -0,0 +1,45 @@
+# This file holds GNU (gcc/g++) specific compiler dependent flags
+# The flag types are:
+# 2) C/C++ Compiler flags
+# 4) Linker flags
+unset(COMPILER_SUPPORTS_QUAD_PRECISION CACHE)
+set(COMPILER_SUPPORTS_QUAD_PRECISION true CACHE BOOL "Does the compiler support a 128-bit floating point type?")
+set(COMPILER_QUAD_TYPE __float128)
+
+#########################################################
+# C/C++ Compiler flags
+function(append_compiler_specific_c_and_cxx_flags input_c_flags input_cxx_flags)
+ set(local_c_flags)
+ set(local_cxx_flags)
+ append_c_and_cxx_flags("-std=c++0x") # Enables support for many C++11 (formerly known as C++0x) features. The following are the most recently added features:
+ append_c_and_cxx_flags("-fno-exceptions") # Exception handling table generation is disabled.
+ append_c_and_cxx_flags("-x c++") # Compile C files as C++ files
+ if(${IA32})
+ append_c_and_cxx_flags("-m32") # Generate 32 bit IA-32 architecture code
+ append_c_and_cxx_flags("-msse2") # Allow use of Streaming SIMD Instructions
+ elseif(${ARM})
+ append_c_and_cxx_flags("-marm") # Target the ARM architecture
+ endif()
+ set(${input_c_flags} ${${input_c_flags}} "${local_c_flags}" PARENT_SCOPE)
+ set(${input_cxx_flags} ${${input_cxx_flags}} "${local_cxx_flags}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Linker flags
+function(append_compiler_specific_linker_flags input_ld_flags input_ld_flags_libs)
+ set(local_ld_flags)
+ set(local_ld_flags_libs)
+ if(${WINDOWS})
+ elseif(${MAC})
+ elseif(${MIC})
+ else()
+ append_linker_flags("-static-libgcc") # Causes libgcc to be linked in statically
+ endif()
+ if(${IA32})
+ append_linker_flags("-m32")
+ append_linker_flags("-msse2")
+ endif()
+ set(${input_ld_flags} ${${input_ld_flags}} "${local_ld_flags}" PARENT_SCOPE)
+ set(${input_ld_flags_libs} ${${input_ld_flags_libs}} "${local_ld_flags_libs}" PARENT_SCOPE)
+endfunction()
+
diff --git a/openmp/runtime/cmake/GNU/FortranFlags.cmake b/openmp/runtime/cmake/GNU/FortranFlags.cmake
new file mode 100644
index 00000000000..2a479b28dd3
--- /dev/null
+++ b/openmp/runtime/cmake/GNU/FortranFlags.cmake
@@ -0,0 +1,14 @@
+# This file holds GNU (gcc/g++) specific compiler dependent flags
+# The flag types are:
+# 1) Fortran Compiler flags
+
+#########################################################
+# Fortran Compiler flags (for creating .mod files)
+function(append_fortran_compiler_specific_fort_flags input_fort_flags)
+ set(local_fort_flags)
+ if(${IA32})
+ append_fort_flags("-m32")
+ append_fort_flags("-msse2")
+ endif()
+ set(${input_fort_flags} ${${input_fort_flags}} "${local_fort_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/openmp/runtime/cmake/HelperFunctions.cmake b/openmp/runtime/cmake/HelperFunctions.cmake
new file mode 100644
index 00000000000..91902485c57
--- /dev/null
+++ b/openmp/runtime/cmake/HelperFunctions.cmake
@@ -0,0 +1,254 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#// 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.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+####################################### FUNCTIONS/MACROS ###########################################
+# It should be noted that in cmake, functions can only be used on a single line with the return value
+# stored in a parameter you send to the function. There isn't a true return value. So technically,
+# all functions would have a C/C++ prototype of:
+# void function_name(parameter1, parameter2, ...);
+#
+# If you want a return value, you have to use a parameter so the function prototype would be:
+# void function_name(input_parameter1, input_parameter2, ..., return_value)
+# ##################
+
+# void say(string message_to_user);
+# - prints out message_to_user
+macro(say message_to_user)
+ message("${message_to_user}")
+endmacro()
+
+# void warning_say(string message_to_user);
+# - prints out message_to_user with a warning
+macro(warning_say message_to_user)
+ message(WARNING "${message_to_user}")
+endmacro()
+
+# void error_say(string message_to_user);
+# - prints out message_to_user with an error and exits cmake
+macro(error_say message_to_user)
+ message(FATAL_ERROR "${message_to_user}")
+endmacro()
+
+# void debug_say(string message_to_developer);
+# - prints out message when GLOBAL_DEBUG == 1 (for debugging cmake build)
+macro(debug_say message_to_developer)
+ if(${GLOBAL_DEBUG} STREQUAL "1")
+ say("DEBUG: ${message_to_developer}")
+ endif()
+endmacro()
+
+# void debug_say_var(variable var);
+# - prints the variable name and its value (for debugging cmake build)
+macro(debug_say_var var)
+ if(${GLOBAL_DEBUG} STREQUAL "1")
+ say("DEBUG: Variable: ${var} = ${${var}} ")
+ endif()
+endmacro()
+
+# void set_legal_arch(string* return_arch_string);
+# - returns (through return_arch_string) the formal architecture
+# string or warns user of unknown architecture
+function(set_legal_arch return_arch_string)
+ if(${IA32})
+ set(${return_arch_string} "IA-32" PARENT_SCOPE)
+ elseif(${INTEL64})
+ set(${return_arch_string} "Intel(R) 64" PARENT_SCOPE)
+ elseif(${MIC})
+ set(${return_arch_string} "Intel(R) Many Integrated Core Architecture" PARENT_SCOPE)
+ elseif(${arch} STREQUAL "l1")
+ set(${return_arch_string} "L1OM" PARENT_SCOPE)
+ elseif(${ARM})
+ set(${return_arch_string} "ARM" PARENT_SCOPE)
+ else()
+ warning_say("set_legal_arch(): Warning: Unknown architecture...")
+ endif()
+endfunction()
+
+# void check_variable(string var, string var_name, list<string>values_list);
+# - runs through values_list checking if ${var} == values_list[i] for any i.
+# - if the var is found, then just print it out
+# - if the var is not found, then warn user
+function(check_variable var values_list)
+ set(valid_flag 0)
+ foreach(value IN LISTS values_list)
+ if("${${var}}" STREQUAL "${value}")
+ set(valid_flag 1)
+ set(the_value "${value}")
+ endif()
+ endforeach()
+ if(${valid_flag} EQUAL 0)
+ error_say("check_variable(): ${var} = ${${var}} is unknown")
+ endif()
+endfunction()
+
+# void _export_lib_dir(string export_dir, string platform, string suffix, string* return_value);
+# - basically a special case for mac platforms where it adds '.thin' to the output lib directory
+function(_export_lib_dir pltfrm return_value)
+ if(${MAC})
+ set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib.thin" PARENT_SCOPE)
+ else()
+ set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib" PARENT_SCOPE)
+ endif()
+endfunction()
+
+# void _export_lib_fat_dir(string export_dir, string platform, string suffix, string* return_value);
+# - another mac specialty case for fat libraries.
+# - this sets export_lib_fat_dir in the MAIN part of CMakeLists.txt
+function(_export_lib_fat_dir pltfrm return_value)
+ set(${return_value} "${export_dir}/${pltfrm}${suffix}/lib" PARENT_SCOPE)
+endfunction()
+
+# void get_build_number(string src_dir, string* return_build_number);
+# - grab the eight digit build number (or 00000000) from kmp_version.c
+function(get_build_number src_dir return_build_number)
+ # sets file_lines_list to a list of all lines in kmp_version.c
+ file(STRINGS "${src_dir}/src/kmp_version.c" file_lines_list)
+
+ # runs through each line in kmp_version.c
+ foreach(line IN LISTS file_lines_list)
+ # if the line begins with "#define KMP_VERSION_BUILD" then we take not of the build number
+ string(REGEX MATCH "^[ \t]*#define[ \t]+KMP_VERSION_BUILD" valid "${line}")
+ if(NOT "${valid}" STREQUAL "") # if we matched "#define KMP_VERSION_BUILD", then grab the build number
+ string(REGEX REPLACE "^[ \t]*#define[ \t]+KMP_VERSION_BUILD[ \t]+([0-9]+)" "\\1"
+ build_number "${line}"
+ )
+ endif()
+ endforeach()
+ set(${return_build_number} "${build_number}" PARENT_SCOPE) # return build number
+endfunction()
+
+# void set_legal_type(string* return_legal_type);
+# - set the legal type name Performance/Profiling/Stub
+function(set_legal_type return_legal_type)
+ if(${NORMAL_LIBRARY})
+ set(${return_legal_type} "Performance" PARENT_SCOPE)
+ elseif(${PROFILE_LIBRARY})
+ set(${return_legal_type} "Profiling" PARENT_SCOPE)
+ elseif(${STUBS_LIBRARY})
+ set(${return_legal_type} "Stub" PARENT_SCOPE)
+ endif()
+endfunction()
+
+# void set_mac_os_new(bool* return_mac_os_new);
+# - sets the return_mac_os_new variable to true or false based on macosx version
+# - no real "cmakey" way to do this. Have to call execute_process()
+function(set_mac_os_new return_mac_os_new)
+ execute_process(COMMAND "sw_vers" "-productVersion" OUTPUT_VARIABLE mac_osx_version)
+ if("${mac_osx_version}" VERSION_GREATER "10.6")
+ set(${return_mac_os_new} TRUE PARENT_SCOPE)
+ else()
+ set(${return_mac_os_new} FALSE PARENT_SCOPE)
+ endif()
+endfunction()
+
+# void add_prefix(string prefix, list<string>* list_of_items);
+# - returns list_of_items with prefix prepended to all items
+# - original list is modified
+function(add_prefix prefix list_of_items)
+ set(local_list "")
+ foreach(item IN LISTS "${list_of_items}")
+ if(NOT "${item}" STREQUAL "")
+ list(APPEND local_list "${prefix}${item}")
+ endif()
+ endforeach()
+ set(${list_of_items} "${local_list}" PARENT_SCOPE)
+endfunction()
+
+# void add_suffix(string suffix, list<string>* list_of_items);
+# - returns list_of_items with suffix appended to all items
+# - original list is modified
+function(add_suffix suffix list_of_items)
+ set(local_list "")
+ foreach(item IN LISTS "${list_of_items}")
+ if(NOT "${item}" STREQUAL "")
+ list(APPEND local_list "${item}${suffix}")
+ endif()
+ endforeach()
+ set(${list_of_items} "${local_list}" PARENT_SCOPE)
+endfunction()
+
+# void strip_suffix(list<string> list_of_items, list<string>* return_list);
+# - returns a new list with suffix stripped (i.e., foo.c => foo)
+# - list_of_items is not modified, return_list is modified
+function(strip_suffix list_of_items return_list)
+ set(local_list "")
+ foreach(item IN LISTS "${list_of_items}")
+ if(NOT "${item}" STREQUAL "")
+ get_filename_component(filename "${item}" NAME_WE)
+ list(APPEND local_list "${filename}")
+ endif()
+ endforeach()
+ set(${return_list} "${local_list}" PARENT_SCOPE)
+endfunction()
+
+# void list_to_string(list<string> list_of_things, string* return_string);
+# - converts a list to a space separated string
+function(list_to_string list_of_things return_string)
+ string(REPLACE ";" " " output_variable "${list_of_things}")
+ set(${return_string} "${output_variable}" PARENT_SCOPE)
+endfunction()
+
+# void string_to_list(string str, list<string>* return_list);
+# - converts a string to a semicolon separated list
+# - what it really does is just string_replace all running whitespace to a semicolon
+# - in cmake, a list is strings separated by semicolons: i.e., list of four items, list = "item1;item2;item3;item4"
+function(string_to_list str return_list)
+ set(outstr)
+ string(REGEX REPLACE "[ \t]+" ";" outstr "${str}")
+ set(${return_list} "${outstr}" PARENT_SCOPE)
+endfunction()
+
+# void get_date(string* return_date);
+# - returns the current date "yyyy-mm-dd hh:mm:ss UTC"
+# - this function alone causes the need for CMake v2.8.11 (TIMESTAMP)
+#function(get_date return_date)
+# string(TIMESTAMP local_date "%Y-%m-%d %H:%M:%S UTC" UTC)
+# set(${return_date} ${local_date} PARENT_SCOPE)
+#endfunction()
+
+# void find_a_program(string program_name, list<string> extra_paths, bool fail_on_not_found, string return_variable_name);
+# - returns the full path of a program_name
+# - first looks in the list of extra_paths
+# - if not found in extra_paths, then look through system path
+# - errors out if fail_on_not_found == true and cmake could not find program_name.
+function(find_a_program program_name extra_paths fail_on_not_found return_variable_name)
+ # first try to find the program in the extra_paths
+ find_program(${return_variable_name} "${program_name}" PATHS "${extra_paths}" DOC "Path to ${program_name}" NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_PATH NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
+ if("${${return_variable_name}}" MATCHES NOTFOUND)
+ # if no extra_paths, or couldn't find it, then look in system $PATH
+ find_program(${return_variable_name} "${program_name}" DOC "Path to ${program_name}")
+ if("${${return_variable_name}}" MATCHES NOTFOUND AND ${fail_on_not_found})
+ error_say("Error: Could not find program: ${program_name}")
+ endif()
+ endif()
+
+ if(NOT "${${return_variable_name}}" MATCHES NOTFOUND)
+ say("-- Found ${program_name}: ${${return_variable_name}}")
+ endif()
+
+ set(${return_variable_name} ${${return_variable_name}} PARENT_SCOPE)
+endfunction()
+
+# WINDOWS SPECIFIC
+# void replace_md_with_mt(string flags_var)
+# - This macro replaces the /MD compiler flags (Windows specific) with /MT compiler flags
+# - This does nothing if no /MD flags were replaced.
+macro(replace_md_with_mt flags_var)
+ set(flags_var_name ${flags_var}) # i.e., CMAKE_C_FLAGS_RELEASE
+ set(flags_var_value ${${flags_var}}) # i.e., "/MD /O2 ..."
+ string(REPLACE /MD /MT temp_out "${flags_var_value}")
+ string(COMPARE NOTEQUAL "${temp_out}" "${flags_var_value}" something_was_replaced)
+ if("${something_was_replaced}")
+ unset(${flags_var_name} CACHE)
+ set(${flags_var_name} ${temp_out} CACHE STRING "Replaced /MD with /MT compiler flags")
+ endif()
+endmacro()
+
diff --git a/openmp/runtime/cmake/Intel/AsmFlags.cmake b/openmp/runtime/cmake/Intel/AsmFlags.cmake
new file mode 100644
index 00000000000..59d22d99502
--- /dev/null
+++ b/openmp/runtime/cmake/Intel/AsmFlags.cmake
@@ -0,0 +1,31 @@
+# This file holds Intel(R) C Compiler / Intel(R) C++ Compiler / Intel(R) Fortran Compiler (icc/icpc/icl.exe/ifort) dependent flags
+# The flag types are:
+# 1) Assembly flags
+
+#########################################################
+# Assembly flags
+function(append_assembler_specific_asm_flags input_asm_flags)
+ set(local_asm_flags)
+ append_asm_flags("-x assembler-with-cpp") # Assembly file that needs to be preprocessed
+ if(${IA32})
+ append_asm_flags("-safeseh") # Registers exception handlers for safe exception handling.
+ append_asm_flags("-coff") # Generates common object file format (COFF) type of object module.
+ # Generally required for Win32 assembly language development.
+ append_asm_flags("-D _M_IA32")
+ elseif(${INTEL64})
+ append_asm_flags("-D _M_AMD64")
+ endif()
+ if(${MIC})
+ append_asm_flags("-mmic") # Build Intel(R) MIC Architecture native code
+ endif()
+ if(${WINDOWS})
+ # CMake prefers the /MD flags when compiling Windows sources, but libiomp5 needs to use /MT instead
+ # So we replace these /MD instances with /MT within the CMAKE_*_FLAGS variables and put that out to the CACHE.
+ # replace_md_with_mt() is in HelperFunctions.cmake
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELEASE)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELWITHDEBINFO)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_DEBUG)
+ endif()
+ set(${input_asm_flags} ${${input_asm_flags}} "${local_asm_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/openmp/runtime/cmake/Intel/CFlags.cmake b/openmp/runtime/cmake/Intel/CFlags.cmake
new file mode 100644
index 00000000000..2122e29933d
--- /dev/null
+++ b/openmp/runtime/cmake/Intel/CFlags.cmake
@@ -0,0 +1,148 @@
+# This file holds Intel(R) C Compiler / Intel(R) C++ Compiler / Intel(R) Fortran Compiler (icc/icpc/icl.exe/ifort) dependent flags
+# The flag types are:
+# 2) C/C++ Compiler flags
+# 4) Linker flags
+
+# icc has a 128-bit floating point type called _Quad. Always compile with 128-bit floating point if it exists.
+unset(COMPILER_SUPPORTS_QUAD_PRECISION CACHE)
+set(COMPILER_SUPPORTS_QUAD_PRECISION true CACHE BOOL "Does the compiler support a 128-bit floating point type?")
+set(COMPILER_QUAD_TYPE _Quad)
+
+#########################################################
+# icc C/C++ Compiler flags
+function(append_compiler_specific_c_and_cxx_flags input_c_flags input_cxx_flags)
+ set(local_c_flags)
+ set(local_cxx_flags)
+ if(${WINDOWS})
+
+ append_c_flags("-TP") # Tells the compiler to process a file as a C++ source file.
+ append_cxx_flags("-EHsc") # Enable C++ exception handling.
+ append_c_and_cxx_flags("-nologo") # Turn off tool banner.
+ append_c_and_cxx_flags("-W3") # Enables diagnostics for remarks, warnings, and errors.
+ # Additional warnings are also enabled above level 2 warnings.
+ append_c_and_cxx_flags("-WX") # Change all Warnings to Errors
+ append_c_and_cxx_flags("-GS") # Lets you control the threshold at which the stack checking routine is called or not called.
+ append_c_and_cxx_flags("-Qoption,cpp,--extended_float_types") # Enabled _Quad type.
+ if(${IA32})
+ append_c_and_cxx_flags("-arch:ia32") # Tells the compiler which features it may target (ia32)
+ append_c_and_cxx_flags("-Oy-") # equivalent to -fno-omit-frame-pointer
+ endif()
+ append_c_and_cxx_flags("-Qlong_double") # enable long double
+ append_c_and_cxx_flags("-Qdiag-disable:177") # Disable warning: "... declared but never referenced"
+ if(${IA32})
+ append_c_and_cxx_flags("-Qsafeseh") # Registers exception handlers for safe exception handling.
+ endif()
+ if(${RELEASE_BUILD} OR ${RELWITHDEBINFO_BUILD})
+ append_c_and_cxx_flags("-Qinline-min-size=1") # Specifies the upper limit for the size of what the inliner considers to be a small routine.
+ else()
+ append_c_and_cxx_flags("-Od") # Disables all optimizations.
+ append_c_and_cxx_flags("-RTC1") # Enables run-time checks of the stack frame, and enables run-time checks for unintialized variables.
+ append_c_and_cxx_flags("-MTd") # Tells the linker to search for unresolved references in a multithreaded, static run-time library.
+ endif()
+ else()
+ append_c_and_cxx_flags("-Wsign-compare") # warn on sign comparisons
+ append_c_and_cxx_flags("-Werror") # Changes all warnings to errors.
+ append_c_and_cxx_flags("-Qoption,cpp,--extended_float_types") # Enabled _Quad type.
+ append_c_and_cxx_flags("-fno-exceptions") # Exception handling table generation is disabled.
+ append_c_and_cxx_flags("-x c++") # Compile C files as C++ files
+ if(${MIC})
+ append_c_and_cxx_flags("-mmic") # Build Intel(R) MIC Architecture native code
+ append_c_and_cxx_flags("-ftls-model=initial-exec") # Changes the thread local storage (TLS) model. Generates a restrictive, optimized TLS code.
+ # To use this setting, the thread-local variables accessed must be defined in one of the
+ # modules available to the program.
+ append_c_and_cxx_flags("-opt-streaming-stores never") # Disables generation of streaming stores for optimization.
+ append_c_and_cxx_flags("-sox") # Tells the compiler to save the compilation options and version number
+ # in the executable file. It also lets you choose whether to include
+ # lists of certain functions.
+ elseif(${LINUX})
+ append_c_and_cxx_flags("-Werror") # Changes all warnings to errors.
+ append_c_and_cxx_flags("-sox")
+ if(${IA32})
+ append_c_and_cxx_flags("-falign-stack=maintain-16-byte") # Tells the compiler the stack alignment to use on entry to routines.
+ append_c_and_cxx_flags("-mia32") # Tells the compiler which features it may target (ia32)
+ endif()
+ endif()
+ endif()
+ # CMake prefers the /MD flags when compiling Windows sources, but libiomp5 needs to use /MT instead
+ # So we replace these /MD instances with /MT within the CMAKE_*_FLAGS variables and put that out to the CACHE.
+ # replace_md_with_mt() is in HelperFunctions.cmake
+ if(${WINDOWS})
+ replace_md_with_mt(CMAKE_C_FLAGS)
+ replace_md_with_mt(CMAKE_C_FLAGS_RELEASE)
+ replace_md_with_mt(CMAKE_C_FLAGS_RELWITHDEBINFO)
+ replace_md_with_mt(CMAKE_C_FLAGS_DEBUG)
+ replace_md_with_mt(CMAKE_CXX_FLAGS)
+ replace_md_with_mt(CMAKE_CXX_FLAGS_RELEASE)
+ replace_md_with_mt(CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+ replace_md_with_mt(CMAKE_CXX_FLAGS_DEBUG)
+ endif()
+ set(${input_c_flags} ${${input_c_flags}} "${local_c_flags}" PARENT_SCOPE)
+ set(${input_cxx_flags} ${${input_cxx_flags}} "${local_cxx_flags}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# icc Linker flags
+function(append_compiler_specific_linker_flags input_ld_flags input_ld_flags_libs)
+ set(local_ld_flags)
+ set(local_ld_flags_libs)
+ if(${WINDOWS})
+ # Have icc use link.exe directly when Windows
+ set(CMAKE_C_CREATE_SHARED_LIBRARY "link.exe /out:<TARGET> <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES>" PARENT_SCOPE)
+ set(CMAKE_SHARED_LINKER_FLAGS "$ENV{LDFLAGS}" CACHE STRING "Linker Flags" FORCE)
+ append_linker_flags("-nologo") # Turn off tool banner.
+ append_linker_flags("-dll")
+ append_linker_flags("-WX:NO")
+ append_linker_flags("-incremental:no")
+ append_linker_flags("-version:${version}.0")
+ append_linker_flags("-NXCompat")
+ append_linker_flags("-DynamicBase") # This option modifies the header of an executable to indicate
+ # whether the application should be randomly rebased at load time.
+ if(${IA32})
+ append_linker_flags("-machine:i386")
+ append_linker_flags("-safeseh")
+ elseif(${INTEL64})
+ append_linker_flags("-machine:amd64")
+ endif()
+ if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD})
+ if(NOT "${pdb_file}" STREQUAL "")
+ append_linker_flags("-debug")
+ append_linker_flags("-pdb:${pdb_file}")
+ endif()
+ else()
+ if(NOT "${pdb_file}" STREQUAL "")
+ append_linker_flags("-debug")
+ append_linker_flags("-pdb:${pdb_file}")
+ append_linker_flags("-pdbstripped:${pdb_file}.stripped")
+ endif()
+ endif()
+ if(NOT "${imp_file}" STREQUAL "")
+ append_linker_flags("-implib:${lib_file}${lib}")
+ endif()
+ if(NOT "${def_file}" STREQUAL "")
+ append_linker_flags("-def:${def_file}")
+ endif()
+ elseif(${MAC})
+ append_linker_flags("-no-intel-extensions")
+ if(NOT ${STUBS_LIBRARY})
+ append_linker_flags_library("-pthread") # link in pthread library
+ append_linker_flags_library("-ldl") # link in libdl (dynamic loader library)
+ endif()
+ if(${STATS_GATHERING})
+ append_linker_flags_library("-Wl,-lstdc++") # link in standard c++ library (stats-gathering needs it)
+ endif()
+ elseif(${MIC})
+ append_linker_flags("-mmic") # enable MIC linking
+ append_linker_flags("-static-intel") # Causes Intel-provided libraries to be linked in statically.
+ append_linker_flags("-no-intel-extensions") # Enables or disables all Intel C and Intel C++ language extensions.
+ else()
+ append_linker_flags("-static-intel") # Causes Intel-provided libraries to be linked in statically.
+ append_linker_flags("-Werror") # Warnings become errors
+ if(${IA32})
+ append_linker_flags_library("-lirc_pic") # link in libirc_pic
+ endif()
+ endif()
+
+ set(${input_ld_flags} ${${input_ld_flags}} "${local_ld_flags}" PARENT_SCOPE)
+ set(${input_ld_flags_libs} ${${input_ld_flags_libs}} "${local_ld_flags_libs}" PARENT_SCOPE)
+endfunction()
+
diff --git a/openmp/runtime/cmake/Intel/FortranFlags.cmake b/openmp/runtime/cmake/Intel/FortranFlags.cmake
new file mode 100644
index 00000000000..9279a887e88
--- /dev/null
+++ b/openmp/runtime/cmake/Intel/FortranFlags.cmake
@@ -0,0 +1,29 @@
+# This file holds Intel(R) C Compiler / Intel(R) C++ Compiler / Intel(R) Fortran Compiler (icc/icpc/icl.exe/ifort) dependent flags
+# The flag types are:
+# 1) Fortran Compiler flags
+
+#########################################################
+# icc Fortran Compiler flags (for creating .mod files)
+function(append_fortran_compiler_specific_fort_flags input_fort_flags)
+ set(local_fort_flags)
+ #set(CMAKE_Fortran_FLAGS "$ENV{FFLAGS}" CACHE STRING "Fortran flags" FORCE)
+ #set(CMAKE_Fortran_FLAGS_RELEASE "" CACHE STRING "Fortran flags" FORCE)
+ #set(CMAKE_Fortran_FLAGS_DEBUG "" CACHE STRING "Fortran flags" FORCE)
+ #set(CMAKE_Fortran_FLAGS_RELWITHDEBINFO "" CACHE STRING "Fortran flags" FORCE)
+ if(${WINDOWS})
+ append_fort_flags("-Qdiag-disable:177,5082")
+ append_fort_flags("-Qsox")
+ append_fort_flags("-nologo")
+ append_fort_flags("-GS")
+ append_fort_flags("-DynamicBase")
+ append_fort_flags("-Zi")
+ else()
+ if(${MIC})
+ append_fort_flags("-mmic")
+ endif()
+ if(NOT ${MAC})
+ append_fort_flags("-sox")
+ endif()
+ endif()
+ set(${input_fort_flags} ${${input_fort_flags}} "${local_fort_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/openmp/runtime/cmake/MSVC/AsmFlags.cmake b/openmp/runtime/cmake/MSVC/AsmFlags.cmake
new file mode 100644
index 00000000000..dcc83021183
--- /dev/null
+++ b/openmp/runtime/cmake/MSVC/AsmFlags.cmake
@@ -0,0 +1,26 @@
+# This file holds Microsoft Visual Studio dependent flags
+# The flag types are:
+# 1) Assembly flags
+
+#########################################################
+# Assembly flags
+function(append_assembler_specific_asm_flags input_asm_flags)
+ set(local_asm_flags)
+ append_asm_flags("-nologo") # Turn off tool banner.
+ if(${IA32})
+ append_asm_flags("-safeseh") # Registers exception handlers for safe exception handling.
+ append_asm_flags("-coff") # Generates common object file format (COFF) type of object module.
+ # Generally required for Win32 assembly language development.
+ append_asm_flags("-D _M_IA32")
+ elseif(${INTEL64})
+ append_asm_flags("-D _M_AMD64")
+ endif()
+ # CMake prefers the /MD flags when compiling Windows sources, but libiomp5 needs to use /MT instead
+ # So we replace these /MD instances with /MT within the CMAKE_*_FLAGS variables and put that out to the CACHE.
+ # replace_md_with_mt() is in HelperFunctions.cmake
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELEASE)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELWITHDEBINFO)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_DEBUG)
+ set(${input_asm_flags} ${${input_asm_flags}} "${local_asm_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/openmp/runtime/cmake/MSVC/CFlags.cmake b/openmp/runtime/cmake/MSVC/CFlags.cmake
new file mode 100644
index 00000000000..b76147a0ded
--- /dev/null
+++ b/openmp/runtime/cmake/MSVC/CFlags.cmake
@@ -0,0 +1,64 @@
+# This file holds Microsoft Visual Studio dependent flags
+# The flag types are:
+# 1) C/C++ Compiler flags
+# 2) Fortran Compiler flags
+
+#########################################################
+# Visual Studio C/C++ Compiler flags
+function(append_compiler_specific_c_and_cxx_flags input_c_flags input_cxx_flags)
+ set(local_c_flags)
+ set(local_cxx_flags)
+ append_c_flags("-TP") # Tells the compiler to process a file as a C++ source file.
+ append_cxx_flags("-EHsc") # Enable C++ exception handling.
+ append_c_and_cxx_flags("-W3") # Enables diagnostics for remarks, warnings, and errors.
+ # Additional warnings are also enabled above level 2 warnings.
+ append_c_and_cxx_flags("-GS") # Lets you control the threshold at which the stack checking routine is called or not called.
+ if(${IA32})
+ append_c_and_cxx_flags("-arch:ia32") # Tells the compiler which features it may target (ia32)
+ append_c_and_cxx_flags("-Oy-") # equivalent to -fno-omit-frame-pointer
+ endif()
+ # CMake prefers the /MD flags when compiling Windows sources, but libiomp5 needs to use /MT instead
+ # So we replace these /MD instances with /MT within the CMAKE_*_FLAGS variables and put that out to the CACHE.
+ # replace_md_with_mt() is in HelperFunctions.cmake
+ replace_md_with_mt(CMAKE_C_FLAGS)
+ replace_md_with_mt(CMAKE_C_FLAGS_RELEASE)
+ replace_md_with_mt(CMAKE_C_FLAGS_RELWITHDEBINFO)
+ replace_md_with_mt(CMAKE_C_FLAGS_DEBUG)
+ replace_md_with_mt(CMAKE_CXX_FLAGS)
+ replace_md_with_mt(CMAKE_CXX_FLAGS_RELEASE)
+ replace_md_with_mt(CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+ replace_md_with_mt(CMAKE_CXX_FLAGS_DEBUG)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELEASE)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_RELWITHDEBINFO)
+ replace_md_with_mt(CMAKE_ASM_MASM_FLAGS_DEBUG)
+ set(${input_c_flags} ${${input_c_flags}} "${local_c_flags}" PARENT_SCOPE)
+ set(${input_cxx_flags} ${${input_cxx_flags}} "${local_cxx_flags}" PARENT_SCOPE)
+endfunction()
+
+#########################################################
+# Visual Studio Linker flags
+function(append_compiler_specific_linker_flags input_ld_flags input_ld_flags_libs)
+ set(local_ld_flags)
+ set(local_ld_flags_libs)
+ append_linker_flags("-WX:NO")
+ append_linker_flags("-version:${version}.0")
+ append_linker_flags("-NXCompat")
+ append_linker_flags("-DynamicBase") # This option modifies the header of an executable to indicate
+ # whether the application should be randomly rebased at load time.
+ if(${IA32})
+ append_linker_flags("-machine:i386")
+ append_linker_flags("-safeseh")
+ elseif(${INTEL64})
+ append_linker_flags("-machine:amd64")
+ endif()
+ if(NOT "${def_file}" STREQUAL "")
+ append_linker_flags("-def:${def_file}")
+ endif()
+ # Have Visual Studio use link.exe directly
+ #set(CMAKE_C_CREATE_SHARED_LIBRARY "link.exe /out:<TARGET> <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES>" PARENT_SCOPE)
+ #set(CMAKE_SHARED_LINKER_FLAGS "$ENV{LDLFAGS}" CACHE STRING "Linker Flags" FORCE)
+ set(${input_ld_flags} ${${input_ld_flags}} "${local_ld_flags}" PARENT_SCOPE)
+ set(${input_ld_flags_libs} ${${input_ld_flags_libs}} "${local_ld_flags_libs}" PARENT_SCOPE)
+endfunction()
+
diff --git a/openmp/runtime/cmake/MicroTests.cmake b/openmp/runtime/cmake/MicroTests.cmake
new file mode 100644
index 00000000000..50beb594db8
--- /dev/null
+++ b/openmp/runtime/cmake/MicroTests.cmake
@@ -0,0 +1,277 @@
+######################################################
+# MICRO TESTS
+# The following micro-tests are small tests to perform on
+# the library just created in ${build_dir}/, there are currently
+# five micro-tests:
+# (1) test-touch
+# - Compile and run a small program using newly created libiomp5 library
+# - Fails if test-touch.c does not compile or if test-touch.c does not run after compilation
+# - Program dependencies: gcc or g++, grep, bourne shell
+# - Available for all Linux,Mac,Windows builds. Not availble on Intel(R) MIC Architecture builds.
+# (2) test-relo
+# - Tests dynamic libraries for position-dependent code (can not have any position dependent code)
+# - Fails if TEXTREL is in output of readelf -d libiomp5.so command
+# - Program dependencies: readelf, grep, bourne shell
+# - Available for Linux, Intel(R) MIC Architecture dynamic library builds. Not available otherwise.
+# (3) test-execstack
+# - Tests if stack is executable
+# - Fails if stack is executable. Should only be readable and writable. Not exectuable.
+# - Program dependencies: perl, readelf
+# - Available for Linux dynamic library builds. Not available otherwise.
+# (4) test-instr (Intel(R) MIC Architecutre only)
+# - Tests Intel(R) MIC Architecture libraries for valid instruction set
+# - Fails if finds invalid instruction for Intel(R) MIC Architecture (wasn't compiled with correct flags)
+# - Program dependencies: perl, objdump
+# - Available for Intel(R) MIC Architecture builds. Not available otherwise.
+# (5) test-deps
+# - Tests newly created libiomp5 for library dependencies
+# - Fails if sees a dependence not listed in td_exp variable below
+# - Program dependencies: perl, (linux)readelf, (mac)otool[64], (windows)link.exe
+# - Available for Linux,Mac,Windows, Intel(R) MIC Architecture dynamic builds and Windows static builds. Not available otherwise.
+#
+# All tests can be turned off by including -Dtests=off when calling cmake
+# An individual test can be turned off by issuing something like -Dtest_touch=off when calling cmake
+
+# test-touch
+if(NOT ${MIC} AND ${test_touch} AND ${tests})
+ if(${WINDOWS})
+ set(do_test_touch_mt TRUE)
+ if(${do_test_touch_mt})
+ set(test_touch_items ${test_touch_items} test-touch-md test-touch-mt)
+ else()
+ set(test_touch_items ${test_touch_items} test-touch-md)
+ endif()
+ else()
+ set(test_touch_items ${test_touch_items} test-touch-rt)
+ endif()
+ set(regular_test_touch_items "${test_touch_items}")
+ add_suffix("/.success" regular_test_touch_items)
+ # test-touch : ${test_touch_items}/.success
+ set(ldeps "${regular_test_touch_items}")
+ add_custom_target( test-touch DEPENDS ${ldeps})
+
+ if(${WINDOWS})
+ # pick test-touch compiler
+ set(tt-c cl)
+ # test-touch compilation flags
+ list(APPEND tt-c-flags -nologo)
+ if(${RELEASE_BUILD} OR ${RELWITHDEBINFO_BUILD})
+ list(APPEND tt-c-flags-mt -MT)
+ list(APPEND tt-c-flags-md -MD)
+ else()
+ list(APPEND tt-c-flags-mt -MTd)
+ list(APPEND tt-c-flags-md -MDd)
+ endif()
+ list(APPEND tt-libs ${build_dir}/${imp_file})
+ list(APPEND tt-ld-flags -link -nodefaultlib:oldnames)
+ if(${IA32})
+ list(APPEND tt-ld-flags -safeseh)
+ endif()
+ list(APPEND tt-ld-flags-v -verbose)
+ else() # (Unix based systems, Intel(R) MIC Architecture, and Mac)
+ # pick test-touch compiler
+ if(${STD_CPP_LIB})
+ set(tt-c ${CMAKE_CXX_COMPILER})
+ else()
+ set(tt-c ${CMAKE_C_COMPILER})
+ endif()
+ # test-touch compilation flags
+ if(${LINUX})
+ list(APPEND tt-c-flags -pthread)
+ endif()
+ if(${IA32})
+ list(APPEND tt-c-flags -m32)
+ elseif(${INTEL64})
+ list(APPEND tt-c-flags -m64)
+ endif()
+ list(APPEND tt-libs ${build_dir}/${lib_file})
+ if(${MAC})
+ list(APPEND tt-ld-flags-v -Wl,-t)
+ set(tt-env "DYLD_LIBRARY_PATH=.:$ENV{DYLD_LIBRARY_PATH}")
+ else()
+ list(APPEND tt-ld-flags-v -Wl,--verbose)
+ set(tt-env LD_LIBRARY_PATH=".:${build_dir}:$ENV{LD_LIBRARY_PATH}")
+ endif()
+ endif()
+ list(APPEND tt-c-flags "${tt-c-flags-rt}")
+ list(APPEND tt-env "KMP_VERSION=1")
+
+ macro(test_touch_recipe test_touch_dir)
+ file(MAKE_DIRECTORY ${build_dir}/${test_touch_dir})
+ set(ldeps ${src_dir}/test-touch.c ${build_dir}/${lib_file})
+ set(tt-exe-file ${test_touch_dir}/test-touch${exe})
+ if(${WINDOWS})
+ # ****** list(APPEND tt-c-flags -Fo$(dir $@)test-touch${obj} -Fe$(dir $@)test-touch${exe}) *******
+ set(tt-c-flags-out -Fo${test_touch_dir}/test-touch${obj} -Fe${test_touch_dir}/test-touch${exe})
+ list(APPEND ldeps ${build_dir}/${imp_file})
+ else()
+ # ****** list(APPEND tt-c-flags -o $(dir $@)test-touch${exe}) ********
+ set(tt-c-flags-out -o ${test_touch_dir}/test-touch${exe})
+ endif()
+ add_custom_command(
+ OUTPUT ${test_touch_dir}/.success
+ COMMAND ${CMAKE_COMMAND} -E remove -f ${test_touch_dir}/*
+ COMMAND ${tt-c} ${tt-c-flags-out} ${tt-c-flags} ${src_dir}/test-touch.c ${tt-libs} ${tt-ld-flags}
+ COMMAND ${CMAKE_COMMAND} -E remove -f ${tt-exe-file}
+ COMMAND ${tt-c} ${tt-c-flags-out} ${tt-c-flags} ${src_dir}/test-touch.c ${tt-libs} ${tt-ld-flags} ${tt-ld-flags-v} > ${test_touch_dir}/build.log 2>&1
+ COMMAND ${tt-env} ${tt-exe-file}
+ #COMMAND grep -i -e \"[^_]libirc\" ${test_touch_dir}/build.log > ${test_touch_dir}/libirc.log \; [ $$? -eq 1 ]
+ COMMAND ${CMAKE_COMMAND} -E touch ${test_touch_dir}/.success
+ DEPENDS ${ldeps}
+ )
+ endmacro()
+ if(${WINDOWS})
+ test_touch_recipe(test-touch-mt)
+ test_touch_recipe(test-touch-md)
+ else()
+ test_touch_recipe(test-touch-rt)
+ endif()
+else()
+ add_custom_target(test-touch DEPENDS test-touch/.success)
+ macro(test_touch_recipe_skip test_touch_dir)
+ if(${tests} AND ${test_touch})
+ set(test_touch_message 'test-touch is not available for the Intel(R) MIC Architecture. Will not perform it.')
+ else()
+ set(test_touch_message "test-touch is turned off. Will not perform it.")
+ endif()
+ add_custom_command(
+ OUTPUT ${test_touch_dir}/.success
+ COMMAND ${CMAKE_COMMAND} -E echo ${test_touch_message}
+ )
+ endmacro()
+ test_touch_recipe_skip(test-touch-rt)
+ test_touch_recipe_skip(test-touch-mt)
+ test_touch_recipe_skip(test-touch-md)
+endif()
+
+# test-relo
+add_custom_target(test-relo DEPENDS test-relo/.success)
+if((${LINUX} OR ${MIC}) AND ${test_relo} AND ${tests})
+ file(MAKE_DIRECTORY ${build_dir}/test-relo)
+ add_custom_command(
+ OUTPUT test-relo/.success
+ COMMAND readelf -d ${build_dir}/${lib_file} > test-relo/readelf.log
+ COMMAND grep -e TEXTREL test-relo/readelf.log \; [ $$? -eq 1 ]
+ COMMAND ${CMAKE_COMMAND} -E touch test-relo/.success
+ DEPENDS ${build_dir}/${lib_file}
+ )
+else()
+ if(${tests} AND ${test_relo})
+ set(test_relo_message 'test-relo is only available for dynamic library on Linux or Intel(R) MIC Architecture. Will not perform it.')
+ else()
+ set(test_relo_message "test-relo is turned off. Will not perform it.")
+ endif()
+ add_custom_command(
+ OUTPUT test-relo/.success
+ COMMAND ${CMAKE_COMMAND} -E echo ${test_relo_message}
+ )
+endif()
+
+# test-execstack
+add_custom_target(test-execstack DEPENDS test-execstack/.success)
+if(${LINUX} AND ${test_execstack} AND ${tests})
+ file(MAKE_DIRECTORY ${build_dir}/test-execstack)
+ add_custom_command(
+ OUTPUT test-execstack/.success
+ COMMAND ${PERL_EXECUTABLE} ${tools_dir}/check-execstack.pl ${build_dir}/${lib_file}
+ COMMAND ${CMAKE_COMMAND} -E touch test-execstack/.success
+ DEPENDS ${build_dir}/${lib_file}
+ )
+else()
+ if(${tests} AND ${test_execstack})
+ set(test_execstack_message "test-execstack is only available for dynamic library on Linux. Will not perform it.")
+ else()
+ set(test_execstack_message "test-execstack is turned off. Will not perform it.")
+ endif()
+ add_custom_command(
+ OUTPUT test-execstack/.success
+ COMMAND ${CMAKE_COMMAND} -E echo ${test_execstack_message}
+ )
+endif()
+
+# test-instr
+add_custom_target(test-instr DEPENDS test-instr/.success)
+if(${MIC} AND ${test_instr} AND ${tests})
+ file(MAKE_DIRECTORY ${build_dir}/test-instr)
+ add_custom_command(
+ OUTPUT test-instr/.success
+ COMMAND ${PERL_EXECUTABLE} ${tools_dir}/check-instruction-set.pl ${oa_opts} --show --mic-arch=${mic_arch} --mic-os=${mic_os} ${build_dir}/${lib_file}
+ COMMAND ${CMAKE_COMMAND} -E touch test-instr/.success
+ DEPENDS ${build_dir}/${lib_file} ${tools_dir}/check-instruction-set.pl
+ )
+else()
+ if(${tests} AND ${test_instr})
+ set(test_instr_message 'test-instr is only available for Intel(R) MIC Architecture libraries. Will not perform it.')
+ else()
+ set(test_instr_message "test-instr is turned off. Will not perform it.")
+ endif()
+ add_custom_command(
+ OUTPUT test-instr/.success
+ COMMAND ${CMAKE_COMMAND} -E echo ${test_instr_message}
+ )
+endif()
+
+# test-deps
+add_custom_target(test-deps DEPENDS test-deps/.success)
+if(${test_deps} AND ${tests})
+ set(td_exp)
+ if(${FREEBSD})
+ set(td_exp libc.so.7 libthr.so.3 libunwind.so.5)
+ elseif(${LINUX})
+ set(td_exp libdl.so.2,libgcc_s.so.1)
+ if(NOT ${IA32} AND NOT ${INTEL64})
+ set(td_exp ${td_exp},libffi.so.6,libffi.so.5)
+ endif()
+ if(${IA32})
+ set(td_exp ${td_exp},libc.so.6,ld-linux.so.2)
+ elseif(${INTEL64})
+ set(td_exp ${td_exp},libc.so.6,ld-linux-x86-64.so.2)
+ elseif(${ARM})
+ set(td_exp ${td_exp},libc.so.6,ld-linux-armhf.so.3)
+ endif()
+ if(${STD_CPP_LIB})
+ set(td_exp ${td_exp},libstdc++.so.6)
+ endif()
+ if(NOT ${STUBS_LIBRARY})
+ set(td_exp ${td_exp},libpthread.so.0)
+ endif()
+ elseif(${MIC})
+ if("${mic_os}" STREQUAL "lin")
+ set(td_exp libc.so.6,libpthread.so.0,libdl.so.2)
+ if(${STD_CPP_LIB})
+ set(td_exp ${td_exp},libstdc++.so.6)
+ endif()
+ if("${mic_arch}" STREQUAL "knf")
+ set(td_exp ${td_exp},ld-linux-l1om.so.2,libgcc_s.so.1)
+ elseif("${mic_arch}" STREQUAL "knc")
+ set(td_exp ${td_exp},ld-linux-k1om.so.2)
+ endif()
+ elseif("${mic_os}" STREQUAL "bsd")
+ set(td_exp libc.so.7,libthr.so.3,libunwind.so.5)
+ endif()
+ elseif(${MAC})
+ set(td_exp /usr/lib/libSystem.B.dylib)
+ elseif(${WINDOWS})
+ set(td_exp kernel32.dll)
+ endif()
+
+ file(MAKE_DIRECTORY ${build_dir}/test-deps)
+ add_custom_command(
+ OUTPUT test-deps/.success
+ COMMAND ${PERL_EXECUTABLE} ${tools_dir}/check-depends.pl ${oa_opts} --expected="${td_exp}" ${build_dir}/${lib_file}
+ COMMAND ${CMAKE_COMMAND} -E touch test-deps/.success
+ DEPENDS ${build_dir}/${lib_file} ${tools_dir}/check-depends.pl
+ )
+else()
+ if(${tests} AND ${test_deps})
+ set(test_deps_message 'test-deps is available for dynamic libraries on Linux, Mac, Intel(R) MIC Architecture, Windows and static libraries on Windows. Will not perform it.')
+ else()
+ set(test_deps_message "test-deps is turned off. Will not perform it.")
+ endif()
+ add_custom_command(
+ OUTPUT test-deps/.success
+ COMMAND ${CMAKE_COMMAND} -E echo ${test_deps_message}
+ )
+endif()
+# END OF TESTS
+######################################################
diff --git a/openmp/runtime/cmake/PerlFlags.cmake b/openmp/runtime/cmake/PerlFlags.cmake
new file mode 100644
index 00000000000..c34d29d84e5
--- /dev/null
+++ b/openmp/runtime/cmake/PerlFlags.cmake
@@ -0,0 +1,90 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#// 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.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+# void append_ev_flags(string new_flag);
+# - appends new_flag to ev_flags list
+macro(append_ev_flags new_flag)
+ list(APPEND local_ev_flags "${new_flag}")
+endmacro()
+
+# void append_gd_flags(string new_flag);
+# - appends new_flag to gd_flags list
+macro(append_gd_flags new_flag)
+ list(APPEND local_gd_flags "${new_flag}")
+endmacro()
+
+include(HelperFunctions) # for set_legal_type(), set_legal_arch()
+
+# Perl expand-vars.pl flags
+function(set_ev_flags input_ev_flags)
+ set(local_ev_flags)
+ set_legal_type("${lib_type}" legal_type)
+ set_legal_arch("${arch}" legal_arch)
+ # need -D Revision="\$Revision" to show up
+ append_ev_flags("-D Revision=\"\\\\$$Revision\"")
+ append_ev_flags("-D Date=\"\\\\$$Date\"")
+ append_ev_flags("-D KMP_TYPE=\"${legal_type}\"")
+ append_ev_flags("-D KMP_ARCH=\"${legal_arch}\"")
+ append_ev_flags("-D KMP_VERSION_MAJOR=${version}")
+ append_ev_flags("-D KMP_VERSION_MINOR=0")
+ append_ev_flags("-D KMP_VERSION_BUILD=${build_number}")
+ append_ev_flags("-D KMP_BUILD_DATE=\"${date}\"")
+ append_ev_flags("-D KMP_TARGET_COMPILER=12")
+ if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD})
+ append_ev_flags("-D KMP_DIAG=1")
+ append_ev_flags("-D KMP_DEBUG_INFO=1")
+ else()
+ append_ev_flags("-D KMP_DIAG=0")
+ append_ev_flags("-D KMP_DEBUG_INFO=0")
+ endif()
+ if(${omp_version} EQUAL 40)
+ append_ev_flags("-D OMP_VERSION=201307")
+ elseif(${omp_version} EQUAL 30)
+ append_ev_flags("-D OMP_VERSION=201107")
+ else()
+ append_ev_flags("-D OMP_VERSION=200505")
+ endif()
+ set(${input_ev_flags} "${local_ev_flags}" PARENT_SCOPE)
+endfunction()
+
+function(set_gd_flags input_gd_flags)
+ set(local_gd_flags)
+ if(${IA32})
+ append_gd_flags("-D arch_32")
+ elseif(${INTEL64})
+ append_gd_flags("-D arch_32e")
+ else()
+ append_gd_flags("-D arch_${arch}")
+ endif()
+ if(${NORMAL_LIBRARY})
+ append_gd_flags("-D norm")
+ elseif(${PROFILE_LIBRARY})
+ append_gd_flags("-D prof")
+ elseif(${STUBS_LIBRARY})
+ append_gd_flags("-D stub")
+ endif()
+ if(${omp_version} GREATER 40 OR ${omp_version} EQUAL 40)
+ append_gd_flags("-D OMP_40")
+ endif()
+ if(${omp_version} GREATER 30 OR ${omp_version} EQUAL 30)
+ append_gd_flags("-D OMP_30")
+ endif()
+ if(NOT "${version}" STREQUAL "4")
+ append_gd_flags("-D msvc_compat")
+ endif()
+ if(${DEBUG_BUILD} OR ${RELWITHDEBINFO_BUILD})
+ append_gd_flags("-D KMP_DEBUG")
+ endif()
+ if(${COMPILER_SUPPORTS_QUAD_PRECISION})
+ append_gd_flags("-D HAVE_QUAD")
+ endif()
+ set(${input_gd_flags} "${local_gd_flags}" PARENT_SCOPE)
+endfunction()
diff --git a/openmp/runtime/cmake/SourceFiles.cmake b/openmp/runtime/cmake/SourceFiles.cmake
new file mode 100644
index 00000000000..a884feaf51b
--- /dev/null
+++ b/openmp/runtime/cmake/SourceFiles.cmake
@@ -0,0 +1,110 @@
+#
+#//===----------------------------------------------------------------------===//
+#//
+#// 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.
+#//
+#//===----------------------------------------------------------------------===//
+#
+
+macro(append_c_source_file new_c_file)
+ list(APPEND local_c_source_files "${new_c_file}")
+endmacro()
+
+macro(append_cpp_source_file new_cpp_file)
+ list(APPEND local_cpp_source_files "${new_cpp_file}")
+endmacro()
+
+macro(append_asm_source_file new_asm_file)
+ list(APPEND local_asm_source_files "${new_asm_file}")
+endmacro()
+
+macro(append_imp_c_source_file new_import_c_file)
+ list(APPEND local_imp_c_files "${new_import_c_file}")
+endmacro()
+
+# files are relative to the src directory
+
+function(set_c_files input_c_source_files)
+ set(local_c_source_files "")
+ append_c_source_file("kmp_ftn_cdecl.c")
+ append_c_source_file("kmp_ftn_extra.c")
+ append_c_source_file("kmp_version.c")
+ if(${STUBS_LIBRARY})
+ append_c_source_file("kmp_stub.c")
+ else()
+ append_c_source_file("kmp_alloc.c")
+ append_c_source_file("kmp_atomic.c")
+ append_c_source_file("kmp_csupport.c")
+ append_c_source_file("kmp_debug.c")
+ append_c_source_file("kmp_itt.c")
+ append_c_source_file("kmp_environment.c")
+ append_c_source_file("kmp_error.c")
+ append_c_source_file("kmp_global.c")
+ append_c_source_file("kmp_i18n.c")
+ append_c_source_file("kmp_io.c")
+ append_c_source_file("kmp_runtime.c")
+ append_c_source_file("kmp_settings.c")
+ append_c_source_file("kmp_str.c")
+ append_c_source_file("kmp_tasking.c")
+ append_c_source_file("kmp_taskq.c")
+ append_c_source_file("kmp_threadprivate.c")
+ append_c_source_file("kmp_utility.c")
+ if(${USE_ITT_NOTIFY})
+ append_c_source_file("thirdparty/ittnotify/ittnotify_static.c")
+ endif()
+ if(${WINDOWS})
+ append_c_source_file("z_Windows_NT_util.c")
+ append_c_source_file("z_Windows_NT-586_util.c")
+ else()
+ append_c_source_file("z_Linux_util.c")
+ append_c_source_file("kmp_gsupport.c")
+ endif()
+ endif()
+ set(${input_c_source_files} "${local_c_source_files}" PARENT_SCOPE)
+endfunction()
+
+function(set_cpp_files input_cpp_source_files)
+ set(local_cpp_source_files "")
+ if(NOT ${STUBS_LIBRARY})
+ #append_cpp_source_file("kmp_barrier.cpp")
+ append_cpp_source_file("kmp_affinity.cpp")
+ append_cpp_source_file("kmp_dispatch.cpp")
+ append_cpp_source_file("kmp_lock.cpp")
+ append_cpp_source_file("kmp_sched.cpp")
+ if("${omp_version}" STREQUAL "40")
+ append_cpp_source_file("kmp_taskdeps.cpp")
+ append_cpp_source_file("kmp_cancel.cpp")
+ endif()
+ #if(${STATS_GATHERING})
+ # append_cpp_source_file("kmp_stats.cpp")
+ # append_cpp_source_file("kmp_stats_timing.cpp")
+ #endif()
+ endif()
+
+ set(${input_cpp_source_files} "${local_cpp_source_files}" PARENT_SCOPE)
+endfunction()
+
+
+function(set_asm_files input_asm_source_files)
+ set(local_asm_source_files "")
+ if(NOT ${STUBS_LIBRARY})
+ if(${WINDOWS})
+ append_asm_source_file("z_Windows_NT-586_asm.asm")
+ else()
+ append_asm_source_file("z_Linux_asm.s")
+ endif()
+ endif()
+ set(${input_asm_source_files} "${local_asm_source_files}" PARENT_SCOPE)
+endfunction()
+
+
+function(set_imp_c_files input_imp_c_files)
+ set(local_imp_c_files "")
+ if(${WINDOWS})
+ append_imp_c_source_file("kmp_import.c")
+ endif()
+ set(${input_imp_c_files} "${local_imp_c_files}" PARENT_SCOPE)
+endfunction()
OpenPOWER on IntegriCloud