gdb/obstack.c

   1 /* obstack.c - subroutines used implicitly by object stack macros
   2    Copyright (C) 1988 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify it
   5 under the terms of the GNU General Public License as published by the
   6 Free Software Foundation; either version 1, or (at your option) any
   7 later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 #include "obstack.h"
  19
  20 #ifdef __STDC__
  21 #define POINTER void *
  22 #else
  23 #define POINTER char *
  24 #endif
  25
  26 /* Determine default alignment.  */
  27 struct fooalign {char x; double d;};
  28 #define DEFAULT_ALIGNMENT ((char *)&((struct fooalign *) 0)->d - (char *)0)
  29 /* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT.
  30    But in fact it might be less smart and round addresses to as much as
  31    DEFAULT_ROUNDING.  So we prepare for it to do that.  */
  32 union fooround {long x; double d;};
  33 #define DEFAULT_ROUNDING (sizeof (union fooround))
  34
  35 /* When we copy a long block of data, this is the unit to do it with.
  36    On some machines, copying successive ints does not work;
  37    in such a case, redefine COPYING_UNIT to `long' (if that works)
  38    or `char' as a last resort.  */
  39 #ifndef COPYING_UNIT
  40 #define COPYING_UNIT int
  41 #endif
  42
  43 /* The non-GNU-C macros copy the obstack into this global variable
  44    to avoid multiple evaluation.  */
  45
  46 struct obstack *_obstack;
  47 \f
  48 /* Initialize an obstack H for use.  Specify chunk size SIZE (0 means default).
  49    Objects start on multiples of ALIGNMENT (0 means use default).
  50    CHUNKFUN is the function to use to allocate chunks,
  51    and FREEFUN the function to free them.  */
  52
  53 void
  54 _obstack_begin (h, size, alignment, chunkfun, freefun)
  55      struct obstack *h;
  56      int size;
  57      int alignment;
  58      POINTER (*chunkfun) ();
  59      void (*freefun) ();
  60 {
  61   register struct _obstack_chunk* chunk; /* points to new chunk */
  62
  63   if (alignment == 0)
  64     alignment = DEFAULT_ALIGNMENT;
  65   if (size == 0)
  66     /* Default size is what GNU malloc can fit in a 4096-byte block.  */
  67     {
  68       /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc.
  69          Use the values for range checking, because if range checking is off,
  70          the extra bytes won't be missed terribly, but if range checking is on
  71          and we used a larger request, a whole extra 4096 bytes would be
  72          allocated.
  73
  74          These number are irrelevant to the new GNU malloc.  I suspect it is
  75          less sensitive to the size of the request.  */
  76       int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1))
  77                     + 4 + DEFAULT_ROUNDING - 1)
  78                    & ~(DEFAULT_ROUNDING - 1));
  79       size = 4096 - extra;
  80     }
  81
  82   h->chunkfun = chunkfun;
  83   h->freefun = freefun;
  84   h->chunk_size = size;
  85   h->alignment_mask = alignment - 1;
  86
  87   chunk = h->chunk = (struct _obstack_chunk *)(*h->chunkfun) (h->chunk_size);
  88   h->next_free = h->object_base = chunk->contents;
  89   h->chunk_limit = chunk->limit
  90    = (char *) chunk + h->chunk_size;
  91   chunk->prev = 0;
  92 }
  93
  94 /* Allocate a new current chunk for the obstack *H
  95    on the assumption that LENGTH bytes need to be added
  96    to the current object, or a new object of length LENGTH allocated.
  97    Copies any partial object from the end of the old chunk
  98    to the beginning of the new one.
  99
 100    The function must be "int" so it can be used in non-ANSI C
 101    compilers in a : expression.  */
 102
 103 int
 104 _obstack_newchunk (h, length)
 105      struct obstack *h;
 106      int length;
 107 {
 108   register struct _obstack_chunk*       old_chunk = h->chunk;
 109   register struct _obstack_chunk*       new_chunk;
 110   register long new_size;
 111   register int obj_size = h->next_free - h->object_base;
 112   register int i;
 113   int already;
 114
 115   /* Compute size for new chunk.  */
 116   new_size = (obj_size + length) + (obj_size >> 3) + 100;
 117   if (new_size < h->chunk_size)
 118     new_size = h->chunk_size;
 119
 120   /* Allocate and initialize the new chunk.  */
 121   new_chunk = h->chunk = (struct _obstack_chunk *)(*h->chunkfun) (new_size);
 122   new_chunk->prev = old_chunk;
 123   new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;
 124
 125   /* Move the existing object to the new chunk.
 126      Word at a time is fast and is safe if the object
 127      is sufficiently aligned.  */
 128   if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT)
 129     {
 130       for (i = obj_size / sizeof (COPYING_UNIT) - 1;
 131            i >= 0; i--)
 132         ((COPYING_UNIT *)new_chunk->contents)[i]
 133           = ((COPYING_UNIT *)h->object_base)[i];
 134       /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT,
 135          but that can cross a page boundary on a machine
 136          which does not do strict alignment for COPYING_UNITS.  */
 137       already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT);
 138     }
 139   else
 140     already = 0;
 141   /* Copy remaining bytes one by one.  */
 142   for (i = already; i < obj_size; i++)
 143     new_chunk->contents[i] = h->object_base[i];
 144
 145   h->object_base = new_chunk->contents;
 146   h->next_free = h->object_base + obj_size;
 147 }
 148
 149 /* Return nonzero if object OBJ has been allocated from obstack H.
 150    This is here for debugging.
 151    If you use it in a program, you are probably losing.  */
 152
 153 int
 154 _obstack_allocated_p (h, obj)
 155      struct obstack *h;
 156      POINTER obj;
 157 {
 158   register struct _obstack_chunk*  lp;  /* below addr of any objects in this chunk */
 159   register struct _obstack_chunk*  plp; /* point to previous chunk if any */
 160
 161   lp = (h)->chunk;
 162   while (lp != 0 && ((POINTER)lp > obj || (POINTER)(lp)->limit < obj))
 163     {
 164       plp = lp -> prev;
 165       lp = plp;
 166     }
 167   return lp != 0;
 168 }
 169
 170 /* Free objects in obstack H, including OBJ and everything allocate
 171    more recently than OBJ.  If OBJ is zero, free everything in H.  */
 172
 173 #ifdef __STDC__
 174 #undef obstack_free
 175 void
 176 obstack_free (struct obstack *h, POINTER obj)
 177 #else
 178 int
 179 _obstack_free (h, obj)
 180      struct obstack *h;
 181      POINTER obj;
 182 #endif
 183 {
 184   register struct _obstack_chunk*  lp;  /* below addr of any objects in this chunk */
 185   register struct _obstack_chunk*  plp; /* point to previous chunk if any */
 186
 187   lp = (h)->chunk;
 188   /* We use >= because there cannot be an object at the beginning of a chunk.
 189      But there can be an empty object at that address
 190      at the end of another chunk.  */
 191   while (lp != 0 && ((POINTER)lp >= obj || (POINTER)(lp)->limit < obj))
 192     {
 193       plp = lp -> prev;
 194       (*h->freefun) ((POINTER) lp);
 195       lp = plp;
 196     }
 197   if (lp)
 198     {
 199       (h)->object_base = (h)->next_free = (char *)(obj);
 200       (h)->chunk_limit = lp->limit;
 201       (h)->chunk = lp;
 202     }
 203   else if (obj != 0)
 204     /* obj is not in any of the chunks! */
 205     abort ();
 206 }
 207
 208 /* Let same .o link with output of gcc and other compilers.  */
 209
 210 #ifdef __STDC__
 211 int
 212 _obstack_free (h, obj)
 213      struct obstack *h;
 214      POINTER obj;
 215 {
 216   obstack_free (h, obj);
 217 }
 218 #endif
 219 \f
 220 /* #if 0 */
 221 /* These are now turned off because the applications do not use it
 222    and it uses bcopy via obstack_grow, which causes trouble on sysV.  */
 223
 224 /* Now define the functional versions of the obstack macros.
 225    Define them to simply use the corresponding macros to do the job.  */
 226
 227 #ifdef __STDC__
 228 /* These function definitions do not work with non-ANSI preprocessors;
 229    they won't pass through the macro names in parentheses.  */
 230
 231 /* The function names appear in parentheses in order to prevent
 232    the macro-definitions of the names from being expanded there.  */
 233
 234 POINTER (obstack_base) (obstack)
 235      struct obstack *obstack;
 236 {
 237   return obstack_base (obstack);
 238 }
 239
 240 POINTER (obstack_next_free) (obstack)
 241      struct obstack *obstack;
 242 {
 243   return obstack_next_free (obstack);
 244 }
 245
 246 int (obstack_object_size) (obstack)
 247      struct obstack *obstack;
 248 {
 249   return obstack_object_size (obstack);
 250 }
 251
 252 int (obstack_room) (obstack)
 253      struct obstack *obstack;
 254 {
 255   return obstack_room (obstack);
 256 }
 257
 258 void (obstack_grow) (obstack, pointer, length)
 259      struct obstack *obstack;
 260      POINTER pointer;
 261      int length;
 262 {
 263   obstack_grow (obstack, pointer, length);
 264 }
 265
 266 void (obstack_grow0) (obstack, pointer, length)
 267      struct obstack *obstack;
 268      POINTER pointer;
 269      int length;
 270 {
 271   obstack_grow0 (obstack, pointer, length);
 272 }
 273
 274 void (obstack_1grow) (obstack, character)
 275      struct obstack *obstack;
 276      int character;
 277 {
 278   obstack_1grow (obstack, character);
 279 }
 280
 281 void (obstack_blank) (obstack, length)
 282      struct obstack *obstack;
 283      int length;
 284 {
 285   obstack_blank (obstack, length);
 286 }
 287
 288 void (obstack_1grow_fast) (obstack, character)
 289      struct obstack *obstack;
 290      int character;
 291 {
 292   obstack_1grow_fast (obstack, character);
 293 }
 294
 295 void (obstack_blank_fast) (obstack, length)
 296      struct obstack *obstack;
 297      int length;
 298 {
 299   obstack_blank_fast (obstack, length);
 300 }
 301
 302 POINTER (obstack_finish) (obstack)
 303      struct obstack *obstack;
 304 {
 305   return obstack_finish (obstack);
 306 }
 307
 308 POINTER (obstack_alloc) (obstack, length)
 309      struct obstack *obstack;
 310      int length;
 311 {
 312   return obstack_alloc (obstack, length);
 313 }
 314
 315 POINTER (obstack_copy) (obstack, pointer, length)
 316      struct obstack *obstack;
 317      POINTER pointer;
 318      int length;
 319 {
 320   return obstack_copy (obstack, pointer, length);
 321 }
 322
 323 POINTER (obstack_copy0) (obstack, pointer, length)
 324      struct obstack *obstack;
 325      POINTER pointer;
 326      int length;
 327 {
 328   return obstack_copy0 (obstack, pointer, length);
 329 }
 330
 331 #endif /* __STDC__ */
 332
 333 /* #endif 0 */