[gcc.git] / gcc / varray.h

/* Virtual array support.
   Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
   Contributed by Cygnus Solutions.

   This file is part of GNU CC.

   GNU CC is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GNU CC is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GNU CC; see the file COPYING.  If not, write to the Free
   the Free Software Foundation, 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#ifndef _VARRAY_H_
#define _VARRAY_H_

#ifndef HOST_WIDE_INT
#include "machmode.h"
#endif

#ifndef __GCC_SYSTEM_H__
#include "system.h"
#endif

/* Auxiliary structure used inside the varray structure, used for
   function integration data.  */

struct const_equiv_data {
  /* Map pseudo reg number in calling function to equivalent constant.  We
     cannot in general substitute constants into parameter pseudo registers,
     since some machine descriptions (many RISCs) won't always handle
     the resulting insns.  So if an incoming parameter has a constant
     equivalent, we record it here, and if the resulting insn is
     recognizable, we go with it.

     We also use this mechanism to convert references to incoming arguments
     and stacked variables.  copy_rtx_and_substitute will replace the virtual
     incoming argument and virtual stacked variables registers with new
     pseudos that contain pointers into the replacement area allocated for
     this inline instance.  These pseudos are then marked as being equivalent
     to the appropriate address and substituted if valid.  */
  struct rtx_def *rtx;

  /* Record the valid age for each entry.  The entry is invalid if its
     age is less than const_age.  */
  unsigned age;
};

/* Union of various array types that are used.  */
typedef union varray_data_tag {
  char			 c[1];
  unsigned char		 uc[1];
  short			 s[1];
  unsigned short	 us[1];
  int			 i[1];
  unsigned int		 u[1];
  long			 l[1];
  unsigned long		 ul[1];
  HOST_WIDE_INT		 hint[1];
  unsigned HOST_WIDE_INT uhint[1];
  PTR			 generic[1];
  char			 *cptr[1];
  struct rtx_def	 *rtx[1];
  struct rtvec_def	 *rtvec[1];
  union tree_node	 *tree[1];
  struct bitmap_head_def *bitmap[1];
  struct sched_info_tag	 *sched[1];
  struct reg_info_def	 *reg[1];
  struct const_equiv_data const_equiv[1];
  struct basic_block_def *bb[1];
  struct elt_list       *te[1];
} varray_data;

/* Virtual array of pointers header.  */
typedef struct varray_head_tag {
  size_t	num_elements;	/* maximum element number allocated */
  size_t        elements_used;  /* the number of elements used, if
				   using VARRAY_PUSH/VARRAY_POP.  */
  size_t	element_size;	/* size of each data element */
  const char   *name;		/* name of the varray for reporting errors */
  varray_data	data;		/* data elements follow, must be last */
} *varray_type;

/* Allocate a virtual array with NUM elements, each of which is SIZE bytes
   long, named NAME.  Array elements are zeroed.  */
extern varray_type varray_init	PARAMS ((size_t, size_t, const char *));

#define VARRAY_CHAR_INIT(va, num, name) \
  va = varray_init (num, sizeof (char), name)

#define VARRAY_UCHAR_INIT(va, num, name) \
  va = varray_init (num, sizeof (unsigned char), name)

#define VARRAY_SHORT_INIT(va, num, name) \
  va = varray_init (num, sizeof (short), name)

#define VARRAY_USHORT_INIT(va, num, name) \
  va = varray_init (num, sizeof (unsigned short), name)

#define VARRAY_INT_INIT(va, num, name) \
  va = varray_init (num, sizeof (int), name)

#define VARRAY_UINT_INIT(va, num, name) \
  va = varray_init (num, sizeof (unsigned int), name)

#define VARRAY_LONG_INIT(va, num, name) \
  va = varray_init (num, sizeof (long), name)

#define VARRAY_ULONG_INIT(va, num, name) \
  va = varray_init (num, sizeof (unsigned long), name)

#define VARRAY_WIDE_INT_INIT(va, num, name) \
  va = varray_init (num, sizeof (HOST_WIDE_INT), name)

#define VARRAY_UWIDE_INT_INIT(va, num, name) \
  va = varray_init (num, sizeof (unsigned HOST_WIDE_INT), name)

