[scudo][standalone] Code tidying (NFC)

[cryptoad]

Summary

• we have clutter-reducing helpers for relaxed atomics that were barely used, use them everywhere we can
• clang-format everything with a recent version

compiler-rt/lib/scudo/standalone/memtag.h

 
 #if defined(__aarch64__) || defined(SCUDO_FUZZ)
 
 inline constexpr bool archSupportsMemoryTagging() { return true; }
 inline constexpr uptr archMemoryTagGranuleSize() { return 16; }
 
 inline uptr untagPointer(uptr Ptr) { return Ptr & ((1ULL << 56) - 1); }
 
-inline uint8_t extractTag(uptr Ptr) {
-  return (Ptr >> 56) & 0xf;
-}
+inline uint8_t extractTag(uptr Ptr) { return (Ptr >> 56) & 0xf; }
 
 #else
 
 inline constexpr bool archSupportsMemoryTagging() { return false; }
 
 inline uptr archMemoryTagGranuleSize() {
   UNREACHABLE("memory tagging not supported");
 }

 
 inline void enableMemoryTagChecksTestOnly() {
   __asm__ __volatile__(".arch_extension mte; msr tco, #0");
 }
 
 class ScopedDisableMemoryTagChecks {
   size_t PrevTCO;
 
- public:
   ScopedDisableMemoryTagChecks() {
     __asm__ __volatile__(".arch_extension mte; mrs %0, tco; msr tco, #1"
                          : "=r"(PrevTCO));
   }
 
   ~ScopedDisableMemoryTagChecks() {
     __asm__ __volatile__(".arch_extension mte; msr tco, %0" : : "r"(PrevTCO));
   }
1:
     // Finally, set the tag of the granule past the end of the allocation to 0.
     and %[Cur], %[Cur], #(1 << 56) - 1
     cmp %[Cur], %[BlockEnd]
     b.eq 2f
     stg %[Cur], [%[Cur]]
 
   2:
   )"
-                       : [ Cur ] "+&r"(RoundOldPtr), [ End ] "+&r"(NewPtr)
-                       : [ BlockEnd ] "r"(BlockEnd)
+                       : [Cur] "+&r"(RoundOldPtr), [End] "+&r"(NewPtr)
+                       : [BlockEnd] "r"(BlockEnd)
                        : "memory");
 }
 
 inline uptr loadTag(uptr Ptr) {
   uptr TaggedPtr = Ptr;
   __asm__ __volatile__(".arch_extension mte; ldg %0, [%0]"
                        : "+r"(TaggedPtr)
                        :

compiler-rt/lib/scudo/standalone/options.h

return static_cast<FillContentsMode>(
         (Val >> static_cast<u32>(OptionBit::FillContents0of2)) & 3);
   }
 };
 
 struct AtomicOptions {
   atomic_u32 Val;
 
 public:
-  Options load() const {
-    return Options{atomic_load(&Val, memory_order_relaxed)};
-  }
+  Options load() const { return Options{atomic_load_relaxed(&Val)}; }
 
   void clear(OptionBit Opt) {
     atomic_fetch_and(&Val, ~(1U << static_cast<u32>(Opt)),
                      memory_order_relaxed);
   }
 
   void set(OptionBit Opt) {
     atomic_fetch_or(&Val, 1U << static_cast<u32>(Opt), memory_order_relaxed);
   }
 
   void setFillContentsMode(FillContentsMode FillContents) {
-    u32 Opts = atomic_load(&Val, memory_order_relaxed), NewOpts;
+    u32 Opts = atomic_load_relaxed(&Val), NewOpts;
     do {
       NewOpts = Opts;
       NewOpts &= ~(3U << static_cast<u32>(OptionBit::FillContents0of2));
       NewOpts |= static_cast<u32>(FillContents)
                  << static_cast<u32>(OptionBit::FillContents0of2);
     } while (!atomic_compare_exchange_strong(&Val, &Opts, NewOpts,
                                              memory_order_relaxed));
   }
 };
 
 } // namespace scudo
 
 #endif // SCUDO_OPTIONS_H_

