tree-vectorizer.c (slpeel_add_loop_guard): Fix types.

2008-09-11  Richard Guenther  <rguenther@suse.de>

	* tree-vectorizer.c (slpeel_add_loop_guard): Fix types.
	(set_prologue_iterations): Likewise.
	* tree-vect-transform.c (vect_create_addr_base_for_vector_ref):
	Likewise.
	(vect_update_init_of_dr): Likewise.
	* tree-ssa-forwprop.c (forward_propagate_addr_expr_1): Fix
	type verification.
	* fold-const.c (fold_unary): Do not generate calculations
	in sub-types.

From-SVN: r140291

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 2f4e784fc632b320667ed7b29af87480781de8c8..33de0138db08b747c059d38d0c0f6057cf62e31c 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,15 @@
+2008-09-11  Richard Guenther  <rguenther@suse.de>
+
+       * tree-vectorizer.c (slpeel_add_loop_guard): Fix types.
+       (set_prologue_iterations): Likewise.
+       * tree-vect-transform.c (vect_create_addr_base_for_vector_ref):
+       Likewise.
+       (vect_update_init_of_dr): Likewise.
+       * tree-ssa-forwprop.c (forward_propagate_addr_expr_1): Fix
+       type verification.
+       * fold-const.c (fold_unary): Do not generate calculations
+       in sub-types.
+
 2008-09-11  Paolo Bonzini  <bonzini@gnu.org>
 
        * dojump.c (do_jump) [BIT_AND_EXPR]: Move below.  Fall through to

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index aea7a653b188ceda01629c072776df2b163f006e..2c822b561e2fe79e6f9b0e37bc61db2602d235d1 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -7883,7 +7883,9 @@ fold_unary (enum tree_code code, tree type, tree op0)
         transformation effectively doesn't preserve non-maximal ranges.  */
       if (TREE_CODE (type) == INTEGER_TYPE
          && TREE_CODE (op0) == BIT_AND_EXPR
-         && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
+         && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST
+         /* Not if the conversion is to the sub-type.  */
+         && TREE_TYPE (type) != TREE_TYPE (op0))
        {
          tree and = op0;
          tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);

diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index bf860d9075878cbef9c2fc97c505efd875599cca..3513ee09e9f77a8997a5e3d63e781b189cf4b90e 100644 (file)
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -834,7 +834,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
   if (TREE_CODE (rhs2) == SSA_NAME
       /* Avoid problems with IVopts creating PLUS_EXPRs with a
         different type than their operands.  */
-      && useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (name)))
+      && useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (def_rhs)))
     return forward_propagate_addr_into_variable_array_index (rhs2, def_rhs,
                                                             use_stmt_gsi);
   return false;

diff --git a/gcc/tree-vect-transform.c b/gcc/tree-vect-transform.c
index a889836f298b0fb604fb1db00998ccbed664d013..d69ce51814b7fe3f80e82490e189e939b29a342a 100644 (file)
--- a/gcc/tree-vect-transform.c
+++ b/gcc/tree-vect-transform.c
@@ -918,9 +918,10 @@ vect_create_addr_base_for_vector_ref (gimple stmt,
   gimple_seq_add_seq (new_stmt_list, seq);
 
   /* Create base_offset */
-  base_offset = size_binop (PLUS_EXPR, base_offset, init);
-  base_offset = fold_convert (sizetype, base_offset);
-  dest = create_tmp_var (TREE_TYPE (base_offset), "base_off");
+  base_offset = size_binop (PLUS_EXPR,
+                           fold_convert (sizetype, base_offset),
+                           fold_convert (sizetype, init));
+  dest = create_tmp_var (sizetype, "base_off");
   add_referenced_var (dest);
   base_offset = force_gimple_operand (base_offset, &seq, true, dest);
   gimple_seq_add_seq (new_stmt_list, seq);
@@ -930,8 +931,9 @@ vect_create_addr_base_for_vector_ref (gimple stmt,
       tree tmp = create_tmp_var (sizetype, "offset");
 
       add_referenced_var (tmp);
-      offset = fold_build2 (MULT_EXPR, TREE_TYPE (offset), offset, step);
-      base_offset = fold_build2 (PLUS_EXPR, TREE_TYPE (base_offset),
+      offset = fold_build2 (MULT_EXPR, sizetype,
+                           fold_convert (sizetype, offset), step);
+      base_offset = fold_build2 (PLUS_EXPR, sizetype,
                                 base_offset, offset);
       base_offset = force_gimple_operand (base_offset, &seq, false, tmp);
       gimple_seq_add_seq (new_stmt_list, seq);
@@ -7632,8 +7634,10 @@ vect_update_init_of_dr (struct data_reference *dr, tree niters)
 {
   tree offset = DR_OFFSET (dr);
       
-  niters = fold_build2 (MULT_EXPR, TREE_TYPE (niters), niters, DR_STEP (dr));
-  offset = fold_build2 (PLUS_EXPR, TREE_TYPE (offset), offset, niters);
+  niters = fold_build2 (MULT_EXPR, sizetype,
+                       fold_convert (sizetype, niters),
+                       fold_convert (sizetype, DR_STEP (dr)));
+  offset = fold_build2 (PLUS_EXPR, sizetype, offset, niters);
   DR_OFFSET (dr) = offset;
 }
 

diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c
index 40d1302c723388f8d39c2dddfd8715e03d847213..47821e89a9e558b02aa52ce627036633d1e872f9 100644 (file)
--- a/gcc/tree-vectorizer.c
+++ b/gcc/tree-vectorizer.c
@@ -940,10 +940,9 @@ slpeel_add_loop_guard (basic_block guard_bb, tree cond, basic_block exit_bb,
   enter_e->flags |= EDGE_FALSE_VALUE;
   gsi = gsi_last_bb (guard_bb);
 
-  cond =
-    force_gimple_operand (cond, &gimplify_stmt_list, true,
-                         NULL_TREE);
-  cond_stmt = gimple_build_cond (NE_EXPR, cond, integer_zero_node,
+  cond = force_gimple_operand (cond, &gimplify_stmt_list, true, NULL_TREE);
+  cond_stmt = gimple_build_cond (NE_EXPR,
+                                cond, build_int_cst (TREE_TYPE (cond), 0),
                                 NULL_TREE, NULL_TREE);
   if (gimplify_stmt_list)
     gsi_insert_seq_after (&gsi, gimplify_stmt_list, GSI_NEW_STMT);
@@ -1073,7 +1072,8 @@ set_prologue_iterations (basic_block bb_before_first_loop,
     force_gimple_operand (cost_pre_condition, &gimplify_stmt_list,
                          true, NULL_TREE);
   cond_stmt = gimple_build_cond (NE_EXPR, cost_pre_condition,
-                                integer_zero_node, NULL_TREE, NULL_TREE);
+                                build_int_cst (TREE_TYPE (cost_pre_condition),
+                                               0), NULL_TREE, NULL_TREE);
 
   gsi = gsi_last_bb (cond_bb);
   if (gimplify_stmt_list)