[OpenMP] Add LoongArch64 support

[prcups]

Summary

LoongArch64 is a new risc architecture established by Loongson. There has been PC which contains 3A5000 using this architecture. Now gcc, glibc and binutils have added support for it, while linux mainline will fully support it after 6.1.
This patch adds support for LLVM OpenMP following D59880 for RISCV64.

[SixWeining]

Thanks.

This touches files like D59880 did except openmp/runtime/src/thirdparty/ittnotify/ittnotify_config.h and outdated openmp/www. For ittnotify I suppose we do not need to change it because D109333.

Some concerns:

1. Have you tested existing testcases on a native LoongArch machine? If so, do you use clang or gcc?
2. Do we need to add new tests?

openmp/runtime/CMakeLists.txt

189

nit: Maybe LoongArch64 is better.

openmp/runtime/src/z_Linux_asm.S

1762–1770

What does that mean?

1824

Nit: useless blank line

1833

Nit: generally speaking, comment sentence should ends with a dot('.').

[prcups]

In D132925#3758209, @SixWeining wrote:

Thanks.

This touches files like D59880 did except openmp/runtime/src/thirdparty/ittnotify/ittnotify_config.h and outdated openmp/www. For ittnotify I suppose we do not need to change it because D109333.

Some concerns:

1. Have you tested existing testcases on a native LoongArch machine? If so, do you use clang or gcc?
2. Do we need to add new tests?

For 1, I tried to use "make check", unfortunately, almost all test unit failed. Threads crash just before ending and it seems to be about stack. The crash happened at the end of process kmp_invoke_task_func near kmp_run_after_invoked_task. I 'm trying to find the possible cause.
For 2, because RISC-V doesn't have particular test, and I think common tests on loongarch are adequate to find errors, it is not neccessary to add new tests.

[prcups]

Now I have fixed the problem(The cause is just about not saving return address before calling). Although that, it still failed 4 tests after I ran "make check-openmp". The failed tests are affinity/kmp-affinity.c, affinity/kmp-hw-subset.c, affinity/omp-places.c and teams/teams.c. I 'm not sure if it's necessary to care about and how to handle them. There are also 1 unexpextedly passed and 3 expectedly failed tests.

The comment in CMakeList.txt has been fixed. The 1762-1770 lines in z_Linux_asm.S are just rubbish code I carelessly pasted.

For the dot after comment, in z_Linux_asm.S, it is the same as riscv. Is it also necessary to modify them?

[SixWeining]

In D132925#3763451, @prcups wrote:

Now I have fixed the problem(The cause is just about not saving return address before calling). Although that, it still failed 4 tests after I ran "make check-openmp". The failed tests are affinity/kmp-affinity.c, affinity/kmp-hw-subset.c, affinity/omp-places.c and teams/teams.c. I 'm not sure if it's necessary to care about and how to handle them. There are also 1 unexpextedly passed and 3 expectedly failed tests.

The comment in CMakeList.txt has been fixed. The 1762-1770 lines in z_Linux_asm.S are just rubbish code I carelessly pasted.

For the dot after comment, in z_Linux_asm.S, it is the same as riscv. Is it also necessary to modify them?

Excellent! I haven’t saw this ra issue when I review the patch.

I think you’re using gcc to build the openmp since clang currently is unable to build such complex programs, right?

AFAIK, some tests can only be run by clang. check-openmp is only part of all tests. There are some other targets like check-libomptarget IIRC. So I think it’s better to mention your testing environment, methods and results in the patch summary.

And I’m not a regular reviewer of the openmp subproject. Let’s wait others’ inputs.

[xen0n]

Thanks and welcome to the LLVM community! Some minor comments regarding LoongArch and general coding style.

openmp/README.rst

140

The list is alphabetically sorted, so please put this before "mic".

openmp/runtime/src/kmp_csupport.cpp

703

Similarly place this before MIPS.

openmp/runtime/src/z_Linux_asm.S

1762–1770

I guess it means the return value is in a0 which is always 1.

1777

RISCV instruction words can be 2 bytes long due to RVC, but LoongArch insns are always 4 bytes long. So the p2align value probably should be 2.

1817–1818

