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)
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. */
27 #include "coretypes.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
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);
80 /* Finish out the statement-expression begun by the previous call to
81 begin_init_stmts. Returns the statement-expression itself. */
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);
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. */
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);
119 /* Initialize all the vtable pointers in the object pointed to by
123 initialize_vtbl_ptrs (tree addr)
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
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
150 build_zero_init (tree type, tree nelts, bool static_storage_p)
152 tree init = NULL_TREE;
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
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
167 -- if T is an array type, the storage for each element is
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))
189 /* Build a constructor to contain the initializations. */
190 init = build_constructor (type, NULL_TREE);
191 /* Iterate over the fields, building initializations. */
193 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
195 if (TREE_CODE (field) != FIELD_DECL)
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),
209 /* For unions, only the first field is initialized. */
210 if (TREE_CODE (type) == UNION_TYPE)
213 CONSTRUCTOR_ELTS (init) = nreverse (inits);
215 else if (TREE_CODE (type) == ARRAY_TYPE)
220 /* Build a constructor to contain the initializations. */
221 init = build_constructor (type, NULL_TREE);
222 /* Iterate over the array elements, building initializations. */
225 max_index = fold (build2 (MINUS_EXPR, TREE_TYPE (nelts),
226 nelts, integer_one_node));
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),
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;
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);
252 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
254 /* In all cases, the initializer is a constant. */
257 TREE_CONSTANT (init) = 1;
258 TREE_INVARIANT (init) = 1;
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. */
272 build_default_init (tree type, tree nelts)
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
301 if (TYPE_NEEDS_CONSTRUCTING (type)
302 || (nelts && TREE_CODE (nelts) != INTEGER_CST))
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. */
315 perform_member_init (tree member, tree init)
318 tree type = TREE_TYPE (member);
321 explicit = (init != NULL_TREE);
323 /* Effective C++ rule 12 requires that all data members be
325 if (warn_ecpp && !explicit && TREE_CODE (type) != ARRAY_TYPE)
326 warning ("%J%qD should be initialized in the member initialization "
327 "list", current_function_decl, member);
329 if (init == void_type_node)
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)
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))
346 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
347 finish_expr_stmt (init);
350 else if (TYPE_NEEDS_CONSTRUCTING (type))
353 && TREE_CODE (type) == ARRAY_TYPE
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),
363 finish_expr_stmt (build_aggr_init (decl, init, 0));
367 if (init == NULL_TREE)
371 init = build_default_init (type, /*nelts=*/NULL_TREE);
372 if (TREE_CODE (type) == REFERENCE_TYPE)
373 warning ("%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
388 init = build_x_compound_expr_from_list (init, "member initializer");
391 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
394 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
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. */
413 build_field_list (tree t, tree list, int *uses_unions_p)
419 /* Note whether or not T is a union. */
420 if (TREE_CODE (t) == UNION_TYPE)
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))
429 /* Keep track of whether or not any fields are unions. */
430 if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
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,
445 /* Add this field. */
446 else if (DECL_NAME (fields))
447 list = tree_cons (fields, NULL_TREE, 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. */
462 sort_mem_initializers (tree t, tree mem_inits)
465 tree base, binfo, base_binfo;
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
503 for (init = mem_inits; init; init = TREE_CHAIN (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
513 for (subobject_init = next_subobject;
515 subobject_init = TREE_CHAIN (subobject_init))
516 if (TREE_PURPOSE (subobject_init) == subobject)
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));
528 warning ("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);
533 warning (" base %qT", subobject);
534 warning ("%J when initialized here", current_function_decl);
537 /* Look again, from the beginning of the list. */
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
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);
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;
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. */
569 tree last_field = NULL_TREE;
570 for (init = sorted_inits; init; init = TREE_CHAIN (init))
576 /* Skip uninitialized members and base classes. */
577 if (!TREE_VALUE (init)
578 || TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
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)
588 /* If this field is not a member of a union, skip it. */
589 if (TREE_CODE (field_type) != UNION_TYPE)
592 /* It's only an error if we have two initializers for the same
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);
612 tree last_field_type;
614 last_field_type = DECL_CONTEXT (last_field);
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);
626 if (same_type_p (last_field_type, t))
629 last_field_type = TYPE_CONTEXT (last_field_type);
632 /* If we've reached the outermost class, then we're
634 if (same_type_p (field_type, t))
637 field_type = TYPE_CONTEXT (field_type);
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. */
656 emit_mem_initializers (tree mem_inits)
658 /* Sort the mem-initializers into the order in which the
659 initializations should be performed. */
660 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
662 in_base_initializer = 1;
664 /* Initialize base classes. */
666 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
668 tree subobject = TREE_PURPOSE (mem_inits);
669 tree arguments = TREE_VALUE (mem_inits);
671 /* If these initializations are taking place in a copy
672 constructor, the base class should probably be explicitly
674 if (extra_warnings && !arguments
675 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
676 && TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (subobject)))
677 warning ("%Jbase class %q#T should be explicitly initialized in the "
679 current_function_decl, BINFO_TYPE (subobject));
681 /* If an explicit -- but empty -- initializer list was present,
682 treat it just like default initialization at this point. */
683 if (arguments == void_type_node)
684 arguments = NULL_TREE;
686 /* Initialize the base. */
687 if (BINFO_VIRTUAL_P (subobject))
688 construct_virtual_base (subobject, arguments);
693 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
695 expand_aggr_init_1 (subobject, NULL_TREE,
696 build_indirect_ref (base_addr, NULL),
699 expand_cleanup_for_base (subobject, NULL_TREE);
702 mem_inits = TREE_CHAIN (mem_inits);
704 in_base_initializer = 0;
706 /* Initialize the vptrs. */
707 initialize_vtbl_ptrs (current_class_ptr);
709 /* Initialize the data members. */
712 perform_member_init (TREE_PURPOSE (mem_inits),
713 TREE_VALUE (mem_inits));
714 mem_inits = TREE_CHAIN (mem_inits);
718 /* Returns the address of the vtable (i.e., the value that should be
719 assigned to the vptr) for BINFO. */
722 build_vtbl_address (tree binfo)
724 tree binfo_for = binfo;
727 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
728 /* If this is a virtual primary base, then the vtable we want to store
729 is that for the base this is being used as the primary base of. We
730 can't simply skip the initialization, because we may be expanding the
731 inits of a subobject constructor where the virtual base layout
733 while (BINFO_PRIMARY_P (binfo_for))
734 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
736 /* Figure out what vtable BINFO's vtable is based on, and mark it as
738 vtbl = get_vtbl_decl_for_binfo (binfo_for);
739 assemble_external (vtbl);
740 TREE_USED (vtbl) = 1;
742 /* Now compute the address to use when initializing the vptr. */
743 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
744 if (TREE_CODE (vtbl) == VAR_DECL)
745 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
750 /* This code sets up the virtual function tables appropriate for
751 the pointer DECL. It is a one-ply initialization.
753 BINFO is the exact type that DECL is supposed to be. In
754 multiple inheritance, this might mean "C's A" if C : A, B. */
757 expand_virtual_init (tree binfo, tree decl)
762 /* Compute the initializer for vptr. */
763 vtbl = build_vtbl_address (binfo);
765 /* We may get this vptr from a VTT, if this is a subobject
766 constructor or subobject destructor. */
767 vtt_index = BINFO_VPTR_INDEX (binfo);
773 /* Compute the value to use, when there's a VTT. */
774 vtt_parm = current_vtt_parm;
775 vtbl2 = build2 (PLUS_EXPR,
776 TREE_TYPE (vtt_parm),
779 vtbl2 = build_indirect_ref (vtbl2, NULL);
780 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
782 /* The actual initializer is the VTT value only in the subobject
783 constructor. In maybe_clone_body we'll substitute NULL for
784 the vtt_parm in the case of the non-subobject constructor. */
785 vtbl = build3 (COND_EXPR,
787 build2 (EQ_EXPR, boolean_type_node,
788 current_in_charge_parm, integer_zero_node),
793 /* Compute the location of the vtpr. */
794 vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL),
796 gcc_assert (vtbl_ptr != error_mark_node);
798 /* Assign the vtable to the vptr. */
799 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
800 finish_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
803 /* If an exception is thrown in a constructor, those base classes already
804 constructed must be destroyed. This function creates the cleanup
805 for BINFO, which has just been constructed. If FLAG is non-NULL,
806 it is a DECL which is nonzero when this base needs to be
810 expand_cleanup_for_base (tree binfo, tree flag)
814 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
817 /* Call the destructor. */
818 expr = build_special_member_call (current_class_ref,
819 base_dtor_identifier,
822 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
824 expr = fold (build3 (COND_EXPR, void_type_node,
825 c_common_truthvalue_conversion (flag),
826 expr, integer_zero_node));
828 finish_eh_cleanup (expr);
831 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
835 construct_virtual_base (tree vbase, tree arguments)
841 /* If there are virtual base classes with destructors, we need to
842 emit cleanups to destroy them if an exception is thrown during
843 the construction process. These exception regions (i.e., the
844 period during which the cleanups must occur) begin from the time
845 the construction is complete to the end of the function. If we
846 create a conditional block in which to initialize the
847 base-classes, then the cleanup region for the virtual base begins
848 inside a block, and ends outside of that block. This situation
849 confuses the sjlj exception-handling code. Therefore, we do not
850 create a single conditional block, but one for each
851 initialization. (That way the cleanup regions always begin
852 in the outer block.) We trust the back-end to figure out
853 that the FLAG will not change across initializations, and
854 avoid doing multiple tests. */
855 flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
856 inner_if_stmt = begin_if_stmt ();
857 finish_if_stmt_cond (flag, inner_if_stmt);
859 /* Compute the location of the virtual base. If we're
860 constructing virtual bases, then we must be the most derived
861 class. Therefore, we don't have to look up the virtual base;
862 we already know where it is. */
863 exp = convert_to_base_statically (current_class_ref, vbase);
865 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
867 finish_then_clause (inner_if_stmt);
868 finish_if_stmt (inner_if_stmt);
870 expand_cleanup_for_base (vbase, flag);
873 /* Find the context in which this FIELD can be initialized. */
876 initializing_context (tree field)
878 tree t = DECL_CONTEXT (field);
880 /* Anonymous union members can be initialized in the first enclosing
881 non-anonymous union context. */
882 while (t && ANON_AGGR_TYPE_P (t))
883 t = TYPE_CONTEXT (t);
887 /* Function to give error message if member initialization specification
888 is erroneous. FIELD is the member we decided to initialize.
889 TYPE is the type for which the initialization is being performed.
890 FIELD must be a member of TYPE.
892 MEMBER_NAME is the name of the member. */
895 member_init_ok_or_else (tree field, tree type, tree member_name)
897 if (field == error_mark_node)
901 error ("class %qT does not have any field named %qD", type,
905 if (TREE_CODE (field) == VAR_DECL)
907 error ("%q#D is a static data member; it can only be "
908 "initialized at its definition",
912 if (TREE_CODE (field) != FIELD_DECL)
914 error ("%q#D is not a non-static data member of %qT",
918 if (initializing_context (field) != type)
920 error ("class %qT does not have any field named %qD", type,
928 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
929 is a _TYPE node or TYPE_DECL which names a base for that type.
930 Check the validity of NAME, and return either the base _TYPE, base
931 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
932 NULL_TREE and issue a diagnostic.
934 An old style unnamed direct single base construction is permitted,
935 where NAME is NULL. */
938 expand_member_init (tree name)
943 if (!current_class_ref)
948 /* This is an obsolete unnamed base class initializer. The
949 parser will already have warned about its use. */
950 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
953 error ("unnamed initializer for %qT, which has no base classes",
957 basetype = BINFO_TYPE
958 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
961 error ("unnamed initializer for %qT, which uses multiple inheritance",
966 else if (TYPE_P (name))
968 basetype = TYPE_MAIN_VARIANT (name);
969 name = TYPE_NAME (name);
971 else if (TREE_CODE (name) == TYPE_DECL)
972 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
974 basetype = NULL_TREE;
983 if (current_template_parms)
986 class_binfo = TYPE_BINFO (current_class_type);
987 direct_binfo = NULL_TREE;
988 virtual_binfo = NULL_TREE;
990 /* Look for a direct base. */
991 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
992 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
995 /* Look for a virtual base -- unless the direct base is itself
997 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
998 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1000 /* [class.base.init]
1002 If a mem-initializer-id is ambiguous because it designates
1003 both a direct non-virtual base class and an inherited virtual
1004 base class, the mem-initializer is ill-formed. */
1005 if (direct_binfo && virtual_binfo)
1007 error ("%qD is both a direct base and an indirect virtual base",
1012 if (!direct_binfo && !virtual_binfo)
1014 if (CLASSTYPE_VBASECLASSES (current_class_type))
1015 error ("type %qD is not a direct or virtual base of %qT",
1016 name, current_class_type);
1018 error ("type %qD is not a direct base of %qT",
1019 name, current_class_type);
1023 return direct_binfo ? direct_binfo : virtual_binfo;
1027 if (TREE_CODE (name) == IDENTIFIER_NODE)
1028 field = lookup_field (current_class_type, name, 1, false);
1032 if (member_init_ok_or_else (field, current_class_type, name))
1039 /* This is like `expand_member_init', only it stores one aggregate
1042 INIT comes in two flavors: it is either a value which
1043 is to be stored in EXP, or it is a parameter list
1044 to go to a constructor, which will operate on EXP.
1045 If INIT is not a parameter list for a constructor, then set
1046 LOOKUP_ONLYCONVERTING.
1047 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1048 the initializer, if FLAGS is 0, then it is the (init) form.
1049 If `init' is a CONSTRUCTOR, then we emit a warning message,
1050 explaining that such initializations are invalid.
1052 If INIT resolves to a CALL_EXPR which happens to return
1053 something of the type we are looking for, then we know
1054 that we can safely use that call to perform the
1057 The virtual function table pointer cannot be set up here, because
1058 we do not really know its type.
1060 This never calls operator=().
1062 When initializing, nothing is CONST.
1064 A default copy constructor may have to be used to perform the
1067 A constructor or a conversion operator may have to be used to
1068 perform the initialization, but not both, as it would be ambiguous. */
1071 build_aggr_init (tree exp, tree init, int flags)
1076 tree type = TREE_TYPE (exp);
1077 int was_const = TREE_READONLY (exp);
1078 int was_volatile = TREE_THIS_VOLATILE (exp);
1081 if (init == error_mark_node)
1082 return error_mark_node;
1084 TREE_READONLY (exp) = 0;
1085 TREE_THIS_VOLATILE (exp) = 0;
1087 if (init && TREE_CODE (init) != TREE_LIST)
1088 flags |= LOOKUP_ONLYCONVERTING;
1090 if (TREE_CODE (type) == ARRAY_TYPE)
1094 /* An array may not be initialized use the parenthesized
1095 initialization form -- unless the initializer is "()". */
1096 if (init && TREE_CODE (init) == TREE_LIST)
1098 error ("bad array initializer");
1099 return error_mark_node;
1101 /* Must arrange to initialize each element of EXP
1102 from elements of INIT. */
1103 itype = init ? TREE_TYPE (init) : NULL_TREE;
1104 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
1105 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1106 if (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
1107 itype = TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1108 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1109 itype && same_type_p (itype,
1111 TREE_READONLY (exp) = was_const;
1112 TREE_THIS_VOLATILE (exp) = was_volatile;
1113 TREE_TYPE (exp) = type;
1115 TREE_TYPE (init) = itype;
1119 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1120 /* Just know that we've seen something for this node. */
1121 TREE_USED (exp) = 1;
1123 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1124 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1125 destroy_temps = stmts_are_full_exprs_p ();
1126 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1127 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1128 init, LOOKUP_NORMAL|flags);
1129 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1130 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1131 TREE_TYPE (exp) = type;
1132 TREE_READONLY (exp) = was_const;
1133 TREE_THIS_VOLATILE (exp) = was_volatile;
1138 /* Like build_aggr_init, but not just for aggregates. */
1141 build_init (tree decl, tree init, int flags)
1145 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1146 expr = build_aggr_init (decl, init, flags);
1147 else if (CLASS_TYPE_P (TREE_TYPE (decl)))
1148 expr = build_special_member_call (decl, complete_ctor_identifier,
1149 build_tree_list (NULL_TREE, init),
1151 LOOKUP_NORMAL|flags);
1153 expr = build2 (INIT_EXPR, TREE_TYPE (decl), decl, init);
1159 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags)
1161 tree type = TREE_TYPE (exp);
1164 /* It fails because there may not be a constructor which takes
1165 its own type as the first (or only parameter), but which does
1166 take other types via a conversion. So, if the thing initializing
1167 the expression is a unit element of type X, first try X(X&),
1168 followed by initialization by X. If neither of these work
1169 out, then look hard. */
1173 if (init && TREE_CODE (init) != TREE_LIST
1174 && (flags & LOOKUP_ONLYCONVERTING))
1176 /* Base subobjects should only get direct-initialization. */
1177 gcc_assert (true_exp == exp);
1179 if (flags & DIRECT_BIND)
1180 /* Do nothing. We hit this in two cases: Reference initialization,
1181 where we aren't initializing a real variable, so we don't want
1182 to run a new constructor; and catching an exception, where we
1183 have already built up the constructor call so we could wrap it
1184 in an exception region. */;
1185 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
1187 /* A brace-enclosed initializer for an aggregate. */
1188 gcc_assert (CP_AGGREGATE_TYPE_P (type));
1189 init = digest_init (type, init, (tree *)NULL);
1192 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1194 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1195 /* We need to protect the initialization of a catch parm with a
1196 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1197 around the TARGET_EXPR for the copy constructor. See
1198 initialize_handler_parm. */
1200 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1201 TREE_OPERAND (init, 0));
1202 TREE_TYPE (init) = void_type_node;
1205 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1206 TREE_SIDE_EFFECTS (init) = 1;
1207 finish_expr_stmt (init);
1211 if (init == NULL_TREE
1212 || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1216 init = TREE_VALUE (parms);
1219 parms = build_tree_list (NULL_TREE, init);
1221 if (true_exp == exp)
1222 ctor_name = complete_ctor_identifier;
1224 ctor_name = base_ctor_identifier;
1226 rval = build_special_member_call (exp, ctor_name, parms, binfo, flags);
1227 if (TREE_SIDE_EFFECTS (rval))
1228 finish_expr_stmt (convert_to_void (rval, NULL));
1231 /* This function is responsible for initializing EXP with INIT
1234 BINFO is the binfo of the type for who we are performing the
1235 initialization. For example, if W is a virtual base class of A and B,
1237 If we are initializing B, then W must contain B's W vtable, whereas
1238 were we initializing C, W must contain C's W vtable.
1240 TRUE_EXP is nonzero if it is the true expression being initialized.
1241 In this case, it may be EXP, or may just contain EXP. The reason we
1242 need this is because if EXP is a base element of TRUE_EXP, we
1243 don't necessarily know by looking at EXP where its virtual
1244 baseclass fields should really be pointing. But we do know
1245 from TRUE_EXP. In constructors, we don't know anything about
1246 the value being initialized.
1248 FLAGS is just passed to `build_new_method_call'. See that function
1249 for its description. */
1252 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags)
1254 tree type = TREE_TYPE (exp);
1256 gcc_assert (init != error_mark_node && type != error_mark_node);
1257 gcc_assert (building_stmt_tree ());
1259 /* Use a function returning the desired type to initialize EXP for us.
1260 If the function is a constructor, and its first argument is
1261 NULL_TREE, know that it was meant for us--just slide exp on
1262 in and expand the constructor. Constructors now come
1265 if (init && TREE_CODE (exp) == VAR_DECL
1266 && TREE_CODE (init) == CONSTRUCTOR
1267 && TREE_HAS_CONSTRUCTOR (init))
1269 /* If store_init_value returns NULL_TREE, the INIT has been
1270 record in the DECL_INITIAL for EXP. That means there's
1271 nothing more we have to do. */
1272 init = store_init_value (exp, init);
1274 finish_expr_stmt (init);
1278 /* We know that expand_default_init can handle everything we want
1280 expand_default_init (binfo, true_exp, exp, init, flags);
1283 /* Report an error if TYPE is not a user-defined, aggregate type. If
1284 OR_ELSE is nonzero, give an error message. */
1287 is_aggr_type (tree type, int or_else)
1289 if (type == error_mark_node)
1292 if (! IS_AGGR_TYPE (type)
1293 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1294 && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
1297 error ("%qT is not an aggregate type", type);
1304 get_type_value (tree name)
1306 if (name == error_mark_node)
1309 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1310 return IDENTIFIER_TYPE_VALUE (name);
1315 /* Build a reference to a member of an aggregate. This is not a C++
1316 `&', but really something which can have its address taken, and
1317 then act as a pointer to member, for example TYPE :: FIELD can have
1318 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1319 this expression is the operand of "&".
1321 @@ Prints out lousy diagnostics for operator <typename>
1324 @@ This function should be rewritten and placed in search.c. */
1327 build_offset_ref (tree type, tree name, bool address_p)
1331 tree basebinfo = NULL_TREE;
1332 tree orig_name = name;
1334 /* class templates can come in as TEMPLATE_DECLs here. */
1335 if (TREE_CODE (name) == TEMPLATE_DECL)
1338 if (dependent_type_p (type) || type_dependent_expression_p (name))
1339 return build_min_nt (SCOPE_REF, type, name);
1341 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1343 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1344 something like `a.template f<int>' or the like. For the most
1345 part, we treat this just like a.f. We do remember, however,
1346 the template-id that was used. */
1347 name = TREE_OPERAND (orig_name, 0);
1350 name = DECL_NAME (name);
1353 if (TREE_CODE (name) == COMPONENT_REF)
1354 name = TREE_OPERAND (name, 1);
1355 if (TREE_CODE (name) == OVERLOAD)
1356 name = DECL_NAME (OVL_CURRENT (name));
1359 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1362 if (type == NULL_TREE)
1363 return error_mark_node;
1365 /* Handle namespace names fully here. */
1366 if (TREE_CODE (type) == NAMESPACE_DECL)
1368 tree t = lookup_namespace_name (type, name);
1369 if (t == error_mark_node)
1371 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1372 /* Reconstruct the TEMPLATE_ID_EXPR. */
1373 t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t),
1374 t, TREE_OPERAND (orig_name, 1));
1375 if (! type_unknown_p (t))
1378 t = convert_from_reference (t);
1383 if (! is_aggr_type (type, 1))
1384 return error_mark_node;
1386 if (TREE_CODE (name) == BIT_NOT_EXPR)
1388 if (! check_dtor_name (type, name))
1389 error ("qualified type %qT does not match destructor name %<~%T%>",
1390 type, TREE_OPERAND (name, 0));
1391 name = dtor_identifier;
1394 if (!COMPLETE_TYPE_P (complete_type (type))
1395 && !TYPE_BEING_DEFINED (type))
1397 error ("incomplete type %qT does not have member %qD", type, name);
1398 return error_mark_node;
1401 /* Set up BASEBINFO for member lookup. */
1402 decl = maybe_dummy_object (type, &basebinfo);
1404 if (BASELINK_P (name) || DECL_P (name))
1408 member = lookup_member (basebinfo, name, 1, 0);
1410 if (member == error_mark_node)
1411 return error_mark_node;
1416 error ("%qD is not a member of type %qT", name, type);
1417 return error_mark_node;
1420 if (TREE_CODE (member) == TYPE_DECL)
1422 TREE_USED (member) = 1;
1425 /* static class members and class-specific enum
1426 values can be returned without further ado. */
1427 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1430 return convert_from_reference (member);
1433 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1435 error ("invalid pointer to bit-field %qD", member);
1436 return error_mark_node;
1439 /* A lot of this logic is now handled in lookup_member. */
1440 if (BASELINK_P (member))
1442 /* Go from the TREE_BASELINK to the member function info. */
1443 tree fnfields = member;
1444 tree t = BASELINK_FUNCTIONS (fnfields);
1446 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1448 /* The FNFIELDS are going to contain functions that aren't
1449 necessarily templates, and templates that don't
1450 necessarily match the explicit template parameters. We
1451 save all the functions, and the explicit parameters, and
1452 then figure out exactly what to instantiate with what
1453 arguments in instantiate_type. */
1455 if (TREE_CODE (t) != OVERLOAD)
1456 /* The code in instantiate_type which will process this
1457 expects to encounter OVERLOADs, not raw functions. */
1458 t = ovl_cons (t, NULL_TREE);
1460 t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t), t,
1461 TREE_OPERAND (orig_name, 1));
1462 t = build2 (OFFSET_REF, unknown_type_node, decl, t);
1464 PTRMEM_OK_P (t) = 1;
1469 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1471 /* Get rid of a potential OVERLOAD around it. */
1472 t = OVL_CURRENT (t);
1474 /* Unique functions are handled easily. */
1476 /* For non-static member of base class, we need a special rule
1477 for access checking [class.protected]:
1479 If the access is to form a pointer to member, the
1480 nested-name-specifier shall name the derived class
1481 (or any class derived from that class). */
1482 if (address_p && DECL_P (t)
1483 && DECL_NONSTATIC_MEMBER_P (t))
1484 perform_or_defer_access_check (TYPE_BINFO (type), t);
1486 perform_or_defer_access_check (basebinfo, t);
1489 if (DECL_STATIC_FUNCTION_P (t))
1495 TREE_TYPE (fnfields) = unknown_type_node;
1499 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1500 /* We need additional test besides the one in
1501 check_accessibility_of_qualified_id in case it is
1502 a pointer to non-static member. */
1503 perform_or_defer_access_check (TYPE_BINFO (type), member);
1507 /* If MEMBER is non-static, then the program has fallen afoul of
1510 An id-expression that denotes a nonstatic data member or
1511 nonstatic member function of a class can only be used:
1513 -- as part of a class member access (_expr.ref_) in which the
1514 object-expression refers to the member's class or a class
1515 derived from that class, or
1517 -- to form a pointer to member (_expr.unary.op_), or
1519 -- in the body of a nonstatic member function of that class or
1520 of a class derived from that class (_class.mfct.nonstatic_), or
1522 -- in a mem-initializer for a constructor for that class or for
1523 a class derived from that class (_class.base.init_). */
1524 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1526 /* Build a representation of a the qualified name suitable
1527 for use as the operand to "&" -- even though the "&" is
1528 not actually present. */
1529 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1530 /* In Microsoft mode, treat a non-static member function as if
1531 it were a pointer-to-member. */
1532 if (flag_ms_extensions)
1534 PTRMEM_OK_P (member) = 1;
1535 return build_unary_op (ADDR_EXPR, member, 0);
1537 error ("invalid use of non-static member function %qD",
1538 TREE_OPERAND (member, 1));
1541 else if (TREE_CODE (member) == FIELD_DECL)
1543 error ("invalid use of non-static data member %qD", member);
1544 return error_mark_node;
1549 /* In member functions, the form `type::name' is no longer
1550 equivalent to `this->type::name', at least not until
1551 resolve_offset_ref. */
1552 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1553 PTRMEM_OK_P (member) = 1;
1557 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1558 constant of integral or enumeration type, then return that value.
1559 These are those variables permitted in constant expressions by
1560 [5.19/1]. FIXME:If we did lazy folding, this could be localized. */
1563 integral_constant_value (tree decl)
1565 while ((TREE_CODE (decl) == CONST_DECL
1566 || (TREE_CODE (decl) == VAR_DECL
1567 /* And so are variables with a 'const' type -- unless they
1568 are also 'volatile'. */
1569 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl))
1570 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)))
1571 && DECL_INITIAL (decl)
1572 && DECL_INITIAL (decl) != error_mark_node
1573 && TREE_TYPE (DECL_INITIAL (decl))
1574 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl)))
1575 decl = DECL_INITIAL (decl);
1579 /* A more relaxed version of integral_constant_value, for which type
1580 is not considered. This is used by the common C/C++ code, and not
1581 directly by the C++ front end. */
1584 decl_constant_value (tree decl)
1586 if ((TREE_CODE (decl) == CONST_DECL
1587 || (TREE_CODE (decl) == VAR_DECL
1588 /* And so are variables with a 'const' type -- unless they
1589 are also 'volatile'. */
1590 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl))))
1591 && DECL_INITIAL (decl)
1592 && DECL_INITIAL (decl) != error_mark_node
1593 /* This is invalid if initial value is not constant. If it has
1594 either a function call, a memory reference, or a variable,
1595 then re-evaluating it could give different results. */
1596 && TREE_CONSTANT (DECL_INITIAL (decl)))
1597 return DECL_INITIAL (decl);
1602 /* Common subroutines of build_new and build_vec_delete. */
1604 /* Call the global __builtin_delete to delete ADDR. */
1607 build_builtin_delete_call (tree addr)
1609 mark_used (global_delete_fndecl);
1610 return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
1613 /* Generate a representation for a C++ "new" expression. PLACEMENT is
1614 a TREE_LIST of placement-new arguments (or NULL_TREE if none). If
1615 NELTS is NULL, TYPE is the type of the storage to be allocated. If
1616 NELTS is not NULL, then this is an array-new allocation; TYPE is
1617 the type of the elements in the array and NELTS is the number of
1618 elements in the array. INIT, if non-NULL, is the initializer for
1619 the new object. If USE_GLOBAL_NEW is true, then the user
1620 explicitly wrote "::new" rather than just "new". */
1623 build_new (tree placement, tree type, tree nelts, tree init,
1628 if (type == error_mark_node)
1629 return error_mark_node;
1631 if (processing_template_decl)
1633 rval = build_min (NEW_EXPR, build_pointer_type (type),
1634 placement, type, nelts, init);
1635 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1636 TREE_SIDE_EFFECTS (rval) = 1;
1642 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
1643 pedwarn ("size in array new must have integral type");
1644 nelts = save_expr (cp_convert (sizetype, nelts));
1645 if (nelts == integer_zero_node)
1646 warning ("zero size array reserves no space");
1649 /* ``A reference cannot be created by the new operator. A reference
1650 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
1651 returned by new.'' ARM 5.3.3 */
1652 if (TREE_CODE (type) == REFERENCE_TYPE)
1654 error ("new cannot be applied to a reference type");
1655 type = TREE_TYPE (type);
1658 if (TREE_CODE (type) == FUNCTION_TYPE)
1660 error ("new cannot be applied to a function type");
1661 return error_mark_node;
1664 rval = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
1666 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1667 TREE_SIDE_EFFECTS (rval) = 1;
1668 rval = build_new_1 (rval);
1669 if (rval == error_mark_node)
1670 return error_mark_node;
1672 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
1673 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
1674 TREE_NO_WARNING (rval) = 1;
1679 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
1682 build_java_class_ref (tree type)
1684 tree name = NULL_TREE, class_decl;
1685 static tree CL_suffix = NULL_TREE;
1686 if (CL_suffix == NULL_TREE)
1687 CL_suffix = get_identifier("class$");
1688 if (jclass_node == NULL_TREE)
1690 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
1691 if (jclass_node == NULL_TREE)
1692 fatal_error ("call to Java constructor, while %<jclass%> undefined");
1694 jclass_node = TREE_TYPE (jclass_node);
1697 /* Mangle the class$ field. */
1700 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1701 if (DECL_NAME (field) == CL_suffix)
1703 mangle_decl (field);
1704 name = DECL_ASSEMBLER_NAME (field);
1708 internal_error ("can't find class$");
1711 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
1712 if (class_decl == NULL_TREE)
1714 class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
1715 TREE_STATIC (class_decl) = 1;
1716 DECL_EXTERNAL (class_decl) = 1;
1717 TREE_PUBLIC (class_decl) = 1;
1718 DECL_ARTIFICIAL (class_decl) = 1;
1719 DECL_IGNORED_P (class_decl) = 1;
1720 pushdecl_top_level (class_decl);
1721 make_decl_rtl (class_decl);
1727 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
1728 value is immediately handed to expand_expr. */
1731 build_new_1 (tree exp)
1733 tree placement, init;
1735 /* True iff this is a call to "operator new[]" instead of just
1737 bool array_p = false;
1738 /* True iff ARRAY_P is true and the bound of the array type is
1739 not necessarily a compile time constant. For example, VLA_P is
1740 true for "new int[f()]". */
1742 /* The type being allocated. If ARRAY_P is true, this will be an
1745 /* If ARRAY_P is true, the element type of the array. This is an
1746 never ARRAY_TYPE; for something like "new int[3][4]", the
1747 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1750 /* The type of the new-expression. (This type is always a pointer
1753 /* The type pointed to by POINTER_TYPE. This type may be different
1754 from ELT_TYPE for a multi-dimensional array; ELT_TYPE is never an
1755 ARRAY_TYPE, but TYPE may be an ARRAY_TYPE. */
1757 /* A pointer type pointing to the FULL_TYPE. */
1758 tree full_pointer_type;
1759 tree outer_nelts = NULL_TREE;
1760 tree nelts = NULL_TREE;
1761 tree alloc_call, alloc_expr;
1762 /* The address returned by the call to "operator new". This node is
1763 a VAR_DECL and is therefore reusable. */
1766 tree cookie_expr, init_expr;
1767 int nothrow, check_new;
1768 /* Nonzero if the user wrote `::new' rather than just `new'. */
1769 int globally_qualified_p;
1770 int use_java_new = 0;
1771 /* If non-NULL, the number of extra bytes to allocate at the
1772 beginning of the storage allocated for an array-new expression in
1773 order to store the number of elements. */
1774 tree cookie_size = NULL_TREE;
1775 /* True if the function we are calling is a placement allocation
1777 bool placement_allocation_fn_p;
1778 tree args = NULL_TREE;
1779 /* True if the storage must be initialized, either by a constructor
1780 or due to an explicit new-initializer. */
1781 bool is_initialized;
1782 /* The address of the thing allocated, not including any cookie. In
1783 particular, if an array cookie is in use, DATA_ADDR is the
1784 address of the first array element. This node is a VAR_DECL, and
1785 is therefore reusable. */
1787 tree init_preeval_expr = NULL_TREE;
1789 placement = TREE_OPERAND (exp, 0);
1790 type = TREE_OPERAND (exp, 1);
1791 nelts = TREE_OPERAND (exp, 2);
1792 init = TREE_OPERAND (exp, 3);
1793 globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
1799 outer_nelts = nelts;
1802 /* ??? The middle-end will error on us for building a VLA outside a
1803 function context. Methinks that's not it's purvey. So we'll do
1804 our own VLA layout later. */
1806 full_type = build_cplus_array_type (type, NULL_TREE);
1807 index = convert (sizetype, nelts);
1808 index = size_binop (MINUS_EXPR, index, size_one_node);
1809 TYPE_DOMAIN (full_type) = build_index_type (index);
1814 if (TREE_CODE (type) == ARRAY_TYPE)
1817 nelts = array_type_nelts_top (type);
1818 outer_nelts = nelts;
1819 type = TREE_TYPE (type);
1823 /* If our base type is an array, then make sure we know how many elements
1825 for (elt_type = type;
1826 TREE_CODE (elt_type) == ARRAY_TYPE;
1827 elt_type = TREE_TYPE (elt_type))
1828 nelts = cp_build_binary_op (MULT_EXPR, nelts,
1829 array_type_nelts_top (elt_type));
1831 if (!complete_type_or_else (elt_type, exp))
1832 return error_mark_node;
1834 if (TREE_CODE (elt_type) == VOID_TYPE)
1836 error ("invalid type %<void%> for new");
1837 return error_mark_node;
1840 if (abstract_virtuals_error (NULL_TREE, elt_type))
1841 return error_mark_node;
1843 is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || init);
1844 if (CP_TYPE_CONST_P (elt_type) && !is_initialized)
1846 error ("uninitialized const in %<new%> of %q#T", elt_type);
1847 return error_mark_node;
1850 size = size_in_bytes (elt_type);
1853 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1858 /* Do our own VLA layout. Setting TYPE_SIZE/_UNIT is
1859 necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
1860 ...>> to be valid. */
1861 TYPE_SIZE_UNIT (full_type) = size;
1862 n = convert (bitsizetype, nelts);
1863 bitsize = size_binop (MULT_EXPR, TYPE_SIZE (elt_type), n);
1864 TYPE_SIZE (full_type) = bitsize;
1868 /* Allocate the object. */
1869 if (! placement && TYPE_FOR_JAVA (elt_type))
1871 tree class_addr, alloc_decl;
1872 tree class_decl = build_java_class_ref (elt_type);
1873 static const char alloc_name[] = "_Jv_AllocObject";
1877 if (!get_global_value_if_present (get_identifier (alloc_name),
1880 error ("call to Java constructor with %qs undefined", alloc_name);
1881 return error_mark_node;
1883 else if (really_overloaded_fn (alloc_decl))
1885 error ("%qD should never be overloaded", alloc_decl);
1886 return error_mark_node;
1888 alloc_decl = OVL_CURRENT (alloc_decl);
1889 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1890 alloc_call = (build_function_call
1892 build_tree_list (NULL_TREE, class_addr)));
1899 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
1901 if (!globally_qualified_p
1902 && CLASS_TYPE_P (elt_type)
1904 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
1905 : TYPE_HAS_NEW_OPERATOR (elt_type)))
1907 /* Use a class-specific operator new. */
1908 /* If a cookie is required, add some extra space. */
1909 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1911 cookie_size = targetm.cxx.get_cookie_size (elt_type);
1912 size = size_binop (PLUS_EXPR, size, cookie_size);
1914 /* Create the argument list. */
1915 args = tree_cons (NULL_TREE, size, placement);
1916 /* Do name-lookup to find the appropriate operator. */
1917 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
1918 if (TREE_CODE (fns) == TREE_LIST)
1920 error ("request for member %qD is ambiguous", fnname);
1921 print_candidates (fns);
1922 return error_mark_node;
1924 alloc_call = build_new_method_call (build_dummy_object (elt_type),
1926 /*conversion_path=*/NULL_TREE,
1931 /* Use a global operator new. */
1932 /* See if a cookie might be required. */
1933 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1934 cookie_size = targetm.cxx.get_cookie_size (elt_type);
1936 cookie_size = NULL_TREE;
1938 alloc_call = build_operator_new_call (fnname, placement,
1939 &size, &cookie_size);
1943 if (alloc_call == error_mark_node)
1944 return error_mark_node;
1946 /* In the simple case, we can stop now. */
1947 pointer_type = build_pointer_type (type);
1948 if (!cookie_size && !is_initialized)
1949 return build_nop (pointer_type, alloc_call);
1951 /* While we're working, use a pointer to the type we've actually
1952 allocated. Store the result of the call in a variable so that we
1953 can use it more than once. */
1954 full_pointer_type = build_pointer_type (full_type);
1955 alloc_expr = get_target_expr (build_nop (full_pointer_type, alloc_call));
1956 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
1958 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
1959 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
1960 alloc_call = TREE_OPERAND (alloc_call, 1);
1961 alloc_fn = get_callee_fndecl (alloc_call);
1962 gcc_assert (alloc_fn != NULL_TREE);
1964 /* Now, check to see if this function is actually a placement
1965 allocation function. This can happen even when PLACEMENT is NULL
1966 because we might have something like:
1968 struct S { void* operator new (size_t, int i = 0); };
1970 A call to `new S' will get this allocation function, even though
1971 there is no explicit placement argument. If there is more than
1972 one argument, or there are variable arguments, then this is a
1973 placement allocation function. */
1974 placement_allocation_fn_p
1975 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
1976 || varargs_function_p (alloc_fn));
1978 /* Preevaluate the placement args so that we don't reevaluate them for a
1979 placement delete. */
1980 if (placement_allocation_fn_p)
1983 stabilize_call (alloc_call, &inits);
1985 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
1989 /* unless an allocation function is declared with an empty excep-
1990 tion-specification (_except.spec_), throw(), it indicates failure to
1991 allocate storage by throwing a bad_alloc exception (clause _except_,
1992 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
1993 cation function is declared with an empty exception-specification,
1994 throw(), it returns null to indicate failure to allocate storage and a
1995 non-null pointer otherwise.
1997 So check for a null exception spec on the op new we just called. */
1999 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2000 check_new = (flag_check_new || nothrow) && ! use_java_new;
2007 /* Adjust so we're pointing to the start of the object. */
2008 data_addr = get_target_expr (build2 (PLUS_EXPR, full_pointer_type,
2009 alloc_node, cookie_size));
2011 /* Store the number of bytes allocated so that we can know how
2012 many elements to destroy later. We use the last sizeof
2013 (size_t) bytes to store the number of elements. */
2014 cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2015 data_addr, size_in_bytes (sizetype));
2016 cookie = build_indirect_ref (cookie_ptr, NULL);
2018 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2020 if (targetm.cxx.cookie_has_size ())
2022 /* Also store the element size. */
2023 cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2024 cookie_ptr, size_in_bytes (sizetype));
2025 cookie = build_indirect_ref (cookie_ptr, NULL);
2026 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2027 size_in_bytes(elt_type));
2028 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2029 cookie, cookie_expr);
2031 data_addr = TARGET_EXPR_SLOT (data_addr);
2035 cookie_expr = NULL_TREE;
2036 data_addr = alloc_node;
2039 /* Now initialize the allocated object. Note that we preevaluate the
2040 initialization expression, apart from the actual constructor call or
2041 assignment--we do this because we want to delay the allocation as long
2042 as possible in order to minimize the size of the exception region for
2043 placement delete. */
2048 init_expr = build_indirect_ref (data_addr, NULL);
2050 if (init == void_zero_node)
2051 init = build_default_init (full_type, nelts);
2052 else if (init && array_p)
2053 pedwarn ("ISO C++ forbids initialization in array new");
2058 = build_vec_init (init_expr,
2059 cp_build_binary_op (MINUS_EXPR, outer_nelts,
2061 init, /*from_array=*/0);
2063 /* An array initialization is stable because the initialization
2064 of each element is a full-expression, so the temporaries don't
2068 else if (TYPE_NEEDS_CONSTRUCTING (type))
2070 init_expr = build_special_member_call (init_expr,
2071 complete_ctor_identifier,
2074 stable = stabilize_init (init_expr, &init_preeval_expr);
2078 /* We are processing something like `new int (10)', which
2079 means allocate an int, and initialize it with 10. */
2081 if (TREE_CODE (init) == TREE_LIST)
2082 init = build_x_compound_expr_from_list (init, "new initializer");
2085 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2086 || TREE_TYPE (init) != NULL_TREE);
2088 init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
2089 stable = stabilize_init (init_expr, &init_preeval_expr);
2092 if (init_expr == error_mark_node)
2093 return error_mark_node;
2095 /* If any part of the object initialization terminates by throwing an
2096 exception and a suitable deallocation function can be found, the
2097 deallocation function is called to free the memory in which the
2098 object was being constructed, after which the exception continues
2099 to propagate in the context of the new-expression. If no
2100 unambiguous matching deallocation function can be found,
2101 propagating the exception does not cause the object's memory to be
2103 if (flag_exceptions && ! use_java_new)
2105 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2108 /* The Standard is unclear here, but the right thing to do
2109 is to use the same method for finding deallocation
2110 functions that we use for finding allocation functions. */
2111 cleanup = build_op_delete_call (dcode, alloc_node, size,
2112 globally_qualified_p,
2113 (placement_allocation_fn_p
2114 ? alloc_call : NULL_TREE));
2119 /* This is much simpler if we were able to preevaluate all of
2120 the arguments to the constructor call. */
2121 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2122 init_expr, cleanup);
2124 /* Ack! First we allocate the memory. Then we set our sentry
2125 variable to true, and expand a cleanup that deletes the
2126 memory if sentry is true. Then we run the constructor, and
2127 finally clear the sentry.
2129 We need to do this because we allocate the space first, so
2130 if there are any temporaries with cleanups in the
2131 constructor args and we weren't able to preevaluate them, we
2132 need this EH region to extend until end of full-expression
2133 to preserve nesting. */
2135 tree end, sentry, begin;
2137 begin = get_target_expr (boolean_true_node);
2138 CLEANUP_EH_ONLY (begin) = 1;
2140 sentry = TARGET_EXPR_SLOT (begin);
2142 TARGET_EXPR_CLEANUP (begin)
2143 = build3 (COND_EXPR, void_type_node, sentry,
2144 cleanup, void_zero_node);
2146 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2147 sentry, boolean_false_node);
2150 = build2 (COMPOUND_EXPR, void_type_node, begin,
2151 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2158 init_expr = NULL_TREE;
2160 /* Now build up the return value in reverse order. */
2165 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2167 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2169 if (rval == alloc_node)
2170 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2171 and return the call (which doesn't need to be adjusted). */
2172 rval = TARGET_EXPR_INITIAL (alloc_expr);
2177 tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
2179 rval = build_conditional_expr (ifexp, rval, alloc_node);
2182 /* Perform the allocation before anything else, so that ALLOC_NODE
2183 has been initialized before we start using it. */
2184 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2187 if (init_preeval_expr)
2188 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2190 /* Convert to the final type. */
2191 rval = build_nop (pointer_type, rval);
2193 /* A new-expression is never an lvalue. */
2194 if (real_lvalue_p (rval))
2195 rval = build1 (NON_LVALUE_EXPR, TREE_TYPE (rval), rval);
2201 build_vec_delete_1 (tree base, tree maxindex, tree type,
2202 special_function_kind auto_delete_vec, int use_global_delete)
2205 tree ptype = build_pointer_type (type = complete_type (type));
2206 tree size_exp = size_in_bytes (type);
2208 /* Temporary variables used by the loop. */
2209 tree tbase, tbase_init;
2211 /* This is the body of the loop that implements the deletion of a
2212 single element, and moves temp variables to next elements. */
2215 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2218 /* This is the thing that governs what to do after the loop has run. */
2219 tree deallocate_expr = 0;
2221 /* This is the BIND_EXPR which holds the outermost iterator of the
2222 loop. It is convenient to set this variable up and test it before
2223 executing any other code in the loop.
2224 This is also the containing expression returned by this function. */
2225 tree controller = NULL_TREE;
2227 /* We should only have 1-D arrays here. */
2228 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2230 if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2233 /* The below is short by the cookie size. */
2234 virtual_size = size_binop (MULT_EXPR, size_exp,
2235 convert (sizetype, maxindex));
2237 tbase = create_temporary_var (ptype);
2238 tbase_init = build_modify_expr (tbase, NOP_EXPR,
2239 fold (build2 (PLUS_EXPR, ptype,
2242 DECL_REGISTER (tbase) = 1;
2243 controller = build3 (BIND_EXPR, void_type_node, tbase,
2244 NULL_TREE, NULL_TREE);
2245 TREE_SIDE_EFFECTS (controller) = 1;
2247 body = build1 (EXIT_EXPR, void_type_node,
2248 build2 (EQ_EXPR, boolean_type_node, base, tbase));
2249 body = build_compound_expr
2250 (body, build_modify_expr (tbase, NOP_EXPR,
2251 build2 (MINUS_EXPR, ptype, tbase, size_exp)));
2252 body = build_compound_expr
2253 (body, build_delete (ptype, tbase, sfk_complete_destructor,
2254 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2256 loop = build1 (LOOP_EXPR, void_type_node, body);
2257 loop = build_compound_expr (tbase_init, loop);
2260 /* If the delete flag is one, or anything else with the low bit set,
2261 delete the storage. */
2262 if (auto_delete_vec != sfk_base_destructor)
2266 /* The below is short by the cookie size. */
2267 virtual_size = size_binop (MULT_EXPR, size_exp,
2268 convert (sizetype, maxindex));
2270 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2277 cookie_size = targetm.cxx.get_cookie_size (type);
2279 = cp_convert (ptype,
2280 cp_build_binary_op (MINUS_EXPR,
2281 cp_convert (string_type_node,
2284 /* True size with header. */
2285 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2288 if (auto_delete_vec == sfk_deleting_destructor)
2289 deallocate_expr = build_x_delete (base_tbd,
2290 2 | use_global_delete,
2295 if (!deallocate_expr)
2298 body = deallocate_expr;
2300 body = build_compound_expr (body, deallocate_expr);
2303 body = integer_zero_node;
2305 /* Outermost wrapper: If pointer is null, punt. */
2306 body = fold (build3 (COND_EXPR, void_type_node,
2307 fold (build2 (NE_EXPR, boolean_type_node, base,
2308 convert (TREE_TYPE (base),
2309 integer_zero_node))),
2310 body, integer_zero_node));
2311 body = build1 (NOP_EXPR, void_type_node, body);
2315 TREE_OPERAND (controller, 1) = body;
2319 if (TREE_CODE (base) == SAVE_EXPR)
2320 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2321 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2323 return convert_to_void (body, /*implicit=*/NULL);
2326 /* Create an unnamed variable of the indicated TYPE. */
2329 create_temporary_var (tree type)
2333 decl = build_decl (VAR_DECL, NULL_TREE, type);
2334 TREE_USED (decl) = 1;
2335 DECL_ARTIFICIAL (decl) = 1;
2336 DECL_IGNORED_P (decl) = 1;
2337 DECL_SOURCE_LOCATION (decl) = input_location;
2338 DECL_CONTEXT (decl) = current_function_decl;
2343 /* Create a new temporary variable of the indicated TYPE, initialized
2346 It is not entered into current_binding_level, because that breaks
2347 things when it comes time to do final cleanups (which take place
2348 "outside" the binding contour of the function). */
2351 get_temp_regvar (tree type, tree init)
2355 decl = create_temporary_var (type);
2356 add_decl_expr (decl);
2358 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
2363 /* `build_vec_init' returns tree structure that performs
2364 initialization of a vector of aggregate types.
2366 BASE is a reference to the vector, of ARRAY_TYPE.
2367 MAXINDEX is the maximum index of the array (one less than the
2368 number of elements). It is only used if
2369 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2370 INIT is the (possibly NULL) initializer.
2372 FROM_ARRAY is 0 if we should init everything with INIT
2373 (i.e., every element initialized from INIT).
2374 FROM_ARRAY is 1 if we should index into INIT in parallel
2375 with initialization of DECL.
2376 FROM_ARRAY is 2 if we should index into INIT in parallel,
2377 but use assignment instead of initialization. */
2380 build_vec_init (tree base, tree maxindex, tree init, int from_array)
2383 tree base2 = NULL_TREE;
2385 tree itype = NULL_TREE;
2387 /* The type of the array. */
2388 tree atype = TREE_TYPE (base);
2389 /* The type of an element in the array. */
2390 tree type = TREE_TYPE (atype);
2391 /* The type of a pointer to an element in the array. */
2396 tree try_block = NULL_TREE;
2397 int num_initialized_elts = 0;
2400 if (TYPE_DOMAIN (atype))
2401 maxindex = array_type_nelts (atype);
2403 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2404 return error_mark_node;
2408 ? (!CLASS_TYPE_P (type) || !TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2409 : !TYPE_NEEDS_CONSTRUCTING (type))
2410 && ((TREE_CODE (init) == CONSTRUCTOR
2411 /* Don't do this if the CONSTRUCTOR might contain something
2412 that might throw and require us to clean up. */
2413 && (CONSTRUCTOR_ELTS (init) == NULL_TREE
2414 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type))))
2417 /* Do non-default initialization of POD arrays resulting from
2418 brace-enclosed initializers. In this case, digest_init and
2419 store_constructor will handle the semantics for us. */
2421 stmt_expr = build2 (INIT_EXPR, atype, base, init);
2425 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2426 ptype = build_pointer_type (type);
2427 size = size_in_bytes (type);
2428 if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
2429 base = cp_convert (ptype, decay_conversion (base));
2431 /* The code we are generating looks like:
2435 ptrdiff_t iterator = maxindex;
2437 for (; iterator != -1; --iterator) {
2438 ... initialize *t1 ...
2442 ... destroy elements that were constructed ...
2447 We can omit the try and catch blocks if we know that the
2448 initialization will never throw an exception, or if the array
2449 elements do not have destructors. We can omit the loop completely if
2450 the elements of the array do not have constructors.
2452 We actually wrap the entire body of the above in a STMT_EXPR, for
2455 When copying from array to another, when the array elements have
2456 only trivial copy constructors, we should use __builtin_memcpy
2457 rather than generating a loop. That way, we could take advantage
2458 of whatever cleverness the back-end has for dealing with copies
2459 of blocks of memory. */
2461 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2462 destroy_temps = stmts_are_full_exprs_p ();
2463 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2464 rval = get_temp_regvar (ptype, base);
2465 base = get_temp_regvar (ptype, rval);
2466 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2468 /* Protect the entire array initialization so that we can destroy
2469 the partially constructed array if an exception is thrown.
2470 But don't do this if we're assigning. */
2471 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2474 try_block = begin_try_block ();
2477 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2479 /* Do non-default initialization of non-POD arrays resulting from
2480 brace-enclosed initializers. */
2485 for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
2487 tree elt = TREE_VALUE (elts);
2488 tree baseref = build1 (INDIRECT_REF, type, base);
2490 num_initialized_elts++;
2492 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2493 if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2494 finish_expr_stmt (build_aggr_init (baseref, elt, 0));
2496 finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
2498 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2500 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2501 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
2504 /* Clear out INIT so that we don't get confused below. */
2507 else if (from_array)
2509 /* If initializing one array from another, initialize element by
2510 element. We rely upon the below calls the do argument
2514 base2 = decay_conversion (init);
2515 itype = TREE_TYPE (base2);
2516 base2 = get_temp_regvar (itype, base2);
2517 itype = TREE_TYPE (itype);
2519 else if (TYPE_LANG_SPECIFIC (type)
2520 && TYPE_NEEDS_CONSTRUCTING (type)
2521 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2523 error ("initializer ends prematurely");
2524 return error_mark_node;
2528 /* Now, default-initialize any remaining elements. We don't need to
2529 do that if a) the type does not need constructing, or b) we've
2530 already initialized all the elements.
2532 We do need to keep going if we're copying an array. */
2535 || (TYPE_NEEDS_CONSTRUCTING (type)
2536 && ! (host_integerp (maxindex, 0)
2537 && (num_initialized_elts
2538 == tree_low_cst (maxindex, 0) + 1))))
2540 /* If the ITERATOR is equal to -1, then we don't have to loop;
2541 we've already initialized all the elements. */
2545 for_stmt = begin_for_stmt ();
2546 finish_for_init_stmt (for_stmt);
2547 finish_for_cond (build2 (NE_EXPR, boolean_type_node,
2548 iterator, integer_minus_one_node),
2550 finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0),
2555 tree to = build1 (INDIRECT_REF, type, base);
2559 from = build1 (INDIRECT_REF, itype, base2);
2563 if (from_array == 2)
2564 elt_init = build_modify_expr (to, NOP_EXPR, from);
2565 else if (TYPE_NEEDS_CONSTRUCTING (type))
2566 elt_init = build_aggr_init (to, from, 0);
2568 elt_init = build_modify_expr (to, NOP_EXPR, from);
2572 else if (TREE_CODE (type) == ARRAY_TYPE)
2576 ("cannot initialize multi-dimensional array with initializer");
2577 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2581 elt_init = build_aggr_init (build1 (INDIRECT_REF, type, base),
2584 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2585 finish_expr_stmt (elt_init);
2586 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2588 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2590 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));
2592 finish_for_stmt (for_stmt);
2595 /* Make sure to cleanup any partially constructed elements. */
2596 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2600 tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);
2602 /* Flatten multi-dimensional array since build_vec_delete only
2603 expects one-dimensional array. */
2604 if (TREE_CODE (type) == ARRAY_TYPE)
2606 m = cp_build_binary_op (MULT_EXPR, m,
2607 array_type_nelts_total (type));
2608 type = strip_array_types (type);
2611 finish_cleanup_try_block (try_block);
2612 e = build_vec_delete_1 (rval, m, type, sfk_base_destructor,
2613 /*use_global_delete=*/0);
2614 finish_cleanup (e, try_block);
2617 /* The value of the array initialization is the array itself, RVAL
2618 is a pointer to the first element. */
2619 finish_stmt_expr_expr (rval, stmt_expr);
2621 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2623 /* Now convert make the result have the correct type. */
2624 atype = build_pointer_type (atype);
2625 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2626 stmt_expr = build_indirect_ref (stmt_expr, NULL);
2628 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2632 /* Free up storage of type TYPE, at address ADDR.
2634 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2637 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2638 used as the second argument to operator delete. It can include
2639 things like padding and magic size cookies. It has virtual in it,
2640 because if you have a base pointer and you delete through a virtual
2641 destructor, it should be the size of the dynamic object, not the
2642 static object, see Free Store 12.5 ISO C++.
2644 This does not call any destructors. */
2647 build_x_delete (tree addr, int which_delete, tree virtual_size)
2649 int use_global_delete = which_delete & 1;
2650 int use_vec_delete = !!(which_delete & 2);
2651 enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
2653 return build_op_delete_call (code, addr, virtual_size, use_global_delete,
2657 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
2661 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2667 case sfk_complete_destructor:
2668 name = complete_dtor_identifier;
2671 case sfk_base_destructor:
2672 name = base_dtor_identifier;
2675 case sfk_deleting_destructor:
2676 name = deleting_dtor_identifier;
2682 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2683 return build_new_method_call (exp, fn,
2685 /*conversion_path=*/NULL_TREE,
2689 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2690 ADDR is an expression which yields the store to be destroyed.
2691 AUTO_DELETE is the name of the destructor to call, i.e., either
2692 sfk_complete_destructor, sfk_base_destructor, or
2693 sfk_deleting_destructor.
2695 FLAGS is the logical disjunction of zero or more LOOKUP_
2696 flags. See cp-tree.h for more info. */
2699 build_delete (tree type, tree addr, special_function_kind auto_delete,
2700 int flags, int use_global_delete)
2704 if (addr == error_mark_node)
2705 return error_mark_node;
2707 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2708 set to `error_mark_node' before it gets properly cleaned up. */
2709 if (type == error_mark_node)
2710 return error_mark_node;
2712 type = TYPE_MAIN_VARIANT (type);
2714 if (TREE_CODE (type) == POINTER_TYPE)
2716 bool complete_p = true;
2718 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2719 if (TREE_CODE (type) == ARRAY_TYPE)
2722 /* We don't want to warn about delete of void*, only other
2723 incomplete types. Deleting other incomplete types
2724 invokes undefined behavior, but it is not ill-formed, so
2725 compile to something that would even do The Right Thing
2726 (TM) should the type have a trivial dtor and no delete
2728 if (!VOID_TYPE_P (type))
2730 complete_type (type);
2731 if (!COMPLETE_TYPE_P (type))
2733 warning ("possible problem detected in invocation of "
2734 "delete operator:");
2735 cxx_incomplete_type_diagnostic (addr, type, 1);
2736 inform ("neither the destructor nor the class-specific "
2737 "operator delete will be called, even if they are "
2738 "declared when the class is defined.");
2742 if (VOID_TYPE_P (type) || !complete_p || !IS_AGGR_TYPE (type))
2743 /* Call the builtin operator delete. */
2744 return build_builtin_delete_call (addr);
2745 if (TREE_SIDE_EFFECTS (addr))
2746 addr = save_expr (addr);
2748 /* Throw away const and volatile on target type of addr. */
2749 addr = convert_force (build_pointer_type (type), addr, 0);
2751 else if (TREE_CODE (type) == ARRAY_TYPE)
2755 if (TYPE_DOMAIN (type) == NULL_TREE)
2757 error ("unknown array size in delete");
2758 return error_mark_node;
2760 return build_vec_delete (addr, array_type_nelts (type),
2761 auto_delete, use_global_delete);
2765 /* Don't check PROTECT here; leave that decision to the
2766 destructor. If the destructor is accessible, call it,
2767 else report error. */
2768 addr = build_unary_op (ADDR_EXPR, addr, 0);
2769 if (TREE_SIDE_EFFECTS (addr))
2770 addr = save_expr (addr);
2772 addr = convert_force (build_pointer_type (type), addr, 0);
2775 gcc_assert (IS_AGGR_TYPE (type));
2777 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2779 if (auto_delete != sfk_deleting_destructor)
2780 return void_zero_node;
2782 return build_op_delete_call
2783 (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), use_global_delete,
2788 tree do_delete = NULL_TREE;
2791 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
2792 lazily_declare_fn (sfk_destructor, type);
2794 /* For `::delete x', we must not use the deleting destructor
2795 since then we would not be sure to get the global `operator
2797 if (use_global_delete && auto_delete == sfk_deleting_destructor)
2799 /* We will use ADDR multiple times so we must save it. */
2800 addr = save_expr (addr);
2801 /* Delete the object. */
2802 do_delete = build_builtin_delete_call (addr);
2803 /* Otherwise, treat this like a complete object destructor
2805 auto_delete = sfk_complete_destructor;
2807 /* If the destructor is non-virtual, there is no deleting
2808 variant. Instead, we must explicitly call the appropriate
2809 `operator delete' here. */
2810 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
2811 && auto_delete == sfk_deleting_destructor)
2813 /* We will use ADDR multiple times so we must save it. */
2814 addr = save_expr (addr);
2815 /* Build the call. */
2816 do_delete = build_op_delete_call (DELETE_EXPR,
2818 cxx_sizeof_nowarn (type),
2821 /* Call the complete object destructor. */
2822 auto_delete = sfk_complete_destructor;
2824 else if (auto_delete == sfk_deleting_destructor
2825 && TYPE_GETS_REG_DELETE (type))
2827 /* Make sure we have access to the member op delete, even though
2828 we'll actually be calling it from the destructor. */
2829 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2830 /*global_p=*/false, NULL_TREE);
2833 expr = build_dtor_call (build_indirect_ref (addr, NULL),
2834 auto_delete, flags);
2836 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
2838 if (flags & LOOKUP_DESTRUCTOR)
2839 /* Explicit destructor call; don't check for null pointer. */
2840 ifexp = integer_one_node;
2842 /* Handle deleting a null pointer. */
2843 ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
2845 if (ifexp != integer_one_node)
2846 expr = build3 (COND_EXPR, void_type_node,
2847 ifexp, expr, void_zero_node);
2853 /* At the beginning of a destructor, push cleanups that will call the
2854 destructors for our base classes and members.
2856 Called from begin_destructor_body. */
2859 push_base_cleanups (void)
2861 tree binfo, base_binfo;
2867 /* Run destructors for all virtual baseclasses. */
2868 if (CLASSTYPE_VBASECLASSES (current_class_type))
2870 tree cond = (condition_conversion
2871 (build2 (BIT_AND_EXPR, integer_type_node,
2872 current_in_charge_parm,
2873 integer_two_node)));
2875 /* The CLASSTYPE_VBASECLASSES vector is in initialization
2876 order, which is also the right order for pushing cleanups. */
2877 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
2878 VEC_iterate (tree, vbases, i, base_binfo); i++)
2880 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
2882 expr = build_special_member_call (current_class_ref,
2883 base_dtor_identifier,
2887 | LOOKUP_NONVIRTUAL));
2888 expr = build3 (COND_EXPR, void_type_node, cond,
2889 expr, void_zero_node);
2890 finish_decl_cleanup (NULL_TREE, expr);
2895 /* Take care of the remaining baseclasses. */
2896 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2897 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2899 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
2900 || BINFO_VIRTUAL_P (base_binfo))
2903 expr = build_special_member_call (current_class_ref,
2904 base_dtor_identifier,
2905 NULL_TREE, base_binfo,
2906 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
2907 finish_decl_cleanup (NULL_TREE, expr);
2910 for (member = TYPE_FIELDS (current_class_type); member;
2911 member = TREE_CHAIN (member))
2913 if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
2915 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
2917 tree this_member = (build_class_member_access_expr
2918 (current_class_ref, member,
2919 /*access_path=*/NULL_TREE,
2920 /*preserve_reference=*/false));
2921 tree this_type = TREE_TYPE (member);
2922 expr = build_delete (this_type, this_member,
2923 sfk_complete_destructor,
2924 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
2926 finish_decl_cleanup (NULL_TREE, expr);
2931 /* Build a C++ vector delete expression.
2932 MAXINDEX is the number of elements to be deleted.
2933 ELT_SIZE is the nominal size of each element in the vector.
2934 BASE is the expression that should yield the store to be deleted.
2935 This function expands (or synthesizes) these calls itself.
2936 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
2938 This also calls delete for virtual baseclasses of elements of the vector.
2940 Update: MAXINDEX is no longer needed. The size can be extracted from the
2941 start of the vector for pointers, and from the type for arrays. We still
2942 use MAXINDEX for arrays because it happens to already have one of the
2943 values we'd have to extract. (We could use MAXINDEX with pointers to
2944 confirm the size, and trap if the numbers differ; not clear that it'd
2945 be worth bothering.) */
2948 build_vec_delete (tree base, tree maxindex,
2949 special_function_kind auto_delete_vec, int use_global_delete)
2953 tree base_init = NULL_TREE;
2955 type = TREE_TYPE (base);
2957 if (TREE_CODE (type) == POINTER_TYPE)
2959 /* Step back one from start of vector, and read dimension. */
2962 if (TREE_SIDE_EFFECTS (base))
2964 base_init = get_target_expr (base);
2965 base = TARGET_EXPR_SLOT (base_init);
2967 type = strip_array_types (TREE_TYPE (type));
2968 cookie_addr = build2 (MINUS_EXPR,
2969 build_pointer_type (sizetype),
2971 TYPE_SIZE_UNIT (sizetype));
2972 maxindex = build_indirect_ref (cookie_addr, NULL);
2974 else if (TREE_CODE (type) == ARRAY_TYPE)
2976 /* Get the total number of things in the array, maxindex is a
2978 maxindex = array_type_nelts_total (type);
2979 type = strip_array_types (type);
2980 base = build_unary_op (ADDR_EXPR, base, 1);
2981 if (TREE_SIDE_EFFECTS (base))
2983 base_init = get_target_expr (base);
2984 base = TARGET_EXPR_SLOT (base_init);
2989 if (base != error_mark_node)
2990 error ("type to vector delete is neither pointer or array type");
2991 return error_mark_node;
2994 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
2997 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);