tree-optimization/107803 - abnormal cleanup from the SSA propagator

Message ID 20221122110546.F01EF3851883@sourceware.org
State New
Headers
Series tree-optimization/107803 - abnormal cleanup from the SSA propagator |

Commit Message

Richard Biener Nov. 22, 2022, 11:05 a.m. UTC
  The SSA propagator is missing abnormal cleanup which shows in a
sanity check in the uninit engine (and missed CFG verification).
The following adds that.

Bootstrapped and tested on x86_64-unknown-linux-gnu, pushed.

	PR tree-optimization/107803
	* tree-ssa-propagate.cc (substitute_and_fold_dom_walker): Add
	need_ab_cleanup member.
	(substitute_and_fold_dom_walker::before_dom_children): When
	a stmt can no longer transfer control flow abnormally set
	need_ab_cleanup.
	(substitute_and_fold_engine::substitute_and_fold): Cleanup
	abnormal control flow.

	* g++.dg/pr107803.C: New testcase.
---
 gcc/testsuite/g++.dg/pr107803.C | 19 +++++++++++++++++++
 gcc/tree-ssa-propagate.cc       | 20 ++++++++++++++++++--
 2 files changed, 37 insertions(+), 2 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/pr107803.C
  

Patch

diff --git a/gcc/testsuite/g++.dg/pr107803.C b/gcc/testsuite/g++.dg/pr107803.C
new file mode 100644
index 00000000000..f814e968b69
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pr107803.C
@@ -0,0 +1,19 @@ 
+// { dg-do compile }
+// { dg-options "-O -fno-tree-dominator-opts -fno-tree-fre -Wmaybe-uninitialized" }
+
+void printf(...);
+void __sigsetjmp_cancel() __attribute__((__returns_twice__));
+int z, main_ret;
+void func(void *) {}
+
+int
+main()
+{
+  int x;
+  void (*__cancel_routine)(void *)(func);
+  __sigsetjmp_cancel();
+  __cancel_routine(0);
+  if (main_ret)
+    x = z;
+  printf(x);
+}
diff --git a/gcc/tree-ssa-propagate.cc b/gcc/tree-ssa-propagate.cc
index 9dc4bfd85bf..d8b0aed4564 100644
--- a/gcc/tree-ssa-propagate.cc
+++ b/gcc/tree-ssa-propagate.cc
@@ -671,12 +671,14 @@  public:
       stmts_to_remove.create (0);
       stmts_to_fixup.create (0);
       need_eh_cleanup = BITMAP_ALLOC (NULL);
+      need_ab_cleanup = BITMAP_ALLOC (NULL);
     }
     ~substitute_and_fold_dom_walker ()
     {
       stmts_to_remove.release ();
       stmts_to_fixup.release ();
       BITMAP_FREE (need_eh_cleanup);
+      BITMAP_FREE (need_ab_cleanup);
     }
 
     edge before_dom_children (basic_block) final override;
@@ -689,6 +691,7 @@  public:
     vec<gimple *> stmts_to_remove;
     vec<gimple *> stmts_to_fixup;
     bitmap need_eh_cleanup;
+    bitmap need_ab_cleanup;
 
     class substitute_and_fold_engine *substitute_and_fold_engine;
 
@@ -838,8 +841,13 @@  substitute_and_fold_dom_walker::before_dom_children (basic_block bb)
 	 folded.  */
       did_replace = false;
       gimple *old_stmt = stmt;
-      bool was_noreturn = (is_gimple_call (stmt)
-			   && gimple_call_noreturn_p (stmt));
+      bool was_noreturn = false;
+      bool can_make_abnormal_goto = false;
+      if (is_gimple_call (stmt))
+	{
+	  was_noreturn = gimple_call_noreturn_p (stmt);
+	  can_make_abnormal_goto = stmt_can_make_abnormal_goto (stmt);
+	}
 
       /* Replace real uses in the statement.  */
       did_replace |= substitute_and_fold_engine->replace_uses_in (stmt);
@@ -905,6 +913,12 @@  substitute_and_fold_dom_walker::before_dom_children (basic_block bb)
 	  if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt))
 	    bitmap_set_bit (need_eh_cleanup, bb->index);
 
+	  /* If we turned a call with possible abnormal control transfer
+	     into one that doesn't, remove abnormal edges.  */
+	  if (can_make_abnormal_goto
+	      && !stmt_can_make_abnormal_goto (stmt))
+	    bitmap_set_bit (need_ab_cleanup, bb->index);
+
 	  /* If we turned a not noreturn call into a noreturn one
 	     schedule it for fixup.  */
 	  if (!was_noreturn
@@ -1012,6 +1026,8 @@  substitute_and_fold_engine::substitute_and_fold (basic_block block)
 
   if (!bitmap_empty_p (walker.need_eh_cleanup))
     gimple_purge_all_dead_eh_edges (walker.need_eh_cleanup);
+  if (!bitmap_empty_p (walker.need_ab_cleanup))
+    gimple_purge_all_dead_abnormal_call_edges (walker.need_ab_cleanup);
 
   /* Fixup stmts that became noreturn calls.  This may require splitting
      blocks and thus isn't possible during the dominator walk.  Do this