[gcc.git] / gcc / varray.h

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

   This file is part of GCC.

   GCC 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.

   GCC 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 GCC; 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 GCC_VARRAY_H
#define GCC_VARRAY_H

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

#ifndef GCC_SYSTEM_H
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#endif

/* Enum indicating what the varray contains.
   If this is changed, `element' in varray.c needs to be updated.  */

enum varray_data_enum {
  VARRAY_DATA_C,
  VARRAY_DATA_UC,
  VARRAY_DATA_S,
  VARRAY_DATA_US,
  VARRAY_DATA_I,
  VARRAY_DATA_U,
  VARRAY_DATA_L,
  VARRAY_DATA_UL,
  VARRAY_DATA_HINT,
  VARRAY_DATA_UHINT,
  VARRAY_DATA_GENERIC,
  VARRAY_DATA_GENERIC_NOGC,
  VARRAY_DATA_CPTR,
  VARRAY_DATA_RTX,
  VARRAY_DATA_RTVEC,
  VARRAY_DATA_TREE,
  VARRAY_DATA_BITMAP,
  VARRAY_DATA_REG,
  VARRAY_DATA_BB,
  VARRAY_DATA_TE,
  VARRAY_DATA_EDGE,
  VARRAY_DATA_TREE_PTR,
  NUM_VARRAY_DATA
};

/* Union of various array types that are used.  */
typedef union varray_data_tag GTY (()) {
  char			  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_C")))		c[1];
  unsigned char		  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_UC")))	uc[1];
  short			  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_S")))		s[1];
  unsigned short	  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_US")))	us[1];
  int			  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_I")))		i[1];
  unsigned int		  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_U")))		u[1];
  long			  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_L")))		l[1];
  unsigned long		  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_UL")))	ul[1];
  HOST_WIDE_INT		  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_HINT")))	hint[1];
  unsigned HOST_WIDE_INT  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_UHINT")))	uhint[1];
  PTR			  GTY ((length ("%0.num_elements"), use_param,
				tag ("VARRAY_DATA_GENERIC")))	generic[1];
  PTR			  GTY ((length ("%0.num_elements"), skip (""),
				tag ("VARRAY_DATA_GENERIC_NOGC")))	generic_nogc[1];
  char			 *GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_CPTR")))	cptr[1];
  rtx			  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_RTX")))	rtx[1];
  rtvec			  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_RTVEC")))	rtvec[1];
  tree			  GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_TREE")))	tree[1];
  struct bitmap_head_def *GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_BITMAP")))	bitmap[1];
  struct reg_info_def	 *GTY ((length ("%0.num_elements"), skip,
				tag ("VARRAY_DATA_REG")))	reg[1];
  struct basic_block_def *GTY ((length ("%0.num_elements"), skip,
				tag ("VARRAY_DATA_BB")))	bb[1];
  struct elt_list	 *GTY ((length ("%0.num_elements"),
				tag ("VARRAY_DATA_TE")))	te[1];
  struct edge_def        *GTY ((length ("%0.num_elements"),
	                        tag ("VARRAY_DATA_EDGE")))	e[1];
  tree                   *GTY ((length ("%0.num_elements"), skip (""),
	                        tag ("VARRAY_DATA_TREE_PTR")))	tp[1];
} varray_data;

/* Virtual array of pointers header.  */
struct varray_head_tag GTY(()) {
  size_t	num_elements;	/* Maximum element number allocated.  */
  size_t        elements_used;  /* The number of elements used, if
				   using VARRAY_PUSH/VARRAY_POP.  */
  enum varray_data_enum type;	/* The kind of elements in the varray.  */
  const char   *name;		/* name of the varray for reporting errors */
  varray_data	GTY ((desc ("%0.type"))) data;	/* The data elements follow,
						   must be last.  */
};
typedef struct varray_head_tag *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 (size_t, enum varray_data_enum, const char *);

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

#define VARRAY_UCHAR_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_UC, name)

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

#define VARRAY_USHORT_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_US, name)

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

#define VARRAY_UINT_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_U, name)

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

#define VARRAY_ULONG_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_UL, name)

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

#define VARRAY_UWIDE_INT_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_UHINT, name)

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

#define VARRAY_GENERIC_PTR_NOGC_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_GENERIC_NOGC, name)

#define VARRAY_CHAR_PTR_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_CPTR, name)

#define VARRAY_RTX_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_RTX, name)

