OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove VEC_RSHIFT_EXPR tree code, now unused 

* fold-const.c (const_binop): Remove code handling VEC_RSHIFT_EXPR.
	* tree-cfg.c (verify_gimple_assign_binary): Likewise.
	* tree-inline.c (estimate_operator_cost): Likewise.
	* tree-pretty-print.c (dump_generic_node, op_code_prio, op_symbol_code):
	Likewise.

	* tree-vect-generic.c (expand_vector_operations_1): Remove assertion
	against VEC_RSHIFT_EXPR.

	* optabs.h (expand_vec_shift_expr): Remove.
	* optabs.c (optab_for_tree_code): Remove case VEC_RSHIFT_EXPR.
	(expand_vec_shift_expr): Remove.
	* tree.def (VEC_RSHIFT_EXPR): Remove

From-SVN: r217510
This commit is contained in:
Alan Lawrence 2014-11-13 16:35:06 +00:00 committed by Alan Lawrence
parent cf7aa6a3b7
commit 1c4188463c
11 changed files with 23 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
gcc/ChangeLog
View File

@ -1,3 +1,19 @@
2014-11-13 Alan Lawrence <alan.lawrence@arm.com>
* fold-const.c (const_binop): Remove code handling VEC_RSHIFT_EXPR.
* tree-cfg.c (verify_gimple_assign_binary): Likewise.
* tree-inline.c (estimate_operator_cost): Likewise.
* tree-pretty-print.c (dump_generic_node, op_code_prio, op_symbol_code):
Likewise.
* tree-vect-generic.c (expand_vector_operations_1): Remove assertion
against VEC_RSHIFT_EXPR.
* optabs.h (expand_vec_shift_expr): Remove.
* optabs.c (optab_for_tree_code): Remove case VEC_RSHIFT_EXPR.
(expand_vec_shift_expr): Remove.
* tree.def (VEC_RSHIFT_EXPR): Remove
2014-11-13 Alan Lawrence <alan.lawrence@arm.com>
* optabs.c (can_vec_perm_p): Update comment, does not consider vec_shr.

1
gcc/cfgexpand.c
View File

@ -4659,7 +4659,6 @@ expand_debug_expr (tree exp)
case VEC_PACK_FIX_TRUNC_EXPR:
case VEC_PACK_SAT_EXPR:
case VEC_PACK_TRUNC_EXPR:
case VEC_RSHIFT_EXPR:
case VEC_UNPACK_FLOAT_HI_EXPR:
case VEC_UNPACK_FLOAT_LO_EXPR:
case VEC_UNPACK_HI_EXPR:

6
gcc/expr.c
View File

@ -9142,12 +9142,6 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode,
return temp;
}
case VEC_RSHIFT_EXPR:
{
target = expand_vec_shift_expr (ops, target);
return target;
}
case VEC_UNPACK_HI_EXPR:
case VEC_UNPACK_LO_EXPR:
{

41
gcc/fold-const.c
View File

@ -1418,44 +1418,17 @@ const_binop (enum tree_code code, tree arg1, tree arg2)
int count = TYPE_VECTOR_SUBPARTS (type), i;
tree *elts = XALLOCAVEC (tree, count);
if (code == VEC_RSHIFT_EXPR)
for (i = 0; i < count; i++)
{
if (!tree_fits_uhwi_p (arg2))
return NULL_TREE;
tree elem1 = VECTOR_CST_ELT (arg1, i);
unsigned HOST_WIDE_INT shiftc = tree_to_uhwi (arg2);
unsigned HOST_WIDE_INT outerc = tree_to_uhwi (TYPE_SIZE (type));
unsigned HOST_WIDE_INT innerc
= tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type)));
if (shiftc >= outerc || (shiftc % innerc) != 0)
elts[i] = const_binop (code, elem1, arg2);
/* It is possible that const_binop cannot handle the given
code and return NULL_TREE. */
if (elts[i] == NULL_TREE)
return NULL_TREE;
int offset = shiftc / innerc;
/* The direction of VEC_RSHIFT_EXPR is endian dependent.
For reductions, if !BYTES_BIG_ENDIAN then compiler picks first
vector element, but last element if BYTES_BIG_ENDIAN. */
if (BYTES_BIG_ENDIAN)
offset = -offset;
tree zero = build_zero_cst (TREE_TYPE (type));
for (i = 0; i < count; i++)
{
if (i + offset < 0 || i + offset >= count)
elts[i] = zero;
else
elts[i] = VECTOR_CST_ELT (arg1, i + offset);
}
}
else
for (i = 0; i < count; i++)
{
tree elem1 = VECTOR_CST_ELT (arg1, i);
elts[i] = const_binop (code, elem1, arg2);
/* It is possible that const_binop cannot handle the given
code and return NULL_TREE */
if (elts[i] == NULL_TREE)
return NULL_TREE;
}
return build_vector (type, elts);
}

31
gcc/optabs.c
View File

