2011-09-06 Richard Guenther <rguenther@suse.de>

	PR tree-optimization/48149
	* tree-ssa-sccvn.c (vn_get_expr_for): Simplify.  Fix tuplification bug.
	(vn_valueize): Move earlier.
	(valueize_expr): Use vn_valueize.
	(simplify_binary_expression): Simplify, also combine COMPLEX_EXPR
	operands.
	(simplify_unary_expression): Simplify.

	* gcc.dg/tree-ssa/ssa-fre-32.c: New testcase.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 0a59a05..3109216 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,15 @@
 2011-09-06  Richard Guenther  <rguenther@suse.de>
 
+       PR tree-optimization/48149
+       * tree-ssa-sccvn.c (vn_get_expr_for): Simplify.  Fix tuplification bug.
+       (vn_valueize): Move earlier.
+       (valueize_expr): Use vn_valueize.
+       (simplify_binary_expression): Simplify, also combine COMPLEX_EXPR
+       operands.
+       (simplify_unary_expression): Simplify.
+
+2011-09-06  Richard Guenther  <rguenther@suse.de>
+
        PR tree-optimization/48317
        * tree-ssa-sccvn.h (struct vn_nary_op_s): Make op a true
        trailing array.

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index d22fe49..c1c0073 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,5 +1,10 @@
 2011-09-06  Richard Guenther  <rguenther@suse.de>
 
+       PR tree-optimization/48149
+       * gcc.dg/tree-ssa/ssa-fre-32.c: New testcase.
+
+2011-09-06  Richard Guenther  <rguenther@suse.de>
+
        PR tree-optimization/48317
        * gcc.dg/tree-ssa/ssa-fre-31.c: New testcase.
 

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-32.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-32.c
new file mode 100644 (file)
index 0000000..537fd5a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-32.c
@@ -0,0 +1,28 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fdump-tree-fre1-details" } */
+
+_Complex float 
+foo (_Complex float x)
+{    
+  float r = __real x;
+  float i = __imag x;
+  _Complex float z;
+  __real z = r;
+  __imag z = i;
+  return z;
+} 
+
+_Complex float 
+bar (_Complex float x)
+{    
+  float r = __real x;
+  float i = __imag x;
+  _Complex float z = x;
+  __real z = r;
+  __imag z = i;
+  return z;
+} 
+
+/* We should CSE all the way to replace the final assignment to z with x.  */
+/* { dg-final { scan-tree-dump-times "with x_1\\\(D\\\) in z" 3 "fre1" } } */
+/* { dg-final { cleanup-tree-dump "fre1" } } */

diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index aeb2e08..811cb65 100644 (file)
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -217,6 +217,7 @@ vn_get_expr_for (tree name)
   vn_ssa_aux_t vn = VN_INFO (name);
   gimple def_stmt;
   tree expr = NULL_TREE;
+  enum tree_code code;
 
   if (vn->valnum == VN_TOP)
     return name;
@@ -241,37 +242,34 @@ vn_get_expr_for (tree name)
   /* Otherwise use the defining statement to build the expression.  */
   def_stmt = SSA_NAME_DEF_STMT (vn->valnum);
 
-  /* If the value number is a default-definition or a PHI result
-     use it directly.  */
-  if (gimple_nop_p (def_stmt)
-      || gimple_code (def_stmt) == GIMPLE_PHI)
-    return vn->valnum;
-
+  /* If the value number is not an assignment use it directly.  */
   if (!is_gimple_assign (def_stmt))
     return vn->valnum;
 
   /* FIXME tuples.  This is incomplete and likely will miss some
      simplifications.  */