#define VARRAY_GENERIC_PTR_INIT(va, num, name) \
  va = varray_init (num, sizeof (PTR), name)

#define VARRAY_CHAR_PTR_INIT(va, num, name) \
  va = varray_init (num, sizeof (char *), name)

#define VARRAY_RTX_INIT(va, num, name) \
  va = varray_init (num, sizeof (struct rtx_def *), name)

#define VARRAY_RTVEC_INIT(va, num, name) \
  va = varray_init (num, sizeof (struct rtvec_def), name)

#define VARRAY_TREE_INIT(va, num, name) \
  va = varray_init (num, sizeof (union tree_node *), name)

#define VARRAY_BITMAP_INIT(va, num, name) \
  va = varray_init (num, sizeof (struct bitmap_head_def *), name)

#define VARRAY_SCHED_INIT(va, num, name) \
  va = varray_init (num, sizeof (struct sched_info_tag *), name)

#define VARRAY_REG_INIT(va, num, name) \
  va = varray_init (num, sizeof (struct reg_info_def *), name)

#define VARRAY_CONST_EQUIV_INIT(va, num, name) \
  va = varray_init (num, sizeof (struct const_equiv_data), name)

#define VARRAY_BB_INIT(va, num, name) \
  va = varray_init (num, sizeof (struct basic_block_def *), name)

#define VARRAY_ELT_LIST_INIT(va, num, name) \
  va = varray_init (num, sizeof (struct elt_list *), name)

/* Free up memory allocated by the virtual array, but do not free any of the
   elements involved.  */
#define VARRAY_FREE(vp) \
  do { if (vp) { free (vp); vp = (varray_type)0; } } while (0)

/* Grow/shrink the virtual array VA to N elements.  */
extern varray_type varray_grow	PARAMS ((varray_type, size_t));

#define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))

#define VARRAY_SIZE(VA)	((VA)->num_elements)

/* Check for VARRAY_xxx macros being in bound.  */
#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
extern void varray_check_failed PARAMS ((varray_type, size_t,
					const char *, int,
					const char *)) ATTRIBUTE_NORETURN;
#define VARRAY_CHECK(VA, N, T)					\
(*({ varray_type _va = VA;					\
     size_t _n = N; 						\
     if (_n >= _va->num_elements)				\
       varray_check_failed (_va, _n, __FILE__, __LINE__,	\
			    __PRETTY_FUNCTION__);		\
     &_va->data.T[_n]; }))
#else
#define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
#endif

/* Push X onto VA.  T is the name of the field in varray_data
   corresponding to the type of X.  */
#define VARRAY_PUSH(VA, T, X) 				\
  do 							\
    {							\
      if ((VA)->elements_used >= (VA)->num_elements)	\
        VARRAY_GROW ((VA), 2 * (VA)->num_elements);	\
      (VA)->data.T[(VA)->elements_used++] = (X);	\
    }							\
  while (0)

/* Pop the top element of VA.  */
#define VARRAY_POP(VA) \
  ((VA)->elements_used--)

/* Return the top element of VA.  */
#define VARRAY_TOP(VA, T) \
  ((VA)->data.T[(VA)->elements_used - 1])

#define VARRAY_CHAR(VA, N)		VARRAY_CHECK (VA, N, c)
#define VARRAY_UCHAR(VA, N)		VARRAY_CHECK (VA, N, uc)
#define VARRAY_SHORT(VA, N)		VARRAY_CHECK (VA, N, s)
#define VARRAY_USHORT(VA, N)		VARRAY_CHECK (VA, N, us)
#define VARRAY_INT(VA, N)		VARRAY_CHECK (VA, N, i)
#define VARRAY_UINT(VA, N)		VARRAY_CHECK (VA, N, u)
#define VARRAY_LONG(VA, N)		VARRAY_CHECK (VA, N, l)
#define VARRAY_ULONG(VA, N)		VARRAY_CHECK (VA, N, ul)
#define VARRAY_WIDE_INT(VA, N)		VARRAY_CHECK (VA, N, hint)
#define VARRAY_UWIDE_INT(VA, N)		VARRAY_CHECK (VA, N, uhint)
#define VARRAY_GENERIC_PTR(VA,N)	VARRAY_CHECK (VA, N, generic)
#define VARRAY_CHAR_PTR(VA,N)		VARRAY_CHECK (VA, N, cptr)
#define VARRAY_RTX(VA, N)		VARRAY_CHECK (VA, N, rtx)
#define VARRAY_RTVEC(VA, N)		VARRAY_CHECK (VA, N, rtvec)
#define VARRAY_TREE(VA, N)		VARRAY_CHECK (VA, N, tree)
#define VARRAY_BITMAP(VA, N)		VARRAY_CHECK (VA, N, bitmap)
#define VARRAY_SCHED(VA, N)		VARRAY_CHECK (VA, N, sched)
#define VARRAY_REG(VA, N)		VARRAY_CHECK (VA, N, reg)
#define VARRAY_CONST_EQUIV(VA, N)	VARRAY_CHECK (VA, N, const_equiv)
#define VARRAY_BB(VA, N)		VARRAY_CHECK (VA, N, bb)
#define VARRAY_ELT_LIST(VA, N)		VARRAY_CHECK (VA, N, te)

