[CMake] Refactor common settings and flags

[Hahnfeld]

Summary

These are needed by both libraries, so we can do that in a
common namespace and unify configuration parameters.
Also make sure that the user isn't requesting libomptarget
if the library cannot be built on the system. Issue an error
in that case.

[Hahnfeld]

Rebase.

[Hahnfeld]

Rebase onto recent changes.

[Hahnfeld]

Remove project() that crept back into libomptarget/CMakeLists.txt.

[jlpeyton]

libomptarget/CMakeLists.txt

44–46

While we are cleaning up... I think this would be cleaner if all prerequisites were checked here and an error issued if one is not met. Currently there seems to be only one (need -std=c++11 flag) I don't think it would hurt to check for users trying to build on mac or windows here either and issue a similar message, because that would mean they tried to improperly override OPENMP_ENABLE_LIBOMPTARGET

# Check prerequisites for building libomptarget
if (NOT OPENMP_HAVE_STD_CPP11_FLAG)
  libomptarget_error_say("Requested build of libomptarget with no -std=c++11 flag")
endif()

You could also add OPENMP_HAVE_STD_CPP11_FLAG into the logic which determines the default ENABLE_LIBOMPTARGET inside the top-level CMakeLists.txt file.

If a user somehow finds them self inside the libomptarget/CMakeLists.txt file without -std=c++11 flag support. I think its better for CMake to scream at the user during config time rather than for a status message to get lost in a sea of CMake output, because then the user builds all of LLVM and they scratch their heads trying to find libomptarget.

[Hahnfeld]

libomptarget/CMakeLists.txt

44–46

I disagree: If the user explicitly tells the build system to build libomptarget, it's the user's fault.

Regarding C++11: Doesn't libomp also depend on that standard? Maybe we should just error out completely in the top-level CMakeLists.txt, I think LLVM requires a C++11-capable compiler anyway...

[jlpeyton]

libomptarget/CMakeLists.txt

44–46

Actually we are in total agreement that the user is at fault.

But, one of the main goals of a configuration system is to check prerequisites and then error out when they aren't met. I'm in favor of aiding the user in seeing the error of their ways (or setup). At the *very least*, it should be a warning so that the output is pronounced in the CMake output. It does not make sense to me to require something for the build, but not error out when you do not have the prerequisites but at the same time request the feature (either by the default, ENABLE_LIBOMPTARGET, which currently does not check for the flag, or explicitly setting OPENMP_ENABLE_LIBOMPTARGET=On). To me, this boils down to when OPENMP_ENABLE_LIBOMPTARGET=On for whatever reason, then it implies the user absolutely wants the library.

There should be checks for attribute((weak)) as well.

We can't error out in the top level because libomp is supported on Visual Studio which doesn't use the -std=c++11.

[Hahnfeld]

libomptarget/CMakeLists.txt

44–46

Ok, then I'd say we just shouldn't make OPENMP_ENABLE_LIBOMPTARGET available on Windows and Mac OS X in the top-level CMakeLists.txt. Because it's not reasonable to have a switch that the user isn't allowed to use because the build system will yell immediately.

I still think that we should silently accept if a compiler doesn't support C++11: The build system builds whatever it finds possible with the given compiler. Maybe we should switch it to a warning though?

[jlpeyton]

I'm going to make one last plea for doing it correctly. Here is actual CMake code from LLVM's main CMakeLists.txt. It is reasonable to error-check what the user requests no matter how odd you may find it! The user may not know that something is only available on a certain platform until they request it. They do not wrap the option in operating system guards. Although some other options they do wrap in OS guards. Please just add the three line OS error check and the three line flag check.

option(LLVM_USE_INTEL_JITEVENTS
  "Use Intel JIT API to inform Intel(R) VTune(TM) Amplifier XE 2011 about JIT code"
  OFF)

if( LLVM_USE_INTEL_JITEVENTS )
  # Verify we are on a supported platform
  if( NOT CMAKE_SYSTEM_NAME MATCHES "Windows" AND NOT CMAKE_SYSTEM_NAME MATCHES "Linux" )
    message(FATAL_ERROR
      "Intel JIT API support is available on Linux and Windows only.")
  endif()
endif( LLVM_USE_INTEL_JITEVENTS )

option(LLVM_USE_OPROFILE
  "Use opagent JIT interface to inform OProfile about JIT code" OFF)

