diff mbox series

tree-optimization/112909 - uninit diagnostic with abnormal copy

Message ID 20231208103109.A8303138FF@imap2.dmz-prg2.suse.org
State New
Headers show
Series tree-optimization/112909 - uninit diagnostic with abnormal copy | expand

Commit Message

Richard Biener Dec. 8, 2023, 10:31 a.m. UTC 
The following avoids spurious uninit diagnostics for SSA name
copies which mostly appear when the source is marked as abnormal
which prevents copy propagation.

To prevent regressions I remove the bail out for anonymous SSA
names in the PHI arg place from warn_uninitialized_phi leaving
that to warn_uninit where I handle SSA copies from a SSA name
which isn't anonymous.  In theory this might cause more
valid and false positive diagnostics to pop up.

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

	PR tree-optimization/112909
	* tree-ssa-uninit.cc (find_uninit_use): Look through a
	single level of SSA name copies with single use.

	* gcc.dg/uninit-pr112909.c: New testcase.
---
 gcc/testsuite/gcc.dg/uninit-pr112909.c | 28 +++++++++++++++
 gcc/tree-ssa-uninit.cc                 | 47 ++++++++++++++++++++------
 2 files changed, 64 insertions(+), 11 deletions(-)
 create mode 100644 gcc/testsuite/gcc.dg/uninit-pr112909.c
diff mbox series

Patch

diff --git a/gcc/testsuite/gcc.dg/uninit-pr112909.c b/gcc/testsuite/gcc.dg/uninit-pr112909.c
new file mode 100644
index 00000000000..d2998f715aa
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/uninit-pr112909.c
@@ -0,0 +1,28 @@ 
+/* { dg-do compile } */
+/* { dg-options "-O2 -Wuninitialized" } */
+
+struct machine_thread_all_state {
+  int set;
+} _hurd_setup_sighandler_state;
+int _hurd_setup_sighandler_ss_0;
+struct {
+  int ctx;
+} *_hurd_setup_sighandler_stackframe;
+void _setjmp();
+void __thread_get_state();
+int machine_get_basic_state(struct machine_thread_all_state *state) {
+  if (state->set)
+    __thread_get_state();
+  return 1;
+}
+int *_hurd_setup_sighandler() {
+  int *scp;				/* { dg-bogus "used uninitialized" } */
+  if (_hurd_setup_sighandler_ss_0) {
+    _setjmp();
+    _hurd_setup_sighandler_state.set |= 5;
+  }
+  machine_get_basic_state(&_hurd_setup_sighandler_state);
+  scp = &_hurd_setup_sighandler_stackframe->ctx;
+  _setjmp();
+  return scp;
+}
diff --git a/gcc/tree-ssa-uninit.cc b/gcc/tree-ssa-uninit.cc
index f42f76cd5c6..9a7c7d12dd8 100644
--- a/gcc/tree-ssa-uninit.cc
+++ b/gcc/tree-ssa-uninit.cc
@@ -204,14 +204,29 @@  warn_uninit (opt_code opt, tree t, tree var, gimple *context,
     {
       var_def_stmt = SSA_NAME_DEF_STMT (t);
 
-      if (is_gimple_assign (var_def_stmt)
-	  && gimple_assign_rhs_code (var_def_stmt) == COMPLEX_EXPR)
+      if (gassign *ass = dyn_cast <gassign *> (var_def_stmt))
 	{
-	  tree v = gimple_assign_rhs1 (var_def_stmt);
-	  if (TREE_CODE (v) == SSA_NAME
-	      && has_undefined_value_p (v)
-	      && zerop (gimple_assign_rhs2 (var_def_stmt)))
-	    var = SSA_NAME_VAR (v);
+	  switch (gimple_assign_rhs_code (var_def_stmt))
+	    {
+	    case COMPLEX_EXPR:
+	      {
+		tree v = gimple_assign_rhs1 (ass);
+		if (TREE_CODE (v) == SSA_NAME
+		    && has_undefined_value_p (v)
+		    && zerop (gimple_assign_rhs2 (ass)))
+		  var = SSA_NAME_VAR (v);
+		break;
+	      }
+	    case SSA_NAME:
+	      {
+		tree v = gimple_assign_rhs1 (ass);
+		if (TREE_CODE (v) == SSA_NAME
+		    && SSA_NAME_VAR (v))
+		  var = SSA_NAME_VAR (v);
+		break;
+	      }
+	    default:;
+	    }
 	}
 
       if (gimple_call_internal_p (var_def_stmt, IFN_DEFERRED_INIT))
@@ -1229,6 +1244,18 @@  find_uninit_use (gphi *phi, unsigned uninit_opnds, int *bb_to_rpo)
       if (is_gimple_debug (use_stmt))
 	continue;
 
+      /* Look through a single level of SSA name copies.  This is
+	 important for copies involving abnormals which we can't always
+	 proapgate out but which result in spurious unguarded uses.  */
+      use_operand_p use2_p;
+      gimple *use2_stmt;
+      if (gimple_assign_ssa_name_copy_p (use_stmt)
+	  && single_imm_use (gimple_assign_lhs (use_stmt), &use2_p, &use2_stmt))
+	{
+	  use_p = use2_p;
+	  use_stmt = use2_stmt;
+	}
+
       if (gphi *use_phi = dyn_cast<gphi *> (use_stmt))
 	{
 	  unsigned idx = PHI_ARG_INDEX_FROM_USE (use_p);
@@ -1262,9 +1289,9 @@  find_uninit_use (gphi *phi, unsigned uninit_opnds, int *bb_to_rpo)
 		       e->src->index, e->dest->index);
 	      print_gimple_stmt (dump_file, use_stmt, 0);
 	    }
-	  /* Found a phi use that is not guarded, mark the phi_result as
+	  /* Found a phi use that is not guarded, mark the use as
 	     possibly undefined.  */
-	  possibly_undefined_names->add (phi_result);
+	  possibly_undefined_names->add (USE_FROM_PTR (use_p));
 	}
       else
 	cands.safe_push (use_stmt);
@@ -1318,8 +1345,6 @@  warn_uninitialized_phi (gphi *phi, unsigned uninit_opnds, int *bb_to_rpo)
 
   unsigned phiarg_index = MASK_FIRST_SET_BIT (uninit_opnds);
   tree uninit_op = gimple_phi_arg_def (phi, phiarg_index);
-  if (SSA_NAME_VAR (uninit_op) == NULL_TREE)
-    return;
 
   location_t loc = UNKNOWN_LOCATION;
   if (gimple_phi_arg_has_location (phi, phiarg_index))