/* Push a new element on the end of VA, extending it if necessary.  */
#define VARRAY_PUSH_CHAR(VA, X)		VARRAY_PUSH (VA, c, X)
#define VARRAY_PUSH_UCHAR(VA, X)	VARRAY_PUSH (VA, uc, X)
#define VARRAY_PUSH_SHORT(VA, X)	VARRAY_PUSH (VA, s, X)
#define VARRAY_PUSH_USHORT(VA, X)	VARRAY_PUSH (VA, us, X)
#define VARRAY_PUSH_INT(VA, X)		VARRAY_PUSH (VA, i, X)
#define VARRAY_PUSH_UINT(VA, X)		VARRAY_PUSH (VA, u, X)
#define VARRAY_PUSH_LONG(VA, X)		VARRAY_PUSH (VA, l, X)
#define VARRAY_PUSH_ULONG(VA, X)	VARRAY_PUSH (VA, ul, X)
#define VARRAY_PUSH_WIDE_INT(VA, X)	VARRAY_PUSH (VA, hint, X)
#define VARRAY_PUSH_UWIDE_INT(VA, X)	VARRAY_PUSH (VA, uhint, X)
#define VARRAY_PUSH_GENERIC_PTR(VA,N)	VARRAY_PUSH (VA, generic, X)
#define VARRAY_PUSH_CHAR_PTR(VA,N)	VARRAY_PUSH (VA, cptr, X)
#define VARRAY_PUSH_RTX(VA, X)		VARRAY_PUSH (VA, rtx, X)
#define VARRAY_PUSH_RTVEC(VA, X)	VARRAY_PUSH (VA, rtvec, X)
#define VARRAY_PUSH_TREE(VA, X)		VARRAY_PUSH (VA, tree, X)
#define VARRAY_PUSH_BITMAP(VA, X)	VARRAY_PUSH (VA, bitmap, X)
#define VARRAY_PUSH_SCHED(VA, X)	VARRAY_PUSH (VA, sched, X)
#define VARRAY_PUSH_REG(VA, X)		VARRAY_PUSH (VA, reg, X)
#define VARRAY_PUSH_CONST_EQUIV(VA, X)	VARRAY_PUSH (VA, const_equiv, X)
#define VARRAY_PUSH_BB(VA, X)		VARRAY_PUSH (VA, bb, X)

