1 // Copyright 2016 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifdef PARTITION_ALLOC_SHIM_ALLOCATOR_SHIM_OVERRIDE_CPP_SYMBOLS_H_
6 #error This header is meant to be included only once by allocator_shim.cc
7 #endif
8
9 #ifndef PARTITION_ALLOC_SHIM_ALLOCATOR_SHIM_OVERRIDE_CPP_SYMBOLS_H_
10 #define PARTITION_ALLOC_SHIM_ALLOCATOR_SHIM_OVERRIDE_CPP_SYMBOLS_H_
11
12 #include "partition_alloc/partition_alloc_buildflags.h"
13
14 #if BUILDFLAG(USE_ALLOCATOR_SHIM)
15 // Preempt the default new/delete C++ symbols so they call the shim entry
16 // points. This file is strongly inspired by tcmalloc's
17 // libc_override_redefine.h.
18
19 #include <new>
20
21 #include "build/build_config.h"
22 #include "partition_alloc/partition_alloc_base/compiler_specific.h"
23 #include "partition_alloc/shim/allocator_shim_internals.h"
24
25 #if !BUILDFLAG(IS_APPLE)
26 #define SHIM_CPP_SYMBOLS_EXPORT SHIM_ALWAYS_EXPORT
27 #else
28 // On Apple OSes, prefer not exporting these symbols (as this reverts to the
29 // default behavior, they are still exported in e.g. component builds). This is
30 // partly due to intentional limits on exported symbols in the main library, but
31 // it is also needless, since no library used on macOS imports these.
32 //
33 // TODO(lizeb): It may not be necessary anywhere to export these.
34 #define SHIM_CPP_SYMBOLS_EXPORT PA_NOINLINE
35 #endif
36
new(size_t size)37 SHIM_CPP_SYMBOLS_EXPORT void* operator new(size_t size) {
38 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
39 return malloc(size);
40 #else
41 return ShimCppNew(size);
42 #endif
43 }
44
delete(void * p)45 SHIM_CPP_SYMBOLS_EXPORT void operator delete(void* p) __THROW {
46 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
47 free(p);
48 #else
49 ShimCppDelete(p);
50 #endif
51 }
52
53 SHIM_CPP_SYMBOLS_EXPORT void* operator new[](size_t size) {
54 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
55 return malloc(size);
56 #else
57 return ShimCppNew(size);
58 #endif
59 }
60
61 SHIM_CPP_SYMBOLS_EXPORT void operator delete[](void* p) __THROW {
62 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
63 free(p);
64 #else
65 ShimCppDelete(p);
66 #endif
67 }
68
new(size_t size,const std::nothrow_t &)69 SHIM_CPP_SYMBOLS_EXPORT void* operator new(size_t size,
70 const std::nothrow_t&) __THROW {
71 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
72 return malloc(size);
73 #else
74 return ShimCppNewNoThrow(size);
75 #endif
76 }
77
78 SHIM_CPP_SYMBOLS_EXPORT void* operator new[](size_t size,
79 const std::nothrow_t&) __THROW {
80 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
81 return malloc(size);
82 #else
83 return ShimCppNewNoThrow(size);
84 #endif
85 }
86
delete(void * p,const std::nothrow_t &)87 SHIM_CPP_SYMBOLS_EXPORT void operator delete(void* p,
88 const std::nothrow_t&) __THROW {
89 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
90 free(p);
91 #else
92 ShimCppDelete(p);
93 #endif
94 }
95
96 SHIM_CPP_SYMBOLS_EXPORT void operator delete[](void* p,
97 const std::nothrow_t&) __THROW {
98 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
99 free(p);
100 #else
101 ShimCppDelete(p);
102 #endif
103 }
104
delete(void * p,size_t)105 SHIM_CPP_SYMBOLS_EXPORT void operator delete(void* p, size_t) __THROW {
106 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
107 free(p);
108 #else
109 ShimCppDelete(p);
110 #endif
111 }
112
113 SHIM_CPP_SYMBOLS_EXPORT void operator delete[](void* p, size_t) __THROW {
114 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
115 free(p);
116 #else
117 ShimCppDelete(p);
118 #endif
119 }
120
new(std::size_t size,std::align_val_t alignment)121 SHIM_CPP_SYMBOLS_EXPORT void* operator new(std::size_t size,
122 std::align_val_t alignment) {
123 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
124 return aligned_alloc(static_cast<size_t>(alignment), size);
125 #else
126 return ShimCppAlignedNew(size, static_cast<size_t>(alignment));
127 #endif
128 }
129
new(std::size_t size,std::align_val_t alignment,const std::nothrow_t &)130 SHIM_CPP_SYMBOLS_EXPORT void* operator new(std::size_t size,
131 std::align_val_t alignment,
132 const std::nothrow_t&) __THROW {
133 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
134 return aligned_alloc(static_cast<size_t>(alignment), size);
135 #else
136 return ShimCppAlignedNew(size, static_cast<size_t>(alignment));
137 #endif
138 }
139
delete(void * p,std::align_val_t)140 SHIM_CPP_SYMBOLS_EXPORT void operator delete(void* p,
141 std::align_val_t) __THROW {
142 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
143 free(p);
144 #else
145 ShimCppDelete(p);
146 #endif
147 }
148
delete(void * p,std::size_t size,std::align_val_t)149 SHIM_CPP_SYMBOLS_EXPORT void operator delete(void* p,
150 std::size_t size,
151 std::align_val_t) __THROW {
152 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
153 free(p);
154 #else
155 ShimCppDelete(p);
156 #endif
157 }
158
delete(void * p,std::align_val_t,const std::nothrow_t &)159 SHIM_CPP_SYMBOLS_EXPORT void operator delete(void* p,
160 std::align_val_t,
161 const std::nothrow_t&) __THROW {
162 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
163 free(p);
164 #else
165 ShimCppDelete(p);
166 #endif
167 }
168
169 SHIM_CPP_SYMBOLS_EXPORT void* operator new[](std::size_t size,
170 std::align_val_t alignment) {
171 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
172 return aligned_alloc(static_cast<size_t>(alignment), size);
173 #else
174 return ShimCppAlignedNew(size, static_cast<size_t>(alignment));
175 #endif
176 }
177
178 SHIM_CPP_SYMBOLS_EXPORT void* operator new[](std::size_t size,
179 std::align_val_t alignment,
180 const std::nothrow_t&) __THROW {
181 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
182 return aligned_alloc(static_cast<size_t>(alignment), size);
183 #else
184 return ShimCppAlignedNew(size, static_cast<size_t>(alignment));
185 #endif
186 }
187
188 SHIM_CPP_SYMBOLS_EXPORT void operator delete[](void* p,
189 std::align_val_t) __THROW {
190 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
191 free(p);
192 #else
193 ShimCppDelete(p);
194 #endif
195 }
196
197 SHIM_CPP_SYMBOLS_EXPORT void operator delete[](void* p,
198 std::size_t size,
199 std::align_val_t) __THROW {
200 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
201 free(p);
202 #else
203 ShimCppDelete(p);
204 #endif
205 }
206
207 SHIM_CPP_SYMBOLS_EXPORT void operator delete[](void* p,
208 std::align_val_t,
209 const std::nothrow_t&) __THROW {
210 #if BUILDFLAG(FORWARD_THROUGH_MALLOC)
211 free(p);
212 #else
213 ShimCppDelete(p);
214 #endif
215 }
216
217 #endif // BUILDFLAG(USE_ALLOCATOR_SHIM)
218
219 #endif // PARTITION_ALLOC_SHIM_ALLOCATOR_SHIM_OVERRIDE_CPP_SYMBOLS_H_
220