[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

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

59–60

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.

88

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

59–60

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

88

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

88

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

88

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)
 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
 
+#if SCUDO_FUCHSIA
+#ifndef SCUDO_ENABLE_HOOKS
+#define SCUDO_ENABLE_HOOKS
+#endif
+#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)
 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);
+
+#if defined(SCUDO_ENABLE_HOOKS)
 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);
-
 __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;
 }
+
+#define INVALIDATE_ALLOC_HOOK_PTR_AS(P)                                        \
+  do {                                                                         \
+    AC.Ptr = P;                                                                \
+  } while (false)
+#define VERIFY_ALLOC_HOOK_PTR(P) EXPECT_EQ(P, AC.Ptr)
+#define VERIFY_ALLOC_HOOK_SIZE(S) EXPECT_EQ(S, AC.Size)
+#define VERIFY_DEALLOC_HOOK_PTR(P) EXPECT_EQ(P, DC.Ptr)
+#else
+#define INVALIDATE_ALLOC_HOOK_PTR_AS(P)
+#define VERIFY_ALLOC_HOOK_PTR(P)
+#define VERIFY_ALLOC_HOOK_SIZE(Size)
+#define VERIFY_DEALLOC_HOOK_PTR(P)
+#endif // defined(SCUDO_ENABLE_HOOKS)
 }
 
 // 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) {
   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);
+  VERIFY_ALLOC_HOOK_PTR(P);
+  VERIFY_ALLOC_HOOK_SIZE(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);
+  VERIFY_DEALLOC_HOOK_PTR(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) {
   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);
+  VERIFY_ALLOC_HOOK_PTR(P);
+  VERIFY_ALLOC_HOOK_SIZE(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);
+  VERIFY_DEALLOC_HOOK_PTR(P);
 
   P = calloc(1U, 0U);
   EXPECT_NE(P, nullptr);
   free(P);
   P = calloc(0U, 1U);
   EXPECT_NE(P, nullptr);
   free(P);
 
TEST(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);
+    VERIFY_ALLOC_HOOK_PTR(P);
+    VERIFY_ALLOC_HOOK_SIZE(Size);
     free(P);
-    EXPECT_EQ(P, DC.Ptr);
+    VERIFY_DEALLOC_HOOK_PTR(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);
+    VERIFY_ALLOC_HOOK_PTR(P);
+    VERIFY_ALLOC_HOOK_SIZE(Size);
     free(P);
-    EXPECT_EQ(P, DC.Ptr);
+    VERIFY_DEALLOC_HOOK_PTR(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);
+      VERIFY_ALLOC_HOOK_PTR(P);
+      VERIFY_ALLOC_HOOK_SIZE(Size);
       free(P);
-      EXPECT_EQ(P, DC.Ptr);
+      VERIFY_DEALLOC_HOOK_PTR(P);
     }
   }
 }
 
 TEST(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);
+  VERIFY_ALLOC_HOOK_PTR(P);
+  VERIFY_ALLOC_HOOK_SIZE(Alignment * 4U);
   free(P);
-  EXPECT_EQ(P, DC.Ptr);
+  VERIFY_DEALLOC_HOOK_PTR(P);
 
   errno = 0;
   P = aligned_alloc(Alignment, Size);
   EXPECT_EQ(P, nullptr);
   EXPECT_EQ(errno, EINVAL);
 }
 
 TEST(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);
+  VERIFY_ALLOC_HOOK_PTR(P);
+  VERIFY_ALLOC_HOOK_SIZE(Size);
   free(P);
-  EXPECT_EQ(P, DC.Ptr);
+  VERIFY_DEALLOC_HOOK_PTR(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);
+  VERIFY_DEALLOC_HOOK_PTR(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);
+  INVALIDATE_ALLOC_HOOK_PTR_AS(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));
+    VERIFY_ALLOC_HOOK_PTR(reinterpret_cast<void *>(0xdeadbeef));
   } else {
-    EXPECT_EQ(P, AC.Ptr);
-    EXPECT_EQ(Size * 2U, AC.Size);
-    EXPECT_EQ(OldP, DC.Ptr);
+    VERIFY_ALLOC_HOOK_PTR(P);
+    VERIFY_ALLOC_HOOK_SIZE(Size * 2U);
+    VERIFY_DEALLOC_HOOK_PTR(OldP);
   }
 
