[CMake] Detect information about test compiler

[Hahnfeld]

Summary

Perform a nested CMake invocation to avoid writing our own parser
for compiler versions when we are not testing the in-tree compiler.
Use the extracted information to mark a test as unsupported that
hangs with Clang prior to version 4.0.1 and restrict tests for
libomptarget to Clang version 6.0.0 and later.

[Hahnfeld]

Fix stale variable from previous tries.

[Hahnfeld]

Fix broken (inverted) logic of previous update and use LLVM_VERSION.

[Hahnfeld]

Rebase onto recent changes.

[jlpeyton]

LGTM.

[Hahnfeld]

In D40083#939530, @jlpeyton wrote:

LGTM.

Thanks for the review! I'm going to wait until I got one round of testing by the build bots for the refactoring patches though.

[omalyshe]

Why do we limit the test compiler to be the same as the build compiler for libomp?
CMAKE_TEST_<lang>_COMPILER option would be useful to be able to run tests with different compilers.

[Hahnfeld]

I hope there is no such restriction in this patch: You should still be able to set OPENMP_TEST_C_COMPILER and OPENMP_TEST_CXX_COMPILER as before. To get their versions I implemented a nested CMake invocation where -DCMAKE_C_COMPILER=${OPENMP_TEST_C_COMPILER} -DCMAKE_CXX_COMPILER=${OPENMP_TEST_CXX_COMPILER} so that we don't have to maintain a version parser for all supported compilers.

The only restriction I added is a check that C and C++ compiler have the same ID - which was assumed anyway and could lead to nasty problems if the user passes in something different.

[omalyshe]

In D40083#940432, @Hahnfeld wrote:

You should still be able to set OPENMP_TEST_C_COMPILER and OPENMP_TEST_CXX_COMPILER as before.

I failed to specify a test compiler with previous LIBOMP_TEST_* staff because I tried -DLIBOMP_TEST_C_COMPILER=gcc but it actually should have been -DLIBOMP_TEST_COMPILER=gcc. Somehow the old macro had _<lang>_ part missed ;)
It works for me now and I believe it will work for OPENMP_TEST_* too.
Thank you!

[Hahnfeld]

In D40083#940524, @omalyshe wrote:

In D40083#940432, @Hahnfeld wrote:

You should still be able to set OPENMP_TEST_C_COMPILER and OPENMP_TEST_CXX_COMPILER as before.

I failed to specify a test compiler with previous LIBOMP_TEST_* staff because I tried -DLIBOMP_TEST_C_COMPILER=gcc but it actually should have been -DLIBOMP_TEST_COMPILER=gcc. Somehow the old macro had _<lang>_ part missed ;)
It works for me now and I believe it will work for OPENMP_TEST_* too.
Thank you!

Yes, I fixed that inconsistency in the previous refactoring. But I'm a bit confused because LIBOMP_TEST_* shouldn't work anymore?

[omalyshe]

In D40083#940557, @Hahnfeld wrote:

In D40083#940524, @omalyshe wrote:

In D40083#940432, @Hahnfeld wrote:

You should still be able to set OPENMP_TEST_C_COMPILER and OPENMP_TEST_CXX_COMPILER as before.

I failed to specify a test compiler with previous LIBOMP_TEST_* staff because I tried -DLIBOMP_TEST_C_COMPILER=gcc but it actually should have been -DLIBOMP_TEST_COMPILER=gcc. Somehow the old macro had _<lang>_ part missed ;)
It works for me now and I believe it will work for OPENMP_TEST_* too.
Thank you!

Yes, I fixed that inconsistency in the previous refactoring. But I'm a bit confused because LIBOMP_TEST_* shouldn't work anymore?

I only confirm that the old LIBOMP_TEST* works if I use the correct macro name :).
I didn't check the new OPENP_TEST_* staff.

[Hahnfeld]

In D40083#940566, @omalyshe wrote:

I only confirm that the old LIBOMP_TEST* works if I use the correct macro name :).
I didn't check the new OPENP_TEST_* staff.

Ok, do you then have more comments on this patch or can I go ahead and commit the change?

[omalyshe]

LGTM.

CMakeLists.txt

 include(config-ix)
 include(HandleOpenMPOptions)
 
 # Set up testing infrastructure.
 include(OpenMPTesting)
 
 set(OPENMP_TEST_FLAGS "" CACHE STRING
   "Extra compiler flags to send to the test compiler.")
