[openmp] Allow x87 fp functions only in Openmp runtime for x86.

[malharJ]

Summary

This patch allows Openmp runtime atomic functions operating on x87 high-precision
to be present only in Openmp runtime for x86 architectures

The functions affected are:

__kmpc_atomic_10
__kmpc_atomic_20
__kmpc_atomic_cmplx10_add
__kmpc_atomic_cmplx10_div
__kmpc_atomic_cmplx10_mul
__kmpc_atomic_cmplx10_sub
__kmpc_atomic_float10_add
__kmpc_atomic_float10_div
__kmpc_atomic_float10_mul
__kmpc_atomic_float10_sub

__kmpc_atomic_float10_add_fp
__kmpc_atomic_float10_div_fp
__kmpc_atomic_float10_mul_fp
__kmpc_atomic_float10_sub_fp
__kmpc_atomic_float10_max
__kmpc_atomic_float10_min

[AndreyChurbanov]

LGTM

[alvinhochun]

This change seems to be the cause of https://github.com/llvm/llvm-project/issues/56349.

openmp/runtime/src/kmp_atomic.cpp

 MIN_MAX_COMPXCHG(float4, max, kmp_real32, 32, <, 4r, 3,
                  KMP_ARCH_X86) // __kmpc_atomic_float4_max
 MIN_MAX_COMPXCHG(float4, min, kmp_real32, 32, >, 4r, 3,
                  KMP_ARCH_X86) // __kmpc_atomic_float4_min
 MIN_MAX_COMPXCHG(float8, max, kmp_real64, 64, <, 8r, 7,
                  KMP_ARCH_X86) // __kmpc_atomic_float8_max
 MIN_MAX_COMPXCHG(float8, min, kmp_real64, 64, >, 8r, 7,
                  KMP_ARCH_X86) // __kmpc_atomic_float8_min
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 MIN_MAX_CRITICAL(float10, max, long double, <, 10r,
                  1) // __kmpc_atomic_float10_max
 MIN_MAX_CRITICAL(float10, min, long double, >, 10r,
                  1) // __kmpc_atomic_float10_min
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
 #if KMP_HAVE_QUAD
 MIN_MAX_CRITICAL(float16, max, QUAD_LEGACY, <, 16r,
                  1) // __kmpc_atomic_float16_max
 MIN_MAX_CRITICAL(float16, min, QUAD_LEGACY, >, 16r,
                  1) // __kmpc_atomic_float16_min
 #if (KMP_ARCH_X86)
 MIN_MAX_CRITICAL(float16, max_a16, Quad_a16_t, <, 16r,
                  1) // __kmpc_atomic_float16_max_a16

 //     LCK_ID  - lock identifier, used to possibly distinguish lock variable
 #define ATOMIC_CRITICAL(TYPE_ID, OP_ID, TYPE, OP, LCK_ID, GOMP_FLAG)           \
   ATOMIC_BEGIN(TYPE_ID, OP_ID, TYPE, void)                                     \
   OP_UPDATE_GOMP_CRITICAL(TYPE, OP, GOMP_FLAG) /* send assignment */           \
   OP_UPDATE_CRITICAL(TYPE, OP, LCK_ID) /* send assignment */                   \
   }
 
 /* ------------------------------------------------------------------------- */
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 // routines for long double type
 ATOMIC_CRITICAL(float10, add, long double, +, 10r,
                 1) // __kmpc_atomic_float10_add
 ATOMIC_CRITICAL(float10, sub, long double, -, 10r,
                 1) // __kmpc_atomic_float10_sub
 ATOMIC_CRITICAL(float10, mul, long double, *, 10r,
                 1) // __kmpc_atomic_float10_mul
 ATOMIC_CRITICAL(float10, div, long double, /, 10r,
                 1) // __kmpc_atomic_float10_div
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
 #if KMP_HAVE_QUAD
 // routines for _Quad type
 ATOMIC_CRITICAL(float16, add, QUAD_LEGACY, +, 16r,
                 1) // __kmpc_atomic_float16_add
 ATOMIC_CRITICAL(float16, sub, QUAD_LEGACY, -, 16r,
                 1) // __kmpc_atomic_float16_sub
 ATOMIC_CRITICAL(float16, mul, QUAD_LEGACY, *, 16r,
                 1) // __kmpc_atomic_float16_mul

 ATOMIC_CRITICAL(cmplx4, mul, kmp_cmplx32, *, 8c, 1) // __kmpc_atomic_cmplx4_mul
 ATOMIC_CRITICAL(cmplx4, div, kmp_cmplx32, /, 8c, 1) // __kmpc_atomic_cmplx4_div
 #endif // USE_CMPXCHG_FIX
 
 ATOMIC_CRITICAL(cmplx8, add, kmp_cmplx64, +, 16c, 1) // __kmpc_atomic_cmplx8_add
 ATOMIC_CRITICAL(cmplx8, sub, kmp_cmplx64, -, 16c, 1) // __kmpc_atomic_cmplx8_sub
 ATOMIC_CRITICAL(cmplx8, mul, kmp_cmplx64, *, 16c, 1) // __kmpc_atomic_cmplx8_mul
 ATOMIC_CRITICAL(cmplx8, div, kmp_cmplx64, /, 16c, 1) // __kmpc_atomic_cmplx8_div
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 ATOMIC_CRITICAL(cmplx10, add, kmp_cmplx80, +, 20c,
                 1) // __kmpc_atomic_cmplx10_add
 ATOMIC_CRITICAL(cmplx10, sub, kmp_cmplx80, -, 20c,
                 1) // __kmpc_atomic_cmplx10_sub
 ATOMIC_CRITICAL(cmplx10, mul, kmp_cmplx80, *, 20c,
                 1) // __kmpc_atomic_cmplx10_mul
 ATOMIC_CRITICAL(cmplx10, div, kmp_cmplx80, /, 20c,
                 1) // __kmpc_atomic_cmplx10_div
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
 #if KMP_HAVE_QUAD
 ATOMIC_CRITICAL(cmplx16, add, CPLX128_LEG, +, 32c,
                 1) // __kmpc_atomic_cmplx16_add
 ATOMIC_CRITICAL(cmplx16, sub, CPLX128_LEG, -, 32c,
                 1) // __kmpc_atomic_cmplx16_sub
 ATOMIC_CRITICAL(cmplx16, mul, CPLX128_LEG, *, 32c,
                 1) // __kmpc_atomic_cmplx16_mul
 ATOMIC_CRITICAL(cmplx16, div, CPLX128_LEG, /, 32c,
ATOMIC_CMPXCHG_MIX(float8, kmp_real64, add, 64, +, fp, _Quad, 8r, 7,
                    KMP_ARCH_X86) // __kmpc_atomic_float8_add_fp
 ATOMIC_CMPXCHG_MIX(float8, kmp_real64, sub, 64, -, fp, _Quad, 8r, 7,
                    KMP_ARCH_X86) // __kmpc_atomic_float8_sub_fp
 ATOMIC_CMPXCHG_MIX(float8, kmp_real64, mul, 64, *, fp, _Quad, 8r, 7,
                    KMP_ARCH_X86) // __kmpc_atomic_float8_mul_fp
 ATOMIC_CMPXCHG_MIX(float8, kmp_real64, div, 64, /, fp, _Quad, 8r, 7,
                    KMP_ARCH_X86) // __kmpc_atomic_float8_div_fp
 
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 ATOMIC_CRITICAL_FP(float10, long double, add, +, fp, _Quad, 10r,
                    1) // __kmpc_atomic_float10_add_fp
 ATOMIC_CRITICAL_FP(float10, long double, sub, -, fp, _Quad, 10r,
                    1) // __kmpc_atomic_float10_sub_fp
 ATOMIC_CRITICAL_FP(float10, long double, mul, *, fp, _Quad, 10r,
                    1) // __kmpc_atomic_float10_mul_fp
 ATOMIC_CRITICAL_FP(float10, long double, div, /, fp, _Quad, 10r,
                    1) // __kmpc_atomic_float10_div_fp
 
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 // Reverse operations
 ATOMIC_CMPXCHG_REV_MIX(fixed1, char, sub_rev, 8, -, fp, _Quad, 1i, 0,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1_sub_rev_fp
 ATOMIC_CMPXCHG_REV_MIX(fixed1u, uchar, sub_rev, 8, -, fp, _Quad, 1i, 0,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1u_sub_rev_fp
 ATOMIC_CMPXCHG_REV_MIX(fixed1, char, div_rev, 8, /, fp, _Quad, 1i, 0,
                        KMP_ARCH_X86) // __kmpc_atomic_fixed1_div_rev_fp
 ATOMIC_CMPXCHG_REV_MIX(fixed1u, uchar, div_rev, 8, /, fp, _Quad, 1i, 0,

 #ifdef KMP_GOMP_COMPAT
     if (__kmp_atomic_mode == 2) {
       __kmp_release_atomic_lock(&__kmp_atomic_lock, gtid);
     } else
 #endif /* KMP_GOMP_COMPAT */
       __kmp_release_atomic_lock(&__kmp_atomic_lock_8i, gtid);
   }
 }
-
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 void __kmpc_atomic_10(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *)) {
   KMP_DEBUG_ASSERT(__kmp_init_serial);
 
 #ifdef KMP_GOMP_COMPAT
   if (__kmp_atomic_mode == 2) {
     __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
   } else
 #endif /* KMP_GOMP_COMPAT */
     __kmp_acquire_atomic_lock(&__kmp_atomic_lock_10r, gtid);
 
   (*f)(lhs, lhs, rhs);
 
 #ifdef KMP_GOMP_COMPAT
   if (__kmp_atomic_mode == 2) {
     __kmp_release_atomic_lock(&__kmp_atomic_lock, gtid);
   } else
 #endif /* KMP_GOMP_COMPAT */
     __kmp_release_atomic_lock(&__kmp_atomic_lock_10r, gtid);
 }
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
 
 void __kmpc_atomic_16(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *)) {
   KMP_DEBUG_ASSERT(__kmp_init_serial);
 
 #ifdef KMP_GOMP_COMPAT
   if (__kmp_atomic_mode == 2) {
     __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
   } else
 #endif /* KMP_GOMP_COMPAT */
     __kmp_acquire_atomic_lock(&__kmp_atomic_lock_16c, gtid);
 
   (*f)(lhs, lhs, rhs);
 
 #ifdef KMP_GOMP_COMPAT
   if (__kmp_atomic_mode == 2) {
     __kmp_release_atomic_lock(&__kmp_atomic_lock, gtid);
   } else
 #endif /* KMP_GOMP_COMPAT */
     __kmp_release_atomic_lock(&__kmp_atomic_lock_16c, gtid);
 }
-
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 void __kmpc_atomic_20(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *)) {
   KMP_DEBUG_ASSERT(__kmp_init_serial);
 
 #ifdef KMP_GOMP_COMPAT
   if (__kmp_atomic_mode == 2) {
     __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
   } else
 #endif /* KMP_GOMP_COMPAT */
     __kmp_acquire_atomic_lock(&__kmp_atomic_lock_20c, gtid);
 
   (*f)(lhs, lhs, rhs);
 
 #ifdef KMP_GOMP_COMPAT
   if (__kmp_atomic_mode == 2) {
     __kmp_release_atomic_lock(&__kmp_atomic_lock, gtid);
   } else
 #endif /* KMP_GOMP_COMPAT */
     __kmp_release_atomic_lock(&__kmp_atomic_lock_20c, gtid);
 }
-
+#endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
 void __kmpc_atomic_32(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *)) {
   KMP_DEBUG_ASSERT(__kmp_init_serial);
 
 #ifdef KMP_GOMP_COMPAT
   if (__kmp_atomic_mode == 2) {
     __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
   } else