[Alignment][NFC] Move and type functions from MathExtras to Alignment

[gchatelet]

Summary

This is patch is part of a series to introduce an Alignment type.
See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2019-July/133851.html
See this patch for the introduction of the type: https://reviews.llvm.org/D64790

[courbet]

Please rename commit to [Alignment][NFC] Move and type functions from MathExtra to Alignment

[courbet]

llvm/unittests/Support/AlignmentTest.cpp

216

Add comment: // A value of any integral or enumeration type can be converted to a pointer type.

I had to check to verify that this was legal.

[gchatelet]

• Address comments

[hans]

llvm/include/llvm/Support/Alignment.h

176

Because Alignment.value() is a uint64_t, this won't catch overflows when addresses are 32 bits.

This breaks the AlignmentDeathTest.AlignAddr test on 32-bit Windows, for example. And also here: http://lab.llvm.org:8011/builders/clang-cmake-armv7-quick/builds/10957

Hopefully r375090 fixes this, but maybe it would be better for Alignment::value() not to be 64-bit for example.

[gchatelet]

llvm/include/llvm/Support/Alignment.h

176

Thx for reporting this and for fixing it @hans.

llvm/include/llvm/Support/Alignment.h

 
 /// Checks that SizeInBytes is a multiple of the alignment.
 /// Returns false if the alignment is undefined.
 inline bool isAligned(MaybeAlign Lhs, uint64_t SizeInBytes) {
   ALIGN_CHECK_ISSET(Lhs);
   return SizeInBytes % (*Lhs).value() == 0;
 }
 
+/// Checks that Addr is a multiple of the alignment.
+inline bool isAddrAligned(Align Lhs, const void *Addr) {
+  return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr));
+}
+
 /// Returns a multiple of A needed to store `Size` bytes.
 inline uint64_t alignTo(uint64_t Size, Align A) {
   return (Size + A.value() - 1) / A.value() * A.value();
 }
 
 /// Returns a multiple of A needed to store `Size` bytes.
 /// Returns `Size` if current alignment is undefined.
 inline uint64_t alignTo(uint64_t Size, MaybeAlign A) {
   return A ? alignTo(Size, A.getValue()) : Size;
 }
 
+/// Aligns `Addr` to `Alignment` bytes, rounding up.
+inline uintptr_t alignAddr(const void *Addr, Align Alignment) {
+  uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr);
+  assert(ArithAddr + Alignment.value() - 1 >= ArithAddr && "Overflow");
+  return alignTo(ArithAddr, Alignment);
+}
+
 /// Returns the offset to the next integer (mod 2**64) that is greater than
 /// or equal to \p Value and is a multiple of \p Align.
 inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) {
   return alignTo(Value, Alignment) - Value;
 }
 
