OSDN Git Service

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