1/* xalloc.h -- malloc with out-of-memory checking
2
3   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4   1999, 2000, 2003, 2004, 2006, 2007, 2008, 2009 Free Software
5   Foundation, Inc.
6
7   This program is free software: you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 3 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20#ifndef XALLOC_H_
21# define XALLOC_H_
22
23# include <stddef.h>
24
25
26# ifdef __cplusplus
27extern "C" {
28# endif
29
30
31# ifndef __attribute__
32#  if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
33#   define __attribute__(x)
34#  endif
35# endif
36
37# ifndef ATTRIBUTE_NORETURN
38#  define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
39# endif
40
41# ifndef ATTRIBUTE_MALLOC
42#  if __GNUC__ >= 3
43#   define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
44#  else
45#   define ATTRIBUTE_MALLOC
46#  endif
47# endif
48
49/* This function is always triggered when memory is exhausted.
50   It must be defined by the application, either explicitly
51   or by using gnulib's xalloc-die module.  This is the
52   function to call when one wants the program to die because of a
53   memory allocation failure.  */
54extern void xalloc_die (void) ATTRIBUTE_NORETURN;
55
56void *xmalloc (size_t s) ATTRIBUTE_MALLOC;
57void *xzalloc (size_t s) ATTRIBUTE_MALLOC;
58void *xcalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
59void *xrealloc (void *p, size_t s);
60void *x2realloc (void *p, size_t *pn);
61void *xmemdup (void const *p, size_t s) ATTRIBUTE_MALLOC;
62char *xstrdup (char const *str) ATTRIBUTE_MALLOC;
63
64/* Return 1 if an array of N objects, each of size S, cannot exist due
65   to size arithmetic overflow.  S must be positive and N must be
66   nonnegative.  This is a macro, not an inline function, so that it
67   works correctly even when SIZE_MAX < N.
68
69   By gnulib convention, SIZE_MAX represents overflow in size
70   calculations, so the conservative dividend to use here is
71   SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
72   However, malloc (SIZE_MAX) fails on all known hosts where
73   sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
74   exactly-SIZE_MAX allocations on such hosts; this avoids a test and
75   branch when S is known to be 1.  */
76# define xalloc_oversized(n, s) \
77    ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
78
79
80/* In the following macros, T must be an elementary or structure/union or
81   typedef'ed type, or a pointer to such a type.  To apply one of the
82   following macros to a function pointer or array type, you need to typedef
83   it first and use the typedef name.  */
84
85/* Allocate an object of type T dynamically, with error checking.  */
86/* extern t *XMALLOC (typename t); */
87# define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
88
89/* Allocate memory for N elements of type T, with error checking.  */
90/* extern t *XNMALLOC (size_t n, typename t); */
91# define XNMALLOC(n, t) \
92    ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
93
94/* Allocate an object of type T dynamically, with error checking,
95   and zero it.  */
96/* extern t *XZALLOC (typename t); */
97# define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
98
99/* Allocate memory for N elements of type T, with error checking,
100   and zero it.  */
101/* extern t *XCALLOC (size_t n, typename t); */
102# define XCALLOC(n, t) \
103    ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
104
105
106# if HAVE_INLINE
107#  define static_inline static inline
108# else
109   void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
110   void *xnrealloc (void *p, size_t n, size_t s);
111   void *x2nrealloc (void *p, size_t *pn, size_t s);
112   char *xcharalloc (size_t n) ATTRIBUTE_MALLOC;
113# endif
114
115# ifdef static_inline
116
117/* Allocate an array of N objects, each with S bytes of memory,
118   dynamically, with error checking.  S must be nonzero.  */
119
120static_inline void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
121static_inline void *
122xnmalloc (size_t n, size_t s)
123{
124  if (xalloc_oversized (n, s))
125    xalloc_die ();
126  return xmalloc (n * s);
127}
128
129/* Change the size of an allocated block of memory P to an array of N
130   objects each of S bytes, with error checking.  S must be nonzero.  */
131
132static_inline void *
133xnrealloc (void *p, size_t n, size_t s)
134{
135  if (xalloc_oversized (n, s))
136    xalloc_die ();
137  return xrealloc (p, n * s);
138}
139
140/* If P is null, allocate a block of at least *PN such objects;
141   otherwise, reallocate P so that it contains more than *PN objects
142   each of S bytes.  *PN must be nonzero unless P is null, and S must
143   be nonzero.  Set *PN to the new number of objects, and return the
144   pointer to the new block.  *PN is never set to zero, and the
145   returned pointer is never null.
146
147   Repeated reallocations are guaranteed to make progress, either by
148   allocating an initial block with a nonzero size, or by allocating a
149   larger block.
150
151   In the following implementation, nonzero sizes are increased by a
152   factor of approximately 1.5 so that repeated reallocations have
153   O(N) overall cost rather than O(N**2) cost, but the
154   specification for this function does not guarantee that rate.
155
156   Here is an example of use:
157
158     int *p = NULL;
159     size_t used = 0;
160     size_t allocated = 0;
161
162     void
163     append_int (int value)
164       {
165	 if (used == allocated)
166	   p = x2nrealloc (p, &allocated, sizeof *p);
167	 p[used++] = value;
168       }
169
170   This causes x2nrealloc to allocate a block of some nonzero size the
171   first time it is called.
172
173   To have finer-grained control over the initial size, set *PN to a
174   nonzero value before calling this function with P == NULL.  For
175   example:
176
177     int *p = NULL;
178     size_t used = 0;
179     size_t allocated = 0;
180     size_t allocated1 = 1000;
181
182     void
183     append_int (int value)
184       {
185	 if (used == allocated)
186	   {
187	     p = x2nrealloc (p, &allocated1, sizeof *p);
188	     allocated = allocated1;
189	   }
190	 p[used++] = value;
191       }
192
193   */
194
195static_inline void *
196x2nrealloc (void *p, size_t *pn, size_t s)
197{
198  size_t n = *pn;
199
200  if (! p)
201    {
202      if (! n)
203	{
204	  /* The approximate size to use for initial small allocation
205	     requests, when the invoking code specifies an old size of
206	     zero.  64 bytes is the largest "small" request for the
207	     GNU C library malloc.  */
208	  enum { DEFAULT_MXFAST = 64 };
209
210	  n = DEFAULT_MXFAST / s;
211	  n += !n;
212	}
213    }
214  else
215    {
216      /* Set N = ceil (1.5 * N) so that progress is made if N == 1.
217	 Check for overflow, so that N * S stays in size_t range.
218	 The check is slightly conservative, but an exact check isn't
219	 worth the trouble.  */
220      if ((size_t) -1 / 3 * 2 / s <= n)
221	xalloc_die ();
222      n += (n + 1) / 2;
223    }
224
225  *pn = n;
226  return xrealloc (p, n * s);
227}
228
229/* Return a pointer to a new buffer of N bytes.  This is like xmalloc,
230   except it returns char *.  */
231
232static_inline char *xcharalloc (size_t n) ATTRIBUTE_MALLOC;
233static_inline char *
234xcharalloc (size_t n)
235{
236  return XNMALLOC (n, char);
237}
238
239# endif
240
241# ifdef __cplusplus
242}
243
244/* C++ does not allow conversions from void * to other pointer types
245   without a cast.  Use templates to work around the problem when
246   possible.  */
247
248template <typename T> inline T *
249xrealloc (T *p, size_t s)
250{
251  return (T *) xrealloc ((void *) p, s);
252}
253
254template <typename T> inline T *
255xnrealloc (T *p, size_t n, size_t s)
256{
257  return (T *) xnrealloc ((void *) p, n, s);
258}
259
260template <typename T> inline T *
261x2realloc (T *p, size_t *pn)
262{
263  return (T *) x2realloc ((void *) p, pn);
264}
265
266template <typename T> inline T *
267x2nrealloc (T *p, size_t *pn, size_t s)
268{
269  return (T *) x2nrealloc ((void *) p, pn, s);
270}
271
272template <typename T> inline T *
273xmemdup (T const *p, size_t s)
274{
275  return (T *) xmemdup ((void const *) p, s);
276}
277
278# endif
279
280
281#endif /* !XALLOC_H_ */
282