[OpenMP][libomp] Introduce oneAPI compiler support

[jlpeyton]

Summary

Introduce KMP_COMPILER_ICX macro to represent compilation with oneAPI compiler. This is just paired with KMP_COMPILER_ICC in most places

Fixup flag detection and compiler ID detection in CMake. Older CMake's detect IntelLLVM as Clang. Check for the __INTEL_CLANG_COMPILER pre-defined macro to determine if actually using oneAPI compiler.

Fix many compiler warnings from oneAPI compiler (both Linux and Windows). Many are unused variable warnings.

Fixup many of the tests to have non-empty parallel regions as they are elided by oneAPI compiler. Also have OMPT tests include -fno-omit-frame-pointer when available as oneAPI removes it by default.

[AndreyChurbanov]

openmp/runtime/test/ompt/callback.h

15 ↗

(On Diff #404749)

This header should be included as "../omp_testsuite.h". Otherwise "file not found" error issued on two tests of OMPT multiplex (tried "make check-openmp").

[jlpeyton]

Update to address Andrey's comments.

I removed the indirect include of omp_testsuite.h (through callback.h) and just directly included it in the relevant OMPT tests. This avoids affecting the projects in the openmp/tools/ subdirectory and those tests that rely on callback.h.

[AndreyChurbanov]

LGTM

[jlpeyton]

Forgot the Differential Revision: link in the commit message. This is closed by commit: https://github.com/llvm/llvm-project/commit/1234011b80f835a297482467ca6ca2099677c39c

openmp/cmake/DetectTestCompiler/CMakeLists.txt

 cmake_minimum_required(VERSION 3.13.4)
 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}")
+  set(information "${information}\\;${${lang}_HAS_OMIT_FRAME_POINTER}")
   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()
 
+check_c_compiler_flag("-fno-omit-frame-pointer" C_HAS_OMIT_FRAME_POINTER)
+check_cxx_compiler_flag("-fno-omit-frame-pointer" CXX_HAS_OMIT_FRAME_POINTER)
+
 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)
