[scudo] Add SCUDO_ENABLE_HOOKS to enable hooks at compilation time

[Chia-hungDuan]

Summary

Accessing the PLT entries of hooks can lead a certain amount of
performance overhead. This is observed on certain tasks which will do a
bunch of malloc/free and their throughputs are impacted by the null
check of hooks.

Also add SCUDO_ENABLE_HOOKS_TESTS to select if we want to run the hook
tests. On some platforms they may have different ways to run the
wrappers tests (end-to-end tests) and test the hooks along with the
wrappers tests may not be feasible. Provide an option to turn it ON/OFF.

By default, we only verify the hook behavior in the scudo standalone
tests if SCUDO_ENABLE_HOOKS is defined or COMPILER_RT_DEBUG is true.

[cferris]

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

22–25

Would it be better to make this a 0/1 define? Then you could just do a:

if (SCUDO_HOOKS_ENABLED) {

.
.
.

}

I think that would remove a lot of the macro definitions. You could even add it to the report functions so that none of the calls have to be removed, the calls themselves just don't do anything.

[Chia-hungDuan]

1. Address review comment
2. Add SCUDO_ENABLE_HOOKS_TESTS to bypass the hooks tests

[Chia-hungDuan]

By default, Fuchsia doesn't support running hooks tests with wrapper tests

[fabio-d]

Thanks for adding the possibility to disable the hooks tests

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

77

I can add SCUDO_ENABLE_HOOKS=1 to our build files instead, to avoid introducing special cases here.

[cferris]

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

67

I do prefer this method, but the rest of the code just uses #if XXX.

It's up to you since this is a small nit.

83

Would it be better to use GTEST_SKIP() << "Hooks ..."?

I think if you do this, you can remove the if checks in all of the tests.

[Chia-hungDuan]

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

67

Agree. Let me change the style to (XXX == 1) in another CL

83

The hooks tests are embedded in end-to-end tests. Using GTEST_SKIP() will skip all the tests. Or am I misunderstanding it?

[Chia-hungDuan]

Remove SCUDO_ENABLE_HOOKS=1 on Fuchsia by default

[cferris]

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

83

Oops, I somehow thought all of the tests were hooks. You are correct that would cause all tests to be skipped.

Should this be some kind of error? This seems to indicate a configuration error?

Also, should you test the opposite (!SCUDO_ENABLE_HOOKS && SCUDO_ENABLE_HOOKS_TESTS)?

[Chia-hungDuan]

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

83

For (SCUDO_ENABLE_HOOKS && !SCUDO_ENABLE_HOOKS_TESTS), it's supposed to allow the platforms don't support this kind of hooks test still be able to run the remaining end-to-end stuff

For (!SCUDO_ENABLE_HOOKS && SCUDO_ENABLE_HOOKS_TESTS), this will issue an error at the beginning of these two end-to-end test files

[cferris]

LGTM

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

 append_list_if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions SCUDO_CFLAGS)
 
 append_list_if(COMPILER_RT_HAS_WNO_PEDANTIC -Wno-pedantic SCUDO_CFLAGS)
 
 # FIXME: find cleaner way to agree with GWPAsan flags
 append_list_if(COMPILER_RT_HAS_FNO_LTO_FLAG -fno-lto SCUDO_CFLAGS)
 
 if(COMPILER_RT_DEBUG)
-  list(APPEND SCUDO_CFLAGS -O0 -DSCUDO_DEBUG=1)
+  list(APPEND SCUDO_CFLAGS -O0 -DSCUDO_DEBUG=1 -DSCUDO_ENABLE_HOOKS=1)
 else()
   list(APPEND SCUDO_CFLAGS -O3)
 endif()
 
 append_list_if(COMPILER_RT_HAS_WTHREAD_SAFETY_FLAG -Werror=thread-safety
   SCUDO_CFLAGS)
 
 set(SCUDO_LINK_FLAGS)

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

 #ifndef SCUDO_SMALL_STACK_DEPOT
 #if defined(SCUDO_FUZZ) || SCUDO_TRUSTY
 #define SCUDO_SMALL_STACK_DEPOT 1
 #else
 #define SCUDO_SMALL_STACK_DEPOT 0
 #endif
 #endif
 
+#ifndef SCUDO_ENABLE_HOOKS
+#define SCUDO_ENABLE_HOOKS 0
+#endif
+
 #ifndef SCUDO_MIN_ALIGNMENT_LOG
 // We force malloc-type functions to be aligned to std::max_align_t, but there
 // is no reason why the minimum alignment for all other functions can't be 8
 // bytes. Except obviously for applications making incorrect assumptions.
 // TODO(kostyak): define SCUDO_MIN_ALIGNMENT_LOG 3
 #define SCUDO_MIN_ALIGNMENT_LOG FIRST_32_SECOND_64(3, 4)
 #endif
 

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