-  AC.Ptr = reinterpret_cast<void *>(0xdeadbeef);
+  INVALIDATE_ALLOC_HOOK_PTR_AS(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));
+    VERIFY_ALLOC_HOOK_PTR(reinterpret_cast<void *>(0xdeadbeef));
   } else {
-    EXPECT_EQ(P, AC.Ptr);
-    EXPECT_EQ(Size / 2U, AC.Size);
+    VERIFY_ALLOC_HOOK_PTR(P);
+    VERIFY_ALLOC_HOOK_SIZE(Size / 2U);
   }
   free(P);
 
   EXPECT_DEATH(P = realloc(P, Size), "");
 
   errno = 0;
   EXPECT_EQ(realloc(nullptr, SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);

 TEST(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);
+  VERIFY_ALLOC_HOOK_PTR(P);
   // Size will be rounded up to PageSize.
-  EXPECT_EQ(PageSize, AC.Size);
+  VERIFY_ALLOC_HOOK_SIZE(PageSize);
   free(P);
-  EXPECT_EQ(P, DC.Ptr);
+  VERIFY_DEALLOC_HOOK_PTR(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

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" {
+#if defined(SCUDO_ENABLE_HOOKS)
 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" {
 __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;
 }
+#define INVALIDATE_ALLOC_HOOK_PTR_AS(P)                                        \
+  do {                                                                         \
+    AC.Ptr = P;                                                                \
+  } while (false)
+#define VERIFY_ALLOC_HOOK_PTR(P) EXPECT_EQ(P, AC.Ptr)
+#define VERIFY_ALLOC_HOOK_SIZE(S) EXPECT_EQ(S, AC.Size);
+#define VERIFY_DEALLOC_HOOK_PTR(P) EXPECT_EQ(P, DC.Ptr)
+#else
+#define INVALIDATE_ALLOC_HOOK_PTR_AS(Ptr)
+#define VERIFY_ALLOC_HOOK_PTR(Ptr)
+#define VERIFY_ALLOC_HOOK_SIZE(Size)
+#define VERIFY_DEALLOC_HOOK_PTR(Ptr)
+#endif // defined(SCUDO_ENABLE_HOOKS)
 }
 // 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() {
   T *P = new T;
   EXPECT_NE(P, nullptr);
-  EXPECT_EQ(P, AC.Ptr);
-  EXPECT_EQ(sizeof(T), AC.Size);
+  VERIFY_ALLOC_HOOK_PTR(P);
+  VERIFY_ALLOC_HOOK_SIZE(sizeof(T));
   memset(P, 0x42, sizeof(T));
   EXPECT_DEATH(delete[] P, "");
   delete P;
-  EXPECT_EQ(P, DC.Ptr);
+  VERIFY_DEALLOC_HOOK_PTR(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);
+  VERIFY_DEALLOC_HOOK_PTR(P);
 
   P = new (std::nothrow) T;
-  EXPECT_EQ(P, AC.Ptr);
-  EXPECT_EQ(sizeof(T), AC.Size);
+  VERIFY_ALLOC_HOOK_PTR(P);
+  VERIFY_ALLOC_HOOK_SIZE(sizeof(T));
   EXPECT_NE(P, nullptr);
   memset(P, 0x42, sizeof(T));
   delete P;
-  EXPECT_EQ(P, DC.Ptr);
+  VERIFY_DEALLOC_HOOK_PTR(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);
+  VERIFY_ALLOC_HOOK_PTR(A);
+  VERIFY_ALLOC_HOOK_SIZE(sizeof(T) * N);
   memset(A, 0x42, sizeof(T) * N);
   EXPECT_DEATH(delete A, "");
   delete[] A;
-  EXPECT_EQ(A, DC.Ptr);
+  VERIFY_DEALLOC_HOOK_PTR(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);
+  VERIFY_DEALLOC_HOOK_PTR(A);
 
   A = new (std::nothrow) T[N];
-  EXPECT_EQ(A, AC.Ptr);
-  EXPECT_EQ(sizeof(T) * N, AC.Size);
+  VERIFY_ALLOC_HOOK_PTR(A);
+  VERIFY_ALLOC_HOOK_SIZE(sizeof(T) * N);
   EXPECT_NE(A, nullptr);
   memset(A, 0x42, sizeof(T) * N);
   delete[] A;
