[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

1 files changed, 33 insertions, 0 deletions

diff --git a/include/llvm/Support/Allocator.h b/include/llvm/Support/Allocator.h
index 5eccbccbfc..4da7acefb6 100644
--- 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 {