/* Value Numbering routines for tree expressions.
- Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Daniel Berlin <dan@dberlin.org>, Steven Bosscher
<stevenb@suse.de> and Diego Novillo <dnovillo@redhat.com>
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 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. */
#include "config.h"
#include "system.h"
/* Associated expression. */
tree e;
- /* Virtual uses in E. */
- vuse_optype vuses;
+ /* for comparing Virtual uses in E. */
+ tree stmt;
/* E's hash value. */
hashval_t hashcode;
VAL can be used to iterate by passing previous value numbers (it is
used by iterative_hash_expr).
- VUSES is the set of virtual use operands associated with EXPR. It
- may be NULL if EXPR has no virtual operands. */
+ STMT is the stmt associated with EXPR for comparing virtual operands. */
hashval_t
-vn_compute (tree expr, hashval_t val, vuse_optype vuses)
+vn_compute (tree expr, hashval_t val, tree stmt)
{
- size_t i;
+ 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. */
/* If the expression has virtual uses, incorporate them into the
hash value computed for EXPR. */
- for (i = 0; i < NUM_VUSES (vuses); i++)
- val = iterative_hash_expr (VUSE_OP (vuses, i), val);
+ if (stmt)
+ FOR_EACH_SSA_TREE_OPERAND (vuse, stmt, iter, SSA_OP_VUSE)
+ val = iterative_hash_expr (vuse, val);
return val;
}
te1 = TREE_TYPE (e1);
te2 = TREE_TYPE (e2);
- if (TREE_CODE (e1) == TREE_CODE (e2)
- && (te1 == te2 || lang_hooks.types_compatible_p (te1, te2))
- && operand_equal_p (e1, e2, OEP_PURE_SAME))
+ if (TREE_CODE (e1) == TREE_LIST && TREE_CODE (e2) == TREE_LIST)
+ {
+ tree lop1 = e1;
+ tree lop2 = e2;
+ for (lop1 = e1, lop2 = e2;
+ lop1 || lop2;
+ lop1 = TREE_CHAIN (lop1), lop2 = TREE_CHAIN (lop2))
+ {
+ if (!lop1 || !lop2)
+ return false;
+ if (!expressions_equal_p (TREE_VALUE (lop1), TREE_VALUE (lop2)))
+ return false;
+ }
+ return true;
+
+ }
+ else if (TREE_CODE (e1) == TREE_CODE (e2)
+ && (te1 == te2 || lang_hooks.types_compatible_p (te1, te2))
+ && operand_equal_p (e1, e2, OEP_PURE_SAME))
return true;
return false;
static int
val_expr_pair_expr_eq (const void *p1, const void *p2)
{
+ bool ret;
const val_expr_pair_t ve1 = (val_expr_pair_t) p1;
const val_expr_pair_t ve2 = (val_expr_pair_t) p2;
- size_t i;
if (! expressions_equal_p (ve1->e, ve2->e))
return false;
- if (NUM_VUSES (ve1->vuses) != NUM_VUSES (ve2->vuses))
- return false;
-
- for (i = 0; i < NUM_VUSES (ve1->vuses); i++)
- if (! expressions_equal_p (VUSE_OP (ve1->vuses, i),
- VUSE_OP (ve2->vuses, i)))
- return false;
-
- return true;
+ ret = compare_ssa_operands_equal (ve1->stmt, ve2->stmt, SSA_OP_VUSE);
+ return ret;
}
-/* Set the value handle for expression E to value V */
+/* Set the value handle for expression E to value V. */
static void
set_value_handle (tree e, tree v)
{
if (TREE_CODE (e) == SSA_NAME)
SSA_NAME_VALUE (e) = v;
- else if (EXPR_P (e) || DECL_P (e))
+ else if (EXPR_P (e) || DECL_P (e) || TREE_CODE (e) == TREE_LIST)
get_tree_ann (e)->common.value_handle = v;
else
/* Do nothing. Constants are their own value handles. */
/* Insert EXPR into VALUE_TABLE with value VAL, and add expression
- EXPR to the value set for value VAL. VUSES represent the virtual
- use operands associated with EXPR (if any). They are used when
- computing the hash value for EXPR. */
+ 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. */
void
-vn_add (tree expr, tree val, vuse_optype vuses)
+vn_add (tree expr, tree val, tree stmt)
{
void **slot;
val_expr_pair_t new_pair;
new_pair = xmalloc (sizeof (struct val_expr_pair_d));
new_pair->e = expr;
new_pair->v = val;
- new_pair->vuses = vuses;
- new_pair->hashcode = vn_compute (expr, 0, vuses);
+ new_pair->stmt = stmt;
+ new_pair->hashcode = vn_compute (expr, 0, stmt);
slot = htab_find_slot_with_hash (value_table, new_pair, new_pair->hashcode,
INSERT);
if (*slot)
/* Search in VALUE_TABLE for an existing instance of expression EXPR,
- and return its value, or NULL if none has been set. VUSES
- represent the virtual use operands associated with EXPR (if any).
- They are used when computing the hash value for EXPR. */
+ and return its value, or NULL if none has been set. STMT
+ represents the stmt associated with EXPR. It is used when computing the
+ hash value for EXPR. */
tree
-vn_lookup (tree expr, vuse_optype vuses)
+vn_lookup (tree expr, tree stmt)
{
void **slot;
struct val_expr_pair_d vep = {NULL, NULL, NULL, 0};
return expr;
vep.e = expr;
- vep.vuses = vuses;
- vep.hashcode = vn_compute (expr, 0, vuses);
+ vep.stmt = stmt;
+ vep.hashcode = vn_compute (expr, 0, stmt);
slot = htab_find_slot_with_hash (value_table, &vep, vep.hashcode, NO_INSERT);
if (!slot)
return NULL_TREE;
/* 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. VUSES represent the virtual use operands
- associated with EXPR (if any). They are used when computing the
- hash value for EXPR. */
+ 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 (tree expr, vuse_optype vuses)
+vn_lookup_or_add (tree expr, tree stmt)
{
- tree v = vn_lookup (expr, vuses);
+ tree v = vn_lookup (expr, stmt);
if (v == NULL_TREE)
{
v = make_value_handle (TREE_TYPE (expr));
fprintf (dump_file, "\n");
}
- vn_add (expr, v, vuses);
+ vn_add (expr, v, stmt);
}
set_value_handle (expr, 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
- handle associated, it returns NULL_TREE. */
+ handle associated, it returns NULL_TREE.
+ NB: If EXPR is min_invariant, this function is *required* to return EXPR. */
tree
get_value_handle (tree expr)
{
+
+ if (is_gimple_min_invariant (expr))
+ return expr;
+
if (TREE_CODE (expr) == SSA_NAME)
return SSA_NAME_VALUE (expr);
- else if (EXPR_P (expr) || DECL_P (expr))
+ else if (EXPR_P (expr) || DECL_P (expr) || TREE_CODE (expr) == TREE_LIST)
{
tree_ann_t ann = tree_ann (expr);
return ((ann) ? ann->common.value_handle : NULL_TREE);
}
else
- {
- gcc_assert (is_gimple_min_invariant (expr));
- return expr;
- }
+ gcc_unreachable ();
}
OSDN Git Service
