/* Handle initialization things in C++.

Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,

2011 Free Software Foundation, Inc.

Contributed by Michael Tiemann (tiemann@cygnus.com)

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 3, or (at your option)

any later version.

GCC is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3. If not see

<http://www.gnu.org/licenses/>. */

/* High-level class interface. */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "cp-tree.h"

#include "flags.h"

#include "output.h"

#include "target.h"

static bool begin_init_stmts (tree *, tree *);

static tree finish_init_stmts (bool, tree, tree);

static void construct_virtual_base (tree, tree);

static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);

static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);

static void perform_member_init (tree, tree);

static tree build_builtin_delete_call (tree);

static int member_init_ok_or_else (tree, tree, tree);

static void expand_virtual_init (tree, tree);

static tree sort_mem_initializers (tree, tree);

static tree initializing_context (tree);

static void expand_cleanup_for_base (tree, tree);

static tree dfs_initialize_vtbl_ptrs (tree, void *);

static tree build_field_list (tree, tree, int *);

static tree build_vtbl_address (tree);

static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool);

/* We are about to generate some complex initialization code.

Conceptually, it is all a single expression. However, we may want

to include conditionals, loops, and other such statement-level

constructs. Therefore, we build the initialization code inside a

statement-expression. This function starts such an expression.

STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;

pass them back to finish_init_stmts when the expression is

complete. */

static bool

begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)

{

bool is_global = !building_stmt_list_p ();

*stmt_expr_p = begin_stmt_expr ();

*compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);

return is_global;

}

/* Finish out the statement-expression begun by the previous call to

begin_init_stmts. Returns the statement-expression itself. */

static tree

finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)

{

finish_compound_stmt (compound_stmt);

stmt_expr = finish_stmt_expr (stmt_expr, true);

gcc_assert (!building_stmt_list_p () == is_global);

return stmt_expr;

}

/* Constructors */

/* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base

which we want to initialize the vtable pointer for, DATA is

TREE_LIST whose TREE_VALUE is the this ptr expression. */

static tree

dfs_initialize_vtbl_ptrs (tree binfo, void *data)

{

if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))

return dfs_skip_bases;

if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))

{

tree base_ptr = TREE_VALUE ((tree) data);

base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);

expand_virtual_init (binfo, base_ptr);

}

return NULL_TREE;

}

/* Initialize all the vtable pointers in the object pointed to by

ADDR. */

void

initialize_vtbl_ptrs (tree addr)

{

tree list;

tree type;

type = TREE_TYPE (TREE_TYPE (addr));

list = build_tree_list (type, addr);

/* Walk through the hierarchy, initializing the vptr in each base

class. We do these in pre-order because we can't find the virtual

bases for a class until we've initialized the vtbl for that

class. */

dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);

}

/* Return an expression for the zero-initialization of an object with

type T. This expression will either be a constant (in the case

that T is a scalar), or a CONSTRUCTOR (in the case that T is an

aggregate), or NULL (in the case that T does not require

initialization). In either case, the value can be used as

DECL_INITIAL for a decl of the indicated TYPE; it is a valid static

initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS

is the number of elements in the array. If STATIC_STORAGE_P is

TRUE, initializers are only generated for entities for which

zero-initialization does not simply mean filling the storage with

zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,

subfields with bit positions at or above that bit size shouldn't

be added. */

static tree

build_zero_init_1 (tree type, tree nelts, bool static_storage_p,

tree field_size)

{

tree init = NULL_TREE;

/* [dcl.init]

To zero-initialize an object of type T means:

-- if T is a scalar type, the storage is set to the value of zero

converted to T.

-- if T is a non-union class type, the storage for each nonstatic

data member and each base-class subobject is zero-initialized.

-- if T is a union type, the storage for its first data member is

zero-initialized.

-- if T is an array type, the storage for each element is

zero-initialized.

-- if T is a reference type, no initialization is performed. */

gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);

if (type == error_mark_node)

;

