diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index eadd6d4844e..28ee9f739fc 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2012-02-24  Richard Guenther  <rguenther@suse.de>
+
+	PR middle-end/52361
+	* gimple.c (walk_gimple_op): Use predicates with less redundant
+	tests.
+	(is_gimple_reg_type): Move inline ...
+	* gimple.h (is_gimple_reg_type): ... here.
+
 2012-02-24  Richard Guenther  <rguenther@suse.de>
 
 	PR middle-end/52361
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 805ad2d77b2..3876912e471 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -1481,7 +1481,7 @@ walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
 	  tree lhs = gimple_assign_lhs (stmt);
 	  wi->val_only
 	    = (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
-	      || !gimple_assign_single_p (stmt);
+	      || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
 	}
 
       for (i = 1; i < gimple_num_ops (stmt); i++)
@@ -1497,11 +1497,14 @@ walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
       if (wi)
 	{
           /* If the RHS has more than 1 operand, it is not appropriate
-             for the memory.  */
-	  wi->val_only = !(is_gimple_mem_rhs (gimple_assign_rhs1 (stmt))
-			   || TREE_CODE (gimple_assign_rhs1 (stmt))
-			      == CONSTRUCTOR)
-                         || !gimple_assign_single_p (stmt);
+             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.  */
+	  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->is_lhs = true;
 	}
 
@@ -2908,14 +2911,6 @@ is_gimple_id (tree t)
 	  || TREE_CODE (t) == STRING_CST);
 }
 
-/* Return true if TYPE is a suitable type for a scalar register variable.  */
-
-bool
-is_gimple_reg_type (tree type)
-{
-  return !AGGREGATE_TYPE_P (type);
-}
-
 /* Return true if T is a non-aggregate register variable.  */
 
 bool
diff --git a/gcc/gimple.h b/gcc/gimple.h
index ec32f2577a3..b2b345edfab 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -963,8 +963,6 @@ tree gimple_extract_devirt_binfo_from_cst (tree);
 /* Returns true iff T is a valid GIMPLE statement.  */
 extern bool is_gimple_stmt (tree);
 
-/* Returns true iff TYPE is a valid type for a scalar register variable.  */
-extern bool is_gimple_reg_type (tree);
 /* Returns true iff T is a scalar register variable.  */
 extern bool is_gimple_reg (tree);
 /* Returns true iff T is any sort of variable.  */
@@ -4838,6 +4836,13 @@ gimple_expr_type (const_gimple stmt)
     return void_type_node;
 }
 
+/* Return true if TYPE is a suitable type for a scalar register variable.  */
+
+static inline bool
+is_gimple_reg_type (tree type)
+{
+  return !AGGREGATE_TYPE_P (type);
+}
 
 /* Return a new iterator pointing to GIMPLE_SEQ's first statement.  */