diff options
author | obrien <obrien@FreeBSD.org> | 2002-02-01 18:16:02 +0000 |
---|---|---|
committer | obrien <obrien@FreeBSD.org> | 2002-02-01 18:16:02 +0000 |
commit | c9ab9ae440a8066b2c2b85b157b1fdadcf09916a (patch) | |
tree | 086d9d6c8fbd4fc8fe4495059332f66bc0f8d12b /contrib/gcc/varray.h | |
parent | 2ecfd8bd04b63f335c1ec6295740a4bfd97a4fa6 (diff) | |
download | FreeBSD-src-c9ab9ae440a8066b2c2b85b157b1fdadcf09916a.zip FreeBSD-src-c9ab9ae440a8066b2c2b85b157b1fdadcf09916a.tar.gz |
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.
Diffstat (limited to 'contrib/gcc/varray.h')
-rw-r--r-- | contrib/gcc/varray.h | 177 |
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 */ |