[Bug c++/108975] New: Internal compiler error on constexpr variable used as nontype template

[Bug c++/108975] New: Internal compiler error on constexpr variable used as nontype template

[samuelpmish at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

            Bug ID: 108975
           Summary: Internal compiler error on constexpr variable used as
                    nontype template
           Product: gcc
           Version: 12.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: samuelpmish at gmail dot com
  Target Milestone: ---

Hi, 

I'm running into an internal compiler error with g++ (12.1.0):


internal compiler error: in lookup_template_class_1, at cp/pt.cc:10114
[build]   120 |     using derivative_type   =
decltype(domain_integral::get_derivative_type<index, dim, trials...>(qf,
state_type{}));
[build]       |                                                                
                   ^~~
[build] 0x662042 lookup_template_class_1
[build]         ../../src/gcc/cp/pt.cc:10114
[build] 0x81c004 lookup_template_class(tree_node*, tree_node*, tree_node*,
tree_node*, int, int)
[build]         ../../src/gcc/cp/pt.cc:10353
[build] 0x81c004 tsubst_aggr_type
[build]         ../../src/gcc/cp/pt.cc:13747
[build] 0x80e549 tsubst_aggr_type
[build]         ../../src/gcc/cp/pt.cc:17421
[build] 0x80e549 tsubst_copy
[build]         ../../src/gcc/cp/pt.cc:16928
[build] 0x80fc58 tsubst_copy_and_build(tree_node*, tree_node*, int, tree_node*,
bool, bool)
[build]         ../../src/gcc/cp/pt.cc:21050
[build] 0x8200e8 tsubst_expr(tree_node*, tree_node*, int, tree_node*, bool)
[build]         ../../src/gcc/cp/pt.cc:19491
[build] 0x81cfb2 tsubst_expr(tree_node*, tree_node*, int, tree_node*, bool)
[build]         ../../src/gcc/cp/pt.cc:18462
[build] 0x81cfb2 tsubst_decl
[build]         ../../src/gcc/cp/pt.cc:15004
[build] 0x80e92b tsubst_copy
[build]         ../../src/gcc/cp/pt.cc:17000
[build] 0x80f4e1 tsubst_copy_and_build(tree_node*, tree_node*, int, tree_node*,
bool, bool)
[build]         ../../src/gcc/cp/pt.cc:21265
[build] 0x80fe8d tsubst_copy_and_build(tree_node*, tree_node*, int, tree_node*,
bool, bool)
[build]         ../../src/gcc/cp/pt.cc:20117
[build] 0x8200e8 tsubst_expr(tree_node*, tree_node*, int, tree_node*, bool)
[build]         ../../src/gcc/cp/pt.cc:19491
[build] 0x825bad tsubst_template_args(tree_node*, tree_node*, int, tree_node*)
[build]         ../../src/gcc/cp/pt.cc:13517
[build] 0x8108fe tsubst_copy_and_build(tree_node*, tree_node*, int, tree_node*,
bool, bool)
[build]         ../../src/gcc/cp/pt.cc:20055
[build] 0x80f865 tsubst_copy_and_build(tree_node*, tree_node*, int, tree_node*,
bool, bool)
[build]         ../../src/gcc/cp/pt.cc:20676
[build] 0x818c01 tsubst(tree_node*, tree_node*, int, tree_node*)
[build]         ../../src/gcc/cp/pt.cc:16315
[build] 0x81c344 tsubst_decl
[build]         ../../src/gcc/cp/pt.cc:14952
[build] 0x8226bb tsubst_expr(tree_node*, tree_node*, int, tree_node*, bool)
[build]         ../../src/gcc/cp/pt.cc:18590
[build] 0x821632 tsubst_expr(tree_node*, tree_node*, int, tree_node*, bool)
[build]         ../../src/gcc/cp/pt.cc:18462

g++ (11.3.0) also fails in a similar way: 

internal compiler error: in lookup_template_class_1, at cp/pt.c:10093
[build]   120 |     using derivative_type   =
decltype(domain_integral::get_derivative_type<index, dim, trials...>(qf,
state_type{}));
[build]       |                                                                
                 ^~~
[build] 0x7fc84da29d8f __libc_start_call_main
[build]         ../sysdeps/nptl/libc_start_call_main.h:58
[build] 0x7fc84da29e3f __libc_start_main_impl
[build]         ../csu/libc-start.c:392

but g++ (10.4.0) and clang (14.0.0) compile the same code without any issues.

-------------------------------------

The line of code it referred to before the backtrace is something like:

  constexpr int dim = dimension_of(geom);
  [&](auto index) {
    ...
    using derivative_type =
decltype(domain_integral::get_derivative_type<index, dim, trials...>(qf,
state_type{}));
    ...
  }

If I make `dim` static in addition to constexpr, then the internal compiler
error disappears. I've tried for a bit to come up with a smaller example that
reproduces this issue, but wasn't able to find one.

The full compilation line is (after removing some long include directory flags)

/usr/bin/g++-12 -DAXOM_DEBUG -DGTEST_HAS_DEATH_TEST=0 -Wall -Wextra  -pthread
-freport-bug     -Werror  -Wshadow -Wdouble-promotion -Wconversion -Wundef
-Wnull-dereference -Wold-style-cast -g -fPIE -fopenmp -Wno-class-memaccess
-DCONDUIT_RELAY_IO_MPI_ENABLED -DCONDUIT_BLUEPRINT_MPI_ENABLED -std=c++17 -o
file.o -c file.cpp

Following the guidance in README.Bugs, I also compiled with -save-temps to
produce a .ii file, but it is too large to attach here, so I'll include a
dropbox link to it: https://www.dropbox.com/s/slrf8r500vargd5/file.ii?dl=0 

I'm new to submitting bugs to gcc/g++, so if there's any more information I can
provide please let me know.

Sam

[Bug c++/108975] Internal compiler error on constexpr variable used as nontype template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
>but it is too large to attach here, 

You can use bzip2 or zip to compress it and attach that.

[Bug c++/108975] Internal compiler error on constexpr variable used as nontype template

[samuelpmish at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #2 from Sam Mish <samuelpmish at gmail dot com> ---
Does the dropbox link to the .ii file not work for you, Andrew?

[Bug c++/108975] Internal compiler error on constexpr variable used as nontype template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Sam Mish from comment #2)
> Does the dropbox link to the .ii file not work for you, Andrew?

It does but I was just explaining how we are ok with compressed files in many
cases.

[Bug c++/108975] Internal compiler error on constexpr variable used as nontype template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #4 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Created attachment 54560
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=54560&action=edit
Original unreduced testcase

[Bug c++/108975] Internal compiler error on constexpr variable used as nontype template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #5 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Trying to reduce this.

[Bug c++/108975] Internal compiler error on constexpr variable used as nontype template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2023-03-01
           Keywords|needs-reduction             |
             Status|UNCONFIRMED                 |NEW
     Ever confirmed|0                           |1

--- Comment #6 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Reduced:
int h(int);
template <int index, int dim, typename trials>
  auto get_derivative_type1() { return 0; }
template <typename test, typename trials>
void generate_kernels1() {
        const unsigned num_elements = 1;
        constexpr int dim = 1;
        [&](auto index) {
                using derivative_type = decltype(get_derivative_type1<index,
dim, trials>());
                h(num_elements * 1);
        };
}
void thermal_test()  {
        generate_kernels1<int, int>();
}

[Bug c++/108975] [10/11/12/13 Regression] Internal compiler error on constexpr variable used as nontype template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
      Known to work|                            |8.2.0
           Keywords|                            |ice-on-valid-code,
                   |                            |needs-bisection
   Target Milestone|---                         |10.5
      Known to fail|                            |8.3.0
            Summary|Internal compiler error on  |[10/11/12/13 Regression]
                   |constexpr variable used as  |Internal compiler error on
                   |nontype template            |constexpr variable used as
                   |                            |nontype template

--- Comment #7 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
>but g++ (10.4.0) and clang (14.0.0) compile the same code without any issues.


Interesting because my reduced testcase also ICEs with GCC 10.4.0. Anyways it
is still a regression between GCC 8.2.0 and GCC 8.3.0.

[Bug c++/108975] [10/11/12/13 Regression] Internal compiler error on constexpr variable used as nontype template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #8 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
A slightly more reduced:
int h(int);
template <int dim>
  auto hh() { return 0; }
template<int a>
void mm() {
        const unsigned num_elements = 1;
        constexpr int dim = 1;
        [&]() {
                typedef decltype(hh<dim>()) derivative_type;
                h(num_elements * 1);
        };
}
void u()  {
        mm<1>();
}

[Bug c++/108975] [10/11/12/13 Regression] Internal compiler error on constexpr variable used as nontype template

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #9 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
The trunk ICE is definitely lambda related:
          /* Lambda closures are regenerated in tsubst_lambda_expr, not
             instantiated here.  */
          gcc_assert (!LAMBDA_TYPE_P (template_type));

[Bug c++/108975] [10/11/12/13 Regression] Internal compiler error on constexpr variable used as nontype template

[samuelpmish at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #10 from Sam Mish <samuelpmish at gmail dot com> ---
Great-- thanks for finding such a small reproducer, Andrew.

[Bug c++/108975] [10/11/12/13 Regression] Internal compiler error on constexpr variable used as nontype template

[ppalka at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|needs-bisection             |
                 CC|                            |ppalka at gcc dot gnu.org

--- Comment #11 from Patrick Palka <ppalka at gcc dot gnu.org> ---
Started with r268016

[Bug c++/108975] [10/11/12/13 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[ppalka at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|[10/11/12/13 Regression]    |[10/11/12/13 Regression]
                   |ICE on constexpr variable   |ICE on constexpr variable
                   |used as nontype template    |used as nontype template
                   |since                       |since
                   |e32fc4499f863fe0fa81767d11f |r9-5473-ge32fc4499f863f
                   |40ad2f1ab1668               |

--- Comment #12 from Patrick Palka <ppalka at gcc dot gnu.org> ---
(In reply to Patrick Palka from comment #11)
> Started with r268016
... aka r9-5473-ge32fc4499f863f.


More reduced testcase:

template<class T>
void f() {
  constexpr int dim = 1;
  auto f = [&] {
    int n[dim * 1];
  };
}

template void f<int>();

<stdin>: In instantiation of ‘void f() [with T = int]’:
<stdin>:9:22:   required from here
<stdin>:5:11: internal compiler error: in lookup_template_class, at
cp/pt.cc:10080


We similarly crash when using a generic lambda:

template<class T>
void f() {
  constexpr int dim = 1;
  auto f = [&] (auto) {
    int n[dim * 1];
  };
  f(0);
}

template void f<int>();

In either case, since dim is a constant variable we should prune the implicit
capture of it and sizeof(f) should be 1.

[Bug c++/108975] [10/11/12/13 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[mpolacek at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |mpolacek at gcc dot gnu.org
           Priority|P3                          |P2

[Bug c++/108975] [10/11/12/13 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[jason at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Jason Merrill <jason at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |ASSIGNED
                 CC|                            |jason at gcc dot gnu.org
           Assignee|unassigned at gcc dot gnu.org      |jason at gcc dot gnu.org

[Bug c++/108975] [10/11/12/13 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #13 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The trunk branch has been updated by Jason Merrill <jason@gcc.gnu.org>:

https://gcc.gnu.org/g:6f90de97634d6f1617a054429f28b85fbfbd8b6f

commit r13-6743-g6f90de97634d6f1617a054429f28b85fbfbd8b6f
Author: Jason Merrill <jason@redhat.com>
Date:   Fri Mar 17 17:26:40 2023 -0400

    c++: constant, array, lambda, template [PR108975]

    When a lambda refers to a constant local variable in the enclosing scope,
we
    tentatively capture it, but if we end up pulling out its constant value, we
    go back at the end of the lambda and prune any unneeded captures.  Here
    while parsing the template we decided that the dim capture was unneeded,
    because we folded it away, but then we brought back the use in the template
    trees that try to preserve the source representation with added type info.
    So then when we tried to instantiate that use, we couldn't find what it was
    trying to use, and crashed.

    Fixed by not trying to prune when parsing a template; we'll prune at
    instantiation time.

            PR c++/108975

    gcc/cp/ChangeLog:

            * lambda.cc (prune_lambda_captures): Don't bother in a template.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/lambda/lambda-const11.C: New test.

[Bug c++/108975] [10/11/12 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #14 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-12 branch has been updated by Jason Merrill
<jason@gcc.gnu.org>:

https://gcc.gnu.org/g:55ab4606ab1084a55d53184c5cf4543740a7f65d

commit r12-9440-g55ab4606ab1084a55d53184c5cf4543740a7f65d
Author: Jason Merrill <jason@redhat.com>
Date:   Fri Mar 17 17:26:40 2023 -0400

    c++: constant, array, lambda, template [PR108975]

    When a lambda refers to a constant local variable in the enclosing scope,
we
    tentatively capture it, but if we end up pulling out its constant value, we
    go back at the end of the lambda and prune any unneeded captures.  Here
    while parsing the template we decided that the dim capture was unneeded,
    because we folded it away, but then we brought back the use in the template
    trees that try to preserve the source representation with added type info.
    So then when we tried to instantiate that use, we couldn't find what it was
    trying to use, and crashed.

    Fixed by not trying to prune when parsing a template; we'll prune at
    instantiation time.

            PR c++/108975

    gcc/cp/ChangeLog:

            * lambda.cc (prune_lambda_captures): Don't bother in a template.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/lambda/lambda-const11.C: New test.

[Bug c++/108975] [10/11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #15 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-10 branch has been updated by Jason Merrill
<jason@gcc.gnu.org>:

https://gcc.gnu.org/g:92e2bb31ffe25271e5ae70d7533469419b883864

commit r10-11305-g92e2bb31ffe25271e5ae70d7533469419b883864
Author: Jason Merrill <jason@redhat.com>
Date:   Fri Mar 17 17:26:40 2023 -0400

    c++: constant, array, lambda, template [PR108975]

    When a lambda refers to a constant local variable in the enclosing scope,
we
    tentatively capture it, but if we end up pulling out its constant value, we
    go back at the end of the lambda and prune any unneeded captures.  Here
    while parsing the template we decided that the dim capture was unneeded,
    because we folded it away, but then we brought back the use in the template
    trees that try to preserve the source representation with added type info.
    So then when we tried to instantiate that use, we couldn't find what it was
    trying to use, and crashed.

    Fixed by not trying to prune when parsing a template; we'll prune at
    instantiation time.

            PR c++/108975

    gcc/cp/ChangeLog:

            * lambda.c (prune_lambda_captures): Don't bother in a template.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/lambda/lambda-const11.C: New test.

[Bug c++/108975] [10/11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #16 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-11 branch has been updated by Jason Merrill
<jason@gcc.gnu.org>:

https://gcc.gnu.org/g:51738bb097444dd3ca7adcfa28ae8dcff5a14c50

commit r11-10645-g51738bb097444dd3ca7adcfa28ae8dcff5a14c50
Author: Jason Merrill <jason@redhat.com>
Date:   Fri Mar 17 17:26:40 2023 -0400

    c++: constant, array, lambda, template [PR108975]

    When a lambda refers to a constant local variable in the enclosing scope,
we
    tentatively capture it, but if we end up pulling out its constant value, we
    go back at the end of the lambda and prune any unneeded captures.  Here
    while parsing the template we decided that the dim capture was unneeded,
    because we folded it away, but then we brought back the use in the template
    trees that try to preserve the source representation with added type info.
    So then when we tried to instantiate that use, we couldn't find what it was
    trying to use, and crashed.

    Fixed by not trying to prune when parsing a template; we'll prune at
    instantiation time.

            PR c++/108975

    gcc/cp/ChangeLog:

            * lambda.c (prune_lambda_captures): Don't bother in a template.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/lambda/lambda-const11.C: New test.

[Bug c++/108975] [10/11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #17 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Patrick Palka <ppalka@gcc.gnu.org>:

https://gcc.gnu.org/g:3d674e29d7f89bf93fcfcc963ff0248c6347586d

commit r14-228-g3d674e29d7f89bf93fcfcc963ff0248c6347586d
Author: Patrick Palka <ppalka@redhat.com>
Date:   Tue Apr 25 15:59:22 2023 -0400

    c++: value dependence of by-ref lambda capture [PR108975]

    We are still ICEing on the generic lambda version of the testcase from
    this PR, even after r13-6743-g6f90de97634d6f, due to the by-ref capture
    of the constant local variable 'dim' being considered value-dependent
    when regenerating the lambda (at which point processing_template_decl is
    set since the lambda is generic), which prevents us from constant folding
    its uses.  Later during prune_lambda_captures we end up not thoroughly
    walking the body of the lambda and overlook the (non-folded) uses of
    'dim' within the array bound and using-decls.

    We could fix this by making prune_lambda_captures walk the body of the
    lambda more thoroughly so that it finds these uses of 'dim', but ideally
    we should be able to constant fold all uses of 'dim' ahead of time and
    prune the implicit capture after all.

    To that end this patch makes value_dependent_expression_p return false
    for such by-ref captures of constant local variables, allowing their
    uses to get constant folded ahead of time.  It seems we just need to
    disable the predicate's conservative early exit for reference variables
    (added by r5-5022-g51d72abe5ea04e) when DECL_HAS_VALUE_EXPR_P.  This
    effectively makes us treat by-value and by-ref captures more consistently
    when it comes to value dependence.

            PR c++/108975

    gcc/cp/ChangeLog:

            * pt.cc (value_dependent_expression_p) <case VAR_DECL>:
            Suppress conservative early exit for reference variables
            when DECL_HAS_VALUE_EXPR_P.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/lambda/lambda-const11a.C: New test.

[Bug c++/108975] [11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|10.5                        |11.5

--- Comment #18 from Richard Biener <rguenth at gcc dot gnu.org> ---
GCC 10 branch is being closed.

[Bug c++/108975] [11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[jason at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Jason Merrill <jason at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Assignee|jason at gcc dot gnu.org           |ppalka at gcc dot gnu.org
   Target Milestone|11.5                        |11.4

--- Comment #19 from Jason Merrill <jason at gcc dot gnu.org> ---
Patrick, do you want to backport your patch?

[Bug c++/108975] [11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[ppalka at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #20 from Patrick Palka <ppalka at gcc dot gnu.org> ---
(In reply to Jason Merrill from comment #19)
> Patrick, do you want to backport your patch?

Sure, will do

[Bug c++/108975] [11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #21 from GCC Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-13 branch has been updated by Patrick Palka
<ppalka@gcc.gnu.org>:

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

commit r13-8170-gc563e5d6c5177bedf0dd8fc410f390bb3ec37183
Author: Patrick Palka <ppalka@redhat.com>
Date:   Tue Apr 25 15:59:22 2023 -0400

    c++: value dependence of by-ref lambda capture [PR108975]

    We are still ICEing on the generic lambda version of the testcase from
    this PR, even after r13-6743-g6f90de97634d6f, due to the by-ref capture
    of the constant local variable 'dim' being considered value-dependent
    when regenerating the lambda (at which point processing_template_decl is
    set since the lambda is generic), which prevents us from constant folding
    its uses.  Later during prune_lambda_captures we end up not thoroughly
    walking the body of the lambda and overlook the (non-folded) uses of
    'dim' within the array bound and using-decls.

    We could fix this by making prune_lambda_captures walk the body of the
    lambda more thoroughly so that it finds these uses of 'dim', but ideally
    we should be able to constant fold all uses of 'dim' ahead of time and
    prune the implicit capture after all.

    To that end this patch makes value_dependent_expression_p return false
    for such by-ref captures of constant local variables, allowing their
    uses to get constant folded ahead of time.  It seems we just need to
    disable the predicate's conservative early exit for reference variables
    (added by r5-5022-g51d72abe5ea04e) when DECL_HAS_VALUE_EXPR_P.  This
    effectively makes us treat by-value and by-ref captures more consistently
    when it comes to value dependence.

            PR c++/108975

    gcc/cp/ChangeLog:

            * pt.cc (value_dependent_expression_p) <case VAR_DECL>:
            Suppress conservative early exit for reference variables
            when DECL_HAS_VALUE_EXPR_P.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/lambda/lambda-const11a.C: New test.

    (cherry picked from commit 3d674e29d7f89bf93fcfcc963ff0248c6347586d)

[Bug c++/108975] [11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #22 from GCC Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-12 branch has been updated by Patrick Palka
<ppalka@gcc.gnu.org>:

https://gcc.gnu.org/g:035fa0105e8d12ca6750545369dd901cb0a2aff0

commit r12-10063-g035fa0105e8d12ca6750545369dd901cb0a2aff0
Author: Patrick Palka <ppalka@redhat.com>
Date:   Tue Apr 25 15:59:22 2023 -0400

    c++: value dependence of by-ref lambda capture [PR108975]

    We are still ICEing on the generic lambda version of the testcase from
    this PR, even after r13-6743-g6f90de97634d6f, due to the by-ref capture
    of the constant local variable 'dim' being considered value-dependent
    when regenerating the lambda (at which point processing_template_decl is
    set since the lambda is generic), which prevents us from constant folding
    its uses.  Later during prune_lambda_captures we end up not thoroughly
    walking the body of the lambda and overlook the (non-folded) uses of
    'dim' within the array bound and using-decls.

    We could fix this by making prune_lambda_captures walk the body of the
    lambda more thoroughly so that it finds these uses of 'dim', but ideally
    we should be able to constant fold all uses of 'dim' ahead of time and
    prune the implicit capture after all.

    To that end this patch makes value_dependent_expression_p return false
    for such by-ref captures of constant local variables, allowing their
    uses to get constant folded ahead of time.  It seems we just need to
    disable the predicate's conservative early exit for reference variables
    (added by r5-5022-g51d72abe5ea04e) when DECL_HAS_VALUE_EXPR_P.  This
    effectively makes us treat by-value and by-ref captures more consistently
    when it comes to value dependence.

            PR c++/108975

    gcc/cp/ChangeLog:

            * pt.cc (value_dependent_expression_p) <case VAR_DECL>:
            Suppress conservative early exit for reference variables
            when DECL_HAS_VALUE_EXPR_P.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/lambda/lambda-const11a.C: New test.

    (cherry picked from commit 3d674e29d7f89bf93fcfcc963ff0248c6347586d)

[Bug c++/108975] [11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

--- Comment #23 from GCC Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-11 branch has been updated by Patrick Palka
<ppalka@gcc.gnu.org>:

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

commit r11-11161-ga53f988e36132761c8fe17da421b736e737dec30
Author: Patrick Palka <ppalka@redhat.com>
Date:   Tue Apr 25 15:59:22 2023 -0400

    c++: value dependence of by-ref lambda capture [PR108975]

    We are still ICEing on the generic lambda version of the testcase from
    this PR, even after r13-6743-g6f90de97634d6f, due to the by-ref capture
    of the constant local variable 'dim' being considered value-dependent
    when regenerating the lambda (at which point processing_template_decl is
    set since the lambda is generic), which prevents us from constant folding
    its uses.  Later during prune_lambda_captures we end up not thoroughly
    walking the body of the lambda and overlook the (non-folded) uses of
    'dim' within the array bound and using-decls.

    We could fix this by making prune_lambda_captures walk the body of the
    lambda more thoroughly so that it finds these uses of 'dim', but ideally
    we should be able to constant fold all uses of 'dim' ahead of time and
    prune the implicit capture after all.

    To that end this patch makes value_dependent_expression_p return false
    for such by-ref captures of constant local variables, allowing their
    uses to get constant folded ahead of time.  It seems we just need to
    disable the predicate's conservative early exit for reference variables
    (added by r5-5022-g51d72abe5ea04e) when DECL_HAS_VALUE_EXPR_P.  This
    effectively makes us treat by-value and by-ref captures more consistently
    when it comes to value dependence.

            PR c++/108975

    gcc/cp/ChangeLog:

            * pt.c (value_dependent_expression_p) <case VAR_DECL>:
            Suppress conservative early exit for reference variables
            when DECL_HAS_VALUE_EXPR_P.

    gcc/testsuite/ChangeLog:

            * g++.dg/cpp0x/lambda/lambda-const11a.C: New test.

    (cherry picked from commit 3d674e29d7f89bf93fcfcc963ff0248c6347586d)

[Bug c++/108975] [11 Regression] ICE on constexpr variable used as nontype template since r9-5473-ge32fc4499f863f

[ppalka at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108975

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         Resolution|---                         |FIXED
             Status|ASSIGNED                    |RESOLVED

--- Comment #24 from Patrick Palka <ppalka at gcc dot gnu.org> ---
Partially fixed (the non-generic lambda case) for 10.5/11.4/12.3/13.2, more
thoroughly fixed (the generic lambda casE) for 11.5/12.4/13.3.