summaryrefslogtreecommitdiffstats
path: root/lib/xmalloc.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/xmalloc.c')
-rw-r--r--lib/xmalloc.c210
1 files changed, 176 insertions, 34 deletions
diff --git a/lib/xmalloc.c b/lib/xmalloc.c
index 3affee7a..181006b4 100644
--- a/lib/xmalloc.c
+++ b/lib/xmalloc.c
@@ -1,5 +1,7 @@
1/* xmalloc.c -- malloc with out of memory checking 1/* xmalloc.c -- malloc with out of memory checking
2 Copyright (C) 1990-1999, 2000, 2002 Free Software Foundation, Inc. 2
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2003,
4 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
3 5
4 This program is free software; you can redistribute it and/or modify 6 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by 7 it under the terms of the GNU General Public License as published by
@@ -19,30 +21,22 @@
19# include <config.h> 21# include <config.h>
20#endif 22#endif
21 23
22#include <sys/types.h> 24#include "xalloc.h"
23 25
24#if STDC_HEADERS 26#include <stdlib.h>
25# include <stdlib.h> 27#include <string.h>
26#else
27void *calloc ();
28void *malloc ();
29void *realloc ();
30void free ();
31#endif
32 28
33#include "gettext.h" 29#include "gettext.h"
34#define _(msgid) gettext (msgid) 30#define _(msgid) gettext (msgid)
35#define N_(msgid) msgid 31#define N_(msgid) msgid
36 32
37#include "error.h" 33#include "error.h"
38#include "xalloc.h" 34#include "exitfail.h"
39 35
40#ifndef EXIT_FAILURE 36#ifndef SIZE_MAX
41# define EXIT_FAILURE 1 37# define SIZE_MAX ((size_t) -1)
42#endif 38#endif
43 39
44/* The following tests require AC_PREREQ(2.54). */
45
46#ifndef HAVE_MALLOC 40#ifndef HAVE_MALLOC
47"you must run the autoconf test for a GNU libc compatible malloc" 41"you must run the autoconf test for a GNU libc compatible malloc"
48#endif 42#endif
@@ -51,12 +45,8 @@ void free ();
51"you must run the autoconf test for a GNU libc compatible realloc" 45"you must run the autoconf test for a GNU libc compatible realloc"
52#endif 46#endif
53 47
54/* Exit value when the requested amount of memory is not available.
55 The caller may set it to some other value. */
56int xalloc_exit_failure = EXIT_FAILURE;
57
58/* If non NULL, call this function when memory is exhausted. */ 48/* If non NULL, call this function when memory is exhausted. */
59void (*xalloc_fail_func) PARAMS ((void)) = 0; 49void (*xalloc_fail_func) (void) = 0;
60 50
61/* If XALLOC_FAIL_FUNC is NULL, or does return, display this message 51/* If XALLOC_FAIL_FUNC is NULL, or does return, display this message
62 before exiting when memory is exhausted. Goes through gettext. */ 52 before exiting when memory is exhausted. Goes through gettext. */
@@ -67,11 +57,29 @@ xalloc_die (void)
67{ 57{
68 if (xalloc_fail_func) 58 if (xalloc_fail_func)
69 (*xalloc_fail_func) (); 59 (*xalloc_fail_func) ();
70 error (xalloc_exit_failure, 0, "%s", _(xalloc_msg_memory_exhausted)); 60 error (exit_failure, 0, "%s", _(xalloc_msg_memory_exhausted));
71 /* The `noreturn' cannot be given to error, since it may return if 61 /* The `noreturn' cannot be given to error, since it may return if
72 its first argument is 0. To help compilers understand the 62 its first argument is 0. To help compilers understand the
73 xalloc_die does terminate, call exit. */ 63 xalloc_die does terminate, call abort. */
74 exit (EXIT_FAILURE); 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);
75} 83}
76 84
77/* Allocate N bytes of memory dynamically, with error checking. */ 85/* Allocate N bytes of memory dynamically, with error checking. */
@@ -79,35 +87,169 @@ xalloc_die (void)
79void * 87void *
80xmalloc (size_t n) 88xmalloc (size_t n)
81{ 89{
82 void *p; 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. */
83 95
84 p = malloc (n); 96static inline void *
85 if (p == 0) 97xnrealloc_inline (void *p, size_t n, size_t s)
98{
99 if (xalloc_oversized (n, s) || ! (p = realloc (p, n * s)))
86 xalloc_die (); 100 xalloc_die ();
87 return p; 101 return p;
88} 102}
89 103
104void *
105xnrealloc (void *p, size_t n, size_t s)
106{
107 return xnrealloc_inline (p, n, s);
108}
109
90/* Change the size of an allocated block of memory P to N bytes, 110/* Change the size of an allocated block of memory P to N bytes,
91 with error checking. */ 111 with error checking. */
92 112
93void * 113void *
94xrealloc (void *p, size_t n) 114xrealloc (void *p, size_t n)
95{ 115{
96 p = realloc (p, n); 116 return xnrealloc_inline (p, n, 1);
97 if (p == 0)
98 xalloc_die ();
99 return p;
100} 117}
101 118
102/* Allocate memory for N elements of S bytes, with error checking. */ 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. */
103 235
104void * 236void *
105xcalloc (size_t n, size_t s) 237xcalloc (size_t n, size_t s)
106{ 238{
107 void *p; 239 void *p;
108 240 /* Test for overflow, since some calloc implementations don't have
109 p = calloc (n, s); 241 proper overflow checks. */
110 if (p == 0) 242 if (xalloc_oversized (n, s) || ! (p = calloc (n, s)))
111 xalloc_die (); 243 xalloc_die ();
112 return p; 244 return p;
113} 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}