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 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 ((!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
105 && TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
107 tree base_ptr = TREE_VALUE ((tree) data);
109 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
111 expand_virtual_init (binfo, base_ptr);
114 BINFO_MARKED (binfo) = 1;
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_real (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs,
136 NULL, unmarkedp, list);
137 dfs_walk (TYPE_BINFO (type), dfs_unmark, markedp, type);
140 /* Return an expression for the zero-initialization of an object with
141 type T. This expression will either be a constant (in the case
142 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
143 aggregate). In either case, the value can be used as DECL_INITIAL
144 for a decl of the indicated TYPE; it is a valid static initializer.
145 If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS is the
146 number of elements in the array. If STATIC_STORAGE_P is TRUE,
147 initializers are only generated for entities for which
148 zero-initialization does not simply mean filling the storage with
152 build_zero_init (tree type, tree nelts, bool static_storage_p)
154 tree init = NULL_TREE;
158 To zero-initialization storage for an object of type T means:
160 -- if T is a scalar type, the storage is set to the value of zero
163 -- if T is a non-union class type, the storage for each nonstatic
164 data member and each base-class subobject is zero-initialized.
166 -- if T is a union type, the storage for its first data member is
169 -- if T is an array type, the storage for each element is
172 -- if T is a reference type, no initialization is performed. */
174 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
176 if (type == error_mark_node)
178 else if (static_storage_p && zero_init_p (type))
179 /* In order to save space, we do not explicitly build initializers
180 for items that do not need them. GCC's semantics are that
181 items with static storage duration that are not otherwise
182 initialized are initialized to zero. */
184 else if (SCALAR_TYPE_P (type))
185 init = convert (type, integer_zero_node);
186 else if (CLASS_TYPE_P (type))
191 /* Build a constructor to contain the initializations. */
192 init = build_constructor (type, NULL_TREE);
193 /* Iterate over the fields, building initializations. */
195 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
197 if (TREE_CODE (field) != FIELD_DECL)
200 /* Note that for class types there will be FIELD_DECLs
201 corresponding to base classes as well. Thus, iterating
202 over TYPE_FIELDs will result in correct initialization of
203 all of the subobjects. */
204 if (static_storage_p && !zero_init_p (TREE_TYPE (field)))
205 inits = tree_cons (field,
206 build_zero_init (TREE_TYPE (field),
211 /* For unions, only the first field is initialized. */
212 if (TREE_CODE (type) == UNION_TYPE)
215 CONSTRUCTOR_ELTS (init) = nreverse (inits);
217 else if (TREE_CODE (type) == ARRAY_TYPE)
223 /* Build a constructor to contain the initializations. */
224 init = build_constructor (type, NULL_TREE);
225 /* Iterate over the array elements, building initializations. */
227 max_index = nelts ? nelts : array_type_nelts (type);
228 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
230 /* A zero-sized array, which is accepted as an extension, will
231 have an upper bound of -1. */
232 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
233 for (index = size_zero_node;
234 !tree_int_cst_lt (max_index, index);
235 index = size_binop (PLUS_EXPR, index, size_one_node))
236 inits = tree_cons (index,
237 build_zero_init (TREE_TYPE (type),
241 CONSTRUCTOR_ELTS (init) = nreverse (inits);
244 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
246 /* In all cases, the initializer is a constant. */
249 TREE_CONSTANT (init) = 1;
250 TREE_INVARIANT (init) = 1;
256 /* Build an expression for the default-initialization of an object of
257 the indicated TYPE. If NELTS is non-NULL, and TYPE is an
258 ARRAY_TYPE, NELTS is the number of elements in the array. If
259 initialization of TYPE requires calling constructors, this function
260 returns NULL_TREE; the caller is responsible for arranging for the
261 constructors to be called. */
264 build_default_init (tree type, tree nelts)
268 To default-initialize an object of type T means:
270 --if T is a non-POD class type (clause _class_), the default construc-
271 tor for T is called (and the initialization is ill-formed if T has
272 no accessible default constructor);
274 --if T is an array type, each element is default-initialized;
276 --otherwise, the storage for the object is zero-initialized.
278 A program that calls for default-initialization of an entity of refer-
279 ence type is ill-formed. */
281 /* If TYPE_NEEDS_CONSTRUCTING is true, the caller is responsible for
282 performing the initialization. This is confusing in that some
283 non-PODs do not have TYPE_NEEDS_CONSTRUCTING set. (For example,
284 a class with a pointer-to-data member as a non-static data member
285 does not have TYPE_NEEDS_CONSTRUCTING set.) Therefore, we end up
286 passing non-PODs to build_zero_init below, which is contrary to
287 the semantics quoted above from [dcl.init].
289 It happens, however, that the behavior of the constructor the
290 standard says we should have generated would be precisely the
291 same as that obtained by calling build_zero_init below, so things
293 if (TYPE_NEEDS_CONSTRUCTING (type)
294 || (nelts && TREE_CODE (nelts) != INTEGER_CST))
297 /* At this point, TYPE is either a POD class type, an array of POD
298 classes, or something even more innocuous. */
299 return build_zero_init (type, nelts, /*static_storage_p=*/false);
302 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
303 arguments. If TREE_LIST is void_type_node, an empty initializer
304 list was given; if NULL_TREE no initializer was given. */
307 perform_member_init (tree member, tree init)
310 tree type = TREE_TYPE (member);
313 explicit = (init != NULL_TREE);
315 /* Effective C++ rule 12 requires that all data members be
317 if (warn_ecpp && !explicit && TREE_CODE (type) != ARRAY_TYPE)
318 warning ("%J%qD should be initialized in the member initialization "
319 "list", current_function_decl, member);
321 if (init == void_type_node)
324 /* Get an lvalue for the data member. */
325 decl = build_class_member_access_expr (current_class_ref, member,
326 /*access_path=*/NULL_TREE,
327 /*preserve_reference=*/true);
328 if (decl == error_mark_node)
331 /* Deal with this here, as we will get confused if we try to call the
332 assignment op for an anonymous union. This can happen in a
333 synthesized copy constructor. */
334 if (ANON_AGGR_TYPE_P (type))
338 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
339 finish_expr_stmt (init);
342 else if (TYPE_NEEDS_CONSTRUCTING (type))
345 && TREE_CODE (type) == ARRAY_TYPE
347 && TREE_CHAIN (init) == NULL_TREE
348 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
350 /* Initialization of one array from another. */
351 finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
355 finish_expr_stmt (build_aggr_init (decl, init, 0));
359 if (init == NULL_TREE)
363 init = build_default_init (type, /*nelts=*/NULL_TREE);
364 if (TREE_CODE (type) == REFERENCE_TYPE)
365 warning ("%Jdefault-initialization of %q#D, "
366 "which has reference type",
367 current_function_decl, member);
369 /* member traversal: note it leaves init NULL */
370 else if (TREE_CODE (type) == REFERENCE_TYPE)
371 pedwarn ("%Juninitialized reference member %qD",
372 current_function_decl, member);
373 else if (CP_TYPE_CONST_P (type))
374 pedwarn ("%Juninitialized member %qD with %<const%> type %qT",
375 current_function_decl, member, type);
377 else if (TREE_CODE (init) == TREE_LIST)
378 /* There was an explicit member initialization. Do some work
380 init = build_x_compound_expr_from_list (init, "member initializer");
383 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
386 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
390 expr = build_class_member_access_expr (current_class_ref, member,
391 /*access_path=*/NULL_TREE,
392 /*preserve_reference=*/false);
393 expr = build_delete (type, expr, sfk_complete_destructor,
394 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
396 if (expr != error_mark_node)
397 finish_eh_cleanup (expr);
401 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
402 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
405 build_field_list (tree t, tree list, int *uses_unions_p)
411 /* Note whether or not T is a union. */
412 if (TREE_CODE (t) == UNION_TYPE)
415 for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
417 /* Skip CONST_DECLs for enumeration constants and so forth. */
418 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
421 /* Keep track of whether or not any fields are unions. */
422 if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
425 /* For an anonymous struct or union, we must recursively
426 consider the fields of the anonymous type. They can be
427 directly initialized from the constructor. */
428 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
430 /* Add this field itself. Synthesized copy constructors
431 initialize the entire aggregate. */
432 list = tree_cons (fields, NULL_TREE, list);
433 /* And now add the fields in the anonymous aggregate. */
434 list = build_field_list (TREE_TYPE (fields), list,
437 /* Add this field. */
438 else if (DECL_NAME (fields))
439 list = tree_cons (fields, NULL_TREE, list);
445 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
446 a FIELD_DECL or BINFO in T that needs initialization. The
447 TREE_VALUE gives the initializer, or list of initializer arguments.
449 Return a TREE_LIST containing all of the initializations required
450 for T, in the order in which they should be performed. The output
451 list has the same format as the input. */
454 sort_mem_initializers (tree t, tree mem_inits)
457 tree base, binfo, base_binfo;
464 /* Build up a list of initializations. The TREE_PURPOSE of entry
465 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
466 TREE_VALUE will be the constructor arguments, or NULL if no
467 explicit initialization was provided. */
468 sorted_inits = NULL_TREE;
470 /* Process the virtual bases. */
471 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
472 VEC_iterate (tree, vbases, i, base); i++)
473 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
475 /* Process the direct bases. */
476 for (binfo = TYPE_BINFO (t), i = 0;
477 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
478 if (!BINFO_VIRTUAL_P (base_binfo))
479 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
481 /* Process the non-static data members. */
482 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
483 /* Reverse the entire list of initializations, so that they are in
484 the order that they will actually be performed. */
485 sorted_inits = nreverse (sorted_inits);
487 /* If the user presented the initializers in an order different from
488 that in which they will actually occur, we issue a warning. Keep
489 track of the next subobject which can be explicitly initialized
490 without issuing a warning. */
491 next_subobject = sorted_inits;
493 /* Go through the explicit initializers, filling in TREE_PURPOSE in
495 for (init = mem_inits; init; init = TREE_CHAIN (init))
500 subobject = TREE_PURPOSE (init);
502 /* If the explicit initializers are in sorted order, then
503 SUBOBJECT will be NEXT_SUBOBJECT, or something following
505 for (subobject_init = next_subobject;
507 subobject_init = TREE_CHAIN (subobject_init))
508 if (TREE_PURPOSE (subobject_init) == subobject)
511 /* Issue a warning if the explicit initializer order does not
512 match that which will actually occur.
513 ??? Are all these on the correct lines? */
514 if (warn_reorder && !subobject_init)
516 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
517 cp_warning_at ("`%D' will be initialized after",
518 TREE_PURPOSE (next_subobject));
520 warning ("base `%T' will be initialized after",
521 TREE_PURPOSE (next_subobject));
522 if (TREE_CODE (subobject) == FIELD_DECL)
523 cp_warning_at (" `%#D'", subobject);
525 warning (" base `%T'", subobject);
526 warning ("%J when initialized here", current_function_decl);
529 /* Look again, from the beginning of the list. */
532 subobject_init = sorted_inits;
533 while (TREE_PURPOSE (subobject_init) != subobject)
534 subobject_init = TREE_CHAIN (subobject_init);
537 /* It is invalid to initialize the same subobject more than
539 if (TREE_VALUE (subobject_init))
541 if (TREE_CODE (subobject) == FIELD_DECL)
542 error ("%Jmultiple initializations given for %qD",
543 current_function_decl, subobject);
545 error ("%Jmultiple initializations given for base %qT",
546 current_function_decl, subobject);
549 /* Record the initialization. */
550 TREE_VALUE (subobject_init) = TREE_VALUE (init);
551 next_subobject = subobject_init;
556 If a ctor-initializer specifies more than one mem-initializer for
557 multiple members of the same union (including members of
558 anonymous unions), the ctor-initializer is ill-formed. */
561 tree last_field = NULL_TREE;
562 for (init = sorted_inits; init; init = TREE_CHAIN (init))
568 /* Skip uninitialized members and base classes. */
569 if (!TREE_VALUE (init)
570 || TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
572 /* See if this field is a member of a union, or a member of a
573 structure contained in a union, etc. */
574 field = TREE_PURPOSE (init);
575 for (field_type = DECL_CONTEXT (field);
576 !same_type_p (field_type, t);
577 field_type = TYPE_CONTEXT (field_type))
578 if (TREE_CODE (field_type) == UNION_TYPE)
580 /* If this field is not a member of a union, skip it. */
581 if (TREE_CODE (field_type) != UNION_TYPE)
584 /* It's only an error if we have two initializers for the same
592 /* See if LAST_FIELD and the field initialized by INIT are
593 members of the same union. If so, there's a problem,
594 unless they're actually members of the same structure
595 which is itself a member of a union. For example, given:
597 union { struct { int i; int j; }; };
599 initializing both `i' and `j' makes sense. */
600 field_type = DECL_CONTEXT (field);
604 tree last_field_type;
606 last_field_type = DECL_CONTEXT (last_field);
609 if (same_type_p (last_field_type, field_type))
611 if (TREE_CODE (field_type) == UNION_TYPE)
612 error ("%Jinitializations for multiple members of %qT",
613 current_function_decl, last_field_type);
618 if (same_type_p (last_field_type, t))
621 last_field_type = TYPE_CONTEXT (last_field_type);
624 /* If we've reached the outermost class, then we're
626 if (same_type_p (field_type, t))
629 field_type = TYPE_CONTEXT (field_type);
640 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
641 is a TREE_LIST giving the explicit mem-initializer-list for the
642 constructor. The TREE_PURPOSE of each entry is a subobject (a
643 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
644 is a TREE_LIST giving the arguments to the constructor or
645 void_type_node for an empty list of arguments. */
648 emit_mem_initializers (tree mem_inits)
650 /* Sort the mem-initializers into the order in which the
651 initializations should be performed. */
652 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
654 in_base_initializer = 1;
656 /* Initialize base classes. */
658 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
660 tree subobject = TREE_PURPOSE (mem_inits);
661 tree arguments = TREE_VALUE (mem_inits);
663 /* If these initializations are taking place in a copy
664 constructor, the base class should probably be explicitly
666 if (extra_warnings && !arguments
667 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
668 && TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (subobject)))
669 warning ("%Jbase class `%#T' should be explicitly initialized in the "
671 current_function_decl, BINFO_TYPE (subobject));
673 /* If an explicit -- but empty -- initializer list was present,
674 treat it just like default initialization at this point. */
675 if (arguments == void_type_node)
676 arguments = NULL_TREE;
678 /* Initialize the base. */
679 if (BINFO_VIRTUAL_P (subobject))
680 construct_virtual_base (subobject, arguments);
685 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
687 expand_aggr_init_1 (subobject, NULL_TREE,
688 build_indirect_ref (base_addr, NULL),
691 expand_cleanup_for_base (subobject, NULL_TREE);
694 mem_inits = TREE_CHAIN (mem_inits);
696 in_base_initializer = 0;
698 /* Initialize the vptrs. */
699 initialize_vtbl_ptrs (current_class_ptr);
701 /* Initialize the data members. */
704 perform_member_init (TREE_PURPOSE (mem_inits),
705 TREE_VALUE (mem_inits));
706 mem_inits = TREE_CHAIN (mem_inits);
710 /* Returns the address of the vtable (i.e., the value that should be
711 assigned to the vptr) for BINFO. */
714 build_vtbl_address (tree binfo)
716 tree binfo_for = binfo;
719 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
720 /* If this is a virtual primary base, then the vtable we want to store
721 is that for the base this is being used as the primary base of. We
722 can't simply skip the initialization, because we may be expanding the
723 inits of a subobject constructor where the virtual base layout
725 while (BINFO_PRIMARY_P (binfo_for))
726 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
728 /* Figure out what vtable BINFO's vtable is based on, and mark it as
730 vtbl = get_vtbl_decl_for_binfo (binfo_for);
731 assemble_external (vtbl);
732 TREE_USED (vtbl) = 1;
734 /* Now compute the address to use when initializing the vptr. */
735 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
736 if (TREE_CODE (vtbl) == VAR_DECL)
737 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
742 /* This code sets up the virtual function tables appropriate for
743 the pointer DECL. It is a one-ply initialization.
745 BINFO is the exact type that DECL is supposed to be. In
746 multiple inheritance, this might mean "C's A" if C : A, B. */
749 expand_virtual_init (tree binfo, tree decl)
754 /* Compute the initializer for vptr. */
755 vtbl = build_vtbl_address (binfo);
757 /* We may get this vptr from a VTT, if this is a subobject
758 constructor or subobject destructor. */
759 vtt_index = BINFO_VPTR_INDEX (binfo);
765 /* Compute the value to use, when there's a VTT. */
766 vtt_parm = current_vtt_parm;
767 vtbl2 = build2 (PLUS_EXPR,
768 TREE_TYPE (vtt_parm),
771 vtbl2 = build_indirect_ref (vtbl2, NULL);
772 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
774 /* The actual initializer is the VTT value only in the subobject
775 constructor. In maybe_clone_body we'll substitute NULL for
776 the vtt_parm in the case of the non-subobject constructor. */
777 vtbl = build3 (COND_EXPR,
779 build2 (EQ_EXPR, boolean_type_node,
780 current_in_charge_parm, integer_zero_node),
785 /* Compute the location of the vtpr. */
786 vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL),
788 gcc_assert (vtbl_ptr != error_mark_node);
790 /* Assign the vtable to the vptr. */
791 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
792 finish_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
795 /* If an exception is thrown in a constructor, those base classes already
796 constructed must be destroyed. This function creates the cleanup
797 for BINFO, which has just been constructed. If FLAG is non-NULL,
798 it is a DECL which is nonzero when this base needs to be
802 expand_cleanup_for_base (tree binfo, tree flag)
806 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
809 /* Call the destructor. */
810 expr = build_special_member_call (current_class_ref,
811 base_dtor_identifier,
814 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
816 expr = fold (build3 (COND_EXPR, void_type_node,
817 c_common_truthvalue_conversion (flag),
818 expr, integer_zero_node));
820 finish_eh_cleanup (expr);
823 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
827 construct_virtual_base (tree vbase, tree arguments)
833 /* If there are virtual base classes with destructors, we need to
834 emit cleanups to destroy them if an exception is thrown during
835 the construction process. These exception regions (i.e., the
836 period during which the cleanups must occur) begin from the time
837 the construction is complete to the end of the function. If we
838 create a conditional block in which to initialize the
839 base-classes, then the cleanup region for the virtual base begins
840 inside a block, and ends outside of that block. This situation
841 confuses the sjlj exception-handling code. Therefore, we do not
842 create a single conditional block, but one for each
843 initialization. (That way the cleanup regions always begin
844 in the outer block.) We trust the back-end to figure out
845 that the FLAG will not change across initializations, and
846 avoid doing multiple tests. */
847 flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
848 inner_if_stmt = begin_if_stmt ();
849 finish_if_stmt_cond (flag, inner_if_stmt);
851 /* Compute the location of the virtual base. If we're
852 constructing virtual bases, then we must be the most derived
853 class. Therefore, we don't have to look up the virtual base;
854 we already know where it is. */
855 exp = convert_to_base_statically (current_class_ref, vbase);
857 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
859 finish_then_clause (inner_if_stmt);
860 finish_if_stmt (inner_if_stmt);
862 expand_cleanup_for_base (vbase, flag);
865 /* Find the context in which this FIELD can be initialized. */
868 initializing_context (tree field)
870 tree t = DECL_CONTEXT (field);
872 /* Anonymous union members can be initialized in the first enclosing
873 non-anonymous union context. */
874 while (t && ANON_AGGR_TYPE_P (t))
875 t = TYPE_CONTEXT (t);
879 /* Function to give error message if member initialization specification
880 is erroneous. FIELD is the member we decided to initialize.
881 TYPE is the type for which the initialization is being performed.
882 FIELD must be a member of TYPE.
884 MEMBER_NAME is the name of the member. */
887 member_init_ok_or_else (tree field, tree type, tree member_name)
889 if (field == error_mark_node)
893 error ("class `%T' does not have any field named `%D'", type,
897 if (TREE_CODE (field) == VAR_DECL)
899 error ("`%#D' is a static data member; it can only be "
900 "initialized at its definition",
904 if (TREE_CODE (field) != FIELD_DECL)
906 error ("`%#D' is not a non-static data member of `%T'",
910 if (initializing_context (field) != type)
912 error ("class `%T' does not have any field named `%D'", type,
920 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
921 is a _TYPE node or TYPE_DECL which names a base for that type.
922 Check the validity of NAME, and return either the base _TYPE, base
923 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
924 NULL_TREE and issue a diagnostic.
926 An old style unnamed direct single base construction is permitted,
927 where NAME is NULL. */
930 expand_member_init (tree name)
935 if (!current_class_ref)
940 /* This is an obsolete unnamed base class initializer. The
941 parser will already have warned about its use. */
942 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
945 error ("unnamed initializer for `%T', which has no base classes",
949 basetype = BINFO_TYPE
950 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
953 error ("unnamed initializer for `%T', which uses multiple inheritance",
958 else if (TYPE_P (name))
960 basetype = TYPE_MAIN_VARIANT (name);
961 name = TYPE_NAME (name);
963 else if (TREE_CODE (name) == TYPE_DECL)
964 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
966 basetype = NULL_TREE;
975 if (current_template_parms)
978 class_binfo = TYPE_BINFO (current_class_type);
979 direct_binfo = NULL_TREE;
980 virtual_binfo = NULL_TREE;
982 /* Look for a direct base. */
983 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
984 if (same_type_p (basetype, BINFO_TYPE (direct_binfo)))
987 /* Look for a virtual base -- unless the direct base is itself
989 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
990 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
994 If a mem-initializer-id is ambiguous because it designates
995 both a direct non-virtual base class and an inherited virtual
996 base class, the mem-initializer is ill-formed. */
997 if (direct_binfo && virtual_binfo)
999 error ("'%D' is both a direct base and an indirect virtual base",
1004 if (!direct_binfo && !virtual_binfo)
1006 if (CLASSTYPE_VBASECLASSES (current_class_type))
1007 error ("type `%D' is not a direct or virtual base of `%T'",
1008 name, current_class_type);
1010 error ("type `%D' is not a direct base of `%T'",
1011 name, current_class_type);
1015 return direct_binfo ? direct_binfo : virtual_binfo;
1019 if (TREE_CODE (name) == IDENTIFIER_NODE)
1020 field = lookup_field (current_class_type, name, 1, false);
1024 if (member_init_ok_or_else (field, current_class_type, name))
1031 /* This is like `expand_member_init', only it stores one aggregate
1034 INIT comes in two flavors: it is either a value which
1035 is to be stored in EXP, or it is a parameter list
1036 to go to a constructor, which will operate on EXP.
1037 If INIT is not a parameter list for a constructor, then set
1038 LOOKUP_ONLYCONVERTING.
1039 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1040 the initializer, if FLAGS is 0, then it is the (init) form.
1041 If `init' is a CONSTRUCTOR, then we emit a warning message,
1042 explaining that such initializations are invalid.
1044 If INIT resolves to a CALL_EXPR which happens to return
1045 something of the type we are looking for, then we know
1046 that we can safely use that call to perform the
1049 The virtual function table pointer cannot be set up here, because
1050 we do not really know its type.
1052 This never calls operator=().
1054 When initializing, nothing is CONST.
1056 A default copy constructor may have to be used to perform the
1059 A constructor or a conversion operator may have to be used to
1060 perform the initialization, but not both, as it would be ambiguous. */
1063 build_aggr_init (tree exp, tree init, int flags)
1068 tree type = TREE_TYPE (exp);
1069 int was_const = TREE_READONLY (exp);
1070 int was_volatile = TREE_THIS_VOLATILE (exp);
1073 if (init == error_mark_node)
1074 return error_mark_node;
1076 TREE_READONLY (exp) = 0;
1077 TREE_THIS_VOLATILE (exp) = 0;
1079 if (init && TREE_CODE (init) != TREE_LIST)
1080 flags |= LOOKUP_ONLYCONVERTING;
1082 if (TREE_CODE (type) == ARRAY_TYPE)
1086 /* An array may not be initialized use the parenthesized
1087 initialization form -- unless the initializer is "()". */
1088 if (init && TREE_CODE (init) == TREE_LIST)
1090 error ("bad array initializer");
1091 return error_mark_node;
1093 /* Must arrange to initialize each element of EXP
1094 from elements of INIT. */
1095 itype = init ? TREE_TYPE (init) : NULL_TREE;
1096 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
1097 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1098 if (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
1099 itype = TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1100 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1101 itype && same_type_p (itype,
1103 TREE_READONLY (exp) = was_const;
1104 TREE_THIS_VOLATILE (exp) = was_volatile;
1105 TREE_TYPE (exp) = type;
1107 TREE_TYPE (init) = itype;
1111 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1112 /* Just know that we've seen something for this node. */
1113 TREE_USED (exp) = 1;
1115 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1116 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1117 destroy_temps = stmts_are_full_exprs_p ();
1118 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1119 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1120 init, LOOKUP_NORMAL|flags);
1121 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1122 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1123 TREE_TYPE (exp) = type;
1124 TREE_READONLY (exp) = was_const;
1125 TREE_THIS_VOLATILE (exp) = was_volatile;
1130 /* Like build_aggr_init, but not just for aggregates. */
1133 build_init (tree decl, tree init, int flags)
1137 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1138 expr = build_aggr_init (decl, init, flags);
1139 else if (CLASS_TYPE_P (TREE_TYPE (decl)))
1140 expr = build_special_member_call (decl, complete_ctor_identifier,
1141 build_tree_list (NULL_TREE, init),
1143 LOOKUP_NORMAL|flags);
1145 expr = build2 (INIT_EXPR, TREE_TYPE (decl), decl, init);
1151 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags)
1153 tree type = TREE_TYPE (exp);
1156 /* It fails because there may not be a constructor which takes
1157 its own type as the first (or only parameter), but which does
1158 take other types via a conversion. So, if the thing initializing
1159 the expression is a unit element of type X, first try X(X&),
1160 followed by initialization by X. If neither of these work
1161 out, then look hard. */
1165 if (init && TREE_CODE (init) != TREE_LIST
1166 && (flags & LOOKUP_ONLYCONVERTING))
1168 /* Base subobjects should only get direct-initialization. */
1169 gcc_assert (true_exp == exp);
1171 if (flags & DIRECT_BIND)
1172 /* Do nothing. We hit this in two cases: Reference initialization,
1173 where we aren't initializing a real variable, so we don't want
1174 to run a new constructor; and catching an exception, where we
1175 have already built up the constructor call so we could wrap it
1176 in an exception region. */;
1177 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
1179 /* A brace-enclosed initializer for an aggregate. */
1180 gcc_assert (CP_AGGREGATE_TYPE_P (type));
1181 init = digest_init (type, init, (tree *)NULL);
1184 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1186 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1187 /* We need to protect the initialization of a catch parm with a
1188 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1189 around the TARGET_EXPR for the copy constructor. See
1190 initialize_handler_parm. */
1192 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1193 TREE_OPERAND (init, 0));
1194 TREE_TYPE (init) = void_type_node;
1197 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1198 TREE_SIDE_EFFECTS (init) = 1;
1199 finish_expr_stmt (init);
1203 if (init == NULL_TREE
1204 || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1208 init = TREE_VALUE (parms);
1211 parms = build_tree_list (NULL_TREE, init);
1213 if (true_exp == exp)
1214 ctor_name = complete_ctor_identifier;
1216 ctor_name = base_ctor_identifier;
1218 rval = build_special_member_call (exp, ctor_name, parms, binfo, flags);
1219 if (TREE_SIDE_EFFECTS (rval))
1220 finish_expr_stmt (convert_to_void (rval, NULL));
1223 /* This function is responsible for initializing EXP with INIT
1226 BINFO is the binfo of the type for who we are performing the
1227 initialization. For example, if W is a virtual base class of A and B,
1229 If we are initializing B, then W must contain B's W vtable, whereas
1230 were we initializing C, W must contain C's W vtable.
1232 TRUE_EXP is nonzero if it is the true expression being initialized.
1233 In this case, it may be EXP, or may just contain EXP. The reason we
1234 need this is because if EXP is a base element of TRUE_EXP, we
1235 don't necessarily know by looking at EXP where its virtual
1236 baseclass fields should really be pointing. But we do know
1237 from TRUE_EXP. In constructors, we don't know anything about
1238 the value being initialized.
1240 FLAGS is just passed to `build_new_method_call'. See that function
1241 for its description. */
1244 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags)
1246 tree type = TREE_TYPE (exp);
1248 gcc_assert (init != error_mark_node && type != error_mark_node);
1249 gcc_assert (building_stmt_tree ());
1251 /* Use a function returning the desired type to initialize EXP for us.
1252 If the function is a constructor, and its first argument is
1253 NULL_TREE, know that it was meant for us--just slide exp on
1254 in and expand the constructor. Constructors now come
1257 if (init && TREE_CODE (exp) == VAR_DECL
1258 && TREE_CODE (init) == CONSTRUCTOR
1259 && TREE_HAS_CONSTRUCTOR (init))
1261 /* If store_init_value returns NULL_TREE, the INIT has been
1262 record in the DECL_INITIAL for EXP. That means there's
1263 nothing more we have to do. */
1264 init = store_init_value (exp, init);
1266 finish_expr_stmt (init);
1270 /* We know that expand_default_init can handle everything we want
1272 expand_default_init (binfo, true_exp, exp, init, flags);
1275 /* Report an error if TYPE is not a user-defined, aggregate type. If
1276 OR_ELSE is nonzero, give an error message. */
1279 is_aggr_type (tree type, int or_else)
1281 if (type == error_mark_node)
1284 if (! IS_AGGR_TYPE (type)
1285 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1286 && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
1289 error ("`%T' is not an aggregate type", type);
1296 get_type_value (tree name)
1298 if (name == error_mark_node)
1301 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1302 return IDENTIFIER_TYPE_VALUE (name);
1307 /* Build a reference to a member of an aggregate. This is not a C++
1308 `&', but really something which can have its address taken, and
1309 then act as a pointer to member, for example TYPE :: FIELD can have
1310 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1311 this expression is the operand of "&".
1313 @@ Prints out lousy diagnostics for operator <typename>
1316 @@ This function should be rewritten and placed in search.c. */
1319 build_offset_ref (tree type, tree name, bool address_p)
1323 tree basebinfo = NULL_TREE;
1324 tree orig_name = name;
1326 /* class templates can come in as TEMPLATE_DECLs here. */
1327 if (TREE_CODE (name) == TEMPLATE_DECL)
1330 if (dependent_type_p (type) || type_dependent_expression_p (name))
1331 return build_min_nt (SCOPE_REF, type, name);
1333 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1335 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1336 something like `a.template f<int>' or the like. For the most
1337 part, we treat this just like a.f. We do remember, however,
1338 the template-id that was used. */
1339 name = TREE_OPERAND (orig_name, 0);
1342 name = DECL_NAME (name);
1345 if (TREE_CODE (name) == COMPONENT_REF)
1346 name = TREE_OPERAND (name, 1);
1347 if (TREE_CODE (name) == OVERLOAD)
1348 name = DECL_NAME (OVL_CURRENT (name));
1351 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1354 if (type == NULL_TREE)
1355 return error_mark_node;
1357 /* Handle namespace names fully here. */
1358 if (TREE_CODE (type) == NAMESPACE_DECL)
1360 tree t = lookup_namespace_name (type, name);
1361 if (t == error_mark_node)
1363 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1364 /* Reconstruct the TEMPLATE_ID_EXPR. */
1365 t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t),
1366 t, TREE_OPERAND (orig_name, 1));
1367 if (! type_unknown_p (t))
1370 t = convert_from_reference (t);
1375 if (! is_aggr_type (type, 1))
1376 return error_mark_node;
1378 if (TREE_CODE (name) == BIT_NOT_EXPR)
1380 if (! check_dtor_name (type, name))
1381 error ("qualified type `%T' does not match destructor name `~%T'",
1382 type, TREE_OPERAND (name, 0));
1383 name = dtor_identifier;
1386 if (!COMPLETE_TYPE_P (complete_type (type))
1387 && !TYPE_BEING_DEFINED (type))
1389 error ("incomplete type `%T' does not have member `%D'", type,
1391 return error_mark_node;
1394 /* Set up BASEBINFO for member lookup. */
1395 decl = maybe_dummy_object (type, &basebinfo);
1397 if (BASELINK_P (name) || DECL_P (name))
1401 member = lookup_member (basebinfo, name, 1, 0);
1403 if (member == error_mark_node)
1404 return error_mark_node;
1409 error ("`%D' is not a member of type `%T'", name, type);
1410 return error_mark_node;
1413 if (processing_template_decl)
1415 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1416 return build_min (SCOPE_REF, TREE_TYPE (member), type, orig_name);
1418 return build_min (SCOPE_REF, TREE_TYPE (member), type, name);
1421 if (TREE_CODE (member) == TYPE_DECL)
1423 TREE_USED (member) = 1;
1426 /* static class members and class-specific enum
1427 values can be returned without further ado. */
1428 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1431 return convert_from_reference (member);
1434 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1436 error ("invalid pointer to bit-field `%D'", member);
1437 return error_mark_node;
1440 /* A lot of this logic is now handled in lookup_member. */
1441 if (BASELINK_P (member))
1443 /* Go from the TREE_BASELINK to the member function info. */
1444 tree fnfields = member;
1445 tree t = BASELINK_FUNCTIONS (fnfields);
1447 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1449 /* The FNFIELDS are going to contain functions that aren't
1450 necessarily templates, and templates that don't
1451 necessarily match the explicit template parameters. We
1452 save all the functions, and the explicit parameters, and
1453 then figure out exactly what to instantiate with what
1454 arguments in instantiate_type. */
1456 if (TREE_CODE (t) != OVERLOAD)
1457 /* The code in instantiate_type which will process this
1458 expects to encounter OVERLOADs, not raw functions. */
1459 t = ovl_cons (t, NULL_TREE);
1461 t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t), t,
1462 TREE_OPERAND (orig_name, 1));
1463 t = build2 (OFFSET_REF, unknown_type_node, decl, t);
1465 PTRMEM_OK_P (t) = 1;
1470 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1472 /* Get rid of a potential OVERLOAD around it. */
1473 t = OVL_CURRENT (t);
1475 /* Unique functions are handled easily. */
1477 /* For non-static member of base class, we need a special rule
1478 for access checking [class.protected]:
1480 If the access is to form a pointer to member, the
1481 nested-name-specifier shall name the derived class
1482 (or any class derived from that class). */
1483 if (address_p && DECL_P (t)
1484 && DECL_NONSTATIC_MEMBER_P (t))
1485 perform_or_defer_access_check (TYPE_BINFO (type), t);
1487 perform_or_defer_access_check (basebinfo, t);
1490 if (DECL_STATIC_FUNCTION_P (t))
1496 TREE_TYPE (fnfields) = unknown_type_node;
1500 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1501 /* We need additional test besides the one in
1502 check_accessibility_of_qualified_id in case it is
1503 a pointer to non-static member. */
1504 perform_or_defer_access_check (TYPE_BINFO (type), member);
1508 /* If MEMBER is non-static, then the program has fallen afoul of
1511 An id-expression that denotes a nonstatic data member or
1512 nonstatic member function of a class can only be used:
1514 -- as part of a class member access (_expr.ref_) in which the
1515 object-expression refers to the member's class or a class
1516 derived from that class, or
1518 -- to form a pointer to member (_expr.unary.op_), or
1520 -- in the body of a nonstatic member function of that class or
1521 of a class derived from that class (_class.mfct.nonstatic_), or
1523 -- in a mem-initializer for a constructor for that class or for
1524 a class derived from that class (_class.base.init_). */
1525 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1527 /* Build a representation of a the qualified name suitable
1528 for use as the operand to "&" -- even though the "&" is
1529 not actually present. */
1530 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1531 /* In Microsoft mode, treat a non-static member function as if
1532 it were a pointer-to-member. */
1533 if (flag_ms_extensions)
1535 PTRMEM_OK_P (member) = 1;
1536 return build_unary_op (ADDR_EXPR, member, 0);
1538 error ("invalid use of non-static member function `%D'",
1539 TREE_OPERAND (member, 1));
1542 else if (TREE_CODE (member) == FIELD_DECL)
1544 error ("invalid use of non-static data member `%D'", member);
1545 return error_mark_node;
1550 /* In member functions, the form `type::name' is no longer
1551 equivalent to `this->type::name', at least not until
1552 resolve_offset_ref. */
1553 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1554 PTRMEM_OK_P (member) = 1;
1558 /* If DECL is a `const' declaration, and its value is a known
1559 constant, then return that value. */
1562 decl_constant_value (tree decl)
1564 /* When we build a COND_EXPR, we don't know whether it will be used
1565 as an lvalue or as an rvalue. If it is an lvalue, it's not safe
1566 to replace the second and third operands with their
1567 initializers. So, we do that here. */
1568 if (TREE_CODE (decl) == COND_EXPR)
1573 d1 = decl_constant_value (TREE_OPERAND (decl, 1));
1574 d2 = decl_constant_value (TREE_OPERAND (decl, 2));
1576 if (d1 != TREE_OPERAND (decl, 1) || d2 != TREE_OPERAND (decl, 2))
1577 return build3 (COND_EXPR,
1579 TREE_OPERAND (decl, 0), d1, d2);
1583 && (/* Enumeration constants are constant. */
1584 TREE_CODE (decl) == CONST_DECL
1585 /* And so are variables with a 'const' type -- unless they
1586 are also 'volatile'. */
1587 || CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))
1588 && TREE_CODE (decl) != PARM_DECL
1589 && DECL_INITIAL (decl)
1590 && DECL_INITIAL (decl) != error_mark_node
1591 /* This is invalid if initial value is not constant.
1592 If it has either a function call, a memory reference,
1593 or a variable, then re-evaluating it could give different results. */
1594 && TREE_CONSTANT (DECL_INITIAL (decl))
1595 /* Check for cases where this is sub-optimal, even though valid. */
1596 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1597 return DECL_INITIAL (decl);
1601 /* Common subroutines of build_new and build_vec_delete. */
1603 /* Call the global __builtin_delete to delete ADDR. */
1606 build_builtin_delete_call (tree addr)
1608 mark_used (global_delete_fndecl);
1609 return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
1612 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1613 (which needs to go through some sort of groktypename) or it
1614 is the name of the class we are newing. INIT is an initialization value.
1615 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1616 If INIT is void_type_node, it means do *not* call a constructor
1619 For types with constructors, the data returned is initialized
1620 by the appropriate constructor.
1622 Whether the type has a constructor or not, if it has a pointer
1623 to a virtual function table, then that pointer is set up
1626 Unless I am mistaken, a call to new () will return initialized
1627 data regardless of whether the constructor itself is private or
1628 not. NOPE; new fails if the constructor is private (jcm).
1630 Note that build_new does nothing to assure that any special
1631 alignment requirements of the type are met. Rather, it leaves
1632 it up to malloc to do the right thing. Otherwise, folding to
1633 the right alignment cal cause problems if the user tries to later
1634 free the memory returned by `new'.
1636 PLACEMENT is the `placement' list for user-defined operator new (). */
1639 build_new (tree placement, tree type, tree nelts, tree init,
1644 if (type == error_mark_node)
1645 return error_mark_node;
1647 if (processing_template_decl)
1649 rval = build_min (NEW_EXPR, build_pointer_type (type),
1650 placement, type, nelts, init);
1651 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1652 TREE_SIDE_EFFECTS (rval) = 1;
1656 /* ``A reference cannot be created by the new operator. A reference
1657 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
1658 returned by new.'' ARM 5.3.3 */
1659 if (TREE_CODE (type) == REFERENCE_TYPE)
1661 error ("new cannot be applied to a reference type");
1662 type = TREE_TYPE (type);
1665 if (TREE_CODE (type) == FUNCTION_TYPE)
1667 error ("new cannot be applied to a function type");
1668 return error_mark_node;
1671 rval = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
1673 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1674 TREE_SIDE_EFFECTS (rval) = 1;
1675 rval = build_new_1 (rval);
1676 if (rval == error_mark_node)
1677 return error_mark_node;
1679 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
1680 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
1681 TREE_NO_WARNING (rval) = 1;
1686 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
1689 build_java_class_ref (tree type)
1691 tree name = NULL_TREE, class_decl;
1692 static tree CL_suffix = NULL_TREE;
1693 if (CL_suffix == NULL_TREE)
1694 CL_suffix = get_identifier("class$");
1695 if (jclass_node == NULL_TREE)
1697 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
1698 if (jclass_node == NULL_TREE)
1699 fatal_error ("call to Java constructor, while `jclass' undefined");
1701 jclass_node = TREE_TYPE (jclass_node);
1704 /* Mangle the class$ field. */
1707 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1708 if (DECL_NAME (field) == CL_suffix)
1710 mangle_decl (field);
1711 name = DECL_ASSEMBLER_NAME (field);
1715 internal_error ("can't find class$");
1718 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
1719 if (class_decl == NULL_TREE)
1721 class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
1722 TREE_STATIC (class_decl) = 1;
1723 DECL_EXTERNAL (class_decl) = 1;
1724 TREE_PUBLIC (class_decl) = 1;
1725 DECL_ARTIFICIAL (class_decl) = 1;
1726 DECL_IGNORED_P (class_decl) = 1;
1727 pushdecl_top_level (class_decl);
1728 make_decl_rtl (class_decl);
1734 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
1735 value is immediately handed to expand_expr. */
1738 build_new_1 (tree exp)
1740 tree placement, init;
1741 tree true_type, size, rval;
1742 /* The type of the new-expression. (This type is always a pointer
1745 /* The type pointed to by POINTER_TYPE. */
1747 /* The type being allocated. For "new T[...]" this will be an
1750 /* A pointer type pointing to to the FULL_TYPE. */
1751 tree full_pointer_type;
1752 tree outer_nelts = NULL_TREE;
1753 tree nelts = NULL_TREE;
1754 tree alloc_call, alloc_expr;
1755 /* The address returned by the call to "operator new". This node is
1756 a VAR_DECL and is therefore reusable. */
1759 tree cookie_expr, init_expr;
1761 enum tree_code code;
1762 int nothrow, check_new;
1763 /* Nonzero if the user wrote `::new' rather than just `new'. */
1764 int globally_qualified_p;
1765 int use_java_new = 0;
1766 /* If non-NULL, the number of extra bytes to allocate at the
1767 beginning of the storage allocated for an array-new expression in
1768 order to store the number of elements. */
1769 tree cookie_size = NULL_TREE;
1770 /* True if the function we are calling is a placement allocation
1772 bool placement_allocation_fn_p;
1773 tree args = NULL_TREE;
1774 /* True if the storage must be initialized, either by a constructor
1775 or due to an explicit new-initializer. */
1776 bool is_initialized;
1777 /* The address of the thing allocated, not including any cookie. In
1778 particular, if an array cookie is in use, DATA_ADDR is the
1779 address of the first array element. This node is a VAR_DECL, and
1780 is therefore reusable. */
1782 tree init_preeval_expr = NULL_TREE;
1784 placement = TREE_OPERAND (exp, 0);
1785 type = TREE_OPERAND (exp, 1);
1786 nelts = TREE_OPERAND (exp, 2);
1787 init = TREE_OPERAND (exp, 3);
1788 globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
1795 outer_nelts = nelts;
1797 /* ??? The middle-end will error on us for building a VLA outside a
1798 function context. Methinks that's not it's purvey. So we'll do
1799 our own VLA layout later. */
1801 full_type = build_cplus_array_type (type, NULL_TREE);
1803 index = convert (sizetype, nelts);
1804 index = size_binop (MINUS_EXPR, index, size_one_node);
1805 TYPE_DOMAIN (full_type) = build_index_type (index);
1812 code = has_array ? VEC_NEW_EXPR : NEW_EXPR;
1814 /* If our base type is an array, then make sure we know how many elements
1816 while (TREE_CODE (true_type) == ARRAY_TYPE)
1818 tree this_nelts = array_type_nelts_top (true_type);
1819 nelts = cp_build_binary_op (MULT_EXPR, nelts, this_nelts);
1820 true_type = TREE_TYPE (true_type);
1823 if (!complete_type_or_else (true_type, exp))
1824 return error_mark_node;
1826 if (TREE_CODE (true_type) == VOID_TYPE)
1828 error ("invalid type `void' for new");
1829 return error_mark_node;
1832 if (abstract_virtuals_error (NULL_TREE, true_type))
1833 return error_mark_node;
1835 is_initialized = (TYPE_NEEDS_CONSTRUCTING (type) || init);
1836 if (CP_TYPE_CONST_P (true_type) && !is_initialized)
1838 error ("uninitialized const in `new' of `%#T'", true_type);
1839 return error_mark_node;
1842 size = size_in_bytes (true_type);
1847 /* Do our own VLA layout. Setting TYPE_SIZE/_UNIT is necessary in
1848 order for the <INIT_EXPR <*foo> <CONSTRUCTOR ...>> to be valid. */
1850 n = convert (sizetype, nelts);
1851 size = size_binop (MULT_EXPR, size, n);
1852 TYPE_SIZE_UNIT (full_type) = size;
1854 n = convert (bitsizetype, nelts);
1855 bitsize = size_binop (MULT_EXPR, TYPE_SIZE (true_type), n);
1856 TYPE_SIZE (full_type) = bitsize;
1859 /* Allocate the object. */
1860 if (! placement && TYPE_FOR_JAVA (true_type))
1862 tree class_addr, alloc_decl;
1863 tree class_decl = build_java_class_ref (true_type);
1864 static const char alloc_name[] = "_Jv_AllocObject";
1868 if (!get_global_value_if_present (get_identifier (alloc_name),
1871 error ("call to Java constructor with `%s' undefined", alloc_name);
1872 return error_mark_node;
1874 else if (really_overloaded_fn (alloc_decl))
1876 error ("`%D' should never be overloaded", alloc_decl);
1877 return error_mark_node;
1879 alloc_decl = OVL_CURRENT (alloc_decl);
1880 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1881 alloc_call = (build_function_call
1883 build_tree_list (NULL_TREE, class_addr)));
1890 fnname = ansi_opname (code);
1892 if (!globally_qualified_p
1893 && CLASS_TYPE_P (true_type)
1895 ? TYPE_HAS_ARRAY_NEW_OPERATOR (true_type)
1896 : TYPE_HAS_NEW_OPERATOR (true_type)))
1898 /* Use a class-specific operator new. */
1899 /* If a cookie is required, add some extra space. */
1900 if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type))
1902 cookie_size = targetm.cxx.get_cookie_size (true_type);
1903 size = size_binop (PLUS_EXPR, size, cookie_size);
1905 /* Create the argument list. */
1906 args = tree_cons (NULL_TREE, size, placement);
1907 /* Do name-lookup to find the appropriate operator. */
1908 fns = lookup_fnfields (true_type, fnname, /*protect=*/2);
1909 if (TREE_CODE (fns) == TREE_LIST)
1911 error ("request for member `%D' is ambiguous", fnname);
1912 print_candidates (fns);
1913 return error_mark_node;
1915 alloc_call = build_new_method_call (build_dummy_object (true_type),
1917 /*conversion_path=*/NULL_TREE,
1922 /* Use a global operator new. */
1923 /* See if a cookie might be required. */
1924 if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type))
1925 cookie_size = targetm.cxx.get_cookie_size (true_type);
1927 cookie_size = NULL_TREE;
1929 alloc_call = build_operator_new_call (fnname, placement,
1930 &size, &cookie_size);
1934 if (alloc_call == error_mark_node)
1935 return error_mark_node;
1937 /* In the simple case, we can stop now. */
1938 pointer_type = build_pointer_type (type);
1939 if (!cookie_size && !is_initialized)
1940 return build_nop (pointer_type, alloc_call);
1942 /* While we're working, use a pointer to the type we've actually
1943 allocated. Store the result of the call in a variable so that we
1944 can use it more than once. */
1945 full_pointer_type = build_pointer_type (full_type);
1946 alloc_expr = get_target_expr (build_nop (full_pointer_type, alloc_call));
1947 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
1949 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
1950 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
1951 alloc_call = TREE_OPERAND (alloc_call, 1);
1952 alloc_fn = get_callee_fndecl (alloc_call);
1953 gcc_assert (alloc_fn != NULL_TREE);
1955 /* Now, check to see if this function is actually a placement
1956 allocation function. This can happen even when PLACEMENT is NULL
1957 because we might have something like:
1959 struct S { void* operator new (size_t, int i = 0); };
1961 A call to `new S' will get this allocation function, even though
1962 there is no explicit placement argument. If there is more than
1963 one argument, or there are variable arguments, then this is a
1964 placement allocation function. */
1965 placement_allocation_fn_p
1966 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
1967 || varargs_function_p (alloc_fn));
1969 /* Preevaluate the placement args so that we don't reevaluate them for a
1970 placement delete. */
1971 if (placement_allocation_fn_p)
1974 stabilize_call (alloc_call, &inits);
1976 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
1980 /* unless an allocation function is declared with an empty excep-
1981 tion-specification (_except.spec_), throw(), it indicates failure to
1982 allocate storage by throwing a bad_alloc exception (clause _except_,
1983 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
1984 cation function is declared with an empty exception-specification,
1985 throw(), it returns null to indicate failure to allocate storage and a
1986 non-null pointer otherwise.
1988 So check for a null exception spec on the op new we just called. */
1990 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
1991 check_new = (flag_check_new || nothrow) && ! use_java_new;
1998 /* Adjust so we're pointing to the start of the object. */
1999 data_addr = get_target_expr (build2 (PLUS_EXPR, full_pointer_type,
2000 alloc_node, cookie_size));
2002 /* Store the number of bytes allocated so that we can know how
2003 many elements to destroy later. We use the last sizeof
2004 (size_t) bytes to store the number of elements. */
2005 cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2006 data_addr, size_in_bytes (sizetype));
2007 cookie = build_indirect_ref (cookie_ptr, NULL);
2009 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2011 if (targetm.cxx.cookie_has_size ())
2013 /* Also store the element size. */
2014 cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2015 cookie_ptr, size_in_bytes (sizetype));
2016 cookie = build_indirect_ref (cookie_ptr, NULL);
2017 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2018 size_in_bytes(true_type));
2019 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2020 cookie, cookie_expr);
2022 data_addr = TARGET_EXPR_SLOT (data_addr);
2026 cookie_expr = NULL_TREE;
2027 data_addr = alloc_node;
2030 /* Now initialize the allocated object. Note that we preevaluate the
2031 initialization expression, apart from the actual constructor call or
2032 assignment--we do this because we want to delay the allocation as long
2033 as possible in order to minimize the size of the exception region for
2034 placement delete. */
2039 init_expr = build_indirect_ref (data_addr, NULL);
2041 if (init == void_zero_node)
2042 init = build_default_init (full_type, nelts);
2043 else if (init && has_array)
2044 pedwarn ("ISO C++ forbids initialization in array new");
2049 = build_vec_init (init_expr,
2050 cp_build_binary_op (MINUS_EXPR, outer_nelts,
2052 init, /*from_array=*/0);
2054 /* An array initialization is stable because the initialization
2055 of each element is a full-expression, so the temporaries don't
2059 else if (TYPE_NEEDS_CONSTRUCTING (type))
2061 init_expr = build_special_member_call (init_expr,
2062 complete_ctor_identifier,
2065 stable = stabilize_init (init_expr, &init_preeval_expr);
2069 /* We are processing something like `new int (10)', which
2070 means allocate an int, and initialize it with 10. */
2072 if (TREE_CODE (init) == TREE_LIST)
2073 init = build_x_compound_expr_from_list (init, "new initializer");
2076 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2077 || TREE_TYPE (init) != NULL_TREE);
2079 init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
2080 stable = stabilize_init (init_expr, &init_preeval_expr);
2083 if (init_expr == error_mark_node)
2084 return error_mark_node;
2086 /* If any part of the object initialization terminates by throwing an
2087 exception and a suitable deallocation function can be found, the
2088 deallocation function is called to free the memory in which the
2089 object was being constructed, after which the exception continues
2090 to propagate in the context of the new-expression. If no
2091 unambiguous matching deallocation function can be found,
2092 propagating the exception does not cause the object's memory to be
2094 if (flag_exceptions && ! use_java_new)
2096 enum tree_code dcode = has_array ? VEC_DELETE_EXPR : DELETE_EXPR;
2099 /* The Standard is unclear here, but the right thing to do
2100 is to use the same method for finding deallocation
2101 functions that we use for finding allocation functions. */
2102 cleanup = build_op_delete_call (dcode, alloc_node, size,
2103 globally_qualified_p,
2104 (placement_allocation_fn_p
2105 ? alloc_call : NULL_TREE));
2110 /* This is much simpler if we were able to preevaluate all of
2111 the arguments to the constructor call. */
2112 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2113 init_expr, cleanup);
2115 /* Ack! First we allocate the memory. Then we set our sentry
2116 variable to true, and expand a cleanup that deletes the
2117 memory if sentry is true. Then we run the constructor, and
2118 finally clear the sentry.
2120 We need to do this because we allocate the space first, so
2121 if there are any temporaries with cleanups in the
2122 constructor args and we weren't able to preevaluate them, we
2123 need this EH region to extend until end of full-expression
2124 to preserve nesting. */
2126 tree end, sentry, begin;
2128 begin = get_target_expr (boolean_true_node);
2129 CLEANUP_EH_ONLY (begin) = 1;
2131 sentry = TARGET_EXPR_SLOT (begin);
2133 TARGET_EXPR_CLEANUP (begin)
2134 = build3 (COND_EXPR, void_type_node, sentry,
2135 cleanup, void_zero_node);
2137 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2138 sentry, boolean_false_node);
2141 = build2 (COMPOUND_EXPR, void_type_node, begin,
2142 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2149 init_expr = NULL_TREE;
2151 /* Now build up the return value in reverse order. */
2156 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2158 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2160 if (rval == alloc_node)
2161 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2162 and return the call (which doesn't need to be adjusted). */
2163 rval = TARGET_EXPR_INITIAL (alloc_expr);
2168 tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
2170 rval = build_conditional_expr (ifexp, rval, alloc_node);
2173 /* Perform the allocation before anything else, so that ALLOC_NODE
2174 has been initialized before we start using it. */
2175 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2178 if (init_preeval_expr)
2179 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2181 /* Convert to the final type. */
2182 rval = build_nop (pointer_type, rval);
2184 /* A new-expression is never an lvalue. */
2185 if (real_lvalue_p (rval))
2186 rval = build1 (NON_LVALUE_EXPR, TREE_TYPE (rval), rval);
2192 build_vec_delete_1 (tree base, tree maxindex, tree type,
2193 special_function_kind auto_delete_vec, int use_global_delete)
2196 tree ptype = build_pointer_type (type = complete_type (type));
2197 tree size_exp = size_in_bytes (type);
2199 /* Temporary variables used by the loop. */
2200 tree tbase, tbase_init;
2202 /* This is the body of the loop that implements the deletion of a
2203 single element, and moves temp variables to next elements. */
2206 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2209 /* This is the thing that governs what to do after the loop has run. */
2210 tree deallocate_expr = 0;
2212 /* This is the BIND_EXPR which holds the outermost iterator of the
2213 loop. It is convenient to set this variable up and test it before
2214 executing any other code in the loop.
2215 This is also the containing expression returned by this function. */
2216 tree controller = NULL_TREE;
2218 /* We should only have 1-D arrays here. */
2219 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2221 if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2224 /* The below is short by the cookie size. */
2225 virtual_size = size_binop (MULT_EXPR, size_exp,
2226 convert (sizetype, maxindex));
2228 tbase = create_temporary_var (ptype);
2229 tbase_init = build_modify_expr (tbase, NOP_EXPR,
2230 fold (build2 (PLUS_EXPR, ptype,
2233 DECL_REGISTER (tbase) = 1;
2234 controller = build3 (BIND_EXPR, void_type_node, tbase,
2235 NULL_TREE, NULL_TREE);
2236 TREE_SIDE_EFFECTS (controller) = 1;
2238 body = build1 (EXIT_EXPR, void_type_node,
2239 build2 (EQ_EXPR, boolean_type_node, base, tbase));
2240 body = build_compound_expr
2241 (body, build_modify_expr (tbase, NOP_EXPR,
2242 build2 (MINUS_EXPR, ptype, tbase, size_exp)));
2243 body = build_compound_expr
2244 (body, build_delete (ptype, tbase, sfk_complete_destructor,
2245 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2247 loop = build1 (LOOP_EXPR, void_type_node, body);
2248 loop = build_compound_expr (tbase_init, loop);
2251 /* If the delete flag is one, or anything else with the low bit set,
2252 delete the storage. */
2253 if (auto_delete_vec != sfk_base_destructor)
2257 /* The below is short by the cookie size. */
2258 virtual_size = size_binop (MULT_EXPR, size_exp,
2259 convert (sizetype, maxindex));
2261 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2268 cookie_size = targetm.cxx.get_cookie_size (type);
2270 = cp_convert (ptype,
2271 cp_build_binary_op (MINUS_EXPR,
2272 cp_convert (string_type_node,
2275 /* True size with header. */
2276 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2279 if (auto_delete_vec == sfk_deleting_destructor)
2280 deallocate_expr = build_x_delete (base_tbd,
2281 2 | use_global_delete,
2286 if (!deallocate_expr)
2289 body = deallocate_expr;
2291 body = build_compound_expr (body, deallocate_expr);
2294 body = integer_zero_node;
2296 /* Outermost wrapper: If pointer is null, punt. */
2297 body = fold (build3 (COND_EXPR, void_type_node,
2298 fold (build2 (NE_EXPR, boolean_type_node, base,
2299 convert (TREE_TYPE (base),
2300 integer_zero_node))),
2301 body, integer_zero_node));
2302 body = build1 (NOP_EXPR, void_type_node, body);
2306 TREE_OPERAND (controller, 1) = body;
2310 if (TREE_CODE (base) == SAVE_EXPR)
2311 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2312 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2314 return convert_to_void (body, /*implicit=*/NULL);
2317 /* Create an unnamed variable of the indicated TYPE. */
2320 create_temporary_var (tree type)
2324 decl = build_decl (VAR_DECL, NULL_TREE, type);
2325 TREE_USED (decl) = 1;
2326 DECL_ARTIFICIAL (decl) = 1;
2327 DECL_SOURCE_LOCATION (decl) = input_location;
2328 DECL_IGNORED_P (decl) = 1;
2329 DECL_CONTEXT (decl) = current_function_decl;
2334 /* Create a new temporary variable of the indicated TYPE, initialized
2337 It is not entered into current_binding_level, because that breaks
2338 things when it comes time to do final cleanups (which take place
2339 "outside" the binding contour of the function). */
2342 get_temp_regvar (tree type, tree init)
2346 decl = create_temporary_var (type);
2347 add_decl_expr (decl);
2349 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
2354 /* `build_vec_init' returns tree structure that performs
2355 initialization of a vector of aggregate types.
2357 BASE is a reference to the vector, of ARRAY_TYPE.
2358 MAXINDEX is the maximum index of the array (one less than the
2359 number of elements). It is only used if
2360 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2361 INIT is the (possibly NULL) initializer.
2363 FROM_ARRAY is 0 if we should init everything with INIT
2364 (i.e., every element initialized from INIT).
2365 FROM_ARRAY is 1 if we should index into INIT in parallel
2366 with initialization of DECL.
2367 FROM_ARRAY is 2 if we should index into INIT in parallel,
2368 but use assignment instead of initialization. */
2371 build_vec_init (tree base, tree maxindex, tree init, int from_array)
2374 tree base2 = NULL_TREE;
2376 tree itype = NULL_TREE;
2378 /* The type of the array. */
2379 tree atype = TREE_TYPE (base);
2380 /* The type of an element in the array. */
2381 tree type = TREE_TYPE (atype);
2382 /* The type of a pointer to an element in the array. */
2387 tree try_block = NULL_TREE;
2388 int num_initialized_elts = 0;
2391 if (TYPE_DOMAIN (atype))
2392 maxindex = array_type_nelts (atype);
2394 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2395 return error_mark_node;
2399 ? (!CLASS_TYPE_P (type) || !TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2400 : !TYPE_NEEDS_CONSTRUCTING (type))
2401 && ((TREE_CODE (init) == CONSTRUCTOR
2402 /* Don't do this if the CONSTRUCTOR might contain something
2403 that might throw and require us to clean up. */
2404 && (CONSTRUCTOR_ELTS (init) == NULL_TREE
2405 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type))))
2408 /* Do non-default initialization of POD arrays resulting from
2409 brace-enclosed initializers. In this case, digest_init and
2410 store_constructor will handle the semantics for us. */
2412 stmt_expr = build2 (INIT_EXPR, atype, base, init);
2416 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2417 ptype = build_pointer_type (type);
2418 size = size_in_bytes (type);
2419 if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
2420 base = cp_convert (ptype, decay_conversion (base));
2422 /* The code we are generating looks like:
2426 ptrdiff_t iterator = maxindex;
2428 for (; iterator != -1; --iterator) {
2429 ... initialize *t1 ...
2433 ... destroy elements that were constructed ...
2438 We can omit the try and catch blocks if we know that the
2439 initialization will never throw an exception, or if the array
2440 elements do not have destructors. We can omit the loop completely if
2441 the elements of the array do not have constructors.
2443 We actually wrap the entire body of the above in a STMT_EXPR, for
2446 When copying from array to another, when the array elements have
2447 only trivial copy constructors, we should use __builtin_memcpy
2448 rather than generating a loop. That way, we could take advantage
2449 of whatever cleverness the back-end has for dealing with copies
2450 of blocks of memory. */
2452 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2453 destroy_temps = stmts_are_full_exprs_p ();
2454 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2455 rval = get_temp_regvar (ptype, base);
2456 base = get_temp_regvar (ptype, rval);
2457 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2459 /* Protect the entire array initialization so that we can destroy
2460 the partially constructed array if an exception is thrown.
2461 But don't do this if we're assigning. */
2462 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2465 try_block = begin_try_block ();
2468 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2470 /* Do non-default initialization of non-POD arrays resulting from
2471 brace-enclosed initializers. */
2476 for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
2478 tree elt = TREE_VALUE (elts);
2479 tree baseref = build1 (INDIRECT_REF, type, base);
2481 num_initialized_elts++;
2483 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2484 if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2485 finish_expr_stmt (build_aggr_init (baseref, elt, 0));
2487 finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
2489 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2491 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2492 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
2495 /* Clear out INIT so that we don't get confused below. */
2498 else if (from_array)
2500 /* If initializing one array from another, initialize element by
2501 element. We rely upon the below calls the do argument
2505 base2 = decay_conversion (init);
2506 itype = TREE_TYPE (base2);
2507 base2 = get_temp_regvar (itype, base2);
2508 itype = TREE_TYPE (itype);
2510 else if (TYPE_LANG_SPECIFIC (type)
2511 && TYPE_NEEDS_CONSTRUCTING (type)
2512 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2514 error ("initializer ends prematurely");
2515 return error_mark_node;
2519 /* Now, default-initialize any remaining elements. We don't need to
2520 do that if a) the type does not need constructing, or b) we've
2521 already initialized all the elements.
2523 We do need to keep going if we're copying an array. */
2526 || (TYPE_NEEDS_CONSTRUCTING (type)
2527 && ! (host_integerp (maxindex, 0)
2528 && (num_initialized_elts
2529 == tree_low_cst (maxindex, 0) + 1))))
2531 /* If the ITERATOR is equal to -1, then we don't have to loop;
2532 we've already initialized all the elements. */
2536 for_stmt = begin_for_stmt ();
2537 finish_for_init_stmt (for_stmt);
2538 finish_for_cond (build2 (NE_EXPR, boolean_type_node,
2539 iterator, integer_minus_one_node),
2541 finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0),
2546 tree to = build1 (INDIRECT_REF, type, base);
2550 from = build1 (INDIRECT_REF, itype, base2);
2554 if (from_array == 2)
2555 elt_init = build_modify_expr (to, NOP_EXPR, from);
2556 else if (TYPE_NEEDS_CONSTRUCTING (type))
2557 elt_init = build_aggr_init (to, from, 0);
2559 elt_init = build_modify_expr (to, NOP_EXPR, from);
2563 else if (TREE_CODE (type) == ARRAY_TYPE)
2567 ("cannot initialize multi-dimensional array with initializer");
2568 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2572 elt_init = build_aggr_init (build1 (INDIRECT_REF, type, base),
2575 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2576 finish_expr_stmt (elt_init);
2577 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2579 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2581 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));
2583 finish_for_stmt (for_stmt);
2586 /* Make sure to cleanup any partially constructed elements. */
2587 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2591 tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);
2593 /* Flatten multi-dimensional array since build_vec_delete only
2594 expects one-dimensional array. */
2595 if (TREE_CODE (type) == ARRAY_TYPE)
2597 m = cp_build_binary_op (MULT_EXPR, m,
2598 array_type_nelts_total (type));
2599 type = strip_array_types (type);
2602 finish_cleanup_try_block (try_block);
2603 e = build_vec_delete_1 (rval, m, type, sfk_base_destructor,
2604 /*use_global_delete=*/0);
2605 finish_cleanup (e, try_block);
2608 /* The value of the array initialization is the array itself, RVAL
2609 is a pointer to the first element. */
2610 finish_stmt_expr_expr (rval, stmt_expr);
2612 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2614 /* Now convert make the result have the correct type. */
2615 atype = build_pointer_type (atype);
2616 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2617 stmt_expr = build_indirect_ref (stmt_expr, NULL);
2619 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2623 /* Free up storage of type TYPE, at address ADDR.
2625 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2628 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2629 used as the second argument to operator delete. It can include
2630 things like padding and magic size cookies. It has virtual in it,
2631 because if you have a base pointer and you delete through a virtual
2632 destructor, it should be the size of the dynamic object, not the
2633 static object, see Free Store 12.5 ISO C++.
2635 This does not call any destructors. */
2638 build_x_delete (tree addr, int which_delete, tree virtual_size)
2640 int use_global_delete = which_delete & 1;
2641 int use_vec_delete = !!(which_delete & 2);
2642 enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
2644 return build_op_delete_call (code, addr, virtual_size, use_global_delete,
2648 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
2652 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2658 case sfk_complete_destructor:
2659 name = complete_dtor_identifier;
2662 case sfk_base_destructor:
2663 name = base_dtor_identifier;
2666 case sfk_deleting_destructor:
2667 name = deleting_dtor_identifier;
2674 exp = convert_from_reference (exp);
2675 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2676 return build_new_method_call (exp, fn,
2678 /*conversion_path=*/NULL_TREE,
2682 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2683 ADDR is an expression which yields the store to be destroyed.
2684 AUTO_DELETE is the name of the destructor to call, i.e., either
2685 sfk_complete_destructor, sfk_base_destructor, or
2686 sfk_deleting_destructor.
2688 FLAGS is the logical disjunction of zero or more LOOKUP_
2689 flags. See cp-tree.h for more info. */
2692 build_delete (tree type, tree addr, special_function_kind auto_delete,
2693 int flags, int use_global_delete)
2697 if (addr == error_mark_node)
2698 return error_mark_node;
2700 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2701 set to `error_mark_node' before it gets properly cleaned up. */
2702 if (type == error_mark_node)
2703 return error_mark_node;
2705 type = TYPE_MAIN_VARIANT (type);
2707 if (TREE_CODE (type) == POINTER_TYPE)
2709 bool complete_p = true;
2711 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2712 if (TREE_CODE (type) == ARRAY_TYPE)
2715 /* We don't want to warn about delete of void*, only other
2716 incomplete types. Deleting other incomplete types
2717 invokes undefined behavior, but it is not ill-formed, so
2718 compile to something that would even do The Right Thing
2719 (TM) should the type have a trivial dtor and no delete
2721 if (!VOID_TYPE_P (type))
2723 complete_type (type);
2724 if (!COMPLETE_TYPE_P (type))
2726 warning ("possible problem detected in invocation of "
2727 "delete operator:");
2728 cxx_incomplete_type_diagnostic (addr, type, 1);
2729 inform ("neither the destructor nor the class-specific "
2730 "operator delete will be called, even if they are "
2731 "declared when the class is defined.");
2735 if (VOID_TYPE_P (type) || !complete_p || !IS_AGGR_TYPE (type))
2736 /* Call the builtin operator delete. */
2737 return build_builtin_delete_call (addr);
2738 if (TREE_SIDE_EFFECTS (addr))
2739 addr = save_expr (addr);
2741 /* Throw away const and volatile on target type of addr. */
2742 addr = convert_force (build_pointer_type (type), addr, 0);
2744 else if (TREE_CODE (type) == ARRAY_TYPE)
2748 if (TYPE_DOMAIN (type) == NULL_TREE)
2750 error ("unknown array size in delete");
2751 return error_mark_node;
2753 return build_vec_delete (addr, array_type_nelts (type),
2754 auto_delete, use_global_delete);
2758 /* Don't check PROTECT here; leave that decision to the
2759 destructor. If the destructor is accessible, call it,
2760 else report error. */
2761 addr = build_unary_op (ADDR_EXPR, addr, 0);
2762 if (TREE_SIDE_EFFECTS (addr))
2763 addr = save_expr (addr);
2765 addr = convert_force (build_pointer_type (type), addr, 0);
2768 gcc_assert (IS_AGGR_TYPE (type));
2770 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2772 if (auto_delete != sfk_deleting_destructor)
2773 return void_zero_node;
2775 return build_op_delete_call
2776 (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), use_global_delete,
2781 tree do_delete = NULL_TREE;
2784 gcc_assert (TYPE_HAS_DESTRUCTOR (type));
2786 /* For `::delete x', we must not use the deleting destructor
2787 since then we would not be sure to get the global `operator
2789 if (use_global_delete && auto_delete == sfk_deleting_destructor)
2791 /* We will use ADDR multiple times so we must save it. */
2792 addr = save_expr (addr);
2793 /* Delete the object. */
2794 do_delete = build_builtin_delete_call (addr);
2795 /* Otherwise, treat this like a complete object destructor
2797 auto_delete = sfk_complete_destructor;
2799 /* If the destructor is non-virtual, there is no deleting
2800 variant. Instead, we must explicitly call the appropriate
2801 `operator delete' here. */
2802 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
2803 && auto_delete == sfk_deleting_destructor)
2805 /* We will use ADDR multiple times so we must save it. */
2806 addr = save_expr (addr);
2807 /* Build the call. */
2808 do_delete = build_op_delete_call (DELETE_EXPR,
2810 cxx_sizeof_nowarn (type),
2813 /* Call the complete object destructor. */
2814 auto_delete = sfk_complete_destructor;
2816 else if (auto_delete == sfk_deleting_destructor
2817 && TYPE_GETS_REG_DELETE (type))
2819 /* Make sure we have access to the member op delete, even though
2820 we'll actually be calling it from the destructor. */
2821 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2822 /*global_p=*/false, NULL_TREE);
2825 expr = build_dtor_call (build_indirect_ref (addr, NULL),
2826 auto_delete, flags);
2828 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
2830 if (flags & LOOKUP_DESTRUCTOR)
2831 /* Explicit destructor call; don't check for null pointer. */
2832 ifexp = integer_one_node;
2834 /* Handle deleting a null pointer. */
2835 ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
2837 if (ifexp != integer_one_node)
2838 expr = build3 (COND_EXPR, void_type_node,
2839 ifexp, expr, void_zero_node);
2845 /* At the beginning of a destructor, push cleanups that will call the
2846 destructors for our base classes and members.
2848 Called from begin_destructor_body. */
2851 push_base_cleanups (void)
2853 tree binfo, base_binfo;
2859 /* Run destructors for all virtual baseclasses. */
2860 if (CLASSTYPE_VBASECLASSES (current_class_type))
2862 tree cond = (condition_conversion
2863 (build2 (BIT_AND_EXPR, integer_type_node,
2864 current_in_charge_parm,
2865 integer_two_node)));
2867 /* The CLASSTYPE_VBASECLASSES vector is in initialization
2868 order, which is also the right order for pushing cleanups. */
2869 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
2870 VEC_iterate (tree, vbases, i, base_binfo); i++)
2872 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
2874 expr = build_special_member_call (current_class_ref,
2875 base_dtor_identifier,
2879 | LOOKUP_NONVIRTUAL));
2880 expr = build3 (COND_EXPR, void_type_node, cond,
2881 expr, void_zero_node);
2882 finish_decl_cleanup (NULL_TREE, expr);
2887 /* Take care of the remaining baseclasses. */
2888 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2889 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2891 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
2892 || BINFO_VIRTUAL_P (base_binfo))
2895 expr = build_special_member_call (current_class_ref,
2896 base_dtor_identifier,
2897 NULL_TREE, base_binfo,
2898 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
2899 finish_decl_cleanup (NULL_TREE, expr);
2902 for (member = TYPE_FIELDS (current_class_type); member;
2903 member = TREE_CHAIN (member))
2905 if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
2907 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
2909 tree this_member = (build_class_member_access_expr
2910 (current_class_ref, member,
2911 /*access_path=*/NULL_TREE,
2912 /*preserve_reference=*/false));
2913 tree this_type = TREE_TYPE (member);
2914 expr = build_delete (this_type, this_member,
2915 sfk_complete_destructor,
2916 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
2918 finish_decl_cleanup (NULL_TREE, expr);
2923 /* For type TYPE, delete the virtual baseclass objects of DECL. */
2926 build_vbase_delete (tree type, tree decl)
2932 tree addr = build_unary_op (ADDR_EXPR, decl, 0);
2934 gcc_assert (addr != error_mark_node);
2936 result = convert_to_void (integer_zero_node, NULL);
2937 for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0;
2938 VEC_iterate (tree, vbases, ix, binfo); ix++)
2940 tree base_addr = convert_force
2941 (build_pointer_type (BINFO_TYPE (binfo)), addr, 0);
2942 tree base_delete = build_delete
2943 (TREE_TYPE (base_addr), base_addr, sfk_base_destructor,
2944 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
2946 result = build_compound_expr (result, base_delete);
2951 /* Build a C++ vector delete expression.
2952 MAXINDEX is the number of elements to be deleted.
2953 ELT_SIZE is the nominal size of each element in the vector.
2954 BASE is the expression that should yield the store to be deleted.
2955 This function expands (or synthesizes) these calls itself.
2956 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
2958 This also calls delete for virtual baseclasses of elements of the vector.
2960 Update: MAXINDEX is no longer needed. The size can be extracted from the
2961 start of the vector for pointers, and from the type for arrays. We still
2962 use MAXINDEX for arrays because it happens to already have one of the
2963 values we'd have to extract. (We could use MAXINDEX with pointers to
2964 confirm the size, and trap if the numbers differ; not clear that it'd
2965 be worth bothering.) */
2968 build_vec_delete (tree base, tree maxindex,
2969 special_function_kind auto_delete_vec, int use_global_delete)
2973 tree base_init = NULL_TREE;
2975 type = TREE_TYPE (base);
2977 if (TREE_CODE (type) == POINTER_TYPE)
2979 /* Step back one from start of vector, and read dimension. */
2982 if (TREE_SIDE_EFFECTS (base))
2984 base_init = get_target_expr (base);
2985 base = TARGET_EXPR_SLOT (base_init);
2987 type = strip_array_types (TREE_TYPE (type));
2988 cookie_addr = build2 (MINUS_EXPR,
2989 build_pointer_type (sizetype),
2991 TYPE_SIZE_UNIT (sizetype));
2992 maxindex = build_indirect_ref (cookie_addr, NULL);
2994 else if (TREE_CODE (type) == ARRAY_TYPE)
2996 /* Get the total number of things in the array, maxindex is a
2998 maxindex = array_type_nelts_total (type);
2999 type = strip_array_types (type);
3000 base = build_unary_op (ADDR_EXPR, base, 1);
3001 if (TREE_SIDE_EFFECTS (base))
3003 base_init = get_target_expr (base);
3004 base = TARGET_EXPR_SLOT (base_init);
3009 if (base != error_mark_node)
3010 error ("type to vector delete is neither pointer or array type");
3011 return error_mark_node;
3014 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3017 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);