2012-04-05 Richard Guenther <rguenther@suse.de>

	* gimple.c (walk_gimple_op): Compute val_only for the LHS
	of an assigment in the canonical way, avoiding is_gimple_mem_rhs.
	(is_gimple_mem_rhs, is_gimple_reg_rhs, is_gimple_stmt): Move ...
	* gimplify.c (is_gimple_mem_rhs, is_gimple_reg_rhs, is_gimple_stmt):
	... here and make static.
	* gimple.h (is_gimple_mem_rhs, is_gimple_reg_rhs, is_gimple_stmt):
	Remove.


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

1 files changed, 5 insertions, 83 deletions

diff --git a/gcc/gimple.c b/gcc/gimple.c
index 3876912e471..95d79dc1e02 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -1496,15 +1496,12 @@ walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
 	 may use a COMPONENT_REF on the LHS.  */
       if (wi)
 	{
-          /* If the RHS has more than 1 operand, it is not appropriate
-             for the memory.
-	     ???  A lhs always requires an lvalue, checking the val_only flag
-	     does not make any sense, so we should be able to avoid computing
-	     it here.  */
+          /* If the RHS is of a non-renamable type or is a register variable,
+	     we may use a COMPONENT_REF on the LHS.  */
 	  tree rhs1 = gimple_assign_rhs1 (stmt);
-	  wi->val_only = !(is_gimple_mem_rhs (rhs1)
-			   || TREE_CODE (rhs1) == CONSTRUCTOR)
-                         || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
+	  wi->val_only
+	    = (is_gimple_reg_type (TREE_TYPE (rhs1)) && !is_gimple_reg (rhs1))
+	      || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
 	  wi->is_lhs = true;
 	}
 
@@ -2639,29 +2636,6 @@ const unsigned char gimple_rhs_class_table[] = {
 
 /* Validation of GIMPLE expressions.  */
 
-/* Returns true iff T is a valid RHS for an assignment to a renamed
-   user -- or front-end generated artificial -- variable.  */
-
-bool
-is_gimple_reg_rhs (tree t)
-{
-  return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
-}
-
-/* Returns true iff T is a valid RHS for an assignment to an un-renamed
-   LHS, or for a call argument.  */
-
-bool
-is_gimple_mem_rhs (tree t)
-{
-  /* If we're dealing with a renamable type, either source or dest must be
-     a renamed variable.  */
-  if (is_gimple_reg_type (TREE_TYPE (t)))
-    return is_gimple_val (t);
-  else
-    return is_gimple_val (t) || is_gimple_lvalue (t);
-}
-
 /*  Return true if T is a valid LHS for a GIMPLE assignment expression.  */
 
 bool
@@ -2835,58 +2809,6 @@ is_gimple_ip_invariant (const_tree t)
   return is_gimple_constant (t);
 }
 
-/* Return true if T looks like a valid GIMPLE statement.  */
-
-bool
-is_gimple_stmt (tree t)
-{
-  const enum tree_code code = TREE_CODE (t);
-
-  switch (code)
-    {
-    case NOP_EXPR:
-      /* The only valid NOP_EXPR is the empty statement.  */
-      return IS_EMPTY_STMT (t);
-
-    case BIND_EXPR:
-    case COND_EXPR:
-      /* These are only valid if they're void.  */
-      return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
-
-    case SWITCH_EXPR:
-    case GOTO_EXPR:
-    case RETURN_EXPR:
-    case LABEL_EXPR:
-    case CASE_LABEL_EXPR:
-    case TRY_CATCH_EXPR:
-    case TRY_FINALLY_EXPR:
-    case EH_FILTER_EXPR:
-    case CATCH_EXPR:
-    case ASM_EXPR:
-    case STATEMENT_LIST:
-    case OMP_PARALLEL:
-    case OMP_FOR:
-    case OMP_SECTIONS:
-    case OMP_SECTION:
-    case OMP_SINGLE:
-    case OMP_MASTER:
-    case OMP_ORDERED:
-    case OMP_CRITICAL:
-    case OMP_TASK:
-      /* These are always void.  */
-      return true;
-
-    case CALL_EXPR:
-    case MODIFY_EXPR:
-    case PREDICT_EXPR:
-      /* These are valid regardless of their type.  */
-      return true;
-
-    default:
-      return false;
-    }
-}
-
 /* Return true if T is a variable.  */
 
 bool