else if (static_storage_p && zero_init_p (type))

/* In order to save space, we do not explicitly build initializers

for items that do not need them. GCC's semantics are that

items with static storage duration that are not otherwise

initialized are initialized to zero. */

;

else if (SCALAR_TYPE_P (type))

init = convert (type, integer_zero_node);

else if (CLASS_TYPE_P (type))

{

tree field;

VEC(constructor_elt,gc) *v = NULL;

/* Iterate over the fields, building initializations. */

for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))

{

if (TREE_CODE (field) != FIELD_DECL)

continue;

/* Don't add virtual bases for base classes if they are beyond

the size of the current field, that means it is present

somewhere else in the object. */

if (field_size)

{

tree bitpos = bit_position (field);

if (TREE_CODE (bitpos) == INTEGER_CST

&& !tree_int_cst_lt (bitpos, field_size))

continue;

}

/* Note that for class types there will be FIELD_DECLs

corresponding to base classes as well. Thus, iterating

over TYPE_FIELDs will result in correct initialization of

all of the subobjects. */

if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))

{

tree new_field_size

= (DECL_FIELD_IS_BASE (field)

&& DECL_SIZE (field)

&& TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)

? DECL_SIZE (field) : NULL_TREE;

tree value = build_zero_init_1 (TREE_TYPE (field),

/*nelts=*/NULL_TREE,

static_storage_p,

new_field_size);

if (value)

CONSTRUCTOR_APPEND_ELT(v, field, value);

}

/* For unions, only the first field is initialized. */

if (TREE_CODE (type) == UNION_TYPE)

break;

}

/* Build a constructor to contain the initializations. */

init = build_constructor (type, v);

}

else if (TREE_CODE (type) == ARRAY_TYPE)

{

tree max_index;

VEC(constructor_elt,gc) *v = NULL;

/* Iterate over the array elements, building initializations. */

if (nelts)

max_index = fold_build2_loc (input_location,

MINUS_EXPR, TREE_TYPE (nelts),

nelts, integer_one_node);

else

max_index = array_type_nelts (type);

/* If we have an error_mark here, we should just return error mark

as we don't know the size of the array yet. */

if (max_index == error_mark_node)

return error_mark_node;

gcc_assert (TREE_CODE (max_index) == INTEGER_CST);

/* A zero-sized array, which is accepted as an extension, will

have an upper bound of -1. */

if (!tree_int_cst_equal (max_index, integer_minus_one_node))

{

constructor_elt *ce;

v = VEC_alloc (constructor_elt, gc, 1);

ce = VEC_quick_push (constructor_elt, v, NULL);

/* If this is a one element array, we just use a regular init. */

if (tree_int_cst_equal (size_zero_node, max_index))

ce->index = size_zero_node;

else

ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,

max_index);

ce->value = build_zero_init_1 (TREE_TYPE (type),

/*nelts=*/NULL_TREE,

static_storage_p, NULL_TREE);

}

/* Build a constructor to contain the initializations. */

init = build_constructor (type, v);

}

else if (TREE_CODE (type) == VECTOR_TYPE)

init = build_zero_cst (type);

else

gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);

/* In all cases, the initializer is a constant. */

if (init)

TREE_CONSTANT (init) = 1;

return init;

}

/* Return an expression for the zero-initialization of an object with

type T. This expression will either be a constant (in the case

that T is a scalar), or a CONSTRUCTOR (in the case that T is an

aggregate), or NULL (in the case that T does not require

initialization). In either case, the value can be used as

DECL_INITIAL for a decl of the indicated TYPE; it is a valid static

initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS

is the number of elements in the array. If STATIC_STORAGE_P is

TRUE, initializers are only generated for entities for which

zero-initialization does not simply mean filling the storage with

zero bytes. */

tree

build_zero_init (tree type, tree nelts, bool static_storage_p)

{

return build_zero_init_1 (type, nelts, static_storage_p, NULL_TREE);

}

