Reverting r76825 and r76828, since they caused clang runtime errors and some build failure involving memset.

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

1 files changed, 5 insertions, 92 deletions

diff --git a/include/llvm/Support/Allocator.h b/include/llvm/Support/Allocator.h
index 4c84878..c0414f9 100644
--- a/include/llvm/Support/Allocator.h
+++ b/include/llvm/Support/Allocator.h
@@ -15,8 +15,6 @@
 #define LLVM_SUPPORT_ALLOCATOR_H
 
 #include "llvm/Support/AlignOf.h"
-#include "llvm/Support/DataTypes.h"
-#include <cassert>
 #include <cstdlib>
 
 namespace llvm {
@@ -43,104 +41,21 @@ public:
   void PrintStats() const {}
 };
 
-/// MemSlab - This structure lives at the beginning of every slab allocated by
-/// the bump allocator.
-class MemSlab {
-public:
-  size_t Size;
-  MemSlab *NextPtr;
-};
-
-/// SlabAllocator - This class can be used to parameterize the underlying
-/// allocation strategy for the bump allocator.  In particular, this is used
-/// by the JIT to allocate contiguous swathes of executable memory.  The
-/// interface uses MemSlab's instead of void *'s so that the allocator
-/// doesn't have to remember the size of the pointer it allocated.
-class SlabAllocator {
-public:
-  virtual ~SlabAllocator();
-  virtual MemSlab *Allocate(size_t Size) = 0;
-  virtual void Deallocate(MemSlab *Slab) = 0;
-};
-
-/// MallocSlabAllocator - The default slab allocator for the bump allocator
-/// is an adapter class for MallocAllocator that just forwards the method
-/// calls and translates the arguments.
-class MallocSlabAllocator : public SlabAllocator {
-  /// Allocator - The underlying allocator that we forward to.
-  ///
-  MallocAllocator Allocator;
-
-public:
-  MallocSlabAllocator() : Allocator() { }
-  virtual ~MallocSlabAllocator();
-  virtual MemSlab *Allocate(size_t Size);
-  virtual void Deallocate(MemSlab *Slab);
-};
-
-/// BumpPtrAllocator - This allocator is useful for containers that need
-/// very simple memory allocation strategies.  In particular, this just keeps
+/// BumpPtrAllocator - This allocator is useful for containers that need very
+/// simple memory allocation strategies.  In particular, this just keeps
 /// allocating memory, and never deletes it until the entire block is dead. This
 /// makes allocation speedy, but must only be used when the trade-off is ok.
 class BumpPtrAllocator {
   BumpPtrAllocator(const BumpPtrAllocator &); // do not implement
   void operator=(const BumpPtrAllocator &);   // do not implement
 
-  /// SlabSize - Allocate data into slabs of this size unless we get an
-  /// allocation above SizeThreshold.
-  size_t SlabSize;
-
-  /// SizeThreshold - For any allocation larger than this threshold, we should
-  /// allocate a separate slab.
-  size_t SizeThreshold;
-
-  /// Allocator - The underlying allocator we use to get slabs of memory.  This
-  /// defaults to MallocSlabAllocator, which wraps malloc, but it could be
-  /// changed to use a custom allocator.
-  SlabAllocator &Allocator;
-
-  /// CurSlab - The slab that we are currently allocating into.
-  ///
-  MemSlab *CurSlab;
-
-  /// CurPtr - The current pointer into the current slab.  This points to the
-  /// next free byte in the slab.
-  char *CurPtr;
-
-  /// End - The end of the current slab.
-  ///
-  char *End;
-
-  /// BytesAllocated - This field tracks how many bytes we've allocated, so
-  /// that we can compute how much space was wasted.
-  size_t BytesAllocated;
-
-  /// AlignPtr - Align Ptr to Alignment bytes, rounding up.  Alignment should
-  /// be a power of two.  This method rounds up, so AlignPtr(7, 4) == 8 and
-  /// AlignPtr(8, 4) == 8.
-  static char *AlignPtr(char *Ptr, size_t Alignment);
-
-  /// StartNewSlab - Allocate a new slab and move the bump pointers over into
-  /// the new slab.  Modifies CurPtr and End.
-  void StartNewSlab();
-
-  /// DeallocateSlabs - Deallocate all memory slabs after and including this
-  /// one.
-  void DeallocateSlabs(MemSlab *Slab);
-
-  static MallocSlabAllocator DefaultSlabAllocator;
-
+  void *TheMemory;
 public:
-  BumpPtrAllocator(size_t size = 4096, size_t threshold = 4096,
-                   SlabAllocator &allocator = DefaultSlabAllocator);
+  BumpPtrAllocator();
   ~BumpPtrAllocator();
 
-  /// Reset - Deallocate all but the current slab and reset the current pointer
-  /// to the beginning of it, freeing all memory allocated so far.
   void Reset();
 
-  /// Allocate - Allocate space at the specified alignment.
-  ///
   void *Allocate(size_t Size, size_t Alignment);
 
   /// Allocate space, but do not construct, one object.
@@ -168,11 +83,9 @@ public:
 
   void Deallocate(const void * /*Ptr*/) {}
 
-  unsigned GetNumSlabs() const;
-
   void PrintStats() const;
 };
 
 }  // end namespace llvm
 
-#endif // LLVM_SUPPORT_ALLOCATOR_H
+#endif