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

   1 // Copyright 2012 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 "globals.h"
  32
  33 namespace v8 {
  34 namespace internal {
  35
  36 // Called when allocation routines fail to allocate.
  37 // This function should not return, but should terminate the current
  38 // processing.
  39 void FatalProcessOutOfMemory(const char* message);
  40
  41 // Superclass for classes managed with new & delete.
  42 class Malloced {
  43  public:
  44   void* operator new(size_t size) { return New(size); }
  45   void  operator delete(void* p) { Delete(p); }
  46
  47   static void FatalProcessOutOfMemory();
  48   static void* New(size_t size);
  49   static void Delete(void* p);
  50 };
  51
  52
  53 // A macro is used for defining the base class used for embedded instances.
  54 // The reason is some compilers allocate a minimum of one word for the
  55 // superclass. The macro prevents the use of new & delete in debug mode.
  56 // In release mode we are not willing to pay this overhead.
  57
  58 #ifdef DEBUG
  59 // Superclass for classes with instances allocated inside stack
  60 // activations or inside other objects.
  61 class Embedded {
  62  public:
  63   void* operator new(size_t size);
  64   void  operator delete(void* p);
  65 };
  66 #define BASE_EMBEDDED : public Embedded
  67 #else
  68 #define BASE_EMBEDDED
  69 #endif
  70
  71
  72 // Superclass for classes only using statics.
  73 class AllStatic {
  74 #ifdef DEBUG
  75  public:
  76   void* operator new(size_t size);
  77   void operator delete(void* p);
  78 #endif
  79 };
  80
  81
  82 template <typename T>
  83 T* NewArray(size_t size) {
  84   T* result = new T[size];
  85   if (result == NULL) Malloced::FatalProcessOutOfMemory();
  86   return result;
  87 }
  88
  89
  90 template <typename T>
  91 void DeleteArray(T* array) {
  92   delete[] array;
  93 }
  94
  95
  96 // The normal strdup functions use malloc.  These versions of StrDup
  97 // and StrNDup uses new and calls the FatalProcessOutOfMemory handler
  98 // if allocation fails.
  99 char* StrDup(const char* str);
 100 char* StrNDup(const char* str, int n);
 101
 102
 103 // Allocation policy for allocating in the C free store using malloc
 104 // and free. Used as the default policy for lists.
 105 class FreeStoreAllocationPolicy {
 106  public:
 107   INLINE(static void* New(size_t size)) { return Malloced::New(size); }
 108   INLINE(static void Delete(void* p)) { Malloced::Delete(p); }
 109 };
 110
 111
 112 // Allocation policy for allocating in preallocated space.
 113 // Used as an allocation policy for ScopeInfo when generating
 114 // stack traces.
 115 class PreallocatedStorage {
 116  public:
 117   explicit PreallocatedStorage(size_t size);
 118   size_t size() { return size_; }
 119
 120   // TODO(isolates): Get rid of these-- we'll have to change the allocator
 121   //                 interface to include a pointer to an isolate to do this
 122   //                 efficiently.
 123   static inline void* New(size_t size);
 124   static inline void Delete(void* p);
 125
 126  private:
 127   size_t size_;
 128   PreallocatedStorage* previous_;
 129   PreallocatedStorage* next_;
 130
 131   void LinkTo(PreallocatedStorage* other);
 132   void Unlink();
 133
 134   friend class Isolate;
 135
 136   DISALLOW_IMPLICIT_CONSTRUCTORS(PreallocatedStorage);
 137 };
 138
 139
 140 } }  // namespace v8::internal
 141
 142 #endif  // V8_ALLOCATION_H_