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