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

 
     %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_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

openmp/runtime/src/kmp_atomic.h

 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);

 kmp_cmplx32 __kmpc_atomic_cmplx4_rd(ident_t *id_ref, int gtid,
                                     kmp_cmplx32 *loc);
 #endif
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 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);
+#endif
 #if KMP_HAVE_QUAD
 CPLX128_LEG __kmpc_atomic_cmplx16_rd(ident_t *id_ref, int gtid,
                                      CPLX128_LEG *loc);

                                   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);
-
+#if KMP_ARCH_X86 || KMP_ARCH_X86_64
 kmp_cmplx64 __kmpc_atomic_cmplx8_add_cpt(ident_t *id_ref, int gtid,
                                          kmp_cmplx64 *lhs, kmp_cmplx64 rhs,
                                          int flag);

 kmp_cmplx80 __kmpc_atomic_cmplx10_div_cpt(ident_t *id_ref, int gtid,
                                           kmp_cmplx80 *lhs, kmp_cmplx80 rhs,
                                           int flag);
+#endif
 #if KMP_HAVE_QUAD
 CPLX128_LEG __kmpc_atomic_cmplx16_add_cpt(ident_t *id_ref, int gtid,
                                           CPLX128_LEG *lhs, CPLX128_LEG rhs,

 
 // 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,

openmp/runtime/src/kmp_atomic.cpp

 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

 // 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)

openmp/runtime/src/kmp_os.h

 }
 
 // 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