libiberty/alloca.c

   1 /* alloca.c -- allocate automatically reclaimed memory
   2    (Mostly) portable public-domain implementation -- D A Gwyn
   3
   4    This implementation of the PWB library alloca function,
   5    which is used to allocate space off the run-time stack so
   6    that it is automatically reclaimed upon procedure exit,
   7    was inspired by discussions with J. Q. Johnson of Cornell.
   8    J.Otto Tennant <[email protected]> contributed the Cray support.
   9
  10    There are some preprocessor constants that can
  11    be defined when compiling for your specific system, for
  12    improved efficiency; however, the defaults should be okay.
  13
  14    The general concept of this implementation is to keep
  15    track of all alloca-allocated blocks, and reclaim any
  16    that are found to be deeper in the stack than the current
  17    invocation.  This heuristic does not reclaim storage as
  18    soon as it becomes invalid, but it will do so eventually.
  19
  20    As a special case, alloca(0) reclaims storage without
  21    allocating any.  It is a good idea to use alloca(0) in
  22    your main control loop, etc. to force garbage collection.  */
  23
  24 /*
  25
  26 @deftypefn Replacement void* alloca (size_t)
  27
  28 This function allocates memory which will be automatically reclaimed
  29 after the procedure exits.  The @libib{} implementation does not free
  30 the memory immediately but will do so eventually during subsequent
  31 calls to this function.  Memory is allocated using @code{xmalloc} under
  32 normal circumstances.
  33
  34 The header file @file{alloca-conf.h} can be used in conjunction with the
  35 GNU Autoconf test @code{AC_FUNC_ALLOCA} to test for and properly make
  36 available this function.  The @code{AC_FUNC_ALLOCA} test requires that
  37 client code use a block of preprocessor code to be safe (see the Autoconf
  38 manual for more); this header incorporates that logic and more, including
  39 the possibility of a GCC builtin function.
  40
  41 @end deftypefn
  42
  43 */
  44
  45 #ifdef HAVE_CONFIG_H
  46 #include <config.h>
  47 #endif
  48
  49 #include <libiberty.h>
  50
  51 #ifdef HAVE_STRING_H
  52 #include <string.h>
  53 #endif
  54 #ifdef HAVE_STDLIB_H
  55 #include <stdlib.h>
  56 #endif
  57
  58 /* These variables are used by the ASTRDUP implementation that relies
  59    on C_alloca.  */
  60 const char *libiberty_optr;
  61 char *libiberty_nptr;
  62 unsigned long libiberty_len;
  63
  64 /* If your stack is a linked list of frames, you have to
  65    provide an "address metric" ADDRESS_FUNCTION macro.  */
  66
  67 #if defined (CRAY) && defined (CRAY_STACKSEG_END)
  68 static long i00afunc ();
  69 #define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg))
  70 #else
  71 #define ADDRESS_FUNCTION(arg) &(arg)
  72 #endif
  73
  74 #ifndef NULL
  75 #define NULL    0
  76 #endif
  77
  78 /* Define STACK_DIRECTION if you know the direction of stack
  79    growth for your system; otherwise it will be automatically
  80    deduced at run-time.
  81
  82    STACK_DIRECTION > 0 => grows toward higher addresses
  83    STACK_DIRECTION < 0 => grows toward lower addresses
  84    STACK_DIRECTION = 0 => direction of growth unknown  */
  85
  86 #ifndef STACK_DIRECTION
  87 #define STACK_DIRECTION 0       /* Direction unknown.  */
  88 #endif
  89
  90 #if STACK_DIRECTION != 0
  91
  92 #define STACK_DIR       STACK_DIRECTION /* Known at compile-time.  */
  93
  94 #else /* STACK_DIRECTION == 0; need run-time code.  */
  95
  96 static int stack_dir;           /* 1 or -1 once known.  */
  97 #define STACK_DIR       stack_dir
  98
  99 static void
 100 find_stack_direction ()
 101 {
 102   static char *addr = NULL;     /* Address of first `dummy', once known.  */
 103   auto char dummy;              /* To get stack address.  */
 104
 105   if (addr == NULL)
 106     {                           /* Initial entry.  */
 107       addr = ADDRESS_FUNCTION (dummy);
 108
 109       find_stack_direction ();  /* Recurse once.  */
 110     }
 111   else
 112     {
 113       /* Second entry.  */
 114       if (ADDRESS_FUNCTION (dummy) > addr)
 115         stack_dir = 1;          /* Stack grew upward.  */
 116       else
 117         stack_dir = -1;         /* Stack grew downward.  */
 118     }
 119 }
 120
 121 #endif /* STACK_DIRECTION == 0 */
 122
 123 /* An "alloca header" is used to:
 124    (a) chain together all alloca'ed blocks;
 125    (b) keep track of stack depth.
 126
 127    It is very important that sizeof(header) agree with malloc
 128    alignment chunk size.  The following default should work okay.  */
 129
 130 #ifndef ALIGN_SIZE
 131 #define ALIGN_SIZE      sizeof(double)
 132 #endif
 133
 134 typedef union hdr
 135 {
 136   char align[ALIGN_SIZE];       /* To force sizeof(header).  */
 137   struct
 138     {
 139       union hdr *next;          /* For chaining headers.  */
 140       char *deep;               /* For stack depth measure.  */
 141     } h;
 142 } header;
 143
 144 static header *last_alloca_header = NULL;       /* -> last alloca header.  */
 145
 146 /* Return a pointer to at least SIZE bytes of storage,
 147    which will be automatically reclaimed upon exit from
 148    the procedure that called alloca.  Originally, this space
 149    was supposed to be taken from the current stack frame of the
 150    caller, but that method cannot be made to work for some
 151    implementations of C, for example under Gould's UTX/32.  */
 152
 153 PTR
 154 C_alloca (size)
 155      size_t size;
 156 {
 157   auto char probe;              /* Probes stack depth: */
 158   register char *depth = ADDRESS_FUNCTION (probe);
 159
 160 #if STACK_DIRECTION == 0
 161   if (STACK_DIR == 0)           /* Unknown growth direction.  */
 162     find_stack_direction ();
 163 #endif
 164
 165   /* Reclaim garbage, defined as all alloca'd storage that
 166      was allocated from deeper in the stack than currently.  */
 167
 168   {
 169     register header *hp;        /* Traverses linked list.  */
 170
 171     for (hp = last_alloca_header; hp != NULL;)
 172       if ((STACK_DIR > 0 && hp->h.deep > depth)
 173           || (STACK_DIR < 0 && hp->h.deep < depth))
 174         {
 175           register header *np = hp->h.next;
 176
 177           free ((PTR) hp);      /* Collect garbage.  */
 178
 179           hp = np;              /* -> next header.  */
 180         }
 181       else
 182         break;                  /* Rest are not deeper.  */
 183
 184     last_alloca_header = hp;    /* -> last valid storage.  */
 185   }
 186
 187   if (size == 0)
 188     return NULL;                /* No allocation required.  */
 189
 190   /* Allocate combined header + user data storage.  */
 191
 192   {
 193     register PTR new = xmalloc (sizeof (header) + size);
 194     /* Address of header.  */
 195
 196     if (new == 0)
 197       abort();
 198
 199     ((header *) new)->h.next = last_alloca_header;
 200     ((header *) new)->h.deep = depth;
 201
 202     last_alloca_header = (header *) new;
 203
 204     /* User storage begins just after header.  */
 205
 206     return (PTR) ((char *) new + sizeof (header));
 207   }
 208 }
 209
 210 #if defined (CRAY) && defined (CRAY_STACKSEG_END)
 211
 212 #ifdef DEBUG_I00AFUNC
 213 #include <stdio.h>
 214 #endif
 215
 216 #ifndef CRAY_STACK
 217 #define CRAY_STACK
 218 #ifndef CRAY2
 219 /* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */
 220 struct stack_control_header
 221   {
 222     long shgrow:32;             /* Number of times stack has grown.  */
 223     long shaseg:32;             /* Size of increments to stack.  */
 224     long shhwm:32;              /* High water mark of stack.  */
 225     long shsize:32;             /* Current size of stack (all segments).  */
 226   };
 227
 228 /* The stack segment linkage control information occurs at
 229    the high-address end of a stack segment.  (The stack
 230    grows from low addresses to high addresses.)  The initial
 231    part of the stack segment linkage control information is
 232    0200 (octal) words.  This provides for register storage
 233    for the routine which overflows the stack.  */
 234
 235 struct stack_segment_linkage
 236   {
 237     long ss[0200];              /* 0200 overflow words.  */
 238     long sssize:32;             /* Number of words in this segment.  */
 239     long ssbase:32;             /* Offset to stack base.  */
 240     long:32;
 241     long sspseg:32;             /* Offset to linkage control of previous
 242                                    segment of stack.  */
 243     long:32;
 244     long sstcpt:32;             /* Pointer to task common address block.  */
 245     long sscsnm;                /* Private control structure number for
 246                                    microtasking.  */
 247     long ssusr1;                /* Reserved for user.  */
 248     long ssusr2;                /* Reserved for user.  */
 249     long sstpid;                /* Process ID for pid based multi-tasking.  */
 250     long ssgvup;                /* Pointer to multitasking thread giveup.  */
 251     long sscray[7];             /* Reserved for Cray Research.  */
 252     long ssa0;
 253     long ssa1;
 254     long ssa2;
 255     long ssa3;
 256     long ssa4;
 257     long ssa5;
 258     long ssa6;
 259     long ssa7;
 260     long sss0;
 261     long sss1;
 262     long sss2;
 263     long sss3;
 264     long sss4;
 265     long sss5;
 266     long sss6;
 267     long sss7;
 268   };
 269
 270 #else /* CRAY2 */
 271 /* The following structure defines the vector of words
 272    returned by the STKSTAT library routine.  */
 273 struct stk_stat
 274   {
 275     long now;                   /* Current total stack size.  */
 276     long maxc;                  /* Amount of contiguous space which would
 277                                    be required to satisfy the maximum
 278                                    stack demand to date.  */
 279     long high_water;            /* Stack high-water mark.  */
 280     long overflows;             /* Number of stack overflow ($STKOFEN) calls.  */
 281     long hits;                  /* Number of internal buffer hits.  */
 282     long extends;               /* Number of block extensions.  */
 283     long stko_mallocs;          /* Block allocations by $STKOFEN.  */
 284     long underflows;            /* Number of stack underflow calls ($STKRETN).  */
 285     long stko_free;             /* Number of deallocations by $STKRETN.  */
 286     long stkm_free;             /* Number of deallocations by $STKMRET.  */
 287     long segments;              /* Current number of stack segments.  */
 288     long maxs;                  /* Maximum number of stack segments so far.  */
 289     long pad_size;              /* Stack pad size.  */
 290     long current_address;       /* Current stack segment address.  */
 291     long current_size;          /* Current stack segment size.  This
 292                                    number is actually corrupted by STKSTAT to
 293                                    include the fifteen word trailer area.  */
 294     long initial_address;       /* Address of initial segment.  */
 295     long initial_size;          /* Size of initial segment.  */
 296   };
 297
 298 /* The following structure describes the data structure which trails
 299    any stack segment.  I think that the description in 'asdef' is
 300    out of date.  I only describe the parts that I am sure about.  */
 301
 302 struct stk_trailer
 303   {
 304     long this_address;          /* Address of this block.  */
 305     long this_size;             /* Size of this block (does not include
 306                                    this trailer).  */
 307     long unknown2;
 308     long unknown3;
 309     long link;                  /* Address of trailer block of previous
 310                                    segment.  */
 311     long unknown5;
 312     long unknown6;
 313     long unknown7;
 314     long unknown8;
 315     long unknown9;
 316     long unknown10;
 317     long unknown11;
 318     long unknown12;
 319     long unknown13;
 320     long unknown14;
 321   };
 322
 323 #endif /* CRAY2 */
 324 #endif /* not CRAY_STACK */
 325
 326 #ifdef CRAY2
 327 /* Determine a "stack measure" for an arbitrary ADDRESS.
 328    I doubt that "lint" will like this much.  */
 329
 330 static long
 331 i00afunc (long *address)
 332 {
 333   struct stk_stat status;
 334   struct stk_trailer *trailer;
 335   long *block, size;
 336   long result = 0;
 337
 338   /* We want to iterate through all of the segments.  The first
 339      step is to get the stack status structure.  We could do this
 340      more quickly and more directly, perhaps, by referencing the
 341      $LM00 common block, but I know that this works.  */
 342
 343   STKSTAT (&status);
 344
 345   /* Set up the iteration.  */
 346
 347   trailer = (struct stk_trailer *) (status.current_address
 348                                     + status.current_size
 349                                     - 15);
 350
 351   /* There must be at least one stack segment.  Therefore it is
 352      a fatal error if "trailer" is null.  */
 353
 354   if (trailer == 0)
 355     abort ();
 356
 357   /* Discard segments that do not contain our argument address.  */
 358
 359   while (trailer != 0)
 360     {
 361       block = (long *) trailer->this_address;
 362       size = trailer->this_size;
 363       if (block == 0 || size == 0)
 364         abort ();
 365       trailer = (struct stk_trailer *) trailer->link;
 366       if ((block <= address) && (address < (block + size)))
 367         break;
 368     }
 369
 370   /* Set the result to the offset in this segment and add the sizes
 371      of all predecessor segments.  */
 372
 373   result = address - block;
 374
 375   if (trailer == 0)
 376     {
 377       return result;
 378     }
 379
 380   do
 381     {
 382       if (trailer->this_size <= 0)
 383         abort ();
 384       result += trailer->this_size;
 385       trailer = (struct stk_trailer *) trailer->link;
 386     }
 387   while (trailer != 0);
 388
 389   /* We are done.  Note that if you present a bogus address (one
 390      not in any segment), you will get a different number back, formed
 391      from subtracting the address of the first block.  This is probably
 392      not what you want.  */
 393
 394   return (result);
 395 }
 396
 397 #else /* not CRAY2 */
 398 /* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP.
 399    Determine the number of the cell within the stack,
 400    given the address of the cell.  The purpose of this
 401    routine is to linearize, in some sense, stack addresses
 402    for alloca.  */
 403
 404 static long
 405 i00afunc (long address)
 406 {
 407   long stkl = 0;
 408
 409   long size, pseg, this_segment, stack;
 410   long result = 0;
 411
 412   struct stack_segment_linkage *ssptr;
 413
 414   /* Register B67 contains the address of the end of the
 415      current stack segment.  If you (as a subprogram) store
 416      your registers on the stack and find that you are past
 417      the contents of B67, you have overflowed the segment.
 418
 419      B67 also points to the stack segment linkage control
 420      area, which is what we are really interested in.  */
 421
 422   stkl = CRAY_STACKSEG_END ();
 423   ssptr = (struct stack_segment_linkage *) stkl;
 424
 425   /* If one subtracts 'size' from the end of the segment,
 426      one has the address of the first word of the segment.
 427
 428      If this is not the first segment, 'pseg' will be
 429      nonzero.  */
 430
 431   pseg = ssptr->sspseg;
 432   size = ssptr->sssize;
 433
 434   this_segment = stkl - size;
 435
 436   /* It is possible that calling this routine itself caused
 437      a stack overflow.  Discard stack segments which do not
 438      contain the target address.  */
 439
 440   while (!(this_segment <= address && address <= stkl))
 441     {
 442 #ifdef DEBUG_I00AFUNC
 443       fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl);
 444 #endif
 445       if (pseg == 0)
 446         break;
 447       stkl = stkl - pseg;
 448       ssptr = (struct stack_segment_linkage *) stkl;
 449       size = ssptr->sssize;
 450       pseg = ssptr->sspseg;
 451       this_segment = stkl - size;
 452     }
 453
 454   result = address - this_segment;
 455
 456   /* If you subtract pseg from the current end of the stack,
 457      you get the address of the previous stack segment's end.
 458      This seems a little convoluted to me, but I'll bet you save
 459      a cycle somewhere.  */
 460
 461   while (pseg != 0)
 462     {
 463 #ifdef DEBUG_I00AFUNC
 464       fprintf (stderr, "%011o %011o\n", pseg, size);
 465 #endif
 466       stkl = stkl - pseg;
 467       ssptr = (struct stack_segment_linkage *) stkl;
 468       size = ssptr->sssize;
 469       pseg = ssptr->sspseg;
 470       result += size;
 471     }
 472   return (result);
 473 }
 474
 475 #endif /* not CRAY2 */
 476 #endif /* CRAY */