This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[tree-ssa] Add VARRAY_TREE_PTR type [patch]
- From: Diego Novillo <dnovillo at redhat dot com>
- To: "gcc-patches at gcc dot gnu dot org" <gcc-patches at gcc dot gnu dot org>
- Date: Sat, 06 Sep 2003 09:25:15 -0400
- Subject: [tree-ssa] Add VARRAY_TREE_PTR type [patch]
- Organization: Red Hat Canada
Cleans up the interface to array operands. Instead of using
VARRAY_GENERIC_PTR, it introduces a new VARRAY_TREE_PTR, which avoids
all the typecasting needed when accessing statement operands.
The one thing I haven't been able to do is avoid using 'skip' to mark
the new 'tree *'. gengtype complains that it doesn't know anything
about type 'tree *'.
Bootstrapped and tested x86, amd64 and ia64.
Diego.
* varray.c (element): Add entry for 'tree *'.
* varray.h (enum varray_data_enum): Add VARRAY_DATA_TREE_PTR.
(union varray_data_tag): Add entry for 'tree *'.
(VARRAY_TREE_PTR_INIT): Define.
(VARRAY_TREE_PTR): Define.
(VARRAY_PUSH_TREE_PTR): Define.
(VARRAY_TOP_TREE_PTR): Define.
* tree-cfg.c: Replace uses of VARRAY_GENERIC_PTR with
VARRAY_TREE_PTR when accessing operand arrays.
* tree-ssa-ccp.c: Likewise.
* tree-ssa-copyprop.c: Likewise.
* tree-ssa-dce.c: Likewise.
* tree-ssa-dom.c: Likewise.
* tree-ssa-live.c: Likewise.
* tree-ssa-pre.c: Likewise.
* tree-dfa.c: Likewise.
* tree-ssa.c: Likewise.
* tree-flow.h (struct operands_d): Remove 'skip' GC markers from
all fields.
(struct dataflow_d): Likewise.
Index: tree-cfg.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-cfg.c,v
retrieving revision 1.1.4.157
diff -d -c -p -d -u -p -r1.1.4.157 tree-cfg.c
--- tree-cfg.c 4 Sep 2003 13:52:34 -0000 1.1.4.157
+++ tree-cfg.c 6 Sep 2003 13:16:12 -0000
@@ -2110,7 +2110,7 @@ remove_stmt (tree *stmt_p, bool remove_a
defs = def_ops (stmt);
for (i = 0; defs && i < VARRAY_ACTIVE_SIZE (defs); i++)
{
- tree *def_p = VARRAY_GENERIC_PTR (defs, i);
+ tree *def_p = VARRAY_TREE_PTR (defs, i);
if (TREE_CODE (*def_p) == SSA_NAME)
SSA_NAME_DEF_STMT (*def_p) = build_empty_stmt ();
}
Index: tree-dfa.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-dfa.c,v
retrieving revision 1.1.4.155
diff -d -c -p -d -u -p -r1.1.4.155 tree-dfa.c
--- tree-dfa.c 5 Sep 2003 23:02:39 -0000 1.1.4.155
+++ tree-dfa.c 6 Sep 2003 13:16:15 -0000
@@ -682,9 +682,9 @@ add_def (tree *def_p, tree stmt)
}
if (ann->ops->def_ops == NULL)
- VARRAY_GENERIC_PTR_INIT (ann->ops->def_ops, 1, "def_ops");
+ VARRAY_TREE_PTR_INIT (ann->ops->def_ops, 1, "def_ops");
- VARRAY_PUSH_GENERIC_PTR (ann->ops->def_ops, def_p);
+ VARRAY_PUSH_TREE_PTR (ann->ops->def_ops, def_p);
}
@@ -710,9 +710,9 @@ add_use (tree *use_p, tree stmt)
}
if (ann->ops->use_ops == NULL)
- VARRAY_GENERIC_PTR_INIT (ann->ops->use_ops, 3, "use_ops");
+ VARRAY_TREE_PTR_INIT (ann->ops->use_ops, 3, "use_ops");
- VARRAY_PUSH_GENERIC_PTR (ann->ops->use_ops, use_p);
+ VARRAY_PUSH_TREE_PTR (ann->ops->use_ops, use_p);
}
@@ -1174,7 +1174,7 @@ compute_immediate_uses_for (tree stmt, i
ops = use_ops (stmt);
for (i = 0; i < VARRAY_ACTIVE_SIZE (ops); i++)
{
- tree *use_p = VARRAY_GENERIC_PTR (ops, i);
+ tree *use_p = VARRAY_TREE_PTR (ops, i);
tree imm_rdef_stmt = SSA_NAME_DEF_STMT (*use_p);
if (!IS_EMPTY_STMT (imm_rdef_stmt))
add_immediate_use (imm_rdef_stmt, stmt);
Index: tree-flow.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-flow.h,v
retrieving revision 1.1.4.108
diff -d -c -p -d -u -p -r1.1.4.108 tree-flow.h
--- tree-flow.h 1 Sep 2003 15:47:14 -0000 1.1.4.108
+++ tree-flow.h 6 Sep 2003 13:16:16 -0000
@@ -135,10 +135,10 @@ struct var_ann_d GTY(())
struct operands_d GTY(())
{
/* LHS of assignment statements. */
- varray_type GTY ((skip (""))) def_ops;
+ varray_type def_ops;
/* Array of pointers to each operand in the statement. */
- varray_type GTY ((skip (""))) use_ops;
+ varray_type use_ops;
};
typedef struct operands_d *operands_t;
@@ -150,7 +150,7 @@ struct voperands_d GTY(())
varray_type vdef_ops;
/* List of VUSE references in this statement. */
- varray_type GTY ((skip (""))) vuse_ops;
+ varray_type vuse_ops;
};
typedef struct voperands_d *voperands_t;
@@ -161,7 +161,7 @@ struct dataflow_d GTY(())
/* Immediate uses. This is a list of all the statements and PHI nodes
that are immediately reached by the definitions made in this
statement. */
- varray_type GTY ((skip (""))) immediate_uses;
+ varray_type immediate_uses;
/* Reached uses. This is a list of all the possible program statements
that may be reached directly or indirectly by definitions made in this
@@ -179,7 +179,7 @@ struct dataflow_d GTY(())
includes statement #5 because 'a1' could reach 'a3' via the PHI node
at statement #4. The set of REACHED_USES is then the transitive
closure over all the PHI nodes in the IMMEDIATE_USES set. */
- varray_type GTY ((skip (""))) reached_uses;
+ varray_type reached_uses;
/* Reaching definitions. Similarly to REACHED_USES, the set
REACHING_DEFS is the set of all the statements that make definitions
@@ -187,7 +187,7 @@ struct dataflow_d GTY(())
similar entry for immediate definitions, as these are represented by
the SSA_NAME nodes themselves (each SSA_NAME node contains a pointer
to the statement that makes that definition). */
- varray_type GTY ((skip (""))) reaching_defs;
+ varray_type reaching_defs;
};
typedef struct dataflow_d *dataflow_t;
Index: tree-ssa-ccp.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-ccp.c,v
retrieving revision 1.1.2.86
diff -d -c -p -d -u -p -r1.1.2.86 tree-ssa-ccp.c
--- tree-ssa-ccp.c 25 Aug 2003 02:44:23 -0000 1.1.2.86
+++ tree-ssa-ccp.c 6 Sep 2003 13:16:18 -0000
@@ -554,7 +554,7 @@ visit_stmt (tree stmt)
ops = def_ops (stmt);
for (i = 0; i < VARRAY_ACTIVE_SIZE (ops); i++)
{
- tree *def_p = VARRAY_GENERIC_PTR (ops, i);
+ tree *def_p = VARRAY_TREE_PTR (ops, i);
def_to_varying (*def_p);
}
}
@@ -827,7 +827,7 @@ ccp_fold (tree stmt)
/* Preserve the original values of every operand. */
orig = xmalloc (sizeof (tree) * VARRAY_ACTIVE_SIZE (uses));
for (i = 0; i < VARRAY_ACTIVE_SIZE (uses); i++)
- orig[i] = *((tree *) VARRAY_GENERIC_PTR (uses, i));
+ orig[i] = *(VARRAY_TREE_PTR (uses, i));
/* Substitute operands with their values and try to fold. */
replace_uses_in (stmt);
@@ -835,7 +835,7 @@ ccp_fold (tree stmt)
/* Restore operands to their original form. */
for (i = 0; i < VARRAY_ACTIVE_SIZE (uses); i++)
- *((tree *) VARRAY_GENERIC_PTR (uses, i)) = orig[i];
+ *(VARRAY_TREE_PTR (uses, i)) = orig[i];
free (orig);
}
}
@@ -1190,7 +1190,7 @@ replace_uses_in (tree stmt)
uses = use_ops (stmt);
for (i = 0; uses && i < VARRAY_ACTIVE_SIZE (uses); i++)
{
- tree *use = VARRAY_GENERIC_PTR (uses, i);
+ tree *use = VARRAY_TREE_PTR (uses, i);
value *val = get_value (*use);
if (val->lattice_val == CONSTANT)
@@ -1258,7 +1258,7 @@ likely_value (tree stmt)
uses = use_ops (stmt);
for (i = 0; uses && i < VARRAY_ACTIVE_SIZE (uses); i++)
{
- tree *use = VARRAY_GENERIC_PTR (uses, i);
+ tree *use = VARRAY_TREE_PTR (uses, i);
value *val = get_value (*use);
if (val->lattice_val == UNDEFINED)
Index: tree-ssa-copyprop.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-copyprop.c,v
retrieving revision 1.1.2.12
diff -d -c -p -d -u -p -r1.1.2.12 tree-ssa-copyprop.c
--- tree-ssa-copyprop.c 19 Aug 2003 19:03:24 -0000 1.1.2.12
+++ tree-ssa-copyprop.c 6 Sep 2003 13:16:18 -0000
@@ -109,7 +109,7 @@ copyprop_stmt (tree stmt)
uses = use_ops (stmt);
for (i = 0; uses && i < VARRAY_ACTIVE_SIZE (uses); i++)
{
- tree *use_p = (tree *) VARRAY_GENERIC_PTR (uses, i);
+ tree *use_p = VARRAY_TREE_PTR (uses, i);
tree orig = get_original (*use_p);
if (orig && may_propagate_copy (*use_p, orig))
Index: tree-ssa-dce.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-dce.c,v
retrieving revision 1.1.2.52
diff -d -c -p -d -u -p -r1.1.2.52 tree-ssa-dce.c
--- tree-ssa-dce.c 8 Aug 2003 00:27:10 -0000 1.1.2.52
+++ tree-ssa-dce.c 6 Sep 2003 13:16:19 -0000
@@ -286,7 +286,7 @@ stmt_useful_p (tree stmt)
ops = def_ops (stmt);
for (i = 0; ops && i < VARRAY_ACTIVE_SIZE (ops); i++)
- if (need_to_preserve_store (*((tree *) VARRAY_GENERIC_PTR (ops, i))))
+ if (need_to_preserve_store (*(VARRAY_TREE_PTR (ops, i))))
return true;
ops = vdef_ops (stmt);
@@ -401,7 +401,7 @@ process_worklist (void)
ops = use_ops (i);
for (k = 0; ops && k < VARRAY_ACTIVE_SIZE (ops); k++)
{
- tree *use_p = VARRAY_GENERIC_PTR (ops, k);
+ tree *use_p = VARRAY_TREE_PTR (ops, k);
mark_necessary (SSA_NAME_DEF_STMT (*use_p));
}
Index: tree-ssa-dom.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-dom.c,v
retrieving revision 1.1.2.32
diff -d -c -p -d -u -p -r1.1.2.32 tree-ssa-dom.c
--- tree-ssa-dom.c 4 Sep 2003 13:52:38 -0000 1.1.2.32
+++ tree-ssa-dom.c 6 Sep 2003 13:16:21 -0000
@@ -734,7 +734,7 @@ optimize_stmt (block_stmt_iterator si, v
/* Get a pointer to the operand we want to const/copy propagate
into. Each table has a slightly different structure. */
if (*table == uses)
- op_p = (tree *) VARRAY_GENERIC_PTR (uses, i);
+ op_p = VARRAY_TREE_PTR (uses, i);
else if (*table == vuses)
op_p = (tree *) &VARRAY_TREE (vuses, i);
else
@@ -1498,7 +1498,7 @@ avail_expr_eq (const void *p1, const voi
{
size_t i;
for (i = 0; i < VARRAY_ACTIVE_SIZE (ops1); i++)
- if (VARRAY_GENERIC_PTR (ops1, i) != VARRAY_GENERIC_PTR (ops2, i))
+ if (VARRAY_TREE_PTR (ops1, i) != VARRAY_TREE_PTR (ops2, i))
return false;
#ifdef ENABLE_CHECKING
@@ -1554,7 +1554,7 @@ mark_new_vars_to_rename (tree stmt, sbit
ops = def_ops (stmt);
for (i = 0; ops && i < VARRAY_ACTIVE_SIZE (ops); i++)
{
- tree *var_p = VARRAY_GENERIC_PTR (ops, i);
+ tree *var_p = VARRAY_TREE_PTR (ops, i);
if (DECL_P (*var_p))
SET_BIT (vars_to_rename, var_ann (*var_p)->uid);
}
@@ -1562,7 +1562,7 @@ mark_new_vars_to_rename (tree stmt, sbit
ops = use_ops (stmt);
for (i = 0; ops && i < VARRAY_ACTIVE_SIZE (ops); i++)
{
- tree *var_p = VARRAY_GENERIC_PTR (ops, i);
+ tree *var_p = VARRAY_TREE_PTR (ops, i);
if (DECL_P (*var_p))
SET_BIT (vars_to_rename, var_ann (*var_p)->uid);
}
Index: tree-ssa-live.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-live.c,v
retrieving revision 1.1.2.15
diff -d -c -p -d -u -p -r1.1.2.15 tree-ssa-live.c
--- tree-ssa-live.c 8 Aug 2003 00:27:10 -0000 1.1.2.15
+++ tree-ssa-live.c 6 Sep 2003 13:16:23 -0000
@@ -338,14 +338,14 @@ create_ssa_var_map (void)
ops = use_ops (stmt);
for (x = 0; ops && x < VARRAY_ACTIVE_SIZE (ops); x++)
{
- use = VARRAY_GENERIC_PTR (ops, x);
+ use = VARRAY_TREE_PTR (ops, x);
register_ssa_partition (map, *use);
}
ops = def_ops (stmt);
for (x = 0; ops && x < VARRAY_ACTIVE_SIZE (ops); x++)
{
- dest = VARRAY_GENERIC_PTR (ops, x);
+ dest = VARRAY_TREE_PTR (ops, x);
register_ssa_partition (map, *dest);
}
@@ -537,7 +537,7 @@ calculate_live_on_entry (var_map map)
num = (ops ? VARRAY_ACTIVE_SIZE (ops) : 0);
for (i = 0; i < num; i++)
{
- vec = VARRAY_GENERIC_PTR (ops, i);
+ vec = VARRAY_TREE_PTR (ops, i);
add_livein_if_notdef (live, saw_def, *vec, bb);
}
@@ -561,7 +561,7 @@ calculate_live_on_entry (var_map map)
num = (ops ? VARRAY_ACTIVE_SIZE (ops) : 0);
for (i = 0; i < num; i++)
{
- vec = VARRAY_GENERIC_PTR (ops, i);
+ vec = VARRAY_TREE_PTR (ops, i);
set_if_valid (map, saw_def, *vec);
}
@@ -1248,7 +1248,7 @@ build_tree_conflict_graph (tree_live_inf
num = ((ops) ? VARRAY_ACTIVE_SIZE (ops) : 0);
for (x = 0; x < num; x++)
{
- var_p = VARRAY_GENERIC_PTR (ops, x);
+ var_p = VARRAY_TREE_PTR (ops, x);
add_conflicts_if_valid (tpa, graph, map, live, *var_p);
}
@@ -1256,7 +1256,7 @@ build_tree_conflict_graph (tree_live_inf
num = ((ops) ? VARRAY_ACTIVE_SIZE (ops) : 0);
for (x = 0; x < num; x++)
{
- var_p = VARRAY_GENERIC_PTR (ops, x);
+ var_p = VARRAY_TREE_PTR (ops, x);
set_if_valid (map, live, *var_p);
}
}
Index: tree-ssa-pre.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa-pre.c,v
retrieving revision 1.1.4.77
diff -d -c -p -d -u -p -r1.1.4.77 tree-ssa-pre.c
--- tree-ssa-pre.c 5 Sep 2003 21:17:23 -0000 1.1.4.77
+++ tree-ssa-pre.c 6 Sep 2003 13:16:25 -0000
@@ -386,7 +386,7 @@ maybe_find_rhs_use_for_var (tree def, tr
return NULL_TREE;
for (i = startpos; i < VARRAY_ACTIVE_SIZE (uses); i++)
{
- tree *usep = VARRAY_GENERIC_PTR (uses, i);
+ tree *usep = VARRAY_TREE_PTR (uses, i);
tree use = *usep;
if (names_match_p (use, var))
return use;
@@ -660,7 +660,7 @@ expr_phi_insertion (bitmap * dfs, struct
uses = use_ops (occurp);
for (j = 0; j < VARRAY_ACTIVE_SIZE (uses); j ++)
{
- tree *usep = VARRAY_GENERIC_PTR (uses, j);
+ tree *usep = VARRAY_TREE_PTR (uses, j);
tree use = *usep;
if (ei->strred_cand)
use = factor_through_injuries (ei, use, SSA_NAME_VAR (use),
@@ -1083,7 +1083,7 @@ bool same_e_version_phi_result (struct e
return false;
for (i = 0; i < VARRAY_ACTIVE_SIZE (cruses); i++)
{
- tree *use1p = VARRAY_GENERIC_PTR (cruses, i);
+ tree *use1p = VARRAY_TREE_PTR (cruses, i);
tree use1;
if (!use1p)
continue;
@@ -1522,7 +1522,7 @@ get_default_def (tree var, htab_t seen)
defs = def_ops (defstmt);
for (i = 0; defs && i < VARRAY_ACTIVE_SIZE (defs); i++)
{
- tree *def_p = VARRAY_GENERIC_PTR (defs, i);
+ tree *def_p = VARRAY_TREE_PTR (defs, i);
if (SSA_NAME_VAR (*def_p) == SSA_NAME_VAR (var))
{
if (htab_find (seen, *def_p) != NULL)
@@ -1572,7 +1572,7 @@ reaching_def (tree var, tree currstmt, b
defs = def_ops (bsi_stmt (bsi));
for (i = 0; defs && i < VARRAY_ACTIVE_SIZE (defs); i++)
{
- def = VARRAY_GENERIC_PTR (defs, i);
+ def = VARRAY_TREE_PTR (defs, i);
if (def && *def != ignore && names_match_p (var, *def))
{
curruse = *def;
Index: tree-ssa.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/tree-ssa.c,v
retrieving revision 1.1.4.123
diff -d -c -p -d -u -p -r1.1.4.123 tree-ssa.c
--- tree-ssa.c 4 Sep 2003 13:52:38 -0000 1.1.4.123
+++ tree-ssa.c 6 Sep 2003 13:16:28 -0000
@@ -559,7 +559,7 @@ mark_def_sites (sbitmap globals)
ops = use_ops (stmt);
for (i = 0; ops && i < VARRAY_ACTIVE_SIZE (ops); i++)
{
- tree *use_p = VARRAY_GENERIC_PTR (ops, i);
+ tree *use_p = VARRAY_TREE_PTR (ops, i);
if (prepare_operand_for_rename (use_p, &uid)
&& !TEST_BIT (kills, uid))
@@ -610,7 +610,7 @@ mark_def_sites (sbitmap globals)
ops = def_ops (stmt);
for (i = 0; ops && i < VARRAY_ACTIVE_SIZE (ops); i++)
{
- tree *def_p = VARRAY_GENERIC_PTR (ops, i);
+ tree *def_p = VARRAY_TREE_PTR (ops, i);
if (prepare_operand_for_rename (def_p, &uid))
{
@@ -1706,7 +1706,7 @@ rewrite_out_of_ssa (tree fndecl)
for (i = 0; i < num_uses; i++)
{
- use_p = VARRAY_GENERIC_PTR (ops, i);
+ use_p = VARRAY_TREE_PTR (ops, i);
replace_variable (map, use_p);
}
@@ -1715,7 +1715,7 @@ rewrite_out_of_ssa (tree fndecl)
for (i = 0; i < num_defs; i++)
{
- tree *def_p = VARRAY_GENERIC_PTR (ops, i);
+ tree *def_p = VARRAY_TREE_PTR (ops, i);
*def_p = var_to_partition_to_var (map, *def_p);
replace_variable (map, def_p);
@@ -2049,7 +2049,7 @@ rewrite_stmt (block_stmt_iterator si, va
/* Step 1. Rewrite USES and VUSES in the statement. */
for (i = 0; uses && i < VARRAY_ACTIVE_SIZE (uses); i++)
- rewrite_operand ((tree *) VARRAY_GENERIC_PTR (uses, i));
+ rewrite_operand (VARRAY_TREE_PTR (uses, i));
/* Rewrite virtual uses in the statement. */
for (i = 0; vuses && i < VARRAY_ACTIVE_SIZE (vuses); i++)
@@ -2058,7 +2058,7 @@ rewrite_stmt (block_stmt_iterator si, va
/* Step 2. Register the statement's DEF and VDEF operands. */
for (i = 0; defs && i < VARRAY_ACTIVE_SIZE (defs); i++)
{
- tree *def_p = VARRAY_GENERIC_PTR (defs, i);
+ tree *def_p = VARRAY_TREE_PTR (defs, i);
if (TREE_CODE (*def_p) != SSA_NAME)
*def_p = make_ssa_name (*def_p, stmt);
Index: varray.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/varray.c,v
retrieving revision 1.15.2.5
diff -d -c -p -d -u -p -r1.15.2.5 varray.c
--- varray.c 8 Aug 2003 00:27:10 -0000 1.15.2.5
+++ varray.c 6 Sep 2003 13:16:28 -0000
@@ -58,6 +58,7 @@ static const struct {
{ sizeof (struct basic_block_def *), 0 },
{ sizeof (struct elt_list *), 1 },
{ sizeof (struct edge_def *), 0 },
+ { sizeof (tree *), 1 },
};
/* Allocate a virtual array with NUM_ELEMENT elements, each of which is
Index: varray.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/varray.h,v
retrieving revision 1.28.2.4
diff -d -c -p -d -u -p -r1.28.2.4 varray.h
--- varray.h 8 Aug 2003 00:27:10 -0000 1.28.2.4
+++ varray.h 6 Sep 2003 13:16:29 -0000
@@ -82,6 +82,7 @@ enum varray_data_enum {
VARRAY_DATA_BB,
VARRAY_DATA_TE,
VARRAY_DATA_EDGE,
+ VARRAY_DATA_TREE_PTR,
NUM_VARRAY_DATA
};
@@ -129,6 +130,8 @@ typedef union varray_data_tag GTY (()) {
tag ("VARRAY_DATA_TE"))) te[1];
struct edge_def *GTY ((length ("%0.num_elements"), skip (""),
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. */
@@ -210,6 +213,9 @@ extern varray_type varray_init (size_t,
#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) \
@@ -283,6 +289,7 @@ extern void varray_check_failed (varray_
#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)
@@ -305,6 +312,7 @@ extern void varray_check_failed (varray_
#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_CHAR(VA) VARRAY_TOP (VA, c)
@@ -327,5 +335,6 @@ extern void varray_check_failed (varray_
#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 */