tree-vectorizer.c (vect_analyze_offset_expr): Use ssizetype instead sizetype.

2005-01-31  Ira Rosen  <irar@il.ibm.com>

        * tree-vectorizer.c (vect_analyze_offset_expr): Use ssizetype instead
        sizetype.
        (vect_get_base_and_offset): Use ssizetype instead sizetype. Remove
        redundant fold. Fix misalignment for MINUS_EXPR.
        (vect_compute_data_ref_alignment): Use ssizetype instead sizetype.
        (vect_analyze_pointer_ref_access): Likewise.
        (vect_get_memtag_and_dr): Likewise.

From-SVN: r94480

1 files changed, 45 insertions, 44 deletions

diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c
index d0892bc..6e2b91a 100644
--- a/gcc/tree-vectorizer.c
+++ b/gcc/tree-vectorizer.c
@@ -1407,12 +1407,12 @@ vect_analyze_offset_expr (tree expr,
 {
   tree oprnd0;
   tree oprnd1;
-  tree left_offset = size_zero_node;
-  tree right_offset = size_zero_node;
-  tree left_misalign = size_zero_node;
-  tree right_misalign = size_zero_node;
-  tree left_step = size_zero_node;
-  tree right_step = size_zero_node;
+  tree left_offset = ssize_int (0);
+  tree right_offset = ssize_int (0);
+  tree left_misalign = ssize_int (0);
+  tree right_misalign = ssize_int (0);
+  tree left_step = ssize_int (0);
+  tree right_step = ssize_int (0);
   enum tree_code code;
   tree init, evolution;
 
@@ -1429,9 +1429,9 @@ vect_analyze_offset_expr (tree expr,
      1. Constant.  */
   if (TREE_CODE (expr) == INTEGER_CST)
     {
-      *initial_offset = fold_convert (sizetype, expr);
-      *misalign = fold_convert (sizetype, expr);      
-      *step = size_zero_node;
+      *initial_offset = fold_convert (ssizetype, expr);
+      *misalign = fold_convert (ssizetype, expr);      
+      *step = ssize_int (0);
       return true;
     }
 
@@ -1459,14 +1459,14 @@ vect_analyze_offset_expr (tree expr,
 	return false;
 
       if (TREE_CODE (init) == INTEGER_CST)
-	*misalign = fold_convert (sizetype, init);
+	*misalign = fold_convert (ssizetype, init);
       else
 	/* Not constant, misalignment cannot be calculated.  */
 	*misalign = NULL_TREE;
 
-      *initial_offset = fold_convert (sizetype, init); 
+      *initial_offset = fold_convert (ssizetype, init); 
 
-      *step = evolution ? fold_convert (sizetype, evolution) : size_zero_node;
+      *step = evolution ? fold_convert (ssizetype, evolution) : ssize_int (0);
       return true;      
     }
 
@@ -1511,8 +1511,8 @@ vect_analyze_offset_expr (tree expr,
 	  /* If the left side contains variable that cannot be substituted with 
 	     constant, we check if the right side is a multiple of ALIGNMENT.  */
 	  if (integer_zerop (size_binop (TRUNC_MOD_EXPR, right_offset, 
-					 vectype_alignment)))
-	    *misalign = size_zero_node;
+			          fold_convert (ssizetype, vectype_alignment))))
+	    *misalign = ssize_int (0);
 	  else
 	    /* If the remainder is not zero or the right side isn't constant, we 
 	       can't compute  misalignment.  */
@@ -1551,7 +1551,7 @@ vect_analyze_offset_expr (tree expr,
     }
 
   /* Compute offset.  */
-  *initial_offset = fold_convert (sizetype, 
+  *initial_offset = fold_convert (ssizetype, 
 				  fold (build2 (code, TREE_TYPE (left_offset), 
 						left_offset, 
 						right_offset)));
@@ -1602,9 +1602,9 @@ vect_get_base_and_offset (struct data_reference *dr,
 			  tree *step,
 			  bool *base_aligned_p)
 {
-  tree this_offset = size_zero_node;
-  tree this_misalign = size_zero_node;
-  tree this_step = size_zero_node;
+  tree this_offset = ssize_int (0);
+  tree this_misalign = ssize_int (0);
+  tree this_step = ssize_int (0);
   tree base = NULL_TREE;
   tree next_ref;
   tree oprnd0, oprnd1;
@@ -1624,9 +1624,9 @@ vect_get_base_and_offset (struct data_reference *dr,
     /* These cases end the recursion:  */
     case VAR_DECL:
     case PARM_DECL:
-      *initial_offset = size_zero_node;
-      *step = size_zero_node;
-      *misalign = size_zero_node;
+      *initial_offset = ssize_int (0);
+      *step = ssize_int (0);
+      *misalign = ssize_int (0);
       if (DECL_ALIGN (expr) >= TYPE_ALIGN (vectype))
 	*base_aligned_p = true;
       return expr;
@@ -1644,16 +1644,16 @@ vect_get_base_and_offset (struct data_reference *dr,
       else
 	{	  
 	  *base_aligned_p = true;
-	  *misalign = size_zero_node;
+	  *misalign = ssize_int (0);
 	}
-      *initial_offset = size_zero_node;
-      *step = size_zero_node;
+      *initial_offset = ssize_int (0);
+      *step = ssize_int (0);
       return expr;
       
     case INTEGER_CST:      
-      *initial_offset = fold_convert (sizetype, expr);
-      *misalign = fold_convert (sizetype, expr);
-      *step = size_zero_node;
+      *initial_offset = fold_convert (ssizetype, expr);
+      *misalign = fold_convert (ssizetype, expr);
+      *step = ssize_int (0);
       return expr;
 
     /* These cases continue the recursion:  */
@@ -1679,11 +1679,13 @@ vect_get_base_and_offset (struct data_reference *dr,
 				       &this_offset, &this_misalign, 
 				       &this_step, base_aligned_p);  
       /* Offset was already computed in vect_analyze_pointer_ref_access.  */
-      this_offset = size_zero_node;
+      this_offset = ssize_int (0);
 
       if (!base) 
 	this_misalign = NULL_TREE;
-
+      else
+	this_misalign = size_binop (TREE_CODE (expr), ssize_int (0),
+				    this_misalign);
       next_ref = oprnd0;
       break;
 
@@ -1712,7 +1714,7 @@ vect_get_base_and_offset (struct data_reference *dr,
 
       /* Add bit position to OFFSET and MISALIGN.  */
 
-      bit_pos_in_bytes = size_int (pbitpos/BITS_PER_UNIT);
+      bit_pos_in_bytes = ssize_int (pbitpos/BITS_PER_UNIT);
       /* Check that there is no remainder in bits.  */
       if (pbitpos%BITS_PER_UNIT)
 	{
@@ -1720,8 +1722,8 @@ vect_get_base_and_offset (struct data_reference *dr,
 	    fprintf (dump_file, "bit offset alignment.");
 	  return NULL_TREE;
 	}
-      this_offset = fold (size_binop (PLUS_EXPR, bit_pos_in_bytes, 
-				      fold_convert (sizetype, this_offset)));     
+      this_offset = size_binop (PLUS_EXPR, bit_pos_in_bytes, 
+				fold_convert (ssizetype, this_offset));     
       if (this_misalign) 
 	this_misalign = size_binop (PLUS_EXPR, this_misalign, bit_pos_in_bytes); 
 
@@ -1743,8 +1745,7 @@ vect_get_base_and_offset (struct data_reference *dr,
 
       *step = size_binop (PLUS_EXPR, *step, this_step);
 
-      *initial_offset = fold (build2 (PLUS_EXPR, TREE_TYPE (*initial_offset), 
-				      *initial_offset, this_offset));
+      *initial_offset = size_binop (PLUS_EXPR, *initial_offset, this_offset);
 
       if (vect_debug_details (NULL))
         {
@@ -4201,7 +4202,7 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
 		  && DECL_ALIGN (base) >= TYPE_ALIGN (vectype)));
 
   /* Alignment required, in bytes:  */
-  alignment = size_int (TYPE_ALIGN (vectype)/BITS_PER_UNIT);
+  alignment = ssize_int (TYPE_ALIGN (vectype)/BITS_PER_UNIT);
 
   /* Modulo alignment.  */
   misalign = size_binop (TRUNC_MOD_EXPR, misalign, alignment);
@@ -4667,14 +4668,14 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read)
       return NULL;
     }
 
-  STMT_VINFO_VECT_STEP (stmt_info) = fold_convert (sizetype, step);
+  STMT_VINFO_VECT_STEP (stmt_info) = fold_convert (ssizetype, step);
   if (TREE_CODE (init) == PLUS_EXPR 
       || TREE_CODE (init) == MINUS_EXPR)
     STMT_VINFO_VECT_INIT_OFFSET (stmt_info) = 
-      fold (size_binop (TREE_CODE (init), size_zero_node, 
-			fold_convert (sizetype, TREE_OPERAND (init, 1))));
+      size_binop (TREE_CODE (init), ssize_int (0),  
+		  fold_convert (ssizetype, TREE_OPERAND (init, 1)));
   else
-    STMT_VINFO_VECT_INIT_OFFSET (stmt_info) = size_zero_node;
+    STMT_VINFO_VECT_INIT_OFFSET (stmt_info) = ssize_int (0);
 
   indx_access_fn = 
 	build_polynomial_chrec (loopnum, integer_zero_node, integer_one_node);
@@ -4833,9 +4834,9 @@ vect_get_memtag_and_dr (tree memref, tree stmt, bool is_read,
 	  return NULL_TREE;
 	}  
 
-      offset = size_zero_node;
-      misalign = size_zero_node;
-      step = size_zero_node;
+      offset = ssize_int (0);
+      misalign = ssize_int (0);
+      step = ssize_int (0);
 
       /* Analyze data-ref, find its base, initial offset from the base, step,
 	 and alignment.  */
@@ -4850,8 +4851,8 @@ vect_get_memtag_and_dr (tree memref, tree stmt, bool is_read,
 	 vect_analyze_pointer_ref_access, we combine the values here. */
       if (STMT_VINFO_VECT_INIT_OFFSET (stmt_info))
 	STMT_VINFO_VECT_INIT_OFFSET (stmt_info) = 
-	  fold (build2 (PLUS_EXPR, TREE_TYPE (offset), offset,
-			STMT_VINFO_VECT_INIT_OFFSET (stmt_info)));		  
+	  size_binop (PLUS_EXPR, offset, 
+		      STMT_VINFO_VECT_INIT_OFFSET (stmt_info));		  
       else
 	STMT_VINFO_VECT_INIT_OFFSET (stmt_info) = offset;