/* Return a suitable initializer for value-initializing an object of type

TYPE, as described in [dcl.init]. */

tree

build_value_init (tree type, tsubst_flags_t complain)

{

/* [dcl.init]

To value-initialize an object of type T means:

- if T is a class type (clause 9) with a user-provided constructor

(12.1), then the default constructor for T is called (and the

initialization is ill-formed if T has no accessible default

constructor);

- if T is a non-union class type without a user-provided constructor,

then every non-static data member and base-class component of T is

value-initialized;92)

- if T is an array type, then each element is value-initialized;

- otherwise, the object is zero-initialized.

A program that calls for default-initialization or

value-initialization of an entity of reference type is ill-formed.

92) Value-initialization for such a class object may be implemented by

zero-initializing the object and then calling the default

constructor. */

/* The AGGR_INIT_EXPR tweaking below breaks in templates. */

gcc_assert (!processing_template_decl);

if (CLASS_TYPE_P (type))

{

/* Instead of the above, only consider the user-providedness of the

default constructor itself so value-initializing a class with an

explicitly defaulted default constructor and another user-provided

constructor works properly (c++std-core-19883). */

if (type_has_user_provided_default_constructor (type)

|| (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)

&& type_has_user_provided_constructor (type)))

return build_aggr_init_expr

(type,

build_special_member_call (NULL_TREE, complete_ctor_identifier,

NULL, type, LOOKUP_NORMAL,

complain),

complain);

else if (TYPE_HAS_COMPLEX_DFLT (type))

{

/* This is a class that needs constructing, but doesn't have

a user-provided constructor. So we need to zero-initialize

the object and then call the implicitly defined ctor.

This will be handled in simplify_aggr_init_expr. */

tree ctor = build_special_member_call

(NULL_TREE, complete_ctor_identifier,

NULL, type, LOOKUP_NORMAL, complain);

if (ctor != error_mark_node)

{

ctor = build_aggr_init_expr (type, ctor, complain);

AGGR_INIT_ZERO_FIRST (ctor) = 1;

}

return ctor;

}

}

return build_value_init_noctor (type, complain);

}

/* Like build_value_init, but don't call the constructor for TYPE. Used

for base initializers. */

tree

build_value_init_noctor (tree type, tsubst_flags_t complain)

{

/* FIXME the class and array cases should just use digest_init once it is

SFINAE-enabled. */

if (CLASS_TYPE_P (type))

{

gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type));

if (TREE_CODE (type) != UNION_TYPE)

{

tree field;

VEC(constructor_elt,gc) *v = NULL;

/* Iterate over the fields, building initializations. */

for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))

{

tree ftype, value;

if (TREE_CODE (field) != FIELD_DECL)

continue;

ftype = TREE_TYPE (field);

/* We could skip vfields and fields of types with

user-defined constructors, but I think that won't improve

performance at all; it should be simpler in general just

to zero out the entire object than try to only zero the

bits that actually need it. */

/* Note that for class types there will be FIELD_DECLs

corresponding to base classes as well. Thus, iterating

over TYPE_FIELDs will result in correct initialization of

all of the subobjects. */

value = build_value_init (ftype, complain);

if (value == error_mark_node)

return error_mark_node;

if (value)

CONSTRUCTOR_APPEND_ELT(v, field, value);

}

/* Build a constructor to contain the zero- initializations. */

return build_constructor (type, v);

}

}

else if (TREE_CODE (type) == ARRAY_TYPE)

