OSDN Git Service

f80c475f7ac2bbbacc9d56921f826a6d4f2598b2
[pf3gnuchains/gcc-fork.git] / gcc / cp / init.c
1 /* Handle initialization things in C++.
2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4    2011 Free Software Foundation, Inc.
5    Contributed by Michael Tiemann (tiemann@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 /* High-level class interface.  */
24
25 #include "config.h"
26 #include "system.h"
27 #include "coretypes.h"
28 #include "tm.h"
29 #include "tree.h"
30 #include "cp-tree.h"
31 #include "flags.h"
32 #include "output.h"
33 #include "target.h"
34
35 static bool begin_init_stmts (tree *, tree *);
36 static tree finish_init_stmts (bool, tree, tree);
37 static void construct_virtual_base (tree, tree);
38 static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);
39 static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);
40 static void perform_member_init (tree, tree);
41 static tree build_builtin_delete_call (tree);
42 static int member_init_ok_or_else (tree, tree, tree);
43 static void expand_virtual_init (tree, tree);
44 static tree sort_mem_initializers (tree, tree);
45 static tree initializing_context (tree);
46 static void expand_cleanup_for_base (tree, tree);
47 static tree dfs_initialize_vtbl_ptrs (tree, void *);
48 static tree build_field_list (tree, tree, int *);
49 static tree build_vtbl_address (tree);
50 static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool);
51
52 /* We are about to generate some complex initialization code.
53    Conceptually, it is all a single expression.  However, we may want
54    to include conditionals, loops, and other such statement-level
55    constructs.  Therefore, we build the initialization code inside a
56    statement-expression.  This function starts such an expression.
57    STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
58    pass them back to finish_init_stmts when the expression is
59    complete.  */
60
61 static bool
62 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
63 {
64   bool is_global = !building_stmt_list_p ();
65
66   *stmt_expr_p = begin_stmt_expr ();
67   *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
68
69   return is_global;
70 }
71
72 /* Finish out the statement-expression begun by the previous call to
73    begin_init_stmts.  Returns the statement-expression itself.  */
74
75 static tree
76 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
77 {
78   finish_compound_stmt (compound_stmt);
79
80   stmt_expr = finish_stmt_expr (stmt_expr, true);
81
82   gcc_assert (!building_stmt_list_p () == is_global);
83
84   return stmt_expr;
85 }
86
87 /* Constructors */
88
89 /* Called from initialize_vtbl_ptrs via dfs_walk.  BINFO is the base
90    which we want to initialize the vtable pointer for, DATA is
91    TREE_LIST whose TREE_VALUE is the this ptr expression.  */
92
93 static tree
94 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
95 {
96   if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
97     return dfs_skip_bases;
98
99   if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
100     {
101       tree base_ptr = TREE_VALUE ((tree) data);
102
103       base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
104
105       expand_virtual_init (binfo, base_ptr);
106     }
107
108   return NULL_TREE;
109 }
110
111 /* Initialize all the vtable pointers in the object pointed to by
112    ADDR.  */
113
114 void
115 initialize_vtbl_ptrs (tree addr)
116 {
117   tree list;
118   tree type;
119
120   type = TREE_TYPE (TREE_TYPE (addr));
121   list = build_tree_list (type, addr);
122
123   /* Walk through the hierarchy, initializing the vptr in each base
124      class.  We do these in pre-order because we can't find the virtual
125      bases for a class until we've initialized the vtbl for that
126      class.  */
127   dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
128 }
129
130 /* Return an expression for the zero-initialization of an object with
131    type T.  This expression will either be a constant (in the case
132    that T is a scalar), or a CONSTRUCTOR (in the case that T is an
133    aggregate), or NULL (in the case that T does not require
134    initialization).  In either case, the value can be used as
135    DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
136    initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
137    is the number of elements in the array.  If STATIC_STORAGE_P is
138    TRUE, initializers are only generated for entities for which
139    zero-initialization does not simply mean filling the storage with
140    zero bytes.  FIELD_SIZE, if non-NULL, is the bit size of the field,
141    subfields with bit positions at or above that bit size shouldn't
142    be added.  */
143
144 static tree
145 build_zero_init_1 (tree type, tree nelts, bool static_storage_p,
146                    tree field_size)
147 {
148   tree init = NULL_TREE;
149
150   /* [dcl.init]
151
152      To zero-initialize an object of type T means:
153
154      -- if T is a scalar type, the storage is set to the value of zero
155         converted to T.
156
157      -- if T is a non-union class type, the storage for each nonstatic
158         data member and each base-class subobject is zero-initialized.
159
160      -- if T is a union type, the storage for its first data member is
161         zero-initialized.
162
163      -- if T is an array type, the storage for each element is
164         zero-initialized.
165
166      -- if T is a reference type, no initialization is performed.  */
167
168   gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
169
170   if (type == error_mark_node)
171     ;
172   else if (static_storage_p && zero_init_p (type))
173     /* In order to save space, we do not explicitly build initializers
174        for items that do not need them.  GCC's semantics are that
175        items with static storage duration that are not otherwise
176        initialized are initialized to zero.  */
177     ;
178   else if (SCALAR_TYPE_P (type))
179     init = convert (type, integer_zero_node);
180   else if (CLASS_TYPE_P (type))
181     {
182       tree field;
183       VEC(constructor_elt,gc) *v = NULL;
184
185       /* Iterate over the fields, building initializations.  */
186       for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
187         {
188           if (TREE_CODE (field) != FIELD_DECL)
189             continue;
190
191           /* Don't add virtual bases for base classes if they are beyond
192              the size of the current field, that means it is present
193              somewhere else in the object.  */
194           if (field_size)
195             {
196               tree bitpos = bit_position (field);
197               if (TREE_CODE (bitpos) == INTEGER_CST
198                   && !tree_int_cst_lt (bitpos, field_size))
199                 continue;
200             }
201
202           /* Note that for class types there will be FIELD_DECLs
203              corresponding to base classes as well.  Thus, iterating
204              over TYPE_FIELDs will result in correct initialization of
205              all of the subobjects.  */
206           if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
207             {
208               tree new_field_size
209                 = (DECL_FIELD_IS_BASE (field)
210                    && DECL_SIZE (field)
211                    && TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
212                   ? DECL_SIZE (field) : NULL_TREE;
213               tree value = build_zero_init_1 (TREE_TYPE (field),
214                                               /*nelts=*/NULL_TREE,
215                                               static_storage_p,
216                                               new_field_size);
217               if (value)
218                 CONSTRUCTOR_APPEND_ELT(v, field, value);
219             }
220
221           /* For unions, only the first field is initialized.  */
222           if (TREE_CODE (type) == UNION_TYPE)
223             break;
224         }
225
226       /* Build a constructor to contain the initializations.  */
227       init = build_constructor (type, v);
228     }
229   else if (TREE_CODE (type) == ARRAY_TYPE)
230     {
231       tree max_index;
232       VEC(constructor_elt,gc) *v = NULL;
233
234       /* Iterate over the array elements, building initializations.  */
235       if (nelts)
236         max_index = fold_build2_loc (input_location,
237                                  MINUS_EXPR, TREE_TYPE (nelts),
238                                  nelts, integer_one_node);
239       else
240         max_index = array_type_nelts (type);
241
242       /* If we have an error_mark here, we should just return error mark
243          as we don't know the size of the array yet.  */
244       if (max_index == error_mark_node)
245         return error_mark_node;
246       gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
247
248       /* A zero-sized array, which is accepted as an extension, will
249          have an upper bound of -1.  */
250       if (!tree_int_cst_equal (max_index, integer_minus_one_node))
251         {
252           constructor_elt *ce;
253
254           v = VEC_alloc (constructor_elt, gc, 1);
255           ce = VEC_quick_push (constructor_elt, v, NULL);
256
257           /* If this is a one element array, we just use a regular init.  */
258           if (tree_int_cst_equal (size_zero_node, max_index))
259             ce->index = size_zero_node;
260           else
261             ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
262                                 max_index);
263
264           ce->value = build_zero_init_1 (TREE_TYPE (type),
265                                          /*nelts=*/NULL_TREE,
266                                          static_storage_p, NULL_TREE);
267         }
268
269       /* Build a constructor to contain the initializations.  */
270       init = build_constructor (type, v);
271     }
272   else if (TREE_CODE (type) == VECTOR_TYPE)
273     init = build_zero_cst (type);
274   else
275     gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
276
277   /* In all cases, the initializer is a constant.  */
278   if (init)
279     TREE_CONSTANT (init) = 1;
280
281   return init;
282 }
283
284 /* Return an expression for the zero-initialization of an object with
285    type T.  This expression will either be a constant (in the case
286    that T is a scalar), or a CONSTRUCTOR (in the case that T is an
287    aggregate), or NULL (in the case that T does not require
288    initialization).  In either case, the value can be used as
289    DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
290    initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
291    is the number of elements in the array.  If STATIC_STORAGE_P is
292    TRUE, initializers are only generated for entities for which
293    zero-initialization does not simply mean filling the storage with
294    zero bytes.  */
295
296 tree
297 build_zero_init (tree type, tree nelts, bool static_storage_p)
298 {
299   return build_zero_init_1 (type, nelts, static_storage_p, NULL_TREE);
300 }
301
302 /* Return a suitable initializer for value-initializing an object of type
303    TYPE, as described in [dcl.init].  */
304
305 tree
306 build_value_init (tree type, tsubst_flags_t complain)
307 {
308   /* [dcl.init]
309
310      To value-initialize an object of type T means:
311
312      - if T is a class type (clause 9) with a user-provided constructor
313        (12.1), then the default constructor for T is called (and the
314        initialization is ill-formed if T has no accessible default
315        constructor);
316
317      - if T is a non-union class type without a user-provided constructor,
318        then every non-static data member and base-class component of T is
319        value-initialized;92)
320
321      - if T is an array type, then each element is value-initialized;
322
323      - otherwise, the object is zero-initialized.
324
325      A program that calls for default-initialization or
326      value-initialization of an entity of reference type is ill-formed.
327
328      92) Value-initialization for such a class object may be implemented by
329      zero-initializing the object and then calling the default
330      constructor.  */
331
332   /* The AGGR_INIT_EXPR tweaking below breaks in templates.  */
333   gcc_assert (!processing_template_decl);
334
335   if (CLASS_TYPE_P (type))
336     {
337       /* Instead of the above, only consider the user-providedness of the
338          default constructor itself so value-initializing a class with an
339          explicitly defaulted default constructor and another user-provided
340          constructor works properly (c++std-core-19883).  */
341       if (type_has_user_provided_default_constructor (type)
342           || (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)
343               && type_has_user_provided_constructor (type)))
344         return build_aggr_init_expr
345           (type,
346            build_special_member_call (NULL_TREE, complete_ctor_identifier,
347                                       NULL, type, LOOKUP_NORMAL,
348                                       complain),
349            complain);
350       else if (TYPE_HAS_COMPLEX_DFLT (type))
351         {
352           /* This is a class that needs constructing, but doesn't have
353              a user-provided constructor.  So we need to zero-initialize
354              the object and then call the implicitly defined ctor.
355              This will be handled in simplify_aggr_init_expr.  */
356           tree ctor = build_special_member_call
357             (NULL_TREE, complete_ctor_identifier,
358              NULL, type, LOOKUP_NORMAL, complain);
359           if (ctor != error_mark_node)
360             {
361               ctor = build_aggr_init_expr (type, ctor, complain);
362               AGGR_INIT_ZERO_FIRST (ctor) = 1;
363             }
364           return ctor;
365         }
366     }
367   return build_value_init_noctor (type, complain);
368 }
369
370 /* Like build_value_init, but don't call the constructor for TYPE.  Used
371    for base initializers.  */
372
373 tree
374 build_value_init_noctor (tree type, tsubst_flags_t complain)
375 {
376   /* FIXME the class and array cases should just use digest_init once it is
377      SFINAE-enabled.  */
378   if (CLASS_TYPE_P (type))
379     {
380       gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type));
381         
382       if (TREE_CODE (type) != UNION_TYPE)
383         {
384           tree field;
385           VEC(constructor_elt,gc) *v = NULL;
386
387           /* Iterate over the fields, building initializations.  */
388           for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
389             {
390               tree ftype, value;
391
392               if (TREE_CODE (field) != FIELD_DECL)
393                 continue;
394
395               ftype = TREE_TYPE (field);
396
397               /* We could skip vfields and fields of types with
398                  user-defined constructors, but I think that won't improve
399                  performance at all; it should be simpler in general just
400                  to zero out the entire object than try to only zero the
401                  bits that actually need it.  */
402
403               /* Note that for class types there will be FIELD_DECLs
404                  corresponding to base classes as well.  Thus, iterating
405                  over TYPE_FIELDs will result in correct initialization of
406                  all of the subobjects.  */
407               value = build_value_init (ftype, complain);
408
409               if (value == error_mark_node)
410                 return error_mark_node;
411
412               if (value)
413                 CONSTRUCTOR_APPEND_ELT(v, field, value);
414             }
415
416           /* Build a constructor to contain the zero- initializations.  */
417           return build_constructor (type, v);
418         }
419     }
420   else if (TREE_CODE (type) == ARRAY_TYPE)
421     {
422       VEC(constructor_elt,gc) *v = NULL;
423
424       /* Iterate over the array elements, building initializations.  */
425       tree max_index = array_type_nelts (type);
426
427       /* If we have an error_mark here, we should just return error mark
428          as we don't know the size of the array yet.  */
429       if (max_index == error_mark_node)
430         {
431           if (complain & tf_error)
432             error ("cannot value-initialize array of unknown bound %qT",
433                    type);
434           return error_mark_node;
435         }
436       gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
437
438       /* A zero-sized array, which is accepted as an extension, will
439          have an upper bound of -1.  */
440       if (!tree_int_cst_equal (max_index, integer_minus_one_node))
441         {
442           constructor_elt *ce;
443
444           v = VEC_alloc (constructor_elt, gc, 1);
445           ce = VEC_quick_push (constructor_elt, v, NULL);
446
447           /* If this is a one element array, we just use a regular init.  */
448           if (tree_int_cst_equal (size_zero_node, max_index))
449             ce->index = size_zero_node;
450           else
451             ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
452                                 max_index);
453
454           ce->value = build_value_init (TREE_TYPE (type), complain);
455
456           if (ce->value == error_mark_node)
457             return error_mark_node;
458
459           /* We shouldn't have gotten here for anything that would need
460              non-trivial initialization, and gimplify_init_ctor_preeval
461              would need to be fixed to allow it.  */
462           gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
463                       && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
464         }
465
466       /* Build a constructor to contain the initializations.  */
467       return build_constructor (type, v);
468     }
469   else if (TREE_CODE (type) == FUNCTION_TYPE)
470     {
471       if (complain & tf_error)
472         error ("value-initialization of function type %qT", type);
473       return error_mark_node;
474     }
475   else if (TREE_CODE (type) == REFERENCE_TYPE)
476     {
477       if (complain & tf_error)
478         error ("value-initialization of reference type %qT", type);
479       return error_mark_node;
480     }
481
482   return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
483 }
484
485 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
486    arguments.  If TREE_LIST is void_type_node, an empty initializer
487    list was given; if NULL_TREE no initializer was given.  */
488
489 static void
490 perform_member_init (tree member, tree init)
491 {
492   tree decl;
493   tree type = TREE_TYPE (member);
494
495   /* Effective C++ rule 12 requires that all data members be
496      initialized.  */
497   if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
498     warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
499                 "%qD should be initialized in the member initialization list",
500                 member);
501
502   /* Get an lvalue for the data member.  */
503   decl = build_class_member_access_expr (current_class_ref, member,
504                                          /*access_path=*/NULL_TREE,
505                                          /*preserve_reference=*/true,
506                                          tf_warning_or_error);
507   if (decl == error_mark_node)
508     return;
509
510   if (warn_init_self && init && TREE_CODE (init) == TREE_LIST
511       && TREE_CHAIN (init) == NULL_TREE)
512     {
513       tree val = TREE_VALUE (init);
514       if (TREE_CODE (val) == COMPONENT_REF && TREE_OPERAND (val, 1) == member
515           && TREE_OPERAND (val, 0) == current_class_ref)
516         warning_at (DECL_SOURCE_LOCATION (current_function_decl),
517                     OPT_Wuninitialized, "%qD is initialized with itself",
518                     member);
519     }
520
521   if (init == void_type_node)
522     {
523       /* mem() means value-initialization.  */
524       if (TREE_CODE (type) == ARRAY_TYPE)
525         {
526           init = build_vec_init_expr (type, init, tf_warning_or_error);
527           init = build2 (INIT_EXPR, type, decl, init);
528           finish_expr_stmt (init);
529         }
530       else
531         {
532           tree value = build_value_init (type, tf_warning_or_error);
533           if (value == error_mark_node)
534             return;
535           init = build2 (INIT_EXPR, type, decl, value);
536           finish_expr_stmt (init);
537         }
538     }
539   /* Deal with this here, as we will get confused if we try to call the
540      assignment op for an anonymous union.  This can happen in a
541      synthesized copy constructor.  */
542   else if (ANON_AGGR_TYPE_P (type))
543     {
544       if (init)
545         {
546           init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
547           finish_expr_stmt (init);
548         }
549     }
550   else if (type_build_ctor_call (type))
551     {
552       if (TREE_CODE (type) == ARRAY_TYPE)
553         {
554           if (init)
555             {
556               gcc_assert (TREE_CHAIN (init) == NULL_TREE);
557               init = TREE_VALUE (init);
558               if (BRACE_ENCLOSED_INITIALIZER_P (init))
559                 init = digest_init (type, init, tf_warning_or_error);
560             }
561           if (init == NULL_TREE
562               || same_type_ignoring_top_level_qualifiers_p (type,
563                                                             TREE_TYPE (init)))
564             {
565               init = build_vec_init_expr (type, init, tf_warning_or_error);
566               init = build2 (INIT_EXPR, type, decl, init);
567               finish_expr_stmt (init);
568             }
569           else
570             error ("invalid initializer for array member %q#D", member);
571         }
572       else
573         {
574           int flags = LOOKUP_NORMAL;
575           if (DECL_DEFAULTED_FN (current_function_decl))
576             flags |= LOOKUP_DEFAULTED;
577           if (CP_TYPE_CONST_P (type)
578               && init == NULL_TREE
579               && !type_has_user_provided_default_constructor (type))
580             /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
581                vtable; still give this diagnostic.  */
582             permerror (DECL_SOURCE_LOCATION (current_function_decl),
583                        "uninitialized member %qD with %<const%> type %qT",
584                        member, type);
585           finish_expr_stmt (build_aggr_init (decl, init, flags,
586                                              tf_warning_or_error));
587         }
588     }
589   else
590     {
591       if (init == NULL_TREE)
592         {
593           tree core_type;
594           /* member traversal: note it leaves init NULL */
595           if (TREE_CODE (type) == REFERENCE_TYPE)
596             permerror (DECL_SOURCE_LOCATION (current_function_decl),
597                        "uninitialized reference member %qD",
598                        member);
599           else if (CP_TYPE_CONST_P (type))
600             permerror (DECL_SOURCE_LOCATION (current_function_decl),
601                        "uninitialized member %qD with %<const%> type %qT",
602                        member, type);
603
604           core_type = strip_array_types (type);
605
606           if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
607               && !type_has_constexpr_default_constructor (core_type))
608             {
609               if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))
610                 error ("uninitialized member %qD in %<constexpr%> constructor",
611                        member);
612               DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
613             }
614
615           if (CLASS_TYPE_P (core_type)
616               && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
617                   || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
618             diagnose_uninitialized_cst_or_ref_member (core_type,
619                                                       /*using_new=*/false,
620                                                       /*complain=*/true);
621         }
622       else if (TREE_CODE (init) == TREE_LIST)
623         /* There was an explicit member initialization.  Do some work
624            in that case.  */
625         init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
626                                                 tf_warning_or_error);
627
628       if (init)
629         finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
630                                                 tf_warning_or_error));
631     }
632
633   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
634     {
635       tree expr;
636
637       expr = build_class_member_access_expr (current_class_ref, member,
638                                              /*access_path=*/NULL_TREE,
639                                              /*preserve_reference=*/false,
640                                              tf_warning_or_error);
641       expr = build_delete (type, expr, sfk_complete_destructor,
642                            LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
643                            tf_warning_or_error);
644
645       if (expr != error_mark_node)
646         finish_eh_cleanup (expr);
647     }
648 }
649
650 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
651    the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order.  */
652
653 static tree
654 build_field_list (tree t, tree list, int *uses_unions_p)
655 {
656   tree fields;
657
658   *uses_unions_p = 0;
659
660   /* Note whether or not T is a union.  */
661   if (TREE_CODE (t) == UNION_TYPE)
662     *uses_unions_p = 1;
663
664   for (fields = TYPE_FIELDS (t); fields; fields = DECL_CHAIN (fields))
665     {
666       tree fieldtype;
667
668       /* Skip CONST_DECLs for enumeration constants and so forth.  */
669       if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
670         continue;
671
672       fieldtype = TREE_TYPE (fields);
673       /* Keep track of whether or not any fields are unions.  */
674       if (TREE_CODE (fieldtype) == UNION_TYPE)
675         *uses_unions_p = 1;
676
677       /* For an anonymous struct or union, we must recursively
678          consider the fields of the anonymous type.  They can be
679          directly initialized from the constructor.  */
680       if (ANON_AGGR_TYPE_P (fieldtype))
681         {
682           /* Add this field itself.  Synthesized copy constructors
683              initialize the entire aggregate.  */
684           list = tree_cons (fields, NULL_TREE, list);
685           /* And now add the fields in the anonymous aggregate.  */
686           list = build_field_list (fieldtype, list, uses_unions_p);
687         }
688       /* Add this field.  */
689       else if (DECL_NAME (fields))
690         list = tree_cons (fields, NULL_TREE, list);
691     }
692
693   return list;
694 }
695
696 /* The MEM_INITS are a TREE_LIST.  The TREE_PURPOSE of each list gives
697    a FIELD_DECL or BINFO in T that needs initialization.  The
698    TREE_VALUE gives the initializer, or list of initializer arguments.
699
700    Return a TREE_LIST containing all of the initializations required
701    for T, in the order in which they should be performed.  The output
702    list has the same format as the input.  */
703
704 static tree
705 sort_mem_initializers (tree t, tree mem_inits)
706 {
707   tree init;
708   tree base, binfo, base_binfo;
709   tree sorted_inits;
710   tree next_subobject;
711   VEC(tree,gc) *vbases;
712   int i;
713   int uses_unions_p;
714
715   /* Build up a list of initializations.  The TREE_PURPOSE of entry
716      will be the subobject (a FIELD_DECL or BINFO) to initialize.  The
717      TREE_VALUE will be the constructor arguments, or NULL if no
718      explicit initialization was provided.  */
719   sorted_inits = NULL_TREE;
720
721   /* Process the virtual bases.  */
722   for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
723        VEC_iterate (tree, vbases, i, base); i++)
724     sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
725
726   /* Process the direct bases.  */
727   for (binfo = TYPE_BINFO (t), i = 0;
728        BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
729     if (!BINFO_VIRTUAL_P (base_binfo))
730       sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
731
732   /* Process the non-static data members.  */
733   sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
734   /* Reverse the entire list of initializations, so that they are in
735      the order that they will actually be performed.  */
736   sorted_inits = nreverse (sorted_inits);
737
738   /* If the user presented the initializers in an order different from
739      that in which they will actually occur, we issue a warning.  Keep
740      track of the next subobject which can be explicitly initialized
741      without issuing a warning.  */
742   next_subobject = sorted_inits;
743
744   /* Go through the explicit initializers, filling in TREE_PURPOSE in
745      the SORTED_INITS.  */
746   for (init = mem_inits; init; init = TREE_CHAIN (init))
747     {
748       tree subobject;
749       tree subobject_init;
750
751       subobject = TREE_PURPOSE (init);
752
753       /* If the explicit initializers are in sorted order, then
754          SUBOBJECT will be NEXT_SUBOBJECT, or something following
755          it.  */
756       for (subobject_init = next_subobject;
757            subobject_init;
758            subobject_init = TREE_CHAIN (subobject_init))
759         if (TREE_PURPOSE (subobject_init) == subobject)
760           break;
761
762       /* Issue a warning if the explicit initializer order does not
763          match that which will actually occur.
764          ??? Are all these on the correct lines?  */
765       if (warn_reorder && !subobject_init)
766         {
767           if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
768             warning (OPT_Wreorder, "%q+D will be initialized after",
769                      TREE_PURPOSE (next_subobject));
770           else
771             warning (OPT_Wreorder, "base %qT will be initialized after",
772                      TREE_PURPOSE (next_subobject));
773           if (TREE_CODE (subobject) == FIELD_DECL)
774             warning (OPT_Wreorder, "  %q+#D", subobject);
775           else
776             warning (OPT_Wreorder, "  base %qT", subobject);
777           warning_at (DECL_SOURCE_LOCATION (current_function_decl),
778                       OPT_Wreorder, "  when initialized here");
779         }
780
781       /* Look again, from the beginning of the list.  */
782       if (!subobject_init)
783         {
784           subobject_init = sorted_inits;
785           while (TREE_PURPOSE (subobject_init) != subobject)
786             subobject_init = TREE_CHAIN (subobject_init);
787         }
788
789       /* It is invalid to initialize the same subobject more than
790          once.  */
791       if (TREE_VALUE (subobject_init))
792         {
793           if (TREE_CODE (subobject) == FIELD_DECL)
794             error_at (DECL_SOURCE_LOCATION (current_function_decl),
795                       "multiple initializations given for %qD",
796                       subobject);
797           else
798             error_at (DECL_SOURCE_LOCATION (current_function_decl),
799                       "multiple initializations given for base %qT",
800                       subobject);
801         }
802
803       /* Record the initialization.  */
804       TREE_VALUE (subobject_init) = TREE_VALUE (init);
805       next_subobject = subobject_init;
806     }
807
808   /* [class.base.init]
809
810      If a ctor-initializer specifies more than one mem-initializer for
811      multiple members of the same union (including members of
812      anonymous unions), the ctor-initializer is ill-formed.
813
814      Here we also splice out uninitialized union members.  */
815   if (uses_unions_p)
816     {
817       tree last_field = NULL_TREE;
818       tree *p;
819       for (p = &sorted_inits; *p; )
820         {
821           tree field;
822           tree ctx;
823           int done;
824
825           init = *p;
826
827           field = TREE_PURPOSE (init);
828
829           /* Skip base classes.  */
830           if (TREE_CODE (field) != FIELD_DECL)
831             goto next;
832
833           /* If this is an anonymous union with no explicit initializer,
834              splice it out.  */
835           if (!TREE_VALUE (init) && ANON_UNION_TYPE_P (TREE_TYPE (field)))
836             goto splice;
837
838           /* See if this field is a member of a union, or a member of a
839              structure contained in a union, etc.  */
840           for (ctx = DECL_CONTEXT (field);
841                !same_type_p (ctx, t);
842                ctx = TYPE_CONTEXT (ctx))
843             if (TREE_CODE (ctx) == UNION_TYPE)
844               break;
845           /* If this field is not a member of a union, skip it.  */
846           if (TREE_CODE (ctx) != UNION_TYPE)
847             goto next;
848
849           /* If this union member has no explicit initializer, splice
850              it out.  */
851           if (!TREE_VALUE (init))
852             goto splice;
853
854           /* It's only an error if we have two initializers for the same
855              union type.  */
856           if (!last_field)
857             {
858               last_field = field;
859               goto next;
860             }
861
862           /* See if LAST_FIELD and the field initialized by INIT are
863              members of the same union.  If so, there's a problem,
864              unless they're actually members of the same structure
865              which is itself a member of a union.  For example, given:
866
867                union { struct { int i; int j; }; };
868
869              initializing both `i' and `j' makes sense.  */
870           ctx = DECL_CONTEXT (field);
871           done = 0;
872           do
873             {
874               tree last_ctx;
875
876               last_ctx = DECL_CONTEXT (last_field);
877               while (1)
878                 {
879                   if (same_type_p (last_ctx, ctx))
880                     {
881                       if (TREE_CODE (ctx) == UNION_TYPE)
882                         error_at (DECL_SOURCE_LOCATION (current_function_decl),
883                                   "initializations for multiple members of %qT",
884                                   last_ctx);
885                       done = 1;
886                       break;
887                     }
888
889                   if (same_type_p (last_ctx, t))
890                     break;
891
892                   last_ctx = TYPE_CONTEXT (last_ctx);
893                 }
894
895               /* If we've reached the outermost class, then we're
896                  done.  */
897               if (same_type_p (ctx, t))
898                 break;
899
900               ctx = TYPE_CONTEXT (ctx);
901             }
902           while (!done);
903
904           last_field = field;
905
906         next:
907           p = &TREE_CHAIN (*p);
908           continue;
909         splice:
910           *p = TREE_CHAIN (*p);
911           continue;
912         }
913     }
914
915   return sorted_inits;
916 }
917
918 /* Initialize all bases and members of CURRENT_CLASS_TYPE.  MEM_INITS
919    is a TREE_LIST giving the explicit mem-initializer-list for the
920    constructor.  The TREE_PURPOSE of each entry is a subobject (a
921    FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE.  The TREE_VALUE
922    is a TREE_LIST giving the arguments to the constructor or
923    void_type_node for an empty list of arguments.  */
924
925 void
926 emit_mem_initializers (tree mem_inits)
927 {
928   int flags = LOOKUP_NORMAL;
929
930   /* We will already have issued an error message about the fact that
931      the type is incomplete.  */
932   if (!COMPLETE_TYPE_P (current_class_type))
933     return;
934
935   if (DECL_DEFAULTED_FN (current_function_decl))
936     flags |= LOOKUP_DEFAULTED;
937
938   /* Sort the mem-initializers into the order in which the
939      initializations should be performed.  */
940   mem_inits = sort_mem_initializers (current_class_type, mem_inits);
941
942   in_base_initializer = 1;
943
944   /* Initialize base classes.  */
945   while (mem_inits
946          && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
947     {
948       tree subobject = TREE_PURPOSE (mem_inits);
949       tree arguments = TREE_VALUE (mem_inits);
950
951       if (arguments == NULL_TREE)
952         {
953           /* If these initializations are taking place in a copy constructor,
954              the base class should probably be explicitly initialized if there
955              is a user-defined constructor in the base class (other than the
956              default constructor, which will be called anyway).  */
957           if (extra_warnings
958               && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
959               && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
960             warning_at (DECL_SOURCE_LOCATION (current_function_decl),
961                         OPT_Wextra, "base class %q#T should be explicitly "
962                         "initialized in the copy constructor",
963                         BINFO_TYPE (subobject));
964
965           if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
966               && !(type_has_constexpr_default_constructor
967                    (BINFO_TYPE (subobject))))
968             {
969               if (!DECL_TEMPLATE_INSTANTIATION (current_function_decl))
970                 error ("uninitialized base %qT in %<constexpr%> constructor",
971                        BINFO_TYPE (subobject));
972               DECL_DECLARED_CONSTEXPR_P (current_function_decl) = false;
973             }
974         }
975
976       /* Initialize the base.  */
977       if (BINFO_VIRTUAL_P (subobject))
978         construct_virtual_base (subobject, arguments);
979       else
980         {
981           tree base_addr;
982
983           base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
984                                        subobject, 1);
985           expand_aggr_init_1 (subobject, NULL_TREE,
986                               cp_build_indirect_ref (base_addr, RO_NULL,
987                                                      tf_warning_or_error),
988                               arguments,
989                               flags,
990                               tf_warning_or_error);
991           expand_cleanup_for_base (subobject, NULL_TREE);
992         }
993
994       mem_inits = TREE_CHAIN (mem_inits);
995     }
996   in_base_initializer = 0;
997
998   /* Initialize the vptrs.  */
999   initialize_vtbl_ptrs (current_class_ptr);
1000
1001   /* Initialize the data members.  */
1002   while (mem_inits)
1003     {
1004       perform_member_init (TREE_PURPOSE (mem_inits),
1005                            TREE_VALUE (mem_inits));
1006       mem_inits = TREE_CHAIN (mem_inits);
1007     }
1008 }
1009
1010 /* Returns the address of the vtable (i.e., the value that should be
1011    assigned to the vptr) for BINFO.  */
1012
1013 static tree
1014 build_vtbl_address (tree binfo)
1015 {
1016   tree binfo_for = binfo;
1017   tree vtbl;
1018
1019   if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
1020     /* If this is a virtual primary base, then the vtable we want to store
1021        is that for the base this is being used as the primary base of.  We
1022        can't simply skip the initialization, because we may be expanding the
1023        inits of a subobject constructor where the virtual base layout
1024        can be different.  */
1025     while (BINFO_PRIMARY_P (binfo_for))
1026       binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
1027
1028   /* Figure out what vtable BINFO's vtable is based on, and mark it as
1029      used.  */
1030   vtbl = get_vtbl_decl_for_binfo (binfo_for);
1031   TREE_USED (vtbl) = 1;
1032
1033   /* Now compute the address to use when initializing the vptr.  */
1034   vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
1035   if (TREE_CODE (vtbl) == VAR_DECL)
1036     vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
1037
1038   return vtbl;
1039 }
1040
1041 /* This code sets up the virtual function tables appropriate for
1042    the pointer DECL.  It is a one-ply initialization.
1043
1044    BINFO is the exact type that DECL is supposed to be.  In
1045    multiple inheritance, this might mean "C's A" if C : A, B.  */
1046
1047 static void
1048 expand_virtual_init (tree binfo, tree decl)
1049 {
1050   tree vtbl, vtbl_ptr;
1051   tree vtt_index;
1052
1053   /* Compute the initializer for vptr.  */
1054   vtbl = build_vtbl_address (binfo);
1055
1056   /* We may get this vptr from a VTT, if this is a subobject
1057      constructor or subobject destructor.  */
1058   vtt_index = BINFO_VPTR_INDEX (binfo);
1059   if (vtt_index)
1060     {
1061       tree vtbl2;
1062       tree vtt_parm;
1063
1064       /* Compute the value to use, when there's a VTT.  */
1065       vtt_parm = current_vtt_parm;
1066       vtbl2 = build2 (POINTER_PLUS_EXPR,
1067                       TREE_TYPE (vtt_parm),
1068                       vtt_parm,
1069                       vtt_index);
1070       vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
1071       vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
1072
1073       /* The actual initializer is the VTT value only in the subobject
1074          constructor.  In maybe_clone_body we'll substitute NULL for
1075          the vtt_parm in the case of the non-subobject constructor.  */
1076       vtbl = build3 (COND_EXPR,
1077                      TREE_TYPE (vtbl),
1078                      build2 (EQ_EXPR, boolean_type_node,
1079                              current_in_charge_parm, integer_zero_node),
1080                      vtbl2,
1081                      vtbl);
1082     }
1083
1084   /* Compute the location of the vtpr.  */
1085   vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL, 
1086                                                       tf_warning_or_error),
1087                                TREE_TYPE (binfo));
1088   gcc_assert (vtbl_ptr != error_mark_node);
1089
1090   /* Assign the vtable to the vptr.  */
1091   vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
1092   finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
1093                                           tf_warning_or_error));
1094 }
1095
1096 /* If an exception is thrown in a constructor, those base classes already
1097    constructed must be destroyed.  This function creates the cleanup
1098    for BINFO, which has just been constructed.  If FLAG is non-NULL,
1099    it is a DECL which is nonzero when this base needs to be
1100    destroyed.  */
1101
1102 static void
1103 expand_cleanup_for_base (tree binfo, tree flag)
1104 {
1105   tree expr;
1106
1107   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
1108     return;
1109
1110   /* Call the destructor.  */
1111   expr = build_special_member_call (current_class_ref,
1112                                     base_dtor_identifier,
1113                                     NULL,
1114                                     binfo,
1115                                     LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
1116                                     tf_warning_or_error);
1117   if (flag)
1118     expr = fold_build3_loc (input_location,
1119                         COND_EXPR, void_type_node,
1120                         c_common_truthvalue_conversion (input_location, flag),
1121                         expr, integer_zero_node);
1122
1123   finish_eh_cleanup (expr);
1124 }
1125
1126 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1127    constructor.  */
1128
1129 static void
1130 construct_virtual_base (tree vbase, tree arguments)
1131 {
1132   tree inner_if_stmt;
1133   tree exp;
1134   tree flag;
1135
1136   /* If there are virtual base classes with destructors, we need to
1137      emit cleanups to destroy them if an exception is thrown during
1138      the construction process.  These exception regions (i.e., the
1139      period during which the cleanups must occur) begin from the time
1140      the construction is complete to the end of the function.  If we
1141      create a conditional block in which to initialize the
1142      base-classes, then the cleanup region for the virtual base begins
1143      inside a block, and ends outside of that block.  This situation
1144      confuses the sjlj exception-handling code.  Therefore, we do not
1145      create a single conditional block, but one for each
1146      initialization.  (That way the cleanup regions always begin
1147      in the outer block.)  We trust the back end to figure out
1148      that the FLAG will not change across initializations, and
1149      avoid doing multiple tests.  */
1150   flag = DECL_CHAIN (DECL_ARGUMENTS (current_function_decl));
1151   inner_if_stmt = begin_if_stmt ();
1152   finish_if_stmt_cond (flag, inner_if_stmt);
1153
1154   /* Compute the location of the virtual base.  If we're
1155      constructing virtual bases, then we must be the most derived
1156      class.  Therefore, we don't have to look up the virtual base;
1157      we already know where it is.  */
1158   exp = convert_to_base_statically (current_class_ref, vbase);
1159
1160   expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1161                       LOOKUP_COMPLAIN, tf_warning_or_error);
1162   finish_then_clause (inner_if_stmt);
1163   finish_if_stmt (inner_if_stmt);
1164
1165   expand_cleanup_for_base (vbase, flag);
1166 }
1167
1168 /* Find the context in which this FIELD can be initialized.  */
1169
1170 static tree
1171 initializing_context (tree field)
1172 {
1173   tree t = DECL_CONTEXT (field);
1174
1175   /* Anonymous union members can be initialized in the first enclosing
1176      non-anonymous union context.  */
1177   while (t && ANON_AGGR_TYPE_P (t))
1178     t = TYPE_CONTEXT (t);
1179   return t;
1180 }
1181
1182 /* Function to give error message if member initialization specification
1183    is erroneous.  FIELD is the member we decided to initialize.
1184    TYPE is the type for which the initialization is being performed.
1185    FIELD must be a member of TYPE.
1186
1187    MEMBER_NAME is the name of the member.  */
1188
1189 static int
1190 member_init_ok_or_else (tree field, tree type, tree member_name)
1191 {
1192   if (field == error_mark_node)
1193     return 0;
1194   if (!field)
1195     {
1196       error ("class %qT does not have any field named %qD", type,
1197              member_name);
1198       return 0;
1199     }
1200   if (TREE_CODE (field) == VAR_DECL)
1201     {
1202       error ("%q#D is a static data member; it can only be "
1203              "initialized at its definition",
1204              field);
1205       return 0;
1206     }
1207   if (TREE_CODE (field) != FIELD_DECL)
1208     {
1209       error ("%q#D is not a non-static data member of %qT",
1210              field, type);
1211       return 0;
1212     }
1213   if (initializing_context (field) != type)
1214     {
1215       error ("class %qT does not have any field named %qD", type,
1216                 member_name);
1217       return 0;
1218     }
1219
1220   return 1;
1221 }
1222
1223 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1224    is a _TYPE node or TYPE_DECL which names a base for that type.
1225    Check the validity of NAME, and return either the base _TYPE, base
1226    binfo, or the FIELD_DECL of the member.  If NAME is invalid, return
1227    NULL_TREE and issue a diagnostic.
1228
1229    An old style unnamed direct single base construction is permitted,
1230    where NAME is NULL.  */
1231
1232 tree
1233 expand_member_init (tree name)
1234 {
1235   tree basetype;
1236   tree field;
1237
1238   if (!current_class_ref)
1239     return NULL_TREE;
1240
1241   if (!name)
1242     {
1243       /* This is an obsolete unnamed base class initializer.  The
1244          parser will already have warned about its use.  */
1245       switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1246         {
1247         case 0:
1248           error ("unnamed initializer for %qT, which has no base classes",
1249                  current_class_type);
1250           return NULL_TREE;
1251         case 1:
1252           basetype = BINFO_TYPE
1253             (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1254           break;
1255         default:
1256           error ("unnamed initializer for %qT, which uses multiple inheritance",
1257                  current_class_type);
1258           return NULL_TREE;
1259       }
1260     }
1261   else if (TYPE_P (name))
1262     {
1263       basetype = TYPE_MAIN_VARIANT (name);
1264       name = TYPE_NAME (name);
1265     }
1266   else if (TREE_CODE (name) == TYPE_DECL)
1267     basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1268   else
1269     basetype = NULL_TREE;
1270
1271   if (basetype)
1272     {
1273       tree class_binfo;
1274       tree direct_binfo;
1275       tree virtual_binfo;
1276       int i;
1277
1278       if (current_template_parms)
1279         return basetype;
1280
1281       class_binfo = TYPE_BINFO (current_class_type);
1282       direct_binfo = NULL_TREE;
1283       virtual_binfo = NULL_TREE;
1284
1285       /* Look for a direct base.  */
1286       for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1287         if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1288           break;
1289
1290       /* Look for a virtual base -- unless the direct base is itself
1291          virtual.  */
1292       if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1293         virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1294
1295       /* [class.base.init]
1296
1297          If a mem-initializer-id is ambiguous because it designates
1298          both a direct non-virtual base class and an inherited virtual
1299          base class, the mem-initializer is ill-formed.  */
1300       if (direct_binfo && virtual_binfo)
1301         {
1302           error ("%qD is both a direct base and an indirect virtual base",
1303                  basetype);
1304           return NULL_TREE;
1305         }
1306
1307       if (!direct_binfo && !virtual_binfo)
1308         {
1309           if (CLASSTYPE_VBASECLASSES (current_class_type))
1310             error ("type %qT is not a direct or virtual base of %qT",
1311                    basetype, current_class_type);
1312           else
1313             error ("type %qT is not a direct base of %qT",
1314                    basetype, current_class_type);
1315           return NULL_TREE;
1316         }
1317
1318       return direct_binfo ? direct_binfo : virtual_binfo;
1319     }
1320   else
1321     {
1322       if (TREE_CODE (name) == IDENTIFIER_NODE)
1323         field = lookup_field (current_class_type, name, 1, false);
1324       else
1325         field = name;
1326
1327       if (member_init_ok_or_else (field, current_class_type, name))
1328         return field;
1329     }
1330
1331   return NULL_TREE;
1332 }
1333
1334 /* This is like `expand_member_init', only it stores one aggregate
1335    value into another.
1336
1337    INIT comes in two flavors: it is either a value which
1338    is to be stored in EXP, or it is a parameter list
1339    to go to a constructor, which will operate on EXP.
1340    If INIT is not a parameter list for a constructor, then set
1341    LOOKUP_ONLYCONVERTING.
1342    If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1343    the initializer, if FLAGS is 0, then it is the (init) form.
1344    If `init' is a CONSTRUCTOR, then we emit a warning message,
1345    explaining that such initializations are invalid.
1346
1347    If INIT resolves to a CALL_EXPR which happens to return
1348    something of the type we are looking for, then we know
1349    that we can safely use that call to perform the
1350    initialization.
1351
1352    The virtual function table pointer cannot be set up here, because
1353    we do not really know its type.
1354
1355    This never calls operator=().
1356
1357    When initializing, nothing is CONST.
1358
1359    A default copy constructor may have to be used to perform the
1360    initialization.
1361
1362    A constructor or a conversion operator may have to be used to
1363    perform the initialization, but not both, as it would be ambiguous.  */
1364
1365 tree
1366 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1367 {
1368   tree stmt_expr;
1369   tree compound_stmt;
1370   int destroy_temps;
1371   tree type = TREE_TYPE (exp);
1372   int was_const = TREE_READONLY (exp);
1373   int was_volatile = TREE_THIS_VOLATILE (exp);
1374   int is_global;
1375
1376   if (init == error_mark_node)
1377     return error_mark_node;
1378
1379   TREE_READONLY (exp) = 0;
1380   TREE_THIS_VOLATILE (exp) = 0;
1381
1382   if (init && TREE_CODE (init) != TREE_LIST
1383       && !(BRACE_ENCLOSED_INITIALIZER_P (init)
1384            && CONSTRUCTOR_IS_DIRECT_INIT (init)))
1385     flags |= LOOKUP_ONLYCONVERTING;
1386
1387   if (TREE_CODE (type) == ARRAY_TYPE)
1388     {
1389       tree itype;
1390
1391       /* An array may not be initialized use the parenthesized
1392          initialization form -- unless the initializer is "()".  */
1393       if (init && TREE_CODE (init) == TREE_LIST)
1394         {
1395           if (complain & tf_error)
1396             error ("bad array initializer");
1397           return error_mark_node;
1398         }
1399       /* Must arrange to initialize each element of EXP
1400          from elements of INIT.  */
1401       itype = init ? TREE_TYPE (init) : NULL_TREE;
1402       if (cv_qualified_p (type))
1403         TREE_TYPE (exp) = cv_unqualified (type);
1404       if (itype && cv_qualified_p (itype))
1405         TREE_TYPE (init) = cv_unqualified (itype);
1406       stmt_expr = build_vec_init (exp, NULL_TREE, init,
1407                                   /*explicit_value_init_p=*/false,
1408                                   itype && same_type_p (TREE_TYPE (init),
1409                                                         TREE_TYPE (exp)),
1410                                   complain);
1411       TREE_READONLY (exp) = was_const;
1412       TREE_THIS_VOLATILE (exp) = was_volatile;
1413       TREE_TYPE (exp) = type;
1414       if (init)
1415         TREE_TYPE (init) = itype;
1416       return stmt_expr;
1417     }
1418
1419   if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1420     /* Just know that we've seen something for this node.  */
1421     TREE_USED (exp) = 1;
1422
1423   is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1424   destroy_temps = stmts_are_full_exprs_p ();
1425   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1426   expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1427                       init, LOOKUP_NORMAL|flags, complain);
1428   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1429   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1430   TREE_READONLY (exp) = was_const;
1431   TREE_THIS_VOLATILE (exp) = was_volatile;
1432
1433   return stmt_expr;
1434 }
1435
1436 static void
1437 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1438                      tsubst_flags_t complain)
1439 {
1440   tree type = TREE_TYPE (exp);
1441   tree ctor_name;
1442
1443   /* It fails because there may not be a constructor which takes
1444      its own type as the first (or only parameter), but which does
1445      take other types via a conversion.  So, if the thing initializing
1446      the expression is a unit element of type X, first try X(X&),
1447      followed by initialization by X.  If neither of these work
1448      out, then look hard.  */
1449   tree rval;
1450   VEC(tree,gc) *parms;
1451
1452   /* If we have direct-initialization from an initializer list, pull
1453      it out of the TREE_LIST so the code below can see it.  */
1454   if (init && TREE_CODE (init) == TREE_LIST
1455       && BRACE_ENCLOSED_INITIALIZER_P (TREE_VALUE (init))
1456       && CONSTRUCTOR_IS_DIRECT_INIT (TREE_VALUE (init)))
1457     {
1458       gcc_checking_assert ((flags & LOOKUP_ONLYCONVERTING) == 0
1459                            && TREE_CHAIN (init) == NULL_TREE);
1460       init = TREE_VALUE (init);
1461     }
1462
1463   if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
1464       && CP_AGGREGATE_TYPE_P (type))
1465     {
1466       /* A brace-enclosed initializer for an aggregate.  In C++0x this can
1467          happen for direct-initialization, too.  */
1468       init = digest_init (type, init, complain);
1469       init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1470       TREE_SIDE_EFFECTS (init) = 1;
1471       finish_expr_stmt (init);
1472       return;
1473     }
1474
1475   if (init && TREE_CODE (init) != TREE_LIST
1476       && (flags & LOOKUP_ONLYCONVERTING))
1477     {
1478       /* Base subobjects should only get direct-initialization.  */
1479       gcc_assert (true_exp == exp);
1480
1481       if (flags & DIRECT_BIND)
1482         /* Do nothing.  We hit this in two cases:  Reference initialization,
1483            where we aren't initializing a real variable, so we don't want
1484            to run a new constructor; and catching an exception, where we
1485            have already built up the constructor call so we could wrap it
1486            in an exception region.  */;
1487       else
1488         init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1489
1490       if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1491         /* We need to protect the initialization of a catch parm with a
1492            call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1493            around the TARGET_EXPR for the copy constructor.  See
1494            initialize_handler_parm.  */
1495         {
1496           TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1497                                            TREE_OPERAND (init, 0));
1498           TREE_TYPE (init) = void_type_node;
1499         }
1500       else
1501         init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1502       TREE_SIDE_EFFECTS (init) = 1;
1503       finish_expr_stmt (init);
1504       return;
1505     }
1506
1507   if (init == NULL_TREE)
1508     parms = NULL;
1509   else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
1510     {
1511       parms = make_tree_vector ();
1512       for (; init != NULL_TREE; init = TREE_CHAIN (init))
1513         VEC_safe_push (tree, gc, parms, TREE_VALUE (init));
1514     }
1515   else
1516     parms = make_tree_vector_single (init);
1517
1518   if (true_exp == exp)
1519     ctor_name = complete_ctor_identifier;
1520   else
1521     ctor_name = base_ctor_identifier;
1522
1523   rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
1524                                     complain);
1525
1526   if (parms != NULL)
1527     release_tree_vector (parms);
1528
1529   if (exp == true_exp && TREE_CODE (rval) == CALL_EXPR)
1530     {
1531       tree fn = get_callee_fndecl (rval);
1532       if (fn && DECL_DECLARED_CONSTEXPR_P (fn))
1533         {
1534           tree e = maybe_constant_init (rval);
1535           if (TREE_CONSTANT (e))
1536             rval = build2 (INIT_EXPR, type, exp, e);
1537         }
1538     }
1539
1540   /* FIXME put back convert_to_void?  */
1541   if (TREE_SIDE_EFFECTS (rval))
1542     finish_expr_stmt (rval);
1543 }
1544
1545 /* This function is responsible for initializing EXP with INIT
1546    (if any).
1547
1548    BINFO is the binfo of the type for who we are performing the
1549    initialization.  For example, if W is a virtual base class of A and B,
1550    and C : A, B.
1551    If we are initializing B, then W must contain B's W vtable, whereas
1552    were we initializing C, W must contain C's W vtable.
1553
1554    TRUE_EXP is nonzero if it is the true expression being initialized.
1555    In this case, it may be EXP, or may just contain EXP.  The reason we
1556    need this is because if EXP is a base element of TRUE_EXP, we
1557    don't necessarily know by looking at EXP where its virtual
1558    baseclass fields should really be pointing.  But we do know
1559    from TRUE_EXP.  In constructors, we don't know anything about
1560    the value being initialized.
1561
1562    FLAGS is just passed to `build_new_method_call'.  See that function
1563    for its description.  */
1564
1565 static void
1566 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1567                     tsubst_flags_t complain)
1568 {
1569   tree type = TREE_TYPE (exp);
1570
1571   gcc_assert (init != error_mark_node && type != error_mark_node);
1572   gcc_assert (building_stmt_list_p ());
1573
1574   /* Use a function returning the desired type to initialize EXP for us.
1575      If the function is a constructor, and its first argument is
1576      NULL_TREE, know that it was meant for us--just slide exp on
1577      in and expand the constructor.  Constructors now come
1578      as TARGET_EXPRs.  */
1579
1580   if (init && TREE_CODE (exp) == VAR_DECL
1581       && COMPOUND_LITERAL_P (init))
1582     {
1583       /* If store_init_value returns NULL_TREE, the INIT has been
1584          recorded as the DECL_INITIAL for EXP.  That means there's
1585          nothing more we have to do.  */
1586       init = store_init_value (exp, init, flags);
1587       if (init)
1588         finish_expr_stmt (init);
1589       return;
1590     }
1591
1592   /* If an explicit -- but empty -- initializer list was present,
1593      that's value-initialization.  */
1594   if (init == void_type_node)
1595     {
1596       /* If there's a user-provided constructor, we just call that.  */
1597       if (type_has_user_provided_constructor (type))
1598         /* Fall through.  */;
1599       /* If there isn't, but we still need to call the constructor,
1600          zero out the object first.  */
1601       else if (type_build_ctor_call (type))
1602         {
1603           init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
1604           init = build2 (INIT_EXPR, type, exp, init);
1605           finish_expr_stmt (init);
1606           /* And then call the constructor.  */
1607         }
1608       /* If we don't need to mess with the constructor at all,
1609          then just zero out the object and we're done.  */
1610       else
1611         {
1612           init = build2 (INIT_EXPR, type, exp,
1613                          build_value_init_noctor (type, complain));
1614           finish_expr_stmt (init);
1615           return;
1616         }
1617       init = NULL_TREE;
1618     }
1619
1620   /* We know that expand_default_init can handle everything we want
1621      at this point.  */
1622   expand_default_init (binfo, true_exp, exp, init, flags, complain);
1623 }
1624
1625 /* Report an error if TYPE is not a user-defined, class type.  If
1626    OR_ELSE is nonzero, give an error message.  */
1627
1628 int
1629 is_class_type (tree type, int or_else)
1630 {
1631   if (type == error_mark_node)
1632     return 0;
1633
1634   if (! CLASS_TYPE_P (type))
1635     {
1636       if (or_else)
1637         error ("%qT is not a class type", type);
1638       return 0;
1639     }
1640   return 1;
1641 }
1642
1643 tree
1644 get_type_value (tree name)
1645 {
1646   if (name == error_mark_node)
1647     return NULL_TREE;
1648
1649   if (IDENTIFIER_HAS_TYPE_VALUE (name))
1650     return IDENTIFIER_TYPE_VALUE (name);
1651   else
1652     return NULL_TREE;
1653 }
1654
1655 /* Build a reference to a member of an aggregate.  This is not a C++
1656    `&', but really something which can have its address taken, and
1657    then act as a pointer to member, for example TYPE :: FIELD can have
1658    its address taken by saying & TYPE :: FIELD.  ADDRESS_P is true if
1659    this expression is the operand of "&".
1660
1661    @@ Prints out lousy diagnostics for operator <typename>
1662    @@ fields.
1663
1664    @@ This function should be rewritten and placed in search.c.  */
1665
1666 tree
1667 build_offset_ref (tree type, tree member, bool address_p)
1668 {
1669   tree decl;
1670   tree basebinfo = NULL_TREE;
1671
1672   /* class templates can come in as TEMPLATE_DECLs here.  */
1673   if (TREE_CODE (member) == TEMPLATE_DECL)
1674     return member;
1675
1676   if (dependent_scope_p (type) || type_dependent_expression_p (member))
1677     return build_qualified_name (NULL_TREE, type, member,
1678                                   /*template_p=*/false);
1679
1680   gcc_assert (TYPE_P (type));
1681   if (! is_class_type (type, 1))
1682     return error_mark_node;
1683
1684   gcc_assert (DECL_P (member) || BASELINK_P (member));
1685   /* Callers should call mark_used before this point.  */
1686   gcc_assert (!DECL_P (member) || TREE_USED (member));
1687
1688   type = TYPE_MAIN_VARIANT (type);
1689   if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type)))
1690     {
1691       error ("incomplete type %qT does not have member %qD", type, member);
1692       return error_mark_node;
1693     }
1694
1695   /* Entities other than non-static members need no further
1696      processing.  */
1697   if (TREE_CODE (member) == TYPE_DECL)
1698     return member;
1699   if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1700     return convert_from_reference (member);
1701
1702   if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1703     {
1704       error ("invalid pointer to bit-field %qD", member);
1705       return error_mark_node;
1706     }
1707
1708   /* Set up BASEBINFO for member lookup.  */
1709   decl = maybe_dummy_object (type, &basebinfo);
1710
1711   /* A lot of this logic is now handled in lookup_member.  */
1712   if (BASELINK_P (member))
1713     {
1714       /* Go from the TREE_BASELINK to the member function info.  */
1715       tree t = BASELINK_FUNCTIONS (member);
1716
1717       if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1718         {
1719           /* Get rid of a potential OVERLOAD around it.  */
1720           t = OVL_CURRENT (t);
1721
1722           /* Unique functions are handled easily.  */
1723
1724           /* For non-static member of base class, we need a special rule
1725              for access checking [class.protected]:
1726
1727                If the access is to form a pointer to member, the
1728                nested-name-specifier shall name the derived class
1729                (or any class derived from that class).  */
1730           if (address_p && DECL_P (t)
1731               && DECL_NONSTATIC_MEMBER_P (t))
1732             perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1733           else
1734             perform_or_defer_access_check (basebinfo, t, t);
1735
1736           if (DECL_STATIC_FUNCTION_P (t))
1737             return t;
1738           member = t;
1739         }
1740       else
1741         TREE_TYPE (member) = unknown_type_node;
1742     }
1743   else if (address_p && TREE_CODE (member) == FIELD_DECL)
1744     /* We need additional test besides the one in
1745        check_accessibility_of_qualified_id in case it is
1746        a pointer to non-static member.  */
1747     perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1748
1749   if (!address_p)
1750     {
1751       /* If MEMBER is non-static, then the program has fallen afoul of
1752          [expr.prim]:
1753
1754            An id-expression that denotes a nonstatic data member or
1755            nonstatic member function of a class can only be used:
1756
1757            -- as part of a class member access (_expr.ref_) in which the
1758            object-expression refers to the member's class or a class
1759            derived from that class, or
1760
1761            -- to form a pointer to member (_expr.unary.op_), or
1762
1763            -- in the body of a nonstatic member function of that class or
1764            of a class derived from that class (_class.mfct.nonstatic_), or
1765
1766            -- in a mem-initializer for a constructor for that class or for
1767            a class derived from that class (_class.base.init_).  */
1768       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1769         {
1770           /* Build a representation of the qualified name suitable
1771              for use as the operand to "&" -- even though the "&" is
1772              not actually present.  */
1773           member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1774           /* In Microsoft mode, treat a non-static member function as if
1775              it were a pointer-to-member.  */
1776           if (flag_ms_extensions)
1777             {
1778               PTRMEM_OK_P (member) = 1;
1779               return cp_build_addr_expr (member, tf_warning_or_error);
1780             }
1781           error ("invalid use of non-static member function %qD",
1782                  TREE_OPERAND (member, 1));
1783           return error_mark_node;
1784         }
1785       else if (TREE_CODE (member) == FIELD_DECL)
1786         {
1787           error ("invalid use of non-static data member %qD", member);
1788           return error_mark_node;
1789         }
1790       return member;
1791     }
1792
1793   member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1794   PTRMEM_OK_P (member) = 1;
1795   return member;
1796 }
1797
1798 /* If DECL is a scalar enumeration constant or variable with a
1799    constant initializer, return the initializer (or, its initializers,
1800    recursively); otherwise, return DECL.  If INTEGRAL_P, the
1801    initializer is only returned if DECL is an integral
1802    constant-expression.  */
1803
1804 static tree
1805 constant_value_1 (tree decl, bool integral_p)
1806 {
1807   while (TREE_CODE (decl) == CONST_DECL
1808          || (integral_p
1809              ? decl_constant_var_p (decl)
1810              : (TREE_CODE (decl) == VAR_DECL
1811                 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1812     {
1813       tree init;
1814       /* If DECL is a static data member in a template
1815          specialization, we must instantiate it here.  The
1816          initializer for the static data member is not processed
1817          until needed; we need it now.  */
1818       mark_used (decl);
1819       mark_rvalue_use (decl);
1820       init = DECL_INITIAL (decl);
1821       if (init == error_mark_node)
1822         {
1823           if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
1824             /* Treat the error as a constant to avoid cascading errors on
1825                excessively recursive template instantiation (c++/9335).  */
1826             return init;
1827           else
1828             return decl;
1829         }
1830       /* Initializers in templates are generally expanded during
1831          instantiation, so before that for const int i(2)
1832          INIT is a TREE_LIST with the actual initializer as
1833          TREE_VALUE.  */
1834       if (processing_template_decl
1835           && init
1836           && TREE_CODE (init) == TREE_LIST
1837           && TREE_CHAIN (init) == NULL_TREE)
1838         init = TREE_VALUE (init);
1839       if (!init
1840           || !TREE_TYPE (init)
1841           || !TREE_CONSTANT (init)
1842           || (!integral_p
1843               /* Do not return an aggregate constant (of which
1844                  string literals are a special case), as we do not
1845                  want to make inadvertent copies of such entities,
1846                  and we must be sure that their addresses are the
1847                  same everywhere.  */
1848               && (TREE_CODE (init) == CONSTRUCTOR
1849                   || TREE_CODE (init) == STRING_CST)))
1850         break;
1851       decl = unshare_expr (init);
1852     }
1853   return decl;
1854 }
1855
1856 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1857    constant of integral or enumeration type, then return that value.
1858    These are those variables permitted in constant expressions by
1859    [5.19/1].  */
1860
1861 tree
1862 integral_constant_value (tree decl)
1863 {
1864   return constant_value_1 (decl, /*integral_p=*/true);
1865 }
1866
1867 /* A more relaxed version of integral_constant_value, used by the
1868    common C/C++ code and by the C++ front end for optimization
1869    purposes.  */
1870
1871 tree
1872 decl_constant_value (tree decl)
1873 {
1874   return constant_value_1 (decl,
1875                            /*integral_p=*/processing_template_decl);
1876 }
1877 \f
1878 /* Common subroutines of build_new and build_vec_delete.  */
1879
1880 /* Call the global __builtin_delete to delete ADDR.  */
1881
1882 static tree
1883 build_builtin_delete_call (tree addr)
1884 {
1885   mark_used (global_delete_fndecl);
1886   return build_call_n (global_delete_fndecl, 1, addr);
1887 }
1888 \f
1889 /* Build and return a NEW_EXPR.  If NELTS is non-NULL, TYPE[NELTS] is
1890    the type of the object being allocated; otherwise, it's just TYPE.
1891    INIT is the initializer, if any.  USE_GLOBAL_NEW is true if the
1892    user explicitly wrote "::operator new".  PLACEMENT, if non-NULL, is
1893    a vector of arguments to be provided as arguments to a placement
1894    new operator.  This routine performs no semantic checks; it just
1895    creates and returns a NEW_EXPR.  */
1896
1897 static tree
1898 build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts,
1899                     VEC(tree,gc) *init, int use_global_new)
1900 {
1901   tree init_list;
1902   tree new_expr;
1903
1904   /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1905      If INIT is not NULL, then we want to store VOID_ZERO_NODE.  This
1906      permits us to distinguish the case of a missing initializer "new
1907      int" from an empty initializer "new int()".  */
1908   if (init == NULL)
1909     init_list = NULL_TREE;
1910   else if (VEC_empty (tree, init))
1911     init_list = void_zero_node;
1912   else
1913     init_list = build_tree_list_vec (init);
1914
1915   new_expr = build4 (NEW_EXPR, build_pointer_type (type),
1916                      build_tree_list_vec (placement), type, nelts,
1917                      init_list);
1918   NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1919   TREE_SIDE_EFFECTS (new_expr) = 1;
1920
1921   return new_expr;
1922 }
1923
1924 /* Diagnose uninitialized const members or reference members of type
1925    TYPE. USING_NEW is used to disambiguate the diagnostic between a
1926    new expression without a new-initializer and a declaration. Returns
1927    the error count. */
1928
1929 static int
1930 diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin,
1931                                             bool using_new, bool complain)
1932 {
1933   tree field;
1934   int error_count = 0;
1935
1936   if (type_has_user_provided_constructor (type))
1937     return 0;
1938
1939   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1940     {
1941       tree field_type;
1942
1943       if (TREE_CODE (field) != FIELD_DECL)
1944         continue;
1945
1946       field_type = strip_array_types (TREE_TYPE (field));
1947
1948       if (type_has_user_provided_constructor (field_type))
1949         continue;
1950
1951       if (TREE_CODE (field_type) == REFERENCE_TYPE)
1952         {
1953           ++ error_count;
1954           if (complain)
1955             {
1956               if (using_new)
1957                 error ("uninitialized reference member in %q#T "
1958                        "using %<new%> without new-initializer", origin);
1959               else
1960                 error ("uninitialized reference member in %q#T", origin);
1961               inform (DECL_SOURCE_LOCATION (field),
1962                       "%qD should be initialized", field);
1963             }
1964         }
1965
1966       if (CP_TYPE_CONST_P (field_type))
1967         {
1968           ++ error_count;
1969           if (complain)
1970             {
1971               if (using_new)
1972                 error ("uninitialized const member in %q#T "
1973                        "using %<new%> without new-initializer", origin);
1974               else
1975                 error ("uninitialized const member in %q#T", origin);
1976               inform (DECL_SOURCE_LOCATION (field),
1977                       "%qD should be initialized", field);
1978             }
1979         }
1980
1981       if (CLASS_TYPE_P (field_type))
1982         error_count
1983           += diagnose_uninitialized_cst_or_ref_member_1 (field_type, origin,
1984                                                          using_new, complain);
1985     }
1986   return error_count;
1987 }
1988
1989 int
1990 diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new, bool complain)
1991 {
1992   return diagnose_uninitialized_cst_or_ref_member_1 (type, type, using_new, complain);
1993 }
1994
1995 /* Generate code for a new-expression, including calling the "operator
1996    new" function, initializing the object, and, if an exception occurs
1997    during construction, cleaning up.  The arguments are as for
1998    build_raw_new_expr.  This may change PLACEMENT and INIT.  */
1999
2000 static tree
2001 build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
2002              VEC(tree,gc) **init, bool globally_qualified_p,
2003              tsubst_flags_t complain)
2004 {
2005   tree size, rval;
2006   /* True iff this is a call to "operator new[]" instead of just
2007      "operator new".  */
2008   bool array_p = false;
2009   /* If ARRAY_P is true, the element type of the array.  This is never
2010      an ARRAY_TYPE; for something like "new int[3][4]", the
2011      ELT_TYPE is "int".  If ARRAY_P is false, this is the same type as
2012      TYPE.  */
2013   tree elt_type;
2014   /* The type of the new-expression.  (This type is always a pointer
2015      type.)  */
2016   tree pointer_type;
2017   tree non_const_pointer_type;
2018   tree outer_nelts = NULL_TREE;
2019   tree alloc_call, alloc_expr;
2020   /* The address returned by the call to "operator new".  This node is
2021      a VAR_DECL and is therefore reusable.  */
2022   tree alloc_node;
2023   tree alloc_fn;
2024   tree cookie_expr, init_expr;
2025   int nothrow, check_new;
2026   int use_java_new = 0;
2027   /* If non-NULL, the number of extra bytes to allocate at the
2028      beginning of the storage allocated for an array-new expression in
2029      order to store the number of elements.  */
2030   tree cookie_size = NULL_TREE;
2031   tree placement_first;
2032   tree placement_expr = NULL_TREE;
2033   /* True if the function we are calling is a placement allocation
2034      function.  */
2035   bool placement_allocation_fn_p;
2036   /* True if the storage must be initialized, either by a constructor
2037      or due to an explicit new-initializer.  */
2038   bool is_initialized;
2039   /* The address of the thing allocated, not including any cookie.  In
2040      particular, if an array cookie is in use, DATA_ADDR is the
2041      address of the first array element.  This node is a VAR_DECL, and
2042      is therefore reusable.  */
2043   tree data_addr;
2044   tree init_preeval_expr = NULL_TREE;
2045
2046   if (nelts)
2047     {
2048       outer_nelts = nelts;
2049       array_p = true;
2050     }
2051   else if (TREE_CODE (type) == ARRAY_TYPE)
2052     {
2053       array_p = true;
2054       nelts = array_type_nelts_top (type);
2055       outer_nelts = nelts;
2056       type = TREE_TYPE (type);
2057     }
2058
2059   /* If our base type is an array, then make sure we know how many elements
2060      it has.  */
2061   for (elt_type = type;
2062        TREE_CODE (elt_type) == ARRAY_TYPE;
2063        elt_type = TREE_TYPE (elt_type))
2064     nelts = cp_build_binary_op (input_location,
2065                                 MULT_EXPR, nelts,
2066                                 array_type_nelts_top (elt_type),
2067                                 complain);
2068
2069   if (TREE_CODE (elt_type) == VOID_TYPE)
2070     {
2071       if (complain & tf_error)
2072         error ("invalid type %<void%> for new");
2073       return error_mark_node;
2074     }
2075
2076   if (abstract_virtuals_error_sfinae (NULL_TREE, elt_type, complain))
2077     return error_mark_node;
2078
2079   is_initialized = (type_build_ctor_call (elt_type) || *init != NULL);
2080
2081   if (*init == NULL)
2082     {
2083       bool maybe_uninitialized_error = false;
2084       /* A program that calls for default-initialization [...] of an
2085          entity of reference type is ill-formed. */
2086       if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
2087         maybe_uninitialized_error = true;
2088
2089       /* A new-expression that creates an object of type T initializes
2090          that object as follows:
2091       - If the new-initializer is omitted:
2092         -- If T is a (possibly cv-qualified) non-POD class type
2093            (or array thereof), the object is default-initialized (8.5).
2094            [...]
2095         -- Otherwise, the object created has indeterminate
2096            value. If T is a const-qualified type, or a (possibly
2097            cv-qualified) POD class type (or array thereof)
2098            containing (directly or indirectly) a member of
2099            const-qualified type, the program is ill-formed; */
2100
2101       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
2102         maybe_uninitialized_error = true;
2103
2104       if (maybe_uninitialized_error
2105           && diagnose_uninitialized_cst_or_ref_member (elt_type,
2106                                                        /*using_new=*/true,
2107                                                        complain & tf_error))
2108         return error_mark_node;
2109     }
2110
2111   if (CP_TYPE_CONST_P (elt_type) && *init == NULL
2112       && !type_has_user_provided_default_constructor (elt_type))
2113     {
2114       if (complain & tf_error)
2115         error ("uninitialized const in %<new%> of %q#T", elt_type);
2116       return error_mark_node;
2117     }
2118
2119   size = size_in_bytes (elt_type);
2120   if (array_p)
2121     size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
2122
2123   alloc_fn = NULL_TREE;
2124
2125   /* If PLACEMENT is a single simple pointer type not passed by
2126      reference, prepare to capture it in a temporary variable.  Do
2127      this now, since PLACEMENT will change in the calls below.  */
2128   placement_first = NULL_TREE;
2129   if (VEC_length (tree, *placement) == 1
2130       && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0)))
2131           == POINTER_TYPE))
2132     placement_first = VEC_index (tree, *placement, 0);
2133
2134   /* Allocate the object.  */
2135   if (VEC_empty (tree, *placement) && TYPE_FOR_JAVA (elt_type))
2136     {
2137       tree class_addr;
2138       tree class_decl = build_java_class_ref (elt_type);
2139       static const char alloc_name[] = "_Jv_AllocObject";
2140
2141       if (class_decl == error_mark_node)
2142         return error_mark_node;
2143
2144       use_java_new = 1;
2145       if (!get_global_value_if_present (get_identifier (alloc_name),
2146                                         &alloc_fn))
2147         {
2148           if (complain & tf_error)
2149             error ("call to Java constructor with %qs undefined", alloc_name);
2150           return error_mark_node;
2151         }
2152       else if (really_overloaded_fn (alloc_fn))
2153         {
2154           if (complain & tf_error)
2155             error ("%qD should never be overloaded", alloc_fn);
2156           return error_mark_node;
2157         }
2158       alloc_fn = OVL_CURRENT (alloc_fn);
2159       class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2160       alloc_call = cp_build_function_call_nary (alloc_fn, complain,
2161                                                 class_addr, NULL_TREE);
2162     }
2163   else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
2164     {
2165       error ("Java class %q#T object allocated using placement new", elt_type);
2166       return error_mark_node;
2167     }
2168   else
2169     {
2170       tree fnname;
2171       tree fns;
2172
2173       fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
2174
2175       if (!globally_qualified_p
2176           && CLASS_TYPE_P (elt_type)
2177           && (array_p
2178               ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
2179               : TYPE_HAS_NEW_OPERATOR (elt_type)))
2180         {
2181           /* Use a class-specific operator new.  */
2182           /* If a cookie is required, add some extra space.  */
2183           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2184             {
2185               cookie_size = targetm.cxx.get_cookie_size (elt_type);
2186               size = size_binop (PLUS_EXPR, size, cookie_size);
2187             }
2188           /* Create the argument list.  */
2189           VEC_safe_insert (tree, gc, *placement, 0, size);
2190           /* Do name-lookup to find the appropriate operator.  */
2191           fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
2192           if (fns == NULL_TREE)
2193             {
2194               if (complain & tf_error)
2195                 error ("no suitable %qD found in class %qT", fnname, elt_type);
2196               return error_mark_node;
2197             }
2198           if (TREE_CODE (fns) == TREE_LIST)
2199             {
2200               if (complain & tf_error)
2201                 {
2202                   error ("request for member %qD is ambiguous", fnname);
2203                   print_candidates (fns);
2204                 }
2205               return error_mark_node;
2206             }
2207           alloc_call = build_new_method_call (build_dummy_object (elt_type),
2208                                               fns, placement,
2209                                               /*conversion_path=*/NULL_TREE,
2210                                               LOOKUP_NORMAL,
2211                                               &alloc_fn,
2212                                               complain);
2213         }
2214       else
2215         {
2216           /* Use a global operator new.  */
2217           /* See if a cookie might be required.  */
2218           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2219             cookie_size = targetm.cxx.get_cookie_size (elt_type);
2220           else
2221             cookie_size = NULL_TREE;
2222
2223           alloc_call = build_operator_new_call (fnname, placement,
2224                                                 &size, &cookie_size,
2225                                                 &alloc_fn);
2226         }
2227     }
2228
2229   if (alloc_call == error_mark_node)
2230     return error_mark_node;
2231
2232   gcc_assert (alloc_fn != NULL_TREE);
2233
2234   /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2235      into a temporary variable.  */
2236   if (!processing_template_decl
2237       && placement_first != NULL_TREE
2238       && TREE_CODE (alloc_call) == CALL_EXPR
2239       && call_expr_nargs (alloc_call) == 2
2240       && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
2241       && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
2242     {
2243       tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
2244
2245       if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
2246           || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
2247         {
2248           placement_expr = get_target_expr (placement_first);
2249           CALL_EXPR_ARG (alloc_call, 1)
2250             = convert (TREE_TYPE (placement_arg), placement_expr);
2251         }
2252     }
2253
2254   /* In the simple case, we can stop now.  */
2255   pointer_type = build_pointer_type (type);
2256   if (!cookie_size && !is_initialized)
2257     return build_nop (pointer_type, alloc_call);
2258
2259   /* Store the result of the allocation call in a variable so that we can
2260      use it more than once.  */
2261   alloc_expr = get_target_expr (alloc_call);
2262   alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2263
2264   /* Strip any COMPOUND_EXPRs from ALLOC_CALL.  */
2265   while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2266     alloc_call = TREE_OPERAND (alloc_call, 1);
2267
2268   /* Now, check to see if this function is actually a placement
2269      allocation function.  This can happen even when PLACEMENT is NULL
2270      because we might have something like:
2271
2272        struct S { void* operator new (size_t, int i = 0); };
2273
2274      A call to `new S' will get this allocation function, even though
2275      there is no explicit placement argument.  If there is more than
2276      one argument, or there are variable arguments, then this is a
2277      placement allocation function.  */
2278   placement_allocation_fn_p
2279     = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2280        || varargs_function_p (alloc_fn));
2281
2282   /* Preevaluate the placement args so that we don't reevaluate them for a
2283      placement delete.  */
2284   if (placement_allocation_fn_p)
2285     {
2286       tree inits;
2287       stabilize_call (alloc_call, &inits);
2288       if (inits)
2289         alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2290                              alloc_expr);
2291     }
2292
2293   /*        unless an allocation function is declared with an empty  excep-
2294      tion-specification  (_except.spec_),  throw(), it indicates failure to
2295      allocate storage by throwing a bad_alloc exception  (clause  _except_,
2296      _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2297      cation function is declared  with  an  empty  exception-specification,
2298      throw(), it returns null to indicate failure to allocate storage and a
2299      non-null pointer otherwise.
2300
2301      So check for a null exception spec on the op new we just called.  */
2302
2303   nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2304   check_new = (flag_check_new || nothrow) && ! use_java_new;
2305
2306   if (cookie_size)
2307     {
2308       tree cookie;
2309       tree cookie_ptr;
2310       tree size_ptr_type;
2311
2312       /* Adjust so we're pointing to the start of the object.  */
2313       data_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2314                           alloc_node, cookie_size);
2315
2316       /* Store the number of bytes allocated so that we can know how
2317          many elements to destroy later.  We use the last sizeof
2318          (size_t) bytes to store the number of elements.  */
2319       cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2320       cookie_ptr = fold_build2_loc (input_location,
2321                                 POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2322                                 alloc_node, cookie_ptr);
2323       size_ptr_type = build_pointer_type (sizetype);
2324       cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2325       cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2326
2327       cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2328
2329       if (targetm.cxx.cookie_has_size ())
2330         {
2331           /* Also store the element size.  */
2332           cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
2333                                fold_build1_loc (input_location,
2334                                             NEGATE_EXPR, sizetype,
2335                                             size_in_bytes (sizetype)));
2336
2337           cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2338           cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2339                            size_in_bytes (elt_type));
2340           cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2341                                 cookie, cookie_expr);
2342         }
2343     }
2344   else
2345     {
2346       cookie_expr = NULL_TREE;
2347       data_addr = alloc_node;
2348     }
2349
2350   /* Now use a pointer to the type we've actually allocated.  */
2351
2352   /* But we want to operate on a non-const version to start with,
2353      since we'll be modifying the elements.  */
2354   non_const_pointer_type = build_pointer_type
2355     (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST));
2356
2357   data_addr = fold_convert (non_const_pointer_type, data_addr);
2358   /* Any further uses of alloc_node will want this type, too.  */
2359   alloc_node = fold_convert (non_const_pointer_type, alloc_node);
2360
2361   /* Now initialize the allocated object.  Note that we preevaluate the
2362      initialization expression, apart from the actual constructor call or
2363      assignment--we do this because we want to delay the allocation as long
2364      as possible in order to minimize the size of the exception region for
2365      placement delete.  */
2366   if (is_initialized)
2367     {
2368       bool stable;
2369       bool explicit_value_init_p = false;
2370
2371       if (*init != NULL && VEC_empty (tree, *init))
2372         {
2373           *init = NULL;
2374           explicit_value_init_p = true;
2375         }
2376
2377       if (processing_template_decl && explicit_value_init_p)
2378         {
2379           /* build_value_init doesn't work in templates, and we don't need
2380              the initializer anyway since we're going to throw it away and
2381              rebuild it at instantiation time, so just build up a single
2382              constructor call to get any appropriate diagnostics.  */
2383           init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2384           if (type_build_ctor_call (elt_type))
2385             init_expr = build_special_member_call (init_expr,
2386                                                    complete_ctor_identifier,
2387                                                    init, elt_type,
2388                                                    LOOKUP_NORMAL,
2389                                                    complain);
2390           stable = stabilize_init (init_expr, &init_preeval_expr);
2391         }
2392       else if (array_p)
2393         {
2394           tree vecinit = NULL_TREE;
2395           if (*init && VEC_length (tree, *init) == 1
2396               && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *init, 0))
2397               && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *init, 0)))
2398             {
2399               vecinit = VEC_index (tree, *init, 0);
2400               if (CONSTRUCTOR_NELTS (vecinit) == 0)
2401                 /* List-value-initialization, leave it alone.  */;
2402               else
2403                 {
2404                   tree arraytype, domain;
2405                   if (TREE_CONSTANT (nelts))
2406                     domain = compute_array_index_type (NULL_TREE, nelts,
2407                                                        complain);
2408                   else
2409                     {
2410                       domain = NULL_TREE;
2411                       if (CONSTRUCTOR_NELTS (vecinit) > 0)
2412                         warning (0, "non-constant array size in new, unable "
2413                                  "to verify length of initializer-list");
2414                     }
2415                   arraytype = build_cplus_array_type (type, domain);
2416                   vecinit = digest_init (arraytype, vecinit, complain);
2417                 }
2418             }
2419           else if (*init)
2420             {
2421               if (complain & tf_error)
2422                 permerror (input_location,
2423                            "parenthesized initializer in array new");
2424               else
2425                 return error_mark_node;
2426               vecinit = build_tree_list_vec (*init);
2427             }
2428           init_expr
2429             = build_vec_init (data_addr,
2430                               cp_build_binary_op (input_location,
2431                                                   MINUS_EXPR, outer_nelts,
2432                                                   integer_one_node,
2433                                                   complain),
2434                               vecinit,
2435                               explicit_value_init_p,
2436                               /*from_array=*/0,
2437                               complain);
2438
2439           /* An array initialization is stable because the initialization
2440              of each element is a full-expression, so the temporaries don't
2441              leak out.  */
2442           stable = true;
2443         }
2444       else
2445         {
2446           init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2447
2448           if (type_build_ctor_call (type) && !explicit_value_init_p)
2449             {
2450               init_expr = build_special_member_call (init_expr,
2451                                                      complete_ctor_identifier,
2452                                                      init, elt_type,
2453                                                      LOOKUP_NORMAL,
2454                                                      complain);
2455             }
2456           else if (explicit_value_init_p)
2457             {
2458               /* Something like `new int()'.  */
2459               tree val = build_value_init (type, complain);
2460               if (val == error_mark_node)
2461                 return error_mark_node;
2462               init_expr = build2 (INIT_EXPR, type, init_expr, val);
2463             }
2464           else
2465             {
2466               tree ie;
2467
2468               /* We are processing something like `new int (10)', which
2469                  means allocate an int, and initialize it with 10.  */
2470
2471               ie = build_x_compound_expr_from_vec (*init, "new initializer");
2472               init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, ie,
2473                                                 complain);
2474             }
2475           stable = stabilize_init (init_expr, &init_preeval_expr);
2476         }
2477
2478       if (init_expr == error_mark_node)
2479         return error_mark_node;
2480
2481       /* If any part of the object initialization terminates by throwing an
2482          exception and a suitable deallocation function can be found, the
2483          deallocation function is called to free the memory in which the
2484          object was being constructed, after which the exception continues
2485          to propagate in the context of the new-expression. If no
2486          unambiguous matching deallocation function can be found,
2487          propagating the exception does not cause the object's memory to be
2488          freed.  */
2489       if (flag_exceptions && ! use_java_new)
2490         {
2491           enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2492           tree cleanup;
2493
2494           /* The Standard is unclear here, but the right thing to do
2495              is to use the same method for finding deallocation
2496              functions that we use for finding allocation functions.  */
2497           cleanup = (build_op_delete_call
2498                      (dcode,
2499                       alloc_node,
2500                       size,
2501                       globally_qualified_p,
2502                       placement_allocation_fn_p ? alloc_call : NULL_TREE,
2503                       alloc_fn));
2504
2505           if (!cleanup)
2506             /* We're done.  */;
2507           else if (stable)
2508             /* This is much simpler if we were able to preevaluate all of
2509                the arguments to the constructor call.  */
2510             {
2511               /* CLEANUP is compiler-generated, so no diagnostics.  */
2512               TREE_NO_WARNING (cleanup) = true;
2513               init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2514                                   init_expr, cleanup);
2515               /* Likewise, this try-catch is compiler-generated.  */
2516               TREE_NO_WARNING (init_expr) = true;
2517             }
2518           else
2519             /* Ack!  First we allocate the memory.  Then we set our sentry
2520                variable to true, and expand a cleanup that deletes the
2521                memory if sentry is true.  Then we run the constructor, and
2522                finally clear the sentry.
2523
2524                We need to do this because we allocate the space first, so
2525                if there are any temporaries with cleanups in the
2526                constructor args and we weren't able to preevaluate them, we
2527                need this EH region to extend until end of full-expression
2528                to preserve nesting.  */
2529             {
2530               tree end, sentry, begin;
2531
2532               begin = get_target_expr (boolean_true_node);
2533               CLEANUP_EH_ONLY (begin) = 1;
2534
2535               sentry = TARGET_EXPR_SLOT (begin);
2536
2537               /* CLEANUP is compiler-generated, so no diagnostics.  */
2538               TREE_NO_WARNING (cleanup) = true;
2539
2540               TARGET_EXPR_CLEANUP (begin)
2541                 = build3 (COND_EXPR, void_type_node, sentry,
2542                           cleanup, void_zero_node);
2543
2544               end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2545                             sentry, boolean_false_node);
2546
2547               init_expr
2548                 = build2 (COMPOUND_EXPR, void_type_node, begin,
2549                           build2 (COMPOUND_EXPR, void_type_node, init_expr,
2550                                   end));
2551               /* Likewise, this is compiler-generated.  */
2552               TREE_NO_WARNING (init_expr) = true;
2553             }
2554         }
2555     }
2556   else
2557     init_expr = NULL_TREE;
2558
2559   /* Now build up the return value in reverse order.  */
2560
2561   rval = data_addr;
2562
2563   if (init_expr)
2564     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2565   if (cookie_expr)
2566     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2567
2568   if (rval == data_addr)
2569     /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2570        and return the call (which doesn't need to be adjusted).  */
2571     rval = TARGET_EXPR_INITIAL (alloc_expr);
2572   else
2573     {
2574       if (check_new)
2575         {
2576           tree ifexp = cp_build_binary_op (input_location,
2577                                            NE_EXPR, alloc_node,
2578                                            integer_zero_node,
2579                                            complain);
2580           rval = build_conditional_expr (ifexp, rval, alloc_node, 
2581                                          complain);
2582         }
2583
2584       /* Perform the allocation before anything else, so that ALLOC_NODE
2585          has been initialized before we start using it.  */
2586       rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2587     }
2588
2589   if (init_preeval_expr)
2590     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2591
2592   /* A new-expression is never an lvalue.  */
2593   gcc_assert (!lvalue_p (rval));
2594
2595   return convert (pointer_type, rval);
2596 }
2597
2598 /* Generate a representation for a C++ "new" expression.  *PLACEMENT
2599    is a vector of placement-new arguments (or NULL if none).  If NELTS
2600    is NULL, TYPE is the type of the storage to be allocated.  If NELTS
2601    is not NULL, then this is an array-new allocation; TYPE is the type
2602    of the elements in the array and NELTS is the number of elements in
2603    the array.  *INIT, if non-NULL, is the initializer for the new
2604    object, or an empty vector to indicate an initializer of "()".  If
2605    USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2606    rather than just "new".  This may change PLACEMENT and INIT.  */
2607
2608 tree
2609 build_new (VEC(tree,gc) **placement, tree type, tree nelts,
2610            VEC(tree,gc) **init, int use_global_new, tsubst_flags_t complain)
2611 {
2612   tree rval;
2613   VEC(tree,gc) *orig_placement = NULL;
2614   tree orig_nelts = NULL_TREE;
2615   VEC(tree,gc) *orig_init = NULL;
2616
2617   if (type == error_mark_node)
2618     return error_mark_node;
2619
2620   if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2621     {
2622       tree auto_node = type_uses_auto (type);
2623       if (auto_node)
2624         {
2625           tree d_init = VEC_index (tree, *init, 0);
2626           d_init = resolve_nondeduced_context (d_init);
2627           type = do_auto_deduction (type, d_init, auto_node);
2628         }
2629     }
2630
2631   if (processing_template_decl)
2632     {
2633       if (dependent_type_p (type)
2634           || any_type_dependent_arguments_p (*placement)
2635           || (nelts && type_dependent_expression_p (nelts))
2636           || any_type_dependent_arguments_p (*init))
2637         return build_raw_new_expr (*placement, type, nelts, *init,
2638                                    use_global_new);
2639
2640       orig_placement = make_tree_vector_copy (*placement);
2641       orig_nelts = nelts;
2642       orig_init = make_tree_vector_copy (*init);
2643
2644       make_args_non_dependent (*placement);
2645       if (nelts)
2646         nelts = build_non_dependent_expr (nelts);
2647       make_args_non_dependent (*init);
2648     }
2649
2650   if (nelts)
2651     {
2652       if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2653         {
2654           if (complain & tf_error)
2655             permerror (input_location, "size in array new must have integral type");
2656           else
2657             return error_mark_node;
2658         }
2659       nelts = mark_rvalue_use (nelts);
2660       nelts = cp_save_expr (cp_convert (sizetype, nelts));
2661     }
2662
2663   /* ``A reference cannot be created by the new operator.  A reference
2664      is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2665      returned by new.'' ARM 5.3.3 */
2666   if (TREE_CODE (type) == REFERENCE_TYPE)
2667     {
2668       if (complain & tf_error)
2669         error ("new cannot be applied to a reference type");
2670       else
2671         return error_mark_node;
2672       type = TREE_TYPE (type);
2673     }
2674
2675   if (TREE_CODE (type) == FUNCTION_TYPE)
2676     {
2677       if (complain & tf_error)
2678         error ("new cannot be applied to a function type");
2679       return error_mark_node;
2680     }
2681
2682   /* The type allocated must be complete.  If the new-type-id was
2683      "T[N]" then we are just checking that "T" is complete here, but
2684      that is equivalent, since the value of "N" doesn't matter.  */
2685   if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
2686     return error_mark_node;
2687
2688   rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2689   if (rval == error_mark_node)
2690     return error_mark_node;
2691
2692   if (processing_template_decl)
2693     {
2694       tree ret = build_raw_new_expr (orig_placement, type, orig_nelts,
2695                                      orig_init, use_global_new);
2696       release_tree_vector (orig_placement);
2697       release_tree_vector (orig_init);
2698       return ret;
2699     }
2700
2701   /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain.  */
2702   rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2703   TREE_NO_WARNING (rval) = 1;
2704
2705   return rval;
2706 }
2707
2708 /* Given a Java class, return a decl for the corresponding java.lang.Class.  */
2709
2710 tree
2711 build_java_class_ref (tree type)
2712 {
2713   tree name = NULL_TREE, class_decl;
2714   static tree CL_suffix = NULL_TREE;
2715   if (CL_suffix == NULL_TREE)
2716     CL_suffix = get_identifier("class$");
2717   if (jclass_node == NULL_TREE)
2718     {
2719       jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2720       if (jclass_node == NULL_TREE)
2721         {
2722           error ("call to Java constructor, while %<jclass%> undefined");
2723           return error_mark_node;
2724         }
2725       jclass_node = TREE_TYPE (jclass_node);
2726     }
2727
2728   /* Mangle the class$ field.  */
2729   {
2730     tree field;
2731     for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2732       if (DECL_NAME (field) == CL_suffix)
2733         {
2734           mangle_decl (field);
2735           name = DECL_ASSEMBLER_NAME (field);
2736           break;
2737         }
2738     if (!field)
2739       {
2740         error ("can%'t find %<class$%> in %qT", type);
2741         return error_mark_node;
2742       }
2743   }
2744
2745   class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2746   if (class_decl == NULL_TREE)
2747     {
2748       class_decl = build_decl (input_location,
2749                                VAR_DECL, name, TREE_TYPE (jclass_node));
2750       TREE_STATIC (class_decl) = 1;
2751       DECL_EXTERNAL (class_decl) = 1;
2752       TREE_PUBLIC (class_decl) = 1;
2753       DECL_ARTIFICIAL (class_decl) = 1;
2754       DECL_IGNORED_P (class_decl) = 1;
2755       pushdecl_top_level (class_decl);
2756       make_decl_rtl (class_decl);
2757     }
2758   return class_decl;
2759 }
2760 \f
2761 static tree
2762 build_vec_delete_1 (tree base, tree maxindex, tree type,
2763                     special_function_kind auto_delete_vec,
2764                     int use_global_delete, tsubst_flags_t complain)
2765 {
2766   tree virtual_size;
2767   tree ptype = build_pointer_type (type = complete_type (type));
2768   tree size_exp = size_in_bytes (type);
2769
2770   /* Temporary variables used by the loop.  */
2771   tree tbase, tbase_init;
2772
2773   /* This is the body of the loop that implements the deletion of a
2774      single element, and moves temp variables to next elements.  */
2775   tree body;
2776
2777   /* This is the LOOP_EXPR that governs the deletion of the elements.  */
2778   tree loop = 0;
2779
2780   /* This is the thing that governs what to do after the loop has run.  */
2781   tree deallocate_expr = 0;
2782
2783   /* This is the BIND_EXPR which holds the outermost iterator of the
2784      loop.  It is convenient to set this variable up and test it before
2785      executing any other code in the loop.
2786      This is also the containing expression returned by this function.  */
2787   tree controller = NULL_TREE;
2788   tree tmp;
2789
2790   /* We should only have 1-D arrays here.  */
2791   gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2792
2793   if (base == error_mark_node || maxindex == error_mark_node)
2794     return error_mark_node;
2795
2796   if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2797     goto no_destructor;
2798
2799   /* The below is short by the cookie size.  */
2800   virtual_size = size_binop (MULT_EXPR, size_exp,
2801                              convert (sizetype, maxindex));
2802
2803   tbase = create_temporary_var (ptype);
2804   tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2805                                      fold_build2_loc (input_location,
2806                                                   POINTER_PLUS_EXPR, ptype,
2807                                                   fold_convert (ptype, base),
2808                                                   virtual_size),
2809                                      complain);
2810   if (tbase_init == error_mark_node)
2811     return error_mark_node;
2812   controller = build3 (BIND_EXPR, void_type_node, tbase,
2813                        NULL_TREE, NULL_TREE);
2814   TREE_SIDE_EFFECTS (controller) = 1;
2815
2816   body = build1 (EXIT_EXPR, void_type_node,
2817                  build2 (EQ_EXPR, boolean_type_node, tbase,
2818                          fold_convert (ptype, base)));
2819   tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
2820   tmp = build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp);
2821   tmp = cp_build_modify_expr (tbase, NOP_EXPR, tmp, complain);
2822   if (tmp == error_mark_node)
2823     return error_mark_node;
2824   body = build_compound_expr (input_location, body, tmp);
2825   tmp = build_delete (ptype, tbase, sfk_complete_destructor,
2826                       LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1,
2827                       complain);
2828   if (tmp == error_mark_node)
2829     return error_mark_node;
2830   body = build_compound_expr (input_location, body, tmp);
2831
2832   loop = build1 (LOOP_EXPR, void_type_node, body);
2833   loop = build_compound_expr (input_location, tbase_init, loop);
2834
2835  no_destructor:
2836   /* Delete the storage if appropriate.  */
2837   if (auto_delete_vec == sfk_deleting_destructor)
2838     {
2839       tree base_tbd;
2840
2841       /* The below is short by the cookie size.  */
2842       virtual_size = size_binop (MULT_EXPR, size_exp,
2843                                  convert (sizetype, maxindex));
2844
2845       if (! TYPE_VEC_NEW_USES_COOKIE (type))
2846         /* no header */
2847         base_tbd = base;
2848       else
2849         {
2850           tree cookie_size;
2851
2852           cookie_size = targetm.cxx.get_cookie_size (type);
2853           base_tbd = cp_build_binary_op (input_location,
2854                                          MINUS_EXPR,
2855                                          cp_convert (string_type_node,
2856                                                      base),
2857                                          cookie_size,
2858                                          complain);
2859           if (base_tbd == error_mark_node)
2860             return error_mark_node;
2861           base_tbd = cp_convert (ptype, base_tbd);
2862           /* True size with header.  */
2863           virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2864         }
2865
2866       deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2867                                               base_tbd, virtual_size,
2868                                               use_global_delete & 1,
2869                                               /*placement=*/NULL_TREE,
2870                                               /*alloc_fn=*/NULL_TREE);
2871     }
2872
2873   body = loop;
2874   if (!deallocate_expr)
2875     ;
2876   else if (!body)
2877     body = deallocate_expr;
2878   else
2879     body = build_compound_expr (input_location, body, deallocate_expr);
2880
2881   if (!body)
2882     body = integer_zero_node;
2883
2884   /* Outermost wrapper: If pointer is null, punt.  */
2885   body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
2886                       fold_build2_loc (input_location,
2887                                    NE_EXPR, boolean_type_node, base,
2888                                    convert (TREE_TYPE (base),
2889                                             integer_zero_node)),
2890                       body, integer_zero_node);
2891   body = build1 (NOP_EXPR, void_type_node, body);
2892
2893   if (controller)
2894     {
2895       TREE_OPERAND (controller, 1) = body;
2896       body = controller;
2897     }
2898
2899   if (TREE_CODE (base) == SAVE_EXPR)
2900     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
2901     body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2902
2903   return convert_to_void (body, ICV_CAST, complain);
2904 }
2905
2906 /* Create an unnamed variable of the indicated TYPE.  */
2907
2908 tree
2909 create_temporary_var (tree type)
2910 {
2911   tree decl;
2912
2913   decl = build_decl (input_location,
2914                      VAR_DECL, NULL_TREE, type);
2915   TREE_USED (decl) = 1;
2916   DECL_ARTIFICIAL (decl) = 1;
2917   DECL_IGNORED_P (decl) = 1;
2918   DECL_CONTEXT (decl) = current_function_decl;
2919
2920   return decl;
2921 }
2922
2923 /* Create a new temporary variable of the indicated TYPE, initialized
2924    to INIT.
2925
2926    It is not entered into current_binding_level, because that breaks
2927    things when it comes time to do final cleanups (which take place
2928    "outside" the binding contour of the function).  */
2929
2930 tree
2931 get_temp_regvar (tree type, tree init)
2932 {
2933   tree decl;
2934
2935   decl = create_temporary_var (type);
2936   add_decl_expr (decl);
2937
2938   finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init, 
2939                                           tf_warning_or_error));
2940
2941   return decl;
2942 }
2943
2944 /* `build_vec_init' returns tree structure that performs
2945    initialization of a vector of aggregate types.
2946
2947    BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2948      to the first element, of POINTER_TYPE.
2949    MAXINDEX is the maximum index of the array (one less than the
2950      number of elements).  It is only used if BASE is a pointer or
2951      TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2952
2953    INIT is the (possibly NULL) initializer.
2954
2955    If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL.  All
2956    elements in the array are value-initialized.
2957
2958    FROM_ARRAY is 0 if we should init everything with INIT
2959    (i.e., every element initialized from INIT).
2960    FROM_ARRAY is 1 if we should index into INIT in parallel
2961    with initialization of DECL.
2962    FROM_ARRAY is 2 if we should index into INIT in parallel,
2963    but use assignment instead of initialization.  */
2964
2965 tree
2966 build_vec_init (tree base, tree maxindex, tree init,
2967                 bool explicit_value_init_p,
2968                 int from_array, tsubst_flags_t complain)
2969 {
2970   tree rval;
2971   tree base2 = NULL_TREE;
2972   tree itype = NULL_TREE;
2973   tree iterator;
2974   /* The type of BASE.  */
2975   tree atype = TREE_TYPE (base);
2976   /* The type of an element in the array.  */
2977   tree type = TREE_TYPE (atype);
2978   /* The element type reached after removing all outer array
2979      types.  */
2980   tree inner_elt_type;
2981   /* The type of a pointer to an element in the array.  */
2982   tree ptype;
2983   tree stmt_expr;
2984   tree compound_stmt;
2985   int destroy_temps;
2986   tree try_block = NULL_TREE;
2987   int num_initialized_elts = 0;
2988   bool is_global;
2989   tree const_init = NULL_TREE;
2990   tree obase = base;
2991   bool xvalue = false;
2992   bool errors = false;
2993
2994   if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2995     maxindex = array_type_nelts (atype);
2996
2997   if (maxindex == NULL_TREE || maxindex == error_mark_node)
2998     return error_mark_node;
2999
3000   if (explicit_value_init_p)
3001     gcc_assert (!init);
3002
3003   inner_elt_type = strip_array_types (type);
3004
3005   /* Look through the TARGET_EXPR around a compound literal.  */
3006   if (init && TREE_CODE (init) == TARGET_EXPR
3007       && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
3008       && from_array != 2)
3009     init = TARGET_EXPR_INITIAL (init);
3010
3011   if (init
3012       && TREE_CODE (atype) == ARRAY_TYPE
3013       && (from_array == 2
3014           ? (!CLASS_TYPE_P (inner_elt_type)
3015              || !TYPE_HAS_COMPLEX_COPY_ASSIGN (inner_elt_type))
3016           : !TYPE_NEEDS_CONSTRUCTING (type))
3017       && ((TREE_CODE (init) == CONSTRUCTOR
3018            /* Don't do this if the CONSTRUCTOR might contain something
3019               that might throw and require us to clean up.  */
3020            && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
3021                || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
3022           || from_array))
3023     {
3024       /* Do non-default initialization of trivial arrays resulting from
3025          brace-enclosed initializers.  In this case, digest_init and
3026          store_constructor will handle the semantics for us.  */
3027
3028       stmt_expr = build2 (INIT_EXPR, atype, base, init);
3029       return stmt_expr;
3030     }
3031
3032   maxindex = cp_convert (ptrdiff_type_node, maxindex);
3033   if (TREE_CODE (atype) == ARRAY_TYPE)
3034     {
3035       ptype = build_pointer_type (type);
3036       base = cp_convert (ptype, decay_conversion (base));
3037     }
3038   else
3039     ptype = atype;
3040
3041   /* The code we are generating looks like:
3042      ({
3043        T* t1 = (T*) base;
3044        T* rval = t1;
3045        ptrdiff_t iterator = maxindex;
3046        try {
3047          for (; iterator != -1; --iterator) {
3048            ... initialize *t1 ...
3049            ++t1;
3050          }
3051        } catch (...) {
3052          ... destroy elements that were constructed ...
3053        }
3054        rval;
3055      })
3056
3057      We can omit the try and catch blocks if we know that the
3058      initialization will never throw an exception, or if the array
3059      elements do not have destructors.  We can omit the loop completely if
3060      the elements of the array do not have constructors.
3061
3062      We actually wrap the entire body of the above in a STMT_EXPR, for
3063      tidiness.
3064
3065      When copying from array to another, when the array elements have
3066      only trivial copy constructors, we should use __builtin_memcpy
3067      rather than generating a loop.  That way, we could take advantage
3068      of whatever cleverness the back end has for dealing with copies
3069      of blocks of memory.  */
3070
3071   is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
3072   destroy_temps = stmts_are_full_exprs_p ();
3073   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3074   rval = get_temp_regvar (ptype, base);
3075   base = get_temp_regvar (ptype, rval);
3076   iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
3077
3078   /* If initializing one array from another, initialize element by
3079      element.  We rely upon the below calls to do the argument
3080      checking.  Evaluate the initializer before entering the try block.  */
3081   if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
3082     {
3083       if (lvalue_kind (init) & clk_rvalueref)
3084         xvalue = true;
3085       base2 = decay_conversion (init);
3086       itype = TREE_TYPE (base2);
3087       base2 = get_temp_regvar (itype, base2);
3088       itype = TREE_TYPE (itype);
3089     }
3090
3091   /* Protect the entire array initialization so that we can destroy
3092      the partially constructed array if an exception is thrown.
3093      But don't do this if we're assigning.  */
3094   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3095       && from_array != 2)
3096     {
3097       try_block = begin_try_block ();
3098     }
3099
3100   /* If the initializer is {}, then all elements are initialized from {}.
3101      But for non-classes, that's the same as value-initialization.  */
3102   if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
3103       && CONSTRUCTOR_NELTS (init) == 0)
3104     {
3105       if (CLASS_TYPE_P (type))
3106         /* Leave init alone.  */;
3107       else
3108         {
3109           init = NULL_TREE;
3110           explicit_value_init_p = true;
3111         }
3112     }
3113
3114   /* Maybe pull out constant value when from_array? */
3115
3116   else if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
3117     {
3118       /* Do non-default initialization of non-trivial arrays resulting from
3119          brace-enclosed initializers.  */
3120       unsigned HOST_WIDE_INT idx;
3121       tree field, elt;
3122       /* Should we try to create a constant initializer?  */
3123       bool try_const = (TREE_CODE (atype) == ARRAY_TYPE
3124                         && (literal_type_p (inner_elt_type)
3125                             || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type)));
3126       bool saw_non_const = false;
3127       bool saw_const = false;
3128       /* If we're initializing a static array, we want to do static
3129          initialization of any elements with constant initializers even if
3130          some are non-constant.  */
3131       bool do_static_init = (DECL_P (obase) && TREE_STATIC (obase));
3132       VEC(constructor_elt,gc) *new_vec;
3133       from_array = 0;
3134
3135       if (try_const)
3136         new_vec = VEC_alloc (constructor_elt, gc, CONSTRUCTOR_NELTS (init));
3137       else
3138         new_vec = NULL;
3139
3140       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt)
3141         {
3142           tree baseref = build1 (INDIRECT_REF, type, base);
3143           tree one_init;
3144
3145           num_initialized_elts++;
3146
3147           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3148           if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
3149             one_init = build_aggr_init (baseref, elt, 0, complain);
3150           else
3151             one_init = cp_build_modify_expr (baseref, NOP_EXPR,
3152                                              elt, complain);
3153           if (one_init == error_mark_node)
3154             errors = true;
3155           if (try_const)
3156             {
3157               tree e = one_init;
3158               if (TREE_CODE (e) == EXPR_STMT)
3159                 e = TREE_OPERAND (e, 0);
3160               if (TREE_CODE (e) == CONVERT_EXPR
3161                   && VOID_TYPE_P (TREE_TYPE (e)))
3162                 e = TREE_OPERAND (e, 0);
3163               e = maybe_constant_init (e);
3164               if (reduced_constant_expression_p (e))
3165                 {
3166                   CONSTRUCTOR_APPEND_ELT (new_vec, field, e);
3167                   if (do_static_init)
3168                     one_init = NULL_TREE;
3169                   else
3170                     one_init = build2 (INIT_EXPR, type, baseref, e);
3171                   saw_const = true;
3172                 }
3173               else
3174                 {
3175                   if (do_static_init)
3176                     CONSTRUCTOR_APPEND_ELT (new_vec, field,
3177                                             build_zero_init (TREE_TYPE (e),
3178                                                              NULL_TREE, true));
3179                   saw_non_const = true;
3180                 }
3181             }
3182
3183           if (one_init)
3184             finish_expr_stmt (one_init);
3185           current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3186
3187           one_init = cp_build_unary_op (PREINCREMENT_EXPR, base, 0, complain);
3188           if (one_init == error_mark_node)
3189             errors = true;
3190           else
3191             finish_expr_stmt (one_init);
3192
3193           one_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3194                                         complain);
3195           if (one_init == error_mark_node)
3196             errors = true;
3197           else
3198             finish_expr_stmt (one_init);
3199         }
3200
3201       if (try_const)
3202         {
3203           if (!saw_non_const)
3204             const_init = build_constructor (atype, new_vec);
3205           else if (do_static_init && saw_const)
3206             DECL_INITIAL (obase) = build_constructor (atype, new_vec);
3207           else
3208             VEC_free (constructor_elt, gc, new_vec);
3209         }
3210
3211       /* Clear out INIT so that we don't get confused below.  */
3212       init = NULL_TREE;
3213     }
3214   else if (from_array)
3215     {
3216       if (init)
3217         /* OK, we set base2 above.  */;
3218       else if (CLASS_TYPE_P (type)
3219                && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3220         {
3221           if (complain & tf_error)
3222             error ("initializer ends prematurely");
3223           errors = true;
3224         }
3225     }
3226
3227   /* Now, default-initialize any remaining elements.  We don't need to
3228      do that if a) the type does not need constructing, or b) we've
3229      already initialized all the elements.
3230
3231      We do need to keep going if we're copying an array.  */
3232
3233   if (from_array
3234       || ((type_build_ctor_call (type) || init || explicit_value_init_p)
3235           && ! (host_integerp (maxindex, 0)
3236                 && (num_initialized_elts
3237                     == tree_low_cst (maxindex, 0) + 1))))
3238     {
3239       /* If the ITERATOR is equal to -1, then we don't have to loop;
3240          we've already initialized all the elements.  */
3241       tree for_stmt;
3242       tree elt_init;
3243       tree to;
3244
3245       for_stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
3246       finish_for_init_stmt (for_stmt);
3247       finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
3248                                build_int_cst (TREE_TYPE (iterator), -1)),
3249                        for_stmt);
3250       elt_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3251                                     complain);
3252       if (elt_init == error_mark_node)
3253         errors = true;
3254       finish_for_expr (elt_init, for_stmt);
3255
3256       to = build1 (INDIRECT_REF, type, base);
3257
3258       if (from_array)
3259         {
3260           tree from;
3261
3262           if (base2)
3263             {
3264               from = build1 (INDIRECT_REF, itype, base2);
3265               if (xvalue)
3266                 from = move (from);
3267             }
3268           else
3269             from = NULL_TREE;
3270
3271           if (from_array == 2)
3272             elt_init = cp_build_modify_expr (to, NOP_EXPR, from, 
3273                                              complain);
3274           else if (type_build_ctor_call (type))
3275             elt_init = build_aggr_init (to, from, 0, complain);
3276           else if (from)
3277             elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3278                                              complain);
3279           else
3280             gcc_unreachable ();
3281         }
3282       else if (TREE_CODE (type) == ARRAY_TYPE)
3283         {
3284           if (init != 0)
3285             sorry
3286               ("cannot initialize multi-dimensional array with initializer");
3287           elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
3288                                      0, 0,
3289                                      explicit_value_init_p,
3290                                      0, complain);
3291         }
3292       else if (explicit_value_init_p)
3293         {
3294           elt_init = build_value_init (type, complain);
3295           if (elt_init != error_mark_node)
3296             elt_init = build2 (INIT_EXPR, type, to, elt_init);
3297         }
3298       else
3299         {
3300           gcc_assert (type_build_ctor_call (type) || init);
3301           if (CLASS_TYPE_P (type))
3302             elt_init = build_aggr_init (to, init, 0, complain);
3303           else
3304             {
3305               if (TREE_CODE (init) == TREE_LIST)
3306                 init = build_x_compound_expr_from_list (init, ELK_INIT,
3307                                                         complain);
3308               elt_init = build2 (INIT_EXPR, type, to, init);
3309             }
3310         }
3311
3312       if (elt_init == error_mark_node)
3313         errors = true;
3314
3315       current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3316       finish_expr_stmt (elt_init);
3317       current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3318
3319       finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
3320                                            complain));
3321       if (base2)
3322         finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
3323                                              complain));
3324
3325       finish_for_stmt (for_stmt);
3326     }
3327
3328   /* Make sure to cleanup any partially constructed elements.  */
3329   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3330       && from_array != 2)
3331     {
3332       tree e;
3333       tree m = cp_build_binary_op (input_location,
3334                                    MINUS_EXPR, maxindex, iterator,
3335                                    complain);
3336
3337       /* Flatten multi-dimensional array since build_vec_delete only
3338          expects one-dimensional array.  */
3339       if (TREE_CODE (type) == ARRAY_TYPE)
3340         m = cp_build_binary_op (input_location,
3341                                 MULT_EXPR, m,
3342                                 array_type_nelts_total (type),
3343                                 complain);
3344
3345       finish_cleanup_try_block (try_block);
3346       e = build_vec_delete_1 (rval, m,
3347                               inner_elt_type, sfk_complete_destructor,
3348                               /*use_global_delete=*/0, complain);
3349       if (e == error_mark_node)
3350         errors = true;
3351       finish_cleanup (e, try_block);
3352     }
3353
3354   /* The value of the array initialization is the array itself, RVAL
3355      is a pointer to the first element.  */
3356   finish_stmt_expr_expr (rval, stmt_expr);
3357
3358   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
3359
3360   /* Now make the result have the correct type.  */
3361   if (TREE_CODE (atype) == ARRAY_TYPE)
3362     {
3363       atype = build_pointer_type (atype);
3364       stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
3365       stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
3366       TREE_NO_WARNING (stmt_expr) = 1;
3367     }
3368
3369   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
3370
3371   if (const_init)
3372     return build2 (INIT_EXPR, atype, obase, const_init);
3373   if (errors)
3374     return error_mark_node;
3375   return stmt_expr;
3376 }
3377
3378 /* Call the DTOR_KIND destructor for EXP.  FLAGS are as for
3379    build_delete.  */
3380
3381 static tree
3382 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags,
3383                  tsubst_flags_t complain)
3384 {
3385   tree name;
3386   tree fn;
3387   switch (dtor_kind)
3388     {
3389     case sfk_complete_destructor:
3390       name = complete_dtor_identifier;
3391       break;
3392
3393     case sfk_base_destructor:
3394       name = base_dtor_identifier;
3395       break;
3396
3397     case sfk_deleting_destructor:
3398       name = deleting_dtor_identifier;
3399       break;
3400
3401     default:
3402       gcc_unreachable ();
3403     }
3404   fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
3405   return build_new_method_call (exp, fn,
3406                                 /*args=*/NULL,
3407                                 /*conversion_path=*/NULL_TREE,
3408                                 flags,
3409                                 /*fn_p=*/NULL,
3410                                 complain);
3411 }
3412
3413 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3414    ADDR is an expression which yields the store to be destroyed.
3415    AUTO_DELETE is the name of the destructor to call, i.e., either
3416    sfk_complete_destructor, sfk_base_destructor, or
3417    sfk_deleting_destructor.
3418
3419    FLAGS is the logical disjunction of zero or more LOOKUP_
3420    flags.  See cp-tree.h for more info.  */
3421
3422 tree
3423 build_delete (tree type, tree addr, special_function_kind auto_delete,
3424               int flags, int use_global_delete, tsubst_flags_t complain)
3425 {
3426   tree expr;
3427
3428   if (addr == error_mark_node)
3429     return error_mark_node;
3430
3431   /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3432      set to `error_mark_node' before it gets properly cleaned up.  */
3433   if (type == error_mark_node)
3434     return error_mark_node;
3435
3436   type = TYPE_MAIN_VARIANT (type);
3437
3438   addr = mark_rvalue_use (addr);
3439
3440   if (TREE_CODE (type) == POINTER_TYPE)
3441     {
3442       bool complete_p = true;
3443
3444       type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3445       if (TREE_CODE (type) == ARRAY_TYPE)
3446         goto handle_array;
3447
3448       /* We don't want to warn about delete of void*, only other
3449           incomplete types.  Deleting other incomplete types
3450           invokes undefined behavior, but it is not ill-formed, so
3451           compile to something that would even do The Right Thing
3452           (TM) should the type have a trivial dtor and no delete
3453           operator.  */
3454       if (!VOID_TYPE_P (type))
3455         {
3456           complete_type (type);
3457           if (!COMPLETE_TYPE_P (type))
3458             {
3459               if ((complain & tf_warning)
3460                   && warning (0, "possible problem detected in invocation of "
3461                               "delete operator:"))
3462                 {
3463                   cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3464                   inform (input_location, "neither the destructor nor the class-specific "
3465                           "operator delete will be called, even if they are "
3466                           "declared when the class is defined");
3467                 }
3468               complete_p = false;
3469             }
3470           else if (warn_delnonvdtor && MAYBE_CLASS_TYPE_P (type)
3471                    && !CLASSTYPE_FINAL (type) && TYPE_POLYMORPHIC_P (type))
3472             {
3473               tree dtor;
3474               dtor = CLASSTYPE_DESTRUCTORS (type);
3475               if (!dtor || !DECL_VINDEX (dtor))
3476                 {
3477                   if (CLASSTYPE_PURE_VIRTUALS (type))
3478                     warning (OPT_Wdelete_non_virtual_dtor,
3479                              "deleting object of abstract class type %qT"
3480                              " which has non-virtual destructor"
3481                              " will cause undefined behaviour", type);
3482                   else
3483                     warning (OPT_Wdelete_non_virtual_dtor,
3484                              "deleting object of polymorphic class type %qT"
3485                              " which has non-virtual destructor"
3486                              " might cause undefined behaviour", type);
3487                 }
3488             }
3489         }
3490       if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3491         /* Call the builtin operator delete.  */
3492         return build_builtin_delete_call (addr);
3493       if (TREE_SIDE_EFFECTS (addr))
3494         addr = save_expr (addr);
3495
3496       /* Throw away const and volatile on target type of addr.  */
3497       addr = convert_force (build_pointer_type (type), addr, 0);
3498     }
3499   else if (TREE_CODE (type) == ARRAY_TYPE)
3500     {
3501     handle_array:
3502
3503       if (TYPE_DOMAIN (type) == NULL_TREE)
3504         {
3505           if (complain & tf_error)
3506             error ("unknown array size in delete");
3507           return error_mark_node;
3508         }
3509       return build_vec_delete (addr, array_type_nelts (type),
3510                                auto_delete, use_global_delete, complain);
3511     }
3512   else
3513     {
3514       /* Don't check PROTECT here; leave that decision to the
3515          destructor.  If the destructor is accessible, call it,
3516          else report error.  */
3517       addr = cp_build_addr_expr (addr, complain);
3518       if (addr == error_mark_node)
3519         return error_mark_node;
3520       if (TREE_SIDE_EFFECTS (addr))
3521         addr = save_expr (addr);
3522
3523       addr = convert_force (build_pointer_type (type), addr, 0);
3524     }
3525
3526   gcc_assert (MAYBE_CLASS_TYPE_P (type));
3527
3528   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3529     {
3530       if (auto_delete != sfk_deleting_destructor)
3531         return void_zero_node;
3532
3533       return build_op_delete_call (DELETE_EXPR, addr,
3534                                    cxx_sizeof_nowarn (type),
3535                                    use_global_delete,
3536                                    /*placement=*/NULL_TREE,
3537                                    /*alloc_fn=*/NULL_TREE);
3538     }
3539   else
3540     {
3541       tree head = NULL_TREE;
3542       tree do_delete = NULL_TREE;
3543       tree ifexp;
3544
3545       if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3546         lazily_declare_fn (sfk_destructor, type);
3547
3548       /* For `::delete x', we must not use the deleting destructor
3549          since then we would not be sure to get the global `operator
3550          delete'.  */
3551       if (use_global_delete && auto_delete == sfk_deleting_destructor)
3552         {
3553           /* We will use ADDR multiple times so we must save it.  */
3554           addr = save_expr (addr);
3555           head = get_target_expr (build_headof (addr));
3556           /* Delete the object.  */
3557           do_delete = build_builtin_delete_call (head);
3558           /* Otherwise, treat this like a complete object destructor
3559              call.  */
3560           auto_delete = sfk_complete_destructor;
3561         }
3562       /* If the destructor is non-virtual, there is no deleting
3563          variant.  Instead, we must explicitly call the appropriate
3564          `operator delete' here.  */
3565       else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3566                && auto_delete == sfk_deleting_destructor)
3567         {
3568           /* We will use ADDR multiple times so we must save it.  */
3569           addr = save_expr (addr);
3570           /* Build the call.  */
3571           do_delete = build_op_delete_call (DELETE_EXPR,
3572                                             addr,
3573                                             cxx_sizeof_nowarn (type),
3574                                             /*global_p=*/false,
3575                                             /*placement=*/NULL_TREE,
3576                                             /*alloc_fn=*/NULL_TREE);
3577           /* Call the complete object destructor.  */
3578           auto_delete = sfk_complete_destructor;
3579         }
3580       else if (auto_delete == sfk_deleting_destructor
3581                && TYPE_GETS_REG_DELETE (type))
3582         {
3583           /* Make sure we have access to the member op delete, even though
3584              we'll actually be calling it from the destructor.  */
3585           build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3586                                 /*global_p=*/false,
3587                                 /*placement=*/NULL_TREE,
3588                                 /*alloc_fn=*/NULL_TREE);
3589         }
3590
3591       expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL, complain),
3592                               auto_delete, flags, complain);
3593       if (expr == error_mark_node)
3594         return error_mark_node;
3595       if (do_delete)
3596         expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3597
3598       /* We need to calculate this before the dtor changes the vptr.  */
3599       if (head)
3600         expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3601
3602       if (flags & LOOKUP_DESTRUCTOR)
3603         /* Explicit destructor call; don't check for null pointer.  */
3604         ifexp = integer_one_node;
3605       else
3606         {
3607           /* Handle deleting a null pointer.  */
3608           ifexp = fold (cp_build_binary_op (input_location,
3609                                             NE_EXPR, addr, integer_zero_node,
3610                                             complain));
3611           if (ifexp == error_mark_node)
3612             return error_mark_node;
3613         }
3614
3615       if (ifexp != integer_one_node)
3616         expr = build3 (COND_EXPR, void_type_node,
3617                        ifexp, expr, void_zero_node);
3618
3619       return expr;
3620     }
3621 }
3622
3623 /* At the beginning of a destructor, push cleanups that will call the
3624    destructors for our base classes and members.
3625
3626    Called from begin_destructor_body.  */
3627
3628 void
3629 push_base_cleanups (void)
3630 {
3631   tree binfo, base_binfo;
3632   int i;
3633   tree member;
3634   tree expr;
3635   VEC(tree,gc) *vbases;
3636
3637   /* Run destructors for all virtual baseclasses.  */
3638   if (CLASSTYPE_VBASECLASSES (current_class_type))
3639     {
3640       tree cond = (condition_conversion
3641                    (build2 (BIT_AND_EXPR, integer_type_node,
3642                             current_in_charge_parm,
3643                             integer_two_node)));
3644
3645       /* The CLASSTYPE_VBASECLASSES vector is in initialization
3646          order, which is also the right order for pushing cleanups.  */
3647       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3648            VEC_iterate (tree, vbases, i, base_binfo); i++)
3649         {
3650           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3651             {
3652               expr = build_special_member_call (current_class_ref,
3653                                                 base_dtor_identifier,
3654                                                 NULL,
3655                                                 base_binfo,
3656                                                 (LOOKUP_NORMAL
3657                                                  | LOOKUP_NONVIRTUAL),
3658                                                 tf_warning_or_error);
3659               expr = build3 (COND_EXPR, void_type_node, cond,
3660                              expr, void_zero_node);
3661               finish_decl_cleanup (NULL_TREE, expr);
3662             }
3663         }
3664     }
3665
3666   /* Take care of the remaining baseclasses.  */
3667   for (binfo = TYPE_BINFO (current_class_type), i = 0;
3668        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3669     {
3670       if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3671           || BINFO_VIRTUAL_P (base_binfo))
3672         continue;
3673
3674       expr = build_special_member_call (current_class_ref,
3675                                         base_dtor_identifier,
3676                                         NULL, base_binfo,
3677                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3678                                         tf_warning_or_error);
3679       finish_decl_cleanup (NULL_TREE, expr);
3680     }
3681
3682   /* Don't automatically destroy union members.  */
3683   if (TREE_CODE (current_class_type) == UNION_TYPE)
3684     return;
3685
3686   for (member = TYPE_FIELDS (current_class_type); member;
3687        member = DECL_CHAIN (member))
3688     {
3689       tree this_type = TREE_TYPE (member);
3690       if (this_type == error_mark_node
3691           || TREE_CODE (member) != FIELD_DECL
3692           || DECL_ARTIFICIAL (member))
3693         continue;
3694       if (ANON_UNION_TYPE_P (this_type))
3695         continue;
3696       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type))
3697         {
3698           tree this_member = (build_class_member_access_expr
3699                               (current_class_ref, member,
3700                                /*access_path=*/NULL_TREE,
3701                                /*preserve_reference=*/false,
3702                                tf_warning_or_error));
3703           expr = build_delete (this_type, this_member,
3704                                sfk_complete_destructor,
3705                                LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3706                                0, tf_warning_or_error);
3707           finish_decl_cleanup (NULL_TREE, expr);
3708         }
3709     }
3710 }
3711
3712 /* Build a C++ vector delete expression.
3713    MAXINDEX is the number of elements to be deleted.
3714    ELT_SIZE is the nominal size of each element in the vector.
3715    BASE is the expression that should yield the store to be deleted.
3716    This function expands (or synthesizes) these calls itself.
3717    AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3718
3719    This also calls delete for virtual baseclasses of elements of the vector.
3720
3721    Update: MAXINDEX is no longer needed.  The size can be extracted from the
3722    start of the vector for pointers, and from the type for arrays.  We still
3723    use MAXINDEX for arrays because it happens to already have one of the
3724    values we'd have to extract.  (We could use MAXINDEX with pointers to
3725    confirm the size, and trap if the numbers differ; not clear that it'd
3726    be worth bothering.)  */
3727
3728 tree
3729 build_vec_delete (tree base, tree maxindex,
3730                   special_function_kind auto_delete_vec,
3731                   int use_global_delete, tsubst_flags_t complain)
3732 {
3733   tree type;
3734   tree rval;
3735   tree base_init = NULL_TREE;
3736
3737   type = TREE_TYPE (base);
3738
3739   if (TREE_CODE (type) == POINTER_TYPE)
3740     {
3741       /* Step back one from start of vector, and read dimension.  */
3742       tree cookie_addr;
3743       tree size_ptr_type = build_pointer_type (sizetype);
3744
3745       if (TREE_SIDE_EFFECTS (base))
3746         {
3747           base_init = get_target_expr (base);
3748           base = TARGET_EXPR_SLOT (base_init);
3749         }
3750       type = strip_array_types (TREE_TYPE (type));
3751       cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
3752                                  sizetype, TYPE_SIZE_UNIT (sizetype));
3753       cookie_addr = build2 (POINTER_PLUS_EXPR,
3754                             size_ptr_type,
3755                             fold_convert (size_ptr_type, base),
3756                             cookie_addr);
3757       maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, complain);
3758     }
3759   else if (TREE_CODE (type) == ARRAY_TYPE)
3760     {
3761       /* Get the total number of things in the array, maxindex is a
3762          bad name.  */
3763       maxindex = array_type_nelts_total (type);
3764       type = strip_array_types (type);
3765       base = cp_build_addr_expr (base, complain);
3766       if (base == error_mark_node)
3767         return error_mark_node;
3768       if (TREE_SIDE_EFFECTS (base))
3769         {
3770           base_init = get_target_expr (base);
3771           base = TARGET_EXPR_SLOT (base_init);
3772         }
3773     }
3774   else
3775     {
3776       if (base != error_mark_node && !(complain & tf_error))
3777         error ("type to vector delete is neither pointer or array type");
3778       return error_mark_node;
3779     }
3780
3781   rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3782                              use_global_delete, complain);
3783   if (base_init && rval != error_mark_node)
3784     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
3785
3786   return rval;
3787 }