c++: Avoid unnecessary copying in cp_fold [PR94038]

When folding a CALL_EXPR, we can avoid copying it until folding changes
one of its arguments.  And when folding a TREE_VEC, we can avoid using
an intermediate releasing_vec by copying the TREE_VEC as soon as folding
changes one of its arguments, like we do in the CALL_EXPR case.

Incidentally, the CALL_EXPR change also fixes the testcase in PR94038.
The reason is that the call to maybe_constant_value from cp_fold on
the call 'bar<int>()' now reuses the result of the earlier call to
maybe_constant_value from fold_for_warn, via the cv_cache.  This earlier
call passes uid_sensitive=true, whereas the call from cp_fold passes
uid_sensitive=false, and so by reusing the cached result of the earlier
call we now avoid instantiating bar<int> at all.

gcc/cp/ChangeLog:

	PR c++/94038
	* cp-gimplify.c (cp_fold) <case CALL_EXPR>: Move some variable
	declarations closer to their uses.  Copy the CALL_EXPR only
	when one of its arguments has changed.
	<case TREE_VEC>: Instead of first collecting the folded
	arguments into a releasing_vec, just make a copy of the TREE_VEC
	as soon as folding changes one of its arguments.

gcc/testsuite/ChangeLog:

	PR c++/94038
	* g++.dg/warn/pr94038.C: New test.

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 70f620fc353ea955ae9bc4ffd381ba8192b12c18..a3ae5efba0163fb6d006309019fcd1b869d3fa52 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,13 @@
+2020-05-04  Patrick Palka  <ppalka@redhat.com>
+
+       PR c++/94038
+       * cp-gimplify.c (cp_fold) <case CALL_EXPR>: Move some variable
+       declarations closer to their uses.  Copy the CALL_EXPR only
+       when one of its arguments has changed.
+       <case TREE_VEC>: Instead of first collecting the folded
+       arguments into a releasing_vec, just make a copy of the TREE_VEC
+       as soon as folding changes one of its arguments.
+
 2020-05-04  Iain Sandoe  <iain@sandoe.co.uk>
 
        * coroutines.cc (morph_fn_to_coro): Mark the coro.gro variable

diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index f326d71637b927cbafdccaf89338b21abbb35187..fc26a85f43aa00eda4f13799c9f0f4dae3f45e88 100644 (file)
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -2744,7 +2744,7 @@ cp_fold (tree x)
 
     case CALL_EXPR:
       {
-       int i, m, sv = optimize, nw = sv, changed = 0;
+       int sv = optimize, nw = sv;
        tree callee = get_callee_fndecl (x);
 
        /* Some built-in function calls will be evaluated at compile-time in
@@ -2770,10 +2770,9 @@ cp_fold (tree x)
            break;
          }
 
-       x = copy_node (x);
-
-       m = call_expr_nargs (x);
-       for (i = 0; i < m; i++)
+       bool changed = false;
+       int m = call_expr_nargs (x);
+       for (int i = 0; i < m; i++)
          {
            r = cp_fold (CALL_EXPR_ARG (x, i));
            if (r != CALL_EXPR_ARG (x, i))
@@ -2783,9 +2782,11 @@ cp_fold (tree x)
                    x = error_mark_node;
                    break;
                  }
-               changed = 1;
+               if (!changed)
+                 x = copy_node (x);
+               CALL_EXPR_ARG (x, i) = r;
+               changed = true;
              }
-           CALL_EXPR_ARG (x, i) = r;
          }
        if (x == error_mark_node)
          break;
@@ -2825,8 +2826,6 @@ cp_fold (tree x)
            break;
          }
 
-       if (!changed)
-         x = org_x;
        break;
       }
 
@@ -2865,24 +2864,18 @@ cp_fold (tree x)
     case TREE_VEC:
       {
        bool changed = false;
-       releasing_vec vec;
-       int i, n = TREE_VEC_LENGTH (x);
-       vec_safe_reserve (vec, n);
+       int n = TREE_VEC_LENGTH (x);
 
-       for (i = 0; i < n; i++)
+       for (int i = 0; i < n; i++)
          {
            tree op = cp_fold (TREE_VEC_ELT (x, i));
-           vec->quick_push (op);
            if (op != TREE_VEC_ELT (x, i))
-             changed = true;
-         }
-
-       if (changed)
-         {
-           r = copy_node (x);
-           for (i = 0; i < n; i++)
-             TREE_VEC_ELT (r, i) = (*vec)[i];
-           x = r;
+             {
+               if (!changed)
+                 x = copy_node (x);
+               TREE_VEC_ELT (x, i) = op;
+               changed = true;
+             }
          }
       }
 

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 4a36c855d39f4b4f5b3ef8be4b4c37963c578db2..09f89951042f0ee8e4506274162320c81bd6780f 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2020-05-04  Patrick Palka  <ppalka@redhat.com>
+
+       PR c++/94038
+       * g++.dg/warn/pr94038.C: New test.
+
 2020-05-04  Richard Sandiford  <richard.sandiford@arm.com>
 
        PR middle-end/94941

diff --git a/gcc/testsuite/g++.dg/warn/pr94038.C b/gcc/testsuite/g++.dg/warn/pr94038.C
new file mode 100644 (file)
index 0000000..4edfae7
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/pr94038.C
@@ -0,0 +1,26 @@
+// PR c++/94038
+// { dg-do compile { target c++11 } }
+// { dg-additional-options "-O -Wall" }
+
+template<typename T>
+constexpr int
+foo()
+{
+  static_assert(T(1) == 0, "");
+  return 0;
+}
+
+template<typename T>
+constexpr int
+bar()
+{
+  return foo<T>();
+}
+
+constexpr int
+baz(int a)
+{
+  return a;
+}
+
+static_assert(decltype(baz(bar<int>())){} == 0, "");