mirror of
https://github.com/shadow-maint/shadow.git
synced 2026-01-27 06:14:09 +00:00
09775d3718
If we consider simple objects as arrays of size 1, we can considerably
simplify these APIs, merging the *ARRAY and the non-array variants.
That will produce more readable code, since lines will be shorter (by
not having ARRAY in the macro names, as all macros will consistently
handle arrays), and the allocated size will be also more explicit.
The syntax will now be of the form:
p = MALLOC(42, foo_t); // allocate 42 elements of type foo_t.
p = MALLOC(1, bar_t); // allocate 1 element of type foo_t.
The _array() allocation functions should _never_ be called directly, and
instead these macros should be used.
The non-array functions (e.g., malloc(3)) still have their place, but
are limited to allocating structures with flexible array members. For
any other uses, the macros should be used.
Thus, we don't use any array or ARRAY variants in any code any more, and
they are only used as implementation details of these macros.
Link: <https://software.codidact.com/posts/285898/288023#answer-288023>
Signed-off-by: Alejandro Colomar <alx@kernel.org>
116 lines
3.3 KiB
C
116 lines
3.3 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2023, Alejandro Colomar <alx@kernel.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
|
|
#ifndef SHADOW_INCLUDE_LIB_MALLOC_H_
|
|
#define SHADOW_INCLUDE_LIB_MALLOC_H_
|
|
|
|
|
|
#include <config.h>
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "defines.h"
|
|
|
|
|
|
#define CALLOC(n, type) ((type *) calloc(n, sizeof(type)))
|
|
#define XCALLOC(n, type) ((type *) xcalloc(n, sizeof(type)))
|
|
#define MALLOC(n, type) ((type *) mallocarray(n, sizeof(type)))
|
|
#define XMALLOC(n, type) ((type *) xmallocarray(n, sizeof(type)))
|
|
|
|
#define REALLOC(ptr, n, type) \
|
|
({ \
|
|
__auto_type p_ = (ptr); \
|
|
\
|
|
static_assert(__builtin_types_compatible_p(typeof(p_), type *), ""); \
|
|
\
|
|
(type *) reallocarray(p_, n, sizeof(type)); \
|
|
})
|
|
|
|
#define REALLOCF(ptr, n, type) \
|
|
({ \
|
|
__auto_type p_ = (ptr); \
|
|
\
|
|
static_assert(__builtin_types_compatible_p(typeof(p_), type *), ""); \
|
|
\
|
|
(type *) reallocarrayf(p_, n, sizeof(type)); \
|
|
})
|
|
|
|
#define XREALLOC(ptr, n, type) \
|
|
({ \
|
|
__auto_type p_ = (ptr); \
|
|
\
|
|
static_assert(__builtin_types_compatible_p(typeof(p_), type *), ""); \
|
|
\
|
|
(type *) xreallocarray(p_, n, sizeof(type)); \
|
|
})
|
|
|
|
|
|
ATTR_MALLOC(free)
|
|
inline void *xmalloc(size_t size);
|
|
ATTR_MALLOC(free)
|
|
inline void *xmallocarray(size_t nmemb, size_t size);
|
|
ATTR_MALLOC(free)
|
|
inline void *mallocarray(size_t nmemb, size_t size);
|
|
ATTR_MALLOC(free)
|
|
inline void *reallocarrayf(void *p, size_t nmemb, size_t size);
|
|
ATTR_MALLOC(free)
|
|
inline char *xstrdup(const char *str);
|
|
|
|
ATTR_MALLOC(free)
|
|
void *xcalloc(size_t nmemb, size_t size);
|
|
ATTR_MALLOC(free)
|
|
void *xreallocarray(void *p, size_t nmemb, size_t size);
|
|
|
|
|
|
inline void *
|
|
xmalloc(size_t size)
|
|
{
|
|
return xmallocarray(1, size);
|
|
}
|
|
|
|
|
|
inline void *
|
|
xmallocarray(size_t nmemb, size_t size)
|
|
{
|
|
return xreallocarray(NULL, nmemb, size);
|
|
}
|
|
|
|
|
|
inline void *
|
|
mallocarray(size_t nmemb, size_t size)
|
|
{
|
|
return reallocarray(NULL, nmemb, size);
|
|
}
|
|
|
|
|
|
inline void *
|
|
reallocarrayf(void *p, size_t nmemb, size_t size)
|
|
{
|
|
void *q;
|
|
|
|
q = reallocarray(p, nmemb, size);
|
|
|
|
/* realloc(p, 0) is equivalent to free(p); avoid double free. */
|
|
if (q == NULL && nmemb != 0 && size != 0)
|
|
free(p);
|
|
return q;
|
|
}
|
|
|
|
|
|
inline char *
|
|
xstrdup(const char *str)
|
|
{
|
|
return strcpy(XMALLOC(strlen(str) + 1, char), str);
|
|
}
|
|
|
|
|
|
#endif // include guard
|