LoongArch base ISA has fairly decent bitops, so we can simply bstrins.d $sp, $zero, 3, 0 to clear the lowest 4 bits. (Literally "insert $zero's content into $sp[3:0]".)

openmp/runtime/tools/lib/Platform.pm

102

Place before "mic".

[prcups]

I have followed these instructions to modify it.

[xry111]

openmp/runtime/src/z_Linux_asm.S

1802–1808

Let's be less tricky and reduce one instruction.

[prcups]

Sure

[xry111]

openmp/runtime/src/z_Linux_asm.S

1806

Hmm, looks like something has gone wrong here when my change is applied... addi.d $t0, $t0, 1 is duplicated, and addi.d $t0, $a3, -6 is missing.

[SixWeining]

openmp/runtime/src/z_Linux_asm.S

1805

Should place this line before line 1802?

[SixWeining]

This change LGTM regarding LoongArch.

a samll tip: The patch's summary can be edited in this web page in case you want to mention the testing result. :)

[prcups]

@MaskRay So could you help me commit these changes?

[MaskRay]

In D132925#3785902, @prcups wrote:

@MaskRay So could you help me commit these changes?

I'll do some verification.

[MaskRay]

This works on a GCC compiler farm machine.

gcc -fopenmp a.c -g -o a -I ~/llvm/out/release/projects/openmp/runtime/src ~/llvm/out/release/lib/libomp.so -Wl,-rpath=$HOME/llvm/out/release/lib
./a  # good

[MaskRay]

openmp/runtime/src/kmp_csupport.cpp

703

Revert this change after D130928

[SixWeining]

In D132925#3763451, @prcups wrote:

Now I have fixed the problem(The cause is just about not saving return address before calling). Although that, it still failed 4 tests after I ran "make check-openmp". The failed tests are affinity/kmp-affinity.c, affinity/kmp-hw-subset.c, affinity/omp-places.c and teams/teams.c. I 'm not sure if it's necessary to care about and how to handle them. There are also 1 unexpextedly passed and 3 expectedly failed tests.

Some of failed cases could be fixed by D139802.

openmp/README.rst

 
 **OPENMP_NOT_EXECUTABLE** = ``/path/to/not``
   Specify full path to ``not`` executable for running tests.  The default
   is to search the ``PATH`` and the directory in **OPENMP_LLVM_TOOLS_DIR**.
 
 Options for ``libomp``
 ----------------------
 
-**LIBOMP_ARCH** = ``aarch64|arm|i386|mic|mips|mips64|ppc64|ppc64le|x86_64|riscv64``
+**LIBOMP_ARCH** = ``aarch64|arm|i386|mic|mips|mips64|ppc64|ppc64le|x86_64|riscv64|loongarch64``
   The default value for this option is chosen based on probing the compiler for
   architecture macros (e.g., is ``__x86_64__`` predefined by compiler?).
 
 **LIBOMP_MIC_ARCH** = ``knc|knf``
   Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) to
   build for.  This value is ignored if **LIBOMP_ARCH** does not equal ``mic``.
 
 **LIBOMP_LIB_TYPE** = ``normal|profile|stubs``

 
 **LIBOMP_USE_INTERNODE_ALIGNMENT** = ``OFF|ON``
   Align certain data structures on 4096-byte.  This option is useful on
   multi-node systems where a small ``CACHE_LINE`` setting leads to false sharing.
 
 **LIBOMP_OMPT_SUPPORT** = ``ON|OFF``
   Include support for the OpenMP Tools Interface (OMPT).
   This option is supported and ``ON`` by default for x86, x86_64, AArch64,
-  PPC64 and RISCV64 on Linux* and macOS*.
+  PPC64, RISCV64 and LoongArch64 on Linux* and macOS*.
   This option is ``OFF`` if this feature is not supported for the platform.
 
 **LIBOMP_OMPT_OPTIONAL** = ``ON|OFF``
   Include support for optional OMPT functionality.  This option is ignored if
   **LIBOMP_OMPT_SUPPORT** is ``OFF``.
 
 **LIBOMP_STATS** = ``OFF|ON``
   Include stats-gathering code.

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).")
+    "The architecture to build for (x86_64/i386/arm/ppc64/ppc64le/aarch64/mic/mips/mips64/riscv64/loongarch64).")
   # 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 "aarch64")
     set(LIBOMP_ARCH aarch64)
   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)
   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)