{

VEC(constructor_elt,gc) *v = NULL;

/* Iterate over the array elements, building initializations. */

tree max_index = array_type_nelts (type);

/* If we have an error_mark here, we should just return error mark

as we don't know the size of the array yet. */

if (max_index == error_mark_node)

{

if (complain & tf_error)

error ("cannot value-initialize array of unknown bound %qT",

type);

return error_mark_node;

}

gcc_assert (TREE_CODE (max_index) == INTEGER_CST);

/* A zero-sized array, which is accepted as an extension, will

have an upper bound of -1. */

if (!tree_int_cst_equal (max_index, integer_minus_one_node))

{

constructor_elt *ce;

v = VEC_alloc (constructor_elt, gc, 1);

ce = VEC_quick_push (constructor_elt, v, NULL);

/* If this is a one element array, we just use a regular init. */

if (tree_int_cst_equal (size_zero_node, max_index))

ce->index = size_zero_node;

else

ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,

max_index);

ce->value = build_value_init (TREE_TYPE (type), complain);

if (ce->value == error_mark_node)

return error_mark_node;

/* We shouldn't have gotten here for anything that would need

non-trivial initialization, and gimplify_init_ctor_preeval

would need to be fixed to allow it. */

gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR

&& TREE_CODE (ce->value) != AGGR_INIT_EXPR);

}

/* Build a constructor to contain the initializations. */

return build_constructor (type, v);

}

else if (TREE_CODE (type) == FUNCTION_TYPE)

{

if (complain & tf_error)

error ("value-initialization of function type %qT", type);

return error_mark_node;

}

else if (TREE_CODE (type) == REFERENCE_TYPE)

{

if (complain & tf_error)

error ("value-initialization of reference type %qT", type);

return error_mark_node;

}

return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);

}

/* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of

arguments. If TREE_LIST is void_type_node, an empty initializer

list was given; if NULL_TREE no initializer was given. */

static void

perform_member_init (tree member, tree init)

{

tree decl;

tree type = TREE_TYPE (member);

/* Effective C++ rule 12 requires that all data members be

initialized. */

if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)

warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,

"%qD should be initialized in the member initialization list",

member);

/* Get an lvalue for the data member. */

decl = build_class_member_access_expr (current_class_ref, member,

/*access_path=*/NULL_TREE,

/*preserve_reference=*/true,

tf_warning_or_error);

if (decl == error_mark_node)

return;

if (warn_init_self && init && TREE_CODE (init) == TREE_LIST

&& TREE_CHAIN (init) == NULL_TREE)

{

tree val = TREE_VALUE (init);

if (TREE_CODE (val) == COMPONENT_REF && TREE_OPERAND (val, 1) == member

&& TREE_OPERAND (val, 0) == current_class_ref)

warning_at (DECL_SOURCE_LOCATION (current_function_decl),

OPT_Wuninitialized, "%qD is initialized with itself",

member);

}

if (init == void_type_node)

{

/* mem() means value-initialization. */

if (TREE_CODE (type) == ARRAY_TYPE)

{

init = build_vec_init_expr (type, init, tf_warning_or_error);

init = build2 (INIT_EXPR, type, decl, init);

finish_expr_stmt (init);

}

else

{

tree value = build_value_init (type, tf_warning_or_error);

if (value == error_mark_node)

return;

init = build2 (INIT_EXPR, type, decl, value);

finish_expr_stmt (init);

}

}

/* Deal with this here, as we will get confused if we try to call the

assignment op for an anonymous union. This can happen in a

synthesized copy constructor. */

else if (ANON_AGGR_TYPE_P (type))

{

if (init)

{

init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));

finish_expr_stmt (init);

}

}

else if (type_build_ctor_call (type))

{

if (TREE_CODE (type) == ARRAY_TYPE)

{

if (init)

{

gcc_assert (TREE_CHAIN (init) == NULL_TREE);

init = TREE_VALUE (init);

if (BRACE_ENCLOSED_INITIALIZER_P (init))

init = digest_init (type, init, tf_warning_or_error);

}

if (init == NULL_TREE

|| same_type_ignoring_top_level_qualifiers_p (type,

TREE_TYPE (init)))

{

init = build_vec_init_expr (type, init, tf_warning_or_error);

init = build2 (INIT_EXPR, type, decl, init);

finish_expr_stmt (init);

}

else

error ("invalid initializer for array member %q#D", member);

}

else

{

int flags = LOOKUP_NORMAL;

if (DECL_DEFAULTED_FN (current_function_decl))

flags |= LOOKUP_DEFAULTED;

if (CP_TYPE_CONST_P (type)

&& init == NULL_TREE

&& !type_has_user_provided_default_constructor (type))

/* TYPE_NEEDS_CONSTRUCTING can be set just because we have a

vtable; still give this diagnostic. */

permerror (DECL_SOURCE_LOCATION (current_function_decl),

"uninitialized member %qD with %<const%> type %qT",

member, type);

finish_expr_stmt (build_aggr_init (decl, init, flags,

tf_warning_or_error));

}

}

