[glibc] Revert "malloc: aarch64: Add ifuncs for malloc functions"
Yury Khrustalev via Glibc-cvs <[email protected]> Mon, 6 Jul 2026 15:35:57 +0000 (GMT)
| Newsgroups | gmane.comp.lib.glibc.cvs |
|---|---|
| Message-ID | <[email protected]> |
https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=d70dd7d72273ac1aa53b435156de3f50f0c5a868 commit d70dd7d72273ac1aa53b435156de3f50f0c5a868 Author: Yury Khrustalev <[email protected]> Date: Wed Jul 1 13:45:40 2026 +0100 Revert "malloc: aarch64: Add ifuncs for malloc functions" Due to issue in GDB and Valgrind that incorrectly call malloc ifunc resolver as the malloc function, we have to revert this change. GDB BZ: https://sourceware.org/bugzilla/show_bug.cgi?id=34330 Valgrind bug: https://bugs.kde.org/show_bug.cgi?id=522497 This reverts commit 9ed3576e61f7a87eb83d512531566f5e5d6bb032. Reviewed-by: Adhemerval Zanella <[email protected]> Diff: --- malloc/malloc-internal.h | 2 - malloc/malloc.c | 155 ++++++++++++++++++++++++---- sysdeps/aarch64/multiarch/Makefile | 10 +- sysdeps/aarch64/multiarch/malloc-ifuncs.c | 77 -------------- sysdeps/aarch64/multiarch/malloc-ifuncs.h | 24 ----- sysdeps/generic/malloc-api.h | 161 ------------------------------ sysdeps/generic/malloc-ifuncs.h | 36 ------- 7 files changed, 135 insertions(+), 330 deletions(-) diff --git a/malloc/malloc-internal.h b/malloc/malloc-internal.h index 29bc3734c6..a6340bfd88 100644 --- a/malloc/malloc-internal.h +++ b/malloc/malloc-internal.h @@ -24,8 +24,6 @@ #include <malloc-size.h> #include <hugepages.h> #include <calloc-clear-memory.h> -#include <malloc-api.h> -#include <malloc-ifuncs.h> /* Called in the parent process before a fork. */ void __malloc_fork_lock_parent (void) attribute_hidden; diff --git a/malloc/malloc.c b/malloc/malloc.c index c39d60b509..258f203f1e 100644 --- a/malloc/malloc.c +++ b/malloc/malloc.c @@ -459,10 +459,101 @@ static int extra_mmap_prot = 0; /* ---------- description of public routines ------------ */ #if IS_IN (libc) +/* + malloc(size_t n) + Returns a pointer to a newly allocated chunk of at least n bytes, or null + if no space is available. Additionally, on failure, errno is + set to ENOMEM on ANSI C systems. + + If n is zero, malloc returns a minimum-sized chunk. (The minimum + size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit + systems.) On most systems, size_t is an unsigned type, so calls + with negative arguments are interpreted as requests for huge amounts + of space, which will often fail. The maximum supported value of n + differs across systems, but is in all cases less than the maximum + representable value of a size_t. +*/ +void *__libc_malloc (size_t); +libc_hidden_proto (__libc_malloc) static void *__libc_calloc2 (size_t); static void *__libc_malloc2 (size_t); +/* + free(void* p) + Releases the chunk of memory pointed to by p, that had been previously + allocated using malloc or a related routine such as realloc. + It has no effect if p is null. It can have arbitrary (i.e., bad!) + effects if p has already been freed. + + Unless disabled (using mallopt), freeing very large spaces will + when possible, automatically trigger operations that give + back unused memory to the system, thus reducing program footprint. +*/ +void __libc_free(void*); +libc_hidden_proto (__libc_free) + +/* + calloc(size_t n_elements, size_t element_size); + Returns a pointer to n_elements * element_size bytes, with all locations + set to zero. +*/ +void* __libc_calloc(size_t, size_t); + +/* + realloc(void* p, size_t n) + Returns a pointer to a chunk of size n that contains the same data + as does chunk p up to the minimum of (n, p's size) bytes, or null + if no space is available. + + The returned pointer may or may not be the same as p. The algorithm + prefers extending p when possible, otherwise it employs the + equivalent of a malloc-copy-free sequence. + + If p is null, realloc is equivalent to malloc. + + If space is not available, realloc returns null, errno is set (if on + ANSI) and p is NOT freed. + + if n is for fewer bytes than already held by p, the newly unused + space is lopped off and freed if possible. Unless the #define + REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of + zero (re)allocates a minimum-sized chunk. + + Large chunks that were internally obtained via mmap will always be + grown using malloc-copy-free sequences unless the system supports + MREMAP (currently only linux). + + The old unix realloc convention of allowing the last-free'd chunk + to be used as an argument to realloc is not supported. +*/ +void* __libc_realloc(void*, size_t); +libc_hidden_proto (__libc_realloc) + +/* + memalign(size_t alignment, size_t n); + Returns a pointer to a newly allocated chunk of n bytes, aligned + in accord with the alignment argument. + + The alignment argument should be a power of two. If the argument is + not a power of two, the nearest greater power is used. + 8-byte alignment is guaranteed by normal malloc calls, so don't + bother calling memalign with an argument of 8 or less. + + Overreliance on memalign is a sure way to fragment space. +*/ +void* __libc_memalign(size_t, size_t); +libc_hidden_proto (__libc_memalign) + +/* + valloc(size_t n); + Equivalent to memalign(pagesize, n), where pagesize is the page + size of the system. If the pagesize is unknown, 4096 is used. +*/ +void* __libc_valloc(size_t); + + + /* mallinfo() Returns (by copy) a struct containing various summary statistics: @@ -487,6 +578,14 @@ libc_hidden_proto (__libc_mallinfo2) struct mallinfo __libc_mallinfo(void); + +/* + pvalloc(size_t n); + Equivalent to valloc(minimum-page-that-holds(n)), that is, + round up n to nearest pagesize. + */ +void* __libc_pvalloc(size_t); + /* malloc_trim(size_t pad); @@ -513,6 +612,23 @@ struct mallinfo __libc_mallinfo(void); */ int __malloc_trim(size_t); +/* + malloc_usable_size(void* p); + + Returns the number of bytes you can actually use in + an allocated chunk, which may be more than you requested (although + often not) due to alignment and minimum size constraints. + You can use this many bytes without worrying about + overwriting other allocated objects. This is not a particularly great + programming practice. malloc_usable_size can be more useful in + debugging and assertions, for example: + + p = malloc(n); + assert(malloc_usable_size(p) >= 256); + +*/ +size_t __malloc_usable_size(void*); + /* malloc_stats(); Prints on stderr the amount of space obtained from the system (both @@ -535,6 +651,12 @@ int __malloc_trim(size_t); */ void __malloc_stats(void); +/* + posix_memalign(void **memptr, size_t alignment, size_t size); + + POSIX wrapper like memalign(), checking for validity of size. +*/ +int __posix_memalign(void **, size_t, size_t); #endif /* IS_IN (libc) */ /* @@ -3190,8 +3312,10 @@ __libc_memalign (size_t alignment, size_t bytes) } libc_hidden_def (__libc_memalign) +/* For ISO C17. */ void * -__aligned_alloc (size_t alignment, size_t bytes) +weak_function +aligned_alloc (size_t alignment, size_t bytes) { /* Starting with ISO C17 the standard requires an error for alignments that are not supported. Only integral powers of 2 are valid. */ @@ -3203,10 +3327,11 @@ __aligned_alloc (size_t alignment, size_t bytes) return _mid_memalign (alignment, bytes); } -libc_hidden_def (__aligned_alloc) +/* For ISO C23. */ void -__free_sized (void *ptr, __attribute_maybe_unused__ size_t size) +weak_function +free_sized (void *ptr, __attribute_maybe_unused__ size_t size) { /* We do not perform validation that size is the same as the original requested size at this time. We leave that to the sanitizers. We @@ -3215,10 +3340,11 @@ __free_sized (void *ptr, __attribute_maybe_unused__ size_t size) free (ptr); } -libc_hidden_def (__free_sized) +/* For ISO C23. */ void -__free_aligned_sized (void *ptr, __attribute_maybe_unused__ size_t alignment, +weak_function +free_aligned_sized (void *ptr, __attribute_maybe_unused__ size_t alignment, __attribute_maybe_unused__ size_t size) { /* We do not perform validation that size and alignment is the same as @@ -3228,7 +3354,6 @@ __free_aligned_sized (void *ptr, __attribute_maybe_unused__ size_t alignment, free (ptr); } -libc_hidden_def (__free_aligned_sized) static void * _mid_memalign (size_t alignment, size_t bytes) @@ -3277,7 +3402,6 @@ __libc_valloc (size_t bytes) { return _mid_memalign (GLRO (dl_pagesize), bytes); } -libc_hidden_def (__libc_valloc) void * __libc_pvalloc (size_t bytes) @@ -3295,7 +3419,6 @@ __libc_pvalloc (size_t bytes) return _mid_memalign (pagesize, rounded_bytes & -pagesize); } -libc_hidden_def (__libc_pvalloc) static void * __attribute_noinline__ __libc_calloc2 (size_t sz) @@ -3417,7 +3540,6 @@ __libc_calloc (size_t n, size_t elem_size) #endif return __libc_calloc2 (bytes); } -libc_hidden_def (__libc_calloc) #endif /* IS_IN (libc) */ /* @@ -4410,7 +4532,6 @@ __malloc_usable_size (void *m) return 0; return musable (m); } -libc_hidden_def (__malloc_usable_size) #endif /* IS_IN (libc) */ /* @@ -4984,7 +5105,6 @@ __posix_memalign (void **memptr, size_t alignment, size_t size) *memptr = mem; return 0; } -libc_hidden_def (__posix_memalign) #endif /* IS_IN (libc) */ @@ -5147,9 +5267,6 @@ __malloc_info (int options, FILE *fp) } #if IS_IN (libc) - -/* See sysdeps/generic/malloc-ifuncs.h for details. */ -# if !USE_MULTIARCH_MALLOC strong_alias (__libc_malloc, malloc) strong_alias (__libc_realloc, realloc) strong_alias (__libc_free, free) @@ -5159,10 +5276,6 @@ weak_alias (__posix_memalign, posix_memalign) weak_alias (__libc_valloc, valloc) weak_alias (__libc_pvalloc, pvalloc) weak_alias (__malloc_usable_size, malloc_usable_size) -weak_alias (__aligned_alloc, aligned_alloc) -weak_alias (__free_sized, free_sized) -weak_alias (__free_aligned_sized, free_aligned_sized) -#endif /* !USE_MULTIARCH_MALLOC */ weak_alias (__malloc_info, malloc_info) weak_alias (__libc_mallinfo, mallinfo) @@ -5172,11 +5285,9 @@ weak_alias (__malloc_stats, malloc_stats) weak_alias (__malloc_trim, malloc_trim) #endif /* IS_IN (libc) */ -#if !USE_MULTIARCH_MALLOC -# if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_26) +#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_26) compat_symbol (libc, __libc_free, cfree, GLIBC_2_0); -# endif -#endif /* !USE_MULTIARCH_MALLOC */ +#endif /* ------------------------------------------------------------ History: diff --git a/sysdeps/aarch64/multiarch/Makefile b/sysdeps/aarch64/multiarch/Makefile index a8a03a0491..38952655b1 100644 --- a/sysdeps/aarch64/multiarch/Makefile +++ b/sysdeps/aarch64/multiarch/Makefile @@ -18,11 +18,5 @@ sysdep_routines += \ memset_zva64 \ strlen_asimd \ strlen_generic \ - # sysdep_routines -endif # ifeq ($(subdir),string) - -ifeq ($(subdir),malloc) -sysdep_routines += \ - malloc-ifuncs \ - # sysdep_routines -endif # ifeq ($(subdir),malloc) +# sysdep_routines +endif diff --git a/sysdeps/aarch64/multiarch/malloc-ifuncs.c b/sysdeps/aarch64/multiarch/malloc-ifuncs.c deleted file mode 100644 index 648fb617de..0000000000 --- a/sysdeps/aarch64/multiarch/malloc-ifuncs.c +++ /dev/null @@ -1,77 +0,0 @@ -/* Code for ifunc resolvers for malloc: aarch64 version. - Copyright (C) 2026 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#if IS_IN (libc) - -#include <init-arch.h> -#include <malloc-api.h> -#include <shlib-compat.h> - -libc_ifunc_hidden (__libc_malloc, __libc_malloc_redirect, - __libc_malloc) -strong_alias (__libc_malloc_redirect, malloc) - -libc_ifunc_hidden (__libc_calloc, __libc_calloc_redirect, - __libc_calloc) -weak_alias (__libc_calloc_redirect, calloc) - -libc_ifunc_hidden (__libc_memalign, __libc_memalign_redirect, - __libc_memalign) -weak_alias (__libc_memalign_redirect, memalign) - -libc_ifunc_hidden (__libc_valloc, __libc_valloc_redirect, - __libc_valloc) -weak_alias (__libc_valloc_redirect, valloc) - -libc_ifunc_hidden (__libc_pvalloc, __libc_pvalloc_redirect, - __libc_pvalloc) -weak_alias (__libc_pvalloc_redirect, pvalloc) - -libc_ifunc_hidden (__libc_realloc, __libc_realloc_redirect, - __libc_realloc) -strong_alias (__libc_realloc_redirect, realloc) - -libc_ifunc_hidden (__libc_free, __libc_free_redirect, - __libc_free) -strong_alias (__libc_free_redirect, free) - -libc_ifunc_hidden (__malloc_usable_size, __malloc_usable_size_redirect, - __malloc_usable_size) -weak_alias (__malloc_usable_size_redirect, malloc_usable_size) - -libc_ifunc_hidden (__posix_memalign, __posix_memalign_redirect, - __posix_memalign) -weak_alias (__posix_memalign_redirect, posix_memalign) - -libc_ifunc_hidden (__aligned_alloc, __aligned_alloc_redirect, - __aligned_alloc) -weak_alias (__aligned_alloc_redirect, aligned_alloc) - -libc_ifunc_hidden (__free_sized, __free_sized_redirect, - __free_sized) -weak_alias (__free_sized_redirect, free_sized) - -libc_ifunc_hidden (__free_aligned_sized, __free_aligned_sized_redirect, - __free_aligned_sized) -weak_alias (__free_aligned_sized_redirect, free_aligned_sized) - -#endif /* IS_IN (libc) */ - -#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_26) -compat_symbol (libc, __libc_free_redirect, cfree, GLIBC_2_0); -#endif diff --git a/sysdeps/aarch64/multiarch/malloc-ifuncs.h b/sysdeps/aarch64/multiarch/malloc-ifuncs.h deleted file mode 100644 index 572c2f229e..0000000000 --- a/sysdeps/aarch64/multiarch/malloc-ifuncs.h +++ /dev/null @@ -1,24 +0,0 @@ -/* Definitions for ifunc resolvers for malloc: aarch64 version. - Copyright (C) 2026 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#ifndef _AARCH64_MALLOC_IFUNCS_H -#define _AARCH64_MALLOC_IFUNCS_H - -#define USE_MULTIARCH_MALLOC 1 - -#endif /* _AARCH64_MALLOC_IFUNCS_H */ diff --git a/sysdeps/generic/malloc-api.h b/sysdeps/generic/malloc-api.h deleted file mode 100644 index 2a243cc4af..0000000000 --- a/sysdeps/generic/malloc-api.h +++ /dev/null @@ -1,161 +0,0 @@ -/* Malloc API functions. - Copyright (C) 2026 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public License as - published by the Free Software Foundation; either version 2.1 of the - License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; see the file COPYING.LIB. If - not, see <https://www.gnu.org/licenses/>. */ - -#ifndef _MALLOC_API_H -#define _MALLOC_API_H - -#include <stddef.h> -#include <libc-symbols.h> - -/* - malloc(size_t n) - Returns a pointer to a newly allocated chunk of at least n bytes, or null - if no space is available. Additionally, on failure, errno is - set to ENOMEM on ANSI C systems. - - If n is zero, malloc returns a minimum-sized chunk. (The minimum - size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit - systems.) On most systems, size_t is an unsigned type, so calls - with negative arguments are interpreted as requests for huge amounts - of space, which will often fail. The maximum supported value of n - differs across systems, but is in all cases less than the maximum - representable value of a size_t. -*/ -void *__libc_malloc (size_t); -libc_hidden_proto (__libc_malloc) - -/* - calloc(size_t n_elements, size_t element_size); - Returns a pointer to n_elements * element_size bytes, with all locations - set to zero. -*/ -void *__libc_calloc (size_t, size_t); -libc_hidden_proto (__libc_calloc) - -/* - memalign(size_t alignment, size_t n); - Returns a pointer to a newly allocated chunk of n bytes, aligned - in accord with the alignment argument. - - The alignment argument should be a power of two. If the argument is - not a power of two, the nearest greater power is used. - 8-byte alignment is guaranteed by normal malloc calls, so don't - bother calling memalign with an argument of 8 or less. - - Overreliance on memalign is a sure way to fragment space. -*/ -void *__libc_memalign (size_t, size_t); -libc_hidden_proto (__libc_memalign) - -/* - valloc(size_t n); - Equivalent to memalign(pagesize, n), where pagesize is the page - size of the system. If the pagesize is unknown, 4096 is used. -*/ -void *__libc_valloc (size_t); -libc_hidden_proto (__libc_valloc) - -/* - pvalloc(size_t n); - Equivalent to valloc(minimum-page-that-holds(n)), that is, - round up n to nearest pagesize. - */ -void *__libc_pvalloc (size_t); -libc_hidden_proto (__libc_pvalloc) - -/* - realloc(void* p, size_t n) - Returns a pointer to a chunk of size n that contains the same data - as does chunk p up to the minimum of (n, p's size) bytes, or null - if no space is available. - - The returned pointer may or may not be the same as p. The algorithm - prefers extending p when possible, otherwise it employs the - equivalent of a malloc-copy-free sequence. - - If p is null, realloc is equivalent to malloc. - - If space is not available, realloc returns null, errno is set (if on - ANSI) and p is NOT freed. - - if n is for fewer bytes than already held by p, the newly unused - space is lopped off and freed if possible. Unless the #define - REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of - zero (re)allocates a minimum-sized chunk. - - Large chunks that were internally obtained via mmap will always be - grown using malloc-copy-free sequences unless the system supports - MREMAP (currently only linux). - - The old unix realloc convention of allowing the last-free'd chunk - to be used as an argument to realloc is not supported. -*/ -void *__libc_realloc (void *, size_t); -libc_hidden_proto (__libc_realloc) - -/* - free(void* p) - Releases the chunk of memory pointed to by p, that had been previously - allocated using malloc or a related routine such as realloc. - It has no effect if p is null. It can have arbitrary (i.e., bad!) - effects if p has already been freed. - - Unless disabled (using mallopt), freeing very large spaces will - when possible, automatically trigger operations that give - back unused memory to the system, thus reducing program footprint. -*/ -void __libc_free (void *); -libc_hidden_proto (__libc_free) - -/* - malloc_usable_size(void* p); - - Returns the number of bytes you can actually use in - an allocated chunk, which may be more than you requested (although - often not) due to alignment and minimum size constraints. - You can use this many bytes without worrying about - overwriting other allocated objects. This is not a particularly great - programming practice. malloc_usable_size can be more useful in - debugging and assertions, for example: - - p = malloc(n); - assert(malloc_usable_size(p) >= 256); - -*/ -size_t __malloc_usable_size (void *); -libc_hidden_proto (__malloc_usable_size) - -/* - posix_memalign(void **memptr, size_t alignment, size_t size); - - POSIX wrapper like memalign(), checking for validity of size. -*/ -int __posix_memalign (void **, size_t, size_t); -libc_hidden_proto (__posix_memalign) - -/* For ISO C17. */ -void *__aligned_alloc (size_t, size_t); -libc_hidden_proto (__aligned_alloc) - -/* For ISO C23. */ -void __free_sized (void *, size_t); -libc_hidden_proto (__free_sized) -void __free_aligned_sized (void *, size_t, size_t); -libc_hidden_proto (__free_aligned_sized) - -#endif /* _MALLOC_API_H */ diff --git a/sysdeps/generic/malloc-ifuncs.h b/sysdeps/generic/malloc-ifuncs.h deleted file mode 100644 index 8fe88af95e..0000000000 --- a/sysdeps/generic/malloc-ifuncs.h +++ /dev/null @@ -1,36 +0,0 @@ -/* Definitions for ifunc resolvers for malloc: generic version. - Copyright (C) 2026 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <https://www.gnu.org/licenses/>. */ - -#ifndef _GENERIC_MALLOC_IFUNCS_H -#define _GENERIC_MALLOC_IFUNCS_H - -/* Targets that support GNU ifuncs should define this macro - if they provide ifuncs for malloc functions. - - When USE_MULTIARCH_MALLOC is defined as 1, the following - functions should be implemented via ifuncs: - - malloc, calloc, free, realloc - memalign, valloc, pvalloc - posix_memalign - malloc_usable_size - aligned_alloc, free_sized, free_aligned_sized -*/ -#define USE_MULTIARCH_MALLOC 0 - -#endif /* _GENERIC_MALLOC_IFUNCS_H */