-set(OPENMP_TEST_OPENMP_FLAGS "-fopenmp" CACHE STRING
+set(OPENMP_TEST_OPENMP_FLAGS ${OPENMP_TEST_COMPILER_OPENMP_FLAGS} CACHE STRING
   "OpenMP compiler flag to use for testing OpenMP runtime libraries.")
 
 
 # Build host runtime library.
 add_subdirectory(runtime)
 
 
 set(ENABLE_LIBOMPTARGET ON)

cmake/DetectTestCompiler/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+project(DetectTestCompiler C CXX)
+
+function(write_compiler_information lang)
+  set(information "${CMAKE_${lang}_COMPILER}")
+  set(information "${information}\\;${CMAKE_${lang}_COMPILER_ID}")
+  set(information "${information}\\;${CMAKE_${lang}_COMPILER_VERSION}")
+  set(information "${information}\\;${OpenMP_${lang}_FLAGS}")
+  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${lang}CompilerInformation.txt ${information})
+endfunction(write_compiler_information)
+
+find_package(OpenMP)
+if (NOT OpenMP_Found)
+  set(OpenMP_C_FLAGS "-fopenmp")
+  set(OpenMP_CXX_FLAGS "-fopenmp")
+endif()
+
+write_compiler_information(C)
+write_compiler_information(CXX)

cmake/OpenMPTesting.cmake

if (DEFINED LIBOMP_LIT_ARGS)
     set(DEFAULT_LIT_ARGS ${LIBOMP_LIT_ARGS})
   endif()
   set(OPENMP_LIT_ARGS "${DEFAULT_LIT_ARGS}" CACHE STRING "Options for lit.")
   separate_arguments(OPENMP_LIT_ARGS)
 else()
   set(OPENMP_FILECHECK_EXECUTABLE ${LLVM_RUNTIME_OUTPUT_INTDIR}/FileCheck)
 endif()
 
+# Macro to extract information about compiler from file. (no own scope)
+macro(extract_test_compiler_information lang file)
+  file(READ ${file} information)
+  list(GET information 0 path)
+  list(GET information 1 id)
+  list(GET information 2 version)
+  list(GET information 3 openmp_flags)
+
+  set(OPENMP_TEST_${lang}_COMPILER_PATH ${path})
+  set(OPENMP_TEST_${lang}_COMPILER_ID ${id})
+  set(OPENMP_TEST_${lang}_COMPILER_VERSION ${version})
+  set(OPENMP_TEST_${lang}_COMPILER_OPENMP_FLAGS ${openmp_flags})
+endmacro()
+
+# Function to set variables with information about the test compiler.
+function(set_test_compiler_information dir)
+  extract_test_compiler_information(C ${dir}/CCompilerInformation.txt)
+  extract_test_compiler_information(CXX ${dir}/CXXCompilerInformation.txt)
+  if (NOT("${OPENMP_TEST_C_COMPILER_ID}" STREQUAL "${OPENMP_TEST_CXX_COMPILER_ID}" AND
+          "${OPENMP_TEST_C_COMPILER_VERSION}" STREQUAL "${OPENMP_TEST_CXX_COMPILER_VERSION}"))
+    message(STATUS "Test compilers for C and C++ don't match.")
+    message(WARNING "The check targets will not be available!")
+    set(ENABLE_CHECK_TARGETS FALSE PARENT_SCOPE)
+  else()
+    set(OPENMP_TEST_COMPILER_ID "${OPENMP_TEST_C_COMPILER_ID}" PARENT_SCOPE)
+    set(OPENMP_TEST_COMPILER_VERSION "${OPENMP_TEST_C_COMPILER_VERSION}" PARENT_SCOPE)
+    set(OPENMP_TEST_COMPILER_OPENMP_FLAGS "${OPENMP_TEST_C_COMPILER_OPENMP_FLAGS}" PARENT_SCOPE)
+
+    # Determine major version.
+    string(REGEX MATCH "[0-9]+" major "${OPENMP_TEST_C_COMPILER_VERSION}")
+    set(OPENMP_TEST_COMPILER_VERSION_MAJOR "${major}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+if (${OPENMP_STANDALONE_BUILD})
+  # Detect compiler that should be used for testing.
+  # We cannot use ExternalProject_Add() because its configuration runs when this
+  # project is built which is too late for detecting the compiler...
+  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/DetectTestCompiler)
+  execute_process(
+    COMMAND ${CMAKE_COMMAND} ${CMAKE_CURRENT_LIST_DIR}/DetectTestCompiler
+      -DCMAKE_C_COMPILER=${OPENMP_TEST_C_COMPILER}
+      -DCMAKE_CXX_COMPILER=${OPENMP_TEST_CXX_COMPILER}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/DetectTestCompiler
+    OUTPUT_VARIABLE DETECT_COMPILER_OUT
+    ERROR_VARIABLE DETECT_COMPILER_ERR
+    RESULT_VARIABLE DETECT_COMPILER_RESULT)
+  if (DETECT_COMPILER_RESULT)
+    message(STATUS "Could not detect test compilers.")
+    message(WARNING "The check targets will not be available!")
+    set(ENABLE_CHECK_TARGETS FALSE)
+  else()
+    set_test_compiler_information(${CMAKE_CURRENT_BINARY_DIR}/DetectTestCompiler)
+  endif()
+else()
+  # Set the information that we know.
+  set(OPENMP_TEST_COMPILER_ID "Clang")
+  # Cannot use CLANG_VERSION because we are not guaranteed that this is already set.
+  set(OPENMP_TEST_COMPILER_VERSION "${LLVM_VERSION}")
+  set(OPENMP_TEST_COMPILER_VERSION_MAJOR "${LLVM_MAJOR_VERSION}")
+  set(OPENMP_TEST_COMPILER_OPENMP_FLAGS "-fopenmp")
+endif()
+
+# Function to set compiler features for use in lit.
+function(set_test_compiler_features)
+  if ("${OPENMP_TEST_COMPILER_ID}" STREQUAL "GNU")
+    set(comp "gcc")
+  else()
+    # Just use the lowercase of the compiler ID as fallback.
+    string(TOLOWER "${OPENMP_TEST_COMPILER_ID}" comp)
+  endif()
+  set(OPENMP_TEST_COMPILER_FEATURES "['${comp}', '${comp}-${OPENMP_TEST_COMPILER_VERSION_MAJOR}', '${comp}-${OPENMP_TEST_COMPILER_VERSION}']" PARENT_SCOPE)
+endfunction()
+set_test_compiler_features()
+
 # Function to add a testsuite for an OpenMP runtime library.
 function(add_openmp_testsuite target comment)
   if (NOT ENABLE_CHECK_TARGETS)
     add_custom_target(${target}
       COMMAND ${CMAKE_COMMAND} -E echo "${target} does nothing, dependencies not found.")
     message(STATUS "${target} does nothing.")
     return()
   endif()

