1 /* Malloc debug DSO.
2 Copyright (C) 2021-2023 Free Software Foundation, Inc.
3 Copyright The GNU Toolchain Authors.
4 This file is part of the GNU C Library.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If
18 not, see <https://www.gnu.org/licenses/>. */
19
20 #include <atomic.h>
21 #include <libc-symbols.h>
22 #include <shlib-compat.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <sys/param.h>
26
27 /* Support only the glibc allocators. */
28 extern void *__libc_malloc (size_t);
29 extern void __libc_free (void *);
30 extern void *__libc_realloc (void *, size_t);
31 extern void *__libc_memalign (size_t, size_t);
32 extern void *__libc_valloc (size_t);
33 extern void *__libc_pvalloc (size_t);
34 extern void *__libc_calloc (size_t, size_t);
35
36 #define DEBUG_FN(fn) \
37 static __typeof (__libc_ ## fn) __debug_ ## fn
38
39 DEBUG_FN(malloc);
40 DEBUG_FN(free);
41 DEBUG_FN(realloc);
42 DEBUG_FN(memalign);
43 DEBUG_FN(valloc);
44 DEBUG_FN(pvalloc);
45 DEBUG_FN(calloc);
46
47 static int debug_initialized = -1;
48
49 enum malloc_debug_hooks
50 {
51 MALLOC_NONE_HOOK = 0,
52 MALLOC_MCHECK_HOOK = 1 << 0, /* mcheck() */
53 MALLOC_MTRACE_HOOK = 1 << 1, /* mtrace() */
54 MALLOC_CHECK_HOOK = 1 << 2, /* MALLOC_CHECK_ or glibc.malloc.check. */
55 };
56 static unsigned __malloc_debugging_hooks;
57
58 static __always_inline bool
59 __is_malloc_debug_enabled (enum malloc_debug_hooks flag)
60 {
61 return __malloc_debugging_hooks & flag;
62 }
63
64 static __always_inline void
65 __malloc_debug_enable (enum malloc_debug_hooks flag)
66 {
67 __malloc_debugging_hooks |= flag;
68 }
69
70 static __always_inline void
71 __malloc_debug_disable (enum malloc_debug_hooks flag)
72 {
73 __malloc_debugging_hooks &= ~flag;
74 }
75
76 #include "mcheck.c"
77 #include "mtrace.c"
78 #include "malloc-check.c"
79
80 #if SHLIB_COMPAT (libc_malloc_debug, GLIBC_2_0, GLIBC_2_24)
81 extern void (*__malloc_initialize_hook) (void);
82 compat_symbol_reference (libc, __malloc_initialize_hook,
83 __malloc_initialize_hook, GLIBC_2_0);
84 #endif
85
86 static void *malloc_hook_ini (size_t, const void *) __THROW;
87 static void *realloc_hook_ini (void *, size_t, const void *) __THROW;
88 static void *memalign_hook_ini (size_t, size_t, const void *) __THROW;
89
90 void (*__free_hook) (void *, const void *) = NULL;
91 void *(*__malloc_hook) (size_t, const void *) = malloc_hook_ini;
92 void *(*__realloc_hook) (void *, size_t, const void *) = realloc_hook_ini;
93 void *(*__memalign_hook) (size_t, size_t, const void *) = memalign_hook_ini;
94
95 /* Hooks for debugging versions. The initial hooks just call the
96 initialization routine, then do the normal work. */
97
98 /* These hooks will get executed only through the interposed allocator
99 functions in libc_malloc_debug.so. This means that the calls to malloc,
100 realloc, etc. will lead back into the interposed functions, which is what we
101 want.
102
103 These initial hooks are assumed to be called in a single-threaded context,
104 so it is safe to reset all hooks at once upon initialization. */
105
106 static void
107 generic_hook_ini (void)
108 {
109 debug_initialized = 0;
110 __malloc_hook = NULL;
111 __realloc_hook = NULL;
112 __memalign_hook = NULL;
113
114 /* malloc check does not quite co-exist with libc malloc, so initialize
115 either on or the other. */
116 if (!initialize_malloc_check ())
117 /* The compiler does not know that these functions are allocators, so it
118 will not try to optimize it away. */
119 __libc_free (__libc_malloc (0));
120
121 #if SHLIB_COMPAT (libc_malloc_debug, GLIBC_2_0, GLIBC_2_24)
122 void (*hook) (void) = __malloc_initialize_hook;
123 if (hook != NULL)
124 (*hook)();
125 #endif
126
127 debug_initialized = 1;
128 }
129
130 static void *
131 malloc_hook_ini (size_t sz, const void *caller)
132 {
133 generic_hook_ini ();
134 return __debug_malloc (sz);
135 }
136
137 static void *
138 realloc_hook_ini (void *ptr, size_t sz, const void *caller)
139 {
140 generic_hook_ini ();
141 return __debug_realloc (ptr, sz);
142 }
143
144 static void *
145 memalign_hook_ini (size_t alignment, size_t sz, const void *caller)
146 {
147 generic_hook_ini ();
148 return __debug_memalign (alignment, sz);
149 }
150
151 static size_t pagesize;
152
153 /* These variables are used for undumping support. Chunked are marked
154 as using mmap, but we leave them alone if they fall into this
155 range. NB: The chunk size for these chunks only includes the
156 initial size field (of SIZE_SZ bytes), there is no trailing size
157 field (unlike with regular mmapped chunks). */
158 static mchunkptr dumped_main_arena_start; /* Inclusive. */
159 static mchunkptr dumped_main_arena_end; /* Exclusive. */
160
161 /* True if the pointer falls into the dumped arena. Use this after
162 chunk_is_mmapped indicates a chunk is mmapped. */
163 #define DUMPED_MAIN_ARENA_CHUNK(p) \
164 ((p) >= dumped_main_arena_start && (p) < dumped_main_arena_end)
165
166 /* The allocator functions. */
167
168 static void *
169 __debug_malloc (size_t bytes)
170 {
171 void *(*hook) (size_t, const void *) = atomic_forced_read (__malloc_hook);
172 if (__builtin_expect (hook != NULL, 0))
173 return (*hook)(bytes, RETURN_ADDRESS (0));
174
175 void *victim = NULL;
176 size_t orig_bytes = bytes;
177 if ((!__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK)
178 || !malloc_mcheck_before (&bytes, &victim)))
179 {
180 victim = (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK)
181 ? malloc_check (bytes) : __libc_malloc (bytes));
182 }
183 if (__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK) && victim != NULL)
184 victim = malloc_mcheck_after (victim, orig_bytes);
185 if (__is_malloc_debug_enabled (MALLOC_MTRACE_HOOK))
186 malloc_mtrace_after (victim, orig_bytes, RETURN_ADDRESS (0));
187
188 return victim;
189 }
190 strong_alias (__debug_malloc, malloc)
191
192 static void
193 __debug_free (void *mem)
194 {
195 void (*hook) (void *, const void *) = atomic_forced_read (__free_hook);
196 if (__builtin_expect (hook != NULL, 0))
197 {
198 (*hook)(mem, RETURN_ADDRESS (0));
199 return;
200 }
201
202 if (__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK))
203 mem = free_mcheck (mem);
204
205 if (DUMPED_MAIN_ARENA_CHUNK (mem2chunk (mem)))
206 /* Do nothing. */;
207 else if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
208 free_check (mem);
209 else
210 __libc_free (mem);
211 if (__is_malloc_debug_enabled (MALLOC_MTRACE_HOOK))
212 free_mtrace (mem, RETURN_ADDRESS (0));
213 }
214 strong_alias (__debug_free, free)
215
216 static void *
217 __debug_realloc (void *oldmem, size_t bytes)
218 {
219 void *(*hook) (void *, size_t, const void *) =
220 atomic_forced_read (__realloc_hook);
221 if (__builtin_expect (hook != NULL, 0))
222 return (*hook)(oldmem, bytes, RETURN_ADDRESS (0));
223
224 size_t orig_bytes = bytes, oldsize = 0;
225 void *victim = NULL;
226
227 if ((!__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK)
228 || !realloc_mcheck_before (&oldmem, &bytes, &oldsize, &victim)))
229 {
230 mchunkptr oldp = mem2chunk (oldmem);
231
232 /* If this is a faked mmapped chunk from the dumped main arena,
233 always make a copy (and do not free the old chunk). */
234 if (DUMPED_MAIN_ARENA_CHUNK (oldp))
235 {
236 if (bytes == 0 && oldmem != NULL)
237 victim = NULL;
238 else
239 {
240 const INTERNAL_SIZE_T osize = chunksize (oldp);
241 /* Must alloc, copy, free. */
242 victim = __debug_malloc (bytes);
243 /* Copy as many bytes as are available from the old chunk
244 and fit into the new size. NB: The overhead for faked
245 mmapped chunks is only SIZE_SZ, not CHUNK_HDR_SZ as for
246 regular mmapped chunks. */
247 if (victim != NULL)
248 {
249 if (bytes > osize - SIZE_SZ)
250 bytes = osize - SIZE_SZ;
251 memcpy (victim, oldmem, bytes);
252 }
253 }
254 }
255 else if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
256 victim = realloc_check (oldmem, bytes);
257 else
258 victim = __libc_realloc (oldmem, bytes);
259 }
260 if (__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK) && victim != NULL)
261 victim = realloc_mcheck_after (victim, oldmem, orig_bytes,
262 oldsize);
263 if (__is_malloc_debug_enabled (MALLOC_MTRACE_HOOK))
264 realloc_mtrace_after (victim, oldmem, orig_bytes, RETURN_ADDRESS (0));
265
266 return victim;
267 }
268 strong_alias (__debug_realloc, realloc)
269
270 static void *
271 _debug_mid_memalign (size_t alignment, size_t bytes, const void *address)
272 {
273 void *(*hook) (size_t, size_t, const void *) =
274 atomic_forced_read (__memalign_hook);
275 if (__builtin_expect (hook != NULL, 0))
276 return (*hook)(alignment, bytes, address);
277
278 void *victim = NULL;
279 size_t orig_bytes = bytes;
280
281 if ((!__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK)
282 || !memalign_mcheck_before (alignment, &bytes, &victim)))
283 {
284 victim = (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK)
285 ? memalign_check (alignment, bytes)
286 : __libc_memalign (alignment, bytes));
287 }
288 if (__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK) && victim != NULL)
289 victim = memalign_mcheck_after (victim, alignment, orig_bytes);
290 if (__is_malloc_debug_enabled (MALLOC_MTRACE_HOOK))
291 memalign_mtrace_after (victim, orig_bytes, address);
292
293 return victim;
294 }
295
296 static void *
297 __debug_memalign (size_t alignment, size_t bytes)
298 {
299 return _debug_mid_memalign (alignment, bytes, RETURN_ADDRESS (0));
300 }
301 strong_alias (__debug_memalign, memalign)
302 static void *
303 __debug_aligned_alloc (size_t alignment, size_t bytes)
304 {
305 if (!powerof2 (alignment) || alignment == 0)
306 return NULL;
307 return _debug_mid_memalign (alignment, bytes, RETURN_ADDRESS (0));
308 }
309 strong_alias (__debug_aligned_alloc, aligned_alloc)
310
311 static void *
312 __debug_pvalloc (size_t bytes)
313 {
314 size_t rounded_bytes;
315
316 if (!pagesize)
317 pagesize = sysconf (_SC_PAGESIZE);
318
319 /* ALIGN_UP with overflow check. */
320 if (__glibc_unlikely (__builtin_add_overflow (bytes,
321 pagesize - 1,
322 &rounded_bytes)))
323 {
324 errno = ENOMEM;
325 return NULL;
326 }
327 rounded_bytes = rounded_bytes & -(pagesize - 1);
328
329 return _debug_mid_memalign (pagesize, rounded_bytes, RETURN_ADDRESS (0));
330 }
331 strong_alias (__debug_pvalloc, pvalloc)
332
333 static void *
334 __debug_valloc (size_t bytes)
335 {
336 if (!pagesize)
337 pagesize = sysconf (_SC_PAGESIZE);
338
339 return _debug_mid_memalign (pagesize, bytes, RETURN_ADDRESS (0));
340 }
341 strong_alias (__debug_valloc, valloc)
342
343 static int
344 __debug_posix_memalign (void **memptr, size_t alignment, size_t bytes)
345 {
346 /* Test whether the SIZE argument is valid. It must be a power of
347 two multiple of sizeof (void *). */
348 if (alignment % sizeof (void *) != 0
349 || !powerof2 (alignment / sizeof (void *))
350 || alignment == 0)
351 return EINVAL;
352
353 *memptr = _debug_mid_memalign (alignment, bytes, RETURN_ADDRESS (0));
354
355 if (*memptr == NULL)
356 return ENOMEM;
357
358 return 0;
359 }
360 strong_alias (__debug_posix_memalign, posix_memalign)
361
362 static void *
363 __debug_calloc (size_t nmemb, size_t size)
364 {
365 size_t bytes;
366
367 if (__glibc_unlikely (__builtin_mul_overflow (nmemb, size, &bytes)))
368 {
369 errno = ENOMEM;
370 return NULL;
371 }
372
373 void *(*hook) (size_t, const void *) = atomic_forced_read (__malloc_hook);
374 if (__builtin_expect (hook != NULL, 0))
375 {
376 void *mem = (*hook)(bytes, RETURN_ADDRESS (0));
377
378 if (mem != NULL)
379 memset (mem, 0, bytes);
380
381 return mem;
382 }
383
384 size_t orig_bytes = bytes;
385 void *victim = NULL;
386
387 if ((!__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK)
388 || !malloc_mcheck_before (&bytes, &victim)))
389 {
390 victim = (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK)
391 ? malloc_check (bytes) : __libc_malloc (bytes));
392 }
393 if (victim != NULL)
394 {
395 if (__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK))
396 victim = malloc_mcheck_after (victim, orig_bytes);
397 memset (victim, 0, orig_bytes);
398 }
399 if (__is_malloc_debug_enabled (MALLOC_MTRACE_HOOK))
400 malloc_mtrace_after (victim, orig_bytes, RETURN_ADDRESS (0));
401
402 return victim;
403 }
404 strong_alias (__debug_calloc, calloc)
405
406 size_t
407 malloc_usable_size (void *mem)
408 {
409 if (mem == NULL)
410 return 0;
411
412 if (__is_malloc_debug_enabled (MALLOC_MCHECK_HOOK))
413 return mcheck_usable_size (mem);
414 if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
415 return malloc_check_get_size (mem);
416
417 mchunkptr p = mem2chunk (mem);
418 if (DUMPED_MAIN_ARENA_CHUNK (p))
419 return chunksize (p) - SIZE_SZ;
420
421 return musable (mem);
422 }
423
424 #define LIBC_SYMBOL(sym) libc_ ## sym
425 #define SYMHANDLE(sym) sym ## _handle
426
427 #define LOAD_SYM(sym) ({ \
428 static void *SYMHANDLE (sym); \
429 if (SYMHANDLE (sym) == NULL) \
430 SYMHANDLE (sym) = dlsym (RTLD_NEXT, #sym); \
431 SYMHANDLE (sym); \
432 })
433
434 int
435 malloc_info (int options, FILE *fp)
436 {
437 if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
438 return __malloc_info (options, fp);
439
440 int (*LIBC_SYMBOL (malloc_info)) (int, FILE *) = LOAD_SYM (malloc_info);
441 if (LIBC_SYMBOL (malloc_info) == NULL)
442 return -1;
443
444 return LIBC_SYMBOL (malloc_info) (options, fp);
445 }
446
447 int
448 mallopt (int param_number, int value)
449 {
450 if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
451 return __libc_mallopt (param_number, value);
452
453 int (*LIBC_SYMBOL (mallopt)) (int, int) = LOAD_SYM (mallopt);
454 if (LIBC_SYMBOL (mallopt) == NULL)
455 return 0;
456
457 return LIBC_SYMBOL (mallopt) (param_number, value);
458 }
459
460 void
461 malloc_stats (void)
462 {
463 if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
464 return __malloc_stats ();
465
466 void (*LIBC_SYMBOL (malloc_stats)) (void) = LOAD_SYM (malloc_stats);
467 if (LIBC_SYMBOL (malloc_stats) == NULL)
468 return;
469
470 LIBC_SYMBOL (malloc_stats) ();
471 }
472
473 struct mallinfo2
474 mallinfo2 (void)
475 {
476 if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
477 return __libc_mallinfo2 ();
478
479 struct mallinfo2 (*LIBC_SYMBOL (mallinfo2)) (void) = LOAD_SYM (mallinfo2);
480 if (LIBC_SYMBOL (mallinfo2) == NULL)
481 {
482 struct mallinfo2 ret = {0};
483 return ret;
484 }
485
486 return LIBC_SYMBOL (mallinfo2) ();
487 }
488
489 struct mallinfo
490 mallinfo (void)
491 {
492 if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
493 return __libc_mallinfo ();
494
495 struct mallinfo (*LIBC_SYMBOL (mallinfo)) (void) = LOAD_SYM (mallinfo);
496 if (LIBC_SYMBOL (mallinfo) == NULL)
497 {
498 struct mallinfo ret = {0};
499 return ret;
500 }
501
502 return LIBC_SYMBOL (mallinfo) ();
503 }
504
505 int
506 malloc_trim (size_t s)
507 {
508 if (__is_malloc_debug_enabled (MALLOC_CHECK_HOOK))
509 return __malloc_trim (s);
510
511 int (*LIBC_SYMBOL (malloc_trim)) (size_t) = LOAD_SYM (malloc_trim);
512 if (LIBC_SYMBOL (malloc_trim) == NULL)
513 return 0;
514
515 return LIBC_SYMBOL (malloc_trim) (s);
516 }
517
518 #if SHLIB_COMPAT (libc_malloc_debug, GLIBC_2_0, GLIBC_2_25)
519
520 /* Support for restoring dumped heaps contained in historic Emacs
521 executables. The heap saving feature (malloc_get_state) is no
522 longer implemented in this version of glibc, but we have a heap
523 rewriter in malloc_set_state which transforms the heap into a
524 version compatible with current malloc. */
525
526 #define MALLOC_STATE_MAGIC 0x444c4541l
527 #define MALLOC_STATE_VERSION (0 * 0x100l + 5l) /* major*0x100 + minor */
528
529 struct malloc_save_state
530 {
531 long magic;
532 long version;
533 mbinptr av[NBINS * 2 + 2];
534 char *sbrk_base;
535 int sbrked_mem_bytes;
536 unsigned long trim_threshold;
537 unsigned long top_pad;
538 unsigned int n_mmaps_max;
539 unsigned long mmap_threshold;
540 int check_action;
541 unsigned long max_sbrked_mem;
542 unsigned long max_total_mem; /* Always 0, for backwards compatibility. */
543 unsigned int n_mmaps;
544 unsigned int max_n_mmaps;
545 unsigned long mmapped_mem;
546 unsigned long max_mmapped_mem;
547 int using_malloc_checking;
548 unsigned long max_fast;
549 unsigned long arena_test;
550 unsigned long arena_max;
551 unsigned long narenas;
552 };
553
554 /* Dummy implementation which always fails. We need to provide this
555 symbol so that existing Emacs binaries continue to work with
556 BIND_NOW. */
557 void *
558 malloc_get_state (void)
559 {
560 __set_errno (ENOSYS);
561 return NULL;
562 }
563 compat_symbol (libc_malloc_debug, malloc_get_state, malloc_get_state,
564 GLIBC_2_0);
565
566 int
567 malloc_set_state (void *msptr)
568 {
569 struct malloc_save_state *ms = (struct malloc_save_state *) msptr;
570
571 if (ms->magic != MALLOC_STATE_MAGIC)
572 return -1;
573
574 /* Must fail if the major version is too high. */
575 if ((ms->version & ~0xffl) > (MALLOC_STATE_VERSION & ~0xffl))
576 return -2;
577
578 if (debug_initialized == 1)
579 return -1;
580
581 bool check_was_enabled = __is_malloc_debug_enabled (MALLOC_CHECK_HOOK);
582
583 /* It's not too late, so disable MALLOC_CHECK_ and all of the hooks. */
584 __malloc_hook = NULL;
585 __realloc_hook = NULL;
586 __free_hook = NULL;
587 __memalign_hook = NULL;
588 __malloc_debug_disable (MALLOC_CHECK_HOOK);
589
590 /* We do not need to perform locking here because malloc_set_state
591 must be called before the first call into the malloc subsystem (usually via
592 __malloc_initialize_hook). pthread_create always calls calloc and thus
593 must be called only afterwards, so there cannot be more than one thread
594 when we reach this point. Also handle initialization if either we ended
595 up being called before the first malloc or through the hook when
596 malloc-check was enabled. */
597 if (debug_initialized < 0)
598 generic_hook_ini ();
599 else if (check_was_enabled)
600 __libc_free (__libc_malloc (0));
601
602 /* Patch the dumped heap. We no longer try to integrate into the
603 existing heap. Instead, we mark the existing chunks as mmapped.
604 Together with the update to dumped_main_arena_start and
605 dumped_main_arena_end, realloc and free will recognize these
606 chunks as dumped fake mmapped chunks and never free them. */
607
608 /* Find the chunk with the lowest address with the heap. */
609 mchunkptr chunk = NULL;
610 {
611 size_t *candidate = (size_t *) ms->sbrk_base;
612 size_t *end = (size_t *) (ms->sbrk_base + ms->sbrked_mem_bytes);
613 while (candidate < end)
614 if (*candidate != 0)
615 {
616 chunk = mem2chunk ((void *) (candidate + 1));
617 break;
618 }
619 else
620 ++candidate;
621 }
622 if (chunk == NULL)
623 return 0;
624
625 /* Iterate over the dumped heap and patch the chunks so that they
626 are treated as fake mmapped chunks. */
627 mchunkptr top = ms->av[2];
628 while (chunk < top)
629 {
630 if (inuse (chunk))
631 {
632 /* Mark chunk as mmapped, to trigger the fallback path. */
633 size_t size = chunksize (chunk);
634 set_head (chunk, size | IS_MMAPPED);
635 }
636 chunk = next_chunk (chunk);
637 }
638
639 /* The dumped fake mmapped chunks all lie in this address range. */
640 dumped_main_arena_start = (mchunkptr) ms->sbrk_base;
641 dumped_main_arena_end = top;
642
643 return 0;
644 }
645 compat_symbol (libc_malloc_debug, malloc_set_state, malloc_set_state,
646 GLIBC_2_0);
647 #endif
648
649 /* Do not allow linking against the library. */
650 compat_symbol (libc_malloc_debug, aligned_alloc, aligned_alloc, GLIBC_2_16);
651 compat_symbol (libc_malloc_debug, calloc, calloc, GLIBC_2_0);
652 compat_symbol (libc_malloc_debug, free, free, GLIBC_2_0);
653 compat_symbol (libc_malloc_debug, mallinfo2, mallinfo2, GLIBC_2_33);
654 compat_symbol (libc_malloc_debug, mallinfo, mallinfo, GLIBC_2_0);
655 compat_symbol (libc_malloc_debug, malloc_info, malloc_info, GLIBC_2_10);
656 compat_symbol (libc_malloc_debug, malloc, malloc, GLIBC_2_0);
657 compat_symbol (libc_malloc_debug, malloc_stats, malloc_stats, GLIBC_2_0);
658 compat_symbol (libc_malloc_debug, malloc_trim, malloc_trim, GLIBC_2_0);
659 compat_symbol (libc_malloc_debug, malloc_usable_size, malloc_usable_size,
660 GLIBC_2_0);
661 compat_symbol (libc_malloc_debug, mallopt, mallopt, GLIBC_2_0);
662 compat_symbol (libc_malloc_debug, mcheck_check_all, mcheck_check_all,
663 GLIBC_2_2);
664 compat_symbol (libc_malloc_debug, mcheck, mcheck, GLIBC_2_0);
665 compat_symbol (libc_malloc_debug, mcheck_pedantic, mcheck_pedantic, GLIBC_2_2);
666 compat_symbol (libc_malloc_debug, memalign, memalign, GLIBC_2_0);
667 compat_symbol (libc_malloc_debug, mprobe, mprobe, GLIBC_2_0);
668 compat_symbol (libc_malloc_debug, mtrace, mtrace, GLIBC_2_0);
669 compat_symbol (libc_malloc_debug, muntrace, muntrace, GLIBC_2_0);
670 compat_symbol (libc_malloc_debug, posix_memalign, posix_memalign, GLIBC_2_2);
671 compat_symbol (libc_malloc_debug, pvalloc, pvalloc, GLIBC_2_0);
672 compat_symbol (libc_malloc_debug, realloc, realloc, GLIBC_2_0);
673 compat_symbol (libc_malloc_debug, valloc, valloc, GLIBC_2_0);
674 compat_symbol (libc_malloc_debug, __free_hook, __free_hook, GLIBC_2_0);
675 compat_symbol (libc_malloc_debug, __malloc_hook, __malloc_hook, GLIBC_2_0);
676 compat_symbol (libc_malloc_debug, __realloc_hook, __realloc_hook, GLIBC_2_0);
677 compat_symbol (libc_malloc_debug, __memalign_hook, __memalign_hook, GLIBC_2_0);