[gcc r15-3796] c++: Don't ICE due to artificial constructor parameters [PR116722]

[Simon Martin via Gcc-cvs]

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

commit r15-3796-gd7bf5e53887a467b8c5c8439e5aae3ad4e11e62e
Author: Simon Martin <si...@nasilyan.com>
Date:   Wed Sep 18 12:35:27 2024 +0200

    c++: Don't ICE due to artificial constructor parameters [PR116722]
    
    The following code triggers an ICE
    
    === cut here ===
    class base {};
    class derived : virtual public base {
    public:
      template<typename Arg> constexpr derived(Arg) {}
    };
    int main() {
      derived obj(1.);
    }
    === cut here ===
    
    The problem is that cxx_bind_parameters_in_call ends up attempting to
    convert a REAL_CST (the first non artificial parameter) to INTEGER_TYPE
    (the type of the __in_chrg parameter), which ICEs.
    
    This patch changes cxx_bind_parameters_in_call to return early if it's
    called with a *structor that has an __in_chrg or __vtt_parm parameter
    since the expression won't be a constant expression.
    
    Note that in the test case, the constructor is not constexpr-suitable,
    however it's OK since it's a template according to my read of paragraph
    (3) of [dcl.constexpr].
    
            PR c++/116722
    
    gcc/cp/ChangeLog:
    
            * constexpr.cc (cxx_bind_parameters_in_call): Leave early for
            {con,de}structors of classes with virtual bases.
    
    gcc/testsuite/ChangeLog:
    
            * g++.dg/cpp0x/constexpr-ctor22.C: New test.

Diff:
---
 gcc/cp/constexpr.cc                           | 11 ++++++++++-
 gcc/testsuite/g++.dg/cpp0x/constexpr-ctor22.C | 15 +++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc
index f6fd059be466..5c6696740fc9 100644
--- a/gcc/cp/constexpr.cc
+++ b/gcc/cp/constexpr.cc
@@ -1862,6 +1862,15 @@ cxx_bind_parameters_in_call (const constexpr_ctx *ctx, 
tree t, tree fun,
   int nparms = list_length (parms);
   int nbinds = nargs < nparms ? nargs : nparms;
   tree binds = make_tree_vec (nbinds);
+
+  /* The call is not a constant expression if it involves the cdtor for a type
+     with virtual bases.  */
+  if (DECL_HAS_IN_CHARGE_PARM_P (fun) || DECL_HAS_VTT_PARM_P (fun))
+    {
+      *non_constant_p = true;
+      return binds;
+    }
+
   for (i = 0; i < nargs; ++i)
     {
       tree x, arg;
@@ -1871,7 +1880,7 @@ cxx_bind_parameters_in_call (const constexpr_ctx *ctx, 
tree t, tree fun,
       x = get_nth_callarg (t, i);
       /* For member function, the first argument is a pointer to the implied
          object.  For a constructor, it might still be a dummy object, in
-         which case we get the real argument from ctx. */
+        which case we get the real argument from ctx.  */
       if (i == 0 && DECL_CONSTRUCTOR_P (fun)
          && is_dummy_object (x))
        {
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-ctor22.C 
b/gcc/testsuite/g++.dg/cpp0x/constexpr-ctor22.C
new file mode 100644
index 000000000000..279f6ec44547
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-ctor22.C
@@ -0,0 +1,15 @@
+// PR c++/116722
+// We're now accepting this in spite of the virtual base class. This is OK
+// according to [dcl.constexpr] 3: "Except for instantiated constexpr functions
+// non-templated constexpr functions shall be constexpr-suitable".
+// { dg-do compile { target c++11 } }
+
+class base {};
+class derived : virtual public base {
+public:
+  template<typename Arg>
+  constexpr derived(Arg) {}
+};
+int main() {
+  derived obj(1.);
+}