[scudo][standalone] Work with -Werror=class-memaccess

[cryptoad]

Summary

Fuchsia's gcc uses this, which in turn prevents us to compile successfully
due to a few memset'ing some non-trivial classes in some init.

Change those memset to members initialization.

[hctim]

LGTM

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

 #if SCUDO_FUCHSIA
 #include <lib/sync/mutex.h> // for sync_mutex_t
 #endif
 
 namespace scudo {
 
 class HybridMutex {
 public:
-  void init() { memset(this, 0, sizeof(*this)); }
+  void init() { M = {}; }
   bool tryLock();
   NOINLINE void lock() {
     if (LIKELY(tryLock()))
       return;
       // The compiler may try to fully unroll the loop, ending up in a
       // NumberOfTries*NumberOfYields block of pauses mixed with tryLocks. This
       // is large, ugly and unneeded, a compact loop is better for our purpose
       // here. Use a pragma to tell the compiler not to unroll the loop.

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

void initLinkerInitialized(uptr Size, uptr CacheSize) {
 
     atomic_store_relaxed(&MaxSize, Size);
     atomic_store_relaxed(&MinSize, Size / 10 * 9); // 90% of max size.
     atomic_store_relaxed(&MaxCacheSize, CacheSize);
 
     Cache.initLinkerInitialized();
   }
   void init(uptr Size, uptr CacheSize) {
-    memset(this, 0, sizeof(*this));
+    CacheMutex.init();
+    Cache.init();
+    RecycleMutex.init();
+    MinSize = {};
+    MaxSize = {};
+    MaxCacheSize = {};
     initLinkerInitialized(Size, CacheSize);
   }
 
   uptr getMaxSize() const { return atomic_load_relaxed(&MaxSize); }
   uptr getCacheSize() const { return atomic_load_relaxed(&MaxCacheSize); }
 
   void put(CacheT *C, Callback Cb, Node *Ptr, uptr Size) {
     C->enqueue(Cb, Ptr, Size);

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

private:
   atomic_uptr StatsArray[StatCount];
 };
 
 // Global stats, used for aggregation and querying.
 class GlobalStats : public LocalStats {
 public:
   void initLinkerInitialized() {}
   void init() {
-    memset(this, 0, sizeof(*this));
+    LocalStats::init();
+    Mutex.init();
+    StatsList = {};
     initLinkerInitialized();
   }
 
   void link(LocalStats *S) {
     ScopedLock L(Mutex);
     StatsList.push_back(S);
   }