compiler-rt/lib/scudo/standalone/primary32.h

for (uptr I = 0; I < NumClasses; I++)
       getStats(Str, I, 0);
   }
 
   bool setOption(Option O, sptr Value) {
     if (O == Option::ReleaseInterval) {
       const s32 Interval =
           Max(Min(static_cast<s32>(Value), MaxReleaseToOsIntervalMs),
               MinReleaseToOsIntervalMs);
-      atomic_store(&ReleaseToOsIntervalMs, Interval, memory_order_relaxed);
+      atomic_store_relaxed(&ReleaseToOsIntervalMs, Interval);
       return true;
     }
     // Not supported by the Primary, but not an error either.
     return true;
   }
 
   uptr releaseToOS() {
     uptr TotalReleasedBytes = 0;
if (BlockSize < PageSize / 16U) {
         return 0;
       // We want 8x% to 9x% free bytes (the larger the bock, the lower the %).
       if ((BytesInFreeList * 100U) / Sci->AllocatedUser <
           (100U - 1U - BlockSize / 16U))
         return 0;
     }
 
     if (!Force) {
-      const s32 IntervalMs =
-          atomic_load(&ReleaseToOsIntervalMs, memory_order_relaxed);
+      const s32 IntervalMs = atomic_load_relaxed(&ReleaseToOsIntervalMs);
       if (IntervalMs < 0)
         return 0;
       if (Sci->ReleaseInfo.LastReleaseAtNs +
               static_cast<u64>(IntervalMs) * 1000000 >
           getMonotonicTime()) {
         return 0; // Memory was returned recently.
       }
     }

compiler-rt/lib/scudo/standalone/primary64.h

for (uptr I = 0; I < NumClasses; I++)
       getStats(Str, I, 0);
   }
 
   bool setOption(Option O, sptr Value) {
     if (O == Option::ReleaseInterval) {
       const s32 Interval =
           Max(Min(static_cast<s32>(Value), MaxReleaseToOsIntervalMs),
               MinReleaseToOsIntervalMs);
-      atomic_store(&ReleaseToOsIntervalMs, Interval, memory_order_relaxed);
+      atomic_store_relaxed(&ReleaseToOsIntervalMs, Interval);
       return true;
     }
     // Not supported by the Primary, but not an error either.
     return true;
   }
 
   uptr releaseToOS() {
     uptr TotalReleasedBytes = 0;
if (BlockSize < PageSize / 16U) {
         return 0;
       // We want 8x% to 9x% free bytes (the larger the bock, the lower the %).
       if ((BytesInFreeList * 100U) / Region->AllocatedUser <
           (100U - 1U - BlockSize / 16U))
         return 0;
     }
 
     if (!Force) {
-      const s32 IntervalMs =
-          atomic_load(&ReleaseToOsIntervalMs, memory_order_relaxed);
+      const s32 IntervalMs = atomic_load_relaxed(&ReleaseToOsIntervalMs);
       if (IntervalMs < 0)
         return 0;
       if (Region->ReleaseInfo.LastReleaseAtNs +
               static_cast<u64>(IntervalMs) * 1000000 >
           getMonotonicTime()) {
         return 0; // Memory was returned recently.
       }
     }

compiler-rt/lib/scudo/standalone/secondary.h

void init(s32 ReleaseToOsInterval) {
     memset(this, 0, sizeof(*this));
     initLinkerInitialized(ReleaseToOsInterval);
   }
 
   bool store(LargeBlock::Header *H) {
     bool EntryCached = false;
     bool EmptyCache = false;
     const u64 Time = getMonotonicTime();
-    const u32 MaxCount = atomic_load(&MaxEntriesCount, memory_order_relaxed);
+    const u32 MaxCount = atomic_load_relaxed(&MaxEntriesCount);
     {
       ScopedLock L(Mutex);
       if (EntriesCount >= MaxCount) {
         if (IsFullEvents++ == 4U)
           EmptyCache = true;
       } else {
         for (u32 I = 0; I < MaxCount; I++) {
           if (Entries[I].Block)
const u32 MaxCount = atomic_load_relaxed(&MaxEntriesCount);
           EntryCached = true;
           break;
         }
       }
     }
     s32 Interval;
     if (EmptyCache)
       empty();
-    else if ((Interval = atomic_load(&ReleaseToOsIntervalMs,
-                                     memory_order_relaxed)) >= 0)
+    else if ((Interval = atomic_load_relaxed(&ReleaseToOsIntervalMs)) >= 0)
       releaseOlderThan(Time - static_cast<u64>(Interval) * 1000000);
     return EntryCached;
   }
 
   bool retrieve(uptr Size, LargeBlock::Header **H) {
     const uptr PageSize = getPageSizeCached();
-    const u32 MaxCount = atomic_load(&MaxEntriesCount, memory_order_relaxed);
+    const u32 MaxCount = atomic_load_relaxed(&MaxEntriesCount);
     ScopedLock L(Mutex);
     if (EntriesCount == 0)
       return false;
     for (u32 I = 0; I < MaxCount; I++) {
       if (!Entries[I].Block)
         continue;
       const uptr BlockSize = Entries[I].BlockEnd - Entries[I].Block;
       if (Size > BlockSize)
         continue;
       if (Size < BlockSize - PageSize * 4U)
         continue;
       *H = reinterpret_cast<LargeBlock::Header *>(Entries[I].Block);
       Entries[I].Block = 0;
       (*H)->BlockEnd = Entries[I].BlockEnd;
       (*H)->MapBase = Entries[I].MapBase;
       (*H)->MapSize = Entries[I].MapSize;
       (*H)->Data = Entries[I].Data;
       EntriesCount--;
       return true;
     }
     return false;
   }
 
   bool canCache(uptr Size) {
-    return atomic_load(&MaxEntriesCount, memory_order_relaxed) != 0U &&
-           Size <= atomic_load(&MaxEntrySize, memory_order_relaxed);
+    return atomic_load_relaxed(&MaxEntriesCount) != 0U &&
+           Size <= atomic_load_relaxed(&MaxEntrySize);
   }
 
   bool setOption(Option O, sptr Value) {
     if (O == Option::ReleaseInterval) {
       const s32 Interval =
           Max(Min(static_cast<s32>(Value), MaxReleaseToOsIntervalMs),
               MinReleaseToOsIntervalMs);
-      atomic_store(&ReleaseToOsIntervalMs, Interval, memory_order_relaxed);
+      atomic_store_relaxed(&ReleaseToOsIntervalMs, Interval);
       return true;
     } else if (O == Option::MaxCacheEntriesCount) {
       const u32 MaxCount = static_cast<u32>(Value);
       if (MaxCount > EntriesArraySize)
         return false;
-      atomic_store(&MaxEntriesCount, MaxCount, memory_order_relaxed);
+      atomic_store_relaxed(&MaxEntriesCount, MaxCount);
       return true;
     } else if (O == Option::MaxCacheEntrySize) {
-      atomic_store(&MaxEntrySize, static_cast<uptr>(Value),
-                   memory_order_relaxed);
+      atomic_store_relaxed(&MaxEntrySize, static_cast<uptr>(Value));
       return true;
     }
     // Not supported by the Secondary Cache, but not an error either.
     return true;
   }
 
   void releaseToOS() { releaseOlderThan(UINT64_MAX); }
 

compiler-rt/lib/scudo/standalone/stack_depot.h

 namespace scudo {
 
 class MurMur2HashBuilder {
   static const u32 M = 0x5bd1e995;
   static const u32 Seed = 0x9747b28c;
   static const u32 R = 24;
   u32 H;
 
- public:
   explicit MurMur2HashBuilder(u32 Init = 0) { H = Seed ^ Init; }
   void add(u32 K) {
     K *= M;
     K ^= K >> R;
     K *= M;
     H *= M;
     H ^= K;
   }