1/* xmalloc.c -- malloc with out of memory checking
2
3   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2003,
4   1999, 2000, 2002, 2003 Free Software Foundation, Inc.
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   This program is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program; if not, write to the Free Software Foundation,
18   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
19
20#if HAVE_CONFIG_H
21# include <config.h>
22#endif
23
24#include "xalloc.h"
25
26#include <stdlib.h>
27#include <string.h>
28
29#include "gettext.h"
30#define _(msgid) gettext (msgid)
31#define N_(msgid) msgid
32
33#include "error.h"
34#include "exitfail.h"
35
36#ifndef SIZE_MAX
37# define SIZE_MAX ((size_t) -1)
38#endif
39
40#ifndef HAVE_MALLOC
41"you must run the autoconf test for a GNU libc compatible malloc"
42#endif
43
44#ifndef HAVE_REALLOC
45"you must run the autoconf test for a GNU libc compatible realloc"
46#endif
47
48/* If non NULL, call this function when memory is exhausted. */
49void (*xalloc_fail_func) (void) = 0;
50
51/* If XALLOC_FAIL_FUNC is NULL, or does return, display this message
52   before exiting when memory is exhausted.  Goes through gettext. */
53char const xalloc_msg_memory_exhausted[] = N_("memory exhausted");
54
55void
56xalloc_die (void)
57{
58  if (xalloc_fail_func)
59    (*xalloc_fail_func) ();
60  error (exit_failure, 0, "%s", _(xalloc_msg_memory_exhausted));
61  /* The `noreturn' cannot be given to error, since it may return if
62     its first argument is 0.  To help compilers understand the
63     xalloc_die does terminate, call abort.  */
64  abort ();
65}
66
67/* Allocate an array of N objects, each with S bytes of memory,
68   dynamically, with error checking.  S must be nonzero.  */
69
70static inline void *
71xnmalloc_inline (size_t n, size_t s)
72{
73  void *p;
74  if (xalloc_oversized (n, s) || ! (p = malloc (n * s)))
75    xalloc_die ();
76  return p;
77}
78
79void *
80xnmalloc (size_t n, size_t s)
81{
82  return xnmalloc_inline (n, s);
83}
84
85/* Allocate N bytes of memory dynamically, with error checking.  */
86
87void *
88xmalloc (size_t n)
89{
90  return xnmalloc_inline (n, 1);
91}
92
93/* Change the size of an allocated block of memory P to an array of N
94   objects each of S bytes, with error checking.  S must be nonzero.  */
95
96static inline void *
97xnrealloc_inline (void *p, size_t n, size_t s)
98{
99  if (xalloc_oversized (n, s) || ! (p = realloc (p, n * s)))
100    xalloc_die ();
101  return p;
102}
103
104void *
105xnrealloc (void *p, size_t n, size_t s)
106{
107  return xnrealloc_inline (p, n, s);
108}
109
110/* Change the size of an allocated block of memory P to N bytes,
111   with error checking.  */
112
113void *
114xrealloc (void *p, size_t n)
115{
116  return xnrealloc_inline (p, n, 1);
117}
118
119
120/* If P is null, allocate a block of at least *PN such objects;
121   otherwise, reallocate P so that it contains more than *PN objects
122   each of S bytes.  *PN must be nonzero unless P is null, and S must
123   be nonzero.  Set *PN to the new number of objects, and return the
124   pointer to the new block.  *PN is never set to zero, and the
125   returned pointer is never null.
126
127   Repeated reallocations are guaranteed to make progress, either by
128   allocating an initial block with a nonzero size, or by allocating a
129   larger block.
130
131   In the following implementation, nonzero sizes are doubled so that
132   repeated reallocations have O(N log N) overall cost rather than
133   O(N**2) cost, but the specification for this function does not
134   guarantee that sizes are doubled.
135
136   Here is an example of use:
137
138     int *p = NULL;
139     size_t used = 0;
140     size_t allocated = 0;
141
142     void
143     append_int (int value)
144       {
145	 if (used == allocated)
146	   p = x2nrealloc (p, &allocated, sizeof *p);
147	 p[used++] = value;
148       }
149
150   This causes x2nrealloc to allocate a block of some nonzero size the
151   first time it is called.
152
153   To have finer-grained control over the initial size, set *PN to a
154   nonzero value before calling this function with P == NULL.  For
155   example:
156
157     int *p = NULL;
158     size_t used = 0;
159     size_t allocated = 0;
160     size_t allocated1 = 1000;
161
162     void
163     append_int (int value)
164       {
165	 if (used == allocated)
166	   {
167	     p = x2nrealloc (p, &allocated1, sizeof *p);
168	     allocated = allocated1;
169	   }
170	 p[used++] = value;
171       }
172
173   */
174
175static inline void *
176x2nrealloc_inline (void *p, size_t *pn, size_t s)
177{
178  size_t n = *pn;
179
180  if (! p)
181    {
182      if (! n)
183	{
184	  /* The approximate size to use for initial small allocation
185	     requests, when the invoking code specifies an old size of
186	     zero.  64 bytes is the largest "small" request for the
187	     GNU C library malloc.  */
188	  enum { DEFAULT_MXFAST = 64 };
189
190	  n = DEFAULT_MXFAST / s;
191	  n += !n;
192	}
193    }
194  else
195    {
196      if (SIZE_MAX / 2 / s < n)
197	xalloc_die ();
198      n *= 2;
199    }
200
201  *pn = n;
202  return xrealloc (p, n * s);
203}
204
205void *
206x2nrealloc (void *p, size_t *pn, size_t s)
207{
208  return x2nrealloc_inline (p, pn, s);
209}
210
211/* If P is null, allocate a block of at least *PN bytes; otherwise,
212   reallocate P so that it contains more than *PN bytes.  *PN must be
213   nonzero unless P is null.  Set *PN to the new block's size, and
214   return the pointer to the new block.  *PN is never set to zero, and
215   the returned pointer is never null.  */
216
217void *
218x2realloc (void *p, size_t *pn)
219{
220  return x2nrealloc_inline (p, pn, 1);
221}
222
223/* Allocate S bytes of zeroed memory dynamically, with error checking.
224   There's no need for xnzalloc (N, S), since it would be equivalent
225   to xcalloc (N, S).  */
226
227void *
228xzalloc (size_t s)
229{
230  return memset (xmalloc (s), 0, s);
231}
232
233/* Allocate zeroed memory for N elements of S bytes, with error
234   checking.  S must be nonzero.  */
235
236void *
237xcalloc (size_t n, size_t s)
238{
239  void *p;
240  /* Test for overflow, since some calloc implementations don't have
241     proper overflow checks.  */
242  if (xalloc_oversized (n, s) || ! (p = calloc (n, s)))
243    xalloc_die ();
244  return p;
245}
246
247/* Clone an object P of size S, with error checking.  There's no need
248   for xnclone (P, N, S), since xclone (P, N * S) works without any
249   need for an arithmetic overflow check.  */
250
251void *
252xclone (void const *p, size_t s)
253{
254  return memcpy (xmalloc (s), p, s);
255}
256