pa.c (reloc_needed): Use CASE_CONVERT.

        * config/pa/pa.c (reloc_needed): Use CASE_CONVERT.

        * tree-cfg.c (verify_expr, verify_gimple_expr): Likewise.

        * tree-ssa-structalias.c (get_constraint_for): Likewise.

        * c-common.c (c_common_truthvalue_conversion): Likewise.

        * tree-object-size.c (compute_object_offset): Likewise.

        * tree-inline.c (estimate_num_insns_1): Likewise.

        * varasm.c (const_hash_1, compare_constant, copy_constant)
        (compute_reloc_for_constant, output_addressed_constants)
        (initializer_constant_valid_p): Likewise.

        * c-omp.c (check_omp_for_incr_expr): Likewise.

        * gimplify.c (gimplify_expr): Likewise.

        * c-typeck.c (c_finish_return): Likewise.

        * tree-vectorizer.c (supportable_widening_operation)
        (supportable_narrowing_operation): Likewise.

        * c-pretty-print.c (pp_c_cast_expression, pp_c_expression):
        Likewise.

        * matrix-reorg.c (can_calculate_expr_before_stmt): Likewise.

        * expr.c (highest_pow2_factor, expand_expr_real_1): Likewise.

        * dwarf2out.c (loc_descriptor_from_tree_1, add_bound_info)
        (descr_info_loc): Likewise.

        * tree-ssa-loop-ivopts.c (may_be_nonaddressable_p): Likewise.

        * fold-const.c (operand_equal_p, make_range, extract_muldiv_1)
        (fold_unary): Likewise.

        * builtins.c (get_pointer_alignment): Likewise.

        * tree-scalar-evolution.c (interpret_rhs_modify_stmt)
        (instantiate_parameters_1): Likewise.

        * tree.c (expr_align, stabilize_reference): Likewise.

        * tree-pretty-print.c (dump_generic_node, op_prio): Likewise.

        * tree-ssa-loop-niter.c (derive_constant_upper_bound): Likewise.

        * convert.c (strip_float_extensions): Use CONVERT_EXPR_P.

        * tree-ssa-threadedge.c (simplify_control_stmt_condition):
        Likewise.

        * config/alpha/alpha.c (va_list_skip_additions): Likewise.

        * c-common.c (c_alignof_expr, check_function_arguments_recurse):
        Likewise.

        * tree-ssa.c (tree_ssa_useless_type_conversion): Likewise.

        * varasm.c (initializer_constant_valid_p, output_constant):
        Likewise.

        * tree-ssa-forwprop.c (get_prop_source_stmt, can_propagate_from)
        (forward_propagate_addr_expr_1, forward_propagate_addr_expr)
        (forward_propagate_comparison)
        (tree_ssa_forward_propagate_single_use_vars): Likewise.

        * cfgexpand.c (discover_nonconstant_array_refs_r): Likewise.

        * emit-rtl.c (component_ref_for_mem_expr)
        (set_mem_attributes_minus_bitpos): Likewise.

        * tree-ssa-phiopt.c (conditional_replacement): Likewise.

        * gimplify.c (gimplify_conversion, goa_lhs_expr_p,
        gimplify_expr): Likewise.

        * c-typeck.c (default_function_array_conversion,
        build_indirect_ref)
        (build_function_call, pointer_diff, build_compound_expr)
        (c_finish_return): Likewise.

        * tree-vect-analyze.c (vect_determine_vectorization_factor):
        Likewise.

        * matrix-reorg.c (get_inner_of_cast_expr,
        may_flatten_matrices_1): Likewise.

        * tree-ssa-ifcombine.c (recognize_single_bit_test): Likewise.

        * expr.c (is_aligning_offset): Likewise.

        * tree-ssa-alias.c (is_escape_site): Likewise.

        * tree-stdarg.c (va_list_counter_bump, check_va_list_escapes)
        (check_all_va_list_escapes): Likewise.

        * tree-ssa-loop-ivopts.c (determine_base_object)
        (determine_common_wider_type): Likewise.

        * dojump.c (do_jump): Likewise.

        * tree-ssa-sccvn.c (simplify_unary_expression): Likewise.

        * tree-gimple.c (is_gimple_cast): Likewise.

        * fold-const.c (decode_field_reference, )
        (fold_sign_changed_comparison, fold_unary, fold_comparison)
        (fold_binary): Likewise.

        * tree-ssa-alias-warnings.c (find_alias_site_helper)
        (already_warned_in_frontend_p): Likewise.

        * builtins.c (get_memory_rtx, fold_builtin_next_arg): Likewise.

        * tree.c (really_constant_p, get_unwidened): Likewise.

        * tree-ssa-loop-niter.c (expand_simple_operations): Likewise.

        * tree-ssa-loop-im.c (rewrite_bittest): Likewise.

        * tree-vrp.c (register_edge_assert_for_2,
        register_edge_assert_for_1): Likewise.

        * tree.h (STRIP_NOPS, STRIP_SIGN_NOPS, STRIP_TYPE_NOPS): Use
        CONVERT_EXPR_P.
        (CONVERT_EXPR_P): Define.
        (CASE_CONVERT): Define.

From-SVN: r135114

