maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

After three iterations of community review, we believe that this new 

CMAKE buld system should meet everyone's requirements.

Enhanced CMake Build System Commit 

* Supports Linux, Mac, Windows, and Intel® Xeon Phi builds
* Supports building with gcc, icc, clang, and Visual Studio compilers
* Supports bulding "fat" libraries on OS/X with clang
* Details and documentation on how to use build system 
  are in Build_With_CMake.txt
* To use the old CMake build system (corresponds to 
  CMakeLists.txt.old), just rename CMakeLists.txt to
  CMakeLists.txt.other and rename CMakeLists.txt.old to
  CMakeLists.txt

llvm-svn: 214850
This commit is contained in:
Jim Cownie 2014-08-05 09:32:28 +00:00
parent 947cef191d
commit 3b81ce6b15
27 changed files with 2630 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
openmp/runtime/Build_With_CMake.txt Normal file
View File

@ -0,0 +1,224 @@
#
#//===----------------------------------------------------------------------===//
#//
#// 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.
#//
#//===----------------------------------------------------------------------===//
#
Building libiomp5 using CMake
=============================
---- Version of CMake required: v2.8.0 or above ----
============================================
How to call cmake initially, then repeatedly
============================================
- When calling cmake for the first time, all needed compiler options
must be specified on the command line. After this initial call to
cmake, the compiler definitions must not be included for further calls
to cmake. Other options can be specified on the command line multiple
times including all definitions in the Build options section below.
- Example of configuring, building, reconfiguring, rebuilding:
$ mkdir build
$ cd build
$ cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -Darch=32 .. # Initial configuration
$ make all common
...
$ make clean
$ cmake -Darch=32e -DCMAKE_BUILD_TYPE=Debug .. # Second configuration
$ make all common
...
$ rm -rf *
$ cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -Darch=32e .. # Third configuration
$ make all common
- Notice in the example how the compiler definitions are only specified
for an empty build directory, but other Build options are used at any time.
- The file CMakeCache.txt which is created after the first call to cmake
is a configuration file which holds all the values for the Build options.
These configuration values can be changed using a text editor to modify
CMakeCache.txt as opposed to using definitions on the command line.
- To have cmake create a particular type of build generator file simply
inlude the -G <Generator name> option:
$ cmake -G "Unix Makefiles" ...
You can see a list of generators cmake supports by executing cmake with
no arguments and a list will be printed.
=====================
Instructions to Build
=====================
$ cd libomp_top_level/ [ directory with src/ , exports/ , tools/ , etc. ]
$ mkdir build
$ cd build
[ Linux* , Mac* Libraries ]
$ cmake -DCMAKE_C_COMPILER=<C Compiler> -DCMAKE_CXX_COMPILER=<C++ Compiler> ..
[ Intel(R) Many Integrated Core Library (Intel(R) MIC Library) ]
$ cmake -DCMAKE_C_COMPILER=<C Compiler> -DCMAKE_CXX_COMPILER=<C++ Compiler> -Dos=mic -Darch=32e ..
[ Windows Libraries ]
$ cmake -G "Unix Makefiles" -DCMAKE_C_COMPILER=<C Compiler> -DCMAKE_CXX_COMPILER=<C++ Compiler> -DCMAKE_ASM_MASM_COMPILER=[ml | ml64] -DCMAKE_BUILD_TYPE=Release ..
$ make all common
=================
Mac* Fat Libraries
=================
On OS X* machines, it is possible to build universal (or fat) libraries which
include both IA-32 architecture and Intel(R) 64 architecture objects in a
single archive; just build the 32 and 32e libraries separately:
$ cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -Darch=32 ..
$ make
$ cmake -Darch=32e ..
$ make
then invoke make again with a special argument as follows:
$ make fat
- The fat target is only available for the arch=32e configuration.
- The fat libraries will be put in exports/mac_32e/lib while the "thin" libraries
will be in exports/mac_32e/lib.thin and exports/mac_32/lib.thin
================
Compiler options
================
-DCMAKE_C_COMPILER=<C compiler name>
-DCMAKE_CXX_COMPILER=<C++ compiler name>
-DCMAKE_Fortran_COMPILER=<Fortran compiler name>
Unix* systems (Optional as compiler is default):
This option is only needed when -Dcreate_fortran_modules is true
-DCMAKE_ASM_COMPILER=<Assembler name>
This option isn't usually needed for Non-Windows* builds
-DCMAKE_ASM_MASM_COMPILER=[ml | ml64 ]
This option is Windows* Only
=============
Build options
=============
==========================
==== Operating System ====
==========================
-Dos=lin|mac|win|mic
* Operating system can be lin (Linux*), mac (Mac*), win (Windows*), or
mic (Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture)).
If not specified, cmake will try to determine your current operating system.
======================
==== Architecture ====
======================
-Darch=32|32e|arm
* Architecture can be 32 (IA-32 architecture), 32e (Intel(R) 64 architecture)
or arm (ARM architecture). This option, by default is chosen based on the
CMake variable CMAKE_SIZEOF_VOID_P. If it is 8, then Intel(R) 64 architecture
is assumed. If it is 4, then IA-32 architecture is assumed. If you want to
use a different architecture other than x86 based architecture, you must specify
it when calling cmake initially using this -Darch=<arch> option or by changing
the arch value via CMakeCache.txt or the CMake GUI after the initial CMake run.
---- First values listed are the default value ----
-Dlib_type=normal|profile|stubs
Library type can be normal, profile, or stubs.
-DCMAKE_BUILD_TYPE=Release|Debug|RelWithDebInfo
Build type can be Release, Debug, or RelWithDebInfo.
See below for interaction when -DUSE_BUILDPL_RULES is on.
-Dversion=5|4
libiomp5 version can be 5 or 4.
-Domp_version=40|30
OpenMP version can be either 40 or 30.
-Dmic_arch=knc|knf
Intel(R) MIC Architecture. Can be
knf (Knights Ferry) or knc (Knights Corner).
This value is ignored if os != mic
-Dmic_os=lin|bsd
Operating system on Intel(R) MIC Architecture.
Can be either bsd or lin. This value is ignored if os != mic
-Dcreate_fortran_modules=off|on
Should the Fortran modules be created (requires Fortran compiler)
-Dstats=off|on
Should include stats-gathering code?
=====================
==== Micro tests ====
=====================
After the library has been built, five microtests are performed.
Some will be skipped based upon the platform.
These tests can be turned on (default) or off with the following options:
-Dtest_touch=on|off -- Should the touch test be done?
-Dtest_relo=on|off -- Should the position independent code test be done?
-Dtest_execstack=on|off -- Should the stack be checked for executability?
-Dtest_instr=on|off -- Should the Intel(R) MIC Libraries be checked
for correct instruction set?
-Dtest_deps=on|off -- Should libiomp5's dependencies be checked?
-Dtests=off|on -- Should any of the above tests be done?
============================================
==== How to append flags to compilation ====
============================================
- These flags are *appended*. They do not
overwrite any of the preset flags.
-DUSER_CPP_FLAGS=<space-separated flags> -- Additional C Preprocessor flags
(typically additional -Ddef=val flags)
-DUSER_C_FLAGS=<space-separated flags> -- Additional C compiler flags
-DUSER_CXX_FLAGS=<space-separated flags> -- Additional C++ compiler flags
-DUSER_ASM_FLAGS=<space-separated flags> -- Additional assembly flags
-DUSER_LD_FLAGS=<space-separated flags> -- Additional linker flags
-DUSER_LD_LIB_FLAGS=<space-separated flags> -- Additional libraries to link
to during link phase
-DUSER_F_FLAGS=<space-separated flags> -- Additional Fortran compiler flags
===================================
==== Feature Based Compilation ====
===================================
-DUSE_BUILDPL_RULES=false|true
Should the build imitate build.pl's build process.
When this is true, the Unix* Release builds will build libiomp5
with -O2 and -g flags activated (same as RelWithDebInfo). Then,
the debug info is stripped out of the library and put into libiomp5.dbg
This is done for interaction with Intel(R) Parallel Amplifier.
-DUSE_ADAPTIVE_LOCKS=true|false
Should adaptive (TSX-based) locks be included?
These are x86 specific. This feature is turned on by default
for IA-32 architecture and Intel(R) 64 architecture.
Otherwise, it is turned off.
-DUSE_PREDEFINED_LINKER_FLAGS=true|false
Should the predefined linker flags in CommonFlags.cmake be included
in the link command? This is true by default and should work for
Linux*, Mac*, and Windows*. The --version-script flag on Unix* based
operating systems will be included regardless.
========================
Examples usages of CMake
========================
---- Typical usage ----
cmake -DCMAKE_C_COMPILER=icc -DCMAKE_CXX_COMPILER=icpc ..
cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ ..
cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ ..
---- With Various Options ----
cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -Dos=lin -Darch=32 ..
cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -Dos=mac -Darch=32 -DCMAKE_BUILD_TYPE=Debug ..
cmake -DCMAKE_C_COMPILER=icc -DCMAKE_CXX_COMPILER=icpc -DCMAKE_Fortran_COMPILER=ifort -Dtests=on -Dcreate_fortran_modules=on -DUSE_BUILDPL_RULES=on ..
cmake -DUSER_CFLAGS='Werror' -DUSER_CPP_FLAGS='-DNEW_FEATURE=1 -DOLD_FEATURE=0' -DUSER_CXX_FLAGS='-Werror -Wsign-compare' ..
---- Stubs library ----
cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -Dlib_type=stubs ..
=========
Footnotes
=========
[*] Other names and brands may be claimed as the property of others.

