# makefile.mk # # #//===----------------------------------------------------------------------===// #// #// 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. #// #//===----------------------------------------------------------------------===// # # Check and normalize LIBOMP_WORK. # This piece of code is common, but it cannot be moved to common file. ifeq "$(LIBOMP_WORK)" "" $(error LIBOMP_WORK environment variable must be set) endif ifneq "$(words $(LIBOMP_WORK))" "1" $(error LIBOMP_WORK must not contain spaces) endif override LIBOMP_WORK := $(subst \,/,$(LIBOMP_WORK)) ifeq "$(filter %/,$(LIBOMP_WORK))" "" override LIBOMP_WORK := $(LIBOMP_WORK)/ endif # Include definitions common for RTL and DSL. include $(LIBOMP_WORK)src/defs.mk src_dir = $(LIBOMP_WORK)src/ inc_dir = $(LIBOMP_WORK)src/include/$(OMP_VERSION)/ # -------------------------------------------------------------------------------------------------- # Configuration options. # -------------------------------------------------------------------------------------------------- # Build compiler BUILD_COMPILER := $(call check_variable,BUILD_COMPILER,icc gcc clang icl icl.exe) # Distribution type: com (commercial) or oss (open-source) DISTRIBUTION := $(call check_variable,DISTRIBUTION,com oss) ifeq "$(c)" "" c = $(BUILD_COMPILER) ifeq "$(os)" "win" c = icl.exe endif endif ifeq "$(dist)" "" dist = $(DISTRIBUTION) endif ifeq "$(dist)" "" dist = com endif # Compile all C files as C++ source. CPLUSPLUS := $(call check_variable,CPLUSPLUS,on) # Turn on instrumentation for code coverage. COVERAGE := $(call check_variable,COVERAGE,off on) # Instruct compiler to emit debug information. DEBUG_INFO := $(call check_variable,DEBUG_INFO,on off) # Turn on debug support in library code, assertions and traces. DIAG := $(call check_variable,DIAG,on off) LIB_TYPE := $(call check_variable,LIB_TYPE,norm prof stub) # Type of library: dynamic or static linking. LINK_TYPE := $(call check_variable,LINK_TYPE,dyna stat) # Supported OpenMP version, 2.5 or 3.0. OMP_VERSION := $(call check_variable,OMP_VERSION,40 30 25) # Generate optimized code. OPTIMIZATION := $(call check_variable,OPTIMIZATION,off on) # 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/ VPATH += $(inc_dir) VPATH += $(src_dir)thirdparty/ittnotify/ # Define config. define curr_config CPLUSPLUS=$(CPLUSPLUS) COVERAGE=$(COVERAGE) DEBUG_INFO=$(DEBUG_INFO) DIAG=$(DIAG) LIB_TYPE=$(LIB_TYPE) LINK_TYPE=$(LINK_TYPE) OMP_VERSION=$(OMP_VERSION) OPTIMIZATION=$(OPTIMIZATION) VERSION=$(VERSION) CPPFLAGS=$(subst $(space),_,$(CPPFLAGS)) CFLAGS=$(subst $(space),_,$(CFLAGS)) CXXFLAGS=$(subst $(space),_,$(CXXFLAGS)) FFLAGS=$(subst $(space),_,$(FFLAGS)) LDFLAGS=$(subst $(space),_,$(LDFLAGS)) endef # And check it. include $(tools_dir)src/common-checks.mk # Function to convert LIB_TYPE to printable one. legal_type = $(if $(filter norm,$(LIB_TYPE)),Performance,$(if $(filter prof,$(LIB_TYPE)),Profiling,Stub)) # Check the OS X version (we need it to decide which tool use for objects accumulation) ifeq "$(os)" "mac" mac_os_new := $(shell /bin/sh -c 'if [[ `sw_vers -productVersion` > 10.6 ]]; then echo "1"; else echo "0"; fi') endif # -------------------------------------------------------------------------------------------------- # Dev tools and general options (like -fpic, -O2 or -g). # -------------------------------------------------------------------------------------------------- include $(tools_dir)src/common-tools.mk # -------------------------------------------------------------------------------------------------- # Project-specific tools options. # -------------------------------------------------------------------------------------------------- # --- Assembler options --- ifeq "$(os)" "win" ifeq "$(arch)" "32" as-flags += -coff as-flags += -D_M_IA32 endif ifeq "$(arch)" "32e" as-flags += -D_M_AMD64 endif ifeq "$(arch)" "64" endif endif # --- C/C++ options --- # Enable _Quad type. ifneq "$(filter icc icl icl.exe,$(c))" "" c-flags += -Qoption,cpp,--extended_float_types cxx-flags += -Qoption,cpp,--extended_float_types endif ifeq "$(c)" "gcc" ifeq "$(arch)" "32" c-flags += -m32 -msse cxx-flags += -m32 -msse fort-flags += -m32 -msse ld-flags += -m32 -msse as-flags += -m32 -msse endif endif ifeq "$(c)" "clang" c-flags += -Wno-unused-value -Wno-switch -Wno-deprecated-register cxx-flags += -Wno-unused-value -Wno-switch -Wno-deprecated-register ifeq "$(arch)" "32" c-flags += -m32 -msse cxx-flags += -m32 -msse fort-flags += -m32 -msse ld-flags += -m32 -msse as-flags += -m32 -msse endif HAVE_QUAD = 0 endif ifeq "$(LINK_TYPE)" "dyna" # debug-info ifeq "$(os)" "win" c-flags += -Zi cxx-flags += -Zi fort-flags += -Zi else ifneq "$(os)" "mac" c-flags += -g cxx-flags += -g fort-flags += -g ld-flags += -g endif endif endif # Enable 80-bit "long double". # ??? In original makefile, it was enabled for all files on win_32 and win_64, and only for one # file kmp_atomic.c on win_32e. ifeq "$(os)" "win" c-flags += -Qlong_double cxx-flags += -Qlong_double endif # Enable saving compiler options and version in object files and libraries. ifeq "$(filter gcc clang,$(c))" "" ifeq "$(os)" "win" # Newer MS linker issues warnings if -Qsox is used: # "warning LNK4224: /COMMENT is no longer supported; ignored" # so let us comment it out (and delete later). # ifneq "$(arch)" "32e" # c-flags += -Qsox # cxx-flags += -Qsox # endif fort-flags += -Qsox else # For unknown reason, icc and ifort on mac does not accept this option. ifneq "$(filter lin,$(os))" "" c-flags += -sox cxx-flags += -sox fort-flags += -sox endif endif endif # On Linux and Windows Intel64 we need offload attribute for all Fortran entries # in order to support OpenMP function calls inside Device constructs ifeq "$(fort)" "ifort" ifeq "$(os)_$(arch)" "lin_32e" # TODO: change to -qoffload... when we stop supporting 14.0 compiler (-offload is deprecated) fort-flags += -offload-attribute-target=mic endif ifeq "$(os)_$(arch)" "win_32e" fort-flags += /Qoffload-attribute-target:mic endif endif ifeq "$(arch)" "mic" c-flags += -mmic cxx-flags += -mmic fort-flags += -mmic ld-flags += -mmic as-flags += -mmic cpp-flags += -mmic endif # Exception handling. ifeq "$(os)" "win" # ??? Enable exception handling? ifeq "$(LINK_TYPE)" "dyna" c-flags += -EHsc cxx-flags += -EHsc endif else # Disable exception handling. c-flags += -fno-exceptions cxx-flags += -fno-exceptions endif # Disable use of EBP as general purpose register. ifeq "$(os)" "win" ifeq "$(arch)" "32" c-flags += -Oy- cxx-flags += -Oy- endif endif ifeq "$(os)" "lin" ifneq "$(arch)" "mic" c-flags += -Wsign-compare cxx-flags += -Wsign-compare ld-flags += -Wsign-compare ifeq "$(filter gcc clang,$(c))" "" c-flags += -Werror cxx-flags += -Werror ld-flags += -Werror endif endif endif ifeq "$(os)" "win" c-flags += -WX cxx-flags += -WX ld-flags += -WX:NO endif ifeq "$(arch)" "mic" # With "-ftls-model=initial-exec" the compiler generates faster code for static TLS # accesses, it generates slower calls to glibc otherwise. We don't use this # feature on Linux because it prevents dynamic loading (use of dlopen) of the library. # Reliable dynamic loading is more important than slightly faster access to TLS. # On Intel(R) Xeon Phi(TM) coprocessor we haven't encountered dynamic loading problem yet, so use faster # access to static TLS. c-flags += -ftls-model=initial-exec cxx-flags += -ftls-model=initial-exec # disable streaming stores in order to work on A0 Si c-flags += -opt-streaming-stores never cxx-flags += -opt-streaming-stores never endif # Select C runtime. ifeq "$(os)" "win" # Regardless of following -Zl option, we should specify -MT or -MTd, otherwise test-touch # wil fails due to unresolved reference "_errno". ifeq "$(OPTIMIZATION)" "on" c-flags += -MT cxx-flags += -MT else c-flags += -MTd cxx-flags += -MTd endif ifeq "$(LINK_TYPE)" "stat" # Do not emit C runtime library to object file. It will allows link OpenMP RTL with either static # or dynamic C runtime. Windows* OS specific, applicable only to static RTL. c-flags += -Zl cxx-flags += -Zl endif endif ifeq "$(os)" "win" c-flags += -W3 cxx-flags += -W3 # Disable warning: "... declared but never referenced" # Disable remark #5082: Directive ignored - Syntax error, found IDENTIFIER 'LRB'... fort-flags += -Qdiag-disable:177,5082 c-flags += -Qdiag-disable:177 cxx-flags += -Qdiag-disable:177 endif ifeq "$(CPLUSPLUS)" "on" ifeq "$(os)" "win" c-flags += -TP else ifeq "$(arch)" "ppc64" # c++11 on ppc64 linux removes definition of preproc. macros, needed in .hs c-flags += -x c++ -std=gnu++11 else ifneq "$(filter gcc clang,$(c))" "" c-flags += -x c++ -std=c++11 else c-flags += -Kc++ endif endif endif # --- Linker options --- ifeq "$(os)" "lin" ifneq "$(arch)" "mic" ifneq "$(LIB_TYPE)" "stub" ifeq "$(ld)" "ld" # Warn about non-PIC code presence ld-flags += --warn-shared-textrel ld-flags += -fini=__kmp_internal_end_fini ld-flags += -lpthread else # $(c) or $(cxx) ld-flags += -Wl,--warn-shared-textrel ld-flags += -Wl,-fini=__kmp_internal_end_fini ld-flags += -pthread endif endif ifeq "$(ld)" "$(c)" ld-flags += -fPIC ifeq "$(DEBUG_INFO)" "on" ld-flags += -g endif ifeq "$(OPTIMIZATION)" "off" ld-flags += -O0 endif ld-flags += -Wl,--version-script=$(src_dir)exports_so.txt else ld-flags += --version-script=$(src_dir)exports_so.txt endif ifeq "$(ld)" "$(c)" # to remove dependency on libimf, libsvml, libintlc: ifeq "$(c)" "icc" ld-flags-dll += -static-intel endif ld-flags-dll += -Wl,--as-needed # to remove dependency on libgcc_s: ifeq "$(c)" "gcc" ld-flags-dll += -static-libgcc # omp_os is non-empty only in the open-source code ifneq "$(omp_os)" "freebsd" ld-flags-extra += -Wl,-ldl endif endif ifeq "$(c)" "clang" ifneq "$(omp_os)" "freebsd" ld-flags-extra += -Wl,-ldl endif endif ifeq "$(arch)" "32" ifeq "$(filter gcc clang,$(c))" "" # to workaround CQ215229 link libirc_pic manually ld-flags-extra += -lirc_pic endif endif ifeq "$(filter 32 32e 64 ppc64 ppc64le,$(arch))" "" ld-flags-extra += $(shell pkg-config --libs libffi) endif else ifeq "$(arch)" "32e" # ??? ld-flags += -Bstatic -L/usr/lib64 -lc_nonshared -Bdynamic endif endif else # Below are Intel(R) Many Integrated Core Architecture linker flags ifeq "$(ld)" "ld" ifneq "$(LIB_TYPE)" "stub" ld-flags += -lthr ld-flags += -fini=__kmp_internal_end_atexit # Warn about non-PIC code presence ld-flags += --warn-shared-textrel endif ld-flags += --version-script=$(src_dir)exports_so.txt endif ifeq "$(ld)" "$(c)" ld-flags += -Wl,--warn-shared-textrel ld-flags += -Wl,--version-script=$(src_dir)exports_so.txt ld-flags += -static-intel # Don't link libcilk*. ld-flags += -no-intel-extensions # Discard unneeded dependencies. ld-flags += -Wl,--as-needed # ld-flags += -nodefaultlibs # To check which libraries the compiler links comment above line and uncomment below line # ld-flags += -\# # link libraries in the order the icc compiler uses (obtained using "icc -shared -#" command line) # Compiler 20101017 uses "-lintlc -lthr -lc -lintlc -lirc_s" sequence, we follow it: # ld-flags += -lintlc ifneq "$(LIB_TYPE)" "stub" ld-flags += -pthread ld-flags += -ldl endif # include the c++ library for stats-gathering code ifeq "$(stats)" "on" ld-flags-extra += -Wl,-lstdc++ endif endif endif endif ifeq "$(os)" "mac" ifeq "$(ld)" "icc" ld-flags += -no-intel-extensions endif ld-flags += -single_module ld-flags += -current_version $(VERSION).0 -compatibility_version $(VERSION).0 endif ifeq "$(os)" "win" ld-flags += -incremental:no ld-flags += -version:$(VERSION).0 endif # -------------------------------------------------------------------------------------------------- # Project-specific preprocessor definitions. # -------------------------------------------------------------------------------------------------- cpp-flags += -D KMP_ARCH_STR="\"$(call legal_arch,$(arch))\"" ifeq "$(os)" "win" cpp-flags += -D _WINDOWS -D _WINNT -D _WIN32_WINNT=0x0501 # 0x0501 means Windows* XP* OS or Windows* Server 2003* OS or later. # We need this for GetModuleHanleEx function. ifeq "$(LINK_TYPE)" "dyna" cpp-flags += -D _USRDLL endif else # lin, mic or mac cpp-flags += -D _GNU_SOURCE cpp-flags += -D _REENTRANT endif # TODO: DIAG leads to DEBUG. Confusing a bit. Raname KMP_DEBUG to KMP_DIAG? ifeq "$(DIAG)" "on" cpp-flags += -D KMP_DEBUG endif ifeq "$(COVERAGE)" "on" cpp-flags += -D COVER endif # Assertions in OMP RTL code are controlled by two macros: KMP_DEBUG enables or disables assertions # iff KMP_USE_ASSERT is defined. If KMP_USE_ASSERT is not defined, assertions disabled regardless of # KMP_DEBUG. It was implemented for code coverage -- to have debug build with no assertion, but it # does not have much effect. TODO: Remove macro. ifeq "$(COVERAGE)" "off" cpp-flags += -D KMP_USE_ASSERT endif cpp-flags += -D BUILD_I8 ifneq "$(os)" "win" cpp-flags += -D BUILD_TV endif cpp-flags += -D KMP_LIBRARY_FILE=\"$(lib_file)\" cpp-flags += -D KMP_VERSION_MAJOR=$(VERSION) # Customize ppc64 and aarch64 cache line size to 128, use 64 otherwise # Almost all data structures (kmp.h) are aligned to a cache line to reduce false sharing, thus # increasing performance. For heavily accessed data structures (e.g., kmp_base_info), there are # members of the data structure that are grouped together according to their memory access # pattern. For example, readonly data is put on cache lines together. Then, on separate cachelines, # private data used by the working thread is put on its own cache lines. etc. ifneq "$(filter aarch64 ppc64 ppc64le,$(arch))" "" cpp-flags += -D CACHE_LINE=128 else cpp-flags += -D CACHE_LINE=64 endif cpp-flags += -D KMP_ADJUST_BLOCKTIME=1 cpp-flags += -D BUILD_PARALLEL_ORDERED cpp-flags += -D KMP_ASM_INTRINS cpp-flags += -D KMP_USE_INTERNODE_ALIGNMENT=0 # Linux and MIC compile with version symbols # ppc64 and ppc64le architectures don't compile with version symbols ifneq "$(filter lin,$(os))" "" ifeq "$(filter ppc64 ppc64le,$(arch))" "" cpp-flags += -D KMP_USE_VERSION_SYMBOLS endif endif ifneq "$(arch)" "mic" cpp-flags += -D USE_LOAD_BALANCE endif ifneq "$(os)" "win" cpp-flags += -D USE_CBLKDATA # ??? Windows* OS: USE_CBLKDATA defined in kmp.h. endif ifeq "$(os)" "win" cpp-flags += -D KMP_WIN_CDECL endif ifeq "$(LINK_TYPE)" "dyna" cpp-flags += -D GUIDEDLL_EXPORTS endif ifeq "$(LIB_TYPE)" "stub" cpp-flags += -D KMP_STUB endif ifeq "$(VERSION)" "4" else # 5 ifeq "$(os)" "win" else cpp-flags += -D KMP_GOMP_COMPAT endif endif cpp-flags += -D KMP_NESTED_HOT_TEAMS ifneq "$(filter 32 32e mic,$(arch))" "" cpp-flags += -D KMP_USE_ADAPTIVE_LOCKS=1 -D KMP_DEBUG_ADAPTIVE_LOCKS=0 endif # is the std c++ library needed? (for stats-gathering, it is) std_cpp_lib=0 ifneq "$(filter lin,$(os))" "" ifeq "$(stats)" "on" cpp-flags += -D KMP_STATS_ENABLED=1 std_cpp_lib=1 else cpp-flags += -D KMP_STATS_ENABLED=0 endif else # no mac or windows support for stats-gathering ifeq "$(stats)" "on" $(error Statistics-gathering functionality not available on $(os) platform) endif cpp-flags += -D KMP_STATS_ENABLED=0 endif # define compatibility with different OpenMP versions have_omp_50=0 have_omp_41=0 have_omp_40=0 ifeq "$(OMP_VERSION)" "50" have_omp_50=1 have_omp_41=1 have_omp_40=1 endif ifeq "$(OMP_VERSION)" "41" have_omp_50=0 have_omp_41=1 have_omp_40=1 endif ifeq "$(OMP_VERSION)" "40" have_omp_50=0 have_omp_41=0 have_omp_40=1 endif ifeq "$(OMP_VERSION)" "30" have_omp_50=0 have_omp_41=0 have_omp_40=0 endif cpp-flags += -D OMP_50_ENABLED=$(have_omp_50) -D OMP_41_ENABLED=$(have_omp_41) -D OMP_40_ENABLED=$(have_omp_40) # Using ittnotify is enabled by default. USE_ITT_NOTIFY = 1 ifeq "$(os)-$(arch)" "win-64" USE_ITT_NOTIFY = 0 endif ifeq "$(LINK_TYPE)" "stat" USE_ITT_NOTIFY = 0 endif cpp-flags += -D USE_ITT_NOTIFY=$(USE_ITT_NOTIFY) ifeq "$(USE_ITT_NOTIFY)" "0" # Disable all ittnotify calls. cpp-flags += -D INTEL_NO_ITTNOTIFY_API else ifeq "$(os)" "win" ittnotify_static$(obj) : cpp-flags += -D UNICODE endif endif # Specify prefix to be used for external symbols. Prefix is required even if ITT Nofity turned off # because we have some functions with __itt_ prefix (__itt_error_handler) and want prefix to be # changed to __kmp_itt_. cpp-flags += -D INTEL_ITTNOTIFY_PREFIX=__kmp_itt_ # Linux* OS: __declspec(thread) TLS is still buggy on static builds. # Windows* OS: This define causes problems with LoadLibrary + declspec(thread) on Windows* OS. See CQ50564, # tests kmp_load_library_lib*.c, and the following MSDN reference: # http://support.microsoft.com/kb/118816 ifneq "$(filter lin ,$(os))" "" ifeq "$(LINK_TYPE)" "dyna" cpp-flags += -D KMP_TDATA_GTID else # AC: allow __thread in static build for Intel(R) 64, looks like it is # working there. It is broken on IA-32 architecture for RHEL4 and SLES9. ifeq "$(arch)" "32e" cpp-flags += -D KMP_TDATA_GTID endif endif endif # Intel compiler has a bug: in case of cross-build if used with # -x assembler-with-cpp option, it defines macros for both architectures, # host and tartget. For example, if compiler for IA-32 architecture # runs on Intel(R) 64, it defines both __i386 and __x86_64. (Note it is a bug # only if -x assembler-with-cpp is specified, in case of C files icc defines # only one, target architecture). So we cannot autodetect target architecture # within the file, and have to pass target architecture from command line. ifneq "$(os)" "win" ifeq "$(arch)" "arm" z_Linux_asm$(obj) : \ cpp-flags += -D KMP_ARCH_ARM else ifneq "$(filter ppc64 ppc64le,$(arch))" "" z_Linux_asm$(obj) : \ cpp-flags += -D KMP_ARCH_PPC64 else ifeq "$(arch)" "aarch64" z_Linux_asm$(obj) : \ cpp-flags += -D KMP_ARCH_AARCH64 else z_Linux_asm$(obj) : \ cpp-flags += -D KMP_ARCH_X86$(if $(filter 32e mic,$(arch)),_64) endif endif # Defining KMP_BUILD_DATE for all files leads to warning "incompatible redefinition", because the # same macro is also defined in omp.h. To avoid conflict, let us define macro with different name, # _KMP_BUILD_TIME. kmp_version$(obj) : cpp-flags += -D _KMP_BUILD_TIME="\"$(date)\"" # --- Macros for generate-def.pl --- 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 ifeq "$(OMP_VERSION)" "30" gd-flags += -D OMP_30 endif endif ifneq "$(VERSION)" "4" gd-flags += -D msvc_compat endif ifeq "$(DIAG)" "on" gd-flags += -D KMP_DEBUG endif # --- Macro for expand-vars.pl --- # $Revision and $Date often occur in file header, so define these variables to satisfy expand-vars.pl. ev-flags += -D Revision="\$$Revision" -D Date="\$$Date" # Various variables. ev-flags += -D KMP_TYPE="$(call legal_type,$(LIB_TYPE))" -D KMP_ARCH="$(call legal_arch,$(arch))" ev-flags += -D KMP_VERSION_MAJOR=$(VERSION) -D KMP_VERSION_MINOR=0 -D KMP_VERSION_BUILD=$(build) ev-flags += -D KMP_BUILD_DATE="$(date)" ev-flags += -D KMP_DIAG=$(if $(filter on,$(DIAG)),1,0) ev-flags += -D KMP_DEBUG_INFO=$(if $(filter on,$(DEBUG_INFO)),1,0) ifeq "$(OMP_VERSION)" "40" ev-flags += -D OMP_VERSION=201307 else ifeq "$(OMP_VERSION)" "30" ev-flags += -D OMP_VERSION=201107 else ev-flags += -D OMP_VERSION=200505 endif endif # -- Options specified in command line --- cpp-flags += $(CPPFLAGS) c-flags += $(CFLAGS) cxx-flags += $(CXXFLAGS) fort-flags += $(FFLAGS) ld-flags += $(LDFLAGS) # -------------------------------------------------------------------------------------------------- # Files. # -------------------------------------------------------------------------------------------------- # Library files. These files participate in all kinds of library. lib_c_items := \ kmp_ftn_cdecl \ kmp_ftn_extra \ kmp_version \ $(empty) lib_cpp_items := lib_asm_items := # Files to be linked into import library. imp_c_items := do_test_touch_mt := 1 ifeq "$(LIB_TYPE)" "stub" lib_c_items += kmp_stub else # norm or prof lib_c_items += \ kmp_alloc \ kmp_atomic \ kmp_csupport \ kmp_debug \ kmp_itt \ $(empty) ifeq "$(USE_ITT_NOTIFY)" "1" lib_c_items += ittnotify_static endif lib_cpp_items += \ kmp_environment \ kmp_error \ kmp_global \ kmp_i18n \ kmp_io \ kmp_runtime \ kmp_wait_release \ kmp_barrier \ kmp_settings \ kmp_str \ kmp_tasking \ kmp_taskq \ kmp_threadprivate \ kmp_utility \ kmp_affinity \ kmp_dispatch \ kmp_lock \ kmp_sched \ $(empty) ifeq "$(OMP_VERSION)" "40" lib_cpp_items += kmp_taskdeps lib_cpp_items += kmp_cancel endif ifeq "$(stats)" "on" lib_cpp_items += kmp_stats lib_cpp_items += kmp_stats_timing endif # OS-specific files. ifeq "$(os)" "win" lib_c_items += z_Windows_NT_util # Arch-specific files. lib_c_items += z_Windows_NT-586_util lib_asm_items += z_Windows_NT-586_asm ifeq "$(LINK_TYPE)" "dyna" imp_c_items += kmp_import # for win_32/win_32e dynamic libguide40.dll, # build the shim lib instead ifeq "$(VERSION)" "4" ifneq "$(arch)" "64" ifeq "$(LIB_TYPE)" "norm" lib_c_items = kmp_shim lib_cpp_items = lib_asm_items = gd-flags += -D shim # for some reason, test-touch-md is able to work with # the build compiler's version of libiomp5md.dll, but # test-touch-mt can't load it. do_test_touch_mt := 0 endif endif endif endif else # lin, mic or mac lib_c_items += z_Linux_util # GCC Compatibility files ifeq "$(VERSION)" "4" else # 5 lib_c_items += kmp_gsupport endif lib_asm_items += z_Linux_asm endif endif lib_obj_files := $(sort $(addsuffix $(obj),$(lib_c_items) $(lib_cpp_items) $(lib_asm_items))) imp_obj_files := $(sort $(addsuffix $(obj),$(imp_c_items) $(imp_cpp_items) $(imp_asm_items))) dep_files := $(sort $(addsuffix .d,$(lib_c_items) $(lib_cpp_items) $(imp_c_items) $(imp_cpp_items))) i_files := $(sort $(addsuffix .i,$(lib_c_items) $(lib_cpp_items) $(imp_c_items) $(imp_cpp_items))) # --- Construct library file name --- ifeq "$(VERSION)" "4" ifeq "$(LIB_TYPE)" "stub" _lib_item = libompstub else # norm or prof _lib_item = libguide endif ifeq "$(os)-$(LINK_TYPE)" "win-dyna" _lib_item += 40 endif ifeq "$(LIB_TYPE)" "prof" _lib_item += _stats endif else _lib_item = libiomp ifeq "$(LIB_TYPE)" "prof" _lib_item += prof endif ifeq "$(LIB_TYPE)" "stub" _lib_item += stubs endif _lib_item += $(VERSION) ifeq "$(os)" "win" ifeq "$(LINK_TYPE)" "dyna" _lib_item += md else _lib_item += mt endif endif endif # _lib_item is a list of space separated name parts. Remove spaces to form final name. lib_item = $(subst $(space),,$(_lib_item)) ifeq "$(LINK_TYPE)" "dyna" lib_ext = $(dll) else lib_ext = $(lib) endif lib_file = $(lib_item)$(lib_ext) ifeq "$(os)-$(LINK_TYPE)" "win-dyna" imp_file = $(lib_item)$(lib) def_file = $(lib_item).def res_file = $(lib_item).res rc_file = $(lib_item).rc # PDB file should be generated if: ( DEBIG_INFO is on ) OR ( we are building 32-bit normal # library AND version is 5 ). ifneq "$(filter on,$(DEBUG_INFO))$(filter norm-5,$(LIB_TYPE)-$(VERSION))" "" pdb_file = $(lib_item).pdb endif endif ifneq "$(filter lin,$(os))" "" ifeq "$(LINK_TYPE)" "dyna" ifneq "$(DEBUG_INFO)" "on" dbg_file = $(lib_item).dbg endif else dbg_strip = "on" endif endif # --- Output files --- out_lib_files = $(addprefix $(out_lib_dir),$(lib_file) $(imp_file) $(pdb_file) $(dbg_file)) out_inc_files = $(addprefix $(out_ptf_dir)include_compat/,iomp_lib.h) out_mod_files = \ $(addprefix $(out_ptf_dir)include/,omp_lib.mod omp_lib_kinds.mod) out_cmn_files = \ $(addprefix $(out_cmn_dir)include/,omp.h omp_lib.h omp_lib.f omp_lib.f90) \ $(addprefix $(out_cmn_dir)include_compat/,iomp.h) ifneq "$(out_lib_fat_dir)" "" out_lib_fat_files = $(addprefix $(out_lib_fat_dir),$(lib_file) $(imp_file)) endif # --- Special dependencies --- # We have to encode dependencies on omp.h manually, because automatic dependency generation # by compiler produces depedency on omp.h file located in compiler include directory. kmp_csupport$(obj) : omp.h kmp_stub$(obj) : omp.h # -------------------------------------------------------------------------------------------------- # External libraries to link in. # -------------------------------------------------------------------------------------------------- # We (actually, our customers) do no want OpenMP RTL depends on external libraries, so we have to # pick up some object files from libirc library (Intel compiler generate code with calls to libirc) # and link them into OMP RTL. # libipgo is required only for collecting code coverage data, but is is convenient to link in into # OMP RTL as well, not to depend on extra libs and paths. # libirc does matter only if Intel compiler is used. ifneq "$(filter icc icl icl.exe,$(c))" "" ifneq "$(ICC_LIB_DIR)" "" icc_lib_dir := $(ICC_LIB_DIR) else # # Let us find path to Intel libraries first. (don't use tabs in these lines!) # icc_path := $(shell which $(c)) $(call debug,icc_path) ifeq "$(words $(icc_path))" "0" $(error Path to "$(c)" not found, reported path: $(icc_path)) endif ifneq "$(words $(icc_path))" "1" $(error Path to "$(c)" contains spaces: "$(icc_path)") endif ifeq "$(os)" "win" # Windows* OS specific. # `which' can return path with backslashes. Convert them. icc_path := $(subst \,/,$(icc_path)) # icc's "bin/" directory may be named as "Bin/" or even "BIN/". Convert it to lower case. icc_path := $(subst B,b,$(icc_path)) icc_path := $(subst I,i,$(icc_path)) icc_path := $(subst N,n,$(icc_path)) $(call debug,icc_path) endif # icc 10.x directory layout: # bin/ # lib/ # icc 11.x directory layout: # bin/{ia32,intel64}/ # lib/{ia32,intel64}/ # icc 12.x directory layout: # bin/{ia32,intel64}/ # compiler/lib/{ia32,intel64}/ # Note: On OS X* fat libraries reside in lib/ directory. On other systems libraries are in # lib//. icc_path_up1 := $(dir $(icc_path)) icc_path_up2 := $(dir $(patsubst %/,%,$(icc_path_up1))) $(call debug,icc_path_up1) $(call debug,icc_path_up2) ifneq "$(filter %/bin/,$(icc_path_up1))" "" # Look like 10.x compiler. icc_lib_dir := $(patsubst %/bin/,%/lib/,$(icc_path_up1)) else ifneq "$(filter %/bin/,$(icc_path_up2))" "" # It looks like 11.x or later compiler. ifeq "$(os)" "mac" icc_lib12 := $(patsubst %/bin/,%/compiler/lib/,$(icc_path_up2)) ifneq "$(wildcard $(icc_lib12)libirc*$(lib))" "" # 12.x icc_lib_dir := $(icc_lib12) else # 11.x icc_lib_dir := $(patsubst %/bin/,%/lib/,$(icc_path_up2)) endif else icc_lib12 := $(patsubst %/bin/,%/compiler/lib/,$(icc_path_up2))$(notdir $(patsubst %/,%,$(icc_path_up1)))/ ifneq "$(wildcard $(icc_lib12)libirc*$(lib))" "" # 12.x icc_lib_dir := $(icc_lib12) else # 11.x icc_lib_dir := $(patsubst %/bin/,%/lib/,$(icc_path_up2))$(notdir $(patsubst %/,%,$(icc_path_up1)))/ endif endif endif endif $(call debug,icc_lib_dir) ifeq "$(icc_lib_dir)" "" $(error Path to $(c) lib/ dir not found) endif endif # # Then select proper libraries. # ifeq "$(os)" "win" libirc = $(icc_lib_dir)\libircmt$(lib) libipgo = $(icc_lib_dir)\libipgo$(lib) else # lin, mic or mac ifeq "$(LINK_TYPE)" "dyna" # In case of dynamic linking, prefer libi*_pic.a libraries, they contains # position-independent code. libirc = $(icc_lib_dir)libirc_pic$(lib) libipgo = $(icc_lib_dir)libipgo_pic$(lib) # If libi*_pic.a is not found (it is missed in older compilers), use libi*.a. ifeq "$(wildcard $(libirc))" "" libirc = $(icc_lib_dir)libirc$(lib) endif ifeq "$(wildcard $(libipgo))" "" libipgo = $(icc_lib_dir)libipgo$(lib) endif else libirc = $(icc_lib_dir)libirc$(lib) libipgo = $(icc_lib_dir)libipgo$(lib) endif endif # Ok, now let us decide when linked # Linux* OS: # We link in libraries to static library only. ifeq "$(os)-$(LINK_TYPE)" "lin-stat" ifneq "$(arch)" "mic" linked_in_libs += libirc endif endif # OS X*: # The trick is not required in case of dynamic library, but on Intel(R) 64 architecture we have a # problem: libirc.a is a fat, so linker (libtool) produces fat libguide.dylib... :-( (Only # functions from libirc are presented for both architectures, libguide functions are for Intel(R) 64 # only.) To avoid this undesired effect, libirc trick is enabled for both static and dynamic # builds. Probably we can instruct libtool to produce "thin" (not fat) library by using # -arch_only option... ifeq "$(os)" "mac" linked_in_libs += libirc endif # Windows* OS: # The trick is required only in case of static OMP RTL. In case of dynamic OMP RTL linker does # the job. ifeq "$(os)-$(LINK_TYPE)" "win-stat" linked_in_libs += libirc endif ifeq "$(COVERAGE)" "on" linked_in_libs += libipgo endif endif # -------------------------------------------------------------------------------------------------- # Main targets. # -------------------------------------------------------------------------------------------------- all : lib inc mod lib : tests $(out_lib_files) inc : $(out_inc_files) mod : $(out_mod_files) clean : $(rm) $(out_lib_files) $(out_lib_fat_files) $(rm) $(out_inc_files) $(out_mod_files) # -------------------------------------------------------------------------------------------------- # Building library. # -------------------------------------------------------------------------------------------------- $(lib_file) : $(if $(dbg_file),stripped,unstripped)/$(lib_file) $(target) $(cp) $< $@ ifneq "$(dbg_file)" "" $(dbg_file) : unstripped/$(dbg_file) $(target) $(cp) $< $@ endif ifneq "$(filter lin,$(os))" "" lib_file_deps = $(if $(linked_in_libs),required/.objs,$(lib_obj_files)) endif ifeq "$(os)" "mac" lib_file_deps = iomp$(obj) endif ifeq "$(os)" "win" lib_file_deps = $(if $(linked_in_libs),wiped/.objs,$(lib_obj_files)) endif # obj_dep_files -- object files, explicitly specified in dependency list. Other files (non-object) # are filtered out. obj_deps_files = $(filter %$(obj),$^) # obj_deps_flags -- object files corresponding to flags, specified in dependency list. Flag is a # special file like "required/.objs". Flag file is replaced with a list of all object files in flag # directory, for example, "required/*.o" obj_deps_flags = $(addsuffix *$(obj),$(dir $(filter %/.objs,$^))) # obj_deps_all -- list of all object files specified in dependency list, either explicit or found # in flagged directories. obj_deps_all = $(obj_deps_files) $(obj_deps_flags) unstripped/$(lib_file).lst : $(lib_file_deps) unstripped/.dir .rebuild $(target) echo $(obj_deps_all) > $@ ifeq "$(os)-$(LINK_TYPE)" "lin-dyna" $(lib_file) : exports_so.txt endif # Copy object files, wiping out references to libirc library. Object files (ours and extracted # from libirc.lib) have "-defaultlib:libirc.lib" linker directive, so linker will require libirc.lib # regardless of absence of real dependency. Actually, this rule is required only on Windows* OS, but # there is no Windows* OS-specific commands, so I omit conditions to keep code shorter and be able test # the rule on Linux* OS. # Note: If we are not going to pick up objects from libirc, there is no point in wiping out # libirc references. # Addition: Wipe also references to C++ runtime (libcpmt.lib) for the same reason: sometimes C++ # runtime routines are not actually used, but compiler puts "-defaultlib:libcpmt.lib" directive to # object file. Wipe it out, if we have real dependency on C++ runtime, test-touch will fail. wiped/.objs : required/.objs \ $(tools_dir)wipe-string.pl wiped/.dir .rebuild $(target) $(rm) $(dir $@)*$(obj) ifeq "$(os)" "win" $(perl) $(tools_dir)wipe-string.pl --quiet \ --wipe-regexp="(-|/)(defaultlib|DEFAULTLIB):\"(libir|libc|LIBC|OLDN|libmm|libde|svml).*?\"" \ --target-directory=$(dir $@) $(obj_deps_all) else $(perl) $(tools_dir)wipe-string.pl --quiet \ --wipe-regexp="(-|/)(defaultlib|DEFAULTLIB):\"(libir|libc|LIBC|OLDN).*?\"" \ --target-directory=$(dir $@) $(obj_deps_all) endif $(touch) $@ # required-objects.pl uses "objcopy" utility to rename symbols in object files. On Linux* OS this is a # standard utility (from binutils package). On Windows* OS we provides homebrew implementation (very # limited, but enough for our purposes). ifeq "$(os)" "win" objcopy = objcopy$(exe) endif # required/ is a directory containing OMP RTL object files and really required files from external # libraries. required/.obj is a flag. If this file present, it means all required objects already # in place. Note, required-objects.pl copies files to specified directory. It is necessary, because # object files are edited during copying -- symbols defined in external object files are renamed. required/.objs : $(lib_obj_files) $(addsuffix /.objs,$(linked_in_libs)) \ $(tools_dir)required-objects.pl $(objcopy) required/.dir .rebuild $(target) $(rm) $(dir $@)*$(obj) $(perl) $(tools_dir)required-objects.pl --quiet $(oa-opts) --prefix=__kmp_external_ \ --base $(obj_deps_files) --extra $(obj_deps_flags) --copy-all=$(dir $@) $(touch) $@ # Extracting object files from libirc. File "libirc/.obj" is a flag. If the file present, make # thinks files are extracted. ifneq "$(libirc)" "" libirc/.objs : $(libirc) \ $(tools_dir)extract-objects.pl libirc/.dir .rebuild $(target) $(rm) $(dir $@)*$(obj) $(perl) $(tools_dir)extract-objects.pl --quiet $(oa-opts) --output=$(dir $@) $< $(touch) $@ endif # Extracting object files from libipgo. File "/libipgo/.obj" is a flag. If the file present, make # thinks objects are extracted. ifneq "$(libipgo)" "" libipgo/.objs : $(libipgo) \ $(tools_dir)extract-objects.pl libipgo/.dir .rebuild $(target) $(rm) $(dir $@)*$(obj) $(perl) $(tools_dir)extract-objects.pl --quiet $(oa-opts) --output=$(dir $@) $< $(touch) $@ endif stripped/$(lib_file) : unstripped/$(lib_file) $(dbg_file) stripped/.dir .rebuild $(target) ifeq "$(arch)" "mic" x86_64-k1om-linux-objcopy --strip-debug $< $@.tmp x86_64-k1om-linux-objcopy --add-gnu-debuglink=$(dbg_file) $@.tmp $@ else objcopy --strip-debug $< $@.tmp objcopy --add-gnu-debuglink=$(dbg_file) $@.tmp $@ endif ifeq "$(os)" "mac" # These targets are under condition because of some OS X*-specific ld and nm options. For # example, GNU nm does not accept -j, GNU ld does not know -filelist. # iomp.o is a big object file including all the OMP RTL object files and object files from # external libraries (like libirc). It is partially linked, references to external symbols # (e. g. references to libirc) already resolved, symbols defined in external libraries are # hidden by using -unexported-symbol-list and -non_global_symbols_strip_list linker options # (both options are required). # AC: 2012-04-12: after MAC machines upgrade compiler fails to create object, so use linker instead ifeq "$(mac_os_new)" "1" iomp$(obj) : $(lib_obj_files) external-symbols.lst external-objects.lst .rebuild $(target) ld -r -unexported_symbols_list external-symbols.lst \ -non_global_symbols_strip_list external-symbols.lst \ -filelist external-objects.lst \ -o $@ $(obj_deps_files) else iomp$(obj) : $(lib_obj_files) external-symbols.lst external-objects.lst .rebuild $(target) $(c) -r -nostartfiles -static-intel -no-intel-extensions \ -Wl,-unexported_symbols_list,external-symbols.lst \ -Wl,-non_global_symbols_strip_list,external-symbols.lst \ -filelist external-objects.lst \ -o $@ $(obj_deps_files) endif # external-objects.lst is a list of object files extracted from external libraries, which should # be linked into iomp.o. kmp_dummy.o is added to the list to avoid empty list -- OS X* utilities # nm and ld do not like empty lists. external-objects.lst : $(lib_obj_files) $(addsuffix /.objs,$(linked_in_libs)) kmp_dummy$(obj) \ $(tools_dir)required-objects.pl .rebuild $(target) $(perl) $(tools_dir)required-objects.pl $(oa-opts) \ --base $(obj_deps_files) --extra $(obj_deps_flags) --print-extra > $@.tmp echo "kmp_dummy$(obj)" >> $@.tmp mv $@.tmp $@ # Prepare list of symbols in external object files. We will hide all these symbols. # Note: -j is non-GNU option which means "Just display the symbol names (no value or type)." external-symbols.lst : external-objects.lst .rebuild $(target) nm -goj $$(cat external-objects.lst) > $@.0.tmp cut -f2 -d" " $@.0.tmp > $@.1.tmp mv $@.1.tmp $@ endif # mac # Import library tricks are Windows* OS-specific. ifeq "$(os)" "win" import$(lib) : $(lib_item)$(dll) # Change the name of import library produced by the linker, we will combine it with some more # object files to produce "extended import lib". $(lib_item)$(dll) : imp_file := import$(lib) # Default rule "c to obj" will compile sources with -MT option, which is not desired. # Cancel effect of -MT with -Zl. # AC: Currently we only have one object that does not need any special # compiler options, so use minimal set. With standard set of options we used # there were problems with debug info leaked into the import library # with this object (bug report #334565). $(imp_obj_files) : c-flags := -Zl -nologo -c $(imp_file).lst : $(imp_obj_files) import$(lib) .rebuild $(target) echo $(filter-out .rebuild,$^) > $@ endif kmp_i18n_id.inc : en_US.txt \ $(tools_dir)message-converter.pl .rebuild $(target) $(perl) $(tools_dir)message-converter.pl $(oa-opts) --prefix=kmp_i18n --enum=$@ $< kmp_i18n_default.inc : en_US.txt \ $(tools_dir)message-converter.pl .rebuild $(target) $(perl) $(tools_dir)message-converter.pl $(oa-opts) --prefix=kmp_i18n --default=$@ $< # Rebuilt kmp_version.o on any change to have actual build time string always updated. kmp_version$(obj): $(filter-out kmp_version$(obj),$(lib_obj_files) $(imp_obj_files)) $(def_file) : dllexports \ $(tools_dir)generate-def.pl .rebuild $(target) $(perl) $(tools_dir)generate-def.pl $(gd-flags) -o $@ $< libiomp.rc : libiomp.rc.var kmp_version.c libiomp.rc : ev-flags += -D KMP_FILE=$(lib_file) $(rc_file) : libiomp.rc .rebuild $(target) $(cp) $< $@ kmp_dummy.c : .rebuild $(target) echo "void __kmp_dummy() {}" > $@ # -------------------------------------------------------------------------------------------------- # Tests. # -------------------------------------------------------------------------------------------------- # --- test-touch --- # test-touch is not available for mic. ifneq "$(arch)" "mic" # Compile a simple C test and link it with the library. Do it two times: the first link gives us # clear message if there are any problems, the second link run in verbose mode, linker output # searched for "libirc" string -- should not be any libirc references. Finally, test executable # run with KMP_VERBOSE=1. ifeq "$(os)" "win" ifneq "$(do_test_touch_mt)" "0" test_touch_items += test-touch-md test-touch-mt else test_touch_items += test-touch-md endif else test_touch_items += test-touch-rt endif force-test-touch : $(addsuffix /.force,$(test_touch_items)) $(addsuffix /.test,$(test_touch_items)) test-touch : $(addsuffix /.test,$(test_touch_items)) tt-exe-file = $(dir $@)test-touch$(exe) ifeq "$(os)" "win" # On Windows* OS the test quality is problematic, because LIB environment variable is set up for # Intel compiler so Microsoft compiler is able to find libirc if it is specified in defaultlib # directive within object file... This disadvantage is compensated by grepping verbose link # output for "libirc" string. tt-c = cl tt-c-flags += -nologo ifeq "$(OPTIMIZATION)" "on" tt-c-flags-mt = -MT tt-c-flags-md = -MD else tt-c-flags-mt = -MTd tt-c-flags-md = -MDd endif ifeq "$(LINK_TYPE)" "stat" tt-libs += $(lib_file) else tt-libs += $(imp_file) endif ifneq "$(arch)" "32" # To successfully build with VS2008 # tt-libs += bufferoverflowu.lib # Preventing "unresolved external symbol __security_cookie" (and # "... __security_check_cookie") linker errors on win_32e and win_64. endif tt-c-flags += -Fo$(dir $@)test-touch$(obj) -Fe$(tt-exe-file) tt-ld-flags += -link # Some Posix but non-ISO functions (like strdup) are defined in oldnames.lib, which is used # implicitly. Drop oldnames.lib library, so we can catch tt-ld-flags += -nodefaultlib:oldnames ifeq "$(arch)" "32" tt-ld-flags += -safeseh endif tt-ld-flags-v += -verbose else # lin or mac # On Linux* OS and OS X* the test is good enough because GNU compiler knows nothing # about libirc and Intel compiler private lib directories, but we will grep verbose linker # output just in case. # Using clang on OS X* because of discontinued support of GNU compilers. ifeq "$(os)" "mac" ifeq "$(std_cpp_lib)" "1" tt-c = clang++ else tt-c = clang endif else # lin ifeq "$(std_cpp_lib)" "1" tt-c = g++ else tt-c = gcc endif # GCC on OS X* does not recognize -pthread. tt-c-flags += -pthread endif tt-c-flags += -o $(tt-exe-file) ifneq "$(filter 32 32e 64,$(arch))" "" tt-c-flags += $(if $(filter 64,$(arch)),,$(if $(filter 32,$(arch)),-m32,-m64)) endif tt-libs += $(lib_file) ifeq "$(os)-$(COVERAGE)-$(LINK_TYPE)" "lin-on-stat" # Static coverage build on Linux* OS fails due to unresolved symbols dlopen, dlsym, dlclose. # Explicitly add dl library to avoid failure. tt-ld-flags += -ldl endif ifeq "$(os)" "mac" tt-ld-flags-v += -Wl,-t tt-env += DYLD_LIBRARY_PATH=".:$(DYLD_LIBRARY_PATH)" else # lin tt-ld-flags-v += -Wl,--verbose tt-env += LD_LIBRARY_PATH=".:$(LD_LIBRARY_PATH)" endif endif tt-c-flags += $(tt-c-flags-rt) tt-env += KMP_VERSION=1 tt-i = $(if $(filter off,$(TEST_TOUCH)),-) ifndef test-touch-commands # The first building gives short and clear error message in case of any problem. # The second building runs linker in verbose mode and saves linker output for grepping. define test-touch-commands $(rm) $(dir $@)* $(tt-i)$(tt-c) $(tt-c-flags) $< $(tt-libs) $(tt-ld-flags) $(rm) $(tt-exe-file) $(tt-i)$(tt-c) $(tt-c-flags) \ $< $(tt-libs) \ $(tt-ld-flags) $(tt-ld-flags-v) \ > $(dir $@)build.log 2>&1 $(tt-i)$(tt-env) $(tt-exe-file) $(tt-i)grep -i -e "[^_]libirc" $(dir $@)build.log > $(dir $@)libirc.log; \ [ $$? -eq 1 ] endef endif test-touch-rt/.test : tt-c-flags-rt = test-touch-mt/.test : tt-c-flags-rt = $(tt-c-flags-mt) test-touch-md/.test : tt-c-flags-rt = $(tt-c-flags-md) test-touch-rt/.test : test-touch.c $(lib_file) test-touch-rt/.dir .rebuild $(target) $(test-touch-commands) $(touch) $@ test-touch-mt/.test : test-touch.c $(lib_file) $(imp_file) test-touch-mt/.dir .rebuild $(target) $(test-touch-commands) $(touch) $@ test-touch-md/.test : test-touch.c $(lib_file) $(imp_file) test-touch-md/.dir .rebuild $(target) $(test-touch-commands) $(touch) $@ endif # --- test-relo --- # But test-relo does actual work only on Linux* OS and # Intel(R) Many Integrated Core Architecture in case of dynamic linking. ifeq "$(if $(filter lin,$(os)),os)-$(LINK_TYPE)" "os-dyna" # Make sure dynamic library does not contain position-dependent code. force-test-relo : test-relo/.force test-relo/.test test-relo : test-relo/.test test-relo/.test : $(lib_item)$(dll) test-relo/.dir .rebuild $(target) ifeq "$(arch)" "mic" x86_64-k1om-linux-readelf -d $< > $(dir $@)readelf.log else readelf -d $< > $(dir $@)readelf.log endif grep -e TEXTREL $(dir $@)readelf.log; [ $$? -eq 1 ] $(touch) $@ endif # --- test-execstack --- # But test-execstack does actual work only on Linux* OS in case of dynamic linking. ifeq "$(if $(filter lin,$(os)),os)-$(LINK_TYPE)" "os-dyna" tests += test-execstack # Make sure stack is not executable. force-test-execstack : test-execstack/.force test-execstack/.test test-execstack : test-execstack/.test test-execstack/.test : $(lib_item)$(dll) test-execstack/.dir .rebuild $(target) $(perl) $(tools_dir)check-execstack.pl $(oa-opts) $< $(touch) $@ endif # --- test-instr --- # But test-instr does actual work only on Intel(R) Many Integrated Core Architecture. ifeq "$(arch)" "mic" # Make sure dynamic library does not contain position-dependent code. force-test-instr : test-instr/.force test-instr/.test test-instr : test-instr/.test test-instr/.test : $(lib_file) $(tools_dir)check-instruction-set.pl test-instr/.dir .rebuild $(target) $(perl) $(tools_dir)check-instruction-set.pl $(oa-opts) --show --mic-arch=$(MIC_ARCH) $< $(touch) $@ endif # --- test-deps --- # test-deps does actual work for dymanic linking (all OSes), and Windows* OS (all linking types). ifneq "$(filter %-dyna win-%,$(os)-$(LINK_TYPE))" "" force-test-deps : test-deps/.force test-deps/.test test-deps : test-deps/.test td_exp = ifeq "$(os)" "lin" ifeq "$(arch)" "32" td_exp += libc.so.6 td_exp += ld-linux.so.2 td_exp += libgcc_s.so.1 endif ifeq "$(arch)" "32e" td_exp += libc.so.6 td_exp += ld-linux-x86-64.so.2 td_exp += libgcc_s.so.1 endif ifeq "$(arch)" "64" td_exp += libc.so.6.1 td_exp += libgcc_s.so.1 endif ifeq "$(arch)" "arm" td_exp += libc.so.6 td_exp += ld-linux-armhf.so.3 td_exp += libgcc_s.so.1 endif ifneq "$(filter ppc64 ppc64le,$(arch))" "" td_exp += libc.so.6 td_exp += ld64.so.1 # warning: this is for ppc64le, but as we do not currently # distinguish it from ppc64, we need to add this dep here td_exp += ld64.so.2 td_exp += libgcc_s.so.1 endif ifeq "$(arch)" "aarch" td_exp += libc.so.6 td_exp += ld-linux-aarch64.so.1 endif ifeq "$(arch)-$(MIC_ARCH)" "mic-knf" td_exp += ld-linux-l1om.so.2 td_exp += libc.so.6 td_exp += libgcc_s.so.1 endif ifeq "$(arch)-$(MIC_ARCH)" "mic-knc" td_exp += ld-linux-k1om.so.2 td_exp += libc.so.6 endif ifeq "$(std_cpp_lib)" "1" td_exp += libstdc++.so.6 endif td_exp += libdl.so.2 ifeq "$(filter 32 32e 64 ppc64 ppc64le mic,$(arch))" "" td_exp += libffi.so.6 td_exp += libffi.so.5 endif ifneq "$(LIB_TYPE)" "stub" td_exp += libpthread.so.0 endif endif ifeq "$(os)" "mac" # td_exp += /usr/lib/libgcc_s.1.dylib td_exp += /usr/lib/libSystem.B.dylib endif ifeq "$(os)" "win" ifeq "$(LINK_TYPE)" "dyna" td_exp += kernel32.dll else td_exp += uuid endif endif ifeq "$(omp_os)" "freebsd" td_exp = td_exp += libc.so.7 td_exp += libthr.so.3 td_exp += libunwind.so.5 endif test-deps/.test : $(lib_file) $(tools_dir)check-depends.pl test-deps/.dir .rebuild $(target) $(td-i)$(perl) $(tools_dir)check-depends.pl $(oa-opts) \ $(if $(td_exp),--expected="$(subst $(space),$(comma),$(td_exp))") $< $(touch) $@ endif # -------------------------------------------------------------------------------------------------- # Fortran files. # -------------------------------------------------------------------------------------------------- omp_lib_f = omp_lib.f90 omp_lib_kinds.mod : $(omp_lib_f) .rebuild $(target) $(fort) $(fort-flags) $< omp_lib.mod : omp_lib_kinds.mod omp_lib.h : ev-flags += -D KMP_INT_PTR_KIND="int_ptr_kind()" iomp_lib.h : ev-flags += -D KMP_INT_PTR_KIND=$(if $(filter 32,$(arch)),4,8) # -------------------------------------------------------------------------------------------------- # Common files. # -------------------------------------------------------------------------------------------------- common : $(out_cmn_files) clean-common : $(rm) $(out_cmn_files) # -------------------------------------------------------------------------------------------------- # Dependency files and common rules. # -------------------------------------------------------------------------------------------------- .PHONY : dep dep : $(dep_files) $(target) include $(LIBOMP_WORK)src/rules.mk # Initiate rebuild if any of makefiles or build sript is changed. # When developing makefiles, it is useful to comment it, otherwise make will perform full rebuild # on every change of makefiles. .rebuild : $(MAKEFILE_LIST) $(tools_dir)build.pl $(tools_dir)lib/Build.pm ifeq "$(clean)" "" # Do not include dependency files if "clean" goal is specified. -include $(dep_files) endif # end of file #