/* Return the last element of VA.  */
#define VARRAY_TOP_CHAR(VA)		VARRAY_TOP (VA, c)
#define VARRAY_TOP_UCHAR(VA)	        VARRAY_TOP (VA, uc)
#define VARRAY_TOP_SHORT(VA)	        VARRAY_TOP (VA, s)
#define VARRAY_TOP_USHORT(VA)	        VARRAY_TOP (VA, us)
#define VARRAY_TOP_INT(VA)		VARRAY_TOP (VA, i)
#define VARRAY_TOP_UINT(VA)		VARRAY_TOP (VA, u)
#define VARRAY_TOP_LONG(VA)		VARRAY_TOP (VA, l)
#define VARRAY_TOP_ULONG(VA)	        VARRAY_TOP (VA, ul)
#define VARRAY_TOP_WIDE_INT(VA)	        VARRAY_TOP (VA, hint)
#define VARRAY_TOP_UWIDE_INT(VA)	VARRAY_TOP (VA, uhint)
#define VARRAY_TOP_GENERIC_PTR(VA,N)	VARRAY_TOP (VA, generic)
#define VARRAY_TOP_CHAR_PTR(VA,N)	VARRAY_TOP (VA, cptr)
#define VARRAY_TOP_RTX(VA)		VARRAY_TOP (VA, rtx)
#define VARRAY_TOP_RTVEC(VA)	        VARRAY_TOP (VA, rtvec)
#define VARRAY_TOP_TREE(VA)		VARRAY_TOP (VA, tree)
#define VARRAY_TOP_BITMAP(VA)	        VARRAY_TOP (VA, bitmap)
#define VARRAY_TOP_SCHED(VA)	        VARRAY_TOP (VA, sched)
#define VARRAY_TOP_REG(VA)		VARRAY_TOP (VA, reg)
#define VARRAY_TOP_CONST_EQUIV(VA)	VARRAY_TOP (VA, const_equiv)
#define VARRAY_TOP_BB(VA)		VARRAY_TOP (VA, bb)

#endif /* _VARRAY_H_ */
Commit	Line	Data
848205e6	1	/* Virtual array support.
9311a396	2	Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
848205e6 MM	3	Contributed by Cygnus Solutions.
	4
	5	This file is part of GNU CC.
	6
	7	GNU CC is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
	11
	12	GNU CC is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GNU CC; see the file COPYING. If not, write to the Free
	19	the Free Software Foundation, 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
	21
	22	#ifndef _VARRAY_H_
	23	#define _VARRAY_H_
	24
848205e6 MM	25	#ifndef HOST_WIDE_INT
	26	#include "machmode.h"
	27	#endif
	28
4dfb04c6 MM	29	#ifndef __GCC_SYSTEM_H__
	30	#include "system.h"
	31	#endif
	32
c68da89c KR	33	/* Auxiliary structure used inside the varray structure, used for
	34	function integration data. */
	35
	36	struct const_equiv_data {
	37	/* Map pseudo reg number in calling function to equivalent constant. We
	38	cannot in general substitute constants into parameter pseudo registers,
	39	since some machine descriptions (many RISCs) won't always handle
	40	the resulting insns. So if an incoming parameter has a constant
	41	equivalent, we record it here, and if the resulting insn is
	42	recognizable, we go with it.
	43
	44	We also use this mechanism to convert references to incoming arguments
	45	and stacked variables. copy_rtx_and_substitute will replace the virtual
	46	incoming argument and virtual stacked variables registers with new
	47	pseudos that contain pointers into the replacement area allocated for
	48	this inline instance. These pseudos are then marked as being equivalent
	49	to the appropriate address and substituted if valid. */
565e3f3e	50	struct rtx_def *rtx;
c68da89c KR	51
	52	/* Record the valid age for each entry. The entry is invalid if its
	53	age is less than const_age. */
	54	unsigned age;
	55	};
	56
848205e6 MM	57	/* Union of various array types that are used. */
	58	typedef union varray_data_tag {
	59	char c[1];
	60	unsigned char uc[1];
	61	short s[1];
	62	unsigned short us[1];
	63	int i[1];
	64	unsigned int u[1];
	65	long l[1];
	66	unsigned long ul[1];
	67	HOST_WIDE_INT hint[1];
	68	unsigned HOST_WIDE_INT uhint[1];
e1b6684c	69	PTR generic[1];
848205e6 MM	70	char *cptr[1];
	71	struct rtx_def *rtx[1];
	72	struct rtvec_def *rtvec[1];
	73	union tree_node *tree[1];
	74	struct bitmap_head_def *bitmap[1];
	75	struct sched_info_tag *sched[1];
	76	struct reg_info_def *reg[1];
c68da89c	77	struct const_equiv_data const_equiv[1];
e881bb1b	78	struct basic_block_def *bb[1];
eab5c70a	79	struct elt_list *te[1];
848205e6 MM	80	} varray_data;
	81
	82	/* Virtual array of pointers header. */
	83	typedef struct varray_head_tag {
	84	size_t num_elements; /* maximum element number allocated */
a6873608 MM	85	size_t elements_used; /* the number of elements used, if
a6873608 MM	86	using VARRAY_PUSH/VARRAY_POP. */
848205e6 MM	87	size_t element_size; /* size of each data element */
	88	const char name; / name of the varray for reporting errors */
	89	varray_data data; /* data elements follow, must be last */
	90	} *varray_type;
	91
	92	/* Allocate a virtual array with NUM elements, each of which is SIZE bytes
	93	long, named NAME. Array elements are zeroed. */
