2007-11-23 Richard Guenther <rguenther@suse.de>

	* tree-ssa-copy.c (may_propagate_copy): Remove redundant
	checks.
	(merge_alias_info): Do verification only if checking is
	enabled.  Merge flow-sensitive alias information in simple
	cases.
	* tree-ssa-operands.c (get_addr_dereference_operands): Also
	complain about missing NMTs.

	* gcc.dg/tree-ssa/alias-17.c: New testcase.

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

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index ca92fa8..d9aee04 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2007-11-23  Richard Guenther  <rguenther@suse.de>
+
+       * gcc.dg/tree-ssa/alias-17.c: New testcase.
+
 2007-11-22  Joseph Myers  <joseph@codesourcery.com>
 
        PR c/14050

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/alias-17.c b/gcc/testsuite/gcc.dg/tree-ssa/alias-17.c
new file mode 100644 (file)
index 0000000..48e72ff
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/alias-17.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-O -fno-early-inlining -fdump-tree-ccp2" } */
+
+int *p;
+int inline bar(void) { return 0; }
+int foo(int x)
+{
+  int i;
+  int *q;
+  if (bar())
+    q = &i;
+  else
+    q = p;
+  return *q + *p;
+}
+
+/* { dg-final { scan-tree-dump-not "NOTE: no flow-sensitive alias info for" "ccp2" } } */
+/* { dg-final { cleanup-tree-dump "ccp2" } } */

diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c
index 9f58087..ae4f50c 100644 (file)
--- a/gcc/tree-ssa-copy.c
+++ b/gcc/tree-ssa-copy.c
@@ -129,8 +129,6 @@ may_propagate_copy (tree dest, tree orig)
       tree mt_orig = symbol_mem_tag (SSA_NAME_VAR (orig));
       if (mt_dest && mt_orig && mt_dest != mt_orig)
        return false;
-      else if (!useless_type_conversion_p (type_d, type_o))
-       return false;
       else if (get_alias_set (TREE_TYPE (type_d)) != 
               get_alias_set (TREE_TYPE (type_o)))
        return false;
@@ -217,31 +215,13 @@ merge_alias_info (tree orig_name, tree new_name)
       return;
     }
 
-  gcc_assert (POINTER_TYPE_P (TREE_TYPE (orig_name)));
-  gcc_assert (POINTER_TYPE_P (TREE_TYPE (new_name)));
+  gcc_assert (POINTER_TYPE_P (TREE_TYPE (orig_name))
+             && POINTER_TYPE_P (TREE_TYPE (new_name)));
 
 #if defined ENABLE_CHECKING
   gcc_assert (useless_type_conversion_p (TREE_TYPE (orig_name),
                                        TREE_TYPE (new_name)));
 
-  /* If the pointed-to alias sets are different, these two pointers
-     would never have the same memory tag.  In this case, NEW should
-     not have been propagated into ORIG.  */
-  gcc_assert (get_alias_set (TREE_TYPE (TREE_TYPE (new_sym)))
-             == get_alias_set (TREE_TYPE (TREE_TYPE (orig_sym))));
-#endif
-
-  /* Synchronize the symbol tags.  If both pointers had a tag and they
-     are different, then something has gone wrong.  Symbol tags can
-     always be merged because they are flow insensitive, all the SSA
-     names of the same base DECL share the same symbol tag.  */
-  if (new_ann->symbol_mem_tag == NULL_TREE)
-    new_ann->symbol_mem_tag = orig_ann->symbol_mem_tag;
-  else if (orig_ann->symbol_mem_tag == NULL_TREE)
-    orig_ann->symbol_mem_tag = new_ann->symbol_mem_tag;
-  else
-    gcc_assert (new_ann->symbol_mem_tag == orig_ann->symbol_mem_tag);
-
   /* Check that flow-sensitive information is compatible.  Notice that
      we may not merge flow-sensitive information here.  This function
      is called when propagating equivalences dictated by the IL, like
@@ -257,7 +237,11 @@ merge_alias_info (tree orig_name, tree new_name)
 
      Since we cannot distinguish one case from another in this
      function, we can only make sure that if P_i and Q_j have
-     flow-sensitive information, they should be compatible.  */
+     flow-sensitive information, they should be compatible.
+
+     As callers of merge_alias_info are supposed to call may_propagate_copy
+     first, the following check is redundant.  Thus, only do it if checking
+     is enabled.  */
   if (SSA_NAME_PTR_INFO (orig_name) && SSA_NAME_PTR_INFO (new_name))
     {
       struct ptr_info_def *orig_ptr_info = SSA_NAME_PTR_INFO (orig_name);
@@ -278,7 +262,33 @@ merge_alias_info (tree orig_name, tree new_name)
        gcc_assert (bitmap_intersect_p (new_ptr_info->pt_vars,
                                        orig_ptr_info->pt_vars));
     }
-}   
+#endif
+
+  /* Synchronize the symbol tags.  If both pointers had a tag and they
+     are different, then something has gone wrong.  Symbol tags can
+     always be merged because they are flow insensitive, all the SSA
+     names of the same base DECL share the same symbol tag.  */
+  if (new_ann->symbol_mem_tag == NULL_TREE)
+    new_ann->symbol_mem_tag = orig_ann->symbol_mem_tag;
+  else if (orig_ann->symbol_mem_tag == NULL_TREE)
+    orig_ann->symbol_mem_tag = new_ann->symbol_mem_tag;
+  else
+    gcc_assert (new_ann->symbol_mem_tag == orig_ann->symbol_mem_tag);
+
+  /* Copy flow-sensitive alias information in case that NEW_NAME
+     didn't get a NMT but was set to pt_anything for optimization
+     purposes.  In case ORIG_NAME has a NMT we can safely use its
+     flow-sensitive alias information as a conservative estimate.  */
+  if (SSA_NAME_PTR_INFO (orig_name)
+      && SSA_NAME_PTR_INFO (orig_name)->name_mem_tag
+      && (!SSA_NAME_PTR_INFO (new_name)
+         || !SSA_NAME_PTR_INFO (new_name)->name_mem_tag))
+    {
+      struct ptr_info_def *orig_ptr_info = SSA_NAME_PTR_INFO (orig_name);
+      struct ptr_info_def *new_ptr_info = get_ptr_info (new_name);
+      memcpy (new_ptr_info, orig_ptr_info, sizeof (struct ptr_info_def));
+    }
+}
 
 
 /* Common code for propagate_value and replace_exp.

diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 36cf624..96ed4ca 100644 (file)
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -1643,16 +1643,18 @@ get_addr_dereference_operands (tree stmt, tree *addr, int flags, tree full_ref,
          /* If we are emitting debugging dumps, display a warning if
             PTR is an SSA_NAME with no flow-sensitive alias
             information.  That means that we may need to compute
-            aliasing again.  */
+            aliasing again or that a propagation pass forgot to
+            update the alias information on the pointers.  */
          if (dump_file
              && TREE_CODE (ptr) == SSA_NAME
-             && pi == NULL)
+             && (pi == NULL
+                 || pi->name_mem_tag == NULL_TREE))
            {
              fprintf (dump_file,
                  "NOTE: no flow-sensitive alias info for ");
              print_generic_expr (dump_file, ptr, dump_flags);
              fprintf (dump_file, " in ");
-             print_generic_stmt (dump_file, stmt, dump_flags);
+             print_generic_stmt (dump_file, stmt, 0);
            }
 
          if (TREE_CODE (ptr) == SSA_NAME)