[OpenMP][test] Regression tests for OpenMPIRBuilder.

[Meinersbur]

Summary

Categorize libomp regression tests according to whether they currently work with -fopenmp-enable-irbuilder. Tests marked with XFAIL are reliably failing. Tests with UNSUPPORTED fail or succeed occasionally. Add some additional tests that currently fail using the OpenMPIRBuilder.

[Meinersbur]

Rebase to head-of-tree

[Meinersbur]

• Fix/adapt tests

[Leporacanthicus]

LGTM. Just one nit-pick, there's a few new tests that test some pretty specific things. Would be nice to have a line or three about what they actually test - e.g "Tests that destructor is not called until after OpenMP section has completed".

openmp/runtime/test/parallel/omp_dtor_parallel_dtor.cpp

9

Would be nice to describe what the test is actually testing.

Although some of the other tests do not describe the purpose either!

[Meinersbur]

The two additional tests cause clang with -fopenmp-enable-irbuilder to crash, their introduction is not motivated by a specific execution behaviour (although that is useful too). D115216 is the basis to fix those. I will add descriptions to the tests.

openmp/runtime/test/atomic/kmp_atomic_cas.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <stdbool.h>
 #include <omp.h>
 
 // Used to detect architecture
 #include "../../src/kmp_platform.h"
 

openmp/runtime/test/atomic/kmp_atomic_cas_cpt.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <stdbool.h>
 #include <omp.h>
 
 // Used to detect architecture
 #include "../../src/kmp_platform.h"
 

openmp/runtime/test/atomic/omp_atomic.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include <math.h>
 #include "omp_testsuite.h"
 
 #define DOUBLE_DIGITS 20  /* dt^DOUBLE_DIGITS */
 #define MAX_FACTOR 10
 #define KNOWN_PRODUCT 3628800  /* 10! */
 

openmp/runtime/test/lit.cfg

 # -*- Python -*- vim: set ft=python ts=4 sw=4 expandtab tw=79:
 # Configuration file for the 'lit' test runner.
 
 import os
 import re
 import subprocess
 import lit.formats
+import shlex
 
 # Tell pylint that we know config and lit_config exist somewhere.
 if 'PYLINT_IMPORT' in os.environ:
     config = object()
     lit_config = object()
 
 def append_dynamic_library_path(path):
     if config.operating_system == 'Windows':

 
 # compiler flags
 flags = " -I " + config.test_source_root + \
     " -L " + config.library_dir + \
     " " + config.test_extra_flags
 config.test_flags = " -I " + config.omp_header_directory + flags
 config.test_flags_use_compiler_omp_h = flags
 
+if "-fopenmp-enable-irbuilder" in (shlex.split(config.test_openmp_flags) + shlex.split(config.test_flags)):
+    config.available_features.add("irbuilder")
+
 # extra libraries
 libs = ""
 if config.has_libm:
     libs += " -lm"
 if config.has_libatomic:
     libs += " -latomic"
 
 # Allow REQUIRES / UNSUPPORTED / XFAIL to work

openmp/runtime/test/lock/omp_lock.c

 // RUN: %libomp-compile-and-run
 // RUN: env KMP_LOCK_KIND=tas KMP_SPIN_BACKOFF_PARAMS=2048,200 %libomp-run
 // RUN: env KMP_LOCK_KIND=futex %libomp-run
