Neuter WTF_MAKE_FAST_ALLOCATED in GLOBAL_FASTMALLOC_NEW builds.
[WebKit-https.git] / Source / WTF / wtf / FastMalloc.h
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 <new>
25 #include <stdlib.h>
26 #include <wtf/Platform.h>
27 #include <wtf/PossiblyNull.h>
28 #include <wtf/StdLibExtras.h>
29
30 namespace WTF {
31
32     // These functions call CRASH() if an allocation fails.
33     WTF_EXPORT_PRIVATE void* fastMalloc(size_t);
34     WTF_EXPORT_PRIVATE void* fastZeroedMalloc(size_t);
35     WTF_EXPORT_PRIVATE void* fastCalloc(size_t numElements, size_t elementSize);
36     WTF_EXPORT_PRIVATE void* fastRealloc(void*, size_t);
37     WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
38     WTF_EXPORT_PRIVATE size_t fastMallocSize(const void*);
39     WTF_EXPORT_PRIVATE size_t fastMallocGoodSize(size_t);
40
41     struct TryMallocReturnValue {
42         TryMallocReturnValue(void* data)
43             : m_data(data)
44         {
45         }
46         TryMallocReturnValue(const TryMallocReturnValue& source)
47             : m_data(source.m_data)
48         {
49             source.m_data = 0;
50         }
51         ~TryMallocReturnValue() { ASSERT(!m_data); }
52         template <typename T> bool getValue(T& data) WARN_UNUSED_RETURN;
53         template <typename T> operator PossiblyNull<T>()
54         { 
55             T value; 
56             getValue(value); 
57             return PossiblyNull<T>(value);
58         } 
59     private:
60         mutable void* m_data;
61     };
62     
63     template <typename T> bool TryMallocReturnValue::getValue(T& data)
64     {
65         union u { void* data; T target; } res;
66         res.data = m_data;
67         data = res.target;
68         bool returnValue = !!m_data;
69         m_data = 0;
70         return returnValue;
71     }
72
73     WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t n);
74     TryMallocReturnValue tryFastZeroedMalloc(size_t n);
75     WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
76     WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastRealloc(void* p, size_t n);
77
78     WTF_EXPORT_PRIVATE void fastFree(void*);
79
80 #ifndef NDEBUG    
81     WTF_EXPORT_PRIVATE void fastMallocForbid();
82     WTF_EXPORT_PRIVATE void fastMallocAllow();
83 #endif
84
85     WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemory();
86     
87     struct FastMallocStatistics {
88         size_t reservedVMBytes;
89         size_t committedVMBytes;
90         size_t freeListBytes;
91     };
92     WTF_EXPORT_PRIVATE FastMallocStatistics fastMallocStatistics();
93
94     // This defines a type which holds an unsigned integer and is the same
95     // size as the minimally aligned memory allocation.
96     typedef unsigned long long AllocAlignmentInteger;
97
98     namespace Internal {
99         enum AllocType {                    // Start with an unusual number instead of zero, because zero is common.
100             AllocTypeMalloc = 0x375d6750,   // Encompasses fastMalloc, fastZeroedMalloc, fastCalloc, fastRealloc.
101             AllocTypeClassNew,              // Encompasses class operator new from FastAllocBase.
102             AllocTypeClassNewArray,         // Encompasses class operator new[] from FastAllocBase.
103             AllocTypeNew,                   // Encompasses global operator new.
104             AllocTypeNewArray               // Encompasses global operator new[].
105         };
106
107         enum {
108             ValidationPrefix = 0xf00df00d,
109             ValidationSuffix = 0x0badf00d
110         };
111
112         typedef unsigned ValidationTag;
113
114         struct ValidationHeader {
115             AllocType m_type;
116             unsigned m_size;
117             ValidationTag m_prefix;
118             unsigned m_alignment;
119         };
120
121         static const int ValidationBufferSize = sizeof(ValidationHeader) + sizeof(ValidationTag);
122     }
123
124 #if ENABLE(WTF_MALLOC_VALIDATION)
125
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
136     // is implemented.
137
138     namespace Internal {
139     
140         // Handle a detected alloc/free mismatch. By default this calls CRASH().
141         void fastMallocMatchFailed(void* p);
142
143         inline ValidationHeader* fastMallocValidationHeader(void* p)
144         {
145             return reinterpret_cast<ValidationHeader*>(static_cast<char*>(p) - sizeof(ValidationHeader));
146         }
147
148         inline ValidationTag* fastMallocValidationSuffix(void* p)
149         {
150             ValidationHeader* header = fastMallocValidationHeader(p);
151             if (header->m_prefix != static_cast<unsigned>(ValidationPrefix))
152                 fastMallocMatchFailed(p);
153             
154             return reinterpret_cast<ValidationTag*>(static_cast<char*>(p) + header->m_size);
155         }
156
157         // Return the AllocType tag associated with the allocated block p.
158         inline AllocType fastMallocMatchValidationType(void* p)
159         {
160             return fastMallocValidationHeader(p)->m_type;
161         }
162
163         // Set the AllocType tag to be associaged with the allocated block p.
164         inline void setFastMallocMatchValidationType(void* p, AllocType allocType)
165         {
166             fastMallocValidationHeader(p)->m_type = allocType;
167         }
168
169     } // namespace Internal
170
171     // This is a higher level function which is used by FastMalloc-using code.
172     inline void fastMallocMatchValidateMalloc(void* p, Internal::AllocType allocType)
173     {
174         if (!p)
175             return;
176
177         Internal::setFastMallocMatchValidationType(p, allocType);
178     }
179
180     // This is a higher level function which is used by FastMalloc-using code.
181     inline void fastMallocMatchValidateFree(void* p, Internal::AllocType)
182     {
183         if (!p)
184             return;
185     
186         Internal::ValidationHeader* header = Internal::fastMallocValidationHeader(p);
187         if (header->m_prefix != static_cast<unsigned>(Internal::ValidationPrefix))
188             Internal::fastMallocMatchFailed(p);
189
190         if (*Internal::fastMallocValidationSuffix(p) != Internal::ValidationSuffix)
191             Internal::fastMallocMatchFailed(p);
192
193         Internal::setFastMallocMatchValidationType(p, Internal::AllocTypeMalloc);  // Set it to this so that fastFree thinks it's OK.
194     }
195
196     inline void fastMallocValidate(void* p)
197     {
198         if (!p)
199             return;
200         
201         Internal::ValidationHeader* header = Internal::fastMallocValidationHeader(p);
202         if (header->m_prefix != static_cast<unsigned>(Internal::ValidationPrefix))
203             Internal::fastMallocMatchFailed(p);
204         
205         if (*Internal::fastMallocValidationSuffix(p) != Internal::ValidationSuffix)
206             Internal::fastMallocMatchFailed(p);
207     }
208
209 #else
210
211     inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
212     {
213     }
214
215     inline void fastMallocMatchValidateFree(void*, Internal::AllocType)
216     {
217     }
218
219 #endif
220
221 } // namespace WTF
222
223 using WTF::fastCalloc;
224 using WTF::fastFree;
225 using WTF::fastMalloc;
226 using WTF::fastMallocGoodSize;
227 using WTF::fastMallocSize;
228 using WTF::fastRealloc;
229 using WTF::fastStrDup;
230 using WTF::fastZeroedMalloc;
231 using WTF::tryFastCalloc;
232 using WTF::tryFastMalloc;
233 using WTF::tryFastRealloc;
234 using WTF::tryFastZeroedMalloc;
235
236 #ifndef NDEBUG    
237 using WTF::fastMallocForbid;
238 using WTF::fastMallocAllow;
239 #endif
240
241 #if COMPILER(GCC) && OS(DARWIN)
242 #define WTF_PRIVATE_INLINE __private_extern__ inline __attribute__((always_inline))
243 #elif COMPILER(GCC)
244 #define WTF_PRIVATE_INLINE inline __attribute__((always_inline))
245 #elif COMPILER(MSVC) || COMPILER(RVCT)
246 #define WTF_PRIVATE_INLINE __forceinline
247 #else
248 #define WTF_PRIVATE_INLINE inline
249 #endif
250
251 #if !defined(_CRTDBG_MAP_ALLOC) && !(defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC)
252
253 // The nothrow functions here are actually not all that helpful, because fastMalloc will
254 // call CRASH() rather than returning 0, and returning 0 is what nothrow is all about.
255 // But since WebKit code never uses exceptions or nothrow at all, this is probably OK.
256 // Long term we will adopt FastAllocBase.h everywhere, and and replace this with
257 // debug-only code to make sure we don't use the system malloc via the default operator
258 // new by accident.
259
260 #if ENABLE(GLOBAL_FASTMALLOC_NEW)
261
262 #if COMPILER(MSVC)
263 #pragma warning(push)
264 #pragma warning(disable: 4290) // Disable the C++ exception specification ignored warning.
265 #endif
266 WTF_PRIVATE_INLINE void* operator new(size_t size) throw (std::bad_alloc) { return fastMalloc(size); }
267 WTF_PRIVATE_INLINE void* operator new(size_t size, const std::nothrow_t&) throw() { return fastMalloc(size); }
268 WTF_PRIVATE_INLINE void operator delete(void* p) throw() { fastFree(p); }
269 WTF_PRIVATE_INLINE void operator delete(void* p, const std::nothrow_t&) throw() { fastFree(p); }
270 WTF_PRIVATE_INLINE void* operator new[](size_t size) throw (std::bad_alloc) { return fastMalloc(size); }
271 WTF_PRIVATE_INLINE void* operator new[](size_t size, const std::nothrow_t&) throw() { return fastMalloc(size); }
272 WTF_PRIVATE_INLINE void operator delete[](void* p) throw() { fastFree(p); }
273 WTF_PRIVATE_INLINE void operator delete[](void* p, const std::nothrow_t&) throw() { fastFree(p); }
274 #if COMPILER(MSVC)
275 #pragma warning(pop)
276 #endif
277
278 #endif // ENABLE(GLOBAL_FASTMALLOC_NEW)
279 #endif // !defined(_CRTDBG_MAP_ALLOC) && !(defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC)
280
281 #define WTF_FASTMALLOC_OPERATORS \
282 public: \
283     void* operator new(size_t, void* p) { return p; } \
284     void* operator new[](size_t, void* p) { return p; } \
285     \
286     void* operator new(size_t size) \
287     { \
288         void* p = ::WTF::fastMalloc(size); \
289         ::WTF::fastMallocMatchValidateMalloc(p, ::WTF::Internal::AllocTypeClassNew); \
290         return p; \
291     } \
292     \
293     void operator delete(void* p) \
294     { \
295         ::WTF::fastMallocMatchValidateFree(p, ::WTF::Internal::AllocTypeClassNew); \
296         ::WTF::fastFree(p); \
297     } \
298     \
299     void* operator new[](size_t size) \
300     { \
301         void* p = ::WTF::fastMalloc(size); \
302         ::WTF::fastMallocMatchValidateMalloc(p, ::WTF::Internal::AllocTypeClassNewArray); \
303         return p; \
304     } \
305     \
306     void operator delete[](void* p) \
307     { \
308         ::WTF::fastMallocMatchValidateFree(p, ::WTF::Internal::AllocTypeClassNewArray); \
309         ::WTF::fastFree(p); \
310     } \
311     void* operator new(size_t, NotNullTag, void* location) \
312     { \
313         ASSERT(location); \
314         return location; \
315     } \
316 private: \
317 typedef int __thisIsHereToForceASemicolonAfterThisMacro
318
319 #if ENABLE(GLOBAL_FASTMALLOC_NEW)
320 #define WTF_MAKE_FAST_ALLOCATED
321 #else
322 #define WTF_MAKE_FAST_ALLOCATED WTF_FASTMALLOC_OPERATORS
323 #endif
324
325
326 #endif /* WTF_FastMalloc_h */