[gcc r15-99] middle-end/114579 - speed up add_scope_conflicts

[gcc r15-99] middle-end/114579 - speed up add_scope_conflicts

[Richard Biener]

https://gcc.gnu.org/g:bbe83599320288025a417c54d9afcb3885cb2766

commit r15-99-gbbe83599320288025a417c54d9afcb3885cb2766
Author: Richard Biener <rguenther@suse.de>
Date:   Thu Apr 4 14:00:10 2024 +0200

    middle-end/114579 - speed up add_scope_conflicts
    
    The following speeds up stack variable conflict detection by recognizing
    that the all-to-all conflict recording is only necessary for CFG merges
    as it's the unioning of the live variable sets that doesn't come with
    explicit mentions we record conflicts for.
    
    If we employ this optimization we have to make sure to perform the
    all-to-all conflict recording for all CFG merges even those into
    empty blocks where we might previously have skipped this.
    
    I have reworded the comment before the all-to-all conflict recording
    since it seemed to be confusing and missing the point - but maybe I
    am also missing something here.
    
    Nevertheless for the testcase in the PR the compile-time spend in
    add_scope_conflicts at -O1 drops from previously 67s (39%) to 10s (9%).
    
            PR middle-end/114579
            * cfgexpand.cc (add_scope_conflicts_1): Record all-to-all
            conflicts only when there's a CFG merge but for all CFG merges.

Diff:
---
 gcc/cfgexpand.cc | 46 +++++++++++++++++++++++++++++++++-------------
 1 file changed, 33 insertions(+), 13 deletions(-)

diff --git a/gcc/cfgexpand.cc b/gcc/cfgexpand.cc
index cfc5291aa0c..afee064aa15 100644
--- a/gcc/cfgexpand.cc
+++ b/gcc/cfgexpand.cc
@@ -640,21 +640,26 @@ add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
 	{
 	  if (for_conflict && visit == visit_op)
 	    {
-	      /* If this is the first real instruction in this BB we need
-	         to add conflicts for everything live at this point now.
-		 Unlike classical liveness for named objects we can't
-		 rely on seeing a def/use of the names we're interested in.
-		 There might merely be indirect loads/stores.  We'd not add any
-		 conflicts for such partitions.  */
+	      /* When we are inheriting live variables from our predecessors
+		 through a CFG merge we might not see an actual mention of
+		 the variables to record the approprate conflict as defs/uses
+		 might be through indirect stores/loads.  For this reason
+		 we have to make sure each live variable conflicts with
+		 each other.  When there's just a single predecessor the
+		 set of conflicts is already up-to-date.
+		 We perform this delayed at the first real instruction to
+		 allow clobbers starting this block to remove variables from
+		 the set of live variables.  */
 	      bitmap_iterator bi;
 	      unsigned i;
-	      EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)
-		{
-		  class stack_var *a = &stack_vars[i];
-		  if (!a->conflicts)
-		    a->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
-		  bitmap_ior_into (a->conflicts, work);
-		}
+	      if (EDGE_COUNT (bb->preds) > 1)
+		EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)
+		  {
+		    class stack_var *a = &stack_vars[i];
+		    if (!a->conflicts)
+		      a->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
+		    bitmap_ior_into (a->conflicts, work);
+		  }
 	      visit = visit_conflict;
 	    }
 	  walk_stmt_load_store_addr_ops (stmt, work, visit, visit, visit);
@@ -662,6 +667,21 @@ add_scope_conflicts_1 (basic_block bb, bitmap work, bool for_conflict)
 	    add_scope_conflicts_2 (USE_FROM_PTR (use_p), work, visit);
 	}
     }
+
+  /* When there was no real instruction but there's a CFG merge we need
+     to add the conflicts now.  */
+  if (for_conflict && visit == visit_op && EDGE_COUNT (bb->preds) > 1)
+    {
+      bitmap_iterator bi;
+      unsigned i;
+      EXECUTE_IF_SET_IN_BITMAP (work, 0, i, bi)
+	{
+	  class stack_var *a = &stack_vars[i];
+	  if (!a->conflicts)
+	    a->conflicts = BITMAP_ALLOC (&stack_var_bitmap_obstack);
+	  bitmap_ior_into (a->conflicts, work);
+	}
+    }
 }
 
 /* Generate stack partition conflicts between all partitions that are