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: svn+ssh://gcc.gnu.org/svn/gcc/trunk@217510 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 99f18b45a79d62094b23a6f64d9af6e35d4a89a6..5fe28340d3cc556959d45595b1b7026d23fd8eab 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -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.

diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 2df8ce3ba84b8da974fdbbfeaf3c4f6412c32772..15d7638795a252e4dd4734962fea1b34dc8b14c9 100644 (file)
--- 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 2e7f839f31602b25c30ed034b072e06a072c7ae2..930549f8a461a15438201696885a09f30e3e2f28 100644 (file)
--- 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 e51abee590c6e532895bc11cc60bd2cfe0e6f18a..ee9ed7b34fa8f5fa43faa20d0eb8c4eba8de345f 100644 (file)
--- 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 4ddd9cc538f10845202abd1bceac0c9c1437d384..f6548c33b26089d6d9adcbfacf52162dec931677 100644 (file)
--- 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 91e36d61b3bc10ed8a5ba4cf5b368e7e341a3d49..982a5935cfaf423ec3dbcea8df147ee1c9c4bde4 100644 (file)
--- 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 ee10bc614b1c265b370efaa86b3b83f8900a952d..904f2ddf9fb58af179efa31261065cb6d6717f1a 100644 (file)
--- 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 8cb951095c40d0da2f0c00a8a93a2f1449059051..520546e3d09bf45ca3f4eb507e1053fdda5ca226 100644 (file)
--- 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 b8abd144f59c25acbe0b9b5c16a6441c7af85397..53720ded5cd375e9d9b7bf4b1bead1846e07e846 100644 (file)
--- 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 a0c1363eae5cba8b607415c75fa5a6e1600be544..bd9df1599e4daeacb01f7e56fd970e9b3c55a217 100644 (file)
--- 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 91359a2387689a3dae1e26adf3cb60d1edb91bf0..e4625d0982203efd8efcb80c1d93ab98fd15890f 100644 (file)
--- 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)
-\f
 /* 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.