+/// Returns the necessary adjustment for aligning `Addr` to `Alignment`
+/// bytes, rounding up.
+inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) {
+  return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment);
+}
+
 /// Returns the log2 of the alignment.
 inline unsigned Log2(Align A) { return A.ShiftValue; }
 
 /// Returns the log2 of the alignment.
 /// \pre A must be defined.
 inline unsigned Log2(MaybeAlign A) {
   ALIGN_CHECK_ISSET(A);
   return Log2(A.getValue());

llvm/include/llvm/Support/Allocator.h

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ALLOCATOR_H
 #define LLVM_SUPPORT_ALLOCATOR_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemAlloc.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
void Reset() {
 
     __asan_poison_memory_region(*Slabs.begin(), computeSlabSize(0));
     DeallocateSlabs(std::next(Slabs.begin()), Slabs.end());
     Slabs.erase(std::next(Slabs.begin()), Slabs.end());
   }
 
   /// Allocate space at the specified alignment.
   LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
-  Allocate(size_t Size, size_t Alignment) {
-    assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead.");
-
+  Allocate(size_t Size, Align Alignment) {
     // Keep track of how many bytes we've allocated.
     BytesAllocated += Size;
 
-    size_t Adjustment = alignmentAdjustment(CurPtr, Alignment);
+    size_t Adjustment = offsetToAlignedAddr(CurPtr, Alignment);
     assert(Adjustment + Size >= Size && "Adjustment + Size must not overflow");
 
     size_t SizeToAllocate = Size;
 #if LLVM_ADDRESS_SANITIZER_BUILD
     // Add trailing bytes as a "red zone" under ASan.
     SizeToAllocate += RedZoneSize;
 #endif
 
     // Check if we have enough space.
     if (Adjustment + SizeToAllocate <= size_t(End - CurPtr)) {
       char *AlignedPtr = CurPtr + Adjustment;
       CurPtr = AlignedPtr + SizeToAllocate;
       // Update the allocation point of this memory block in MemorySanitizer.
       // Without this, MemorySanitizer messages for values originated from here
       // will point to the allocation of the entire slab.
       __msan_allocated_memory(AlignedPtr, Size);
       // Similarly, tell ASan about this space.
       __asan_unpoison_memory_region(AlignedPtr, Size);
       return AlignedPtr;
     }
 
     // If Size is really big, allocate a separate slab for it.
-    size_t PaddedSize = SizeToAllocate + Alignment - 1;
+    size_t PaddedSize = SizeToAllocate + Alignment.value() - 1;
     if (PaddedSize > SizeThreshold) {
       void *NewSlab = Allocator.Allocate(PaddedSize, 0);
       // We own the new slab and don't want anyone reading anyting other than
       // pieces returned from this method.  So poison the whole slab.
       __asan_poison_memory_region(NewSlab, PaddedSize);
       CustomSizedSlabs.push_back(std::make_pair(NewSlab, PaddedSize));
 
       uintptr_t AlignedAddr = alignAddr(NewSlab, Alignment);
assert(AlignedAddr + SizeToAllocate <= (uintptr_t)End &&
            "Unable to allocate memory!");
     char *AlignedPtr = (char*)AlignedAddr;
     CurPtr = AlignedPtr + SizeToAllocate;
     __msan_allocated_memory(AlignedPtr, Size);
     __asan_unpoison_memory_region(AlignedPtr, Size);
     return AlignedPtr;
   }
 
+  inline LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
+  Allocate(size_t Size, size_t Alignment) {
+    assert(Alignment > 0 && "0-byte alignnment is not allowed. Use 1 instead.");
+    return Allocate(Size, Align(Alignment));
+  }
+
   // Pull in base class overloads.
   using AllocatorBase<BumpPtrAllocatorImpl>::Allocate;
 
   // Bump pointer allocators are expected to never free their storage; and
   // clients expect pointers to remain valid for non-dereferencing uses even
   // after deallocation.
   void Deallocate(const void *Ptr, size_t Size) {
     __asan_poison_memory_region(Ptr, Size);
SpecificBumpPtrAllocator &operator=(SpecificBumpPtrAllocator &&RHS) {
     return *this;
   }
 
   /// Call the destructor of each allocated object and deallocate all but the
   /// current slab and reset the current pointer to the beginning of it, freeing
   /// all memory allocated so far.
   void DestroyAll() {
     auto DestroyElements = [](char *Begin, char *End) {
-      assert(Begin == (char *)alignAddr(Begin, alignof(T)));
+      assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()));
       for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
         reinterpret_cast<T *>(Ptr)->~T();
     };
 
     for (auto I = Allocator.Slabs.begin(), E = Allocator.Slabs.end(); I != E;
          ++I) {
       size_t AllocatedSlabSize = BumpPtrAllocator::computeSlabSize(
           std::distance(Allocator.Slabs.begin(), I));
-      char *Begin = (char *)alignAddr(*I, alignof(T));
+      char *Begin = (char *)alignAddr(*I, Align::Of<T>());
       char *End = *I == Allocator.Slabs.back() ? Allocator.CurPtr
                                                : (char *)*I + AllocatedSlabSize;
 
       DestroyElements(Begin, End);
     }
 
     for (auto &PtrAndSize : Allocator.CustomSizedSlabs) {
       void *Ptr = PtrAndSize.first;
       size_t Size = PtrAndSize.second;
-      DestroyElements((char *)alignAddr(Ptr, alignof(T)), (char *)Ptr + Size);
+      DestroyElements((char *)alignAddr(Ptr, Align::Of<T>()),
+                      (char *)Ptr + Size);
     }
 
     Allocator.Reset();
   }
 
   /// Allocate space for an array of objects without constructing them.
   T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
 };

llvm/include/llvm/Support/BinaryStreamArray.h

const T &operator[](uint32_t Index) const {
     uint32_t Off = Index * sizeof(T);
     ArrayRef<uint8_t> Data;
     if (auto EC = Stream.readBytes(Off, sizeof(T), Data)) {
       assert(false && "Unexpected failure reading from stream");
       // This should never happen since we asserted that the stream length was
       // an exact multiple of the element size.
       consumeError(std::move(EC));
     }
-    assert(llvm::alignmentAdjustment(Data.data(), alignof(T)) == 0);
+    assert(isAddrAligned(Align::Of<T>(), Data.data()));
     return *reinterpret_cast<const T *>(Data.data());
   }
 
   uint32_t size() const { return Stream.getLength() / sizeof(T); }
 
   bool empty() const { return size() == 0; }
 
   FixedStreamArrayIterator<T> begin() const {

llvm/include/llvm/Support/BinaryStreamReader.h

Error readArray(ArrayRef<T> &Array, uint32_t NumElements) {
 
     if (NumElements > UINT32_MAX / sizeof(T))
       return make_error<BinaryStreamError>(
           stream_error_code::invalid_array_size);
 
     if (auto EC = readBytes(Bytes, NumElements * sizeof(T)))
       return EC;
 
-    assert(alignmentAdjustment(Bytes.data(), alignof(T)) == 0 &&
+    assert(isAddrAligned(Align::Of<T>(), Bytes.data()) &&
            "Reading at invalid alignment!");
 
     Array = ArrayRef<T>(reinterpret_cast<const T *>(Bytes.data()), NumElements);
     return Error::success();
   }
 
   /// Read a VarStreamArray of size \p Size bytes and store the result into
   /// \p Array.  Updates the stream's offset to point after the newly read

llvm/include/llvm/Support/MathExtras.h

constexpr inline uint64_t MinAlign(uint64_t A, uint64_t B) {
   // The largest power of 2 that divides both A and B.
   //
   // Replace "-Value" by "1+~Value" in the following commented code to avoid
   // MSVC warning C4146
   //    return (A | B) & -(A | B);
   return (A | B) & (1 + ~(A | B));
 }
 
-/// Aligns \c Addr to \c Alignment bytes, rounding up.
-///
-/// Alignment should be a power of two.  This method rounds up, so
-/// alignAddr(7, 4) == 8 and alignAddr(8, 4) == 8.
-inline uintptr_t alignAddr(const void *Addr, size_t Alignment) {
-  assert(Alignment && isPowerOf2_64((uint64_t)Alignment) &&
-         "Alignment is not a power of two!");
-
-  assert((uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr);
-
-  return (((uintptr_t)Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1));
-}
-
-/// Returns the necessary adjustment for aligning \c Ptr to \c Alignment
-/// bytes, rounding up.
-inline size_t alignmentAdjustment(const void *Ptr, size_t Alignment) {
-  return alignAddr(Ptr, Alignment) - (uintptr_t)Ptr;
-}
-
 /// Returns the next power of two (in 64-bits) that is strictly greater than A.
 /// Returns zero on overflow.
 inline uint64_t NextPowerOf2(uint64_t A) {
   A |= (A >> 1);
   A |= (A >> 2);
   A |= (A >> 4);
   A |= (A >> 8);
   A |= (A >> 16);

llvm/include/llvm/Support/TrailingObjects.h

 /// (thus, private inheritance is suggested).
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_TRAILINGOBJECTS_H
 #define LLVM_SUPPORT_TRAILINGOBJECTS_H
 
 #include "llvm/Support/AlignOf.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/type_traits.h"
 #include <new>
 #include <type_traits>
 
 namespace llvm {
 
getTrailingObjectsImpl(const BaseTy *Obj,
                          TrailingObjectsBase::OverloadToken<NextTy>) {
     auto *Ptr = TopTrailingObj::getTrailingObjectsImpl(
                     Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
                 TopTrailingObj::callNumTrailingObjects(
                     Obj, TrailingObjectsBase::OverloadToken<PrevTy>());
 
     if (requiresRealignment())
       return reinterpret_cast<const NextTy *>(
-          llvm::alignAddr(Ptr, alignof(NextTy)));
+          alignAddr(Ptr, Align::Of<NextTy>()));
     else
       return reinterpret_cast<const NextTy *>(Ptr);
   }
 
   static NextTy *
   getTrailingObjectsImpl(BaseTy *Obj,
                          TrailingObjectsBase::OverloadToken<NextTy>) {
     auto *Ptr = TopTrailingObj::getTrailingObjectsImpl(
                     Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
                 TopTrailingObj::callNumTrailingObjects(
                     Obj, TrailingObjectsBase::OverloadToken<PrevTy>());
 
     if (requiresRealignment())
-      return reinterpret_cast<NextTy *>(llvm::alignAddr(Ptr, alignof(NextTy)));
+      return reinterpret_cast<NextTy *>(alignAddr(Ptr, Align::Of<NextTy>()));
     else
       return reinterpret_cast<NextTy *>(Ptr);
   }
 
   // Helper function for TrailingObjects::additionalSizeToAlloc: this
   // function recurses to superclasses, each of which requires one
   // fewer size_t argument, and adds its own size.
   static constexpr size_t additionalSizeToAllocImpl(

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

Expected<const char *> readFunctionRecords(const char *Buf,
     const char *CovBuf = Buf;
     Buf += CoverageSize;
     const char *CovEnd = Buf;
 
     if (Buf > End)
       return make_error<CoverageMapError>(coveragemap_error::malformed);
     // Each coverage map has an alignment of 8, so we need to adjust alignment
     // before reading the next map.
-    Buf += alignmentAdjustment(Buf, 8);
+    Buf += offsetToAlignedAddr(Buf, Align(8));
 
     auto CFR = reinterpret_cast<const FuncRecordType *>(FunBuf);
     while ((const char *)CFR < FunEnd) {
       // Read the function information
       uint32_t DataSize = CFR->template getDataSize<Endian>();
 
       // Now use that to read the coverage data.
       if (CovBuf + DataSize > CovEnd)
if (Data.size() < ProfileNamesSize)
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   InstrProfSymtab ProfileNames;
   if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address))
     return std::move(E);
   StringRef CoverageMapping = Data.substr(ProfileNamesSize);
   // Skip the padding bytes because coverage map data has an alignment of 8.
   if (CoverageMapping.empty())
     return make_error<CoverageMapError>(coveragemap_error::truncated);
-  size_t Pad = alignmentAdjustment(CoverageMapping.data(), 8);
+  size_t Pad = offsetToAlignedAddr(CoverageMapping.data(), Align(8));
   if (CoverageMapping.size() < Pad)
     return make_error<CoverageMapError>(coveragemap_error::malformed);
   CoverageMapping = CoverageMapping.substr(Pad);
   return BinaryCoverageReader::createCoverageReaderFromBuffer(
       CoverageMapping, std::move(ProfileNames), BytesInAddress, Endian);
 }
 
 static Expected<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) {

llvm/lib/Support/Unix/Memory.inc

Memory::releaseMappedMemory(MemoryBlock &M) {
   M.Address = nullptr;
   M.AllocatedSize = 0;
 
   return std::error_code();
 }
 
 std::error_code
 Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
-  static const size_t PageSize = Process::getPageSizeEstimate();
+  static const Align PageSize = Align(Process::getPageSizeEstimate());
   if (M.Address == nullptr || M.AllocatedSize == 0)
     return std::error_code();
 
   if (!Flags)
     return std::error_code(EINVAL, std::generic_category());
 
   int Protect = getPosixProtectionFlags(Flags);
-  uintptr_t Start = alignAddr((uint8_t *)M.Address - PageSize + 1, PageSize);
-  uintptr_t End = alignAddr((uint8_t *)M.Address + M.AllocatedSize, PageSize);
+  uintptr_t Start = alignAddr((const uint8_t *)M.Address - PageSize.value() + 1, PageSize);
+  uintptr_t End = alignAddr((const uint8_t *)M.Address + M.AllocatedSize, PageSize);
 
   bool InvalidateCache = (Flags & MF_EXEC);
 
 #if defined(__arm__) || defined(__aarch64__)
   // Certain ARM implementations treat icache clear instruction as a memory read,
   // and CPU segfaults on trying to clear cache on !PROT_READ page.  Therefore we need
   // to temporarily add PROT_READ for the sake of flushing the instruction caches.
   if (InvalidateCache && !(Protect & PROT_READ)) {

llvm/unittests/Support/AlignmentTest.cpp

TEST(AlignmentTest, Division) {
   EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0));
 }
 
 TEST(AlignmentTest, AlignTo) {
   struct {
     uint64_t alignment;
     uint64_t offset;
     uint64_t rounded;
+    const void *forgedAddr() const {
+      //  A value of any integral or enumeration type can be converted to a
+      //  pointer type.
+      return reinterpret_cast<const void *>(offset);
+    }
   } kTests[] = {
       // MaybeAlign
       {0, 0, 0},
       {0, 1, 1},
       {0, 5, 5},
       // MaybeAlign / Align
       {1, 0, 0},
       {1, 1, 1},
TEST(AlignmentTest, AlignTo) {
   };
   for (const auto &T : kTests) {
     MaybeAlign A(T.alignment);
     // Test MaybeAlign
     EXPECT_EQ(alignTo(T.offset, A), T.rounded);
     // Test Align
     if (A) {
       EXPECT_EQ(alignTo(T.offset, A.getValue()), T.rounded);
+      EXPECT_EQ(alignAddr(T.forgedAddr(), A.getValue()), T.rounded);
     }
   }
 }
 
 TEST(AlignmentTest, Log2) {
   for (uint64_t Value : getValidAlignments()) {
     EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
     EXPECT_EQ(Log2(MaybeAlign(Value)), Log2_64(Value));
for (uint64_t Value : getValidAlignments()) {
       EXPECT_EQ(Expected, Actual);
     }
   }
   MaybeAlign Actual(0);
   MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
   EXPECT_EQ(Expected, Actual);
 }
 
-TEST(AlignmentTest, isAligned) {
+TEST(AlignmentTest, isAligned_isAddrAligned) {
   struct {
     uint64_t alignment;
     uint64_t offset;
     bool isAligned;
+    const void *forgedAddr() const {
+      //  A value of any integral or enumeration type can be converted to a
+      //  pointer type.
+      return reinterpret_cast<const void *>(offset);
+    }
   } kTests[] = {
-      // MaybeAlign / Align
       {1, 0, true},  {1, 1, true},  {1, 5, true},  {2, 0, true},
       {2, 1, false}, {2, 2, true},  {2, 7, false}, {2, 16, true},
       {4, 0, true},  {4, 1, false}, {4, 4, true},  {4, 6, false},
   };
   for (const auto &T : kTests) {
     MaybeAlign A(T.alignment);
     // Test MaybeAlign
     EXPECT_EQ(isAligned(A, T.offset), T.isAligned);
     // Test Align
     if (A) {
       EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
+      EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned);
     }
   }
 }
 
+TEST(AlignmentTest, offsetToAlignment) {
+  struct {
+    uint64_t alignment;
+    uint64_t offset;
+    uint64_t alignedOffset;
+    const void *forgedAddr() const {
+      //  A value of any integral or enumeration type can be converted to a
+      //  pointer type.
+      return reinterpret_cast<const void *>(offset);
+    }
+  } kTests[] = {
+      {1, 0, 0}, {1, 1, 0},  {1, 5, 0}, {2, 0, 0}, {2, 1, 1}, {2, 2, 0},
+      {2, 7, 1}, {2, 16, 0}, {4, 0, 0}, {4, 1, 3}, {4, 4, 0}, {4, 6, 2},
+  };
+  for (const auto &T : kTests) {
+    const Align A(T.alignment);
+    EXPECT_EQ(offsetToAlignment(T.offset, A), T.alignedOffset);
+    EXPECT_EQ(offsetToAlignedAddr(T.forgedAddr(), A), T.alignedOffset);
+  }
+}
+
 TEST(AlignmentTest, AlignComparisons) {
   std::vector<uint64_t> ValidAlignments = getValidAlignments();
   std::sort(ValidAlignments.begin(), ValidAlignments.end());
   for (size_t I = 1; I < ValidAlignments.size(); ++I) {
     assert(I >= 1);
     const Align A(ValidAlignments[I - 1]);
     const Align B(ValidAlignments[I]);
     EXPECT_EQ(A, A);
for (uint64_t Value : getValidAlignmentsForDeathTest()) {
     EXPECT_DEATH((void)(Align(Value) != MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) >= MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) <= MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) > MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) < MaybeAlign(0)), ".* should be defined");
   }
 }
 
+TEST(AlignmentDeathTest, AlignAddr) {
+  const void *const unaligned_high_ptr =
+      reinterpret_cast<const void *>(std::numeric_limits<uintptr_t>::max() - 1);
+  EXPECT_DEATH(alignAddr(unaligned_high_ptr, Align(16)), "Overflow");
+}
+
 #endif // NDEBUG
 
 } // end anonymous namespace
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif

llvm/unittests/Support/AllocatorTest.cpp

class MockSlabAllocator {
   static size_t LastSlabSize;
 
 public:
   ~MockSlabAllocator() { }
 
   void *Allocate(size_t Size, size_t /*Alignment*/) {
     // Allocate space for the alignment, the slab, and a void* that goes right
     // before the slab.
-    size_t Alignment = 4096;
-    void *MemBase = safe_malloc(Size + Alignment - 1 + sizeof(void*));
+    Align Alignment(4096);
+    void *MemBase = safe_malloc(Size + Alignment.value() - 1 + sizeof(void *));
 
     // Find the slab start.
     void *Slab = (void *)alignAddr((char*)MemBase + sizeof(void *), Alignment);
 
     // Hold a pointer to the base so we can free the whole malloced block.
     ((void**)Slab)[-1] = MemBase;
 
     LastSlabSize = Size;

llvm/unittests/Support/TrailingObjectsTest.cpp

EXPECT_EQ(
       llvm::alignTo(Class4::totalSizeToAlloc<char, long>(1, 1),
                     alignof(Class4)));
 
   std::unique_ptr<char[]> P(new char[1000]);
   Class4 *C = reinterpret_cast<Class4 *>(P.get());
   EXPECT_EQ(C->getTrailingObjects<char>(), reinterpret_cast<char *>(C + 1));
   EXPECT_EQ(C->getTrailingObjects<long>(),
             reinterpret_cast<long *>(llvm::alignAddr(
-                reinterpret_cast<char *>(C + 1) + 1, alignof(long))));
+                reinterpret_cast<char *>(C + 1) + 1, Align::Of<long>())));
 }
 }
 
 // Test the use of TrailingObjects with a template class. This
 // previously failed to compile due to a bug in MSVC's member access
 // control/lookup handling for OverloadToken.
 template <typename Derived>
 class Class5Tmpl : private llvm::TrailingObjects<Derived, float, int> {