[OpenMP][VE] Support OpenMP runtime on VE

[kaz7]

Summary

Support OpenMP runtime library on VE. This patch makes OpenMP compilable
for VE architecture. Almost all tests run correctly on VE.

[kaz7]

ping

[tianshilei1992]

LGTM

openmp/runtime/CMakeLists.txt

 include(LibompHandleFlags)
 include(LibompDefinitions)
 
 # Determine the target architecture
 if(${OPENMP_STANDALONE_BUILD})
   # If adding a new architecture, take a look at cmake/LibompGetArchitecture.cmake
   libomp_get_architecture(LIBOMP_DETECTED_ARCH)
   set(LIBOMP_ARCH ${LIBOMP_DETECTED_ARCH} CACHE STRING
-    "The architecture to build for (x86_64/i386/arm/ppc64/ppc64le/aarch64/mic/mips/mips64/riscv64/loongarch64).")
+    "The architecture to build for (x86_64/i386/arm/ppc64/ppc64le/aarch64/mic/mips/mips64/riscv64/loongarch64/ve).")
   # Should assertions be enabled?  They are on by default.
   set(LIBOMP_ENABLE_ASSERTIONS TRUE CACHE BOOL
     "enable assertions?")
   string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 else() # Part of LLVM build
   # Determine the native architecture from LLVM.
   string(TOLOWER "${LLVM_TARGET_ARCH}" LIBOMP_NATIVE_ARCH)
   if( LIBOMP_NATIVE_ARCH STREQUAL "host" )
else() # Part of LLVM build
   elseif(LIBOMP_NATIVE_ARCH MATCHES "arm64")
     set(LIBOMP_ARCH aarch64)
   elseif(LIBOMP_NATIVE_ARCH MATCHES "arm")
     set(LIBOMP_ARCH arm)
   elseif(LIBOMP_NATIVE_ARCH MATCHES "riscv64")
     set(LIBOMP_ARCH riscv64)
   elseif(LIBOMP_NATIVE_ARCH MATCHES "loongarch64")
     set(LIBOMP_ARCH loongarch64)
+  elseif(LIBOMP_NATIVE_ARCH MATCHES "ve")
+    set(LIBOMP_ARCH ve)
   else()
     # last ditch effort
     libomp_get_architecture(LIBOMP_ARCH)
   endif ()
   set(LIBOMP_ENABLE_ASSERTIONS ${LLVM_ENABLE_ASSERTIONS})
 endif()
 
 # Time profiling support
 set(LIBOMP_PROFILING_SUPPORT ${OPENMP_ENABLE_LIBOMP_PROFILING})
 
 # FUJITSU A64FX is a special processor because its cache line size is 256.
 # We need to pass this information into kmp_config.h.
 if(LIBOMP_ARCH STREQUAL "aarch64")
   libomp_is_aarch64_a64fx(LIBOMP_DETECT_AARCH64_A64FX)
   if (LIBOMP_DETECT_AARCH64_A64FX)
     set(LIBOMP_ARCH "aarch64_a64fx")
     set(LIBOMP_ARCH_AARCH64_A64FX TRUE)
   endif()
 endif()
 
-libomp_check_variable(LIBOMP_ARCH 32e x86_64 32 i386 arm ppc64 ppc64le aarch64 aarch64_a64fx mic mips mips64 riscv64 loongarch64)
+libomp_check_variable(LIBOMP_ARCH 32e x86_64 32 i386 arm ppc64 ppc64le aarch64 aarch64_a64fx mic mips mips64 riscv64 loongarch64 ve)
 
 set(LIBOMP_LIB_TYPE normal CACHE STRING
   "Performance,Profiling,Stubs library (normal/profile/stubs)")
 libomp_check_variable(LIBOMP_LIB_TYPE normal profile stubs)
 # Set the OpenMP Year and Month associated with version
 set(LIBOMP_OMP_YEAR_MONTH 201611)
 set(LIBOMP_MIC_ARCH knc CACHE STRING
   "Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) (knf/knc).  Ignored if not Intel(R) MIC Architecture build.")

 set(PPC64BE FALSE)
 set(PPC64LE FALSE)
 set(PPC64 FALSE)
 set(MIC FALSE)
 set(MIPS64 FALSE)
 set(MIPS FALSE)
 set(RISCV64 FALSE)
 set(LOONGARCH64 FALSE)
