OSDN Git Service

8e3e4895264de7a3b79ad06ceec2f639715a30d7
[pf3gnuchains/gcc-fork.git] / gcc / cp / init.c
1 /* Handle initialization things in C++.
2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
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           if (init)
2122             {
2123               if (complain & tf_error)
2124                 permerror (input_location, "ISO C++ forbids initialization in array new");
2125               else
2126                 return error_mark_node;
2127             }
2128           init_expr
2129             = build_vec_init (data_addr,
2130                               cp_build_binary_op (input_location,
2131                                                   MINUS_EXPR, outer_nelts,
2132                                                   integer_one_node,
2133                                                   complain),
2134                               init,
2135                               explicit_value_init_p,
2136                               /*from_array=*/0,
2137                               complain);
2138
2139           /* An array initialization is stable because the initialization
2140              of each element is a full-expression, so the temporaries don't
2141              leak out.  */
2142           stable = true;
2143         }
2144       else
2145         {
2146           init_expr = cp_build_indirect_ref (data_addr, NULL, complain);
2147
2148           if (TYPE_NEEDS_CONSTRUCTING (type) && !explicit_value_init_p)
2149             {
2150               init_expr = build_special_member_call (init_expr,
2151                                                      complete_ctor_identifier,
2152                                                      init, elt_type,
2153                                                      LOOKUP_NORMAL,
2154                                                      complain);
2155             }
2156           else if (explicit_value_init_p)
2157             {
2158               /* Something like `new int()'.  */
2159               init_expr = build2 (INIT_EXPR, type,
2160                                   init_expr, build_value_init (type));
2161             }
2162           else
2163             {
2164               /* We are processing something like `new int (10)', which
2165                  means allocate an int, and initialize it with 10.  */
2166
2167               if (TREE_CODE (init) == TREE_LIST)
2168                 init = build_x_compound_expr_from_list (init,
2169                                                         "new initializer");
2170               else
2171                 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2172                             || TREE_TYPE (init) != NULL_TREE);
2173
2174               init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, init,
2175                                                 complain);
2176             }
2177           stable = stabilize_init (init_expr, &init_preeval_expr);
2178         }
2179
2180       if (init_expr == error_mark_node)
2181         return error_mark_node;
2182
2183       /* If any part of the object initialization terminates by throwing an
2184          exception and a suitable deallocation function can be found, the
2185          deallocation function is called to free the memory in which the
2186          object was being constructed, after which the exception continues
2187          to propagate in the context of the new-expression. If no
2188          unambiguous matching deallocation function can be found,
2189          propagating the exception does not cause the object's memory to be
2190          freed.  */
2191       if (flag_exceptions && ! use_java_new)
2192         {
2193           enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2194           tree cleanup;
2195
2196           /* The Standard is unclear here, but the right thing to do
2197              is to use the same method for finding deallocation
2198              functions that we use for finding allocation functions.  */
2199           cleanup = (build_op_delete_call
2200                      (dcode,
2201                       alloc_node,
2202                       size,
2203                       globally_qualified_p,
2204                       placement_allocation_fn_p ? alloc_call : NULL_TREE,
2205                       alloc_fn));
2206
2207           if (!cleanup)
2208             /* We're done.  */;
2209           else if (stable)
2210             /* This is much simpler if we were able to preevaluate all of
2211                the arguments to the constructor call.  */
2212             init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2213                                 init_expr, cleanup);
2214           else
2215             /* Ack!  First we allocate the memory.  Then we set our sentry
2216                variable to true, and expand a cleanup that deletes the
2217                memory if sentry is true.  Then we run the constructor, and
2218                finally clear the sentry.
2219
2220                We need to do this because we allocate the space first, so
2221                if there are any temporaries with cleanups in the
2222                constructor args and we weren't able to preevaluate them, we
2223                need this EH region to extend until end of full-expression
2224                to preserve nesting.  */
2225             {
2226               tree end, sentry, begin;
2227
2228               begin = get_target_expr (boolean_true_node);
2229               CLEANUP_EH_ONLY (begin) = 1;
2230
2231               sentry = TARGET_EXPR_SLOT (begin);
2232
2233               TARGET_EXPR_CLEANUP (begin)
2234                 = build3 (COND_EXPR, void_type_node, sentry,
2235                           cleanup, void_zero_node);
2236
2237               end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2238                             sentry, boolean_false_node);
2239
2240               init_expr
2241                 = build2 (COMPOUND_EXPR, void_type_node, begin,
2242                           build2 (COMPOUND_EXPR, void_type_node, init_expr,
2243                                   end));
2244             }
2245
2246         }
2247     }
2248   else
2249     init_expr = NULL_TREE;
2250
2251   /* Now build up the return value in reverse order.  */
2252
2253   rval = data_addr;
2254
2255   if (init_expr)
2256     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2257   if (cookie_expr)
2258     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2259
2260   if (rval == data_addr)
2261     /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2262        and return the call (which doesn't need to be adjusted).  */
2263     rval = TARGET_EXPR_INITIAL (alloc_expr);
2264   else
2265     {
2266       if (check_new)
2267         {
2268           tree ifexp = cp_build_binary_op (input_location,
2269                                            NE_EXPR, alloc_node,
2270                                            integer_zero_node,
2271                                            complain);
2272           rval = build_conditional_expr (ifexp, rval, alloc_node, 
2273                                          complain);
2274         }
2275
2276       /* Perform the allocation before anything else, so that ALLOC_NODE
2277          has been initialized before we start using it.  */
2278       rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2279     }
2280
2281   if (init_preeval_expr)
2282     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2283
2284   /* A new-expression is never an lvalue.  */
2285   gcc_assert (!lvalue_p (rval));
2286
2287   if (placement != NULL)
2288     rval = avoid_placement_new_aliasing (rval, placement_expr);
2289
2290   return rval;
2291 }
2292
2293 /* Generate a representation for a C++ "new" expression.  PLACEMENT is
2294    a TREE_LIST of placement-new arguments (or NULL_TREE if none).  If
2295    NELTS is NULL, TYPE is the type of the storage to be allocated.  If
2296    NELTS is not NULL, then this is an array-new allocation; TYPE is
2297    the type of the elements in the array and NELTS is the number of
2298    elements in the array.  INIT, if non-NULL, is the initializer for
2299    the new object, or void_zero_node to indicate an initializer of
2300    "()".  If USE_GLOBAL_NEW is true, then the user explicitly wrote
2301    "::new" rather than just "new".  */
2302
2303 tree
2304 build_new (tree placement, tree type, tree nelts, tree init,
2305            int use_global_new, tsubst_flags_t complain)
2306 {
2307   tree rval;
2308   tree orig_placement;
2309   tree orig_nelts;
2310   tree orig_init;
2311
2312   if (placement == error_mark_node || type == error_mark_node
2313       || init == error_mark_node)
2314     return error_mark_node;
2315
2316   orig_placement = placement;
2317   orig_nelts = nelts;
2318   orig_init = init;
2319
2320   if (nelts == NULL_TREE && init != void_zero_node && list_length (init) == 1)
2321     {
2322       tree auto_node = type_uses_auto (type);
2323       if (auto_node && describable_type (TREE_VALUE (init)))
2324         type = do_auto_deduction (type, TREE_VALUE (init), auto_node);
2325     }
2326
2327   if (processing_template_decl)
2328     {
2329       if (dependent_type_p (type)
2330           || any_type_dependent_arguments_p (placement)
2331           || (nelts && type_dependent_expression_p (nelts))
2332           || (init != void_zero_node
2333               && any_type_dependent_arguments_p (init)))
2334         return build_raw_new_expr (placement, type, nelts, init,
2335                                    use_global_new);
2336       placement = build_non_dependent_args (placement);
2337       if (nelts)
2338         nelts = build_non_dependent_expr (nelts);
2339       if (init != void_zero_node)
2340         init = build_non_dependent_args (init);
2341     }
2342
2343   if (nelts)
2344     {
2345       if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2346         {
2347           if (complain & tf_error)
2348             permerror (input_location, "size in array new must have integral type");
2349           else
2350             return error_mark_node;
2351         }
2352       nelts = cp_save_expr (cp_convert (sizetype, nelts));
2353     }
2354
2355   /* ``A reference cannot be created by the new operator.  A reference
2356      is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2357      returned by new.'' ARM 5.3.3 */
2358   if (TREE_CODE (type) == REFERENCE_TYPE)
2359     {
2360       if (complain & tf_error)
2361         error ("new cannot be applied to a reference type");
2362       else
2363         return error_mark_node;
2364       type = TREE_TYPE (type);
2365     }
2366
2367   if (TREE_CODE (type) == FUNCTION_TYPE)
2368     {
2369       if (complain & tf_error)
2370         error ("new cannot be applied to a function type");
2371       return error_mark_node;
2372     }
2373
2374   /* The type allocated must be complete.  If the new-type-id was
2375      "T[N]" then we are just checking that "T" is complete here, but
2376      that is equivalent, since the value of "N" doesn't matter.  */
2377   if (!complete_type_or_else (type, NULL_TREE))
2378     return error_mark_node;
2379
2380   rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2381   if (rval == error_mark_node)
2382     return error_mark_node;
2383
2384   if (processing_template_decl)
2385     return build_raw_new_expr (orig_placement, type, orig_nelts, orig_init,
2386                                use_global_new);
2387
2388   /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain.  */
2389   rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2390   TREE_NO_WARNING (rval) = 1;
2391
2392   return rval;
2393 }
2394
2395 /* Given a Java class, return a decl for the corresponding java.lang.Class.  */
2396
2397 tree
2398 build_java_class_ref (tree type)
2399 {
2400   tree name = NULL_TREE, class_decl;
2401   static tree CL_suffix = NULL_TREE;
2402   if (CL_suffix == NULL_TREE)
2403     CL_suffix = get_identifier("class$");
2404   if (jclass_node == NULL_TREE)
2405     {
2406       jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2407       if (jclass_node == NULL_TREE)
2408         {
2409           error ("call to Java constructor, while %<jclass%> undefined");
2410           return error_mark_node;
2411         }
2412       jclass_node = TREE_TYPE (jclass_node);
2413     }
2414
2415   /* Mangle the class$ field.  */
2416   {
2417     tree field;
2418     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2419       if (DECL_NAME (field) == CL_suffix)
2420         {
2421           mangle_decl (field);
2422           name = DECL_ASSEMBLER_NAME (field);
2423           break;
2424         }
2425     if (!field)
2426       {
2427         error ("can't find %<class$%> in %qT", type);
2428         return error_mark_node;
2429       }
2430   }
2431
2432   class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2433   if (class_decl == NULL_TREE)
2434     {
2435       class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
2436       TREE_STATIC (class_decl) = 1;
2437       DECL_EXTERNAL (class_decl) = 1;
2438       TREE_PUBLIC (class_decl) = 1;
2439       DECL_ARTIFICIAL (class_decl) = 1;
2440       DECL_IGNORED_P (class_decl) = 1;
2441       pushdecl_top_level (class_decl);
2442       make_decl_rtl (class_decl);
2443     }
2444   return class_decl;
2445 }
2446 \f
2447 static tree
2448 build_vec_delete_1 (tree base, tree maxindex, tree type,
2449     special_function_kind auto_delete_vec, int use_global_delete)
2450 {
2451   tree virtual_size;
2452   tree ptype = build_pointer_type (type = complete_type (type));
2453   tree size_exp = size_in_bytes (type);
2454
2455   /* Temporary variables used by the loop.  */
2456   tree tbase, tbase_init;
2457
2458   /* This is the body of the loop that implements the deletion of a
2459      single element, and moves temp variables to next elements.  */
2460   tree body;
2461
2462   /* This is the LOOP_EXPR that governs the deletion of the elements.  */
2463   tree loop = 0;
2464
2465   /* This is the thing that governs what to do after the loop has run.  */
2466   tree deallocate_expr = 0;
2467
2468   /* This is the BIND_EXPR which holds the outermost iterator of the
2469      loop.  It is convenient to set this variable up and test it before
2470      executing any other code in the loop.
2471      This is also the containing expression returned by this function.  */
2472   tree controller = NULL_TREE;
2473   tree tmp;
2474
2475   /* We should only have 1-D arrays here.  */
2476   gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2477
2478   if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2479     goto no_destructor;
2480
2481   /* The below is short by the cookie size.  */
2482   virtual_size = size_binop (MULT_EXPR, size_exp,
2483                              convert (sizetype, maxindex));
2484
2485   tbase = create_temporary_var (ptype);
2486   tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2487                                      fold_build2 (POINTER_PLUS_EXPR, ptype,
2488                                                   fold_convert (ptype, base),
2489                                                   virtual_size),
2490                                      tf_warning_or_error);
2491   DECL_REGISTER (tbase) = 1;
2492   controller = build3 (BIND_EXPR, void_type_node, tbase,
2493                        NULL_TREE, NULL_TREE);
2494   TREE_SIDE_EFFECTS (controller) = 1;
2495
2496   body = build1 (EXIT_EXPR, void_type_node,
2497                  build2 (EQ_EXPR, boolean_type_node, tbase,
2498                          fold_convert (ptype, base)));
2499   tmp = fold_build1 (NEGATE_EXPR, sizetype, size_exp);
2500   body = build_compound_expr
2501     (body, cp_build_modify_expr (tbase, NOP_EXPR,
2502                                  build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp),
2503                                  tf_warning_or_error));
2504   body = build_compound_expr
2505     (body, build_delete (ptype, tbase, sfk_complete_destructor,
2506                          LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2507
2508   loop = build1 (LOOP_EXPR, void_type_node, body);
2509   loop = build_compound_expr (tbase_init, loop);
2510
2511  no_destructor:
2512   /* If the delete flag is one, or anything else with the low bit set,
2513      delete the storage.  */
2514   if (auto_delete_vec != sfk_base_destructor)
2515     {
2516       tree base_tbd;
2517
2518       /* The below is short by the cookie size.  */
2519       virtual_size = size_binop (MULT_EXPR, size_exp,
2520                                  convert (sizetype, maxindex));
2521
2522       if (! TYPE_VEC_NEW_USES_COOKIE (type))
2523         /* no header */
2524         base_tbd = base;
2525       else
2526         {
2527           tree cookie_size;
2528
2529           cookie_size = targetm.cxx.get_cookie_size (type);
2530           base_tbd
2531             = cp_convert (ptype,
2532                           cp_build_binary_op (input_location,
2533                                               MINUS_EXPR,
2534                                               cp_convert (string_type_node,
2535                                                           base),
2536                                               cookie_size,
2537                                               tf_warning_or_error));
2538           /* True size with header.  */
2539           virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2540         }
2541
2542       if (auto_delete_vec == sfk_deleting_destructor)
2543         deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2544                                                 base_tbd, virtual_size,
2545                                                 use_global_delete & 1,
2546                                                 /*placement=*/NULL_TREE,
2547                                                 /*alloc_fn=*/NULL_TREE);
2548     }
2549
2550   body = loop;
2551   if (!deallocate_expr)
2552     ;
2553   else if (!body)
2554     body = deallocate_expr;
2555   else
2556     body = build_compound_expr (body, deallocate_expr);
2557
2558   if (!body)
2559     body = integer_zero_node;
2560
2561   /* Outermost wrapper: If pointer is null, punt.  */
2562   body = fold_build3 (COND_EXPR, void_type_node,
2563                       fold_build2 (NE_EXPR, boolean_type_node, base,
2564                                    convert (TREE_TYPE (base),
2565                                             integer_zero_node)),
2566                       body, integer_zero_node);
2567   body = build1 (NOP_EXPR, void_type_node, body);
2568
2569   if (controller)
2570     {
2571       TREE_OPERAND (controller, 1) = body;
2572       body = controller;
2573     }
2574
2575   if (TREE_CODE (base) == SAVE_EXPR)
2576     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
2577     body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2578
2579   return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
2580 }
2581
2582 /* Create an unnamed variable of the indicated TYPE.  */
2583
2584 tree
2585 create_temporary_var (tree type)
2586 {
2587   tree decl;
2588
2589   decl = build_decl (VAR_DECL, NULL_TREE, type);
2590   TREE_USED (decl) = 1;
2591   DECL_ARTIFICIAL (decl) = 1;
2592   DECL_IGNORED_P (decl) = 1;
2593   DECL_SOURCE_LOCATION (decl) = input_location;
2594   DECL_CONTEXT (decl) = current_function_decl;
2595
2596   return decl;
2597 }
2598
2599 /* Create a new temporary variable of the indicated TYPE, initialized
2600    to INIT.
2601
2602    It is not entered into current_binding_level, because that breaks
2603    things when it comes time to do final cleanups (which take place
2604    "outside" the binding contour of the function).  */
2605
2606 static tree
2607 get_temp_regvar (tree type, tree init)
2608 {
2609   tree decl;
2610
2611   decl = create_temporary_var (type);
2612   add_decl_expr (decl);
2613
2614   finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init, 
2615                                           tf_warning_or_error));
2616
2617   return decl;
2618 }
2619
2620 /* `build_vec_init' returns tree structure that performs
2621    initialization of a vector of aggregate types.
2622
2623    BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2624      to the first element, of POINTER_TYPE.
2625    MAXINDEX is the maximum index of the array (one less than the
2626      number of elements).  It is only used if BASE is a pointer or
2627      TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2628
2629    INIT is the (possibly NULL) initializer.
2630
2631    If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL.  All
2632    elements in the array are value-initialized.
2633
2634    FROM_ARRAY is 0 if we should init everything with INIT
2635    (i.e., every element initialized from INIT).
2636    FROM_ARRAY is 1 if we should index into INIT in parallel
2637    with initialization of DECL.
2638    FROM_ARRAY is 2 if we should index into INIT in parallel,
2639    but use assignment instead of initialization.  */
2640
2641 tree
2642 build_vec_init (tree base, tree maxindex, tree init,
2643                 bool explicit_value_init_p,
2644                 int from_array, tsubst_flags_t complain)
2645 {
2646   tree rval;
2647   tree base2 = NULL_TREE;
2648   tree size;
2649   tree itype = NULL_TREE;
2650   tree iterator;
2651   /* The type of BASE.  */
2652   tree atype = TREE_TYPE (base);
2653   /* The type of an element in the array.  */
2654   tree type = TREE_TYPE (atype);
2655   /* The element type reached after removing all outer array
2656      types.  */
2657   tree inner_elt_type;
2658   /* The type of a pointer to an element in the array.  */
2659   tree ptype;
2660   tree stmt_expr;
2661   tree compound_stmt;
2662   int destroy_temps;
2663   tree try_block = NULL_TREE;
2664   int num_initialized_elts = 0;
2665   bool is_global;
2666
2667   if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2668     maxindex = array_type_nelts (atype);
2669
2670   if (maxindex == NULL_TREE || maxindex == error_mark_node)
2671     return error_mark_node;
2672
2673   if (explicit_value_init_p)
2674     gcc_assert (!init);
2675
2676   inner_elt_type = strip_array_types (type);
2677   if (init
2678       && (from_array == 2
2679           ? (!CLASS_TYPE_P (inner_elt_type)
2680              || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2681           : !TYPE_NEEDS_CONSTRUCTING (type))
2682       && ((TREE_CODE (init) == CONSTRUCTOR
2683            /* Don't do this if the CONSTRUCTOR might contain something
2684               that might throw and require us to clean up.  */
2685            && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2686                || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2687           || from_array))
2688     {
2689       /* Do non-default initialization of POD arrays resulting from
2690          brace-enclosed initializers.  In this case, digest_init and
2691          store_constructor will handle the semantics for us.  */
2692
2693       gcc_assert (TREE_CODE (atype) == ARRAY_TYPE);
2694       stmt_expr = build2 (INIT_EXPR, atype, base, init);
2695       return stmt_expr;
2696     }
2697
2698   maxindex = cp_convert (ptrdiff_type_node, maxindex);
2699   size = size_in_bytes (type);
2700   if (TREE_CODE (atype) == ARRAY_TYPE)
2701     {
2702       ptype = build_pointer_type (type);
2703       base = cp_convert (ptype, decay_conversion (base));
2704     }
2705   else
2706     ptype = atype;
2707
2708   /* The code we are generating looks like:
2709      ({
2710        T* t1 = (T*) base;
2711        T* rval = t1;
2712        ptrdiff_t iterator = maxindex;
2713        try {
2714          for (; iterator != -1; --iterator) {
2715            ... initialize *t1 ...
2716            ++t1;
2717          }
2718        } catch (...) {
2719          ... destroy elements that were constructed ...
2720        }
2721        rval;
2722      })
2723
2724      We can omit the try and catch blocks if we know that the
2725      initialization will never throw an exception, or if the array
2726      elements do not have destructors.  We can omit the loop completely if
2727      the elements of the array do not have constructors.
2728
2729      We actually wrap the entire body of the above in a STMT_EXPR, for
2730      tidiness.
2731
2732      When copying from array to another, when the array elements have
2733      only trivial copy constructors, we should use __builtin_memcpy
2734      rather than generating a loop.  That way, we could take advantage
2735      of whatever cleverness the back end has for dealing with copies
2736      of blocks of memory.  */
2737
2738   is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2739   destroy_temps = stmts_are_full_exprs_p ();
2740   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2741   rval = get_temp_regvar (ptype, base);
2742   base = get_temp_regvar (ptype, rval);
2743   iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2744
2745   /* Protect the entire array initialization so that we can destroy
2746      the partially constructed array if an exception is thrown.
2747      But don't do this if we're assigning.  */
2748   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2749       && from_array != 2)
2750     {
2751       try_block = begin_try_block ();
2752     }
2753
2754   if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2755     {
2756       /* Do non-default initialization of non-POD arrays resulting from
2757          brace-enclosed initializers.  */
2758       unsigned HOST_WIDE_INT idx;
2759       tree elt;
2760       from_array = 0;
2761
2762       FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
2763         {
2764           tree baseref = build1 (INDIRECT_REF, type, base);
2765
2766           num_initialized_elts++;
2767
2768           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2769           if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
2770             finish_expr_stmt (build_aggr_init (baseref, elt, 0, complain));
2771           else
2772             finish_expr_stmt (cp_build_modify_expr (baseref, NOP_EXPR,
2773                                                     elt, complain));
2774           current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2775
2776           finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2777                                                complain));
2778           finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2779                                                complain));
2780         }
2781
2782       /* Clear out INIT so that we don't get confused below.  */
2783       init = NULL_TREE;
2784     }
2785   else if (from_array)
2786     {
2787       /* If initializing one array from another, initialize element by
2788          element.  We rely upon the below calls the do argument
2789          checking.  */
2790       if (init)
2791         {
2792           base2 = decay_conversion (init);
2793           itype = TREE_TYPE (base2);
2794           base2 = get_temp_regvar (itype, base2);
2795           itype = TREE_TYPE (itype);
2796         }
2797       else if (TYPE_LANG_SPECIFIC (type)
2798                && TYPE_NEEDS_CONSTRUCTING (type)
2799                && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2800         {
2801           if (complain & tf_error)
2802             error ("initializer ends prematurely");
2803           return error_mark_node;
2804         }
2805     }
2806
2807   /* Now, default-initialize any remaining elements.  We don't need to
2808      do that if a) the type does not need constructing, or b) we've
2809      already initialized all the elements.
2810
2811      We do need to keep going if we're copying an array.  */
2812
2813   if (from_array
2814       || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_value_init_p)
2815           && ! (host_integerp (maxindex, 0)
2816                 && (num_initialized_elts
2817                     == tree_low_cst (maxindex, 0) + 1))))
2818     {
2819       /* If the ITERATOR is equal to -1, then we don't have to loop;
2820          we've already initialized all the elements.  */
2821       tree for_stmt;
2822       tree elt_init;
2823       tree to;
2824
2825       for_stmt = begin_for_stmt ();
2826       finish_for_init_stmt (for_stmt);
2827       finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
2828                                build_int_cst (TREE_TYPE (iterator), -1)),
2829                        for_stmt);
2830       finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2831                                           complain),
2832                        for_stmt);
2833
2834       to = build1 (INDIRECT_REF, type, base);
2835
2836       if (from_array)
2837         {
2838           tree from;
2839
2840           if (base2)
2841             from = build1 (INDIRECT_REF, itype, base2);
2842           else
2843             from = NULL_TREE;
2844
2845           if (from_array == 2)
2846             elt_init = cp_build_modify_expr (to, NOP_EXPR, from, 
2847                                              complain);
2848           else if (TYPE_NEEDS_CONSTRUCTING (type))
2849             elt_init = build_aggr_init (to, from, 0, complain);
2850           else if (from)
2851             elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2852                                              complain);
2853           else
2854             gcc_unreachable ();
2855         }
2856       else if (TREE_CODE (type) == ARRAY_TYPE)
2857         {
2858           if (init != 0)
2859             sorry
2860               ("cannot initialize multi-dimensional array with initializer");
2861           elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2862                                      0, 0,
2863                                      explicit_value_init_p,
2864                                      0, complain);
2865         }
2866       else if (explicit_value_init_p)
2867         elt_init = build2 (INIT_EXPR, type, to,
2868                            build_value_init (type));
2869       else
2870         {
2871           gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
2872           elt_init = build_aggr_init (to, init, 0, complain);
2873         }
2874
2875       current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2876       finish_expr_stmt (elt_init);
2877       current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2878
2879       finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2880                                            complain));
2881       if (base2)
2882         finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
2883                                              complain));
2884
2885       finish_for_stmt (for_stmt);
2886     }
2887
2888   /* Make sure to cleanup any partially constructed elements.  */
2889   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2890       && from_array != 2)
2891     {
2892       tree e;
2893       tree m = cp_build_binary_op (input_location,
2894                                    MINUS_EXPR, maxindex, iterator,
2895                                    complain);
2896
2897       /* Flatten multi-dimensional array since build_vec_delete only
2898          expects one-dimensional array.  */
2899       if (TREE_CODE (type) == ARRAY_TYPE)
2900         m = cp_build_binary_op (input_location,
2901                                 MULT_EXPR, m,
2902                                 array_type_nelts_total (type),
2903                                 complain);
2904
2905       finish_cleanup_try_block (try_block);
2906       e = build_vec_delete_1 (rval, m,
2907                               inner_elt_type, sfk_base_destructor,
2908                               /*use_global_delete=*/0);
2909       finish_cleanup (e, try_block);
2910     }
2911
2912   /* The value of the array initialization is the array itself, RVAL
2913      is a pointer to the first element.  */
2914   finish_stmt_expr_expr (rval, stmt_expr);
2915
2916   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2917
2918   /* Now make the result have the correct type.  */
2919   if (TREE_CODE (atype) == ARRAY_TYPE)
2920     {
2921       atype = build_pointer_type (atype);
2922       stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2923       stmt_expr = cp_build_indirect_ref (stmt_expr, NULL, complain);
2924     }
2925
2926   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2927   return stmt_expr;
2928 }
2929
2930 /* Call the DTOR_KIND destructor for EXP.  FLAGS are as for
2931    build_delete.  */
2932
2933 static tree
2934 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2935 {
2936   tree name;
2937   tree fn;
2938   switch (dtor_kind)
2939     {
2940     case sfk_complete_destructor:
2941       name = complete_dtor_identifier;
2942       break;
2943
2944     case sfk_base_destructor:
2945       name = base_dtor_identifier;
2946       break;
2947
2948     case sfk_deleting_destructor:
2949       name = deleting_dtor_identifier;
2950       break;
2951
2952     default:
2953       gcc_unreachable ();
2954     }
2955   fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2956   return build_new_method_call (exp, fn,
2957                                 /*args=*/NULL_TREE,
2958                                 /*conversion_path=*/NULL_TREE,
2959                                 flags,
2960                                 /*fn_p=*/NULL,
2961                                 tf_warning_or_error);
2962 }
2963
2964 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2965    ADDR is an expression which yields the store to be destroyed.
2966    AUTO_DELETE is the name of the destructor to call, i.e., either
2967    sfk_complete_destructor, sfk_base_destructor, or
2968    sfk_deleting_destructor.
2969
2970    FLAGS is the logical disjunction of zero or more LOOKUP_
2971    flags.  See cp-tree.h for more info.  */
2972
2973 tree
2974 build_delete (tree type, tree addr, special_function_kind auto_delete,
2975     int flags, int use_global_delete)
2976 {
2977   tree expr;
2978
2979   if (addr == error_mark_node)
2980     return error_mark_node;
2981
2982   /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2983      set to `error_mark_node' before it gets properly cleaned up.  */
2984   if (type == error_mark_node)
2985     return error_mark_node;
2986
2987   type = TYPE_MAIN_VARIANT (type);
2988
2989   if (TREE_CODE (type) == POINTER_TYPE)
2990     {
2991       bool complete_p = true;
2992
2993       type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2994       if (TREE_CODE (type) == ARRAY_TYPE)
2995         goto handle_array;
2996
2997       /* We don't want to warn about delete of void*, only other
2998           incomplete types.  Deleting other incomplete types
2999           invokes undefined behavior, but it is not ill-formed, so
3000           compile to something that would even do The Right Thing
3001           (TM) should the type have a trivial dtor and no delete
3002           operator.  */
3003       if (!VOID_TYPE_P (type))
3004         {
3005           complete_type (type);
3006           if (!COMPLETE_TYPE_P (type))
3007             {
3008               if (warning (0, "possible problem detected in invocation of "
3009                            "delete operator:"))
3010                 {
3011                   cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3012                   inform (input_location, "neither the destructor nor the class-specific "
3013                           "operator delete will be called, even if they are "
3014                           "declared when the class is defined.");
3015                 }
3016               complete_p = false;
3017             }
3018         }
3019       if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3020         /* Call the builtin operator delete.  */
3021         return build_builtin_delete_call (addr);
3022       if (TREE_SIDE_EFFECTS (addr))
3023         addr = save_expr (addr);
3024
3025       /* Throw away const and volatile on target type of addr.  */
3026       addr = convert_force (build_pointer_type (type), addr, 0);
3027     }
3028   else if (TREE_CODE (type) == ARRAY_TYPE)
3029     {
3030     handle_array:
3031
3032       if (TYPE_DOMAIN (type) == NULL_TREE)
3033         {
3034           error ("unknown array size in delete");
3035           return error_mark_node;
3036         }
3037       return build_vec_delete (addr, array_type_nelts (type),
3038                                auto_delete, use_global_delete);
3039     }
3040   else
3041     {
3042       /* Don't check PROTECT here; leave that decision to the
3043          destructor.  If the destructor is accessible, call it,
3044          else report error.  */
3045       addr = cp_build_unary_op (ADDR_EXPR, addr, 0, tf_warning_or_error);
3046       if (TREE_SIDE_EFFECTS (addr))
3047         addr = save_expr (addr);
3048
3049       addr = convert_force (build_pointer_type (type), addr, 0);
3050     }
3051
3052   gcc_assert (MAYBE_CLASS_TYPE_P (type));
3053
3054   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3055     {
3056       if (auto_delete != sfk_deleting_destructor)
3057         return void_zero_node;
3058
3059       return build_op_delete_call (DELETE_EXPR, addr,
3060                                    cxx_sizeof_nowarn (type),
3061                                    use_global_delete,
3062                                    /*placement=*/NULL_TREE,
3063                                    /*alloc_fn=*/NULL_TREE);
3064     }
3065   else
3066     {
3067       tree head = NULL_TREE;
3068       tree do_delete = NULL_TREE;
3069       tree ifexp;
3070
3071       if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3072         lazily_declare_fn (sfk_destructor, type);
3073
3074       /* For `::delete x', we must not use the deleting destructor
3075          since then we would not be sure to get the global `operator
3076          delete'.  */
3077       if (use_global_delete && auto_delete == sfk_deleting_destructor)
3078         {
3079           /* We will use ADDR multiple times so we must save it.  */
3080           addr = save_expr (addr);
3081           head = get_target_expr (build_headof (addr));
3082           /* Delete the object.  */
3083           do_delete = build_builtin_delete_call (head);
3084           /* Otherwise, treat this like a complete object destructor
3085              call.  */
3086           auto_delete = sfk_complete_destructor;
3087         }
3088       /* If the destructor is non-virtual, there is no deleting
3089          variant.  Instead, we must explicitly call the appropriate
3090          `operator delete' here.  */
3091       else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3092                && auto_delete == sfk_deleting_destructor)
3093         {
3094           /* We will use ADDR multiple times so we must save it.  */
3095           addr = save_expr (addr);
3096           /* Build the call.  */
3097           do_delete = build_op_delete_call (DELETE_EXPR,
3098                                             addr,
3099                                             cxx_sizeof_nowarn (type),
3100                                             /*global_p=*/false,
3101                                             /*placement=*/NULL_TREE,
3102                                             /*alloc_fn=*/NULL_TREE);
3103           /* Call the complete object destructor.  */
3104           auto_delete = sfk_complete_destructor;
3105         }
3106       else if (auto_delete == sfk_deleting_destructor
3107                && TYPE_GETS_REG_DELETE (type))
3108         {
3109           /* Make sure we have access to the member op delete, even though
3110              we'll actually be calling it from the destructor.  */
3111           build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3112                                 /*global_p=*/false,
3113                                 /*placement=*/NULL_TREE,
3114                                 /*alloc_fn=*/NULL_TREE);
3115         }
3116
3117       expr = build_dtor_call (cp_build_indirect_ref (addr, NULL, 
3118                                                      tf_warning_or_error),
3119                               auto_delete, flags);
3120       if (do_delete)
3121         expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3122
3123       /* We need to calculate this before the dtor changes the vptr.  */
3124       if (head)
3125         expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3126
3127       if (flags & LOOKUP_DESTRUCTOR)
3128         /* Explicit destructor call; don't check for null pointer.  */
3129         ifexp = integer_one_node;
3130       else
3131         /* Handle deleting a null pointer.  */
3132         ifexp = fold (cp_build_binary_op (input_location,
3133                                           NE_EXPR, addr, integer_zero_node,
3134                                           tf_warning_or_error));
3135
3136       if (ifexp != integer_one_node)
3137         expr = build3 (COND_EXPR, void_type_node,
3138                        ifexp, expr, void_zero_node);
3139
3140       return expr;
3141     }
3142 }
3143
3144 /* At the beginning of a destructor, push cleanups that will call the
3145    destructors for our base classes and members.
3146
3147    Called from begin_destructor_body.  */
3148
3149 void
3150 push_base_cleanups (void)
3151 {
3152   tree binfo, base_binfo;
3153   int i;
3154   tree member;
3155   tree expr;
3156   VEC(tree,gc) *vbases;
3157
3158   /* Run destructors for all virtual baseclasses.  */
3159   if (CLASSTYPE_VBASECLASSES (current_class_type))
3160     {
3161       tree cond = (condition_conversion
3162                    (build2 (BIT_AND_EXPR, integer_type_node,
3163                             current_in_charge_parm,
3164                             integer_two_node)));
3165
3166       /* The CLASSTYPE_VBASECLASSES vector is in initialization
3167          order, which is also the right order for pushing cleanups.  */
3168       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3169            VEC_iterate (tree, vbases, i, base_binfo); i++)
3170         {
3171           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3172             {
3173               expr = build_special_member_call (current_class_ref,
3174                                                 base_dtor_identifier,
3175                                                 NULL_TREE,
3176                                                 base_binfo,
3177                                                 (LOOKUP_NORMAL
3178                                                  | LOOKUP_NONVIRTUAL),
3179                                                 tf_warning_or_error);
3180               expr = build3 (COND_EXPR, void_type_node, cond,
3181                              expr, void_zero_node);
3182               finish_decl_cleanup (NULL_TREE, expr);
3183             }
3184         }
3185     }
3186
3187   /* Take care of the remaining baseclasses.  */
3188   for (binfo = TYPE_BINFO (current_class_type), i = 0;
3189        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3190     {
3191       if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3192           || BINFO_VIRTUAL_P (base_binfo))
3193         continue;
3194
3195       expr = build_special_member_call (current_class_ref,
3196                                         base_dtor_identifier,
3197                                         NULL_TREE, base_binfo,
3198                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3199                                         tf_warning_or_error);
3200       finish_decl_cleanup (NULL_TREE, expr);
3201     }
3202
3203   for (member = TYPE_FIELDS (current_class_type); member;
3204        member = TREE_CHAIN (member))
3205     {
3206       if (TREE_TYPE (member) == error_mark_node
3207           || TREE_CODE (member) != FIELD_DECL
3208           || DECL_ARTIFICIAL (member))
3209         continue;
3210       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
3211         {
3212           tree this_member = (build_class_member_access_expr
3213                               (current_class_ref, member,
3214                                /*access_path=*/NULL_TREE,
3215                                /*preserve_reference=*/false,
3216                                tf_warning_or_error));
3217           tree this_type = TREE_TYPE (member);
3218           expr = build_delete (this_type, this_member,
3219                                sfk_complete_destructor,
3220                                LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3221                                0);
3222           finish_decl_cleanup (NULL_TREE, expr);
3223         }
3224     }
3225 }
3226
3227 /* Build a C++ vector delete expression.
3228    MAXINDEX is the number of elements to be deleted.
3229    ELT_SIZE is the nominal size of each element in the vector.
3230    BASE is the expression that should yield the store to be deleted.
3231    This function expands (or synthesizes) these calls itself.
3232    AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3233
3234    This also calls delete for virtual baseclasses of elements of the vector.
3235
3236    Update: MAXINDEX is no longer needed.  The size can be extracted from the
3237    start of the vector for pointers, and from the type for arrays.  We still
3238    use MAXINDEX for arrays because it happens to already have one of the
3239    values we'd have to extract.  (We could use MAXINDEX with pointers to
3240    confirm the size, and trap if the numbers differ; not clear that it'd
3241    be worth bothering.)  */
3242
3243 tree
3244 build_vec_delete (tree base, tree maxindex,
3245     special_function_kind auto_delete_vec, int use_global_delete)
3246 {
3247   tree type;
3248   tree rval;
3249   tree base_init = NULL_TREE;
3250
3251   type = TREE_TYPE (base);
3252
3253   if (TREE_CODE (type) == POINTER_TYPE)
3254     {
3255       /* Step back one from start of vector, and read dimension.  */
3256       tree cookie_addr;
3257       tree size_ptr_type = build_pointer_type (sizetype);
3258
3259       if (TREE_SIDE_EFFECTS (base))
3260         {
3261           base_init = get_target_expr (base);
3262           base = TARGET_EXPR_SLOT (base_init);
3263         }
3264       type = strip_array_types (TREE_TYPE (type));
3265       cookie_addr = fold_build1 (NEGATE_EXPR, sizetype, TYPE_SIZE_UNIT (sizetype));
3266       cookie_addr = build2 (POINTER_PLUS_EXPR,
3267                             size_ptr_type,
3268                             fold_convert (size_ptr_type, base),
3269                             cookie_addr);
3270       maxindex = cp_build_indirect_ref (cookie_addr, NULL, tf_warning_or_error);
3271     }
3272   else if (TREE_CODE (type) == ARRAY_TYPE)
3273     {
3274       /* Get the total number of things in the array, maxindex is a
3275          bad name.  */
3276       maxindex = array_type_nelts_total (type);
3277       type = strip_array_types (type);
3278       base = cp_build_unary_op (ADDR_EXPR, base, 1, tf_warning_or_error);
3279       if (TREE_SIDE_EFFECTS (base))
3280         {
3281           base_init = get_target_expr (base);
3282           base = TARGET_EXPR_SLOT (base_init);
3283         }
3284     }
3285   else
3286     {
3287       if (base != error_mark_node)
3288         error ("type to vector delete is neither pointer or array type");
3289       return error_mark_node;
3290     }
3291
3292   rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3293                              use_global_delete);
3294   if (base_init)
3295     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
3296
3297   return rval;
3298 }