c++: Fix further protected_set_expr_location related -fcompare-debug issues [PR94441]

My recent protected_set_expr_location changes work well when
that function is called unconditionally, but as the testcase shows, the C++
FE has a few spots that do:
  if (!EXPR_HAS_LOCATION (stmt))
    protected_set_expr_location (stmt, locus);
or similar.  Now, if we have for -g0 stmt of some expression that can
have location and has != UNKNOWN_LOCATION, while -g instead has
a STATEMENT_LIST containing some DEBUG_BEGIN_STMTs + that expression with
that location, we don't call protected_set_expr_location in the -g0 case,
but do call it in the -g case, because on the STATEMENT_LIST
!EXPR_HAS_LOCATION.
The following patch introduces a helper function which digs up the single
expression of a STATEMENT_LIST and uses that expression in the
EXPR_HAS_LOCATION check (plus changes protected_set_expr_location to
also use that helper).

Or do we want a further wrapper, perhaps C++ FE only, that would do this
protected_set_expr_location_if_unset (stmt, locus)?

2020-04-04  Jakub Jelinek  <jakub@redhat.com>

	PR debug/94441
	* tree-iterator.h (expr_single): Declare.
	* tree-iterator.c (expr_single): New function.
	* tree.h (protected_set_expr_location_if_unset): Declare.
	* tree.c (protected_set_expr_location): Use expr_single.
	(protected_set_expr_location_if_unset): New function.

	* parser.c (cp_parser_omp_for_loop): Use
	protected_set_expr_location_if_unset.
	* cp-gimplify.c (genericize_if_stmt, genericize_cp_loop): Likewise.

	* g++.dg/opt/pr94441.C: New test.

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 25d1c5d1c381dbfb4f6f637c04d7708d65734096..fdb685a99d1f42d7a3ca4435977772bb1f0be4a0 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2020-04-04  Jakub Jelinek  <jakub@redhat.com>
+
+       PR debug/94441
+       * tree-iterator.h (expr_single): Declare.
+       * tree-iterator.c (expr_single): New function.
+       * tree.h (protected_set_expr_location_if_unset): Declare.
+       * tree.c (protected_set_expr_location): Use expr_single.
+       (protected_set_expr_location_if_unset): New function.
+
 2020-04-03  Jeff Law  <law@redhat.com>
 
        PR rtl-optimization/92264

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index fc3ad899a4a631392e1761205ea9e168eca1948c..14038ccfe90a897dc55f54f2e82f064273ac8c7e 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,5 +1,10 @@
 2020-04-04  Jakub Jelinek  <jakub@redhat.com>
 
+       PR debug/94441
+       * parser.c (cp_parser_omp_for_loop): Use
+       protected_set_expr_location_if_unset.
+       * cp-gimplify.c (genericize_if_stmt, genericize_cp_loop): Likewise.
+
        PR c++/94477
        * pt.c (tsubst_expr) <case OMP_MASTER>: Clear
        omp_parallel_combined_clauses.

diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index 3999695ae93ea6c98dfd9d2f8fa4b3bb70c7f2a6..f326d71637b927cbafdccaf89338b21abbb35187 100644 (file)
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -226,8 +226,7 @@ genericize_if_stmt (tree *stmt_p)
     stmt = else_;
   else
     stmt = build3 (COND_EXPR, void_type_node, cond, then_, else_);
-  if (!EXPR_HAS_LOCATION (stmt))
-    protected_set_expr_location (stmt, locus);
+  protected_set_expr_location_if_unset (stmt, locus);
   *stmt_p = stmt;
 }
 
@@ -248,8 +247,7 @@ genericize_cp_loop (tree *stmt_p, location_t start_locus, tree cond, tree body,
   tree stmt_list = NULL;
   tree debug_begin = NULL;
 
-  if (EXPR_LOCATION (incr) == UNKNOWN_LOCATION)
-    protected_set_expr_location (incr, start_locus);
+  protected_set_expr_location_if_unset (incr, start_locus);
 
   cp_walk_tree (&cond, cp_genericize_r, data, NULL);
   cp_walk_tree (&incr, cp_genericize_r, data, NULL);

diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index fc3c2976e3d96c054b19632191977bf67636a4e4..7e5921e039f18b3cb68ac1b910ae7357c95fa723 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -39149,8 +39149,7 @@ cp_parser_omp_for_loop (cp_parser *parser, enum tree_code code, tree clauses,
            incr = cp_parser_omp_for_incr (parser, real_decl);
          else
            incr = cp_parser_expression (parser);
-         if (!EXPR_HAS_LOCATION (incr))
-           protected_set_expr_location (incr, input_location);
+         protected_set_expr_location_if_unset (incr, input_location);
        }
 
     parse_close_paren:

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 494533f2a559d27c424dcc1f400cd062cbde0e7f..c08bc0d68f74232a51fdfa07e6cd62709f6e2e5e 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,5 +1,8 @@
 2020-04-04  Jakub Jelinek  <jakub@redhat.com>
 
+       PR debug/94441
+       * g++.dg/opt/pr94441.C: New test.
+
        PR c++/94477
        * g++.dg/gomp/pr94477.C: New test.
 

diff --git a/gcc/testsuite/g++.dg/opt/pr94441.C b/gcc/testsuite/g++.dg/opt/pr94441.C
new file mode 100644 (file)
index 0000000..07ce43e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr94441.C
@@ -0,0 +1,16 @@
+// PR debug/94441
+// { dg-do compile }
+// { dg-options "-O3 -fno-forward-propagate --param=max-cse-insns=0 -flive-range-shrinkage -std=c++17 -fcompare-debug" }
+
+template <class,class> struct Same;
+template <class T> struct Same<T,T> {};
+
+auto f()
+{
+  if constexpr (sizeof(int)==3)
+    return 42;
+  else
+    return 42L;
+}
+
+Same<decltype(f()), long> s;

diff --git a/gcc/tree-iterator.c b/gcc/tree-iterator.c
index ddc908f387c57c77b6b08d3c8eb7af6ad0a46cce..81833b592b5e1fa6c60c2a3bdd921dda30dcf1de 100644 (file)
--- a/gcc/tree-iterator.c
+++ b/gcc/tree-iterator.c
@@ -354,4 +354,45 @@ expr_last (tree expr)
   return expr;
 }
 
