1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
// 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
int _CrtDbgReport(int, const char*, int, const char*, const char*, ...) {
return 0;
}
int _CrtDbgReportW(int, const wchar_t*, int, const wchar_t*,
const wchar_t*, ...) {
return 0;
}
int _CrtSetReportMode(int, int) {
return 0;
}
void* _malloc_dbg(size_t size, int , const char*, int) {
return malloc(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
|