829
openmp/runtime/CMakeLists.txt
View File

@ -1,8 +1,825 @@
project(openmp)
cmake_minimum_required(VERSION 2.8)
#
#//===----------------------------------------------------------------------===//
#//
#// 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.
#//
#//===----------------------------------------------------------------------===//
#
set(VERSION 5)
set(OMP_VERSION "201107")
set(OMP_VERSION_NUM "40")
################
# CMAKE libiomp5
cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
project(libiomp C CXX)
#########
# GLOBALS
set(GLOBAL_DEBUG 0)
# Add cmake directory to search for custom cmake functions
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
# Set base libomp directory (directory with exports/ , src/ , tools/ , etc.)
# The top-level CMakeLists.txt should define this variable.
set(LIBOMP_WORK ${CMAKE_CURRENT_SOURCE_DIR})
# These include files are in cmake/ subdirectory except for FindPerl which is a cmake standard module
include(HelperFunctions)
include(Definitions) # -D definitions when compiling
include(CommonFlags) # compiler, assembler, fortran, linker flags common for all compilers
include(SourceFiles) # source files to compile
include(PerlFlags) # Perl flags for generate-def.pl and expand-vars.pl
include(FindPerl) # Standard cmake module to check for Perl
####################################################################
# CONFIGURATION
#
# * Any variable/value that is CACHE-ed can be changed after the initial run of cmake
# through the file, CMakeCache.txt which is in the build directory.
# * If you change any value in CMakeCache.txt, then just run cmake ..
# and the changed will be picked up. One can also use -DVARIABLE=VALUE
# when calling cmake to changed configuration values.
# * CMAKE_C_COMPILER, CMAKE_CXX_COMPILER, CMAKE_ASM_MASM_COMPILER, CMAKE_ASM_COMPILER,
# CMAKE_Fortran_COMPILER can only by specified on the initial run of cmake.
# This means you cannot specify -DCMAKE_C_COMPILER= on a subsequent run of cmake
# in the same build directory until that build directory is emptied.
# If you want to change the compiler, then empty the build directory and rerun cmake.
# Build Configuration
set(os_possible_values lin mac win mic)
set(arch_possible_values 32e 32 arm)
set(build_type_possible_values release debug relwithdebinfo)
set(omp_version_possible_values 40 30)
set(lib_type_possible_values normal profile stubs)
set(mic_arch_possible_values knf knc)
set(mic_os_possible_values bsd lin)
# Below, cmake will try and determine the operating system and architecture for you (it assumes Intel architecture)
# These values are set in CMakeCache.txt when cmake is first run (-Dvar_name=... will take precedence)
# parameter | default value
# ----------------------------
# Right now, this build system considers os=lin to mean "Unix-like that is not MAC"
if(${APPLE}) # Apple goes first because CMake considers Mac to be a Unix based operating system, while libiomp5 considers it a special case
set(os mac CACHE STRING "The operating system to build for (lin/mac/win/mic)")
elseif(${UNIX})
set(os lin CACHE STRING "The operating system to build for (lin/mac/win/mic)")
elseif(${WIN32})
set(os win CACHE STRING "The operating system to build for (lin/mac/win/mic)")
else()
set(os lin CACHE STRING "The operating system to build for (lin/mac/win/mic)")
endif()
if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "4")
set(arch 32 CACHE STRING "The architecture to build for (32e/32/arm). 32e is Intel(R) 64 architecture, 32 is IA-32 architecture")
else()
set(arch 32e CACHE STRING "The architecture to build for (32e/32/arm). 32e is Intel(R) 64 architecture, 32 is IA-32 architecture")
endif()
set(lib_type normal CACHE STRING "Performance,Profiling,Stubs library (normal/profile/stubs)")
set(version 5 CACHE STRING "Produce libguide (version 4) or libiomp5 (version 5)")
set(omp_version 40 CACHE STRING "The OpenMP version (40/30)")
set(mic_arch knc CACHE STRING "Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) (knf/knc). Ignored if not Intel(R) MIC Architecture build.")
set(mic_os lin CACHE STRING "Intel(R) MIC Architecture operating system (bsd/lin). Ignored if not Intel(R) MIC Architecture build.")
set(create_fortran_modules false CACHE STRING "Create Fortran module files? (requires fortran compiler)")
# - These tests are little tests performed after the library is formed.
# - The library won't be copied to the exports directory until it has passed/skipped all below tests
# - To skip these tests, just pass -Dtests=OFF to cmake or change tests value in CMakeCache.txt to OFF after running cmake
set(test_touch true CACHE BOOL "Perform a small touch test?" )
set(test_relo true CACHE BOOL "Perform a relocation test for dynamic libraries?" )
set(test_execstack true CACHE BOOL "Perform a execstack test for linux dynamic libraries?" )
set(test_instr true CACHE BOOL "Perform an instruction test for Intel(R) MIC Architecture libraries?" )
set(test_deps true CACHE BOOL "Perform a library dependency test?" )
set(tests false CACHE BOOL "Perform touch, relo, execstack, instr, and deps tests?" )
# - stats-gathering enables OpenMP stats where things like the number of parallel regions, clock ticks spent in
# particular openmp regions are recorded.
set(stats false CACHE BOOL "Stats-Gathering functionality?" )
# User specified flags. These are appended to the predetermined flags found in CommonFlags.cmake and ${CMAKE_C_COMPILER_ID}/*Flags.cmake (i.e., GNU/CFlags.cmake)
set(USER_C_FLAGS "" CACHE STRING "Appended user specified C compiler flags." )
set(USER_CXX_FLAGS "" CACHE STRING "Appended user specified C++ compiler flags." )
set(USER_CPP_FLAGS "" CACHE STRING "Appended user specified C preprocessor flags." )
set(USER_ASM_FLAGS "" CACHE STRING "Appended user specified assembler flags." )
set(USER_LD_FLAGS "" CACHE STRING "Appended user specified linker flags." )
set(USER_LD_LIB_FLAGS "" CACHE STRING "Appended user specified linked libs flags. (i.e., -lm)")
set(USER_F_FLAGS "" CACHE STRING "Appended user specified Fortran compiler flags. These are only used if create_fortran_modules==true." )
# - Allow three build types: Release, Debug, RelWithDebInfo (these relate to build.pl's release, debug, and diag settings respectively)
# - default is Release (when CMAKE_BUILD_TYPE is not defined)
# - CMAKE_BUILD_TYPE affects the -O and -g flags (CMake magically includes correct version of them on per compiler basis)
# - typical: Release = -O3 -DNDEBUG
# RelWithDebInfo = -O2 -g -DNDEBUG
# Debug = -g
if(CMAKE_BUILD_TYPE)
# CMAKE_BUILD_TYPE was defined, check for validity
string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lowercase)
check_variable(cmake_build_type_lowercase "${build_type_possible_values}")
else()
# CMAKE_BUILD_TYPE was not defined, set default to Release
unset(CMAKE_BUILD_TYPE CACHE)
set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build, options are: Release/Debug/RelWithDebInfo")
string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_lowercase)
check_variable(cmake_build_type_lowercase "${build_type_possible_values}")
endif()
# Check valid values
check_variable(os "${os_possible_values}" )
check_variable(arch "${arch_possible_values}" )
check_variable(omp_version "${omp_version_possible_values}")
check_variable(lib_type "${lib_type_possible_values}" )
if("${os}" STREQUAL "mic")
check_variable(mic_arch "${mic_arch_possible_values}" )
check_variable(mic_os "${mic_os_possible_values}" )
endif()
# Get the build number from kmp_version.c
get_build_number("${LIBOMP_WORK}" build_number)
# Getting time and date
# As of now, no timestamp will be created.
set(date "No Timestamp")
#################################################################
# Set some useful flags variables for other parts of cmake to use
# Operating System
set(LINUX FALSE)
set(MAC FALSE)
set(WINDOWS FALSE)
set(MIC FALSE)
set(FREEBSD FALSE)
if("${os}" STREQUAL "lin")
set(LINUX TRUE)
set(real_os lin)
elseif("${os}" STREQUAL "mac")
set(MAC TRUE)
set(real_os mac)
elseif("${os}" STREQUAL "win")
set(WINDOWS TRUE)
set(real_os win)
elseif("${os}" STREQUAL "mic")
set(MIC TRUE)
set(real_os lrb)
endif()
if("${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD")
set(FREEBSD TRUE)
endif()
# Architecture
set(IA32 FALSE)
set(INTEL64 FALSE)
set(ARM FALSE)
if("${arch}" STREQUAL "32") # IA-32 architecture
set(IA32 TRUE)
elseif("${arch}" STREQUAL "32e") # Intel(R) 64 architecture
set(INTEL64 TRUE)
elseif("${arch}" STREQUAL "arm") # ARM architecture
set(ARM TRUE)
endif()
# Set some flags based on build_type
# cmake_build_type_lowercase is based off of CMAKE_BUILD_TYPE, just put in lowercase.
set(RELEASE_BUILD FALSE)
set(DEBUG_BUILD FALSE)
set(RELWITHDEBINFO_BUILD FALSE)
if("${cmake_build_type_lowercase}" STREQUAL "release")
set(RELEASE_BUILD TRUE)
elseif("${cmake_build_type_lowercase}" STREQUAL "debug")
set(DEBUG_BUILD TRUE)
elseif("${cmake_build_type_lowercase}" STREQUAL "relwithdebinfo")
set(RELWITHDEBINFO_BUILD TRUE)
endif()
# Stats-gathering on or off?
set(STATS_GATHERING FALSE)
if("${stats}") # string "on" or "ON" is seen as boolean TRUE
set(STATS_GATHERING TRUE)
endif()
# Include itt notify interface? Right now, always.
set(USE_ITT_NOTIFY TRUE)
# normal, profile, stubs library.
set(NORMAL_LIBRARY FALSE)
set(STUBS_LIBRARY FALSE)
set(PROFILE_LIBRARY FALSE)
if("${lib_type}" STREQUAL "normal")
set(NORMAL_LIBRARY TRUE)
elseif("${lib_type}" STREQUAL "profile")
set(PROFILE_LIBRARY TRUE)
elseif("${lib_type}" STREQUAL "stubs")
set(STUBS_LIBRARY TRUE)
endif()
###############################################
# Features for compilation and build in general
# - Does the compiler support a 128-bit floating point data type? Default is false
# - If a compiler does, then change it in the CMakeCache.txt file (or using the cmake GUI)
# or send to cmake -DCOMPILER_SUPPORTS_QUAD_PRECISION=true
# - If COMPILER_SUPPORTS_QUAD_PRECISION is true, then a corresponding COMPILER_QUAD_TYPE must be given
# This is the compiler's quad-precision data type.
# ** TODO: This isn't complete yet. Finish it. Requires changing macros in kmp_os.h **
set(COMPILER_SUPPORTS_QUAD_PRECISION false CACHE BOOL "*INCOMPLETE* Does the compiler support a 128-bit floating point type?")
set(COMPILER_QUAD_TYPE "" CACHE STRING "*INCOMPLETE* The quad precision data type (i.e., for gcc, __float128)")
# - Should the orignal build rules for builds be used? (cmake/OriginalBuildRules.cmake). This setting is off by default.
# - This always compiles with -g. And if it is a release build, the debug info is stripped out via objcopy and put into libiomp5.dbg.
set(USE_BUILDPL_RULES false CACHE BOOL "Should the build follow build.pl rules/recipes?")
# - Should the build use the predefined linker flags (OS-dependent) in CommonFlags.cmake?
# - these predefined linker flags should work for Windows, Mac, and True Linux for the most popular compilers/linkers
set(USE_PREDEFINED_LINKER_FLAGS true CACHE BOOL "Should the build use the predefined linker flags in CommonFlags.cmake?")
# - TSX based locks have __asm code which can be troublesome for some compilers. This feature is also x86 specific.
if({${IA32} OR ${INTEL64})
set(USE_ADAPTIVE_LOCKS true CACHE BOOL "Should TSX-based lock be compiled (adaptive lock in kmp_lock.cpp). These are x86 specific.")
else()
set(USE_ADAPTIVE_LOCKS false CACHE BOOL "Should TSX-based lock be compiled (adaptive lock in kmp_lock.cpp). These are x86 specific.")
endif()
##################################
# Error checking the configuration
if(${STATS_GATHERING} AND (${WINDOWS} OR ${MAC}))
error_say("Stats-gathering functionality is only supported on x86-Linux and Intel(R) MIC Architecture")
endif()
if(${STATS_GATHERING} AND NOT (${IA32} OR ${INTEL64}))
error_say("Stats-gathering functionality is only supported on x86-Linux and Intel(R) MIC Architecture")
endif()
if(${USE_ADAPTIVE_LOCKS} AND NOT(${IA32} OR ${INTEL64}))
error_say("Adaptive locks (TSX) functionality is only supported on x86 Architecture")
endif()
###############################################
# - Create the suffix for the export directory
# - Only add to suffix when not a default value
# - Example suffix: .deb.30.s1
# final export directory: exports/lin_32e.deb.30.s1/lib
# - These suffixes imply the build is a Debug, OpenMP 3.0, Stats-Gathering version of the library
if(NOT "${cmake_build_type_lowercase}" STREQUAL "release")
string(SUBSTRING "${cmake_build_type_lowercase}" 0 3 build_type_suffix)
set(suffix "${suffix}.${build_type_suffix}")
endif()
if(NOT "${omp_version}" STREQUAL "40")
set(suffix "${suffix}.${omp_version}")
endif()
if(${STATS_GATHERING})
set(suffix "${suffix}.s1")
endif()
if(${MIC})
if(NOT "${mic_arch}" STREQUAL "knf")
set(suffix "${suffix}.${mic_arch}")
endif()
if(NOT "${mic_os}" STREQUAL "bsd")
set(suffix "${suffix}.${mic_os}")
endif()
endif()
####################################
# Setting file extensions / suffixes
set(obj ${CMAKE_C_OUTPUT_EXTENSION} )
set(lib ${CMAKE_STATIC_LIBRARY_SUFFIX})
set(dll ${CMAKE_SHARED_LIBRARY_SUFFIX})
set(exe ${CMAKE_EXECUTABLE_SUFFIX} )
######################
# Find perl executable
# Perl is used to create omp.h (and other headers) along with kmp_i18n_id.inc and kmp_i18n_default.inc (see below in Rules section)
if(NOT "${PERL_FOUND}") # variable is defined in FindPerl Standard CMake Module
error_say("Error: Could not find valid perl")
endif()
#########################
# Setting directory names
set(platform "${real_os}_${arch}" ) # i.e., lin_32e, mac_32
set(build_dir "${CMAKE_CURRENT_BINARY_DIR}" ) # build directory (Where CMakeCache.txt is created, build files generated)
set(src_dir "${LIBOMP_WORK}/src" )
set(tools_dir "${LIBOMP_WORK}/tools" )
set(export_dir "${LIBOMP_WORK}/exports" )
set(export_cmn_dir "${export_dir}/common${suffix}" )
set(export_ptf_dir "${export_dir}/${platform}${suffix}")
_export_lib_dir(${platform} export_lib_dir) # set exports directory (relative to build_dir) i.e., ../exports/lin_32e/lib/
# or i.e., ../exports/mac_32e/lib.thin/ for mac
if(${MAC})
# macs use lib.thin/ subdirectory for non-fat libraries that only contain one architecture
# macs use lib/ subdirectory for fat libraries that contain both IA-32 architecture and Intel(R) 64 architecture code.
_export_lib_fat_dir(${platform} export_lib_fat_dir)
endif()
set(inc_dir "${LIBOMP_WORK}/src/include/${omp_version}")
############################
# Setting final library name
set(lib_item "libiomp")
if(${PROFILE_LIBRARY})
set(lib_item "${lib_item}prof")
endif()
if(${STUBS_LIBRARY})
set(lib_item "${lib_item}stubs")
endif()
set(lib_item "${lib_item}${version}")
if(${WINDOWS})
set(lib_item "${lib_item}md")
endif()
set(lib_ext "${dll}")
# ${lib_file} is real library name:
# libiomp5.so for Linux
# libiomp5.dylib for Mac
# libiomp5md.dll for Windows
set(lib_file "${lib_item}${lib_ext}")
########################################
# Setting export file names (full paths)
if(${WINDOWS})
set(imp_file "${lib_item}${lib}") # this is exported (libiomp5md.lib)
set(def_file "${lib_item}.def") # this is not exported
set(rc_file "${lib_item}.rc") # this is not exported
if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug" OR "${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo" OR ${USE_BUILDPL_RULES})
set(pdb_file "${lib_file}.pdb") # this is exported if it exists (libiomp5md.dll.pdb)
endif()
endif()
set(export_lib_files "${lib_file}" "${imp_file}" "${pdb_file}")
set(export_inc_files "iomp_lib.h")
set(export_mod_files "omp_lib.mod" "omp_lib_kinds.mod")
set(export_cmn_files1 "omp.h" "omp_lib.h" "omp_lib.f" "omp_lib.f90")
set(export_cmn_files2 "iomp.h")
add_prefix("${export_lib_dir}/" export_lib_files)
add_prefix("${export_ptf_dir}/include_compat/" export_inc_files)
add_prefix("${export_ptf_dir}/include/" export_mod_files)
add_prefix("${export_cmn_dir}/include/" export_cmn_files1)
add_prefix("${export_cmn_dir}/include_compat/" export_cmn_files2)
set(export_cmn_files "${export_cmn_files1}" "${export_cmn_files2}")
if("${export_lib_fat_dir}")
set(export_lib_fat_files "${lib_file}" "${imp_file}")
add_prefix("${export_lib_fat_dir}/" export_lib_fat_files)
endif()
#########################
# Getting legal type/arch
set_legal_type(legal_type)
set_legal_arch(legal_arch)
#################################################
# Preprocessor Definitions (cmake/Definitions.cmake)
# Preprocessor Includes
# Compiler (C/C++) Flags (cmake/CommonFlags.cmake)
# Assembler Flags (cmake/CommonFlags.cmake)
# Fortran Flags (cmake/CommonFlags.cmake)
# Linker Flags (cmake/CommonFlags.cmake)
# Archiver Flags (cmake/CommonFlags.cmake)
# Helper Perl Script Flags (cmake/PerlFlags.cmake)
# * Inside the cmake/CommonFlags.cmake file, the USER_*_FLAGS are added.
# * Cannot use CMAKE_*_FLAGS directly because -x c++ is put in the linker command and mangles the linking phase.
# preprocessor flags (-D definitions and -I includes)
# Grab environment variable CPPFLAGS and append those to definitions
set(include_dirs ${CMAKE_CURRENT_BINARY_DIR} ${src_dir} ${src_dir}/i18n ${inc_dir} ${src_dir}/thirdparty/ittnotify)
include_directories(${include_dirs})
# Grab assembler-dependent flags
# CMake will look for cmake/${CMAKE_ASM_COMPILER_ID}/AsmFlags.cmake to append additional assembler flags.
if(${WINDOWS})
# Windows based systems use CMAKE_ASM_MASM_COMPILER
# The windows assembly files are in MASM format, and they require a tool that can handle MASM syntax (ml.exe or ml64.exe typically)
enable_language(ASM_MASM)
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${CMAKE_ASM_MASM_COMPILER_ID} ${CMAKE_MODULE_PATH})
find_file(assembler_specific_include_file_found AsmFlags.cmake ${CMAKE_MODULE_PATH})
if(assembler_specific_include_file_found)
include(AsmFlags)
append_assembler_specific_asm_flags(ASM_FLAGS)
else()
warning_say("Could not find cmake/${CMAKE_ASM_MASM_COMPILER_ID}/AsmFlags.cmake: will only use default flags")
endif()
else()
# Unix (including Mac) based systems use CMAKE_ASM_COMPILER
# Unix assembly files can be handled by compiler usually.
enable_language(ASM)
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${CMAKE_ASM_COMPILER_ID} ${CMAKE_MODULE_PATH})
find_file(assembler_specific_include_file_found AsmFlags.cmake ${CMAKE_MODULE_PATH})
if(assembler_specific_include_file_found)
include(AsmFlags)
append_assembler_specific_asm_flags(ASM_FLAGS)
else()
warning_say("Could not find cmake/${CMAKE_ASM_COMPILER_ID}/AsmFlags.cmake: will only use default flags")
endif()
endif()
# Grab compiler-dependent flags
# Cmake will look for cmake/${CMAKE_C_COMPILER_ID}/CFlags.cmake to append additional c, cxx, and linker flags.
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${CMAKE_C_COMPILER_ID} ${CMAKE_MODULE_PATH})
find_file(compiler_specific_include_file_found CFlags.cmake ${CMAKE_MODULE_PATH})
if(compiler_specific_include_file_found)
include(CFlags) # COMPILER_SUPPORTS_QUAD_PRECISION changed in here
append_compiler_specific_c_and_cxx_flags(C_FLAGS CXX_FLAGS)
append_compiler_specific_linker_flags(LD_FLAGS LD_LIB_FLAGS)
else()
warning_say("Could not find cmake/${CMAKE_C_COMPILER_ID}/CFlags.cmake: will only use default flags")
endif()
# Grab all the compiler-independent flags
append_c_and_cxx_flags_common(C_FLAGS CXX_FLAGS)
append_asm_flags_common(ASM_FLAGS)
append_fort_flags_common(F_FLAGS)
append_linker_flags_common(LD_FLAGS LD_LIB_FLAGS)
append_archiver_flags_common(AR_FLAGS)
append_cpp_flags(DEFINITIONS_FLAGS)
# Setup the flags correctly for cmake (covert to string)
# Pretty them up (STRIP any beginning and trailing whitespace)
list_to_string("${DEFINITIONS_FLAGS}" DEFINITIONS_FLAGS)
list_to_string("${C_FLAGS}" C_FLAGS )
list_to_string("${CXX_FLAGS}" CXX_FLAGS )
list_to_string("${ASM_FLAGS}" ASM_FLAGS )
list_to_string("${LD_FLAGS}" LD_FLAGS )
list_to_string("${LD_LIB_FLAGS}" LD_LIB_FLAGS )
list_to_string("${AR_FLAGS}" AR_FLAGS ) # Windows specific for creating import library
string(STRIP "${DEFINITIONS_FLAGS}" DEFINITIONS_FLAGS)
string(STRIP "${C_FLAGS}" C_FLAGS )
string(STRIP "${CXX_FLAGS}" CXX_FLAGS )
string(STRIP "${ASM_FLAGS}" ASM_FLAGS )
string(STRIP "${LD_FLAGS}" LD_FLAGS )
string(STRIP "${LD_LIB_FLAGS}" LD_LIB_FLAGS )
string(STRIP "${AR_FLAGS}" AR_FLAGS ) # Windows specific for creating import library
# Grab the Perl flags
set_ev_flags(ev_flags) # expand-vars.pl flags
set_gd_flags(gd_flags) # generate-def.pl flags (Windows only)
set(oa_opts "--os=${real_os}" "--arch=${arch}") # sent to the perl scripts
#########################################################
# Getting correct source files (cmake/SourceFiles.cmake)
set_c_files(lib_c_items)
set_cpp_files(lib_cxx_items)
set_asm_files(lib_asm_items)
set_imp_c_files(imp_c_items) # Windows-specific
###################################
# Setting all source file variables
set(lib_src_files "${lib_c_items}" "${lib_cxx_items}" "${lib_asm_items}")
set(imp_src_files "${imp_c_items}")
add_prefix("${src_dir}/" lib_src_files)
add_prefix("${src_dir}/" imp_src_files) # Windows-specific
add_prefix("${src_dir}/" lib_c_items )
add_prefix("${src_dir}/" lib_cxx_items)
add_prefix("${src_dir}/" lib_asm_items)
add_prefix("${src_dir}/" imp_c_items ) # Windows-specific
#####################################################################
# Debug print outs. Will print "variable = ${variable}" if GLOBAL_DEBUG == 1
if(GLOBAL_DEBUG)
include(CMakePrintSystemInformation)
endif()
debug_say_var(CMAKE_ASM_COMPILE_OBJECT)
debug_say_var(CMAKE_RC_COMPILER)
debug_say_var(CMAKE_C_COMPILER_ID)
debug_say_var(LIBOMP_WORK)
debug_say_var(date)
debug_say_var(stats)
debug_say_var(lib_file)
debug_say_var(export_lib_files)
debug_say_var(DEFINITIONS_FLAGS)
debug_say_var(C_FLAGS)
debug_say_var(CXX_FLAGS)
debug_say_var(ASM_FLAGS)
debug_say_var(F_FLAGS)
debug_say_var(LD_FLAGS)
debug_say_var(LD_LIB_FLAGS)
debug_say_var(AR_FLAGS)
debug_say_var(ev_flags)
debug_say_var(gd_flags)
debug_say_var(oa_opts)
debug_say_var(lib_c_items)
debug_say_var(lib_cxx_items)
debug_say_var(lib_asm_items)
debug_say_var(imp_c_items)
debug_say_var(lib_src_files)
debug_say_var(imp_src_files)
####################################################################
# --------------------- #
# --- Rules/Recipes --- #
# --------------------- #
####################################################################
# Below, ${ldeps} always stands for "local dependencies" for the
# next immediate target to be created via add_custom_target() or
# add_custom_command()
####################
# --- Create all ---
add_custom_target(lib ALL DEPENDS ${export_lib_files})
add_custom_target(inc ALL DEPENDS ${export_inc_files})
if(${create_fortran_modules})
add_custom_target(mod ALL DEPENDS ${export_mod_files})
endif()
# --- Enforce the tests to be completed/skipped before copying to exports directory ---
if(${tests})
if(${WINDOWS})
set(test-dependencies test-touch-mt/.success test-touch-md/.success test-relo/.success test-execstack/.success test-instr/.success test-deps/.success)
else()
set(test-dependencies test-touch-rt/.success test-relo/.success test-execstack/.success test-instr/.success test-deps/.success)
endif()
set_source_files_properties(${export_lib_files} PROPERTIES OBJECT_DEPENDS "${test-dependencies}")
endif()
#############################
# --- Create Common Files ---
add_custom_target(common DEPENDS ${export_cmn_files})
add_custom_target(clean-common COMMAND ${CMAKE_COMMAND} -E remove -f ${export_cmn_files})
##########################################
# --- Copy files to export directories ---
# - just a simple copy recipe which acts as an install step
# - copies out of the src_dir into the dest_dir
#
# dest_dir/target : src_dir/target
# cp src_dir/target dest_dir/target
macro (simple_copy_recipe target src_dir dest_dir)
get_source_file_property(extra_depends ${dest_dir}/${target} OBJECT_DEPENDS)
if("${extra_depends}" MATCHES "NOTFOUND")
set(extra_depends)
endif()
set(ldeps ${src_dir}/${target} "${extra_depends}")
if(NOT "${target}" STREQUAL "")
file(MAKE_DIRECTORY ${dest_dir}) # make sure destination directory exists
add_custom_command(
OUTPUT ${dest_dir}/${target}
COMMAND ${CMAKE_COMMAND} -E copy ${src_dir}/${target} ${dest_dir}/${target}
DEPENDS ${ldeps}
)
endif()
endmacro()
# copy from build directory to final resting places in exports directory
simple_copy_recipe("omp.h" "${build_dir}" "${export_cmn_dir}/include")
simple_copy_recipe("omp_lib.h" "${build_dir}" "${export_cmn_dir}/include")
simple_copy_recipe("omp_lib.f" "${build_dir}" "${export_cmn_dir}/include")
simple_copy_recipe("omp_lib.f90" "${build_dir}" "${export_cmn_dir}/include")
simple_copy_recipe("iomp.h" "${build_dir}" "${export_cmn_dir}/include_compat")
simple_copy_recipe("${lib_file}" "${build_dir}" "${export_lib_dir}")
simple_copy_recipe("${imp_file}" "${build_dir}" "${export_lib_dir}")
simple_copy_recipe("${pdb_file}" "${build_dir}" "${export_lib_dir}")
simple_copy_recipe("${dbg_file}" "${build_dir}" "${export_lib_dir}")
simple_copy_recipe("omp_lib.mod" "${build_dir}" "${export_ptf_dir}/include")
simple_copy_recipe("omp_lib_kinds.mod" "${build_dir}" "${export_ptf_dir}/include")
simple_copy_recipe("iomp_lib.h" "${build_dir}" "${export_ptf_dir}/include_compat")
######################################################
# --- Build the main library ---
# $(lib_file) <== Main library file to create
# objects depend on : .inc files and omp.h
# This way the *.inc and omp.h are generated before any compilations take place
add_custom_target(needed-headers DEPENDS ${build_dir}/kmp_i18n_id.inc ${build_dir}/kmp_i18n_default.inc ${build_dir}/omp.h)
# For Windows, there is a definitions file (.def) and resource file (.res) created using generate-def.pl and rc.exe respectively.
if(${WINDOWS})
add_custom_target(needed-windows-files DEPENDS ${build_dir}/${def_file} ${build_dir}/${rc_file})
list(APPEND lib_src_files ${build_dir}/${rc_file})
# The windows assembly files are in MASM format, and they require a tool that can handle MASM syntax (ml.exe or ml64.exe typically)
enable_language(ASM_MASM)
else()
# Unix assembly files can be handled by compiler.
enable_language(ASM)
endif()
# Remove any cmake-automatic linking of libraries by linker, This is so linux
# and mac don't include libstdc++ just because we compile c++ files.
if(${USE_PREDEFINED_LINKER_FLAGS})
set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "")
set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "")
set(CMAKE_ASM_IMPLICIT_LINK_LIBRARIES "")
endif()
# --- ${lib_file} rule ---
add_library(iomp5 SHARED ${lib_src_files})
set_target_properties(iomp5 PROPERTIES
PREFIX "" SUFFIX "" # Take control
OUTPUT_NAME "${lib_file}" # of output name
LINK_FLAGS "${LD_FLAGS}"
LINKER_LANGUAGE C # use C Compiler for linking step
SKIP_BUILD_RPATH true # have Mac linker -install_name just be "-install_name libiomp5.dylib"
)
# Target lib (export files) depend on the library (iomp5) being built
add_dependencies(lib iomp5)
# Linking command will include libraries in LD_LIB_FLAGS
target_link_libraries(iomp5 ${LD_LIB_FLAGS})
# Create *.inc and omp.h before compiling any sources
add_dependencies(iomp5 needed-headers)
if(${WINDOWS})
# Create .def and .rc file before compiling any sources
add_dependencies(iomp5 needed-windows-files)
endif()
# Set the compiler flags for each type of source
set_source_files_properties(${lib_c_items}
${imp_c_items} PROPERTIES COMPILE_FLAGS "${C_FLAGS}" )
set_source_files_properties(${lib_cxx_items} PROPERTIES COMPILE_FLAGS "${CXX_FLAGS}")
set_source_files_properties(${lib_asm_items} PROPERTIES COMPILE_FLAGS "${ASM_FLAGS}")
# Set the -D definitions for all sources
add_definitions(${DEFINITIONS_FLAGS})
# If creating a build that imitates build.pl's rules then set USE_BUILDPL_RULES to true
if(${USE_BUILDPL_RULES})
include(BuildPLRules)
endif()
######################################################
# --- Source file specific flags ---
# kmp_version.o : -D _KMP_BUILD_TIME="\"$(date)}\""
set_source_files_properties(${src_dir}/kmp_version.c PROPERTIES COMPILE_DEFINITIONS "_KMP_BUILD_TIME=\"\\\"${date}\\\"\"")
# z_Linux_asm.o : -D KMP_ARCH_*
if(${ARM})
set_source_files_properties(${src_dir}/z_Linux_asm.s PROPERTIES COMPILE_DEFINITIONS "KMP_ARCH_ARM")
elseif(${INTEL64})
set_source_files_properties(${src_dir}/z_Linux_asm.s PROPERTIES COMPILE_DEFINITIONS "KMP_ARCH_X86_64")
elseif(${IA32})
set_source_files_properties(${src_dir}/z_Linux_asm.s PROPERTIES COMPILE_DEFINITIONS "KMP_ARCH_X86")
endif()
if(${WINDOWS})
set_source_files_properties(${src_dir}/thirdparty/ittnotify/ittnotify_static.c PROPERTIES COMPILE_DEFINITIONS "UNICODE")
endif()
######################################################
# MAC specific build rules
if(${MAC})
# fat library rules
if(${INTEL64})
_export_lib_fat_dir( "mac_32e" export_fat_mac_32e)
_export_lib_dir( "mac_32" export_mac_32 )
_export_lib_dir( "mac_32e" export_mac_32e )
file(MAKE_DIRECTORY ${export_fat_mac_32e})
add_custom_target(fat
COMMAND ${CMAKE_COMMAND} -E echo Building 32 and 32e fat libraries from ${export_mac_32}/${lib_file} and ${export_mac_32e}/${lib_file}
COMMAND ${CMAKE_COMMAND} -E echo Will put fat library in ${export_fat_mac_32e} directory
COMMAND lipo -create -output ${export_fat_mac_32e}/${lib_file} ${export_mac_32}/${lib_file} ${export_mac_32e}/${lib_file}
)
endif()
endif()
######################################################
# Windows specific build rules
if(${WINDOWS})
# --- Create $(imp_file) ---
# This file is first created in the unstripped/${lib_file} creation step.
# It is then "re-linked" to include kmp_import.c which prevents linking of both Visual Studio OpenMP and newly built OpenMP
if(NOT "${imp_file}" STREQUAL "")
set(generated_import_file ${lib_file}${lib})
add_library(iomp5imp STATIC ${generated_import_file} ${imp_src_files})
set_source_files_properties(${generated_import_file} PROPERTIES GENERATED TRUE EXTERNAL_OBJECT TRUE)
set_target_properties(iomp5imp PROPERTIES
PREFIX "" SUFFIX ""
OUTPUT_NAME "${imp_file}"
STATIC_LIBRARY_FLAGS "${AR_FLAGS}"
LINKER_LANGUAGE C
SKIP_BUILD_RPATH true
)
add_custom_command(TARGET iomp5imp PRE_BUILD COMMAND ${CMAKE_COMMAND} -E remove -f ${imp_file})
add_dependencies(iomp5imp iomp5)
endif()
# --- Create $(def_file) ---
if(NOT "${def_file}" STREQUAL "")
string_to_list("${gd_flags}" gd_flags)
add_custom_command(
OUTPUT ${def_file}
COMMAND ${PERL_EXECUTABLE} ${tools_dir}/generate-def.pl ${gd_flags} -o ${def_file} ${src_dir}/dllexports
DEPENDS ${src_dir}/dllexports ${tools_dir}/generate-def.pl
)
endif()
# --- Create $(rc_file) ---
if(NOT "${rc_file}" STREQUAL "")
add_custom_command(
OUTPUT ${rc_file}
COMMAND ${CMAKE_COMMAND} -E copy libiomp.rc ${rc_file}
DEPENDS libiomp.rc
)
endif()
endif()
######################################################
# kmp_i18n_id.inc and kmp_i18n_default.inc
set(perlcmd "${PERL_EXECUTABLE}" "${tools_dir}/message-converter.pl" "${oa_opts}" "--prefix=kmp_i18n" "--enum=kmp_i18n_id.inc" "${src_dir}/i18n/en_US.txt")
add_custom_command(
OUTPUT ${build_dir}/kmp_i18n_id.inc
COMMAND ${perlcmd}
DEPENDS ${src_dir}/i18n/en_US.txt ${tools_dir}/message-converter.pl
)
set(perlcmd "${PERL_EXECUTABLE}" "${tools_dir}/message-converter.pl" "${oa_opts}" "--prefix=kmp_i18n" "--default=kmp_i18n_default.inc" "${src_dir}/i18n/en_US.txt")
add_custom_command(
OUTPUT ${build_dir}/kmp_i18n_default.inc
COMMAND ${perlcmd}
DEPENDS ${src_dir}/i18n/en_US.txt ${tools_dir}/message-converter.pl
)
######################################################
# Micro test rules for after library has been built (cmake/MicroTests.cmake)
# - Only perform if ${tests} == true (specify when invoking: cmake -Dtests=on ...)
if(${tests})
include(MicroTests)
endif()
######################################################
# --- Create Fortran Files ---
# omp_lib.mod
if(${create_fortran_modules})
# Grab fortran-compiler-dependent flags
# Cmake will look for cmake/${CMAKE_Fortran_COMPILER_ID}/FortranFlags.cmake to append additional fortran flags.
enable_language(Fortran)
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${CMAKE_Fortran_COMPILER_ID} ${CMAKE_MODULE_PATH})
find_file(fortran_specific_include_file_found FortranFlags.cmake ${CMAKE_MODULE_PATH})
if(fortran_specific_include_file_found)
include(FortranFlags)
append_fortran_compiler_specific_fort_flags(F_FLAGS)
else()
warning_say("Could not find cmake/${CMAKE_Fortran_COMPILER_ID}/FortranFlags.cmake: will only use default flags in CommonFlags.cmake")
endif()
set(omp_lib_f "omp_lib.f90" )
add_custom_command(
OUTPUT "omp_lib.mod"
COMMAND ${CMAKE_Fortran_COMPILER} -c ${F_FLAGS} ${omp_lib_f}
DEPENDS ${omp_lib_f}
)
add_custom_command(
OUTPUT "omp_lib_kinds.mod"
COMMAND ${CMAKE_Fortran_COMPILER} -c ${F_FLAGS} ${omp_lib_f}
DEPENDS ${omp_lib_f}
)
# clean omp_lib.o from build directory when "make clean"
set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES omp_lib${obj})
endif()
###############################################################
# --- Using expand-vars.pl to generate files ---
# - 'file' is generated using expand-vars.pl and 'file'.var
# - Any .h .f .f90 .rc files should be created with this recipe
macro(expand_vars_recipe filename)
get_source_file_property(extra_ev_flags ${filename} COMPILE_DEFINITIONS)
if("${extra_ev_flags}" MATCHES "NOTFOUND")
set(extra_ev_flags)
else()
string_to_list("${extra_ev_flags}" extra_ev_flags)
endif()
find_file(${filename}_path ${filename}.var PATHS ${src_dir}/include/${omp_version} ${src_dir})
set(ldeps "${${filename}_path}" "${src_dir}/kmp_version.c" "${tools_dir}/expand-vars.pl")
set(expandvarscmd ${PERL_EXECUTABLE} ${tools_dir}/expand-vars.pl --strict ${ev_flags} ${extra_ev_flags} ${${filename}_path} ${filename})
if(NOT "${filename}" STREQUAL "")
add_custom_command(
OUTPUT ${filename}
COMMAND ${expandvarscmd}
DEPENDS ${ldeps}
)
endif()
endmacro()
string_to_list("${ev_flags}" ev_flags)
# omp_lib.h : ev-flags += -D KMP_INT_PTR_KIND="int_ptr_kind()"
set_source_files_properties(omp_lib.h PROPERTIES COMPILE_DEFINITIONS "-D KMP_INT_PTR_KIND=\"int_ptr_kind()\"")
# iomp_lib.h : ev-flags += -D KMP_INT_PTR_KIND=$(if $(filter 32,$(arch)),4,8)
if(${IA32}) # 32 bit archs
set_source_files_properties(iomp_lib.h PROPERTIES COMPILE_DEFINITIONS "-D KMP_INT_PTR_KIND=4")
else()
set_source_files_properties(iomp_lib.h PROPERTIES COMPILE_DEFINITIONS "-D KMP_INT_PTR_KIND=8")
endif()
# libiomp.rc : ev-flags += -D KMP_FILE=$(lib_file)
set_source_files_properties(libiomp.rc PROPERTIES COMPILE_DEFINITIONS "-D KMP_FILE=${lib_file}")
expand_vars_recipe(omp.h)
expand_vars_recipe(omp_lib.h)
expand_vars_recipe(omp_lib.f)
expand_vars_recipe(omp_lib.f90)
expand_vars_recipe(iomp.h)
expand_vars_recipe(iomp_lib.h)
expand_vars_recipe(libiomp.rc)
####################################################################
# Print configuration after all variables are set.
say("")
say("----------------------- CONFIGURATION -----------------------")
say("Operating System : ${os}")
say("Architecture : ${arch}")
say("Build Type : ${CMAKE_BUILD_TYPE}")
say("OpenMP Version : ${omp_version}")
say("Lib Type : ${lib_type}")
if(${MIC})
say("Intel(R) MIC Architecture : ${mic_arch}")
say("Intel(R) MIC Architecture OS : ${mic_os}")
endif()
say("Fortran Modules : ${create_fortran_modules}")
# will say development if all zeros
if("${build_number}" STREQUAL "00000000")
set(build "development")
else()
set(build "${build_number}")
endif()
say("Build : ${build}")
say("Stats-Gathering : ${stats}")
say("Use build.pl rules : ${USE_BUILDPL_RULES}")
say("Adaptive locks : ${USE_ADAPTIVE_LOCKS}")
say("Use predefined linker flags : ${USE_PREDEFINED_LINKER_FLAGS}")
say("Compiler supports quad precision : ${COMPILER_SUPPORTS_QUAD_PRECISION}")
say("-------------------------------------------------------------")
say("")
add_subdirectory(src)

