← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WTF/wtf/FastMalloc.h

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 <wtf/Platform.h>
 
25
#include <wtf/PossiblyNull.h>
 
26
#include <stdlib.h>
 
27
#include <new>
 
28
 
 
29
namespace WTF {
 
30
 
 
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*);
 
38
 
 
39
    struct TryMallocReturnValue {
 
40
        TryMallocReturnValue(void* data)
 
41
            : m_data(data)
 
42
        {
 
43
        }
 
44
        TryMallocReturnValue(const TryMallocReturnValue& source)
 
45
            : m_data(source.m_data)
 
46
        {
 
47
            source.m_data = 0;
 
48
        }
 
49
        ~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
    
 
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
    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);
 
75
 
 
76
    WTF_EXPORT_PRIVATE void fastFree(void*);
 
77
 
 
78
#ifndef NDEBUG    
 
79
    WTF_EXPORT_PRIVATE void fastMallocForbid();
 
80
    WTF_EXPORT_PRIVATE void fastMallocAllow();
 
81
#endif
 
82
 
 
83
    WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemory();
 
84
    
 
85
    struct FastMallocStatistics {
 
86
        size_t reservedVMBytes;
 
87
        size_t committedVMBytes;
 
88
        size_t freeListBytes;
 
89
    };
 
90
    WTF_EXPORT_PRIVATE 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
        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::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;
 
234
 
 
235
#ifndef NDEBUG    
 
236
using WTF::fastMallocForbid;
 
237
using WTF::fastMallocAllow;
 
238
#endif
 
239
 
 
240
#if COMPILER(GCC) && OS(DARWIN)
 
241
#define WTF_PRIVATE_INLINE __private_extern__ inline __attribute__((always_inline))
 
242
#elif COMPILER(GCC)
 
243
#define WTF_PRIVATE_INLINE inline __attribute__((always_inline))
 
244
#elif COMPILER(MSVC) || COMPILER(RVCT)
 
245
#define WTF_PRIVATE_INLINE __forceinline
 
246
#else
 
247
#define WTF_PRIVATE_INLINE inline
 
248
#endif
 
249
 
 
250
#if !defined(_CRTDBG_MAP_ALLOC) && !(defined(USE_SYSTEM_MALLOC) && USE_SYSTEM_MALLOC)
 
251
 
 
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
 
257
// new by accident.
 
258
 
 
259
#if ENABLE(GLOBAL_FASTMALLOC_NEW)
 
260
 
 
261
#if COMPILER(MSVC)
 
262
#pragma warning(push)
 
263
#pragma warning(disable: 4290) // Disable the C++ exception specification ignored warning.
 
264
#endif
 
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); }
 
273
#if COMPILER(MSVC)
 
274
#pragma warning(pop)
 
275
#endif
 
276
 
 
277
#endif
 
278
 
 
279
#endif
 
280
 
 
281
#endif /* WTF_FastMalloc_h */