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 #endif
 173
 174 /* Change the size of an allocated block of memory P to an array of N
 175    objects each of S bytes, with error checking.  S must be nonzero.  */
 176
 177 static_inline void *
 178 xnrealloc (void *p, size_t n, size_t s)
 179 {
 180   if (xalloc_oversized (n, s))
 181     xalloc_die ();
 182   return xrealloc (p, n * s);
 183 }
 184
 185 /* If P is null, allocate a block of at least *PN such objects;
 186    otherwise, reallocate P so that it contains more than *PN objects
 187    each of S bytes.  *PN must be nonzero unless P is null, and S must
 188    be nonzero.  Set *PN to the new number of objects, and return the
 189    pointer to the new block.  *PN is never set to zero, and the
 190    returned pointer is never null.
 191
 192    Repeated reallocations are guaranteed to make progress, either by
 193    allocating an initial block with a nonzero size, or by allocating a
 194    larger block.
 195
 196    In the following implementation, nonzero sizes are increased by a
 197    factor of approximately 1.5 so that repeated reallocations have
 198    O(N) overall cost rather than O(N**2) cost, but the
 199    specification for this function does not guarantee that rate.
 200
 201    Here is an example of use:
 202
 203      int *p = NULL;
 204      size_t used = 0;
 205      size_t allocated = 0;
 206
 207      void
 208      append_int (int value)
 209        {
 210          if (used == allocated)
 211            p = x2nrealloc (p, &allocated, sizeof *p);
 212          p[used++] = value;
 213        }
 214
 215    This causes x2nrealloc to allocate a block of some nonzero size the
 216    first time it is called.
 217
 218    To have finer-grained control over the initial size, set *PN to a
 219    nonzero value before calling this function with P == NULL.  For
 220    example:
 221
 222      int *p = NULL;
 223      size_t used = 0;
 224      size_t allocated = 0;
 225      size_t allocated1 = 1000;
 226
 227      void
 228      append_int (int value)
 229        {
 230          if (used == allocated)
 231            {
 232              p = x2nrealloc (p, &allocated1, sizeof *p);
 233              allocated = allocated1;
 234            }
 235          p[used++] = value;
 236        }
 237
 238    */
 239
 240 static_inline void *
 241 x2nrealloc (void *p, size_t *pn, size_t s)
 242 {
 243   size_t n = *pn;
 244
 245   if (! p)
 246     {
 247       if (! n)
 248         {
 249           /* The approximate size to use for initial small allocation
 250              requests, when the invoking code specifies an old size of
 251              zero.  64 bytes is the largest "small" request for the
 252              GNU C library malloc.  */
 253           enum { DEFAULT_MXFAST = 64 };
 254
 255           n = DEFAULT_MXFAST / s;
 256           n += !n;
 257         }
 258     }
 259   else
 260     {
 261       /* Set N = ceil (1.5 * N) so that progress is made if N == 1.
 262          Check for overflow, so that N * S stays in size_t range.
 263          The check is slightly conservative, but an exact check isn't
 264          worth the trouble.  */
 265       if ((size_t) -1 / 3 * 2 / s <= n)
 266         xalloc_die ();
 267       n += (n + 1) / 2;
 268     }
 269
 270   *pn = n;
 271   return xrealloc (p, n * s);
 272 }
 273
 274 /* Return a pointer to a new buffer of N bytes.  This is like xmalloc,
 275    except it returns char *.  */
 276
 277 static_inline char *xcharalloc (size_t n) ATTRIBUTE_MALLOC;
 278 static_inline char *
 279 xcharalloc (size_t n)
 280 {
 281   return XNMALLOC (n, char);
 282 }
 283
 284 /* Allocate S bytes of zeroed memory dynamically, with error checking.
 285    There's no need for xnzalloc (N, S), since it would be equivalent
 286    to xcalloc (N, S).  */
 287
 288 inline void *
 289 xzalloc (size_t s)
 290 {
 291   return memset (xmalloc (s), 0, s);
 292 }
 293
 294 # endif
 295
 296 # ifdef __cplusplus
 297 }
 298
 299 /* C++ does not allow conversions from void * to other pointer types
 300    without a cast.  Use templates to work around the problem when
 301    possible.  */
 302
 303 template <typename T> inline T *
 304 xrealloc (T *p, size_t s)
 305 {
 306   return (T *) xrealloc ((void *) p, s);
 307 }
 308
 309 template <typename T> inline T *
 310 xnrealloc (T *p, size_t n, size_t s)
 311 {
 312   return (T *) xnrealloc ((void *) p, n, s);
 313 }
 314
 315 template <typename T> inline T *
 316 x2realloc (T *p, size_t *pn)
 317 {
 318   return (T *) x2realloc ((void *) p, pn);
 319 }
 320
 321 template <typename T> inline T *
 322 x2nrealloc (T *p, size_t *pn, size_t s)
 323 {
 324   return (T *) x2nrealloc ((void *) p, pn, s);
 325 }
 326
 327 template <typename T> inline T *
 328 xmemdup (T const *p, size_t s)
 329 {
 330   return (T *) xmemdup ((void const *) p, s);
 331 }
 332
 333 # endif
 334
 335
 336 #endif /* !XALLOC_H_ */