[thirdparty/gcc.git] / libiberty / alloca.c

/* alloca.c -- allocate automatically reclaimed memory
   (Mostly) portable public-domain implementation -- D A Gwyn

   This implementation of the PWB library alloca function,
   which is used to allocate space off the run-time stack so
   that it is automatically reclaimed upon procedure exit,
   was inspired by discussions with J. Q. Johnson of Cornell.
   J.Otto Tennant <jot@cray.com> contributed the Cray support.

   There are some preprocessor constants that can
   be defined when compiling for your specific system, for
   improved efficiency; however, the defaults should be okay.

   The general concept of this implementation is to keep
   track of all alloca-allocated blocks, and reclaim any
   that are found to be deeper in the stack than the current
   invocation.  This heuristic does not reclaim storage as
   soon as it becomes invalid, but it will do so eventually.

   As a special case, alloca(0) reclaims storage without
   allocating any.  It is a good idea to use alloca(0) in
   your main control loop, etc. to force garbage collection.  */

/*

@deftypefn Replacement void* alloca (size_t)

This function allocates memory which will be automatically reclaimed
after the procedure exits.  The @libib{} implementation does not free
the memory immediately but will do so eventually during subsequent
calls to this function.  Memory is allocated using @code{xmalloc} under
normal circumstances.

The header file @file{alloca-conf.h} can be used in conjunction with the
GNU Autoconf test @code{AC_FUNC_ALLOCA} to test for and properly make
available this function.  The @code{AC_FUNC_ALLOCA} test requires that
client code use a block of preprocessor code to be safe (see the Autoconf
manual for more); this header incorporates that logic and more, including
the possibility of a GCC builtin function.

@end deftypefn

*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <libiberty.h>

#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

/* These variables are used by the ASTRDUP implementation that relies
   on C_alloca.  */
const char *libiberty_optr;
char *libiberty_nptr;
unsigned long libiberty_len;

/* If your stack is a linked list of frames, you have to
   provide an "address metric" ADDRESS_FUNCTION macro.  */

#if defined (CRAY) && defined (CRAY_STACKSEG_END)
static long i00afunc ();
#define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg))
#else
#define ADDRESS_FUNCTION(arg) &(arg)
#endif

#ifndef NULL
#define	NULL	0
#endif

/* Define STACK_DIRECTION if you know the direction of stack
   growth for your system; otherwise it will be automatically
   deduced at run-time.

   STACK_DIRECTION > 0 => grows toward higher addresses
   STACK_DIRECTION < 0 => grows toward lower addresses
   STACK_DIRECTION = 0 => direction of growth unknown  */

#ifndef STACK_DIRECTION
#define	STACK_DIRECTION	0	/* Direction unknown.  */
#endif

#if STACK_DIRECTION != 0

#define	STACK_DIR	STACK_DIRECTION	/* Known at compile-time.  */

#else /* STACK_DIRECTION == 0; need run-time code.  */

static int stack_dir;		/* 1 or -1 once known.  */
#define	STACK_DIR	stack_dir

static void
find_stack_direction ()
{
  static char *addr = NULL;	/* Address of first `dummy', once known.  */
  auto char dummy;		/* To get stack address.  */

  if (addr == NULL)
    {				/* Initial entry.  */
      addr = ADDRESS_FUNCTION (dummy);

      find_stack_direction ();	/* Recurse once.  */
    }
  else
    {
      /* Second entry.  */
      if (ADDRESS_FUNCTION (dummy) > addr)
	stack_dir = 1;		/* Stack grew upward.  */
      else
	stack_dir = -1;		/* Stack grew downward.  */
    }
}

#endif /* STACK_DIRECTION == 0 */

/* An "alloca header" is used to:
   (a) chain together all alloca'ed blocks;
   (b) keep track of stack depth.

   It is very important that sizeof(header) agree with malloc
   alignment chunk size.  The following default should work okay.  */

