2005-05-13 Josh Conner <jconner@apple.com>
[official-gcc.git] / gcc / cp / init.c
blob99891cb2922effc58778cdff36dfa78159c3fbe0
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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* High-level class interface. */
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"
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);
43 static void expand_default_init (tree, tree, tree, tree, int);
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_default_init (tree, tree);
55 static tree build_new_1 (tree);
56 static tree build_dtor_call (tree, special_function_kind, int);
57 static tree build_field_list (tree, tree, int *);
58 static tree build_vtbl_address (tree);
60 /* We are about to generate some complex initialization code.
61 Conceptually, it is all a single expression. However, we may want
62 to include conditionals, loops, and other such statement-level
63 constructs. Therefore, we build the initialization code inside a
64 statement-expression. This function starts such an expression.
65 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
66 pass them back to finish_init_stmts when the expression is
67 complete. */
69 static bool
70 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
72 bool is_global = !building_stmt_tree ();
74 *stmt_expr_p = begin_stmt_expr ();
75 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
77 return is_global;
80 /* Finish out the statement-expression begun by the previous call to
81 begin_init_stmts. Returns the statement-expression itself. */
83 static tree
84 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
86 finish_compound_stmt (compound_stmt);
88 stmt_expr = finish_stmt_expr (stmt_expr, true);
90 gcc_assert (!building_stmt_tree () == is_global);
92 return stmt_expr;
95 /* Constructors */
97 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
98 which we want to initialize the vtable pointer for, DATA is
99 TREE_LIST whose TREE_VALUE is the this ptr expression. */
101 static tree
102 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
104 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
105 return dfs_skip_bases;
107 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
109 tree base_ptr = TREE_VALUE ((tree) data);
111 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
113 expand_virtual_init (binfo, base_ptr);
116 return NULL_TREE;
119 /* Initialize all the vtable pointers in the object pointed to by
120 ADDR. */
122 void
123 initialize_vtbl_ptrs (tree addr)
125 tree list;
126 tree type;
128 type = TREE_TYPE (TREE_TYPE (addr));
129 list = build_tree_list (type, addr);
131 /* Walk through the hierarchy, initializing the vptr in each base
132 class. We do these in pre-order because we can't find the virtual
133 bases for a class until we've initialized the vtbl for that
134 class. */
135 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
138 /* Return an expression for the zero-initialization of an object with
139 type T. This expression will either be a constant (in the case
140 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
141 aggregate). In either case, the value can be used as DECL_INITIAL
142 for a decl of the indicated TYPE; it is a valid static initializer.
143 If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS is the
144 number of elements in the array. If STATIC_STORAGE_P is TRUE,
145 initializers are only generated for entities for which
146 zero-initialization does not simply mean filling the storage with
147 zero bytes. */
149 tree
150 build_zero_init (tree type, tree nelts, bool static_storage_p)
152 tree init = NULL_TREE;
154 /* [dcl.init]
156 To zero-initialization storage for an object of type T means:
158 -- if T is a scalar type, the storage is set to the value of zero
159 converted to T.
161 -- if T is a non-union class type, the storage for each nonstatic
162 data member and each base-class subobject is zero-initialized.
164 -- if T is a union type, the storage for its first data member is
165 zero-initialized.
167 -- if T is an array type, the storage for each element is
168 zero-initialized.
170 -- if T is a reference type, no initialization is performed. */
172 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
174 if (type == error_mark_node)
176 else if (static_storage_p && zero_init_p (type))
177 /* In order to save space, we do not explicitly build initializers
178 for items that do not need them. GCC's semantics are that
179 items with static storage duration that are not otherwise
180 initialized are initialized to zero. */
182 else if (SCALAR_TYPE_P (type))
183 init = convert (type, integer_zero_node);
184 else if (CLASS_TYPE_P (type))
186 tree field;
187 tree inits;
189 /* Build a constructor to contain the initializations. */
190 init = build_constructor (type, NULL_TREE);
191 /* Iterate over the fields, building initializations. */
192 inits = NULL_TREE;
193 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
195 if (TREE_CODE (field) != FIELD_DECL)
196 continue;
198 /* Note that for class types there will be FIELD_DECLs
199 corresponding to base classes as well. Thus, iterating
200 over TYPE_FIELDs will result in correct initialization of
201 all of the subobjects. */
202 if (static_storage_p && !zero_init_p (TREE_TYPE (field)))
203 inits = tree_cons (field,
204 build_zero_init (TREE_TYPE (field),
205 /*nelts=*/NULL_TREE,
206 static_storage_p),
207 inits);
209 /* For unions, only the first field is initialized. */
210 if (TREE_CODE (type) == UNION_TYPE)
211 break;
213 CONSTRUCTOR_ELTS (init) = nreverse (inits);
215 else if (TREE_CODE (type) == ARRAY_TYPE)
217 tree max_index;
218 tree inits;
220 /* Build a constructor to contain the initializations. */
221 init = build_constructor (type, NULL_TREE);
222 /* Iterate over the array elements, building initializations. */
223 inits = NULL_TREE;
224 if (nelts)
225 max_index = fold_build2 (MINUS_EXPR, TREE_TYPE (nelts),
226 nelts, integer_one_node);
227 else
228 max_index = array_type_nelts (type);
229 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
231 /* A zero-sized array, which is accepted as an extension, will
232 have an upper bound of -1. */
233 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
235 tree elt_init = build_zero_init (TREE_TYPE (type),
236 /*nelts=*/NULL_TREE,
237 static_storage_p);
238 tree range;
240 /* If this is a one element array, we just use a regular init. */
241 if (tree_int_cst_equal (size_zero_node, max_index))
242 range = size_zero_node;
243 else
244 range = build2 (RANGE_EXPR, sizetype, size_zero_node, max_index);
246 inits = tree_cons (range, elt_init, inits);
249 CONSTRUCTOR_ELTS (init) = nreverse (inits);
251 else
252 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
254 /* In all cases, the initializer is a constant. */
255 if (init)
257 TREE_CONSTANT (init) = 1;
258 TREE_INVARIANT (init) = 1;
261 return init;
264 /* Build an expression for the default-initialization of an object of
265 the indicated TYPE. If NELTS is non-NULL, and TYPE is an
266 ARRAY_TYPE, NELTS is the number of elements in the array. If
267 initialization of TYPE requires calling constructors, this function
268 returns NULL_TREE; the caller is responsible for arranging for the
269 constructors to be called. */
271 static tree
272 build_default_init (tree type, tree nelts)
274 /* [dcl.init]:
276 To default-initialize an object of type T means:
278 --if T is a non-POD class type (clause _class_), the default construc-
279 tor for T is called (and the initialization is ill-formed if T has
280 no accessible default constructor);
282 --if T is an array type, each element is default-initialized;
284 --otherwise, the storage for the object is zero-initialized.
286 A program that calls for default-initialization of an entity of refer-
287 ence type is ill-formed. */
289 /* If TYPE_NEEDS_CONSTRUCTING is true, the caller is responsible for
290 performing the initialization. This is confusing in that some
291 non-PODs do not have TYPE_NEEDS_CONSTRUCTING set. (For example,
292 a class with a pointer-to-data member as a non-static data member
293 does not have TYPE_NEEDS_CONSTRUCTING set.) Therefore, we end up
294 passing non-PODs to build_zero_init below, which is contrary to
295 the semantics quoted above from [dcl.init].
297 It happens, however, that the behavior of the constructor the
298 standard says we should have generated would be precisely the
299 same as that obtained by calling build_zero_init below, so things
300 work out OK. */
301 if (TYPE_NEEDS_CONSTRUCTING (type)
302 || (nelts && TREE_CODE (nelts) != INTEGER_CST))
303 return NULL_TREE;
305 /* At this point, TYPE is either a POD class type, an array of POD
306 classes, or something even more innocuous. */
307 return build_zero_init (type, nelts, /*static_storage_p=*/false);
310 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
311 arguments. If TREE_LIST is void_type_node, an empty initializer
312 list was given; if NULL_TREE no initializer was given. */
314 static void
315 perform_member_init (tree member, tree init)
317 tree decl;
318 tree type = TREE_TYPE (member);
319 bool explicit;
321 explicit = (init != NULL_TREE);
323 /* Effective C++ rule 12 requires that all data members be
324 initialized. */
325 if (warn_ecpp && !explicit && TREE_CODE (type) != ARRAY_TYPE)
326 warning (0, "%J%qD should be initialized in the member initialization "
327 "list", current_function_decl, member);
329 if (init == void_type_node)
330 init = NULL_TREE;
332 /* Get an lvalue for the data member. */
333 decl = build_class_member_access_expr (current_class_ref, member,
334 /*access_path=*/NULL_TREE,
335 /*preserve_reference=*/true);
336 if (decl == error_mark_node)
337 return;
339 /* Deal with this here, as we will get confused if we try to call the
340 assignment op for an anonymous union. This can happen in a
341 synthesized copy constructor. */
342 if (ANON_AGGR_TYPE_P (type))
344 if (init)
346 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
347 finish_expr_stmt (init);
350 else if (TYPE_NEEDS_CONSTRUCTING (type))
352 if (explicit
353 && TREE_CODE (type) == ARRAY_TYPE
354 && init != NULL_TREE
355 && TREE_CHAIN (init) == NULL_TREE
356 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
358 /* Initialization of one array from another. */
359 finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
360 /* from_array=*/1));
362 else
363 finish_expr_stmt (build_aggr_init (decl, init, 0));
365 else
367 if (init == NULL_TREE)
369 if (explicit)
371 init = build_default_init (type, /*nelts=*/NULL_TREE);
372 if (TREE_CODE (type) == REFERENCE_TYPE)
373 warning (0, "%Jdefault-initialization of %q#D, "
374 "which has reference type",
375 current_function_decl, member);
377 /* member traversal: note it leaves init NULL */
378 else if (TREE_CODE (type) == REFERENCE_TYPE)
379 pedwarn ("%Juninitialized reference member %qD",
380 current_function_decl, member);
381 else if (CP_TYPE_CONST_P (type))
382 pedwarn ("%Juninitialized member %qD with %<const%> type %qT",
383 current_function_decl, member, type);
385 else if (TREE_CODE (init) == TREE_LIST)
386 /* There was an explicit member initialization. Do some work
387 in that case. */
388 init = build_x_compound_expr_from_list (init, "member initializer");
390 if (init)
391 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
394 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
396 tree expr;
398 expr = build_class_member_access_expr (current_class_ref, member,
399 /*access_path=*/NULL_TREE,
400 /*preserve_reference=*/false);
401 expr = build_delete (type, expr, sfk_complete_destructor,
402 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
404 if (expr != error_mark_node)
405 finish_eh_cleanup (expr);
409 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
410 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
412 static tree
413 build_field_list (tree t, tree list, int *uses_unions_p)
415 tree fields;
417 *uses_unions_p = 0;
419 /* Note whether or not T is a union. */
420 if (TREE_CODE (t) == UNION_TYPE)
421 *uses_unions_p = 1;
423 for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
425 /* Skip CONST_DECLs for enumeration constants and so forth. */
426 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
427 continue;
429 /* Keep track of whether or not any fields are unions. */
430 if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
431 *uses_unions_p = 1;
433 /* For an anonymous struct or union, we must recursively
434 consider the fields of the anonymous type. They can be
435 directly initialized from the constructor. */
436 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
438 /* Add this field itself. Synthesized copy constructors
439 initialize the entire aggregate. */
440 list = tree_cons (fields, NULL_TREE, list);
441 /* And now add the fields in the anonymous aggregate. */
442 list = build_field_list (TREE_TYPE (fields), list,
443 uses_unions_p);
445 /* Add this field. */
446 else if (DECL_NAME (fields))
447 list = tree_cons (fields, NULL_TREE, list);
450 return list;
453 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
454 a FIELD_DECL or BINFO in T that needs initialization. The
455 TREE_VALUE gives the initializer, or list of initializer arguments.
457 Return a TREE_LIST containing all of the initializations required
458 for T, in the order in which they should be performed. The output
459 list has the same format as the input. */
461 static tree
462 sort_mem_initializers (tree t, tree mem_inits)
464 tree init;
465 tree base, binfo, base_binfo;
466 tree sorted_inits;
467 tree next_subobject;
468 VEC(tree,gc) *vbases;
469 int i;
470 int uses_unions_p;
472 /* Build up a list of initializations. The TREE_PURPOSE of entry
473 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
474 TREE_VALUE will be the constructor arguments, or NULL if no
475 explicit initialization was provided. */
476 sorted_inits = NULL_TREE;
478 /* Process the virtual bases. */
479 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
480 VEC_iterate (tree, vbases, i, base); i++)
481 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
483 /* Process the direct bases. */
484 for (binfo = TYPE_BINFO (t), i = 0;
485 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
486 if (!BINFO_VIRTUAL_P (base_binfo))
487 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
489 /* Process the non-static data members. */
490 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
491 /* Reverse the entire list of initializations, so that they are in
492 the order that they will actually be performed. */
493 sorted_inits = nreverse (sorted_inits);
495 /* If the user presented the initializers in an order different from
496 that in which they will actually occur, we issue a warning. Keep
497 track of the next subobject which can be explicitly initialized
498 without issuing a warning. */
499 next_subobject = sorted_inits;
501 /* Go through the explicit initializers, filling in TREE_PURPOSE in
502 the SORTED_INITS. */
503 for (init = mem_inits; init; init = TREE_CHAIN (init))
505 tree subobject;
506 tree subobject_init;
508 subobject = TREE_PURPOSE (init);
510 /* If the explicit initializers are in sorted order, then
511 SUBOBJECT will be NEXT_SUBOBJECT, or something following
512 it. */
513 for (subobject_init = next_subobject;
514 subobject_init;
515 subobject_init = TREE_CHAIN (subobject_init))
516 if (TREE_PURPOSE (subobject_init) == subobject)
517 break;
519 /* Issue a warning if the explicit initializer order does not
520 match that which will actually occur.
521 ??? Are all these on the correct lines? */
522 if (warn_reorder && !subobject_init)
524 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
525 cp_warning_at ("%qD will be initialized after",
526 TREE_PURPOSE (next_subobject));
527 else
528 warning (0, "base %qT will be initialized after",
529 TREE_PURPOSE (next_subobject));
530 if (TREE_CODE (subobject) == FIELD_DECL)
531 cp_warning_at (" %q#D", subobject);
532 else
533 warning (0, " base %qT", subobject);
534 warning (0, "%J when initialized here", current_function_decl);
537 /* Look again, from the beginning of the list. */
538 if (!subobject_init)
540 subobject_init = sorted_inits;
541 while (TREE_PURPOSE (subobject_init) != subobject)
542 subobject_init = TREE_CHAIN (subobject_init);
545 /* It is invalid to initialize the same subobject more than
546 once. */
547 if (TREE_VALUE (subobject_init))
549 if (TREE_CODE (subobject) == FIELD_DECL)
550 error ("%Jmultiple initializations given for %qD",
551 current_function_decl, subobject);
552 else
553 error ("%Jmultiple initializations given for base %qT",
554 current_function_decl, subobject);
557 /* Record the initialization. */
558 TREE_VALUE (subobject_init) = TREE_VALUE (init);
559 next_subobject = subobject_init;
562 /* [class.base.init]
564 If a ctor-initializer specifies more than one mem-initializer for
565 multiple members of the same union (including members of
566 anonymous unions), the ctor-initializer is ill-formed. */
567 if (uses_unions_p)
569 tree last_field = NULL_TREE;
570 for (init = sorted_inits; init; init = TREE_CHAIN (init))
572 tree field;
573 tree field_type;
574 int done;
576 /* Skip uninitialized members and base classes. */
577 if (!TREE_VALUE (init)
578 || TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
579 continue;
580 /* See if this field is a member of a union, or a member of a
581 structure contained in a union, etc. */
582 field = TREE_PURPOSE (init);
583 for (field_type = DECL_CONTEXT (field);
584 !same_type_p (field_type, t);
585 field_type = TYPE_CONTEXT (field_type))
586 if (TREE_CODE (field_type) == UNION_TYPE)
587 break;
588 /* If this field is not a member of a union, skip it. */
589 if (TREE_CODE (field_type) != UNION_TYPE)
590 continue;
592 /* It's only an error if we have two initializers for the same
593 union type. */
594 if (!last_field)
596 last_field = field;
597 continue;
600 /* See if LAST_FIELD and the field initialized by INIT are
601 members of the same union. If so, there's a problem,
602 unless they're actually members of the same structure
603 which is itself a member of a union. For example, given:
605 union { struct { int i; int j; }; };
607 initializing both `i' and `j' makes sense. */
608 field_type = DECL_CONTEXT (field);
609 done = 0;
612 tree last_field_type;
614 last_field_type = DECL_CONTEXT (last_field);
615 while (1)
617 if (same_type_p (last_field_type, field_type))
619 if (TREE_CODE (field_type) == UNION_TYPE)
620 error ("%Jinitializations for multiple members of %qT",
621 current_function_decl, last_field_type);
622 done = 1;
623 break;
626 if (same_type_p (last_field_type, t))
627 break;
629 last_field_type = TYPE_CONTEXT (last_field_type);
632 /* If we've reached the outermost class, then we're
633 done. */
634 if (same_type_p (field_type, t))
635 break;
637 field_type = TYPE_CONTEXT (field_type);
639 while (!done);
641 last_field = field;
645 return sorted_inits;
648 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
649 is a TREE_LIST giving the explicit mem-initializer-list for the
650 constructor. The TREE_PURPOSE of each entry is a subobject (a
651 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
652 is a TREE_LIST giving the arguments to the constructor or
653 void_type_node for an empty list of arguments. */
655 void
656 emit_mem_initializers (tree mem_inits)
658 /* We will already have issued an error message about the fact that
659 the type is incomplete. */
660 if (!COMPLETE_TYPE_P (current_class_type))
661 return;
663 /* Sort the mem-initializers into the order in which the
664 initializations should be performed. */
665 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
667 in_base_initializer = 1;
669 /* Initialize base classes. */
670 while (mem_inits
671 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
673 tree subobject = TREE_PURPOSE (mem_inits);
674 tree arguments = TREE_VALUE (mem_inits);
676 /* If these initializations are taking place in a copy
677 constructor, the base class should probably be explicitly
678 initialized. */
679 if (extra_warnings && !arguments
680 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
681 && TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (subobject)))
682 warning (0, "%Jbase class %q#T should be explicitly initialized in the "
683 "copy constructor",
684 current_function_decl, BINFO_TYPE (subobject));
686 /* If an explicit -- but empty -- initializer list was present,
687 treat it just like default initialization at this point. */
688 if (arguments == void_type_node)
689 arguments = NULL_TREE;
691 /* Initialize the base. */
692 if (BINFO_VIRTUAL_P (subobject))
693 construct_virtual_base (subobject, arguments);
694 else
696 tree base_addr;
698 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
699 subobject, 1);
700 expand_aggr_init_1 (subobject, NULL_TREE,
701 build_indirect_ref (base_addr, NULL),
702 arguments,
703 LOOKUP_NORMAL);
704 expand_cleanup_for_base (subobject, NULL_TREE);
707 mem_inits = TREE_CHAIN (mem_inits);
709 in_base_initializer = 0;
711 /* Initialize the vptrs. */
712 initialize_vtbl_ptrs (current_class_ptr);
714 /* Initialize the data members. */
715 while (mem_inits)
717 perform_member_init (TREE_PURPOSE (mem_inits),
718 TREE_VALUE (mem_inits));
719 mem_inits = TREE_CHAIN (mem_inits);
723 /* Returns the address of the vtable (i.e., the value that should be
724 assigned to the vptr) for BINFO. */
726 static tree
727 build_vtbl_address (tree binfo)
729 tree binfo_for = binfo;
730 tree vtbl;
732 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
733 /* If this is a virtual primary base, then the vtable we want to store
734 is that for the base this is being used as the primary base of. We
735 can't simply skip the initialization, because we may be expanding the
736 inits of a subobject constructor where the virtual base layout
737 can be different. */
738 while (BINFO_PRIMARY_P (binfo_for))
739 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
741 /* Figure out what vtable BINFO's vtable is based on, and mark it as
742 used. */
743 vtbl = get_vtbl_decl_for_binfo (binfo_for);
744 assemble_external (vtbl);
745 TREE_USED (vtbl) = 1;
747 /* Now compute the address to use when initializing the vptr. */
748 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
749 if (TREE_CODE (vtbl) == VAR_DECL)
750 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
752 return vtbl;
755 /* This code sets up the virtual function tables appropriate for
756 the pointer DECL. It is a one-ply initialization.
758 BINFO is the exact type that DECL is supposed to be. In
759 multiple inheritance, this might mean "C's A" if C : A, B. */
761 static void
762 expand_virtual_init (tree binfo, tree decl)
764 tree vtbl, vtbl_ptr;
765 tree vtt_index;
767 /* Compute the initializer for vptr. */
768 vtbl = build_vtbl_address (binfo);
770 /* We may get this vptr from a VTT, if this is a subobject
771 constructor or subobject destructor. */
772 vtt_index = BINFO_VPTR_INDEX (binfo);
773 if (vtt_index)
775 tree vtbl2;
776 tree vtt_parm;
778 /* Compute the value to use, when there's a VTT. */
779 vtt_parm = current_vtt_parm;
780 vtbl2 = build2 (PLUS_EXPR,
781 TREE_TYPE (vtt_parm),
782 vtt_parm,
783 vtt_index);
784 vtbl2 = build_indirect_ref (vtbl2, NULL);
785 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
787 /* The actual initializer is the VTT value only in the subobject
788 constructor. In maybe_clone_body we'll substitute NULL for
789 the vtt_parm in the case of the non-subobject constructor. */
790 vtbl = build3 (COND_EXPR,
791 TREE_TYPE (vtbl),
792 build2 (EQ_EXPR, boolean_type_node,
793 current_in_charge_parm, integer_zero_node),
794 vtbl2,
795 vtbl);
798 /* Compute the location of the vtpr. */
799 vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL),
800 TREE_TYPE (binfo));
801 gcc_assert (vtbl_ptr != error_mark_node);
803 /* Assign the vtable to the vptr. */
804 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
805 finish_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
808 /* If an exception is thrown in a constructor, those base classes already
809 constructed must be destroyed. This function creates the cleanup
810 for BINFO, which has just been constructed. If FLAG is non-NULL,
811 it is a DECL which is nonzero when this base needs to be
812 destroyed. */
814 static void
815 expand_cleanup_for_base (tree binfo, tree flag)
817 tree expr;
819 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
820 return;
822 /* Call the destructor. */
823 expr = build_special_member_call (current_class_ref,
824 base_dtor_identifier,
825 NULL_TREE,
826 binfo,
827 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
828 if (flag)
829 expr = fold_build3 (COND_EXPR, void_type_node,
830 c_common_truthvalue_conversion (flag),
831 expr, integer_zero_node);
833 finish_eh_cleanup (expr);
836 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
837 constructor. */
839 static void
840 construct_virtual_base (tree vbase, tree arguments)
842 tree inner_if_stmt;
843 tree exp;
844 tree flag;
846 /* If there are virtual base classes with destructors, we need to
847 emit cleanups to destroy them if an exception is thrown during
848 the construction process. These exception regions (i.e., the
849 period during which the cleanups must occur) begin from the time
850 the construction is complete to the end of the function. If we
851 create a conditional block in which to initialize the
852 base-classes, then the cleanup region for the virtual base begins
853 inside a block, and ends outside of that block. This situation
854 confuses the sjlj exception-handling code. Therefore, we do not
855 create a single conditional block, but one for each
856 initialization. (That way the cleanup regions always begin
857 in the outer block.) We trust the back-end to figure out
858 that the FLAG will not change across initializations, and
859 avoid doing multiple tests. */
860 flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
861 inner_if_stmt = begin_if_stmt ();
862 finish_if_stmt_cond (flag, inner_if_stmt);
864 /* Compute the location of the virtual base. If we're
865 constructing virtual bases, then we must be the most derived
866 class. Therefore, we don't have to look up the virtual base;
867 we already know where it is. */
868 exp = convert_to_base_statically (current_class_ref, vbase);
870 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
871 LOOKUP_COMPLAIN);
872 finish_then_clause (inner_if_stmt);
873 finish_if_stmt (inner_if_stmt);
875 expand_cleanup_for_base (vbase, flag);
878 /* Find the context in which this FIELD can be initialized. */
880 static tree
881 initializing_context (tree field)
883 tree t = DECL_CONTEXT (field);
885 /* Anonymous union members can be initialized in the first enclosing
886 non-anonymous union context. */
887 while (t && ANON_AGGR_TYPE_P (t))
888 t = TYPE_CONTEXT (t);
889 return t;
892 /* Function to give error message if member initialization specification
893 is erroneous. FIELD is the member we decided to initialize.
894 TYPE is the type for which the initialization is being performed.
895 FIELD must be a member of TYPE.
897 MEMBER_NAME is the name of the member. */
899 static int
900 member_init_ok_or_else (tree field, tree type, tree member_name)
902 if (field == error_mark_node)
903 return 0;
904 if (!field)
906 error ("class %qT does not have any field named %qD", type,
907 member_name);
908 return 0;
910 if (TREE_CODE (field) == VAR_DECL)
912 error ("%q#D is a static data member; it can only be "
913 "initialized at its definition",
914 field);
915 return 0;
917 if (TREE_CODE (field) != FIELD_DECL)
919 error ("%q#D is not a non-static data member of %qT",
920 field, type);
921 return 0;
923 if (initializing_context (field) != type)
925 error ("class %qT does not have any field named %qD", type,
926 member_name);
927 return 0;
930 return 1;
933 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
934 is a _TYPE node or TYPE_DECL which names a base for that type.
935 Check the validity of NAME, and return either the base _TYPE, base
936 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
937 NULL_TREE and issue a diagnostic.
939 An old style unnamed direct single base construction is permitted,
940 where NAME is NULL. */
942 tree
943 expand_member_init (tree name)
945 tree basetype;
946 tree field;
948 if (!current_class_ref)
949 return NULL_TREE;
951 if (!name)
953 /* This is an obsolete unnamed base class initializer. The
954 parser will already have warned about its use. */
955 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
957 case 0:
958 error ("unnamed initializer for %qT, which has no base classes",
959 current_class_type);
960 return NULL_TREE;
961 case 1:
962 basetype = BINFO_TYPE
963 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
964 break;
965 default:
966 error ("unnamed initializer for %qT, which uses multiple inheritance",
967 current_class_type);
968 return NULL_TREE;
971 else if (TYPE_P (name))
973 basetype = TYPE_MAIN_VARIANT (name);
974 name = TYPE_NAME (name);
976 else if (TREE_CODE (name) == TYPE_DECL)
977 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
978 else
979 basetype = NULL_TREE;
981 if (basetype)
983 tree class_binfo;
984 tree direct_binfo;
985 tree virtual_binfo;
986 int i;
988 if (current_template_parms)
989 return basetype;
991 class_binfo = TYPE_BINFO (current_class_type);
992 direct_binfo = NULL_TREE;
993 virtual_binfo = NULL_TREE;
995 /* Look for a direct base. */
996 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
997 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
998 break;
1000 /* Look for a virtual base -- unless the direct base is itself
1001 virtual. */
1002 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1003 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1005 /* [class.base.init]
1007 If a mem-initializer-id is ambiguous because it designates
1008 both a direct non-virtual base class and an inherited virtual
1009 base class, the mem-initializer is ill-formed. */
1010 if (direct_binfo && virtual_binfo)
1012 error ("%qD is both a direct base and an indirect virtual base",
1013 basetype);
1014 return NULL_TREE;
1017 if (!direct_binfo && !virtual_binfo)
1019 if (CLASSTYPE_VBASECLASSES (current_class_type))
1020 error ("type %qD is not a direct or virtual base of %qT",
1021 name, current_class_type);
1022 else
1023 error ("type %qD is not a direct base of %qT",
1024 name, current_class_type);
1025 return NULL_TREE;
1028 return direct_binfo ? direct_binfo : virtual_binfo;
1030 else
1032 if (TREE_CODE (name) == IDENTIFIER_NODE)
1033 field = lookup_field (current_class_type, name, 1, false);
1034 else
1035 field = name;
1037 if (member_init_ok_or_else (field, current_class_type, name))
1038 return field;
1041 return NULL_TREE;
1044 /* This is like `expand_member_init', only it stores one aggregate
1045 value into another.
1047 INIT comes in two flavors: it is either a value which
1048 is to be stored in EXP, or it is a parameter list
1049 to go to a constructor, which will operate on EXP.
1050 If INIT is not a parameter list for a constructor, then set
1051 LOOKUP_ONLYCONVERTING.
1052 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1053 the initializer, if FLAGS is 0, then it is the (init) form.
1054 If `init' is a CONSTRUCTOR, then we emit a warning message,
1055 explaining that such initializations are invalid.
1057 If INIT resolves to a CALL_EXPR which happens to return
1058 something of the type we are looking for, then we know
1059 that we can safely use that call to perform the
1060 initialization.
1062 The virtual function table pointer cannot be set up here, because
1063 we do not really know its type.
1065 This never calls operator=().
1067 When initializing, nothing is CONST.
1069 A default copy constructor may have to be used to perform the
1070 initialization.
1072 A constructor or a conversion operator may have to be used to
1073 perform the initialization, but not both, as it would be ambiguous. */
1075 tree
1076 build_aggr_init (tree exp, tree init, int flags)
1078 tree stmt_expr;
1079 tree compound_stmt;
1080 int destroy_temps;
1081 tree type = TREE_TYPE (exp);
1082 int was_const = TREE_READONLY (exp);
1083 int was_volatile = TREE_THIS_VOLATILE (exp);
1084 int is_global;
1086 if (init == error_mark_node)
1087 return error_mark_node;
1089 TREE_READONLY (exp) = 0;
1090 TREE_THIS_VOLATILE (exp) = 0;
1092 if (init && TREE_CODE (init) != TREE_LIST)
1093 flags |= LOOKUP_ONLYCONVERTING;
1095 if (TREE_CODE (type) == ARRAY_TYPE)
1097 tree itype;
1099 /* An array may not be initialized use the parenthesized
1100 initialization form -- unless the initializer is "()". */
1101 if (init && TREE_CODE (init) == TREE_LIST)
1103 error ("bad array initializer");
1104 return error_mark_node;
1106 /* Must arrange to initialize each element of EXP
1107 from elements of INIT. */
1108 itype = init ? TREE_TYPE (init) : NULL_TREE;
1109 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
1110 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1111 if (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
1112 itype = TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1113 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1114 itype && same_type_p (itype,
1115 TREE_TYPE (exp)));
1116 TREE_READONLY (exp) = was_const;
1117 TREE_THIS_VOLATILE (exp) = was_volatile;
1118 TREE_TYPE (exp) = type;
1119 if (init)
1120 TREE_TYPE (init) = itype;
1121 return stmt_expr;
1124 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1125 /* Just know that we've seen something for this node. */
1126 TREE_USED (exp) = 1;
1128 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1129 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1130 destroy_temps = stmts_are_full_exprs_p ();
1131 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1132 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1133 init, LOOKUP_NORMAL|flags);
1134 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1135 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1136 TREE_TYPE (exp) = type;
1137 TREE_READONLY (exp) = was_const;
1138 TREE_THIS_VOLATILE (exp) = was_volatile;
1140 return stmt_expr;
1143 /* Like build_aggr_init, but not just for aggregates. */
1145 tree
1146 build_init (tree decl, tree init, int flags)
1148 tree expr;
1150 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1151 expr = build_aggr_init (decl, init, flags);
1152 else if (CLASS_TYPE_P (TREE_TYPE (decl)))
1153 expr = build_special_member_call (decl, complete_ctor_identifier,
1154 build_tree_list (NULL_TREE, init),
1155 TREE_TYPE (decl),
1156 LOOKUP_NORMAL|flags);
1157 else
1158 expr = build2 (INIT_EXPR, TREE_TYPE (decl), decl, init);
1160 return expr;
1163 static void
1164 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags)
1166 tree type = TREE_TYPE (exp);
1167 tree ctor_name;
1169 /* It fails because there may not be a constructor which takes
1170 its own type as the first (or only parameter), but which does
1171 take other types via a conversion. So, if the thing initializing
1172 the expression is a unit element of type X, first try X(X&),
1173 followed by initialization by X. If neither of these work
1174 out, then look hard. */
1175 tree rval;
1176 tree parms;
1178 if (init && TREE_CODE (init) != TREE_LIST
1179 && (flags & LOOKUP_ONLYCONVERTING))
1181 /* Base subobjects should only get direct-initialization. */
1182 gcc_assert (true_exp == exp);
1184 if (flags & DIRECT_BIND)
1185 /* Do nothing. We hit this in two cases: Reference initialization,
1186 where we aren't initializing a real variable, so we don't want
1187 to run a new constructor; and catching an exception, where we
1188 have already built up the constructor call so we could wrap it
1189 in an exception region. */;
1190 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
1192 /* A brace-enclosed initializer for an aggregate. */
1193 gcc_assert (CP_AGGREGATE_TYPE_P (type));
1194 init = digest_init (type, init, (tree *)NULL);
1196 else
1197 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1199 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1200 /* We need to protect the initialization of a catch parm with a
1201 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1202 around the TARGET_EXPR for the copy constructor. See
1203 initialize_handler_parm. */
1205 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1206 TREE_OPERAND (init, 0));
1207 TREE_TYPE (init) = void_type_node;
1209 else
1210 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1211 TREE_SIDE_EFFECTS (init) = 1;
1212 finish_expr_stmt (init);
1213 return;
1216 if (init == NULL_TREE
1217 || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1219 parms = init;
1220 if (parms)
1221 init = TREE_VALUE (parms);
1223 else
1224 parms = build_tree_list (NULL_TREE, init);
1226 if (true_exp == exp)
1227 ctor_name = complete_ctor_identifier;
1228 else
1229 ctor_name = base_ctor_identifier;
1231 rval = build_special_member_call (exp, ctor_name, parms, binfo, flags);
1232 if (TREE_SIDE_EFFECTS (rval))
1233 finish_expr_stmt (convert_to_void (rval, NULL));
1236 /* This function is responsible for initializing EXP with INIT
1237 (if any).
1239 BINFO is the binfo of the type for who we are performing the
1240 initialization. For example, if W is a virtual base class of A and B,
1241 and C : A, B.
1242 If we are initializing B, then W must contain B's W vtable, whereas
1243 were we initializing C, W must contain C's W vtable.
1245 TRUE_EXP is nonzero if it is the true expression being initialized.
1246 In this case, it may be EXP, or may just contain EXP. The reason we
1247 need this is because if EXP is a base element of TRUE_EXP, we
1248 don't necessarily know by looking at EXP where its virtual
1249 baseclass fields should really be pointing. But we do know
1250 from TRUE_EXP. In constructors, we don't know anything about
1251 the value being initialized.
1253 FLAGS is just passed to `build_new_method_call'. See that function
1254 for its description. */
1256 static void
1257 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags)
1259 tree type = TREE_TYPE (exp);
1261 gcc_assert (init != error_mark_node && type != error_mark_node);
1262 gcc_assert (building_stmt_tree ());
1264 /* Use a function returning the desired type to initialize EXP for us.
1265 If the function is a constructor, and its first argument is
1266 NULL_TREE, know that it was meant for us--just slide exp on
1267 in and expand the constructor. Constructors now come
1268 as TARGET_EXPRs. */
1270 if (init && TREE_CODE (exp) == VAR_DECL
1271 && TREE_CODE (init) == CONSTRUCTOR
1272 && TREE_HAS_CONSTRUCTOR (init))
1274 /* If store_init_value returns NULL_TREE, the INIT has been
1275 record in the DECL_INITIAL for EXP. That means there's
1276 nothing more we have to do. */
1277 init = store_init_value (exp, init);
1278 if (init)
1279 finish_expr_stmt (init);
1280 return;
1283 /* We know that expand_default_init can handle everything we want
1284 at this point. */
1285 expand_default_init (binfo, true_exp, exp, init, flags);
1288 /* Report an error if TYPE is not a user-defined, aggregate type. If
1289 OR_ELSE is nonzero, give an error message. */
1292 is_aggr_type (tree type, int or_else)
1294 if (type == error_mark_node)
1295 return 0;
1297 if (! IS_AGGR_TYPE (type)
1298 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1299 && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
1301 if (or_else)
1302 error ("%qT is not an aggregate type", type);
1303 return 0;
1305 return 1;
1308 tree
1309 get_type_value (tree name)
1311 if (name == error_mark_node)
1312 return NULL_TREE;
1314 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1315 return IDENTIFIER_TYPE_VALUE (name);
1316 else
1317 return NULL_TREE;
1320 /* Build a reference to a member of an aggregate. This is not a C++
1321 `&', but really something which can have its address taken, and
1322 then act as a pointer to member, for example TYPE :: FIELD can have
1323 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1324 this expression is the operand of "&".
1326 @@ Prints out lousy diagnostics for operator <typename>
1327 @@ fields.
1329 @@ This function should be rewritten and placed in search.c. */
1331 tree
1332 build_offset_ref (tree type, tree name, bool address_p)
1334 tree decl;
1335 tree member;
1336 tree basebinfo = NULL_TREE;
1337 tree orig_name = name;
1339 /* class templates can come in as TEMPLATE_DECLs here. */
1340 if (TREE_CODE (name) == TEMPLATE_DECL)
1341 return name;
1343 if (dependent_type_p (type) || type_dependent_expression_p (name))
1344 return build_min_nt (SCOPE_REF, type, name);
1346 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1348 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1349 something like `a.template f<int>' or the like. For the most
1350 part, we treat this just like a.f. We do remember, however,
1351 the template-id that was used. */
1352 name = TREE_OPERAND (orig_name, 0);
1354 if (DECL_P (name))
1355 name = DECL_NAME (name);
1356 else
1358 if (TREE_CODE (name) == COMPONENT_REF)
1359 name = TREE_OPERAND (name, 1);
1360 if (TREE_CODE (name) == OVERLOAD)
1361 name = DECL_NAME (OVL_CURRENT (name));
1364 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1367 if (type == NULL_TREE)
1368 return error_mark_node;
1370 /* Handle namespace names fully here. */
1371 if (TREE_CODE (type) == NAMESPACE_DECL)
1373 tree t = lookup_namespace_name (type, name);
1374 if (t == error_mark_node)
1375 return t;
1376 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1377 /* Reconstruct the TEMPLATE_ID_EXPR. */
1378 t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t),
1379 t, TREE_OPERAND (orig_name, 1));
1380 if (! type_unknown_p (t))
1382 mark_used (t);
1383 t = convert_from_reference (t);
1385 return t;
1388 if (! is_aggr_type (type, 1))
1389 return error_mark_node;
1391 if (TREE_CODE (name) == BIT_NOT_EXPR)
1393 if (! check_dtor_name (type, name))
1394 error ("qualified type %qT does not match destructor name %<~%T%>",
1395 type, TREE_OPERAND (name, 0));
1396 name = dtor_identifier;
1399 if (!COMPLETE_TYPE_P (complete_type (type))
1400 && !TYPE_BEING_DEFINED (type))
1402 error ("incomplete type %qT does not have member %qD", type, name);
1403 return error_mark_node;
1406 /* Set up BASEBINFO for member lookup. */
1407 decl = maybe_dummy_object (type, &basebinfo);
1409 if (BASELINK_P (name) || DECL_P (name))
1410 member = name;
1411 else
1413 member = lookup_member (basebinfo, name, 1, 0);
1415 if (member == error_mark_node)
1416 return error_mark_node;
1419 if (!member)
1421 error ("%qD is not a member of type %qT", name, type);
1422 return error_mark_node;
1425 if (TREE_CODE (member) == TYPE_DECL)
1427 TREE_USED (member) = 1;
1428 return member;
1430 /* static class members and class-specific enum
1431 values can be returned without further ado. */
1432 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1434 mark_used (member);
1435 return convert_from_reference (member);
1438 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1440 error ("invalid pointer to bit-field %qD", member);
1441 return error_mark_node;
1444 /* A lot of this logic is now handled in lookup_member. */
1445 if (BASELINK_P (member))
1447 /* Go from the TREE_BASELINK to the member function info. */
1448 tree fnfields = member;
1449 tree t = BASELINK_FUNCTIONS (fnfields);
1451 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1453 /* The FNFIELDS are going to contain functions that aren't
1454 necessarily templates, and templates that don't
1455 necessarily match the explicit template parameters. We
1456 save all the functions, and the explicit parameters, and
1457 then figure out exactly what to instantiate with what
1458 arguments in instantiate_type. */
1460 if (TREE_CODE (t) != OVERLOAD)
1461 /* The code in instantiate_type which will process this
1462 expects to encounter OVERLOADs, not raw functions. */
1463 t = ovl_cons (t, NULL_TREE);
1465 t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t), t,
1466 TREE_OPERAND (orig_name, 1));
1467 t = build2 (OFFSET_REF, unknown_type_node, decl, t);
1469 PTRMEM_OK_P (t) = 1;
1471 return t;
1474 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1476 /* Get rid of a potential OVERLOAD around it. */
1477 t = OVL_CURRENT (t);
1479 /* Unique functions are handled easily. */
1481 /* For non-static member of base class, we need a special rule
1482 for access checking [class.protected]:
1484 If the access is to form a pointer to member, the
1485 nested-name-specifier shall name the derived class
1486 (or any class derived from that class). */
1487 if (address_p && DECL_P (t)
1488 && DECL_NONSTATIC_MEMBER_P (t))
1489 perform_or_defer_access_check (TYPE_BINFO (type), t);
1490 else
1491 perform_or_defer_access_check (basebinfo, t);
1493 mark_used (t);
1494 if (DECL_STATIC_FUNCTION_P (t))
1495 return t;
1496 member = t;
1498 else
1500 TREE_TYPE (fnfields) = unknown_type_node;
1501 member = fnfields;
1504 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1505 /* We need additional test besides the one in
1506 check_accessibility_of_qualified_id in case it is
1507 a pointer to non-static member. */
1508 perform_or_defer_access_check (TYPE_BINFO (type), member);
1510 if (!address_p)
1512 /* If MEMBER is non-static, then the program has fallen afoul of
1513 [expr.prim]:
1515 An id-expression that denotes a nonstatic data member or
1516 nonstatic member function of a class can only be used:
1518 -- as part of a class member access (_expr.ref_) in which the
1519 object-expression refers to the member's class or a class
1520 derived from that class, or
1522 -- to form a pointer to member (_expr.unary.op_), or
1524 -- in the body of a nonstatic member function of that class or
1525 of a class derived from that class (_class.mfct.nonstatic_), or
1527 -- in a mem-initializer for a constructor for that class or for
1528 a class derived from that class (_class.base.init_). */
1529 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1531 /* Build a representation of a the qualified name suitable
1532 for use as the operand to "&" -- even though the "&" is
1533 not actually present. */
1534 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1535 /* In Microsoft mode, treat a non-static member function as if
1536 it were a pointer-to-member. */
1537 if (flag_ms_extensions)
1539 PTRMEM_OK_P (member) = 1;
1540 return build_unary_op (ADDR_EXPR, member, 0);
1542 error ("invalid use of non-static member function %qD",
1543 TREE_OPERAND (member, 1));
1544 return member;
1546 else if (TREE_CODE (member) == FIELD_DECL)
1548 error ("invalid use of non-static data member %qD", member);
1549 return error_mark_node;
1551 return member;
1554 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1555 PTRMEM_OK_P (member) = 1;
1556 return member;
1559 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1560 constant of integral or enumeration type, then return that value.
1561 These are those variables permitted in constant expressions by
1562 [5.19/1]. FIXME:If we did lazy folding, this could be localized. */
1564 tree
1565 integral_constant_value (tree decl)
1567 while ((TREE_CODE (decl) == CONST_DECL
1568 || (TREE_CODE (decl) == VAR_DECL
1569 /* And so are variables with a 'const' type -- unless they
1570 are also 'volatile'. */
1571 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl))
1572 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)))
1573 && DECL_INITIAL (decl)
1574 && DECL_INITIAL (decl) != error_mark_node
1575 && TREE_TYPE (DECL_INITIAL (decl))
1576 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl)))
1577 decl = DECL_INITIAL (decl);
1578 return decl;
1581 /* A more relaxed version of integral_constant_value, for which type
1582 is not considered. This is used by the common C/C++ code, and not
1583 directly by the C++ front end. */
1585 tree
1586 decl_constant_value (tree decl)
1588 if ((TREE_CODE (decl) == CONST_DECL
1589 || (TREE_CODE (decl) == VAR_DECL
1590 /* And so are variables with a 'const' type -- unless they
1591 are also 'volatile'. */
1592 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl))))
1593 && DECL_INITIAL (decl)
1594 && DECL_INITIAL (decl) != error_mark_node
1595 /* This is invalid if initial value is not constant. If it has
1596 either a function call, a memory reference, or a variable,
1597 then re-evaluating it could give different results. */
1598 && TREE_CONSTANT (DECL_INITIAL (decl)))
1599 return DECL_INITIAL (decl);
1601 return decl;
1604 /* Common subroutines of build_new and build_vec_delete. */
1606 /* Call the global __builtin_delete to delete ADDR. */
1608 static tree
1609 build_builtin_delete_call (tree addr)
1611 mark_used (global_delete_fndecl);
1612 return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
1615 /* Generate a representation for a C++ "new" expression. PLACEMENT is
1616 a TREE_LIST of placement-new arguments (or NULL_TREE if none). If
1617 NELTS is NULL, TYPE is the type of the storage to be allocated. If
1618 NELTS is not NULL, then this is an array-new allocation; TYPE is
1619 the type of the elements in the array and NELTS is the number of
1620 elements in the array. INIT, if non-NULL, is the initializer for
1621 the new object. If USE_GLOBAL_NEW is true, then the user
1622 explicitly wrote "::new" rather than just "new". */
1624 tree
1625 build_new (tree placement, tree type, tree nelts, tree init,
1626 int use_global_new)
1628 tree rval;
1630 if (type == error_mark_node)
1631 return error_mark_node;
1633 if (processing_template_decl)
1635 rval = build_min (NEW_EXPR, build_pointer_type (type),
1636 placement, type, nelts, init);
1637 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1638 TREE_SIDE_EFFECTS (rval) = 1;
1639 return rval;
1642 if (nelts)
1644 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
1645 pedwarn ("size in array new must have integral type");
1646 nelts = save_expr (cp_convert (sizetype, nelts));
1647 if (nelts == integer_zero_node)
1648 warning (0, "zero size array reserves no space");
1651 /* ``A reference cannot be created by the new operator. A reference
1652 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
1653 returned by new.'' ARM 5.3.3 */
1654 if (TREE_CODE (type) == REFERENCE_TYPE)
1656 error ("new cannot be applied to a reference type");
1657 type = TREE_TYPE (type);
1660 if (TREE_CODE (type) == FUNCTION_TYPE)
1662 error ("new cannot be applied to a function type");
1663 return error_mark_node;
1666 rval = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
1667 nelts, init);
1668 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1669 TREE_SIDE_EFFECTS (rval) = 1;
1670 rval = build_new_1 (rval);
1671 if (rval == error_mark_node)
1672 return error_mark_node;
1674 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
1675 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
1676 TREE_NO_WARNING (rval) = 1;
1678 return rval;
1681 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
1683 tree
1684 build_java_class_ref (tree type)
1686 tree name = NULL_TREE, class_decl;
1687 static tree CL_suffix = NULL_TREE;
1688 if (CL_suffix == NULL_TREE)
1689 CL_suffix = get_identifier("class$");
1690 if (jclass_node == NULL_TREE)
1692 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
1693 if (jclass_node == NULL_TREE)
1694 fatal_error ("call to Java constructor, while %<jclass%> undefined");
1696 jclass_node = TREE_TYPE (jclass_node);
1699 /* Mangle the class$ field. */
1701 tree field;
1702 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1703 if (DECL_NAME (field) == CL_suffix)
1705 mangle_decl (field);
1706 name = DECL_ASSEMBLER_NAME (field);
1707 break;
1709 if (!field)
1710 internal_error ("can't find class$");
1713 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
1714 if (class_decl == NULL_TREE)
1716 class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
1717 TREE_STATIC (class_decl) = 1;
1718 DECL_EXTERNAL (class_decl) = 1;
1719 TREE_PUBLIC (class_decl) = 1;
1720 DECL_ARTIFICIAL (class_decl) = 1;
1721 DECL_IGNORED_P (class_decl) = 1;
1722 pushdecl_top_level (class_decl);
1723 make_decl_rtl (class_decl);
1725 return class_decl;
1729 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
1730 value is immediately handed to expand_expr. */
1732 static tree
1733 build_new_1 (tree exp)
1735 tree placement, init;
1736 tree size, rval;
1737 /* True iff this is a call to "operator new[]" instead of just
1738 "operator new". */
1739 bool array_p = false;
1740 /* True iff ARRAY_P is true and the bound of the array type is
1741 not necessarily a compile time constant. For example, VLA_P is
1742 true for "new int[f()]". */
1743 bool vla_p = false;
1744 /* The type being allocated. If ARRAY_P is true, this will be an
1745 ARRAY_TYPE. */
1746 tree full_type;
1747 /* If ARRAY_P is true, the element type of the array. This is an
1748 never ARRAY_TYPE; for something like "new int[3][4]", the
1749 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1750 FULL_TYPE. */
1751 tree elt_type;
1752 /* The type of the new-expression. (This type is always a pointer
1753 type.) */
1754 tree pointer_type;
1755 /* The type pointed to by POINTER_TYPE. This type may be different
1756 from ELT_TYPE for a multi-dimensional array; ELT_TYPE is never an
1757 ARRAY_TYPE, but TYPE may be an ARRAY_TYPE. */
1758 tree type;
1759 /* A pointer type pointing to the FULL_TYPE. */
1760 tree full_pointer_type;
1761 tree outer_nelts = NULL_TREE;
1762 tree nelts = NULL_TREE;
1763 tree alloc_call, alloc_expr;
1764 /* The address returned by the call to "operator new". This node is
1765 a VAR_DECL and is therefore reusable. */
1766 tree alloc_node;
1767 tree alloc_fn;
1768 tree cookie_expr, init_expr;
1769 int nothrow, check_new;
1770 /* Nonzero if the user wrote `::new' rather than just `new'. */
1771 int globally_qualified_p;
1772 int use_java_new = 0;
1773 /* If non-NULL, the number of extra bytes to allocate at the
1774 beginning of the storage allocated for an array-new expression in
1775 order to store the number of elements. */
1776 tree cookie_size = NULL_TREE;
1777 /* True if the function we are calling is a placement allocation
1778 function. */
1779 bool placement_allocation_fn_p;
1780 tree args = NULL_TREE;
1781 /* True if the storage must be initialized, either by a constructor
1782 or due to an explicit new-initializer. */
1783 bool is_initialized;
1784 /* The address of the thing allocated, not including any cookie. In
1785 particular, if an array cookie is in use, DATA_ADDR is the
1786 address of the first array element. This node is a VAR_DECL, and
1787 is therefore reusable. */
1788 tree data_addr;
1789 tree init_preeval_expr = NULL_TREE;
1791 placement = TREE_OPERAND (exp, 0);
1792 type = TREE_OPERAND (exp, 1);
1793 nelts = TREE_OPERAND (exp, 2);
1794 init = TREE_OPERAND (exp, 3);
1795 globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
1797 if (nelts)
1799 tree index;
1801 outer_nelts = nelts;
1802 array_p = true;
1804 /* ??? The middle-end will error on us for building a VLA outside a
1805 function context. Methinks that's not it's purvey. So we'll do
1806 our own VLA layout later. */
1807 vla_p = true;
1808 full_type = build_cplus_array_type (type, NULL_TREE);
1809 index = convert (sizetype, nelts);
1810 index = size_binop (MINUS_EXPR, index, size_one_node);
1811 TYPE_DOMAIN (full_type) = build_index_type (index);
1813 else
1815 full_type = type;
1816 if (TREE_CODE (type) == ARRAY_TYPE)
1818 array_p = true;
1819 nelts = array_type_nelts_top (type);
1820 outer_nelts = nelts;
1821 type = TREE_TYPE (type);
1825 /* If our base type is an array, then make sure we know how many elements
1826 it has. */
1827 for (elt_type = type;
1828 TREE_CODE (elt_type) == ARRAY_TYPE;
1829 elt_type = TREE_TYPE (elt_type))
1830 nelts = cp_build_binary_op (MULT_EXPR, nelts,
1831 array_type_nelts_top (elt_type));
1833 if (!complete_type_or_else (elt_type, exp))
1834 return error_mark_node;
1836 if (TREE_CODE (elt_type) == VOID_TYPE)
1838 error ("invalid type %<void%> for new");
1839 return error_mark_node;
1842 if (abstract_virtuals_error (NULL_TREE, elt_type))
1843 return error_mark_node;
1845 is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || init);
1846 if (CP_TYPE_CONST_P (elt_type) && !is_initialized)
1848 error ("uninitialized const in %<new%> of %q#T", elt_type);
1849 return error_mark_node;
1852 size = size_in_bytes (elt_type);
1853 if (array_p)
1855 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1856 if (vla_p)
1858 tree n, bitsize;
1860 /* Do our own VLA layout. Setting TYPE_SIZE/_UNIT is
1861 necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
1862 ...>> to be valid. */
1863 TYPE_SIZE_UNIT (full_type) = size;
1864 n = convert (bitsizetype, nelts);
1865 bitsize = size_binop (MULT_EXPR, TYPE_SIZE (elt_type), n);
1866 TYPE_SIZE (full_type) = bitsize;
1870 /* Allocate the object. */
1871 if (! placement && TYPE_FOR_JAVA (elt_type))
1873 tree class_addr, alloc_decl;
1874 tree class_decl = build_java_class_ref (elt_type);
1875 static const char alloc_name[] = "_Jv_AllocObject";
1877 use_java_new = 1;
1878 alloc_decl = NULL;
1879 if (!get_global_value_if_present (get_identifier (alloc_name),
1880 &alloc_decl))
1882 error ("call to Java constructor with %qs undefined", alloc_name);
1883 return error_mark_node;
1885 else if (really_overloaded_fn (alloc_decl))
1887 error ("%qD should never be overloaded", alloc_decl);
1888 return error_mark_node;
1890 alloc_decl = OVL_CURRENT (alloc_decl);
1891 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1892 alloc_call = (build_function_call
1893 (alloc_decl,
1894 build_tree_list (NULL_TREE, class_addr)));
1896 else
1898 tree fnname;
1899 tree fns;
1901 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
1903 if (!globally_qualified_p
1904 && CLASS_TYPE_P (elt_type)
1905 && (array_p
1906 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
1907 : TYPE_HAS_NEW_OPERATOR (elt_type)))
1909 /* Use a class-specific operator new. */
1910 /* If a cookie is required, add some extra space. */
1911 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1913 cookie_size = targetm.cxx.get_cookie_size (elt_type);
1914 size = size_binop (PLUS_EXPR, size, cookie_size);
1916 /* Create the argument list. */
1917 args = tree_cons (NULL_TREE, size, placement);
1918 /* Do name-lookup to find the appropriate operator. */
1919 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
1920 if (TREE_CODE (fns) == TREE_LIST)
1922 error ("request for member %qD is ambiguous", fnname);
1923 print_candidates (fns);
1924 return error_mark_node;
1926 alloc_call = build_new_method_call (build_dummy_object (elt_type),
1927 fns, args,
1928 /*conversion_path=*/NULL_TREE,
1929 LOOKUP_NORMAL);
1931 else
1933 /* Use a global operator new. */
1934 /* See if a cookie might be required. */
1935 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1936 cookie_size = targetm.cxx.get_cookie_size (elt_type);
1937 else
1938 cookie_size = NULL_TREE;
1940 alloc_call = build_operator_new_call (fnname, placement,
1941 &size, &cookie_size);
1945 if (alloc_call == error_mark_node)
1946 return error_mark_node;
1948 /* In the simple case, we can stop now. */
1949 pointer_type = build_pointer_type (type);
1950 if (!cookie_size && !is_initialized)
1951 return build_nop (pointer_type, alloc_call);
1953 /* While we're working, use a pointer to the type we've actually
1954 allocated. Store the result of the call in a variable so that we
1955 can use it more than once. */
1956 full_pointer_type = build_pointer_type (full_type);
1957 alloc_expr = get_target_expr (build_nop (full_pointer_type, alloc_call));
1958 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
1960 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
1961 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
1962 alloc_call = TREE_OPERAND (alloc_call, 1);
1963 alloc_fn = get_callee_fndecl (alloc_call);
1964 gcc_assert (alloc_fn != NULL_TREE);
1966 /* Now, check to see if this function is actually a placement
1967 allocation function. This can happen even when PLACEMENT is NULL
1968 because we might have something like:
1970 struct S { void* operator new (size_t, int i = 0); };
1972 A call to `new S' will get this allocation function, even though
1973 there is no explicit placement argument. If there is more than
1974 one argument, or there are variable arguments, then this is a
1975 placement allocation function. */
1976 placement_allocation_fn_p
1977 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
1978 || varargs_function_p (alloc_fn));
1980 /* Preevaluate the placement args so that we don't reevaluate them for a
1981 placement delete. */
1982 if (placement_allocation_fn_p)
1984 tree inits;
1985 stabilize_call (alloc_call, &inits);
1986 if (inits)
1987 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
1988 alloc_expr);
1991 /* unless an allocation function is declared with an empty excep-
1992 tion-specification (_except.spec_), throw(), it indicates failure to
1993 allocate storage by throwing a bad_alloc exception (clause _except_,
1994 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
1995 cation function is declared with an empty exception-specification,
1996 throw(), it returns null to indicate failure to allocate storage and a
1997 non-null pointer otherwise.
1999 So check for a null exception spec on the op new we just called. */
2001 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2002 check_new = (flag_check_new || nothrow) && ! use_java_new;
2004 if (cookie_size)
2006 tree cookie;
2007 tree cookie_ptr;
2009 /* Adjust so we're pointing to the start of the object. */
2010 data_addr = get_target_expr (build2 (PLUS_EXPR, full_pointer_type,
2011 alloc_node, cookie_size));
2013 /* Store the number of bytes allocated so that we can know how
2014 many elements to destroy later. We use the last sizeof
2015 (size_t) bytes to store the number of elements. */
2016 cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2017 data_addr, size_in_bytes (sizetype));
2018 cookie = build_indirect_ref (cookie_ptr, NULL);
2020 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2022 if (targetm.cxx.cookie_has_size ())
2024 /* Also store the element size. */
2025 cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2026 cookie_ptr, size_in_bytes (sizetype));
2027 cookie = build_indirect_ref (cookie_ptr, NULL);
2028 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2029 size_in_bytes(elt_type));
2030 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2031 cookie, cookie_expr);
2033 data_addr = TARGET_EXPR_SLOT (data_addr);
2035 else
2037 cookie_expr = NULL_TREE;
2038 data_addr = alloc_node;
2041 /* Now initialize the allocated object. Note that we preevaluate the
2042 initialization expression, apart from the actual constructor call or
2043 assignment--we do this because we want to delay the allocation as long
2044 as possible in order to minimize the size of the exception region for
2045 placement delete. */
2046 if (is_initialized)
2048 bool stable;
2050 init_expr = build_indirect_ref (data_addr, NULL);
2052 if (init == void_zero_node)
2053 init = build_default_init (full_type, nelts);
2054 else if (init && array_p)
2055 pedwarn ("ISO C++ forbids initialization in array new");
2057 if (array_p)
2059 init_expr
2060 = build_vec_init (init_expr,
2061 cp_build_binary_op (MINUS_EXPR, outer_nelts,
2062 integer_one_node),
2063 init, /*from_array=*/0);
2065 /* An array initialization is stable because the initialization
2066 of each element is a full-expression, so the temporaries don't
2067 leak out. */
2068 stable = true;
2070 else if (TYPE_NEEDS_CONSTRUCTING (type))
2072 init_expr = build_special_member_call (init_expr,
2073 complete_ctor_identifier,
2074 init, elt_type,
2075 LOOKUP_NORMAL);
2076 stable = stabilize_init (init_expr, &init_preeval_expr);
2078 else
2080 /* We are processing something like `new int (10)', which
2081 means allocate an int, and initialize it with 10. */
2083 if (TREE_CODE (init) == TREE_LIST)
2084 init = build_x_compound_expr_from_list (init, "new initializer");
2086 else
2087 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2088 || TREE_TYPE (init) != NULL_TREE);
2090 init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
2091 stable = stabilize_init (init_expr, &init_preeval_expr);
2094 if (init_expr == error_mark_node)
2095 return error_mark_node;
2097 /* If any part of the object initialization terminates by throwing an
2098 exception and a suitable deallocation function can be found, the
2099 deallocation function is called to free the memory in which the
2100 object was being constructed, after which the exception continues
2101 to propagate in the context of the new-expression. If no
2102 unambiguous matching deallocation function can be found,
2103 propagating the exception does not cause the object's memory to be
2104 freed. */
2105 if (flag_exceptions && ! use_java_new)
2107 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2108 tree cleanup;
2110 /* The Standard is unclear here, but the right thing to do
2111 is to use the same method for finding deallocation
2112 functions that we use for finding allocation functions. */
2113 cleanup = build_op_delete_call (dcode, alloc_node, size,
2114 globally_qualified_p,
2115 (placement_allocation_fn_p
2116 ? alloc_call : NULL_TREE));
2118 if (!cleanup)
2119 /* We're done. */;
2120 else if (stable)
2121 /* This is much simpler if we were able to preevaluate all of
2122 the arguments to the constructor call. */
2123 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2124 init_expr, cleanup);
2125 else
2126 /* Ack! First we allocate the memory. Then we set our sentry
2127 variable to true, and expand a cleanup that deletes the
2128 memory if sentry is true. Then we run the constructor, and
2129 finally clear the sentry.
2131 We need to do this because we allocate the space first, so
2132 if there are any temporaries with cleanups in the
2133 constructor args and we weren't able to preevaluate them, we
2134 need this EH region to extend until end of full-expression
2135 to preserve nesting. */
2137 tree end, sentry, begin;
2139 begin = get_target_expr (boolean_true_node);
2140 CLEANUP_EH_ONLY (begin) = 1;
2142 sentry = TARGET_EXPR_SLOT (begin);
2144 TARGET_EXPR_CLEANUP (begin)
2145 = build3 (COND_EXPR, void_type_node, sentry,
2146 cleanup, void_zero_node);
2148 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2149 sentry, boolean_false_node);
2151 init_expr
2152 = build2 (COMPOUND_EXPR, void_type_node, begin,
2153 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2154 end));
2159 else
2160 init_expr = NULL_TREE;
2162 /* Now build up the return value in reverse order. */
2164 rval = data_addr;
2166 if (init_expr)
2167 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2168 if (cookie_expr)
2169 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2171 if (rval == alloc_node)
2172 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2173 and return the call (which doesn't need to be adjusted). */
2174 rval = TARGET_EXPR_INITIAL (alloc_expr);
2175 else
2177 if (check_new)
2179 tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
2180 integer_zero_node);
2181 rval = build_conditional_expr (ifexp, rval, alloc_node);
2184 /* Perform the allocation before anything else, so that ALLOC_NODE
2185 has been initialized before we start using it. */
2186 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2189 if (init_preeval_expr)
2190 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2192 /* Convert to the final type. */
2193 rval = build_nop (pointer_type, rval);
2195 /* A new-expression is never an lvalue. */
2196 if (real_lvalue_p (rval))
2197 rval = build1 (NON_LVALUE_EXPR, TREE_TYPE (rval), rval);
2199 return rval;
2202 static tree
2203 build_vec_delete_1 (tree base, tree maxindex, tree type,
2204 special_function_kind auto_delete_vec, int use_global_delete)
2206 tree virtual_size;
2207 tree ptype = build_pointer_type (type = complete_type (type));
2208 tree size_exp = size_in_bytes (type);
2210 /* Temporary variables used by the loop. */
2211 tree tbase, tbase_init;
2213 /* This is the body of the loop that implements the deletion of a
2214 single element, and moves temp variables to next elements. */
2215 tree body;
2217 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2218 tree loop = 0;
2220 /* This is the thing that governs what to do after the loop has run. */
2221 tree deallocate_expr = 0;
2223 /* This is the BIND_EXPR which holds the outermost iterator of the
2224 loop. It is convenient to set this variable up and test it before
2225 executing any other code in the loop.
2226 This is also the containing expression returned by this function. */
2227 tree controller = NULL_TREE;
2229 /* We should only have 1-D arrays here. */
2230 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2232 if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2233 goto no_destructor;
2235 /* The below is short by the cookie size. */
2236 virtual_size = size_binop (MULT_EXPR, size_exp,
2237 convert (sizetype, maxindex));
2239 tbase = create_temporary_var (ptype);
2240 tbase_init = build_modify_expr (tbase, NOP_EXPR,
2241 fold_build2 (PLUS_EXPR, ptype,
2242 base,
2243 virtual_size));
2244 DECL_REGISTER (tbase) = 1;
2245 controller = build3 (BIND_EXPR, void_type_node, tbase,
2246 NULL_TREE, NULL_TREE);
2247 TREE_SIDE_EFFECTS (controller) = 1;
2249 body = build1 (EXIT_EXPR, void_type_node,
2250 build2 (EQ_EXPR, boolean_type_node, base, tbase));
2251 body = build_compound_expr
2252 (body, build_modify_expr (tbase, NOP_EXPR,
2253 build2 (MINUS_EXPR, ptype, tbase, size_exp)));
2254 body = build_compound_expr
2255 (body, build_delete (ptype, tbase, sfk_complete_destructor,
2256 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2258 loop = build1 (LOOP_EXPR, void_type_node, body);
2259 loop = build_compound_expr (tbase_init, loop);
2261 no_destructor:
2262 /* If the delete flag is one, or anything else with the low bit set,
2263 delete the storage. */
2264 if (auto_delete_vec != sfk_base_destructor)
2266 tree base_tbd;
2268 /* The below is short by the cookie size. */
2269 virtual_size = size_binop (MULT_EXPR, size_exp,
2270 convert (sizetype, maxindex));
2272 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2273 /* no header */
2274 base_tbd = base;
2275 else
2277 tree cookie_size;
2279 cookie_size = targetm.cxx.get_cookie_size (type);
2280 base_tbd
2281 = cp_convert (ptype,
2282 cp_build_binary_op (MINUS_EXPR,
2283 cp_convert (string_type_node,
2284 base),
2285 cookie_size));
2286 /* True size with header. */
2287 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2290 if (auto_delete_vec == sfk_deleting_destructor)
2291 deallocate_expr = build_x_delete (base_tbd,
2292 2 | use_global_delete,
2293 virtual_size);
2296 body = loop;
2297 if (!deallocate_expr)
2299 else if (!body)
2300 body = deallocate_expr;
2301 else
2302 body = build_compound_expr (body, deallocate_expr);
2304 if (!body)
2305 body = integer_zero_node;
2307 /* Outermost wrapper: If pointer is null, punt. */
2308 body = fold_build3 (COND_EXPR, void_type_node,
2309 fold_build2 (NE_EXPR, boolean_type_node, base,
2310 convert (TREE_TYPE (base),
2311 integer_zero_node)),
2312 body, integer_zero_node);
2313 body = build1 (NOP_EXPR, void_type_node, body);
2315 if (controller)
2317 TREE_OPERAND (controller, 1) = body;
2318 body = controller;
2321 if (TREE_CODE (base) == SAVE_EXPR)
2322 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2323 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2325 return convert_to_void (body, /*implicit=*/NULL);
2328 /* Create an unnamed variable of the indicated TYPE. */
2330 tree
2331 create_temporary_var (tree type)
2333 tree decl;
2335 decl = build_decl (VAR_DECL, NULL_TREE, type);
2336 TREE_USED (decl) = 1;
2337 DECL_ARTIFICIAL (decl) = 1;
2338 DECL_IGNORED_P (decl) = 1;
2339 DECL_SOURCE_LOCATION (decl) = input_location;
2340 DECL_CONTEXT (decl) = current_function_decl;
2342 return decl;
2345 /* Create a new temporary variable of the indicated TYPE, initialized
2346 to INIT.
2348 It is not entered into current_binding_level, because that breaks
2349 things when it comes time to do final cleanups (which take place
2350 "outside" the binding contour of the function). */
2352 static tree
2353 get_temp_regvar (tree type, tree init)
2355 tree decl;
2357 decl = create_temporary_var (type);
2358 add_decl_expr (decl);
2360 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
2362 return decl;
2365 /* `build_vec_init' returns tree structure that performs
2366 initialization of a vector of aggregate types.
2368 BASE is a reference to the vector, of ARRAY_TYPE.
2369 MAXINDEX is the maximum index of the array (one less than the
2370 number of elements). It is only used if
2371 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2372 INIT is the (possibly NULL) initializer.
2374 FROM_ARRAY is 0 if we should init everything with INIT
2375 (i.e., every element initialized from INIT).
2376 FROM_ARRAY is 1 if we should index into INIT in parallel
2377 with initialization of DECL.
2378 FROM_ARRAY is 2 if we should index into INIT in parallel,
2379 but use assignment instead of initialization. */
2381 tree
2382 build_vec_init (tree base, tree maxindex, tree init, int from_array)
2384 tree rval;
2385 tree base2 = NULL_TREE;
2386 tree size;
2387 tree itype = NULL_TREE;
2388 tree iterator;
2389 /* The type of the array. */
2390 tree atype = TREE_TYPE (base);
2391 /* The type of an element in the array. */
2392 tree type = TREE_TYPE (atype);
2393 /* The element type reached after removing all outer array
2394 types. */
2395 tree inner_elt_type;
2396 /* The type of a pointer to an element in the array. */
2397 tree ptype;
2398 tree stmt_expr;
2399 tree compound_stmt;
2400 int destroy_temps;
2401 tree try_block = NULL_TREE;
2402 int num_initialized_elts = 0;
2403 bool is_global;
2405 if (TYPE_DOMAIN (atype))
2406 maxindex = array_type_nelts (atype);
2408 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2409 return error_mark_node;
2411 inner_elt_type = strip_array_types (atype);
2412 if (init
2413 && (from_array == 2
2414 ? (!CLASS_TYPE_P (inner_elt_type)
2415 || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2416 : !TYPE_NEEDS_CONSTRUCTING (type))
2417 && ((TREE_CODE (init) == CONSTRUCTOR
2418 /* Don't do this if the CONSTRUCTOR might contain something
2419 that might throw and require us to clean up. */
2420 && (CONSTRUCTOR_ELTS (init) == NULL_TREE
2421 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2422 || from_array))
2424 /* Do non-default initialization of POD arrays resulting from
2425 brace-enclosed initializers. In this case, digest_init and
2426 store_constructor will handle the semantics for us. */
2428 stmt_expr = build2 (INIT_EXPR, atype, base, init);
2429 return stmt_expr;
2432 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2433 ptype = build_pointer_type (type);
2434 size = size_in_bytes (type);
2435 if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
2436 base = cp_convert (ptype, decay_conversion (base));
2438 /* The code we are generating looks like:
2440 T* t1 = (T*) base;
2441 T* rval = t1;
2442 ptrdiff_t iterator = maxindex;
2443 try {
2444 for (; iterator != -1; --iterator) {
2445 ... initialize *t1 ...
2446 ++t1;
2448 } catch (...) {
2449 ... destroy elements that were constructed ...
2451 rval;
2454 We can omit the try and catch blocks if we know that the
2455 initialization will never throw an exception, or if the array
2456 elements do not have destructors. We can omit the loop completely if
2457 the elements of the array do not have constructors.
2459 We actually wrap the entire body of the above in a STMT_EXPR, for
2460 tidiness.
2462 When copying from array to another, when the array elements have
2463 only trivial copy constructors, we should use __builtin_memcpy
2464 rather than generating a loop. That way, we could take advantage
2465 of whatever cleverness the back-end has for dealing with copies
2466 of blocks of memory. */
2468 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2469 destroy_temps = stmts_are_full_exprs_p ();
2470 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2471 rval = get_temp_regvar (ptype, base);
2472 base = get_temp_regvar (ptype, rval);
2473 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2475 /* Protect the entire array initialization so that we can destroy
2476 the partially constructed array if an exception is thrown.
2477 But don't do this if we're assigning. */
2478 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2479 && from_array != 2)
2481 try_block = begin_try_block ();
2484 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2486 /* Do non-default initialization of non-POD arrays resulting from
2487 brace-enclosed initializers. */
2489 tree elts;
2490 from_array = 0;
2492 for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
2494 tree elt = TREE_VALUE (elts);
2495 tree baseref = build1 (INDIRECT_REF, type, base);
2497 num_initialized_elts++;
2499 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2500 if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2501 finish_expr_stmt (build_aggr_init (baseref, elt, 0));
2502 else
2503 finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
2504 elt));
2505 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2507 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2508 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
2511 /* Clear out INIT so that we don't get confused below. */
2512 init = NULL_TREE;
2514 else if (from_array)
2516 /* If initializing one array from another, initialize element by
2517 element. We rely upon the below calls the do argument
2518 checking. */
2519 if (init)
2521 base2 = decay_conversion (init);
2522 itype = TREE_TYPE (base2);
2523 base2 = get_temp_regvar (itype, base2);
2524 itype = TREE_TYPE (itype);
2526 else if (TYPE_LANG_SPECIFIC (type)
2527 && TYPE_NEEDS_CONSTRUCTING (type)
2528 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2530 error ("initializer ends prematurely");
2531 return error_mark_node;
2535 /* Now, default-initialize any remaining elements. We don't need to
2536 do that if a) the type does not need constructing, or b) we've
2537 already initialized all the elements.
2539 We do need to keep going if we're copying an array. */
2541 if (from_array
2542 || (TYPE_NEEDS_CONSTRUCTING (type)
2543 && ! (host_integerp (maxindex, 0)
2544 && (num_initialized_elts
2545 == tree_low_cst (maxindex, 0) + 1))))
2547 /* If the ITERATOR is equal to -1, then we don't have to loop;
2548 we've already initialized all the elements. */
2549 tree for_stmt;
2550 tree elt_init;
2552 for_stmt = begin_for_stmt ();
2553 finish_for_init_stmt (for_stmt);
2554 finish_for_cond (build2 (NE_EXPR, boolean_type_node,
2555 iterator, integer_minus_one_node),
2556 for_stmt);
2557 finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0),
2558 for_stmt);
2560 if (from_array)
2562 tree to = build1 (INDIRECT_REF, type, base);
2563 tree from;
2565 if (base2)
2566 from = build1 (INDIRECT_REF, itype, base2);
2567 else
2568 from = NULL_TREE;
2570 if (from_array == 2)
2571 elt_init = build_modify_expr (to, NOP_EXPR, from);
2572 else if (TYPE_NEEDS_CONSTRUCTING (type))
2573 elt_init = build_aggr_init (to, from, 0);
2574 else if (from)
2575 elt_init = build_modify_expr (to, NOP_EXPR, from);
2576 else
2577 gcc_unreachable ();
2579 else if (TREE_CODE (type) == ARRAY_TYPE)
2581 if (init != 0)
2582 sorry
2583 ("cannot initialize multi-dimensional array with initializer");
2584 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2585 0, 0, 0);
2587 else
2588 elt_init = build_aggr_init (build1 (INDIRECT_REF, type, base),
2589 init, 0);
2591 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2592 finish_expr_stmt (elt_init);
2593 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2595 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2596 if (base2)
2597 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));
2599 finish_for_stmt (for_stmt);
2602 /* Make sure to cleanup any partially constructed elements. */
2603 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2604 && from_array != 2)
2606 tree e;
2607 tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);
2609 /* Flatten multi-dimensional array since build_vec_delete only
2610 expects one-dimensional array. */
2611 if (TREE_CODE (type) == ARRAY_TYPE)
2612 m = cp_build_binary_op (MULT_EXPR, m,
2613 array_type_nelts_total (type));
2615 finish_cleanup_try_block (try_block);
2616 e = build_vec_delete_1 (rval, m,
2617 inner_elt_type, sfk_base_destructor,
2618 /*use_global_delete=*/0);
2619 finish_cleanup (e, try_block);
2622 /* The value of the array initialization is the array itself, RVAL
2623 is a pointer to the first element. */
2624 finish_stmt_expr_expr (rval, stmt_expr);
2626 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2628 /* Now convert make the result have the correct type. */
2629 atype = build_pointer_type (atype);
2630 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2631 stmt_expr = build_indirect_ref (stmt_expr, NULL);
2633 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2634 return stmt_expr;
2637 /* Free up storage of type TYPE, at address ADDR.
2639 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2640 of pointer.
2642 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2643 used as the second argument to operator delete. It can include
2644 things like padding and magic size cookies. It has virtual in it,
2645 because if you have a base pointer and you delete through a virtual
2646 destructor, it should be the size of the dynamic object, not the
2647 static object, see Free Store 12.5 ISO C++.
2649 This does not call any destructors. */
2651 tree
2652 build_x_delete (tree addr, int which_delete, tree virtual_size)
2654 int use_global_delete = which_delete & 1;
2655 int use_vec_delete = !!(which_delete & 2);
2656 enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
2658 return build_op_delete_call (code, addr, virtual_size, use_global_delete,
2659 NULL_TREE);
2662 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
2663 build_delete. */
2665 static tree
2666 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2668 tree name;
2669 tree fn;
2670 switch (dtor_kind)
2672 case sfk_complete_destructor:
2673 name = complete_dtor_identifier;
2674 break;
2676 case sfk_base_destructor:
2677 name = base_dtor_identifier;
2678 break;
2680 case sfk_deleting_destructor:
2681 name = deleting_dtor_identifier;
2682 break;
2684 default:
2685 gcc_unreachable ();
2687 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2688 return build_new_method_call (exp, fn,
2689 /*args=*/NULL_TREE,
2690 /*conversion_path=*/NULL_TREE,
2691 flags);
2694 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2695 ADDR is an expression which yields the store to be destroyed.
2696 AUTO_DELETE is the name of the destructor to call, i.e., either
2697 sfk_complete_destructor, sfk_base_destructor, or
2698 sfk_deleting_destructor.
2700 FLAGS is the logical disjunction of zero or more LOOKUP_
2701 flags. See cp-tree.h for more info. */
2703 tree
2704 build_delete (tree type, tree addr, special_function_kind auto_delete,
2705 int flags, int use_global_delete)
2707 tree expr;
2709 if (addr == error_mark_node)
2710 return error_mark_node;
2712 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2713 set to `error_mark_node' before it gets properly cleaned up. */
2714 if (type == error_mark_node)
2715 return error_mark_node;
2717 type = TYPE_MAIN_VARIANT (type);
2719 if (TREE_CODE (type) == POINTER_TYPE)
2721 bool complete_p = true;
2723 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2724 if (TREE_CODE (type) == ARRAY_TYPE)
2725 goto handle_array;
2727 /* We don't want to warn about delete of void*, only other
2728 incomplete types. Deleting other incomplete types
2729 invokes undefined behavior, but it is not ill-formed, so
2730 compile to something that would even do The Right Thing
2731 (TM) should the type have a trivial dtor and no delete
2732 operator. */
2733 if (!VOID_TYPE_P (type))
2735 complete_type (type);
2736 if (!COMPLETE_TYPE_P (type))
2738 warning (0, "possible problem detected in invocation of "
2739 "delete operator:");
2740 cxx_incomplete_type_diagnostic (addr, type, 1);
2741 inform ("neither the destructor nor the class-specific "
2742 "operator delete will be called, even if they are "
2743 "declared when the class is defined.");
2744 complete_p = false;
2747 if (VOID_TYPE_P (type) || !complete_p || !IS_AGGR_TYPE (type))
2748 /* Call the builtin operator delete. */
2749 return build_builtin_delete_call (addr);
2750 if (TREE_SIDE_EFFECTS (addr))
2751 addr = save_expr (addr);
2753 /* Throw away const and volatile on target type of addr. */
2754 addr = convert_force (build_pointer_type (type), addr, 0);
2756 else if (TREE_CODE (type) == ARRAY_TYPE)
2758 handle_array:
2760 if (TYPE_DOMAIN (type) == NULL_TREE)
2762 error ("unknown array size in delete");
2763 return error_mark_node;
2765 return build_vec_delete (addr, array_type_nelts (type),
2766 auto_delete, use_global_delete);
2768 else
2770 /* Don't check PROTECT here; leave that decision to the
2771 destructor. If the destructor is accessible, call it,
2772 else report error. */
2773 addr = build_unary_op (ADDR_EXPR, addr, 0);
2774 if (TREE_SIDE_EFFECTS (addr))
2775 addr = save_expr (addr);
2777 addr = convert_force (build_pointer_type (type), addr, 0);
2780 gcc_assert (IS_AGGR_TYPE (type));
2782 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2784 if (auto_delete != sfk_deleting_destructor)
2785 return void_zero_node;
2787 return build_op_delete_call
2788 (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), use_global_delete,
2789 NULL_TREE);
2791 else
2793 tree do_delete = NULL_TREE;
2794 tree ifexp;
2796 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
2797 lazily_declare_fn (sfk_destructor, type);
2799 /* For `::delete x', we must not use the deleting destructor
2800 since then we would not be sure to get the global `operator
2801 delete'. */
2802 if (use_global_delete && auto_delete == sfk_deleting_destructor)
2804 /* We will use ADDR multiple times so we must save it. */
2805 addr = save_expr (addr);
2806 /* Delete the object. */
2807 do_delete = build_builtin_delete_call (addr);
2808 /* Otherwise, treat this like a complete object destructor
2809 call. */
2810 auto_delete = sfk_complete_destructor;
2812 /* If the destructor is non-virtual, there is no deleting
2813 variant. Instead, we must explicitly call the appropriate
2814 `operator delete' here. */
2815 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
2816 && auto_delete == sfk_deleting_destructor)
2818 /* We will use ADDR multiple times so we must save it. */
2819 addr = save_expr (addr);
2820 /* Build the call. */
2821 do_delete = build_op_delete_call (DELETE_EXPR,
2822 addr,
2823 cxx_sizeof_nowarn (type),
2824 /*global_p=*/false,
2825 NULL_TREE);
2826 /* Call the complete object destructor. */
2827 auto_delete = sfk_complete_destructor;
2829 else if (auto_delete == sfk_deleting_destructor
2830 && TYPE_GETS_REG_DELETE (type))
2832 /* Make sure we have access to the member op delete, even though
2833 we'll actually be calling it from the destructor. */
2834 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2835 /*global_p=*/false, NULL_TREE);
2838 expr = build_dtor_call (build_indirect_ref (addr, NULL),
2839 auto_delete, flags);
2840 if (do_delete)
2841 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
2843 if (flags & LOOKUP_DESTRUCTOR)
2844 /* Explicit destructor call; don't check for null pointer. */
2845 ifexp = integer_one_node;
2846 else
2847 /* Handle deleting a null pointer. */
2848 ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
2850 if (ifexp != integer_one_node)
2851 expr = build3 (COND_EXPR, void_type_node,
2852 ifexp, expr, void_zero_node);
2854 return expr;
2858 /* At the beginning of a destructor, push cleanups that will call the
2859 destructors for our base classes and members.
2861 Called from begin_destructor_body. */
2863 void
2864 push_base_cleanups (void)
2866 tree binfo, base_binfo;
2867 int i;
2868 tree member;
2869 tree expr;
2870 VEC(tree,gc) *vbases;
2872 /* Run destructors for all virtual baseclasses. */
2873 if (CLASSTYPE_VBASECLASSES (current_class_type))
2875 tree cond = (condition_conversion
2876 (build2 (BIT_AND_EXPR, integer_type_node,
2877 current_in_charge_parm,
2878 integer_two_node)));
2880 /* The CLASSTYPE_VBASECLASSES vector is in initialization
2881 order, which is also the right order for pushing cleanups. */
2882 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
2883 VEC_iterate (tree, vbases, i, base_binfo); i++)
2885 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
2887 expr = build_special_member_call (current_class_ref,
2888 base_dtor_identifier,
2889 NULL_TREE,
2890 base_binfo,
2891 (LOOKUP_NORMAL
2892 | LOOKUP_NONVIRTUAL));
2893 expr = build3 (COND_EXPR, void_type_node, cond,
2894 expr, void_zero_node);
2895 finish_decl_cleanup (NULL_TREE, expr);
2900 /* Take care of the remaining baseclasses. */
2901 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2902 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2904 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
2905 || BINFO_VIRTUAL_P (base_binfo))
2906 continue;
2908 expr = build_special_member_call (current_class_ref,
2909 base_dtor_identifier,
2910 NULL_TREE, base_binfo,
2911 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
2912 finish_decl_cleanup (NULL_TREE, expr);
2915 for (member = TYPE_FIELDS (current_class_type); member;
2916 member = TREE_CHAIN (member))
2918 if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
2919 continue;
2920 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
2922 tree this_member = (build_class_member_access_expr
2923 (current_class_ref, member,
2924 /*access_path=*/NULL_TREE,
2925 /*preserve_reference=*/false));
2926 tree this_type = TREE_TYPE (member);
2927 expr = build_delete (this_type, this_member,
2928 sfk_complete_destructor,
2929 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
2931 finish_decl_cleanup (NULL_TREE, expr);
2936 /* Build a C++ vector delete expression.
2937 MAXINDEX is the number of elements to be deleted.
2938 ELT_SIZE is the nominal size of each element in the vector.
2939 BASE is the expression that should yield the store to be deleted.
2940 This function expands (or synthesizes) these calls itself.
2941 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
2943 This also calls delete for virtual baseclasses of elements of the vector.
2945 Update: MAXINDEX is no longer needed. The size can be extracted from the
2946 start of the vector for pointers, and from the type for arrays. We still
2947 use MAXINDEX for arrays because it happens to already have one of the
2948 values we'd have to extract. (We could use MAXINDEX with pointers to
2949 confirm the size, and trap if the numbers differ; not clear that it'd
2950 be worth bothering.) */
2952 tree
2953 build_vec_delete (tree base, tree maxindex,
2954 special_function_kind auto_delete_vec, int use_global_delete)
2956 tree type;
2957 tree rval;
2958 tree base_init = NULL_TREE;
2960 type = TREE_TYPE (base);
2962 if (TREE_CODE (type) == POINTER_TYPE)
2964 /* Step back one from start of vector, and read dimension. */
2965 tree cookie_addr;
2967 if (TREE_SIDE_EFFECTS (base))
2969 base_init = get_target_expr (base);
2970 base = TARGET_EXPR_SLOT (base_init);
2972 type = strip_array_types (TREE_TYPE (type));
2973 cookie_addr = build2 (MINUS_EXPR,
2974 build_pointer_type (sizetype),
2975 base,
2976 TYPE_SIZE_UNIT (sizetype));
2977 maxindex = build_indirect_ref (cookie_addr, NULL);
2979 else if (TREE_CODE (type) == ARRAY_TYPE)
2981 /* Get the total number of things in the array, maxindex is a
2982 bad name. */
2983 maxindex = array_type_nelts_total (type);
2984 type = strip_array_types (type);
2985 base = build_unary_op (ADDR_EXPR, base, 1);
2986 if (TREE_SIDE_EFFECTS (base))
2988 base_init = get_target_expr (base);
2989 base = TARGET_EXPR_SLOT (base_init);
2992 else
2994 if (base != error_mark_node)
2995 error ("type to vector delete is neither pointer or array type");
2996 return error_mark_node;
2999 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3000 use_global_delete);
3001 if (base_init)
3002 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
3004 return rval;