← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to win32/alloca.c

  • Committer: Monty Taylor
  • Date: 2008-08-02 00:06:32 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080802000632-jsse0zdd9r6ic5ku
Actually turn gettext on...

Show diffs side-by-side

added added

removed removed

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