lib/malloc/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 <jot@cray.com> 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 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 /* If compiling with GCC 2, this file's not needed.  */
  29 #if !defined (__GNUC__) || __GNUC__ < 2
  30
  31 /* If alloca is defined somewhere, this file is not needed. */
  32 #ifndef alloca
  33
  34 #ifdef emacs
  35 #ifdef static
  36 /* actually, only want this if static is defined as ""
  37    -- this is for usg, in which emacs must undefine static
  38    in order to make unexec workable
  39    */
  40 #ifndef STACK_DIRECTION
  41 you
  42 lose
  43 -- must know STACK_DIRECTION at compile-time
  44 #endif /* STACK_DIRECTION undefined */
  45 #endif /* static */
  46 #endif /* emacs */
  47
  48 /* If your stack is a linked list of frames, you have to
  49    provide an "address metric" ADDRESS_FUNCTION macro.  */
  50
  51 #if defined (CRAY) && defined (CRAY_STACKSEG_END)
  52 long i00afunc ();
  53 #define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg))
  54 #else
  55 #define ADDRESS_FUNCTION(arg) &(arg)
  56 #endif /* CRAY && CRAY_STACKSEG_END */
  57
  58 #if __STDC__
  59 typedef void *pointer;
  60 #else
  61 typedef char *pointer;
  62 #endif
  63
  64 #define NULL    0
  65
  66 /* Different portions of Emacs need to call different versions of
  67    malloc.  The Emacs executable needs alloca to call xmalloc, because
  68    ordinary malloc isn't protected from input signals.  On the other
  69    hand, the utilities in lib-src need alloca to call malloc; some of
  70    them are very simple, and don't have an xmalloc routine.
  71
  72    Non-Emacs programs expect this to call use xmalloc.
  73
  74    Callers below should use malloc.  */
  75
  76 #ifndef emacs
  77 #define malloc xmalloc
  78 extern pointer xmalloc ();
  79 #endif
  80
  81 /* Define STACK_DIRECTION if you know the direction of stack
  82    growth for your system; otherwise it will be automatically
  83    deduced at run-time.
  84
  85    STACK_DIRECTION > 0 => grows toward higher addresses
  86    STACK_DIRECTION < 0 => grows toward lower addresses
  87    STACK_DIRECTION = 0 => direction of growth unknown  */
  88
  89 #ifndef STACK_DIRECTION
  90 #define STACK_DIRECTION 0       /* Direction unknown.  */
  91 #endif
  92
  93 #if STACK_DIRECTION != 0
  94
  95 #define STACK_DIR       STACK_DIRECTION /* Known at compile-time.  */
  96
  97 #else /* STACK_DIRECTION == 0; need run-time code.  */
  98
  99 static int stack_dir;           /* 1 or -1 once known.  */
 100 #define STACK_DIR       stack_dir
 101
 102 static void
 103 find_stack_direction ()
 104 {
 105   static char *addr = NULL;     /* Address of first `dummy', once known.  */
 106   auto char dummy;              /* To get stack address.  */
 107
 108   if (addr == NULL)
 109     {                           /* Initial entry.  */
 110       addr = ADDRESS_FUNCTION (dummy);
 111
 112       find_stack_direction ();  /* Recurse once.  */
 113     }
 114   else
 115     {
 116       /* Second entry.  */
 117       if (ADDRESS_FUNCTION (dummy) > addr)
 118         stack_dir = 1;          /* Stack grew upward.  */
 119       else
 120         stack_dir = -1;         /* Stack grew downward.  */
 121     }
 122 }
 123
 124 #endif /* STACK_DIRECTION == 0 */
 125
 126 /* An "alloca header" is used to:
 127    (a) chain together all alloca'ed blocks;
 128    (b) keep track of stack depth.
 129
 130    It is very important that sizeof(header) agree with malloc
 131    alignment chunk size.  The following default should work okay.  */
 132
 133 #ifndef ALIGN_SIZE
 134 #define ALIGN_SIZE      sizeof(double)
 135 #endif
 136
 137 typedef union hdr
 138 {
 139   char align[ALIGN_SIZE];       /* To force sizeof(header).  */
 140   struct
 141     {
 142       union hdr *next;          /* For chaining headers.  */
 143       char *deep;               /* For stack depth measure.  */
 144     } h;
 145 } header;
 146
 147 static header *last_alloca_header = NULL;       /* -> last alloca header.  */
 148
 149 /* Return a pointer to at least SIZE bytes of storage,
 150    which will be automatically reclaimed upon exit from
 151    the procedure that called alloca.  Originally, this space
 152    was supposed to be taken from the current stack frame of the
 153    caller, but that method cannot be made to work for some
 154    implementations of C, for example under Gould's UTX/32.  */
 155
 156 pointer
 157 alloca (size)
 158      unsigned size;
 159 {
 160   auto char probe;              /* Probes stack depth: */
 161   register char *depth = ADDRESS_FUNCTION (probe);
 162
 163 #if STACK_DIRECTION == 0
 164   if (STACK_DIR == 0)           /* Unknown growth direction.  */
 165     find_stack_direction ();
 166 #endif
 167
 168   /* Reclaim garbage, defined as all alloca'd storage that
 169      was allocated from deeper in the stack than currently. */
 170
 171   {
 172     register header *hp;        /* Traverses linked list.  */
 173
 174     for (hp = last_alloca_header; hp != NULL;)
 175       if ((STACK_DIR > 0 && hp->h.deep > depth)
 176           || (STACK_DIR < 0 && hp->h.deep < depth))
 177         {
 178           register header *np = hp->h.next;
 179
 180           free ((pointer) hp);  /* Collect garbage.  */
 181
 182           hp = np;              /* -> next header.  */
 183         }
 184       else
 185         break;                  /* Rest are not deeper.  */
 186
 187     last_alloca_header = hp;    /* -> last valid storage.  */
 188   }
 189
 190   if (size == 0)
 191     return NULL;                /* No allocation required.  */
 192
 193   /* Allocate combined header + user data storage.  */
 194
 195   {
 196     register pointer new = malloc (sizeof (header) + size);
 197     /* Address of header.  */
 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 (pointer) ((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   /* This might be _getb67() or GETB67 () or getb67 () */
 423   stkl = CRAY_STACKSEG_END ();
 424   ssptr = (struct stack_segment_linkage *) stkl;
 425
 426   /* If one subtracts 'size' from the end of the segment,
 427      one has the address of the first word of the segment.
 428
 429      If this is not the first segment, 'pseg' will be
 430      nonzero.  */
 431
 432   pseg = ssptr->sspseg;
 433   size = ssptr->sssize;
 434
 435   this_segment = stkl - size;
 436
 437   /* It is possible that calling this routine itself caused
 438      a stack overflow.  Discard stack segments which do not
 439      contain the target address.  */
 440
 441   while (!(this_segment <= address && address <= stkl))
 442     {
 443 #ifdef DEBUG_I00AFUNC
 444       fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl);
 445 #endif
 446       if (pseg == 0)
 447         break;
 448       stkl = stkl - pseg;
 449       ssptr = (struct stack_segment_linkage *) stkl;
 450       size = ssptr->sssize;
 451       pseg = ssptr->sspseg;
 452       this_segment = stkl - size;
 453     }
 454
 455   result = address - this_segment;
 456
 457   /* If you subtract pseg from the current end of the stack,
 458      you get the address of the previous stack segment's end.
 459      This seems a little convoluted to me, but I'll bet you save
 460      a cycle somewhere.  */
 461
 462   while (pseg != 0)
 463     {
 464 #ifdef DEBUG_I00AFUNC
 465       fprintf (stderr, "%011o %011o\n", pseg, size);
 466 #endif
 467       stkl = stkl - pseg;
 468       ssptr = (struct stack_segment_linkage *) stkl;
 469       size = ssptr->sssize;
 470       pseg = ssptr->sspseg;
 471       result += size;
 472     }
 473   return (result);
 474 }
 475
 476 #endif /* not CRAY2 */
 477 #endif /* CRAY && CRAY_STACKSEG_END */
 478
 479 #endif /* no alloca */
 480 #endif /* !__GNUC__ || __GNUC__ < 2 */