1 files changed, 12 insertions, 22 deletions

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 1250d26..358a616 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -3168,8 +3168,7 @@ operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
       /* Two conversions are equal only if signedness and modes match.  */
       switch (TREE_CODE (arg0))
         {
-        case NOP_EXPR:
-        case CONVERT_EXPR:
+	CASE_CONVERT:
         case FIX_TRUNC_EXPR:
 	  if (TYPE_UNSIGNED (TREE_TYPE (arg0))
 	      != TYPE_UNSIGNED (TREE_TYPE (arg1)))
@@ -3904,8 +3903,7 @@ decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
   /* We are interested in the bare arrangement of bits, so strip everything
      that doesn't affect the machine mode.  However, record the type of the
      outermost expression if it may matter below.  */
-  if (TREE_CODE (exp) == NOP_EXPR
-      || TREE_CODE (exp) == CONVERT_EXPR
+  if (CONVERT_EXPR_P (exp)
       || TREE_CODE (exp) == NON_LVALUE_EXPR)
     outer_type = TREE_TYPE (exp);
   STRIP_NOPS (exp);
@@ -4316,7 +4314,7 @@ make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
 	  exp = arg0;
 	  continue;
 
-	case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
+	CASE_CONVERT: case NON_LVALUE_EXPR:
 	  if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
 	    break;
 
@@ -5728,7 +5726,7 @@ extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
 			    fold_convert (ctype, c), 0);
       break;
 
-    case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
+    CASE_CONVERT: case NON_LVALUE_EXPR:
       /* If op0 is an expression ...  */
       if ((COMPARISON_CLASS_P (op0)
 	   || UNARY_CLASS_P (op0)
@@ -6804,8 +6802,7 @@ fold_sign_changed_comparison (enum tree_code code, tree type,
   tree arg0_inner;
   tree inner_type, outer_type;
 
-  if (TREE_CODE (arg0) != NOP_EXPR
-      && TREE_CODE (arg0) != CONVERT_EXPR)
+  if (!CONVERT_EXPR_P (arg0))
     return NULL_TREE;
 
   outer_type = TREE_TYPE (arg0);
@@ -6830,8 +6827,7 @@ fold_sign_changed_comparison (enum tree_code code, tree type,
     return NULL_TREE;
 
   if (TREE_CODE (arg1) != INTEGER_CST
-      && !((TREE_CODE (arg1) == NOP_EXPR
-	    || TREE_CODE (arg1) == CONVERT_EXPR)
+      && !(CONVERT_EXPR_P (arg1)
 	   && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
     return NULL_TREE;
 
@@ -7726,9 +7722,8 @@ fold_unary (enum tree_code code, tree type, tree op0)
 	return fold_convert (type, op0);
       return NULL_TREE;
 
-    case NOP_EXPR:
+    CASE_CONVERT:
     case FLOAT_EXPR:
-    case CONVERT_EXPR:
     case FIX_TRUNC_EXPR:
       if (TREE_TYPE (op0) == type)
 	return op0;
@@ -7740,8 +7735,7 @@ fold_unary (enum tree_code code, tree type, tree op0)
 			    TREE_OPERAND (op0, 1));
 
       /* Handle cases of two conversions in a row.  */
-      if (TREE_CODE (op0) == NOP_EXPR
-	  || TREE_CODE (op0) == CONVERT_EXPR)
+      if (CONVERT_EXPR_P (op0))
 	{
 	  tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
 	  tree inter_type = TREE_TYPE (op0);
@@ -7936,8 +7930,7 @@ fold_unary (enum tree_code code, tree type, tree op0)
       if (INTEGRAL_TYPE_P (type)
 	  && TREE_CODE (op0) == BIT_NOT_EXPR
 	  && INTEGRAL_TYPE_P (TREE_TYPE (op0))
-	  && (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
-	      || TREE_CODE (TREE_OPERAND (op0, 0)) == CONVERT_EXPR)
+	  && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
 	  && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
 	{
 	  tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
@@ -7993,8 +7986,7 @@ fold_unary (enum tree_code code, tree type, tree op0)
 	return fold_convert (type, op0);
 
       /* Strip inner integral conversions that do not change the precision.  */
-      if ((TREE_CODE (op0) == NOP_EXPR
-	   || TREE_CODE (op0) == CONVERT_EXPR)
+      if (CONVERT_EXPR_P (op0)
 	  && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
 	      || POINTER_TYPE_P (TREE_TYPE (op0)))
 	  && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
@@ -8911,8 +8903,7 @@ fold_comparison (enum tree_code code, tree type, tree op0, tree op1)
     }
 
   if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
-      && (TREE_CODE (arg0) == NOP_EXPR
-	  || TREE_CODE (arg0) == CONVERT_EXPR))
+      && CONVERT_EXPR_P (arg0))
     {
       /* If we are widening one operand of an integer comparison,
 	 see if the other operand is similarly being widened.  Perhaps we
@@ -12666,8 +12657,7 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
 
       if ((code == LT_EXPR || code == GE_EXPR)
 	  && TYPE_UNSIGNED (TREE_TYPE (arg0))
-	  && (TREE_CODE (arg1) == NOP_EXPR
-	      || TREE_CODE (arg1) == CONVERT_EXPR)
+	  && CONVERT_EXPR_P (arg1)
 	  && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
 	  && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
 	return