#define VARRAY_RTVEC_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_RTVEC, name)

#define VARRAY_TREE_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_TREE, name)

#define VARRAY_BITMAP_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_BITMAP, name)

#define VARRAY_REG_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_REG, name)

#define VARRAY_BB_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_BB, name)

#define VARRAY_ELT_LIST_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_TE, name)

#define VARRAY_EDGE_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_EDGE, name)

#define VARRAY_TREE_PTR_INIT(va, num, name) \
  va = varray_init (num, VARRAY_DATA_TREE_PTR, 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 (varray_type, size_t);

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

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

#define VARRAY_ACTIVE_SIZE(VA)	((VA)->elements_used)
#define VARRAY_POP_ALL(VA)	((VA)->elements_used = 0)

#define VARRAY_CLEAR(VA) varray_clear(VA)

extern void varray_clear (varray_type);
extern void dump_varray_statistics (void);

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

#define VARRAY_POP(VA) do {					\
  varray_type const _va = (VA);					\
  if (_va->elements_used == 0)					\
    varray_underflow (_va, __FILE__, __LINE__, __FUNCTION__);	\
  else								\
    _va->elements_used--;					\
} while (0)

#else
#define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
/* Pop the top element of VA.  */
#define VARRAY_POP(VA) do { ((VA)->elements_used--); } while (0)
#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)

#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_GENERIC_PTR_NOGC(VA,N)	VARRAY_CHECK (VA, N, generic_nogc)
#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_REG(VA, N)		VARRAY_CHECK (VA, N, reg)
#define VARRAY_BB(VA, N)		VARRAY_CHECK (VA, N, bb)
#define VARRAY_ELT_LIST(VA, N)		VARRAY_CHECK (VA, N, te)
#define VARRAY_EDGE(VA, N)		VARRAY_CHECK (VA, N, e)
#define VARRAY_TREE_PTR(VA, N)		VARRAY_CHECK (VA, N, tp)

/* 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, X)	VARRAY_PUSH (VA, generic, X)
#define VARRAY_PUSH_GENERIC_PTR_NOGC(VA, X)	VARRAY_PUSH (VA, generic_nogc, X)
#define VARRAY_PUSH_CHAR_PTR(VA, X)	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_REG(VA, X)		VARRAY_PUSH (VA, reg, X)
#define VARRAY_PUSH_BB(VA, X)		VARRAY_PUSH (VA, bb, X)
#define VARRAY_PUSH_EDGE(VA, X)		VARRAY_PUSH (VA, e, X)
#define VARRAY_PUSH_TREE_PTR(VA, X)	VARRAY_PUSH (VA, tp, X)

/* Return the last element of VA.  */
#define VARRAY_TOP(VA, T) VARRAY_CHECK(VA, (VA)->elements_used - 1, T)

#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)	VARRAY_TOP (VA, generic)
#define VARRAY_TOP_GENERIC_PTR_NOGC(VA)	VARRAY_TOP (VA, generic_nogc)
#define VARRAY_TOP_CHAR_PTR(VA)		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_REG(VA)		VARRAY_TOP (VA, reg)
#define VARRAY_TOP_BB(VA)		VARRAY_TOP (VA, bb)
#define VARRAY_TOP_EDGE(VA)		VARRAY_TOP (VA, e)
#define VARRAY_TOP_TREE_PTR(VA)		VARRAY_TOP (VA, tp)

#endif /* ! GCC_VARRAY_H */
Commit	Line	Data
848205e6	1	/* Virtual array support.
d9221e01	2	Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004
2e1eedd6	3	Free Software Foundation, Inc.
848205e6 MM	4	Contributed by Cygnus Solutions.
848205e6 MM	5
1322177d	6	This file is part of GCC.
848205e6	7
1322177d	8	GCC is free software; you can redistribute it and/or modify it
848205e6 MM	9	under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2, or (at your option)
	11	any later version.
	12
1322177d LB	13	GCC is distributed in the hope that it will be useful, but WITHOUT
	14	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
	15	or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
	16	License for more details.
848205e6 MM	17
848205e6 MM	18	You should have received a copy of the GNU General Public License
1322177d LB	19	along with GCC; see the file COPYING. If not, write to the Free
	20	the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
	21	MA 02111-1307, USA. */
