[OpenMP][Tool] Make tests for archer dependent on TSan

[protze.joachim]

Summary

If the openmp project is built standalone, the test compiler is feature tested for an available -fsanitize=thread flag.
If the openmp project is built as part of llvm, the target tsan is needed to test archer.

An additional line (requires tsan) was introduced to the tests, this patch updates the line numbers for the race.

[protze.joachim]

This patch re-enables the testing of Archer for all builds where TSan is available.
I'd prefer to have this patch in the release for testing :)

[jdoerfert]

LGTM.

openmp/cmake/DetectTestCompiler/CMakeLists.txt

 cmake_minimum_required(VERSION 2.8)
 project(DetectTestCompiler C CXX)
 
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 
 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}\\;${${lang}_FLAGS}")
+  set(information "${information}\\;${${lang}_HAS_TSAN_FLAG}")
   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()
if (${lang}_HAS_EXPERIMENTAL_ISEL_FLAG)
       set(${lang}_FLAGS "-fno-experimental-isel ${${lang}_FLAGS}")
     endif()
   endmacro(add_experimental_isel_flag)
 
   add_experimental_isel_flag(C)
   add_experimental_isel_flag(CXX)
 endif()
 
+SET(CMAKE_REQUIRED_FLAGS "-fsanitize=thread")
+check_c_compiler_flag("" C_HAS_TSAN_FLAG)
+check_cxx_compiler_flag("" CXX_HAS_TSAN_FLAG)
+
 write_compiler_information(C)
 write_compiler_information(CXX)

openmp/cmake/OpenMPTesting.cmake

 
 # 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)