-  switch (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)))
+  code = gimple_assign_rhs_code (def_stmt);
+  switch (TREE_CODE_CLASS (code))
     {
     case tcc_reference:
-      if ((gimple_assign_rhs_code (def_stmt) == VIEW_CONVERT_EXPR
-          || gimple_assign_rhs_code (def_stmt) == REALPART_EXPR
-          || gimple_assign_rhs_code (def_stmt) == IMAGPART_EXPR)
-         && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
-       expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
+      if ((code == REALPART_EXPR
+          || code == IMAGPART_EXPR
+          || code == VIEW_CONVERT_EXPR)
+         && TREE_CODE (TREE_OPERAND (gimple_assign_rhs1 (def_stmt),
+                                     0)) == SSA_NAME)
+       expr = fold_build1 (code,
                            gimple_expr_type (def_stmt),
                            TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0));
       break;
 
     case tcc_unary:
-      expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
+      expr = fold_build1 (code,
                          gimple_expr_type (def_stmt),
                          gimple_assign_rhs1 (def_stmt));
       break;
 
     case tcc_binary:
-      expr = fold_build2 (gimple_assign_rhs_code (def_stmt),
+      expr = fold_build2 (code,
                          gimple_expr_type (def_stmt),
                          gimple_assign_rhs1 (def_stmt),
                          gimple_assign_rhs2 (def_stmt));
@@ -2822,6 +2820,19 @@ stmt_has_constants (gimple stmt)
   return false;
 }
 
+/* Valueize NAME if it is an SSA name, otherwise just return it.  */
+
+static inline tree
+vn_valueize (tree name)
+{
+  if (TREE_CODE (name) == SSA_NAME)
+    {
+      tree tem = SSA_VAL (name);
+      return tem == VN_TOP ? name : tem;
+    }
+  return name;
+}
+
 /* Replace SSA_NAMES in expr with their value numbers, and return the
    result.
    This is performed in place. */
@@ -2831,21 +2842,13 @@ valueize_expr (tree expr)
 {
   switch (TREE_CODE_CLASS (TREE_CODE (expr)))
     {
-    case tcc_unary:
-      if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
-         && SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
-       TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
-      break;
     case tcc_binary:
-      if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
-         && SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
-       TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
-      if (TREE_CODE (TREE_OPERAND (expr, 1)) == SSA_NAME
-         && SSA_VAL (TREE_OPERAND (expr, 1)) != VN_TOP)
-       TREE_OPERAND (expr, 1) = SSA_VAL (TREE_OPERAND (expr, 1));
-      break;
-    default:
+      TREE_OPERAND (expr, 1) = vn_valueize (TREE_OPERAND (expr, 1));
+      /* Fallthru.  */
+    case tcc_unary:
+      TREE_OPERAND (expr, 0) = vn_valueize (TREE_OPERAND (expr, 0));
       break;
+    default:;
     }
   return expr;
 }
@@ -2859,6 +2862,7 @@ simplify_binary_expression (gimple stmt)
   tree result = NULL_TREE;
   tree op0 = gimple_assign_rhs1 (stmt);
   tree op1 = gimple_assign_rhs2 (stmt);
+  enum tree_code code = gimple_assign_rhs_code (stmt);
 
   /* This will not catch every single case we could combine, but will
      catch those with constants.  The goal here is to simultaneously
@@ -2867,23 +2871,25 @@ simplify_binary_expression (gimple stmt)
   if (TREE_CODE (op0) == SSA_NAME)
     {
       if (VN_INFO (op0)->has_constants
-         || TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
+         || TREE_CODE_CLASS (code) == tcc_comparison
+         || code == COMPLEX_EXPR)
        op0 = valueize_expr (vn_get_expr_for (op0));
-      else if (SSA_VAL (op0) != VN_TOP && SSA_VAL (op0) != op0)
-       op0 = SSA_VAL (op0);
+      else
+       op0 = vn_valueize (op0);
     }
 
   if (TREE_CODE (op1) == SSA_NAME)
     {
-      if (VN_INFO (op1)->has_constants)
+      if (VN_INFO (op1)->has_constants
+         || code == COMPLEX_EXPR)
        op1 = valueize_expr (vn_get_expr_for (op1));
-      else if (SSA_VAL (op1) != VN_TOP && SSA_VAL (op1) != op1)
-       op1 = SSA_VAL (op1);
+      else
+       op1 = vn_valueize (op1);
     }
 
   /* Pointer plus constant can be represented as invariant address.
      Do so to allow further propatation, see also tree forwprop.  */
-  if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
+  if (code == POINTER_PLUS_EXPR
       && host_integerp (op1, 1)
       && TREE_CODE (op0) == ADDR_EXPR
       && is_gimple_min_invariant (op0))
@@ -2898,8 +2904,7 @@ simplify_binary_expression (gimple stmt)
 
   fold_defer_overflow_warnings ();
 
-  result = fold_binary (gimple_assign_rhs_code (stmt),
-                       gimple_expr_type (stmt), op0, op1);
+  result = fold_binary (code, gimple_expr_type (stmt), op0, op1);
   if (result)
     STRIP_USELESS_TYPE_CONVERSION (result);
 
@@ -2924,12 +2929,13 @@ simplify_unary_expression (gimple stmt)
 {
   tree result = NULL_TREE;
   tree orig_op0, op0 = gimple_assign_rhs1 (stmt);
+  enum tree_code code = gimple_assign_rhs_code (stmt);
 
   /* We handle some tcc_reference codes here that are all
      GIMPLE_ASSIGN_SINGLE codes.  */
-  if (gimple_assign_rhs_code (stmt) == REALPART_EXPR
-      || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
-      || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
+  if (code == REALPART_EXPR
+      || code == IMAGPART_EXPR
+      || code == VIEW_CONVERT_EXPR)
     op0 = TREE_OPERAND (op0, 0);
 
   if (TREE_CODE (op0) != SSA_NAME)
@@ -2938,10 +2944,10 @@ simplify_unary_expression (gimple stmt)
   orig_op0 = op0;
   if (VN_INFO (op0)->has_constants)
     op0 = valueize_expr (vn_get_expr_for (op0));
-  else if (gimple_assign_cast_p (stmt)
-          || gimple_assign_rhs_code (stmt) == REALPART_EXPR
-          || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
-          || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
+  else if (CONVERT_EXPR_CODE_P (code)
+          || code == REALPART_EXPR
+          || code == IMAGPART_EXPR
+          || code == VIEW_CONVERT_EXPR)
     {
       /* We want to do tree-combining on conversion-like expressions.
          Make sure we feed only SSA_NAMEs or constants to fold though.  */
@@ -2958,8 +2964,7 @@ simplify_unary_expression (gimple stmt)
   if (op0 == orig_op0)
     return NULL_TREE;
 
-  result = fold_unary_ignore_overflow (gimple_assign_rhs_code (stmt),
-                                      gimple_expr_type (stmt), op0);
+  result = fold_unary_ignore_overflow (code, gimple_expr_type (stmt), op0);
   if (result)
     {
       STRIP_USELESS_TYPE_CONVERSION (result);
@@ -2970,19 +2975,6 @@ simplify_unary_expression (gimple stmt)
   return NULL_TREE;
 }
 
-/* Valueize NAME if it is an SSA name, otherwise just return it.  */
-
-static inline tree
-vn_valueize (tree name)
-{
-  if (TREE_CODE (name) == SSA_NAME)
-    {
-      tree tem = SSA_VAL (name);
-      return tem == VN_TOP ? name : tem;
-    }
-  return name;
-}
-
 /* Try to simplify RHS using equivalences and constant folding.  */
 
 static tree