Enlist the FreeBSD-CURRENT users as testers of what is to become Gcc 3.1.0.

These bits are taken from the FSF anoncvs repo on 1-Feb-2002 08:20 PST.

1 files changed, 126 insertions, 51 deletions

diff --git a/contrib/gcc/varray.h b/contrib/gcc/varray.h
index 7d4f697..66c4d39 100644
--- a/contrib/gcc/varray.h
+++ b/contrib/gcc/varray.h
@@ -1,32 +1,32 @@
 /* Virtual array support.
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2002 Free Software Foundation, Inc.
    Contributed by Cygnus Solutions.
 
-   This file is part of GNU CC.
+   This file is part of GCC.
 
-   GNU CC is free software; you can redistribute it and/or modify it
+   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.
 
-   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.
+   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 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.  */
+   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 _VARRAY_H_
-#define _VARRAY_H_
+#ifndef GCC_VARRAY_H
+#define GCC_VARRAY_H
 
 #ifndef HOST_WIDE_INT
 #include "machmode.h"
 #endif
 
-#ifndef __GCC_SYSTEM_H__
+#ifndef GCC_SYSTEM_H
 #include "system.h"
 #endif
 
@@ -47,7 +47,7 @@ struct const_equiv_data {
      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.  */
-  rtx rtx;
+  struct rtx_def *rtx;
 
   /* Record the valid age for each entry.  The entry is invalid if its
      age is less than const_age.  */
@@ -66,7 +66,7 @@ typedef union varray_data_tag {
   unsigned long		 ul[1];
   HOST_WIDE_INT		 hint[1];
   unsigned HOST_WIDE_INT uhint[1];
-  GENERIC_PTR		 generic[1];
+  PTR			 generic[1];
   char			 *cptr[1];
   struct rtx_def	 *rtx[1];
   struct rtvec_def	 *rtvec[1];
@@ -76,11 +76,14 @@ typedef union varray_data_tag {
   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 */
@@ -88,7 +91,7 @@ typedef struct varray_head_tag {
 
 /* 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	PROTO ((size_t, size_t, const char *));
+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)
@@ -121,7 +124,7 @@ extern varray_type varray_init	PROTO ((size_t, size_t, const char *));
   va = varray_init (num, sizeof (unsigned HOST_WIDE_INT), name)
 
 #define VARRAY_GENERIC_PTR_INIT(va, num, name) \
-  va = varray_init (num, sizeof (GENERIC_PTR), name)
+  va = varray_init (num, sizeof (PTR), name)
 
 #define VARRAY_CHAR_PTR_INIT(va, num, name) \
   va = varray_init (num, sizeof (char *), name)
@@ -150,50 +153,122 @@ extern varray_type varray_init	PROTO ((size_t, size_t, const char *));
 #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)
+  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	PROTO((varray_type, size_t));
+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, return N for use as an
-   index.  */
-#ifdef ENABLE_CHECKING
-#define VARRAY_CHECK(VA, N)						\
-((((size_t)(N) < (VA)->num_elements)					\
-  ? 0									\
-  : (fatal ("Virtual array %s element %ld out of bounds, at %s:%d",	\
-	    (VA)->name, (long)(N), __FILE__, __LINE__), 0)),		\
- (N))
+#define VARRAY_ACTIVE_SIZE(VA)	((VA)->elements_used)
+#define VARRAY_POP_ALL(VA)	((VA)->elements_used = 0)
+
+/* 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) __extension__			\
+(*({ varray_type _va = VA;					\
+     size_t _n = N; 						\
+     if (_n >= _va->num_elements)				\
+       varray_check_failed (_va, _n, __FILE__, __LINE__, __FUNCTION__);	\
+     &_va->data.T[_n]; }))
 #else
-#define VARRAY_CHECK(VA, N) (N)
+#define VARRAY_CHECK(VA, N, T) ((VA)->data.T[N])
 #endif
 
-#define VARRAY_CHAR(VA, N)	((VA)->data.c[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_UCHAR(VA, N)	((VA)->data.uc[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_SHORT(VA, N)	((VA)->data.s[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_USHORT(VA, N)	((VA)->data.us[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_INT(VA, N)	((VA)->data.i[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_UINT(VA, N)	((VA)->data.u[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_LONG(VA, N)	((VA)->data.l[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_ULONG(VA, N)	((VA)->data.ul[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_WIDE_INT(VA, N)	((VA)->data.hint[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_UWIDE_INT(VA, N)	((VA)->data.uhint[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_GENERIC_PTR(VA,N) ((VA)->data.generic[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_CHAR_PTR(VA,N)	((VA)->data.cptr[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_RTX(VA, N)	((VA)->data.rtx[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_RTVEC(VA, N)	((VA)->data.rtvec[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_TREE(VA, N)	((VA)->data.tree[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_BITMAP(VA, N)	((VA)->data.bitmap[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_SCHED(VA, N)	((VA)->data.sched[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_REG(VA, N)	((VA)->data.reg[ VARRAY_CHECK (VA, N) ])
-#define VARRAY_CONST_EQUIV(VA, N) ((VA)->data.const_equiv[VARRAY_CHECK (VA, N)])
-#define VARRAY_BB(VA, N)	((VA)->data.bb[ VARRAY_CHECK (VA, N) ])
-
-#endif /* _VARRAY_H_ */
+/* 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, X)	VARRAY_PUSH (VA, generic, 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_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)	VARRAY_TOP (VA, generic)
+#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_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 /* ! GCC_VARRAY_H */