[compiler-rt] [builtins] Fix building atomic.c with GCC

[mgorny]

Summary

Make the use of #pragma redefine_extname and appropriate renames of
builtins conditional to using clang. GCC used not to support it outside
Solaris and currently seems to be very restrictive on applying it.
In other words, it does not work for me with GCC 5.4.0 and the built
libraries use the 'internal' names.

On the other hand, GCC does not have any restrictions on redefining
builtins. So instead of trying to figure out how to make the #pragma
work, it is simpler to make the rename conditional to clang.

[theraven]

This code is working around something that's probably a clang bug. It would be better to fix the clang bug than add more complex workarounds.

[mgorny]

In D30025#678462, @theraven wrote:

This code is working around something that's probably a clang bug. It would be better to fix the clang bug than add more complex workarounds.

Well, clang explicitly rejects those functions as errors, so I would guess it does that by design.

[theraven]

No, it's a bug in clang. Clang does not reject other functions that are used to implement builtins (if it did, compiler-rt would be a lot more difficult to build).

[joerg]

Note that the normal compiler-rt functions have a different name than the builtins they provide, at least from the C frontend view.

[mgorny]

If I read the git correctly, the change that forbid defining builtins was initially made in rL64639. @doug.gregor, any chance you could help us over here? Is clang supposed to unconditionally reject those definitions, and are we supposed to always work-around it in compiler-rt, or should we consider adding some additional switch to allow them in clang?

lib/builtins/atomic.c

  *===----------------------------------------------------------------------===
  */
 
 #include <stdint.h>
 #include <string.h>
 
 #include "assembly.h"
 
+#ifdef __clang__
 // Clang objects if you redefine a builtin.  This little hack allows us to
 // define a function with the same name as an intrinsic.
-#pragma redefine_extname __atomic_load_c SYMBOL_NAME(__atomic_load)
-#pragma redefine_extname __atomic_store_c SYMBOL_NAME(__atomic_store)
-#pragma redefine_extname __atomic_exchange_c SYMBOL_NAME(__atomic_exchange)
-#pragma redefine_extname __atomic_compare_exchange_c SYMBOL_NAME(__atomic_compare_exchange)
+#define ATOMIC_IMPL_SYMBOL(x) x##_c
+#pragma redefine_extname ATOMIC_IMPL_SYMBOL(__atomic_load) SYMBOL_NAME(__atomic_load)
+#pragma redefine_extname ATOMIC_IMPL_SYMBOL(__atomic_store) SYMBOL_NAME(__atomic_store)
+#pragma redefine_extname ATOMIC_IMPL_SYMBOL(__atomic_exchange) SYMBOL_NAME(__atomic_exchange)
+#pragma redefine_extname ATOMIC_IMPL_SYMBOL(__atomic_compare_exchange) SYMBOL_NAME(__atomic_compare_exchange)
+#else
+#define ATOMIC_IMPL_SYMBOL(x) SYMBOL_NAME(x)
+#endif
 
 /// Number of locks.  This allocates one page on 32-bit platforms, two on
 /// 64-bit.  This can be specified externally if a different trade between
 /// memory usage and contention probability is required for a given platform.
 #ifndef SPINLOCK_COUNT
 #define SPINLOCK_COUNT (1<<10)
 #endif
 static const long SPINLOCK_MASK = SPINLOCK_COUNT - 1;
case 16:\
         LOCK_FREE_ACTION(__uint128_t);*/\
       }\
   }\
   } while (0)
 
 
 /// An atomic load operation.  This is atomic with respect to the source
 /// pointer only.
-void __atomic_load_c(int size, void *src, void *dest, int model) {
+void ATOMIC_IMPL_SYMBOL(__atomic_load)(int size, void *src, void *dest, int model) {
 #define LOCK_FREE_ACTION(type) \
     *((type*)dest) = __c11_atomic_load((_Atomic(type)*)src, model);\
     return;
   LOCK_FREE_CASES();
 #undef LOCK_FREE_ACTION
   Lock *l = lock_for_pointer(src);
   lock(l);
   memcpy(dest, src, size);
   unlock(l);
 }
 
 /// An atomic store operation.  This is atomic with respect to the destination
 /// pointer only.
-void __atomic_store_c(int size, void *dest, void *src, int model) {
+void ATOMIC_IMPL_SYMBOL(__atomic_store)(int size, void *dest, void *src, int model) {
 #define LOCK_FREE_ACTION(type) \
     __c11_atomic_store((_Atomic(type)*)dest, *(type*)dest, model);\
     return;
   LOCK_FREE_CASES();
 #undef LOCK_FREE_ACTION
   Lock *l = lock_for_pointer(dest);
   lock(l);
   memcpy(dest, src, size);
   unlock(l);
 }
 
 /// Atomic compare and exchange operation.  If the value at *ptr is identical
 /// to the value at *expected, then this copies value at *desired to *ptr.  If
 /// they  are not, then this stores the current value from *ptr in *expected.
 ///
 /// This function returns 1 if the exchange takes place or 0 if it fails. 
-int __atomic_compare_exchange_c(int size, void *ptr, void *expected,
+int ATOMIC_IMPL_SYMBOL(__atomic_compare_exchange)(int size, void *ptr, void *expected,
     void *desired, int success, int failure) {
 #define LOCK_FREE_ACTION(type) \
   return __c11_atomic_compare_exchange_strong((_Atomic(type)*)ptr, (type*)expected,\
       *(type*)desired, success, failure)
   LOCK_FREE_CASES();
 #undef LOCK_FREE_ACTION
   Lock *l = lock_for_pointer(ptr);
   lock(l);
   if (memcmp(ptr, expected, size) == 0) {
     memcpy(ptr, desired, size);
     unlock(l);
     return 1;
   }
   memcpy(expected, ptr, size);
   unlock(l);
   return 0;
 }
 
 /// Performs an atomic exchange operation between two pointers.  This is atomic
 /// with respect to the target address.
-void __atomic_exchange_c(int size, void *ptr, void *val, void *old, int model) {
+void ATOMIC_IMPL_SYMBOL(__atomic_exchange)(int size, void *ptr, void *val, void *old, int model) {
 #define LOCK_FREE_ACTION(type) \
     *(type*)old = __c11_atomic_exchange((_Atomic(type)*)ptr, *(type*)val,\
         model);\
     return;
   LOCK_FREE_CASES();
 #undef LOCK_FREE_ACTION
   Lock *l = lock_for_pointer(ptr);
   lock(l);