848205e6	22
88657302 RH	23	#ifndef GCC_VARRAY_H
88657302 RH	24	#define GCC_VARRAY_H
848205e6	25
848205e6 MM	26	#ifndef HOST_WIDE_INT
	27	#include "machmode.h"
	28	#endif
	29
88657302	30	#ifndef GCC_SYSTEM_H
4dfb04c6	31	#include "system.h"
4977bab6 ZW	32	#include "coretypes.h"
4977bab6 ZW	33	#include "tm.h"
4dfb04c6 MM	34	#endif
4dfb04c6 MM	35
2e1eedd6	36	/* Enum indicating what the varray contains.
19a7414e	37	If this is changed, `element' in varray.c needs to be updated. */
e2500fed GK	38
	39	enum varray_data_enum {
	40	VARRAY_DATA_C,
	41	VARRAY_DATA_UC,
	42	VARRAY_DATA_S,
	43	VARRAY_DATA_US,
	44	VARRAY_DATA_I,
	45	VARRAY_DATA_U,
	46	VARRAY_DATA_L,
	47	VARRAY_DATA_UL,
	48	VARRAY_DATA_HINT,
	49	VARRAY_DATA_UHINT,
	50	VARRAY_DATA_GENERIC,
6de9cd9a	51	VARRAY_DATA_GENERIC_NOGC,
e2500fed GK	52	VARRAY_DATA_CPTR,
	53	VARRAY_DATA_RTX,
	54	VARRAY_DATA_RTVEC,
	55	VARRAY_DATA_TREE,
	56	VARRAY_DATA_BITMAP,
	57	VARRAY_DATA_REG,
e2500fed GK	58	VARRAY_DATA_BB,
e2500fed GK	59	VARRAY_DATA_TE,
6de9cd9a DN	60	VARRAY_DATA_EDGE,
6de9cd9a DN	61	VARRAY_DATA_TREE_PTR,
e2500fed GK	62	NUM_VARRAY_DATA
	63	};
	64
848205e6	65	/* Union of various array types that are used. */
e2500fed GK	66	typedef union varray_data_tag GTY (()) {
	67	char GTY ((length ("%0.num_elements"),
	68	tag ("VARRAY_DATA_C"))) c[1];
	69	unsigned char GTY ((length ("%0.num_elements"),
	70	tag ("VARRAY_DATA_UC"))) uc[1];
	71	short GTY ((length ("%0.num_elements"),
	72	tag ("VARRAY_DATA_S"))) s[1];
	73	unsigned short GTY ((length ("%0.num_elements"),
	74	tag ("VARRAY_DATA_US"))) us[1];
	75	int GTY ((length ("%0.num_elements"),
	76	tag ("VARRAY_DATA_I"))) i[1];
	77	unsigned int GTY ((length ("%0.num_elements"),
	78	tag ("VARRAY_DATA_U"))) u[1];
	79	long GTY ((length ("%0.num_elements"),
	80	tag ("VARRAY_DATA_L"))) l[1];
	81	unsigned long GTY ((length ("%0.num_elements"),
	82	tag ("VARRAY_DATA_UL"))) ul[1];
	83	HOST_WIDE_INT GTY ((length ("%0.num_elements"),
	84	tag ("VARRAY_DATA_HINT"))) hint[1];
	85	unsigned HOST_WIDE_INT GTY ((length ("%0.num_elements"),
	86	tag ("VARRAY_DATA_UHINT"))) uhint[1];
1431042e	87	PTR GTY ((length ("%0.num_elements"), use_param,
e2500fed	88	tag ("VARRAY_DATA_GENERIC"))) generic[1];
6de9cd9a DN	89	PTR GTY ((length ("%0.num_elements"), skip (""),
6de9cd9a DN	90	tag ("VARRAY_DATA_GENERIC_NOGC"))) generic_nogc[1];
e2500fed GK	91	char *GTY ((length ("%0.num_elements"),
e2500fed GK	92	tag ("VARRAY_DATA_CPTR"))) cptr[1];
bcda12f4	93	rtx GTY ((length ("%0.num_elements"),
e2500fed	94	tag ("VARRAY_DATA_RTX"))) rtx[1];
bcda12f4	95	rtvec GTY ((length ("%0.num_elements"),
e2500fed	96	tag ("VARRAY_DATA_RTVEC"))) rtvec[1];
bcda12f4	97	tree GTY ((length ("%0.num_elements"),
e2500fed GK	98	tag ("VARRAY_DATA_TREE"))) tree[1];
	99	struct bitmap_head_def *GTY ((length ("%0.num_elements"),
	100	tag ("VARRAY_DATA_BITMAP"))) bitmap[1];
1431042e	101	struct reg_info_def *GTY ((length ("%0.num_elements"), skip,
e2500fed	102	tag ("VARRAY_DATA_REG"))) reg[1];
1431042e	103	struct basic_block_def *GTY ((length ("%0.num_elements"), skip,
e2500fed GK	104	tag ("VARRAY_DATA_BB"))) bb[1];
	105	struct elt_list *GTY ((length ("%0.num_elements"),
	106	tag ("VARRAY_DATA_TE"))) te[1];
6de9cd9a DN	107	struct edge_def *GTY ((length ("%0.num_elements"),
	108	tag ("VARRAY_DATA_EDGE"))) e[1];
	109	tree *GTY ((length ("%0.num_elements"), skip (""),
	110	tag ("VARRAY_DATA_TREE_PTR"))) tp[1];
848205e6 MM	111	} varray_data;
	112
	113	/* Virtual array of pointers header. */
