wtf/wince/FastMallocWinCE.h

   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
  70 static inline void* __cdecl operator new(size_t s) { return fastMalloc(s); }
  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); }
  74 static inline void* operator new(size_t s, const std::nothrow_t&) throw() { return fastMalloc(s); }
  75 static inline void operator delete(void* p, const std::nothrow_t&) throw() { fastFree(p); }
  76 static inline void* operator new[](size_t s, const std::nothrow_t&) throw() { return fastMalloc(s); }
  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.
 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.
 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.
 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.
 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.
 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
 161     inline void fastMallocMatchValidateMalloc(void*, Internal::AllocType)
 162     {
 163     }
 164
 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