/* Virtual array support.
- Copyright (C) 1998, 1999, 2000, 2002, 2003
+ Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004
Free Software Foundation, Inc.
Contributed by Cygnus Solutions.
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. */
+ the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
+ MA 02110-1301, USA. */
#ifndef GCC_VARRAY_H
#define GCC_VARRAY_H
#include "tm.h"
#endif
-/* Auxiliary structure used inside the varray structure, used for
- function integration data. */
-
-struct const_equiv_data GTY(()) {
- /* 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. */
- rtx rtx;
-
- /* Record the valid age for each entry. The entry is invalid if its
- age is less than const_age. */
- unsigned age;
-};
-
/* Enum indicating what the varray contains.
If this is changed, `element' in varray.c needs to be updated. */
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_CONST_EQUIV,
VARRAY_DATA_BB,
VARRAY_DATA_TE,
+ VARRAY_DATA_EDGE,
+ VARRAY_DATA_TREE_PTR,
NUM_VARRAY_DATA
};
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 (""),
+ 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_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 (""),
+ struct reg_info_def *GTY ((length ("%0.num_elements"), skip,
tag ("VARRAY_DATA_REG"))) reg[1];
- struct const_equiv_data GTY ((length ("%0.num_elements"),
- tag ("VARRAY_DATA_CONST_EQUIV"))) const_equiv[1];
- struct basic_block_def *GTY ((length ("%0.num_elements"), skip (""),
+ 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. */
#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_REG_INIT(va, num, name) \
va = varray_init (num, VARRAY_DATA_REG, name)
-#define VARRAY_CONST_EQUIV_INIT(va, num, name) \
- va = varray_init (num, VARRAY_DATA_CONST_EQUIV, 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) \
#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. */
#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_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)
+#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_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_CONST_EQUIV(VA, X) VARRAY_PUSH (VA, const_equiv, 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_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_CONST_EQUIV(VA) VARRAY_TOP (VA, const_equiv)
#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 */