Enable kmpc_atomic functions for arm64

[branh]

Summary

Define the same kmpc_atomic functions for arm and arm64 that are defined for x86 and x64.

[mstorsjo]

openmp/runtime/src/kmp_atomic.h

1033

Why are these functions only declared on x86? These functions are among the exported ones. Since they aren't declared here (within an extern "C" {...} block, they end up with mangled C++ names. When linking in MSVC mode, the linker still manages to map the undecorated C symbol name to the C++ symbol and exporting that, but in mingw mode, it doesn't automatically find a matching itanium mangled symbol.

1341

The same goes for this ifdef block.

[mstorsjo]

Hmm, that’s a good point. However I don’t get any warnings for these when I build with Clang though…

If these are functions that are supposed to be called from user C code, then they probably don’t make much sense if they return a C-incompatible type. If they are supposed to be called from compiler generated code which handles the return type correctly anyway (or only ever accessed from C++ code), then it’s probably ok to include them and just silence that warning with suitable mechanisms.

// Martin

[branh]

Updated based on Martin's feedback.

[mstorsjo]

Thanks, this version builds successfully for me - but I presume this configuration produces warnings when built with MSVC?

(Btw, when uploading diffs, keep in mind that Phabricator works best if you include extra context, e.g. git diff -U999.)

[mstorsjo]

It seems like Bran's replies via email doesn't make it into Phabricator.

Anyway...:

It produces warnings when built with MSVC, but I think you're right that this is probably okay. The warnings can be suppressed in the command line arguments for the build. It looks like they already occur in a few other places, as we've already suppressed them in our build pipeline.

Ok, with that in mind, this patch looks ok to me.

[branh]

I don't have commit permissions. If the change is good, could someone please commit it?

If not, are there any additional tests I need to run?

Thank you.

[mstorsjo]

In D139139#3972726, @branh wrote:

I don't have commit permissions. If the change is good, could someone please commit it?

Sure - can you state your preferred git author line for the patch, i.e. Real Name <email@address>?

[branh]

Preferred git author line: Bran Hagger <[e-mail]>

openmp/runtime/src/dllexports

%ifdef arch_32
         __kmpc_atomic_cmplx16_add_a16      2261
         __kmpc_atomic_cmplx16_sub_a16      2262
         __kmpc_atomic_cmplx16_mul_a16      2263
         __kmpc_atomic_cmplx16_div_a16      2264
         %endif
 
     %endif
 
-    # These are specific to x86 and x64
-    %ifdef IS_IA_ARCH
-
-        # ATOMIC extensions for OpenMP 3.1 spec (x86 and x64 only)
+        # ATOMIC extensions for OpenMP 3.1 spec
 
         __kmpc_atomic_fixed1_rd                2265
         __kmpc_atomic_fixed2_rd                2266
         __kmpc_atomic_fixed4_rd                2267
         __kmpc_atomic_fixed8_rd                2268
         __kmpc_atomic_float4_rd                2269
         __kmpc_atomic_float8_rd                2270
         __kmpc_atomic_float10_rd               2271
%endif
         __kmpc_atomic_float8_div_cpt_fp
 
         __kmpc_atomic_float10_add_cpt_fp
         __kmpc_atomic_float10_sub_cpt_fp
         __kmpc_atomic_float10_mul_cpt_fp
         __kmpc_atomic_float10_div_cpt_fp
         %endif
 
+            # These are specific to x86 and x64
+            %ifdef IS_IA_ARCH
+
             # ATOMIC extensions for OpenMP 4.0 spec (x86 and x64 only)
 
             __kmpc_atomic_fixed1_swp           2412
             __kmpc_atomic_fixed2_swp           2413
             __kmpc_atomic_fixed4_swp           2414
             __kmpc_atomic_fixed8_swp           2415
             __kmpc_atomic_float4_swp           2416
             __kmpc_atomic_float8_swp           2417

openmp/runtime/src/kmp_atomic.h

void __kmpc_atomic_10(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *));
 void __kmpc_atomic_16(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *));
 void __kmpc_atomic_20(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *));
 void __kmpc_atomic_32(ident_t *id_ref, int gtid, void *lhs, void *rhs,
                       void (*f)(void *, void *, void *));
 
-// READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+// READ, WRITE, CAPTURE
 
 //  Below routines for atomic READ are listed
 char __kmpc_atomic_fixed1_rd(ident_t *id_ref, int gtid, char *loc);
 short __kmpc_atomic_fixed2_rd(ident_t *id_ref, int gtid, short *loc);
 kmp_int32 __kmpc_atomic_fixed4_rd(ident_t *id_ref, int gtid, kmp_int32 *loc);
 kmp_int64 __kmpc_atomic_fixed8_rd(ident_t *id_ref, int gtid, kmp_int64 *loc);
 kmp_real32 __kmpc_atomic_float4_rd(ident_t *id_ref, int gtid, kmp_real32 *loc);
 kmp_real64 __kmpc_atomic_float8_rd(ident_t *id_ref, int gtid, kmp_real64 *loc);
 long double __kmpc_atomic_float10_rd(ident_t *id_ref, int gtid,
                                      long double *loc);
 #if KMP_HAVE_QUAD
 QUAD_LEGACY __kmpc_atomic_float16_rd(ident_t *id_ref, int gtid,
                                      QUAD_LEGACY *loc);
 #endif
 // Fix for CQ220361: cmplx4 READ will return void on Windows* OS; read value
 // will be returned through an additional parameter
 #if (KMP_OS_WINDOWS)
 void __kmpc_atomic_cmplx4_rd(kmp_cmplx32 *out, ident_t *id_ref, int gtid,
                              kmp_cmplx32 *loc);
 #else
 kmp_cmplx32 __kmpc_atomic_cmplx4_rd(ident_t *id_ref, int gtid,
                                     kmp_cmplx32 *loc);
 #endif
 kmp_cmplx64 __kmpc_atomic_cmplx8_rd(ident_t *id_ref, int gtid,
                                     kmp_cmplx64 *loc);
 kmp_cmplx80 __kmpc_atomic_cmplx10_rd(ident_t *id_ref, int gtid,
                                      kmp_cmplx80 *loc);
 #if KMP_HAVE_QUAD
 CPLX128_LEG __kmpc_atomic_cmplx16_rd(ident_t *id_ref, int gtid,
                                      CPLX128_LEG *loc);
 #if (KMP_ARCH_X86)
 // Routines with 16-byte arguments aligned to 16-byte boundary
 Quad_a16_t __kmpc_atomic_float16_a16_rd(ident_t *id_ref, int gtid,

 void __kmpc_atomic_cmplx4_add_cpt(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
                                   kmp_cmplx32 rhs, kmp_cmplx32 *out, int flag);
 void __kmpc_atomic_cmplx4_sub_cpt(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
                                   kmp_cmplx32 rhs, kmp_cmplx32 *out, int flag);
 void __kmpc_atomic_cmplx4_mul_cpt(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
                                   kmp_cmplx32 rhs, kmp_cmplx32 *out, int flag);
 void __kmpc_atomic_cmplx4_div_cpt(ident_t *id_ref, int gtid, kmp_cmplx32 *lhs,
                                   kmp_cmplx32 rhs, kmp_cmplx32 *out, int flag);
-
 kmp_cmplx64 __kmpc_atomic_cmplx8_add_cpt(ident_t *id_ref, int gtid,
                                          kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
                                          int flag);
 kmp_cmplx64 __kmpc_atomic_cmplx8_sub_cpt(ident_t *id_ref, int gtid,
                                          kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
                                          int flag);
 kmp_cmplx64 __kmpc_atomic_cmplx8_mul_cpt(ident_t *id_ref, int gtid,
                                          kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
                                          int flag);
 kmp_cmplx64 __kmpc_atomic_cmplx8_div_cpt(ident_t *id_ref, int gtid,
                                          kmp_cmplx64 *lhs, kmp_cmplx64 rhs,

 #endif
 #endif
 
 void __kmpc_atomic_start(void);
 void __kmpc_atomic_end(void);
 
 // OpenMP 4.0: v = x = expr binop x; { v = x; x = expr binop x; } { x = expr
 // binop x; v = x; }  for non-commutative operations.
-
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 char __kmpc_atomic_fixed1_sub_cpt_rev(ident_t *id_ref, int gtid, char *lhs,
                                       char rhs, int flag);
 char __kmpc_atomic_fixed1_div_cpt_rev(ident_t *id_ref, int gtid, char *lhs,
                                       char rhs, int flag);
 unsigned char __kmpc_atomic_fixed1u_div_cpt_rev(ident_t *id_ref, int gtid,
                                                 unsigned char *lhs,
                                                 unsigned char rhs, int flag);
 char __kmpc_atomic_fixed1_shl_cpt_rev(ident_t *id_ref, int gtid, char *lhs,

openmp/runtime/src/kmp_atomic.cpp

ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, add, 64, +, cmplx8, kmp_cmplx64, 8c,
                      7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_add_cmplx8
 ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, sub, 64, -, cmplx8, kmp_cmplx64, 8c,
                      7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_sub_cmplx8
 ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, mul, 64, *, cmplx8, kmp_cmplx64, 8c,
                      7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_mul_cmplx8
 ATOMIC_CMPXCHG_CMPLX(cmplx4, kmp_cmplx32, div, 64, /, cmplx8, kmp_cmplx64, 8c,
                      7, KMP_ARCH_X86) // __kmpc_atomic_cmplx4_div_cmplx8
 
-// READ, WRITE, CAPTURE are supported only on IA-32 architecture and Intel(R) 64
-#if KMP_ARCH_X86 || KMP_ARCH_X86_64
+// READ, WRITE, CAPTURE
 
 // ------------------------------------------------------------------------
 // Atomic READ routines
 
 // ------------------------------------------------------------------------
 // Beginning of a definition (provides name, parameters, gebug trace)
 //     TYPE_ID - operands type and size (fixed*, fixed*u for signed, unsigned
 //     fixed)
ATOMIC_CRITICAL_CPT(cmplx16, div_a16_cpt, kmp_cmplx128_a16_t, /, 32c,
                     1) // __kmpc_atomic_cmplx16_div_a16_cpt
 #endif // (KMP_ARCH_X86)
 #endif // KMP_HAVE_QUAD
 
 // OpenMP 4.0: v = x = expr binop x; { v = x; x = expr binop x; } { x = expr
 // binop x; v = x; }  for non-commutative operations.
 // Supported only on IA-32 architecture and Intel(R) 64
 
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 // -------------------------------------------------------------------------
 // Operation on *lhs, rhs bound by critical section
 //     OP     - operator (it's supposed to contain an assignment)
 //     LCK_ID - lock identifier
 // Note: don't check gtid as it should always be valid
 // 1, 2-byte - expect valid parameter, other - check before this macro
 #define OP_CRITICAL_CPT_REV(TYPE, OP, LCK_ID)                                  \
   __kmp_acquire_atomic_lock(&ATOMIC_LOCK##LCK_ID, gtid);                       \

openmp/runtime/src/kmp_os.h

 }
 
 inline kmp_int32 __kmp_compare_and_store_ptr(void *volatile *p, void *cv,
                                              void *sv) {
   return _InterlockedCompareExchangePointer(p, sv, cv) == cv;
 }
 
 // The _RET versions return the value instead of a bool
-/*
+
 #define KMP_COMPARE_AND_STORE_RET8(p, cv, sv)                                  \
    _InterlockedCompareExchange8((p), (sv), (cv))
 #define KMP_COMPARE_AND_STORE_RET16(p, cv, sv)                                 \
   _InterlockedCompareExchange16((p), (sv), (cv))
-*/
+
 #define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \
   _InterlockedCompareExchange64((volatile kmp_int64 *)(p), (kmp_int64)(sv),    \
                                 (kmp_int64)(cv))
 
-/*
+
 #define KMP_XCHG_FIXED8(p, v)                                                  \
   _InterlockedExchange8((volatile kmp_int8 *)(p), (kmp_int8)(v));
-*/
-// #define KMP_XCHG_FIXED16(p, v) _InterlockedExchange16((p), (v));
-// #define KMP_XCHG_REAL64(p, v) __kmp_xchg_real64((p), (v)));
+#define KMP_XCHG_FIXED16(p, v) _InterlockedExchange16((p), (v));
+#define KMP_XCHG_REAL64(p, v) __kmp_xchg_real64((p), (v)));
 
-// inline kmp_real64 __kmp_xchg_real64(volatile kmp_real64 *p, kmp_real64 v) {
-//   kmp_int64 tmp = _InterlockedExchange64((volatile kmp_int64 *)p, *(kmp_int64
-//   *)&v); return *(kmp_real64 *)&tmp;
-// }
+inline kmp_real64 __kmp_xchg_real64(volatile kmp_real64 *p, kmp_real64 v) {
+  kmp_int64 tmp = _InterlockedExchange64((volatile kmp_int64 *)p, *(kmp_int64
+  *)&v); return *(kmp_real64 *)&tmp;
+}
 
 #else // !KMP_ARCH_AARCH64
 
 // Routines that we still need to implement in assembly.
 extern kmp_int8 __kmp_test_then_add8(volatile kmp_int8 *p, kmp_int8 v);
 
 extern kmp_int8 __kmp_compare_and_store8(volatile kmp_int8 *p, kmp_int8 cv,
                                          kmp_int8 sv);