1 /*
2 * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
3 * Copyright (C) 2007-2009 Torch Mobile, Inc. All rights reserved
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public License
16 * along with this library; see the file COPYING.LIB. If not, write to
17 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
19 *
20 */
21
22 #ifndef WTF_FastMallocWinCE_h
23 #define WTF_FastMallocWinCE_h
24
25 #include <new.h>
26
27 #ifdef __cplusplus
28 #include <new>
29 #include "MemoryManager.h"
30 extern "C" {
31 #endif
32
33 void* fastMalloc(size_t n);
34 void* fastCalloc(size_t n_elements, size_t element_size);
35 void fastFree(void* p);
36 void* fastRealloc(void* p, size_t n);
37 void* fastZeroedMalloc(size_t n);
38 // These functions return 0 if an allocation fails.
39 void* tryFastMalloc(size_t n);
40 void* tryFastZeroedMalloc(size_t n);
41 void* tryFastCalloc(size_t n_elements, size_t element_size);
42 void* tryFastRealloc(void* p, size_t n);
43 char* fastStrDup(const char*);
44
45 #ifndef NDEBUG
46 void fastMallocForbid();
47 void fastMallocAllow();
48 #endif
49
50 #if !defined(USE_SYSTEM_MALLOC) || !USE_SYSTEM_MALLOC
51
52 #define malloc(n) fastMalloc(n)
53 #define calloc(n_elements, element_size) fastCalloc(n_elements, element_size)
54 #define realloc(p, n) fastRealloc(p, n)
55 #define free(p) fastFree(p)
56 #define strdup(p) fastStrDup(p)
57
58 #else
59
60 #define strdup(p) _strdup(p)
61
62 #endif
63
64 #ifdef __cplusplus
65 }
66 #endif
67
68 #ifdef __cplusplus
69 #if !defined(USE_SYSTEM_MALLOC) || !USE_SYSTEM_MALLOC
new(size_t s)70 static inline void* __cdecl operator new(size_t s) { return fastMalloc(s); }
delete(void * p)71 static inline void __cdecl operator delete(void* p) { fastFree(p); }
72 static inline void* __cdecl operator new[](size_t s) { return fastMalloc(s); }
73 static inline void __cdecl operator delete[](void* p) { fastFree(p); }
new(size_t s,const std::nothrow_t &)74 static inline void* operator new(size_t s, const std::nothrow_t&) throw() { return fastMalloc(s); }
delete(void * p,const std::nothrow_t &)75 static inline void operator delete(void* p, const std::nothrow_t&) throw() { fastFree(p); }
throw()76 static inline void* operator new[](size_t s, const std::nothrow_t&) throw() { return fastMalloc(s); }
throw()77 static inline void operator delete[](void* p, const std::nothrow_t&) throw() { fastFree(p); }
78 #endif
79
80 namespace WTF {
81 // This defines a type which holds an unsigned integer and is the same
82 // size as the minimally aligned memory allocation.
83 typedef unsigned long long AllocAlignmentInteger;
84
85 namespace Internal {
86 enum AllocType { // Start with an unusual number instead of zero, because zero is common.
87 AllocTypeMalloc = 0x375d6750, // Encompasses fastMalloc, fastZeroedMalloc, fastCalloc, fastRealloc.
88 AllocTypeClassNew, // Encompasses class operator new from FastAllocBase.
89 AllocTypeClassNewArray, // Encompasses class operator new[] from FastAllocBase.
90 AllocTypeFastNew, // Encompasses fastNew.
91 AllocTypeFastNewArray, // Encompasses fastNewArray.
92 AllocTypeNew, // Encompasses global operator new.
93 AllocTypeNewArray // Encompasses global operator new[].
94 };
95 }
96
97
98 #if ENABLE(FAST_MALLOC_MATCH_VALIDATION)
99
100 // Malloc validation is a scheme whereby a tag is attached to an
101 // allocation which identifies how it was originally allocated.
102 // This allows us to verify that the freeing operation matches the
103 // allocation operation. If memory is allocated with operator new[]
104 // but freed with free or delete, this system would detect that.
105 // In the implementation here, the tag is an integer prepended to
106 // the allocation memory which is assigned one of the AllocType
107 // enumeration values. An alternative implementation of this
108 // scheme could store the tag somewhere else or ignore it.
109 // Users of FastMalloc don't need to know or care how this tagging
110 // is implemented.
111
112 namespace Internal {
113
114 // Return the AllocType tag associated with the allocated block p.
fastMallocMatchValidationType(const void * p)115 inline AllocType fastMallocMatchValidationType(const void* p)
116 {
117 const AllocAlignmentInteger* type = static_cast<const AllocAlignmentInteger*>(p) - 1;
118 return static_cast<AllocType>(*type);
119 }
120
121 // Return the address of the AllocType tag associated with the allocated block p.
fastMallocMatchValidationValue(void * p)122 inline AllocAlignmentInteger* fastMallocMatchValidationValue(void* p)
123 {
124 return reinterpret_cast<AllocAlignmentInteger*>(static_cast<char*>(p) - sizeof(AllocAlignmentInteger));
125 }
126
127 // Set the AllocType tag to be associaged with the allocated block p.
setFastMallocMatchValidationType(void * p,AllocType allocType)128 inline void setFastMallocMatchValidationType(void* p, AllocType allocType)
129 {
130 AllocAlignmentInteger* type = static_cast<AllocAlignmentInteger*>(p) - 1;
131 *type = static_cast<AllocAlignmentInteger>(allocType);
132 }
133
134 // Handle a detected alloc/free mismatch. By default this calls CRASH().
135 void fastMallocMatchFailed(void* p);
136
137 } // namespace Internal
138
139 // This is a higher level function which is used by FastMalloc-using code.
fastMallocMatchValidateMalloc(void * p,Internal::AllocType allocType)140 inline void fastMallocMatchValidateMalloc(void* p, Internal::AllocType allocType)
141 {
142 if (!p)
143 return;
144
145 Internal::setFastMallocMatchValidationType(p, allocType);
146 }
147
148 // This is a higher level function which is used by FastMalloc-using code.
fastMallocMatchValidateFree(void * p,Internal::AllocType allocType)149 inline void fastMallocMatchValidateFree(void* p, Internal::AllocType allocType)
150 {
151 if (!p)
152 return;
153
154 if (Internal::fastMallocMatchValidationType(p) != allocType)
155 Internal::fastMallocMatchFailed(p);
156 Internal::setFastMallocMatchValidationType(p, Internal::AllocTypeMalloc); // Set it to this so that fastFree thinks it's OK.
157 }
158
159 #else
160
fastMallocMatchValidateMalloc(void *,Internal::AllocType)161 inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
162 {
163 }
164
fastMallocMatchValidateFree(void *,Internal::AllocType)165 inline void fastMallocMatchValidateFree(void*, Internal::AllocType)
166 {
167 }
168
169 #endif
170
171 } // namespace WTF
172
173 #endif
174
175 #endif // WTF_FastMallocWinCE_h
176