e2500fed GK	114	struct varray_head_tag GTY(()) {
	115	size_t num_elements; /* Maximum element number allocated. */
	116	size_t elements_used; /* The number of elements used, if
a6873608	117	using VARRAY_PUSH/VARRAY_POP. */
e2500fed	118	enum varray_data_enum type; /* The kind of elements in the varray. */
848205e6	119	const char name; / name of the varray for reporting errors */
2e1eedd6	120	varray_data GTY ((desc ("%0.type"))) data; /* The data elements follow,
e2500fed GK	121	must be last. */
	122	};
	123	typedef struct varray_head_tag *varray_type;
848205e6 MM	124
	125	/* Allocate a virtual array with NUM elements, each of which is SIZE bytes
	126	long, named NAME. Array elements are zeroed. */
2e1eedd6	127	extern varray_type varray_init (size_t, enum varray_data_enum, const char *);
848205e6 MM	128
848205e6 MM	129	#define VARRAY_CHAR_INIT(va, num, name) \
e2500fed	130	va = varray_init (num, VARRAY_DATA_C, name)
848205e6 MM	131
848205e6 MM	132	#define VARRAY_UCHAR_INIT(va, num, name) \
e2500fed	133	va = varray_init (num, VARRAY_DATA_UC, name)
848205e6 MM	134
848205e6 MM	135	#define VARRAY_SHORT_INIT(va, num, name) \
e2500fed	136	va = varray_init (num, VARRAY_DATA_S, name)
848205e6 MM	137
848205e6 MM	138	#define VARRAY_USHORT_INIT(va, num, name) \
e2500fed	139	va = varray_init (num, VARRAY_DATA_US, name)
848205e6 MM	140
848205e6 MM	141	#define VARRAY_INT_INIT(va, num, name) \
e2500fed	142	va = varray_init (num, VARRAY_DATA_I, name)
848205e6 MM	143
848205e6 MM	144	#define VARRAY_UINT_INIT(va, num, name) \
e2500fed	145	va = varray_init (num, VARRAY_DATA_U, name)
848205e6 MM	146
848205e6 MM	147	#define VARRAY_LONG_INIT(va, num, name) \
e2500fed	148	va = varray_init (num, VARRAY_DATA_L, name)
848205e6 MM	149
848205e6 MM	150	#define VARRAY_ULONG_INIT(va, num, name) \
e2500fed	151	va = varray_init (num, VARRAY_DATA_UL, name)
848205e6 MM	152
848205e6 MM	153	#define VARRAY_WIDE_INT_INIT(va, num, name) \
e2500fed	154	va = varray_init (num, VARRAY_DATA_HINT, name)
848205e6 MM	155
848205e6 MM	156	#define VARRAY_UWIDE_INT_INIT(va, num, name) \
e2500fed	157	va = varray_init (num, VARRAY_DATA_UHINT, name)
848205e6 MM	158
848205e6 MM	159	#define VARRAY_GENERIC_PTR_INIT(va, num, name) \
e2500fed	160	va = varray_init (num, VARRAY_DATA_GENERIC, name)
848205e6	161
6de9cd9a DN	162	#define VARRAY_GENERIC_PTR_NOGC_INIT(va, num, name) \
	163	va = varray_init (num, VARRAY_DATA_GENERIC_NOGC, name)
	164
