2 * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public License
15 * along with this library; see the file COPYING.LIB. If not, write to
16 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
21 #ifndef WTF_FastMalloc_h
22 #define WTF_FastMalloc_h
24 #include <wtf/Platform.h>
25 #include <wtf/PossiblyNull.h>
31 // These functions call CRASH() if an allocation fails.
32 WTF_EXPORT_PRIVATE void* fastMalloc(size_t);
33 WTF_EXPORT_PRIVATE void* fastZeroedMalloc(size_t);
34 WTF_EXPORT_PRIVATE void* fastCalloc(size_t numElements, size_t elementSize);
35 WTF_EXPORT_PRIVATE void* fastRealloc(void*, size_t);
36 WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
37 WTF_EXPORT_PRIVATE size_t fastMallocSize(const void*);
39 struct TryMallocReturnValue {
40 TryMallocReturnValue(void* data)
44 TryMallocReturnValue(const TryMallocReturnValue& source)
45 : m_data(source.m_data)
49 ~TryMallocReturnValue() { ASSERT(!m_data); }
50 template <typename T> bool getValue(T& data) WARN_UNUSED_RETURN;
51 template <typename T> operator PossiblyNull<T>()
55 return PossiblyNull<T>(value);
61 template <typename T> bool TryMallocReturnValue::getValue(T& data)
63 union u { void* data; T target; } res;
66 bool returnValue = !!m_data;
71 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t n);
72 TryMallocReturnValue tryFastZeroedMalloc(size_t n);
73 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
74 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastRealloc(void* p, size_t n);
76 WTF_EXPORT_PRIVATE void fastFree(void*);
79 void fastMallocForbid();
80 void fastMallocAllow();
83 WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemory();
85 struct FastMallocStatistics {
86 size_t reservedVMBytes;
87 size_t committedVMBytes;
90 WTF_EXPORT_PRIVATE FastMallocStatistics fastMallocStatistics();
92 // This defines a type which holds an unsigned integer and is the same
93 // size as the minimally aligned memory allocation.
94 typedef unsigned long long AllocAlignmentInteger;
97 enum AllocType { // Start with an unusual number instead of zero, because zero is common.
98 AllocTypeMalloc = 0x375d6750, // Encompasses fastMalloc, fastZeroedMalloc, fastCalloc, fastRealloc.
99 AllocTypeClassNew, // Encompasses class operator new from FastAllocBase.
100 AllocTypeClassNewArray, // Encompasses class operator new[] from FastAllocBase.
101 AllocTypeFastNew, // Encompasses fastNew.
102 AllocTypeFastNewArray, // Encompasses fastNewArray.
103 AllocTypeNew, // Encompasses global operator new.
104 AllocTypeNewArray // Encompasses global operator new[].
108 ValidationPrefix = 0xf00df00d,
109 ValidationSuffix = 0x0badf00d
112 typedef unsigned ValidationTag;
114 struct ValidationHeader {
117 ValidationTag m_prefix;
118 unsigned m_alignment;
121 static const int ValidationBufferSize = sizeof(ValidationHeader) + sizeof(ValidationTag);
124 #if ENABLE(WTF_MALLOC_VALIDATION)
126 // Malloc validation is a scheme whereby a tag is attached to an
127 // allocation which identifies how it was originally allocated.
128 // This allows us to verify that the freeing operation matches the
129 // allocation operation. If memory is allocated with operator new[]
130 // but freed with free or delete, this system would detect that.
131 // In the implementation here, the tag is an integer prepended to
132 // the allocation memory which is assigned one of the AllocType
133 // enumeration values. An alternative implementation of this
134 // scheme could store the tag somewhere else or ignore it.
135 // Users of FastMalloc don't need to know or care how this tagging
140 // Handle a detected alloc/free mismatch. By default this calls CRASH().
141 void fastMallocMatchFailed(void* p);
143 inline ValidationHeader* fastMallocValidationHeader(void* p)
145 return reinterpret_cast<ValidationHeader*>(static_cast<char*>(p) - sizeof(ValidationHeader));
148 inline ValidationTag* fastMallocValidationSuffix(void* p)
150 ValidationHeader* header = fastMallocValidationHeader(p);
151 if (header->m_prefix != static_cast<unsigned>(ValidationPrefix))
152 fastMallocMatchFailed(p);
154 return reinterpret_cast<ValidationTag*>(static_cast<char*>(p) + header->m_size);
157 // Return the AllocType tag associated with the allocated block p.
158 inline AllocType fastMallocMatchValidationType(void* p)
160 return fastMallocValidationHeader(p)->m_type;
163 // Set the AllocType tag to be associaged with the allocated block p.
164 inline void setFastMallocMatchValidationType(void* p, AllocType allocType)
166 fastMallocValidationHeader(p)->m_type = allocType;
169 } // namespace Internal
171 // This is a higher level function which is used by FastMalloc-using code.
172 inline void fastMallocMatchValidateMalloc(void* p, Internal::AllocType allocType)
177 Internal::setFastMallocMatchValidationType(p, allocType);
180 // This is a higher level function which is used by FastMalloc-using code.
181 inline void fastMallocMatchValidateFree(void* p, Internal::AllocType)
186 Internal::ValidationHeader* header = Internal::fastMallocValidationHeader(p);
187 if (header->m_prefix != static_cast<unsigned>(Internal::ValidationPrefix))
188 Internal::fastMallocMatchFailed(p);
190 if (*Internal::fastMallocValidationSuffix(p) != Internal::ValidationSuffix)
191 Internal::fastMallocMatchFailed(p);
193 Internal::setFastMallocMatchValidationType(p, Internal::AllocTypeMalloc); // Set it to this so that fastFree thinks it's OK.
196 inline void fastMallocValidate(void* p)
201 Internal::ValidationHeader* header = Internal::fastMallocValidationHeader(p);
202 if (header->m_prefix != static_cast<unsigned>(Internal::ValidationPrefix))
203 Internal::fastMallocMatchFailed(p);
205 if (*Internal::fastMallocValidationSuffix(p) != Internal::ValidationSuffix)
206 Internal::fastMallocMatchFailed(p);
211 inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
215 inline void fastMallocMatchValidateFree(void*, Internal::AllocType)
223 using WTF::fastCalloc;
225 using WTF::fastMalloc;
226 using WTF::fastMallocSize;
227 using WTF::fastRealloc;
228 using WTF::fastStrDup;
229 using WTF::fastZeroedMalloc;
230 using WTF::tryFastCalloc;
231 using WTF::tryFastMalloc;
232 using WTF::tryFastRealloc;
233 using WTF::tryFastZeroedMalloc;
236 using WTF::fastMallocForbid;
237 using WTF::fastMallocAllow;
240 #if COMPILER(GCC) && OS(DARWIN)
241 #define WTF_PRIVATE_INLINE __private_extern__ inline __attribute__((always_inline))
243 #define WTF_PRIVATE_INLINE inline __attribute__((always_inline))
244 #elif COMPILER(MSVC) || COMPILER(RVCT)
245 #define WTF_PRIVATE_INLINE __forceinline
247 #define WTF_PRIVATE_INLINE inline
250 #if !defined(_CRTDBG_MAP_ALLOC) && !(defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC)
252 // The nothrow functions here are actually not all that helpful, because fastMalloc will
253 // call CRASH() rather than returning 0, and returning 0 is what nothrow is all about.
254 // But since WebKit code never uses exceptions or nothrow at all, this is probably OK.
255 // Long term we will adopt FastAllocBase.h everywhere, and and replace this with
256 // debug-only code to make sure we don't use the system malloc via the default operator
259 #if ENABLE(GLOBAL_FASTMALLOC_NEW)
262 #pragma warning(push)
263 #pragma warning(disable: 4290) // Disable the C++ exception specification ignored warning.
265 WTF_PRIVATE_INLINE void* operator new(size_t size) throw (std::bad_alloc) { return fastMalloc(size); }
266 WTF_PRIVATE_INLINE void* operator new(size_t size, const std::nothrow_t&) throw() { return fastMalloc(size); }
267 WTF_PRIVATE_INLINE void operator delete(void* p) throw() { fastFree(p); }
268 WTF_PRIVATE_INLINE void operator delete(void* p, const std::nothrow_t&) throw() { fastFree(p); }
269 WTF_PRIVATE_INLINE void* operator new[](size_t size) throw (std::bad_alloc) { return fastMalloc(size); }
270 WTF_PRIVATE_INLINE void* operator new[](size_t size, const std::nothrow_t&) throw() { return fastMalloc(size); }
271 WTF_PRIVATE_INLINE void operator delete[](void* p) throw() { fastFree(p); }
272 WTF_PRIVATE_INLINE void operator delete[](void* p, const std::nothrow_t&) throw() { fastFree(p); }
281 #endif /* WTF_FastMalloc_h */