8
openmp/runtime/CMakeLists.txt.old Normal file
View File

@ -0,0 +1,8 @@
project(openmp)
cmake_minimum_required(VERSION 2.8)
set(VERSION 5)
set(OMP_VERSION "201107")
set(OMP_VERSION_NUM "40")
add_subdirectory(src)

100
openmp/runtime/cmake/BuildPLRules.cmake Normal file
View File

@ -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()

16
openmp/runtime/cmake/Clang/AsmFlags.cmake Normal file
View File

@ -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()

38
openmp/runtime/cmake/Clang/CFlags.cmake Normal file
View File

@ -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()

133
openmp/runtime/cmake/CommonFlags.cmake Normal file
View File

@ -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()

131
openmp/runtime/cmake/Definitions.cmake Normal file
View File

@ -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()

16
openmp/runtime/cmake/GNU/AsmFlags.cmake Normal file
View File

@ -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()

45
openmp/runtime/cmake/GNU/CFlags.cmake Normal file
View File

@ -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()

14
openmp/runtime/cmake/GNU/FortranFlags.cmake Normal file
View File

@ -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()

254
openmp/runtime/cmake/HelperFunctions.cmake Normal file
View File

@ -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()

31
openmp/runtime/cmake/Intel/AsmFlags.cmake Normal file
View File

