src/3rdparty/v8/src/allocation.h

   1 // Copyright 2008 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #ifndef V8_ALLOCATION_H_
  29 #define V8_ALLOCATION_H_
  30
  31 #include "checks.h"
  32 #include "globals.h"
  33
  34 namespace v8 {
  35 namespace internal {
  36
  37 // Called when allocation routines fail to allocate.
  38 // This function should not return, but should terminate the current
  39 // processing.
  40 void FatalProcessOutOfMemory(const char* message);
  41
  42 // Superclass for classes managed with new & delete.
  43 class Malloced {
  44  public:
  45   void* operator new(size_t size) { return New(size); }
  46   void  operator delete(void* p) { Delete(p); }
  47
  48   static void FatalProcessOutOfMemory();
  49   static void* New(size_t size);
  50   static void Delete(void* p);
  51 };
  52
  53
  54 // A macro is used for defining the base class used for embedded instances.
  55 // The reason is some compilers allocate a minimum of one word for the
  56 // superclass. The macro prevents the use of new & delete in debug mode.
  57 // In release mode we are not willing to pay this overhead.
  58
  59 #ifdef DEBUG
  60 // Superclass for classes with instances allocated inside stack
  61 // activations or inside other objects.
  62 class Embedded {
  63  public:
  64   void* operator new(size_t size);
  65   void  operator delete(void* p);
  66 };
  67 #define BASE_EMBEDDED : public Embedded
  68 #else
  69 #define BASE_EMBEDDED
  70 #endif
  71
  72
  73 // Superclass for classes only using statics.
  74 class AllStatic {
  75 #ifdef DEBUG
  76  public:
  77   void* operator new(size_t size);
  78   void operator delete(void* p);
  79 #endif
  80 };
  81
  82
  83 template <typename T>
  84 static T* NewArray(int size) {
  85   T* result = new T[size];
  86   if (result == NULL) Malloced::FatalProcessOutOfMemory();
  87   return result;
  88 }
  89
  90
  91 template <typename T>
  92 static void DeleteArray(T* array) {
  93   delete[] array;
  94 }
  95
  96
  97 // The normal strdup functions use malloc.  These versions of StrDup
  98 // and StrNDup uses new and calls the FatalProcessOutOfMemory handler
  99 // if allocation fails.
 100 char* StrDup(const char* str);
 101 char* StrNDup(const char* str, int n);
 102
 103
 104 // Allocation policy for allocating in the C free store using malloc
 105 // and free. Used as the default policy for lists.
 106 class FreeStoreAllocationPolicy {
 107  public:
 108   INLINE(static void* New(size_t size)) { return Malloced::New(size); }
 109   INLINE(static void Delete(void* p)) { Malloced::Delete(p); }
 110 };
 111
 112
 113 // Allocation policy for allocating in preallocated space.
 114 // Used as an allocation policy for ScopeInfo when generating
 115 // stack traces.
 116 class PreallocatedStorage {
 117  public:
 118   explicit PreallocatedStorage(size_t size);
 119   size_t size() { return size_; }
 120
 121   // TODO(isolates): Get rid of these-- we'll have to change the allocator
 122   //                 interface to include a pointer to an isolate to do this
 123   //                 efficiently.
 124   static inline void* New(size_t size);
 125   static inline void Delete(void* p);
 126
 127  private:
 128   size_t size_;
 129   PreallocatedStorage* previous_;
 130   PreallocatedStorage* next_;
 131
 132   void LinkTo(PreallocatedStorage* other);
 133   void Unlink();
 134
 135   friend class Isolate;
 136
 137   DISALLOW_IMPLICIT_CONSTRUCTORS(PreallocatedStorage);
 138 };
 139
 140
 141 } }  // namespace v8::internal
 142
 143 #endif  // V8_ALLOCATION_H_