169 lines
3.8 KiB
C++
169 lines
3.8 KiB
C++
// Copyright (c) 2009 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// When possible, we implement allocator functions on top of the basic
|
|
// low-level functions malloc() and free(). This way, including a new
|
|
// allocator is as simple as providing just a small interface.
|
|
//
|
|
// As such, this file should not contain any allocator-specific code.
|
|
|
|
// Implement a C++ style allocation, which always calls the new_handler
|
|
// on failure.
|
|
inline void* generic_cpp_alloc(size_t size, bool nothrow) {
|
|
void* ptr;
|
|
for (;;) {
|
|
ptr = malloc(size);
|
|
if (ptr)
|
|
return ptr;
|
|
if (!call_new_handler(nothrow))
|
|
break;
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
extern "C++" {
|
|
|
|
void* __cdecl operator new(size_t size) {
|
|
return generic_cpp_alloc(size, false);
|
|
}
|
|
|
|
void operator delete(void* p) __THROW {
|
|
free(p);
|
|
}
|
|
|
|
void* operator new[](size_t size) {
|
|
return generic_cpp_alloc(size, false);
|
|
}
|
|
|
|
void operator delete[](void* p) __THROW {
|
|
free(p);
|
|
}
|
|
|
|
void* operator new(size_t size, const std::nothrow_t& nt) __THROW {
|
|
return generic_cpp_alloc(size, true);
|
|
}
|
|
|
|
void* operator new[](size_t size, const std::nothrow_t& nt) __THROW {
|
|
return generic_cpp_alloc(size, true);
|
|
}
|
|
|
|
// This function behaves similarly to MSVC's _set_new_mode.
|
|
// If flag is 0 (default), calls to malloc will behave normally.
|
|
// If flag is 1, calls to malloc will behave like calls to new,
|
|
// and the std_new_handler will be invoked on failure.
|
|
// Returns the previous mode.
|
|
int _set_new_mode(int flag) __THROW {
|
|
int old_mode = new_mode;
|
|
new_mode = flag;
|
|
return old_mode;
|
|
}
|
|
|
|
} // extern "C++"
|
|
|
|
extern "C" {
|
|
|
|
void* calloc(size_t n, size_t elem_size) __THROW {
|
|
// Overflow check
|
|
const size_t size = n * elem_size;
|
|
if (elem_size != 0 && size / elem_size != n) return NULL;
|
|
|
|
void* result = malloc(size);
|
|
if (result != NULL) {
|
|
memset(result, 0, size);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void cfree(void* p) __THROW {
|
|
free(p);
|
|
}
|
|
|
|
#ifdef WIN32
|
|
|
|
void* _recalloc(void* p, size_t n, size_t elem_size) {
|
|
if (!p)
|
|
return calloc(n, elem_size);
|
|
|
|
// This API is a bit odd.
|
|
// Note: recalloc only guarantees zeroed memory when p is NULL.
|
|
// Generally, calls to malloc() have padding. So a request
|
|
// to malloc N bytes actually malloc's N+x bytes. Later, if
|
|
// that buffer is passed to recalloc, we don't know what N
|
|
// was anymore. We only know what N+x is. As such, there is
|
|
// no way to know what to zero out.
|
|
const size_t size = n * elem_size;
|
|
if (elem_size != 0 && size / elem_size != n) return NULL;
|
|
return realloc(p, size);
|
|
}
|
|
|
|
void* _calloc_impl(size_t n, size_t size) {
|
|
return calloc(n, size);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
#undef malloc
|
|
#undef free
|
|
#undef calloc
|
|
|
|
static int error_handler(int reportType) {
|
|
switch (reportType) {
|
|
case 0: // _CRT_WARN
|
|
__debugbreak();
|
|
return 0;
|
|
|
|
case 1: // _CRT_ERROR
|
|
__debugbreak();
|
|
return 0;
|
|
|
|
case 2: // _CRT_ASSERT
|
|
__debugbreak();
|
|
return 0;
|
|
}
|
|
char* p = NULL;
|
|
*p = '\0';
|
|
return 0;
|
|
}
|
|
|
|
int _CrtDbgReport(int reportType,
|
|
const char*,
|
|
int, const char*,
|
|
const char*,
|
|
...) {
|
|
return error_handler(reportType);
|
|
}
|
|
|
|
int _CrtDbgReportW(int reportType,
|
|
const wchar_t*,
|
|
int, const wchar_t*,
|
|
const wchar_t*,
|
|
...) {
|
|
return error_handler(reportType);
|
|
}
|
|
|
|
int _CrtSetReportMode(int, int) {
|
|
return 0;
|
|
}
|
|
|
|
void* _malloc_dbg(size_t size, int , const char*, int) {
|
|
return malloc(size);
|
|
}
|
|
|
|
void* _realloc_dbg(void* ptr, size_t size, int, const char*, int) {
|
|
return realloc(ptr, size);
|
|
}
|
|
|
|
void _free_dbg(void* ptr, int) {
|
|
free(ptr);
|
|
}
|
|
|
|
void* _calloc_dbg(size_t n, size_t size, int, const char*, int) {
|
|
return calloc(n, size);
|
|
}
|
|
#endif // NDEBUG
|
|
|
|
#endif // WIN32
|
|
|
|
} // extern C
|
|
|