+set(VE FALSE)
 if("${LIBOMP_ARCH}" STREQUAL "i386" OR "${LIBOMP_ARCH}" STREQUAL "32")    # IA-32 architecture
   set(IA32 TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "x86_64" OR "${LIBOMP_ARCH}" STREQUAL "32e") # Intel(R) 64 architecture
   set(INTEL64 TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "arm") # ARM architecture
   set(ARM TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "ppc64") # PPC64BE architecture
   set(PPC64BE TRUE)

 elseif("${LIBOMP_ARCH}" STREQUAL "mips") # MIPS architecture
     set(MIPS TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "mips64") # MIPS64 architecture
     set(MIPS64 TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "riscv64") # RISCV64 architecture
     set(RISCV64 TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "loongarch64") # LoongArch64 architecture
     set(LOONGARCH64 TRUE)
+elseif("${LIBOMP_ARCH}" STREQUAL "ve") # VE architecture
+    set(VE TRUE)
 endif()
 
 # Set some flags based on build_type
 set(RELEASE_BUILD FALSE)
 set(DEBUG_BUILD FALSE)
 set(RELWITHDEBINFO_BUILD FALSE)
 set(MINSIZEREL_BUILD FALSE)
 if("${uppercase_CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")

openmp/runtime/cmake/LibompGetArchitecture.cmake

