[PATCH 1/1] Revert "malloc: aarch64: Add ifuncs for malloc functions"
Yury Khrustalev
yury.khrustalev@arm.com
Wed Jul 1 14:09:34 GMT 2026
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.
---
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(-)
delete mode 100644 sysdeps/aarch64/multiarch/malloc-ifuncs.c
delete mode 100644 sysdeps/aarch64/multiarch/malloc-ifuncs.h
delete mode 100644 sysdeps/generic/malloc-api.h
delete mode 100644 sysdeps/generic/malloc-ifuncs.h
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 */
--
2.47.3
More information about the Libc-alpha
mailing list