xalloc.h

   1 /* xalloc.h -- malloc with out-of-memory checking
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4    2000, 2003, 2004, 2006, 2007, 2008, 2009, 2010 Free Software Foundation,
   5    Inc.
   6
   7    This program is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef XALLOC_H_
  21 # define XALLOC_H_
  22
  23 # include <stddef.h>
  24
  25
  26 # ifdef __cplusplus
  27 extern "C" {
  28 # endif
  29
  30
  31 # ifndef __attribute__
  32 #  if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
  33 #   define __attribute__(x)
  34 #  endif
  35 # endif
  36
  37 # ifndef ATTRIBUTE_NORETURN
  38 #  define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
  39 # endif
  40
  41 # ifndef ATTRIBUTE_MALLOC
  42 #  if __GNUC__ >= 3
  43 #   define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
  44 #  else
  45 #   define ATTRIBUTE_MALLOC
  46 #  endif
  47 # endif
  48
  49 /* This function is always triggered when memory is exhausted.
  50    It must be defined by the application, either explicitly
  51    or by using gnulib's xalloc-die module.  This is the
  52    function to call when one wants the program to die because of a
  53    memory allocation failure.  */
  54 extern void xalloc_die (void) ATTRIBUTE_NORETURN;
  55
  56 void *xmalloc (size_t s) ATTRIBUTE_MALLOC;
  57 void *xzalloc (size_t s) ATTRIBUTE_MALLOC;
  58 void *xcalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
  59 void *xrealloc (void *p, size_t s);
  60 void *x2realloc (void *p, size_t *pn);
  61 void *xmemdup (void const *p, size_t s) ATTRIBUTE_MALLOC;
  62 char *xstrdup (char const *str) ATTRIBUTE_MALLOC;
  63
  64 /* Return 1 if an array of N objects, each of size S, cannot exist due
  65    to size arithmetic overflow.  S must be positive and N must be
  66    nonnegative.  This is a macro, not an inline function, so that it
  67    works correctly even when SIZE_MAX < N.
  68
  69    By gnulib convention, SIZE_MAX represents overflow in size
  70    calculations, so the conservative dividend to use here is
  71    SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
  72    However, malloc (SIZE_MAX) fails on all known hosts where
  73    sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
  74    exactly-SIZE_MAX allocations on such hosts; this avoids a test and
  75    branch when S is known to be 1.  */
  76 # define xalloc_oversized(n, s) \
  77     ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
  78
  79
  80 /* In the following macros, T must be an elementary or structure/union or
  81    typedef'ed type, or a pointer to such a type.  To apply one of the
  82    following macros to a function pointer or array type, you need to typedef
  83    it first and use the typedef name.  */
  84
  85 /* Allocate an object of type T dynamically, with error checking.  */
  86 /* extern t *XMALLOC (typename t); */
  87 # define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
  88
  89 /* Allocate memory for N elements of type T, with error checking.  */
  90 /* extern t *XNMALLOC (size_t n, typename t); */
  91 # define XNMALLOC(n, t) \
  92     ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
  93
  94 /* Allocate an object of type T dynamically, with error checking,
  95    and zero it.  */
  96 /* extern t *XZALLOC (typename t); */
  97 # define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
  98
  99 /* Allocate memory for N elements of type T, with error checking,
 100    and zero it.  */
 101 /* extern t *XCALLOC (size_t n, typename t); */
 102 # define XCALLOC(n, t) \
 103     ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
 104
 105 /*
 106  * Gawk uses this file only to keep dfa.c happy.
 107  * We're therefore safe in manually defining HAVE_INLINE to
 108  * make the !@#$%^&*() thing just work.
 109  */
 110 #ifdef GAWK
 111 #define HAVE_INLINE     1       /* so there. nyah, nyah, nyah. */
 112 #endif
 113
 114 # if HAVE_INLINE
 115 #  define static_inline static inline
 116 # else
 117 void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
 118 void *xnrealloc (void *p, size_t n, size_t s);
 119 void *x2nrealloc (void *p, size_t *pn, size_t s);
 120 char *xcharalloc (size_t n) ATTRIBUTE_MALLOC;
 121 # endif
 122
 123 # ifdef static_inline
 124
 125 /* Allocate an array of N objects, each with S bytes of memory,
 126    dynamically, with error checking.  S must be nonzero.  */
 127
 128 static_inline void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
 129 static_inline void *
 130 xnmalloc (size_t n, size_t s)
 131 {
 132   if (xalloc_oversized (n, s))
 133     xalloc_die ();
 134   return xmalloc (n * s);
 135 }
 136
 137 #ifdef GAWK
 138 #include <errno.h>
 139 /* Allocate an array of N objects, each with S bytes of memory,
 140    dynamically, with error checking.  S must be nonzero.
 141    Clear the contents afterwards.  */
 142
 143 void *
 144 xcalloc(size_t nmemb, size_t size)
 145 {
 146   void *p = xmalloc (nmemb * size);
 147   memset(p, '\0', nmemb * size);
 148   return p;
 149 }
 150
 151 /* Reallocate a pointer to a new size, with error checking. */
 152
 153 void *
 154 xrealloc(void *p, size_t size)
 155 {
 156    void *new_p = realloc(p, size);
 157    if (new_p ==  0)
 158      xalloc_die ();
 159
 160    return new_p;
 161 }
 162
 163 /* xalloc_die --- fatal error message when malloc fails, needed by dfa.c */
 164
 165 void
 166 xalloc_die (void)
 167 {
 168         extern void r_fatal(const char *msg, ...) ATTRIBUTE_NORETURN ;
 169
 170         r_fatal(_("xalloc: malloc failed: %s"), strerror(errno));
 171 }
 172
 173 /* Clone an object P of size S, with error checking.  There's no need
 174    for xnmemdup (P, N, S), since xmemdup (P, N * S) works without any
 175    need for an arithmetic overflow check.  */
 176
 177 void *
 178 xmemdup (void const *p, size_t s)
 179 {
 180   return memcpy (xmalloc (s), p, s);
 181 }
 182 #endif
 183
 184 /* Change the size of an allocated block of memory P to an array of N
 185    objects each of S bytes, with error checking.  S must be nonzero.  */
 186
 187 static_inline void *
 188 xnrealloc (void *p, size_t n, size_t s)
 189 {
 190   if (xalloc_oversized (n, s))
 191     xalloc_die ();
 192   return xrealloc (p, n * s);
 193 }
 194
 195 /* If P is null, allocate a block of at least *PN such objects;
 196    otherwise, reallocate P so that it contains more than *PN objects
 197    each of S bytes.  *PN must be nonzero unless P is null, and S must
 198    be nonzero.  Set *PN to the new number of objects, and return the
 199    pointer to the new block.  *PN is never set to zero, and the
 200    returned pointer is never null.
 201
 202    Repeated reallocations are guaranteed to make progress, either by
 203    allocating an initial block with a nonzero size, or by allocating a
 204    larger block.
 205
 206    In the following implementation, nonzero sizes are increased by a
 207    factor of approximately 1.5 so that repeated reallocations have
 208    O(N) overall cost rather than O(N**2) cost, but the
 209    specification for this function does not guarantee that rate.
 210
 211    Here is an example of use:
 212
 213      int *p = NULL;
 214      size_t used = 0;
 215      size_t allocated = 0;
 216
 217      void
 218      append_int (int value)
 219        {
 220          if (used == allocated)
 221            p = x2nrealloc (p, &allocated, sizeof *p);
 222          p[used++] = value;
 223        }
 224
 225    This causes x2nrealloc to allocate a block of some nonzero size the
 226    first time it is called.
 227
 228    To have finer-grained control over the initial size, set *PN to a
 229    nonzero value before calling this function with P == NULL.  For
 230    example:
 231
 232      int *p = NULL;
 233      size_t used = 0;
 234      size_t allocated = 0;
 235      size_t allocated1 = 1000;
 236
 237      void
 238      append_int (int value)
 239        {
 240          if (used == allocated)
 241            {
 242              p = x2nrealloc (p, &allocated1, sizeof *p);
 243              allocated = allocated1;
 244            }
 245          p[used++] = value;
 246        }
 247
 248    */
 249
 250 static_inline void *
 251 x2nrealloc (void *p, size_t *pn, size_t s)
 252 {
 253   size_t n = *pn;
 254
 255   if (! p)
 256     {
 257       if (! n)
 258         {
 259           /* The approximate size to use for initial small allocation
 260              requests, when the invoking code specifies an old size of
 261              zero.  64 bytes is the largest "small" request for the
 262              GNU C library malloc.  */
 263           enum { DEFAULT_MXFAST = 64 };
 264
 265           n = DEFAULT_MXFAST / s;
 266           n += !n;
 267         }
 268     }
 269   else
 270     {
 271       /* Set N = ceil (1.5 * N) so that progress is made if N == 1.
 272          Check for overflow, so that N * S stays in size_t range.
 273          The check is slightly conservative, but an exact check isn't
 274          worth the trouble.  */
 275       if ((size_t) -1 / 3 * 2 / s <= n)
 276         xalloc_die ();
 277       n += (n + 1) / 2;
 278     }
 279
 280   *pn = n;
 281   return xrealloc (p, n * s);
 282 }
 283
 284 /* Return a pointer to a new buffer of N bytes.  This is like xmalloc,
 285    except it returns char *.  */
 286
 287 static_inline char *xcharalloc (size_t n) ATTRIBUTE_MALLOC;
 288 static_inline char *
 289 xcharalloc (size_t n)
 290 {
 291   return XNMALLOC (n, char);
 292 }
 293
 294 /* Allocate S bytes of zeroed memory dynamically, with error checking.
 295    There's no need for xnzalloc (N, S), since it would be equivalent
 296    to xcalloc (N, S).  */
 297
 298 inline void *
 299 xzalloc (size_t s)
 300 {
 301   return memset (xmalloc (s), 0, s);
 302 }
 303
 304 # endif
 305
 306 # ifdef __cplusplus
 307 }
 308
 309 /* C++ does not allow conversions from void * to other pointer types
 310    without a cast.  Use templates to work around the problem when
 311    possible.  */
 312
 313 template <typename T> inline T *
 314 xrealloc (T *p, size_t s)
 315 {
 316   return (T *) xrealloc ((void *) p, s);
 317 }
 318
 319 template <typename T> inline T *
 320 xnrealloc (T *p, size_t n, size_t s)
 321 {
 322   return (T *) xnrealloc ((void *) p, n, s);
 323 }
 324
 325 template <typename T> inline T *
 326 x2realloc (T *p, size_t *pn)
 327 {
 328   return (T *) x2realloc ((void *) p, pn);
 329 }
 330
 331 template <typename T> inline T *
 332 x2nrealloc (T *p, size_t *pn, size_t s)
 333 {
 334   return (T *) x2nrealloc ((void *) p, pn, s);
 335 }
 336
 337 template <typename T> inline T *
 338 xmemdup (T const *p, size_t s)
 339 {
 340   return (T *) xmemdup ((void const *) p, s);
 341 }
 342
 343 # endif
 344
 345
 346 #endif /* !XALLOC_H_ */