set(detect_arch_src_txt "
     #elif defined(__mips__) && defined(__mips64)
       #error ARCHITECTURE=mips64
     #elif defined(__mips__) && !defined(__mips64)
       #error ARCHITECTURE=mips
     #elif defined(__riscv) && __riscv_xlen == 64
       #error ARCHITECTURE=riscv64
     #elif defined(__loongarch__) && __loongarch_grlen == 64
       #error ARCHITECTURE=loongarch64
+    #elif defined(__ve__)
+      #error ARCHITECTURE=ve
     #else
       #error ARCHITECTURE=UnknownArchitecture
     #endif
   ")
   # Write out ${detect_arch_src_txt} to a file within the cmake/ subdirectory
   file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/libomp_detect_arch.c" ${detect_arch_src_txt})
 
   # Try to compile using the C Compiler.  It will always error out with an #error directive, so store error output to ${local_architecture}

openmp/runtime/cmake/LibompUtils.cmake

function(libomp_get_legal_arch return_arch_string)
   elseif(${MIPS})
     set(${return_arch_string} "MIPS" PARENT_SCOPE)
   elseif(${MIPS64})
     set(${return_arch_string} "MIPS64" PARENT_SCOPE)
   elseif(${RISCV64})
     set(${return_arch_string} "RISCV64" PARENT_SCOPE)
   elseif(${LOONGARCH64})
     set(${return_arch_string} "LOONGARCH64" PARENT_SCOPE)
+  elseif(${VE})
+    set(${return_arch_string} "VE" PARENT_SCOPE)
   else()
     set(${return_arch_string} "${LIBOMP_ARCH}" PARENT_SCOPE)
     libomp_warning_say("libomp_get_legal_arch(): Warning: Unknown architecture: Using ${LIBOMP_ARCH}")
   endif()
 endfunction()
 
 # void libomp_check_variable(string var, ...);
 # - runs through all values checking if ${var} == value

openmp/runtime/src/kmp.h

 
 #define KMP_MAX_STKSIZE (~((size_t)1 << ((sizeof(size_t) * (1 << 3)) - 1)))
 
 #if KMP_ARCH_X86
 #define KMP_DEFAULT_STKSIZE ((size_t)(2 * 1024 * 1024))
 #elif KMP_ARCH_X86_64
 #define KMP_DEFAULT_STKSIZE ((size_t)(4 * 1024 * 1024))
 #define KMP_BACKUP_STKSIZE ((size_t)(2 * 1024 * 1024))
+#elif KMP_ARCH_VE
+// Minimum stack size for pthread for VE is 4MB.
+//   https://www.hpc.nec/documents/veos/en/glibc/Difference_Points_glibc.htm
+#define KMP_DEFAULT_STKSIZE ((size_t)(4 * 1024 * 1024))
 #else
 #define KMP_DEFAULT_STKSIZE ((size_t)(1024 * 1024))
 #endif
 
 #define KMP_DEFAULT_MALLOC_POOL_INCR ((size_t)(1024 * 1024))
 #define KMP_MIN_MALLOC_POOL_INCR ((size_t)(4 * 1024))
 #define KMP_MAX_MALLOC_POOL_INCR                                               \
   (~((size_t)1 << ((sizeof(size_t) * (1 << 3)) - 1)))

openmp/runtime/src/kmp_affinity.h

 #elif __NR_sched_setaffinity != 122
 #error Wrong code for setaffinity system call.
 #endif /* __NR_sched_setaffinity */
 #ifndef __NR_sched_getaffinity
 #define __NR_sched_getaffinity 123
 #elif __NR_sched_getaffinity != 123
 #error Wrong code for getaffinity system call.
 #endif /* __NR_sched_getaffinity */
+#elif KMP_ARCH_VE
+#ifndef __NR_sched_setaffinity
+#define __NR_sched_setaffinity 203
+#elif __NR_sched_setaffinity != 203
+#error Wrong code for setaffinity system call.
+#endif /* __NR_sched_setaffinity */
+#ifndef __NR_sched_getaffinity
+#define __NR_sched_getaffinity 204
+#elif __NR_sched_getaffinity != 204
+#error Wrong code for getaffinity system call.
+#endif /* __NR_sched_getaffinity */
 #else
 #error Unknown or unsupported architecture
 #endif /* KMP_ARCH_* */
 #elif KMP_OS_FREEBSD
 #include <pthread.h>
 #include <pthread_np.h>
 #endif
 class KMPNativeAffinity : public KMPAffinity {

openmp/runtime/src/kmp_os.h

 #define KMP_UINT32_SPEC "u"
 #define KMP_INT64_SPEC "lld"
 #define KMP_UINT64_SPEC "llu"
 #endif /* KMP_OS_UNIX */
 
 #if KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS
 #define KMP_SIZE_T_SPEC KMP_UINT32_SPEC
 #elif KMP_ARCH_X86_64 || KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 ||                 \
-    KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64
+    KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64 || KMP_ARCH_VE
 #define KMP_SIZE_T_SPEC KMP_UINT64_SPEC
 #else
 #error "Can't determine size_t printf format specifier."
 #endif
 
 #if KMP_ARCH_X86 || KMP_ARCH_ARM
 #define KMP_SIZE_T_MAX (0xFFFFFFFF)
 #else

 #define KMP_IMB() asm("nop")
 #else
 #define KMP_MB() /* _asm{ nop } */
 #define KMP_IMB() /* _asm{ nop } */
 #endif
 #endif /* KMP_OS_WINDOWS */
 
 #if KMP_ARCH_PPC64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS ||     \
-    KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64
+    KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64 || KMP_ARCH_VE
 #if KMP_OS_WINDOWS
 #undef KMP_MB
 #define KMP_MB() std::atomic_thread_fence(std::memory_order_seq_cst)
 #else /* !KMP_OS_WINDOWS */
 #define KMP_MB() __sync_synchronize()
 #endif
 #endif
 

openmp/runtime/src/kmp_platform.h

 #define KMP_ARCH_AARCH64 0
 #define KMP_ARCH_PPC64_ELFv1 0
 #define KMP_ARCH_PPC64_ELFv2 0
 #define KMP_ARCH_PPC64 (KMP_ARCH_PPC64_ELFv2 || KMP_ARCH_PPC64_ELFv1)
 #define KMP_ARCH_MIPS 0
 #define KMP_ARCH_MIPS64 0
 #define KMP_ARCH_RISCV64 0
 #define KMP_ARCH_LOONGARCH64 0
+#define KMP_ARCH_VE 0
 
 #if KMP_OS_WINDOWS
 #if defined(_M_AMD64) || defined(__x86_64)
 #undef KMP_ARCH_X86_64
 #define KMP_ARCH_X86_64 1
 #elif defined(__aarch64__) || defined(_M_ARM64)
 #undef KMP_ARCH_AARCH64
 #define KMP_ARCH_AARCH64 1

 #define KMP_ARCH_MIPS 1
 #endif
 #elif defined __riscv && __riscv_xlen == 64
 #undef KMP_ARCH_RISCV64
 #define KMP_ARCH_RISCV64 1
 #elif defined __loongarch__ && __loongarch_grlen == 64
 #undef KMP_ARCH_LOONGARCH64
 #define KMP_ARCH_LOONGARCH64 1
+#elif defined __ve__
+#undef KMP_ARCH_VE
+#define KMP_ARCH_VE 1
 #endif
 #endif
 
 #if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7R__) ||                     \
     defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7VE__)
 #define KMP_ARCH_ARMV7 1
 #endif
 

 
 // Platforms which support Intel(R) Many Integrated Core Architecture
 #define KMP_MIC_SUPPORTED                                                      \
   ((KMP_ARCH_X86 || KMP_ARCH_X86_64) && (KMP_OS_LINUX || KMP_OS_WINDOWS))
 
 // TODO: Fixme - This is clever, but really fugly
 #if (1 != KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 +     \
               KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64 +             \
-              KMP_ARCH_RISCV64 + KMP_ARCH_LOONGARCH64)
+              KMP_ARCH_RISCV64 + KMP_ARCH_LOONGARCH64 + KMP_ARCH_VE)
 #error Unknown or unsupported architecture
 #endif
 
 #endif // KMP_PLATFORM_H