else

{

if (init == NULL_TREE)

{

tree core_type;

/* member traversal: note it leaves init NULL */

if (TREE_CODE (type) == REFERENCE_TYPE)

permerror (DECL_SOURCE_LOCATION (current_function_decl),

"uninitialized reference member %qD",

member);

else if (CP_TYPE_CONST_P (type))

permerror (DECL_SOURCE_LOCATION (current_function_decl),

"uninitialized member %qD with %<const%> type %qT",

member, type);

core_type = strip_array_types (type);

if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)

&& !type_has_constexpr_default_constructor (core_type))

{

if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))

error ("uninitialized member %qD in %<constexpr%> constructor",

member);

DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;

}

if (CLASS_TYPE_P (core_type)

&& (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)

|| CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))

diagnose_uninitialized_cst_or_ref_member (core_type,

/*using_new=*/false,

/*complain=*/true);

}

else if (TREE_CODE (init) == TREE_LIST)

/* There was an explicit member initialization. Do some work

in that case. */

init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,

tf_warning_or_error);

if (init)

finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,

tf_warning_or_error));

}

if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))

{

tree expr;

expr = build_class_member_access_expr (current_class_ref, member,

/*access_path=*/NULL_TREE,

/*preserve_reference=*/false,

tf_warning_or_error);

expr = build_delete (type, expr, sfk_complete_destructor,

LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,

tf_warning_or_error);

if (expr != error_mark_node)

finish_eh_cleanup (expr);

}

}

/* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all

the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */

static tree

build_field_list (tree t, tree list, int *uses_unions_p)

{

tree fields;

/* Note whether or not T is a union. */

if (TREE_CODE (t) == UNION_TYPE)

*uses_unions_p = 1;

for (fields = TYPE_FIELDS (t); fields; fields = DECL_CHAIN (fields))

{

tree fieldtype;

/* Skip CONST_DECLs for enumeration constants and so forth. */

if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))

continue;

fieldtype = TREE_TYPE (fields);

/* Keep track of whether or not any fields are unions. */

if (TREE_CODE (fieldtype) == UNION_TYPE)

*uses_unions_p = 1;

/* For an anonymous struct or union, we must recursively

consider the fields of the anonymous type. They can be

directly initialized from the constructor. */

if (ANON_AGGR_TYPE_P (fieldtype))

{

/* Add this field itself. Synthesized copy constructors

initialize the entire aggregate. */

list = tree_cons (fields, NULL_TREE, list);

/* And now add the fields in the anonymous aggregate. */

list = build_field_list (fieldtype, list, uses_unions_p);

}

/* Add this field. */

else if (DECL_NAME (fields))

list = tree_cons (fields, NULL_TREE, list);

}

return list;

}

/* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives

a FIELD_DECL or BINFO in T that needs initialization. The

TREE_VALUE gives the initializer, or list of initializer arguments.

Return a TREE_LIST containing all of the initializations required

for T, in the order in which they should be performed. The output

list has the same format as the input. */

static tree

sort_mem_initializers (tree t, tree mem_inits)

{

tree init;

tree base, binfo, base_binfo;

tree sorted_inits;

tree next_subobject;

VEC(tree,gc) *vbases;

int i;

int uses_unions_p = 0;

/* Build up a list of initializations. The TREE_PURPOSE of entry

will be the subobject (a FIELD_DECL or BINFO) to initialize. The

TREE_VALUE will be the constructor arguments, or NULL if no

explicit initialization was provided. */

sorted_inits = NULL_TREE;

/* Process the virtual bases. */

for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;

VEC_iterate (tree, vbases, i, base); i++)

sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);

/* Process the direct bases. */

for (binfo = TYPE_BINFO (t), i = 0;

BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)

if (!BINFO_VIRTUAL_P (base_binfo))

sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);

/* Process the non-static data members. */

sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);

/* Reverse the entire list of initializations, so that they are in

the order that they will actually be performed. */

sorted_inits = nreverse (sorted_inits);

/* If the user presented the initializers in an order different from

that in which they will actually occur, we issue a warning. Keep

track of the next subobject which can be explicitly initialized

without issuing a warning. */

next_subobject = sorted_inits;

/* Go through the explicit initializers, filling in TREE_PURPOSE in

the SORTED_INITS. */

for (init = mem_inits; init; init = TREE_CHAIN (init))

{

tree subobject;

tree subobject_init;

subobject = TREE_PURPOSE (init);

/* If the explicit initializers are in sorted order, then

SUBOBJECT will be NEXT_SUBOBJECT, or something following

it. */

for (subobject_init = next_subobject;

subobject_init;

subobject_init = TREE_CHAIN (subobject_init))

if (TREE_PURPOSE (subobject_init) == subobject)

break;

/* Issue a warning if the explicit initializer order does not

match that which will actually occur.

??? Are all these on the correct lines? */

if (warn_reorder && !subobject_init)

{

if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)

warning (OPT_Wreorder, "%q+D will be initialized after",

TREE_PURPOSE (next_subobject));

else

warning (OPT_Wreorder, "base %qT will be initialized after",

TREE_PURPOSE (next_subobject));

if (TREE_CODE (subobject) == FIELD_DECL)

warning (OPT_Wreorder, " %q+#D", subobject);

else

warning (OPT_Wreorder, " base %qT", subobject);

warning_at (DECL_SOURCE_LOCATION (current_function_decl),

OPT_Wreorder, " when initialized here");

}

/* Look again, from the beginning of the list. */

if (!subobject_init)

{

subobject_init = sorted_inits;

while (TREE_PURPOSE (subobject_init) != subobject)

subobject_init = TREE_CHAIN (subobject_init);

}

/* It is invalid to initialize the same subobject more than

once. */

if (TREE_VALUE (subobject_init))

{

if (TREE_CODE (subobject) == FIELD_DECL)

error_at (DECL_SOURCE_LOCATION (current_function_decl),

"multiple initializations given for %qD",

subobject);

else

error_at (DECL_SOURCE_LOCATION (current_function_decl),

"multiple initializations given for base %qT",

subobject);

}

/* Record the initialization. */

TREE_VALUE (subobject_init) = TREE_VALUE (init);

next_subobject = subobject_init;

}

/* [class.base.init]

If a ctor-initializer specifies more than one mem-initializer for

multiple members of the same union (including members of

anonymous unions), the ctor-initializer is ill-formed.

Here we also splice out uninitialized union members. */

if (uses_unions_p)

