* tree-nested.c (get_trampoline_type): Fix thinko.

[pf3gnuchains/gcc-fork.git] / gcc / tree-ssa-dom.c

diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 0241155..7bed1c2 100644 (file)
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -7,7 +7,7 @@ This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
 any later version.
 
 GCC is distributed in the hope that it will be useful,
@@ -16,9 +16,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 #include "config.h"
 #include "system.h"
@@ -1515,8 +1514,8 @@ eliminate_redundant_computations (tree stmt)
   if (cached_lhs
       && ((TREE_CODE (cached_lhs) != SSA_NAME
           && (modify_expr_p
-              || tree_ssa_useless_type_conversion_1 (TREE_TYPE (*expr_p),
-                                                     TREE_TYPE (cached_lhs))))
+              || useless_type_conversion_p (TREE_TYPE (*expr_p),
+                                           TREE_TYPE (cached_lhs))))
          || may_propagate_copy (*expr_p, cached_lhs)))
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
@@ -1541,8 +1540,8 @@ eliminate_redundant_computations (tree stmt)
        retval = true;
       
       if (modify_expr_p
-         && !tree_ssa_useless_type_conversion_1 (TREE_TYPE (*expr_p),
-                                                 TREE_TYPE (cached_lhs)))
+         && !useless_type_conversion_p (TREE_TYPE (*expr_p),
+                                       TREE_TYPE (cached_lhs)))
        cached_lhs = fold_convert (TREE_TYPE (*expr_p), cached_lhs);
 
       propagate_tree_value (expr_p, cached_lhs);
@@ -1680,7 +1679,7 @@ cprop_operand (tree stmt, use_operand_p op_p)
         propagation opportunity.  */
       if (TREE_CODE (val) != SSA_NAME)
        {
-         if (!lang_hooks.types_compatible_p (op_type, val_type))
+         if (!useless_type_conversion_p (op_type, val_type))
            {
              val = fold_convert (TREE_TYPE (op), val);
              if (!is_gimple_min_invariant (val))
@@ -1997,8 +1996,8 @@ lookup_avail_expr (tree stmt, bool insert)
 static hashval_t
 avail_expr_hash (const void *p)
 {
-  tree stmt = ((struct expr_hash_elt *)p)->stmt;
-  tree rhs = ((struct expr_hash_elt *)p)->rhs;
+  tree stmt = ((const struct expr_hash_elt *)p)->stmt;
+  tree rhs = ((const struct expr_hash_elt *)p)->rhs;
   tree vuse;
   ssa_op_iter iter;
   hashval_t val = 0;
@@ -2033,10 +2032,10 @@ real_avail_expr_hash (const void *p)
 static int
 avail_expr_eq (const void *p1, const void *p2)
 {
-  tree stmt1 = ((struct expr_hash_elt *)p1)->stmt;
-  tree rhs1 = ((struct expr_hash_elt *)p1)->rhs;
-  tree stmt2 = ((struct expr_hash_elt *)p2)->stmt;
-  tree rhs2 = ((struct expr_hash_elt *)p2)->rhs;
+  tree stmt1 = ((const struct expr_hash_elt *)p1)->stmt;
+  tree rhs1 = ((const struct expr_hash_elt *)p1)->rhs;
+  tree stmt2 = ((const struct expr_hash_elt *)p2)->stmt;
+  tree rhs2 = ((const struct expr_hash_elt *)p2)->rhs;
 
   /* If they are the same physical expression, return true.  */
   if (rhs1 == rhs2 && stmt1 == stmt2)
@@ -2048,13 +2047,12 @@ avail_expr_eq (const void *p1, const void *p2)
 
   /* In case of a collision, both RHS have to be identical and have the
      same VUSE operands.  */
-  if ((TREE_TYPE (rhs1) == TREE_TYPE (rhs2)
-       || lang_hooks.types_compatible_p (TREE_TYPE (rhs1), TREE_TYPE (rhs2)))
+  if (types_compatible_p (TREE_TYPE (rhs1), TREE_TYPE (rhs2))
       && operand_equal_p (rhs1, rhs2, OEP_PURE_SAME))
     {
       bool ret = compare_ssa_operands_equal (stmt1, stmt2, SSA_OP_VUSE);
-      gcc_assert (!ret || ((struct expr_hash_elt *)p1)->hash
-                 == ((struct expr_hash_elt *)p2)->hash);
+      gcc_assert (!ret || ((const struct expr_hash_elt *)p1)->hash
+                 == ((const struct expr_hash_elt *)p2)->hash);
       return ret;
     }