pintos-os.org Git - pspp/blob - lib/xmalloc.c

   1 /* xmalloc.c -- malloc with out of memory checking
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2002, 2003, 2004, 2005, 2006 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 2, or (at your option)
  10    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, write to the Free Software Foundation,
  19    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #include <config.h>
  22
  23 #include "xalloc.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #ifndef SIZE_MAX
  29 # define SIZE_MAX ((size_t) -1)
  30 #endif
  31
  32 /* 1 if calloc is known to be compatible with GNU calloc.  This
  33    matters if we are not also using the calloc module, which defines
  34    HAVE_CALLOC and supports the GNU API even on non-GNU platforms.  */
  35 #if defined HAVE_CALLOC || defined __GLIBC__
  36 enum { HAVE_GNU_CALLOC = 1 };
  37 #else
  38 enum { HAVE_GNU_CALLOC = 0 };
  39 #endif
  40
  41 /* Allocate an array of N objects, each with S bytes of memory,
  42    dynamically, with error checking.  S must be nonzero.  */
  43
  44 static inline void *
  45 xnmalloc_inline (size_t n, size_t s)
  46 {
  47   void *p;
  48   if (xalloc_oversized (n, s) || (! (p = malloc (n * s)) && n != 0))
  49     xalloc_die ();
  50   return p;
  51 }
  52
  53 void *
  54 xnmalloc (size_t n, size_t s)
  55 {
  56   return xnmalloc_inline (n, s);
  57 }
  58
  59 /* Allocate N bytes of memory dynamically, with error checking.  */
  60
  61 void *
  62 xmalloc (size_t n)
  63 {
  64   return xnmalloc_inline (n, 1);
  65 }
  66
  67 /* Change the size of an allocated block of memory P to an array of N
  68    objects each of S bytes, with error checking.  S must be nonzero.  */
  69
  70 static inline void *
  71 xnrealloc_inline (void *p, size_t n, size_t s)
  72 {
  73   if (xalloc_oversized (n, s) || (! (p = realloc (p, n * s)) && n != 0))
  74     xalloc_die ();
  75   return p;
  76 }
  77
  78 void *
  79 xnrealloc (void *p, size_t n, size_t s)
  80 {
  81   return xnrealloc_inline (p, n, s);
  82 }
  83
  84 /* Change the size of an allocated block of memory P to N bytes,
  85    with error checking.  */
  86
  87 void *
  88 xrealloc (void *p, size_t n)
  89 {
  90   return xnrealloc_inline (p, n, 1);
  91 }
  92
  93
  94 /* If P is null, allocate a block of at least *PN such objects;
  95    otherwise, reallocate P so that it contains more than *PN objects
  96    each of S bytes.  *PN must be nonzero unless P is null, and S must
  97    be nonzero.  Set *PN to the new number of objects, and return the
  98    pointer to the new block.  *PN is never set to zero, and the
  99    returned pointer is never null.
 100
 101    Repeated reallocations are guaranteed to make progress, either by
 102    allocating an initial block with a nonzero size, or by allocating a
 103    larger block.
 104
 105    In the following implementation, nonzero sizes are doubled so that
 106    repeated reallocations have O(N log N) overall cost rather than
 107    O(N**2) cost, but the specification for this function does not
 108    guarantee that sizes are doubled.
 109
 110    Here is an example of use:
 111
 112      int *p = NULL;
 113      size_t used = 0;
 114      size_t allocated = 0;
 115
 116      void
 117      append_int (int value)
 118        {
 119          if (used == allocated)
 120            p = x2nrealloc (p, &allocated, sizeof *p);
 121          p[used++] = value;
 122        }
 123
 124    This causes x2nrealloc to allocate a block of some nonzero size the
 125    first time it is called.
 126
 127    To have finer-grained control over the initial size, set *PN to a
 128    nonzero value before calling this function with P == NULL.  For
 129    example:
 130
 131      int *p = NULL;
 132      size_t used = 0;
 133      size_t allocated = 0;
 134      size_t allocated1 = 1000;
 135
 136      void
 137      append_int (int value)
 138        {
 139          if (used == allocated)
 140            {
 141              p = x2nrealloc (p, &allocated1, sizeof *p);
 142              allocated = allocated1;
 143            }
 144          p[used++] = value;
 145        }
 146
 147    */
 148
 149 static inline void *
 150 x2nrealloc_inline (void *p, size_t *pn, size_t s)
 151 {
 152   size_t n = *pn;
 153
 154   if (! p)
 155     {
 156       if (! n)
 157         {
 158           /* The approximate size to use for initial small allocation
 159              requests, when the invoking code specifies an old size of
 160              zero.  64 bytes is the largest "small" request for the
 161              GNU C library malloc.  */
 162           enum { DEFAULT_MXFAST = 64 };
 163
 164           n = DEFAULT_MXFAST / s;
 165           n += !n;
 166         }
 167     }
 168   else
 169     {
 170       if (SIZE_MAX / 2 / s < n)
 171         xalloc_die ();
 172       n *= 2;
 173     }
 174
 175   *pn = n;
 176   return xrealloc (p, n * s);
 177 }
 178
 179 void *
 180 x2nrealloc (void *p, size_t *pn, size_t s)
 181 {
 182   return x2nrealloc_inline (p, pn, s);
 183 }
 184
 185 /* If P is null, allocate a block of at least *PN bytes; otherwise,
 186    reallocate P so that it contains more than *PN bytes.  *PN must be
 187    nonzero unless P is null.  Set *PN to the new block's size, and
 188    return the pointer to the new block.  *PN is never set to zero, and
 189    the returned pointer is never null.  */
 190
 191 void *
 192 x2realloc (void *p, size_t *pn)
 193 {
 194   return x2nrealloc_inline (p, pn, 1);
 195 }
 196
 197 /* Allocate S bytes of zeroed memory dynamically, with error checking.
 198    There's no need for xnzalloc (N, S), since it would be equivalent
 199    to xcalloc (N, S).  */
 200
 201 void *
 202 xzalloc (size_t s)
 203 {
 204   return memset (xmalloc (s), 0, s);
 205 }
 206
 207 /* Allocate zeroed memory for N elements of S bytes, with error
 208    checking.  S must be nonzero.  */
 209
 210 void *
 211 xcalloc (size_t n, size_t s)
 212 {
 213   void *p;
 214   /* Test for overflow, since some calloc implementations don't have
 215      proper overflow checks.  But omit overflow and size-zero tests if
 216      HAVE_GNU_CALLOC, since GNU calloc catches overflow and never
 217      returns NULL if successful.  */
 218   if ((! HAVE_GNU_CALLOC && xalloc_oversized (n, s))
 219       || (! (p = calloc (n, s)) && (HAVE_GNU_CALLOC || n != 0)))
 220     xalloc_die ();
 221   return p;
 222 }
 223
 224 /* Clone an object P of size S, with error checking.  There's no need
 225    for xnmemdup (P, N, S), since xmemdup (P, N * S) works without any
 226    need for an arithmetic overflow check.  */
 227
 228 void *
 229 xmemdup (void const *p, size_t s)
 230 {
 231   return memcpy (xmalloc (s), p, s);
 232 }
 233
 234 /* Clone STRING.  */
 235
 236 char *
 237 xstrdup (char const *string)
 238 {
 239   return xmemdup (string, strlen (string) + 1);
 240 }