#ifndef	ALIGN_SIZE
#define	ALIGN_SIZE	sizeof(double)
#endif

typedef union hdr
{
  char align[ALIGN_SIZE];	/* To force sizeof(header).  */
  struct
    {
      union hdr *next;		/* For chaining headers.  */
      char *deep;		/* For stack depth measure.  */
    } h;
} header;

static header *last_alloca_header = NULL;	/* -> last alloca header.  */

/* Return a pointer to at least SIZE bytes of storage,
   which will be automatically reclaimed upon exit from
   the procedure that called alloca.  Originally, this space
   was supposed to be taken from the current stack frame of the
   caller, but that method cannot be made to work for some
   implementations of C, for example under Gould's UTX/32.  */

PTR
C_alloca (size)
     size_t size;
{
  auto char probe;		/* Probes stack depth: */
  register char *depth = ADDRESS_FUNCTION (probe);

#if STACK_DIRECTION == 0
  if (STACK_DIR == 0)		/* Unknown growth direction.  */
    find_stack_direction ();
#endif

  /* Reclaim garbage, defined as all alloca'd storage that
     was allocated from deeper in the stack than currently.  */

  {
    register header *hp;	/* Traverses linked list.  */

    for (hp = last_alloca_header; hp != NULL;)
      if ((STACK_DIR > 0 && hp->h.deep > depth)
	  || (STACK_DIR < 0 && hp->h.deep < depth))
	{
	  register header *np = hp->h.next;

	  free ((PTR) hp);	/* Collect garbage.  */

	  hp = np;		/* -> next header.  */
	}
      else
	break;			/* Rest are not deeper.  */

    last_alloca_header = hp;	/* -> last valid storage.  */
  }

  if (size == 0)
    return NULL;		/* No allocation required.  */

  /* Allocate combined header + user data storage.  */

  {
    register PTR new = xmalloc (sizeof (header) + size);
    /* Address of header.  */

    if (new == 0)
      abort();

    ((header *) new)->h.next = last_alloca_header;
    ((header *) new)->h.deep = depth;

    last_alloca_header = (header *) new;

    /* User storage begins just after header.  */

    return (PTR) ((char *) new + sizeof (header));
  }
}

#if defined (CRAY) && defined (CRAY_STACKSEG_END)

#ifdef DEBUG_I00AFUNC
#include <stdio.h>
#endif

#ifndef CRAY_STACK
#define CRAY_STACK
#ifndef CRAY2
/* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */
struct stack_control_header
  {
    long shgrow:32;		/* Number of times stack has grown.  */
    long shaseg:32;		/* Size of increments to stack.  */
    long shhwm:32;		/* High water mark of stack.  */
    long shsize:32;		/* Current size of stack (all segments).  */
  };

/* The stack segment linkage control information occurs at
   the high-address end of a stack segment.  (The stack
   grows from low addresses to high addresses.)  The initial
   part of the stack segment linkage control information is
   0200 (octal) words.  This provides for register storage
   for the routine which overflows the stack.  */

struct stack_segment_linkage
  {
    long ss[0200];		/* 0200 overflow words.  */
    long sssize:32;		/* Number of words in this segment.  */
    long ssbase:32;		/* Offset to stack base.  */
    long:32;
    long sspseg:32;		/* Offset to linkage control of previous
				   segment of stack.  */
    long:32;
    long sstcpt:32;		/* Pointer to task common address block.  */
    long sscsnm;		/* Private control structure number for
				   microtasking.  */
    long ssusr1;		/* Reserved for user.  */
    long ssusr2;		/* Reserved for user.  */
    long sstpid;		/* Process ID for pid based multi-tasking.  */
    long ssgvup;		/* Pointer to multitasking thread giveup.  */
    long sscray[7];		/* Reserved for Cray Research.  */
    long ssa0;
    long ssa1;
    long ssa2;
    long ssa3;
    long ssa4;
    long ssa5;
    long ssa6;
    long ssa7;
    long sss0;
    long sss1;
    long sss2;
    long sss3;
    long sss4;
    long sss5;
    long sss6;
    long sss7;
  };

