Revert my last series of commits related to Timer and 64-bit atomics. Not all the...

[oota-llvm.git] / include / llvm / Support / Allocator.h

diff --git a/include/llvm/Support/Allocator.h b/include/llvm/Support/Allocator.h
index ffe0d39e521dac022882615669bcaf6e1870a146..c0414f970a29533c80bebcbdddc1656594406df8 100644 (file)
--- a/include/llvm/Support/Allocator.h
+++ b/include/llvm/Support/Allocator.h
@@ -18,20 +18,25 @@
 #include <cstdlib>
 
 namespace llvm {
-    
+
 class MallocAllocator {
 public:
   MallocAllocator() {}
   ~MallocAllocator() {}
-  
+
   void Reset() {}
 
   void *Allocate(size_t Size, size_t /*Alignment*/) { return malloc(Size); }
-  
+
   template <typename T>
   T *Allocate() { return static_cast<T*>(malloc(sizeof(T))); }
-  
-  void Deallocate(void *Ptr) { free(Ptr); }
+
+  template <typename T>
+  T *Allocate(size_t Num) {
+    return static_cast<T*>(malloc(sizeof(T)*Num));
+  }
+
+  void Deallocate(const void *Ptr) { free(const_cast<void*>(Ptr)); }
 
   void PrintStats() const {}
 };
@@ -41,21 +46,42 @@ public:
 /// 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
+
   void *TheMemory;
 public:
   BumpPtrAllocator();
   ~BumpPtrAllocator();
-  
+
   void Reset();
 
   void *Allocate(size_t Size, size_t Alignment);
 
+  /// Allocate space, but do not construct, one object.
+  ///
   template <typename T>
-  T *Allocate() { 
+  T *Allocate() {
     return static_cast<T*>(Allocate(sizeof(T),AlignOf<T>::Alignment));
   }
-  
-  void Deallocate(void */*Ptr*/) {}
+
+  /// Allocate space for an array of objects.  This does not construct the
+  /// objects though.
+  template <typename T>
+  T *Allocate(size_t Num) {
+    return static_cast<T*>(Allocate(Num * sizeof(T), AlignOf<T>::Alignment));
+  }
+
+  /// Allocate space for a specific count of elements and with a specified
+  /// alignment.
+  template <typename T>
+  T *Allocate(size_t Num, size_t Alignment) {
+    // Round EltSize up to the specified alignment.
+    size_t EltSize = (sizeof(T)+Alignment-1)&(-Alignment);
+    return static_cast<T*>(Allocate(Num * EltSize, Alignment));
+  }
+
+  void Deallocate(const void * /*Ptr*/) {}
 
   void PrintStats() const;
 };