@ -520,9 +520,6 @@ optab_for_tree_code (enum tree_code code, const_tree type,
case REDUC_PLUS_EXPR:
return reduc_plus_scal_optab;
case VEC_RSHIFT_EXPR:
return vec_shr_optab;
case VEC_WIDEN_MULT_HI_EXPR:
return TYPE_UNSIGNED (type) ?
vec_widen_umult_hi_optab : vec_widen_smult_hi_optab;
@ -771,34 +768,6 @@ force_expand_binop (machine_mode mode, optab binoptab,
return true;
}
/* Generate insns for VEC_RSHIFT_EXPR. */
rtx
expand_vec_shift_expr (sepops ops, rtx target)
{
struct expand_operand eops[3];
enum insn_code icode;
rtx rtx_op1, rtx_op2;
machine_mode mode = TYPE_MODE (ops->type);
tree vec_oprnd = ops->op0;
tree shift_oprnd = ops->op1;
gcc_assert (ops->code == VEC_RSHIFT_EXPR);
icode = optab_handler (vec_shr_optab, mode);
gcc_assert (icode != CODE_FOR_nothing);
rtx_op1 = expand_normal (vec_oprnd);
rtx_op2 = expand_normal (shift_oprnd);
create_output_operand (&eops[0], target, mode);
create_input_operand (&eops[1], rtx_op1, GET_MODE (rtx_op1));
create_convert_operand_from_type (&eops[2], rtx_op2, TREE_TYPE (shift_oprnd));
expand_insn (icode, 3, eops);
return eops[0].value;
}
/* Create a new vector value in VMODE with all elements set to OP. The
mode of OP must be the element mode of VMODE. If OP is a constant,
then the return value will be a constant. */

2
gcc/optabs.h
View File

@ -287,8 +287,6 @@ extern rtx simplify_expand_binop (machine_mode mode, optab binoptab,
enum optab_methods methods);
extern bool force_expand_binop (machine_mode, optab, rtx, rtx, rtx, int,
enum optab_methods);
/* Generate code for VEC_RSHIFT_EXPR. */
extern rtx expand_vec_shift_expr (struct separate_ops *, rtx);
/* Generate code for a simple binary or unary operation. "Simple" in
this case means "can be unambiguously described by a (mode, code)

32
gcc/tree-cfg.c
View File

@ -3675,38 +3675,6 @@ verify_gimple_assign_binary (gimple stmt)
return false;
}
case VEC_RSHIFT_EXPR:
{
if (TREE_CODE (rhs1_type) != VECTOR_TYPE
|| !(INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
|| POINTER_TYPE_P (TREE_TYPE (rhs1_type))
|| FIXED_POINT_TYPE_P (TREE_TYPE (rhs1_type))
|| SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type)))
|| (!INTEGRAL_TYPE_P (rhs2_type)
&& (TREE_CODE (rhs2_type) != VECTOR_TYPE
|| !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
|| !useless_type_conversion_p (lhs_type, rhs1_type))
{
error ("type mismatch in vector shift expression");
debug_generic_expr (lhs_type);
debug_generic_expr (rhs1_type);
debug_generic_expr (rhs2_type);
return true;
}
/* For shifting a vector of non-integral components we
only allow shifting by a constant multiple of the element size. */
if (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
&& (TREE_CODE (rhs2) != INTEGER_CST
|| !div_if_zero_remainder (rhs2,
TYPE_SIZE (TREE_TYPE (rhs1_type)))))
{
error ("non-element sized vector shift of floating point vector");
return true;
}
return false;
}
case WIDEN_LSHIFT_EXPR:
{
if (!INTEGRAL_TYPE_P (lhs_type)

1
gcc/tree-inline.c
View File

@ -3807,7 +3807,6 @@ estimate_operator_cost (enum tree_code code, eni_weights *weights,
case RSHIFT_EXPR:
case LROTATE_EXPR:
case RROTATE_EXPR:
case VEC_RSHIFT_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:

5
gcc/tree-pretty-print.c
View File

@ -1858,7 +1858,6 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case RSHIFT_EXPR:
case LROTATE_EXPR:
case RROTATE_EXPR:
case VEC_RSHIFT_EXPR:
case WIDEN_LSHIFT_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
@ -3038,7 +3037,6 @@ op_code_prio (enum tree_code code)
case REDUC_MAX_EXPR:
case REDUC_MIN_EXPR:
case REDUC_PLUS_EXPR:
case VEC_RSHIFT_EXPR:
case VEC_UNPACK_HI_EXPR:
case VEC_UNPACK_LO_EXPR:
case VEC_UNPACK_FLOAT_HI_EXPR:
@ -3148,9 +3146,6 @@ op_symbol_code (enum tree_code code)
case RROTATE_EXPR:
return "r>>";
case VEC_RSHIFT_EXPR:
return "v>>";
case WIDEN_LSHIFT_EXPR:
return "w<<";

1
gcc/tree-vect-generic.c
View File

@ -1604,7 +1604,6 @@ expand_vector_operations_1 (gimple_stmt_iterator *gsi)
if (compute_type == type)
return;
gcc_assert (code != VEC_RSHIFT_EXPR);
new_rhs = expand_vector_operation (gsi, type, compute_type, stmt, code);
/* Leave expression untouched for later expansion. */

5
gcc/tree.def
View File

@ -1251,11 +1251,6 @@ DEFTREECODE (WIDEN_LSHIFT_EXPR, "widen_lshift_expr", tcc_binary, 2)
before adding operand three. */
DEFTREECODE (FMA_EXPR, "fma_expr", tcc_expression, 3)
/* Whole vector right shift in bits.
Operand 0 is a vector to be shifted.
Operand 1 is an integer shift amount in bits. */
DEFTREECODE (VEC_RSHIFT_EXPR, "vec_rshift_expr", tcc_binary, 2)
/* Widening vector multiplication.
The two operands are vectors with N elements of size S. Multiplying the
elements of the two vectors will result in N products of size 2*S.