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