[scudo] Select stricter atomic memory_order in MemMapFuchsia

[fabio-d]

Summary

Previously, all operations were relaxed except for the
atomic_compare_exchange call, which was implicitly acquire (but did not
compile anymore because of the changes in commit
3ef766addadd8324f58c0fda0301edcde2185cb3).

In addition to making MemMapFuchsia compile again, this CL selects
memory_order values that better express the intent of the code.

[Chia-hungDuan]

sorry for the breakage

compiler-rt/lib/scudo/standalone/mem_map_fuchsia.cpp

static void setVmoName(zx_handle_t Vmo, const char *Name) {
   zx_status_t Status = _zx_object_set_property(Vmo, ZX_PROP_NAME, Name, Len);
   CHECK_EQ(Status, ZX_OK);
 }
 
 // Returns the (cached) base address of the root VMAR.
 static uptr getRootVmarBase() {
   static atomic_uptr CachedResult = {0};
 
-  uptr Result = atomic_load_relaxed(&CachedResult);
+  uptr Result = atomic_load(&CachedResult, memory_order_acquire);
   if (UNLIKELY(!Result)) {
     zx_info_vmar_t VmarInfo;
     zx_status_t Status =
         _zx_object_get_info(_zx_vmar_root_self(), ZX_INFO_VMAR, &VmarInfo,
                             sizeof(VmarInfo), nullptr, nullptr);
     CHECK_EQ(Status, ZX_OK);
     CHECK_NE(VmarInfo.base, 0);
 
-    atomic_store_relaxed(&CachedResult, VmarInfo.base);
+    atomic_store(&CachedResult, VmarInfo.base, memory_order_release);
     Result = VmarInfo.base;
   }
 
   return Result;
 }
 
 // Lazily creates and then always returns the same zero-sized VMO.
 static zx_handle_t getPlaceholderVmo() {
   static atomic_u32 StoredVmo = {ZX_HANDLE_INVALID};
 
-  zx_handle_t Vmo = atomic_load_relaxed(&StoredVmo);
+  zx_handle_t Vmo = atomic_load(&StoredVmo, memory_order_acquire);
   if (UNLIKELY(Vmo == ZX_HANDLE_INVALID)) {
     // Create a zero-sized placeholder VMO.
     zx_status_t Status = _zx_vmo_create(0, 0, &Vmo);
     if (UNLIKELY(Status != ZX_OK))
       dieOnError(Status, "zx_vmo_create", 0);
 
     setVmoName(Vmo, "scudo:reserved");
 
     // Atomically store its handle. If some other thread wins the race, use its
     // handle and discard ours.
-    zx_handle_t OldValue =
-        atomic_compare_exchange(&StoredVmo, ZX_HANDLE_INVALID, Vmo);
-    if (OldValue != ZX_HANDLE_INVALID) {
+    zx_handle_t OldValue = atomic_compare_exchange_strong(
+        &StoredVmo, ZX_HANDLE_INVALID, Vmo, memory_order_acq_rel);
+    if (UNLIKELY(OldValue != ZX_HANDLE_INVALID)) {
       Status = _zx_handle_close(Vmo);
       CHECK_EQ(Status, ZX_OK);
 
       Vmo = OldValue;
     }
   }
 
   return Vmo;