1 /*
2 * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3 *
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.
8 *
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.
13 *
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.
18 *
19 */
20
21 #ifndef WTF_FastMalloc_h
22 #define WTF_FastMalloc_h
23
24 #include "Platform.h"
25 #include "PossiblyNull.h"
26 #include <stdlib.h>
27 #include <new>
28
29 namespace WTF {
30
31 // These functions call CRASH() if an allocation fails.
32 void* fastMalloc(size_t);
33 void* fastZeroedMalloc(size_t);
34 void* fastCalloc(size_t numElements, size_t elementSize);
35 void* fastRealloc(void*, size_t);
36 char* fastStrDup(const char*);
37 size_t fastMallocSize(const void*);
38
39 struct TryMallocReturnValue {
TryMallocReturnValueTryMallocReturnValue40 TryMallocReturnValue(void* data)
41 : m_data(data)
42 {
43 }
TryMallocReturnValueTryMallocReturnValue44 TryMallocReturnValue(const TryMallocReturnValue& source)
45 : m_data(source.m_data)
46 {
47 source.m_data = 0;
48 }
~TryMallocReturnValueTryMallocReturnValue49 ~TryMallocReturnValue() { ASSERT(!m_data); }
50 template <typename T> bool getValue(T& data) WARN_UNUSED_RETURN;
51 template <typename T> operator PossiblyNull<T>()
52 {
53 T value;
54 getValue(value);
55 return PossiblyNull<T>(value);
56 }
57 private:
58 mutable void* m_data;
59 };
60
getValue(T & data)61 template <typename T> bool TryMallocReturnValue::getValue(T& data)
62 {
63 union u { void* data; T target; } res;
64 res.data = m_data;
65 data = res.target;
66 bool returnValue = !!m_data;
67 m_data = 0;
68 return returnValue;
69 }
70
71 TryMallocReturnValue tryFastMalloc(size_t n);
72 TryMallocReturnValue tryFastZeroedMalloc(size_t n);
73 TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
74 TryMallocReturnValue tryFastRealloc(void* p, size_t n);
75
76 void fastFree(void*);
77
78 #ifndef NDEBUG
79 void fastMallocForbid();
80 void fastMallocAllow();
81 #endif
82
83 void releaseFastMallocFreeMemory();
84
85 struct FastMallocStatistics {
86 size_t reservedVMBytes;
87 size_t committedVMBytes;
88 size_t freeListBytes;
89 };
90 FastMallocStatistics fastMallocStatistics();
91
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;
95
96 namespace Internal {
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[].
105 };
106 }
107
108 #if ENABLE(FAST_MALLOC_MATCH_VALIDATION)
109
110 // Malloc validation is a scheme whereby a tag is attached to an
111 // allocation which identifies how it was originally allocated.
112 // This allows us to verify that the freeing operation matches the
113 // allocation operation. If memory is allocated with operator new[]
114 // but freed with free or delete, this system would detect that.
115 // In the implementation here, the tag is an integer prepended to
116 // the allocation memory which is assigned one of the AllocType
117 // enumeration values. An alternative implementation of this
118 // scheme could store the tag somewhere else or ignore it.
119 // Users of FastMalloc don't need to know or care how this tagging
120 // is implemented.
121
122 namespace Internal {
123
124 // Return the AllocType tag associated with the allocated block p.
fastMallocMatchValidationType(const void * p)125 inline AllocType fastMallocMatchValidationType(const void* p)
126 {
127 const AllocAlignmentInteger* type = static_cast<const AllocAlignmentInteger*>(p) - 1;
128 return static_cast<AllocType>(*type);
129 }
130
131 // Return the address of the AllocType tag associated with the allocated block p.
fastMallocMatchValidationValue(void * p)132 inline AllocAlignmentInteger* fastMallocMatchValidationValue(void* p)
133 {
134 return reinterpret_cast<AllocAlignmentInteger*>(static_cast<char*>(p) - sizeof(AllocAlignmentInteger));
135 }
136
137 // Set the AllocType tag to be associaged with the allocated block p.
setFastMallocMatchValidationType(void * p,AllocType allocType)138 inline void setFastMallocMatchValidationType(void* p, AllocType allocType)
139 {
140 AllocAlignmentInteger* type = static_cast<AllocAlignmentInteger*>(p) - 1;
141 *type = static_cast<AllocAlignmentInteger>(allocType);
142 }
143
144 // Handle a detected alloc/free mismatch. By default this calls CRASH().
145 void fastMallocMatchFailed(void* p);
146
147 } // namespace Internal
148
149 // This is a higher level function which is used by FastMalloc-using code.
fastMallocMatchValidateMalloc(void * p,Internal::AllocType allocType)150 inline void fastMallocMatchValidateMalloc(void* p, Internal::AllocType allocType)
151 {
152 if (!p)
153 return;
154
155 Internal::setFastMallocMatchValidationType(p, allocType);
156 }
157
158 // This is a higher level function which is used by FastMalloc-using code.
fastMallocMatchValidateFree(void * p,Internal::AllocType allocType)159 inline void fastMallocMatchValidateFree(void* p, Internal::AllocType allocType)
160 {
161 if (!p)
162 return;
163
164 if (Internal::fastMallocMatchValidationType(p) != allocType)
165 Internal::fastMallocMatchFailed(p);
166 Internal::setFastMallocMatchValidationType(p, Internal::AllocTypeMalloc); // Set it to this so that fastFree thinks it's OK.
167 }
168
169 #else
170
fastMallocMatchValidateMalloc(void *,Internal::AllocType)171 inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
172 {
173 }
174
fastMallocMatchValidateFree(void *,Internal::AllocType)175 inline void fastMallocMatchValidateFree(void*, Internal::AllocType)
176 {
177 }
178
179 #endif
180
181 } // namespace WTF
182
183 using WTF::fastCalloc;
184 using WTF::fastFree;
185 using WTF::fastMalloc;
186 using WTF::fastMallocSize;
187 using WTF::fastRealloc;
188 using WTF::fastStrDup;
189 using WTF::fastZeroedMalloc;
190 using WTF::tryFastCalloc;
191 using WTF::tryFastMalloc;
192 using WTF::tryFastRealloc;
193 using WTF::tryFastZeroedMalloc;
194
195 #ifndef NDEBUG
196 using WTF::fastMallocForbid;
197 using WTF::fastMallocAllow;
198 #endif
199
200 #if COMPILER(GCC) && OS(DARWIN)
201 #define WTF_PRIVATE_INLINE __private_extern__ inline __attribute__((always_inline))
202 #elif COMPILER(GCC)
203 #define WTF_PRIVATE_INLINE inline __attribute__((always_inline))
204 #elif COMPILER(MSVC) || COMPILER(RVCT)
205 #define WTF_PRIVATE_INLINE __forceinline
206 #else
207 #define WTF_PRIVATE_INLINE inline
208 #endif
209
210 #if !defined(_CRTDBG_MAP_ALLOC) && !(defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC && !PLATFORM(BREWMP))
211
212 // The nothrow functions here are actually not all that helpful, because fastMalloc will
213 // call CRASH() rather than returning 0, and returning 0 is what nothrow is all about.
214 // But since WebKit code never uses exceptions or nothrow at all, this is probably OK.
215 // Long term we will adopt FastAllocBase.h everywhere, and and replace this with
216 // debug-only code to make sure we don't use the system malloc via the default operator
217 // new by accident.
218
219 #if ENABLE(GLOBAL_FASTMALLOC_NEW)
220
221 #if COMPILER(MSVC)
222 #pragma warning(push)
223 #pragma warning(disable: 4290) // Disable the C++ exception specification ignored warning.
224 #endif
new(size_t size)225 WTF_PRIVATE_INLINE void* operator new(size_t size) throw (std::bad_alloc) { return fastMalloc(size); }
new(size_t size,const std::nothrow_t &)226 WTF_PRIVATE_INLINE void* operator new(size_t size, const std::nothrow_t&) throw() { return fastMalloc(size); }
delete(void * p)227 WTF_PRIVATE_INLINE void operator delete(void* p) throw() { fastFree(p); }
delete(void * p,const std::nothrow_t &)228 WTF_PRIVATE_INLINE void operator delete(void* p, const std::nothrow_t&) throw() { fastFree(p); }
throw(std::bad_alloc)229 WTF_PRIVATE_INLINE void* operator new[](size_t size) throw (std::bad_alloc) { return fastMalloc(size); }
throw()230 WTF_PRIVATE_INLINE void* operator new[](size_t size, const std::nothrow_t&) throw() { return fastMalloc(size); }
throw()231 WTF_PRIVATE_INLINE void operator delete[](void* p) throw() { fastFree(p); }
throw()232 WTF_PRIVATE_INLINE void operator delete[](void* p, const std::nothrow_t&) throw() { fastFree(p); }
233 #if COMPILER(MSVC)
234 #pragma warning(pop)
235 #endif
236
237 #endif
238
239 #endif
240
241 #endif /* WTF_FastMalloc_h */
242