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 33namespace v8 { 34namespace internal { 35 36// Called when allocation routines fail to allocate. 37// This function should not return, but should terminate the current 38// processing. 39void FatalProcessOutOfMemory(const char* message); 40 41// Superclass for classes managed with new & delete. 42class 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. 61class 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. 73class AllStatic { 74#ifdef DEBUG 75 public: 76 void* operator new(size_t size); 77 void operator delete(void* p); 78#endif 79}; 80 81 82template <typename T> 83T* NewArray(size_t size) { 84 T* result = new T[size]; 85 if (result == NULL) Malloced::FatalProcessOutOfMemory(); 86 return result; 87} 88 89 90template <typename T> 91void 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. 99char* StrDup(const char* str); 100char* 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. 105class 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. 115class 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_ 143