1 /* xalloc.h -- malloc with out-of-memory checking
3 Copyright (C) 1990-2000, 2003-2004, 2006-2011 Free Software Foundation, Inc.
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
29 # if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)
30 # define _GL_ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
32 # define _GL_ATTRIBUTE_NORETURN /* empty */
36 # define _GL_ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
38 # define _GL_ATTRIBUTE_MALLOC
41 # if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
42 # define _GL_ATTRIBUTE_ALLOC_SIZE(args) __attribute__ ((__alloc_size__ args))
44 # define _GL_ATTRIBUTE_ALLOC_SIZE(args)
47 /* This function is always triggered when memory is exhausted.
48 It must be defined by the application, either explicitly
49 or by using gnulib's xalloc-die module. This is the
50 function to call when one wants the program to die because of a
51 memory allocation failure. */
52 extern void xalloc_die (void) _GL_ATTRIBUTE_NORETURN;
54 void *xmalloc (size_t s)
55 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
56 void *xzalloc (size_t s)
57 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
58 void *xcalloc (size_t n, size_t s)
59 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1, 2));
60 void *xrealloc (void *p, size_t s)
61 _GL_ATTRIBUTE_ALLOC_SIZE ((2));
62 void *x2realloc (void *p, size_t *pn);
63 void *xmemdup (void const *p, size_t s)
64 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((2));
65 char *xstrdup (char const *str)
68 /* Return 1 if an array of N objects, each of size S, cannot exist due
69 to size arithmetic overflow. S must be positive and N must be
70 nonnegative. This is a macro, not an inline function, so that it
71 works correctly even when SIZE_MAX < N.
73 By gnulib convention, SIZE_MAX represents overflow in size
74 calculations, so the conservative dividend to use here is
75 SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
76 However, malloc (SIZE_MAX) fails on all known hosts where
77 sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
78 exactly-SIZE_MAX allocations on such hosts; this avoids a test and
79 branch when S is known to be 1. */
80 # define xalloc_oversized(n, s) \
81 ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
84 /* In the following macros, T must be an elementary or structure/union or
85 typedef'ed type, or a pointer to such a type. To apply one of the
86 following macros to a function pointer or array type, you need to typedef
87 it first and use the typedef name. */
89 /* Allocate an object of type T dynamically, with error checking. */
90 /* extern t *XMALLOC (typename t); */
91 # define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
93 /* Allocate memory for N elements of type T, with error checking. */
94 /* extern t *XNMALLOC (size_t n, typename t); */
95 # define XNMALLOC(n, t) \
96 ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
98 /* Allocate an object of type T dynamically, with error checking,
100 /* extern t *XZALLOC (typename t); */
101 # define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
103 /* Allocate memory for N elements of type T, with error checking,
105 /* extern t *XCALLOC (size_t n, typename t); */
106 # define XCALLOC(n, t) \
107 ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
111 # define static_inline static inline
113 void *xnmalloc (size_t n, size_t s)
114 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1, 2));
115 void *xnrealloc (void *p, size_t n, size_t s)
116 _GL_ATTRIBUTE_ALLOC_SIZE ((2, 3));
117 void *x2nrealloc (void *p, size_t *pn, size_t s);
118 char *xcharalloc (size_t n)
119 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
122 # ifdef static_inline
124 /* Allocate an array of N objects, each with S bytes of memory,
125 dynamically, with error checking. S must be nonzero. */
127 static_inline void *xnmalloc (size_t n, size_t s)
128 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1, 2));
130 xnmalloc (size_t n, size_t s)
132 if (xalloc_oversized (n, s))
134 return xmalloc (n * s);
137 /* Change the size of an allocated block of memory P to an array of N
138 objects each of S bytes, with error checking. S must be nonzero. */
140 static_inline void *xnrealloc (void *p, size_t n, size_t s)
141 _GL_ATTRIBUTE_ALLOC_SIZE ((2, 3));
143 xnrealloc (void *p, size_t n, size_t s)
145 if (xalloc_oversized (n, s))
147 return xrealloc (p, n * s);
150 /* If P is null, allocate a block of at least *PN such objects;
151 otherwise, reallocate P so that it contains more than *PN objects
152 each of S bytes. *PN must be nonzero unless P is null, and S must
153 be nonzero. Set *PN to the new number of objects, and return the
154 pointer to the new block. *PN is never set to zero, and the
155 returned pointer is never null.
157 Repeated reallocations are guaranteed to make progress, either by
158 allocating an initial block with a nonzero size, or by allocating a
161 In the following implementation, nonzero sizes are increased by a
162 factor of approximately 1.5 so that repeated reallocations have
163 O(N) overall cost rather than O(N**2) cost, but the
164 specification for this function does not guarantee that rate.
166 Here is an example of use:
170 size_t allocated = 0;
173 append_int (int value)
175 if (used == allocated)
176 p = x2nrealloc (p, &allocated, sizeof *p);
180 This causes x2nrealloc to allocate a block of some nonzero size the
181 first time it is called.
183 To have finer-grained control over the initial size, set *PN to a
184 nonzero value before calling this function with P == NULL. For
189 size_t allocated = 0;
190 size_t allocated1 = 1000;
193 append_int (int value)
195 if (used == allocated)
197 p = x2nrealloc (p, &allocated1, sizeof *p);
198 allocated = allocated1;
206 x2nrealloc (void *p, size_t *pn, size_t s)
214 /* The approximate size to use for initial small allocation
215 requests, when the invoking code specifies an old size of
216 zero. 64 bytes is the largest "small" request for the
217 GNU C library malloc. */
218 enum { DEFAULT_MXFAST = 64 };
220 n = DEFAULT_MXFAST / s;
226 /* Set N = ceil (1.5 * N) so that progress is made if N == 1.
227 Check for overflow, so that N * S stays in size_t range.
228 The check is slightly conservative, but an exact check isn't
229 worth the trouble. */
230 if ((size_t) -1 / 3 * 2 / s <= n)
236 return xrealloc (p, n * s);
239 /* Return a pointer to a new buffer of N bytes. This is like xmalloc,
240 except it returns char *. */
242 static_inline char *xcharalloc (size_t n)
243 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
245 xcharalloc (size_t n)
247 return XNMALLOC (n, char);
255 /* C++ does not allow conversions from void * to other pointer types
256 without a cast. Use templates to work around the problem when
259 template <typename T> inline T *
260 xrealloc (T *p, size_t s)
262 return (T *) xrealloc ((void *) p, s);
265 template <typename T> inline T *
266 xnrealloc (T *p, size_t n, size_t s)
268 return (T *) xnrealloc ((void *) p, n, s);
271 template <typename T> inline T *
272 x2realloc (T *p, size_t *pn)
274 return (T *) x2realloc ((void *) p, pn);
277 template <typename T> inline T *
278 x2nrealloc (T *p, size_t *pn, size_t s)
280 return (T *) x2nrealloc ((void *) p, pn, s);
283 template <typename T> inline T *
284 xmemdup (T const *p, size_t s)
286 return (T *) xmemdup ((void const *) p, s);
292 #endif /* !XALLOC_H_ */