[scudo][standalone] Enabled SCUDO_DEBUG for tests + fixes

[cryptoad]

Summary

SCUDO_DEBUG was not enabled for unit tests, meaning the DCHECKs
were never tripped. While turning this on, I discovered that a few
of those not-exercised checks were actually wrong. This CL addresses
those incorrect checks.

Not that to work in tests CHECK_IMPL has to explicitely use the
scudo namespace. Also changes a C cast to a C++ cast.

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

NOINLINE void *allocate(uptr Size, Chunk::Origin Origin,
     if (UNLIKELY(ZeroContents && ClassId))
       memset(Block, 0, PrimaryT::getSizeByClassId(ClassId));
 
     Chunk::UnpackedHeader Header = {};
     uptr UserPtr = reinterpret_cast<uptr>(Block) + Chunk::getHeaderSize();
     if (UNLIKELY(!isAligned(UserPtr, Alignment))) {
       const uptr AlignedUserPtr = roundUpTo(UserPtr, Alignment);
       const uptr Offset = AlignedUserPtr - UserPtr;
-      DCHECK_GT(Offset, 2 * sizeof(u32));
+      DCHECK_GE(Offset, 2 * sizeof(u32));
       // The BlockMarker has no security purpose, but is specifically meant for
       // the chunk iteration function that can be used in debugging situations.
       // It is the only situation where we have to locate the start of a chunk
       // based on its block address.
       reinterpret_cast<u32 *>(Block)[0] = BlockMarker;
       reinterpret_cast<u32 *>(Block)[1] = static_cast<u32>(Offset);
       UserPtr = AlignedUserPtr;
       Header.Offset = (Offset >> MinAlignmentLog) & Chunk::OffsetMask;

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

 
 #define RAW_CHECK(Expr) RAW_CHECK_MSG(Expr, #Expr)
 
 void NORETURN reportCheckFailed(const char *File, int Line,
                                 const char *Condition, u64 Value1, u64 Value2);
 
 #define CHECK_IMPL(C1, Op, C2)                                                 \
   do {                                                                         \
-    u64 V1 = (u64)(C1);                                                        \
-    u64 V2 = (u64)(C2);                                                        \
+    scudo::u64 V1 = (scudo::u64)(C1);                                          \
+    scudo::u64 V2 = (scudo::u64)(C2);                                          \
     if (UNLIKELY(!(V1 Op V2))) {                                               \
-      reportCheckFailed(__FILE__, __LINE__, "(" #C1 ") " #Op " (" #C2 ")", V1, \
-                        V2);                                                   \
-      die();                                                                   \
+      scudo::reportCheckFailed(__FILE__, __LINE__,                             \
+                               "(" #C1 ") " #Op " (" #C2 ")", V1, V2);         \
+      scudo::die();                                                            \
     }                                                                          \
   } while (false)
 
 #define CHECK(A) CHECK_IMPL((A), !=, 0)
 #define CHECK_EQ(A, B) CHECK_IMPL((A), ==, (B))
 #define CHECK_NE(A, B) CHECK_IMPL((A), !=, (B))
 #define CHECK_LT(A, B) CHECK_IMPL((A), <, (B))
 #define CHECK_LE(A, B) CHECK_IMPL((A), <=, (B))

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

 // to trim off some of the reserved space.
 // For allocations requested with an alignment greater than or equal to a page,
 // the committed memory will amount to something close to Size - AlignmentHint
 // (pending rounding and headers).
 template <uptr MaxFreeListSize>
 void *MapAllocator<MaxFreeListSize>::allocate(uptr Size, uptr AlignmentHint,
                                               uptr *BlockEnd,
                                               bool ZeroContents) {
-  DCHECK_GT(Size, AlignmentHint);
+  DCHECK_GE(Size, AlignmentHint);
   const uptr PageSize = getPageSizeCached();
   const uptr RoundedSize =
       roundUpTo(Size + LargeBlock::getHeaderSize(), PageSize);
 
   if (MaxFreeListSize && AlignmentHint < PageSize) {
     ScopedLock L(Mutex);
     for (auto &H : FreeBlocks) {
       const uptr FreeBlockSize = H.BlockEnd - reinterpret_cast<uptr>(&H);

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

for (uptr C = 0; C < NumClasses; C++) {
       if (C == BatchClassId)
         continue;
       const uptr S = getSizeByClassId(C);
       CHECK_NE(S, 0U);
       CHECK_EQ(getClassIdBySize(S), C);
       if (C < LargestClassId)
         CHECK_EQ(getClassIdBySize(S + 1), C + 1);
       CHECK_EQ(getClassIdBySize(S - 1), C);
+      if (C - 1 != BatchClassId)
         CHECK_GT(getSizeByClassId(C), getSizeByClassId(C - 1));
     }
     // Do not perform the loop if the maximum size is too large.
     if (MaxSizeLog > 19)
       return;
     for (uptr S = 1; S <= MaxSize; S++) {
       const uptr C = getClassIdBySize(S);
       CHECK_LT(C, NumClasses);
       CHECK_GE(getSizeByClassId(C), S);
-      if (C > 0)
+      if (C - 1 != BatchClassId)
         CHECK_LT(getSizeByClassId(C - 1), S);
     }
   }
 };
 
 typedef SizeClassMap<3, 5, 8, 17, 8, 10> DefaultSizeClassMap;
 
 // TODO(kostyak): further tune class maps for Android & Fuchsia.

compiler-rt/lib/scudo/standalone/tests/CMakeLists.txt

 include_directories(..)
 
 add_custom_target(ScudoUnitTests)
 set_target_properties(ScudoUnitTests PROPERTIES
   FOLDER "Compiler-RT Tests")
 
 set(SCUDO_UNITTEST_CFLAGS
   ${COMPILER_RT_UNITTEST_CFLAGS}
   ${COMPILER_RT_GTEST_CFLAGS}
   -I${COMPILER_RT_SOURCE_DIR}/include
   -I${COMPILER_RT_SOURCE_DIR}/lib
   -I${COMPILER_RT_SOURCE_DIR}/lib/scudo/standalone
   -DGTEST_HAS_RTTI=0
+  -DSCUDO_DEBUG=1
   # Extra flags for the C++ tests
   # TODO(kostyak): find a way to make -fsized-deallocation work
   -Wno-mismatched-new-delete)
 
 set(SCUDO_TEST_ARCH ${SCUDO_STANDALONE_SUPPORTED_ARCH})
 
 # gtests requires c++
 set(LINK_FLAGS ${COMPILER_RT_UNITTEST_LINK_FLAGS})

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

public:
   T *end() { return data() + size(); }
 
 private:
   void reallocate(uptr NewCapacity) {
     DCHECK_GT(NewCapacity, 0);
     DCHECK_LE(Size, NewCapacity);
     const uptr NewCapacityBytes =
         roundUpTo(NewCapacity * sizeof(T), getPageSizeCached());
-    T *NewData = (T *)map(nullptr, NewCapacityBytes, "scudo:vector");
+    T *NewData =
+        reinterpret_cast<T *>(map(nullptr, NewCapacityBytes, "scudo:vector"));
     if (Data) {
       memcpy(NewData, Data, Size * sizeof(T));
       unmap(Data, CapacityBytes);
     }
     Data = NewData;
     CapacityBytes = NewCapacityBytes;
   }