tree-gimple.h (is_gimple_invariant_address): Declare.

2008-03-18  Richard Guenther  <rguenther@suse.de>

	* tree-gimple.h (is_gimple_invariant_address): Declare.
	(is_gimple_constant): Likewise.
	* tree-gimple.c (is_gimple_constant): New function.
	(is_gimple_invariant_address): Likewise.
	(is_gimple_min_invariant): Implement in terms of is_gimple_constant
	and is_gimple_invariant_address.
	* tree-ssa-loop-niter.c (expand_simple_operations): Revert
	previous change.
	* tree-data-ref.c (get_references_in_stmt): A SSA_NAME is not
	an addressable base.

	* gcc.dg/tree-ssa/loop-19.c: Revert previous change.

From-SVN: r133311

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index e5706fb97bea3dd565413bf105a8c0df24d68c0b..8004991f92c2e15d5046b1efae9412f794d1f02b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,16 @@
+2008-03-18  Richard Guenther  <rguenther@suse.de>
+
+       * tree-gimple.h (is_gimple_invariant_address): Declare.
+       (is_gimple_constant): Likewise.
+       * tree-gimple.c (is_gimple_constant): New function.
+       (is_gimple_invariant_address): Likewise.
+       (is_gimple_min_invariant): Implement in terms of is_gimple_constant
+       and is_gimple_invariant_address.
+       * tree-ssa-loop-niter.c (expand_simple_operations): Revert
+       previous change.
+       * tree-data-ref.c (get_references_in_stmt): A SSA_NAME is not
+       an addressable base.
+
 2008-03-18  Jakub Jelinek  <jakub@redhat.com>
 
        PR middle-end/35611

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 964e62f7347e7cab6e42ac781e4d849a5a2c86d5..d5543830532554aac34b5c752ce14dd90cce9508 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2008-03-18  Richard Guenther  <rguenther@suse.de>
+
+       * gcc.dg/tree-ssa/loop-19.c: Revert previous change.
+
 2008-03-17  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
 
        PR libfortran/35617

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c
index 1614f7e4de14a52905f04873605463200785c625..748c6e8143499852a1adf34a25a6a747268670f3 100644 (file)
--- a/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-19.c
@@ -6,7 +6,7 @@
 
 /* { dg-do compile { target i?86-*-* x86_64-*-* powerpc*-*-*} } */
 /* { dg-require-effective-target nonpic } */
-/* { dg-options "-O2 -fdump-tree-final_cleanup" } */
+/* { dg-options "-O3 -fdump-tree-final_cleanup" } */
 
 # define N      2000000
 static double   a[N],c[N];

diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index 70266034aab51ff6990ee13ee5b07494efb7ed5c..f8faed813c78da37534b1487adbb9384507146ec 100644 (file)
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -3965,11 +3965,14 @@ get_references_in_stmt (tree stmt, VEC (data_ref_loc, heap) **references)
 
   if (TREE_CODE (stmt) ==  GIMPLE_MODIFY_STMT)
     {
+      tree base;
       op0 = &GIMPLE_STMT_OPERAND (stmt, 0);
       op1 = &GIMPLE_STMT_OPERAND (stmt, 1);
                
       if (DECL_P (*op1)
-         || (REFERENCE_CLASS_P (*op1) && get_base_address (*op1)))
+         || (REFERENCE_CLASS_P (*op1)
+             && (base = get_base_address (*op1))
+             && TREE_CODE (base) != SSA_NAME))
        {
          ref = VEC_safe_push (data_ref_loc, heap, *references, NULL);
          ref->pos = op1;

diff --git a/gcc/tree-gimple.c b/gcc/tree-gimple.c
index d1e47f65edab38c19c56f9799fc6d19524954bdd..93e99e6cbed1dc11cfe588209f1a09e93d83d4bb 100644 (file)
--- a/gcc/tree-gimple.c
+++ b/gcc/tree-gimple.c
@@ -167,17 +167,13 @@ is_gimple_addressable (tree t)
          || INDIRECT_REF_P (t));
 }
 
-/* Return true if T is a GIMPLE minimal invariant.  It's a restricted
-   form of function invariant.  */
+/* Return true if T is a valid gimple constant.  */
 
 bool