{

tree last_field = NULL_TREE;

tree *p;

for (p = &sorted_inits; *p; )

{

tree field;

tree ctx;

int done;

init = *p;

field = TREE_PURPOSE (init);

/* Skip base classes. */

if (TREE_CODE (field) != FIELD_DECL)

goto next;

/* If this is an anonymous union with no explicit initializer,

splice it out. */

if (!TREE_VALUE (init) && ANON_UNION_TYPE_P (TREE_TYPE (field)))

goto splice;

/* See if this field is a member of a union, or a member of a

structure contained in a union, etc. */

for (ctx = DECL_CONTEXT (field);

!same_type_p (ctx, t);

ctx = TYPE_CONTEXT (ctx))

if (TREE_CODE (ctx) == UNION_TYPE)

break;

/* If this field is not a member of a union, skip it. */

if (TREE_CODE (ctx) != UNION_TYPE)

goto next;

/* If this union member has no explicit initializer, splice

it out. */

if (!TREE_VALUE (init))

goto splice;

/* It's only an error if we have two initializers for the same

union type. */

if (!last_field)

{

last_field = field;

goto next;

}

/* See if LAST_FIELD and the field initialized by INIT are

members of the same union. If so, there's a problem,

unless they're actually members of the same structure

which is itself a member of a union. For example, given:

union { struct { int i; int j; }; };

initializing both `i' and `j' makes sense. */

ctx = DECL_CONTEXT (field);

done = 0;

do

{

tree last_ctx;

last_ctx = DECL_CONTEXT (last_field);

while (1)

{

if (same_type_p (last_ctx, ctx))

{

if (TREE_CODE (ctx) == UNION_TYPE)

error_at (DECL_SOURCE_LOCATION (current_function_decl),

"initializations for multiple members of %qT",

last_ctx);

done = 1;

break;

}

if (same_type_p (last_ctx, t))

break;

last_ctx = TYPE_CONTEXT (last_ctx);

}

/* If we've reached the outermost class, then we're

done. */

if (same_type_p (ctx, t))

break;

ctx = TYPE_CONTEXT (ctx);

}

while (!done);

last_field = field;

next:

p = &TREE_CHAIN (*p);

continue;

splice:

*p = TREE_CHAIN (*p);

continue;

}

}

return sorted_inits;

}

/* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS

is a TREE_LIST giving the explicit mem-initializer-list for the

constructor. The TREE_PURPOSE of each entry is a subobject (a

FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE

is a TREE_LIST giving the arguments to the constructor or

void_type_node for an empty list of arguments. */

void

emit_mem_initializers (tree mem_inits)

{

int flags = LOOKUP_NORMAL;

/* We will already have issued an error message about the fact that

the type is incomplete. */

if (!COMPLETE_TYPE_P (current_class_type))

return;

if (DECL_DEFAULTED_FN (current_function_decl))

flags |= LOOKUP_DEFAULTED;

/* Sort the mem-initializers into the order in which the

initializations should be performed. */

mem_inits = sort_mem_initializers (current_class_type, mem_inits);

in_base_initializer = 1;

/* Initialize base classes. */

while (mem_inits

&& TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)

{

tree subobject = TREE_PURPOSE (mem_inits);

tree arguments = TREE_VALUE (mem_inits);

if (arguments == NULL_TREE)

{

/* If these initializations are taking place in a copy constructor,

the base class should probably be explicitly initialized if there

is a user-defined constructor in the base class (other than the

default constructor, which will be called anyway). */

if (extra_warnings

&& DECL_COPY_CONSTRUCTOR_P (current_function_decl)

&& type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))

warning_at (DECL_SOURCE_LOCATION (current_function_decl),

OPT_Wextra, "base class %q#T should be explicitly "

"initialized in the copy constructor",

BINFO_TYPE (subobject));

if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)

&& !(type_has_constexpr_default_constructor

(BINFO_TYPE (subobject))))

{

if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))

error ("uninitialized base %qT in %<constexpr%> constructor",

BINFO_TYPE (subobject));

DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;

}

}

/* Initialize the base. */

if (BINFO_VIRTUAL_P (subobject))

construct_virtual_base (subobject, arguments);

else

{

tree base_addr;

base_addr = build_base_path (PLUS_EXPR, current_class_ptr,

subobject, 1);

expand_aggr_init_1 (subobject, NULL_TREE,

cp_build_indirect_ref (base_addr, RO_NULL,

tf_warning_or_error),

arguments,

flags,

tf_warning_or_error);

expand_cleanup_for_base (subobject, NULL_TREE);

}

mem_inits = TREE_CHAIN (mem_inits);

}

in_base_initializer = 0;

/* Initialize the vptrs. */

initialize_vtbl_ptrs (current_class_ptr);

/* Initialize the data members. */

while (mem_inits)