#else /* CRAY2 */
/* The following structure defines the vector of words
   returned by the STKSTAT library routine.  */
struct stk_stat
  {
    long now;			/* Current total stack size.  */
    long maxc;			/* Amount of contiguous space which would
				   be required to satisfy the maximum
				   stack demand to date.  */
    long high_water;		/* Stack high-water mark.  */
    long overflows;		/* Number of stack overflow ($STKOFEN) calls.  */
    long hits;			/* Number of internal buffer hits.  */
    long extends;		/* Number of block extensions.  */
    long stko_mallocs;		/* Block allocations by $STKOFEN.  */
    long underflows;		/* Number of stack underflow calls ($STKRETN).  */
    long stko_free;		/* Number of deallocations by $STKRETN.  */
    long stkm_free;		/* Number of deallocations by $STKMRET.  */
    long segments;		/* Current number of stack segments.  */
    long maxs;			/* Maximum number of stack segments so far.  */
    long pad_size;		/* Stack pad size.  */
    long current_address;	/* Current stack segment address.  */
    long current_size;		/* Current stack segment size.  This
				   number is actually corrupted by STKSTAT to
				   include the fifteen word trailer area.  */
    long initial_address;	/* Address of initial segment.  */
    long initial_size;		/* Size of initial segment.  */
  };

/* The following structure describes the data structure which trails
   any stack segment.  I think that the description in 'asdef' is
   out of date.  I only describe the parts that I am sure about.  */

struct stk_trailer
  {
    long this_address;		/* Address of this block.  */
    long this_size;		/* Size of this block (does not include
				   this trailer).  */
    long unknown2;
    long unknown3;
    long link;			/* Address of trailer block of previous
				   segment.  */
    long unknown5;
    long unknown6;
    long unknown7;
    long unknown8;
    long unknown9;
    long unknown10;
    long unknown11;
    long unknown12;
    long unknown13;
    long unknown14;
  };

#endif /* CRAY2 */
#endif /* not CRAY_STACK */

#ifdef CRAY2
/* Determine a "stack measure" for an arbitrary ADDRESS.
   I doubt that "lint" will like this much.  */

static long
i00afunc (long *address)
{
  struct stk_stat status;
  struct stk_trailer *trailer;
  long *block, size;
  long result = 0;

  /* We want to iterate through all of the segments.  The first
     step is to get the stack status structure.  We could do this
     more quickly and more directly, perhaps, by referencing the
     $LM00 common block, but I know that this works.  */

  STKSTAT (&status);

  /* Set up the iteration.  */

  trailer = (struct stk_trailer *) (status.current_address
				    + status.current_size
				    - 15);

  /* There must be at least one stack segment.  Therefore it is
     a fatal error if "trailer" is null.  */

  if (trailer == 0)
    abort ();

  /* Discard segments that do not contain our argument address.  */

  while (trailer != 0)
    {
      block = (long *) trailer->this_address;
      size = trailer->this_size;
      if (block == 0 || size == 0)
	abort ();
      trailer = (struct stk_trailer *) trailer->link;
      if ((block <= address) && (address < (block + size)))
	break;
    }

  /* Set the result to the offset in this segment and add the sizes
     of all predecessor segments.  */

  result = address - block;

  if (trailer == 0)
    {
      return result;
    }

  do
    {
      if (trailer->this_size <= 0)
	abort ();
      result += trailer->this_size;
      trailer = (struct stk_trailer *) trailer->link;
    }
  while (trailer != 0);

  /* We are done.  Note that if you present a bogus address (one
     not in any segment), you will get a different number back, formed
     from subtracting the address of the first block.  This is probably
     not what you want.  */

  return (result);
}

