that's value-initialization. */
if (init == void_type_node)
{
- /* If there's a user-provided constructor, we just call that. */
- if (type_has_user_provided_constructor (type))
- /* Fall through. */;
- /* If there isn't, but we still need to call the constructor,
- zero out the object first. */
- else if (type_build_ctor_call (type))
- {
- init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
+ /* If no user-provided ctor, we need to zero out the object. */
+ if (!type_has_user_provided_constructor (type))
+ {
+ tree field_size = NULL_TREE;
+ if (exp != true_exp && CLASSTYPE_AS_BASE (type) != type)
+ /* Don't clobber already initialized virtual bases. */
+ field_size = TYPE_SIZE (CLASSTYPE_AS_BASE (type));
+ init = build_zero_init_1 (type, NULL_TREE, /*static_storage_p=*/false,
+ field_size);
init = build2 (INIT_EXPR, type, exp, init);
finish_expr_stmt (init);
- /* And then call the constructor. */
}
+
/* If we don't need to mess with the constructor at all,
- then just zero out the object and we're done. */
- else
- {
- init = build2 (INIT_EXPR, type, exp,
- build_value_init_noctor (type, complain));
- finish_expr_stmt (init);
- return;
- }
+ then we're done. */
+ if (! type_build_ctor_call (type))
+ return;
+
+ /* Otherwise fall through and call the constructor. */
init = NULL_TREE;
}
--- /dev/null
+// PR c++/50618
+// { dg-do run }
+
+struct Base
+{
+ const int text;
+ Base():text(1) {}
+ Base(int aText)
+ : text(aText) {}
+};
+struct SubA : public virtual Base
+{
+protected:
+ int x;
+public:
+ SubA(int aX)
+ : x(aX) {}
+};
+class SubB : public virtual Base
+{};
+struct Diamond : public SubA, public SubB
+{
+ Diamond(int text)
+ : Base(text), SubA(5), SubB() {}
+
+ void printText()
+ {
+ if(text != 2)
+ __builtin_abort();
+ if(x!=5)
+ __builtin_abort();
+ }
+};
+
+int main(int, char**)
+{
+ Diamond x(2);
+ x.printText();
+}