+  list(GET information 5 has_omit_frame_pointer_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})
+  set(OPENMP_TEST_${lang}_COMPILER_HAS_OMIT_FRAME_POINTER_FLAGS ${has_omit_frame_pointer_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)
+    set(OPENMP_TEST_COMPILER_HAS_OMIT_FRAME_POINTER_FLAGS "${OPENMP_TEST_C_COMPILER_HAS_OMIT_FRAME_POINTER_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()
   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")
+  set(OPENMP_TEST_COMPILER_HAS_OMIT_FRAME_POINTER_FLAGS 1)
 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")
   elseif ("${OPENMP_TEST_COMPILER_ID}" STREQUAL "Intel")
     set(comp "icc")

openmp/cmake/config-ix.cmake

 include(CheckCXXCompilerFlag)
+include(CheckCXXSourceCompiles)
+
+# Check for oneAPI compiler (some older CMake versions detect as Clang)
+if (CMAKE_C_COMPILER_ID STREQUAL "Clang")
+  check_cxx_source_compiles("#if (defined(__INTEL_CLANG_COMPILER) || defined(__INTEL_LLVM_COMPILER))
+                             int main() { return 0; }
+                             #else
+                             not oneAPI
+                             #endif" OPENMP_HAVE_ONEAPI_COMPILER)
+  if (OPENMP_HAVE_ONEAPI_COMPILER)
+    # According to CMake documentation, the compiler id should
+    # be IntelLLVM when detected oneAPI
+    set(CMAKE_C_COMPILER_ID "IntelLLVM")
+    set(CMAKE_CXX_COMPILER_ID "IntelLLVM")
+  endif()
+endif()
 
 check_cxx_compiler_flag(-Wall OPENMP_HAVE_WALL_FLAG)
 check_cxx_compiler_flag(-Werror OPENMP_HAVE_WERROR_FLAG)
 
 # Additional warnings that are not enabled by -Wall.
 check_cxx_compiler_flag(-Wcast-qual OPENMP_HAVE_WCAST_QUAL_FLAG)
 check_cxx_compiler_flag(-Wformat-pedantic OPENMP_HAVE_WFORMAT_PEDANTIC_FLAG)
 check_cxx_compiler_flag(-Wimplicit-fallthrough OPENMP_HAVE_WIMPLICIT_FALLTHROUGH_FLAG)
 check_cxx_compiler_flag(-Wsign-compare OPENMP_HAVE_WSIGN_COMPARE_FLAG)
 
 # Warnings that we want to disable because they are too verbose or fragile.
 check_cxx_compiler_flag(-Wno-extra OPENMP_HAVE_WNO_EXTRA_FLAG)
 check_cxx_compiler_flag(-Wno-pedantic OPENMP_HAVE_WNO_PEDANTIC_FLAG)
 check_cxx_compiler_flag(-Wno-maybe-uninitialized OPENMP_HAVE_WNO_MAYBE_UNINITIALIZED_FLAG)
 
 check_cxx_compiler_flag(-std=c++14 OPENMP_HAVE_STD_CPP14_FLAG)

openmp/runtime/cmake/LibompCheckLinkerFlag.cmake

set(library_source
     "int foo(int a) { return a*a; }")
   set(cmake_source
     "cmake_minimum_required(VERSION 3.13.4)
      project(foo C)
      set(CMAKE_SHARED_LINKER_FLAGS \"${flag}\")
      add_library(foo SHARED src_to_link.c)")
   # Compiling as a part of runtimes introduces ARCH-unknown-linux-gnu as a part
   # of a working directory.  So adding a guard for unknown.
-  set(failed_regexes "[Ee]rror;[Uu]nknown[^-];[Ss]kipping;LINK : warning")
+  set(failed_regexes "[Ee]rror;[Uu]nknown[^-];[Ss]kipping;LINK : warning;Unsupported command line")
   set(base_dir ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/link_flag_check_${boolean})
   file(MAKE_DIRECTORY ${base_dir})
   file(MAKE_DIRECTORY ${base_dir}/build)
   file(WRITE ${base_dir}/src_to_link.c "${library_source}")
   file(WRITE ${base_dir}/CMakeLists.txt "${cmake_source}")
 
   message(STATUS "Performing Test ${boolean}")
   try_compile(

openmp/runtime/cmake/config-ix.cmake

elseif(NOT APPLE)
   libomp_check_linker_flag(-Wl,--warn-shared-textrel LIBOMP_HAVE_WARN_SHARED_TEXTREL_FLAG)
   libomp_check_linker_flag(-Wl,--as-needed LIBOMP_HAVE_AS_NEEDED_FLAG)
   libomp_check_linker_flag("-Wl,--version-script=${LIBOMP_SRC_DIR}/exports_so.txt" LIBOMP_HAVE_VERSION_SCRIPT_FLAG)
   libomp_check_linker_flag(-static-libgcc LIBOMP_HAVE_STATIC_LIBGCC_FLAG)
   libomp_check_linker_flag(-Wl,-z,noexecstack LIBOMP_HAVE_Z_NOEXECSTACK_FLAG)
 endif()
 
 # Check Intel(R) C Compiler specific flags
-if(CMAKE_C_COMPILER_ID STREQUAL "Intel")
+if(CMAKE_C_COMPILER_ID STREQUAL "Intel" OR CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
   check_cxx_compiler_flag(/Qlong_double LIBOMP_HAVE_LONG_DOUBLE_FLAG)
   check_cxx_compiler_flag(/Qdiag-disable:177 LIBOMP_HAVE_DIAG_DISABLE_177_FLAG)
   check_cxx_compiler_flag(/Qinline-min-size=1 LIBOMP_HAVE_INLINE_MIN_SIZE_FLAG)
   check_cxx_compiler_flag(-Qoption,cpp,--extended_float_types LIBOMP_HAVE_EXTENDED_FLOAT_TYPES_FLAG)
   check_cxx_compiler_flag(-falign-stack=maintain-16-byte LIBOMP_HAVE_FALIGN_STACK_FLAG)
   check_cxx_compiler_flag("-opt-streaming-stores never" LIBOMP_HAVE_OPT_STREAMING_STORES_FLAG)
   libomp_check_linker_flag(-static-intel LIBOMP_HAVE_STATIC_INTEL_FLAG)
   libomp_check_linker_flag(-no-intel-extensions LIBOMP_HAVE_NO_INTEL_EXTENSIONS_FLAG)

 
 # Checking features
 # Check if version symbol assembler directives are supported
 libomp_check_version_symbols(LIBOMP_HAVE_VERSION_SYMBOLS)
 
 # Check if quad precision types are available
 if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
   set(LIBOMP_HAVE_QUAD_PRECISION TRUE)
-elseif(CMAKE_C_COMPILER_ID STREQUAL "Intel")
+elseif(CMAKE_C_COMPILER_ID STREQUAL "Intel" OR CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
   if(LIBOMP_HAVE_EXTENDED_FLOAT_TYPES_FLAG)
     set(LIBOMP_HAVE_QUAD_PRECISION TRUE)
   else()
     set(LIBOMP_HAVE_QUAD_PRECISION TRUE)
   endif()
 else()
   set(LIBOMP_HAVE_QUAD_PRECISION FALSE)
 endif()

openmp/runtime/src/kmp.h

#define KMP_INTERVALS_FROM_BLOCKTIME(blocktime, monitor_wakeups)               \
   (((blocktime) + (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)) - 1) /        \
    (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)))
 #else
 #define KMP_BLOCKTIME(team, tid)                                               \
   (get__bt_set(team, tid) ? get__blocktime(team, tid) : __kmp_dflt_blocktime)
 #if KMP_OS_UNIX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
 // HW TSC is used to reduce overhead (clock tick instead of nanosecond).
 extern kmp_uint64 __kmp_ticks_per_msec;
-#if KMP_COMPILER_ICC
+#if KMP_COMPILER_ICC || KMP_COMPILER_ICX
 #define KMP_NOW() ((kmp_uint64)_rdtsc())
 #else
 #define KMP_NOW() __kmp_hardware_timestamp()
 #endif
 #define KMP_NOW_MSEC() (KMP_NOW() / __kmp_ticks_per_msec)
 #define KMP_BLOCKTIME_INTERVAL(team, tid)                                      \
   (KMP_BLOCKTIME(team, tid) * __kmp_ticks_per_msec)
 #define KMP_BLOCKING(goal, count) ((goal) > KMP_NOW())

openmp/runtime/src/kmp_affinity.cpp

for (int i = 0, j = depth - 1; i < j; ++i, --j) {
     hwloc_types[j] = hwloc_temp;
   }
 
   // Allocate the data structure to be returned.
   __kmp_topology = kmp_topology_t::allocate(__kmp_avail_proc, depth, types);
 
   hw_thread_index = 0;
   pu = NULL;
-  while (pu = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_PU, pu)) {
+  while ((pu = hwloc_get_next_obj_by_type(tp, HWLOC_OBJ_PU, pu))) {
     int index = depth - 1;
     bool included = KMP_CPU_ISSET(pu->os_index, __kmp_affin_fullMask);
     kmp_hw_thread_t &hw_thread = __kmp_topology->at(hw_thread_index);
     if (included) {
       hw_thread.clear();
       hw_thread.ids[index] = pu->logical_index;
       hw_thread.os_id = pu->os_index;
       // If multiple core types, then set that attribute for the hardware thread

openmp/runtime/src/kmp_atomic.h

struct KMP_DO_ALIGN(4) Quad_a4_t {
   }
 };
 
 struct KMP_DO_ALIGN(4) kmp_cmplx128_a4_t {
   kmp_cmplx128 q;
 
   kmp_cmplx128_a4_t() : q() {}
 
+#if defined(__cplusplus) && (KMP_OS_WINDOWS)
+  kmp_cmplx128_a4_t(const std::complex<_Quad> &c128) : q(c128) {}
+#endif
   kmp_cmplx128_a4_t(const kmp_cmplx128 &c128) : q(c128) {}
 
   kmp_cmplx128_a4_t operator+(const kmp_cmplx128_a4_t &b) {
     kmp_cmplx128 lhs = (*this).q;
     kmp_cmplx128 rhs = b.q;
     return (kmp_cmplx128_a4_t)(lhs + rhs);
   }
   kmp_cmplx128_a4_t operator-(const kmp_cmplx128_a4_t &b) {
struct KMP_DO_ALIGN(16) Quad_a16_t {
   }
 };
 
 struct KMP_DO_ALIGN(16) kmp_cmplx128_a16_t {
   kmp_cmplx128 q;
 
   kmp_cmplx128_a16_t() : q() {}
 
+#if defined(__cplusplus) && (KMP_OS_WINDOWS)
+  kmp_cmplx128_a16_t(const std::complex<_Quad> &c128) : q(c128) {}
+#endif
   kmp_cmplx128_a16_t(const kmp_cmplx128 &c128) : q(c128) {}
 
   kmp_cmplx128_a16_t operator+(const kmp_cmplx128_a16_t &b) {
     kmp_cmplx128 lhs = (*this).q;
     kmp_cmplx128 rhs = b.q;
     return (kmp_cmplx128_a16_t)(lhs + rhs);
   }
   kmp_cmplx128_a16_t operator-(const kmp_cmplx128_a16_t &b) {

openmp/runtime/src/kmp_atomic.cpp

KA_TRACE(100,                                                              \
              ("__kmpc_atomic_" #TYPE_ID "_" #OP_ID "_" #RTYPE_ID ": T#%d\n",   \
               gtid));
 
 // -------------------------------------------------------------------------
 #define ATOMIC_CMPXCHG_CPT_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID,       \
                                RTYPE, LCK_ID, MASK, GOMP_FLAG)                 \
   ATOMIC_BEGIN_CPT_MIX(TYPE_ID, OP_ID, TYPE, RTYPE_ID, RTYPE)                  \
   TYPE new_value;                                                              \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_CPT(TYPE, OP, GOMP_FLAG)                                    \
   OP_CMPXCHG_CPT(TYPE, BITS, OP)                                               \
   }
 
 // -------------------------------------------------------------------------
 #define ATOMIC_CRITICAL_CPT_MIX(TYPE_ID, TYPE, OP_ID, OP, RTYPE_ID, RTYPE,     \
                                 LCK_ID, GOMP_FLAG)                             \
   ATOMIC_BEGIN_CPT_MIX(TYPE_ID, OP_ID, TYPE, RTYPE_ID, RTYPE)                  \
   TYPE new_value;                                                              \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_CPT(TYPE, OP, GOMP_FLAG) /* send assignment */              \
   OP_UPDATE_CRITICAL_CPT(TYPE, OP, LCK_ID) /* send assignment */               \
   }
 
 ATOMIC_CMPXCHG_CPT_MIX(fixed1, char, add_cpt, 8, +, fp, _Quad, 1i, 0,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1_add_cpt_fp
 ATOMIC_CMPXCHG_CPT_MIX(fixed1u, uchar, add_cpt, 8, +, fp, _Quad, 1i, 0,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1u_add_cpt_fp

 //     fixed)
 //     OP_ID   - operation identifier (add, sub, mul, ...)
 //     TYPE    - operands' type
 // -------------------------------------------------------------------------
 #define ATOMIC_CMPXCHG_CPT_REV_MIX(TYPE_ID, TYPE, OP_ID, BITS, OP, RTYPE_ID,   \
                                    RTYPE, LCK_ID, MASK, GOMP_FLAG)             \
   ATOMIC_BEGIN_CPT_MIX(TYPE_ID, OP_ID, TYPE, RTYPE_ID, RTYPE)                  \
   TYPE new_value;                                                              \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_CPT_REV(TYPE, OP, GOMP_FLAG)                                \
   OP_CMPXCHG_CPT_REV(TYPE, BITS, OP)                                           \
   }
 
 // -------------------------------------------------------------------------
 #define ATOMIC_CRITICAL_CPT_REV_MIX(TYPE_ID, TYPE, OP_ID, OP, RTYPE_ID, RTYPE, \
                                     LCK_ID, GOMP_FLAG)                         \
   ATOMIC_BEGIN_CPT_MIX(TYPE_ID, OP_ID, TYPE, RTYPE_ID, RTYPE)                  \
   TYPE new_value;                                                              \
+  (void)new_value;                                                             \
   OP_GOMP_CRITICAL_CPT_REV(TYPE, OP, GOMP_FLAG) /* send assignment */          \
   OP_CRITICAL_CPT_REV(TYPE, OP, LCK_ID) /* send assignment */                  \
   }
 
 ATOMIC_CMPXCHG_CPT_REV_MIX(fixed1, char, sub_cpt_rev, 8, -, fp, _Quad, 1i, 0,
                            KMP_ARCH_X86) // __kmpc_atomic_fixed1_sub_cpt_rev_fp
 ATOMIC_CMPXCHG_CPT_REV_MIX(fixed1u, uchar, sub_cpt_rev, 8, -, fp, _Quad, 1i, 0,
                            KMP_ARCH_X86) // __kmpc_atomic_fixed1u_sub_cpt_rev_fp

openmp/runtime/src/kmp_barrier.cpp

 void __kmp_join_barrier(int gtid) {
   KMP_TIME_PARTITIONED_BLOCK(OMP_join_barrier);
   KMP_SET_THREAD_STATE_BLOCK(FORK_JOIN_BARRIER);
 
   KMP_DEBUG_ASSERT(__kmp_threads && __kmp_threads[gtid]);
 
   kmp_info_t *this_thr = __kmp_threads[gtid];
   kmp_team_t *team;
-  kmp_uint nproc;
   int tid;
 #ifdef KMP_DEBUG
   int team_id;
 #endif /* KMP_DEBUG */
 #if USE_ITT_BUILD
   void *itt_sync_obj = NULL;
 #if USE_ITT_NOTIFY
   if (__itt_sync_create_ptr || KMP_ITT_DEBUG) // Don't call routine without need
     // Get object created at fork_barrier
     itt_sync_obj = __kmp_itt_barrier_object(gtid, bs_forkjoin_barrier);
 #endif
 #endif /* USE_ITT_BUILD */
+#if ((USE_ITT_BUILD && USE_ITT_NOTIFY) || defined KMP_DEBUG)
+  int nproc = this_thr->th.th_team_nproc;
+#endif
   KMP_MB();
 
   // Get current info
   team = this_thr->th.th_team;
-  nproc = this_thr->th.th_team_nproc;
-  KMP_DEBUG_ASSERT((int)nproc == team->t.t_nproc);
+  KMP_DEBUG_ASSERT(nproc == team->t.t_nproc);
   tid = __kmp_tid_from_gtid(gtid);
 #ifdef KMP_DEBUG
   team_id = team->t.t_id;
   kmp_info_t *master_thread = this_thr->th.th_team_master;
   if (master_thread != team->t.t_threads[0]) {
     __kmp_print_structure();
   }
 #endif /* KMP_DEBUG */
if ((__itt_frame_submit_v3_ptr || KMP_ITT_DEBUG) &&
         break;
       case 3:
         if (__itt_metadata_add_ptr) {
           // Initialize with primary thread's wait time
           kmp_uint64 delta = cur_time - this_thr->th.th_bar_arrive_time;
           // Set arrive time to zero to be able to check it in
           // __kmp_invoke_task(); the same is done inside the loop below
           this_thr->th.th_bar_arrive_time = 0;
-          for (kmp_uint i = 1; i < nproc; ++i) {
+          for (int i = 1; i < nproc; ++i) {
             delta += (cur_time - other_threads[i]->th.th_bar_arrive_time);
             other_threads[i]->th.th_bar_arrive_time = 0;
           }
           __kmp_itt_metadata_imbalance(gtid, this_thr->th.th_frame_time,
                                        cur_time, delta, 0);
         }
         __kmp_itt_frame_submit(gtid, this_thr->th.th_frame_time, cur_time, 0,
                                loc, nproc);

openmp/runtime/src/kmp_csupport.cpp

#else
   // addressed.
   // mfence is a SSE2 instruction. Do not execute it if CPU is not SSE2.
   if (!__kmp_cpuinfo.initialized) {
     __kmp_query_cpuid(&__kmp_cpuinfo);
   }
   if (!__kmp_cpuinfo.flags.sse2) {
     // CPU cannot execute SSE2 instructions.
   } else {
-#if KMP_COMPILER_ICC
+#if KMP_COMPILER_ICC || KMP_COMPILER_ICX
     _mm_mfence();
 #elif KMP_COMPILER_MSVC
     MemoryBarrier();
 #else
     __sync_synchronize();
-#endif // KMP_COMPILER_ICC
+#endif // KMP_COMPILER_ICC || KMP_COMPILER_ICX
   }
 #endif // KMP_MIC
 #elif (KMP_ARCH_ARM || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS || KMP_ARCH_MIPS64 || \
        KMP_ARCH_RISCV64)
 // Nothing to see here move along
 #elif KMP_ARCH_PPC64
 // Nothing needed here (we have a real MB above).
 #else

openmp/runtime/src/kmp_debugger.cpp

 #undef offset_and_size_of
 #undef addr_and_size_of
 
 /* Intel compiler on IA-32 architecture issues a warning "conversion
   from "unsigned long long" to "char *" may lose significant bits"
   when 64-bit value is assigned to 32-bit pointer. Use this function
   to suppress the warning. */
 static inline void *__kmp_convert_to_ptr(kmp_uint64 addr) {
-#if KMP_COMPILER_ICC
+#if KMP_COMPILER_ICC || KMP_COMPILER_ICX
 #pragma warning(push)
 #pragma warning(disable : 810) // conversion from "unsigned long long" to "char
 // *" may lose significant bits
 #pragma warning(disable : 1195) // conversion from integer to smaller pointer
-#endif // KMP_COMPILER_ICC
+#endif // KMP_COMPILER_ICC || KMP_COMPILER_ICX
   return (void *)addr;
-#if KMP_COMPILER_ICC
+#if KMP_COMPILER_ICC || KMP_COMPILER_ICX
 #pragma warning(pop)
-#endif // KMP_COMPILER_ICC
+#endif // KMP_COMPILER_ICC || KMP_COMPILER_ICX
 } // __kmp_convert_to_ptr
 
 static int kmp_location_match(kmp_str_loc_t *loc, kmp_omp_nthr_item_t *item) {
 
   int file_match = 0;
   int func_match = 0;
   int line_match = 0;
 

openmp/runtime/src/kmp_lock.cpp

 
 static inline bool __kmp_is_unlocked_queuing_lock(kmp_queuing_lock_t *lck) {
   // It is enough to check that the head_id is zero.
   // We don't also need to check the tail.
   bool res = lck->lk.head_id == 0;
 
 // We need a fence here, since we must ensure that no memory operations
 // from later in this thread float above that read.
-#if KMP_COMPILER_ICC
+#if KMP_COMPILER_ICC || KMP_COMPILER_ICX
   _mm_mfence();
 #else
   __sync_synchronize();
 #endif
 
   return res;
 }
 

openmp/runtime/src/kmp_os.h

 #define __has_attribute(x) 0
 #endif
 
 /* ------------------------- Compiler recognition ---------------------- */
 #define KMP_COMPILER_ICC 0
 #define KMP_COMPILER_GCC 0
 #define KMP_COMPILER_CLANG 0
 #define KMP_COMPILER_MSVC 0
+#define KMP_COMPILER_ICX 0
 
-#if defined(__INTEL_COMPILER)
+#if __INTEL_CLANG_COMPILER
+#undef KMP_COMPILER_ICX
+#define KMP_COMPILER_ICX 1
+#elif defined(__INTEL_COMPILER)
 #undef KMP_COMPILER_ICC
 #define KMP_COMPILER_ICC 1
 #elif defined(__clang__)
 #undef KMP_COMPILER_CLANG
 #define KMP_COMPILER_CLANG 1
 #elif defined(__GNUC__)
 #undef KMP_COMPILER_GCC
 #define KMP_COMPILER_GCC 1

 #else
 #define KMP_AFFINITY_SUPPORTED 0
 #define KMP_GROUP_AFFINITY 0
 #endif
 
 /* Check for quad-precision extension. */
 #define KMP_HAVE_QUAD 0
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-#if KMP_COMPILER_ICC
+#if KMP_COMPILER_ICC || KMP_COMPILER_ICX
 /* _Quad is already defined for icc */
 #undef KMP_HAVE_QUAD
 #define KMP_HAVE_QUAD 1
 #elif KMP_COMPILER_CLANG
 /* Clang doesn't support a software-implemented
    128-bit extended precision type yet */
 typedef long double _Quad;
 #elif KMP_COMPILER_GCC

 // Synchronization primitives
 
 #if KMP_ASM_INTRINS && KMP_OS_WINDOWS
 
 #if KMP_MSVC_COMPAT && !KMP_COMPILER_CLANG
 #pragma intrinsic(InterlockedExchangeAdd)
 #pragma intrinsic(InterlockedCompareExchange)
 #pragma intrinsic(InterlockedExchange)
+#if !(KMP_COMPILER_ICX && KMP_32_BIT_ARCH)
 #pragma intrinsic(InterlockedExchange64)
 #endif
+#endif
 
 // Using InterlockedIncrement / InterlockedDecrement causes a library loading
 // ordering problem, so we use InterlockedExchangeAdd instead.
 #define KMP_TEST_THEN_INC32(p) InterlockedExchangeAdd((volatile long *)(p), 1)
 #define KMP_TEST_THEN_INC_ACQ32(p)                                             \
   InterlockedExchangeAdd((volatile long *)(p), 1)
 #define KMP_TEST_THEN_ADD4_32(p) InterlockedExchangeAdd((volatile long *)(p), 4)
 #define KMP_TEST_THEN_ADD4_ACQ32(p)                                            \

 #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
   __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),   \
                                (kmp_uint64)(sv))
 #define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \
   __sync_val_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),    \
                               (kmp_uint64)(sv))
 #endif
 
+#if KMP_OS_DARWIN && defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1800
+#define KMP_XCHG_FIXED8(p, v)                                                  \
+  __atomic_exchange_1((volatile kmp_uint8 *)(p), (kmp_uint8)(v),               \
+                      __ATOMIC_SEQ_CST)
+#else
 #define KMP_XCHG_FIXED8(p, v)                                                  \
   __sync_lock_test_and_set((volatile kmp_uint8 *)(p), (kmp_uint8)(v))
+#endif
 #define KMP_XCHG_FIXED16(p, v)                                                 \
   __sync_lock_test_and_set((volatile kmp_uint16 *)(p), (kmp_uint16)(v))
 #define KMP_XCHG_FIXED32(p, v)                                                 \
   __sync_lock_test_and_set((volatile kmp_uint32 *)(p), (kmp_uint32)(v))
 #define KMP_XCHG_FIXED64(p, v)                                                 \
   __sync_lock_test_and_set((volatile kmp_uint64 *)(p), (kmp_uint64)(v))
 
 inline kmp_real32 KMP_XCHG_REAL32(volatile kmp_real32 *p, kmp_real32 v) {

 #endif
 #endif
 
 #ifndef KMP_MB
 #define KMP_MB() /* nothing to do */
 #endif
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-#if KMP_COMPILER_ICC
+#if KMP_COMPILER_ICC || KMP_COMPILER_ICX
 #define KMP_MFENCE_() _mm_mfence()
 #define KMP_SFENCE_() _mm_sfence()
 #elif KMP_COMPILER_MSVC
 #define KMP_MFENCE_() MemoryBarrier()
 #define KMP_SFENCE_() MemoryBarrier()
 #else
 #define KMP_MFENCE_() __sync_synchronize()
 #define KMP_SFENCE_() __sync_synchronize()

openmp/runtime/src/kmp_runtime.cpp

for (int f = 1; f < old_nthreads; ++f) {
     }
     // The thread should be in_use now
     KMP_DEBUG_ASSERT(team->t.t_threads[f]->th.th_used_in_team.load() == 1);
     // Transition to unused state
     team->t.t_threads[f]->th.th_used_in_team.store(2);
     KMP_DEBUG_ASSERT(team->t.t_threads[f]->th.th_used_in_team.load() == 2);
   }
   // Release all the workers
-  kmp_uint64 new_value; // new value for go
-  new_value = team->t.b->go_release();
+  team->t.b->go_release();
 
   KMP_MFENCE();
 
   // Workers should see transition status 2 and move to 0; but may need to be
   // woken up first
-  size_t my_go_index;
   int count = old_nthreads - 1;
   while (count > 0) {
     count = old_nthreads - 1;
     for (int f = 1; f < old_nthreads; ++f) {
-      my_go_index = f / team->t.b->threads_per_go;
       if (other_threads[f]->th.th_used_in_team.load() != 0) {
         if (__kmp_dflt_blocktime != KMP_MAX_BLOCKTIME) { // Wake up the workers
           kmp_atomic_flag_64<> *flag = (kmp_atomic_flag_64<> *)CCAST(
               void *, other_threads[f]->th.th_sleep_loc);
           __kmp_atomic_resume_64(other_threads[f]->th.th_info.ds.ds_gtid, flag);
         }
       } else {
         KMP_DEBUG_ASSERT(team->t.t_threads[f]->th.th_used_in_team.load() == 0);

openmp/runtime/src/kmp_stub.cpp

#if KMP_OS_WINDOWS
   res = _aligned_malloc(size, 1);
 #else
   res = malloc(size);
 #endif
   return res;
 }
 void *kmp_aligned_malloc(size_t sz, size_t a) {
   i;
-  int err;
   void *res;
 #if KMP_OS_WINDOWS
   res = _aligned_malloc(sz, a);
 #else
+  int err;
   if ((err = posix_memalign(&res, a, sz))) {
     errno = err; // can be EINVAL or ENOMEM
     res = NULL;
   }
 #endif
   return res;
 }
 void *kmp_calloc(size_t nelem, size_t elsize) {

 #else
   res = malloc(size);
 #endif
   return res;
 }
 
 void *omp_aligned_alloc(size_t a, size_t size, omp_allocator_handle_t al) {
   i;
-  int err;
   void *res;
 #if KMP_OS_WINDOWS
   res = _aligned_malloc(size, a);
 #else
-  if (err = posix_memalign(&res, a, size)) {
+  int err;
+  if ((err = posix_memalign(&res, a, size))) {
     errno = err; // can be EINVAL or ENOMEM
     res = NULL;
   }
 #endif
   return res;
 }
 
 void *omp_calloc(size_t nmemb, size_t size, omp_allocator_handle_t al) {
   i;
   void *res;
 #if KMP_OS_WINDOWS
   res = _aligned_recalloc(NULL, nmemb, size, 1);
 #else
   res = calloc(nmemb, size);
 #endif
   return res;
 }
 
 void *omp_aligned_calloc(size_t a, size_t nmemb, size_t size,
                          omp_allocator_handle_t al) {
   i;
-  int err;
   void *res;
 #if KMP_OS_WINDOWS
   res = _aligned_recalloc(NULL, nmemb, size, a);
 #else
-  if (err = posix_memalign(&res, a, nmemb * size)) {
+  int err;
+  if ((err = posix_memalign(&res, a, nmemb * size))) {
     errno = err; // can be EINVAL or ENOMEM
     res = NULL;
   }
   memset(res, 0x00, size);
 #endif
   return res;
 }
 

openmp/runtime/src/kmp_version.cpp

 // Replace with snapshot date YYYYMMDD for promotion build.
 #define KMP_VERSION_BUILD 20140926
 
 // Helper macros to convert value of macro to string literal.
 #define _stringer(x) #x
 #define stringer(x) _stringer(x)
 
 // Detect compiler.
-#if KMP_COMPILER_ICC
+#if KMP_COMPILER_ICX
+#define KMP_COMPILER __VERSION__
+#elif KMP_COMPILER_ICC
 #if __INTEL_COMPILER == 1010
 #define KMP_COMPILER "Intel(R) C++ Compiler 10.1"
 #elif __INTEL_COMPILER == 1100
 #define KMP_COMPILER "Intel(R) C++ Compiler 11.0"
 #elif __INTEL_COMPILER == 1110
 #define KMP_COMPILER "Intel(R) C++ Compiler 11.1"
 #elif __INTEL_COMPILER == 1200
 #define KMP_COMPILER "Intel(R) C++ Compiler 12.0"

 #elif __INTEL_COMPILER == 1700
 #define KMP_COMPILER "Intel(R) C++ Compiler 17.0"
 #elif __INTEL_COMPILER == 1800
 #define KMP_COMPILER "Intel(R) C++ Compiler 18.0"
 #elif __INTEL_COMPILER == 1900
 #define KMP_COMPILER "Intel(R) C++ Compiler 19.0"
 #elif __INTEL_COMPILER == 1910
 #define KMP_COMPILER "Intel(R) C++ Compiler 19.1"
-#elif __INTEL_COMPILER >= 9900
-#define KMP_COMPILER "Intel(R) C++ Compiler mainline"
+#elif __INTEL_COMPILER > 1910
+#define KMP_COMPILER                                                           \
+  "Intel(R) C++ Compiler Classic " stringer(__INTEL_COMPILER) "." stringer(    \
+      __INTEL_COMPILER_UPDATE)
 #endif
 #elif KMP_COMPILER_CLANG
 #define KMP_COMPILER                                                           \
   "Clang " stringer(__clang_major__) "." stringer(__clang_minor__)
 #elif KMP_COMPILER_GCC
 #define KMP_COMPILER "GCC " stringer(__GNUC__) "." stringer(__GNUC_MINOR__)
 #elif KMP_COMPILER_MSVC
 #define KMP_COMPILER "MSVC " stringer(_MSC_FULL_VER)

openmp/runtime/src/ompt-general.cpp

#if KMP_OS_UNIX
             OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: %s\n",
                                               "ompt_start_tool = NULL");
           }
         } else
 #elif KMP_OS_WINDOWS
       OMPT_VERBOSE_INIT_PRINT("Opening %s... ", fname);
       HMODULE h = LoadLibrary(fname);
       if (!h) {
-        OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %u\n", GetLastError());
+        OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %u\n",
+                                          (unsigned)GetLastError());
       } else {
         OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success. \n");
         OMPT_VERBOSE_INIT_PRINT("Searching for ompt_start_tool in %s... ",
                                 fname);
         start_tool = (ompt_start_tool_t)GetProcAddress(h, "ompt_start_tool");
         if (!start_tool) {
           OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %u\n",
-                                            GetLastError());
+                                            (unsigned)GetLastError());
         } else
 #else
 #error Activation of OMPT is not supported on this platform.
 #endif
         { // if (start_tool)
           ret = (*start_tool)(omp_version, runtime_version);
           if (ret) {
             OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n");

openmp/runtime/src/z_Windows_NT_util.cpp

 __kmp_atomic_resume_64<false, true>(int, kmp_atomic_flag_64<false, true> *);
 
 void __kmp_yield() { Sleep(0); }
 
 void __kmp_gtid_set_specific(int gtid) {
   if (__kmp_init_gtid) {
     KA_TRACE(50, ("__kmp_gtid_set_specific: T#%d key:%d\n", gtid,
                   __kmp_gtid_threadprivate_key));
-    if (!TlsSetValue(__kmp_gtid_threadprivate_key, (LPVOID)(gtid + 1)))
+    kmp_intptr_t g = (kmp_intptr_t)gtid;
+    if (!TlsSetValue(__kmp_gtid_threadprivate_key, (LPVOID)(g + 1)))
       KMP_FATAL(TLSSetValueFailed);
   } else {
     KA_TRACE(50, ("__kmp_gtid_set_specific: runtime shutdown, returning\n"));
   }
 }
 
 int __kmp_gtid_get_specific() {
   int gtid;
void __kmp_terminate_thread(int gtid) {
 
   if (TerminateThread(th->th.th_info.ds.ds_thread, (DWORD)-1) == FALSE) {
     /* It's OK, the thread may have exited already */
   }
   __kmp_free_handle(th->th.th_info.ds.ds_thread);
 }
 
 void __kmp_clear_system_time(void) {
-  BOOL status;
   LARGE_INTEGER time;
-  status = QueryPerformanceCounter(&time);
+  QueryPerformanceCounter(&time);
   __kmp_win32_time = (kmp_int64)time.QuadPart;
 }
 
 void __kmp_initialize_system_tick(void) {
   {
     BOOL status;
     LARGE_INTEGER freq;
 
     status = QueryPerformanceFrequency(&freq);
     if (!status) {
       DWORD error = GetLastError();
       __kmp_fatal(KMP_MSG(FunctionError, "QueryPerformanceFrequency()"),
                   KMP_ERR(error), __kmp_msg_null);
 
     } else {
       __kmp_win32_tick = ((double)1.0) / (double)freq.QuadPart;
     }
   }
 }
 
 /* Calculate the elapsed wall clock time for the user */
 
 void __kmp_elapsed(double *t) {
-  BOOL status;
   LARGE_INTEGER now;
-  status = QueryPerformanceCounter(&now);
+  QueryPerformanceCounter(&now);
   *t = ((double)now.QuadPart) * __kmp_win32_tick;
 }
 
 /* Calculate the elapsed wall clock tick for the user */
 
 void __kmp_elapsed_tick(double *t) { *t = __kmp_win32_tick; }
 
 void __kmp_read_system_time(double *delta) {
   if (delta != NULL) {
-    BOOL status;
     LARGE_INTEGER now;
-
-    status = QueryPerformanceCounter(&now);
-
+    QueryPerformanceCounter(&now);
     *delta = ((double)(((kmp_int64)now.QuadPart) - __kmp_win32_time)) *
              __kmp_win32_tick;
   }
 }
 
 /* Return the current time stamp in nsec */
 kmp_uint64 __kmp_now_nsec() {
   LARGE_INTEGER now;
#if KMP_ARCH_X86 || KMP_ARCH_X86_64
   // Set FP control regs to be a copy of the parallel initialization thread's.
   __kmp_clear_x87_fpu_status_word();
   __kmp_load_x87_fpu_control_word(&__kmp_init_x87_fpu_control_word);
   __kmp_load_mxcsr(&__kmp_init_mxcsr);
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
   if (__kmp_stkoffset > 0 && gtid > 0) {
     padding = KMP_ALLOCA(gtid * __kmp_stkoffset);
+    (void)padding;
   }
 
   KMP_FSYNC_RELEASING(&this_thr->th.th_info.ds.ds_alive);
   this_thr->th.th_info.ds.ds_thread_id = GetCurrentThreadId();
   TCW_4(this_thr->th.th_info.ds.ds_alive, TRUE);
 
   if (TCR_4(__kmp_gtid_mode) <
       2) { // check stack only if it is used to get gtid

 #endif /* USE_ITT_BUILD */
   }
 
   __kmp_free_handle(th->th.th_info.ds.ds_thread);
 
   /* NOTE:  The ExitProcess(code) system call causes all threads to Terminate
      with a exit_val = code.  Because of this we can not rely on exit_val having
      any particular value. */
+  kmp_intptr_t e = (kmp_intptr_t)exit_val;
   if (exit_val == STILL_ACTIVE) {
     KA_TRACE(1, ("__kmp_reap_common: thread still active.\n"));
-  } else if ((void *)exit_val != (void *)th) {
+  } else if ((void *)e != (void *)th) {
     KA_TRACE(1, ("__kmp_reap_common: ExitProcess / TerminateThread used?\n"));
   }
 
   KA_TRACE(10,
            ("__kmp_reap_common: done reaping (%d), handle = %" KMP_UINTPTR_SPEC
             "\n",
             th->th.th_info.ds.ds_gtid, th->th.th_info.ds.ds_thread));
 
if (status) {
     DWORD error = GetLastError();
     __kmp_fatal(KMP_MSG(FunctionError, "SleepEx()"), KMP_ERR(error),
                 __kmp_msg_null);
   }
 }
 
 // Determine whether the given address is mapped into the current address space.
 int __kmp_is_address_mapped(void *addr) {
-  DWORD status;
   MEMORY_BASIC_INFORMATION lpBuffer;
   SIZE_T dwLength;
 
   dwLength = sizeof(MEMORY_BASIC_INFORMATION);
 
-  status = VirtualQuery(addr, &lpBuffer, dwLength);
+  VirtualQuery(addr, &lpBuffer, dwLength);
 
   return !(((lpBuffer.State == MEM_RESERVE) || (lpBuffer.State == MEM_FREE)) ||
            ((lpBuffer.Protect == PAGE_NOACCESS) ||
             (lpBuffer.Protect == PAGE_EXECUTE)));
 }
 
 kmp_uint64 __kmp_hardware_timestamp(void) {
   kmp_uint64 r = 0;

openmp/runtime/test/CMakeLists.txt

 endmacro()
 
 pythonize_bool(LIBOMP_USE_HWLOC)
 pythonize_bool(LIBOMP_OMPT_SUPPORT)
 pythonize_bool(LIBOMP_OMPT_OPTIONAL)
 pythonize_bool(LIBOMP_HAVE_LIBM)
 pythonize_bool(LIBOMP_HAVE_LIBATOMIC)
 pythonize_bool(OPENMP_STANDALONE_BUILD)
+pythonize_bool(OPENMP_TEST_COMPILER_HAS_OMIT_FRAME_POINTER_FLAGS)
 
 add_library(ompt-print-callback INTERFACE)
 target_include_directories(ompt-print-callback INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/ompt)
 
 
 add_openmp_testsuite(check-libomp "Running libomp tests" ${CMAKE_CURRENT_BINARY_DIR} DEPENDS omp)
 # Add target check-ompt, but make sure to not add the tests twice to check-openmp.
 add_openmp_testsuite(check-ompt "Running OMPT tests" ${CMAKE_CURRENT_BINARY_DIR}/ompt EXCLUDE_FROM_CHECK_ALL DEPENDS omp)
 
 # Configure the lit.site.cfg.in file
 set(AUTO_GEN_COMMENT "## Autogenerated by libomp configuration.\n# Do not edit!")
 configure_file(lit.site.cfg.in lit.site.cfg @ONLY)

openmp/runtime/test/affinity/format/increase.c

 // RUN: %libomp-compile && env OMP_DISPLAY_AFFINITY=true %libomp-run | %python %S/check.py -c 'CHECK' %s
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
+#include "omp_testsuite.h"
 
 int main(int argc, char** argv) {
   omp_set_affinity_format("TESTER: tl:%L tn:%n nt:%N");
   // should print all for first parallel
-  omp_set_num_threads(4);
-  #pragma omp parallel
-  { }
+  go_parallel_nthreads(4);
   // should print all because of new threads
-  omp_set_num_threads(8);
-  #pragma omp parallel
-  { }
+  go_parallel_nthreads(8);
   // should not print anything here
-  omp_set_num_threads(6);
-  #pragma omp parallel
-  { }
+  go_parallel_nthreads(6);
   // should print all because of new thread
-  omp_set_num_threads(9);
-  #pragma omp parallel
-  { }
+  go_parallel_nthreads(9);
   // should not print anything here
-  omp_set_num_threads(2);
-  #pragma omp parallel
-  { }
-  return 0;
+  go_parallel_nthreads(2);
+
+  return get_exit_value();
 }
 
 // CHECK: num_threads=4 TESTER: tl:1 tn:[0-3] nt:4
 // CHECK: num_threads=8 TESTER: tl:1 tn:[0-7] nt:8
 // CHECK: num_threads=6 TESTER: tl:1 tn:[0-5] nt:6
 // CHECK: num_threads=9 TESTER: tl:1 tn:[0-8] nt:9
 // CHECK: num_threads=2 TESTER: tl:1 tn:[01] nt:2

openmp/runtime/test/affinity/format/nested.c

 // RUN: %libomp-compile && env OMP_DISPLAY_AFFINITY=true OMP_PLACES=threads OMP_PROC_BIND=spread,close %libomp-run | %python %S/check.py -c 'CHECK' %s
 // REQUIRES: affinity
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
+#include "omp_testsuite.h"
 
 int main(int argc, char** argv) {
   omp_set_affinity_format("TESTER: tl:%L at:%a tn:%n nt:%N");
   omp_set_nested(1);
   #pragma omp parallel num_threads(4)
   {
-    #pragma omp parallel num_threads(3)
-    { }
+    go_parallel_nthreads(3);
   }
-  return 0;
+  return get_exit_value();
 }
 
 // CHECK: num_threads=4 TESTER: tl:1 at:0 tn:[0-3] nt:4
 // CHECK: num_threads=3 TESTER: tl:2 at:[0-3] tn:[0-2] nt:3
 // CHECK: num_threads=3 TESTER: tl:2 at:[0-3] tn:[0-2] nt:3
 // CHECK: num_threads=3 TESTER: tl:2 at:[0-3] tn:[0-2] nt:3
 // CHECK: num_threads=3 TESTER: tl:2 at:[0-3] tn:[0-2] nt:3

openmp/runtime/test/affinity/format/nested2.c

 // RUN: %libomp-compile && env OMP_DISPLAY_AFFINITY=true OMP_PLACES=threads OMP_PROC_BIND=spread,close KMP_HOT_TEAMS_MAX_LEVEL=2 %libomp-run | %python %S/check.py -c 'CHECK' %s
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
+#include "omp_testsuite.h"
 
 // Currently, KMP_HOT_TEAMS_MAX_LEVEL has to be equal to the
 // nest depth for intuitive behavior
 int main(int argc, char** argv) {
   omp_set_affinity_format("TESTER: tl:%L tn:%n nt:%N");
   omp_set_nested(1);
   #pragma omp parallel num_threads(4)
   {
-    #pragma omp parallel num_threads(3)
-    { }
-    #pragma omp parallel num_threads(3)
-    { }
+    go_parallel_nthreads(3);
+    go_parallel_nthreads(3);
   }
-  #pragma omp parallel num_threads(4)
-  { }
-  return 0;
+  go_parallel_nthreads(4);
+  return get_exit_value();
 }
 
 // CHECK: num_threads=4 TESTER: tl:1 tn:[0-3] nt:4
 // CHECK: num_threads=3 TESTER: tl:2 tn:[0-2] nt:3
 // CHECK: num_threads=3 TESTER: tl:2 tn:[0-2] nt:3
 // CHECK: num_threads=3 TESTER: tl:2 tn:[0-2] nt:3
 // CHECK: num_threads=3 TESTER: tl:2 tn:[0-2] nt:3
 // CHECK: num_threads=4 TESTER: tl:1 tn:[0-3] nt:4

openmp/runtime/test/affinity/format/nested_mixed.c

 // RUN: %libomp-compile && env OMP_DISPLAY_AFFINITY=true %libomp-run | %python %S/check.py -c 'CHECK' %s
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
+#include "omp_testsuite.h"
 
 int main(int argc, char** argv) {
   omp_set_affinity_format("TESTER: tl:%L at:%a tn:%n nt:%N");
   omp_set_nested(1);
   #pragma omp parallel num_threads(1)
   {
-    #pragma omp parallel num_threads(2)
-    { }
+    go_parallel_nthreads(2);
     #pragma omp parallel num_threads(2)
     {
       #pragma omp parallel num_threads(1)
       {
-        #pragma omp parallel num_threads(2)
-        { }
+        go_parallel_nthreads(2);
       }
     }
-    #pragma omp parallel num_threads(1)
-    { }
+    go_parallel_nthreads(1);
   }
-  #pragma omp parallel num_threads(2)
-  { }
-  #pragma omp parallel num_threads(1)
-  { }
-  return 0;
+  go_parallel_nthreads(2);
+  go_parallel_nthreads(1);
+  return get_exit_value();
 }
 
 // CHECK: num_threads=1 TESTER: tl:1 at:0 tn:0 nt:1
 
 // CHECK: num_threads=2 TESTER: tl:2 at:[0-9] tn:[01] nt:2
 
 // CHECK: num_threads=1 TESTER: tl:3 at:[0-9] tn:0 nt:1
 // CHECK: num_threads=1 TESTER: tl:3 at:[0-9] tn:0 nt:1

openmp/runtime/test/affinity/format/nested_serial.c

 // RUN: %libomp-compile && env OMP_DISPLAY_AFFINITY=true %libomp-run | %python %S/check.py -c 'CHECK' %s
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
+#include "omp_testsuite.h"
 
 int main(int argc, char** argv) {
   omp_set_affinity_format("TESTER: tl:%L at:%a tn:%n nt:%N");
   omp_set_nested(1);
   #pragma omp parallel num_threads(1)
   {
-    #pragma omp parallel num_threads(1)
-    { }
-    #pragma omp parallel num_threads(1)
-    { }
+    go_parallel_nthreads(1);
+    go_parallel_nthreads(1);
     #pragma omp parallel num_threads(1)
     {
-      #pragma omp parallel num_threads(1)
-      { }
+      go_parallel_nthreads(1);
     }
-    #pragma omp parallel num_threads(1)
-    { }
+    go_parallel_nthreads(1);
   }
-  #pragma omp parallel num_threads(1)
-  { }
-  #pragma omp parallel num_threads(1)
-  { }
-  return 0;
+  go_parallel_nthreads(1);
+  go_parallel_nthreads(1);
+  return get_exit_value();
 }
 
 // CHECK: num_threads=1 TESTER: tl:1 at:0 tn:0 nt:1
 // CHECK: num_threads=1 TESTER: tl:2 at:0 tn:0 nt:1
 // CHECK: num_threads=1 TESTER: tl:3 at:0 tn:0 nt:1
 // CHECK: num_threads=1 TESTER: tl:2 at:0 tn:0 nt:1
 // CHECK: num_threads=1 TESTER: tl:1 at:0 tn:0 nt:1

openmp/runtime/test/affinity/format/proc_bind.c

 // RUN: %libomp-compile && env OMP_DISPLAY_AFFINITY=true OMP_PLACES='{0},{0,1},{0},{0,1},{0},{0,1},{0},{0,1},{0},{0,1},{0}' %libomp-run | %python %S/check.py -c 'CHECK' %s
 // REQUIRES: affinity
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
+#include "omp_testsuite.h"
 
 int main(int argc, char** argv) {
   omp_set_affinity_format("TESTER: tl:%L tn:%n nt:%N aff:{%A}");
   omp_set_num_threads(8);
   // Initial parallel
-  #pragma omp parallel proc_bind(spread)
-  { }
-  #pragma omp parallel proc_bind(spread)
-  { }
+  go_parallel_spread();
+  go_parallel_spread();
   // Affinity changes here
-  #pragma omp parallel proc_bind(close)
-  { }
-  #pragma omp parallel proc_bind(close)
-  { }
+  go_parallel_close();
+  go_parallel_close();
   // Affinity changes here
-  #pragma omp parallel proc_bind(master)
-  { }
-  #pragma omp parallel proc_bind(master)
-  { }
-  return 0;
+  go_parallel_master();
+  go_parallel_master();
+  return get_exit_value();
 }
 
 // CHECK: num_threads=8 TESTER: tl:1 tn:[0-7] nt:8 aff:
 // CHECK: num_threads=8 TESTER: tl:1 tn:[0-7] nt:8 aff:
 // CHECK: num_threads=8 TESTER: tl:1 tn:[0-7] nt:8 aff:

openmp/runtime/test/affinity/format/simple.c

 // RUN: %libomp-compile
 // RUN: env OMP_DISPLAY_AFFINITY=false %libomp-run | %python %S/check.py -c 'NOTHING' %s
 // RUN: env OMP_DISPLAY_AFFINITY=true OMP_NUM_THREADS=1 %libomp-run | %python %S/check.py -c 'CHECK' %s
 // RUN: env OMP_DISPLAY_AFFINITY=true OMP_NUM_THREADS=2 %libomp-run | %python %S/check.py -c 'CHECK-2' %s
 // RUN: env OMP_DISPLAY_AFFINITY=true OMP_NUM_THREADS=3 %libomp-run | %python %S/check.py -c 'CHECK-3' %s
 // RUN: env OMP_DISPLAY_AFFINITY=true OMP_NUM_THREADS=4 %libomp-run | %python %S/check.py -c 'CHECK-4' %s
 // RUN: env OMP_DISPLAY_AFFINITY=true OMP_NUM_THREADS=8 %libomp-run | %python %S/check.py -c 'CHECK-8' %s
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
+#include "omp_testsuite.h"
 
 int main(int argc, char** argv) {
   omp_set_affinity_format("TESTER: tl:%L tn:%n nt:%N");
-  #pragma omp parallel
-  { }
-  #pragma omp parallel
-  { }
-  return 0;
+  go_parallel();
+  go_parallel();
+  return get_exit_value();
 }
 
 // NOTHING: NO_OUTPUT
 // CHECK: num_threads=1 TESTER: tl:1 tn:0 nt:1
 // CHECK-2: num_threads=2 TESTER: tl:1 tn:[01] nt:2
 // CHECK-3: num_threads=3 TESTER: tl:1 tn:[0-2] nt:3
 // CHECK-4: num_threads=4 TESTER: tl:1 tn:[0-3] nt:4
 // CHECK-8: num_threads=8 TESTER: tl:1 tn:[0-7] nt:8

openmp/runtime/test/affinity/format/simple_env.c

 // RUN: %libomp-compile
 // RUN: env OMP_DISPLAY_AFFINITY=true OMP_AFFINITY_FORMAT='TESTER-ENV: tl:%L tn:%n nt:%N' OMP_NUM_THREADS=8 %libomp-run | %python %S/check.py -c 'CHECK-8' %s
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <omp.h>
+#include "omp_testsuite.h"
 
 int main(int argc, char** argv) {
-  #pragma omp parallel
-  { }
-  #pragma omp parallel
-  { }
-  return 0;
+  go_parallel();
+  go_parallel();
+  return get_exit_value();
 }
 
 // CHECK-8: num_threads=8 TESTER-ENV: tl:1 tn:[0-7] nt:8$

openmp/runtime/test/affinity/omp-places-invalid-syntax.c

 // RUN: %libomp-compile && env KMP_SETTINGS=1 OMP_PLACES=invalid %libomp-run 2>&1 | FileCheck %s
 // CHECK-DAG: Effective settings
 // CHECK: OMP_PLACES=
 // CHECK-SAME: cores
 // REQUIRES: affinity
 
+#include "omp_testsuite.h"
+
 int main() {
-  #pragma omp parallel
-  {}
-  return 0;
+  go_parallel();
+  return get_exit_value();
 }

openmp/runtime/test/lit.cfg

 
 # test format
 config.test_format = lit.formats.ShTest()
 
 # compiler flags
 flags = " -I " + config.test_source_root + \
     " -L " + config.library_dir + \
     " " + config.test_extra_flags
+if config.has_omit_frame_pointer_flag:
+    flags += " -fno-omit-frame-pointer"
+
 config.test_flags = " -I " + config.omp_header_directory + flags
 config.test_flags_use_compiler_omp_h = flags
 
+
 # extra libraries
 libs = ""
 if config.has_libm:
     libs += " -lm"
 if config.has_libatomic:
     libs += " -latomic"
 
 # Allow REQUIRES / UNSUPPORTED / XFAIL to work

openmp/runtime/test/lit.site.cfg.in

 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@
 config.is_standalone_build = @OPENMP_STANDALONE_BUILD@
+config.has_omit_frame_pointer_flag = @OPENMP_TEST_COMPILER_HAS_OMIT_FRAME_POINTER_FLAGS@
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LIBOMP_BASE_DIR@/test/lit.cfg")

openmp/runtime/test/omp_testsuite.h

 /* following times are in seconds */
 #define SLEEPTIME 1
 
 /* Definitions for tasks                                  */
 /**********************************************************/
 #define NUM_TASKS 25
 #define MAX_TASKS_PER_THREAD 5
 
+// Functions that call a parallel region that does very minimal work
+// Some compilers may optimize away an empty parallel region
+volatile int g_counter__;
+
+// If nthreads == 0, then do not use num_threads() clause
+static void go_parallel() {
+  g_counter__ = 0;
+  #pragma omp parallel
+  {
+    #pragma omp atomic
+    g_counter__++;
+  }
+}
+
+static void go_parallel_nthreads(int nthreads) {
+  g_counter__ = 0;
+  #pragma omp parallel num_threads(nthreads)
+  {
+    #pragma omp atomic
+    g_counter__++;
+  }
+}
+
+static void go_parallel_spread() {
+  g_counter__ = 0;
+  #pragma omp parallel proc_bind(spread)
+  {
+    #pragma omp atomic
+    g_counter__++;
+  }
+}
+
+static void go_parallel_close() {
+  g_counter__ = 0;
+  #pragma omp parallel proc_bind(close)
+  {
+    #pragma omp atomic
+    g_counter__++;
+  }
+}
+
+static void go_parallel_master() {
+  g_counter__ = 0;
+  #pragma omp parallel proc_bind(master)
+  {
+    #pragma omp atomic
+    g_counter__++;
+  }
+}
+
+static inline int get_exit_value() {
+  return ((g_counter__ == -1) ? EXIT_FAILURE : EXIT_SUCCESS);
+}
+
 #ifdef  _WIN32
 // Windows versions of pthread_create() and pthread_join()
 # include <windows.h>
 typedef HANDLE pthread_t;
 
 // encapsulates the information about a pthread-callable function
 struct thread_func_info_t {
   void* (*start_routine)(void*);

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

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 #include "callback.h"
+#include "omp_testsuite.h"
 
 int main() {
-#pragma omp parallel num_threads(2)
-  {}
+  go_parallel_nthreads(2);
 
   printf("Before ompt_finalize_tool\n");
   ompt_finalize_tool();
   printf("After ompt_finalize_tool\n");
 
-  return 0;
+  return get_exit_value();
 }
 
 // CHECK: 0: NULL_POINTER=[[NULL:.*$]]
 // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_thread_begin:
 // CHECK-SAME: thread_type=ompt_thread_initial=1
 
 // CHECK: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin
 // CHECK: {{^}}[[THREAD_ID]]: ompt_event_parallel_end
 
 // CHECK: {{^}}Before ompt_finalize_tool
 
 // CHECK: {{^}}[[THREAD_ID]]: ompt_event_thread_end: thread_id=[[THREAD_ID]]
 // CHECK: 0: ompt_event_runtime_shutdown
 
 // CHECK: {{^}}After ompt_finalize_tool

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

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 #include "callback.h"
+#include "omp_testsuite.h"
 #include <omp.h>
 
 int main()
 {
-  #pragma omp parallel num_threads(1)
-  {
-
-  }
+  go_parallel_nthreads(1);
   ompt_set_callback(ompt_callback_parallel_begin, NULL);
-  #pragma omp parallel num_threads(1)
-  {
-
-  }
+  go_parallel_nthreads(1);
 
   // Check if libomp supports the callbacks for this test.
   // CHECK-NOT: {{^}}0: Could not register callback 'ompt_callback_idle'
 
   // CHECK: 0: NULL_POINTER=[[NULL:.*$]]
 
   // CHECK: {{^}}[[THREAD_ID:[0-9]+]]: ompt_event_parallel_begin:
   // CHECK: {{^}}[[THREAD_ID]]: ompt_event_parallel_end:
   // CHECK-NOT: {{^}}[[THREAD_ID]]: ompt_event_parallel_begin:
   // CHECK: {{^}}[[THREAD_ID]]: ompt_event_parallel_end:
 
-  return 0;
+  return get_exit_value();
 }

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
+// UNSUPPORTED: clang-5, clang-6, clang-6, clang-8, clang-9, clang-10, clang-11, clang-12, clang-13
 
 #include "callback.h"
 #include <omp.h>
 
 int main() {
   int x = 0;
 #pragma omp parallel num_threads(2)
   {