848205e6	165	#define VARRAY_CHAR_PTR_INIT(va, num, name) \
e2500fed	166	va = varray_init (num, VARRAY_DATA_CPTR, name)
848205e6 MM	167
848205e6 MM	168	#define VARRAY_RTX_INIT(va, num, name) \
e2500fed	169	va = varray_init (num, VARRAY_DATA_RTX, name)
848205e6 MM	170
848205e6 MM	171	#define VARRAY_RTVEC_INIT(va, num, name) \
e2500fed	172	va = varray_init (num, VARRAY_DATA_RTVEC, name)
848205e6 MM	173
848205e6 MM	174	#define VARRAY_TREE_INIT(va, num, name) \
e2500fed	175	va = varray_init (num, VARRAY_DATA_TREE, name)
848205e6 MM	176
848205e6 MM	177	#define VARRAY_BITMAP_INIT(va, num, name) \
e2500fed	178	va = varray_init (num, VARRAY_DATA_BITMAP, name)
848205e6 MM	179
848205e6 MM	180	#define VARRAY_REG_INIT(va, num, name) \
e2500fed	181	va = varray_init (num, VARRAY_DATA_REG, name)
848205e6	182
e881bb1b	183	#define VARRAY_BB_INIT(va, num, name) \
e2500fed	184	va = varray_init (num, VARRAY_DATA_BB, name)
e881bb1b	185
eab5c70a	186	#define VARRAY_ELT_LIST_INIT(va, num, name) \
e2500fed	187	va = varray_init (num, VARRAY_DATA_TE, name)
eab5c70a	188
6de9cd9a DN	189	#define VARRAY_EDGE_INIT(va, num, name) \
	190	va = varray_init (num, VARRAY_DATA_EDGE, name)
	191
	192	#define VARRAY_TREE_PTR_INIT(va, num, name) \
	193	va = varray_init (num, VARRAY_DATA_TREE_PTR, name)
	194
848205e6 MM	195	/* Free up memory allocated by the virtual array, but do not free any of the
848205e6 MM	196	elements involved. */
804a4e13	197	#define VARRAY_FREE(vp) \
e9d1b155	198	do { if (vp) { free (vp); vp = (varray_type) 0; } } while (0)
848205e6 MM	199
848205e6 MM	200	/* Grow/shrink the virtual array VA to N elements. */
2e1eedd6	201	extern varray_type varray_grow (varray_type, size_t);
848205e6 MM	202
	203	#define VARRAY_GROW(VA, N) ((VA) = varray_grow (VA, N))
	204
c68da89c KR	205	#define VARRAY_SIZE(VA) ((VA)->num_elements)
c68da89c KR	206
4c85a96d RH	207	#define VARRAY_ACTIVE_SIZE(VA) ((VA)->elements_used)
	208	#define VARRAY_POP_ALL(VA) ((VA)->elements_used = 0)
	209
e2500fed GK	210	#define VARRAY_CLEAR(VA) varray_clear(VA)
e2500fed GK	211
2e1eedd6	212	extern void varray_clear (varray_type);
9b57b627 JH	213	extern void dump_varray_statistics (void);
9b57b627 JH	214
987009bf	215	/* Check for VARRAY_xxx macros being in bound. */
6c9821b7	216	#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
2e1eedd6 AJ	217	extern void varray_check_failed (varray_type, size_t, const char *, int,
2e1eedd6 AJ	218	const char *) ATTRIBUTE_NORETURN;
12a08b40 ZW	219	extern void varray_underflow (varray_type, const char , int, const char )
12a08b40 ZW	220	ATTRIBUTE_NORETURN;
8784fdcd	221	#define VARRAY_CHECK(VA, N, T) __extension__ \
d8750784	222	(*({ varray_type const _va = (VA); \
2e1eedd6	223	const size_t _n = (N); \
987009bf	224	if (_n >= _va->num_elements) \
fbfc1192	225	varray_check_failed (_va, _n, __FILE__, __LINE__, __FUNCTION__); \
987009bf	226	&_va->data.T[_n]; }))
12a08b40 ZW	227
	228	#define VARRAY_POP(VA) do { \
	229	varray_type const _va = (VA); \
	230	if (_va->elements_used == 0) \
	231	varray_underflow (_va, __FILE__, __LINE__, __FUNCTION__); \
	232	else \
	233	_va->elements_used--; \
	234	} while (0)
	235