-  EXPECT_EQ(A, DC.Ptr);
+  VERIFY_DEALLOC_HOOK_PTR(A);
 }
 
 class Pixel {
 public:
   enum class Color { Red, Green, Blue };
   int X = 0;
   int Y = 0;
   Color C = Color::Red;

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
 
+#if defined(SCUDO_ENABLE_HOOKS)
 static void reportAllocation(void *ptr, size_t size) {
   if (__scudo_allocate_hook && ptr)
     __scudo_allocate_hook(ptr, size);
 }
-
 static void reportDeallocation(void *ptr) {
   if (__scudo_deallocate_hook)
     __scudo_deallocate_hook(ptr);
 }
 
+#define REPORT_ALLOC(P, S) reportAllocation(P, S)
+#define REPORT_DEALLOC(P) reportDeallocation(P)
+#else
+#define REPORT_ALLOC(P, S)
+#define REPORT_DEALLOC(P)
+#endif // defined(SCUDO_ENABLE_HOOKS)
+
 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()) {
       errno = ENOMEM;
       return nullptr;
     }
     scudo::reportCallocOverflow(nmemb, size);
   }
   void *Ptr = SCUDO_ALLOCATOR.allocate(Product, scudo::Chunk::Origin::Malloc,
                                        SCUDO_MALLOC_ALIGNMENT, true);
-  reportAllocation(Ptr, Product);
+  REPORT_ALLOC(Ptr, Product);
   return scudo::setErrnoOnNull(Ptr);
 }
 
 INTERFACE WEAK void SCUDO_PREFIX(free)(void *ptr) {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   SCUDO_ALLOCATOR.deallocate(ptr, scudo::Chunk::Origin::Malloc);
 }
 
 INTERFACE WEAK struct SCUDO_MALLINFO SCUDO_PREFIX(mallinfo)(void) {
   struct SCUDO_MALLINFO Info = {};
   scudo::StatCounters Stats;
   SCUDO_ALLOCATOR.getStats(Stats);
   // Space allocated in mmapped regions (bytes)
INTERFACE WEAK struct __scudo_mallinfo2 SCUDO_PREFIX(mallinfo2)(void) {
   Info.fordblks = Info.fsmblks;
   return Info;
 }
 #endif
 
 INTERFACE WEAK void *SCUDO_PREFIX(malloc)(size_t size) {
   void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc,
                                        SCUDO_MALLOC_ALIGNMENT);
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return scudo::setErrnoOnNull(Ptr);
 }
 
 #if SCUDO_ANDROID
 INTERFACE WEAK size_t SCUDO_PREFIX(malloc_usable_size)(const void *ptr) {
 #else
 INTERFACE WEAK size_t SCUDO_PREFIX(malloc_usable_size)(void *ptr) {
 #endif
if (UNLIKELY(!scudo::isPowerOfTwo(alignment))) {
         errno = EINVAL;
         return nullptr;
       }
       scudo::reportAlignmentNotPowerOfTwo(alignment);
     }
   }
   void *Ptr =
       SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign, alignment);
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(posix_memalign)(void **memptr, size_t alignment,
                                                 size_t size) {
   if (UNLIKELY(scudo::checkPosixMemalignAlignment(alignment))) {
     if (!SCUDO_ALLOCATOR.canReturnNull())
       scudo::reportInvalidPosixMemalignAlignment(alignment);
     return EINVAL;
   }
   void *Ptr =
       SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign, alignment);
   if (UNLIKELY(!Ptr))
     return ENOMEM;
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
 
   *memptr = Ptr;
   return 0;
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(pvalloc)(size_t size) {
   const scudo::uptr PageSize = scudo::getPageSizeCached();
   if (UNLIKELY(scudo::checkForPvallocOverflow(size, PageSize))) {
     if (SCUDO_ALLOCATOR.canReturnNull()) {
       errno = ENOMEM;
       return nullptr;
     }
     scudo::reportPvallocOverflow(size);
   }
   // pvalloc(0) should allocate one page.
   void *Ptr =
       SCUDO_ALLOCATOR.allocate(size ? scudo::roundUp(size, PageSize) : PageSize,
                                scudo::Chunk::Origin::Memalign, PageSize);
-  reportAllocation(Ptr, scudo::roundUp(size, PageSize));
+  REPORT_ALLOC(Ptr, scudo::roundUp(size, PageSize));
 
   return scudo::setErrnoOnNull(Ptr);
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(realloc)(void *ptr, size_t size) {
   if (!ptr) {
     void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc,
                                          SCUDO_MALLOC_ALIGNMENT);
-    reportAllocation(Ptr, size);
+    REPORT_ALLOC(Ptr, size);
     return scudo::setErrnoOnNull(Ptr);
   }
   if (size == 0) {
-    reportDeallocation(ptr);
+    REPORT_DEALLOC(ptr);
     SCUDO_ALLOCATOR.deallocate(ptr, scudo::Chunk::Origin::Malloc);
     return nullptr;
   }
 
   void *NewPtr = SCUDO_ALLOCATOR.reallocate(ptr, size, SCUDO_MALLOC_ALIGNMENT);
   if (NewPtr != ptr) {
-    reportAllocation(NewPtr, size);
-    reportDeallocation(ptr);
+    REPORT_ALLOC(NewPtr, size);
+    REPORT_DEALLOC(ptr);
   }
 
   return scudo::setErrnoOnNull(NewPtr);
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(valloc)(size_t size) {
   void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign,
                                        scudo::getPageSizeCached());
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
 
   return scudo::setErrnoOnNull(Ptr);
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(malloc_iterate)(
     uintptr_t base, size_t size,
     void (*callback)(uintptr_t base, size_t size, void *arg), void *arg) {
   SCUDO_ALLOCATOR.iterateOverChunks(base, size, callback, arg);
if (SCUDO_ALLOCATOR.canReturnNull()) {
       errno = EINVAL;
       return nullptr;
     }
     scudo::reportInvalidAlignedAllocAlignment(alignment, size);
   }
 
   void *Ptr =
       SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc, alignment);
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
 
   return scudo::setErrnoOnNull(Ptr);
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(malloc_info)(UNUSED int options, FILE *stream) {
   const scudo::uptr max_size =
       decltype(SCUDO_ALLOCATOR)::PrimaryT::SizeClassMap::MaxSize;
   auto *sizes = static_cast<scudo::uptr *>(

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
 
+#if defined(SCUDO_ENABLE_HOOKS)
 static void reportAllocation(void *ptr, size_t size) {
   if (__scudo_allocate_hook && ptr)
     __scudo_allocate_hook(ptr, size);
 }
-
 static void reportDeallocation(void *ptr) {
   if (__scudo_deallocate_hook)
     __scudo_deallocate_hook(ptr);
 }
+#define REPORT_ALLOC(P, S) reportAllocation(P, S)
+#define REPORT_DEALLOC(P) reportDeallocation(P)
+#else
+#define REPORT_ALLOC(P, S)
+#define REPORT_DEALLOC(P)
+#endif // defined(SCUDO_ENABLE_HOOKS)
 
 INTERFACE WEAK void *operator new(size_t size) {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New);
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size) {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::NewArray);
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 INTERFACE WEAK void *operator new(size_t size,
                                   std::nothrow_t const &) NOEXCEPT {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New);
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size,
                                     std::nothrow_t const &) NOEXCEPT {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::NewArray);
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 INTERFACE WEAK void *operator new(size_t size, std::align_val_t align) {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New,
                                  static_cast<scudo::uptr>(align));
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size, std::align_val_t align) {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::NewArray,
                                  static_cast<scudo::uptr>(align));
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 INTERFACE WEAK void *operator new(size_t size, std::align_val_t align,
                                   std::nothrow_t const &) NOEXCEPT {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New,
                                  static_cast<scudo::uptr>(align));
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size, std::align_val_t align,
                                     std::nothrow_t const &) NOEXCEPT {
   void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::NewArray,
                                  static_cast<scudo::uptr>(align));