+libomp_check_variable(LIBOMP_ARCH 32e x86_64 32 i386 arm ppc64 ppc64le aarch64 aarch64_a64fx mic mips mips64 riscv64 loongarch64)
 
 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(AARCH64_A64FX FALSE)
 set(PPC64BE FALSE)
 set(PPC64LE FALSE)
 set(PPC64 FALSE)
 set(MIC FALSE)
 set(MIPS64 FALSE)
 set(MIPS FALSE)
 set(RISCV64 FALSE)
+set(LOONGARCH64 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)
   set(PPC64 TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "ppc64le") # PPC64LE architecture
   set(PPC64LE TRUE)
   set(PPC64 TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "aarch64") # AARCH64 architecture
   set(AARCH64 TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "aarch64_a64fx") # AARCH64_A64FX architecture
   set(AARCH64_A64FX TRUE)
 elseif("${LIBOMP_ARCH}" STREQUAL "mic") # Intel(R) Many Integrated Core Architecture
   set(MIC 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)
 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/README.txt

 * Intel(R) 64 architecture
 * Intel(R) Many Integrated Core Architecture
 * ARM* architecture
 * Aarch64 (64-bit ARM) architecture
 * IBM(R) Power architecture (big endian)
 * IBM(R) Power architecture (little endian)
 * MIPS and MIPS64 architecture
 * RISCV64 architecture
+* LoongArch64 architecture
 
 Supported RTL Build Configurations
 ==================================
 
 Supported Architectures: IA-32 architecture, Intel(R) 64, and
 Intel(R) Many Integrated Core Architecture
 
               ----------------------------------------------

openmp/runtime/cmake/LibompGetArchitecture.cmake

set(detect_arch_src_txt "
     #elif defined(__powerpc64__)
       #error ARCHITECTURE=ppc64
     #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
     #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/LibompMicroTests.cmake

elseif(${PPC64})
       libomp_append(libomp_expected_library_deps libc.so.6)
       libomp_append(libomp_expected_library_deps ld64.so.1)
     elseif(${MIPS} OR ${MIPS64})
       libomp_append(libomp_expected_library_deps libc.so.6)
       libomp_append(libomp_expected_library_deps ld.so.1)
     elseif(${RISCV64})
       libomp_append(libomp_expected_library_deps libc.so.6)
       libomp_append(libomp_expected_library_deps ld.so.1)
+    elseif(${LOONGARCH64})
+      libomp_append(libomp_expected_library_deps libc.so.6)
+      libomp_append(libomp_expected_library_deps ld.so.1)
     endif()
     libomp_append(libomp_expected_library_deps libpthread.so.0 IF_FALSE STUBS_LIBRARY)
     libomp_append(libomp_expected_library_deps libhwloc.so.5 LIBOMP_USE_HWLOC)
   endif()
   libomp_append(libomp_expected_library_deps libstdc++.so.6 LIBOMP_USE_STDCPPLIB)
   libomp_append(libomp_expected_library_deps libm.so.6 LIBOMP_STATS)
 endif()
 # Perl script expects comma separated list

openmp/runtime/cmake/LibompUtils.cmake

function(libomp_get_legal_arch return_arch_string)
   elseif(${AARCH64_A64FX})
     set(${return_arch_string} "AARCH64_A64FX" PARENT_SCOPE)
   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)
   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/cmake/config-ix.cmake

else()
   if( # hardware architecture supported?
      ((LIBOMP_ARCH STREQUAL x86_64) OR
       (LIBOMP_ARCH STREQUAL i386) OR
 #      (LIBOMP_ARCH STREQUAL arm) OR
       (LIBOMP_ARCH STREQUAL aarch64) OR
       (LIBOMP_ARCH STREQUAL aarch64_a64fx) OR
       (LIBOMP_ARCH STREQUAL ppc64le) OR
       (LIBOMP_ARCH STREQUAL ppc64) OR
-      (LIBOMP_ARCH STREQUAL riscv64))
+      (LIBOMP_ARCH STREQUAL riscv64) OR
+      (LIBOMP_ARCH STREQUAL loongarch64))
      AND # OS supported?
      ((WIN32 AND LIBOMP_HAVE_PSAPI) OR APPLE OR (NOT WIN32 AND LIBOMP_HAVE_WEAK_ATTRIBUTE)))
     set(LIBOMP_HAVE_OMPT_SUPPORT TRUE)
   else()
     set(LIBOMP_HAVE_OMPT_SUPPORT FALSE)
   endif()
 endif()
 

