943 lines
40 KiB
CMake
943 lines
40 KiB
CMake
#
|
|
#//===----------------------------------------------------------------------===//
|
|
#//
|
|
#// 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.
|
|
#//
|
|
#//===----------------------------------------------------------------------===//
|
|
#
|
|
|
|
################
|
|
# CMAKE libomp
|
|
cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
|
|
|
|
#########
|
|
# 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})
|
|
|
|
#######################################################################
|
|
# Standalone build or part of LLVM?
|
|
set(LIBOMP_STANDALONE_BUILD FALSE)
|
|
if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}" OR
|
|
"${CMAKE_SOURCE_DIR}/runtime" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
|
|
project(libomp C CXX)
|
|
set(LIBOMP_STANDALONE_BUILD TRUE)
|
|
endif()
|
|
|
|
# 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
|
|
include(GetArchitecture) # get_architecture()
|
|
|
|
####################################################################
|
|
# 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)
|
|
set(arch_possible_values 32e 32 arm ppc64 ppc64le aarch64 mic)
|
|
set(build_type_possible_values release debug relwithdebinfo)
|
|
set(omp_version_possible_values 41 40 30)
|
|
set(lib_type_possible_values normal profile stubs)
|
|
set(mic_arch_possible_values knf knc)
|
|
|
|
# Below, cmake will try and determine the operating system and architecture for you.
|
|
# 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"
|
|
# Apple goes first because CMake considers Mac to be a Unix based
|
|
# operating system, while libomp considers it a special case
|
|
if(${APPLE})
|
|
set(temp_os mac)
|
|
elseif(${UNIX})
|
|
set(temp_os lin)
|
|
elseif(${WIN32})
|
|
set(temp_os win)
|
|
else()
|
|
set(temp_os lin)
|
|
endif()
|
|
|
|
# If adding a new architecture, take a look at cmake/GetArchitecture.cmake
|
|
get_architecture(detected_arch)
|
|
|
|
set(LIBOMP_OS ${temp_os} CACHE STRING
|
|
"The operating system to build for (lin/mac/win)")
|
|
set(LIBOMP_ARCH ${detected_arch} CACHE STRING
|
|
"The architecture to build for (32e/32/arm/ppc64/ppc64le/aarch64/mic). 32e is Intel(R) 64 architecture, 32 is IA-32 architecture")
|
|
set(LIBOMP_LIB_TYPE normal CACHE STRING
|
|
"Performance,Profiling,Stubs library (normal/profile/stubs)")
|
|
set(LIBOMP_VERSION 5 CACHE STRING
|
|
"Produce libguide (version 4) or libomp (version 5)")
|
|
set(LIBOMP_OMP_VERSION 41 CACHE STRING
|
|
"The OpenMP version (41/40/30)")
|
|
set(LIBOMP_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(LIBOMP_FORTRAN_MODULES false CACHE BOOL
|
|
"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 -DLIBOMP_MICRO_TESTS=OFF to cmake
|
|
set(LIBOMP_TEST_TOUCH true CACHE BOOL
|
|
"Perform a small touch test?")
|
|
set(LIBOMP_TEST_RELO true CACHE BOOL
|
|
"Perform a relocation test for dynamic libraries?")
|
|
set(LIBOMP_TEST_EXECSTACK true CACHE BOOL
|
|
"Perform a execstack test for linux dynamic libraries?")
|
|
set(LIBOMP_TEST_INSTR true CACHE BOOL
|
|
"Perform an instruction test for Intel(R) MIC Architecture libraries?")
|
|
set(LIBOMP_TEST_DEPS true CACHE BOOL
|
|
"Perform a library dependency test?")
|
|
set(LIBOMP_MICRO_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(LIBOMP_STATS false CACHE BOOL
|
|
"Stats-Gathering functionality?")
|
|
|
|
# - Support for universal fat binary builds on Mac
|
|
# - Having this extra variable allows people to build this library as a universal library
|
|
# without forcing a universal build of the llvm/clang compiler.
|
|
set(LIBOMP_OSX_ARCHITECTURES "${CMAKE_OSX_ARCHITECTURES}" CACHE STRING
|
|
"For Mac builds, semicolon separated list of architectures to build for universal fat binary.")
|
|
set(CMAKE_OSX_ARCHITECTURES ${LIBOMP_OSX_ARCHITECTURES})
|
|
|
|
# OMPT-support
|
|
set(LIBOMP_OMPT_SUPPORT false CACHE BOOL
|
|
"OMPT-support?")
|
|
set(LIBOMP_OMPT_BLAME true CACHE BOOL
|
|
"OMPT-blame?")
|
|
set(LIBOMP_OMPT_TRACE true CACHE BOOL
|
|
"OMPT-trace?")
|
|
|
|
# User specified flags. These are appended to the predetermined flags found
|
|
# in CommonFlags.cmake and ${CMAKE_C_COMPILER_ID}/*Flags.cmake (e.g., GNU/CFlags.cmake)
|
|
set(LIBOMP_CFLAGS "" CACHE STRING
|
|
"Appended user specified C compiler flags.")
|
|
set(LIBOMP_CXXFLAGS "" CACHE STRING
|
|
"Appended user specified C++ compiler flags.")
|
|
set(LIBOMP_CPPFLAGS "" CACHE STRING
|
|
"Appended user specified C preprocessor flags.")
|
|
set(LIBOMP_ASMFLAGS "" CACHE STRING
|
|
"Appended user specified assembler flags.")
|
|
set(LIBOMP_LDFLAGS "" CACHE STRING
|
|
"Appended user specified linker flags.")
|
|
set(LIBOMP_LIBFLAGS "" CACHE STRING
|
|
"Appended user specified linked libs flags. (e.g., -lm)")
|
|
set(LIBOMP_FFLAGS "" CACHE STRING
|
|
"Appended user specified Fortran compiler flags. These are only used if LIBOMP_FORTRAN_MODULES==true.")
|
|
|
|
# Should the libomp library and generated headers be copied into the original source exports/ directory
|
|
# Turning this to false aids parallel builds to not interfere with each other.
|
|
set(LIBOMP_COPY_EXPORTS true CACHE STRING
|
|
"Should exports be copied into source exports/ directory?")
|
|
|
|
# - 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()
|
|
|
|
# Allow user to choose a suffix for the installation directory, or if part of
|
|
# LLVM build then just use LLVM_LIBDIR_SUFFIX
|
|
if(${LIBOMP_STANDALONE_BUILD})
|
|
set(LIBOMP_LIBDIR_SUFFIX "" CACHE STRING
|
|
"suffix of lib installation directory e.g., 64 => lib64")
|
|
else()
|
|
set(LIBOMP_LIBDIR_SUFFIX ${LLVM_LIBDIR_SUFFIX})
|
|
endif()
|
|
|
|
# Check valid values
|
|
check_variable(LIBOMP_OS "${os_possible_values}")
|
|
check_variable(LIBOMP_ARCH "${arch_possible_values}")
|
|
check_variable(LIBOMP_OMP_VERSION "${omp_version_possible_values}")
|
|
check_variable(LIBOMP_LIB_TYPE "${lib_type_possible_values}")
|
|
if("${LIBOMP_ARCH}" STREQUAL "mic")
|
|
check_variable(LIBOMP_MIC_ARCH "${mic_arch_possible_values}")
|
|
endif()
|
|
# Get the build number from kmp_version.c
|
|
get_build_number("${CMAKE_CURRENT_SOURCE_DIR}" 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("${LIBOMP_OS}" STREQUAL "lin")
|
|
set(LINUX TRUE)
|
|
set(real_os lin)
|
|
elseif("${LIBOMP_OS}" STREQUAL "mac")
|
|
set(MAC TRUE)
|
|
set(real_os mac)
|
|
elseif("${LIBOMP_OS}" STREQUAL "win")
|
|
set(WINDOWS TRUE)
|
|
set(real_os win)
|
|
endif()
|
|
if("${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD")
|
|
set(FREEBSD TRUE)
|
|
endif()
|
|
|
|
# Architecture
|
|
set(IA32 FALSE)
|
|
set(INTEL64 FALSE)
|
|
set(ARM FALSE)
|
|
set(AARCH64 FALSE)
|
|
set(PPC64BE FALSE)
|
|
set(PPC64LE FALSE)
|
|
set(PPC64 FALSE)
|
|
if("${LIBOMP_ARCH}" STREQUAL "32") # IA-32 architecture
|
|
set(IA32 TRUE)
|
|
elseif("${LIBOMP_ARCH}" STREQUAL "32e") # Intel(R) 64 architecture
|
|
set(INTEL64 TRUE)
|
|
elseif("${LIBOMP_ARCH}" STREQUAL "arm") # ARM architecture
|
|
set(ARM TRUE)
|
|
elseif("${LIBOMP_ARCH}" STREQUAL "ppc64") # PPC64BE architecture
|
|
set(PPC64BE TRUE)
|
|
set(PPC64 TRUE)
|
|
elseif("${LIBOMP_ARCH}" STREQUAL "ppc64le") # PPC64LE architecture
|
|
set(PPC64LE TRUE)
|
|
set(PPC64 TRUE)
|
|
elseif("${LIBOMP_ARCH}" STREQUAL "aarch64") # AARCH64 architecture
|
|
set(AARCH64 TRUE)
|
|
elseif("${LIBOMP_ARCH}" STREQUAL "mic") # Intel(R) Many Integrated Core Architecture
|
|
set(MIC 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()
|
|
|
|
# Include itt notify interface? Right now, always.
|
|
set(LIBOMP_USE_ITT_NOTIFY TRUE)
|
|
|
|
# normal, profile, stubs library.
|
|
set(NORMAL_LIBRARY FALSE)
|
|
set(STUBS_LIBRARY FALSE)
|
|
set(PROFILE_LIBRARY FALSE)
|
|
if("${LIBOMP_LIB_TYPE}" STREQUAL "normal")
|
|
set(NORMAL_LIBRARY TRUE)
|
|
elseif("${LIBOMP_LIB_TYPE}" STREQUAL "profile")
|
|
set(PROFILE_LIBRARY TRUE)
|
|
elseif("${LIBOMP_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(LIBOMP_COMPILER_SUPPORTS_QUAD_PRECISION false CACHE BOOL
|
|
"*INCOMPLETE* Does the compiler support a 128-bit floating point type?")
|
|
set(LIBOMP_COMPILER_QUAD_TYPE "" CACHE STRING
|
|
"*INCOMPLETE* The quad precision data type (e.g., 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 libomp.dbg.
|
|
set(LIBOMP_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(LIBOMP_USE_PREDEFINED_LINKER_FLAGS true CACHE BOOL
|
|
"Should the build use the predefined linker flags in CommonFlags.cmake?")
|
|
|
|
# - On multinode systems, larger alignment is desired to avoid false sharing
|
|
set(LIBOMP_USE_INTERNODE_ALIGNMENT false CACHE BOOL
|
|
"Should larger alignment (4096 bytes) be used for some locks and data structures?")
|
|
|
|
# - libgomp drop-in compatibility
|
|
if(${LINUX} AND NOT ${PPC64})
|
|
set(LIBOMP_USE_VERSION_SYMBOLS true CACHE BOOL
|
|
"Should version symbols be used? These provide binary compatibility with libgomp.")
|
|
else()
|
|
set(LIBOMP_USE_VERSION_SYMBOLS false)
|
|
endif()
|
|
|
|
# - TSX based locks have __asm code which can be troublesome for some compilers. This feature is also x86 specific.
|
|
if(${IA32} OR ${INTEL64})
|
|
set(LIBOMP_USE_ADAPTIVE_LOCKS true CACHE BOOL
|
|
"Should TSX-based lock be compiled (adaptive lock in kmp_lock.cpp). These are x86 specific.")
|
|
else()
|
|
set(LIBOMP_USE_ADAPTIVE_LOCKS false)
|
|
endif()
|
|
|
|
##################################
|
|
# Error checking the configuration
|
|
if(${LIBOMP_STATS} AND (${WINDOWS} OR ${MAC}))
|
|
error_say("Stats-gathering functionality is only supported on x86-Linux and Intel(R) MIC Architecture")
|
|
endif()
|
|
if(${LIBOMP_STATS} AND NOT (${IA32} OR ${INTEL64} OR ${MIC}))
|
|
error_say("Stats-gathering functionality is only supported on x86-Linux and Intel(R) MIC Architecture")
|
|
endif()
|
|
if(${LIBOMP_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 "${LIBOMP_OMP_VERSION}" STREQUAL "41")
|
|
set(suffix "${suffix}.${LIBOMP_OMP_VERSION}")
|
|
endif()
|
|
if(${LIBOMP_STATS})
|
|
set(suffix "${suffix}.s1")
|
|
endif()
|
|
if(${LIBOMP_OMPT_SUPPORT})
|
|
set(suffix "${suffix}.ompt")
|
|
if(NOT ${LIBOMP_OMPT_BLAME})
|
|
set(suffix "${suffix}.no-ompt-blame")
|
|
endif()
|
|
if(NOT ${LIBOMP_OMPT_TRACE})
|
|
set(suffix "${suffix}.no-ompt-trace")
|
|
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
|
|
if(${MIC})
|
|
set(platform "${real_os}_${LIBOMP_MIC_ARCH}") # e.g., lin_knf, lin_knc
|
|
else()
|
|
set(platform "${real_os}_${LIBOMP_ARCH}") # e.g., lin_32e, mac_32
|
|
endif()
|
|
# build directory (Where CMakeCache.txt is created, build files generated)
|
|
set(build_dir "${CMAKE_CURRENT_BINARY_DIR}")
|
|
set(src_dir "${CMAKE_CURRENT_SOURCE_DIR}/src")
|
|
set(tools_dir "${CMAKE_CURRENT_SOURCE_DIR}/tools")
|
|
set(export_dir "${CMAKE_CURRENT_SOURCE_DIR}/exports")
|
|
set(export_ptf_dir "${export_dir}/${platform}${suffix}")
|
|
set(export_cmn_dir "${export_dir}/common${suffix}/include")
|
|
set(export_inc_dir "${export_ptf_dir}/include")
|
|
set(export_mod_dir "${export_ptf_dir}/include_compat")
|
|
_export_lib_dir(${platform} export_lib_dir) # set exports directory (relative to build_dir) e.g., ../exports/lin_32e/lib/
|
|
# or ../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 "${src_dir}/include/${LIBOMP_OMP_VERSION}")
|
|
|
|
############################
|
|
# Setting final library name
|
|
set(lib_item "libomp")
|
|
if(${PROFILE_LIBRARY})
|
|
set(lib_item "${lib_item}prof")
|
|
endif()
|
|
if(${STUBS_LIBRARY})
|
|
set(lib_item "${lib_item}stubs")
|
|
endif()
|
|
if(${WINDOWS})
|
|
set(lib_item "${lib_item}md")
|
|
endif()
|
|
set(LIBOMP_LIB_NAME "${lib_item}" CACHE STRING "OMP library name")
|
|
set(lib_ext "${dll}")
|
|
# ${lib_file} is real library name:
|
|
# libomp.so for Linux
|
|
# libomp.dylib for Mac
|
|
# libompmd.dll for Windows
|
|
set(lib_file "${LIBOMP_LIB_NAME}${lib_ext}")
|
|
|
|
########################################
|
|
# Setting export file names
|
|
if(${WINDOWS})
|
|
set(imp_file "${lib_item}${lib}") # this is exported (libomp.lib)
|
|
set(def_file "${lib_item}.def") # this is not exported
|
|
if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug" OR
|
|
"${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo" OR
|
|
${LIBOMP_USE_BUILDPL_RULES})
|
|
set(pdb_file "${lib_file}.pdb") # this is exported if it exists (libompmd.dll.pdb)
|
|
endif()
|
|
endif()
|
|
set(export_lib_files "${lib_file}" "${imp_file}" "${pdb_file}")
|
|
set(export_mod_files "omp_lib.mod" "omp_lib_kinds.mod")
|
|
set(export_cmn_files "omp.h" "omp_lib.h" "omp_lib.f" "omp_lib.f90")
|
|
|
|
if(${LIBOMP_OMPT_SUPPORT})
|
|
set(export_cmn_files ${export_cmn_files} "ompt.h")
|
|
endif()
|
|
|
|
if("${export_lib_fat_dir}")
|
|
set(export_lib_fat_files "${lib_file}" "${imp_file}")
|
|
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 LIBOMP_*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 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 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.
|
|
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 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)
|
|
# Windows specific for creating import library
|
|
list_to_string("${AR_FLAGS}" AR_FLAGS)
|
|
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)
|
|
# Windows specific for creating import library
|
|
string(STRIP "${AR_FLAGS}" AR_FLAGS)
|
|
|
|
# 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=${LIBOMP_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(date)
|
|
debug_say_var(LIBOMP_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 omp)
|
|
if(${LIBOMP_FORTRAN_MODULES})
|
|
add_custom_target(mod ALL DEPENDS ${export_mod_files})
|
|
endif()
|
|
|
|
#############################
|
|
# --- Create Common Files ---
|
|
add_custom_target(common ALL DEPENDS ${export_cmn_files})
|
|
add_custom_target(clean-common COMMAND ${CMAKE_COMMAND} -E remove -f ${export_cmn_files})
|
|
|
|
# --- Put headers in convenient locations post build ---
|
|
if(${LIBOMP_COPY_EXPORTS})
|
|
add_custom_command(TARGET common POST_BUILD
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${export_cmn_dir}
|
|
COMMAND ${CMAKE_COMMAND} -E copy omp.h ${export_cmn_dir}
|
|
COMMAND ${CMAKE_COMMAND} -E copy omp_lib.h ${export_cmn_dir}
|
|
COMMAND ${CMAKE_COMMAND} -E copy omp_lib.f ${export_cmn_dir}
|
|
COMMAND ${CMAKE_COMMAND} -E copy omp_lib.f90 ${export_cmn_dir}
|
|
)
|
|
if(${LIBOMP_OMPT_SUPPORT})
|
|
add_custom_command(TARGET common POST_BUILD
|
|
COMMAND ${CMAKE_COMMAND} -E copy ompt.h ${export_cmn_dir}
|
|
)
|
|
endif()
|
|
if(${LIBOMP_FORTRAN_MODULES})
|
|
add_custom_command(TARGET mod POST_BUILD
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${export_mod_dir}
|
|
COMMAND ${CMAKE_COMMAND} -E copy omp_lib.mod ${export_mod_dir}
|
|
COMMAND ${CMAKE_COMMAND} -E copy omp_lib_kinds.mod ${export_mod_dir}
|
|
)
|
|
endif()
|
|
endif()
|
|
|
|
######################################################
|
|
# --- 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}/libomp.rc)
|
|
list(APPEND lib_src_files ${build_dir}/libomp.rc)
|
|
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(${LIBOMP_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(omp SHARED ${lib_src_files})
|
|
set_target_properties(omp 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 libomp.dylib"
|
|
)
|
|
|
|
# --- Copy libomp into exports directory post build ---
|
|
if(${WINDOWS})
|
|
get_target_property(LIBOMP_OUTPUT_DIRECTORY omp RUNTIME_OUTPUT_DIRECTORY)
|
|
else()
|
|
get_target_property(LIBOMP_OUTPUT_DIRECTORY omp LIBRARY_OUTPUT_DIRECTORY)
|
|
endif()
|
|
if(NOT LIBOMP_OUTPUT_DIRECTORY)
|
|
set(LIBOMP_OUTPUT_DIRECTORY ${build_dir})
|
|
endif()
|
|
|
|
if(${LIBOMP_COPY_EXPORTS})
|
|
add_custom_command(TARGET omp POST_BUILD
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${export_lib_dir}
|
|
COMMAND ${CMAKE_COMMAND} -E copy ${LIBOMP_OUTPUT_DIRECTORY}/${lib_file} ${export_lib_dir}
|
|
)
|
|
endif()
|
|
|
|
# Linking command will include libraries in LD_LIB_FLAGS
|
|
target_link_libraries(omp ${LD_LIB_FLAGS} ${CMAKE_DL_LIBS})
|
|
|
|
# Create *.inc and omp.h before compiling any sources
|
|
add_dependencies(omp needed-headers)
|
|
if(${WINDOWS})
|
|
# Create .def and .rc file before compiling any sources
|
|
add_dependencies(omp 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}")
|
|
if(${WINDOWS})
|
|
# Windows operating system has to use MASM assembler
|
|
set_source_files_properties(${lib_asm_items} PROPERTIES COMPILE_FLAGS "${ASM_FLAGS}")
|
|
else()
|
|
# Non-Windows operating systems can use compiler to assemble the assembly files
|
|
set_source_files_properties(${lib_asm_items} PROPERTIES COMPILE_FLAGS "${ASM_FLAGS}" LANGUAGE C)
|
|
endif()
|
|
# 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(${LIBOMP_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}\\\"\"")
|
|
|
|
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)
|
|
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 ${CMAKE_COMMAND} -E make_directory ${export_fat_mac_32e}
|
|
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(ompimp STATIC ${generated_import_file} ${imp_src_files})
|
|
set_source_files_properties(${generated_import_file} PROPERTIES GENERATED TRUE EXTERNAL_OBJECT TRUE)
|
|
set_target_properties(ompimp PROPERTIES
|
|
PREFIX "" SUFFIX ""
|
|
OUTPUT_NAME "${imp_file}"
|
|
STATIC_LIBRARY_FLAGS "${AR_FLAGS}"
|
|
LINKER_LANGUAGE C
|
|
SKIP_BUILD_RPATH true
|
|
)
|
|
add_custom_command(TARGET ompimp PRE_BUILD COMMAND ${CMAKE_COMMAND} -E remove -f ${imp_file})
|
|
add_dependencies(ompimp omp)
|
|
get_target_property(LIBOMPIMP_OUTPUT_DIRECTORY ompimp ARCHIVE_OUTPUT_DIRECTORY)
|
|
if(NOT LIBOMPIMP_OUTPUT_DIRECTORY)
|
|
set(LIBOMPIMP_OUTPUT_DIRECTORY ${build_dir})
|
|
endif()
|
|
if(${LIBOMP_COPY_EXPORTS})
|
|
add_custom_command(TARGET ompimp POST_BUILD
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${export_lib_dir}
|
|
COMMAND ${CMAKE_COMMAND} -E copy ${LIBOMPIMP_OUTPUT_DIRECTORY}/${imp_file} ${export_lib_dir}
|
|
)
|
|
endif()
|
|
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()
|
|
|
|
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(${LIBOMP_MICRO_TESTS})
|
|
include(MicroTests)
|
|
add_custom_target(libomp-micro-tests)
|
|
if(NOT ${MIC} AND ${LIBOMP_TEST_TOUCH})
|
|
add_dependencies(libomp-micro-tests libomp-test-touch)
|
|
endif()
|
|
if(${LINUX} AND ${LIBOMP_TEST_RELO})
|
|
add_dependencies(libomp-micro-tests libomp-test-relo)
|
|
endif()
|
|
if(${LINUX} AND ${LIBOMP_TEST_EXECSTACK})
|
|
add_dependencies(libomp-micro-tests libomp-test-execstack)
|
|
endif()
|
|
if(${MIC} AND ${LIBOMP_TEST_INSTR})
|
|
add_dependencies(libomp-micro-tests libomp-test-instr)
|
|
endif()
|
|
if(${LIBOMP_TEST_DEPS})
|
|
add_dependencies(libomp-micro-tests libomp-test-deps)
|
|
endif()
|
|
endif()
|
|
|
|
######################################################
|
|
# --- Create Fortran Files ---
|
|
# omp_lib.mod
|
|
if(${LIBOMP_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 file_dir filename)
|
|
set(extra_ev_flags)
|
|
get_source_file_property(extra_ev_flags ${filename} EV_COMPILE_DEFINITIONS)
|
|
if("${extra_ev_flags}" MATCHES "NOTFOUND")
|
|
set(extra_ev_flags)
|
|
else()
|
|
string_to_list("${extra_ev_flags}" extra_ev_flags)
|
|
endif()
|
|
if(NOT "${filename}" STREQUAL "")
|
|
add_custom_command(
|
|
OUTPUT ${filename}
|
|
COMMAND ${PERL_EXECUTABLE} ${tools_dir}/expand-vars.pl --strict ${ev_flags} ${extra_ev_flags} ${file_dir}/${filename}.var ${filename}
|
|
DEPENDS ${file_dir}/${filename}.var ${src_dir}/kmp_version.c ${tools_dir}/expand-vars.pl
|
|
)
|
|
endif()
|
|
endmacro()
|
|
string_to_list("${ev_flags}" ev_flags)
|
|
# iomp_lib.h : ev-flags += -D KMP_INT_PTR_KIND="int_ptr_kind()"
|
|
set_source_files_properties(omp_lib.h PROPERTIES EV_COMPILE_DEFINITIONS "-D KMP_INT_PTR_KIND=\"int_ptr_kind()\"")
|
|
# libomp.rc : ev-flags += -D KMP_FILE=$(lib_file)
|
|
set_source_files_properties(libomp.rc PROPERTIES EV_COMPILE_DEFINITIONS "-D KMP_FILE=${lib_file}")
|
|
expand_vars_recipe(${src_dir}/include/${LIBOMP_OMP_VERSION} omp.h)
|
|
expand_vars_recipe(${src_dir}/include/${LIBOMP_OMP_VERSION} ompt.h)
|
|
expand_vars_recipe(${src_dir}/include/${LIBOMP_OMP_VERSION} omp_lib.h)
|
|
expand_vars_recipe(${src_dir}/include/${LIBOMP_OMP_VERSION} omp_lib.f)
|
|
expand_vars_recipe(${src_dir}/include/${LIBOMP_OMP_VERSION} omp_lib.f90)
|
|
expand_vars_recipe(${src_dir} libomp.rc)
|
|
|
|
####################################################################
|
|
# Print configuration after all variables are set.
|
|
if(${LIBOMP_STANDALONE_BUILD})
|
|
say("LIBOMP: Operating System -- ${LIBOMP_OS}")
|
|
say("LIBOMP: Target Architecture -- ${LIBOMP_ARCH}")
|
|
if(${MIC})
|
|
say("LIBOMP: Intel(R) MIC Architecture -- ${LIBOMP_MIC_ARCH}")
|
|
endif()
|
|
say("LIBOMP: Build Type -- ${CMAKE_BUILD_TYPE}")
|
|
say("LIBOMP: OpenMP Version -- ${LIBOMP_OMP_VERSION}")
|
|
say("LIBOMP: Lib Type -- ${LIBOMP_LIB_TYPE}")
|
|
say("LIBOMP: Fortran Modules -- ${LIBOMP_FORTRAN_MODULES}")
|
|
# will say development if all zeros
|
|
if("${build_number}" STREQUAL "00000000")
|
|
set(build "development")
|
|
else()
|
|
set(build "${build_number}")
|
|
endif()
|
|
say("LIBOMP: Build -- ${build}")
|
|
say("LIBOMP: Stats-Gathering -- ${LIBOMP_STATS}")
|
|
say("LIBOMP: OMPT-support -- ${LIBOMP_OMPT_SUPPORT}")
|
|
if(${LIBOMP_OMPT_SUPPORT})
|
|
say("LIBOMP: OMPT-blame -- ${LIBOMP_OMPT_BLAME}")
|
|
say("LIBOMP: OMPT-trace -- ${LIBOMP_OMPT_TRACE}")
|
|
endif()
|
|
say("LIBOMP: Use build.pl rules -- ${LIBOMP_USE_BUILDPL_RULES}")
|
|
say("LIBOMP: Adaptive locks -- ${LIBOMP_USE_ADAPTIVE_LOCKS}")
|
|
say("LIBOMP: Use predefined linker flags -- ${LIBOMP_USE_PREDEFINED_LINKER_FLAGS}")
|
|
say("LIBOMP: Compiler supports quad precision -- ${LIBOMP_COMPILER_SUPPORTS_QUAD_PRECISION}")
|
|
endif()
|
|
|
|
####################################################################
|
|
# Install rules
|
|
# We want to install libomp in DESTDIR/CMAKE_INSTALL_PREFIX/lib
|
|
# We want to install headers in DESTDIR/CMAKE_INSTALL_PREFIX/include
|
|
if(${LIBOMP_STANDALONE_BUILD})
|
|
set(LIBOMP_HEADERS_INSTALL_PATH include)
|
|
else()
|
|
string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION ${PACKAGE_VERSION})
|
|
set(LIBOMP_HEADERS_INSTALL_PATH lib${LIBOMP_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}/include)
|
|
endif()
|
|
if(${WINDOWS})
|
|
install(TARGETS omp RUNTIME DESTINATION bin)
|
|
if(NOT "${imp_file}" STREQUAL "")
|
|
install(TARGETS ompimp ARCHIVE DESTINATION lib${LIBOMP_LIBDIR_SUFFIX})
|
|
endif()
|
|
# Create aliases (regular copies) of the library for backwards compatibility
|
|
set(LIBOMP_ALIASES "libiomp5md")
|
|
foreach(alias IN LISTS LIBOMP_ALIASES)
|
|
install(CODE "execute_process(COMMAND \"\${CMAKE_COMMAND}\" -E copy \"${lib_file}\" \"${alias}${dll}\"
|
|
WORKING_DIRECTORY \${CMAKE_INSTALL_PREFIX}/bin)")
|
|
install(CODE "execute_process(COMMAND \"\${CMAKE_COMMAND}\" -E copy \"${imp_file}\" \"${alias}${lib}\"
|
|
WORKING_DIRECTORY \${CMAKE_INSTALL_PREFIX}/lib${LIBOMP_LIBDIR_SUFFIX})")
|
|
endforeach()
|
|
else()
|
|
install(TARGETS omp LIBRARY DESTINATION lib${LIBOMP_LIBDIR_SUFFIX})
|
|
# Create aliases (symlinks) of the library for backwards compatibility
|
|
set(LIBOMP_ALIASES "libgomp;libiomp5")
|
|
foreach(alias IN LISTS LIBOMP_ALIASES)
|
|
install(CODE "execute_process(COMMAND \"\${CMAKE_COMMAND}\" -E create_symlink \"${lib_file}\" \"${alias}${dll}\"
|
|
WORKING_DIRECTORY \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/lib${LIBOMP_LIBDIR_SUFFIX})")
|
|
endforeach()
|
|
endif()
|
|
install(
|
|
FILES
|
|
${build_dir}/omp.h
|
|
DESTINATION ${LIBOMP_HEADERS_INSTALL_PATH}
|
|
)
|
|
if(${LIBOMP_OMPT_SUPPORT})
|
|
install(FILES ${build_dir}/ompt.h DESTINATION ${LIBOMP_HEADERS_INSTALL_PATH})
|
|
endif()
|
|
|