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. */
49 void (*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. */
53 char const xalloc_msg_memory_exhausted[] = N_("memory exhausted");
54
55 void
xalloc_die(void)56 xalloc_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
70 static inline void *
xnmalloc_inline(size_t n,size_t s)71 xnmalloc_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
79 void *
xnmalloc(size_t n,size_t s)80 xnmalloc (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
87 void *
xmalloc(size_t n)88 xmalloc (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
96 static inline void *
xnrealloc_inline(void * p,size_t n,size_t s)97 xnrealloc_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
104 void *
xnrealloc(void * p,size_t n,size_t s)105 xnrealloc (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
113 void *
xrealloc(void * p,size_t n)114 xrealloc (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
175 static inline void *
x2nrealloc_inline(void * p,size_t * pn,size_t s)176 x2nrealloc_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
205 void *
x2nrealloc(void * p,size_t * pn,size_t s)206 x2nrealloc (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
217 void *
x2realloc(void * p,size_t * pn)218 x2realloc (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
227 void *
xzalloc(size_t s)228 xzalloc (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
236 void *
xcalloc(size_t n,size_t s)237 xcalloc (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
251 void *
xclone(void const * p,size_t s)252 xclone (void const *p, size_t s)
253 {
254 return memcpy (xmalloc (s), p, s);
255 }
256