58782098	94	extern varray_type varray_init PARAMS ((size_t, size_t, const char *));
848205e6 MM	95
	96	#define VARRAY_CHAR_INIT(va, num, name) \
	97	va = varray_init (num, sizeof (char), name)
	98
	99	#define VARRAY_UCHAR_INIT(va, num, name) \
	100	va = varray_init (num, sizeof (unsigned char), name)
	101
	102	#define VARRAY_SHORT_INIT(va, num, name) \
	103	va = varray_init (num, sizeof (short), name)
	104
	105	#define VARRAY_USHORT_INIT(va, num, name) \
	106	va = varray_init (num, sizeof (unsigned short), name)
	107
	108	#define VARRAY_INT_INIT(va, num, name) \
	109	va = varray_init (num, sizeof (int), name)
	110
	111	#define VARRAY_UINT_INIT(va, num, name) \
	112	va = varray_init (num, sizeof (unsigned int), name)
	113
	114	#define VARRAY_LONG_INIT(va, num, name) \
	115	va = varray_init (num, sizeof (long), name)
	116
	117	#define VARRAY_ULONG_INIT(va, num, name) \
	118	va = varray_init (num, sizeof (unsigned long), name)
	119
	120	#define VARRAY_WIDE_INT_INIT(va, num, name) \
	121	va = varray_init (num, sizeof (HOST_WIDE_INT), name)
	122
	123	#define VARRAY_UWIDE_INT_INIT(va, num, name) \
	124	va = varray_init (num, sizeof (unsigned HOST_WIDE_INT), name)
	125
	126	#define VARRAY_GENERIC_PTR_INIT(va, num, name) \
e1b6684c	127	va = varray_init (num, sizeof (PTR), name)
848205e6 MM	128
	129	#define VARRAY_CHAR_PTR_INIT(va, num, name) \
	130	va = varray_init (num, sizeof (char *), name)
	131
	132	#define VARRAY_RTX_INIT(va, num, name) \
	133	va = varray_init (num, sizeof (struct rtx_def *), name)
	134
	135	#define VARRAY_RTVEC_INIT(va, num, name) \
	136	va = varray_init (num, sizeof (struct rtvec_def), name)
	137
	138	#define VARRAY_TREE_INIT(va, num, name) \
	139	va = varray_init (num, sizeof (union tree_node *), name)
	140
	141	#define VARRAY_BITMAP_INIT(va, num, name) \
	142	va = varray_init (num, sizeof (struct bitmap_head_def *), name)
	143
	144	#define VARRAY_SCHED_INIT(va, num, name) \
	145	va = varray_init (num, sizeof (struct sched_info_tag *), name)
	146
	147	#define VARRAY_REG_INIT(va, num, name) \
	148	va = varray_init (num, sizeof (struct reg_info_def *), name)
	149
c68da89c KR	150	#define VARRAY_CONST_EQUIV_INIT(va, num, name) \
	151	va = varray_init (num, sizeof (struct const_equiv_data), name)
	152
e881bb1b RH	153	#define VARRAY_BB_INIT(va, num, name) \
	154	va = varray_init (num, sizeof (struct basic_block_def *), name)
	155
eab5c70a BS	156	#define VARRAY_ELT_LIST_INIT(va, num, name) \
	157	va = varray_init (num, sizeof (struct elt_list *), name)
	158
848205e6 MM	159	/* Free up memory allocated by the virtual array, but do not free any of the
848205e6 MM	160	elements involved. */
804a4e13 KG	161	#define VARRAY_FREE(vp) \
804a4e13 KG	162	do { if (vp) { free (vp); vp = (varray_type)0; } } while (0)
848205e6 MM	163
848205e6 MM	164	/* Grow/shrink the virtual array VA to N elements. */
58782098	165	extern varray_type varray_grow PARAMS ((varray_type, size_t));
848205e6 MM	166
	167	#define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))
	168