+  list(GET information 4 has_tsan_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})
+  set(OPENMP_TEST_${lang}_COMPILER_HAS_TSAN_FLAGS ${has_tsan_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)
+    set(OPENMP_TEST_COMPILER_HAS_TSAN_FLAGS "${OPENMP_TEST_C_COMPILER_HAS_TSAN_FLAGS}" PARENT_SCOPE)
 
     # Determine major version.
     string(REGEX MATCH "[0-9]+" major "${OPENMP_TEST_C_COMPILER_VERSION}")
     string(REGEX MATCH "[0-9]+\\.[0-9]+" majorminor "${OPENMP_TEST_C_COMPILER_VERSION}")
     set(OPENMP_TEST_COMPILER_VERSION_MAJOR "${major}" PARENT_SCOPE)
     set(OPENMP_TEST_COMPILER_VERSION_MAJOR_MINOR "${majorminor}" PARENT_SCOPE)
   endif()
 endfunction()
else()
   # Unfortunately the top-level cmake/config-ix.cmake file mangles CMake's
   # CMAKE_THREAD_LIBS_INIT variable from the FindThreads package, so work
   # around that, until it is fixed there.
   if("${CMAKE_THREAD_LIBS_INIT}" STREQUAL "-lpthread")
     set(OPENMP_TEST_COMPILER_THREAD_FLAGS "-pthread")
   else()
     set(OPENMP_TEST_COMPILER_THREAD_FLAGS "${CMAKE_THREAD_LIBS_INIT}")
   endif()
+  if(TARGET tsan)
+    set(OPENMP_TEST_COMPILER_HAS_TSAN_FLAGS 1)
+  else()
+    set(OPENMP_TEST_COMPILER_HAS_TSAN_FLAGS 0)
+  endif()
   # TODO: Implement blockaddress in GlobalISel and remove this flag!
   set(OPENMP_TEST_COMPILER_OPENMP_FLAGS "-fopenmp ${OPENMP_TEST_COMPILER_THREAD_FLAGS} -fno-experimental-isel")
 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")

openmp/tools/archer/tests/CMakeLists.txt

if(NOT LIBARCHER_HAVE_BUILTIN_ATOMIC)
   check_library_exists(atomic __atomic_load_1 "" LIBARCHER_HAVE_LIBATOMIC)
 else()
   # not needed
   set(LIBARCHER_HAVE_LIBATOMIC 0)
 endif()
 
 set(LIBARCHER_TEST_PATH ${CMAKE_CURRENT_SOURCE_DIR})
 
+set(LIBARCHER_TEST_FLAGS "" CACHE STRING
+  "Extra compiler flags to send to the test compiler.")
+
 macro(pythonize_bool var)
   if (${var})
     set(${var} True)
   else()
     set(${var} False)
   endif()
 endmacro()
 
 pythonize_bool(LIBARCHER_HAVE_LIBATOMIC)
+pythonize_bool(OPENMP_TEST_COMPILER_HAS_TSAN_FLAGS)
 
 add_openmp_testsuite(check-libarcher "Running libarcher tests" ${CMAKE_CURRENT_BINARY_DIR} DEPENDS archer)
 
 # Configure the lit.site.cfg.in file
 set(AUTO_GEN_COMMENT "## Autogenerated by libarcher configuration.\n# Do not edit!")
 configure_file(lit.site.cfg.in lit.site.cfg @ONLY)

openmp/tools/archer/tests/lit.cfg

 # test format
 config.test_format = lit.formats.ShTest()
 
 # compiler flags
 config.test_flags = " -I " + config.test_source_root + \
     " -I " + config.omp_header_dir + \
     " -L " + config.omp_library_dir + \
     " -Wl,-rpath," + config.omp_library_dir + \
-    " " + config.test_extra_flags
+    " " + config.test_archer_flags
 
 config.archer_flags = "-g -O1 -fsanitize=thread"
 
 
 # extra libraries
 libs = ""
 if config.has_libatomic:
     libs += " -latomic"
if config.operating_system == 'Darwin':
   out = out.strip()
   res = cmd.wait()
   if res == 0 and out:
     config.test_flags += " -isysroot " + out
 
 if 'Linux' in config.operating_system:
     config.available_features.add("linux")
 
+if config.has_tsan == True:
+    config.available_features.add("tsan")
+
 # to run with icc INTEL_LICENSE_FILE must be set
 if 'INTEL_LICENSE_FILE' in os.environ:
     config.environment['INTEL_LICENSE_FILE'] = os.environ['INTEL_LICENSE_FILE']
 
 # Race Tests
 config.substitutions.append(("%libarcher-compile-and-run-race", \
     "%libarcher-compile && %libarcher-run-race"))
 config.substitutions.append(("%libarcher-compile-and-run", \

openmp/tools/archer/tests/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.omp_library_dir = "@LIBOMP_LIBRARY_DIR@"
 config.omp_header_dir = "@LIBOMP_INCLUDE_DIR@"
 config.operating_system = "@CMAKE_SYSTEM_NAME@"
-config.has_libatomic = "@LIBARCHER_HAVE_LIBATOMIC@"
+config.has_libatomic = @LIBARCHER_HAVE_LIBATOMIC@
+config.has_tsan = @OPENMP_TEST_COMPILER_HAS_TSAN_FLAGS@
 
-config.test_archer_flags = "@OPENMP_TEST_ARCHER_FLAGS@"
+config.test_archer_flags = "@LIBARCHER_TEST_FLAGS@"
 config.libarcher_obj_root = "@CMAKE_CURRENT_BINARY_DIR@"
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg")

openmp/tools/archer/tests/races/critical-unrelated.c

 /*
  * critical-unrelated.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 // RUN: %libarcher-compile-and-run-race | FileCheck %s
 // REQUIRES: tsan
 #include <omp.h>
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int var = 0;
 

 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   {{(Write|Read)}} of size 4
 // CHECK-NEXT: #0 {{.*}}critical-unrelated.c:29
 // CHECK:   Previous write of size 4
 // CHECK-NEXT: #0 {{.*}}critical-unrelated.c:29
 // CHECK: DONE
 // CHECK: ThreadSanitizer: reported 1 warnings
-

openmp/tools/archer/tests/races/lock-nested-unrelated.c

 /*
  * lock-nested-unrelated.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 // RUN: %libarcher-compile-and-run-race | FileCheck %s
 // REQUIRES: tsan
 #include <omp.h>
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int var = 0;
 

 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   {{(Write|Read)}} of size 4
 // CHECK-NEXT: #0 {{.*}}lock-nested-unrelated.c:33
 // CHECK:   Previous write of size 4
 // CHECK-NEXT: #0 {{.*}}lock-nested-unrelated.c:33
 // CHECK: DONE
 // CHECK: ThreadSanitizer: reported 1 warnings
-

openmp/tools/archer/tests/races/lock-unrelated.c

 /*
  * lock-unrelated.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 // RUN: %libarcher-compile-and-run-race | FileCheck %s
 // REQUIRES: tsan
 #include <omp.h>
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int var = 0;
 

 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   {{(Write|Read)}} of size 4
 // CHECK-NEXT: #0 {{.*}}lock-unrelated.c:31
 // CHECK:   Previous write of size 4
 // CHECK-NEXT: #0 {{.*}}lock-unrelated.c:31
 // CHECK: DONE
 // CHECK: ThreadSanitizer: reported 1 warnings
-

openmp/tools/archer/tests/races/parallel-simple.c

 /*
  * parallel-simple.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 // RUN: %libarcher-compile-and-run-race | FileCheck %s
 // REQUIRES: tsan
 #include <omp.h>
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int var = 0;
 
 #pragma omp parallel num_threads(2) shared(var)
   { var++; }
 
   int error = (var != 2);
   fprintf(stderr, "DONE\n");
   return error;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   {{(Write|Read)}} of size 4
 // CHECK-NEXT: #0 {{.*}}parallel-simple.c:23
 // CHECK:   Previous write of size 4
 // CHECK-NEXT: #0 {{.*}}parallel-simple.c:23
 // CHECK: DONE
 // CHECK: ThreadSanitizer: reported 1 warnings
-

openmp/tools/archer/tests/races/task-dependency.c

 /*
  * task-deoendency.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 // RUN: %libarcher-compile-and-run-race | FileCheck %s
 // REQUIRES: tsan
+#include "ompt/ompt-signal.h"
 #include <omp.h>
 #include <stdio.h>
 #include <unistd.h>
-#include "ompt/ompt-signal.h"
 
 int main(int argc, char *argv[]) {
   int var = 0, a = 0;
 
 #pragma omp parallel num_threads(2) shared(var, a)
 #pragma omp master
   {
 #pragma omp task shared(var, a) depend(out : var)

 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   {{(Write|Read)}} of size 4
 // CHECK-NEXT: #0 {{.*}}task-dependency.c:41
 // CHECK:   Previous write of size 4
 // CHECK-NEXT: #0 {{.*}}task-dependency.c:30
 // CHECK: DONE
 // CHECK: ThreadSanitizer: reported 1 warnings
-

openmp/tools/archer/tests/races/task-taskgroup-unrelated.c

 /*
  * task-taskgroup-unrelated.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // RUN: %libarcher-compile-and-run-race | FileCheck %s
 // REQUIRES: tsan
+#include "ompt/ompt-signal.h"
 #include <omp.h>
 #include <stdio.h>
 #include <unistd.h>
-#include "ompt/ompt-signal.h"
 
 int main(int argc, char *argv[]) {
   int var = 0, a = 0;
 
 #pragma omp parallel num_threads(2) shared(var, a)
 #pragma omp master
   {
 #pragma omp task shared(var, a)
#pragma omp task if (0)
 
   int error = (var != 2);
   fprintf(stderr, "DONE\n");
   return error;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   {{(Write|Read)}} of size 4
-// CHECK-NEXT: #0 {{.*}}task-taskgroup-unrelated.c:46
+// CHECK-NEXT: #0 {{.*}}task-taskgroup-unrelated.c:47
 // CHECK:   Previous write of size 4
-// CHECK-NEXT: #0 {{.*}}task-taskgroup-unrelated.c:28
+// CHECK-NEXT: #0 {{.*}}task-taskgroup-unrelated.c:29
 // CHECK: DONE
 // CHECK: ThreadSanitizer: reported 1 warnings
-

openmp/tools/archer/tests/races/task-taskwait-nested.c

 /*
  * task-taskwait-nested.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 // RUN: %libarcher-compile-and-run-race | FileCheck %s
 // REQUIRES: tsan
+#include "ompt/ompt-signal.h"
 #include <omp.h>
 #include <stdio.h>
 #include <unistd.h>
-#include "ompt/ompt-signal.h"
 
 int main(int argc, char *argv[]) {
   int var = 0, a = 0;
 
 #pragma omp parallel num_threads(2) shared(var, a)
 #pragma omp master
   {
 #pragma omp task shared(var, a)

 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   {{(Write|Read)}} of size 4
 // CHECK-NEXT: #0 {{.*}}task-taskwait-nested.c:34
 // CHECK:   Previous write of size 4
 // CHECK-NEXT: #0 {{.*}}task-taskwait-nested.c:44
 // CHECK: DONE
 // CHECK: ThreadSanitizer: reported 1 warnings
-

openmp/tools/archer/tests/races/task-two.c

 /*
  * task-two.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 // RUN: %libarcher-compile-and-run-race | FileCheck %s
 // REQUIRES: tsan
 #include <omp.h>
 #include <stdio.h>
 #include <unistd.h>
 
 #define NUM_THREADS 2
 
 int main(int argc, char *argv[]) {
   int var = 0;
   int i;
 
-#pragma omp parallel for num_threads(NUM_THREADS) shared(var) schedule(static, \
-                                                                       1)
+#pragma omp parallel for num_threads(NUM_THREADS) shared(var)                  \
+    schedule(static, 1)
   for (i = 0; i < NUM_THREADS; i++) {
 #pragma omp task shared(var) if (0) // the task is inlined an executed locally
     { var++; }
   }
 
   int error = (var != 2);
   fprintf(stderr, "DONE\n");
   return error;
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK-NEXT:   {{(Write|Read)}} of size 4
 // CHECK-NEXT: #0 {{.*}}task-two.c:30
 // CHECK:   Previous write of size 4
 // CHECK-NEXT: #0 {{.*}}task-two.c:30
 // CHECK: DONE
 // CHECK: ThreadSanitizer: reported 1 warnings
-