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


git-svn-id: https://gcc.gnu.org/svn/gcc/trunk@217510 138bc75d-0d04-0410-961f-82ee72b054a4

11 files changed, 23 insertions, 118 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 99f18b45a79..5fe28340d3c 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,21 @@
 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.
 	(shift_amt_for_vec_perm_mask): New.
 	(expand_vec_perm_1): Use vec_shr_optab if second vector is const0_rtx
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 2df8ce3ba84..15d7638795a 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -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:
diff --git a/gcc/expr.c b/gcc/expr.c
index 2e7f839f316..930549f8a46 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -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:
       {
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index e51abee590c..ee9ed7b34fa 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -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);
     }
diff --git a/gcc/optabs.c b/gcc/optabs.c
index 4ddd9cc538f..f6548c33b26 100644
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -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.  */
diff --git a/gcc/optabs.h b/gcc/optabs.h
index 91e36d61b3b..982a5935cfa 100644
--- a/gcc/optabs.h
+++ b/gcc/optabs.h
@@ -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)
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index ee10bc614b1..904f2ddf9fb 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -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)
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 8cb951095c4..520546e3d09 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -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:
diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c
index b8abd144f59..53720ded5cd 100644
--- a/gcc/tree-pretty-print.c
+++ b/gcc/tree-pretty-print.c
@@ -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<<";
 
diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c
index a0c1363eae5..bd9df1599e4 100644
--- a/gcc/tree-vect-generic.c
+++ b/gcc/tree-vect-generic.c
@@ -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.  */
diff --git a/gcc/tree.def b/gcc/tree.def
index 91359a23876..e4625d09822 100644
--- a/gcc/tree.def
+++ b/gcc/tree.def
@@ -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.