c68da89c KR	169	#define VARRAY_SIZE(VA) ((VA)->num_elements)
c68da89c KR	170
987009bf	171	/* Check for VARRAY_xxx macros being in bound. */
6c9821b7	172	#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
58782098	173	extern void varray_check_failed PARAMS ((varray_type, size_t,
987009bf ZW	174	const char *, int,
	175	const char *)) ATTRIBUTE_NORETURN;
	176	#define VARRAY_CHECK(VA, N, T) \
	177	(*({ varray_type _va = VA; \
	178	size_t _n = N; \
	179	if (_n >= _va->num_elements) \
	180	varray_check_failed (_va, _n, __FILE__, __LINE__, \
	181	__PRETTY_FUNCTION__); \
	182	&_va->data.T[_n]; }))
848205e6	183	#else
987009bf	184	#define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
848205e6 MM	185	#endif
848205e6 MM	186
a6873608 MM	187	/* Push X onto VA. T is the name of the field in varray_data
	188	corresponding to the type of X. */
	189	#define VARRAY_PUSH(VA, T, X) \
	190	do \
	191	{ \
	192	if ((VA)->elements_used >= (VA)->num_elements) \
	193	VARRAY_GROW ((VA), 2 * (VA)->num_elements); \
	194	(VA)->data.T[(VA)->elements_used++] = (X); \
	195	} \
	196	while (0)
	197
	198	/* Pop the top element of VA. */
	199	#define VARRAY_POP(VA) \
	200	((VA)->elements_used--)
	201
	202	/* Return the top element of VA. */
	203	#define VARRAY_TOP(VA, T) \
	204	((VA)->data.T[(VA)->elements_used - 1])
	205
987009bf ZW	206	#define VARRAY_CHAR(VA, N) VARRAY_CHECK (VA, N, c)
	207	#define VARRAY_UCHAR(VA, N) VARRAY_CHECK (VA, N, uc)
	208	#define VARRAY_SHORT(VA, N) VARRAY_CHECK (VA, N, s)
	209	#define VARRAY_USHORT(VA, N) VARRAY_CHECK (VA, N, us)
	210	#define VARRAY_INT(VA, N) VARRAY_CHECK (VA, N, i)
	211	#define VARRAY_UINT(VA, N) VARRAY_CHECK (VA, N, u)
	212	#define VARRAY_LONG(VA, N) VARRAY_CHECK (VA, N, l)
	213	#define VARRAY_ULONG(VA, N) VARRAY_CHECK (VA, N, ul)
	214	#define VARRAY_WIDE_INT(VA, N) VARRAY_CHECK (VA, N, hint)
	215	#define VARRAY_UWIDE_INT(VA, N) VARRAY_CHECK (VA, N, uhint)
	216	#define VARRAY_GENERIC_PTR(VA,N) VARRAY_CHECK (VA, N, generic)
	217	#define VARRAY_CHAR_PTR(VA,N) VARRAY_CHECK (VA, N, cptr)
	218	#define VARRAY_RTX(VA, N) VARRAY_CHECK (VA, N, rtx)
	219	#define VARRAY_RTVEC(VA, N) VARRAY_CHECK (VA, N, rtvec)
	220	#define VARRAY_TREE(VA, N) VARRAY_CHECK (VA, N, tree)
	221	#define VARRAY_BITMAP(VA, N) VARRAY_CHECK (VA, N, bitmap)
	222	#define VARRAY_SCHED(VA, N) VARRAY_CHECK (VA, N, sched)
	223	#define VARRAY_REG(VA, N) VARRAY_CHECK (VA, N, reg)
	224	#define VARRAY_CONST_EQUIV(VA, N) VARRAY_CHECK (VA, N, const_equiv)
	225	#define VARRAY_BB(VA, N) VARRAY_CHECK (VA, N, bb)
