Disregard incoming equivalences to a path when defining a new one.

The equivalence oracle creates a new equiv set at each def point,
killing any incoming equivalences, however in the path sensitive
oracle we create brand new equivalences at each PHI:

   BB4:

   BB8:
      x_5 = PHI <y_8(4)>

Here we note that x_5 == y_8 at the end of the path.

The current code is intersecting this new equivalence with previously
known equivalences coming into the path.  This is incorrect, as this
is a new definition.  This patch kills any known equivalence before we
register a new one.

This hasn't caused problems so far, but upcoming changes to the
pipeline has us threading more aggressively and triggering corner
cases where this causes incorrect code.

I have tested this patch with the usual regstrap cycle.  I have also
hacked a compiler comparing the old and new behavior to see if we were
previously threading paths where the decision was made due to invalid
equivalences.  Luckily, there were no such paths, but there were 22
paths in a set of .ii files where disregarding incoming relations
allowed us to thread the path.  This is a miniscule improvement,
but we moved a handful of thredable paths earlier in the pipeline,
which is always good.

Tested on x86-64 Linux.

Co-authored-by: Andrew MacLeod <amacleod@redhat.com>
gcc/ChangeLog:

	* gimple-range-path.cc (path_range_query::compute_phi_relations):
	Kill any global relations we may know before registering a new
	one.
	* value-relation.cc (path_oracle::killing_def): New.
	* value-relation.h (path_oracle::killing_def): New.

diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc
index 694271306a764869a30d66420a3dd46887e5c151..557338993aed8338eb1959336d52a653402bf1d8 100644 (file)
--- a/gcc/gimple-range-path.cc
+++ b/gcc/gimple-range-path.cc
@@ -698,7 +698,15 @@ path_range_query::compute_phi_relations (basic_block bb, basic_block prev)
            tree arg = gimple_phi_arg_def (phi, i);
 
            if (gimple_range_ssa_p (arg))
-             m_oracle->register_relation (entry, EQ_EXPR, arg, result);
+             {
+               if (dump_file && (dump_flags & TDF_DETAILS))
+                 fprintf (dump_file, "  from bb%d:", bb->index);
+
+               // Throw away any previous relation.
+               get_path_oracle ()->killing_def (result);
+
+               m_oracle->register_relation (entry, EQ_EXPR, arg, result);
+             }
 
            break;
          }

diff --git a/gcc/value-relation.cc b/gcc/value-relation.cc
index ac5f3f9afc0b9280dab3ff44a0dfe90fe14fd632..2acf375ca9aa2aacd218c9cdc0ec4167e87705e5 100644 (file)
--- a/gcc/value-relation.cc
+++ b/gcc/value-relation.cc
@@ -1285,6 +1285,29 @@ path_oracle::register_equiv (basic_block bb, tree ssa1, tree ssa2)
   bitmap_ior_into (m_equiv.m_names, b);
 }
 
+// Register killing definition of an SSA_NAME.
+
+void
+path_oracle::killing_def (tree ssa)
+{
+  if (dump_file && (dump_flags & TDF_DETAILS))
+    {
+      fprintf (dump_file, " Registering killing_def (path_oracle) ");
+      print_generic_expr (dump_file, ssa, TDF_SLIM);
+      fprintf (dump_file, "\n");
+    }
+
+  bitmap b = BITMAP_ALLOC (&m_bitmaps);
+  bitmap_set_bit (b, SSA_NAME_VERSION (ssa));
+  equiv_chain *ptr = (equiv_chain *) obstack_alloc (&m_chain_obstack,
+                                                   sizeof (equiv_chain));
+  ptr->m_names = b;
+  ptr->m_bb = NULL;
+  ptr->m_next = m_equiv.m_next;
+  m_equiv.m_next = ptr;
+  bitmap_ior_into (m_equiv.m_names, b);
+}
+
 // Register relation K between SSA1 and SSA2, resolving unknowns by
 // querying from BB.
 

diff --git a/gcc/value-relation.h b/gcc/value-relation.h
index 53cefbfa7dcfadcc0f19eae2c7647865cd5de01b..97be325114459eb29c1572d8681c2bc799554621 100644 (file)
--- a/gcc/value-relation.h
+++ b/gcc/value-relation.h
@@ -222,6 +222,7 @@ public:
   ~path_oracle ();
   const_bitmap equiv_set (tree, basic_block);
   void register_relation (basic_block, relation_kind, tree, tree);
+  void killing_def (tree);
   relation_kind query_relation (basic_block, tree, tree);
   relation_kind query_relation (basic_block, const_bitmap, const_bitmap);
   void reset_path ();