gimple.c (gimple_assign_copy_p): Use gimple_assign_single_p.

2010-11-27  Richard Guenther  <rguenther@suse.de>

	* gimple.c (gimple_assign_copy_p): Use gimple_assign_single_p.
	(gimple_assign_ssa_name_copy_p): Likewise.
	(gimple_assign_unary_nop_p): Use is_gimple_assign.
	(is_gimple_cast): Remove.
	(gimple_assign_single_p): Move ...
	* gimple.h (gimple_assign_single_p): ... here.
	(is_gimple_cast): Remove.
	(gimple_assign_rhs_code): Simplify.
	* gimple-fold.c (gimple_fold_builtin): Use CONVERT_EXPR_P
	instead of is_gimple_cast.
	* ipa-type-escape.c (look_for_casts): Likewise.

From-SVN: r167200

gcc/ChangeLog

@@ -1,3 +1,17 @@
+2010-11-27  Richard Guenther  <rguenther@suse.de>
+
+	* gimple.c (gimple_assign_copy_p): Use gimple_assign_single_p.
+	(gimple_assign_ssa_name_copy_p): Likewise.
+	(gimple_assign_unary_nop_p): Use is_gimple_assign.
+	(is_gimple_cast): Remove.
+	(gimple_assign_single_p): Move ...
+	* gimple.h (gimple_assign_single_p): ... here.
+	(is_gimple_cast): Remove.
+	(gimple_assign_rhs_code): Simplify.
+	* gimple-fold.c (gimple_fold_builtin): Use CONVERT_EXPR_P
+	instead of is_gimple_cast.
+	* ipa-type-escape.c (look_for_casts): Likewise.
+
 2010-11-26  Joseph Myers  <joseph@codesourcery.com>
 
 	* doc/options.texi (Enum, EnumValue): Document new record types.

gcc/gimple-fold.c

@@ -1273,7 +1273,7 @@ gimple_fold_builtin (gimple stmt)
 	  /* If the result is not a valid gimple value, or not a cast
 	     of a valid gimple value, then we cannot use the result.  */
 	  if (is_gimple_val (new_val)
-	      || (is_gimple_cast (new_val)
+	      || (CONVERT_EXPR_P (new_val)
 		  && is_gimple_val (TREE_OPERAND (new_val, 0))))
 	    return new_val;
 	}

gcc/gimple.c

@@ -1873,15 +1873,14 @@ gimple_call_return_flags (const_gimple stmt)
     }
 }
 
+
 /* Return true if GS is a copy assignment.  */
 
 bool
 gimple_assign_copy_p (gimple gs)
 {
-  return gimple_code (gs) == GIMPLE_ASSIGN
+  return (gimple_assign_single_p (gs)
-         && get_gimple_rhs_class (gimple_assign_rhs_code (gs))
+	  && is_gimple_val (gimple_op (gs, 1)));
-	    == GIMPLE_SINGLE_RHS
-	 && is_gimple_val (gimple_op (gs, 1));
 }
 
 
@@ -1890,28 +1889,12 @@ gimple_assign_copy_p (gimple gs)
 bool
 gimple_assign_ssa_name_copy_p (gimple gs)
 {
-  return (gimple_code (gs) == GIMPLE_ASSIGN
+  return (gimple_assign_single_p (gs)
-	  && (get_gimple_rhs_class (gimple_assign_rhs_code (gs))
-	      == GIMPLE_SINGLE_RHS)
 	  && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
 	  && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
 }
 
 
-/* Return true if GS is an assignment with a singleton RHS, i.e.,
-   there is no operator associated with the assignment itself.
-   Unlike gimple_assign_copy_p, this predicate returns true for
-   any RHS operand, including those that perform an operation
-   and do not have the semantics of a copy, such as COND_EXPR.  */
-
-bool
-gimple_assign_single_p (gimple gs)
-{
-  return (gimple_code (gs) == GIMPLE_ASSIGN
-          && get_gimple_rhs_class (gimple_assign_rhs_code (gs))
-	     == GIMPLE_SINGLE_RHS);
-}
-
 /* Return true if GS is an assignment with a unary RHS, but the
    operator has no effect on the assigned value.  The logic is adapted
    from STRIP_NOPS.  This predicate is intended to be used in tuplifying
@@ -1929,7 +1912,7 @@ gimple_assign_single_p (gimple gs)
 bool
 gimple_assign_unary_nop_p (gimple gs)
 {
-  return (gimple_code (gs) == GIMPLE_ASSIGN
+  return (is_gimple_assign (gs)
           && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
               || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
           && gimple_assign_rhs1 (gs) != error_mark_node
@@ -2950,15 +2933,6 @@ is_gimple_min_lval (tree t)
   return (is_gimple_id (t) || TREE_CODE (t) == MEM_REF);
 }
 
-/* Return true if T is a typecast operation.  */
-
-bool
-is_gimple_cast (tree t)
-{
-  return (CONVERT_EXPR_P (t)
-          || TREE_CODE (t) == FIX_TRUNC_EXPR);
-}
-
 /* Return true if T is a valid function operand of a CALL_EXPR.  */
 
 bool

gcc/gimple.h

@@ -869,7 +869,6 @@ int gimple_call_arg_flags (const_gimple, unsigned);
 void gimple_call_reset_alias_info (gimple);
 bool gimple_assign_copy_p (gimple);
 bool gimple_assign_ssa_name_copy_p (gimple);
-bool gimple_assign_single_p (gimple);
 bool gimple_assign_unary_nop_p (gimple);
 void gimple_set_bb (gimple, struct basic_block_def *);
 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
@@ -944,8 +943,6 @@ extern bool is_gimple_mem_rhs (tree);
 /* Returns true iff T is a valid if-statement condition.  */
 extern bool is_gimple_condexpr (tree);
 
-/* Returns true iff T is a type conversion.  */
-extern bool is_gimple_cast (tree);
 /* Returns true iff T is a variable that does not need to live in memory.  */
 extern bool is_gimple_non_addressable (tree t);
 
@@ -1904,7 +1901,10 @@ gimple_assign_rhs_code (const_gimple gs)
   enum tree_code code;
   GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
 
-  code = gimple_expr_code (gs);
+  code = (enum tree_code) gs->gsbase.subcode;
+  /* While we initially set subcode to the TREE_CODE of the rhs for
+     GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
+     in sync when we rewrite stmts into SSA form or do SSA propagations.  */
   if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
     code = TREE_CODE (gimple_assign_rhs1 (gs));
 
@@ -1933,6 +1933,19 @@ gimple_assign_rhs_class (const_gimple gs)
   return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
 }
 
+/* Return true if GS is an assignment with a singleton RHS, i.e.,
+   there is no operator associated with the assignment itself.
+   Unlike gimple_assign_copy_p, this predicate returns true for
+   any RHS operand, including those that perform an operation
+   and do not have the semantics of a copy, such as COND_EXPR.  */
+
+static inline bool
+gimple_assign_single_p (gimple gs)
+{
+  return (is_gimple_assign (gs)
+          && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
+}
+
 
 /* Return true if S is a type-cast assignment.  */
 

gcc/ipa-type-escape.c

@@ -1236,7 +1236,7 @@ look_for_casts (tree t)
 {
   unsigned int cast = 0;
 
-  if (is_gimple_cast (t) || TREE_CODE (t) == VIEW_CONVERT_EXPR)
+  if (CONVERT_EXPR_P (t) || TREE_CODE (t) == VIEW_CONVERT_EXPR)
     {
       tree castfromvar = TREE_OPERAND (t, 0);
       cast = cast | check_cast (TREE_TYPE (t), castfromvar);