+/* If EXPR is a STATEMENT_LIST containing just DEBUG_BEGIN_STMTs and
+   a single other stmt, return that other stmt (recursively).
+   If it is a STATEMENT_LIST containing no non-DEBUG_BEGIN_STMTs or
+   multiple, return NULL_TREE.
+   Otherwise return EXPR.  */
+
+tree
+expr_single (tree expr)
+{
+  if (expr == NULL_TREE)
+    return expr;
+
+  if (TREE_CODE (expr) == STATEMENT_LIST)
+    {
+      /* With -gstatement-frontiers we could have a STATEMENT_LIST with
+        DEBUG_BEGIN_STMT(s) and only a single other stmt, which with
+        -g wouldn't be present and we'd have that single other stmt
+        directly instead.  */
+      struct tree_statement_list_node *n = STATEMENT_LIST_HEAD (expr);
+      if (!n)
+       return NULL_TREE;
+      while (TREE_CODE (n->stmt) == DEBUG_BEGIN_STMT)
+       {
+         n = n->next;
+         if (!n)
+           return NULL_TREE;
+       }
+      expr = n->stmt;
+      do
+       {
+         n = n->next;
+         if (!n)
+           return expr_single (expr);
+       }
+      while (TREE_CODE (n->stmt) == DEBUG_BEGIN_STMT);
+      return NULL_TREE;
+    }
+
+  return expr;
+}
+
 #include "gt-tree-iterator.h"

diff --git a/gcc/tree-iterator.h b/gcc/tree-iterator.h
index 0b36221150ece93d17a55596fead3c5e6a2cc5a3..b16ff130728709f303ca8cd05cc829beca818403 100644 (file)
--- a/gcc/tree-iterator.h
+++ b/gcc/tree-iterator.h
@@ -119,5 +119,6 @@ extern void append_to_statement_list (tree, tree *);
 extern void append_to_statement_list_force (tree, tree *);
 extern tree expr_first (tree);
 extern tree expr_last (tree);
+extern tree expr_single (tree);
 
 #endif /* GCC_TREE_ITERATOR_H  */

diff --git a/gcc/tree.c b/gcc/tree.c
index 0fe3afce1b6332999577f65452676011b1f282f8..fa956da28a461b3cd3ade626250bf7d317183f39 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -5148,33 +5148,23 @@ protected_set_expr_location (tree t, location_t loc)
     SET_EXPR_LOCATION (t, loc);
   else if (t && TREE_CODE (t) == STATEMENT_LIST)
     {
-      /* With -gstatement-frontiers we could have a STATEMENT_LIST with
-        DEBUG_BEGIN_STMT(s) and only a single other stmt, which with
-        -g wouldn't be present and we'd have that single other stmt
-        directly instead.  */
-      struct tree_statement_list_node *n = STATEMENT_LIST_HEAD (t);
-      if (!n)
-       return;
-      while (TREE_CODE (n->stmt) == DEBUG_BEGIN_STMT)
-       {
-         n = n->next;
-         if (!n)
-           return;
-       }
-      tree t2 = n->stmt;
-      do
-       {
-         n = n->next;
-         if (!n)
-           {
-             protected_set_expr_location (t2, loc);
-             return;
-           }
-       }
-      while (TREE_CODE (n->stmt) == DEBUG_BEGIN_STMT);
+      t = expr_single (t);
+      if (t && CAN_HAVE_LOCATION_P (t))
+       SET_EXPR_LOCATION (t, loc);
     }
 }
 
+/* Like PROTECTED_SET_EXPR_LOCATION, but only do that if T has
+   UNKNOWN_LOCATION.  */
+
+void
+protected_set_expr_location_if_unset (tree t, location_t loc)
+{
+  t = expr_single (t);
+  if (t && !EXPR_HAS_LOCATION (t))
+    protected_set_expr_location (t, loc);
+}
+
 /* Data used when collecting DECLs and TYPEs for language data removal.  */
 
 class free_lang_data_d

diff --git a/gcc/tree.h b/gcc/tree.h
index 85ce6b3bd6a5fc07dcbf43630224d34428d77a4b..66dfa8762562947ded74b2db5e6f62d96234d10f 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1203,6 +1203,7 @@ get_expr_source_range (tree expr)
 }
 
 extern void protected_set_expr_location (tree, location_t);
+extern void protected_set_expr_location_if_unset (tree, location_t);
 
 extern tree maybe_wrap_with_location (tree, location_t);