openmp/runtime/src/kmp_csupport.cpp

 #elif KMP_COMPILER_MSVC
     MemoryBarrier();
 #else
     __sync_synchronize();
 #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)
+       KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64)
 // Nothing to see here move along
 #elif KMP_ARCH_PPC64
 // Nothing needed here (we have a real MB above).
 #else
 #error Unknown or unsupported architecture
 #endif
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL

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_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64
 #define KMP_SIZE_T_SPEC KMP_UINT64_SPEC
 #else
 #error "Can't determine size_t printf format specifier."
 #endif
 
 #if KMP_ARCH_X86
 #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_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64
 #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_X86_64 0
 #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
 
 #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_MIPS64 1
 #else
 #undef KMP_ARCH_MIPS
 #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
 #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_RISCV64 + KMP_ARCH_LOONGARCH64)
 #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_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64
 
 #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/z_Linux_asm.S

 .Lfunc_end0:
   .size __kmp_invoke_microtask, .Lfunc_end0-__kmp_invoke_microtask
   .cfi_endproc
 
 // -- End  __kmp_invoke_microtask
 
 #endif /* KMP_ARCH_RISCV64 */
 
+#if KMP_ARCH_LOONGARCH64
+
+//------------------------------------------------------------------------
+//
+// 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:
+//   a0: pkfn
+//   a1: gtid
+//   a2: tid
+//   a3: argc
+//   a4: p_argv
+//   a5: 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:
+//
+//  t0: used to calculate the dynamic stack size / used to hold pkfn address
+//  t1: used as temporary for stack placement calculation
+//  t2: used as temporary for stack arguments
+//  t3: used as temporary for number of remaining pkfn parms
+//  t4: used to traverse p_argv array
+//
+// return: a0 (always 1/TRUE)
+//
+
+// -- Begin __kmp_invoke_microtask
+// mark_begin;
+  .text
+  .globl  __kmp_invoke_microtask
+  .p2align  1
+  .type __kmp_invoke_microtask,@function
+__kmp_invoke_microtask:
+  .cfi_startproc
+
+  // First, save ra and fp
+  addi.d  $sp, $sp, -16
+  st.d  $ra, $sp, 8
+  st.d  $fp, $sp, 0
+  addi.d  $fp, $sp, 16
+  .cfi_def_cfa  22, 0
+  .cfi_offset 1, -8
+  .cfi_offset 22, -16
+
+  // 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 each argument that cannot be passed to the 'pkfn'
+  //   function by register. Given that we have 8 of such registers (a[0-7])
+  //   and two + 'argc' arguments (consider &gtid and &tid), we need to
+  //   reserve max(0, argc - 6)*8 extra bytes
+  //
+  // The total number of bytes is then max(0, argc - 6)*8 + 8
+
+  // Compute max(0, argc - 6) using the following bithack:
+  // max(0, x) = x - (x & (x >> 31)), where x := argc - 6
+  // Source: http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax
+  addi.d  $t0, $a3, -6
+  srai.d  $t1, $t0, 31
+  and $t1, $t0, $t1
+  sub.d $t0, $t0, $t1
+
+  addi.d  $t0, $t0, 1
+
+  slli.d  $t0, $t0, 3
+  sub.d $sp, $sp, $t0
+
+  // Align the stack to 16 bytes
+
+  addi.d $t8, $zero, -16
+  and $sp, $sp, $t8
+
+  move  $t0, $a0
+  move  $t3, $a3
+  move  $t4, $a4
+
+#if OMPT_SUPPORT
+  // Save frame pointer into exit_frame
+  st.d  $fp, $a5, 0
+#endif
+
+  // Prepare arguments for the pkfn function (first 8 using a0-a7 registers)
+
+  st.w  $a1, $fp, -20
+  st.w  $a2, $fp, -24
+
+  addi.d  $a0, $fp, -20
+  addi.d  $a1, $fp, -24
+
+  beqz  $t3, .L_kmp_3
+  ld.d  $a2, $t4, 0
+
+  addi.d  $t3, $t3, -1
+  beqz  $t3, .L_kmp_3
+  ld.d  $a3, $t4, 8
+
+  addi.d  $t3, $t3, -1
+  beqz  $t3, .L_kmp_3
+  ld.d  $a4, $t4, 16
+
+  addi.d  $t3, $t3, -1
+  beqz  $t3, .L_kmp_3
+  ld.d  $a5, $t4, 24
+
+  addi.d  $t3, $t3, -1
+  beqz  $t3, .L_kmp_3
+  ld.d  $a6, $t4, 32
+
+  addi.d  $t3, $t3, -1
+  beqz  $t3, .L_kmp_3
+  ld.d  $a7, $t4, 40
+
+  // Prepare any additional argument passed through the stack
+  addi.d  $t4, $t4, 48
+  move  $t1, $sp
+  b .L_kmp_2
+.L_kmp_1:
+  ld.d  $t2, $t4, 0
+  st.d  $t2, $t1, 0
+  addi.d  $t4, $t4, 8
+  addi.d  $t1, $t1, 8
+.L_kmp_2:
+  addi.d  $t3, $t3, -1
+  bnez  $t3, .L_kmp_1
+
+.L_kmp_3:
+  // Call pkfn function
+  jirl  $ra, $t0, 0
+
+  // Restore stack and return
+
+  addi.d  $a0, $zero, 1
+
+  addi.d  $sp, $fp, -16
+  ld.d  $fp, $sp, 0
+  ld.d  $ra, $sp, 8
+  addi.d  $sp, $sp, 16
+  jr $ra
+.Lfunc_end0:
+  .size __kmp_invoke_microtask, .Lfunc_end0-__kmp_invoke_microtask
+  .cfi_endproc
+
+// -- End  __kmp_invoke_microtask
+
+#endif /* KMP_ARCH_LOONGARCH64 */
+
 #if KMP_ARCH_ARM || KMP_ARCH_MIPS
     .data
     .comm .gomp_critical_user_,32,8
     .data
     .align 4
     .global __kmp_unnamed_critical_addr
 __kmp_unnamed_critical_addr:
     .4byte .gomp_critical_user_
     .size __kmp_unnamed_critical_addr,4
 #endif /* KMP_ARCH_ARM */
 
