[compiler-rt][atomics] Add `restrict` modifier to pointer arguments of `__atomic_exchange_c`

[lkail]

Summary

Add constraint that ptr, val and old should not alias each other.

[theraven]

I don't believe a compiler can ever generate code that hits this code path. The public function is:

c
C atomic_exchange_explicit( volatile A* obj, C desired, memory_order order );

The compiler lowers this by allocating space for the return value (*old) and passing desired by reference. The right thing to do is probably document that the two parameters must not alias (I'd be happy with sticking restrict on all three pointer arguments, actually, and documenting that).

I really don't like the xor magic in the alternative path because it breaks any pointer provenance. If the target is any kind of CHERI CPU, it will generate invalid machine code. If we are in an LTO build and end up inlining this function then we're destroying any alias info that we might otherwise have. If we actually need that path, I'd much rather that we copied everything via a temporary and used intptr_t for any chunks that are sized and aligned like an intptr_t.

[lkail]

Thanks @theraven 's detailed explanation. Updated per his suggestion.

compiler-rt/lib/builtins/atomic.c

if (memcmp(ptr, expected, size) == 0) {
     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) {
+/// with respect to the target address. ptr, val and old should not alias each
+/// other.
+void __atomic_exchange_c(int size, void *restrict ptr, void *restrict val,
+                         void *restrict old, int model) {
 #define LOCK_FREE_ACTION(type)                                                 \
   *(type *)old =                                                               \
       __c11_atomic_exchange((_Atomic(type) *)ptr, *(type *)val, model);        \
   return;
   LOCK_FREE_CASES(ptr);
 #undef LOCK_FREE_ACTION
   Lock *l = lock_for_pointer(ptr);
   lock(l);