Home | History | Annotate | Download | only in wtf 
      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 && !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
    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 */
    242