1 /* -*- buffer-read-only: t -*- vi: set ro: */
2 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
3 /* xalloc.h -- malloc with out-of-memory checking
5 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
6 2000, 2003, 2004, 2006, 2007, 2008, 2009, 2010 Free Software Foundation,
9 This program is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
33 # ifndef __attribute__
34 # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
35 # define __attribute__(x)
39 # ifndef ATTRIBUTE_NORETURN
40 # define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
43 # ifndef ATTRIBUTE_MALLOC
45 # define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
47 # define ATTRIBUTE_MALLOC
51 # ifndef ATTRIBUTE_ALLOC_SIZE
52 # if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
53 # define ATTRIBUTE_ALLOC_SIZE(args) __attribute__ ((__alloc_size__ args))
55 # define ATTRIBUTE_ALLOC_SIZE(args)
59 /* This function is always triggered when memory is exhausted.
60 It must be defined by the application, either explicitly
61 or by using gnulib's xalloc-die module. This is the
62 function to call when one wants the program to die because of a
63 memory allocation failure. */
64 extern void xalloc_die (void) ATTRIBUTE_NORETURN;
66 void *xmalloc (size_t s)
67 ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE ((1));
68 void *xzalloc (size_t s)
69 ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE ((1));
70 void *xcalloc (size_t n, size_t s)
71 ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE ((1, 2));
72 void *xrealloc (void *p, size_t s)
73 ATTRIBUTE_ALLOC_SIZE ((2));
74 void *x2realloc (void *p, size_t *pn);
75 void *xmemdup (void const *p, size_t s)
76 ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE ((2));
77 char *xstrdup (char const *str)
80 /* Return 1 if an array of N objects, each of size S, cannot exist due
81 to size arithmetic overflow. S must be positive and N must be
82 nonnegative. This is a macro, not an inline function, so that it
83 works correctly even when SIZE_MAX < N.
85 By gnulib convention, SIZE_MAX represents overflow in size
86 calculations, so the conservative dividend to use here is
87 SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
88 However, malloc (SIZE_MAX) fails on all known hosts where
89 sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
90 exactly-SIZE_MAX allocations on such hosts; this avoids a test and
91 branch when S is known to be 1. */
92 # define xalloc_oversized(n, s) \
93 ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
96 /* In the following macros, T must be an elementary or structure/union or
97 typedef'ed type, or a pointer to such a type. To apply one of the
98 following macros to a function pointer or array type, you need to typedef
99 it first and use the typedef name. */
101 /* Allocate an object of type T dynamically, with error checking. */
102 /* extern t *XMALLOC (typename t); */
103 # define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
105 /* Allocate memory for N elements of type T, with error checking. */
106 /* extern t *XNMALLOC (size_t n, typename t); */
107 # define XNMALLOC(n, t) \
108 ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
110 /* Allocate an object of type T dynamically, with error checking,
112 /* extern t *XZALLOC (typename t); */
113 # define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
115 /* Allocate memory for N elements of type T, with error checking,
117 /* extern t *XCALLOC (size_t n, typename t); */
118 # define XCALLOC(n, t) \
119 ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
123 # define static_inline static inline
125 void *xnmalloc (size_t n, size_t s)
126 ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE ((1, 2));
127 void *xnrealloc (void *p, size_t n, size_t s)
128 ATTRIBUTE_ALLOC_SIZE ((2, 3));
129 void *x2nrealloc (void *p, size_t *pn, size_t s);
130 char *xcharalloc (size_t n)
131 ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE ((1));
134 # ifdef static_inline
136 /* Allocate an array of N objects, each with S bytes of memory,
137 dynamically, with error checking. S must be nonzero. */
139 static_inline void *xnmalloc (size_t n, size_t s)
140 ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE ((1, 2));
142 xnmalloc (size_t n, size_t s)
144 if (xalloc_oversized (n, s))
146 return xmalloc (n * s);
149 /* Change the size of an allocated block of memory P to an array of N
150 objects each of S bytes, with error checking. S must be nonzero. */
152 static_inline void *xnrealloc (void *p, size_t n, size_t s)
153 ATTRIBUTE_ALLOC_SIZE ((2, 3));
155 xnrealloc (void *p, size_t n, size_t s)
157 if (xalloc_oversized (n, s))
159 return xrealloc (p, n * s);
162 /* If P is null, allocate a block of at least *PN such objects;
163 otherwise, reallocate P so that it contains more than *PN objects
164 each of S bytes. *PN must be nonzero unless P is null, and S must
165 be nonzero. Set *PN to the new number of objects, and return the
166 pointer to the new block. *PN is never set to zero, and the
167 returned pointer is never null.
169 Repeated reallocations are guaranteed to make progress, either by
170 allocating an initial block with a nonzero size, or by allocating a
173 In the following implementation, nonzero sizes are increased by a
174 factor of approximately 1.5 so that repeated reallocations have
175 O(N) overall cost rather than O(N**2) cost, but the
176 specification for this function does not guarantee that rate.
178 Here is an example of use:
182 size_t allocated = 0;
185 append_int (int value)
187 if (used == allocated)
188 p = x2nrealloc (p, &allocated, sizeof *p);
192 This causes x2nrealloc to allocate a block of some nonzero size the
193 first time it is called.
195 To have finer-grained control over the initial size, set *PN to a
196 nonzero value before calling this function with P == NULL. For
201 size_t allocated = 0;
202 size_t allocated1 = 1000;
205 append_int (int value)
207 if (used == allocated)
209 p = x2nrealloc (p, &allocated1, sizeof *p);
210 allocated = allocated1;
218 x2nrealloc (void *p, size_t *pn, size_t s)
226 /* The approximate size to use for initial small allocation
227 requests, when the invoking code specifies an old size of
228 zero. 64 bytes is the largest "small" request for the
229 GNU C library malloc. */
230 enum { DEFAULT_MXFAST = 64 };
232 n = DEFAULT_MXFAST / s;
238 /* Set N = ceil (1.5 * N) so that progress is made if N == 1.
239 Check for overflow, so that N * S stays in size_t range.
240 The check is slightly conservative, but an exact check isn't
241 worth the trouble. */
242 if ((size_t) -1 / 3 * 2 / s <= n)
248 return xrealloc (p, n * s);
251 /* Return a pointer to a new buffer of N bytes. This is like xmalloc,
252 except it returns char *. */
254 static_inline char *xcharalloc (size_t n)
255 ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE ((1));
257 xcharalloc (size_t n)
259 return XNMALLOC (n, char);
267 /* C++ does not allow conversions from void * to other pointer types
268 without a cast. Use templates to work around the problem when
271 template <typename T> inline T *
272 xrealloc (T *p, size_t s)
274 return (T *) xrealloc ((void *) p, s);
277 template <typename T> inline T *
278 xnrealloc (T *p, size_t n, size_t s)
280 return (T *) xnrealloc ((void *) p, n, s);
283 template <typename T> inline T *
284 x2realloc (T *p, size_t *pn)
286 return (T *) x2realloc ((void *) p, pn);
289 template <typename T> inline T *
290 x2nrealloc (T *p, size_t *pn, size_t s)
292 return (T *) x2nrealloc ((void *) p, pn, s);
295 template <typename T> inline T *
296 xmemdup (T const *p, size_t s)
298 return (T *) xmemdup ((void const *) p, s);
304 #endif /* !XALLOC_H_ */