+// UNSUPPORTED: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 omp_lock_t lck;
 
 int test_omp_lock()
 {
   int nr_threads_in_single = 0;

openmp/runtime/test/lock/omp_nest_lock.c

 // RUN: %libomp-compile-and-run
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 omp_nest_lock_t lck;
 
 int test_omp_nest_lock()
 {
   int nr_threads_in_single = 0;

openmp/runtime/test/lock/omp_test_lock.c

 // RUN: %libomp-compile-and-run
 // RUN: env KMP_LOCK_KIND=tas %libomp-run
 // RUN: env KMP_LOCK_KIND=futex %libomp-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 omp_lock_t lck;
 
 int test_omp_test_lock()
 {
   int nr_threads_in_single = 0;

openmp/runtime/test/lock/omp_test_nest_lock.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 static omp_nest_lock_t lck;
 
 int test_omp_test_nest_lock()
 {
   int nr_threads_in_single = 0;

openmp/runtime/test/master/omp_master.c

 // RUN: %libomp-compile-and-run
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 int test_omp_master()
 {
   int nthreads;
   int executing_thread;
 

openmp/runtime/test/misc_bugs/cancellation_for_sections.c

 // RUN: %libomp-compile && env OMP_CANCELLATION=true %libomp-run
 // Clang had a bug until version 4.0.1 which resulted in a hang.
 // UNSUPPORTED: clang-3, clang-4.0.0
+// XFAIL: irbuilder
 
 // 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>

openmp/runtime/test/misc_bugs/omp_foreign_thread_team_reuse.c

 // RUN: %libomp-compile-and-run
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 #define NUM_THREADS 10
 
 /*
  After hot teams were enabled by default, the library started using levels
  kept in the team structure.  The levels are broken in case foreign thread

openmp/runtime/test/ompt/cancel/cancel_parallel.c

 // RUN: %libomp-compile && env OMP_CANCELLATION=true %libomp-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // Current GOMP interface implementation does not support cancellation
-// XFAIL: gcc
+// XFAIL: gcc, irbuilder
 
 #include "callback.h"
 #include "omp.h"
 
 int main() {
   #pragma omp parallel num_threads(2)
   {
     if (omp_get_thread_num() == 0) {

openmp/runtime/test/ompt/cancel/cancel_taskgroup.c

 // RUN:  %libomp-compile && env OMP_CANCELLATION=true %libomp-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: clang-3, clang-4.0.0
 // Current GOMP interface implementation does not support cancellation; icc 16 has a bug
-// XFAIL: gcc, icc-16
+// XFAIL: gcc, icc-16, irbuilder
 
 #include "callback.h"
 #include <unistd.h>  
 #include <stdio.h>
 
 int main()
 {
   int condition=0;

openmp/runtime/test/ompt/cancel/cancel_worksharing.c

 // RUN: %libomp-compile && env OMP_CANCELLATION=true %libomp-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // Current GOMP interface implementation does not support cancellation; icc 16 does not distinguish between sections and loops
-// XFAIL: icc-16
+// XFAIL: icc-16, irbuilder
 
 #include "callback.h"
 #include <unistd.h>
 
 int main()
 {
   int condition=0;
   #pragma omp parallel num_threads(2)

openmp/runtime/test/ompt/misc/control_tool.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   #pragma omp parallel num_threads(1)
   {

openmp/runtime/test/ompt/parallel/max_active_levels_serialized.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   omp_set_nested(1);
   omp_set_max_active_levels(1);
 

openmp/runtime/test/ompt/parallel/nested.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN
 #include "callback.h"
 #include <omp.h>
 #include <unistd.h>
 
 int main()
 {
   int condition=0;

openmp/runtime/test/ompt/parallel/nested_lwt.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 #include <unistd.h>
 
 int main()
 {
   omp_set_nested(1);
   int condition = 0;

openmp/runtime/test/ompt/parallel/nested_serialized.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   omp_set_nested(0);
 
   #pragma omp parallel num_threads(4)

openmp/runtime/test/ompt/parallel/nested_thread_num.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=THREADS %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN
 #include "callback.h"
 #include <omp.h>
 #include <unistd.h>
 
 int main() {
   int condition = 0;
   omp_set_nested(1);

openmp/runtime/test/ompt/parallel/parallel_if0.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 
 int main()
 {
 //  print_frame(0);
   #pragma omp parallel if(0)
   {
 //    print_frame(1);

openmp/runtime/test/ompt/parallel/serialized.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 
 int main()
 {
 //  print_frame(0);
   #pragma omp parallel num_threads(1)
   {
 //    print_frame(1);

openmp/runtime/test/ompt/synchronization/barrier/explicit.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   int x = 0;
 
   #pragma omp parallel num_threads(2)

openmp/runtime/test/ompt/synchronization/barrier/for_loop.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   int y[] = {0,1,2,3};
 
   #pragma omp parallel num_threads(2)

openmp/runtime/test/ompt/synchronization/barrier/single.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   int x = 0;
 
   #pragma omp parallel num_threads(2)

openmp/runtime/test/ompt/synchronization/flush.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // GCC generates code that does not call the runtime for the flush construct
-// XFAIL: gcc
+// XFAIL: gcc,irbuilder
 
 #include "callback.h"
 #include <omp.h>
 
 int main() {
 #pragma omp parallel num_threads(2)
   {
     int tid = omp_get_thread_num();

openmp/runtime/test/ompt/synchronization/masked.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 // GCC generates code that does not call the runtime for the master construct
-// XFAIL: gcc
+// XFAIL: gcc,irbuilder
 
 #include "callback.h"
 #include <omp.h>
 
 int main() {
   int x = 0;
 #pragma omp parallel num_threads(2)
   {

openmp/runtime/test/ompt/synchronization/master.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 // GCC generates code that does not call the runtime for the master construct
-// XFAIL: gcc
+// XFAIL: gcc,irbuilder
 
 #define USE_PRIVATE_TOOL 1
 #include "callback.h"
 #include <omp.h>
 
 int main() {
   int x = 0;
 #pragma omp parallel num_threads(2)

openmp/runtime/test/ompt/synchronization/taskgroup.c

 // RUN:  %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
 
 #include "callback.h"
 #include <unistd.h>  
 #include <stdio.h>
 
 int main()
 {
   int condition=0;

openmp/runtime/test/ompt/synchronization/taskwait.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   int x = 0;
   #pragma omp parallel num_threads(2)
   {

openmp/runtime/test/ompt/synchronization/test_nest_lock_parallel.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
   omp_nest_lock_t nest_lock;
   omp_init_nest_lock(&nest_lock);
 

openmp/runtime/test/ompt/tasks/dependences.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
 
 #include "callback.h"
 #include <omp.h>
 #include <math.h>
 #include <unistd.h>
 
 int main() {
   int x = 0;

openmp/runtime/test/ompt/tasks/dependences_mutexinoutset.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
+// XFAIL: irbuilder
 
 // GCC 9 introduced codegen for mutexinoutset
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8
 
 // icc does not yet support mutexinoutset
 // XFAIL: icc
 
 // clang 9 introduced codegen for mutexinoutset

openmp/runtime/test/ompt/tasks/explicit_task.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN
 #include "callback.h"
 #include <omp.h> 
 
 int main()
 {
   int condition=0;
   omp_set_nested(0);

openmp/runtime/test/ompt/tasks/serialized.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #define TEST_NEED_PRINT_FRAME_FROM_OUTLINED_FN
 #include "callback.h"
 #include <omp.h>
 #include <math.h>
 
 int main() {
   omp_set_nested(0);
   print_frame(0);

openmp/runtime/test/ompt/tasks/task_if0-depend.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
+// XFAIL: irbuilder
 
 #include "callback.h"
 #include <omp.h>
 
 int main() {
   int x = 0;
 #pragma omp parallel num_threads(2)
   {

openmp/runtime/test/ompt/tasks/task_late_fulfill.c

 // RUN: %libomp-compile && env OMP_NUM_THREADS='3' \
 // RUN:    %libomp-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
+// XFAIL: irbuilder
 
 // Checked gcc 10.1 still does not support detach clause on task construct.
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8, gcc-9, gcc-10
 // gcc 11 introduced detach clause, but gomp interface in libomp has no support
 // XFAIL: gcc-11, gcc-12
 // clang supports detach clause since version 11.
 // UNSUPPORTED: clang-10, clang-9, clang-8, clang-7
 // icc compiler does not support detach clause.

openmp/runtime/test/ompt/tasks/task_memory.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
+
 #define USE_PRIVATE_TOOL 1
 #include "callback.h"
 #include <omp.h>
 
 int main() {
   int x;
 #pragma omp parallel num_threads(2)
   {

openmp/runtime/test/ompt/tasks/task_types.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
+// XFAIL: irbuilder
+
 #include "callback.h"
 #include <omp.h>
 #include <math.h>
 
 int main() {
   //initialize the OpenMP runtime
   omp_get_num_threads();
 

openmp/runtime/test/ompt/tasks/task_types_serialized.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
+// XFAIL: irbuilder
 
 #include "callback.h"
 #include <omp.h>
 
 __attribute__ ((noinline)) // workaround for bug in icc
 void print_task_type(int id)
 {
   #pragma omp critical

openmp/runtime/test/ompt/tasks/taskwait-depend.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 
 // taskwait with depend clause was introduced with gcc-9
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8
 
 // icc does not yet support taskwait with depend clause
 // XFAIL: icc
 
 // support for taskwait with depend clause introduced in clang-14
 // UNSUPPORTED: clang-5, clang-6, clang-6, clang-8, clang-9, clang-10, clang-11,
 // clang-12, clang-13
+// XFAIL: irbuilder
 
 #include "callback.h"
 #include <omp.h>
 
 int main() {
   int x = 0;
 #pragma omp parallel num_threads(2)
   {

openmp/runtime/test/ompt/tasks/taskyield.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 // Current GOMP interface implements taskyield as stub
-// XFAIL: gcc
+// XFAIL: gcc,irbuilder
 
 #include "callback.h"
 #include <omp.h>   
 #include <unistd.h>
 
 int main()
 {
   int condition=0, x=0;

openmp/runtime/test/ompt/worksharing/for/auto_split.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h
 // REQUIRES: ompt
 // GCC doesn't call runtime for auto = static schedule
 // XFAIL: gcc
+// XFAIL: irbuilder
 
 #define SCHEDULE auto
 #include "base_split.h"

openmp/runtime/test/ompt/worksharing/for/dynamic_split.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
 
 #define SCHEDULE dynamic
 #include "base_split.h"

openmp/runtime/test/ompt/worksharing/for/guided_split.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
 
 #define SCHEDULE guided
 #include "base_split.h"

openmp/runtime/test/ompt/worksharing/for/runtime_split.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h
 // REQUIRES: ompt
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7
+// XFAIL: irbuilder
 
 #define SCHEDULE runtime
 #include "base_split.h"

openmp/runtime/test/ompt/worksharing/for/static_split.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %S/base_split.h
 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck --check-prefix=CHECK-LOOP %S/base_split.h
 // REQUIRES: ompt
 // GCC doesn't call runtime for static schedule
 // XFAIL: gcc
+// XFAIL: irbuilder
 
 #define SCHEDULE static
 #include "base_split.h"

openmp/runtime/test/parallel/omp_dtor_parallel_dtor.cpp

+// RUN: %libomp-cxx-compile
+// RUN: %libomp-run
+
+// XFAIL: irbuilder
+
+#include <stddef.h>
+#include <stdio.h>
+#include <omp.h>
+
+struct Destructible {
+  int &Ref;
+  int Count;
+  Destructible(int &Ref, int Count) : Ref(Ref), Count(Count) {}
+  ~Destructible() { Ref += Count; }
+};
+
+int main() {
+  int common = 0;
+  int result[2] = {0, 0};
+
+  Destructible dtor1{common, 1};
+
+#pragma omp parallel num_threads(2)
+  {
+    int tid = omp_get_thread_num();
+    Destructible dtor2{result[tid], 1};
+  }
+
+  if (common == 0 && result[0] == 1 && result[1] == 1) {
+    printf("SUCCESS\n");
+    return EXIT_SUCCESS;
+  }
+  printf("FAILED (%d, %d, %d)\n", common, result[0], result[1]);
+  return EXIT_FAILURE;
+}

openmp/runtime/test/parallel/omp_parallel_copyin.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "omp_testsuite.h"
 
 static int sum1 = 789;
 #pragma omp threadprivate(sum1)
 
 int test_omp_parallel_copyin()

openmp/runtime/test/parallel/omp_parallel_default.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 int test_omp_parallel_default()
 {
   int i;
   int sum;
   int mysum;

openmp/runtime/test/parallel/omp_parallel_firstprivate.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "omp_testsuite.h"
 
 //static int sum1 = 789;
 
 int test_omp_parallel_firstprivate()
 {

openmp/runtime/test/parallel/omp_parallel_goto.c

+// RUN: %libomp-compile
+// RUN: %libomp-run
+
+// XFAIL: irbuilder
+
+#include <stddef.h>
+#include <stdio.h>
+#include <omp.h>
+
+int main() {
+  int result[] = {0, 0};
+
+#pragma omp parallel num_threads(2)
+  {
+    int tid = omp_get_thread_num();
+    result[tid] += 1;
+    goto cont;
+
+  orphaned:
+    result[tid] += 2;
+    printf("Never executed\n");
+
+  cont:
+    result[tid] += 4;
+  }
+
+  if (result[0] == 5 && result[1] == 5) {
+    printf("SUCCESS\n");
+    return EXIT_SUCCESS;
+  }
+
+  printf("FAILED\n");
+  return EXIT_FAILURE;
+}

openmp/runtime/test/parallel/omp_parallel_if.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 int test_omp_parallel_if()
 {
   int i;
   int sum;
   int known_sum;

openmp/runtime/test/parallel/omp_parallel_private.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include <stdlib.h>
 #include "omp_testsuite.h"
 
 //static int sum1 = 789;
 
 int test_omp_parallel_private()
 {

openmp/runtime/test/parallel/omp_parallel_shared.c

 // RUN: %libomp-compile-and-run
+// UNSUPPORTED: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 int test_omp_parallel_shared()
 {
   int i;
   int sum;
   int known_sum;

openmp/runtime/test/tasking/bug_taskwait_detach.cpp

 // RUN: %libomp-cxx-compile-and-run
+// XFAIL: irbuilder
 
 #include <omp.h>
 
 #include <chrono>
 #include <cstdint>
 #include <iostream>
 #include <thread>
 

openmp/runtime/test/tasking/hidden_helper_task/gtid.cpp

 // RUN: %libomp-cxx-compile-and-run
 // RUN: %libomp-cxx-compile && env OMP_NUM_THREADS=1 %libomp-run
+// XFAIL: irbuilder
 
 /*
  * This test aims to check whether hidden helper thread has right gtid. We also
  * test if there is mixed dependences between regular tasks and hidden helper
  * tasks, the tasks are executed by right set of threads. It is equivalent to
  * the following code:
  *
  * #pragma omp parallel for

openmp/runtime/test/tasking/kmp_detach_tasks_t1.c

 // RUN: %libomp-compile && env OMP_NUM_THREADS='3' %libomp-run
 // RUN: %libomp-compile && env OMP_NUM_THREADS='1' %libomp-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <omp.h>
 #include "omp_my_sleep.h"
 
 // detached untied
 #define PTASK_FLAG_DETACHABLE 0x40
 

openmp/runtime/test/tasking/kmp_detach_tasks_t2.c

 // RUN: %libomp-compile && env OMP_NUM_THREADS='3' %libomp-run
 // RUN: %libomp-compile && env OMP_NUM_THREADS='1' %libomp-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <omp.h>
 #include "omp_my_sleep.h"
 
 // detached tied
 #define PTASK_FLAG_DETACHABLE 0x41
 

openmp/runtime/test/tasking/kmp_detach_tasks_t3.c

 // RUN: %libomp-compile && env OMP_NUM_THREADS='3' %libomp-run
 // RUN: %libomp-compile && env OMP_NUM_THREADS='1' %libomp-run
 // The runtime currently does not get dependency information from GCC.
 // UNSUPPORTED: gcc
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <omp.h>
 #include "omp_my_sleep.h"
 
 // detached untied
 #define PTASK_FLAG_DETACHABLE 0x40
 

openmp/runtime/test/tasking/kmp_task_depend_all.c

 // RUN: %libomp-compile-and-run
 // The runtime currently does not get dependency information from GCC.
 // UNSUPPORTED: gcc
+// XFAIL: irbuilder
 
 // Tests OMP 5.x task dependence "omp_all_memory",
 // emulates compiler codegen versions for new dep kind
 //
 // Task tree created:
 //      task0 - task1 (in: i1, i2)
 //             \
 //        task2 (inoutset: i2), (in: i1)

openmp/runtime/test/tasking/kmp_task_modifier_simple_par_new.cpp

 // RUN: %libomp-cxx-compile-and-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <omp.h>
 
 #define NT 4
 #define INIT 10
 
 /*

openmp/runtime/test/tasking/kmp_task_modifier_simple_par_old.cpp

 // RUN: %libomp-cxx-compile-and-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <omp.h>
 
 #define NT 4
 #define INIT 10
 
 /*

openmp/runtime/test/tasking/kmp_task_modifier_simple_ws_new.cpp

 // RUN: %libomp-cxx-compile-and-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <omp.h>
 
 #define NT 4
 #define INIT 10
 
 /*

openmp/runtime/test/tasking/kmp_task_modifier_simple_ws_old.cpp

 // RUN: %libomp-cxx-compile-and-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <omp.h>
 
 #define NT 4
 #define INIT 10
 
 /*

openmp/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
+// XFAIL: gcc-4,irbuilder
+
 #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
 

openmp/runtime/test/tasking/kmp_taskloop.c

 // RUN: %libomp-compile-and-run
 // RUN: %libomp-compile && env KMP_TASKLOOP_MIN_TASKS=1 %libomp-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include <omp.h>
 #include "omp_my_sleep.h"
 
 #define N 4
 #define GRAIN 10
 #define STRIDE 3
 

openmp/runtime/test/tasking/kmp_taskloop_5.c

 // RUN: %libomp-compile-and-run
 // RUN: %libomp-compile && env KMP_TASKLOOP_MIN_TASKS=1 %libomp-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <omp.h>
 #include "omp_my_sleep.h"
 
 #define N 4
 #define ST 3
 #define UB 118

openmp/runtime/test/tasking/kmp_taskwait_depend_all.c

 // RUN: %libomp-compile-and-run
 // The runtime currently does not get dependency information from GCC.
 // UNSUPPORTED: gcc
+// XFAIL: irbuilder
 
 // Tests OMP 5.x task dependence "omp_all_memory",
 // emulates compiler codegen versions for new dep kind
 //
 // Task tree created:
 //      task0 - task1 (in: i1, i2)
 //             \
 //        task2 (inoutset: i2), (in: i1)

openmp/runtime/test/tasking/kmp_taskwait_depend_in.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 // test checks IN dep kind in depend clause on taskwait construct
 // uses codegen emulation
 #include <stdio.h>
 #include <omp.h>
 // ---------------------------------------------------------------------------
 // internal data to emulate compiler codegen
 typedef struct DEP {

openmp/runtime/test/tasking/kmp_taskwait_nowait.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 // test checks IN dep kind in depend clause on taskwait nowait
 // uses codegen emulation
 // Note: no outlined task routine used
 #include <stdio.h>
 #include <omp.h>
 // ---------------------------------------------------------------------------
 // internal data to emulate compiler codegen

openmp/runtime/test/tasking/omp50_task_depend_mtx.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 // Tests OMP 5.0 task dependences "mutexinoutset", emulates compiler codegen
 // Mutually exclusive tasks get same input dependency info array
 //
 // Task tree created:
 //      task0 task1
 //         \    / \
 //         task2   task5

openmp/runtime/test/tasking/omp50_task_depend_mtx2.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 // Tests OMP 5.0 task dependences "mutexinoutset", emulates compiler codegen
 // Mutually exclusive tasks get input dependency info array sorted differently
 //
 // Task tree created:
 //      task0 task1
 //         \    / \
 //         task2   task5

openmp/runtime/test/tasking/omp50_task_depend_mtx3.c

 // RUN: %libomp-compile-and-run
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8
 // UNSUPPORTED: clang-3, clang-4, clang-5, clang-6, clang-7, clang-8
 // TODO: update expected result when icc supports mutexinoutset
-// XFAIL: icc
+// XFAIL: icc,irbuilder
 
 // Tests OMP 5.0 task dependences "mutexinoutset", emulates compiler codegen
 // Mutually exclusive tasks get same input dependency info array
 //
 // Task tree created:
 //      task0 task1
 //         \    / \
 //         task2   task5

openmp/runtime/test/tasking/omp50_taskdep_depobj.c

 // RUN: %clang %openmp_flags %flags-use-compiler-omp-h %s -o %t && %libomp-run
 // UNSUPPORTED: gcc-5, gcc-6, gcc-7, gcc-8
 // UNSUPPORTED: clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
 // UNSUPPORTED: icc
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 #include "omp_my_sleep.h"
 
 int a, b;
 

openmp/runtime/test/tasking/omp50_taskwait_depend.c

 // RUN: %libomp-compile-and-run
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8
 
 // support for taskwait with depend clause introduced in clang-14
 // UNSUPPORTED: clang-5, clang-6, clang-6, clang-8, clang-9, clang-10, clang-11,
 // clang-12, clang-13
+// XFAIL: irbuilder
 
 // icc does not yet support taskwait with depend clause
 // XFAIL: icc
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 #include "omp_my_sleep.h"

openmp/runtime/test/tasking/omp51_task_dep_inoutset.c

 // RUN: %libomp-compile-and-run
 // RUN: %libomp-cxx-compile-and-run
 // UNSUPPORTED: gcc
+// XFAIL: irbuilder
 
 // Tests OMP 5.0 task dependences "mutexinoutset" and 5.1 "inoutset",
 // emulates compiler codegen for new dep kinds
 // Mutually exclusive tasks get same input dependency info array
 //
 // Task tree created:
 //      task0 - task1 (in)
 //             \

openmp/runtime/test/tasking/omp_detach_taskwait.c

 // RUN: %libomp-compile && env OMP_NUM_THREADS='3' %libomp-run
 // RUN: %libomp-compile && env OMP_NUM_THREADS='1' %libomp-run
+// XFAIL: irbuilder
 
 // Checked gcc 10.1 still does not support detach clause on task construct.
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8, gcc-9, gcc-10
 // gcc 11 introduced detach clause, but gomp interface in libomp has no support
 // XFAIL: gcc-11, gcc-12
 // clang supports detach clause since version 11.
 // UNSUPPORTED: clang-10, clang-9, clang-8, clang-7
 // icc compiler does not support detach clause.

openmp/runtime/test/tasking/omp_task_imp_firstprivate.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include <math.h>
 #include "omp_testsuite.h"
 
 /* Utility function do spend some time in a loop */
 int test_omp_task_imp_firstprivate()
 {
   int i=5;

openmp/runtime/test/tasking/omp_taskwait.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 // This test is known to be fragile on NetBSD kernel at the moment,
 // https://bugs.llvm.org/show_bug.cgi?id=42020.
 // UNSUPPORTED: netbsd
 #include <stdio.h>
 #include <math.h>
 #include "omp_testsuite.h"
 #include "omp_my_sleep.h"

openmp/runtime/test/tasking/task_reduction3.c

 // RUN: %libomp-compile-and-run
 
-// XFAIL: icc
+// XFAIL: icc, irbuilder
 // UNSUPPORTED: clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8
 
 #include <stdio.h>
 #include <stdlib.h>
 
 int a = 0, b = 1;
 

openmp/runtime/test/tasking/task_reduction4.c

 // RUN: %libomp-compile-and-run
 
-// XFAIL: icc
+// XFAIL: icc, irbuilder
 // UNSUPPORTED: clang-4, clang-5, clang-6, clang-7, clang-8, clang-9, clang-10
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8
 
 #include <stdio.h>
 #include <stdlib.h>
 
 int a = 0, b = 1;
 

openmp/runtime/test/tasking/taskdep_if0_2.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 #include "omp_my_sleep.h"
 
 int a = 0, b = 0;
 int task_grabbed = 0, task_can_proceed = 0;

openmp/runtime/test/teams/kmp_num_teams.c

 // RUN: %libomp-compile-and-run
 // UNSUPPORTED: gcc
+// XFAIL: irbuilder
 // Linking fails for icc 18/19
 // UNSUPPORTED: icc-18, icc-19
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 
 #define NT 8

openmp/runtime/test/threadprivate/omp_threadprivate.c

 // RUN: %libomp-compile-and-run
+// UNSUPPORTED: irbuilder
+
 /*
  * Threadprivate is tested in 2 ways:
  * 1. The global variable declared as threadprivate should have
  *  local copy for each thread. Otherwise race condition and
  *  wrong result.
  * 2. If the value of local copy is retained for the two adjacent
  *  parallel regions
  */

openmp/runtime/test/worksharing/for/kmp_sch_simd_runtime_api.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
 
 // The test checks schedule(simd:runtime)
 // in combination with omp_set_schedule()
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 
 #if defined(WIN32) || defined(_WIN32)

openmp/runtime/test/worksharing/for/kmp_sch_simd_runtime_guided.c

 // RUN: %libomp-compile
 // RUN: env OMP_SCHEDULE=guided    %libomp-run
 // RUN: env OMP_SCHEDULE=guided,1  %libomp-run 1
 // RUN: env OMP_SCHEDULE=guided,2  %libomp-run 2
 // RUN: env OMP_SCHEDULE=dynamic   %libomp-run
 // RUN: env OMP_SCHEDULE=dynamic,1 %libomp-run 1
 // RUN: env OMP_SCHEDULE=dynamic,2 %libomp-run 2
 // RUN: env OMP_SCHEDULE=auto      %libomp-run
+// XFAIL: irbuilder
 
 // The test checks schedule(simd:runtime)
 // in combination with OMP_SCHEDULE=guided[,chunk]
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
 
 #if defined(WIN32) || defined(_WIN32)

openmp/runtime/test/worksharing/for/kmp_sch_simd_runtime_static.c

 // RUN: %libomp-compile && %libomp-run
 // RUN: %libomp-run 1 && %libomp-run 2
+// XFAIL: irbuilder
 
 // The test checks schedule(simd:runtime)
 // in combination with OMP_SCHEDULE=static[,chunk]
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <omp.h>
 

openmp/runtime/test/worksharing/for/omp_for_collapse.c

 // RUN: %libomp-compile-and-run
+// UNSUPPORTED: irbuilder
+
 #include <stdio.h>
 #include <math.h>
 #include "omp_testsuite.h"
 
 /* Utility function to check that i is increasing monotonically
    with each call */
 static int check_i_islarger (int i)
 {

openmp/runtime/test/worksharing/for/omp_parallel_for_static.c

+// RUN: %libomp-compile
+// RUN: %libomp-run
+
+#include <stddef.h>
+#include <stdio.h>
+#include <omp.h>
+
+int main() {
+  int result[2] = {0, 0};
+
+#pragma omp parallel num_threads(2)
+  {
+    int tid = omp_get_thread_num();
+#pragma omp for schedule(static)
+    for (int i = 0; i < 6; i += 1)
+      result[tid] += 1 << i;
+  }
+
+  if (result[0] == 1 + 2 + 4 && result[1] == 8 + 16 + 32) {
+    printf("SUCCESS\n");
+    return EXIT_SUCCESS;
+  }
+  printf("FAILED\n");
+  return EXIT_FAILURE;
+}

openmp/runtime/test/worksharing/for/omp_parallel_for_static_chunked.c

+// RUN: %libomp-compile
+// RUN: %libomp-run
+
+#include <stddef.h>
+#include <stdio.h>
+#include <omp.h>
+
+int main() {
+  int result[2] = {0, 0};
+
+#pragma omp parallel num_threads(2)
+  {
+    int tid = omp_get_thread_num();
+#pragma omp for schedule(static, 3)
+    for (int i = 0; i < 10; i += 1)
+      result[tid] += 1 << i;
+  }
+
+  if (result[0] == 1 + 2 + 4 + 64 + 128 + 256 &&
+      result[1] == 8 + 16 + 32 + 512) {
+    printf("SUCCESS\n");
+    return EXIT_SUCCESS;
+  }
+  printf("FAILED\n");
+  return EXIT_FAILURE;
+}

openmp/runtime/test/worksharing/sections/omp_section_lastprivate.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 int test_omp_section_lastprivate()
 {
   int i0 = -1;
   int sum = 0;
   int i;

openmp/runtime/test/worksharing/sections/omp_section_private.c

 // RUN: %libomp-compile-and-run
+// UNSUPPORTED: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 int test_omp_section_private()
 {
   int sum;
   int sum0;
   int i;

openmp/runtime/test/worksharing/sections/omp_sections_nowait.c

 // RUN: %libomp-compile-and-run
+// UNSUPPORTED: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 /*
  * This test will hang if the nowait is not working properly
  *
  * It relies on a thread skipping to the second sections construct to
  * release the threads in the first sections construct

openmp/runtime/test/worksharing/sections/omp_sections_reduction.c

 // RUN: %libomp-compile-and-run
+// UNSUPPORTED: irbuilder
+
 #include <stdio.h>
 #include <math.h>
 #include "omp_testsuite.h"
 
 int test_omp_sections_reduction()
 {
   int sum;
   int known_sum;

openmp/runtime/test/worksharing/single/omp_single.c

 // RUN: %libomp-compile-and-run
+// UNSUPPORTED: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 int test_omp_single()
 {
   int nr_threads_in_single;
   int result;
   int nr_iterations;

openmp/runtime/test/worksharing/single/omp_single_private.c

 // RUN: %libomp-compile-and-run
+// XFAIL: irbuilder
+
 #include <stdio.h>
 #include "omp_testsuite.h"
 
 int myit = 0;
 #pragma omp threadprivate(myit)
 int myresult = 0;
 #pragma omp threadprivate(myresult)
 

openmp/tools/archer/tests/lit.cfg

 # -*- Python -*- vim: set ft=python ts=4 sw=4 expandtab tw=79:
 # Configuration file for the 'lit' test runner.
 
 import os
 import re
 import subprocess
 import lit.formats
+import shlex
 
 # Tell pylint that we know config and lit_config exist somewhere.
 if 'PYLINT_IMPORT' in os.environ:
     config = object()
     lit_config = object()
 
 def append_dynamic_library_path(path):
     if config.operating_system == 'Windows':

 # 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_archer_flags + \
     " " + config.test_extra_flags
 
+if "-fopenmp-enable-irbuilder" in (shlex.split(config.test_openmp_flags) + shlex.split(config.test_flags)):
+    config.available_features.add("irbuilder")
+
 config.archer_flags = "-g -O1 -fsanitize=thread"
 
 
 # extra libraries
 libs = ""
 if config.has_libatomic:
     libs += " -latomic"
 

openmp/tools/archer/tests/parallel/parallel-firstprivate.c

 /*
  * parallel-firstprivate.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 | FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #include <omp.h>
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int var = 0;
 
 #pragma omp parallel num_threads(2) firstprivate(var)
   { var = 1; }

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

 /*
  * task-dependency.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
 // RUN: %libarcher-compile-and-run-race-noserial | FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #include "ompt/ompt-signal.h"
 #include <omp.h>
 #include <stdio.h>
 #include <unistd.h>
 
 int main(int argc, char *argv[]) {
   int var = 0, a = 0, b = 0;
 

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
 // RUN: %libarcher-compile-and-run-race-noserial | FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #include "ompt/ompt-signal.h"
 #include <omp.h>
 #include <stdio.h>
 #include <unistd.h>
 
 int main(int argc, char *argv[]) {
   int var = 0, a = 0;
 

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
 // RUN: %libarcher-compile-and-run-race-noserial | FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #include "ompt/ompt-signal.h"
 #include <omp.h>
 #include <stdio.h>
 #include <unistd.h>
 
 int main(int argc, char *argv[]) {
   int var = 0, a = 0;
 

openmp/tools/archer/tests/reduction/parallel-reduction-nowait.c

 /*
  * parallel-reduction-nowait.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 | FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #include <omp.h>
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int var = 0, i;
   int sum1 = 0;
   int sum2 = 0;
 

openmp/tools/archer/tests/reduction/parallel-reduction.c

 /*
  * parallel-reduction.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| FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #include <omp.h>
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int var = 0;
 
 // Number of threads is empirical: We need enough threads so that
 // the reduction is really performed hierarchically in the barrier!

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

 /*
  * task-dependency.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 | FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #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;
 

openmp/tools/archer/tests/task/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 | FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #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;
 

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

 /*
  * task-taskwait.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 | FileCheck %s
 // REQUIRES: tsan
+// XFAIL: irbuilder
+
 #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;
 

openmp/tools/archer/tests/task/task_late_fulfill.c

 // RUN: %libarcher-compile -fopenmp-version=50 && env OMP_NUM_THREADS='3' \
 // RUN:   %libarcher-run-race | FileCheck %s
 
 // Checked gcc 10.1 still does not support detach clause on task construct.
 // UNSUPPORTED: gcc-4, gcc-5, gcc-6, gcc-7, gcc-8, gcc-9, gcc-10
 // gcc 11 introduced detach clause, but gomp interface in libomp has no support
 // XFAIL: gcc-11, gcc-12
 // clang supports detach clause since version 11.
 // UNSUPPORTED: clang-10, clang-9, clang-8, clang-7
 // icc compiler does not support detach clause.
 // UNSUPPORTED: icc
 // REQUIRES: tsan
+// XFAIL: irbuilder
 
 #include <omp.h>
 #include <stdio.h>
 #include <unistd.h>
 
 int main() {
 #pragma omp parallel
 #pragma omp master