848205e6	236	#else
987009bf	237	#define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
12a08b40 ZW	238	/* Pop the top element of VA. */
12a08b40 ZW	239	#define VARRAY_POP(VA) do { ((VA)->elements_used--); } while (0)
848205e6 MM	240	#endif
848205e6 MM	241
a6873608 MM	242	/* Push X onto VA. T is the name of the field in varray_data
a6873608 MM	243	corresponding to the type of X. */
41077ce4 KH	244	#define VARRAY_PUSH(VA, T, X) \
41077ce4 KH	245	do \
a6873608 MM	246	{ \
	247	if ((VA)->elements_used >= (VA)->num_elements) \
	248	VARRAY_GROW ((VA), 2 * (VA)->num_elements); \
	249	(VA)->data.T[(VA)->elements_used++] = (X); \
	250	} \
	251	while (0)
	252
987009bf ZW	253	#define VARRAY_CHAR(VA, N) VARRAY_CHECK (VA, N, c)
	254	#define VARRAY_UCHAR(VA, N) VARRAY_CHECK (VA, N, uc)
	255	#define VARRAY_SHORT(VA, N) VARRAY_CHECK (VA, N, s)
	256	#define VARRAY_USHORT(VA, N) VARRAY_CHECK (VA, N, us)
	257	#define VARRAY_INT(VA, N) VARRAY_CHECK (VA, N, i)
	258	#define VARRAY_UINT(VA, N) VARRAY_CHECK (VA, N, u)
	259	#define VARRAY_LONG(VA, N) VARRAY_CHECK (VA, N, l)
	260	#define VARRAY_ULONG(VA, N) VARRAY_CHECK (VA, N, ul)
	261	#define VARRAY_WIDE_INT(VA, N) VARRAY_CHECK (VA, N, hint)
	262	#define VARRAY_UWIDE_INT(VA, N) VARRAY_CHECK (VA, N, uhint)
	263	#define VARRAY_GENERIC_PTR(VA,N) VARRAY_CHECK (VA, N, generic)
6de9cd9a	264	#define VARRAY_GENERIC_PTR_NOGC(VA,N) VARRAY_CHECK (VA, N, generic_nogc)
987009bf ZW	265	#define VARRAY_CHAR_PTR(VA,N) VARRAY_CHECK (VA, N, cptr)
	266	#define VARRAY_RTX(VA, N) VARRAY_CHECK (VA, N, rtx)
	267	#define VARRAY_RTVEC(VA, N) VARRAY_CHECK (VA, N, rtvec)
	268	#define VARRAY_TREE(VA, N) VARRAY_CHECK (VA, N, tree)
	269	#define VARRAY_BITMAP(VA, N) VARRAY_CHECK (VA, N, bitmap)
987009bf	270	#define VARRAY_REG(VA, N) VARRAY_CHECK (VA, N, reg)
987009bf	271	#define VARRAY_BB(VA, N) VARRAY_CHECK (VA, N, bb)
eab5c70a	272	#define VARRAY_ELT_LIST(VA, N) VARRAY_CHECK (VA, N, te)
6de9cd9a DN	273	#define VARRAY_EDGE(VA, N) VARRAY_CHECK (VA, N, e)
6de9cd9a DN	274	#define VARRAY_TREE_PTR(VA, N) VARRAY_CHECK (VA, N, tp)
848205e6	275
a6873608 MM	276	/* Push a new element on the end of VA, extending it if necessary. */
	277	#define VARRAY_PUSH_CHAR(VA, X) VARRAY_PUSH (VA, c, X)
	278	#define VARRAY_PUSH_UCHAR(VA, X) VARRAY_PUSH (VA, uc, X)
	279	#define VARRAY_PUSH_SHORT(VA, X) VARRAY_PUSH (VA, s, X)
	280	#define VARRAY_PUSH_USHORT(VA, X) VARRAY_PUSH (VA, us, X)
	281	#define VARRAY_PUSH_INT(VA, X) VARRAY_PUSH (VA, i, X)
	282	#define VARRAY_PUSH_UINT(VA, X) VARRAY_PUSH (VA, u, X)
	283	#define VARRAY_PUSH_LONG(VA, X) VARRAY_PUSH (VA, l, X)
	284	#define VARRAY_PUSH_ULONG(VA, X) VARRAY_PUSH (VA, ul, X)
	285	#define VARRAY_PUSH_WIDE_INT(VA, X) VARRAY_PUSH (VA, hint, X)
	286	#define VARRAY_PUSH_UWIDE_INT(VA, X) VARRAY_PUSH (VA, uhint, X)