-is_gimple_min_invariant (const_tree t)
+is_gimple_constant (const_tree t)
 {
   switch (TREE_CODE (t))
     {
-    case ADDR_EXPR:
-      return TREE_INVARIANT (t);
-
     case INTEGER_CST:
     case REAL_CST:
     case FIXED_CST:
@@ -198,6 +194,87 @@ is_gimple_min_invariant (const_tree t)
     }
 }
 
+/* Return true if T is a gimple invariant address.  */
+
+bool
+is_gimple_invariant_address (const_tree t)
+{
+  tree op;
+
+  if (TREE_CODE (t) != ADDR_EXPR)
+    return false;
+
+  op = TREE_OPERAND (t, 0);
+  while (handled_component_p (op))
+    {
+      switch (TREE_CODE (op))
+       {
+       case ARRAY_REF:
+       case ARRAY_RANGE_REF:
+         if (!is_gimple_constant (TREE_OPERAND (op, 1))
+             || TREE_OPERAND (op, 2) != NULL_TREE
+             || TREE_OPERAND (op, 3) != NULL_TREE)
+           return false;
+         break;
+
+       case COMPONENT_REF:
+         if (TREE_OPERAND (op, 2) != NULL_TREE)
+           return false;
+         break;
+
+       default:;
+       }
+      op = TREE_OPERAND (op, 0);
+    }
+
+  if (CONSTANT_CLASS_P (op))
+    return true;
+
+  if (INDIRECT_REF_P (op))
+    return false;
+
+  switch (TREE_CODE (op))
+    {
+    case PARM_DECL:
+    case RESULT_DECL:
+    case LABEL_DECL:
+    case FUNCTION_DECL:
+      return true;
+
+    case VAR_DECL:
+      if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
+          && ! DECL_DLLIMPORT_P (op))
+         || DECL_THREAD_LOCAL_P (op)
+         || DECL_CONTEXT (op) == current_function_decl
+         || decl_function_context (op) == current_function_decl)
+       return true;
+      break;
+
+    case CONST_DECL:
+      if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
+         || decl_function_context (op) == current_function_decl)
+       return true;
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+
+  return false;
+}
+
+/* Return true if T is a GIMPLE minimal invariant.  It's a restricted
+   form of function invariant.  */
+
+bool
+is_gimple_min_invariant (const_tree t)
+{
+  if (TREE_CODE (t) == ADDR_EXPR)
+    return is_gimple_invariant_address (t);
+
+  return is_gimple_constant (t);
+}
+
 /* Return true if T looks like a valid GIMPLE statement.  */
 
 bool

diff --git a/gcc/tree-gimple.h b/gcc/tree-gimple.h
index 2493b6b24198a52585268129db3a3addc3ee9698..b45b44b2bde318ef1c9e6288baec514614484f62 100644 (file)
--- a/gcc/tree-gimple.h
+++ b/gcc/tree-gimple.h
@@ -62,6 +62,10 @@ extern bool is_gimple_addressable (tree);
 /* Returns true iff T is any valid GIMPLE lvalue.  */
 extern bool is_gimple_lvalue (tree);
 
+/* Returns true iff T is a GIMPLE invariant address.  */
+bool is_gimple_invariant_address (const_tree);
+/* Returns true iff T is a valid GIMPLE constant.  */
+bool is_gimple_constant (const_tree);
 /* Returns true iff T is a GIMPLE restricted function invariant.  */
 extern bool is_gimple_min_invariant (const_tree);
 /* Returns true iff T is a GIMPLE rvalue.  */

diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 0696342bd1b4140be5df73acf5cfb8d305683a42..40e7051c265bf9d70dc54ac93179dbf15a8a9b27 100644 (file)
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -1436,10 +1436,6 @@ expand_simple_operations (tree expr)
     return expr;
 
   e = GIMPLE_STMT_OPERAND (stmt, 1);
-  /* Do not expand random invariants.  */
-  if (TREE_INVARIANT (e)
-      && !is_gimple_min_invariant (e))
-    return expr;
   if (/* Casts are simple.  */
       TREE_CODE (e) != NOP_EXPR
       && TREE_CODE (e) != CONVERT_EXPR