[Allocator] Add Deallocate support to the AllocatorBase CRTP class,

along with templated overloads much like we have for Allocate. These
will facilitate switching the Deallocate interface of all the Allocator
classes to accept the size by pre-filling it from the type size where we
can do so. I plan to convert several uses to the template variants in
subsequent patches prior to adding the Size parameter.

No functionality changed, WIP.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@206230 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Support/Allocator.h b/include/llvm/Support/Allocator.h
index 5eccbccbfc2b5c2b2407cc755397f9339c3b3581..4da7acefb68c2d5e97afc5cf76499d4840b90daf 100644 (file)
--- a/include/llvm/Support/Allocator.h
+++ b/include/llvm/Support/Allocator.h
@@ -61,6 +61,23 @@ public:
     return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
   }
 
+  /// \brief Deallocate \a Ptr to \a Size bytes of memory allocated by this
+  /// allocator.
+  void Deallocate(const void *Ptr) {
+#ifdef __clang__
+    static_assert(static_cast<void (AllocatorBase::*)(const void *)>(
+                      &AllocatorBase::Deallocate) !=
+                      static_cast<void (DerivedT::*)(const void *)>(
+                          &DerivedT::Deallocate),
+                  "Class derives from AllocatorBase without implementing the "
+                  "core Deallocate(void *) overload!");
+#endif
+    return static_cast<DerivedT *>(this)->Deallocate(Ptr);
+  }
+
+  // The rest of these methods are helpers that redirect to one of the above
+  // core methods.
+
   /// \brief Allocate space for one object without constructing it.
   template <typename T> T *Allocate() {
     return static_cast<T *>(Allocate(sizeof(T), AlignOf<T>::Alignment));
@@ -78,6 +95,16 @@ public:
     size_t EltSize = (sizeof(T) + Alignment - 1) & (-Alignment);
     return static_cast<T *>(Allocate(Num * EltSize, Alignment));
   }
+
+  /// \brief Deallocate space for one object without destroying it.
+  template <typename T> void Deallocate(T *Ptr) {
+    Deallocate(static_cast<const void *>(Ptr));
+  }
+
+  /// \brief Allocate space for an array of objects without constructing them.
+  template <typename T> void Deallocate(T *Ptr, size_t /*Num*/) {
+    Deallocate(static_cast<const void *>(Ptr));
+  }
 };
 
 class MallocAllocator : public AllocatorBase<MallocAllocator> {
@@ -94,6 +121,9 @@ public:
 
   void Deallocate(const void *Ptr) { free(const_cast<void *>(Ptr)); }
 
+  // Pull in base class overloads.
+  using AllocatorBase<MallocAllocator>::Deallocate;
+
   void PrintStats() const {}
 };
 
@@ -226,6 +256,9 @@ public:
 
   void Deallocate(const void * /*Ptr*/) {}
 
+  // Pull in base class overloads.
+  using AllocatorBase<BumpPtrAllocatorImpl>::Deallocate;
+
   size_t GetNumSlabs() const { return Slabs.size() + CustomSizedSlabs.size(); }
 
   size_t getTotalMemory() const {