ee418a77	287	#define VARRAY_PUSH_GENERIC_PTR(VA, X) VARRAY_PUSH (VA, generic, X)
6de9cd9a	288	#define VARRAY_PUSH_GENERIC_PTR_NOGC(VA, X) VARRAY_PUSH (VA, generic_nogc, X)
ee418a77	289	#define VARRAY_PUSH_CHAR_PTR(VA, X) VARRAY_PUSH (VA, cptr, X)
a6873608 MM	290	#define VARRAY_PUSH_RTX(VA, X) VARRAY_PUSH (VA, rtx, X)
	291	#define VARRAY_PUSH_RTVEC(VA, X) VARRAY_PUSH (VA, rtvec, X)
	292	#define VARRAY_PUSH_TREE(VA, X) VARRAY_PUSH (VA, tree, X)
	293	#define VARRAY_PUSH_BITMAP(VA, X) VARRAY_PUSH (VA, bitmap, X)
a6873608	294	#define VARRAY_PUSH_REG(VA, X) VARRAY_PUSH (VA, reg, X)
a6873608	295	#define VARRAY_PUSH_BB(VA, X) VARRAY_PUSH (VA, bb, X)
6de9cd9a DN	296	#define VARRAY_PUSH_EDGE(VA, X) VARRAY_PUSH (VA, e, X)
6de9cd9a DN	297	#define VARRAY_PUSH_TREE_PTR(VA, X) VARRAY_PUSH (VA, tp, X)
a6873608 MM	298
a6873608 MM	299	/* Return the last element of VA. */
12a08b40 ZW	300	#define VARRAY_TOP(VA, T) VARRAY_CHECK(VA, (VA)->elements_used - 1, T)
12a08b40 ZW	301
a6873608 MM	302	#define VARRAY_TOP_CHAR(VA) VARRAY_TOP (VA, c)
	303	#define VARRAY_TOP_UCHAR(VA) VARRAY_TOP (VA, uc)
	304	#define VARRAY_TOP_SHORT(VA) VARRAY_TOP (VA, s)
	305	#define VARRAY_TOP_USHORT(VA) VARRAY_TOP (VA, us)
	306	#define VARRAY_TOP_INT(VA) VARRAY_TOP (VA, i)
	307	#define VARRAY_TOP_UINT(VA) VARRAY_TOP (VA, u)
	308	#define VARRAY_TOP_LONG(VA) VARRAY_TOP (VA, l)
	309	#define VARRAY_TOP_ULONG(VA) VARRAY_TOP (VA, ul)
	310	#define VARRAY_TOP_WIDE_INT(VA) VARRAY_TOP (VA, hint)
	311	#define VARRAY_TOP_UWIDE_INT(VA) VARRAY_TOP (VA, uhint)
0cf97c8b	312	#define VARRAY_TOP_GENERIC_PTR(VA) VARRAY_TOP (VA, generic)
6de9cd9a	313	#define VARRAY_TOP_GENERIC_PTR_NOGC(VA) VARRAY_TOP (VA, generic_nogc)
0cf97c8b	314	#define VARRAY_TOP_CHAR_PTR(VA) VARRAY_TOP (VA, cptr)
a6873608 MM	315	#define VARRAY_TOP_RTX(VA) VARRAY_TOP (VA, rtx)
	316	#define VARRAY_TOP_RTVEC(VA) VARRAY_TOP (VA, rtvec)
	317	#define VARRAY_TOP_TREE(VA) VARRAY_TOP (VA, tree)
	318	#define VARRAY_TOP_BITMAP(VA) VARRAY_TOP (VA, bitmap)
a6873608	319	#define VARRAY_TOP_REG(VA) VARRAY_TOP (VA, reg)
a6873608	320	#define VARRAY_TOP_BB(VA) VARRAY_TOP (VA, bb)
6de9cd9a DN	321	#define VARRAY_TOP_EDGE(VA) VARRAY_TOP (VA, e)
6de9cd9a DN	322	#define VARRAY_TOP_TREE_PTR(VA) VARRAY_TOP (VA, tp)
a6873608	323
88657302	324	#endif /* ! GCC_VARRAY_H */