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 "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 {
  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     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.
 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.
 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.
 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.
 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.
 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
 171     inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
 172     {
 173     }
 174
 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)
 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
 225 WTF_PRIVATE_INLINE void* operator new(size_t size) throw (std::bad_alloc) { return fastMalloc(size); }
 226 WTF_PRIVATE_INLINE void* operator new(size_t size, const std::nothrow_t&) throw() { return fastMalloc(size); }
 227 WTF_PRIVATE_INLINE void operator delete(void* p) throw() { fastFree(p); }
 228 WTF_PRIVATE_INLINE void operator delete(void* p, const std::nothrow_t&) throw() { fastFree(p); }
 229 WTF_PRIVATE_INLINE void* operator new[](size_t size) throw (std::bad_alloc) { return fastMalloc(size); }
 230 WTF_PRIVATE_INLINE void* operator new[](size_t size, const std::nothrow_t&) throw() { return fastMalloc(size); }
 231 WTF_PRIVATE_INLINE void operator delete[](void* p) throw() { fastFree(p); }
 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 */