[GWP-ASan] Add aligned allocations.

[hctim]

Summary

Adds a new allocation API to GWP-ASan that handles size+alignment
restrictions.

[cryptoad]

Is there some test that can be added that would find a regression?

[eugenis]

compiler-rt/lib/gwp_asan/optional/backtrace.h

18 ↗

(On Diff #317080)

unrelated comment

compiler-rt/lib/gwp_asan/tests/harness.h

38 ↗

(On Diff #317080)

extra new line

compiler-rt/lib/scudo/scudo_allocator.cpp

333

split hooks into a separate commit, or at least mention them in the message

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

496

another unrelated change

[hctim]

In D94830#2502424, @cryptoad wrote:

Is there some test that can be added that would find a regression?

I'm looking into some cmake magic to also run the scudo-standalone tests using GWP_ASAN_OPTIONS=MaxSimultaneousAllocations=10000:SampleRate=1 as well, but it's taking some time... :(.

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

496

added details to the commit message

[hctim]

Address reviewer comments.

Change the API to take an alignment, not a 'size' and 'real size' paramater. This way, GWP-ASan can use its own alignment guarantees (page alignment).

Needs a little bit more WIP to get the alignment tighter.

[hctim]

Removed Scudo bits for now, made this GWP-ASan specific. Changes to scudo will come in a follow-up patch.

[hctim]

compiler-rt/lib/gwp_asan/guarded_pool_allocator.cpp

160

Note to reviewers: Please check my logic here. This specifically helps with the case where we have a 0x4000 byte slot, and we ask for a 0x1 byte allocation with 0x4000 alignment - this allocation can obviously be resident.

[cryptoad]

compiler-rt/lib/gwp_asan/guarded_pool_allocator.cpp

37

nit: capital X

193

Should this be 1 or alignof(max_align_t)?

[hctim]

Addressed Kostya's comments.

[hctim]

Accidentally committed this in 9dc06762470cb5a6cde8de5833cb75262e1bacb0, and reverted it in 0dcf3324cfb4429e85b54e857f9bb86f423ffc5e. This is still needing review.

[hctim]

Rebase after kerfuffle.

[hctim]

Rebased on top of D95542, which changed the GWP-ASan flag parsing dependencies. This patch does require a small change on the Scudo side, but the actual integration on top of this API (with some new fixes) is at D95884.

[hctim]

(friendly ping)

[eugenis]

LGTM with a nit

getAlignedPtr is very unclear to me, and the 3rd argument is always const anyway!

compiler-rt/lib/gwp_asan/guarded_pool_allocator.cpp

160

this looks correct

222

alignUp(SlotStart, Alignment)

(add a helper function if we don;t have that in gwp-asan yet)

225

alignDown(SlotEnd - Size, Alignment)

[hctim]

Address Evgenii's comments.

compiler-rt/lib/gwp_asan/CMakeLists.txt

 add_compiler_rt_component(gwp_asan)
 
 include_directories(..)
 
 set(GWP_ASAN_SOURCES
   common.cpp
   crash_handler.cpp
   platform_specific/common_posix.cpp
   platform_specific/guarded_pool_allocator_posix.cpp
   platform_specific/mutex_posix.cpp
   platform_specific/utilities_posix.cpp
   guarded_pool_allocator.cpp
   stack_trace_compressor.cpp
-  utilities.cpp
 )
 
 set(GWP_ASAN_HEADERS
   common.h
   crash_handler.h
   definitions.h
   guarded_pool_allocator.h
   mutex.h

compiler-rt/lib/gwp_asan/common.h

struct AllocationMetadata {
   static constexpr size_t kStackFrameStorageBytes = 256;
 
   // Maximum number of stack frames to collect on allocation/deallocation. The
   // actual number of collected frames may be less than this as the stack
   // frames are compressed into a fixed memory range.
   static constexpr size_t kMaxTraceLengthToCollect = 128;
 
   // Records the given allocation metadata into this struct.
-  void RecordAllocation(uintptr_t Addr, size_t Size);
+  void RecordAllocation(uintptr_t Addr, size_t RequestedSize);
   // Record that this allocation is now deallocated.
   void RecordDeallocation();
 
   struct CallSiteInfo {
     // Record the current backtrace to this callsite.
     void RecordBacktrace(options::Backtrace_t Backtrace);
 
     // The compressed backtrace to the allocation/deallocation.
     uint8_t CompressedTrace[kStackFrameStorageBytes];
     // The thread ID for this trace, or kInvalidThreadID if not available.
     uint64_t ThreadID = kInvalidThreadID;
     // The size of the compressed trace (in bytes). Zero indicates that no
     // trace was collected.
     size_t TraceSize = 0;
   };
 
   // The address of this allocation. If zero, the rest of this struct isn't
   // valid, as the allocation has never occurred.
   uintptr_t Addr = 0;
   // Represents the actual size of the allocation.
-  size_t Size = 0;
+  size_t RequestedSize = 0;
 
   CallSiteInfo AllocationTrace;
   CallSiteInfo DeallocationTrace;
 
   // Whether this allocation has been deallocated yet.
   bool IsDeallocated = false;
 };
 

compiler-rt/lib/gwp_asan/common.cpp

 }
 
 constexpr size_t AllocationMetadata::kStackFrameStorageBytes;
 constexpr size_t AllocationMetadata::kMaxTraceLengthToCollect;
 
 void AllocationMetadata::RecordAllocation(uintptr_t AllocAddr,
                                           size_t AllocSize) {
   Addr = AllocAddr;
-  Size = AllocSize;
+  RequestedSize = AllocSize;
   IsDeallocated = false;
 
   AllocationTrace.ThreadID = getThreadID();
   DeallocationTrace.TraceSize = 0;
   DeallocationTrace.ThreadID = kInvalidThreadID;
 }
 
 void AllocationMetadata::RecordDeallocation() {

compiler-rt/lib/gwp_asan/crash_handler.cpp

 
 uintptr_t __gwp_asan_get_allocation_address(
     const gwp_asan::AllocationMetadata *AllocationMeta) {
   return AllocationMeta->Addr;
 }
 
 size_t __gwp_asan_get_allocation_size(
     const gwp_asan::AllocationMetadata *AllocationMeta) {
-  return AllocationMeta->Size;
+  return AllocationMeta->RequestedSize;
 }
 
 uint64_t __gwp_asan_get_allocation_thread_id(
     const gwp_asan::AllocationMetadata *AllocationMeta) {
   return AllocationMeta->AllocationTrace.ThreadID;
 }
 
 size_t __gwp_asan_get_allocation_trace(

compiler-rt/lib/gwp_asan/guarded_pool_allocator.h

 #include "gwp_asan/mutex.h"
 #include "gwp_asan/options.h"
 #include "gwp_asan/platform_specific/guarded_pool_allocator_fuchsia.h" // IWYU pragma: keep
 #include "gwp_asan/platform_specific/guarded_pool_allocator_posix.h" // IWYU pragma: keep
 #include "gwp_asan/platform_specific/guarded_pool_allocator_tls.h"
 
 #include <stddef.h>
 #include <stdint.h>
+// IWYU pragma: no_include <__stddef_max_align_t.h>
 
 namespace gwp_asan {
 // This class is the primary implementation of the allocator portion of GWP-
 // ASan. It is the sole owner of the pool of sequentially allocated guarded
 // slots. It should always be treated as a singleton.
 
 // Functions in the public interface of this class are thread-compatible until
 // init() is called, at which point they become thread-safe (unless specified
public:
   }
 
   // Returns whether the provided pointer is a current sampled allocation that
   // is owned by this pool.
   GWP_ASAN_ALWAYS_INLINE bool pointerIsMine(const void *Ptr) const {
     return State.pointerIsMine(Ptr);
   }
 
-  // Allocate memory in a guarded slot, and return a pointer to the new
-  // allocation. Returns nullptr if the pool is empty, the requested size is too
-  // large for this pool to handle, or the requested size is zero.
-  void *allocate(size_t Size);
+  // Allocate memory in a guarded slot, with the specified `Alignment`. Returns
+  // nullptr if the pool is empty, if the alignnment is not a power of two, or
+  // if the size/alignment makes the allocation too large for this pool to
+  // handle. By default, uses strong alignment (i.e. `max_align_t`), see
+  // http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2293.htm for discussion of
+  // alignment issues in the standard.
+  void *allocate(size_t Size, size_t Alignment = alignof(max_align_t));
 
   // Deallocate memory in a guarded slot. The provided pointer must have been
   // allocated using this pool. This will set the guarded slot as inaccessible.
   void deallocate(void *Ptr);
 
   // Returns the size of the allocation at Ptr.
   size_t getSize(const void *Ptr);
 
   // Returns a pointer to the Metadata region, or nullptr if it doesn't exist.
   const AllocationMetadata *getMetadataRegion() const { return Metadata; }
 
   // Returns a pointer to the AllocatorState region.
   const AllocatorState *getAllocatorState() const { return &State; }
 
+  // Exposed as protected for testing.
+protected:
+  // Returns the actual allocation size required to service an allocation with
+  // the provided Size and Alignment.
+  static size_t getRequiredBackingSize(size_t Size, size_t Alignment,
+                                       size_t PageSize);
+
+  // Returns the provided pointer that meets the specified alignment, depending
+  // on whether it's left or right aligned.
+  static uintptr_t getAlignedPtr(uintptr_t Ptr, size_t Alignment,
+                                 bool IsRightAligned);
+
 private:
   // Name of actively-occupied slot mappings.
   static constexpr const char *kGwpAsanAliveSlotName = "GWP-ASan Alive Slot";
   // Name of the guard pages. This includes all slots that are not actively in
   // use (i.e. were never used, or have been free()'d).)
   static constexpr const char *kGwpAsanGuardPageName = "GWP-ASan Guard Page";
   // Name of the mapping for `FreeSlots`.
   static constexpr const char *kGwpAsanFreeSlotsName = "GWP-ASan Metadata";

compiler-rt/lib/gwp_asan/guarded_pool_allocator.cpp

 //===-- guarded_pool_allocator.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 "gwp_asan/guarded_pool_allocator.h"
 
 #include "gwp_asan/options.h"
 #include "gwp_asan/utilities.h"
 
 #include <assert.h>
+#include <stddef.h>
 
 using AllocationMetadata = gwp_asan::AllocationMetadata;
 using Error = gwp_asan::Error;
 
 namespace gwp_asan {
 namespace {
 // Forward declare the pointer to the singleton version of this class.
 // Instantiated during initialisation, this allows the signal handler
 // to find this class in order to deduce the root cause of failures. Must not be
 // referenced by users outside this translation unit, in order to avoid
 // init-order-fiasco.
 GuardedPoolAllocator *SingletonPtr = nullptr;
 
 size_t roundUpTo(size_t Size, size_t Boundary) {
   return (Size + Boundary - 1) & ~(Boundary - 1);
 }
 
 uintptr_t getPageAddr(uintptr_t Ptr, uintptr_t PageSize) {
   return Ptr & ~(PageSize - 1);
 }
+
+// Unused on -DNDEBUG builds.
+__attribute__((unused)) bool IsPowerOfTwo(uintptr_t x) {
+  return (x & (x - 1)) == 0;
+}
 } // anonymous namespace
 
 // Gets the singleton implementation of this class. Thread-compatible until
 // init() is called, thread-safe afterwards.
 GuardedPoolAllocator *GuardedPoolAllocator::getSingleton() {
   return SingletonPtr;
 }
 
void GuardedPoolAllocator::init(const options::Options &Opts) {
 
   State.MaxSimultaneousAllocations = Opts.MaxSimultaneousAllocations;
 
   const size_t PageSize = getPlatformPageSize();
   // getPageAddr() and roundUpTo() assume the page size to be a power of 2.
   assert((PageSize & (PageSize - 1)) == 0);
   State.PageSize = PageSize;
 
-  PerfectlyRightAlign = Opts.PerfectlyRightAlign;
-
   size_t PoolBytesRequired =
       PageSize * (1 + State.MaxSimultaneousAllocations) +
       State.MaxSimultaneousAllocations * State.maximumAllocationSize();
   assert(PoolBytesRequired % PageSize == 0);
   void *GuardedPoolMemory = reserveGuardedPool(PoolBytesRequired);
 
   size_t BytesRequired =
       roundUpTo(State.MaxSimultaneousAllocations * sizeof(*Metadata), PageSize);

 
 void GuardedPoolAllocator::iterate(void *Base, size_t Size, iterate_callback Cb,
                                    void *Arg) {
   uintptr_t Start = reinterpret_cast<uintptr_t>(Base);
   for (size_t i = 0; i < State.MaxSimultaneousAllocations; ++i) {
     const AllocationMetadata &Meta = Metadata[i];
     if (Meta.Addr && !Meta.IsDeallocated && Meta.Addr >= Start &&
         Meta.Addr < Start + Size)
-      Cb(Meta.Addr, Meta.Size, Arg);
+      Cb(Meta.Addr, Meta.RequestedSize, Arg);
   }
 }
 
 void GuardedPoolAllocator::uninitTestOnly() {
   if (State.GuardedPagePool) {
     unreserveGuardedPool();
     State.GuardedPagePool = 0;
     State.GuardedPagePoolEnd = 0;
   }
   if (Metadata) {
     unmap(Metadata,
           roundUpTo(State.MaxSimultaneousAllocations * sizeof(*Metadata),
                     State.PageSize));
     Metadata = nullptr;
   }
   if (FreeSlots) {
     unmap(FreeSlots,
           roundUpTo(State.MaxSimultaneousAllocations * sizeof(*FreeSlots),
                     State.PageSize));
     FreeSlots = nullptr;
   }
   *getThreadLocals() = ThreadLocalPackedVariables();
 }
 
-void *GuardedPoolAllocator::allocate(size_t Size) {
+// Note, minimum backing allocation size in GWP-ASan is always one page, and
+// each slot could potentially be multiple pages (but always in
+// page-increments). Thus, for anything that requires less than page size
+// alignment, we don't need to allocate extra padding to ensure the alignment
+// can be met.
+size_t GuardedPoolAllocator::getRequiredBackingSize(size_t Size,
+                                                    size_t Alignment,
+                                                    size_t PageSize) {
+  assert(IsPowerOfTwo(Alignment) && "Alignment must be a power of two!");
+  assert(Alignment != 0 && "Alignment should be non-zero");
+  assert(Size != 0 && "Alignment should be non-zero");
+
+  Size = Size ?: 1;
+  Alignment = Alignment ?: 1;
+
+  if (Alignment <= PageSize)
+    return roundUpTo(Size, Alignment);
+
+  return Size + Alignment;
+}
+
+uintptr_t GuardedPoolAllocator::getAlignedPtr(uintptr_t Ptr, size_t Alignment,
+                                              bool IsRightAligned) {
+  assert(IsPowerOfTwo(Alignment) && "Alignment must be a power of two!");
+  assert(Alignment != 0 && "Alignment should be non-zero");
+  if ((Ptr & (Alignment - 1)) == 0)
+    return Ptr;
+
+  if (IsRightAligned)
+    Ptr -= Ptr & (Alignment - 1);
+  else
+    Ptr += Alignment - (Ptr & (Alignment - 1));
+  return Ptr;
+}
+
+void *GuardedPoolAllocator::allocate(size_t Size, size_t Alignment) {
   // GuardedPagePoolEnd == 0 when GWP-ASan is disabled. If we are disabled, fall
   // back to the supporting allocator.
   if (State.GuardedPagePoolEnd == 0) {
     getThreadLocals()->NextSampleCounter =
         (AdjustedSampleRatePlusOne - 1) &
         ThreadLocalPackedVariables::NextSampleCounterMask;
     return nullptr;
   }
 
+  Size = Size ?: 1;
+  Alignment = Alignment ?: 1;
+
+  if (!IsPowerOfTwo(Alignment) || Alignment > State.maximumAllocationSize() ||
+      Size > State.maximumAllocationSize())
+    return nullptr;
+
+  size_t BackingSize = getRequiredBackingSize(Size, Alignment, State.PageSize);
+  if (BackingSize > State.maximumAllocationSize())
+    return nullptr;
+
   // Protect against recursivity.
   if (getThreadLocals()->RecursiveGuard)
     return nullptr;
   ScopedRecursiveGuard SRG;
 
-  if (Size == 0 || Size > State.maximumAllocationSize())
-    return nullptr;
-
   size_t Index;
   {
     ScopedLock L(PoolMutex);
     Index = reserveSlot();
   }
 
   if (Index == kInvalidSlotID)
     return nullptr;
 
-  uintptr_t Ptr = State.slotToAddr(Index);
-  // Should we right-align this allocation?
-  if (getRandomUnsigned32() % 2 == 0) {
-    AlignmentStrategy Align = AlignmentStrategy::DEFAULT;
-    if (PerfectlyRightAlign)
-      Align = AlignmentStrategy::PERFECT;
-    Ptr +=
-        State.maximumAllocationSize() - rightAlignedAllocationSize(Size, Align);
-  }
-  AllocationMetadata *Meta = addrToMetadata(Ptr);
+  uintptr_t SlotStart = State.slotToAddr(Index);
+  AllocationMetadata *Meta = addrToMetadata(SlotStart);
+  uintptr_t SlotEnd = State.slotToAddr(Index) + State.maximumAllocationSize();
+  uintptr_t UserPtr;
+  // Randomly choose whether to left-align or right-align the allocation, and
+  // then apply the necessary adjustments to get an aligned pointer.
+  if (getRandomUnsigned32() % 2 == 0)
+    UserPtr = getAlignedPtr(SlotStart, Alignment, /* IsRightAligned */ false);
+  else
+    UserPtr =
+        getAlignedPtr(SlotEnd - Size, Alignment, /* IsRightAligned */ true);
+
+  assert(UserPtr >= SlotStart && UserPtr < SlotEnd);
 
   // If a slot is multiple pages in size, and the allocation takes up a single
   // page, we can improve overflow detection by leaving the unused pages as
   // unmapped.
   const size_t PageSize = State.PageSize;
-  allocateInGuardedPool(reinterpret_cast<void *>(getPageAddr(Ptr, PageSize)),
-                        roundUpTo(Size, PageSize));
+  allocateInGuardedPool(
+      reinterpret_cast<void *>(getPageAddr(UserPtr, PageSize)),
 
-  Meta->RecordAllocation(Ptr, Size);
+  Meta->RecordAllocation(UserPtr, Size);
   Meta->AllocationTrace.RecordBacktrace(Backtrace);
 
-  return reinterpret_cast<void *>(Ptr);
+  return reinterpret_cast<void *>(UserPtr);
 }
 
 void GuardedPoolAllocator::trapOnAddress(uintptr_t Address, Error E) {
   State.FailureType = E;
   State.FailureAddress = Address;
 
   // Raise a SEGV by touching first guard page.
   volatile char *p = reinterpret_cast<char *>(State.GuardedPagePool);
void GuardedPoolAllocator::deallocate(void *Ptr) {
   freeSlot(Slot);
 }
 
 size_t GuardedPoolAllocator::getSize(const void *Ptr) {
   assert(pointerIsMine(Ptr));
   ScopedLock L(PoolMutex);
   AllocationMetadata *Meta = addrToMetadata(reinterpret_cast<uintptr_t>(Ptr));
   assert(Meta->Addr == reinterpret_cast<uintptr_t>(Ptr));
-  return Meta->Size;
+  return Meta->RequestedSize;
 }
 
 AllocationMetadata *GuardedPoolAllocator::addrToMetadata(uintptr_t Ptr) const {
   return &Metadata[State.getNearestSlot(Ptr)];
 }
 
 size_t GuardedPoolAllocator::reserveSlot() {
   // Avoid potential reuse of a slot before we have made at least a single

compiler-rt/lib/gwp_asan/options.inc

 #define GWP_ASAN_STRINGIFY(S) GWP_ASAN_STRINGIFY_(S)
 #define GWP_ASAN_STRINGIFY_(S) #S
 #endif
 
 GWP_ASAN_OPTION(bool, Enabled, GWP_ASAN_DEFAULT_ENABLED,
                 "Is GWP-ASan enabled? Defaults to " GWP_ASAN_STRINGIFY(
                     GWP_ASAN_DEFAULT_ENABLED) ".")
 
-GWP_ASAN_OPTION(
-    bool, PerfectlyRightAlign, false,
-    "When allocations are right-aligned, should we perfectly align them up to "
-    "the page boundary? By default (false), we round up allocation size to the "
-    "nearest power of two (1, 2, 4, 8, 16) up to a maximum of 16-byte "
-    "alignment for performance reasons. For Bionic, we use 8-byte alignment by "
-    "default. Setting this to true can find single byte buffer-overflows for "
-    "multibyte allocations at the cost of performance, and may be incompatible "
-    "with some architectures.")
-
 GWP_ASAN_OPTION(int, MaxSimultaneousAllocations, 16,
                 "Number of simultaneously-guarded allocations available in the "
                 "pool. Defaults to 16.")
 
 GWP_ASAN_OPTION(int, SampleRate, 5000,
                 "The probability (1 / SampleRate) that an allocation is "
                 "selected for GWP-ASan sampling. Default is 5000. Sample rates "
                 "up to (2^30 - 1) are supported.")

compiler-rt/lib/gwp_asan/tests/alignment.cpp

 //===-- alignment.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 "gwp_asan/guarded_pool_allocator.h"
 #include "gwp_asan/tests/harness.h"
-#include "gwp_asan/utilities.h"
 
-#include <vector>
-
-TEST(AlignmentTest, PowerOfTwo) {
-  std::vector<std::pair<size_t, size_t>> AskedSizeToAlignedSize = {
-      {1, 1},   {2, 2},   {3, 4},       {4, 4},       {5, 8},   {7, 8},
-      {8, 8},   {9, 16},  {15, 16},     {16, 16},     {17, 32}, {31, 32},
-      {32, 32}, {33, 48}, {4095, 4096}, {4096, 4096},
-  };
-
-  for (const auto &KV : AskedSizeToAlignedSize) {
-    EXPECT_EQ(KV.second,
-              gwp_asan::rightAlignedAllocationSize(
-                  KV.first, gwp_asan::AlignmentStrategy::POWER_OF_TWO));
+class AlignmentTestGPA : public gwp_asan::GuardedPoolAllocator {
+public:
+  static size_t getRequiredBackingSize(size_t Size, size_t Alignment,
+                                       size_t PageSize) {
+    return GuardedPoolAllocator::getRequiredBackingSize(Size, Alignment,
+                                                        PageSize);
+  }
+  static uintptr_t getAlignedPtr(uintptr_t Ptr, size_t Alignment,
+                                 bool IsRightAligned) {
+    return GuardedPoolAllocator::getAlignedPtr(Ptr, Alignment, IsRightAligned);
   }
-}
-
-TEST(AlignmentTest, AlignBionic) {
-  std::vector<std::pair<size_t, size_t>> AskedSizeToAlignedSize = {
-      {1, 8},   {2, 8},   {3, 8},       {4, 8},       {5, 8},   {7, 8},
-      {8, 8},   {9, 16},  {15, 16},     {16, 16},     {17, 24}, {31, 32},
-      {32, 32}, {33, 40}, {4095, 4096}, {4096, 4096},
-  };
 
-  for (const auto &KV : AskedSizeToAlignedSize) {
-    EXPECT_EQ(KV.second, gwp_asan::rightAlignedAllocationSize(
-                             KV.first, gwp_asan::AlignmentStrategy::BIONIC));
-  }
-}
+// Assume 4KiB pages across all these tests.
+constexpr size_t kPageSize = 0x1000;
 
-TEST(AlignmentTest, PerfectAlignment) {
-  for (size_t i = 1; i <= 4096; ++i) {
-    EXPECT_EQ(i, gwp_asan::rightAlignedAllocationSize(
-                     i, gwp_asan::AlignmentStrategy::PERFECT));
-  }
+TEST(AlignmentTest, PointerAlignment) {
+
+  EXPECT_EQ(0x1000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x1000, /* Alignment */ 0x1,
+                        /* IsRightAligned */ false));
+  EXPECT_EQ(0x1000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x1000, /* Alignment */ 0x1000,
+                        /* IsRightAligned */ false));
+
+  EXPECT_EQ(0x1000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x1000, /* Alignment */ 0x1,
+                        /* IsRightAligned */ true));
+  EXPECT_EQ(0x1000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x1000, /* Alignment */ 0x1000,
+                        /* IsRightAligned */ false));
+
+  EXPECT_EQ(0x2000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x3000, /* Alignment */ 0x2000,
+                        /* IsRightAligned */ true));
+  EXPECT_EQ(0x4000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x3000, /* Alignment */ 0x2000,
+                        /* IsRightAligned */ false));
+
+  EXPECT_EQ(0x3000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x3000, /* Alignment */ 0x800,
+                        /* IsRightAligned */ true));
+  EXPECT_EQ(0x3000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x3000, /* Alignment */ 0x800,
+                        /* IsRightAligned */ false));
+
+  EXPECT_EQ(0x3000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x3137, /* Alignment */ 0x1000,
+                        /* IsRightAligned */ true));
+  EXPECT_EQ(0x4000, AlignmentTestGPA::getAlignedPtr(
+                        /* Ptr */ 0x3137, /* Alignment */ 0x1000,
+                        /* IsRightAligned */ false));
+}
+
+TEST(AlignmentTest, RequiredBackingSize) {
+  EXPECT_EQ(kPageSize, AlignmentTestGPA::getRequiredBackingSize(
+                           /* Size */ 1, /* Alignment */ kPageSize, kPageSize));
+  EXPECT_EQ(kPageSize,
+            AlignmentTestGPA::getRequiredBackingSize(
+                /* Size */ 1337, /* Alignment */ kPageSize, kPageSize));
+  EXPECT_EQ(kPageSize,
+            AlignmentTestGPA::getRequiredBackingSize(
+                /* Size */ kPageSize, /* Alignment */ kPageSize, kPageSize));
+
+  EXPECT_EQ(kPageSize, AlignmentTestGPA::getRequiredBackingSize(
+                           /* Size */ kPageSize, /* Alignment */ 1, kPageSize));
+  EXPECT_EQ(kPageSize * 2 + 1,
+            AlignmentTestGPA::getRequiredBackingSize(
+                /* Size */ 1, /* Alignment */ kPageSize * 2, kPageSize));
+  EXPECT_EQ(kPageSize * 2, AlignmentTestGPA::getRequiredBackingSize(
+                               /* Size */ kPageSize * 2,
+                               /* Alignment */ kPageSize, kPageSize));
+
+  EXPECT_EQ(kPageSize * 2, AlignmentTestGPA::getRequiredBackingSize(
+                               /* Size */ kPageSize + 1,
+                               /* Alignment */ kPageSize, kPageSize));
 }

compiler-rt/lib/gwp_asan/tests/backtrace.cpp

 //===-- backtrace.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 <string>
 
 #include "gwp_asan/common.h"
 #include "gwp_asan/crash_handler.h"
 #include "gwp_asan/tests/harness.h"
 
 // Optnone to ensure that the calls to these functions are not optimized away,
 // as we're looking for them in the backtraces.
 __attribute((optnone)) void *
TEST_F(BacktraceGuardedPoolAllocator, DoubleFree) {
   DeathRegex.append("was allocated.*");
   DeathRegex.append("AllocateMemory.*");
   ASSERT_DEATH(DeallocateMemory2(GPA, Ptr), DeathRegex);
 }
 
 TEST_F(BacktraceGuardedPoolAllocator, UseAfterFree) {
   void *Ptr = AllocateMemory(GPA);
   DeallocateMemory(GPA, Ptr);
+  std::cerr << "Got ptr: " << Ptr << "\n";
 
   std::string DeathRegex = "Use After Free.*";
   DeathRegex.append("TouchMemory.*");
 
   DeathRegex.append("was deallocated.*");
   DeathRegex.append("DeallocateMemory.*");
 
   DeathRegex.append("was allocated.*");

compiler-rt/lib/gwp_asan/tests/basic.cpp

for (unsigned AllocSize = 1; AllocSize <= MaxAllocSize; AllocSize <<= 1) {
     EXPECT_EQ(AllocSize, GPA.getSize(Ptr));
     GPA.deallocate(Ptr);
   }
 }
 
 TEST_F(DefaultGuardedPoolAllocator, TooLargeAllocation) {
   EXPECT_EQ(nullptr,
             GPA.allocate(GPA.getAllocatorState()->maximumAllocationSize() + 1));
+  EXPECT_EQ(nullptr, GPA.allocate(SIZE_MAX, 0));
+  EXPECT_EQ(nullptr, GPA.allocate(SIZE_MAX, 1));
+  EXPECT_EQ(nullptr, GPA.allocate(0, SIZE_MAX / 2));
+  EXPECT_EQ(nullptr, GPA.allocate(1, SIZE_MAX / 2));
+  EXPECT_EQ(nullptr, GPA.allocate(SIZE_MAX, SIZE_MAX / 2));
+}
+
+TEST_F(DefaultGuardedPoolAllocator, ZeroSizeAndAlignmentAllocations) {
+  void *P;
+  EXPECT_NE(nullptr, (P = GPA.allocate(0, 0)));
+  GPA.deallocate(P);
+  EXPECT_NE(nullptr, (P = GPA.allocate(1, 0)));
+  GPA.deallocate(P);
+  EXPECT_NE(nullptr, (P = GPA.allocate(0, 1)));
+  GPA.deallocate(P);
+}
+
+TEST_F(DefaultGuardedPoolAllocator, NonPowerOfTwoAlignment) {
+  EXPECT_EQ(nullptr, GPA.allocate(0, 3));
+  EXPECT_EQ(nullptr, GPA.allocate(1, 3));
+  EXPECT_EQ(nullptr, GPA.allocate(0, SIZE_MAX));
+  EXPECT_EQ(nullptr, GPA.allocate(1, SIZE_MAX));
 }
 
 TEST_F(CustomGuardedPoolAllocator, AllocAllSlots) {
   constexpr unsigned kNumSlots = 128;
   InitNumSlots(kNumSlots);
   void *Ptrs[kNumSlots];
   for (unsigned i = 0; i < kNumSlots; ++i) {
     Ptrs[i] = GPA.allocate(1);

compiler-rt/lib/gwp_asan/tests/crash_handler_api.cpp

protected:
   size_t metadata(uintptr_t Addr, uintptr_t Size, bool IsDeallocated) {
     // Should only be allocating the 0x3000, 0x5000, 0x7000, 0x9000 pages.
     EXPECT_GE(Addr, 0x3000u);
     EXPECT_LT(Addr, 0xa000u);
 
     size_t Slot = State.getNearestSlot(Addr);
 
     Metadata[Slot].Addr = Addr;
-    Metadata[Slot].Size = Size;
+    Metadata[Slot].RequestedSize = Size;
     Metadata[Slot].IsDeallocated = IsDeallocated;
     Metadata[Slot].AllocationTrace.ThreadID = 123;
     Metadata[Slot].DeallocationTrace.ThreadID = 321;
     setupBacktraces(&Metadata[Slot]);
 
     return Slot;
   }
 
void checkBacktrace(const AllocationMetadata *Meta, bool IsDeallocated) {
     }
   }
 
   void checkMetadata(size_t Index, uintptr_t ErrorPtr) {
     const AllocationMetadata *Meta =
         __gwp_asan_get_metadata(&State, Metadata, ErrorPtr);
     EXPECT_NE(nullptr, Meta);
     EXPECT_EQ(Metadata[Index].Addr, __gwp_asan_get_allocation_address(Meta));
-    EXPECT_EQ(Metadata[Index].Size, __gwp_asan_get_allocation_size(Meta));
+    EXPECT_EQ(Metadata[Index].RequestedSize,
+              __gwp_asan_get_allocation_size(Meta));
     EXPECT_EQ(Metadata[Index].AllocationTrace.ThreadID,
               __gwp_asan_get_allocation_thread_id(Meta));
 
     bool IsDeallocated = __gwp_asan_is_deallocated(Meta);
     EXPECT_EQ(Metadata[Index].IsDeallocated, IsDeallocated);
     checkBacktrace(Meta, IsDeallocated);
 
     if (!IsDeallocated)

compiler-rt/lib/gwp_asan/utilities.h

 void die(const char *Message);
 
 // Checks that `Condition` is true, otherwise dies with `Message`.
 GWP_ASAN_ALWAYS_INLINE void Check(bool Condition, const char *Message) {
   if (Condition)
     return;
   die(Message);
 }
-
-enum class AlignmentStrategy {
-  // Default => POWER_OF_TWO on most platforms, BIONIC for Android Bionic.
-  DEFAULT,
-  POWER_OF_TWO,
-  BIONIC,
-  PERFECT,
-};
-
-// Returns the real size of a right-aligned allocation.
-size_t rightAlignedAllocationSize(
-    size_t RealAllocationSize,
-    AlignmentStrategy Align = AlignmentStrategy::DEFAULT);
 } // namespace gwp_asan
 
 #endif // GWP_ASAN_UTILITIES_H_

compiler-rt/lib/gwp_asan/utilities.cpp

-//===-- utilities.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 "gwp_asan/utilities.h"
-
-#include <assert.h>
-
-namespace gwp_asan {
-// See `bionic/tests/malloc_test.cpp` in the Android source for documentation
-// regarding their alignment guarantees. We always round up to the closest
-// 8-byte window. As GWP-ASan's malloc(X) can always get exactly an X-sized
-// allocation, an allocation that rounds up to 16-bytes will always be given a
-// 16-byte aligned allocation.
-static size_t alignBionic(size_t RealAllocationSize) {
-  if (RealAllocationSize % 8 == 0)
-    return RealAllocationSize;
-  return RealAllocationSize + 8 - (RealAllocationSize % 8);
-}
-
-static size_t alignPowerOfTwo(size_t RealAllocationSize) {
-  if (RealAllocationSize <= 2)
-    return RealAllocationSize;
-  if (RealAllocationSize <= 4)
-    return 4;
-  if (RealAllocationSize <= 8)
-    return 8;
-  if (RealAllocationSize % 16 == 0)
-    return RealAllocationSize;
-  return RealAllocationSize + 16 - (RealAllocationSize % 16);
-}
-
-#ifdef __BIONIC__
-static constexpr AlignmentStrategy PlatformDefaultAlignment =
-    AlignmentStrategy::BIONIC;
-#else  // __BIONIC__
-static constexpr AlignmentStrategy PlatformDefaultAlignment =
-    AlignmentStrategy::POWER_OF_TWO;
-#endif // __BIONIC__
-
-size_t rightAlignedAllocationSize(size_t RealAllocationSize,
-                                  AlignmentStrategy Align) {
-  assert(RealAllocationSize > 0);
-  if (Align == AlignmentStrategy::DEFAULT)
-    Align = PlatformDefaultAlignment;
-
-  switch (Align) {
-  case AlignmentStrategy::BIONIC:
-    return alignBionic(RealAllocationSize);
-  case AlignmentStrategy::POWER_OF_TWO:
-    return alignPowerOfTwo(RealAllocationSize);
-  case AlignmentStrategy::PERFECT:
-    return RealAllocationSize;
-  case AlignmentStrategy::DEFAULT:
-    __builtin_unreachable();
-  }
-  __builtin_unreachable();
-}
-} // namespace gwp_asan

compiler-rt/lib/scudo/scudo_allocator.cpp

struct Allocator {
 
   NOINLINE bool isRssLimitExceeded();
 
   // Allocates a chunk.
   void *allocate(uptr Size, uptr Alignment, AllocType Type,
                  bool ForceZeroContents = false) {
     initThreadMaybe();
 
+    if (UNLIKELY(Alignment > MaxAlignment)) {
+      if (AllocatorMayReturnNull())
+        return nullptr;
+      reportAllocationAlignmentTooBig(Alignment, MaxAlignment);
+    }
+
 #ifdef GWP_ASAN_HOOKS
     if (UNLIKELY(GuardedAlloc.shouldSample())) {
-      if (void *Ptr = GuardedAlloc.allocate(Size))
+      if (void *Ptr = GuardedAlloc.allocate(Size, Alignment)) {
+        if (SCUDO_CAN_USE_HOOKS && &__sanitizer_malloc_hook)
+          __sanitizer_malloc_hook(Ptr, Size);
+
         return Ptr;
       }
+    }
 #endif // GWP_ASAN_HOOKS
 
-    if (UNLIKELY(Alignment > MaxAlignment)) {
-      if (AllocatorMayReturnNull())
-        return nullptr;
-      reportAllocationAlignmentTooBig(Alignment, MaxAlignment);
-    }
     if (UNLIKELY(Alignment < MinAlignment))
       Alignment = MinAlignment;
 
     const uptr NeededSize = RoundUpTo(Size ? Size : 1, MinAlignment) +
         Chunk::getHeaderSize();
     const uptr AlignedSize = (Alignment > MinAlignment) ?
         NeededSize + (Alignment - Chunk::getHeaderSize()) : NeededSize;
     if (UNLIKELY(Size >= MaxAllowedMallocSize) ||
         UNLIKELY(AlignedSize >= MaxAllowedMallocSize)) {
       if (AllocatorMayReturnNull())
         return nullptr;
       reportAllocationSizeTooBig(Size, AlignedSize, MaxAllowedMallocSize);
     }
 
     if (CheckRssLimit && UNLIKELY(isRssLimitExceeded())) {
       if (AllocatorMayReturnNull())
         return nullptr;
       reportRssLimitExceeded();
     }

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

#endif
 
   NOINLINE void *allocate(uptr Size, Chunk::Origin Origin,
                           uptr Alignment = MinAlignment,
                           bool ZeroContents = false) {
     initThreadMaybe();
 
 #ifdef GWP_ASAN_HOOKS
     if (UNLIKELY(GuardedAlloc.shouldSample())) {
-      if (void *Ptr = GuardedAlloc.allocate(roundUpTo(Size, Alignment)))
+      if (void *Ptr = GuardedAlloc.allocate(Size, Alignment)) {
+        if (UNLIKELY(&__scudo_allocate_hook))
+          __scudo_allocate_hook(Ptr, Size);
+        Stats.add(StatAllocated, Size);
         return Ptr;
       }
+    }
 #endif // GWP_ASAN_HOOKS
 
     const Options Options = Primary.Options.load();
     const FillContentsMode FillContents = ZeroContents ? ZeroFill
                                           : TSDRegistry.getDisableMemInit()
                                               ? NoFill
                                               : Options.getFillContentsMode();
 
NOINLINE void deallocate(void *Ptr, Chunk::Origin Origin, uptr DeleteSize = 0,
     // For a deallocation, we only ensure minimal initialization, meaning thread
     // local data will be left uninitialized for now (when using ELF TLS). The
     // fallback cache will be used instead. This is a workaround for a situation
     // where the only heap operation performed in a thread would be a free past
     // the TLS destructors, ending up in initialized thread specific data never
     // being destroyed properly. Any other heap operation will do a full init.
     initThreadMaybe(/*MinimalInit=*/true);
 
+    if (UNLIKELY(&__scudo_deallocate_hook))
+      __scudo_deallocate_hook(Ptr);
+
+    if (UNLIKELY(!Ptr))
+      return;
+
 #ifdef GWP_ASAN_HOOKS
     if (UNLIKELY(GuardedAlloc.pointerIsMine(Ptr))) {
       GuardedAlloc.deallocate(Ptr);
+      Stats.add(StatFree, GuardedAlloc.getSize(Ptr));
       return;
     }
 #endif // GWP_ASAN_HOOKS
 
-    if (UNLIKELY(&__scudo_deallocate_hook))
-      __scudo_deallocate_hook(Ptr);
-
-    if (UNLIKELY(!Ptr))
-      return;
     if (UNLIKELY(!isAligned(reinterpret_cast<uptr>(Ptr), MinAlignment)))
       reportMisalignedPointer(AllocatorAction::Deallocating, Ptr);
 
     Ptr = untagPointerMaybe(Ptr);
 
     Chunk::UnpackedHeader Header;
     Chunk::loadHeader(Cookie, Ptr, &Header);
 

 
 #ifdef GWP_ASAN_HOOKS
     if (UNLIKELY(GuardedAlloc.pointerIsMine(OldPtr))) {
       uptr OldSize = GuardedAlloc.getSize(OldPtr);
       void *NewPtr = allocate(NewSize, Chunk::Origin::Malloc, Alignment);
       if (NewPtr)
         memcpy(NewPtr, OldPtr, (NewSize < OldSize) ? NewSize : OldSize);
       GuardedAlloc.deallocate(OldPtr);
+      Stats.add(StatFree, OldSize);
       return NewPtr;
     }
 #endif // GWP_ASAN_HOOKS
 
     if (UNLIKELY(!isAligned(reinterpret_cast<uptr>(OldPtr), MinAlignment)))
       reportMisalignedPointer(AllocatorAction::Reallocating, OldPtr);
 
     Chunk::UnpackedHeader OldHeader;

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

TEST(ScudoWrappersCTest, Calloc) {
   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) {
+  void *P;
+  for (size_t Size = 1; Size <= 0x10000; Size <<= 1) {
+    for (size_t Align = 1; Align <= 0x10000; Align <<= 1) {
+      for (size_t Count = 0; Count < 3; ++Count) {
+        P = memalign(Align, Size);
+        EXPECT_TRUE(reinterpret_cast<uintptr_t>(P) % Align == 0);
+      }
+    }
+  }
+}
+
 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));