diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 22e6673eadcf84a023bf57851ef1d02ae866e3b8..43dc427c264f668a3e5d1198c4955f47d9a8f38a 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,95 @@
+2005-12-29 Daniel Berlin <dberlin@dberlin.org>
+
+ * tree.h (VALUE_HANDLE_VUSES): New.
+ (struct tree_value_handle): Add vuses.
+
+ * tree-vn.c (struct val_expr_pair_d): Remove stmt, add vuses.
+ (vn_compute): Remove stmt argument.
+ Don't use vuses in hash value computation.
+ (val_expr_pair_eq): Compare vuse lists.
+ (copy_vuses_from_stmt): New function.
+ (shared_vuses_from_stmt): Ditto.
+ (vn_add): Rewrite in terms of vn_add_with_vuses.
+ (vn_add_with_vuses): New function.
+ (vn_lookup): Rewrite in terms of vn_lookup_with_vuses.
+ (vn_lookup_with_vuses): New function.
+ (vuses_compare): New function.
+ (print_creation_to_file): Ditto.
+ (vn_lookup_or_add): Rewrite to handle vuses.
+ (sort_vuses): New function.
+ (vn_lookup_or_add_with_vuses): Ditto.
+ (vn_init): Initialize shared_lookup_vuses.
+ (vn_delete): Free shared_lookup_vuses.
+
+ * tree-ssa-pre.c: Update todo list.
+ (bb_value_sets_t): Add rvuse_in, rvuse_out, rvuse_gen, and
+ rvuse_kill.
+ (RVUSE_IN): New macro.
+ (RVUSE_GEN): Ditto.
+ (RVUSE_KILL): Ditto.
+ (RVUSE_OUT): Ditto.
+ (modify_expr_node_pool): New function.
+ (pretemp): New.
+ (storetemp): Ditto.
+ (mergephitemp): Ditto.
+ (prephitemp): Ditto.
+ (struct expr_pred_trans_d): Add vuses member.
+ (expr_pred_trans_eq): Compare vuses.
+ (phi_trans_lookup): Add vuses argument.
+ (phi_trans_add): Ditto.
+ (translate_vuses_through_block): New function.
+ (phi_translate): Use vuses to ask about those expressions that can
+ have vuses.
+ Properly translate virtual uses through phis, and use
+ vn_lookup_or_add_with vuses. Handle tcc_reference.
+ (phi_translate_set): Don't add pointless translations to the
+ cache.
+ (get_representative): New function.
+ (vuses_dies_in_block_x): Ditto.
+ (valid_in_set): Add block argument. Check virtual use validity.
+ (clean): Add block argument. Update call to valid_in_set
+ (compute_antic_aux): Update call to clean.
+ (dump_bitmap_of_names): New function.
+ (compute_vuse_representatives): Ditto.
+ (compute_rvuse): Ditto.
+ (can_value_number_call): Modified to accept calls with vuses.
+ (can_value_number_operation): New function.
+ (can_PRE_operation): Ditto.
+ (need_creation): New vector of stores that may need creation.
+ (find_or_generate_expression): use can_PRE_operation.
+ (create_expression_by_pieces): Handle INDIRECT_REF.
+ Only create one temp until we have to change types.
+ Mark new vars for renaming.
+ (insert_into_preds_of_block): Ignore loopiness of loads.
+ Use can_PRE_operation.
+ Only create one temp until we have to chnge types.
+ (insert_aux): Use can_PRE_operation.
+ Don't pass name to insert_into_preds_of_block.
+ (insert_extra_phis): Only use one temp until we have to change
+ types.
+ (poolify_tree): New function.
+ (modify_expr_template): New var.
+ (poolify_modify_expr): New function.
+ (insert_fake_stores): Ditto.
+ (realify_fake_stores): Ditto.
+ (compute_avail): Use can_value_number_operation.
+ (mark_operand_necessary): Return NULL for non-SSA names.
+ (remove_dead_inserted_code): Update comment.
+ (init_pre): Initialize pretemp, need_creation, storetemp,
+ mergephitemp, prephitemp.
+ Create modify_expr_node_pool.
+ (fini_pre): Free modify_expr_node_pool and need_creation array.
+ (execute_pre): Call insert_fake_stores, compute_rvuse, and
+ realify_fake_stores.
+ * tree-flow.h (vn_compute): Fix prototype.
+ (vn_add): Ditto.
+ (vn_lookup): Ditto.
+ (sort_vuses): New.
+ (vn_lookup_or_add_with_vuses): Ditto.
+ (vn_add_with_vuses): Ditto.
+ (vn_lookup_with_vuses): Ditto.
+ * passes.c (pass_may_alias): Add.
+
2005-12-30 Gabriel Dos Reis <gdr@integrable-solutions.net>
* c-pretty-print.h (struct c_pretty_print_info): Add new member
diff --git a/gcc/passes.c b/gcc/passes.c
index a5402fa2e0016706ee45e4f9845e2aa63efec77c..dcff796067658615dd382a1eb9a3f1744b5709db 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -554,6 +554,7 @@ init_optimization_passes (void)
NEXT_PASS (pass_cse_reciprocals);
NEXT_PASS (pass_split_crit_edges);
NEXT_PASS (pass_pre);
+ NEXT_PASS (pass_may_alias);
NEXT_PASS (pass_sink_code);
NEXT_PASS (pass_tree_loop);
NEXT_PASS (pass_reassoc);
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loadpre1.c b/gcc/testsuite/gcc.dg/tree-ssa/loadpre1.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6597514743d72575a1ce83114800476a83b08cf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loadpre1.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int *a, int argc)
+{
+ int c;
+ int d, e;
+
+ /* Should be able to eliminate the second load of *a along the main path. */
+ d = *a;
+ if (argc)
+ {
+ a = &c;
+ }
+ e = *a;
+ return d + e;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loadpre2.c b/gcc/testsuite/gcc.dg/tree-ssa/loadpre2.c
new file mode 100644
index 0000000000000000000000000000000000000000..8d6557a9e88dde597c610695b53f063b051b0cf3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loadpre2.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int *a, int argc)
+{
+ int b;
+ int i;
+ int d, e;
+
+ /* Should be able to hoist this out of the loop. */
+ for (i = 0; i < argc; i++)
+ {
+ e = *a;
+ }
+ return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loadpre3.c b/gcc/testsuite/gcc.dg/tree-ssa/loadpre3.c
new file mode 100644
index 0000000000000000000000000000000000000000..8767e16a98e2a543d74c055d6c3477189c338bc9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loadpre3.c
@@ -0,0 +1,24 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int **a,int argc)
+{
+ int b;
+ int d, e;
+
+ if (argc)
+ {
+ d = *(*a);
+ }
+ else
+ {
+
+ }
+ /* Should be able to eliminate one of the *(*a)'s along the if path
+ by pushing it into the else path. We will also eliminate
+ one of the *a's. */
+ e = *(*a);
+ return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loadpre4.c b/gcc/testsuite/gcc.dg/tree-ssa/loadpre4.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b886151be1e430debbc01336d24f5935c3d3e32
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loadpre4.c
@@ -0,0 +1,21 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int main(int *a, int argc)
+{
+ int b;
+ int c;
+ int i;
+ int d, e;
+
+ /* With smarter load PRE, we'd be able to recompute the value at the
+ kill point. arguably not worth it. */
+ for (i = 0; i < argc; i++)
+ {
+ e = *a;
+ *a = 9;
+ }
+ return d + e;
+}
+
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre" { xfail *-*-* } } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loadpre5.c b/gcc/testsuite/gcc.dg/tree-ssa/loadpre5.c
new file mode 100644
index 0000000000000000000000000000000000000000..37314ebe8fd2b4a75f2f31dba06e838e04eb4e21
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loadpre5.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+int p;
+int r;
+int a(void)
+{
+ return p;
+}
+int main(int argc)
+{
+ int q;
+ q = a();
+
+ /* We should be able to move the call to a into the if path.
+ in a perfect world, we'd actually decide that it can't touch
+ r, and not recompute it at all!. */
+ if (argc)
+ r = 9;
+ return q + a();
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loadpre6.c b/gcc/testsuite/gcc.dg/tree-ssa/loadpre6.c
new file mode 100644
index 0000000000000000000000000000000000000000..5283f20d4d40f6f41e728381e85c03293a8edfdf
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loadpre6.c
@@ -0,0 +1,74 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+
+union tree_node;
+typedef union tree_node *tree;
+
+struct tree_common
+{
+ tree chain;
+};
+
+struct tree_list
+{
+ struct tree_common common;
+ tree value;
+};
+
+union tree_node
+
+{
+ struct tree_common common;
+ struct tree_list list;
+};
+
+extern void abort (void) __attribute__((noreturn));
+
+void __attribute__((noinline))
+foo (void)
+{
+ abort ();
+}
+
+void __attribute__((noinline))
+remove_useless_vars (tree *unexpanded_var_list, int dump_file)
+{
+ tree var, *cell;
+ int c = 0;
+ for (cell = unexpanded_var_list; *cell; )
+ {
+ var = (*cell)->list.value;
+ if (var)
+ {
+ if (dump_file)
+ foo ();
+
+ *cell = ((*cell)->common.chain);
+ continue;
+ }
+
+ cell = &((*cell)->common.chain);
+ }
+}
+extern void *malloc (int) __attribute__ ((malloc));
+
+int
+main (void)
+{
+ int i;
+ tree unexpanded_var_list, last = (tree) 0;
+
+ for (i = 0; i < 2; i++)
+ {
+ unexpanded_var_list = malloc (sizeof (struct tree_list));
+ unexpanded_var_list->list.value = (tree) (long unsigned) (i & 1);
+ unexpanded_var_list->common.chain = last;
+ last = unexpanded_var_list;
+ }
+
+ remove_useless_vars (&unexpanded_var_list, 0);
+ return 0;
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre" } } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
+
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loadpre7.c b/gcc/testsuite/gcc.dg/tree-ssa/loadpre7.c
new file mode 100644
index 0000000000000000000000000000000000000000..7cd6838c6ab396b73b15529e1d88b4c7941cfd50
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loadpre7.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+/* We can't eliminate the *p load here in any sane way, as eshup8 may
+ change it. */
+void
+enormlz (x)
+ unsigned short x[];
+{
+ register unsigned short *p;
+ p = &x[2];
+ while ((*p & 0xff00) == 0)
+ {
+ eshup8 (x);
+ }
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 0" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loadpre8.c b/gcc/testsuite/gcc.dg/tree-ssa/loadpre8.c
new file mode 100644
index 0000000000000000000000000000000000000000..86cb1e46bba7f7a4556662b7ce8f8538e72d372e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loadpre8.c
@@ -0,0 +1,97 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-pre-stats" } */
+typedef union tree_node *tree;
+struct tree_common
+{
+ tree chain;
+}
+VEC_constructor_elt_base;
+struct tree_ssa_name
+{
+ tree var;
+};
+union tree_node
+{
+ struct tree_common common;
+ struct tree_ssa_name ssa_name;
+};
+struct edge_def
+{
+ struct basic_block_def *dest;
+};
+typedef struct edge_def *edge;
+typedef struct VEC_edge_base
+{
+}
+VEC_edge_base;
+edge
+VEC_edge_base_index (const VEC_edge_base * vec_, unsigned ix_)
+{
+}
+typedef struct VEC_edge_gc
+{
+ VEC_edge_base base;
+}
+VEC_edge_gc;
+struct basic_block_def
+{
+ VEC_edge_gc *succs;
+};
+typedef struct basic_block_def *basic_block;
+typedef struct
+{
+ unsigned index;
+ VEC_edge_gc **container;
+}
+edge_iterator;
+__inline__ VEC_edge_gc *
+ei_container (edge_iterator i)
+{
+ return *i.container;
+}
+__inline__ edge_iterator
+ei_start_1 (VEC_edge_gc ** ev)
+{
+ edge_iterator i;
+ i.container = ev;
+ return i;
+}
+ei_next (edge_iterator * i)
+{
+}
+static __inline__ edge
+ei_edge (edge_iterator i)
+{
+ return (edge) (VEC_edge_base_index ((((ei_container (i))) ? &((ei_container (i)))->base : 0), (i.index)));
+}
+static __inline__ unsigned char
+ei_cond (edge_iterator ei, edge * p)
+{
+ *p = ei_edge (ei);
+}
+typedef tree *def_operand_p;
+extern tree *get_phi_result_ptr (tree);
+static __inline__ tree
+get_def_from_ptr (def_operand_p def)
+{
+}
+tree
+phi_nodes (basic_block bb)
+{
+}
+
+/* We can eliminate a load of the SRA'd variable edge_iterator.container */
+rewrite_add_phi_arguments (basic_block bb)
+{
+ edge e;
+ edge_iterator ei;
+ for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei), &(e));
+ ei_next (&(ei)))
+ {
+ tree phi;
+ for (phi = phi_nodes (e->dest); phi; phi = (((phi))->common.chain))
+ get_reaching_def ((get_def_from_ptr (get_phi_result_ptr (phi)))->ssa_name.var);
+ }
+}
+/* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
+/* { dg-final { cleanup-tree-dump "pre" } } */
diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
index a507ced434a28700aa4ac56b5584e297ff8bba50..6065a3b39109dfdd6c59677bda0dd16c36e14595 100644
--- a/gcc/tree-flow.h
+++ b/gcc/tree-flow.h
@@ -776,10 +776,14 @@ void print_value_expressions (FILE *, tree);
/* In tree-vn.c */
bool expressions_equal_p (tree, tree);
tree get_value_handle (tree);
-hashval_t vn_compute (tree, hashval_t, tree);
+hashval_t vn_compute (tree, hashval_t);
+void sort_vuses (VEC (tree, gc) *);
tree vn_lookup_or_add (tree, tree);
-void vn_add (tree, tree, tree);
+tree vn_lookup_or_add_with_vuses (tree, VEC (tree, gc) *);
+void vn_add (tree, tree);
+void vn_add_with_vuses (tree, tree, VEC (tree, gc) *);
tree vn_lookup (tree, tree);
+tree vn_lookup_with_vuses (tree, VEC (tree, gc) *);
void vn_init (void);
void vn_delete (void);
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index e8ef1220b19538ab7e981a7f8c7e95bd807295ad..f0bf0205297cb781329105b3cf8e7efe950112ef 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -49,13 +49,9 @@ Boston, MA 02110-1301, USA. */
1. Avail sets can be shared by making an avail_find_leader that
walks up the dominator tree and looks in those avail sets.
This might affect code optimality, it's unclear right now.
- 2. Load motion can be performed by value numbering the loads the
- same as we do other expressions. This requires iterative
- hashing the vuses into the values. Right now we simply assign
- a new value every time we see a statement with a vuse.
- 3. Strength reduction can be performed by anticipating expressions
+ 2. Strength reduction can be performed by anticipating expressions
we can repair later on.
- 4. We can do back-substitution or smarter value numbering to catch
+ 3. We can do back-substitution or smarter value numbering to catch
commutative expressions split up over multiple statements.
*/
@@ -247,7 +243,7 @@ typedef struct bb_value_sets
a given basic block. */
bitmap_set_t avail_out;
- /* The ANTIC_IN set, which represents which values are anticiptable
+ /* The ANTIC_IN set, which represents which values are anticipatable
in a given basic block. */
value_set_t antic_in;
@@ -255,6 +251,13 @@ typedef struct bb_value_sets
AVAIL_OUT set of blocks with the new insertions performed during
the current iteration. */
bitmap_set_t new_sets;
+
+ /* The RVUSE sets, which are used during ANTIC computation to ensure
+ that we don't mark loads ANTIC once they have died. */
+ bitmap rvuse_in;
+ bitmap rvuse_out;
+ bitmap rvuse_gen;
+ bitmap rvuse_kill;
} *bb_value_sets_t;
#define EXP_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->exp_gen
@@ -262,6 +265,10 @@ typedef struct bb_value_sets
#define TMP_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->tmp_gen
#define AVAIL_OUT(BB) ((bb_value_sets_t) ((BB)->aux))->avail_out
#define ANTIC_IN(BB) ((bb_value_sets_t) ((BB)->aux))->antic_in
+#define RVUSE_IN(BB) ((bb_value_sets_t) ((BB)->aux))->rvuse_in
+#define RVUSE_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->rvuse_gen
+#define RVUSE_KILL(BB) ((bb_value_sets_t) ((BB)->aux))->rvuse_kill
+#define RVUSE_OUT(BB) ((bb_value_sets_t) ((BB)->aux))->rvuse_out
#define NEW_SETS(BB) ((bb_value_sets_t) ((BB)->aux))->new_sets
/* This structure is used to keep track of statistics on what
@@ -309,8 +316,18 @@ static alloc_pool reference_node_pool;
static alloc_pool comparison_node_pool;
static alloc_pool expression_node_pool;
static alloc_pool list_node_pool;
+static alloc_pool modify_expr_node_pool;
static bitmap_obstack grand_bitmap_obstack;
+/* To avoid adding 300 temporary variables when we only need one, we
+ only create one temporary variable, on demand, and build ssa names
+ off that. We do have to change the variable if the types don't
+ match the current variable's type. */
+static tree pretemp;
+static tree storetemp;
+static tree mergephitemp;
+static tree prephitemp;
+
/* Set of blocks with statements that have had its EH information
cleaned up. */
static bitmap need_eh_cleanup;
@@ -331,9 +348,13 @@ typedef struct expr_pred_trans_d
/* The predecessor block along which we translated the expression. */
basic_block pred;
+ /* vuses associated with the expression. */
+ VEC (tree, gc) *vuses;
+
/* The value that resulted from the translation. */
tree v;
+
/* The hashcode for the expression, pred pair. This is cached for
speed reasons. */
hashval_t hashcode;
@@ -358,33 +379,50 @@ expr_pred_trans_eq (const void *p1, const void *p2)
const expr_pred_trans_t ve2 = (expr_pred_trans_t) p2;
basic_block b1 = ve1->pred;
basic_block b2 = ve2->pred;
-
+ int i;
+ tree vuse1;
/* If they are not translations for the same basic block, they can't
be equal. */
if (b1 != b2)
return false;
+
/* If they are for the same basic block, determine if the
expressions are equal. */
- if (expressions_equal_p (ve1->e, ve2->e))
+ if (!expressions_equal_p (ve1->e, ve2->e))
+ return false;
+
+ /* Make sure the vuses are equivalent. */
+ if (ve1->vuses == ve2->vuses)
return true;
- return false;
+ if (VEC_length (tree, ve1->vuses) != VEC_length (tree, ve2->vuses))
+ return false;
+
+ for (i = 0; VEC_iterate (tree, ve1->vuses, i, vuse1); i++)
+ {
+ if (VEC_index (tree, ve2->vuses, i) != vuse1)
+ return false;
+ }
+
+ return true;
}
/* Search in the phi translation table for the translation of
- expression E in basic block PRED. Return the translated value, if
- found, NULL otherwise. */
+ expression E in basic block PRED with vuses VUSES.
+ Return the translated value, if found, NULL otherwise. */
static inline tree
-phi_trans_lookup (tree e, basic_block pred)
+phi_trans_lookup (tree e, basic_block pred, VEC (tree, gc) *vuses)
{
void **slot;
struct expr_pred_trans_d ept;
+
ept.e = e;
ept.pred = pred;
- ept.hashcode = vn_compute (e, (unsigned long) pred, NULL);
+ ept.vuses = vuses;
+ ept.hashcode = vn_compute (e, (unsigned long) pred);
slot = htab_find_slot_with_hash (phi_translate_table, &ept, ept.hashcode,
NO_INSERT);
if (!slot)
@@ -394,18 +432,19 @@ phi_trans_lookup (tree e, basic_block pred)
}
-/* Add the tuple mapping from {expression E, basic block PRED} to
+/* Add the tuple mapping from {expression E, basic block PRED, vuses VUSES} to
value V, to the phi translation table. */
static inline void
-phi_trans_add (tree e, tree v, basic_block pred)
+phi_trans_add (tree e, tree v, basic_block pred, VEC (tree, gc) *vuses)
{
void **slot;
expr_pred_trans_t new_pair = XNEW (struct expr_pred_trans_d);
new_pair->e = e;
new_pair->pred = pred;
+ new_pair->vuses = vuses;
new_pair->v = v;
- new_pair->hashcode = vn_compute (e, (unsigned long) pred, NULL);
+ new_pair->hashcode = vn_compute (e, (unsigned long) pred);
slot = htab_find_slot_with_hash (phi_translate_table, new_pair,
new_pair->hashcode, INSERT);
if (*slot)
@@ -936,7 +975,42 @@ pool_copy_list (tree list)
return head;
}
+/* Translate the vuses in the VUSES vector backwards through phi
+ nodes, so that they have the value they would have in BLOCK. */
+
+static VEC(tree, gc) *
+translate_vuses_through_block (VEC (tree, gc) *vuses, basic_block block)
+{
+ tree oldvuse;
+ VEC(tree, gc) *result = NULL;
+ int i;
+ for (i = 0; VEC_iterate (tree, vuses, i, oldvuse); i++)
+ {
+ tree phi = SSA_NAME_DEF_STMT (oldvuse);
+ if (TREE_CODE (phi) == PHI_NODE)
+ {
+ edge e = find_edge (block, bb_for_stmt (phi));
+ if (e)
+ {
+ tree def = PHI_ARG_DEF (phi, e->dest_idx);
+ if (def != oldvuse)
+ {
+ if (!result)
+ result = VEC_copy (tree, gc, vuses);
+ VEC_replace (tree, result, i, def);
+ }
+ }
+ }
+ }
+ if (result)
+ {
+ sort_vuses (result);
+ return result;
+ }
+ return vuses;
+
+}
/* Translate EXPR using phis in PHIBLOCK, so that it has the values of
the phis in PRED. Return NULL if we can't find a leader for each
part of the translated expression. */
@@ -947,7 +1021,6 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
{
tree phitrans = NULL;
tree oldexpr = expr;
-
if (expr == NULL)
return NULL;
@@ -955,7 +1028,19 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
return expr;
/* Phi translations of a given expression don't change. */
- phitrans = phi_trans_lookup (expr, pred);
+ if (EXPR_P (expr))
+ {
+ tree vh;
+
+ vh = get_value_handle (expr);
+ if (vh && TREE_CODE (vh) == VALUE_HANDLE)
+ phitrans = phi_trans_lookup (expr, pred, VALUE_HANDLE_VUSES (vh));
+ else
+ phitrans = phi_trans_lookup (expr, pred, NULL);
+ }
+ else
+ phitrans = phi_trans_lookup (expr, pred, NULL);
+
if (phitrans)
return phitrans;
@@ -976,7 +1061,10 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
tree oldwalker;
tree newwalker;
tree newexpr;
+ tree vh = get_value_handle (expr);
bool listchanged = false;
+ VEC (tree, gc) *vuses = VALUE_HANDLE_VUSES (vh);
+ VEC (tree, gc) *tvuses;
/* Call expressions are kind of weird because they have an
argument list. We don't want to value number the list
@@ -1028,7 +1116,10 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
if (listchanged)
vn_lookup_or_add (newarglist, NULL);
- if (listchanged || (newop0 != oldop0) || (oldop2 != newop2))
+ tvuses = translate_vuses_through_block (vuses, pred);
+
+ if (listchanged || (newop0 != oldop0) || (oldop2 != newop2)
+ || vuses != tvuses)
{
newexpr = (tree) pool_alloc (expression_node_pool);
memcpy (newexpr, expr, tree_size (expr));
@@ -1036,17 +1127,76 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
TREE_OPERAND (newexpr, 1) = listchanged ? newarglist : oldarglist;
TREE_OPERAND (newexpr, 2) = newop2 == oldop2 ? oldop2 : get_value_handle (newop2);
create_tree_ann (newexpr);
- vn_lookup_or_add (newexpr, NULL);
+ vn_lookup_or_add_with_vuses (newexpr, tvuses);
expr = newexpr;
- phi_trans_add (oldexpr, newexpr, pred);
+ phi_trans_add (oldexpr, newexpr, pred, tvuses);
}
}
}
return expr;
+ case tcc_declaration:
+ {
+ VEC (tree, gc) * oldvuses = NULL;
+ VEC (tree, gc) * newvuses = NULL;
+
+ oldvuses = VALUE_HANDLE_VUSES (get_value_handle (expr));
+ if (oldvuses)
+ newvuses = translate_vuses_through_block (oldvuses, pred);
+
+ if (oldvuses != newvuses)
+ vn_lookup_or_add_with_vuses (expr, newvuses);
+
+ phi_trans_add (oldexpr, expr, pred, newvuses);
+ }
+ return expr;
+
case tcc_reference:
- /* XXX: Until we have PRE of loads working, none will be ANTIC. */
- return NULL;
+ {
+ tree oldop1 = TREE_OPERAND (expr, 0);
+ tree newop1;
+ tree newexpr;
+ VEC (tree, gc) * oldvuses = NULL;
+ VEC (tree, gc) * newvuses = NULL;
+
+ if (TREE_CODE (expr) != INDIRECT_REF)
+ return NULL;
+
+ newop1 = phi_translate (find_leader (set, oldop1),
+ set, pred, phiblock);
+ if (newop1 == NULL)
+ return NULL;
+
+ oldvuses = VALUE_HANDLE_VUSES (get_value_handle (expr));
+ if (oldvuses)
+ newvuses = translate_vuses_through_block (oldvuses, pred);
+
+ if (newop1 != oldop1 || newvuses != oldvuses)
+ {
+ tree t;
+
+ newexpr = pool_alloc (reference_node_pool);
+ memcpy (newexpr, expr, tree_size (expr));
+ TREE_OPERAND (newexpr, 0) = get_value_handle (newop1);
+
+ t = fully_constant_expression (newexpr);
+
+ if (t != newexpr)
+ {
+ pool_free (reference_node_pool, newexpr);
+ newexpr = t;
+ }
+ else
+ {
+ create_tree_ann (newexpr);
+ vn_lookup_or_add_with_vuses (newexpr, newvuses);
+ }
+ expr = newexpr;
+ phi_trans_add (oldexpr, newexpr, pred, newvuses);
+ }
+ }
+ return expr;
+ break;
case tcc_binary:
case tcc_comparison:
@@ -1084,7 +1234,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
vn_lookup_or_add (newexpr, NULL);
}
expr = newexpr;
- phi_trans_add (oldexpr, newexpr, pred);
+ phi_trans_add (oldexpr, newexpr, pred, NULL);
}
}
return expr;
@@ -1117,7 +1267,7 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
vn_lookup_or_add (newexpr, NULL);
}
expr = newexpr;
- phi_trans_add (oldexpr, newexpr, pred);
+ phi_trans_add (oldexpr, newexpr, pred, NULL);
}
}
return expr;
@@ -1162,9 +1312,23 @@ phi_translate_set (value_set_t dest, value_set_t set, basic_block pred,
node = node->next)
{
tree translated;
- translated = phi_translate (node->expr, set, pred, phiblock);
- phi_trans_add (node->expr, translated, pred);
+ translated = phi_translate (node->expr, set, pred, phiblock);
+
+ /* Don't add constants or empty translations to the cache, since
+ we won't look them up that way, or use the result, anyway. */
+ if (translated && !is_gimple_min_invariant (translated))
+ {
+ tree vh = get_value_handle (translated);
+ VEC (tree, gc) *vuses;
+
+ /* The value handle itself may also be an invariant, in
+ which case, it has no vuses. */
+ vuses = !is_gimple_min_invariant (vh)
+ ? VALUE_HANDLE_VUSES (vh) : NULL;
+ phi_trans_add (node->expr, translated, pred, vuses);
+ }
+
if (translated != NULL)
value_insert_into_set (dest, translated);
}
@@ -1245,6 +1409,42 @@ find_leader (value_set_t set, tree val)
return NULL;
}
+/* Given the vuse representative map, MAP, and an SSA version number,
+ ID, return the bitmap of names ID represents, or NULL, if none
+ exists. */
+
+static bitmap
+get_representative (bitmap *map, int id)
+{
+ if (map[id] != NULL)
+ return map[id];
+ return NULL;
+}
+
+/* A vuse is anticipable at the top of block x, from the bottom of the
+ block, if it reaches the top of the block, and is not killed in the
+ block. In effect, we are trying to see if the vuse is transparent
+ backwards in the block. */
+
+static bool
+vuses_dies_in_block_x (VEC (tree, gc) *vuses, basic_block block)
+{
+ int i;
+ tree vuse;
+
+ for (i = 0; VEC_iterate (tree, vuses, i, vuse); i++)
+ {
+ /* Any places where this is too conservative, are places
+ where we created a new version and shouldn't have. */
+
+ if (!bitmap_bit_p (RVUSE_IN (block), SSA_NAME_VERSION (vuse))
+ || bitmap_bit_p (RVUSE_KILL (block), SSA_NAME_VERSION
+ (vuse)))
+ return true;
+ }
+ return false;
+}
+
/* Determine if the expression EXPR is valid in SET. This means that
we have a leader for each part of the expression (if it consists of
values), or the expression is an SSA_NAME.
@@ -1255,9 +1455,10 @@ find_leader (value_set_t set, tree val)
(IE VALUE1 + VALUE2, *VALUE1, VALUE1 < VALUE2) */
static bool
-valid_in_set (value_set_t set, tree expr)
+valid_in_set (value_set_t set, tree expr, basic_block block)
{
- switch (TREE_CODE_CLASS (TREE_CODE (expr)))
+ tree vh = get_value_handle (expr);
+ switch (TREE_CODE_CLASS (TREE_CODE (expr)))
{
case tcc_binary:
case tcc_comparison:
@@ -1292,13 +1493,27 @@ valid_in_set (value_set_t set, tree expr)
if (!set_contains_value (set, TREE_VALUE (arglist)))
return false;
}
- return true;
+ return !vuses_dies_in_block_x (VALUE_HANDLE_VUSES (vh), block);
}
return false;
}
case tcc_reference:
- /* XXX: Until PRE of loads works, no reference nodes are ANTIC. */
+ {
+ if (TREE_CODE (expr) == INDIRECT_REF)
+ {
+ tree op0 = TREE_OPERAND (expr, 0);
+ if (is_gimple_min_invariant (op0)
+ || TREE_CODE (op0) == VALUE_HANDLE)
+ {
+ bool retval = set_contains_value (set, op0);
+ if (retval)
+ return !vuses_dies_in_block_x (VALUE_HANDLE_VUSES (vh),
+ block);
+ return false;
+ }
+ }
+ }
return false;
case tcc_exceptional:
@@ -1306,8 +1521,7 @@ valid_in_set (value_set_t set, tree expr)
return true;
case tcc_declaration:
- /* VAR_DECL and PARM_DECL are never anticipatable. */
- return false;
+ return !vuses_dies_in_block_x (VALUE_HANDLE_VUSES (vh), block);
default:
/* No other cases should be encountered. */
@@ -1320,7 +1534,7 @@ valid_in_set (value_set_t set, tree expr)
in SET. */
static void
-clean (value_set_t set)
+clean (value_set_t set, basic_block block)
{
value_set_node_t node;
value_set_node_t next;
@@ -1328,7 +1542,7 @@ clean (value_set_t set)
while (node)
{
next = node->next;
- if (!valid_in_set (set, node->expr))
+ if (!valid_in_set (set, node->expr, block))
set_remove (set, node->expr);
node = next;
}
@@ -1402,6 +1616,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
{
tree val;
value_set_node_t next = node->next;
+
val = get_value_handle (node->expr);
if (!set_contains_value (ANTIC_IN (bprime), val))
set_remove (ANTIC_OUT, node->expr);
@@ -1424,7 +1639,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
for (node = S->head; node; node = node->next)
value_insert_into_set (ANTIC_IN (block), node->expr);
- clean (ANTIC_IN (block));
+ clean (ANTIC_IN (block), block);
if (!set_equal (old, ANTIC_IN (block)))
changed = true;
@@ -1492,7 +1707,304 @@ compute_antic (void)
fprintf (dump_file, "compute_antic required %d iterations\n", num_iterations);
}
+/* Print the names represented by the bitmap NAMES, to the file OUT. */
+static void
+dump_bitmap_of_names (FILE *out, bitmap names)
+{
+ bitmap_iterator bi;
+ unsigned int i;
+
+ fprintf (out, " { ");
+ EXECUTE_IF_SET_IN_BITMAP (names, 0, i, bi)
+ {
+ print_generic_expr (out, ssa_name (i), 0);
+ fprintf (out, " ");
+ }
+ fprintf (out, "}\n");
+}
+
+ /* Compute a set of representative vuse versions for each phi. This
+ is so we can compute conservative kill sets in terms of all vuses
+ that are killed, instead of continually walking chains.
+
+ We also have to be able kill all names associated with a phi when
+ the phi dies in order to ensure we don't generate overlapping
+ live ranges, which are not allowed in virtual SSA. */
+
+static bitmap *vuse_names;
+static void
+compute_vuse_representatives (void)
+{
+ tree phi;
+ basic_block bb;
+ VEC (tree, heap) *phis = NULL;
+ bool changed = true;
+ size_t i;
+
+ FOR_EACH_BB (bb)
+ {
+ for (phi = phi_nodes (bb);
+ phi;
+ phi = PHI_CHAIN (phi))
+ if (!is_gimple_reg (PHI_RESULT (phi)))
+ VEC_safe_push (tree, heap, phis, phi);
+ }
+
+ while (changed)
+ {
+ changed = false;
+
+ for (i = 0; VEC_iterate (tree, phis, i, phi); i++)
+ {
+ size_t ver = SSA_NAME_VERSION (PHI_RESULT (phi));
+ use_operand_p usep;
+ ssa_op_iter iter;
+
+ if (vuse_names[ver] == NULL)
+ {
+ vuse_names[ver] = BITMAP_ALLOC (&grand_bitmap_obstack);
+ bitmap_set_bit (vuse_names[ver], ver);
+ }
+ FOR_EACH_PHI_ARG (usep, phi, iter, SSA_OP_ALL_USES)
+ {
+ tree use = USE_FROM_PTR (usep);
+ bitmap usebitmap = get_representative (vuse_names,
+ SSA_NAME_VERSION (use));
+ if (usebitmap != NULL)
+ {
+ changed |= bitmap_ior_into (vuse_names[ver],
+ usebitmap);
+ }
+ else
+ {
+ changed |= !bitmap_bit_p (vuse_names[ver],
+ SSA_NAME_VERSION (use));
+ if (changed)
+ bitmap_set_bit (vuse_names[ver],
+ SSA_NAME_VERSION (use));
+ }
+ }
+ }
+ }
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ for (i = 0; VEC_iterate (tree, phis, i, phi); i++)
+ {
+ bitmap reps = get_representative (vuse_names,
+ SSA_NAME_VERSION (PHI_RESULT (phi)));
+ if (reps)
+ {
+ print_generic_expr (dump_file, PHI_RESULT (phi), 0);
+ fprintf (dump_file, " represents ");
+ dump_bitmap_of_names (dump_file, reps);
+ }
+ }
+ VEC_free (tree, heap, phis);
+}
+
+/* Compute reaching vuses. This is a small bit of iterative dataflow
+ to determine what virtual uses reach what blocks. Because we can't
+ generate overlapping virtual uses, and virtual uses *do* actually
+ die, this ends up being faster in most cases than continually
+ walking the virtual use/def chains to determine whether we are
+ inside a block where a given virtual is still available to be
+ used. */
+
+static void
+compute_rvuse (void)
+{
+
+ size_t i;
+ tree phi;
+ basic_block bb;
+ int *postorder;
+ bool changed = true;
+
+ compute_vuse_representatives ();
+
+ FOR_ALL_BB (bb)
+ {
+ RVUSE_IN (bb) = BITMAP_ALLOC (&grand_bitmap_obstack);
+ RVUSE_GEN (bb) = BITMAP_ALLOC (&grand_bitmap_obstack);
+ RVUSE_KILL (bb) = BITMAP_ALLOC (&grand_bitmap_obstack);
+ RVUSE_OUT (bb) = BITMAP_ALLOC (&grand_bitmap_obstack);
+ }
+
+
+ /* Mark live on entry */
+ for (i = 0; i < num_ssa_names; i++)
+ {
+ tree name = ssa_name (i);
+ if (name && !is_gimple_reg (name)
+ && IS_EMPTY_STMT (SSA_NAME_DEF_STMT (name)))
+ bitmap_set_bit (RVUSE_OUT (ENTRY_BLOCK_PTR),
+ SSA_NAME_VERSION (name));
+ }
+
+ /* Compute local sets for reaching vuses.
+ GEN(block) = generated in block and not locally killed.
+ KILL(block) = set of vuses killed in block.
+ */
+
+ FOR_EACH_BB (bb)
+ {
+ block_stmt_iterator bsi;
+ ssa_op_iter iter;
+ def_operand_p defp;
+ use_operand_p usep;
+
+
+ for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
+ {
+ tree stmt = bsi_stmt (bsi);
+ FOR_EACH_SSA_USE_OPERAND (usep, stmt, iter, SSA_OP_VIRTUAL_KILLS
+ | SSA_OP_VMAYUSE)
+ {
+ tree use = USE_FROM_PTR (usep);
+ bitmap repbit = get_representative (vuse_names,
+ SSA_NAME_VERSION (use));
+ if (repbit != NULL)
+ {
+ bitmap_and_compl_into (RVUSE_GEN (bb), repbit);
+ bitmap_ior_into (RVUSE_KILL (bb), repbit);
+ }
+ else
+ {
+ bitmap_set_bit (RVUSE_KILL (bb), SSA_NAME_VERSION (use));
+ bitmap_clear_bit (RVUSE_GEN (bb), SSA_NAME_VERSION (use));
+ }
+ }
+ FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_VIRTUAL_DEFS)
+ {
+ tree def = DEF_FROM_PTR (defp);
+ bitmap_set_bit (RVUSE_GEN (bb), SSA_NAME_VERSION (def));
+ }
+ }
+ }
+
+ FOR_EACH_BB (bb)
+ {
+ for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+ {
+ if (!is_gimple_reg (PHI_RESULT (phi)))
+ {
+ edge e;
+ edge_iterator ei;
+
+ tree def = PHI_RESULT (phi);
+ /* In reality, the PHI result is generated at the end of
+ each predecessor block. This will make the value
+ LVUSE_IN for the bb containing the PHI, which is
+ correct. */
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ bitmap_set_bit (RVUSE_GEN (e->src), SSA_NAME_VERSION (def));
+ }
+ }
+ }
+
+ /* Solve reaching vuses.
+
+ RVUSE_IN[BB] = Union of RVUSE_OUT of predecessors.
+ RVUSE_OUT[BB] = RVUSE_GEN[BB] U (RVUSE_IN[BB] - RVUSE_KILL[BB])
+ */
+ postorder = xmalloc (sizeof (int) * (n_basic_blocks - NUM_FIXED_BLOCKS));
+ pre_and_rev_post_order_compute (NULL, postorder, false);
+
+ changed = true;
+ while (changed)
+ {
+ int j;
+ changed = false;
+ for (j = 0; j < n_basic_blocks - NUM_FIXED_BLOCKS; j++)
+ {
+ edge e;
+ edge_iterator ei;
+ bb = BASIC_BLOCK (postorder[j]);
+
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ bitmap_ior_into (RVUSE_IN (bb), RVUSE_OUT (e->src));
+
+ changed |= bitmap_ior_and_compl (RVUSE_OUT (bb),
+ RVUSE_GEN (bb),
+ RVUSE_IN (bb),
+ RVUSE_KILL (bb));
+ }
+ }
+ free (postorder);
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ FOR_ALL_BB (bb)
+ {
+ fprintf (dump_file, "RVUSE_IN (%d) =", bb->index);
+ dump_bitmap_of_names (dump_file, RVUSE_IN (bb));
+
+ fprintf (dump_file, "RVUSE_KILL (%d) =", bb->index);
+ dump_bitmap_of_names (dump_file, RVUSE_KILL (bb));
+
+ fprintf (dump_file, "RVUSE_GEN (%d) =", bb->index);
+ dump_bitmap_of_names (dump_file, RVUSE_GEN (bb));
+
+ fprintf (dump_file, "RVUSE_OUT (%d) =", bb->index);
+ dump_bitmap_of_names (dump_file, RVUSE_OUT (bb));
+ }
+ }
+}
+
+/* Return true if we can value number the call in STMT. This is true
+ if we have a pure or constant call. */
+
+static bool
+can_value_number_call (tree stmt)
+{
+ tree call = get_call_expr_in (stmt);
+
+ if (call_expr_flags (call) & (ECF_PURE | ECF_CONST))
+ return true;
+ return false;
+}
+
+/* Return true if OP is a tree which we can perform value numbering
+ on. */
+
+static bool
+can_value_number_operation (tree op)
+{
+ return UNARY_CLASS_P (op)
+ || BINARY_CLASS_P (op)
+ || COMPARISON_CLASS_P (op)
+ || REFERENCE_CLASS_P (op)
+ || (TREE_CODE (op) == CALL_EXPR
+ && can_value_number_call (op));
+}
+
+
+/* Return true if OP is a tree which we can perform PRE on
+ on. This may not match the operations we can value number, but in
+ a perfect world would. */
+
+static bool
+can_PRE_operation (tree op)
+{
+ return UNARY_CLASS_P (op)
+ || BINARY_CLASS_P (op)
+ || COMPARISON_CLASS_P (op)
+ || TREE_CODE (op) == INDIRECT_REF
+ || TREE_CODE (op) == CALL_EXPR;
+}
+
+
+/* Inserted expressions are placed onto this worklist, which is used
+ for performing quick dead code elimination of insertions we made
+ that didn't turn out to be necessary. */
static VEC(tree,heap) *inserted_exprs;
+
+/* Pool allocated fake store expressions are placed onto this
+ worklist, which, after performing dead code elimination, is walked
+ to see which expressions need to be put into GC'able memory */
+static VEC(tree, heap) *need_creation;
+
+
/* Find a leader for an expression, or generate one using
create_expression_by_pieces if it's ANTIC but
complex.
@@ -1512,11 +2024,8 @@ find_or_generate_expression (basic_block block, tree expr, tree stmts)
if (genop == NULL)
{
genop = VALUE_HANDLE_EXPR_SET (expr)->head->expr;
- gcc_assert (UNARY_CLASS_P (genop)
- || BINARY_CLASS_P (genop)
- || COMPARISON_CLASS_P (genop)
- || REFERENCE_CLASS_P (genop)
- || TREE_CODE (genop) == CALL_EXPR);
+
+ gcc_assert (can_PRE_operation (genop));
genop = create_expression_by_pieces (block, genop, stmts);
}
return genop;
@@ -1568,9 +2077,9 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
genwalker && walker;
genwalker = TREE_CHAIN (genwalker), walker = TREE_CHAIN (walker))
{
- TREE_VALUE (genwalker) = find_or_generate_expression (block,
- TREE_VALUE (walker),
- stmts);
+ TREE_VALUE (genwalker)
+ = find_or_generate_expression (block, TREE_VALUE (walker),
+ stmts);
}
if (op2)
@@ -1582,6 +2091,16 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
}
break;
+ case tcc_reference:
+ gcc_assert (TREE_CODE (expr) == INDIRECT_REF);
+ {
+ tree op1 = TREE_OPERAND (expr, 0);
+ tree genop1 = find_or_generate_expression (block, op1, stmts);
+
+ folded = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr),
+ genop1);
+ break;
+ }
case tcc_binary:
case tcc_comparison:
@@ -1628,9 +2147,11 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
tree val = vn_lookup_or_add (forcedexpr, NULL);
VEC_safe_push (tree, heap, inserted_exprs, stmt);
- vn_add (forcedname, val, NULL);
+ vn_add (forcedname, val);
bitmap_value_replace_in_set (NEW_SETS (block), forcedname);
bitmap_value_replace_in_set (AVAIL_OUT (block), forcedname);
+ update_stmt (stmt);
+ mark_new_vars_to_rename (tsi_stmt (tsi));
}
tsi = tsi_last (stmts);
tsi_link_after (&tsi, forced_stmts, TSI_CONTINUE_LINKING);
@@ -1638,17 +2159,28 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
/* Build and insert the assignment of the end result to the temporary
that we will return. */
- temp = create_tmp_var (TREE_TYPE (expr), "pretmp");
+ if (!pretemp || TREE_TYPE (expr) != TREE_TYPE (pretemp))
+ {
+ pretemp = create_tmp_var (TREE_TYPE (expr), "pretmp");
+ get_var_ann (pretemp);
+ }
+
+ temp = pretemp;
add_referenced_tmp_var (temp);
+
if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
DECL_COMPLEX_GIMPLE_REG_P (temp) = 1;
+
newexpr = build2 (MODIFY_EXPR, TREE_TYPE (expr), temp, newexpr);
name = make_ssa_name (temp, newexpr);
TREE_OPERAND (newexpr, 0) = name;
NECESSARY (newexpr) = 0;
+
tsi = tsi_last (stmts);
tsi_link_after (&tsi, newexpr, TSI_CONTINUE_LINKING);
VEC_safe_push (tree, heap, inserted_exprs, newexpr);
+ update_stmt (newexpr);
+ mark_new_vars_to_rename (newexpr);
/* Add a value handle to the temporary.
The value may already exist in either NEW_SETS, or AVAIL_OUT, because
@@ -1656,7 +2188,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
the expression may have been represented. There is no harm in replacing
here. */
v = get_value_handle (expr);
- vn_add (name, v, NULL);
+ vn_add (name, v);
bitmap_value_replace_in_set (NEW_SETS (block), name);
bitmap_value_replace_in_set (AVAIL_OUT (block), name);
@@ -1671,14 +2203,14 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
return name;
}
-/* Insert the to-be-made-available values of NODE for each predecessor, stored
- in AVAIL, into the predecessors of BLOCK, and merge the result with a phi
- node, given the same value handle as NODE. The prefix of the phi node is
- given with TMPNAME. Return true if we have inserted new stuff. */
+/* Insert the to-be-made-available values of NODE for each
+ predecessor, stored in AVAIL, into the predecessors of BLOCK, and
+ merge the result with a phi node, given the same value handle as
+ NODE. Return true if we have inserted new stuff. */
static bool
insert_into_preds_of_block (basic_block block, value_set_node_t node,
- tree *avail, const char *tmpname)
+ tree *avail)
{
tree val = get_value_handle (node->expr);
edge pred;
@@ -1694,11 +2226,15 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
{
fprintf (dump_file, "Found partial redundancy for expression ");
print_generic_expr (dump_file, node->expr, 0);
+ fprintf (dump_file, " (");
+ print_generic_expr (dump_file, val, 0);
+ fprintf (dump_file, ")");
fprintf (dump_file, "\n");
}
/* Make sure we aren't creating an induction variable. */
- if (block->loop_depth > 0 && EDGE_COUNT (block->preds) == 2)
+ if (block->loop_depth > 0 && EDGE_COUNT (block->preds) == 2
+ && TREE_CODE_CLASS (TREE_CODE (node->expr)) != tcc_reference )
{
bool firstinsideloop = false;
bool secondinsideloop = false;
@@ -1723,11 +2259,32 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
tree builtexpr;
bprime = pred->src;
eprime = avail[bprime->index];
- if (BINARY_CLASS_P (eprime)
- || COMPARISON_CLASS_P (eprime)
- || UNARY_CLASS_P (eprime)
- || TREE_CODE (eprime) == CALL_EXPR)
+
+ if (can_PRE_operation (eprime))
{
+#ifdef ENABLE_CHECKING
+ tree vh;
+
+ /* eprime may be an invariant. */
+ vh = TREE_CODE (eprime) == VALUE_HANDLE
+ ? eprime
+ : get_value_handle (eprime);
+
+ /* ensure that the virtual uses we need reach our block. */
+ if (TREE_CODE (vh) == VALUE_HANDLE)
+ {
+ int i;
+ tree vuse;
+ for (i = 0;
+ VEC_iterate (tree, VALUE_HANDLE_VUSES (vh), i, vuse);
+ i++)
+ {
+ size_t id = SSA_NAME_VERSION (vuse);
+ gcc_assert (bitmap_bit_p (RVUSE_OUT (bprime), id)
+ || IS_EMPTY_STMT (SSA_NAME_DEF_STMT (vuse)));
+ }
+ }
+#endif
builtexpr = create_expression_by_pieces (bprime,
eprime,
stmts);
@@ -1746,17 +2303,25 @@ insert_into_preds_of_block (basic_block block, value_set_node_t node,
return false;
/* Now build a phi for the new variable. */
- temp = create_tmp_var (type, tmpname);
+ if (!prephitemp || TREE_TYPE (prephitemp) != type)
+ {
+ prephitemp = create_tmp_var (type, "prephitmp");
+ get_var_ann (prephitemp);
+ }
+
+ temp = prephitemp;
add_referenced_tmp_var (temp);
+
if (TREE_CODE (type) == COMPLEX_TYPE)
DECL_COMPLEX_GIMPLE_REG_P (temp) = 1;
temp = create_phi_node (temp, block);
+
NECESSARY (temp) = 0;
VEC_safe_push (tree, heap, inserted_exprs, temp);
FOR_EACH_EDGE (pred, ei, block->preds)
add_phi_arg (temp, avail[pred->src->index], pred);
- vn_add (PHI_RESULT (temp), val, NULL);
+ vn_add (PHI_RESULT (temp), val);
/* The value should *not* exist in PHI_GEN, or else we wouldn't be doing
this insertion, since we test for the existence of this value in PHI_GEN
@@ -1840,10 +2405,7 @@ insert_aux (basic_block block)
node;
node = node->next)
{
- if (BINARY_CLASS_P (node->expr)
- || COMPARISON_CLASS_P (node->expr)
- || UNARY_CLASS_P (node->expr)
- || TREE_CODE (node->expr) == CALL_EXPR)
+ if (can_PRE_operation (node->expr))
{
tree *avail;
tree val;
@@ -1927,8 +2489,7 @@ insert_aux (basic_block block)
partially redundant. */
if (!cant_insert && !all_same && by_some)
{
- if (insert_into_preds_of_block (block, node, avail,
- "prephitmp"))
+ if (insert_into_preds_of_block (block, node, avail))
new_stuff = true;
}
/* If all edges produce the same value and that value is
@@ -1940,11 +2501,12 @@ insert_aux (basic_block block)
{
value_set_t exprset = VALUE_HANDLE_EXPR_SET (val);
value_set_node_t node;
+
for (node = exprset->head; node; node = node->next)
{
if (TREE_CODE (node->expr) == SSA_NAME)
{
- vn_add (node->expr, eprime, NULL);
+ vn_add (node->expr, eprime);
pre_stats.constified++;
}
}
@@ -2007,7 +2569,7 @@ is_undefined_value (tree expr)
S1 and its value handle to S2.
VUSES represent the virtual use operands associated with EXPR (if
- any). They are used when computing the hash value for EXPR. */
+ any). */
static inline void
add_to_sets (tree var, tree expr, tree stmt, bitmap_set_t s1,
@@ -2020,7 +2582,7 @@ add_to_sets (tree var, tree expr, tree stmt, bitmap_set_t s1,
statements that make aliased stores). In those cases, we are
only interested in making VAR available as its own value. */
if (var != expr)
- vn_add (var, val, NULL_TREE);
+ vn_add (var, val);
if (s1)
bitmap_insert_into_set (s1, var);
@@ -2033,8 +2595,7 @@ add_to_sets (tree var, tree expr, tree stmt, bitmap_set_t s1,
replaced with the value handles of each of the operands of EXPR.
VUSES represent the virtual use operands associated with EXPR (if
- any). They are used when computing the hash value for EXPR.
- Insert EXPR's operands into the EXP_GEN set for BLOCK. */
+ any). Insert EXPR's operands into the EXP_GEN set for BLOCK. */
static inline tree
create_value_expr_from (tree expr, basic_block block, tree stmt)
@@ -2049,7 +2610,8 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
|| TREE_CODE_CLASS (code) == tcc_comparison
|| TREE_CODE_CLASS (code) == tcc_reference
|| TREE_CODE_CLASS (code) == tcc_expression
- || TREE_CODE_CLASS (code) == tcc_exceptional);
+ || TREE_CODE_CLASS (code) == tcc_exceptional
+ || TREE_CODE_CLASS (code) == tcc_declaration);
if (TREE_CODE_CLASS (code) == tcc_unary)
pool = unary_node_pool;
@@ -2167,21 +2729,6 @@ create_value_expr_from (tree expr, basic_block block, tree stmt)
}
-/* Return true if we can value number a call. This is true if we have
- a pure or constant call. */
-static bool
-can_value_number_call (tree stmt)
-{
- tree call = get_call_expr_in (stmt);
-
- /* This is a temporary restriction until we translate vuses through
- phi nodes. This is only needed for PRE, of course. */
- if (!in_fre && !ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
- return false;
- if (call_expr_flags (call) & (ECF_PURE | ECF_CONST))
- return true;
- return false;
-}
/* Insert extra phis to merge values that are fully available from
preds of BLOCK, but have no dominating representative coming from
@@ -2221,7 +2768,16 @@ insert_extra_phis (basic_block block, basic_block dom)
{
tree name = ssa_name (i);
tree val = get_value_handle (name);
- tree temp = create_tmp_var (TREE_TYPE (name), "mergephitmp");
+ tree temp;
+
+ if (!mergephitemp
+ || TREE_TYPE (name) != TREE_TYPE (mergephitemp))
+ {
+ mergephitemp = create_tmp_var (TREE_TYPE (name),
+ "mergephitmp");
+ get_var_ann (mergephitemp);
+ }
+ temp = mergephitemp;
if (dump_file && (dump_flags & TDF_DETAILS))
{
@@ -2249,7 +2805,7 @@ insert_extra_phis (basic_block block, basic_block dom)
}
}
- vn_add (PHI_RESULT (temp), val, NULL);
+ vn_add (PHI_RESULT (temp), val);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\n");
@@ -2329,6 +2885,174 @@ try_look_through_load (tree lhs, tree mem_ref, tree stmt, basic_block block)
return false;
}
+/* Return a copy of NODE that is stored in the temporary alloc_pool's.
+ This is made recursively true, so that the operands are stored in
+ the pool as well. */
+
+static tree
+poolify_tree (tree node)
+{
+ switch (TREE_CODE (node))
+ {
+ case INDIRECT_REF:
+ {
+ tree temp = pool_alloc (reference_node_pool);
+ memcpy (temp, node, tree_size (node));
+ TREE_OPERAND (temp, 0) = poolify_tree (TREE_OPERAND (temp, 0));
+ return temp;
+ }
+ break;
+ case MODIFY_EXPR:
+ {
+ tree temp = pool_alloc (modify_expr_node_pool);
+ memcpy (temp, node, tree_size (node));
+ TREE_OPERAND (temp, 0) = poolify_tree (TREE_OPERAND (temp, 0));
+ TREE_OPERAND (temp, 1) = poolify_tree (TREE_OPERAND (temp, 1));
+ return temp;
+ }
+ break;
+ case SSA_NAME:
+ case INTEGER_CST:
+ case STRING_CST:
+ case REAL_CST:
+ case PARM_DECL:
+ case VAR_DECL:
+ case RESULT_DECL:
+ return node;
+ default:
+ gcc_unreachable ();
+ }
+}
+
+static tree modify_expr_template;
+
+/* Allocate a MODIFY_EXPR with TYPE, and operands OP1, OP2 in the
+ alloc pools and return it. */
+static tree
+poolify_modify_expr (tree type, tree op1, tree op2)
+{
+ if (modify_expr_template == NULL)
+ modify_expr_template = build2 (MODIFY_EXPR, type, op1, op2);
+
+ TREE_OPERAND (modify_expr_template, 0) = op1;
+ TREE_OPERAND (modify_expr_template, 1) = op2;
+ TREE_TYPE (modify_expr_template) = type;
+
+ return poolify_tree (modify_expr_template);
+}
+
+
+/* For each real store operation of the form
+ *a = <value> that we see, create a corresponding fake store of the
+ form storetmp_<version> = *a.
+
+ This enables AVAIL computation to mark the results of stores as
+ available. Without this, you'd need to do some computation to
+ mark the result of stores as ANTIC and AVAIL at all the right
+ points.
+ To save memory, we keep the store
+ statements pool allocated until we decide whether they are
+ necessary or not. */
+
+static void
+insert_fake_stores (void)
+{
+ basic_block block;
+
+ FOR_ALL_BB (block)
+ {
+ block_stmt_iterator bsi;
+ for (bsi = bsi_start (block); !bsi_end_p (bsi); bsi_next (&bsi))
+ {
+ tree stmt = bsi_stmt (bsi);
+
+ /* We can't generate SSA names for stores that are complex
+ or aggregate. We also want to ignore things whose
+ virtual uses occur in abnormal phis. */
+
+ if (TREE_CODE (stmt) == MODIFY_EXPR
+ && TREE_CODE (TREE_OPERAND (stmt, 0)) == INDIRECT_REF
+ && !AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (stmt, 0)))
+ && TREE_CODE (TREE_TYPE (TREE_OPERAND (stmt, 0))) != COMPLEX_TYPE)
+ {
+ ssa_op_iter iter;
+ def_operand_p defp;
+ tree lhs = TREE_OPERAND (stmt, 0);
+ tree rhs = TREE_OPERAND (stmt, 1);
+ tree new;
+ bool notokay = false;
+
+ FOR_EACH_SSA_DEF_OPERAND (defp, stmt, iter, SSA_OP_VIRTUAL_DEFS)
+ {
+ tree defvar = DEF_FROM_PTR (defp);
+ if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (defvar))
+ {
+ notokay = true;
+ break;
+ }
+ }
+
+ if (notokay)
+ continue;
+
+ if (!storetemp || TREE_TYPE (rhs) != TREE_TYPE (storetemp))
+ {
+ storetemp = create_tmp_var (TREE_TYPE (rhs), "storetmp");
+ get_var_ann (storetemp);
+ }
+
+ new = poolify_modify_expr (TREE_TYPE (stmt), storetemp, lhs);
+
+ lhs = make_ssa_name (storetemp, new);
+ TREE_OPERAND (new, 0) = lhs;
+ create_ssa_artficial_load_stmt (new, stmt);
+
+ NECESSARY (new) = 0;
+ VEC_safe_push (tree, heap, inserted_exprs, new);
+ VEC_safe_push (tree, heap, need_creation, new);
+ bsi_insert_after (&bsi, new, BSI_NEW_STMT);
+ }
+ }
+ }
+}
+
+/* Turn the pool allocated fake stores that we created back into real
+ GC allocated ones if they turned out to be necessary to PRE some
+ expressions. */
+
+static void
+realify_fake_stores (void)
+{
+ unsigned int i;
+ tree stmt;
+
+ for (i = 0; VEC_iterate (tree, need_creation, i, stmt); i++)
+ {
+ if (NECESSARY (stmt))
+ {
+ block_stmt_iterator bsi;
+ tree newstmt;
+
+ /* Mark the temp variable as referenced */
+ add_referenced_tmp_var (SSA_NAME_VAR (TREE_OPERAND (stmt, 0)));
+
+ /* Put the new statement in GC memory, fix up the annotation
+ and SSA_NAME_DEF_STMT on it, and then put it in place of
+ the old statement in the IR stream. */
+ newstmt = unshare_expr (stmt);
+ SSA_NAME_DEF_STMT (TREE_OPERAND (newstmt, 0)) = newstmt;
+
+ newstmt->common.ann = stmt->common.ann;
+
+ bsi = bsi_for_stmt (stmt);
+ bsi_replace (&bsi, newstmt, true);
+ }
+ else
+ release_defs (stmt);
+ }
+}
+
+
/* Compute the AVAIL set for all basic blocks.
This function performs value numbering of the statements in each basic
@@ -2410,10 +3134,10 @@ compute_avail (void)
stmt = bsi_stmt (bsi);
ann = stmt_ann (stmt);
- /* We are only interested in assignments of the form
- X_i = EXPR, where EXPR represents an "interesting"
- computation, it has no volatile operands and X_i
- doesn't flow through an abnormal edge. */
+ /* For regular value numbering, we are only interested in
+ assignments of the form X_i = EXPR, where EXPR represents
+ an "interesting" computation, it has no volatile operands
+ and X_i doesn't flow through an abnormal edge. */
if (TREE_CODE (stmt) == MODIFY_EXPR
&& !ann->has_volatile_ops
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == SSA_NAME
@@ -2429,17 +3153,11 @@ compute_avail (void)
continue;
STRIP_USELESS_TYPE_CONVERSION (rhs);
- if (UNARY_CLASS_P (rhs)
- || BINARY_CLASS_P (rhs)
- || COMPARISON_CLASS_P (rhs)
- || REFERENCE_CLASS_P (rhs)
- || (TREE_CODE (rhs) == CALL_EXPR
- && can_value_number_call (stmt)))
+ if (can_value_number_operation (rhs))
{
- /* For binary, unary, and reference expressions,
- create a duplicate expression with the operands
- replaced with the value handles of the original
- RHS. */
+ /* For value numberable operation, create a
+ duplicate expression with the operands replaced
+ with the value handles of the original RHS. */
tree newt = create_value_expr_from (rhs, block, stmt);
if (newt)
{
@@ -2582,6 +3300,9 @@ mark_operand_necessary (tree op)
gcc_assert (op);
+ if (TREE_CODE (op) != SSA_NAME)
+ return NULL;
+
stmt = SSA_NAME_DEF_STMT (op);
gcc_assert (stmt);
@@ -2614,14 +3335,12 @@ remove_dead_inserted_code (void)
while (VEC_length (tree, worklist) > 0)
{
t = VEC_pop (tree, worklist);
+
+ /* PHI nodes are somewhat special in that each PHI alternative has
+ data and control dependencies. All the statements feeding the
+ PHI node's arguments are always necessary. */
if (TREE_CODE (t) == PHI_NODE)
{
- /* PHI nodes are somewhat special in that each PHI alternative has
- data and control dependencies. All the statements feeding the
- PHI node's arguments are always necessary. In aggressive mode,
- we also consider the control dependent edges leading to the
- predecessor block associated with each PHI alternative as
- necessary. */
int k;
VEC_reserve (tree, heap, worklist, PHI_NUM_ARGS (t));
@@ -2657,16 +3376,19 @@ remove_dead_inserted_code (void)
}
}
}
+
for (i = 0; VEC_iterate (tree, inserted_exprs, i, t); i++)
{
if (!NECESSARY (t))
{
block_stmt_iterator bsi;
+
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Removing unnecessary insertion:");
print_generic_stmt (dump_file, t, 0);
}
+
if (TREE_CODE (t) == PHI_NODE)
{
remove_phi_node (t, NULL);
@@ -2675,11 +3397,13 @@ remove_dead_inserted_code (void)
{
bsi = bsi_for_stmt (t);
bsi_remove (&bsi);
+ release_defs (t);
}
}
}
VEC_free (tree, heap, worklist);
}
+
/* Initialize data structures used by PRE. */
static void
@@ -2690,9 +3414,16 @@ init_pre (bool do_fre)
in_fre = do_fre;
inserted_exprs = NULL;
+ need_creation = NULL;
+ pretemp = NULL_TREE;
+ storetemp = NULL_TREE;
+ mergephitemp = NULL_TREE;
+ prephitemp = NULL_TREE;
+
vn_init ();
if (!do_fre)
current_loops = loop_optimizer_init (dump_file);
+
connect_infinite_loops_to_exit ();
memset (&pre_stats, 0, sizeof (pre_stats));
@@ -2733,6 +3464,11 @@ init_pre (bool do_fre)
tree_code_size (TREE_LIST), 30);
comparison_node_pool = create_alloc_pool ("Comparison tree nodes",
tree_code_size (EQ_EXPR), 30);
+ modify_expr_node_pool = create_alloc_pool ("MODIFY_EXPR nodes",
+ tree_code_size (MODIFY_EXPR),
+ 30);
+ modify_expr_template = NULL;
+
FOR_ALL_BB (bb)
{
EXP_GEN (bb) = set_new (true);
@@ -2754,6 +3490,7 @@ fini_pre (bool do_fre)
unsigned int i;
VEC_free (tree, heap, inserted_exprs);
+ VEC_free (tree, heap, need_creation);
bitmap_obstack_release (&grand_bitmap_obstack);
free_alloc_pool (value_set_pool);
free_alloc_pool (bitmap_set_pool);
@@ -2764,6 +3501,7 @@ fini_pre (bool do_fre)
free_alloc_pool (list_node_pool);
free_alloc_pool (expression_node_pool);
free_alloc_pool (comparison_node_pool);
+ free_alloc_pool (modify_expr_node_pool);
htab_delete (phi_translate_table);
remove_fake_exit_edges ();
@@ -2804,7 +3542,6 @@ fini_pre (bool do_fre)
}
}
-
/* Main entry point to the SSA-PRE pass. DO_FRE is true if the caller
only wants to do full redundancy elimination. */
@@ -2813,6 +3550,9 @@ execute_pre (bool do_fre)
{
init_pre (do_fre);
+ if (!do_fre)
+ insert_fake_stores ();
+
/* Collect and value number expressions computed in each basic block. */
compute_avail ();
@@ -2837,8 +3577,11 @@ execute_pre (bool do_fre)
computing ANTIC, either, even though it's plenty fast. */
if (!do_fre && n_basic_blocks < 4000)
{
+ vuse_names = xcalloc (num_ssa_names, sizeof (bitmap));
+ compute_rvuse ();
compute_antic ();
insert ();
+ free (vuse_names);
}
/* Remove all the redundant expressions. */
@@ -2854,13 +3597,17 @@ execute_pre (bool do_fre)
}
bsi_commit_edge_inserts ();
+
if (!do_fre)
- remove_dead_inserted_code ();
+ {
+ remove_dead_inserted_code ();
+ realify_fake_stores ();
+ }
+
fini_pre (do_fre);
}
-
/* Gate and execute functions for PRE. */
static void
diff --git a/gcc/tree-vn.c b/gcc/tree-vn.c
index 805318736339d494172a22443a6749438d722e4d..0bc5c0309df441e56cb9176a1d623ebb86ed0d91 100644
--- a/gcc/tree-vn.c
+++ b/gcc/tree-vn.c
@@ -48,8 +48,8 @@ typedef struct val_expr_pair_d
/* Associated expression. */
tree e;
- /* for comparing Virtual uses in E. */
- tree stmt;
+ /* For comparing virtual uses in E. */
+ VEC (tree, gc) *vuses;
/* E's hash value. */
hashval_t hashcode;
@@ -77,16 +77,11 @@ make_value_handle (tree type)
any).
VAL can be used to iterate by passing previous value numbers (it is
- used by iterative_hash_expr).
-
- STMT is the stmt associated with EXPR for comparing virtual operands. */
+ used by iterative_hash_expr). */
hashval_t
-vn_compute (tree expr, hashval_t val, tree stmt)
+vn_compute (tree expr, hashval_t val)
{
- ssa_op_iter iter;
- tree vuse;
-
/* EXPR must not be a statement. We are only interested in value
numbering expressions on the RHS of assignments. */
gcc_assert (expr);
@@ -94,17 +89,9 @@ vn_compute (tree expr, hashval_t val, tree stmt)
|| expr->common.ann->common.type != STMT_ANN);
val = iterative_hash_expr (expr, val);
-
- /* If the expression has virtual uses, incorporate them into the
- hash value computed for EXPR. */
- if (stmt)
- FOR_EACH_SSA_TREE_OPERAND (vuse, stmt, iter, SSA_OP_VUSE)
- val = iterative_hash_expr (vuse, val);
-
return val;
}
-
/* Compare two expressions E1 and E2 and return true if they are
equal. */
@@ -163,15 +150,26 @@ val_expr_pair_hash (const void *p)
static int
val_expr_pair_expr_eq (const void *p1, const void *p2)
{
- bool ret;
+ int i;
+ tree vuse1;
const val_expr_pair_t ve1 = (val_expr_pair_t) p1;
const val_expr_pair_t ve2 = (val_expr_pair_t) p2;
if (! expressions_equal_p (ve1->e, ve2->e))
return false;
- ret = compare_ssa_operands_equal (ve1->stmt, ve2->stmt, SSA_OP_VUSE);
- return ret;
+ if (ve1->vuses == ve2->vuses)
+ return true;
+
+ if (VEC_length (tree, ve1->vuses) != VEC_length (tree, ve2->vuses))
+ return false;
+
+ for (i = 0; VEC_iterate (tree, ve1->vuses, i, vuse1); i++)
+ {
+ if (VEC_index (tree, ve2->vuses, i) != vuse1)
+ return false;
+ }
+ return true;
}
@@ -190,13 +188,68 @@ set_value_handle (tree e, tree v)
gcc_assert (is_gimple_min_invariant (e));
}
+/* Copy the virtual uses from STMT into a newly allocated VEC(tree),
+ and return the VEC(tree). */
+
+static VEC (tree, gc) *
+copy_vuses_from_stmt (tree stmt)
+{
+ ssa_op_iter iter;
+ tree vuse;
+ VEC (tree, gc) *vuses = NULL;
+
+ if (!stmt)
+ return NULL;
+
+ FOR_EACH_SSA_TREE_OPERAND (vuse, stmt, iter, SSA_OP_VUSE)
+ VEC_safe_push (tree, gc, vuses, vuse);
+
+ return vuses;
+}
+
+/* Place for shared_vuses_from_stmt to shove vuses. */
+static VEC (tree, gc) *shared_lookup_vuses;
+
+/* Copy the virtual uses from STMT into SHARED_LOOKUP_VUSES.
+ This function will overwrite the current SHARED_LOOKUP_VUSES
+ variable. */
+
+static VEC (tree, gc) *
+shared_vuses_from_stmt (tree stmt)
+{
+ ssa_op_iter iter;
+ tree vuse;
+
+ if (!stmt)
+ return NULL;
+
+ VEC_truncate (tree, shared_lookup_vuses, 0);
+
+ FOR_EACH_SSA_TREE_OPERAND (vuse, stmt, iter, SSA_OP_VUSE)
+ VEC_safe_push (tree, gc, shared_lookup_vuses, vuse);
+
+ if (VEC_length (tree, shared_lookup_vuses) > 1)
+ sort_vuses (shared_lookup_vuses);
+
+ return shared_lookup_vuses;
+}
+
+/* Insert EXPR into VALUE_TABLE with value VAL, and add expression
+ EXPR to the value set for value VAL. */
+
+void
+vn_add (tree expr, tree val)
+{
+ vn_add_with_vuses (expr, val, NULL);
+}
/* Insert EXPR into VALUE_TABLE with value VAL, and add expression
- EXPR to the value set for value VAL. STMT represents the stmt
- associated with EXPR. It is used when computing a hash value for EXPR. */
+ EXPR to the value set for value VAL. VUSES represents the virtual
+ use operands associated with EXPR. It is used when computing a
+ hash value for EXPR. */
void
-vn_add (tree expr, tree val, tree stmt)
+vn_add_with_vuses (tree expr, tree val, VEC (tree, gc) *vuses)
{
void **slot;
val_expr_pair_t new_pair;
@@ -204,8 +257,8 @@ vn_add (tree expr, tree val, tree stmt)
new_pair = XNEW (struct val_expr_pair_d);
new_pair->e = expr;
new_pair->v = val;
- new_pair->stmt = stmt;
- new_pair->hashcode = vn_compute (expr, 0, stmt);
+ new_pair->vuses = vuses;
+ new_pair->hashcode = vn_compute (expr, 0);
slot = htab_find_slot_with_hash (value_table, new_pair, new_pair->hashcode,
INSERT);
if (*slot)
@@ -213,7 +266,8 @@ vn_add (tree expr, tree val, tree stmt)
*slot = (void *) new_pair;
set_value_handle (expr, val);
- add_to_value (val, expr);
+ if (TREE_CODE (val) == VALUE_HANDLE)
+ add_to_value (val, expr);
}
@@ -224,6 +278,17 @@ vn_add (tree expr, tree val, tree stmt)
tree
vn_lookup (tree expr, tree stmt)
+{
+ return vn_lookup_with_vuses (expr, shared_vuses_from_stmt (stmt));
+}
+
+/* Search in VALUE_TABLE for an existing instance of expression EXPR,
+ and return its value, or NULL if none has been set. VUSES is the
+ list of virtual use operands associated with EXPR. It is used when
+ computing the hash value for EXPR. */
+
+tree
+vn_lookup_with_vuses (tree expr, VEC (tree, gc) *vuses)
{
void **slot;
struct val_expr_pair_d vep = {NULL, NULL, NULL, 0};
@@ -233,8 +298,8 @@ vn_lookup (tree expr, tree stmt)
return expr;
vep.e = expr;
- vep.stmt = stmt;
- vep.hashcode = vn_compute (expr, 0, stmt);
+ vep.vuses = vuses;
+ vep.hashcode = vn_compute (expr, 0);
slot = htab_find_slot_with_hash (value_table, &vep, vep.hashcode, NO_INSERT);
if (!slot)
return NULL_TREE;
@@ -243,10 +308,53 @@ vn_lookup (tree expr, tree stmt)
}
+/* A comparison function for use in qsort to compare vuses. Simply
+ subtracts version numbers. */
+
+static int
+vuses_compare (const void *pa, const void *pb)
+{
+ const tree vusea = *((const tree *)pa);
+ const tree vuseb = *((const tree *)pb);
+ int sn = SSA_NAME_VERSION (vusea) - SSA_NAME_VERSION (vuseb);
+
+ return sn;
+}
+
+/* Print out the "Created value <x> for <Y>" statement to the
+ dump_file.
+ This is factored because both versions of lookup use it, and it
+ obscures the real work going on in those functions. */
+
+static void
+print_creation_to_file (tree v, tree expr, VEC (tree, gc) *vuses)
+{
+ fprintf (dump_file, "Created value ");
+ print_generic_expr (dump_file, v, dump_flags);
+ fprintf (dump_file, " for ");
+ print_generic_expr (dump_file, expr, dump_flags);
+
+ if (vuses && VEC_length (tree, vuses) != 0)
+ {
+ size_t i;
+ tree vuse;
+
+ fprintf (dump_file, " vuses: (");
+ for (i = 0; VEC_iterate (tree, vuses, i, vuse); i++)
+ {
+ print_generic_expr (dump_file, vuse, dump_flags);
+ if (VEC_length (tree, vuses) - 1 != i)
+ fprintf (dump_file, ",");
+ }
+ fprintf (dump_file, ")");
+ }
+ fprintf (dump_file, "\n");
+}
+
/* Like vn_lookup, but creates a new value for expression EXPR, if
EXPR doesn't already have a value. Return the existing/created
- value for EXPR. STMT represents the stmt associated with EXPR. It is used
- when computing the hash value for EXPR. */
+ value for EXPR. STMT represents the stmt associated with EXPR. It
+ is used when computing the VUSES for EXPR. */
tree
vn_lookup_or_add (tree expr, tree stmt)
@@ -254,18 +362,17 @@ vn_lookup_or_add (tree expr, tree stmt)
tree v = vn_lookup (expr, stmt);
if (v == NULL_TREE)
{
+ VEC(tree,gc) *vuses;
+
v = make_value_handle (TREE_TYPE (expr));
+ vuses = copy_vuses_from_stmt (stmt);
+ sort_vuses (vuses);
if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "Created value ");
- print_generic_expr (dump_file, v, dump_flags);
- fprintf (dump_file, " for ");
- print_generic_expr (dump_file, expr, dump_flags);
- fprintf (dump_file, "\n");
- }
+ print_creation_to_file (v, expr, vuses);
- vn_add (expr, v, stmt);
+ VALUE_HANDLE_VUSES (v) = vuses;
+ vn_add_with_vuses (expr, v, vuses);
}
set_value_handle (expr, v);
@@ -273,6 +380,46 @@ vn_lookup_or_add (tree expr, tree stmt)
return v;
}
+/* Sort the VUSE array so that we can do equality comparisons
+ quicker on two vuse vecs. */
+
+void
+sort_vuses (VEC (tree,gc) *vuses)
+{
+ if (VEC_length (tree, vuses) > 1)
+ qsort (VEC_address (tree, vuses),
+ VEC_length (tree, vuses),
+ sizeof (tree),
+ vuses_compare);
+}
+
+/* Like vn_lookup, but creates a new value for expression EXPR, if
+ EXPR doesn't already have a value. Return the existing/created
+ value for EXPR. STMT represents the stmt associated with EXPR. It is used
+ when computing the hash value for EXPR. */
+
+tree
+vn_lookup_or_add_with_vuses (tree expr, VEC (tree, gc) *vuses)
+{
+ tree v = vn_lookup_with_vuses (expr, vuses);
+ if (v == NULL_TREE)
+ {
+ v = make_value_handle (TREE_TYPE (expr));
+ sort_vuses (vuses);
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ print_creation_to_file (v, expr, vuses);
+
+ VALUE_HANDLE_VUSES (v) = vuses;
+ vn_add_with_vuses (expr, v, vuses);
+ }
+
+ set_value_handle (expr, v);
+
+ return v;
+}
+
+
/* Get the value handle of EXPR. This is the only correct way to get
the value handle for a "thing". If EXPR does not have a value
@@ -306,6 +453,7 @@ vn_init (void)
{
value_table = htab_create (511, val_expr_pair_hash,
val_expr_pair_expr_eq, free);
+ shared_lookup_vuses = NULL;
}
@@ -315,5 +463,6 @@ void
vn_delete (void)
{
htab_delete (value_table);
+ VEC_free (tree, gc, shared_lookup_vuses);
value_table = NULL;
}
diff --git a/gcc/tree.h b/gcc/tree.h
index 0efe68337a6e59ff47d57d4a03dc02f6755ccfb0..78c3bc33738abf1cd0e250d41fb63b1e6e809eb6 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -2814,6 +2814,9 @@ struct tree_statement_list
#define VALUE_HANDLE_EXPR_SET(NODE) \
(VALUE_HANDLE_CHECK (NODE)->value_handle.expr_set)
+#define VALUE_HANDLE_VUSES(NODE) \
+ (VALUE_HANDLE_CHECK (NODE)->value_handle.vuses)
+
/* Defined and used in tree-ssa-pre.c. */
struct value_set;
@@ -2828,6 +2831,9 @@ struct tree_value_handle GTY(())
conveniently dense form starting at 0, so that we can make
bitmaps of value handles. */
unsigned int id;
+
+ /* Set of virtual uses represented by this handle. */
+ VEC (tree, gc) *vuses;
};
/* Define the overall contents of a tree node.