OSDN Git Service

812042d7f7fde7c732c4176b495969bd853800d9
[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   TREE_USED (vtbl) = 1;
873
874   /* Now compute the address to use when initializing the vptr.  */
875   vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
876   if (TREE_CODE (vtbl) == VAR_DECL)
877     vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
878
879   return vtbl;
880 }
881
882 /* This code sets up the virtual function tables appropriate for
883    the pointer DECL.  It is a one-ply initialization.
884
885    BINFO is the exact type that DECL is supposed to be.  In
886    multiple inheritance, this might mean "C's A" if C : A, B.  */
887
888 static void
889 expand_virtual_init (tree binfo, tree decl)
890 {
891   tree vtbl, vtbl_ptr;
892   tree vtt_index;
893
894   /* Compute the initializer for vptr.  */
895   vtbl = build_vtbl_address (binfo);
896
897   /* We may get this vptr from a VTT, if this is a subobject
898      constructor or subobject destructor.  */
899   vtt_index = BINFO_VPTR_INDEX (binfo);
900   if (vtt_index)
901     {
902       tree vtbl2;
903       tree vtt_parm;
904
905       /* Compute the value to use, when there's a VTT.  */
906       vtt_parm = current_vtt_parm;
907       vtbl2 = build2 (POINTER_PLUS_EXPR,
908                       TREE_TYPE (vtt_parm),
909                       vtt_parm,
910                       vtt_index);
911       vtbl2 = cp_build_indirect_ref (vtbl2, NULL, tf_warning_or_error);
912       vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
913
914       /* The actual initializer is the VTT value only in the subobject
915          constructor.  In maybe_clone_body we'll substitute NULL for
916          the vtt_parm in the case of the non-subobject constructor.  */
917       vtbl = build3 (COND_EXPR,
918                      TREE_TYPE (vtbl),
919                      build2 (EQ_EXPR, boolean_type_node,
920                              current_in_charge_parm, integer_zero_node),
921                      vtbl2,
922                      vtbl);
923     }
924
925   /* Compute the location of the vtpr.  */
926   vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, NULL, 
927                                                       tf_warning_or_error),
928                                TREE_TYPE (binfo));
929   gcc_assert (vtbl_ptr != error_mark_node);
930
931   /* Assign the vtable to the vptr.  */
932   vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
933   finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
934                                           tf_warning_or_error));
935 }
936
937 /* If an exception is thrown in a constructor, those base classes already
938    constructed must be destroyed.  This function creates the cleanup
939    for BINFO, which has just been constructed.  If FLAG is non-NULL,
940    it is a DECL which is nonzero when this base needs to be
941    destroyed.  */
942
943 static void
944 expand_cleanup_for_base (tree binfo, tree flag)
945 {
946   tree expr;
947
948   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
949     return;
950
951   /* Call the destructor.  */
952   expr = build_special_member_call (current_class_ref,
953                                     base_dtor_identifier,
954                                     NULL_TREE,
955                                     binfo,
956                                     LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
957                                     tf_warning_or_error);
958   if (flag)
959     expr = fold_build3 (COND_EXPR, void_type_node,
960                         c_common_truthvalue_conversion (input_location, flag),
961                         expr, integer_zero_node);
962
963   finish_eh_cleanup (expr);
964 }
965
966 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
967    constructor.  */
968
969 static void
970 construct_virtual_base (tree vbase, tree arguments)
971 {
972   tree inner_if_stmt;
973   tree exp;
974   tree flag;
975
976   /* If there are virtual base classes with destructors, we need to
977      emit cleanups to destroy them if an exception is thrown during
978      the construction process.  These exception regions (i.e., the
979      period during which the cleanups must occur) begin from the time
980      the construction is complete to the end of the function.  If we
981      create a conditional block in which to initialize the
982      base-classes, then the cleanup region for the virtual base begins
983      inside a block, and ends outside of that block.  This situation
984      confuses the sjlj exception-handling code.  Therefore, we do not
985      create a single conditional block, but one for each
986      initialization.  (That way the cleanup regions always begin
987      in the outer block.)  We trust the back end to figure out
988      that the FLAG will not change across initializations, and
989      avoid doing multiple tests.  */
990   flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
991   inner_if_stmt = begin_if_stmt ();
992   finish_if_stmt_cond (flag, inner_if_stmt);
993
994   /* Compute the location of the virtual base.  If we're
995      constructing virtual bases, then we must be the most derived
996      class.  Therefore, we don't have to look up the virtual base;
997      we already know where it is.  */
998   exp = convert_to_base_statically (current_class_ref, vbase);
999
1000   expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1001                       LOOKUP_COMPLAIN, tf_warning_or_error);
1002   finish_then_clause (inner_if_stmt);
1003   finish_if_stmt (inner_if_stmt);
1004
1005   expand_cleanup_for_base (vbase, flag);
1006 }
1007
1008 /* Find the context in which this FIELD can be initialized.  */
1009
1010 static tree
1011 initializing_context (tree field)
1012 {
1013   tree t = DECL_CONTEXT (field);
1014
1015   /* Anonymous union members can be initialized in the first enclosing
1016      non-anonymous union context.  */
1017   while (t && ANON_AGGR_TYPE_P (t))
1018     t = TYPE_CONTEXT (t);
1019   return t;
1020 }
1021
1022 /* Function to give error message if member initialization specification
1023    is erroneous.  FIELD is the member we decided to initialize.
1024    TYPE is the type for which the initialization is being performed.
1025    FIELD must be a member of TYPE.
1026
1027    MEMBER_NAME is the name of the member.  */
1028
1029 static int
1030 member_init_ok_or_else (tree field, tree type, tree member_name)
1031 {
1032   if (field == error_mark_node)
1033     return 0;
1034   if (!field)
1035     {
1036       error ("class %qT does not have any field named %qD", type,
1037              member_name);
1038       return 0;
1039     }
1040   if (TREE_CODE (field) == VAR_DECL)
1041     {
1042       error ("%q#D is a static data member; it can only be "
1043              "initialized at its definition",
1044              field);
1045       return 0;
1046     }
1047   if (TREE_CODE (field) != FIELD_DECL)
1048     {
1049       error ("%q#D is not a non-static data member of %qT",
1050              field, type);
1051       return 0;
1052     }
1053   if (initializing_context (field) != type)
1054     {
1055       error ("class %qT does not have any field named %qD", type,
1056                 member_name);
1057       return 0;
1058     }
1059
1060   return 1;
1061 }
1062
1063 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1064    is a _TYPE node or TYPE_DECL which names a base for that type.
1065    Check the validity of NAME, and return either the base _TYPE, base
1066    binfo, or the FIELD_DECL of the member.  If NAME is invalid, return
1067    NULL_TREE and issue a diagnostic.
1068
1069    An old style unnamed direct single base construction is permitted,
1070    where NAME is NULL.  */
1071
1072 tree
1073 expand_member_init (tree name)
1074 {
1075   tree basetype;
1076   tree field;
1077
1078   if (!current_class_ref)
1079     return NULL_TREE;
1080
1081   if (!name)
1082     {
1083       /* This is an obsolete unnamed base class initializer.  The
1084          parser will already have warned about its use.  */
1085       switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1086         {
1087         case 0:
1088           error ("unnamed initializer for %qT, which has no base classes",
1089                  current_class_type);
1090           return NULL_TREE;
1091         case 1:
1092           basetype = BINFO_TYPE
1093             (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1094           break;
1095         default:
1096           error ("unnamed initializer for %qT, which uses multiple inheritance",
1097                  current_class_type);
1098           return NULL_TREE;
1099       }
1100     }
1101   else if (TYPE_P (name))
1102     {
1103       basetype = TYPE_MAIN_VARIANT (name);
1104       name = TYPE_NAME (name);
1105     }
1106   else if (TREE_CODE (name) == TYPE_DECL)
1107     basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1108   else
1109     basetype = NULL_TREE;
1110
1111   if (basetype)
1112     {
1113       tree class_binfo;
1114       tree direct_binfo;
1115       tree virtual_binfo;
1116       int i;
1117
1118       if (current_template_parms)
1119         return basetype;
1120
1121       class_binfo = TYPE_BINFO (current_class_type);
1122       direct_binfo = NULL_TREE;
1123       virtual_binfo = NULL_TREE;
1124
1125       /* Look for a direct base.  */
1126       for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1127         if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1128           break;
1129
1130       /* Look for a virtual base -- unless the direct base is itself
1131          virtual.  */
1132       if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1133         virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1134
1135       /* [class.base.init]
1136
1137          If a mem-initializer-id is ambiguous because it designates
1138          both a direct non-virtual base class and an inherited virtual
1139          base class, the mem-initializer is ill-formed.  */
1140       if (direct_binfo && virtual_binfo)
1141         {
1142           error ("%qD is both a direct base and an indirect virtual base",
1143                  basetype);
1144           return NULL_TREE;
1145         }
1146
1147       if (!direct_binfo && !virtual_binfo)
1148         {
1149           if (CLASSTYPE_VBASECLASSES (current_class_type))
1150             error ("type %qT is not a direct or virtual base of %qT",
1151                    basetype, current_class_type);
1152           else
1153             error ("type %qT is not a direct base of %qT",
1154                    basetype, current_class_type);
1155           return NULL_TREE;
1156         }
1157
1158       return direct_binfo ? direct_binfo : virtual_binfo;
1159     }
1160   else
1161     {
1162       if (TREE_CODE (name) == IDENTIFIER_NODE)
1163         field = lookup_field (current_class_type, name, 1, false);
1164       else
1165         field = name;
1166
1167       if (member_init_ok_or_else (field, current_class_type, name))
1168         return field;
1169     }
1170
1171   return NULL_TREE;
1172 }
1173
1174 /* This is like `expand_member_init', only it stores one aggregate
1175    value into another.
1176
1177    INIT comes in two flavors: it is either a value which
1178    is to be stored in EXP, or it is a parameter list
1179    to go to a constructor, which will operate on EXP.
1180    If INIT is not a parameter list for a constructor, then set
1181    LOOKUP_ONLYCONVERTING.
1182    If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1183    the initializer, if FLAGS is 0, then it is the (init) form.
1184    If `init' is a CONSTRUCTOR, then we emit a warning message,
1185    explaining that such initializations are invalid.
1186
1187    If INIT resolves to a CALL_EXPR which happens to return
1188    something of the type we are looking for, then we know
1189    that we can safely use that call to perform the
1190    initialization.
1191
1192    The virtual function table pointer cannot be set up here, because
1193    we do not really know its type.
1194
1195    This never calls operator=().
1196
1197    When initializing, nothing is CONST.
1198
1199    A default copy constructor may have to be used to perform the
1200    initialization.
1201
1202    A constructor or a conversion operator may have to be used to
1203    perform the initialization, but not both, as it would be ambiguous.  */
1204
1205 tree
1206 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1207 {
1208   tree stmt_expr;
1209   tree compound_stmt;
1210   int destroy_temps;
1211   tree type = TREE_TYPE (exp);
1212   int was_const = TREE_READONLY (exp);
1213   int was_volatile = TREE_THIS_VOLATILE (exp);
1214   int is_global;
1215
1216   if (init == error_mark_node)
1217     return error_mark_node;
1218
1219   TREE_READONLY (exp) = 0;
1220   TREE_THIS_VOLATILE (exp) = 0;
1221
1222   if (init && TREE_CODE (init) != TREE_LIST)
1223     flags |= LOOKUP_ONLYCONVERTING;
1224
1225   if (TREE_CODE (type) == ARRAY_TYPE)
1226     {
1227       tree itype;
1228
1229       /* An array may not be initialized use the parenthesized
1230          initialization form -- unless the initializer is "()".  */
1231       if (init && TREE_CODE (init) == TREE_LIST)
1232         {
1233           if (complain & tf_error)
1234             error ("bad array initializer");
1235           return error_mark_node;
1236         }
1237       /* Must arrange to initialize each element of EXP
1238          from elements of INIT.  */
1239       itype = init ? TREE_TYPE (init) : NULL_TREE;
1240       if (cp_type_quals (type) != TYPE_UNQUALIFIED)
1241         TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1242       if (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
1243         itype = TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1244       stmt_expr = build_vec_init (exp, NULL_TREE, init,
1245                                   /*explicit_value_init_p=*/false,
1246                                   itype && same_type_p (itype,
1247                                                         TREE_TYPE (exp)),
1248                                   complain);
1249       TREE_READONLY (exp) = was_const;
1250       TREE_THIS_VOLATILE (exp) = was_volatile;
1251       TREE_TYPE (exp) = type;
1252       if (init)
1253         TREE_TYPE (init) = itype;
1254       return stmt_expr;
1255     }
1256
1257   if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1258     /* Just know that we've seen something for this node.  */
1259     TREE_USED (exp) = 1;
1260
1261   is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1262   destroy_temps = stmts_are_full_exprs_p ();
1263   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1264   expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1265                       init, LOOKUP_NORMAL|flags, complain);
1266   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1267   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1268   TREE_READONLY (exp) = was_const;
1269   TREE_THIS_VOLATILE (exp) = was_volatile;
1270
1271   return stmt_expr;
1272 }
1273
1274 static void
1275 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1276                      tsubst_flags_t complain)
1277 {
1278   tree type = TREE_TYPE (exp);
1279   tree ctor_name;
1280
1281   /* It fails because there may not be a constructor which takes
1282      its own type as the first (or only parameter), but which does
1283      take other types via a conversion.  So, if the thing initializing
1284      the expression is a unit element of type X, first try X(X&),
1285      followed by initialization by X.  If neither of these work
1286      out, then look hard.  */
1287   tree rval;
1288   tree parms;
1289
1290   if (init && TREE_CODE (init) != TREE_LIST
1291       && (flags & LOOKUP_ONLYCONVERTING))
1292     {
1293       /* Base subobjects should only get direct-initialization.  */
1294       gcc_assert (true_exp == exp);
1295
1296       if (flags & DIRECT_BIND)
1297         /* Do nothing.  We hit this in two cases:  Reference initialization,
1298            where we aren't initializing a real variable, so we don't want
1299            to run a new constructor; and catching an exception, where we
1300            have already built up the constructor call so we could wrap it
1301            in an exception region.  */;
1302       else if (BRACE_ENCLOSED_INITIALIZER_P (init)
1303                && CP_AGGREGATE_TYPE_P (type))
1304         {
1305           /* A brace-enclosed initializer for an aggregate.  */
1306           init = digest_init (type, init);
1307         }
1308       else
1309         init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1310
1311       if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1312         /* We need to protect the initialization of a catch parm with a
1313            call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1314            around the TARGET_EXPR for the copy constructor.  See
1315            initialize_handler_parm.  */
1316         {
1317           TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1318                                            TREE_OPERAND (init, 0));
1319           TREE_TYPE (init) = void_type_node;
1320         }
1321       else
1322         init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1323       TREE_SIDE_EFFECTS (init) = 1;
1324       finish_expr_stmt (init);
1325       return;
1326     }
1327
1328   if (init == NULL_TREE
1329       || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1330     {
1331       parms = init;
1332       if (parms)
1333         init = TREE_VALUE (parms);
1334     }
1335   else
1336     parms = build_tree_list (NULL_TREE, init);
1337
1338   if (true_exp == exp)
1339     ctor_name = complete_ctor_identifier;
1340   else
1341     ctor_name = base_ctor_identifier;
1342
1343   rval = build_special_member_call (exp, ctor_name, parms, binfo, flags,
1344                                     complain);
1345   if (TREE_SIDE_EFFECTS (rval))
1346     finish_expr_stmt (convert_to_void (rval, NULL, complain));
1347 }
1348
1349 /* This function is responsible for initializing EXP with INIT
1350    (if any).
1351
1352    BINFO is the binfo of the type for who we are performing the
1353    initialization.  For example, if W is a virtual base class of A and B,
1354    and C : A, B.
1355    If we are initializing B, then W must contain B's W vtable, whereas
1356    were we initializing C, W must contain C's W vtable.
1357
1358    TRUE_EXP is nonzero if it is the true expression being initialized.
1359    In this case, it may be EXP, or may just contain EXP.  The reason we
1360    need this is because if EXP is a base element of TRUE_EXP, we
1361    don't necessarily know by looking at EXP where its virtual
1362    baseclass fields should really be pointing.  But we do know
1363    from TRUE_EXP.  In constructors, we don't know anything about
1364    the value being initialized.
1365
1366    FLAGS is just passed to `build_new_method_call'.  See that function
1367    for its description.  */
1368
1369 static void
1370 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1371                     tsubst_flags_t complain)
1372 {
1373   tree type = TREE_TYPE (exp);
1374
1375   gcc_assert (init != error_mark_node && type != error_mark_node);
1376   gcc_assert (building_stmt_tree ());
1377
1378   /* Use a function returning the desired type to initialize EXP for us.
1379      If the function is a constructor, and its first argument is
1380      NULL_TREE, know that it was meant for us--just slide exp on
1381      in and expand the constructor.  Constructors now come
1382      as TARGET_EXPRs.  */
1383
1384   if (init && TREE_CODE (exp) == VAR_DECL
1385       && COMPOUND_LITERAL_P (init))
1386     {
1387       /* If store_init_value returns NULL_TREE, the INIT has been
1388          recorded as the DECL_INITIAL for EXP.  That means there's
1389          nothing more we have to do.  */
1390       init = store_init_value (exp, init);
1391       if (init)
1392         finish_expr_stmt (init);
1393       return;
1394     }
1395
1396   /* If an explicit -- but empty -- initializer list was present,
1397      that's value-initialization.  */
1398   if (init == void_type_node)
1399     {
1400       /* If there's a user-provided constructor, we just call that.  */
1401       if (type_has_user_provided_constructor (type))
1402         /* Fall through.  */;
1403       /* If there isn't, but we still need to call the constructor,
1404          zero out the object first.  */
1405       else if (TYPE_NEEDS_CONSTRUCTING (type))
1406         {
1407           init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
1408           init = build2 (INIT_EXPR, type, exp, init);
1409           finish_expr_stmt (init);
1410           /* And then call the constructor.  */
1411         }
1412       /* If we don't need to mess with the constructor at all,
1413          then just zero out the object and we're done.  */
1414       else
1415         {
1416           init = build2 (INIT_EXPR, type, exp, build_value_init_noctor (type));
1417           finish_expr_stmt (init);
1418           return;
1419         }
1420       init = NULL_TREE;
1421     }
1422
1423   /* We know that expand_default_init can handle everything we want
1424      at this point.  */
1425   expand_default_init (binfo, true_exp, exp, init, flags, complain);
1426 }
1427
1428 /* Report an error if TYPE is not a user-defined, class type.  If
1429    OR_ELSE is nonzero, give an error message.  */
1430
1431 int
1432 is_class_type (tree type, int or_else)
1433 {
1434   if (type == error_mark_node)
1435     return 0;
1436
1437   if (! CLASS_TYPE_P (type))
1438     {
1439       if (or_else)
1440         error ("%qT is not a class type", type);
1441       return 0;
1442     }
1443   return 1;
1444 }
1445
1446 tree
1447 get_type_value (tree name)
1448 {
1449   if (name == error_mark_node)
1450     return NULL_TREE;
1451
1452   if (IDENTIFIER_HAS_TYPE_VALUE (name))
1453     return IDENTIFIER_TYPE_VALUE (name);
1454   else
1455     return NULL_TREE;
1456 }
1457
1458 /* Build a reference to a member of an aggregate.  This is not a C++
1459    `&', but really something which can have its address taken, and
1460    then act as a pointer to member, for example TYPE :: FIELD can have
1461    its address taken by saying & TYPE :: FIELD.  ADDRESS_P is true if
1462    this expression is the operand of "&".
1463
1464    @@ Prints out lousy diagnostics for operator <typename>
1465    @@ fields.
1466
1467    @@ This function should be rewritten and placed in search.c.  */
1468
1469 tree
1470 build_offset_ref (tree type, tree member, bool address_p)
1471 {
1472   tree decl;
1473   tree basebinfo = NULL_TREE;
1474
1475   /* class templates can come in as TEMPLATE_DECLs here.  */
1476   if (TREE_CODE (member) == TEMPLATE_DECL)
1477     return member;
1478
1479   if (dependent_type_p (type) || type_dependent_expression_p (member))
1480     return build_qualified_name (NULL_TREE, type, member,
1481                                  /*template_p=*/false);
1482
1483   gcc_assert (TYPE_P (type));
1484   if (! is_class_type (type, 1))
1485     return error_mark_node;
1486
1487   gcc_assert (DECL_P (member) || BASELINK_P (member));
1488   /* Callers should call mark_used before this point.  */
1489   gcc_assert (!DECL_P (member) || TREE_USED (member));
1490
1491   if (!COMPLETE_TYPE_P (complete_type (type))
1492       && !TYPE_BEING_DEFINED (type))
1493     {
1494       error ("incomplete type %qT does not have member %qD", type, member);
1495       return error_mark_node;
1496     }
1497
1498   /* Entities other than non-static members need no further
1499      processing.  */
1500   if (TREE_CODE (member) == TYPE_DECL)
1501     return member;
1502   if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1503     return convert_from_reference (member);
1504
1505   if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1506     {
1507       error ("invalid pointer to bit-field %qD", member);
1508       return error_mark_node;
1509     }
1510
1511   /* Set up BASEBINFO for member lookup.  */
1512   decl = maybe_dummy_object (type, &basebinfo);
1513
1514   /* A lot of this logic is now handled in lookup_member.  */
1515   if (BASELINK_P (member))
1516     {
1517       /* Go from the TREE_BASELINK to the member function info.  */
1518       tree t = BASELINK_FUNCTIONS (member);
1519
1520       if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1521         {
1522           /* Get rid of a potential OVERLOAD around it.  */
1523           t = OVL_CURRENT (t);
1524
1525           /* Unique functions are handled easily.  */
1526
1527           /* For non-static member of base class, we need a special rule
1528              for access checking [class.protected]:
1529
1530                If the access is to form a pointer to member, the
1531                nested-name-specifier shall name the derived class
1532                (or any class derived from that class).  */
1533           if (address_p && DECL_P (t)
1534               && DECL_NONSTATIC_MEMBER_P (t))
1535             perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1536           else
1537             perform_or_defer_access_check (basebinfo, t, t);
1538
1539           if (DECL_STATIC_FUNCTION_P (t))
1540             return t;
1541           member = t;
1542         }
1543       else
1544         TREE_TYPE (member) = unknown_type_node;
1545     }
1546   else if (address_p && TREE_CODE (member) == FIELD_DECL)
1547     /* We need additional test besides the one in
1548        check_accessibility_of_qualified_id in case it is
1549        a pointer to non-static member.  */
1550     perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1551
1552   if (!address_p)
1553     {
1554       /* If MEMBER is non-static, then the program has fallen afoul of
1555          [expr.prim]:
1556
1557            An id-expression that denotes a nonstatic data member or
1558            nonstatic member function of a class can only be used:
1559
1560            -- as part of a class member access (_expr.ref_) in which the
1561            object-expression refers to the member's class or a class
1562            derived from that class, or
1563
1564            -- to form a pointer to member (_expr.unary.op_), or
1565
1566            -- in the body of a nonstatic member function of that class or
1567            of a class derived from that class (_class.mfct.nonstatic_), or
1568
1569            -- in a mem-initializer for a constructor for that class or for
1570            a class derived from that class (_class.base.init_).  */
1571       if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1572         {
1573           /* Build a representation of the qualified name suitable
1574              for use as the operand to "&" -- even though the "&" is
1575              not actually present.  */
1576           member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1577           /* In Microsoft mode, treat a non-static member function as if
1578              it were a pointer-to-member.  */
1579           if (flag_ms_extensions)
1580             {
1581               PTRMEM_OK_P (member) = 1;
1582               return cp_build_unary_op (ADDR_EXPR, member, 0, 
1583                                         tf_warning_or_error);
1584             }
1585           error ("invalid use of non-static member function %qD",
1586                  TREE_OPERAND (member, 1));
1587           return error_mark_node;
1588         }
1589       else if (TREE_CODE (member) == FIELD_DECL)
1590         {
1591           error ("invalid use of non-static data member %qD", member);
1592           return error_mark_node;
1593         }
1594       return member;
1595     }
1596
1597   member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1598   PTRMEM_OK_P (member) = 1;
1599   return member;
1600 }
1601
1602 /* If DECL is a scalar enumeration constant or variable with a
1603    constant initializer, return the initializer (or, its initializers,
1604    recursively); otherwise, return DECL.  If INTEGRAL_P, the
1605    initializer is only returned if DECL is an integral
1606    constant-expression.  */
1607
1608 static tree
1609 constant_value_1 (tree decl, bool integral_p)
1610 {
1611   while (TREE_CODE (decl) == CONST_DECL
1612          || (integral_p
1613              ? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
1614              : (TREE_CODE (decl) == VAR_DECL
1615                 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1616     {
1617       tree init;
1618       /* Static data members in template classes may have
1619          non-dependent initializers.  References to such non-static
1620          data members are not value-dependent, so we must retrieve the
1621          initializer here.  The DECL_INITIAL will have the right type,
1622          but will not have been folded because that would prevent us
1623          from performing all appropriate semantic checks at
1624          instantiation time.  */
1625       if (DECL_CLASS_SCOPE_P (decl)
1626           && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
1627           && uses_template_parms (CLASSTYPE_TI_ARGS
1628                                   (DECL_CONTEXT (decl))))
1629         {
1630           ++processing_template_decl;
1631           init = fold_non_dependent_expr (DECL_INITIAL (decl));
1632           --processing_template_decl;
1633         }
1634       else
1635         {
1636           /* If DECL is a static data member in a template
1637              specialization, we must instantiate it here.  The
1638              initializer for the static data member is not processed
1639              until needed; we need it now.  */
1640           mark_used (decl);
1641           init = DECL_INITIAL (decl);
1642         }
1643       if (init == error_mark_node)
1644         return decl;
1645       /* Initializers in templates are generally expanded during
1646          instantiation, so before that for const int i(2)
1647          INIT is a TREE_LIST with the actual initializer as
1648          TREE_VALUE.  */
1649       if (processing_template_decl
1650           && init
1651           && TREE_CODE (init) == TREE_LIST
1652           && TREE_CHAIN (init) == NULL_TREE)
1653         init = TREE_VALUE (init);
1654       if (!init
1655           || !TREE_TYPE (init)
1656           || (integral_p
1657               ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
1658               : (!TREE_CONSTANT (init)
1659                  /* Do not return an aggregate constant (of which
1660                     string literals are a special case), as we do not
1661                     want to make inadvertent copies of such entities,
1662                     and we must be sure that their addresses are the
1663                     same everywhere.  */
1664                  || TREE_CODE (init) == CONSTRUCTOR
1665                  || TREE_CODE (init) == STRING_CST)))
1666         break;
1667       decl = unshare_expr (init);
1668     }
1669   return decl;
1670 }
1671
1672 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1673    constant of integral or enumeration type, then return that value.
1674    These are those variables permitted in constant expressions by
1675    [5.19/1].  */
1676
1677 tree
1678 integral_constant_value (tree decl)
1679 {
1680   return constant_value_1 (decl, /*integral_p=*/true);
1681 }
1682
1683 /* A more relaxed version of integral_constant_value, used by the
1684    common C/C++ code and by the C++ front end for optimization
1685    purposes.  */
1686
1687 tree
1688 decl_constant_value (tree decl)
1689 {
1690   return constant_value_1 (decl,
1691                            /*integral_p=*/processing_template_decl);
1692 }
1693 \f
1694 /* Common subroutines of build_new and build_vec_delete.  */
1695
1696 /* Call the global __builtin_delete to delete ADDR.  */
1697
1698 static tree
1699 build_builtin_delete_call (tree addr)
1700 {
1701   mark_used (global_delete_fndecl);
1702   return build_call_n (global_delete_fndecl, 1, addr);
1703 }
1704 \f
1705 /* Build and return a NEW_EXPR.  If NELTS is non-NULL, TYPE[NELTS] is
1706    the type of the object being allocated; otherwise, it's just TYPE.
1707    INIT is the initializer, if any.  USE_GLOBAL_NEW is true if the
1708    user explicitly wrote "::operator new".  PLACEMENT, if non-NULL, is
1709    the TREE_LIST of arguments to be provided as arguments to a
1710    placement new operator.  This routine performs no semantic checks;
1711    it just creates and returns a NEW_EXPR.  */
1712
1713 static tree
1714 build_raw_new_expr (tree placement, tree type, tree nelts, tree init,
1715                     int use_global_new)
1716 {
1717   tree new_expr;
1718
1719   new_expr = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
1720                      nelts, init);
1721   NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1722   TREE_SIDE_EFFECTS (new_expr) = 1;
1723
1724   return new_expr;
1725 }
1726
1727 /* Make sure that there are no aliasing issues with T, a placement new
1728    expression applied to PLACEMENT, by recording the change in dynamic
1729    type.  If placement new is inlined, as it is with libstdc++, and if
1730    the type of the placement new differs from the type of the
1731    placement location itself, then alias analysis may think it is OK
1732    to interchange writes to the location from before the placement new
1733    and from after the placement new.  We have to prevent type-based
1734    alias analysis from applying.  PLACEMENT may be NULL, which means
1735    that we couldn't capture it in a temporary variable, in which case
1736    we use a memory clobber.  */
1737
1738 static tree
1739 avoid_placement_new_aliasing (tree t, tree placement)
1740 {
1741   tree type_change;
1742
1743   if (processing_template_decl)
1744     return t;
1745
1746   /* If we are not using type based aliasing, we don't have to do
1747      anything.  */
1748   if (!flag_strict_aliasing)
1749     return t;
1750
1751   /* If we have a pointer and a location, record the change in dynamic
1752      type.  Otherwise we need a general memory clobber.  */
1753   if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
1754       && placement != NULL_TREE
1755       && TREE_CODE (TREE_TYPE (placement)) == POINTER_TYPE)
1756     type_change = build_stmt (CHANGE_DYNAMIC_TYPE_EXPR,
1757                               TREE_TYPE (t),
1758                               placement);
1759   else
1760     {
1761       /* Build a memory clobber.  */
1762       type_change = build_stmt (ASM_EXPR,
1763                                 build_string (0, ""),
1764                                 NULL_TREE,
1765                                 NULL_TREE,
1766                                 tree_cons (NULL_TREE,
1767                                            build_string (6, "memory"),
1768                                            NULL_TREE));
1769
1770       ASM_VOLATILE_P (type_change) = 1;
1771     }
1772
1773   return build2 (COMPOUND_EXPR, TREE_TYPE (t), type_change, t);
1774 }
1775
1776 /* Generate code for a new-expression, including calling the "operator
1777    new" function, initializing the object, and, if an exception occurs
1778    during construction, cleaning up.  The arguments are as for
1779    build_raw_new_expr.  */
1780
1781 static tree
1782 build_new_1 (tree placement, tree type, tree nelts, tree init,
1783              bool globally_qualified_p, tsubst_flags_t complain)
1784 {
1785   tree size, rval;
1786   /* True iff this is a call to "operator new[]" instead of just
1787      "operator new".  */
1788   bool array_p = false;
1789   /* If ARRAY_P is true, the element type of the array.  This is never
1790      an ARRAY_TYPE; for something like "new int[3][4]", the
1791      ELT_TYPE is "int".  If ARRAY_P is false, this is the same type as
1792      TYPE.  */
1793   tree elt_type;
1794   /* The type of the new-expression.  (This type is always a pointer
1795      type.)  */
1796   tree pointer_type;
1797   tree outer_nelts = NULL_TREE;
1798   tree alloc_call, alloc_expr;
1799   /* The address returned by the call to "operator new".  This node is
1800      a VAR_DECL and is therefore reusable.  */
1801   tree alloc_node;
1802   tree alloc_fn;
1803   tree cookie_expr, init_expr;
1804   int nothrow, check_new;
1805   int use_java_new = 0;
1806   /* If non-NULL, the number of extra bytes to allocate at the
1807      beginning of the storage allocated for an array-new expression in
1808      order to store the number of elements.  */
1809   tree cookie_size = NULL_TREE;
1810   tree placement_expr = NULL_TREE;
1811   /* True if the function we are calling is a placement allocation
1812      function.  */
1813   bool placement_allocation_fn_p;
1814   tree args = NULL_TREE;
1815   /* True if the storage must be initialized, either by a constructor
1816      or due to an explicit new-initializer.  */
1817   bool is_initialized;
1818   /* The address of the thing allocated, not including any cookie.  In
1819      particular, if an array cookie is in use, DATA_ADDR is the
1820      address of the first array element.  This node is a VAR_DECL, and
1821      is therefore reusable.  */
1822   tree data_addr;
1823   tree init_preeval_expr = NULL_TREE;
1824
1825   if (nelts)
1826     {
1827       outer_nelts = nelts;
1828       array_p = true;
1829     }
1830   else if (TREE_CODE (type) == ARRAY_TYPE)
1831     {
1832       array_p = true;
1833       nelts = array_type_nelts_top (type);
1834       outer_nelts = nelts;
1835       type = TREE_TYPE (type);
1836     }
1837
1838   /* If our base type is an array, then make sure we know how many elements
1839      it has.  */
1840   for (elt_type = type;
1841        TREE_CODE (elt_type) == ARRAY_TYPE;
1842        elt_type = TREE_TYPE (elt_type))
1843     nelts = cp_build_binary_op (input_location,
1844                                 MULT_EXPR, nelts,
1845                                 array_type_nelts_top (elt_type),
1846                                 complain);
1847
1848   if (TREE_CODE (elt_type) == VOID_TYPE)
1849     {
1850       if (complain & tf_error)
1851         error ("invalid type %<void%> for new");
1852       return error_mark_node;
1853     }
1854
1855   if (abstract_virtuals_error (NULL_TREE, elt_type))
1856     return error_mark_node;
1857
1858   is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || init);
1859
1860   if (CP_TYPE_CONST_P (elt_type) && !init
1861       && !type_has_user_provided_default_constructor (elt_type))
1862     {
1863       if (complain & tf_error)
1864         error ("uninitialized const in %<new%> of %q#T", elt_type);
1865       return error_mark_node;
1866     }
1867
1868   size = size_in_bytes (elt_type);
1869   if (array_p)
1870     size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1871
1872   alloc_fn = NULL_TREE;
1873
1874   /* Allocate the object.  */
1875   if (! placement && TYPE_FOR_JAVA (elt_type))
1876     {
1877       tree class_addr;
1878       tree class_decl = build_java_class_ref (elt_type);
1879       static const char alloc_name[] = "_Jv_AllocObject";
1880
1881       if (class_decl == error_mark_node)
1882         return error_mark_node;
1883
1884       use_java_new = 1;
1885       if (!get_global_value_if_present (get_identifier (alloc_name),
1886                                         &alloc_fn))
1887         {
1888           if (complain & tf_error)
1889             error ("call to Java constructor with %qs undefined", alloc_name);
1890           return error_mark_node;
1891         }
1892       else if (really_overloaded_fn (alloc_fn))
1893         {
1894           if (complain & tf_error)
1895             error ("%qD should never be overloaded", alloc_fn);
1896           return error_mark_node;
1897         }
1898       alloc_fn = OVL_CURRENT (alloc_fn);
1899       class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1900       alloc_call = (cp_build_function_call
1901                     (alloc_fn,
1902                      build_tree_list (NULL_TREE, class_addr),
1903                      complain));
1904     }
1905   else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
1906     {
1907       error ("Java class %q#T object allocated using placement new", elt_type);
1908       return error_mark_node;
1909     }
1910   else
1911     {
1912       tree fnname;
1913       tree fns;
1914
1915       fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
1916
1917       if (!globally_qualified_p
1918           && CLASS_TYPE_P (elt_type)
1919           && (array_p
1920               ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
1921               : TYPE_HAS_NEW_OPERATOR (elt_type)))
1922         {
1923           /* Use a class-specific operator new.  */
1924           /* If a cookie is required, add some extra space.  */
1925           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1926             {
1927               cookie_size = targetm.cxx.get_cookie_size (elt_type);
1928               size = size_binop (PLUS_EXPR, size, cookie_size);
1929             }
1930           /* Create the argument list.  */
1931           args = tree_cons (NULL_TREE, size, placement);
1932           /* Do name-lookup to find the appropriate operator.  */
1933           fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
1934           if (fns == NULL_TREE)
1935             {
1936               if (complain & tf_error)
1937                 error ("no suitable %qD found in class %qT", fnname, elt_type);
1938               return error_mark_node;
1939             }
1940           if (TREE_CODE (fns) == TREE_LIST)
1941             {
1942               if (complain & tf_error)
1943                 {
1944                   error ("request for member %qD is ambiguous", fnname);
1945                   print_candidates (fns);
1946                 }
1947               return error_mark_node;
1948             }
1949           alloc_call = build_new_method_call (build_dummy_object (elt_type),
1950                                               fns, args,
1951                                               /*conversion_path=*/NULL_TREE,
1952                                               LOOKUP_NORMAL,
1953                                               &alloc_fn,
1954                                               complain);
1955         }
1956       else
1957         {
1958           /* Use a global operator new.  */
1959           /* See if a cookie might be required.  */
1960           if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1961             cookie_size = targetm.cxx.get_cookie_size (elt_type);
1962           else
1963             cookie_size = NULL_TREE;
1964
1965           alloc_call = build_operator_new_call (fnname, placement,
1966                                                 &size, &cookie_size,
1967                                                 &alloc_fn);
1968         }
1969     }
1970
1971   if (alloc_call == error_mark_node)
1972     return error_mark_node;
1973
1974   gcc_assert (alloc_fn != NULL_TREE);
1975
1976   /* If PLACEMENT is a simple pointer type and is not passed by reference,
1977      then copy it into PLACEMENT_EXPR.  */
1978   if (!processing_template_decl
1979       && placement != NULL_TREE
1980       && TREE_CHAIN (placement) == NULL_TREE
1981       && TREE_CODE (TREE_TYPE (TREE_VALUE (placement))) == POINTER_TYPE
1982       && TREE_CODE (alloc_call) == CALL_EXPR
1983       && call_expr_nargs (alloc_call) == 2
1984       && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
1985       && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
1986     {
1987       tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
1988
1989       if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
1990           || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
1991         {
1992           placement_expr = get_target_expr (TREE_VALUE (placement));
1993           CALL_EXPR_ARG (alloc_call, 1)
1994             = convert (TREE_TYPE (placement_arg), placement_expr);
1995         }
1996     }
1997
1998   /* In the simple case, we can stop now.  */
1999   pointer_type = build_pointer_type (type);
2000   if (!cookie_size && !is_initialized)
2001     {
2002       rval = build_nop (pointer_type, alloc_call);
2003       if (placement != NULL)
2004         rval = avoid_placement_new_aliasing (rval, placement_expr);
2005       return rval;
2006     }
2007
2008   /* Store the result of the allocation call in a variable so that we can
2009      use it more than once.  */
2010   alloc_expr = get_target_expr (alloc_call);
2011   alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2012
2013   /* Strip any COMPOUND_EXPRs from ALLOC_CALL.  */
2014   while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2015     alloc_call = TREE_OPERAND (alloc_call, 1);
2016
2017   /* Now, check to see if this function is actually a placement
2018      allocation function.  This can happen even when PLACEMENT is NULL
2019      because we might have something like:
2020
2021        struct S { void* operator new (size_t, int i = 0); };
2022
2023      A call to `new S' will get this allocation function, even though
2024      there is no explicit placement argument.  If there is more than
2025      one argument, or there are variable arguments, then this is a
2026      placement allocation function.  */
2027   placement_allocation_fn_p
2028     = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2029        || varargs_function_p (alloc_fn));
2030
2031   /* Preevaluate the placement args so that we don't reevaluate them for a
2032      placement delete.  */
2033   if (placement_allocation_fn_p)
2034     {
2035       tree inits;
2036       stabilize_call (alloc_call, &inits);
2037       if (inits)
2038         alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2039                              alloc_expr);
2040     }
2041
2042   /*        unless an allocation function is declared with an empty  excep-
2043      tion-specification  (_except.spec_),  throw(), it indicates failure to
2044      allocate storage by throwing a bad_alloc exception  (clause  _except_,
2045      _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2046      cation function is declared  with  an  empty  exception-specification,
2047      throw(), it returns null to indicate failure to allocate storage and a
2048      non-null pointer otherwise.
2049
2050      So check for a null exception spec on the op new we just called.  */
2051
2052   nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2053   check_new = (flag_check_new || nothrow) && ! use_java_new;
2054
2055   if (cookie_size)
2056     {
2057       tree cookie;
2058       tree cookie_ptr;
2059       tree size_ptr_type;
2060
2061       /* Adjust so we're pointing to the start of the object.  */
2062       data_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2063                           alloc_node, cookie_size);
2064
2065       /* Store the number of bytes allocated so that we can know how
2066          many elements to destroy later.  We use the last sizeof
2067          (size_t) bytes to store the number of elements.  */
2068       cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2069       cookie_ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2070                                 alloc_node, cookie_ptr);
2071       size_ptr_type = build_pointer_type (sizetype);
2072       cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2073       cookie = cp_build_indirect_ref (cookie_ptr, NULL, complain);
2074
2075       cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2076
2077       if (targetm.cxx.cookie_has_size ())
2078         {
2079           /* Also store the element size.  */
2080           cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
2081                                fold_build1 (NEGATE_EXPR, sizetype,
2082                                             size_in_bytes (sizetype)));
2083
2084           cookie = cp_build_indirect_ref (cookie_ptr, NULL, complain);
2085           cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2086                            size_in_bytes (elt_type));
2087           cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2088                                 cookie, cookie_expr);
2089         }
2090     }
2091   else
2092     {
2093       cookie_expr = NULL_TREE;
2094       data_addr = alloc_node;
2095     }
2096
2097   /* Now use a pointer to the type we've actually allocated.  */
2098   data_addr = fold_convert (pointer_type, data_addr);
2099   /* Any further uses of alloc_node will want this type, too.  */
2100   alloc_node = fold_convert (pointer_type, alloc_node);
2101
2102   /* Now initialize the allocated object.  Note that we preevaluate the
2103      initialization expression, apart from the actual constructor call or
2104      assignment--we do this because we want to delay the allocation as long
2105      as possible in order to minimize the size of the exception region for
2106      placement delete.  */
2107   if (is_initialized)
2108     {
2109       bool stable;
2110       bool explicit_value_init_p = false;
2111
2112       if (init == void_zero_node)
2113         {
2114           init = NULL_TREE;
2115           explicit_value_init_p = true;
2116         }
2117
2118       if (array_p)
2119         {
2120           if (init)
2121             {
2122               if (complain & tf_error)
2123                 permerror (input_location, "ISO C++ forbids initialization in array new");
2124               else
2125                 return error_mark_node;
2126             }
2127           init_expr
2128             = build_vec_init (data_addr,
2129                               cp_build_binary_op (input_location,
2130                                                   MINUS_EXPR, outer_nelts,
2131                                                   integer_one_node,
2132                                                   complain),
2133                               init,
2134                               explicit_value_init_p,
2135                               /*from_array=*/0,
2136                               complain);
2137
2138           /* An array initialization is stable because the initialization
2139              of each element is a full-expression, so the temporaries don't
2140              leak out.  */
2141           stable = true;
2142         }
2143       else
2144         {
2145           init_expr = cp_build_indirect_ref (data_addr, NULL, complain);
2146
2147           if (TYPE_NEEDS_CONSTRUCTING (type) && !explicit_value_init_p)
2148             {
2149               init_expr = build_special_member_call (init_expr,
2150                                                      complete_ctor_identifier,
2151                                                      init, elt_type,
2152                                                      LOOKUP_NORMAL,
2153                                                      complain);
2154             }
2155           else if (explicit_value_init_p)
2156             {
2157               /* Something like `new int()'.  */
2158               init_expr = build2 (INIT_EXPR, type,
2159                                   init_expr, build_value_init (type));
2160             }
2161           else
2162             {
2163               /* We are processing something like `new int (10)', which
2164                  means allocate an int, and initialize it with 10.  */
2165
2166               if (TREE_CODE (init) == TREE_LIST)
2167                 init = build_x_compound_expr_from_list (init,
2168                                                         "new initializer");
2169               else
2170                 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2171                             || TREE_TYPE (init) != NULL_TREE);
2172
2173               init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, init,
2174                                                 complain);
2175             }
2176           stable = stabilize_init (init_expr, &init_preeval_expr);
2177         }
2178
2179       if (init_expr == error_mark_node)
2180         return error_mark_node;
2181
2182       /* If any part of the object initialization terminates by throwing an
2183          exception and a suitable deallocation function can be found, the
2184          deallocation function is called to free the memory in which the
2185          object was being constructed, after which the exception continues
2186          to propagate in the context of the new-expression. If no
2187          unambiguous matching deallocation function can be found,
2188          propagating the exception does not cause the object's memory to be
2189          freed.  */
2190       if (flag_exceptions && ! use_java_new)
2191         {
2192           enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2193           tree cleanup;
2194
2195           /* The Standard is unclear here, but the right thing to do
2196              is to use the same method for finding deallocation
2197              functions that we use for finding allocation functions.  */
2198           cleanup = (build_op_delete_call
2199                      (dcode,
2200                       alloc_node,
2201                       size,
2202                       globally_qualified_p,
2203                       placement_allocation_fn_p ? alloc_call : NULL_TREE,
2204                       alloc_fn));
2205
2206           if (!cleanup)
2207             /* We're done.  */;
2208           else if (stable)
2209             /* This is much simpler if we were able to preevaluate all of
2210                the arguments to the constructor call.  */
2211             init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2212                                 init_expr, cleanup);
2213           else
2214             /* Ack!  First we allocate the memory.  Then we set our sentry
2215                variable to true, and expand a cleanup that deletes the
2216                memory if sentry is true.  Then we run the constructor, and
2217                finally clear the sentry.
2218
2219                We need to do this because we allocate the space first, so
2220                if there are any temporaries with cleanups in the
2221                constructor args and we weren't able to preevaluate them, we
2222                need this EH region to extend until end of full-expression
2223                to preserve nesting.  */
2224             {
2225               tree end, sentry, begin;
2226
2227               begin = get_target_expr (boolean_true_node);
2228               CLEANUP_EH_ONLY (begin) = 1;
2229
2230               sentry = TARGET_EXPR_SLOT (begin);
2231
2232               TARGET_EXPR_CLEANUP (begin)
2233                 = build3 (COND_EXPR, void_type_node, sentry,
2234                           cleanup, void_zero_node);
2235
2236               end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2237                             sentry, boolean_false_node);
2238
2239               init_expr
2240                 = build2 (COMPOUND_EXPR, void_type_node, begin,
2241                           build2 (COMPOUND_EXPR, void_type_node, init_expr,
2242                                   end));
2243             }
2244
2245         }
2246     }
2247   else
2248     init_expr = NULL_TREE;
2249
2250   /* Now build up the return value in reverse order.  */
2251
2252   rval = data_addr;
2253
2254   if (init_expr)
2255     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2256   if (cookie_expr)
2257     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2258
2259   if (rval == data_addr)
2260     /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2261        and return the call (which doesn't need to be adjusted).  */
2262     rval = TARGET_EXPR_INITIAL (alloc_expr);
2263   else
2264     {
2265       if (check_new)
2266         {
2267           tree ifexp = cp_build_binary_op (input_location,
2268                                            NE_EXPR, alloc_node,
2269                                            integer_zero_node,
2270                                            complain);
2271           rval = build_conditional_expr (ifexp, rval, alloc_node, 
2272                                          complain);
2273         }
2274
2275       /* Perform the allocation before anything else, so that ALLOC_NODE
2276          has been initialized before we start using it.  */
2277       rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2278     }
2279
2280   if (init_preeval_expr)
2281     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2282
2283   /* A new-expression is never an lvalue.  */
2284   gcc_assert (!lvalue_p (rval));
2285
2286   if (placement != NULL)
2287     rval = avoid_placement_new_aliasing (rval, placement_expr);
2288
2289   return rval;
2290 }
2291
2292 /* Generate a representation for a C++ "new" expression.  PLACEMENT is
2293    a TREE_LIST of placement-new arguments (or NULL_TREE if none).  If
2294    NELTS is NULL, TYPE is the type of the storage to be allocated.  If
2295    NELTS is not NULL, then this is an array-new allocation; TYPE is
2296    the type of the elements in the array and NELTS is the number of
2297    elements in the array.  INIT, if non-NULL, is the initializer for
2298    the new object, or void_zero_node to indicate an initializer of
2299    "()".  If USE_GLOBAL_NEW is true, then the user explicitly wrote
2300    "::new" rather than just "new".  */
2301
2302 tree
2303 build_new (tree placement, tree type, tree nelts, tree init,
2304            int use_global_new, tsubst_flags_t complain)
2305 {
2306   tree rval;
2307   tree orig_placement;
2308   tree orig_nelts;
2309   tree orig_init;
2310
2311   if (placement == error_mark_node || type == error_mark_node
2312       || init == error_mark_node)
2313     return error_mark_node;
2314
2315   orig_placement = placement;
2316   orig_nelts = nelts;
2317   orig_init = init;
2318
2319   if (nelts == NULL_TREE && init != void_zero_node && list_length (init) == 1)
2320     {
2321       tree auto_node = type_uses_auto (type);
2322       if (auto_node && describable_type (TREE_VALUE (init)))
2323         type = do_auto_deduction (type, TREE_VALUE (init), auto_node);
2324     }
2325
2326   if (processing_template_decl)
2327     {
2328       if (dependent_type_p (type)
2329           || any_type_dependent_arguments_p (placement)
2330           || (nelts && type_dependent_expression_p (nelts))
2331           || (init != void_zero_node
2332               && any_type_dependent_arguments_p (init)))
2333         return build_raw_new_expr (placement, type, nelts, init,
2334                                    use_global_new);
2335       placement = build_non_dependent_args (placement);
2336       if (nelts)
2337         nelts = build_non_dependent_expr (nelts);
2338       if (init != void_zero_node)
2339         init = build_non_dependent_args (init);
2340     }
2341
2342   if (nelts)
2343     {
2344       if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2345         {
2346           if (complain & tf_error)
2347             permerror (input_location, "size in array new must have integral type");
2348           else
2349             return error_mark_node;
2350         }
2351       nelts = cp_save_expr (cp_convert (sizetype, nelts));
2352     }
2353
2354   /* ``A reference cannot be created by the new operator.  A reference
2355      is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2356      returned by new.'' ARM 5.3.3 */
2357   if (TREE_CODE (type) == REFERENCE_TYPE)
2358     {
2359       if (complain & tf_error)
2360         error ("new cannot be applied to a reference type");
2361       else
2362         return error_mark_node;
2363       type = TREE_TYPE (type);
2364     }
2365
2366   if (TREE_CODE (type) == FUNCTION_TYPE)
2367     {
2368       if (complain & tf_error)
2369         error ("new cannot be applied to a function type");
2370       return error_mark_node;
2371     }
2372
2373   /* The type allocated must be complete.  If the new-type-id was
2374      "T[N]" then we are just checking that "T" is complete here, but
2375      that is equivalent, since the value of "N" doesn't matter.  */
2376   if (!complete_type_or_else (type, NULL_TREE))
2377     return error_mark_node;
2378
2379   rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2380   if (rval == error_mark_node)
2381     return error_mark_node;
2382
2383   if (processing_template_decl)
2384     return build_raw_new_expr (orig_placement, type, orig_nelts, orig_init,
2385                                use_global_new);
2386
2387   /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain.  */
2388   rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2389   TREE_NO_WARNING (rval) = 1;
2390
2391   return rval;
2392 }
2393
2394 /* Given a Java class, return a decl for the corresponding java.lang.Class.  */
2395
2396 tree
2397 build_java_class_ref (tree type)
2398 {
2399   tree name = NULL_TREE, class_decl;
2400   static tree CL_suffix = NULL_TREE;
2401   if (CL_suffix == NULL_TREE)
2402     CL_suffix = get_identifier("class$");
2403   if (jclass_node == NULL_TREE)
2404     {
2405       jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2406       if (jclass_node == NULL_TREE)
2407         {
2408           error ("call to Java constructor, while %<jclass%> undefined");
2409           return error_mark_node;
2410         }
2411       jclass_node = TREE_TYPE (jclass_node);
2412     }
2413
2414   /* Mangle the class$ field.  */
2415   {
2416     tree field;
2417     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2418       if (DECL_NAME (field) == CL_suffix)
2419         {
2420           mangle_decl (field);
2421           name = DECL_ASSEMBLER_NAME (field);
2422           break;
2423         }
2424     if (!field)
2425       {
2426         error ("can't find %<class$%> in %qT", type);
2427         return error_mark_node;
2428       }
2429   }
2430
2431   class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2432   if (class_decl == NULL_TREE)
2433     {
2434       class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
2435       TREE_STATIC (class_decl) = 1;
2436       DECL_EXTERNAL (class_decl) = 1;
2437       TREE_PUBLIC (class_decl) = 1;
2438       DECL_ARTIFICIAL (class_decl) = 1;
2439       DECL_IGNORED_P (class_decl) = 1;
2440       pushdecl_top_level (class_decl);
2441       make_decl_rtl (class_decl);
2442     }
2443   return class_decl;
2444 }
2445 \f
2446 static tree
2447 build_vec_delete_1 (tree base, tree maxindex, tree type,
2448     special_function_kind auto_delete_vec, int use_global_delete)
2449 {
2450   tree virtual_size;
2451   tree ptype = build_pointer_type (type = complete_type (type));
2452   tree size_exp = size_in_bytes (type);
2453
2454   /* Temporary variables used by the loop.  */
2455   tree tbase, tbase_init;
2456
2457   /* This is the body of the loop that implements the deletion of a
2458      single element, and moves temp variables to next elements.  */
2459   tree body;
2460
2461   /* This is the LOOP_EXPR that governs the deletion of the elements.  */
2462   tree loop = 0;
2463
2464   /* This is the thing that governs what to do after the loop has run.  */
2465   tree deallocate_expr = 0;
2466
2467   /* This is the BIND_EXPR which holds the outermost iterator of the
2468      loop.  It is convenient to set this variable up and test it before
2469      executing any other code in the loop.
2470      This is also the containing expression returned by this function.  */
2471   tree controller = NULL_TREE;
2472   tree tmp;
2473
2474   /* We should only have 1-D arrays here.  */
2475   gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2476
2477   if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2478     goto no_destructor;
2479
2480   /* The below is short by the cookie size.  */
2481   virtual_size = size_binop (MULT_EXPR, size_exp,
2482                              convert (sizetype, maxindex));
2483
2484   tbase = create_temporary_var (ptype);
2485   tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2486                                      fold_build2 (POINTER_PLUS_EXPR, ptype,
2487                                                   fold_convert (ptype, base),
2488                                                   virtual_size),
2489                                      tf_warning_or_error);
2490   DECL_REGISTER (tbase) = 1;
2491   controller = build3 (BIND_EXPR, void_type_node, tbase,
2492                        NULL_TREE, NULL_TREE);
2493   TREE_SIDE_EFFECTS (controller) = 1;
2494
2495   body = build1 (EXIT_EXPR, void_type_node,
2496                  build2 (EQ_EXPR, boolean_type_node, tbase,
2497                          fold_convert (ptype, base)));
2498   tmp = fold_build1 (NEGATE_EXPR, sizetype, size_exp);
2499   body = build_compound_expr
2500     (body, cp_build_modify_expr (tbase, NOP_EXPR,
2501                                  build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp),
2502                                  tf_warning_or_error));
2503   body = build_compound_expr
2504     (body, build_delete (ptype, tbase, sfk_complete_destructor,
2505                          LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2506
2507   loop = build1 (LOOP_EXPR, void_type_node, body);
2508   loop = build_compound_expr (tbase_init, loop);
2509
2510  no_destructor:
2511   /* If the delete flag is one, or anything else with the low bit set,
2512      delete the storage.  */
2513   if (auto_delete_vec != sfk_base_destructor)
2514     {
2515       tree base_tbd;
2516
2517       /* The below is short by the cookie size.  */
2518       virtual_size = size_binop (MULT_EXPR, size_exp,
2519                                  convert (sizetype, maxindex));
2520
2521       if (! TYPE_VEC_NEW_USES_COOKIE (type))
2522         /* no header */
2523         base_tbd = base;
2524       else
2525         {
2526           tree cookie_size;
2527
2528           cookie_size = targetm.cxx.get_cookie_size (type);
2529           base_tbd
2530             = cp_convert (ptype,
2531                           cp_build_binary_op (input_location,
2532                                               MINUS_EXPR,
2533                                               cp_convert (string_type_node,
2534                                                           base),
2535                                               cookie_size,
2536                                               tf_warning_or_error));
2537           /* True size with header.  */
2538           virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2539         }
2540
2541       if (auto_delete_vec == sfk_deleting_destructor)
2542         deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2543                                                 base_tbd, virtual_size,
2544                                                 use_global_delete & 1,
2545                                                 /*placement=*/NULL_TREE,
2546                                                 /*alloc_fn=*/NULL_TREE);
2547     }
2548
2549   body = loop;
2550   if (!deallocate_expr)
2551     ;
2552   else if (!body)
2553     body = deallocate_expr;
2554   else
2555     body = build_compound_expr (body, deallocate_expr);
2556
2557   if (!body)
2558     body = integer_zero_node;
2559
2560   /* Outermost wrapper: If pointer is null, punt.  */
2561   body = fold_build3 (COND_EXPR, void_type_node,
2562                       fold_build2 (NE_EXPR, boolean_type_node, base,
2563                                    convert (TREE_TYPE (base),
2564                                             integer_zero_node)),
2565                       body, integer_zero_node);
2566   body = build1 (NOP_EXPR, void_type_node, body);
2567
2568   if (controller)
2569     {
2570       TREE_OPERAND (controller, 1) = body;
2571       body = controller;
2572     }
2573
2574   if (TREE_CODE (base) == SAVE_EXPR)
2575     /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
2576     body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2577
2578   return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
2579 }
2580
2581 /* Create an unnamed variable of the indicated TYPE.  */
2582
2583 tree
2584 create_temporary_var (tree type)
2585 {
2586   tree decl;
2587
2588   decl = build_decl (VAR_DECL, NULL_TREE, type);
2589   TREE_USED (decl) = 1;
2590   DECL_ARTIFICIAL (decl) = 1;
2591   DECL_IGNORED_P (decl) = 1;
2592   DECL_SOURCE_LOCATION (decl) = input_location;
2593   DECL_CONTEXT (decl) = current_function_decl;
2594
2595   return decl;
2596 }
2597
2598 /* Create a new temporary variable of the indicated TYPE, initialized
2599    to INIT.
2600
2601    It is not entered into current_binding_level, because that breaks
2602    things when it comes time to do final cleanups (which take place
2603    "outside" the binding contour of the function).  */
2604
2605 static tree
2606 get_temp_regvar (tree type, tree init)
2607 {
2608   tree decl;
2609
2610   decl = create_temporary_var (type);
2611   add_decl_expr (decl);
2612
2613   finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init, 
2614                                           tf_warning_or_error));
2615
2616   return decl;
2617 }
2618
2619 /* `build_vec_init' returns tree structure that performs
2620    initialization of a vector of aggregate types.
2621
2622    BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2623      to the first element, of POINTER_TYPE.
2624    MAXINDEX is the maximum index of the array (one less than the
2625      number of elements).  It is only used if BASE is a pointer or
2626      TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2627
2628    INIT is the (possibly NULL) initializer.
2629
2630    If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL.  All
2631    elements in the array are value-initialized.
2632
2633    FROM_ARRAY is 0 if we should init everything with INIT
2634    (i.e., every element initialized from INIT).
2635    FROM_ARRAY is 1 if we should index into INIT in parallel
2636    with initialization of DECL.
2637    FROM_ARRAY is 2 if we should index into INIT in parallel,
2638    but use assignment instead of initialization.  */
2639
2640 tree
2641 build_vec_init (tree base, tree maxindex, tree init,
2642                 bool explicit_value_init_p,
2643                 int from_array, tsubst_flags_t complain)
2644 {
2645   tree rval;
2646   tree base2 = NULL_TREE;
2647   tree size;
2648   tree itype = NULL_TREE;
2649   tree iterator;
2650   /* The type of BASE.  */
2651   tree atype = TREE_TYPE (base);
2652   /* The type of an element in the array.  */
2653   tree type = TREE_TYPE (atype);
2654   /* The element type reached after removing all outer array
2655      types.  */
2656   tree inner_elt_type;
2657   /* The type of a pointer to an element in the array.  */
2658   tree ptype;
2659   tree stmt_expr;
2660   tree compound_stmt;
2661   int destroy_temps;
2662   tree try_block = NULL_TREE;
2663   int num_initialized_elts = 0;
2664   bool is_global;
2665
2666   if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2667     maxindex = array_type_nelts (atype);
2668
2669   if (maxindex == NULL_TREE || maxindex == error_mark_node)
2670     return error_mark_node;
2671
2672   if (explicit_value_init_p)
2673     gcc_assert (!init);
2674
2675   inner_elt_type = strip_array_types (type);
2676   if (init
2677       && (from_array == 2
2678           ? (!CLASS_TYPE_P (inner_elt_type)
2679              || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2680           : !TYPE_NEEDS_CONSTRUCTING (type))
2681       && ((TREE_CODE (init) == CONSTRUCTOR
2682            /* Don't do this if the CONSTRUCTOR might contain something
2683               that might throw and require us to clean up.  */
2684            && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2685                || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2686           || from_array))
2687     {
2688       /* Do non-default initialization of POD arrays resulting from
2689          brace-enclosed initializers.  In this case, digest_init and
2690          store_constructor will handle the semantics for us.  */
2691
2692       gcc_assert (TREE_CODE (atype) == ARRAY_TYPE);
2693       stmt_expr = build2 (INIT_EXPR, atype, base, init);
2694       return stmt_expr;
2695     }
2696
2697   maxindex = cp_convert (ptrdiff_type_node, maxindex);
2698   size = size_in_bytes (type);
2699   if (TREE_CODE (atype) == ARRAY_TYPE)
2700     {
2701       ptype = build_pointer_type (type);
2702       base = cp_convert (ptype, decay_conversion (base));
2703     }
2704   else
2705     ptype = atype;
2706
2707   /* The code we are generating looks like:
2708      ({
2709        T* t1 = (T*) base;
2710        T* rval = t1;
2711        ptrdiff_t iterator = maxindex;
2712        try {
2713          for (; iterator != -1; --iterator) {
2714            ... initialize *t1 ...
2715            ++t1;
2716          }
2717        } catch (...) {
2718          ... destroy elements that were constructed ...
2719        }
2720        rval;
2721      })
2722
2723      We can omit the try and catch blocks if we know that the
2724      initialization will never throw an exception, or if the array
2725      elements do not have destructors.  We can omit the loop completely if
2726      the elements of the array do not have constructors.
2727
2728      We actually wrap the entire body of the above in a STMT_EXPR, for
2729      tidiness.
2730
2731      When copying from array to another, when the array elements have
2732      only trivial copy constructors, we should use __builtin_memcpy
2733      rather than generating a loop.  That way, we could take advantage
2734      of whatever cleverness the back end has for dealing with copies
2735      of blocks of memory.  */
2736
2737   is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2738   destroy_temps = stmts_are_full_exprs_p ();
2739   current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2740   rval = get_temp_regvar (ptype, base);
2741   base = get_temp_regvar (ptype, rval);
2742   iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2743
2744   /* Protect the entire array initialization so that we can destroy
2745      the partially constructed array if an exception is thrown.
2746      But don't do this if we're assigning.  */
2747   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2748       && from_array != 2)
2749     {
2750       try_block = begin_try_block ();
2751     }
2752
2753   if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2754     {
2755       /* Do non-default initialization of non-POD arrays resulting from
2756          brace-enclosed initializers.  */
2757       unsigned HOST_WIDE_INT idx;
2758       tree elt;
2759       from_array = 0;
2760
2761       FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
2762         {
2763           tree baseref = build1 (INDIRECT_REF, type, base);
2764
2765           num_initialized_elts++;
2766
2767           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2768           if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
2769             finish_expr_stmt (build_aggr_init (baseref, elt, 0, complain));
2770           else
2771             finish_expr_stmt (cp_build_modify_expr (baseref, NOP_EXPR,
2772                                                     elt, complain));
2773           current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2774
2775           finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2776                                                complain));
2777           finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2778                                                complain));
2779         }
2780
2781       /* Clear out INIT so that we don't get confused below.  */
2782       init = NULL_TREE;
2783     }
2784   else if (from_array)
2785     {
2786       /* If initializing one array from another, initialize element by
2787          element.  We rely upon the below calls the do argument
2788          checking.  */
2789       if (init)
2790         {
2791           base2 = decay_conversion (init);
2792           itype = TREE_TYPE (base2);
2793           base2 = get_temp_regvar (itype, base2);
2794           itype = TREE_TYPE (itype);
2795         }
2796       else if (TYPE_LANG_SPECIFIC (type)
2797                && TYPE_NEEDS_CONSTRUCTING (type)
2798                && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2799         {
2800           if (complain & tf_error)
2801             error ("initializer ends prematurely");
2802           return error_mark_node;
2803         }
2804     }
2805
2806   /* Now, default-initialize any remaining elements.  We don't need to
2807      do that if a) the type does not need constructing, or b) we've
2808      already initialized all the elements.
2809
2810      We do need to keep going if we're copying an array.  */
2811
2812   if (from_array
2813       || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_value_init_p)
2814           && ! (host_integerp (maxindex, 0)
2815                 && (num_initialized_elts
2816                     == tree_low_cst (maxindex, 0) + 1))))
2817     {
2818       /* If the ITERATOR is equal to -1, then we don't have to loop;
2819          we've already initialized all the elements.  */
2820       tree for_stmt;
2821       tree elt_init;
2822       tree to;
2823
2824       for_stmt = begin_for_stmt ();
2825       finish_for_init_stmt (for_stmt);
2826       finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
2827                                build_int_cst (TREE_TYPE (iterator), -1)),
2828                        for_stmt);
2829       finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2830                                           complain),
2831                        for_stmt);
2832
2833       to = build1 (INDIRECT_REF, type, base);
2834
2835       if (from_array)
2836         {
2837           tree from;
2838
2839           if (base2)
2840             from = build1 (INDIRECT_REF, itype, base2);
2841           else
2842             from = NULL_TREE;
2843
2844           if (from_array == 2)
2845             elt_init = cp_build_modify_expr (to, NOP_EXPR, from, 
2846                                              complain);
2847           else if (TYPE_NEEDS_CONSTRUCTING (type))
2848             elt_init = build_aggr_init (to, from, 0, complain);
2849           else if (from)
2850             elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2851                                              complain);
2852           else
2853             gcc_unreachable ();
2854         }
2855       else if (TREE_CODE (type) == ARRAY_TYPE)
2856         {
2857           if (init != 0)
2858             sorry
2859               ("cannot initialize multi-dimensional array with initializer");
2860           elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2861                                      0, 0,
2862                                      explicit_value_init_p,
2863                                      0, complain);
2864         }
2865       else if (explicit_value_init_p)
2866         elt_init = build2 (INIT_EXPR, type, to,
2867                            build_value_init (type));
2868       else
2869         {
2870           gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
2871           elt_init = build_aggr_init (to, init, 0, complain);
2872         }
2873
2874       current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2875       finish_expr_stmt (elt_init);
2876       current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2877
2878       finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2879                                            complain));
2880       if (base2)
2881         finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
2882                                              complain));
2883
2884       finish_for_stmt (for_stmt);
2885     }
2886
2887   /* Make sure to cleanup any partially constructed elements.  */
2888   if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2889       && from_array != 2)
2890     {
2891       tree e;
2892       tree m = cp_build_binary_op (input_location,
2893                                    MINUS_EXPR, maxindex, iterator,
2894                                    complain);
2895
2896       /* Flatten multi-dimensional array since build_vec_delete only
2897          expects one-dimensional array.  */
2898       if (TREE_CODE (type) == ARRAY_TYPE)
2899         m = cp_build_binary_op (input_location,
2900                                 MULT_EXPR, m,
2901                                 array_type_nelts_total (type),
2902                                 complain);
2903
2904       finish_cleanup_try_block (try_block);
2905       e = build_vec_delete_1 (rval, m,
2906                               inner_elt_type, sfk_base_destructor,
2907                               /*use_global_delete=*/0);
2908       finish_cleanup (e, try_block);
2909     }
2910
2911   /* The value of the array initialization is the array itself, RVAL
2912      is a pointer to the first element.  */
2913   finish_stmt_expr_expr (rval, stmt_expr);
2914
2915   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2916
2917   /* Now make the result have the correct type.  */
2918   if (TREE_CODE (atype) == ARRAY_TYPE)
2919     {
2920       atype = build_pointer_type (atype);
2921       stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2922       stmt_expr = cp_build_indirect_ref (stmt_expr, NULL, complain);
2923     }
2924
2925   current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2926   return stmt_expr;
2927 }
2928
2929 /* Call the DTOR_KIND destructor for EXP.  FLAGS are as for
2930    build_delete.  */
2931
2932 static tree
2933 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2934 {
2935   tree name;
2936   tree fn;
2937   switch (dtor_kind)
2938     {
2939     case sfk_complete_destructor:
2940       name = complete_dtor_identifier;
2941       break;
2942
2943     case sfk_base_destructor:
2944       name = base_dtor_identifier;
2945       break;
2946
2947     case sfk_deleting_destructor:
2948       name = deleting_dtor_identifier;
2949       break;
2950
2951     default:
2952       gcc_unreachable ();
2953     }
2954   fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2955   return build_new_method_call (exp, fn,
2956                                 /*args=*/NULL_TREE,
2957                                 /*conversion_path=*/NULL_TREE,
2958                                 flags,
2959                                 /*fn_p=*/NULL,
2960                                 tf_warning_or_error);
2961 }
2962
2963 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2964    ADDR is an expression which yields the store to be destroyed.
2965    AUTO_DELETE is the name of the destructor to call, i.e., either
2966    sfk_complete_destructor, sfk_base_destructor, or
2967    sfk_deleting_destructor.
2968
2969    FLAGS is the logical disjunction of zero or more LOOKUP_
2970    flags.  See cp-tree.h for more info.  */
2971
2972 tree
2973 build_delete (tree type, tree addr, special_function_kind auto_delete,
2974     int flags, int use_global_delete)
2975 {
2976   tree expr;
2977
2978   if (addr == error_mark_node)
2979     return error_mark_node;
2980
2981   /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2982      set to `error_mark_node' before it gets properly cleaned up.  */
2983   if (type == error_mark_node)
2984     return error_mark_node;
2985
2986   type = TYPE_MAIN_VARIANT (type);
2987
2988   if (TREE_CODE (type) == POINTER_TYPE)
2989     {
2990       bool complete_p = true;
2991
2992       type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2993       if (TREE_CODE (type) == ARRAY_TYPE)
2994         goto handle_array;
2995
2996       /* We don't want to warn about delete of void*, only other
2997           incomplete types.  Deleting other incomplete types
2998           invokes undefined behavior, but it is not ill-formed, so
2999           compile to something that would even do The Right Thing
3000           (TM) should the type have a trivial dtor and no delete
3001           operator.  */
3002       if (!VOID_TYPE_P (type))
3003         {
3004           complete_type (type);
3005           if (!COMPLETE_TYPE_P (type))
3006             {
3007               if (warning (0, "possible problem detected in invocation of "
3008                            "delete operator:"))
3009                 {
3010                   cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3011                   inform (input_location, "neither the destructor nor the class-specific "
3012                           "operator delete will be called, even if they are "
3013                           "declared when the class is defined.");
3014                 }
3015               complete_p = false;
3016             }
3017         }
3018       if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3019         /* Call the builtin operator delete.  */
3020         return build_builtin_delete_call (addr);
3021       if (TREE_SIDE_EFFECTS (addr))
3022         addr = save_expr (addr);
3023
3024       /* Throw away const and volatile on target type of addr.  */
3025       addr = convert_force (build_pointer_type (type), addr, 0);
3026     }
3027   else if (TREE_CODE (type) == ARRAY_TYPE)
3028     {
3029     handle_array:
3030
3031       if (TYPE_DOMAIN (type) == NULL_TREE)
3032         {
3033           error ("unknown array size in delete");
3034           return error_mark_node;
3035         }
3036       return build_vec_delete (addr, array_type_nelts (type),
3037                                auto_delete, use_global_delete);
3038     }
3039   else
3040     {
3041       /* Don't check PROTECT here; leave that decision to the
3042          destructor.  If the destructor is accessible, call it,
3043          else report error.  */
3044       addr = cp_build_unary_op (ADDR_EXPR, addr, 0, tf_warning_or_error);
3045       if (TREE_SIDE_EFFECTS (addr))
3046         addr = save_expr (addr);
3047
3048       addr = convert_force (build_pointer_type (type), addr, 0);
3049     }
3050
3051   gcc_assert (MAYBE_CLASS_TYPE_P (type));
3052
3053   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3054     {
3055       if (auto_delete != sfk_deleting_destructor)
3056         return void_zero_node;
3057
3058       return build_op_delete_call (DELETE_EXPR, addr,
3059                                    cxx_sizeof_nowarn (type),
3060                                    use_global_delete,
3061                                    /*placement=*/NULL_TREE,
3062                                    /*alloc_fn=*/NULL_TREE);
3063     }
3064   else
3065     {
3066       tree head = NULL_TREE;
3067       tree do_delete = NULL_TREE;
3068       tree ifexp;
3069
3070       if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3071         lazily_declare_fn (sfk_destructor, type);
3072
3073       /* For `::delete x', we must not use the deleting destructor
3074          since then we would not be sure to get the global `operator
3075          delete'.  */
3076       if (use_global_delete && auto_delete == sfk_deleting_destructor)
3077         {
3078           /* We will use ADDR multiple times so we must save it.  */
3079           addr = save_expr (addr);
3080           head = get_target_expr (build_headof (addr));
3081           /* Delete the object.  */
3082           do_delete = build_builtin_delete_call (head);
3083           /* Otherwise, treat this like a complete object destructor
3084              call.  */
3085           auto_delete = sfk_complete_destructor;
3086         }
3087       /* If the destructor is non-virtual, there is no deleting
3088          variant.  Instead, we must explicitly call the appropriate
3089          `operator delete' here.  */
3090       else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3091                && auto_delete == sfk_deleting_destructor)
3092         {
3093           /* We will use ADDR multiple times so we must save it.  */
3094           addr = save_expr (addr);
3095           /* Build the call.  */
3096           do_delete = build_op_delete_call (DELETE_EXPR,
3097                                             addr,
3098                                             cxx_sizeof_nowarn (type),
3099                                             /*global_p=*/false,
3100                                             /*placement=*/NULL_TREE,
3101                                             /*alloc_fn=*/NULL_TREE);
3102           /* Call the complete object destructor.  */
3103           auto_delete = sfk_complete_destructor;
3104         }
3105       else if (auto_delete == sfk_deleting_destructor
3106                && TYPE_GETS_REG_DELETE (type))
3107         {
3108           /* Make sure we have access to the member op delete, even though
3109              we'll actually be calling it from the destructor.  */
3110           build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3111                                 /*global_p=*/false,
3112                                 /*placement=*/NULL_TREE,
3113                                 /*alloc_fn=*/NULL_TREE);
3114         }
3115
3116       expr = build_dtor_call (cp_build_indirect_ref (addr, NULL, 
3117                                                      tf_warning_or_error),
3118                               auto_delete, flags);
3119       if (do_delete)
3120         expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3121
3122       /* We need to calculate this before the dtor changes the vptr.  */
3123       if (head)
3124         expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3125
3126       if (flags & LOOKUP_DESTRUCTOR)
3127         /* Explicit destructor call; don't check for null pointer.  */
3128         ifexp = integer_one_node;
3129       else
3130         /* Handle deleting a null pointer.  */
3131         ifexp = fold (cp_build_binary_op (input_location,
3132                                           NE_EXPR, addr, integer_zero_node,
3133                                           tf_warning_or_error));
3134
3135       if (ifexp != integer_one_node)
3136         expr = build3 (COND_EXPR, void_type_node,
3137                        ifexp, expr, void_zero_node);
3138
3139       return expr;
3140     }
3141 }
3142
3143 /* At the beginning of a destructor, push cleanups that will call the
3144    destructors for our base classes and members.
3145
3146    Called from begin_destructor_body.  */
3147
3148 void
3149 push_base_cleanups (void)
3150 {
3151   tree binfo, base_binfo;
3152   int i;
3153   tree member;
3154   tree expr;
3155   VEC(tree,gc) *vbases;
3156
3157   /* Run destructors for all virtual baseclasses.  */
3158   if (CLASSTYPE_VBASECLASSES (current_class_type))
3159     {
3160       tree cond = (condition_conversion
3161                    (build2 (BIT_AND_EXPR, integer_type_node,
3162                             current_in_charge_parm,
3163                             integer_two_node)));
3164
3165       /* The CLASSTYPE_VBASECLASSES vector is in initialization
3166          order, which is also the right order for pushing cleanups.  */
3167       for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3168            VEC_iterate (tree, vbases, i, base_binfo); i++)
3169         {
3170           if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3171             {
3172               expr = build_special_member_call (current_class_ref,
3173                                                 base_dtor_identifier,
3174                                                 NULL_TREE,
3175                                                 base_binfo,
3176                                                 (LOOKUP_NORMAL
3177                                                  | LOOKUP_NONVIRTUAL),
3178                                                 tf_warning_or_error);
3179               expr = build3 (COND_EXPR, void_type_node, cond,
3180                              expr, void_zero_node);
3181               finish_decl_cleanup (NULL_TREE, expr);
3182             }
3183         }
3184     }
3185
3186   /* Take care of the remaining baseclasses.  */
3187   for (binfo = TYPE_BINFO (current_class_type), i = 0;
3188        BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3189     {
3190       if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3191           || BINFO_VIRTUAL_P (base_binfo))
3192         continue;
3193
3194       expr = build_special_member_call (current_class_ref,
3195                                         base_dtor_identifier,
3196                                         NULL_TREE, base_binfo,
3197                                         LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3198                                         tf_warning_or_error);
3199       finish_decl_cleanup (NULL_TREE, expr);
3200     }
3201
3202   for (member = TYPE_FIELDS (current_class_type); member;
3203        member = TREE_CHAIN (member))
3204     {
3205       if (TREE_TYPE (member) == error_mark_node
3206           || TREE_CODE (member) != FIELD_DECL
3207           || DECL_ARTIFICIAL (member))
3208         continue;
3209       if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
3210         {
3211           tree this_member = (build_class_member_access_expr
3212                               (current_class_ref, member,
3213                                /*access_path=*/NULL_TREE,
3214                                /*preserve_reference=*/false,
3215                                tf_warning_or_error));
3216           tree this_type = TREE_TYPE (member);
3217           expr = build_delete (this_type, this_member,
3218                                sfk_complete_destructor,
3219                                LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3220                                0);
3221           finish_decl_cleanup (NULL_TREE, expr);
3222         }
3223     }
3224 }
3225
3226 /* Build a C++ vector delete expression.
3227    MAXINDEX is the number of elements to be deleted.
3228    ELT_SIZE is the nominal size of each element in the vector.
3229    BASE is the expression that should yield the store to be deleted.
3230    This function expands (or synthesizes) these calls itself.
3231    AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3232
3233    This also calls delete for virtual baseclasses of elements of the vector.
3234
3235    Update: MAXINDEX is no longer needed.  The size can be extracted from the
3236    start of the vector for pointers, and from the type for arrays.  We still
3237    use MAXINDEX for arrays because it happens to already have one of the
3238    values we'd have to extract.  (We could use MAXINDEX with pointers to
3239    confirm the size, and trap if the numbers differ; not clear that it'd
3240    be worth bothering.)  */
3241
3242 tree
3243 build_vec_delete (tree base, tree maxindex,
3244     special_function_kind auto_delete_vec, int use_global_delete)
3245 {
3246   tree type;
3247   tree rval;
3248   tree base_init = NULL_TREE;
3249
3250   type = TREE_TYPE (base);
3251
3252   if (TREE_CODE (type) == POINTER_TYPE)
3253     {
3254       /* Step back one from start of vector, and read dimension.  */
3255       tree cookie_addr;
3256       tree size_ptr_type = build_pointer_type (sizetype);
3257
3258       if (TREE_SIDE_EFFECTS (base))
3259         {
3260           base_init = get_target_expr (base);
3261           base = TARGET_EXPR_SLOT (base_init);
3262         }
3263       type = strip_array_types (TREE_TYPE (type));
3264       cookie_addr = fold_build1 (NEGATE_EXPR, sizetype, TYPE_SIZE_UNIT (sizetype));
3265       cookie_addr = build2 (POINTER_PLUS_EXPR,
3266                             size_ptr_type,
3267                             fold_convert (size_ptr_type, base),
3268                             cookie_addr);
3269       maxindex = cp_build_indirect_ref (cookie_addr, NULL, tf_warning_or_error);
3270     }
3271   else if (TREE_CODE (type) == ARRAY_TYPE)
3272     {
3273       /* Get the total number of things in the array, maxindex is a
3274          bad name.  */
3275       maxindex = array_type_nelts_total (type);
3276       type = strip_array_types (type);
3277       base = cp_build_unary_op (ADDR_EXPR, base, 1, tf_warning_or_error);
3278       if (TREE_SIDE_EFFECTS (base))
3279         {
3280           base_init = get_target_expr (base);
3281           base = TARGET_EXPR_SLOT (base_init);
3282         }
3283     }
3284   else
3285     {
3286       if (base != error_mark_node)
3287         error ("type to vector delete is neither pointer or array type");
3288       return error_mark_node;
3289     }
3290
3291   rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3292                              use_global_delete);
3293   if (base_init)
3294     rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
3295
3296   return rval;
3297 }