libomptarget/test/CMakeLists.txt

 # CMakeLists.txt file for unit testing OpenMP offloading runtime library.
+if(NOT "${OPENMP_TEST_COMPILER_ID}" STREQUAL "Clang" OR
+   ${OPENMP_TEST_COMPILER_VERSION} VERSION_LESS 6.0.0)
+  libomptarget_say("Can only test with Clang compiler in version 6.0.0 or later.")
+  libomptarget_warning_say("The check-libomptarget target will not be available!")
+  return()
+endif()
 
 if(LIBOMPTARGET_CMAKE_BUILD_TYPE MATCHES debug)
   set(LIBOMPTARGET_DEBUG True)
 else()
   set(LIBOMPTARGET_DEBUG False)
 endif()
 
-if(${OPENMP_STANDALONE_BUILD})
-  if (NOT(${OPENMP_TEST_C_COMPILER} MATCHES "clang" AND ${OPENMP_TEST_CXX_COMPILER} MATCHES "clang"))
-    libomptarget_say("Can only test with Clang compiler!")
-    libomptarget_warning_say("The check-libomptarget target will not be available!")
-    return()
-  endif()
-
-  execute_process(
-    COMMAND ${OPENMP_TEST_C_COMPILER} --version
-    OUTPUT_VARIABLE TEST_COMPILER_VERSION)
-  string(REGEX MATCH "version ([0-9.]+)" TEST_COMPILER_VERSION ${TEST_COMPILER_VERSION})
-  if (NOT(TEST_COMPILER_VERSION))
-    libomptarget_say("Unable to determine Clang compiler version!")
-    libomptarget_warning_say("The check-libomptarget target will not be available!")
-    return()
-  endif()
-  set(TEST_COMPILER_VERSION ${CMAKE_MATCH_1})
-  if (TEST_COMPILER_VERSION VERSION_LESS 6.0.0)
-    libomptarget_say("Clang compiler version does not implement all codegen, please update to 6.0.0!")
-    libomptarget_warning_say("The check-libomptarget target will not be available!")
-    return()
-  endif()
-endif()
-
 add_openmp_testsuite(check-libomptarget "Running libomptarget tests" ${CMAKE_CURRENT_BINARY_DIR} DEPENDS omptarget omp)
 
 if(${OPENMP_STANDALONE_BUILD})
   set(LIBOMPTARGET_OPENMP_HEADER_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/../../runtime/src" CACHE STRING
     "Path to folder containing omp.h")
   set(LIBOMPTARGET_OPENMP_HOST_RTL_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/../../runtime/src" CACHE STRING
     "Path to folder containing libomp.so")
 else()
   set(LIBOMPTARGET_OPENMP_HEADER_FOLDER "${LIBOMPTARGET_BINARY_DIR}/../runtime/src")
 endif()
 
 # Configure the lit.site.cfg.in file
 set(AUTO_GEN_COMMENT "## Autogenerated by libomptarget configuration.\n# Do not edit!")
 configure_file(lit.site.cfg.in lit.site.cfg @ONLY)