eab5c70a	226	#define VARRAY_ELT_LIST(VA, N) VARRAY_CHECK (VA, N, te)
848205e6	227
a6873608 MM	228	/* Push a new element on the end of VA, extending it if necessary. */
	229	#define VARRAY_PUSH_CHAR(VA, X) VARRAY_PUSH (VA, c, X)
	230	#define VARRAY_PUSH_UCHAR(VA, X) VARRAY_PUSH (VA, uc, X)
	231	#define VARRAY_PUSH_SHORT(VA, X) VARRAY_PUSH (VA, s, X)
	232	#define VARRAY_PUSH_USHORT(VA, X) VARRAY_PUSH (VA, us, X)
	233	#define VARRAY_PUSH_INT(VA, X) VARRAY_PUSH (VA, i, X)
	234	#define VARRAY_PUSH_UINT(VA, X) VARRAY_PUSH (VA, u, X)
	235	#define VARRAY_PUSH_LONG(VA, X) VARRAY_PUSH (VA, l, X)
	236	#define VARRAY_PUSH_ULONG(VA, X) VARRAY_PUSH (VA, ul, X)
	237	#define VARRAY_PUSH_WIDE_INT(VA, X) VARRAY_PUSH (VA, hint, X)
	238	#define VARRAY_PUSH_UWIDE_INT(VA, X) VARRAY_PUSH (VA, uhint, X)
	239	#define VARRAY_PUSH_GENERIC_PTR(VA,N) VARRAY_PUSH (VA, generic, X)
	240	#define VARRAY_PUSH_CHAR_PTR(VA,N) VARRAY_PUSH (VA, cptr, X)
	241	#define VARRAY_PUSH_RTX(VA, X) VARRAY_PUSH (VA, rtx, X)
	242	#define VARRAY_PUSH_RTVEC(VA, X) VARRAY_PUSH (VA, rtvec, X)
	243	#define VARRAY_PUSH_TREE(VA, X) VARRAY_PUSH (VA, tree, X)
	244	#define VARRAY_PUSH_BITMAP(VA, X) VARRAY_PUSH (VA, bitmap, X)
	245	#define VARRAY_PUSH_SCHED(VA, X) VARRAY_PUSH (VA, sched, X)
	246	#define VARRAY_PUSH_REG(VA, X) VARRAY_PUSH (VA, reg, X)
	247	#define VARRAY_PUSH_CONST_EQUIV(VA, X) VARRAY_PUSH (VA, const_equiv, X)
	248	#define VARRAY_PUSH_BB(VA, X) VARRAY_PUSH (VA, bb, X)
	249
	250	/* Return the last element of VA. */
	251	#define VARRAY_TOP_CHAR(VA) VARRAY_TOP (VA, c)
	252	#define VARRAY_TOP_UCHAR(VA) VARRAY_TOP (VA, uc)
	253	#define VARRAY_TOP_SHORT(VA) VARRAY_TOP (VA, s)
	254	#define VARRAY_TOP_USHORT(VA) VARRAY_TOP (VA, us)
	255	#define VARRAY_TOP_INT(VA) VARRAY_TOP (VA, i)
	256	#define VARRAY_TOP_UINT(VA) VARRAY_TOP (VA, u)
	257	#define VARRAY_TOP_LONG(VA) VARRAY_TOP (VA, l)
	258	#define VARRAY_TOP_ULONG(VA) VARRAY_TOP (VA, ul)
	259	#define VARRAY_TOP_WIDE_INT(VA) VARRAY_TOP (VA, hint)
	260	#define VARRAY_TOP_UWIDE_INT(VA) VARRAY_TOP (VA, uhint)
	261	#define VARRAY_TOP_GENERIC_PTR(VA,N) VARRAY_TOP (VA, generic)
	262	#define VARRAY_TOP_CHAR_PTR(VA,N) VARRAY_TOP (VA, cptr)
	263	#define VARRAY_TOP_RTX(VA) VARRAY_TOP (VA, rtx)
	264	#define VARRAY_TOP_RTVEC(VA) VARRAY_TOP (VA, rtvec)
	265	#define VARRAY_TOP_TREE(VA) VARRAY_TOP (VA, tree)
	266	#define VARRAY_TOP_BITMAP(VA) VARRAY_TOP (VA, bitmap)
	267	#define VARRAY_TOP_SCHED(VA) VARRAY_TOP (VA, sched)
	268	#define VARRAY_TOP_REG(VA) VARRAY_TOP (VA, reg)
	269	#define VARRAY_TOP_CONST_EQUIV(VA) VARRAY_TOP (VA, const_equiv)
	270	#define VARRAY_TOP_BB(VA) VARRAY_TOP (VA, bb)
	271
848205e6	272	#endif /* _VARRAY_H_ */