]> git.proxmox.com Git - rustc.git/blob - src/jemalloc/src/util.c
Imported Upstream version 1.9.0+dfsg1
[rustc.git] / src / jemalloc / src / util.c
1 /*
2 * Define simple versions of assertion macros that won't recurse in case
3 * of assertion failures in malloc_*printf().
4 */
5 #define assert(e) do { \
6 if (config_debug && !(e)) { \
7 malloc_write("<jemalloc>: Failed assertion\n"); \
8 abort(); \
9 } \
10 } while (0)
11
12 #define not_reached() do { \
13 if (config_debug) { \
14 malloc_write("<jemalloc>: Unreachable code reached\n"); \
15 abort(); \
16 } \
17 } while (0)
18
19 #define not_implemented() do { \
20 if (config_debug) { \
21 malloc_write("<jemalloc>: Not implemented\n"); \
22 abort(); \
23 } \
24 } while (0)
25
26 #define JEMALLOC_UTIL_C_
27 #include "jemalloc/internal/jemalloc_internal.h"
28
29 /******************************************************************************/
30 /* Function prototypes for non-inline static functions. */
31
32 static void wrtmessage(void *cbopaque, const char *s);
33 #define U2S_BUFSIZE ((1U << (LG_SIZEOF_INTMAX_T + 3)) + 1)
34 static char *u2s(uintmax_t x, unsigned base, bool uppercase, char *s,
35 size_t *slen_p);
36 #define D2S_BUFSIZE (1 + U2S_BUFSIZE)
37 static char *d2s(intmax_t x, char sign, char *s, size_t *slen_p);
38 #define O2S_BUFSIZE (1 + U2S_BUFSIZE)
39 static char *o2s(uintmax_t x, bool alt_form, char *s, size_t *slen_p);
40 #define X2S_BUFSIZE (2 + U2S_BUFSIZE)
41 static char *x2s(uintmax_t x, bool alt_form, bool uppercase, char *s,
42 size_t *slen_p);
43
44 /******************************************************************************/
45
46 /* malloc_message() setup. */
47 static void
48 wrtmessage(void *cbopaque, const char *s)
49 {
50
51 #ifdef SYS_write
52 /*
53 * Use syscall(2) rather than write(2) when possible in order to avoid
54 * the possibility of memory allocation within libc. This is necessary
55 * on FreeBSD; most operating systems do not have this problem though.
56 *
57 * syscall() returns long or int, depending on platform, so capture the
58 * unused result in the widest plausible type to avoid compiler
59 * warnings.
60 */
61 UNUSED long result = syscall(SYS_write, STDERR_FILENO, s, strlen(s));
62 #else
63 UNUSED ssize_t result = write(STDERR_FILENO, s, strlen(s));
64 #endif
65 }
66
67 JEMALLOC_EXPORT void (*je_malloc_message)(void *, const char *s);
68
69 /*
70 * Wrapper around malloc_message() that avoids the need for
71 * je_malloc_message(...) throughout the code.
72 */
73 void
74 malloc_write(const char *s)
75 {
76
77 if (je_malloc_message != NULL)
78 je_malloc_message(NULL, s);
79 else
80 wrtmessage(NULL, s);
81 }
82
83 /*
84 * glibc provides a non-standard strerror_r() when _GNU_SOURCE is defined, so
85 * provide a wrapper.
86 */
87 int
88 buferror(int err, char *buf, size_t buflen)
89 {
90
91 #ifdef _WIN32
92 FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0,
93 (LPSTR)buf, (DWORD)buflen, NULL);
94 return (0);
95 #elif defined(__GLIBC__) && defined(_GNU_SOURCE)
96 char *b = strerror_r(err, buf, buflen);
97 if (b != buf) {
98 strncpy(buf, b, buflen);
99 buf[buflen-1] = '\0';
100 }
101 return (0);
102 #else
103 return (strerror_r(err, buf, buflen));
104 #endif
105 }
106
107 uintmax_t
108 malloc_strtoumax(const char *restrict nptr, char **restrict endptr, int base)
109 {
110 uintmax_t ret, digit;
111 unsigned b;
112 bool neg;
113 const char *p, *ns;
114
115 p = nptr;
116 if (base < 0 || base == 1 || base > 36) {
117 ns = p;
118 set_errno(EINVAL);
119 ret = UINTMAX_MAX;
120 goto label_return;
121 }
122 b = base;
123
124 /* Swallow leading whitespace and get sign, if any. */
125 neg = false;
126 while (true) {
127 switch (*p) {
128 case '\t': case '\n': case '\v': case '\f': case '\r': case ' ':
129 p++;
130 break;
131 case '-':
132 neg = true;
133 /* Fall through. */
134 case '+':
135 p++;
136 /* Fall through. */
137 default:
138 goto label_prefix;
139 }
140 }
141
142 /* Get prefix, if any. */
143 label_prefix:
144 /*
145 * Note where the first non-whitespace/sign character is so that it is
146 * possible to tell whether any digits are consumed (e.g., " 0" vs.
147 * " -x").
148 */
149 ns = p;
150 if (*p == '0') {
151 switch (p[1]) {
152 case '0': case '1': case '2': case '3': case '4': case '5':
153 case '6': case '7':
154 if (b == 0)
155 b = 8;
156 if (b == 8)
157 p++;
158 break;
159 case 'X': case 'x':
160 switch (p[2]) {
161 case '0': case '1': case '2': case '3': case '4':
162 case '5': case '6': case '7': case '8': case '9':
163 case 'A': case 'B': case 'C': case 'D': case 'E':
164 case 'F':
165 case 'a': case 'b': case 'c': case 'd': case 'e':
166 case 'f':
167 if (b == 0)
168 b = 16;
169 if (b == 16)
170 p += 2;
171 break;
172 default:
173 break;
174 }
175 break;
176 default:
177 p++;
178 ret = 0;
179 goto label_return;
180 }
181 }
182 if (b == 0)
183 b = 10;
184
185 /* Convert. */
186 ret = 0;
187 while ((*p >= '0' && *p <= '9' && (digit = *p - '0') < b)
188 || (*p >= 'A' && *p <= 'Z' && (digit = 10 + *p - 'A') < b)
189 || (*p >= 'a' && *p <= 'z' && (digit = 10 + *p - 'a') < b)) {
190 uintmax_t pret = ret;
191 ret *= b;
192 ret += digit;
193 if (ret < pret) {
194 /* Overflow. */
195 set_errno(ERANGE);
196 ret = UINTMAX_MAX;
197 goto label_return;
198 }
199 p++;
200 }
201 if (neg)
202 ret = -ret;
203
204 if (p == ns) {
205 /* No conversion performed. */
206 set_errno(EINVAL);
207 ret = UINTMAX_MAX;
208 goto label_return;
209 }
210
211 label_return:
212 if (endptr != NULL) {
213 if (p == ns) {
214 /* No characters were converted. */
215 *endptr = (char *)nptr;
216 } else
217 *endptr = (char *)p;
218 }
219 return (ret);
220 }
221
222 static char *
223 u2s(uintmax_t x, unsigned base, bool uppercase, char *s, size_t *slen_p)
224 {
225 unsigned i;
226
227 i = U2S_BUFSIZE - 1;
228 s[i] = '\0';
229 switch (base) {
230 case 10:
231 do {
232 i--;
233 s[i] = "0123456789"[x % (uint64_t)10];
234 x /= (uint64_t)10;
235 } while (x > 0);
236 break;
237 case 16: {
238 const char *digits = (uppercase)
239 ? "0123456789ABCDEF"
240 : "0123456789abcdef";
241
242 do {
243 i--;
244 s[i] = digits[x & 0xf];
245 x >>= 4;
246 } while (x > 0);
247 break;
248 } default: {
249 const char *digits = (uppercase)
250 ? "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
251 : "0123456789abcdefghijklmnopqrstuvwxyz";
252
253 assert(base >= 2 && base <= 36);
254 do {
255 i--;
256 s[i] = digits[x % (uint64_t)base];
257 x /= (uint64_t)base;
258 } while (x > 0);
259 }}
260
261 *slen_p = U2S_BUFSIZE - 1 - i;
262 return (&s[i]);
263 }
264
265 static char *
266 d2s(intmax_t x, char sign, char *s, size_t *slen_p)
267 {
268 bool neg;
269
270 if ((neg = (x < 0)))
271 x = -x;
272 s = u2s(x, 10, false, s, slen_p);
273 if (neg)
274 sign = '-';
275 switch (sign) {
276 case '-':
277 if (!neg)
278 break;
279 /* Fall through. */
280 case ' ':
281 case '+':
282 s--;
283 (*slen_p)++;
284 *s = sign;
285 break;
286 default: not_reached();
287 }
288 return (s);
289 }
290
291 static char *
292 o2s(uintmax_t x, bool alt_form, char *s, size_t *slen_p)
293 {
294
295 s = u2s(x, 8, false, s, slen_p);
296 if (alt_form && *s != '0') {
297 s--;
298 (*slen_p)++;
299 *s = '0';
300 }
301 return (s);
302 }
303
304 static char *
305 x2s(uintmax_t x, bool alt_form, bool uppercase, char *s, size_t *slen_p)
306 {
307
308 s = u2s(x, 16, uppercase, s, slen_p);
309 if (alt_form) {
310 s -= 2;
311 (*slen_p) += 2;
312 memcpy(s, uppercase ? "0X" : "0x", 2);
313 }
314 return (s);
315 }
316
317 int
318 malloc_vsnprintf(char *str, size_t size, const char *format, va_list ap)
319 {
320 int ret;
321 size_t i;
322 const char *f;
323
324 #define APPEND_C(c) do { \
325 if (i < size) \
326 str[i] = (c); \
327 i++; \
328 } while (0)
329 #define APPEND_S(s, slen) do { \
330 if (i < size) { \
331 size_t cpylen = (slen <= size - i) ? slen : size - i; \
332 memcpy(&str[i], s, cpylen); \
333 } \
334 i += slen; \
335 } while (0)
336 #define APPEND_PADDED_S(s, slen, width, left_justify) do { \
337 /* Left padding. */ \
338 size_t pad_len = (width == -1) ? 0 : ((slen < (size_t)width) ? \
339 (size_t)width - slen : 0); \
340 if (!left_justify && pad_len != 0) { \
341 size_t j; \
342 for (j = 0; j < pad_len; j++) \
343 APPEND_C(' '); \
344 } \
345 /* Value. */ \
346 APPEND_S(s, slen); \
347 /* Right padding. */ \
348 if (left_justify && pad_len != 0) { \
349 size_t j; \
350 for (j = 0; j < pad_len; j++) \
351 APPEND_C(' '); \
352 } \
353 } while (0)
354 #define GET_ARG_NUMERIC(val, len) do { \
355 switch (len) { \
356 case '?': \
357 val = va_arg(ap, int); \
358 break; \
359 case '?' | 0x80: \
360 val = va_arg(ap, unsigned int); \
361 break; \
362 case 'l': \
363 val = va_arg(ap, long); \
364 break; \
365 case 'l' | 0x80: \
366 val = va_arg(ap, unsigned long); \
367 break; \
368 case 'q': \
369 val = va_arg(ap, long long); \
370 break; \
371 case 'q' | 0x80: \
372 val = va_arg(ap, unsigned long long); \
373 break; \
374 case 'j': \
375 val = va_arg(ap, intmax_t); \
376 break; \
377 case 'j' | 0x80: \
378 val = va_arg(ap, uintmax_t); \
379 break; \
380 case 't': \
381 val = va_arg(ap, ptrdiff_t); \
382 break; \
383 case 'z': \
384 val = va_arg(ap, ssize_t); \
385 break; \
386 case 'z' | 0x80: \
387 val = va_arg(ap, size_t); \
388 break; \
389 case 'p': /* Synthetic; used for %p. */ \
390 val = va_arg(ap, uintptr_t); \
391 break; \
392 default: \
393 not_reached(); \
394 val = 0; \
395 } \
396 } while (0)
397
398 i = 0;
399 f = format;
400 while (true) {
401 switch (*f) {
402 case '\0': goto label_out;
403 case '%': {
404 bool alt_form = false;
405 bool left_justify = false;
406 bool plus_space = false;
407 bool plus_plus = false;
408 int prec = -1;
409 int width = -1;
410 unsigned char len = '?';
411
412 f++;
413 /* Flags. */
414 while (true) {
415 switch (*f) {
416 case '#':
417 assert(!alt_form);
418 alt_form = true;
419 break;
420 case '-':
421 assert(!left_justify);
422 left_justify = true;
423 break;
424 case ' ':
425 assert(!plus_space);
426 plus_space = true;
427 break;
428 case '+':
429 assert(!plus_plus);
430 plus_plus = true;
431 break;
432 default: goto label_width;
433 }
434 f++;
435 }
436 /* Width. */
437 label_width:
438 switch (*f) {
439 case '*':
440 width = va_arg(ap, int);
441 f++;
442 if (width < 0) {
443 left_justify = true;
444 width = -width;
445 }
446 break;
447 case '0': case '1': case '2': case '3': case '4':
448 case '5': case '6': case '7': case '8': case '9': {
449 uintmax_t uwidth;
450 set_errno(0);
451 uwidth = malloc_strtoumax(f, (char **)&f, 10);
452 assert(uwidth != UINTMAX_MAX || get_errno() !=
453 ERANGE);
454 width = (int)uwidth;
455 break;
456 } default:
457 break;
458 }
459 /* Width/precision separator. */
460 if (*f == '.')
461 f++;
462 else
463 goto label_length;
464 /* Precision. */
465 switch (*f) {
466 case '*':
467 prec = va_arg(ap, int);
468 f++;
469 break;
470 case '0': case '1': case '2': case '3': case '4':
471 case '5': case '6': case '7': case '8': case '9': {
472 uintmax_t uprec;
473 set_errno(0);
474 uprec = malloc_strtoumax(f, (char **)&f, 10);
475 assert(uprec != UINTMAX_MAX || get_errno() !=
476 ERANGE);
477 prec = (int)uprec;
478 break;
479 }
480 default: break;
481 }
482 /* Length. */
483 label_length:
484 switch (*f) {
485 case 'l':
486 f++;
487 if (*f == 'l') {
488 len = 'q';
489 f++;
490 } else
491 len = 'l';
492 break;
493 case 'q': case 'j': case 't': case 'z':
494 len = *f;
495 f++;
496 break;
497 default: break;
498 }
499 /* Conversion specifier. */
500 switch (*f) {
501 char *s;
502 size_t slen;
503 case '%':
504 /* %% */
505 APPEND_C(*f);
506 f++;
507 break;
508 case 'd': case 'i': {
509 intmax_t val JEMALLOC_CC_SILENCE_INIT(0);
510 char buf[D2S_BUFSIZE];
511
512 GET_ARG_NUMERIC(val, len);
513 s = d2s(val, (plus_plus ? '+' : (plus_space ?
514 ' ' : '-')), buf, &slen);
515 APPEND_PADDED_S(s, slen, width, left_justify);
516 f++;
517 break;
518 } case 'o': {
519 uintmax_t val JEMALLOC_CC_SILENCE_INIT(0);
520 char buf[O2S_BUFSIZE];
521
522 GET_ARG_NUMERIC(val, len | 0x80);
523 s = o2s(val, alt_form, buf, &slen);
524 APPEND_PADDED_S(s, slen, width, left_justify);
525 f++;
526 break;
527 } case 'u': {
528 uintmax_t val JEMALLOC_CC_SILENCE_INIT(0);
529 char buf[U2S_BUFSIZE];
530
531 GET_ARG_NUMERIC(val, len | 0x80);
532 s = u2s(val, 10, false, buf, &slen);
533 APPEND_PADDED_S(s, slen, width, left_justify);
534 f++;
535 break;
536 } case 'x': case 'X': {
537 uintmax_t val JEMALLOC_CC_SILENCE_INIT(0);
538 char buf[X2S_BUFSIZE];
539
540 GET_ARG_NUMERIC(val, len | 0x80);
541 s = x2s(val, alt_form, *f == 'X', buf, &slen);
542 APPEND_PADDED_S(s, slen, width, left_justify);
543 f++;
544 break;
545 } case 'c': {
546 unsigned char val;
547 char buf[2];
548
549 assert(len == '?' || len == 'l');
550 assert_not_implemented(len != 'l');
551 val = va_arg(ap, int);
552 buf[0] = val;
553 buf[1] = '\0';
554 APPEND_PADDED_S(buf, 1, width, left_justify);
555 f++;
556 break;
557 } case 's':
558 assert(len == '?' || len == 'l');
559 assert_not_implemented(len != 'l');
560 s = va_arg(ap, char *);
561 slen = (prec < 0) ? strlen(s) : (size_t)prec;
562 APPEND_PADDED_S(s, slen, width, left_justify);
563 f++;
564 break;
565 case 'p': {
566 uintmax_t val;
567 char buf[X2S_BUFSIZE];
568
569 GET_ARG_NUMERIC(val, 'p');
570 s = x2s(val, true, false, buf, &slen);
571 APPEND_PADDED_S(s, slen, width, left_justify);
572 f++;
573 break;
574 } default: not_reached();
575 }
576 break;
577 } default: {
578 APPEND_C(*f);
579 f++;
580 break;
581 }}
582 }
583 label_out:
584 if (i < size)
585 str[i] = '\0';
586 else
587 str[size - 1] = '\0';
588 assert(i < INT_MAX);
589 ret = (int)i;
590
591 #undef APPEND_C
592 #undef APPEND_S
593 #undef APPEND_PADDED_S
594 #undef GET_ARG_NUMERIC
595 return (ret);
596 }
597
598 JEMALLOC_FORMAT_PRINTF(3, 4)
599 int
600 malloc_snprintf(char *str, size_t size, const char *format, ...)
601 {
602 int ret;
603 va_list ap;
604
605 va_start(ap, format);
606 ret = malloc_vsnprintf(str, size, format, ap);
607 va_end(ap);
608
609 return (ret);
610 }
611
612 void
613 malloc_vcprintf(void (*write_cb)(void *, const char *), void *cbopaque,
614 const char *format, va_list ap)
615 {
616 char buf[MALLOC_PRINTF_BUFSIZE];
617
618 if (write_cb == NULL) {
619 /*
620 * The caller did not provide an alternate write_cb callback
621 * function, so use the default one. malloc_write() is an
622 * inline function, so use malloc_message() directly here.
623 */
624 write_cb = (je_malloc_message != NULL) ? je_malloc_message :
625 wrtmessage;
626 cbopaque = NULL;
627 }
628
629 malloc_vsnprintf(buf, sizeof(buf), format, ap);
630 write_cb(cbopaque, buf);
631 }
632
633 /*
634 * Print to a callback function in such a way as to (hopefully) avoid memory
635 * allocation.
636 */
637 JEMALLOC_FORMAT_PRINTF(3, 4)
638 void
639 malloc_cprintf(void (*write_cb)(void *, const char *), void *cbopaque,
640 const char *format, ...)
641 {
642 va_list ap;
643
644 va_start(ap, format);
645 malloc_vcprintf(write_cb, cbopaque, format, ap);
646 va_end(ap);
647 }
648
649 /* Print to stderr in such a way as to avoid memory allocation. */
650 JEMALLOC_FORMAT_PRINTF(1, 2)
651 void
652 malloc_printf(const char *format, ...)
653 {
654 va_list ap;
655
656 va_start(ap, format);
657 malloc_vcprintf(NULL, NULL, format, ap);
658 va_end(ap);
659 }
660
661 /*
662 * Restore normal assertion macros, in order to make it possible to compile all
663 * C files as a single concatenation.
664 */
665 #undef assert
666 #undef not_reached
667 #undef not_implemented
668 #include "jemalloc/internal/assert.h"