{
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;
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;
}
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;
}
/* 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. */
}
/* Compute offset. */
- *initial_offset = fold_convert (sizetype,
+ *initial_offset = fold_convert (ssizetype,
fold (build2 (code, TREE_TYPE (left_offset),
left_offset,
right_offset)));
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;
/* 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;
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: */
&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;
/* 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)
{
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);
*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))
{
&& 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);
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);
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. */
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;