The reported problem was due to creating a CONSTRUCTOR with pointer
type, expecting it to be an array; now we only build a CONSTRUCTOR for
array type. While I was looking at this issue I noticed that the
user-defined type case also had problems, because it was still using T()
instead of {} to initialize an aggregate element without an explicit
initializer. And then after fixing that I needed to fix substitution
failure recovery in convert_like_real.
Tested x86_64-pc-linux-gnu, applying to trunk.
commit c4c9a3c2114d65faf23819ab9efdb9fdc4d650f1
Author: Jason Merrill <ja...@redhat.com>
Date: Mon Jun 20 17:14:39 2011 -0400
PR c++/49216
* init.c (build_vec_init): Don't try to use a CONSTRUCTOR when
base is a pointer.
* typeck2.c (process_init_constructor_array): Use {} for classes,
too.
* call.c (convert_like_real): Handle substitution failure.
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index e9d6e7e..caf95b0 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -5621,7 +5621,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
expr = build_cplus_new (totype, expr, complain);
/* Remember that this was list-initialization. */
- if (convs->check_narrowing)
+ if (convs->check_narrowing && expr != error_mark_node)
TARGET_EXPR_LIST_INIT_P (expr) = true;
}
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 140e064..3c347a4 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -3082,8 +3082,9 @@ build_vec_init (tree base, tree maxindex, tree init,
unsigned HOST_WIDE_INT idx;
tree field, elt;
/* Should we try to create a constant initializer? */
- bool try_const = (literal_type_p (inner_elt_type)
- || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type));
+ bool try_const = (TREE_CODE (atype) == ARRAY_TYPE
+ && (literal_type_p (inner_elt_type)
+ || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type)));
bool saw_non_const = false;
bool saw_const = false;
/* If we're initializing a static array, we want to do static
diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index 6d6267e..ff2949c 100644
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -1051,14 +1051,9 @@ process_init_constructor_array (tree type, tree init,
if (type_build_ctor_call (TREE_TYPE (type)))
{
/* If this type needs constructors run for default-initialization,
- we can't rely on the back end to do it for us, so build up
- TARGET_EXPRs. If the type in question is a class, just build
- one up; if it's an array, recurse. */
- if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
- next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
- complain);
- else
- next = build_constructor (init_list_type_node, NULL);
+ we can't rely on the back end to do it for us, so make the
+ initialization explicit by list-initializing from {}. */
+ next = build_constructor (init_list_type_node, NULL);
next = digest_init (TREE_TYPE (type), next, complain);
}
else if (!zero_init_p (TREE_TYPE (type)))
diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist53.C b/gcc/testsuite/g++.dg/cpp0x/initlist53.C
new file mode 100644
index 0000000..750ebba
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/initlist53.C
@@ -0,0 +1,20 @@
+// PR c++/49216
+// { dg-options -std=c++0x }
+// { dg-do run }
+
+#include <initializer_list>
+extern "C" void abort();
+
+bool constructed;
+
+struct A
+{
+ A(std::initializer_list<int>) { constructed = true; }
+};
+
+int main() {
+ new A[1]{};
+ int *p = new int[1]{};
+ if (p[0] != 0 || !constructed)
+ abort();
+}