openmp/runtime/src/kmp_runtime.cpp

if (team_size == 1) {
 
     retval = empty_reduce_block;
 
   } else {
 
     int atomic_available = FAST_REDUCTION_ATOMIC_METHOD_GENERATED;
 
 #if KMP_ARCH_X86_64 || KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 ||                   \
-    KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64
+    KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64 || KMP_ARCH_VE
 
 #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||     \
     KMP_OS_OPENBSD || KMP_OS_WINDOWS || KMP_OS_DARWIN || KMP_OS_HURD
 
     int teamsize_cutoff = 4;
 
 #if KMP_MIC_SUPPORTED
     if (__kmp_mic_type != non_mic) {

openmp/runtime/src/thirdparty/ittnotify/ittnotify_config.h

 #ifndef ITT_ARCH_PPC64
 #define ITT_ARCH_PPC64 5
 #endif /* ITT_ARCH_PPC64 */
 
 #ifndef ITT_ARCH_ARM64
 #define ITT_ARCH_ARM64 6
 #endif /* ITT_ARCH_ARM64 */
 
+#ifndef ITT_ARCH_VE
+#define ITT_ARCH_VE 8
+#endif /* ITT_ARCH_VE */
+
 #ifndef ITT_ARCH
 #if defined _M_IX86 || defined __i386__
 #define ITT_ARCH ITT_ARCH_IA32
 #elif defined _M_X64 || defined _M_AMD64 || defined __x86_64__
 #define ITT_ARCH ITT_ARCH_IA32E
 #elif defined _M_IA64 || defined __ia64__
 #define ITT_ARCH ITT_ARCH_IA64
 #elif defined _M_ARM || defined __arm__
 #define ITT_ARCH ITT_ARCH_ARM
 #elif defined __aarch64__
 #define ITT_ARCH ITT_ARCH_ARM64
 #elif defined __powerpc64__
 #define ITT_ARCH ITT_ARCH_PPC64
+#elif defined __ve__
+#define ITT_ARCH ITT_ARCH_VE
 #endif
 #endif
 
 #ifdef __cplusplus
 #define ITT_EXTERN_C extern "C"
 #define ITT_EXTERN_C_BEGIN extern "C" {
 #define ITT_EXTERN_C_END }
 #else

openmp/runtime/src/z_Linux_asm.S

 .Lfunc_end0:
   .size __kmp_invoke_microtask, .Lfunc_end0-__kmp_invoke_microtask
   .cfi_endproc
 
 // -- End  __kmp_invoke_microtask
 
 #endif /* KMP_ARCH_LOONGARCH64 */
 
+#if KMP_ARCH_VE
+
+//------------------------------------------------------------------------
+//
+// typedef void (*microtask_t)(int *gtid, int *tid, ...);
+//
+// int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int tid, int argc,
+//                            void *p_argv[]
+// #if OMPT_SUPPORT
+//                            ,
+//                            void **exit_frame_ptr
+// #endif
+//                            ) {
+// #if OMPT_SUPPORT
+//   *exit_frame_ptr = OMPT_GET_FRAME_ADDRESS(0);
+// #endif
+//
+//   (*pkfn)(&gtid, &tid, argv[0], ...);
+//
+//   return 1;
+// }
+//
+// Parameters:
+//   s0: pkfn
+//   s1: gtid
+//   s2: tid
+//   s3: argc
+//   s4: p_argv
+//   s5: exit_frame_ptr
+//
+// Locals:
+//   __gtid: gtid param pushed on stack so can pass &gtid to pkfn
+//   __tid: tid param pushed on stack so can pass &tid to pkfn
+//
+// Temp. registers:
+//
+//  s34: used to calculate the dynamic stack size
+//  s35: used as temporary for stack placement calculation
+//  s36: used as temporary for stack arguments
+//  s37: used as temporary for number of remaining pkfn parms
+//  s38: used to traverse p_argv array
+//
+// return: s0 (always 1/TRUE)
+//
+
+__gtid = -4
+__tid = -8
+
+// -- Begin __kmp_invoke_microtask
+// mark_begin;
+  .text
+  .globl  __kmp_invoke_microtask
+  // A function requires 8 bytes align.
+  .p2align  3
+  .type __kmp_invoke_microtask,@function
+__kmp_invoke_microtask:
+  .cfi_startproc
+
+  // First, save fp and lr.  VE stores them at caller stack frame.
+  st  %fp, 0(, %sp)
+  st  %lr, 8(, %sp)
+  or  %fp, 0, %sp
+  .cfi_def_cfa  %fp, 0
+  .cfi_offset %lr, 8
+  .cfi_offset %fp, 0
+
+  // Compute the dynamic stack size:
+  //
+  // - We need 8 bytes for storing 'gtid' and 'tid', so we can pass them
+  //   by reference
+  // - We need 8 bytes for whole arguments.  We have two + 'argc'
+  //   arguments (condider &gtid and &tid).  We need to reserve
+  //   (argc + 2) * 8 bytes.
+  // - We need 176 bytes for RSA and others
+  //
+  // The total number of bytes is then (argc + 2) * 8 + 8 + 176.
+  //
+  // |------------------------------|
+  // | return address of callee     | 8(%fp)
+  // |------------------------------|
+  // | frame pointer of callee      | 0(%fp)
+  // |------------------------------| <------------------ %fp
+  // | __tid / __gtid               | -8(%fp) / -4(%fp)
+  // |------------------------------|
+  // | argc+2 for arguments         | 176(%sp)
+  // |------------------------------|
+  // | RSA                          |
+  // |------------------------------|
+  // | return address               |
+  // |------------------------------|
+  // | frame pointer                |
+  // |------------------------------| <------------------ %sp
+
+  adds.w.sx %s34, 2, %s3
+  sll %s34, %s34, 3
+  lea %s34, 184(, %s34)
+  subs.l  %sp, %sp, %s34
+
+  // Align the stack to 16 bytes.
+  and %sp, -16, %sp
+
+  // Save pkfn.
+  or  %s12, 0, %s0
+
+  // Call host to allocate stack if it is necessary.
+  brge.l  %sp, %sl, .L_kmp_pass
+  ld  %s61, 24(, %tp)
+  lea %s63, 0x13b
+  shm.l %s63, 0(%s61)
+  shm.l %sl, 8(%s61)
+  shm.l %sp, 16(%s61)
+  monc
+
+.L_kmp_pass:
+  lea %s35, 176(, %sp)
+  adds.w.sx %s37, 0, %s3
+  or  %s38, 0, %s4
+
+#if OMPT_SUPPORT
+  // Save frame pointer into exit_frame.
+  st  %fp, 0(%s5)
+#endif
+
+  // Prepare arguments for the pkfn function (first 8 using s0-s7
+  // registers, but need to store stack also because of varargs).
+
+  stl %s1, __gtid(%fp)
+  stl %s2, __tid(%fp)
+
+  adds.l  %s0, __gtid, %fp
+  st  %s0, 0(, %s35)
+  adds.l  %s1, __tid, %fp
+  st  %s1, 8(, %s35)
+
+  breq.l  0, %s37, .L_kmp_call
+  ld  %s2, 0(, %s38)
+  st  %s2, 16(, %s35)
+
+  breq.l  1, %s37, .L_kmp_call
+  ld  %s3, 8(, %s38)
+  st  %s3, 24(, %s35)
+
+  breq.l  2, %s37, .L_kmp_call
+  ld  %s4, 16(, %s38)
+  st  %s4, 32(, %s35)
+
+  breq.l  3, %s37, .L_kmp_call
+  ld  %s5, 24(, %s38)
+  st  %s5, 40(, %s35)
+
+  breq.l  4, %s37, .L_kmp_call
+  ld  %s6, 32(, %s38)
+  st  %s6, 48(, %s35)
+
+  breq.l  5, %s37, .L_kmp_call
+  ld  %s7, 40(, %s38)
+  st  %s7, 56(, %s35)
+
+  breq.l  6, %s37, .L_kmp_call
+
+  // Prepare any additional argument passed through the stack.
+  adds.l  %s37, -6, %s37
+  lea %s38, 48(, %s38)
+  lea %s35, 64(, %s35)
+.L_kmp_loop:
+  ld  %s36, 0(, %s38)
+  st  %s36, 0(, %s35)
+  adds.l  %s37, -1, %s37
+  adds.l  %s38, 8, %s38
+  adds.l  %s35, 8, %s35
+  brne.l  0, %s37, .L_kmp_loop
+
+.L_kmp_call:
+  // Call pkfn function.
+  bsic  %lr, (, %s12)
+
+  // Return value.
+  lea %s0, 1
+
+  // Restore stack and return.
+  or  %sp, 0, %fp
+  ld  %lr, 8(, %sp)
+  ld  %fp, 0(, %sp)
+  b.l.t (, %lr)
+.Lfunc_end0:
+  .size __kmp_invoke_microtask, .Lfunc_end0-__kmp_invoke_microtask
+  .cfi_endproc
+
+// -- End  __kmp_invoke_microtask
+
+#endif /* KMP_ARCH_VE */
+
 #if KMP_ARCH_ARM || KMP_ARCH_MIPS
     .data
     COMMON .gomp_critical_user_, 32, 3
     .data
     .align 4
     .global __kmp_unnamed_critical_addr
 __kmp_unnamed_critical_addr:
     .4byte .gomp_critical_user_
 #ifdef __ELF__
     .size __kmp_unnamed_critical_addr,4
 #endif
 #endif /* KMP_ARCH_ARM */
 
-#if KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64
+#if KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64 ||                   \
+    KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64 || KMP_ARCH_VE
 #ifndef KMP_PREFIX_UNDERSCORE
 # define KMP_PREFIX_UNDERSCORE(x) x
 #endif
     .data
     COMMON .gomp_critical_user_, 32, 3
     .data
     .align 8
     .global KMP_PREFIX_UNDERSCORE(__kmp_unnamed_critical_addr)
 KMP_PREFIX_UNDERSCORE(__kmp_unnamed_critical_addr):
     .8byte .gomp_critical_user_
 #ifdef __ELF__
     .size KMP_PREFIX_UNDERSCORE(__kmp_unnamed_critical_addr),8
 #endif
 #endif /* KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64 ||
-          KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64 */
+          KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64 || KMP_ARCH_VE */
 
 #if KMP_OS_LINUX
 # if KMP_ARCH_ARM || KMP_ARCH_AARCH64
 .section .note.GNU-stack,"",%progbits
 # else
 .section .note.GNU-stack,"",@progbits
 # endif
 #endif

openmp/runtime/src/z_Linux_util.cpp

 
 #endif // KMP_OS_DARWIN
 
 #endif // USE_LOAD_BALANCE
 
 #if !(KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_MIC ||                            \
       ((KMP_OS_LINUX || KMP_OS_DARWIN) && KMP_ARCH_AARCH64) ||                 \
       KMP_ARCH_PPC64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64 ||            \
-      KMP_ARCH_ARM)
+      KMP_ARCH_ARM || KMP_ARCH_VE)
 
 // we really only need the case with 1 argument, because CLANG always build
 // a struct of pointers to shared variables referenced in the outlined function
 int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int tid, int argc,
                            void *p_argv[]
 #if OMPT_SUPPORT
                            ,
                            void **exit_frame_ptr