@ -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()

148
openmp/runtime/cmake/Intel/CFlags.cmake Normal file
View File

@ -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()

29
openmp/runtime/cmake/Intel/FortranFlags.cmake Normal file
View File

@ -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()

26
openmp/runtime/cmake/MSVC/AsmFlags.cmake Normal file
View File

@ -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()

64
openmp/runtime/cmake/MSVC/CFlags.cmake Normal file
View File

@ -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()

277
openmp/runtime/cmake/MicroTests.cmake Normal file
View File

@ -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
######################################################

90
openmp/runtime/cmake/PerlFlags.cmake Normal file
View File

@ -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()

110
openmp/runtime/cmake/SourceFiles.cmake Normal file
View File

@ -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()

36
openmp/runtime/src/dllexports
View File

@ -471,7 +471,9 @@ kmp_set_warnings_off 780
# ATOMIC entries
%ifdef HAVE_QUAD
__kmpc_atomic_cmplx16_div 2000
%endif
__kmpc_atomic_fixed1_add 2001
__kmpc_atomic_fixed1_andb 2002
@ -577,6 +579,7 @@ kmp_set_warnings_off 780
__kmpc_atomic_cmplx10_sub 2094
__kmpc_atomic_cmplx10_mul 2095
__kmpc_atomic_cmplx10_div 2096
%ifdef HAVE_QUAD
__kmpc_atomic_cmplx16_add 2097
__kmpc_atomic_cmplx16_sub 2098
__kmpc_atomic_cmplx16_mul 2099
@ -627,6 +630,7 @@ kmp_set_warnings_off 780
__kmpc_atomic_float10_sub_fp 2136
__kmpc_atomic_float10_mul_fp 2137
__kmpc_atomic_float10_div_fp 2138
%endif
__kmpc_atomic_fixed1_mul_float8 2169
__kmpc_atomic_fixed1_div_float8 2170
@ -661,6 +665,7 @@ kmp_set_warnings_off 780
%ifdef arch_32
%ifdef HAVE_QUAD
__kmpc_atomic_float16_add_a16 2255
__kmpc_atomic_float16_sub_a16 2256
__kmpc_atomic_float16_mul_a16 2257
@ -672,6 +677,7 @@ kmp_set_warnings_off 780
__kmpc_atomic_cmplx16_sub_a16 2262
__kmpc_atomic_cmplx16_mul_a16 2263
__kmpc_atomic_cmplx16_div_a16 2264
%endif
%endif
@ -686,14 +692,18 @@ kmp_set_warnings_off 780
__kmpc_atomic_float4_rd 2269
__kmpc_atomic_float8_rd 2270
__kmpc_atomic_float10_rd 2271
%ifdef HAVE_QUAD
__kmpc_atomic_float16_rd 2272
%endif
__kmpc_atomic_cmplx4_rd 2273
__kmpc_atomic_cmplx8_rd 2274
__kmpc_atomic_cmplx10_rd 2275
%ifdef HAVE_QUAD
__kmpc_atomic_cmplx16_rd 2276
%ifdef arch_32
__kmpc_atomic_float16_a16_rd 2277
__kmpc_atomic_cmplx16_a16_rd 2278
%ifdef arch_32
__kmpc_atomic_float16_a16_rd 2277
__kmpc_atomic_cmplx16_a16_rd 2278
%endif
%endif
__kmpc_atomic_fixed1_wr 2279
__kmpc_atomic_fixed2_wr 2280
@ -702,15 +712,19 @@ kmp_set_warnings_off 780
__kmpc_atomic_float4_wr 2283
__kmpc_atomic_float8_wr 2284
__kmpc_atomic_float10_wr 2285
%ifdef HAVE_QUAD
__kmpc_atomic_float16_wr 2286
%endif
__kmpc_atomic_cmplx4_wr 2287
__kmpc_atomic_cmplx8_wr 2288
__kmpc_atomic_cmplx10_wr 2289
%ifdef HAVE_QUAD
__kmpc_atomic_cmplx16_wr 2290
%ifdef arch_32
__kmpc_atomic_float16_a16_wr 2291
__kmpc_atomic_cmplx16_a16_wr 2292
%endif
%endif
__kmpc_atomic_fixed1_add_cpt 2293
__kmpc_atomic_fixed1_andb_cpt 2294
__kmpc_atomic_fixed1_div_cpt 2295
@ -783,8 +797,10 @@ kmp_set_warnings_off 780
__kmpc_atomic_float4_min_cpt 2362
__kmpc_atomic_float8_max_cpt 2363
__kmpc_atomic_float8_min_cpt 2364
%ifdef HAVE_QUAD
__kmpc_atomic_float16_max_cpt 2365
__kmpc_atomic_float16_min_cpt 2366
%endif
__kmpc_atomic_fixed1_neqv_cpt 2367
__kmpc_atomic_fixed2_neqv_cpt 2368
__kmpc_atomic_fixed4_neqv_cpt 2369
@ -797,10 +813,12 @@ kmp_set_warnings_off 780
__kmpc_atomic_float10_sub_cpt 2376
__kmpc_atomic_float10_mul_cpt 2377
__kmpc_atomic_float10_div_cpt 2378
%ifdef HAVE_QUAD
__kmpc_atomic_float16_add_cpt 2379
__kmpc_atomic_float16_sub_cpt 2380
__kmpc_atomic_float16_mul_cpt 2381
__kmpc_atomic_float16_div_cpt 2382
%endif
__kmpc_atomic_cmplx4_add_cpt 2383
__kmpc_atomic_cmplx4_sub_cpt 2384
__kmpc_atomic_cmplx4_mul_cpt 2385
@ -813,13 +831,16 @@ kmp_set_warnings_off 780
__kmpc_atomic_cmplx10_sub_cpt 2392
__kmpc_atomic_cmplx10_mul_cpt 2393
__kmpc_atomic_cmplx10_div_cpt 2394
%ifdef HAVE_QUAD
__kmpc_atomic_cmplx16_add_cpt 2395
__kmpc_atomic_cmplx16_sub_cpt 2396
__kmpc_atomic_cmplx16_mul_cpt 2397
__kmpc_atomic_cmplx16_div_cpt 2398
%endif
#__kmpc_atomic_cmplx4_add_cpt_tmp 2409
%ifdef arch_32
%ifdef HAVE_QUAD
__kmpc_atomic_float16_add_a16_cpt 2399
__kmpc_atomic_float16_sub_a16_cpt 2400
__kmpc_atomic_float16_mul_a16_cpt 2401
@ -831,6 +852,7 @@ kmp_set_warnings_off 780
__kmpc_atomic_cmplx16_mul_a16_cpt 2407
__kmpc_atomic_cmplx16_div_a16_cpt 2408
%endif
%endif
__kmpc_atomic_start 2410
__kmpc_atomic_end 2411
@ -846,16 +868,20 @@ kmp_set_warnings_off 780
__kmpc_atomic_float4_swp 2416
__kmpc_atomic_float8_swp 2417
__kmpc_atomic_float10_swp 2418
%ifdef HAVE_QUAD
__kmpc_atomic_float16_swp 2419
%endif
__kmpc_atomic_cmplx4_swp 2420
__kmpc_atomic_cmplx8_swp 2421
__kmpc_atomic_cmplx10_swp 2422
%ifdef HAVE_QUAD
__kmpc_atomic_cmplx16_swp 2423
%ifdef arch_32
__kmpc_atomic_float16_a16_swp 2424
__kmpc_atomic_cmplx16_a16_swp 2425
%endif
%endif
__kmpc_atomic_fixed1_sub_cpt_rev 2426
__kmpc_atomic_fixed1_div_cpt_rev 2427
@ -887,14 +913,17 @@ kmp_set_warnings_off 780
__kmpc_atomic_float8_div_cpt_rev 2453
__kmpc_atomic_float10_sub_cpt_rev 2454
__kmpc_atomic_float10_div_cpt_rev 2455
%ifdef HAVE_QUAD
__kmpc_atomic_float16_sub_cpt_rev 2456
__kmpc_atomic_float16_div_cpt_rev 2457
%endif
__kmpc_atomic_cmplx4_sub_cpt_rev 2458
__kmpc_atomic_cmplx4_div_cpt_rev 2459
__kmpc_atomic_cmplx8_sub_cpt_rev 2460
__kmpc_atomic_cmplx8_div_cpt_rev 2461
__kmpc_atomic_cmplx10_sub_cpt_rev 2462
__kmpc_atomic_cmplx10_div_cpt_rev 2463
%ifdef HAVE_QUAD
__kmpc_atomic_cmplx16_sub_cpt_rev 2464
__kmpc_atomic_cmplx16_div_cpt_rev 2465
@ -904,6 +933,7 @@ kmp_set_warnings_off 780
__kmpc_atomic_cmplx16_sub_a16_cpt_rev 2468
__kmpc_atomic_cmplx16_div_a16_cpt_rev 2469
%endif
%endif
%endif # OMP_40