# If enabled, verify we are on a platform that supports oprofile.
if( LLVM_USE_OPROFILE )
  if( NOT CMAKE_SYSTEM_NAME MATCHES "Linux" )
    message(FATAL_ERROR "OProfile support is available on Linux only.")
  endif( NOT CMAKE_SYSTEM_NAME MATCHES "Linux" )
endif( LLVM_USE_OPROFILE )

Also, here is LLVM's -std=c++11 flag check, so you could use this if you want (notice the FATAL_ERROR):

if (LLVM_ENABLE_CXX1Y)
  check_cxx_compiler_flag("-std=c++1y" CXX_SUPPORTS_CXX1Y)
  append_if(CXX_SUPPORTS_CXX1Y "-std=c++1y" CMAKE_CXX_FLAGS)
elseif(LLVM_ENABLE_CXX1Z)
  check_cxx_compiler_flag("-std=c++1z" CXX_SUPPORTS_CXX1Z)
  append_if(CXX_SUPPORTS_CXX1Z "-std=c++1z" CMAKE_CXX_FLAGS)
else()
  check_cxx_compiler_flag("-std=c++11" CXX_SUPPORTS_CXX11)
  if (CXX_SUPPORTS_CXX11)
    if (CYGWIN OR MINGW)
      # MinGW and Cygwin are a bit stricter and lack things like
      # 'strdup', 'stricmp', etc in c++11 mode.
      append("-std=gnu++11" CMAKE_CXX_FLAGS)
    else()
      append("-std=c++11" CMAKE_CXX_FLAGS)
    endif()
  else()
    message(FATAL_ERROR "LLVM requires C++11 support but the '-std=c++11' flag isn't supported.")
  endif()
endif()

[Hahnfeld]

Ok, I finally got your point. I especially agree on "The user may not know that something is only available on a certain platform until they request it" which kind of invalidates my previous arguments. I will update the patch tomorrow. I'm still tending towards putting this into the top-level CMakeLists.txt, right next to the definition of OPENMP_ENABLE_LIBOMPTARGET to have it in one place. What do you think?

Regarding -std=c++11: How does MSVC survive that LLVM check?

[Hahnfeld]

Check that the user isn't requesting libomptarget on unsupported configurations.

[jlpeyton]

LGTM

CMakeLists.txt

 cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
 
