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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: sw=2 ts=4 et :
*/
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_mozalloc_h
#define mozilla_mozalloc_h
/*
* https://bugzilla.mozilla.org/show_bug.cgi?id=427099
*/
#if defined(__cplusplus)
# include <new>
// Since libstdc++ 6, including the C headers (e.g. stdlib.h) instead of the
// corresponding C++ header (e.g. cstdlib) can cause confusion in C++ code
// using things defined there. Specifically, with stdlib.h, the use of abs()
// in gfx/graphite2/src/inc/UtfCodec.h somehow ends up picking the wrong abs()
# include <cstdlib>
#else
# include <stdlib.h>
#endif
#if defined(MOZ_MEMORY) && defined(IMPL_MFBT)
# define MOZ_MEMORY_IMPL
# include "mozmemory_wrap.h"
# define MALLOC_FUNCS MALLOC_FUNCS_MALLOC
// See mozmemory_wrap.h for more details. Files that are part of libmozglue,
// need to use _impl suffixes, which is becoming cumbersome. We'll have to use
// something like a malloc.h wrapper and allow the use of the functions without
// a _impl suffix. In the meanwhile, this is enough to get by for C++ code.
# define NOTHROW_MALLOC_DECL(name, return_type, ...) \
MOZ_MEMORY_API return_type name##_impl(__VA_ARGS__) noexcept(true);
# define MALLOC_DECL(name, return_type, ...) \
MOZ_MEMORY_API return_type name##_impl(__VA_ARGS__);
# include "malloc_decls.h"
#endif
#if defined(__cplusplus)
# include "mozilla/fallible.h"
# include "mozilla/mozalloc_abort.h"
# include "mozilla/TemplateLib.h"
#endif
#include "mozilla/Attributes.h"
#include "mozilla/Types.h"
MOZ_BEGIN_EXTERN_C
/*
* We need to use malloc_impl and free_impl in this file when they are
* defined, because of how mozglue.dll is linked on Windows, where using
* malloc/free would end up using the symbols from the MSVCRT instead of
* ours.
*/
#ifndef free_impl
# define free_impl free
# define free_impl_
#endif
#ifndef malloc_impl
# define malloc_impl malloc
# define malloc_impl_
#endif
/*
* Each declaration below is analogous to a "standard" allocation
* function, except that the out-of-memory handling is made explicit.
* The |moz_x| versions will never return a NULL pointer; if memory
* is exhausted, they abort. The |moz_| versions may return NULL
* pointers if memory is exhausted: their return value must be checked.
*
* All these allocation functions are *guaranteed* to return a pointer
* to memory allocated in such a way that that memory can be freed by
* passing that pointer to |free()|.
*/
MFBT_API void* moz_xmalloc(size_t size) MOZ_INFALLIBLE_ALLOCATOR;
MFBT_API void* moz_xcalloc(size_t nmemb, size_t size) MOZ_INFALLIBLE_ALLOCATOR;
MFBT_API void* moz_xrealloc(void* ptr, size_t size) MOZ_INFALLIBLE_ALLOCATOR;
MFBT_API char* moz_xstrdup(const char* str) MOZ_INFALLIBLE_ALLOCATOR;
#if defined(HAVE_STRNDUP)
MFBT_API char* moz_xstrndup(const char* str,
size_t strsize) MOZ_INFALLIBLE_ALLOCATOR;
#endif /* if defined(HAVE_STRNDUP) */
MFBT_API void* moz_xmemdup(const void* ptr,
size_t size) MOZ_INFALLIBLE_ALLOCATOR;
MFBT_API void* moz_xmemalign(size_t boundary,
size_t size) MOZ_INFALLIBLE_ALLOCATOR;
MFBT_API size_t moz_malloc_usable_size(void* ptr);
MFBT_API size_t moz_malloc_size_of(const void* ptr);
/*
* Like moz_malloc_size_of(), but works reliably with interior pointers, i.e.
* pointers into the middle of a live allocation.
*/
MFBT_API size_t moz_malloc_enclosing_size_of(const void* ptr);
MOZ_END_EXTERN_C
#ifdef __cplusplus
/* NB: This is defined with MFBT_API just to silence vacuous warnings
* about symbol visibility on OS X/gcc.
* These symbols are force-inline mainly for performance reasons, and
* not exported. While the standard doesn't allow that, we are in a
* controlled environment where the issues the standard tries to
* prevent don't apply, and we can't end up in situations where
* operator new and operator delete are inconsistent. */
# ifdef __clang__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Winline-new-delete"
# endif
# if defined(XP_MACOSX)
# define MOZALLOC_EXPORT_NEW MFBT_API MOZ_ALWAYS_INLINE_EVEN_DEBUG
# else
# define MOZALLOC_EXPORT_NEW MOZ_ALWAYS_INLINE_EVEN_DEBUG
# endif
# include "mozilla/cxxalloc.h"
# ifdef __clang__
# pragma clang diagnostic pop
# endif
/*
* This policy is identical to MallocAllocPolicy, except it uses
* moz_xmalloc/moz_xcalloc/moz_xrealloc instead of
* malloc/calloc/realloc.
*/
class InfallibleAllocPolicy {
public:
template <typename T>
T* maybe_pod_malloc(size_t aNumElems) {
return pod_malloc<T>(aNumElems);
}
template <typename T>
T* maybe_pod_calloc(size_t aNumElems) {
return pod_calloc<T>(aNumElems);
}
template <typename T>
T* maybe_pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize) {
return pod_realloc<T>(aPtr, aOldSize, aNewSize);
}
template <typename T>
T* pod_malloc(size_t aNumElems) {
if (aNumElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
reportAllocOverflow();
}
return static_cast<T*>(moz_xmalloc(aNumElems * sizeof(T)));
}
template <typename T>
T* pod_calloc(size_t aNumElems) {
return static_cast<T*>(moz_xcalloc(aNumElems, sizeof(T)));
}
template <typename T>
T* pod_realloc(T* aPtr, size_t aOldSize, size_t aNewSize) {
if (aNewSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value) {
reportAllocOverflow();
}
return static_cast<T*>(moz_xrealloc(aPtr, aNewSize * sizeof(T)));
}
template <typename T>
void free_(T* aPtr, size_t aNumElems = 0) {
free_impl(aPtr);
}
void reportAllocOverflow() const { mozalloc_abort("alloc overflow"); }
bool checkSimulatedOOM() const { return true; }
};
#endif /* ifdef __cplusplus */
#ifdef malloc_impl_
# undef malloc_impl_
# undef malloc_impl
#endif
#ifdef free_impl_
# undef free_impl_
# undef free_impl
#endif
#endif /* ifndef mozilla_mozalloc_h */
|