openmp/runtime/test/ompt/callback.h

 // On LoongArch64 the NOP instruction is 4 bytes long, can be followed by
 // inserted jump instruction (another 4 bytes long). And an additional jump
 // instruction may appear (adding 4 more bytes) when the NOP is referenced
 // elsewhere (ie. another branch).
 #define print_possible_return_addresses(addr)                                  \
   printf("%" PRIu64 ": current_address=%p or %p or %p\n",                      \
          ompt_get_thread_data()->value, ((char *)addr) - 4,                    \
          ((char *)addr) - 8, ((char *)addr) - 12)
+#elif KMP_ARCH_VE
+// On VE the NOP instruction is 8 byte long. In addition, the compiler inserts
+// a ??? instruction for non-void runtime functions which is ? bytes long.
+#define print_possible_return_addresses(addr)                                  \
+  printf("%" PRIu64 ": current_address=%p or %p\n",                            \
+         ompt_get_thread_data()->value, ((char *)addr) - 8,                    \
+         ((char *)addr) - 8)
 #else
 #error Unsupported target architecture, cannot determine address offset!
 #endif
 
 
 // This macro performs a somewhat similar job to print_current_address(), except
 // that it discards a certain number of nibbles from the address and only prints
 // the most significant bits / nibbles. This can be used for cases where the