[scudo][NFC] Rename local variables to avoid shadowing class members

[vitalybuka]

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

21

LLVM use this very often, I would rather disable this warning

[ddcc]

That's fair, we're building the standalone version out-of-tree with -Weverything -Werror among other things in our build system, which is why I've been seeing more warnings. Not sure if anything needs to be done then for the in-tree standalone build, since -Wall isn't documented to include -Wshadow?

[vitalybuka]

In D121849#3389831, @ddcc wrote:

That's fair, we're building the standalone version out-of-tree with -Weverything -Werror among other things in our build system, which is why I've been seeing more warnings. Not sure if anything needs to be done then for the in-tree standalone build, since -Wall isn't documented to include -Wshadow?

I am not sure it's practical to enforce such rules on dependencies.
Can you use -isystem to include SCUDO to avoid warnings there?

[ddcc]

Ok, we can workaround this locally.

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

struct QuarantineBatch {
   // With the following count, a batch (and the header that protects it) occupy
   // 4096 bytes on 32-bit platforms, and 8192 bytes on 64-bit.
   static const u32 MaxCount = 1019;
   QuarantineBatch *Next;
   uptr Size;
   u32 Count;
   void *Batch[MaxCount];
 
-  void init(void *Ptr, uptr Size) {
+  void init(void *Ptr, uptr Sz) {
     Count = 1;
     Batch[0] = Ptr;
-    this->Size = Size + sizeof(QuarantineBatch); // Account for the Batch Size.
+    this->Size = Sz + sizeof(QuarantineBatch); // Account for the Batch Size.
   }
 
   // The total size of quarantined nodes recorded in this batch.
   uptr getQuarantinedSize() const { return Size - sizeof(QuarantineBatch); }
 
-  void push_back(void *Ptr, uptr Size) {
+  void push_back(void *Ptr, uptr Sz) {
     DCHECK_LT(Count, MaxCount);
     Batch[Count++] = Ptr;
-    this->Size += Size;
+    this->Size += Sz;
   }
 
   bool canMerge(const QuarantineBatch *const From) const {
     return Count + From->Count <= MaxCount;
   }
 
   void merge(QuarantineBatch *const From) {
     DCHECK_LE(Count + From->Count, MaxCount);

 public:
   void init() { DCHECK_EQ(atomic_load_relaxed(&Size), 0U); }
 
   // Total memory used, including internal accounting.
   uptr getSize() const { return atomic_load_relaxed(&Size); }
   // Memory used for internal accounting.
   uptr getOverheadSize() const { return List.size() * sizeof(QuarantineBatch); }
 
-  void enqueue(Callback Cb, void *Ptr, uptr Size) {
+  void enqueue(Callback Cb, void *Ptr, uptr Sz) {
     if (List.empty() || List.back()->Count == QuarantineBatch::MaxCount) {
       QuarantineBatch *B =
           reinterpret_cast<QuarantineBatch *>(Cb.allocate(sizeof(*B)));
       DCHECK(B);
-      B->init(Ptr, Size);
+      B->init(Ptr, Sz);
       enqueueBatch(B);
     } else {
-      List.back()->push_back(Ptr, Size);
-      addToSize(Size);
+      List.back()->push_back(Ptr, Sz);
+      addToSize(Sz);
     }
   }
 
   void transfer(QuarantineCache *From) {
     List.append_back(&From->List);
     addToSize(From->getSize());
     atomic_store_relaxed(&From->Size, 0);
   }
private:
   // Read-only data.
   alignas(SCUDO_CACHE_LINE_SIZE) HybridMutex CacheMutex;
   CacheT Cache;
   alignas(SCUDO_CACHE_LINE_SIZE) HybridMutex RecycleMutex;
   atomic_uptr MinSize = {};
   atomic_uptr MaxSize = {};
   alignas(SCUDO_CACHE_LINE_SIZE) atomic_uptr MaxCacheSize = {};
 
-  void NOINLINE recycle(uptr MinSize, Callback Cb) {
+  void NOINLINE recycle(uptr MinSz, Callback Cb) {
     CacheT Tmp;
     Tmp.init();
     {
       ScopedLock L(CacheMutex);
       // Go over the batches and merge partially filled ones to
       // save some memory, otherwise batches themselves (since the memory used
       // by them is counted against quarantine limit) can overcome the actual
       // user's quarantined chunks, which diminishes the purpose of the
       // quarantine.
       const uptr CacheSize = Cache.getSize();
       const uptr OverheadSize = Cache.getOverheadSize();
       DCHECK_GE(CacheSize, OverheadSize);
       // Do the merge only when overhead exceeds this predefined limit (might
       // require some tuning). It saves us merge attempt when the batch list
       // quarantine is unlikely to contain batches suitable for merge.
       constexpr uptr OverheadThresholdPercents = 100;
       if (CacheSize > OverheadSize &&
           OverheadSize * (100 + OverheadThresholdPercents) >
               CacheSize * OverheadThresholdPercents) {
         Cache.mergeBatches(&Tmp);
       }
       // Extract enough chunks from the quarantine to get below the max
       // quarantine size and leave some leeway for the newly quarantined chunks.
-      while (Cache.getSize() > MinSize)
+      while (Cache.getSize() > MinSz)
         Tmp.enqueueBatch(Cache.dequeueBatch());
     }
     RecycleMutex.unlock();
     doRecycle(&Tmp, Cb);
   }
 
   void NOINLINE doRecycle(CacheT *C, Callback Cb) {
     while (QuarantineBatch *B = C->dequeueBatch()) {

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

 #include "common.h"
 #include "list.h"
 #include "mutex.h"
 
 namespace scudo {
 
 class ReleaseRecorder {
 public:
-  ReleaseRecorder(uptr Base, MapPlatformData *Data = nullptr)
-      : Base(Base), Data(Data) {}
+  ReleaseRecorder(uptr _Base, MapPlatformData *_Data = nullptr)
+      : Base(_Base), Data(_Data) {}
 
   uptr getReleasedRangesCount() const { return ReleasedRangesCount; }
 
   uptr getReleasedBytes() const { return ReleasedBytes; }
 
   uptr getBase() const { return Base; }
 
   // Releases [From, To) range of pages back to OS.
private:
   uptr *Buffer;
 
   static HybridMutex Mutex;
   static uptr StaticBuffer[StaticBufferCount];
 };
 
 template <class ReleaseRecorderT> class FreePagesRangeTracker {
 public:
-  explicit FreePagesRangeTracker(ReleaseRecorderT *Recorder)
-      : Recorder(Recorder), PageSizeLog(getLog2(getPageSizeCached())) {}
+  explicit FreePagesRangeTracker(ReleaseRecorderT *_Recorder)
+      : Recorder(_Recorder), PageSizeLog(getLog2(getPageSizeCached())) {}
 
   void processNextPage(bool Freed) {
     if (Freed) {
       if (!InRange) {
         CurrentRangeStatePage = CurrentPage;
         InRange = true;
       }
     } else {