gl/xalloc.h

   1 /* xalloc.h -- malloc with out-of-memory checking
   2
   3    Copyright (C) 1990-2000, 2003-2004, 2006-2013 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 _GL_INLINE_HEADER_BEGIN
  26 #ifndef XALLOC_INLINE
  27 # define XALLOC_INLINE _GL_INLINE
  28 #endif
  29
  30 #ifdef __cplusplus
  31 extern "C" {
  32 #endif
  33
  34
  35 #if __GNUC__ >= 3
  36 # define _GL_ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
  37 #else
  38 # define _GL_ATTRIBUTE_MALLOC
  39 #endif
  40
  41 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
  42 # define _GL_ATTRIBUTE_ALLOC_SIZE(args) __attribute__ ((__alloc_size__ args))
  43 #else
  44 # define _GL_ATTRIBUTE_ALLOC_SIZE(args)
  45 #endif
  46
  47 /* This function is always triggered when memory is exhausted.
  48    It must be defined by the application, either explicitly
  49    or by using gnulib's xalloc-die module.  This is the
  50    function to call when one wants the program to die because of a
  51    memory allocation failure.  */
  52 extern _Noreturn void xalloc_die (void);
  53
  54 void *xmalloc (size_t s)
  55       _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
  56 void *xzalloc (size_t s)
  57       _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
  58 void *xcalloc (size_t n, size_t s)
  59       _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1, 2));
  60 void *xrealloc (void *p, size_t s)
  61       _GL_ATTRIBUTE_ALLOC_SIZE ((2));
  62 void *x2realloc (void *p, size_t *pn);
  63 void *xmemdup (void const *p, size_t s)
  64       _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((2));
  65 char *xstrdup (char const *str)
  66       _GL_ATTRIBUTE_MALLOC;
  67
  68 /* In the following macros, T must be an elementary or structure/union or
  69    typedef'ed type, or a pointer to such a type.  To apply one of the
  70    following macros to a function pointer or array type, you need to typedef
  71    it first and use the typedef name.  */
  72
  73 /* Allocate an object of type T dynamically, with error checking.  */
  74 /* extern t *XMALLOC (typename t); */
  75 #define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
  76
  77 /* Allocate memory for N elements of type T, with error checking.  */
  78 /* extern t *XNMALLOC (size_t n, typename t); */
  79 #define XNMALLOC(n, t) \
  80    ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
  81
  82 /* Allocate an object of type T dynamically, with error checking,
  83    and zero it.  */
  84 /* extern t *XZALLOC (typename t); */
  85 #define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
  86
  87 /* Allocate memory for N elements of type T, with error checking,
  88    and zero it.  */
  89 /* extern t *XCALLOC (size_t n, typename t); */
  90 #define XCALLOC(n, t) \
  91    ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
  92
  93
  94 /* Allocate an array of N objects, each with S bytes of memory,
  95    dynamically, with error checking.  S must be nonzero.  */
  96
  97 XALLOC_INLINE void *xnmalloc (size_t n, size_t s)
  98                     _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1, 2));
  99 XALLOC_INLINE void *
 100 xnmalloc (size_t n, size_t s)
 101 {
 102   if (xalloc_oversized (n, s))
 103     xalloc_die ();
 104   return xmalloc (n * s);
 105 }
 106
 107 /* Change the size of an allocated block of memory P to an array of N
 108    objects each of S bytes, with error checking.  S must be nonzero.  */
 109
 110 XALLOC_INLINE void *xnrealloc (void *p, size_t n, size_t s)
 111                     _GL_ATTRIBUTE_ALLOC_SIZE ((2, 3));
 112 XALLOC_INLINE void *
 113 xnrealloc (void *p, size_t n, size_t s)
 114 {
 115   if (xalloc_oversized (n, s))
 116     xalloc_die ();
 117   return xrealloc (p, n * s);
 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 increased by a
 132    factor of approximately 1.5 so that repeated reallocations have
 133    O(N) overall cost rather than O(N**2) cost, but the
 134    specification for this function does not guarantee that rate.
 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 XALLOC_INLINE void *
 176 x2nrealloc (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.  This is the largest "small" request for the GNU C
 187              library malloc.  */
 188           enum { DEFAULT_MXFAST = 64 * sizeof (size_t) / 4 };
 189
 190           n = DEFAULT_MXFAST / s;
 191           n += !n;
 192         }
 193     }
 194   else
 195     {
 196       /* Set N = ceil (1.5 * N) so that progress is made if N == 1.
 197          Check for overflow, so that N * S stays in size_t range.
 198          The check is slightly conservative, but an exact check isn't
 199          worth the trouble.  */
 200       if ((size_t) -1 / 3 * 2 / s <= n)
 201         xalloc_die ();
 202       n += (n + 1) / 2;
 203     }
 204
 205   *pn = n;
 206   return xrealloc (p, n * s);
 207 }
 208
 209 /* Return a pointer to a new buffer of N bytes.  This is like xmalloc,
 210    except it returns char *.  */
 211
 212 XALLOC_INLINE char *xcharalloc (size_t n)
 213                     _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_ALLOC_SIZE ((1));
 214 XALLOC_INLINE char *
 215 xcharalloc (size_t n)
 216 {
 217   return XNMALLOC (n, char);
 218 }
 219
 220 #ifdef __cplusplus
 221 }
 222
 223 /* C++ does not allow conversions from void * to other pointer types
 224    without a cast.  Use templates to work around the problem when
 225    possible.  */
 226
 227 template <typename T> inline T *
 228 xrealloc (T *p, size_t s)
 229 {
 230   return (T *) xrealloc ((void *) p, s);
 231 }
 232
 233 template <typename T> inline T *
 234 xnrealloc (T *p, size_t n, size_t s)
 235 {
 236   return (T *) xnrealloc ((void *) p, n, s);
 237 }
 238
 239 template <typename T> inline T *
 240 x2realloc (T *p, size_t *pn)
 241 {
 242   return (T *) x2realloc ((void *) p, pn);
 243 }
 244
 245 template <typename T> inline T *
 246 x2nrealloc (T *p, size_t *pn, size_t s)
 247 {
 248   return (T *) x2nrealloc ((void *) p, pn, s);
 249 }
 250
 251 template <typename T> inline T *
 252 xmemdup (T const *p, size_t s)
 253 {
 254   return (T *) xmemdup ((void const *) p, s);
 255 }
 256
 257 #endif
 258
 259
 260 #endif /* !XALLOC_H_ */