runtime/test/lit.cfg

 libs = ""
 if config.has_libm:
     libs += " -lm"
 if config.has_libatomic:
     libs += " -latomic"
 
 # Allow XFAIL to work
 config.target_triple = [ ]
-if re.search('gcc', config.test_c_compiler) is not None:
-    config.available_features.add('gcc')
+for feature in config.test_compiler_features:
+    config.available_features.add(feature)
 
 # Setup environment to find dynamic library at runtime
 append_dynamic_library_path(config.library_dir)
 if config.using_hwloc:
     append_dynamic_library_path(config.hwloc_library_dir)
     config.available_features.add('hwloc')
 
 # Rpath modifications for Darwin

runtime/test/lit.site.cfg.in

 @AUTO_GEN_COMMENT@
 
 config.test_c_compiler = "@OPENMP_TEST_C_COMPILER@"
 config.test_cxx_compiler = "@OPENMP_TEST_CXX_COMPILER@"
+config.test_compiler_features = @OPENMP_TEST_COMPILER_FEATURES@
 config.test_filecheck = "@OPENMP_FILECHECK_EXECUTABLE@"
 config.test_openmp_flags = "@OPENMP_TEST_OPENMP_FLAGS@"
 config.test_extra_flags = "@OPENMP_TEST_FLAGS@"
 config.libomp_obj_root = "@CMAKE_CURRENT_BINARY_DIR@"
 config.library_dir = "@LIBOMP_LIBRARY_DIR@"
 config.omp_header_directory = "@LIBOMP_BINARY_DIR@/src"
 config.operating_system = "@CMAKE_SYSTEM_NAME@"
 config.hwloc_library_dir = "@LIBOMP_HWLOC_LIBRARY_DIR@"
 config.using_hwloc = @LIBOMP_USE_HWLOC@
 config.has_ompt = @LIBOMP_OMPT_SUPPORT@ and @LIBOMP_OMPT_OPTIONAL@
 config.has_libm = @LIBOMP_HAVE_LIBM@
 config.has_libatomic = @LIBOMP_HAVE_LIBATOMIC@
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBOMP_BASE_DIR@/test/lit.cfg")

runtime/test/misc_bugs/cancellation_for_sections.c

 // RUN: %libomp-compile && env OMP_CANCELLATION=true %libomp-run
 // XFAIL: gcc
+// Clang had a bug until version 4.0.1 which resulted in a hang.
+// UNSUPPORTED: clang-3, clang-4.0.0
+
 // Regression test for a bug in cancellation to cover effect of `#pragma omp cancel`
 // in a loop construct, on sections construct.
 // Pass condition: Cancellation status from `for` does not persist
 // to `sections`.
 
 #include <stdio.h>
 #include <omp.h>
 
if (result[0] != 1 || result[1] != 2) {
                result[0], result[1]);
         printf("FAILED\n");
         return 1;
     }
 
     printf("PASSED\n");
     return 0;
 }
-

runtime/test/tasking/kmp_task_reduction_nest.cpp

 // RUN: %libomp-cxx-compile-and-run
 // RUN: %libomp-cxx-compile -DFLG=1 && %libomp-run
+// GCC-5 is needed for OpenMP 4.0 support (taskgroup)
+// XFAIL: gcc-4
 #include <cstdio>
 #include <cmath>
 #include <cassert>
 #include <omp.h>
 
 // Total number of loop iterations, should be multiple of T for this test
 #define N 10000