-#if KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64
+#if KMP_ARCH_PPC64 || KMP_ARCH_AARCH64 || KMP_ARCH_MIPS64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64
 #ifndef KMP_PREFIX_UNDERSCORE
 # define KMP_PREFIX_UNDERSCORE(x) x
 #endif
     .data
     .comm .gomp_critical_user_,32,8
     .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_RISCV64 || KMP_ARCH_LOONGARCH64 */
 
 #if KMP_OS_LINUX
 # if KMP_ARCH_ARM
 .section .note.GNU-stack,"",%progbits
 # else
 .section .note.GNU-stack,"",@progbits
 # endif
 #endif

openmp/runtime/src/z_Linux_util.cpp

 } // __kmp_get_load_balance
 
 #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_PPC64 || KMP_ARCH_RISCV64 || KMP_ARCH_LOONGARCH64)
 
 // 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

 // inserts a J instruction (targeting the successor basic block), which
 // accounts for another 4 bytes. Finally, an additional J 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\n", \
          ompt_get_thread_data()->value, ((char *)addr) - 8, ((char *)addr) - 12)
 #endif
+#elif KMP_ARCH_LOONGARCH64
+// On LoongArch64 the NOP instruction is 4 bytes long, can be followed by
+// inserted jump instruction (another 4 bytes long).
+#define print_possible_return_addresses(addr)                                  \
+  printf("%" PRIu64 ": current_address=%p or %p\n",                            \
+         ompt_get_thread_data()->value, ((char *)addr) - 4,                    \
+         ((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

openmp/runtime/tools/lib/Platform.pm

if ( defined( $arch ) ) {
         } elsif ( $arch =~ m{\Amic} ) {
             $arch = "mic";
         } elsif ( $arch =~ m{\Amips64} ) {
             $arch = "mips64";
         } elsif ( $arch =~ m{\Amips} ) {
             $arch = "mips";
         } elsif ( $arch =~ m{\Ariscv64} ) {
             $arch = "riscv64";
+        } elsif ( $arch =~ m{\Aloongarch64} ) {
+            $arch = "loongarch64";
         } else {
             $arch = undef;
         }; # if
     }; # if
     return $arch;
 }; # sub canon_arch
 
 # Canonize Intel(R) Many Integrated Core Architecture name.
my %legal = (
         "32"  => "IA-32 architecture",
         "32e" => "Intel(R) 64",
         "arm" => "ARM",
         "aarch64" => "AArch64",
         "mic" => "Intel(R) Many Integrated Core Architecture",
         "mips" => "MIPS",
         "mips64" => "MIPS64",
         "riscv64" => "RISC-V (64-bit)",
+        "loongarch64" => "LoongArch64",
     );
 
     sub legal_arch($) {
         my ( $arch ) = @_;
         $arch = canon_arch( $arch );
         if ( defined( $arch ) ) {
             $arch = $legal{ $arch };
         }; # if
# Detect host arch.
     } elsif ( $hardware_platform eq "aarch64" ) {
         $_host_arch = "aarch64";
     } elsif ( $hardware_platform eq "mips64" ) {
         $_host_arch = "mips64";
     } elsif ( $hardware_platform eq "mips" ) {
         $_host_arch = "mips";
     } elsif ( $hardware_platform eq "riscv64" ) {
         $_host_arch = "riscv64";
+    } elsif ( $hardware_platform eq "loongarch64" ) {
+        $_host_arch = "loongarch64";
     } else {
         die "Unsupported host hardware platform: \"$hardware_platform\"; stopped";
     }; # if
 }
 
 # Detect host OS.
 {
     my $operating_system = Uname::operating_system();

 =head2 Functions.
 
 =over
 
 =item B<canon_arch( $arch )>
 
 Input string is an architecture name to canonize. The function recognizes many variants, for example:
 C<32e>, C<Intel64>, C<Intel(R) 64>, etc. Returned string is a canonized architecture name,
-one of: C<32>, C<32e>, C<64>, C<arm>, C<ppc64le>, C<ppc64>, C<mic>, C<mips>, C<mips64>, C<riscv64> or C<undef> is input string is not recognized.
+one of: C<32>, C<32e>, C<64>, C<arm>, C<ppc64le>, C<ppc64>, C<mic>, C<mips>, C<mips64>, C<riscv64>, C<loongarch64> or C<undef> is input string is not recognized.
 
 =item B<legal_arch( $arch )>
 
 Input string is architecture name. The function recognizes the same variants as C<arch_canon()> does.
 Returned string is a name approved by Intel Legal, one of: C<IA-32 architecture>, C<Intel(R) 64>
 or C<undef> if input string is not recognized.
 
 =item B<arch_opt( $arch )>

openmp/runtime/tools/lib/Uname.pm

if ( 0 ) {
     } elsif ( $values{ machine } =~ m{\Aaarch64\z} ) {
         $values{ hardware_platform } = "aarch64";
     } elsif ( $values{ machine } =~ m{\Amips64\z} ) {
         $values{ hardware_platform } = "mips64";
     } elsif ( $values{ machine } =~ m{\Amips\z} ) {
         $values{ hardware_platform } = "mips";
     } elsif ( $values{ machine } =~ m{\Ariscv64\z} ) {
         $values{ hardware_platform } = "riscv64";
+    } elsif ( $values{ machine } =~ m{\Aloongarch64\z} ) {
+        $values{ hardware_platform } = "loongarch64";
     } else {
         die "Unsupported machine (\"$values{ machine }\") returned by POSIX::uname(); stopped";
     }; # if
 } elsif ( $^O eq "darwin" ) {
     if ( 0 ) {
     } elsif ( $values{ machine } eq "x86" or $values{ machine } eq "i386" ) {
         $values{ hardware_platform } =
             sub {