1/* xalloc.h -- malloc with out-of-memory checking
2
3   Copyright (C) 1990-2000, 2003-2004, 2006-2014 Free Software Foundation, Inc.
4
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.
9
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.
14
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/>.  */
17
18#ifndef XALLOC_H_
19#define XALLOC_H_
20
21#include <stddef.h>
22
23#include "xalloc-oversized.h"
24
25#ifndef _GL_INLINE_HEADER_BEGIN
26 #error "Please include config.h first."
27#endif
28_GL_INLINE_HEADER_BEGIN
29#ifndef XALLOC_INLINE
30# define XALLOC_INLINE _GL_INLINE
31#endif
32
33#ifdef __cplusplus
34extern "C" {
35#endif
36
37
38#if __GNUC__ >= 3
39# define _GL_ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
40#else
41# define _GL_ATTRIBUTE_MALLOC
42#endif
43
44#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
45# define _GL_ATTRIBUTE_ALLOC_SIZE(args) __attribute__ ((__alloc_size__ args))
46#else
47# define _GL_ATTRIBUTE_ALLOC_SIZE(args)
48#endif
49
50/* This function is always triggered when memory is exhausted.
51   It must be defined by the application, either explicitly
52   or by using gnulib's xalloc-die module.  This is the
53   function to call when one wants the program to die because of a
54   memory allocation failure.  */
55extern _Noreturn void xalloc_die (void);
56
57void *xmalloc (size_t s)
58      _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
59void *xzalloc (size_t s)
60      _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
61void *xcalloc (size_t n, size_t s)
62      _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1, 2));
63void *xrealloc (void *p, size_t s)
64      _GL_ATTRIBUTE_ALLOC_SIZE ((2));
65void *x2realloc (void *p, size_t *pn);
66void *xmemdup (void const *p, size_t s)
67      _GL_ATTRIBUTE_ALLOC_SIZE ((2));
68char *xstrdup (char const *str)
69      _GL_ATTRIBUTE_MALLOC;
70
71/* In the following macros, T must be an elementary or structure/union or
72   typedef'ed type, or a pointer to such a type.  To apply one of the
73   following macros to a function pointer or array type, you need to typedef
74   it first and use the typedef name.  */
75
76/* Allocate an object of type T dynamically, with error checking.  */
77/* extern t *XMALLOC (typename t); */
78#define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
79
80/* Allocate memory for N elements of type T, with error checking.  */
81/* extern t *XNMALLOC (size_t n, typename t); */
82#define XNMALLOC(n, t) \
83   ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
84
85/* Allocate an object of type T dynamically, with error checking,
86   and zero it.  */
87/* extern t *XZALLOC (typename t); */
88#define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
89
90/* Allocate memory for N elements of type T, with error checking,
91   and zero it.  */
92/* extern t *XCALLOC (size_t n, typename t); */
93#define XCALLOC(n, t) \
94   ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
95
96
97/* Allocate an array of N objects, each with S bytes of memory,
98   dynamically, with error checking.  S must be nonzero.  */
99
100XALLOC_INLINE void *xnmalloc (size_t n, size_t s)
101                    _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1, 2));
102XALLOC_INLINE void *
103xnmalloc (size_t n, size_t s)
104{
105  if (xalloc_oversized (n, s))
106    xalloc_die ();
107  return xmalloc (n * s);
108}
109
110/* Change the size of an allocated block of memory P to an array of N
111   objects each of S bytes, with error checking.  S must be nonzero.  */
112
113XALLOC_INLINE void *xnrealloc (void *p, size_t n, size_t s)
114                    _GL_ATTRIBUTE_ALLOC_SIZE ((2, 3));
115XALLOC_INLINE void *
116xnrealloc (void *p, size_t n, size_t s)
117{
118  if (xalloc_oversized (n, s))
119    xalloc_die ();
120  return xrealloc (p, n * s);
121}
122
123/* If P is null, allocate a block of at least *PN such objects;
124   otherwise, reallocate P so that it contains more than *PN objects
125   each of S bytes.  S must be nonzero.  Set *PN to the new number of
126   objects, and return the pointer to the new block.  *PN is never set
127   to zero, and the returned pointer is never null.
128
129   Repeated reallocations are guaranteed to make progress, either by
130   allocating an initial block with a nonzero size, or by allocating a
131   larger block.
132
133   In the following implementation, nonzero sizes are increased by a
134   factor of approximately 1.5 so that repeated reallocations have
135   O(N) overall cost rather than O(N**2) cost, but the
136   specification for this function does not guarantee that rate.
137
138   Here is an example of use:
139
140     int *p = NULL;
141     size_t used = 0;
142     size_t allocated = 0;
143
144     void
145     append_int (int value)
146       {
147         if (used == allocated)
148           p = x2nrealloc (p, &allocated, sizeof *p);
149         p[used++] = value;
150       }
151
152   This causes x2nrealloc to allocate a block of some nonzero size the
153   first time it is called.
154
155   To have finer-grained control over the initial size, set *PN to a
156   nonzero value before calling this function with P == NULL.  For
157   example:
158
159     int *p = NULL;
160     size_t used = 0;
161     size_t allocated = 0;
162     size_t allocated1 = 1000;
163
164     void
165     append_int (int value)
166       {
167         if (used == allocated)
168           {
169             p = x2nrealloc (p, &allocated1, sizeof *p);
170             allocated = allocated1;
171           }
172         p[used++] = value;
173       }
174
175   */
176
177XALLOC_INLINE void *
178x2nrealloc (void *p, size_t *pn, size_t s)
179{
180  size_t n = *pn;
181
182  if (! p)
183    {
184      if (! n)
185        {
186          /* The approximate size to use for initial small allocation
187             requests, when the invoking code specifies an old size of
188             zero.  This is the largest "small" request for the GNU C
189             library malloc.  */
190          enum { DEFAULT_MXFAST = 64 * sizeof (size_t) / 4 };
191
192          n = DEFAULT_MXFAST / s;
193          n += !n;
194        }
195    }
196  else
197    {
198      /* Set N = floor (1.5 * N) + 1 so that progress is made even if N == 0.
199         Check for overflow, so that N * S stays in size_t range.
200         The check may be slightly conservative, but an exact check isn't
201         worth the trouble.  */
202      if ((size_t) -1 / 3 * 2 / s <= n)
203        xalloc_die ();
204      n += n / 2 + 1;
205    }
206
207  *pn = n;
208  return xrealloc (p, n * s);
209}
210
211/* Return a pointer to a new buffer of N bytes.  This is like xmalloc,
212   except it returns char *.  */
213
214XALLOC_INLINE char *xcharalloc (size_t n)
215                    _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
216XALLOC_INLINE char *
217xcharalloc (size_t n)
218{
219  return XNMALLOC (n, char);
220}
221
222#ifdef __cplusplus
223}
224
225/* C++ does not allow conversions from void * to other pointer types
226   without a cast.  Use templates to work around the problem when
227   possible.  */
228
229template <typename T> inline T *
230xrealloc (T *p, size_t s)
231{
232  return (T *) xrealloc ((void *) p, s);
233}
234
235template <typename T> inline T *
236xnrealloc (T *p, size_t n, size_t s)
237{
238  return (T *) xnrealloc ((void *) p, n, s);
239}
240
241template <typename T> inline T *
242x2realloc (T *p, size_t *pn)
243{
244  return (T *) x2realloc ((void *) p, pn);
245}
246
247template <typename T> inline T *
248x2nrealloc (T *p, size_t *pn, size_t s)
249{
250  return (T *) x2nrealloc ((void *) p, pn, s);
251}
252
253template <typename T> inline T *
254xmemdup (T const *p, size_t s)
255{
256  return (T *) xmemdup ((void const *) p, s);
257}
258
259#endif
260
261
262#endif /* !XALLOC_H_ */
263