1 /******************************************************************************/
2 #ifdef JEMALLOC_H_TYPES
3
4 /* Size of stack-allocated buffer passed to buferror(). */
5 #define BUFERROR_BUF 64
6
7 /*
8 * Size of stack-allocated buffer used by malloc_{,v,vc}printf(). This must be
9 * large enough for all possible uses within jemalloc.
10 */
11 #define MALLOC_PRINTF_BUFSIZE 4096
12
13 /*
14 * Wrap a cpp argument that contains commas such that it isn't broken up into
15 * multiple arguments.
16 */
17 #define JEMALLOC_ARG_CONCAT(...) __VA_ARGS__
18
19 /*
20 * Silence compiler warnings due to uninitialized values. This is used
21 * wherever the compiler fails to recognize that the variable is never used
22 * uninitialized.
23 */
24 #ifdef JEMALLOC_CC_SILENCE
25 # define JEMALLOC_CC_SILENCE_INIT(v) = v
26 #else
27 # define JEMALLOC_CC_SILENCE_INIT(v)
28 #endif
29
30 /*
31 * Define a custom assert() in order to reduce the chances of deadlock during
32 * assertion failure.
33 */
34 #ifndef assert
35 #define assert(e) do { \
36 if (config_debug && !(e)) { \
37 malloc_printf( \
38 "<jemalloc>: %s:%d: Failed assertion: \"%s\"\n", \
39 __FILE__, __LINE__, #e); \
40 abort(); \
41 } \
42 } while (0)
43 #endif
44
45 #ifndef not_reached
46 #define not_reached() do { \
47 if (config_debug) { \
48 malloc_printf( \
49 "<jemalloc>: %s:%d: Unreachable code reached\n", \
50 __FILE__, __LINE__); \
51 abort(); \
52 } \
53 } while (0)
54 #endif
55
56 #ifndef not_implemented
57 #define not_implemented() do { \
58 if (config_debug) { \
59 malloc_printf("<jemalloc>: %s:%d: Not implemented\n", \
60 __FILE__, __LINE__); \
61 abort(); \
62 } \
63 } while (0)
64 #endif
65
66 #ifndef assert_not_implemented
67 #define assert_not_implemented(e) do { \
68 if (config_debug && !(e)) \
69 not_implemented(); \
70 } while (0)
71 #endif
72
73 /* Use to assert a particular configuration, e.g., cassert(config_debug). */
74 #define cassert(c) do { \
75 if ((c) == false) \
76 not_reached(); \
77 } while (0)
78
79 #endif /* JEMALLOC_H_TYPES */
80 /******************************************************************************/
81 #ifdef JEMALLOC_H_STRUCTS
82
83 #endif /* JEMALLOC_H_STRUCTS */
84 /******************************************************************************/
85 #ifdef JEMALLOC_H_EXTERNS
86
87 int buferror(int err, char *buf, size_t buflen);
88 uintmax_t malloc_strtoumax(const char *restrict nptr,
89 char **restrict endptr, int base);
90 void malloc_write(const char *s);
91
92 /*
93 * malloc_vsnprintf() supports a subset of snprintf(3) that avoids floating
94 * point math.
95 */
96 int malloc_vsnprintf(char *str, size_t size, const char *format,
97 va_list ap);
98 int malloc_snprintf(char *str, size_t size, const char *format, ...)
99 JEMALLOC_ATTR(format(printf, 3, 4));
100 void malloc_vcprintf(void (*write_cb)(void *, const char *), void *cbopaque,
101 const char *format, va_list ap);
102 void malloc_cprintf(void (*write)(void *, const char *), void *cbopaque,
103 const char *format, ...) JEMALLOC_ATTR(format(printf, 3, 4));
104 void malloc_printf(const char *format, ...)
105 JEMALLOC_ATTR(format(printf, 1, 2));
106
107 #endif /* JEMALLOC_H_EXTERNS */
108 /******************************************************************************/
109 #ifdef JEMALLOC_H_INLINES
110
111 #ifndef JEMALLOC_ENABLE_INLINE
112 int jemalloc_ffsl(long bitmap);
113 int jemalloc_ffs(int bitmap);
114 size_t pow2_ceil(size_t x);
115 size_t lg_floor(size_t x);
116 void set_errno(int errnum);
117 int get_errno(void);
118 #endif
119
120 #if (defined(JEMALLOC_ENABLE_INLINE) || defined(JEMALLOC_UTIL_C_))
121
122 /* Sanity check: */
123 #if !defined(JEMALLOC_INTERNAL_FFSL) || !defined(JEMALLOC_INTERNAL_FFS)
124 # error Both JEMALLOC_INTERNAL_FFSL && JEMALLOC_INTERNAL_FFS should have been defined by configure
125 #endif
126
127 JEMALLOC_ALWAYS_INLINE int
jemalloc_ffsl(long bitmap)128 jemalloc_ffsl(long bitmap)
129 {
130
131 return (JEMALLOC_INTERNAL_FFSL(bitmap));
132 }
133
134 JEMALLOC_ALWAYS_INLINE int
jemalloc_ffs(int bitmap)135 jemalloc_ffs(int bitmap)
136 {
137
138 return (JEMALLOC_INTERNAL_FFS(bitmap));
139 }
140
141 /* Compute the smallest power of 2 that is >= x. */
142 JEMALLOC_INLINE size_t
pow2_ceil(size_t x)143 pow2_ceil(size_t x)
144 {
145
146 x--;
147 x |= x >> 1;
148 x |= x >> 2;
149 x |= x >> 4;
150 x |= x >> 8;
151 x |= x >> 16;
152 #if (LG_SIZEOF_PTR == 3)
153 x |= x >> 32;
154 #endif
155 x++;
156 return (x);
157 }
158
159 #if (defined(__i386__) || defined(__amd64__) || defined(__x86_64__))
160 JEMALLOC_INLINE size_t
lg_floor(size_t x)161 lg_floor(size_t x)
162 {
163 size_t ret;
164
165 asm ("bsr %1, %0"
166 : "=r"(ret) // Outputs.
167 : "r"(x) // Inputs.
168 );
169 return (ret);
170 }
171 #elif (defined(JEMALLOC_HAVE_BUILTIN_CLZ))
172 JEMALLOC_INLINE size_t
lg_floor(size_t x)173 lg_floor(size_t x)
174 {
175
176 #if (LG_SIZEOF_PTR == LG_SIZEOF_INT)
177 return (((8 << LG_SIZEOF_PTR) - 1) - __builtin_clz(x));
178 #elif (LG_SIZEOF_PTR == LG_SIZEOF_LONG)
179 return (((8 << LG_SIZEOF_PTR) - 1) - __builtin_clzl(x));
180 #else
181 # error "Unsupported type sizes for lg_floor()"
182 #endif
183 }
184 #else
185 JEMALLOC_INLINE size_t
lg_floor(size_t x)186 lg_floor(size_t x)
187 {
188
189 x |= (x >> 1);
190 x |= (x >> 2);
191 x |= (x >> 4);
192 x |= (x >> 8);
193 x |= (x >> 16);
194 #if (LG_SIZEOF_PTR == 3 && LG_SIZEOF_PTR == LG_SIZEOF_LONG)
195 x |= (x >> 32);
196 if (x == KZU(0xffffffffffffffff))
197 return (63);
198 x++;
199 return (jemalloc_ffsl(x) - 2);
200 #elif (LG_SIZEOF_PTR == 2)
201 if (x == KZU(0xffffffff))
202 return (31);
203 x++;
204 return (jemalloc_ffs(x) - 2);
205 #else
206 # error "Unsupported type sizes for lg_floor()"
207 #endif
208 }
209 #endif
210
211 /* Sets error code */
212 JEMALLOC_INLINE void
set_errno(int errnum)213 set_errno(int errnum)
214 {
215
216 #ifdef _WIN32
217 SetLastError(errnum);
218 #else
219 errno = errnum;
220 #endif
221 }
222
223 /* Get last error code */
224 JEMALLOC_INLINE int
get_errno(void)225 get_errno(void)
226 {
227
228 #ifdef _WIN32
229 return (GetLastError());
230 #else
231 return (errno);
232 #endif
233 }
234 #endif
235
236 #endif /* JEMALLOC_H_INLINES */
237 /******************************************************************************/
238