set(SCUDO_UNITTEST_CFLAGS
   -I${COMPILER_RT_SOURCE_DIR}/lib/scudo/standalone/include
   -DGTEST_HAS_RTTI=0
   -g
   # Extra flags for the C++ tests
   # TODO(kostyak): find a way to make -fsized-deallocation work
   -Wno-mismatched-new-delete)
 
 if(COMPILER_RT_DEBUG)
-  list(APPEND SCUDO_UNITTEST_CFLAGS -DSCUDO_DEBUG=1)
+  list(APPEND SCUDO_UNITTEST_CFLAGS -DSCUDO_DEBUG=1 -DSCUDO_ENABLE_HOOKS=1)
+  if (NOT FUCHSIA)
+    list(APPEND SCUDO_UNITTEST_CFLAGS -DSCUDO_ENABLE_HOOKS_TESTS=1)
+  endif()
 endif()
 
 if(ANDROID)
   list(APPEND SCUDO_UNITTEST_CFLAGS -fno-emulated-tls)
 endif()
 
 if (COMPILER_RT_HAS_GWP_ASAN)
   list(APPEND SCUDO_UNITTEST_CFLAGS -DGWP_ASAN_HOOKS -fno-omit-frame-pointer

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

 #define HAVE_VALLOC 1
 #endif // !defined(__LP64__)
 #else
 // All others assumed to support both functions.
 #define HAVE_PVALLOC 1
 #define HAVE_VALLOC 1
 #endif
 
+extern "C" {
+void malloc_enable(void);
+void malloc_disable(void);
+int malloc_iterate(uintptr_t base, size_t size,
+                   void (*callback)(uintptr_t base, size_t size, void *arg),
+                   void *arg);
+void *valloc(size_t size);
+void *pvalloc(size_t size);
+
+#ifndef SCUDO_ENABLE_HOOKS_TESTS
+#define SCUDO_ENABLE_HOOKS_TESTS 0
+#endif
+
+#if (SCUDO_ENABLE_HOOKS_TESTS == 1) && (SCUDO_ENABLE_HOOKS == 0)
+#error "Hooks tests should have hooks enabled as well!"
+#endif
+
 struct AllocContext {
   void *Ptr;
   size_t Size;
 };
 struct DeallocContext {
   void *Ptr;
 };
 static AllocContext AC;
 static DeallocContext DC;
 
-extern "C" {
-void malloc_enable(void);
-void malloc_disable(void);
-int malloc_iterate(uintptr_t base, size_t size,
-                   void (*callback)(uintptr_t base, size_t size, void *arg),
-                   void *arg);
-void *valloc(size_t size);
-void *pvalloc(size_t size);
-
+#if (SCUDO_ENABLE_HOOKS_TESTS == 1)
 __attribute__((visibility("default"))) void __scudo_allocate_hook(void *Ptr,
                                                                   size_t Size) {
   AC.Ptr = Ptr;
   AC.Size = Size;
 }
 __attribute__((visibility("default"))) void __scudo_deallocate_hook(void *Ptr) {
   DC.Ptr = Ptr;
 }
+#endif // (SCUDO_ENABLE_HOOKS_TESTS == 1)
+}
+
+class ScudoWrappersCTest : public Test {
+protected:
+  void SetUp() override {
+    if (SCUDO_ENABLE_HOOKS && !SCUDO_ENABLE_HOOKS_TESTS)
+      printf("Hooks are enabled but hooks tests are disabled.\n");
   }
 
+  void invalidateAllocHookPtrAs(UNUSED void *Ptr) {
+    if (SCUDO_ENABLE_HOOKS_TESTS)
+      AC.Ptr = Ptr;
+  }
+  void verifyAllocHookPtr(UNUSED void *Ptr) {
+    if (SCUDO_ENABLE_HOOKS_TESTS)
+      EXPECT_EQ(Ptr, AC.Ptr);
+  }
+  void verifyAllocHookSize(UNUSED size_t Size) {
+    if (SCUDO_ENABLE_HOOKS_TESTS)
+      EXPECT_EQ(Size, AC.Size);
+  }
+  void verifyDeallocHookPtr(UNUSED void *Ptr) {
+    if (SCUDO_ENABLE_HOOKS_TESTS)
+      EXPECT_EQ(Ptr, DC.Ptr);
+  }
+};
+using ScudoWrappersCDeathTest = ScudoWrappersCTest;
+
 // Note that every C allocation function in the test binary will be fulfilled
 // by Scudo (this includes the gtest APIs, etc.), which is a test by itself.
 // But this might also lead to unexpected side-effects, since the allocation and
 // deallocation operations in the TEST functions will coexist with others (see
 // the EXPECT_DEATH comment below).
 
 // We have to use a small quarantine to make sure that our double-free tests
 // trigger. Otherwise EXPECT_DEATH ends up reallocating the chunk that was just
 // freed (this depends on the size obviously) and the following free succeeds.
 
 static const size_t Size = 100U;
 
-TEST(ScudoWrappersCDeathTest, Malloc) {
+TEST_F(ScudoWrappersCDeathTest, Malloc) {
   void *P = malloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0U);
-  EXPECT_EQ(P, AC.Ptr);
-  EXPECT_EQ(Size, AC.Size);
+  verifyAllocHookPtr(P);
+  verifyAllocHookSize(Size);
 
   // An update to this warning in Clang now triggers in this line, but it's ok
   // because the check is expecting a bad pointer and should fail.
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
 #endif
   EXPECT_DEATH(
       free(reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(P) | 1U)), "");
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic pop
 #endif
 
   free(P);
-  EXPECT_EQ(P, DC.Ptr);
+  verifyDeallocHookPtr(P);
   EXPECT_DEATH(free(P), "");
 
   P = malloc(0U);
   EXPECT_NE(P, nullptr);
   free(P);
 
   errno = 0;
   EXPECT_EQ(malloc(SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
 }
 
-TEST(ScudoWrappersCTest, Calloc) {
+TEST_F(ScudoWrappersCTest, Calloc) {
   void *P = calloc(1U, Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
-  EXPECT_EQ(P, AC.Ptr);
-  EXPECT_EQ(Size, AC.Size);
+  verifyAllocHookPtr(P);
+  verifyAllocHookSize(Size);
   for (size_t I = 0; I < Size; I++)
     EXPECT_EQ((reinterpret_cast<uint8_t *>(P))[I], 0U);
   free(P);
-  EXPECT_EQ(P, DC.Ptr);
+  verifyDeallocHookPtr(P);
 
   P = calloc(1U, 0U);
   EXPECT_NE(P, nullptr);
   free(P);
   P = calloc(0U, 1U);
   EXPECT_NE(P, nullptr);
   free(P);
 
   errno = 0;
   EXPECT_EQ(calloc(SIZE_MAX, 1U), nullptr);
   EXPECT_EQ(errno, ENOMEM);
   errno = 0;
   EXPECT_EQ(calloc(static_cast<size_t>(LONG_MAX) + 1U, 2U), nullptr);
   if (SCUDO_ANDROID)
     EXPECT_EQ(errno, ENOMEM);
   errno = 0;
   EXPECT_EQ(calloc(SIZE_MAX, SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
 }
 
-TEST(ScudoWrappersCTest, SmallAlign) {
+TEST_F(ScudoWrappersCTest, SmallAlign) {
   // Allocating pointers by the powers of 2 from 1 to 0x10000
   // Using powers of 2 due to memalign using powers of 2 and test more sizes
   constexpr size_t MaxSize = 0x10000;
   std::vector<void *> ptrs;
   // Reserving space to prevent further allocation during the test
   ptrs.reserve((scudo::getLeastSignificantSetBitIndex(MaxSize) + 1) *
                (scudo::getLeastSignificantSetBitIndex(MaxSize) + 1) * 3);
   for (size_t Size = 1; Size <= MaxSize; Size <<= 1) {
     for (size_t Align = 1; Align <= MaxSize; Align <<= 1) {
       for (size_t Count = 0; Count < 3; ++Count) {
         void *P = memalign(Align, Size);
         EXPECT_TRUE(reinterpret_cast<uintptr_t>(P) % Align == 0);
         ptrs.push_back(P);
       }
     }
   }
   for (void *ptr : ptrs)
     free(ptr);
 }
 
-TEST(ScudoWrappersCTest, Memalign) {
+TEST_F(ScudoWrappersCTest, Memalign) {
   void *P;
   for (size_t I = FIRST_32_SECOND_64(2U, 3U); I <= 18U; I++) {
     const size_t Alignment = 1U << I;
 
     P = memalign(Alignment, Size);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
     EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
-    EXPECT_EQ(P, AC.Ptr);
-    EXPECT_EQ(Size, AC.Size);
+    verifyAllocHookPtr(P);
+    verifyAllocHookSize(Size);
     free(P);
-    EXPECT_EQ(P, DC.Ptr);
+    verifyDeallocHookPtr(P);
 
     P = nullptr;
     EXPECT_EQ(posix_memalign(&P, Alignment, Size), 0);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
     EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
-    EXPECT_EQ(P, AC.Ptr);
-    EXPECT_EQ(Size, AC.Size);
+    verifyAllocHookPtr(P);
+    verifyAllocHookSize(Size);
     free(P);
-    EXPECT_EQ(P, DC.Ptr);
+    verifyDeallocHookPtr(P);
   }
 
   EXPECT_EQ(memalign(4096U, SIZE_MAX), nullptr);
   EXPECT_EQ(posix_memalign(&P, 15U, Size), EINVAL);
   EXPECT_EQ(posix_memalign(&P, 4096U, SIZE_MAX), ENOMEM);
 
   // Android's memalign accepts non power-of-2 alignments, and 0.
   if (SCUDO_ANDROID) {
     for (size_t Alignment = 0U; Alignment <= 128U; Alignment++) {
       P = memalign(Alignment, 1024U);
       EXPECT_NE(P, nullptr);
-      EXPECT_EQ(P, AC.Ptr);
-      EXPECT_EQ(Size, AC.Size);
+      verifyAllocHookPtr(P);
+      verifyAllocHookSize(Size);
       free(P);
-      EXPECT_EQ(P, DC.Ptr);
+      verifyDeallocHookPtr(P);
     }
   }
 }
 
-TEST(ScudoWrappersCTest, AlignedAlloc) {
+TEST_F(ScudoWrappersCTest, AlignedAlloc) {
   const size_t Alignment = 4096U;
   void *P = aligned_alloc(Alignment, Alignment * 4U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Alignment * 4U, malloc_usable_size(P));
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
-  EXPECT_EQ(P, AC.Ptr);
-  EXPECT_EQ(Alignment * 4U, AC.Size);
+  verifyAllocHookPtr(P);
+  verifyAllocHookSize(Alignment * 4U);
   free(P);
-  EXPECT_EQ(P, DC.Ptr);
+  verifyDeallocHookPtr(P);
 
   errno = 0;
   P = aligned_alloc(Alignment, Size);
   EXPECT_EQ(P, nullptr);
   EXPECT_EQ(errno, EINVAL);
 }
 
-TEST(ScudoWrappersCDeathTest, Realloc) {
+TEST_F(ScudoWrappersCDeathTest, Realloc) {
   // realloc(nullptr, N) is malloc(N)
   void *P = realloc(nullptr, Size);
   EXPECT_NE(P, nullptr);
-  EXPECT_EQ(P, AC.Ptr);
-  EXPECT_EQ(Size, AC.Size);
+  verifyAllocHookPtr(P);
+  verifyAllocHookSize(Size);
   free(P);
-  EXPECT_EQ(P, DC.Ptr);
+  verifyDeallocHookPtr(P);
 
   P = malloc(Size);
   EXPECT_NE(P, nullptr);
   // realloc(P, 0U) is free(P) and returns nullptr
   EXPECT_EQ(realloc(P, 0U), nullptr);
-  EXPECT_EQ(P, DC.Ptr);
+  verifyDeallocHookPtr(P);
 
   P = malloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   memset(P, 0x42, Size);
 
-  AC.Ptr = reinterpret_cast<void *>(0xdeadbeef);
+  invalidateAllocHookPtrAs(reinterpret_cast<void *>(0xdeadbeef));
   void *OldP = P;
   P = realloc(P, Size * 2U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size * 2U, malloc_usable_size(P));
   for (size_t I = 0; I < Size; I++)
     EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
   if (OldP == P) {
-    EXPECT_EQ(AC.Ptr, reinterpret_cast<void *>(0xdeadbeef));
+    verifyAllocHookPtr(reinterpret_cast<void *>(0xdeadbeef));
   } else {
-    EXPECT_EQ(P, AC.Ptr);
-    EXPECT_EQ(Size * 2U, AC.Size);
-    EXPECT_EQ(OldP, DC.Ptr);
+    verifyAllocHookPtr(P);
+    verifyAllocHookSize(Size * 2U);
+    verifyDeallocHookPtr(OldP);
   }
 
-  AC.Ptr = reinterpret_cast<void *>(0xdeadbeef);
+  invalidateAllocHookPtrAs(reinterpret_cast<void *>(0xdeadbeef));
   OldP = P;
   P = realloc(P, Size / 2U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size / 2U, malloc_usable_size(P));
   for (size_t I = 0; I < Size / 2U; I++)
     EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
   if (OldP == P) {
-    EXPECT_EQ(AC.Ptr, reinterpret_cast<void *>(0xdeadbeef));
+    verifyAllocHookPtr(reinterpret_cast<void *>(0xdeadbeef));
   } else {
-    EXPECT_EQ(P, AC.Ptr);
-    EXPECT_EQ(Size / 2U, AC.Size);
+    verifyAllocHookPtr(P);
+    verifyAllocHookSize(Size / 2U);
   }
   free(P);
 
   EXPECT_DEATH(P = realloc(P, Size), "");
 
   errno = 0;
   EXPECT_EQ(realloc(nullptr, SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
if (SCUDO_ANDROID) {
     EXPECT_LE(Size * 2U, malloc_usable_size(P));
     for (size_t I = 0; I < Size; I++)
       EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
     free(P);
   }
 }
 
 #if !SCUDO_FUCHSIA
-TEST(ScudoWrappersCTest, MallOpt) {
+TEST_F(ScudoWrappersCTest, MallOpt) {
   errno = 0;
   EXPECT_EQ(mallopt(-1000, 1), 0);
   // mallopt doesn't set errno.
   EXPECT_EQ(errno, 0);
 
   EXPECT_EQ(mallopt(M_PURGE, 0), 1);
 
   EXPECT_EQ(mallopt(M_DECAY_TIME, 1), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 0), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 1), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 0), 1);
 
   if (SCUDO_ANDROID) {
     EXPECT_EQ(mallopt(M_CACHE_COUNT_MAX, 100), 1);
     EXPECT_EQ(mallopt(M_CACHE_SIZE_MAX, 1024 * 1024 * 2), 1);
     EXPECT_EQ(mallopt(M_TSDS_COUNT_MAX, 10), 1);
   }
 }
 #endif
 
-TEST(ScudoWrappersCTest, OtherAlloc) {
+TEST_F(ScudoWrappersCTest, OtherAlloc) {
 #if HAVE_PVALLOC
   const size_t PageSize = static_cast<size_t>(sysconf(_SC_PAGESIZE));
 
   void *P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
   EXPECT_LE(PageSize, malloc_usable_size(P));
-  EXPECT_EQ(P, AC.Ptr);
+  verifyAllocHookPtr(P);
   // Size will be rounded up to PageSize.
-  EXPECT_EQ(PageSize, AC.Size);
+  verifyAllocHookSize(PageSize);
   free(P);
-  EXPECT_EQ(P, DC.Ptr);
+  verifyDeallocHookPtr(P);
 
   EXPECT_EQ(pvalloc(SIZE_MAX), nullptr);
 
   P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
   free(P);
 #endif
 
 #if HAVE_VALLOC
   EXPECT_EQ(valloc(SIZE_MAX), nullptr);
 #endif
 }
 
 #if !SCUDO_FUCHSIA
-TEST(ScudoWrappersCTest, MallInfo) {
+TEST_F(ScudoWrappersCTest, MallInfo) {
   // mallinfo is deprecated.
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
   const size_t BypassQuarantineSize = 1024U;
   struct mallinfo MI = mallinfo();
   size_t Allocated = MI.uordblks;
   void *P = malloc(BypassQuarantineSize);
   EXPECT_NE(P, nullptr);
   MI = mallinfo();
   EXPECT_GE(static_cast<size_t>(MI.uordblks), Allocated + BypassQuarantineSize);
   EXPECT_GT(static_cast<size_t>(MI.hblkhd), 0U);
   size_t Free = MI.fordblks;
   free(P);
   MI = mallinfo();
   EXPECT_GE(static_cast<size_t>(MI.fordblks), Free + BypassQuarantineSize);
 #pragma clang diagnostic pop
 }
 #endif
 
 #if __GLIBC_PREREQ(2, 33)
-TEST(ScudoWrappersCTest, MallInfo2) {
+TEST_F(ScudoWrappersCTest, MallInfo2) {
   const size_t BypassQuarantineSize = 1024U;
   struct mallinfo2 MI = mallinfo2();
   size_t Allocated = MI.uordblks;
   void *P = malloc(BypassQuarantineSize);
   EXPECT_NE(P, nullptr);
   MI = mallinfo2();
   EXPECT_GE(MI.uordblks, Allocated + BypassQuarantineSize);
   EXPECT_GT(MI.hblkhd, 0U);
static void callback(uintptr_t Base, UNUSED size_t Size, UNUSED void *Arg) {
   if (Base == BoundaryP)
     Count++;
 }
 
 // Verify that a block located on an iteration boundary is not mis-accounted.
 // To achieve this, we allocate a chunk for which the backing block will be
 // aligned on a page, then run the malloc_iterate on both the pages that the
 // block is a boundary for. It must only be seen once by the callback function.
-TEST(ScudoWrappersCTest, MallocIterateBoundary) {
+TEST_F(ScudoWrappersCTest, MallocIterateBoundary) {
   const size_t PageSize = static_cast<size_t>(sysconf(_SC_PAGESIZE));
 #if SCUDO_ANDROID
   // Android uses a 16 byte alignment for both 32 bit and 64 bit.
   const size_t BlockDelta = 16U;
 #else
   const size_t BlockDelta = FIRST_32_SECOND_64(8U, 16U);
 #endif
   const size_t SpecialSize = PageSize - BlockDelta;
while (P) {
     void *NextP = *reinterpret_cast<void **>(P);
     free(P);
     P = NextP;
   }
 }
 
 // Fuchsia doesn't have alarm, fork or malloc_info.
 #if !SCUDO_FUCHSIA
-TEST(ScudoWrappersCDeathTest, MallocDisableDeadlock) {
+TEST_F(ScudoWrappersCDeathTest, MallocDisableDeadlock) {
   // We expect heap operations within a disable/enable scope to deadlock.
   EXPECT_DEATH(
       {
         void *P = malloc(Size);
         EXPECT_NE(P, nullptr);
         free(P);
         malloc_disable();
         alarm(1);
         P = malloc(Size);
         malloc_enable();
       },
       "");
 }
 
-TEST(ScudoWrappersCTest, MallocInfo) {
+TEST_F(ScudoWrappersCTest, MallocInfo) {
   // Use volatile so that the allocations don't get optimized away.
   void *volatile P1 = malloc(1234);
   void *volatile P2 = malloc(4321);
 
   char Buffer[16384];
   FILE *F = fmemopen(Buffer, sizeof(Buffer), "w+");
   EXPECT_NE(F, nullptr);
   errno = 0;
   EXPECT_EQ(malloc_info(0, F), 0);
   EXPECT_EQ(errno, 0);
   fclose(F);
   EXPECT_EQ(strncmp(Buffer, "<malloc version=\"scudo-", 23), 0);
   EXPECT_NE(nullptr, strstr(Buffer, "<alloc size=\"1234\" count=\""));
   EXPECT_NE(nullptr, strstr(Buffer, "<alloc size=\"4321\" count=\""));
 
   free(P1);
   free(P2);
 }
 
-TEST(ScudoWrappersCDeathTest, Fork) {
+TEST_F(ScudoWrappersCDeathTest, Fork) {
   void *P;
   pid_t Pid = fork();
   EXPECT_GE(Pid, 0) << strerror(errno);
   if (Pid == 0) {
     P = malloc(Size);
     EXPECT_NE(P, nullptr);
     memset(P, 0x42, Size);
     free(P);
static void *enableMalloc(UNUSED void *Unused) {
 
   // Wait for the malloc_disable & fork, then enable the allocator again.
   sleep(1);
   malloc_enable();
 
   return nullptr;
 }
 
-TEST(ScudoWrappersCTest, DisableForkEnable) {
+TEST_F(ScudoWrappersCTest, DisableForkEnable) {
   pthread_t ThreadId;
   Ready = false;
   EXPECT_EQ(pthread_create(&ThreadId, nullptr, &enableMalloc, nullptr), 0);
 
   // Wait for the thread to be warmed up.
   pthread_mutex_lock(&Mutex);
   while (!Ready)
     pthread_cond_wait(&Conditional, &Mutex);

compiler-rt/lib/scudo/standalone/tests/wrappers_cpp_test.cpp

 
 // Android does not support checking for new/delete mismatches.
 #if SCUDO_ANDROID
 #define SKIP_MISMATCH_TESTS 1
 #else
 #define SKIP_MISMATCH_TESTS 0
 #endif
 
+void operator delete(void *, size_t) noexcept;
+void operator delete[](void *, size_t) noexcept;
+
+extern "C" {
+#ifndef SCUDO_ENABLE_HOOKS_TESTS
+#define SCUDO_ENABLE_HOOKS_TESTS 0
+#endif
+
+#if (SCUDO_ENABLE_HOOKS_TESTS == 1) && (SCUDO_ENABLE_HOOKS == 0)
+#error "Hooks tests should have hooks enabled as well!"
+#endif
+
 struct AllocContext {
   void *Ptr;
   size_t Size;
 };
 struct DeallocContext {
   void *Ptr;
 };
 static AllocContext AC;
 static DeallocContext DC;
 
-void operator delete(void *, size_t) noexcept;
-void operator delete[](void *, size_t) noexcept;
-
-extern "C" {
+#if (SCUDO_ENABLE_HOOKS_TESTS == 1)
 __attribute__((visibility("default"))) void __scudo_allocate_hook(void *Ptr,
                                                                   size_t Size) {
   AC.Ptr = Ptr;
   AC.Size = Size;
 }
 __attribute__((visibility("default"))) void __scudo_deallocate_hook(void *Ptr) {
   DC.Ptr = Ptr;
 }
+#endif // (SCUDO_ENABLE_HOOKS_TESTS == 1)
+}
+
+class ScudoWrappersCppTest : public Test {
+protected:
+  void SetUp() override {
+    if (SCUDO_ENABLE_HOOKS && !SCUDO_ENABLE_HOOKS_TESTS)
+      printf("Hooks are enabled but hooks tests are disabled.\n");
+  }
+
+  void verifyAllocHookPtr(UNUSED void *Ptr) {
+    if (SCUDO_ENABLE_HOOKS_TESTS)
+      EXPECT_EQ(Ptr, AC.Ptr);
+  }
+  void verifyAllocHookSize(UNUSED size_t Size) {
+    if (SCUDO_ENABLE_HOOKS_TESTS)
+      EXPECT_EQ(Size, AC.Size);
+  }
+  void verifyDeallocHookPtr(UNUSED void *Ptr) {
+    if (SCUDO_ENABLE_HOOKS_TESTS)
+      EXPECT_EQ(Ptr, DC.Ptr);
   }
-// Note that every Cxx allocation function in the test binary will be fulfilled
-// by Scudo. See the comment in the C counterpart of this file.
 
-template <typename T> static void testCxxNew() {
+  template <typename T> void testCxxNew() {
     T *P = new T;
     EXPECT_NE(P, nullptr);
-  EXPECT_EQ(P, AC.Ptr);
-  EXPECT_EQ(sizeof(T), AC.Size);
+    verifyAllocHookPtr(P);
+    verifyAllocHookSize(sizeof(T));
     memset(P, 0x42, sizeof(T));
     EXPECT_DEATH(delete[] P, "");
     delete P;
-  EXPECT_EQ(P, DC.Ptr);
+    verifyDeallocHookPtr(P);
     EXPECT_DEATH(delete P, "");
 
     P = new T;
     EXPECT_NE(P, nullptr);
     memset(P, 0x42, sizeof(T));
     operator delete(P, sizeof(T));
-  EXPECT_EQ(P, DC.Ptr);
+    verifyDeallocHookPtr(P);
 
     P = new (std::nothrow) T;
-  EXPECT_EQ(P, AC.Ptr);
-  EXPECT_EQ(sizeof(T), AC.Size);
+    verifyAllocHookPtr(P);
+    verifyAllocHookSize(sizeof(T));
     EXPECT_NE(P, nullptr);
     memset(P, 0x42, sizeof(T));
     delete P;
-  EXPECT_EQ(P, DC.Ptr);
+    verifyDeallocHookPtr(P);
 
     const size_t N = 16U;
     T *A = new T[N];
     EXPECT_NE(A, nullptr);
-  EXPECT_EQ(A, AC.Ptr);
-  EXPECT_EQ(sizeof(T) * N, AC.Size);
+    verifyAllocHookPtr(A);
+    verifyAllocHookSize(sizeof(T) * N);
     memset(A, 0x42, sizeof(T) * N);
     EXPECT_DEATH(delete A, "");
     delete[] A;
-  EXPECT_EQ(A, DC.Ptr);
+    verifyDeallocHookPtr(A);
     EXPECT_DEATH(delete[] A, "");
 
     A = new T[N];
     EXPECT_NE(A, nullptr);
     memset(A, 0x42, sizeof(T) * N);
     operator delete[](A, sizeof(T) * N);
-  EXPECT_EQ(A, DC.Ptr);
+    verifyDeallocHookPtr(A);
 
     A = new (std::nothrow) T[N];
-  EXPECT_EQ(A, AC.Ptr);
-  EXPECT_EQ(sizeof(T) * N, AC.Size);
+    verifyAllocHookPtr(A);
+    verifyAllocHookSize(sizeof(T) * N);
     EXPECT_NE(A, nullptr);
     memset(A, 0x42, sizeof(T) * N);
     delete[] A;
-  EXPECT_EQ(A, DC.Ptr);
+    verifyDeallocHookPtr(A);
   }
+};
+using ScudoWrappersCppDeathTest = ScudoWrappersCppTest;
 
 class Pixel {
 public:
   enum class Color { Red, Green, Blue };
   int X = 0;
   int Y = 0;
   Color C = Color::Red;
 };
 
-TEST(ScudoWrappersCppDeathTest, New) {
+// Note that every Cxx allocation function in the test binary will be fulfilled
+// by Scudo. See the comment in the C counterpart of this file.
+
+TEST_F(ScudoWrappersCppDeathTest, New) {
   if (getenv("SKIP_TYPE_MISMATCH") || SKIP_MISMATCH_TESTS) {
     printf("Skipped type mismatch tests.\n");
     return;
   }
   testCxxNew<bool>();
   testCxxNew<uint8_t>();
   testCxxNew<uint16_t>();
   testCxxNew<uint32_t>();
for (size_t I = 0; I < 256U; I++) {
     }
   }
   while (!V.empty()) {
     delete[] V.back();
     V.pop_back();
   }
 }
 
-TEST(ScudoWrappersCppTest, ThreadedNew) {
+TEST_F(ScudoWrappersCppTest, ThreadedNew) {
   // TODO: Investigate why libc sometimes crashes with tag missmatch in
   // __pthread_clockjoin_ex.
   std::unique_ptr<scudo::ScopedDisableMemoryTagChecks> NoTags;
   if (!SCUDO_ANDROID && scudo::archSupportsMemoryTagging() &&
       scudo::systemSupportsMemoryTagging())
     NoTags = std::make_unique<scudo::ScopedDisableMemoryTagChecks>();
 
   Ready = false;
   std::thread Threads[32];
   for (size_t I = 0U; I < sizeof(Threads) / sizeof(Threads[0]); I++)
     Threads[I] = std::thread(stressNew);
   {
     std::unique_lock<std::mutex> Lock(Mutex);
     Ready = true;
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
 }
 
 #if !SCUDO_FUCHSIA
-TEST(ScudoWrappersCppTest, AllocAfterFork) {
+TEST_F(ScudoWrappersCppTest, AllocAfterFork) {
   // This test can fail flakily when ran as a part of large number of
   // other tests if the maxmimum number of mappings allowed is low.
   // We tried to reduce the number of iterations of the loops with
   // moderate success, so we will now skip this test under those
   // circumstances.
   if (SCUDO_LINUX) {
     long MaxMapCount = 0;
     // If the file can't be accessed, we proceed with the test.

compiler-rt/lib/scudo/standalone/wrappers_c.cpp

 //===-- wrappers_c.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // Skip this compilation unit if compiled as part of Bionic.
 #if !SCUDO_ANDROID || !_BIONIC
 
 #include "allocator_config.h"
+#include "internal_defs.h"
+#include "platform.h"
 #include "scudo/interface.h"
 #include "wrappers_c.h"
 #include "wrappers_c_checks.h"
 
 #include <stdint.h>
 #include <stdio.h>
 
 #define SCUDO_PREFIX(name) name

compiler-rt/lib/scudo/standalone/wrappers_c.inc

 // malloc-type functions have to be aligned to std::max_align_t. This is
 // distinct from (1U << SCUDO_MIN_ALIGNMENT_LOG), since C++ new-type functions
 // do not have to abide by the same requirement.
 #ifndef SCUDO_MALLOC_ALIGNMENT
 #define SCUDO_MALLOC_ALIGNMENT FIRST_32_SECOND_64(8U, 16U)
 #endif
 
 static void reportAllocation(void *ptr, size_t size) {
+  if (SCUDO_ENABLE_HOOKS)
     if (__scudo_allocate_hook && ptr)
       __scudo_allocate_hook(ptr, size);
 }
-
 static void reportDeallocation(void *ptr) {
+  if (SCUDO_ENABLE_HOOKS)
     if (__scudo_deallocate_hook)
       __scudo_deallocate_hook(ptr);
 }
 
 extern "C" {
 
 INTERFACE WEAK void *SCUDO_PREFIX(calloc)(size_t nmemb, size_t size) {
   scudo::uptr Product;
   if (UNLIKELY(scudo::checkForCallocOverflow(size, nmemb, &Product))) {
     if (SCUDO_ALLOCATOR.canReturnNull()) {

compiler-rt/lib/scudo/standalone/wrappers_c_bionic.cpp

 //===-- wrappers_c_bionic.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // This is only used when compiled as part of Bionic.
 #if SCUDO_ANDROID && _BIONIC
 
 #include "allocator_config.h"
+#include "internal_defs.h"
+#include "platform.h"
 #include "scudo/interface.h"
 #include "wrappers_c.h"
 #include "wrappers_c_checks.h"
 
 #include <stdint.h>
 #include <stdio.h>
 
 // Regular MallocDispatch definitions.

compiler-rt/lib/scudo/standalone/wrappers_cpp.cpp

 //===-- wrappers_cpp.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // Skip this compilation unit if compiled as part of Bionic.
 #if !SCUDO_ANDROID || !_BIONIC
 
 #include "allocator_config.h"
+#include "internal_defs.h"
+#include "platform.h"
 #include "scudo/interface.h"
 #include "wrappers_c.h"
 
 #include <stdint.h>
 
 namespace std {
 struct nothrow_t {};
 enum class align_val_t : size_t {};
 } // namespace std
 
 static void reportAllocation(void *ptr, size_t size) {
+  if (SCUDO_ENABLE_HOOKS)
     if (__scudo_allocate_hook && ptr)
       __scudo_allocate_hook(ptr, size);
 }
-
 static void reportDeallocation(void *ptr) {
+  if (SCUDO_ENABLE_HOOKS)
     if (__scudo_deallocate_hook)
       __scudo_deallocate_hook(ptr);
 }
 
 INTERFACE WEAK void *operator new(size_t size) {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New);
   reportAllocation(Ptr, size);
   return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size) {