[scudo] Minor Secondary changes

[cryptoad]

Summary

Few changes to the secondary:

• mark const variables as such;
• change some CHECK to DCHECK: I don't feel we need to be as conservative as we were with out checks, as they are the results of our own computation.
• mark a condition as UNLIKELY.

lib/scudo/scudo_allocator_secondary.h

if (Alignment > MinAlignment)
       MapSize += Alignment;
     const uptr PageSize = PageSizeCached;
     MapSize = RoundUpTo(MapSize, PageSize);
     // Account for 2 guard pages, one before and one after the chunk.
     MapSize += 2 * PageSize;
 
     ReservedAddressRange AddressRange;
     uptr MapBeg = AddressRange.Init(MapSize);
-    if (MapBeg == ~static_cast<uptr>(0))
+    if (UNLIKELY(MapBeg == ~static_cast<uptr>(0)))
       return ReturnNullOrDieOnFailure::OnOOM();
     // A page-aligned pointer is assumed after that, so check it now.
     CHECK(IsAligned(MapBeg, PageSize));
     uptr MapEnd = MapBeg + MapSize;
     // The beginning of the user area for that allocation comes after the
     // initial guard page, and both headers. This is the pointer that has to
     // abide by alignment requirements.
     uptr UserBeg = MapBeg + PageSize + HeadersSize;
     uptr UserEnd = UserBeg + UserSize;
 
     // In the rare event of larger alignments, we will attempt to fit the mmap
     // area better and unmap extraneous memory. This will also ensure that the
     // offset and unused bytes field of the header stay small.
     if (Alignment > MinAlignment) {
       if (!IsAligned(UserBeg, Alignment)) {
         UserBeg = RoundUpTo(UserBeg, Alignment);
-        CHECK_GE(UserBeg, MapBeg);
-        uptr NewMapBeg = RoundDownTo(UserBeg - HeadersSize, PageSize) -
+        DCHECK_GE(UserBeg, MapBeg);
+        const uptr NewMapBeg = RoundDownTo(UserBeg - HeadersSize, PageSize) -
             PageSize;
-        CHECK_GE(NewMapBeg, MapBeg);
+        DCHECK_GE(NewMapBeg, MapBeg);
         if (NewMapBeg != MapBeg) {
           AddressRange.Unmap(MapBeg, NewMapBeg - MapBeg);
           MapBeg = NewMapBeg;
         }
         UserEnd = UserBeg + UserSize;
       }
-      uptr NewMapEnd = RoundUpTo(UserEnd, PageSize) + PageSize;
+      const uptr NewMapEnd = RoundUpTo(UserEnd, PageSize) + PageSize;
       if (NewMapEnd != MapEnd) {
         AddressRange.Unmap(NewMapEnd, MapEnd - NewMapEnd);
         MapEnd = NewMapEnd;
       }
       MapSize = MapEnd - MapBeg;
     }
 
-    CHECK_LE(UserEnd, MapEnd - PageSize);
+    DCHECK_LE(UserEnd, MapEnd - PageSize);
     // Actually mmap the memory, preserving the guard pages on either side
     CHECK_EQ(MapBeg + PageSize,
              AddressRange.Map(MapBeg + PageSize, MapSize - 2 * PageSize));
     const uptr Ptr = UserBeg - AlignedChunkHeaderSize;
     ReservedAddressRange *StoredRange = getReservedAddressRange(Ptr);
     *StoredRange = AddressRange;
 
     // The primary adds the whole class size to the stats when allocating a
ReservedAddressRange AddressRange = *getReservedAddressRange(Ptr);
       Stats->Sub(AllocatorStatAllocated, AddressRange.size() - 2 * PageSize);
       Stats->Sub(AllocatorStatMapped, AddressRange.size() - 2 * PageSize);
     }
     AddressRange.Unmap(reinterpret_cast<uptr>(AddressRange.base()),
                        AddressRange.size());
   }
 
   uptr GetActuallyAllocatedSize(void *Ptr) {
-    ReservedAddressRange *StoredRange = getReservedAddressRange(Ptr);
+    const ReservedAddressRange *StoredRange = getReservedAddressRange(Ptr);
     // Deduct PageSize as ReservedAddressRange size includes the trailing guard
     // page.
-    uptr MapEnd = reinterpret_cast<uptr>(StoredRange->base()) +
+    const uptr MapEnd = reinterpret_cast<uptr>(StoredRange->base()) +
         StoredRange->size() - PageSizeCached;
     return MapEnd - reinterpret_cast<uptr>(Ptr);
   }
 
  private:
   ReservedAddressRange *getReservedAddressRange(uptr Ptr) {
     return reinterpret_cast<ReservedAddressRange*>(
         Ptr - sizeof(ReservedAddressRange));