[scudo][standalone] Minor corrections

[cryptoad]

Summary

Few corrections with no functional change:

• replacing %zd with %zu all around: the values are unsigned
• prefer MAP_ANONYMOUS to MAP_ANON (it's deprecated)
• remove the unused enum LinkerInitialized
• mark a parameter as UNUSED in Fuchsia's getRandom
• correct the casing of a variable and use nullptr instead of 0 for pointers in list.h
• reorder some typedef to be consistent between signed and unsigned

[morehouse]

LGTM

compiler-rt/trunk/lib/scudo/standalone/fuchsia.cpp

 void HybridMutex::unlock() __TA_NO_THREAD_SAFETY_ANALYSIS {
   sync_mutex_unlock(&M);
 }
 
 u64 getMonotonicTime() { return _zx_clock_get_monotonic(); }
 
 u32 getNumberOfCPUs() { return _zx_system_get_num_cpus(); }
 
-bool getRandom(void *Buffer, uptr Length, bool Blocking) {
+bool getRandom(void *Buffer, uptr Length, UNUSED bool Blocking) {
   COMPILER_CHECK(MaxRandomLength <= ZX_CPRNG_DRAW_MAX_LEN);
   if (UNLIKELY(!Buffer || !Length || Length > MaxRandomLength))
     return false;
   _zx_cprng_draw(Buffer, Length);
   return true;
 }
 
 void outputRaw(const char *Buffer) {
   __sanitizer_log_write(Buffer, strlen(Buffer));
 }
 
 void setAbortMessage(const char *Message) {}
 
 } // namespace scudo
 
 #endif // SCUDO_FUCHSIA

compiler-rt/trunk/lib/scudo/standalone/internal_defs.h

 #endif
 #define UNUSED __attribute__((unused))
 #define USED __attribute__((used))
 #define NOEXCEPT noexcept
 
 namespace scudo {
 
 typedef unsigned long uptr;
-typedef signed long sptr;
 typedef unsigned char u8;
 typedef unsigned short u16;
 typedef unsigned int u32;
 typedef unsigned long long u64;
+typedef signed long sptr;
 typedef signed char s8;
 typedef signed short s16;
 typedef signed int s32;
 typedef signed long long s64;
 
 // The following two functions have platform specific implementations.
 void outputRaw(const char *Buffer);
 void NORETURN die();

 #define UNREACHABLE(Msg)                                                       \
   do {                                                                         \
     CHECK(0 && Msg);                                                           \
     die();                                                                     \
   } while (0)
 
 #define COMPILER_CHECK(Pred) static_assert(Pred, "")
 
-enum LinkerInitialized { LINKER_INITIALIZED = 0 };
-
 } // namespace scudo
 
 #endif // SCUDO_INTERNAL_DEFS_H_

compiler-rt/trunk/lib/scudo/standalone/linux.cpp

 namespace scudo {
 
 uptr getPageSize() { return static_cast<uptr>(sysconf(_SC_PAGESIZE)); }
 
 void NORETURN die() { abort(); }
 
 void *map(void *Addr, uptr Size, UNUSED const char *Name, uptr Flags,
           UNUSED MapPlatformData *Data) {
-  int MmapFlags = MAP_PRIVATE | MAP_ANON;
+  int MmapFlags = MAP_PRIVATE | MAP_ANONYMOUS;
   int MmapProt;
   if (Flags & MAP_NOACCESS) {
     MmapFlags |= MAP_NORESERVE;
     MmapProt = PROT_NONE;
   } else {
     MmapProt = PROT_READ | PROT_WRITE;
   }
   if (Addr) {

compiler-rt/trunk/lib/scudo/standalone/list.h

if (empty()) {
       Last = L->Last;
       Size += L->size();
     }
     L->clear();
   }
 
   void checkConsistency() {
     if (Size == 0) {
-      CHECK_EQ(First, 0);
-      CHECK_EQ(Last, 0);
+      CHECK_EQ(First, nullptr);
+      CHECK_EQ(Last, nullptr);
     } else {
-      uptr count = 0;
+      uptr Count = 0;
       for (Item *I = First;; I = I->Next) {
-        count++;
+        Count++;
         if (I == Last)
           break;
       }
-      CHECK_EQ(size(), count);
-      CHECK_EQ(Last->Next, 0);
+      CHECK_EQ(size(), Count);
+      CHECK_EQ(Last->Next, nullptr);
     }
   }
 
   template <class ItemT> class IteratorBase {
   public:
     explicit IteratorBase(ItemT *CurrentItem) : Current(CurrentItem) {}
     IteratorBase &operator++() {
       Current = Current->Next;

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

const uptr ChunksUsagePercent =
         (QuarantineChunksCapacity == 0)
             ? 0
             : TotalQuarantineChunks * 100 / QuarantineChunksCapacity;
     const uptr TotalQuarantinedBytes = TotalBytes - TotalOverheadBytes;
     const uptr MemoryOverheadPercent =
         (TotalQuarantinedBytes == 0)
             ? 0
             : TotalOverheadBytes * 100 / TotalQuarantinedBytes;
-    Printf("Global quarantine stats: batches: %zd; bytes: %zd (user: %zd); "
-           "chunks: %zd (capacity: %zd); %zd%% chunks used; %zd%% memory "
+    Printf("Global quarantine stats: batches: %zu; bytes: %zu (user: %zu); "
+           "chunks: %zu (capacity: %zu); %zu%% chunks used; %zu%% memory "
            "overhead\n",
            BatchCount, TotalBytes, TotalQuarantinedBytes, TotalQuarantineChunks,
            QuarantineChunksCapacity, ChunksUsagePercent, MemoryOverheadPercent);
   }
 
 private:
   IntrusiveList<QuarantineBatch> List;
   atomic_uptr Size;
void NOINLINE drainAndRecycle(CacheT *C, Callback Cb) {
       Cache.transfer(C);
     }
     RecyleMutex.lock();
     recycle(0, Cb);
   }
 
   void printStats() const {
     // It assumes that the world is stopped, just as the allocator's printStats.
-    Printf("Quarantine limits: global: %zdM; thread local: %zdK\n",
+    Printf("Quarantine limits: global: %zuM; thread local: %zuK\n",
            getMaxSize() >> 20, getCacheSize() >> 10);
     Cache.printStats();
   }
 
 private:
   // Read-only data.
   alignas(SCUDO_CACHE_LINE_SIZE) HybridMutex CacheMutex;
   CacheT Cache;

compiler-rt/trunk/lib/scudo/standalone/secondary.cpp

void MapAllocator::deallocate(void *Ptr) {
   void *Addr = reinterpret_cast<void *>(H->MapBase);
   const uptr Size = H->MapSize;
   MapPlatformData Data;
   Data = H->Data;
   unmap(Addr, Size, UNMAP_ALL, &Data);
 }
 
 void MapAllocator::printStats() const {
-  Printf("Stats: MapAllocator: allocated %zd times (%zdK), freed %zd times "
-         "(%zdK), remains %zd (%zdK) max %zdM\n",
+  Printf("Stats: MapAllocator: allocated %zu times (%zuK), freed %zu times "
+         "(%zuK), remains %zu (%zuK) max %zuM\n",
          NumberOfAllocs, AllocatedBytes >> 10, NumberOfFrees, FreedBytes >> 10,
          NumberOfAllocs - NumberOfFrees, (AllocatedBytes - FreedBytes) >> 10,
          LargestSize >> 20);
 }
 
 } // namespace scudo