2
openmp/runtime/src/kmp_csupport.c
View File

@ -828,7 +828,7 @@ __kmpc_flush(ident_t *loc, ...)
if ( ! __kmp_cpuinfo.sse2 ) {
// CPU cannot execute SSE2 instructions.
} else {
#if KMP_COMPILER_ICC
#if KMP_COMPILER_ICC || KMP_COMPILER_MSVC
_mm_mfence();
#else
__sync_synchronize();

7
openmp/runtime/src/kmp_ftn_entry.h
View File

@ -263,7 +263,7 @@ FTN_GET_AFFINITY_MAX_PROC( void )
#if KMP_OS_WINDOWS && KMP_ARCH_X86_64
if ( __kmp_num_proc_groups <= 1 ) {
return KMP_CPU_SETSIZE;
return (int)KMP_CPU_SETSIZE;
}
#endif /* KMP_OS_WINDOWS && KMP_ARCH_X86_64 */
return __kmp_xproc;
@ -412,7 +412,7 @@ xexpand(FTN_GET_THREAD_NUM)( void )
gtid = __kmp_entry_gtid();
#elif KMP_OS_WINDOWS
if (!__kmp_init_parallel ||
(gtid = ((kmp_intptr_t)TlsGetValue( __kmp_gtid_threadprivate_key ))) == 0) {
(gtid = (int)((kmp_intptr_t)TlsGetValue( __kmp_gtid_threadprivate_key ))) == 0) {
// Either library isn't initialized or thread is not registered
// 0 is the correct TID in this case
return 0;
@ -463,7 +463,6 @@ xexpand(FTN_GET_NUM_PROCS)( void )
#ifdef KMP_STUB
return 1;
#else
int gtid;
if ( ! TCR_4(__kmp_init_middle) ) {
__kmp_middle_initialize();
}
@ -1013,7 +1012,7 @@ FTN_SET_DEFAULTS( char const * str
{
#ifndef KMP_STUB
#ifdef PASS_ARGS_BY_VALUE
int len = strlen( str );
int len = (int)strlen( str );
#endif
__kmp_aux_set_defaults( str, len );
#endif

6
openmp/runtime/src/kmp_os.h
View File

@ -46,6 +46,7 @@
#define KMP_COMPILER_ICC 0
#define KMP_COMPILER_GCC 0
#define KMP_COMPILER_CLANG 0
#define KMP_COMPILER_MSVC 0
#if defined( __INTEL_COMPILER )
# undef KMP_COMPILER_ICC
@ -56,6 +57,9 @@
#elif defined( __GNUC__ )
# undef KMP_COMPILER_GCC
# define KMP_COMPILER_GCC 1
#elif defined( _MSC_VER )
# undef KMP_COMPILER_MSVC
# define KMP_COMPILER_MSVC 1
#else
# error Unknown compiler
#endif
@ -175,6 +179,8 @@
typedef __float128 _Quad;
# undef KMP_HAVE_QUAD
# define KMP_HAVE_QUAD 1
# elif KMP_COMPILER_MSVC
typedef long double _Quad;
# endif
#else
# if __LDBL_MAX_EXP__ >= 16384 && KMP_COMPILER_GCC

5
openmp/runtime/src/kmp_str.h
View File

@ -28,9 +28,8 @@
#endif // __cplusplus
#if KMP_OS_WINDOWS
#define strdup _strdup
#define snprintf _snprintf
#define vsnprintf _vsnprintf
# define strdup _strdup
# define snprintf _snprintf
#endif
/* some macros to replace ctype.h functions */

2
openmp/runtime/src/kmp_version.c
View File

@ -53,6 +53,8 @@
#define KMP_COMPILER "Clang " stringer( __clang_major__ ) "." stringer( __clang_minor__ )
#elif KMP_COMPILER_GCC
#define KMP_COMPILER "GCC " stringer( __GNUC__ ) "." stringer( __GNUC_MINOR__ )
#elif KMP_COMPILER_MSVC
#define KMP_COMPILER "MSVC " stringer( __MSC_FULL_VER )
#endif
#ifndef KMP_COMPILER
#warning "Unknown compiler"

6
openmp/runtime/src/makefile.mk
View File

@ -73,6 +73,8 @@ OPTIMIZATION := $(call check_variable,OPTIMIZATION,off on)
TARGET_COMPILER := $(call check_variable,TARGET_COMPILER,12 11)
# Library version: 4 -- legacy, 5 -- compat.
VERSION := $(call check_variable,VERSION,5 4)
# quad precision floating point
HAVE_QUAD = 1
VPATH += $(src_dir)
VPATH += $(src_dir)i18n/
@ -171,6 +173,7 @@ ifeq "$(c)" "clang"
ld-flags += -m32 -msse
as-flags += -m32 -msse
endif
HAVE_QUAD = 0
endif
ifeq "$(LINK_TYPE)" "dyna"
@ -596,6 +599,9 @@ kmp_version$(obj) : cpp-flags += -D _KMP_BUILD_TIME="\"$(date)\""
gd-flags += -D arch_$(arch)
gd-flags += -D $(LIB_TYPE)
ifeq "$(HAVE_QUAD)" "1"
gd-flags += -D HAVE_QUAD
endif
ifeq "$(OMP_VERSION)" "40"
gd-flags += -D OMP_40 -D OMP_30
else