1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // When possible, we implement allocator functions on top of the basic 6 // low-level functions malloc() and free(). This way, including a new 7 // allocator is as simple as providing just a small interface. 8 // 9 // As such, this file should not contain any allocator-specific code. 10 11 // Implement a C++ style allocation, which always calls the new_handler 12 // on failure. 13 inline void* generic_cpp_alloc(size_t size, bool nothrow) { 14 void* ptr; 15 for (;;) { 16 ptr = malloc(size); 17 if (ptr) 18 return ptr; 19 if (!call_new_handler(nothrow)) 20 break; 21 } 22 return ptr; 23 } 24 25 extern "C++" { 26 27 void* __cdecl operator new(size_t size) { 28 return generic_cpp_alloc(size, false); 29 } 30 31 void operator delete(void* p) __THROW { 32 free(p); 33 } 34 35 void* operator new[](size_t size) { 36 return generic_cpp_alloc(size, false); 37 } 38 39 void operator delete[](void* p) __THROW { 40 free(p); 41 } 42 43 void* operator new(size_t size, const std::nothrow_t& nt) __THROW { 44 return generic_cpp_alloc(size, true); 45 } 46 47 void* operator new[](size_t size, const std::nothrow_t& nt) __THROW { 48 return generic_cpp_alloc(size, true); 49 } 50 51 // This function behaves similarly to MSVC's _set_new_mode. 52 // If flag is 0 (default), calls to malloc will behave normally. 53 // If flag is 1, calls to malloc will behave like calls to new, 54 // and the std_new_handler will be invoked on failure. 55 // Returns the previous mode. 56 int _set_new_mode(int flag) __THROW { 57 int old_mode = new_mode; 58 new_mode = flag; 59 return old_mode; 60 } 61 62 } // extern "C++" 63 64 extern "C" { 65 66 void* calloc(size_t n, size_t elem_size) __THROW { 67 // Overflow check 68 const size_t size = n * elem_size; 69 if (elem_size != 0 && size / elem_size != n) return NULL; 70 71 void* result = malloc(size); 72 if (result != NULL) { 73 memset(result, 0, size); 74 } 75 return result; 76 } 77 78 void cfree(void* p) __THROW { 79 free(p); 80 } 81 82 #ifdef WIN32 83 84 void* _recalloc(void* p, size_t n, size_t elem_size) { 85 if (!p) 86 return calloc(n, elem_size); 87 88 // This API is a bit odd. 89 // Note: recalloc only guarantees zeroed memory when p is NULL. 90 // Generally, calls to malloc() have padding. So a request 91 // to malloc N bytes actually malloc's N+x bytes. Later, if 92 // that buffer is passed to recalloc, we don't know what N 93 // was anymore. We only know what N+x is. As such, there is 94 // no way to know what to zero out. 95 const size_t size = n * elem_size; 96 if (elem_size != 0 && size / elem_size != n) return NULL; 97 return realloc(p, size); 98 } 99 100 void* _calloc_impl(size_t n, size_t size) { 101 return calloc(n, size); 102 } 103 104 #ifndef NDEBUG 105 #undef malloc 106 #undef free 107 #undef calloc 108 109 static int error_handler(int reportType) { 110 switch (reportType) { 111 case 0: // _CRT_WARN 112 __debugbreak(); 113 return 0; 114 115 case 1: // _CRT_ERROR 116 __debugbreak(); 117 return 0; 118 119 case 2: // _CRT_ASSERT 120 __debugbreak(); 121 return 0; 122 } 123 char* p = NULL; 124 *p = '\0'; 125 return 0; 126 } 127 128 int _CrtDbgReport(int reportType, 129 const char*, 130 int, const char*, 131 const char*, 132 ...) { 133 return error_handler(reportType); 134 } 135 136 int _CrtDbgReportW(int reportType, 137 const wchar_t*, 138 int, const wchar_t*, 139 const wchar_t*, 140 ...) { 141 return error_handler(reportType); 142 } 143 144 int _CrtSetReportMode(int, int) { 145 return 0; 146 } 147 148 void* _malloc_dbg(size_t size, int , const char*, int) { 149 return malloc(size); 150 } 151 152 void* _realloc_dbg(void* ptr, size_t size, int, const char*, int) { 153 return realloc(ptr, size); 154 } 155 156 void _free_dbg(void* ptr, int) { 157 free(ptr); 158 } 159 160 void* _calloc_dbg(size_t n, size_t size, int, const char*, int) { 161 return calloc(n, size); 162 } 163 #endif // NDEBUG 164 165 #endif // WIN32 166 167 } // extern C 168 169