+# Add cmake directory to search for custom cmake functions.
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
+
 # llvm/runtimes/ will set OPENMP_STANDALONE_BUILD.
 if (OPENMP_STANDALONE_BUILD OR "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
   set(OPENMP_STANDALONE_BUILD TRUE)
   project(openmp C CXX)
 
   # CMAKE_BUILD_TYPE was not set, default to Release.
   if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
   endif()
 
+  # Group common settings.
+  set(OPENMP_ENABLE_WERROR FALSE CACHE BOOL
+    "Enable -Werror flags to turn warnings into errors for supporting compilers.")
+  set(OPENMP_LIBDIR_SUFFIX "" CACHE STRING
+    "suffix of lib installation directory, e.g. 64 => lib64")
+
   set(OPENMP_LLVM_TOOLS_DIR "" CACHE PATH "Path to LLVM tools for testing.")
+else()
+  set(OPENMP_ENABLE_WERROR ${LLVM_ENABLE_WERROR})
+  # If building in tree, we honor the same install suffix LLVM uses.
+  set(OPENMP_LIBDIR_SUFFIX ${LLVM_LIBDIR_SUFFIX})
 endif()
 
+# Check and set up common compiler flags.
+include(config-ix)
+include(HandleOpenMPOptions)
+
+
+# Build host runtime library.
 add_subdirectory(runtime)
 
 
 # The tests currently don't pass if the generic ELF plugin is built.
 # TODO: Fix the tests and enable libomptarget by default on supported
 #       architectures and platforms.
 set(ENABLE_LIBOMPTARGET OFF)
 # Currently libomptarget cannot be compiled on Windows or MacOS X.

cmake/HandleOpenMPOptions.cmake

+if (${OPENMP_STANDALONE_BUILD})
+  # From HandleLLVMOptions.cmake
+  function(append_if condition value)
+    if (${condition})
+      foreach(variable ${ARGN})
+        set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
+      endforeach(variable)
+    endif()
+  endfunction()
+endif()
+
+if (${OPENMP_ENABLE_WERROR})
+  append_if(OPENMP_HAVE_WERROR_FLAG "-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+endif()
+
+append_if(OPENMP_HAVE_STD_CPP11_FLAG "-std=c++11" CMAKE_CXX_FLAGS)
 No newline at end of file

cmake/config-ix.cmake

+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+
+check_c_compiler_flag(-Werror OPENMP_HAVE_WERROR_FLAG)
+
+check_cxx_compiler_flag(-std=c++11 OPENMP_HAVE_STD_CPP11_FLAG)
 No newline at end of file

libomptarget/Build_With_CMake.txt

 
 -DCMAKE_CXX_COMPILER=<C++ compiler name>
 Specify the C++ compiler
 
 ==== First values listed are the default value ====
 -DCMAKE_BUILD_TYPE=Release|Debug|RelWithDebInfo
 Build type can be Release, Debug, or RelWithDebInfo.
 
--DLIBOMPTARGET_ENABLE_WERROR=true|false
+-DOPENMP_ENABLE_WERROR=true|false
 Should consider warnings as errors.
 
 -DLIBOMPTARGET_LLVM_LIT_EXECUTABLE=""
 Full path to the llvm-lit tool. Required for testing in out-of-tree builds.
 
 -DLIBOMPTARGET_FILECHECK_EXECUTABLE=""
 Full path to the FileCheck tool. Required for testing in out-of-tree builds.
 

libomptarget/CMakeLists.txt

 # Build offloading library libomptarget.so.
 #
 ##===----------------------------------------------------------------------===##
 
 if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
   message(FATAL_ERROR "Direct configuration not supported, please use parent directory!")
 endif()
 
-# Add cmake directory to search for custom cmake functions.
-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules ${CMAKE_MODULE_PATH})
-
 if(OPENMP_STANDALONE_BUILD)
-  set(LIBOMPTARGET_ENABLE_WERROR FALSE CACHE BOOL
-    "Enable -Werror flags to turn warnings into errors for supporting compilers.")
-  set(LIBOMPTARGET_LIBDIR_SUFFIX "" CACHE STRING
-    "suffix of lib installation directory, e.g. 64 => lib64")
-
   # Build all libraries into a common place so that tests can find them.
   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-else()
-  set(LIBOMPTARGET_ENABLE_WERROR ${LLVM_ENABLE_WERROR})
-  # If building in tree, we honor the same install suffix LLVM uses.
-  set(LIBOMPTARGET_LIBDIR_SUFFIX ${LLVM_LIBDIR_SUFFIX})
 endif()
 
-# Compiler flag checks.
-include(config-ix)
-
 # Message utilities.
 include(LibomptargetUtils)
 
 # Get dependencies for the different components of the project.
 include(LibomptargetGetDependencies)
 
 # This is a list of all the targets that are supported/tested right now.
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} aarch64-unknown-linux-gnu")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} powerpc64le-ibm-linux-gnu")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} powerpc64-ibm-linux-gnu")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} x86_64-pc-linux-gnu")
 set (LIBOMPTARGET_ALL_TARGETS "${LIBOMPTARGET_ALL_TARGETS} nvptx64-nvidia-cuda")
 
 # Once the plugins for the different targets are validated, they will be added to
 # the list of supported targets in the current system.
 set (LIBOMPTARGET_SYSTEM_TARGETS "")
 
 # Set base directories - required for lit to locate the tests.
 set(LIBOMPTARGET_BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(LIBOMPTARGET_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 # We need C++11 support.
-if(LIBOMPTARGET_HAVE_STD_CPP11_FLAG)
+if(OPENMP_HAVE_STD_CPP11_FLAG)
   
   libomptarget_say("Building offloading runtime library libomptarget.")
 
-  # Enable support for C++11.
-  add_definitions(-std=c++11)
-  
-  if(LIBOMPTARGET_ENABLE_WERROR AND LIBOMPTARGET_HAVE_WERROR_FLAG)
-    add_definitions(-Werror)
-  endif()
-  
   # If building this library in debug mode, we define a macro to enable
   # dumping progress messages at runtime.
   string( TOLOWER "${CMAKE_BUILD_TYPE}" LIBOMPTARGET_CMAKE_BUILD_TYPE)
   if(LIBOMPTARGET_CMAKE_BUILD_TYPE MATCHES debug)
     add_definitions(-DOMPTARGET_DEBUG)
     add_definitions(-g)
     add_definitions(-O0)
   endif()
   
   set(src_files
     src/omptarget.cpp
   )
   
   include_directories(src/)
   
   # Build libomptarget library with libdl dependency.
   add_library(omptarget SHARED ${src_files})
   target_link_libraries(omptarget
     ${CMAKE_DL_LIBS}
     "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/exports")
   
   # Install libomptarget under the lib destination folder.
-  install(TARGETS omptarget LIBRARY DESTINATION lib${LIBOMPTARGET_LIBDIR_SUFFIX})
+  install(TARGETS omptarget LIBRARY DESTINATION lib${OPENMP_LIBDIR_SUFFIX})
   
   # Retrieve the path to the resulting library so that it can be used for 
   # testing.
   get_target_property(LIBOMPTARGET_LIBRARY_DIR omptarget LIBRARY_OUTPUT_DIRECTORY)
   if(NOT LIBOMPTARGET_LIBRARY_DIR)
     set(LIBOMPTARGET_LIBRARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
   endif()
 
   # Build offloading plugins and device RTLs if they are available.
   add_subdirectory(plugins)
   
   # Add tests.
   add_subdirectory(test)
   
-else(LIBOMPTARGET_HAVE_STD_CPP11_FLAG)
+else(OPENMP_HAVE_STD_CPP11_FLAG)
   libomptarget_say("Not building offloading runtime library libomptarget: host compiler must have c++11 support.")
-endif(LIBOMPTARGET_HAVE_STD_CPP11_FLAG)
+endif(OPENMP_HAVE_STD_CPP11_FLAG)

libomptarget/cmake/Modules/config-ix.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.
-#//
-#//===----------------------------------------------------------------------===//
-#
-
-include(CheckCCompilerFlag)
-include(CheckCXXCompilerFlag)
-
-# Checking C, CXX
-check_cxx_compiler_flag(-std=c++11 LIBOMPTARGET_HAVE_STD_CPP11_FLAG)
-check_c_compiler_flag(-Werror LIBOMPTARGET_HAVE_WERROR_FLAG)

libomptarget/plugins/CMakeLists.txt

if(LIBOMPTARGET_DEP_LIBFFI_FOUND)
       # Define macro with the ELF ID for this target.
       add_definitions("-DTARGET_ELF_ID=${elf_machine_id}")
     
       add_library("omptarget.rtl.${tmachine_libname}" SHARED 
         ${CMAKE_CURRENT_SOURCE_DIR}/../generic-elf-64bit/src/rtl.cpp)
         
       # Install plugin under the lib destination folder.
       install(TARGETS "omptarget.rtl.${tmachine_libname}" 
-        LIBRARY DESTINATION lib${LIBOMPTARGET_LIBDIR_SUFFIX})
+        LIBRARY DESTINATION lib${OPENMP_LIBDIR_SUFFIX})
         
       target_link_libraries(
         "omptarget.rtl.${tmachine_libname}"
         ${LIBOMPTARGET_DEP_LIBFFI_LIBRARIES} 
         ${LIBOMPTARGET_DEP_LIBELF_LIBRARIES}
         dl
         "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exports")
     

libomptarget/plugins/cuda/CMakeLists.txt

if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64)|(ppc64le)$" AND CMAKE_SYSTEM_NAME MATCHES "Linux")
       endif()
       
       include_directories(${LIBOMPTARGET_DEP_CUDA_INCLUDE_DIRS})
       include_directories(${LIBOMPTARGET_DEP_LIBELF_INCLUDE_DIRS})
     
       add_library(omptarget.rtl.cuda SHARED src/rtl.cpp)
       
       # Install plugin under the lib destination folder.
-      install(TARGETS omptarget.rtl.cuda LIBRARY DESTINATION lib${LIBOMPTARGET_LIBDIR_SUFFIX})
+      install(TARGETS omptarget.rtl.cuda LIBRARY DESTINATION lib${OPENMP_LIBDIR_SUFFIX})
       
       target_link_libraries(omptarget.rtl.cuda 
         ${LIBOMPTARGET_DEP_CUDA_LIBRARIES} 
         cuda 
         ${LIBOMPTARGET_DEP_LIBELF_LIBRARIES}
         "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exports")
     
       # Report to the parent scope that we are building a plugin for CUDA.

runtime/CMakeLists.txt

 include(LibompDefinitions)
 
 # Determine the target architecture
 if(${OPENMP_STANDALONE_BUILD})
   # If adding a new architecture, take a look at cmake/LibompGetArchitecture.cmake
   libomp_get_architecture(LIBOMP_DETECTED_ARCH)
   set(LIBOMP_ARCH ${LIBOMP_DETECTED_ARCH} CACHE STRING
     "The architecture to build for (x86_64/i386/arm/ppc64/ppc64le/aarch64/mic/mips/mips64).")
-  # Allow user to choose a suffix for the installation directory.
-  set(LIBOMP_LIBDIR_SUFFIX "" CACHE STRING
-    "suffix of lib installation directory e.g., 64 => lib64")
   # Should assertions be enabled?  They are on by default.
   set(LIBOMP_ENABLE_ASSERTIONS TRUE CACHE BOOL
     "enable assertions?")
-  set(LIBOMP_ENABLE_WERROR FALSE CACHE BOOL
-    "Enable -Werror flags to turn warnings into errors for supporting compilers.")
 else() # Part of LLVM build
   # Determine the native architecture from LLVM.
   string(TOLOWER "${LLVM_TARGET_ARCH}" LIBOMP_NATIVE_ARCH)
   if( LIBOMP_NATIVE_ARCH STREQUAL "host" )
     string(REGEX MATCH "^[^-]*" LIBOMP_NATIVE_ARCH ${LLVM_HOST_TRIPLE})
   endif ()
   if(LIBOMP_NATIVE_ARCH MATCHES "i[2-6]86")
     set(LIBOMP_ARCH i386)
else() # Part of LLVM build
   elseif(LIBOMP_NATIVE_ARCH MATCHES "arm64")
     set(LIBOMP_ARCH aarch64)
   elseif(LIBOMP_NATIVE_ARCH MATCHES "arm")
     set(LIBOMP_ARCH arm)
   else()
     # last ditch effort
     libomp_get_architecture(LIBOMP_ARCH)
   endif ()
-  set(LIBOMP_LIBDIR_SUFFIX ${LLVM_LIBDIR_SUFFIX})
   set(LIBOMP_ENABLE_ASSERTIONS ${LLVM_ENABLE_ASSERTIONS})
-  set(LIBOMP_ENABLE_WERROR ${LLVM_ENABLE_WERROR})
 endif()
 libomp_check_variable(LIBOMP_ARCH 32e x86_64 32 i386 arm ppc64 ppc64le aarch64 mic mips mips64)
 
 set(LIBOMP_LIB_TYPE normal CACHE STRING
   "Performance,Profiling,Stubs library (normal/profile/stubs)")
 libomp_check_variable(LIBOMP_LIB_TYPE normal profile stubs)
 set(LIBOMP_OMP_VERSION 50 CACHE STRING
   "The OpenMP version (50/45/40/30)")

runtime/cmake/LibompHandleFlags.cmake

if(NOT "${${flags}}" STREQUAL "") # if flags are empty, don't do anything
     string(STRIP "${flags_local}" flags_local)
     set(${flags} "${flags_local}")
   endif()
 endmacro()
 
 # Gets flags common to both the C and C++ compiler
 function(libomp_get_c_and_cxxflags_common flags)
   set(flags_local)
-  libomp_append(flags_local -std=c++11 LIBOMP_HAVE_STD_CPP11_FLAG)
   libomp_append(flags_local -fno-exceptions LIBOMP_HAVE_FNO_EXCEPTIONS_FLAG)
   libomp_append(flags_local -fno-rtti LIBOMP_HAVE_FNO_RTTI_FLAG)
-  if(${LIBOMP_ENABLE_WERROR})
-    libomp_append(flags_local -Werror LIBOMP_HAVE_WERROR_FLAG)
-  endif()
   libomp_append(flags_local -Wno-sign-compare LIBOMP_HAVE_WNO_SIGN_COMPARE_FLAG)
   libomp_append(flags_local -Wno-unused-function LIBOMP_HAVE_WNO_UNUSED_FUNCTION_FLAG)
   libomp_append(flags_local -Wno-unused-local-typedef LIBOMP_HAVE_WNO_UNUSED_LOCAL_TYPEDEF_FLAG)
   libomp_append(flags_local -Wno-unused-value LIBOMP_HAVE_WNO_UNUSED_VALUE_FLAG)
   libomp_append(flags_local -Wno-unused-variable LIBOMP_HAVE_WNO_UNUSED_VARIABLE_FLAG)
   libomp_append(flags_local -Wno-switch LIBOMP_HAVE_WNO_SWITCH_FLAG)
   libomp_append(flags_local -Wno-covered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
   libomp_append(flags_local -Wno-deprecated-register LIBOMP_HAVE_WNO_DEPRECATED_REGISTER_FLAG)

runtime/cmake/config-ix.cmake

 # Includes the architecture flag in both compile and link phase
 function(libomp_check_architecture_flag flag retval)
   set(CMAKE_REQUIRED_FLAGS "${flag}")
   check_c_compiler_flag("${flag}" ${retval})
   set(${retval} ${${retval}} PARENT_SCOPE)
 endfunction()
 
 # Checking C, CXX, Linker Flags
-check_cxx_compiler_flag(-std=c++11 LIBOMP_HAVE_STD_CPP11_FLAG)
 check_cxx_compiler_flag(-fno-exceptions LIBOMP_HAVE_FNO_EXCEPTIONS_FLAG)
 check_cxx_compiler_flag(-fno-rtti LIBOMP_HAVE_FNO_RTTI_FLAG)
 check_c_compiler_flag("-x c++" LIBOMP_HAVE_X_CPP_FLAG)
-check_c_compiler_flag(-Werror LIBOMP_HAVE_WERROR_FLAG)
 check_c_compiler_flag(-Wunused-function LIBOMP_HAVE_WNO_UNUSED_FUNCTION_FLAG)
 check_c_compiler_flag(-Wunused-local-typedef LIBOMP_HAVE_WNO_UNUSED_LOCAL_TYPEDEF_FLAG)
 check_c_compiler_flag(-Wunused-value LIBOMP_HAVE_WNO_UNUSED_VALUE_FLAG)
 check_c_compiler_flag(-Wunused-variable LIBOMP_HAVE_WNO_UNUSED_VARIABLE_FLAG)
 check_c_compiler_flag(-Wswitch LIBOMP_HAVE_WNO_SWITCH_FLAG)
 check_c_compiler_flag(-Wcovered-switch-default LIBOMP_HAVE_WNO_COVERED_SWITCH_DEFAULT_FLAG)
 check_c_compiler_flag(-Wdeprecated-register LIBOMP_HAVE_WNO_DEPRECATED_REGISTER_FLAG)
 check_c_compiler_flag(-Wsign-compare LIBOMP_HAVE_WNO_SIGN_COMPARE_FLAG)

runtime/src/CMakeLists.txt

 
 # 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(${OPENMP_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)
+  set(LIBOMP_HEADERS_INSTALL_PATH lib${OPENMP_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}/include)
 endif()
 if(WIN32)
   install(TARGETS omp RUNTIME DESTINATION bin)
-  install(TARGETS ompimp ARCHIVE DESTINATION lib${LIBOMP_LIBDIR_SUFFIX})
+  install(TARGETS ompimp ARCHIVE DESTINATION lib${OPENMP_LIBDIR_SUFFIX})
   # 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 \"${LIBOMP_LIB_FILE}\"
       \"${alias}${LIBOMP_LIBRARY_SUFFIX}\" WORKING_DIRECTORY \${CMAKE_INSTALL_PREFIX}/bin)")
     install(CODE "execute_process(COMMAND \"\${CMAKE_COMMAND}\" -E copy \"${LIBOMP_IMP_LIB_FILE}\"
-      \"${alias}${LIBOMP_LIBRARY_SUFFIX}\" WORKING_DIRECTORY \${CMAKE_INSTALL_PREFIX}/lib${LIBOMP_LIBDIR_SUFFIX})")
+      \"${alias}${LIBOMP_LIBRARY_SUFFIX}\" WORKING_DIRECTORY \${CMAKE_INSTALL_PREFIX}/lib${OPENMP_LIBDIR_SUFFIX})")
   endforeach()
 else()
 
-  install(TARGETS omp ${LIBOMP_INSTALL_KIND} DESTINATION lib${LIBOMP_LIBDIR_SUFFIX})
+  install(TARGETS omp ${LIBOMP_INSTALL_KIND} DESTINATION lib${OPENMP_LIBDIR_SUFFIX})
 
   if(${LIBOMP_INSTALL_ALIASES})
     # 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 \"${LIBOMP_LIB_FILE}\"
         \"${alias}${LIBOMP_LIBRARY_SUFFIX}\" WORKING_DIRECTORY
-        \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/lib${LIBOMP_LIBDIR_SUFFIX})")
+        \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/lib${OPENMP_LIBDIR_SUFFIX})")
     endforeach()
   endif()
 endif()
 install(
   FILES
   ${CMAKE_CURRENT_BINARY_DIR}/omp.h
   DESTINATION ${LIBOMP_HEADERS_INSTALL_PATH}
 )