#else /* not CRAY2 */
/* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP.
   Determine the number of the cell within the stack,
   given the address of the cell.  The purpose of this
   routine is to linearize, in some sense, stack addresses
   for alloca.  */

static long
i00afunc (long address)
{
  long stkl = 0;

  long size, pseg, this_segment, stack;
  long result = 0;

  struct stack_segment_linkage *ssptr;

  /* Register B67 contains the address of the end of the
     current stack segment.  If you (as a subprogram) store
     your registers on the stack and find that you are past
     the contents of B67, you have overflowed the segment.

     B67 also points to the stack segment linkage control
     area, which is what we are really interested in.  */

  stkl = CRAY_STACKSEG_END ();
  ssptr = (struct stack_segment_linkage *) stkl;

  /* If one subtracts 'size' from the end of the segment,
     one has the address of the first word of the segment.

     If this is not the first segment, 'pseg' will be
     nonzero.  */

  pseg = ssptr->sspseg;
  size = ssptr->sssize;

  this_segment = stkl - size;

  /* It is possible that calling this routine itself caused
     a stack overflow.  Discard stack segments which do not
     contain the target address.  */

  while (!(this_segment <= address && address <= stkl))
    {
#ifdef DEBUG_I00AFUNC
      fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl);
#endif
      if (pseg == 0)
	break;
      stkl = stkl - pseg;
      ssptr = (struct stack_segment_linkage *) stkl;
      size = ssptr->sssize;
      pseg = ssptr->sspseg;
      this_segment = stkl - size;
    }

  result = address - this_segment;

  /* If you subtract pseg from the current end of the stack,
     you get the address of the previous stack segment's end.
     This seems a little convoluted to me, but I'll bet you save
     a cycle somewhere.  */

  while (pseg != 0)
    {
#ifdef DEBUG_I00AFUNC
      fprintf (stderr, "%011o %011o\n", pseg, size);
#endif
      stkl = stkl - pseg;
      ssptr = (struct stack_segment_linkage *) stkl;
      size = ssptr->sssize;
      pseg = ssptr->sspseg;
      result += size;
    }
  return (result);
}

#endif /* not CRAY2 */
#endif /* CRAY */
Commit	Line	Data
6599da04 JM	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
aaa5f039 DD	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
6599da04	45	#ifdef HAVE_CONFIG_H
29382d66	46	#include <config.h>
6599da04 JM	47	#endif
6599da04 JM	48
b548dffb ZW	49	#include <libiberty.h>
b548dffb ZW	50
29382d66 JL	51	#ifdef HAVE_STRING_H
	52	#include <string.h>
	53	#endif
	54	#ifdef HAVE_STDLIB_H
	55	#include <stdlib.h>
	56	#endif
	57
c1d49704 KG	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
6599da04 JM	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)
b548dffb	68	static long i00afunc ();
6599da04 JM	69	#define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg))
	70	#else
	71	#define ADDRESS_FUNCTION(arg) &(arg)
	72	#endif
	73
6599da04 JM	74	#ifndef NULL
	75	#define NULL 0
	76	#endif
	77
6599da04 JM	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
b548dffb ZW	153	PTR
	154	C_alloca (size)
	155	size_t size;
6599da04 JM	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
29382d66	166	was allocated from deeper in the stack than currently. */
6599da04 JM	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
b548dffb	177	free ((PTR) hp); /* Collect garbage. */
6599da04 JM	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	{
b548dffb	193	register PTR new = xmalloc (sizeof (header) + size);
6599da04 JM	194	/* Address of header. */
6599da04 JM	195
29382d66 JL	196	if (new == 0)
	197	abort();
	198
6599da04 JM	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
b548dffb	206	return (PTR) ((char *) new + sizeof (header));
6599da04 JM	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.
29382d66	328	I doubt that "lint" will like this much. */
6599da04 JM	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 */