-  reportAllocation(Ptr, size);
+  REPORT_ALLOC(Ptr, size);
   return Ptr;
 }
 
 INTERFACE WEAK void operator delete(void *ptr) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New);
 }
 INTERFACE WEAK void operator delete[](void *ptr) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray);
 }
 INTERFACE WEAK void operator delete(void *ptr,
                                     std::nothrow_t const &) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New);
 }
 INTERFACE WEAK void operator delete[](void *ptr,
                                       std::nothrow_t const &) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray);
 }
 INTERFACE WEAK void operator delete(void *ptr, size_t size) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New, size);
 }
 INTERFACE WEAK void operator delete[](void *ptr, size_t size) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, size);
 }
 INTERFACE WEAK void operator delete(void *ptr,
                                     std::align_val_t align) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New, 0,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete[](void *ptr,
                                       std::align_val_t align) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, 0,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete(void *ptr, std::align_val_t align,
                                     std::nothrow_t const &) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New, 0,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete[](void *ptr, std::align_val_t align,
                                       std::nothrow_t const &) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, 0,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete(void *ptr, size_t size,
                                     std::align_val_t align) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New, size,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete[](void *ptr, size_t size,
                                       std::align_val_t align) NOEXCEPT {
-  reportDeallocation(ptr);
+  REPORT_DEALLOC(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, size,
                        static_cast<scudo::uptr>(align));
 }
 
 #endif // !SCUDO_ANDROID || !_BIONIC