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 /* We will already have issued an error message about the fact that
659 the type is incomplete. */
660 if (!COMPLETE_TYPE_P (current_class_type))
663 /* Sort the mem-initializers into the order in which the
664 initializations should be performed. */
665 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
667 in_base_initializer = 1;
669 /* Initialize base classes. */
671 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
673 tree subobject = TREE_PURPOSE (mem_inits);
674 tree arguments = TREE_VALUE (mem_inits);
676 /* If these initializations are taking place in a copy
677 constructor, the base class should probably be explicitly
679 if (extra_warnings && !arguments
680 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
681 && TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (subobject)))
682 warning ("%Jbase class %q#T should be explicitly initialized in the "
684 current_function_decl, BINFO_TYPE (subobject));
686 /* If an explicit -- but empty -- initializer list was present,
687 treat it just like default initialization at this point. */
688 if (arguments == void_type_node)
689 arguments = NULL_TREE;
691 /* Initialize the base. */
692 if (BINFO_VIRTUAL_P (subobject))
693 construct_virtual_base (subobject, arguments);
698 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
700 expand_aggr_init_1 (subobject, NULL_TREE,
701 build_indirect_ref (base_addr, NULL),
704 expand_cleanup_for_base (subobject, NULL_TREE);
707 mem_inits = TREE_CHAIN (mem_inits);
709 in_base_initializer = 0;
711 /* Initialize the vptrs. */
712 initialize_vtbl_ptrs (current_class_ptr);
714 /* Initialize the data members. */
717 perform_member_init (TREE_PURPOSE (mem_inits),
718 TREE_VALUE (mem_inits));
719 mem_inits = TREE_CHAIN (mem_inits);
723 /* Returns the address of the vtable (i.e., the value that should be
724 assigned to the vptr) for BINFO. */
727 build_vtbl_address (tree binfo)
729 tree binfo_for = binfo;
732 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
733 /* If this is a virtual primary base, then the vtable we want to store
734 is that for the base this is being used as the primary base of. We
735 can't simply skip the initialization, because we may be expanding the
736 inits of a subobject constructor where the virtual base layout
738 while (BINFO_PRIMARY_P (binfo_for))
739 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
741 /* Figure out what vtable BINFO's vtable is based on, and mark it as
743 vtbl = get_vtbl_decl_for_binfo (binfo_for);
744 assemble_external (vtbl);
745 TREE_USED (vtbl) = 1;
747 /* Now compute the address to use when initializing the vptr. */
748 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
749 if (TREE_CODE (vtbl) == VAR_DECL)
750 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
755 /* This code sets up the virtual function tables appropriate for
756 the pointer DECL. It is a one-ply initialization.
758 BINFO is the exact type that DECL is supposed to be. In
759 multiple inheritance, this might mean "C's A" if C : A, B. */
762 expand_virtual_init (tree binfo, tree decl)
767 /* Compute the initializer for vptr. */
768 vtbl = build_vtbl_address (binfo);
770 /* We may get this vptr from a VTT, if this is a subobject
771 constructor or subobject destructor. */
772 vtt_index = BINFO_VPTR_INDEX (binfo);
778 /* Compute the value to use, when there's a VTT. */
779 vtt_parm = current_vtt_parm;
780 vtbl2 = build2 (PLUS_EXPR,
781 TREE_TYPE (vtt_parm),
784 vtbl2 = build_indirect_ref (vtbl2, NULL);
785 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
787 /* The actual initializer is the VTT value only in the subobject
788 constructor. In maybe_clone_body we'll substitute NULL for
789 the vtt_parm in the case of the non-subobject constructor. */
790 vtbl = build3 (COND_EXPR,
792 build2 (EQ_EXPR, boolean_type_node,
793 current_in_charge_parm, integer_zero_node),
798 /* Compute the location of the vtpr. */
799 vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL),
801 gcc_assert (vtbl_ptr != error_mark_node);
803 /* Assign the vtable to the vptr. */
804 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
805 finish_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
808 /* If an exception is thrown in a constructor, those base classes already
809 constructed must be destroyed. This function creates the cleanup
810 for BINFO, which has just been constructed. If FLAG is non-NULL,
811 it is a DECL which is nonzero when this base needs to be
815 expand_cleanup_for_base (tree binfo, tree flag)
819 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
822 /* Call the destructor. */
823 expr = build_special_member_call (current_class_ref,
824 base_dtor_identifier,
827 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
829 expr = fold_build3 (COND_EXPR, void_type_node,
830 c_common_truthvalue_conversion (flag),
831 expr, integer_zero_node);
833 finish_eh_cleanup (expr);
836 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
840 construct_virtual_base (tree vbase, tree arguments)
846 /* If there are virtual base classes with destructors, we need to
847 emit cleanups to destroy them if an exception is thrown during
848 the construction process. These exception regions (i.e., the
849 period during which the cleanups must occur) begin from the time
850 the construction is complete to the end of the function. If we
851 create a conditional block in which to initialize the
852 base-classes, then the cleanup region for the virtual base begins
853 inside a block, and ends outside of that block. This situation
854 confuses the sjlj exception-handling code. Therefore, we do not
855 create a single conditional block, but one for each
856 initialization. (That way the cleanup regions always begin
857 in the outer block.) We trust the back-end to figure out
858 that the FLAG will not change across initializations, and
859 avoid doing multiple tests. */
860 flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
861 inner_if_stmt = begin_if_stmt ();
862 finish_if_stmt_cond (flag, inner_if_stmt);
864 /* Compute the location of the virtual base. If we're
865 constructing virtual bases, then we must be the most derived
866 class. Therefore, we don't have to look up the virtual base;
867 we already know where it is. */
868 exp = convert_to_base_statically (current_class_ref, vbase);
870 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
872 finish_then_clause (inner_if_stmt);
873 finish_if_stmt (inner_if_stmt);
875 expand_cleanup_for_base (vbase, flag);
878 /* Find the context in which this FIELD can be initialized. */
881 initializing_context (tree field)
883 tree t = DECL_CONTEXT (field);
885 /* Anonymous union members can be initialized in the first enclosing
886 non-anonymous union context. */
887 while (t && ANON_AGGR_TYPE_P (t))
888 t = TYPE_CONTEXT (t);
892 /* Function to give error message if member initialization specification
893 is erroneous. FIELD is the member we decided to initialize.
894 TYPE is the type for which the initialization is being performed.
895 FIELD must be a member of TYPE.
897 MEMBER_NAME is the name of the member. */
900 member_init_ok_or_else (tree field, tree type, tree member_name)
902 if (field == error_mark_node)
906 error ("class %qT does not have any field named %qD", type,
910 if (TREE_CODE (field) == VAR_DECL)
912 error ("%q#D is a static data member; it can only be "
913 "initialized at its definition",
917 if (TREE_CODE (field) != FIELD_DECL)
919 error ("%q#D is not a non-static data member of %qT",
923 if (initializing_context (field) != type)
925 error ("class %qT does not have any field named %qD", type,
933 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
934 is a _TYPE node or TYPE_DECL which names a base for that type.
935 Check the validity of NAME, and return either the base _TYPE, base
936 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
937 NULL_TREE and issue a diagnostic.
939 An old style unnamed direct single base construction is permitted,
940 where NAME is NULL. */
943 expand_member_init (tree name)
948 if (!current_class_ref)
953 /* This is an obsolete unnamed base class initializer. The
954 parser will already have warned about its use. */
955 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
958 error ("unnamed initializer for %qT, which has no base classes",
962 basetype = BINFO_TYPE
963 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
966 error ("unnamed initializer for %qT, which uses multiple inheritance",
971 else if (TYPE_P (name))
973 basetype = TYPE_MAIN_VARIANT (name);
974 name = TYPE_NAME (name);
976 else if (TREE_CODE (name) == TYPE_DECL)
977 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
979 basetype = NULL_TREE;
988 if (current_template_parms)
991 class_binfo = TYPE_BINFO (current_class_type);
992 direct_binfo = NULL_TREE;
993 virtual_binfo = NULL_TREE;
995 /* Look for a direct base. */
996 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
997 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1000 /* Look for a virtual base -- unless the direct base is itself
1002 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1003 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1005 /* [class.base.init]
1007 If a mem-initializer-id is ambiguous because it designates
1008 both a direct non-virtual base class and an inherited virtual
1009 base class, the mem-initializer is ill-formed. */
1010 if (direct_binfo && virtual_binfo)
1012 error ("%qD is both a direct base and an indirect virtual base",
1017 if (!direct_binfo && !virtual_binfo)
1019 if (CLASSTYPE_VBASECLASSES (current_class_type))
1020 error ("type %qD is not a direct or virtual base of %qT",
1021 name, current_class_type);
1023 error ("type %qD is not a direct base of %qT",
1024 name, current_class_type);
1028 return direct_binfo ? direct_binfo : virtual_binfo;
1032 if (TREE_CODE (name) == IDENTIFIER_NODE)
1033 field = lookup_field (current_class_type, name, 1, false);
1037 if (member_init_ok_or_else (field, current_class_type, name))
1044 /* This is like `expand_member_init', only it stores one aggregate
1047 INIT comes in two flavors: it is either a value which
1048 is to be stored in EXP, or it is a parameter list
1049 to go to a constructor, which will operate on EXP.
1050 If INIT is not a parameter list for a constructor, then set
1051 LOOKUP_ONLYCONVERTING.
1052 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1053 the initializer, if FLAGS is 0, then it is the (init) form.
1054 If `init' is a CONSTRUCTOR, then we emit a warning message,
1055 explaining that such initializations are invalid.
1057 If INIT resolves to a CALL_EXPR which happens to return
1058 something of the type we are looking for, then we know
1059 that we can safely use that call to perform the
1062 The virtual function table pointer cannot be set up here, because
1063 we do not really know its type.
1065 This never calls operator=().
1067 When initializing, nothing is CONST.
1069 A default copy constructor may have to be used to perform the
1072 A constructor or a conversion operator may have to be used to
1073 perform the initialization, but not both, as it would be ambiguous. */
1076 build_aggr_init (tree exp, tree init, int flags)
1081 tree type = TREE_TYPE (exp);
1082 int was_const = TREE_READONLY (exp);
1083 int was_volatile = TREE_THIS_VOLATILE (exp);
1086 if (init == error_mark_node)
1087 return error_mark_node;
1089 TREE_READONLY (exp) = 0;
1090 TREE_THIS_VOLATILE (exp) = 0;
1092 if (init && TREE_CODE (init) != TREE_LIST)
1093 flags |= LOOKUP_ONLYCONVERTING;
1095 if (TREE_CODE (type) == ARRAY_TYPE)
1099 /* An array may not be initialized use the parenthesized
1100 initialization form -- unless the initializer is "()". */
1101 if (init && TREE_CODE (init) == TREE_LIST)
1103 error ("bad array initializer");
1104 return error_mark_node;
1106 /* Must arrange to initialize each element of EXP
1107 from elements of INIT. */
1108 itype = init ? TREE_TYPE (init) : NULL_TREE;
1109 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
1110 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1111 if (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
1112 itype = TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1113 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1114 itype && same_type_p (itype,
1116 TREE_READONLY (exp) = was_const;
1117 TREE_THIS_VOLATILE (exp) = was_volatile;
1118 TREE_TYPE (exp) = type;
1120 TREE_TYPE (init) = itype;
1124 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1125 /* Just know that we've seen something for this node. */
1126 TREE_USED (exp) = 1;
1128 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1129 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1130 destroy_temps = stmts_are_full_exprs_p ();
1131 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1132 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1133 init, LOOKUP_NORMAL|flags);
1134 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1135 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1136 TREE_TYPE (exp) = type;
1137 TREE_READONLY (exp) = was_const;
1138 TREE_THIS_VOLATILE (exp) = was_volatile;
1143 /* Like build_aggr_init, but not just for aggregates. */
1146 build_init (tree decl, tree init, int flags)
1150 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1151 expr = build_aggr_init (decl, init, flags);
1152 else if (CLASS_TYPE_P (TREE_TYPE (decl)))
1153 expr = build_special_member_call (decl, complete_ctor_identifier,
1154 build_tree_list (NULL_TREE, init),
1156 LOOKUP_NORMAL|flags);
1158 expr = build2 (INIT_EXPR, TREE_TYPE (decl), decl, init);
1164 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags)
1166 tree type = TREE_TYPE (exp);
1169 /* It fails because there may not be a constructor which takes
1170 its own type as the first (or only parameter), but which does
1171 take other types via a conversion. So, if the thing initializing
1172 the expression is a unit element of type X, first try X(X&),
1173 followed by initialization by X. If neither of these work
1174 out, then look hard. */
1178 if (init && TREE_CODE (init) != TREE_LIST
1179 && (flags & LOOKUP_ONLYCONVERTING))
1181 /* Base subobjects should only get direct-initialization. */
1182 gcc_assert (true_exp == exp);
1184 if (flags & DIRECT_BIND)
1185 /* Do nothing. We hit this in two cases: Reference initialization,
1186 where we aren't initializing a real variable, so we don't want
1187 to run a new constructor; and catching an exception, where we
1188 have already built up the constructor call so we could wrap it
1189 in an exception region. */;
1190 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
1192 /* A brace-enclosed initializer for an aggregate. */
1193 gcc_assert (CP_AGGREGATE_TYPE_P (type));
1194 init = digest_init (type, init, (tree *)NULL);
1197 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1199 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1200 /* We need to protect the initialization of a catch parm with a
1201 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1202 around the TARGET_EXPR for the copy constructor. See
1203 initialize_handler_parm. */
1205 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1206 TREE_OPERAND (init, 0));
1207 TREE_TYPE (init) = void_type_node;
1210 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1211 TREE_SIDE_EFFECTS (init) = 1;
1212 finish_expr_stmt (init);
1216 if (init == NULL_TREE
1217 || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1221 init = TREE_VALUE (parms);
1224 parms = build_tree_list (NULL_TREE, init);
1226 if (true_exp == exp)
1227 ctor_name = complete_ctor_identifier;
1229 ctor_name = base_ctor_identifier;
1231 rval = build_special_member_call (exp, ctor_name, parms, binfo, flags);
1232 if (TREE_SIDE_EFFECTS (rval))
1233 finish_expr_stmt (convert_to_void (rval, NULL));
1236 /* This function is responsible for initializing EXP with INIT
1239 BINFO is the binfo of the type for who we are performing the
1240 initialization. For example, if W is a virtual base class of A and B,
1242 If we are initializing B, then W must contain B's W vtable, whereas
1243 were we initializing C, W must contain C's W vtable.
1245 TRUE_EXP is nonzero if it is the true expression being initialized.
1246 In this case, it may be EXP, or may just contain EXP. The reason we
1247 need this is because if EXP is a base element of TRUE_EXP, we
1248 don't necessarily know by looking at EXP where its virtual
1249 baseclass fields should really be pointing. But we do know
1250 from TRUE_EXP. In constructors, we don't know anything about
1251 the value being initialized.
1253 FLAGS is just passed to `build_new_method_call'. See that function
1254 for its description. */
1257 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags)
1259 tree type = TREE_TYPE (exp);
1261 gcc_assert (init != error_mark_node && type != error_mark_node);
1262 gcc_assert (building_stmt_tree ());
1264 /* Use a function returning the desired type to initialize EXP for us.
1265 If the function is a constructor, and its first argument is
1266 NULL_TREE, know that it was meant for us--just slide exp on
1267 in and expand the constructor. Constructors now come
1270 if (init && TREE_CODE (exp) == VAR_DECL
1271 && TREE_CODE (init) == CONSTRUCTOR
1272 && TREE_HAS_CONSTRUCTOR (init))
1274 /* If store_init_value returns NULL_TREE, the INIT has been
1275 record in the DECL_INITIAL for EXP. That means there's
1276 nothing more we have to do. */
1277 init = store_init_value (exp, init);
1279 finish_expr_stmt (init);
1283 /* We know that expand_default_init can handle everything we want
1285 expand_default_init (binfo, true_exp, exp, init, flags);
1288 /* Report an error if TYPE is not a user-defined, aggregate type. If
1289 OR_ELSE is nonzero, give an error message. */
1292 is_aggr_type (tree type, int or_else)
1294 if (type == error_mark_node)
1297 if (! IS_AGGR_TYPE (type)
1298 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1299 && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
1302 error ("%qT is not an aggregate type", type);
1309 get_type_value (tree name)
1311 if (name == error_mark_node)
1314 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1315 return IDENTIFIER_TYPE_VALUE (name);
1320 /* Build a reference to a member of an aggregate. This is not a C++
1321 `&', but really something which can have its address taken, and
1322 then act as a pointer to member, for example TYPE :: FIELD can have
1323 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1324 this expression is the operand of "&".
1326 @@ Prints out lousy diagnostics for operator <typename>
1329 @@ This function should be rewritten and placed in search.c. */
1332 build_offset_ref (tree type, tree name, bool address_p)
1336 tree basebinfo = NULL_TREE;
1337 tree orig_name = name;
1339 /* class templates can come in as TEMPLATE_DECLs here. */
1340 if (TREE_CODE (name) == TEMPLATE_DECL)
1343 if (dependent_type_p (type) || type_dependent_expression_p (name))
1344 return build_min_nt (SCOPE_REF, type, name);
1346 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1348 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1349 something like `a.template f<int>' or the like. For the most
1350 part, we treat this just like a.f. We do remember, however,
1351 the template-id that was used. */
1352 name = TREE_OPERAND (orig_name, 0);
1355 name = DECL_NAME (name);
1358 if (TREE_CODE (name) == COMPONENT_REF)
1359 name = TREE_OPERAND (name, 1);
1360 if (TREE_CODE (name) == OVERLOAD)
1361 name = DECL_NAME (OVL_CURRENT (name));
1364 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1367 if (type == NULL_TREE)
1368 return error_mark_node;
1370 /* Handle namespace names fully here. */
1371 if (TREE_CODE (type) == NAMESPACE_DECL)
1373 tree t = lookup_namespace_name (type, name);
1374 if (t == error_mark_node)
1376 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1377 /* Reconstruct the TEMPLATE_ID_EXPR. */
1378 t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t),
1379 t, TREE_OPERAND (orig_name, 1));
1380 if (! type_unknown_p (t))
1383 t = convert_from_reference (t);
1388 if (! is_aggr_type (type, 1))
1389 return error_mark_node;
1391 if (TREE_CODE (name) == BIT_NOT_EXPR)
1393 if (! check_dtor_name (type, name))
1394 error ("qualified type %qT does not match destructor name %<~%T%>",
1395 type, TREE_OPERAND (name, 0));
1396 name = dtor_identifier;
1399 if (!COMPLETE_TYPE_P (complete_type (type))
1400 && !TYPE_BEING_DEFINED (type))
1402 error ("incomplete type %qT does not have member %qD", type, name);
1403 return error_mark_node;
1406 /* Set up BASEBINFO for member lookup. */
1407 decl = maybe_dummy_object (type, &basebinfo);
1409 if (BASELINK_P (name) || DECL_P (name))
1413 member = lookup_member (basebinfo, name, 1, 0);
1415 if (member == error_mark_node)
1416 return error_mark_node;
1421 error ("%qD is not a member of type %qT", name, type);
1422 return error_mark_node;
1425 if (TREE_CODE (member) == TYPE_DECL)
1427 TREE_USED (member) = 1;
1430 /* static class members and class-specific enum
1431 values can be returned without further ado. */
1432 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1435 return convert_from_reference (member);
1438 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1440 error ("invalid pointer to bit-field %qD", member);
1441 return error_mark_node;
1444 /* A lot of this logic is now handled in lookup_member. */
1445 if (BASELINK_P (member))
1447 /* Go from the TREE_BASELINK to the member function info. */
1448 tree fnfields = member;
1449 tree t = BASELINK_FUNCTIONS (fnfields);
1451 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1453 /* The FNFIELDS are going to contain functions that aren't
1454 necessarily templates, and templates that don't
1455 necessarily match the explicit template parameters. We
1456 save all the functions, and the explicit parameters, and
1457 then figure out exactly what to instantiate with what
1458 arguments in instantiate_type. */
1460 if (TREE_CODE (t) != OVERLOAD)
1461 /* The code in instantiate_type which will process this
1462 expects to encounter OVERLOADs, not raw functions. */
1463 t = ovl_cons (t, NULL_TREE);
1465 t = build2 (TEMPLATE_ID_EXPR, TREE_TYPE (t), t,
1466 TREE_OPERAND (orig_name, 1));
1467 t = build2 (OFFSET_REF, unknown_type_node, decl, t);
1469 PTRMEM_OK_P (t) = 1;
1474 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1476 /* Get rid of a potential OVERLOAD around it. */
1477 t = OVL_CURRENT (t);
1479 /* Unique functions are handled easily. */
1481 /* For non-static member of base class, we need a special rule
1482 for access checking [class.protected]:
1484 If the access is to form a pointer to member, the
1485 nested-name-specifier shall name the derived class
1486 (or any class derived from that class). */
1487 if (address_p && DECL_P (t)
1488 && DECL_NONSTATIC_MEMBER_P (t))
1489 perform_or_defer_access_check (TYPE_BINFO (type), t);
1491 perform_or_defer_access_check (basebinfo, t);
1494 if (DECL_STATIC_FUNCTION_P (t))
1500 TREE_TYPE (fnfields) = unknown_type_node;
1504 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1505 /* We need additional test besides the one in
1506 check_accessibility_of_qualified_id in case it is
1507 a pointer to non-static member. */
1508 perform_or_defer_access_check (TYPE_BINFO (type), member);
1512 /* If MEMBER is non-static, then the program has fallen afoul of
1515 An id-expression that denotes a nonstatic data member or
1516 nonstatic member function of a class can only be used:
1518 -- as part of a class member access (_expr.ref_) in which the
1519 object-expression refers to the member's class or a class
1520 derived from that class, or
1522 -- to form a pointer to member (_expr.unary.op_), or
1524 -- in the body of a nonstatic member function of that class or
1525 of a class derived from that class (_class.mfct.nonstatic_), or
1527 -- in a mem-initializer for a constructor for that class or for
1528 a class derived from that class (_class.base.init_). */
1529 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1531 /* Build a representation of a the qualified name suitable
1532 for use as the operand to "&" -- even though the "&" is
1533 not actually present. */
1534 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1535 /* In Microsoft mode, treat a non-static member function as if
1536 it were a pointer-to-member. */
1537 if (flag_ms_extensions)
1539 PTRMEM_OK_P (member) = 1;
1540 return build_unary_op (ADDR_EXPR, member, 0);
1542 error ("invalid use of non-static member function %qD",
1543 TREE_OPERAND (member, 1));
1546 else if (TREE_CODE (member) == FIELD_DECL)
1548 error ("invalid use of non-static data member %qD", member);
1549 return error_mark_node;
1554 /* In member functions, the form `type::name' is no longer
1555 equivalent to `this->type::name', at least not until
1556 resolve_offset_ref. */
1557 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1558 PTRMEM_OK_P (member) = 1;
1562 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1563 constant of integral or enumeration type, then return that value.
1564 These are those variables permitted in constant expressions by
1565 [5.19/1]. FIXME:If we did lazy folding, this could be localized. */
1568 integral_constant_value (tree decl)
1570 while ((TREE_CODE (decl) == CONST_DECL
1571 || (TREE_CODE (decl) == VAR_DECL
1572 /* And so are variables with a 'const' type -- unless they
1573 are also 'volatile'. */
1574 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl))
1575 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)))
1576 && DECL_INITIAL (decl)
1577 && DECL_INITIAL (decl) != error_mark_node
1578 && TREE_TYPE (DECL_INITIAL (decl))
1579 && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl)))
1580 decl = DECL_INITIAL (decl);
1584 /* A more relaxed version of integral_constant_value, for which type
1585 is not considered. This is used by the common C/C++ code, and not
1586 directly by the C++ front end. */
1589 decl_constant_value (tree decl)
1591 if ((TREE_CODE (decl) == CONST_DECL
1592 || (TREE_CODE (decl) == VAR_DECL
1593 /* And so are variables with a 'const' type -- unless they
1594 are also 'volatile'. */
1595 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl))))
1596 && DECL_INITIAL (decl)
1597 && DECL_INITIAL (decl) != error_mark_node
1598 /* This is invalid if initial value is not constant. If it has
1599 either a function call, a memory reference, or a variable,
1600 then re-evaluating it could give different results. */
1601 && TREE_CONSTANT (DECL_INITIAL (decl)))
1602 return DECL_INITIAL (decl);
1607 /* Common subroutines of build_new and build_vec_delete. */
1609 /* Call the global __builtin_delete to delete ADDR. */
1612 build_builtin_delete_call (tree addr)
1614 mark_used (global_delete_fndecl);
1615 return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
1618 /* Generate a representation for a C++ "new" expression. PLACEMENT is
1619 a TREE_LIST of placement-new arguments (or NULL_TREE if none). If
1620 NELTS is NULL, TYPE is the type of the storage to be allocated. If
1621 NELTS is not NULL, then this is an array-new allocation; TYPE is
1622 the type of the elements in the array and NELTS is the number of
1623 elements in the array. INIT, if non-NULL, is the initializer for
1624 the new object. If USE_GLOBAL_NEW is true, then the user
1625 explicitly wrote "::new" rather than just "new". */
1628 build_new (tree placement, tree type, tree nelts, tree init,
1633 if (type == error_mark_node)
1634 return error_mark_node;
1636 if (processing_template_decl)
1638 rval = build_min (NEW_EXPR, build_pointer_type (type),
1639 placement, type, nelts, init);
1640 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1641 TREE_SIDE_EFFECTS (rval) = 1;
1647 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
1648 pedwarn ("size in array new must have integral type");
1649 nelts = save_expr (cp_convert (sizetype, nelts));
1650 if (nelts == integer_zero_node)
1651 warning ("zero size array reserves no space");
1654 /* ``A reference cannot be created by the new operator. A reference
1655 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
1656 returned by new.'' ARM 5.3.3 */
1657 if (TREE_CODE (type) == REFERENCE_TYPE)
1659 error ("new cannot be applied to a reference type");
1660 type = TREE_TYPE (type);
1663 if (TREE_CODE (type) == FUNCTION_TYPE)
1665 error ("new cannot be applied to a function type");
1666 return error_mark_node;
1669 rval = build4 (NEW_EXPR, build_pointer_type (type), placement, type,
1671 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1672 TREE_SIDE_EFFECTS (rval) = 1;
1673 rval = build_new_1 (rval);
1674 if (rval == error_mark_node)
1675 return error_mark_node;
1677 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
1678 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
1679 TREE_NO_WARNING (rval) = 1;
1684 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
1687 build_java_class_ref (tree type)
1689 tree name = NULL_TREE, class_decl;
1690 static tree CL_suffix = NULL_TREE;
1691 if (CL_suffix == NULL_TREE)
1692 CL_suffix = get_identifier("class$");
1693 if (jclass_node == NULL_TREE)
1695 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
1696 if (jclass_node == NULL_TREE)
1697 fatal_error ("call to Java constructor, while %<jclass%> undefined");
1699 jclass_node = TREE_TYPE (jclass_node);
1702 /* Mangle the class$ field. */
1705 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1706 if (DECL_NAME (field) == CL_suffix)
1708 mangle_decl (field);
1709 name = DECL_ASSEMBLER_NAME (field);
1713 internal_error ("can't find class$");
1716 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
1717 if (class_decl == NULL_TREE)
1719 class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
1720 TREE_STATIC (class_decl) = 1;
1721 DECL_EXTERNAL (class_decl) = 1;
1722 TREE_PUBLIC (class_decl) = 1;
1723 DECL_ARTIFICIAL (class_decl) = 1;
1724 DECL_IGNORED_P (class_decl) = 1;
1725 pushdecl_top_level (class_decl);
1726 make_decl_rtl (class_decl);
1732 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
1733 value is immediately handed to expand_expr. */
1736 build_new_1 (tree exp)
1738 tree placement, init;
1740 /* True iff this is a call to "operator new[]" instead of just
1742 bool array_p = false;
1743 /* True iff ARRAY_P is true and the bound of the array type is
1744 not necessarily a compile time constant. For example, VLA_P is
1745 true for "new int[f()]". */
1747 /* The type being allocated. If ARRAY_P is true, this will be an
1750 /* If ARRAY_P is true, the element type of the array. This is an
1751 never ARRAY_TYPE; for something like "new int[3][4]", the
1752 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1755 /* The type of the new-expression. (This type is always a pointer
1758 /* The type pointed to by POINTER_TYPE. This type may be different
1759 from ELT_TYPE for a multi-dimensional array; ELT_TYPE is never an
1760 ARRAY_TYPE, but TYPE may be an ARRAY_TYPE. */
1762 /* A pointer type pointing to the FULL_TYPE. */
1763 tree full_pointer_type;
1764 tree outer_nelts = NULL_TREE;
1765 tree nelts = NULL_TREE;
1766 tree alloc_call, alloc_expr;
1767 /* The address returned by the call to "operator new". This node is
1768 a VAR_DECL and is therefore reusable. */
1771 tree cookie_expr, init_expr;
1772 int nothrow, check_new;
1773 /* Nonzero if the user wrote `::new' rather than just `new'. */
1774 int globally_qualified_p;
1775 int use_java_new = 0;
1776 /* If non-NULL, the number of extra bytes to allocate at the
1777 beginning of the storage allocated for an array-new expression in
1778 order to store the number of elements. */
1779 tree cookie_size = NULL_TREE;
1780 /* True if the function we are calling is a placement allocation
1782 bool placement_allocation_fn_p;
1783 tree args = NULL_TREE;
1784 /* True if the storage must be initialized, either by a constructor
1785 or due to an explicit new-initializer. */
1786 bool is_initialized;
1787 /* The address of the thing allocated, not including any cookie. In
1788 particular, if an array cookie is in use, DATA_ADDR is the
1789 address of the first array element. This node is a VAR_DECL, and
1790 is therefore reusable. */
1792 tree init_preeval_expr = NULL_TREE;
1794 placement = TREE_OPERAND (exp, 0);
1795 type = TREE_OPERAND (exp, 1);
1796 nelts = TREE_OPERAND (exp, 2);
1797 init = TREE_OPERAND (exp, 3);
1798 globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
1804 outer_nelts = nelts;
1807 /* ??? The middle-end will error on us for building a VLA outside a
1808 function context. Methinks that's not it's purvey. So we'll do
1809 our own VLA layout later. */
1811 full_type = build_cplus_array_type (type, NULL_TREE);
1812 index = convert (sizetype, nelts);
1813 index = size_binop (MINUS_EXPR, index, size_one_node);
1814 TYPE_DOMAIN (full_type) = build_index_type (index);
1819 if (TREE_CODE (type) == ARRAY_TYPE)
1822 nelts = array_type_nelts_top (type);
1823 outer_nelts = nelts;
1824 type = TREE_TYPE (type);
1828 /* If our base type is an array, then make sure we know how many elements
1830 for (elt_type = type;
1831 TREE_CODE (elt_type) == ARRAY_TYPE;
1832 elt_type = TREE_TYPE (elt_type))
1833 nelts = cp_build_binary_op (MULT_EXPR, nelts,
1834 array_type_nelts_top (elt_type));
1836 if (!complete_type_or_else (elt_type, exp))
1837 return error_mark_node;
1839 if (TREE_CODE (elt_type) == VOID_TYPE)
1841 error ("invalid type %<void%> for new");
1842 return error_mark_node;
1845 if (abstract_virtuals_error (NULL_TREE, elt_type))
1846 return error_mark_node;
1848 is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || init);
1849 if (CP_TYPE_CONST_P (elt_type) && !is_initialized)
1851 error ("uninitialized const in %<new%> of %q#T", elt_type);
1852 return error_mark_node;
1855 size = size_in_bytes (elt_type);
1858 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1863 /* Do our own VLA layout. Setting TYPE_SIZE/_UNIT is
1864 necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
1865 ...>> to be valid. */
1866 TYPE_SIZE_UNIT (full_type) = size;
1867 n = convert (bitsizetype, nelts);
1868 bitsize = size_binop (MULT_EXPR, TYPE_SIZE (elt_type), n);
1869 TYPE_SIZE (full_type) = bitsize;
1873 /* Allocate the object. */
1874 if (! placement && TYPE_FOR_JAVA (elt_type))
1876 tree class_addr, alloc_decl;
1877 tree class_decl = build_java_class_ref (elt_type);
1878 static const char alloc_name[] = "_Jv_AllocObject";
1882 if (!get_global_value_if_present (get_identifier (alloc_name),
1885 error ("call to Java constructor with %qs undefined", alloc_name);
1886 return error_mark_node;
1888 else if (really_overloaded_fn (alloc_decl))
1890 error ("%qD should never be overloaded", alloc_decl);
1891 return error_mark_node;
1893 alloc_decl = OVL_CURRENT (alloc_decl);
1894 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1895 alloc_call = (build_function_call
1897 build_tree_list (NULL_TREE, class_addr)));
1904 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
1906 if (!globally_qualified_p
1907 && CLASS_TYPE_P (elt_type)
1909 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
1910 : TYPE_HAS_NEW_OPERATOR (elt_type)))
1912 /* Use a class-specific operator new. */
1913 /* If a cookie is required, add some extra space. */
1914 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1916 cookie_size = targetm.cxx.get_cookie_size (elt_type);
1917 size = size_binop (PLUS_EXPR, size, cookie_size);
1919 /* Create the argument list. */
1920 args = tree_cons (NULL_TREE, size, placement);
1921 /* Do name-lookup to find the appropriate operator. */
1922 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
1923 if (TREE_CODE (fns) == TREE_LIST)
1925 error ("request for member %qD is ambiguous", fnname);
1926 print_candidates (fns);
1927 return error_mark_node;
1929 alloc_call = build_new_method_call (build_dummy_object (elt_type),
1931 /*conversion_path=*/NULL_TREE,
1936 /* Use a global operator new. */
1937 /* See if a cookie might be required. */
1938 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1939 cookie_size = targetm.cxx.get_cookie_size (elt_type);
1941 cookie_size = NULL_TREE;
1943 alloc_call = build_operator_new_call (fnname, placement,
1944 &size, &cookie_size);
1948 if (alloc_call == error_mark_node)
1949 return error_mark_node;
1951 /* In the simple case, we can stop now. */
1952 pointer_type = build_pointer_type (type);
1953 if (!cookie_size && !is_initialized)
1954 return build_nop (pointer_type, alloc_call);
1956 /* While we're working, use a pointer to the type we've actually
1957 allocated. Store the result of the call in a variable so that we
1958 can use it more than once. */
1959 full_pointer_type = build_pointer_type (full_type);
1960 alloc_expr = get_target_expr (build_nop (full_pointer_type, alloc_call));
1961 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
1963 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
1964 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
1965 alloc_call = TREE_OPERAND (alloc_call, 1);
1966 alloc_fn = get_callee_fndecl (alloc_call);
1967 gcc_assert (alloc_fn != NULL_TREE);
1969 /* Now, check to see if this function is actually a placement
1970 allocation function. This can happen even when PLACEMENT is NULL
1971 because we might have something like:
1973 struct S { void* operator new (size_t, int i = 0); };
1975 A call to `new S' will get this allocation function, even though
1976 there is no explicit placement argument. If there is more than
1977 one argument, or there are variable arguments, then this is a
1978 placement allocation function. */
1979 placement_allocation_fn_p
1980 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
1981 || varargs_function_p (alloc_fn));
1983 /* Preevaluate the placement args so that we don't reevaluate them for a
1984 placement delete. */
1985 if (placement_allocation_fn_p)
1988 stabilize_call (alloc_call, &inits);
1990 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
1994 /* unless an allocation function is declared with an empty excep-
1995 tion-specification (_except.spec_), throw(), it indicates failure to
1996 allocate storage by throwing a bad_alloc exception (clause _except_,
1997 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
1998 cation function is declared with an empty exception-specification,
1999 throw(), it returns null to indicate failure to allocate storage and a
2000 non-null pointer otherwise.
2002 So check for a null exception spec on the op new we just called. */
2004 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2005 check_new = (flag_check_new || nothrow) && ! use_java_new;
2012 /* Adjust so we're pointing to the start of the object. */
2013 data_addr = get_target_expr (build2 (PLUS_EXPR, full_pointer_type,
2014 alloc_node, cookie_size));
2016 /* Store the number of bytes allocated so that we can know how
2017 many elements to destroy later. We use the last sizeof
2018 (size_t) bytes to store the number of elements. */
2019 cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2020 data_addr, size_in_bytes (sizetype));
2021 cookie = build_indirect_ref (cookie_ptr, NULL);
2023 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2025 if (targetm.cxx.cookie_has_size ())
2027 /* Also store the element size. */
2028 cookie_ptr = build2 (MINUS_EXPR, build_pointer_type (sizetype),
2029 cookie_ptr, size_in_bytes (sizetype));
2030 cookie = build_indirect_ref (cookie_ptr, NULL);
2031 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2032 size_in_bytes(elt_type));
2033 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2034 cookie, cookie_expr);
2036 data_addr = TARGET_EXPR_SLOT (data_addr);
2040 cookie_expr = NULL_TREE;
2041 data_addr = alloc_node;
2044 /* Now initialize the allocated object. Note that we preevaluate the
2045 initialization expression, apart from the actual constructor call or
2046 assignment--we do this because we want to delay the allocation as long
2047 as possible in order to minimize the size of the exception region for
2048 placement delete. */
2053 init_expr = build_indirect_ref (data_addr, NULL);
2055 if (init == void_zero_node)
2056 init = build_default_init (full_type, nelts);
2057 else if (init && array_p)
2058 pedwarn ("ISO C++ forbids initialization in array new");
2063 = build_vec_init (init_expr,
2064 cp_build_binary_op (MINUS_EXPR, outer_nelts,
2066 init, /*from_array=*/0);
2068 /* An array initialization is stable because the initialization
2069 of each element is a full-expression, so the temporaries don't
2073 else if (TYPE_NEEDS_CONSTRUCTING (type))
2075 init_expr = build_special_member_call (init_expr,
2076 complete_ctor_identifier,
2079 stable = stabilize_init (init_expr, &init_preeval_expr);
2083 /* We are processing something like `new int (10)', which
2084 means allocate an int, and initialize it with 10. */
2086 if (TREE_CODE (init) == TREE_LIST)
2087 init = build_x_compound_expr_from_list (init, "new initializer");
2090 gcc_assert (TREE_CODE (init) != CONSTRUCTOR
2091 || TREE_TYPE (init) != NULL_TREE);
2093 init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
2094 stable = stabilize_init (init_expr, &init_preeval_expr);
2097 if (init_expr == error_mark_node)
2098 return error_mark_node;
2100 /* If any part of the object initialization terminates by throwing an
2101 exception and a suitable deallocation function can be found, the
2102 deallocation function is called to free the memory in which the
2103 object was being constructed, after which the exception continues
2104 to propagate in the context of the new-expression. If no
2105 unambiguous matching deallocation function can be found,
2106 propagating the exception does not cause the object's memory to be
2108 if (flag_exceptions && ! use_java_new)
2110 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2113 /* The Standard is unclear here, but the right thing to do
2114 is to use the same method for finding deallocation
2115 functions that we use for finding allocation functions. */
2116 cleanup = build_op_delete_call (dcode, alloc_node, size,
2117 globally_qualified_p,
2118 (placement_allocation_fn_p
2119 ? alloc_call : NULL_TREE));
2124 /* This is much simpler if we were able to preevaluate all of
2125 the arguments to the constructor call. */
2126 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2127 init_expr, cleanup);
2129 /* Ack! First we allocate the memory. Then we set our sentry
2130 variable to true, and expand a cleanup that deletes the
2131 memory if sentry is true. Then we run the constructor, and
2132 finally clear the sentry.
2134 We need to do this because we allocate the space first, so
2135 if there are any temporaries with cleanups in the
2136 constructor args and we weren't able to preevaluate them, we
2137 need this EH region to extend until end of full-expression
2138 to preserve nesting. */
2140 tree end, sentry, begin;
2142 begin = get_target_expr (boolean_true_node);
2143 CLEANUP_EH_ONLY (begin) = 1;
2145 sentry = TARGET_EXPR_SLOT (begin);
2147 TARGET_EXPR_CLEANUP (begin)
2148 = build3 (COND_EXPR, void_type_node, sentry,
2149 cleanup, void_zero_node);
2151 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2152 sentry, boolean_false_node);
2155 = build2 (COMPOUND_EXPR, void_type_node, begin,
2156 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2163 init_expr = NULL_TREE;
2165 /* Now build up the return value in reverse order. */
2170 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2172 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2174 if (rval == alloc_node)
2175 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2176 and return the call (which doesn't need to be adjusted). */
2177 rval = TARGET_EXPR_INITIAL (alloc_expr);
2182 tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
2184 rval = build_conditional_expr (ifexp, rval, alloc_node);
2187 /* Perform the allocation before anything else, so that ALLOC_NODE
2188 has been initialized before we start using it. */
2189 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2192 if (init_preeval_expr)
2193 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2195 /* Convert to the final type. */
2196 rval = build_nop (pointer_type, rval);
2198 /* A new-expression is never an lvalue. */
2199 if (real_lvalue_p (rval))
2200 rval = build1 (NON_LVALUE_EXPR, TREE_TYPE (rval), rval);
2206 build_vec_delete_1 (tree base, tree maxindex, tree type,
2207 special_function_kind auto_delete_vec, int use_global_delete)
2210 tree ptype = build_pointer_type (type = complete_type (type));
2211 tree size_exp = size_in_bytes (type);
2213 /* Temporary variables used by the loop. */
2214 tree tbase, tbase_init;
2216 /* This is the body of the loop that implements the deletion of a
2217 single element, and moves temp variables to next elements. */
2220 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2223 /* This is the thing that governs what to do after the loop has run. */
2224 tree deallocate_expr = 0;
2226 /* This is the BIND_EXPR which holds the outermost iterator of the
2227 loop. It is convenient to set this variable up and test it before
2228 executing any other code in the loop.
2229 This is also the containing expression returned by this function. */
2230 tree controller = NULL_TREE;
2232 /* We should only have 1-D arrays here. */
2233 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2235 if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2238 /* The below is short by the cookie size. */
2239 virtual_size = size_binop (MULT_EXPR, size_exp,
2240 convert (sizetype, maxindex));
2242 tbase = create_temporary_var (ptype);
2243 tbase_init = build_modify_expr (tbase, NOP_EXPR,
2244 fold_build2 (PLUS_EXPR, ptype,
2247 DECL_REGISTER (tbase) = 1;
2248 controller = build3 (BIND_EXPR, void_type_node, tbase,
2249 NULL_TREE, NULL_TREE);
2250 TREE_SIDE_EFFECTS (controller) = 1;
2252 body = build1 (EXIT_EXPR, void_type_node,
2253 build2 (EQ_EXPR, boolean_type_node, base, tbase));
2254 body = build_compound_expr
2255 (body, build_modify_expr (tbase, NOP_EXPR,
2256 build2 (MINUS_EXPR, ptype, tbase, size_exp)));
2257 body = build_compound_expr
2258 (body, build_delete (ptype, tbase, sfk_complete_destructor,
2259 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2261 loop = build1 (LOOP_EXPR, void_type_node, body);
2262 loop = build_compound_expr (tbase_init, loop);
2265 /* If the delete flag is one, or anything else with the low bit set,
2266 delete the storage. */
2267 if (auto_delete_vec != sfk_base_destructor)
2271 /* The below is short by the cookie size. */
2272 virtual_size = size_binop (MULT_EXPR, size_exp,
2273 convert (sizetype, maxindex));
2275 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2282 cookie_size = targetm.cxx.get_cookie_size (type);
2284 = cp_convert (ptype,
2285 cp_build_binary_op (MINUS_EXPR,
2286 cp_convert (string_type_node,
2289 /* True size with header. */
2290 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2293 if (auto_delete_vec == sfk_deleting_destructor)
2294 deallocate_expr = build_x_delete (base_tbd,
2295 2 | use_global_delete,
2300 if (!deallocate_expr)
2303 body = deallocate_expr;
2305 body = build_compound_expr (body, deallocate_expr);
2308 body = integer_zero_node;
2310 /* Outermost wrapper: If pointer is null, punt. */
2311 body = fold_build3 (COND_EXPR, void_type_node,
2312 fold_build2 (NE_EXPR, boolean_type_node, base,
2313 convert (TREE_TYPE (base),
2314 integer_zero_node)),
2315 body, integer_zero_node);
2316 body = build1 (NOP_EXPR, void_type_node, body);
2320 TREE_OPERAND (controller, 1) = body;
2324 if (TREE_CODE (base) == SAVE_EXPR)
2325 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2326 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2328 return convert_to_void (body, /*implicit=*/NULL);
2331 /* Create an unnamed variable of the indicated TYPE. */
2334 create_temporary_var (tree type)
2338 decl = build_decl (VAR_DECL, NULL_TREE, type);
2339 TREE_USED (decl) = 1;
2340 DECL_ARTIFICIAL (decl) = 1;
2341 DECL_IGNORED_P (decl) = 1;
2342 DECL_SOURCE_LOCATION (decl) = input_location;
2343 DECL_CONTEXT (decl) = current_function_decl;
2348 /* Create a new temporary variable of the indicated TYPE, initialized
2351 It is not entered into current_binding_level, because that breaks
2352 things when it comes time to do final cleanups (which take place
2353 "outside" the binding contour of the function). */
2356 get_temp_regvar (tree type, tree init)
2360 decl = create_temporary_var (type);
2361 add_decl_expr (decl);
2363 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
2368 /* `build_vec_init' returns tree structure that performs
2369 initialization of a vector of aggregate types.
2371 BASE is a reference to the vector, of ARRAY_TYPE.
2372 MAXINDEX is the maximum index of the array (one less than the
2373 number of elements). It is only used if
2374 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2375 INIT is the (possibly NULL) initializer.
2377 FROM_ARRAY is 0 if we should init everything with INIT
2378 (i.e., every element initialized from INIT).
2379 FROM_ARRAY is 1 if we should index into INIT in parallel
2380 with initialization of DECL.
2381 FROM_ARRAY is 2 if we should index into INIT in parallel,
2382 but use assignment instead of initialization. */
2385 build_vec_init (tree base, tree maxindex, tree init, int from_array)
2388 tree base2 = NULL_TREE;
2390 tree itype = NULL_TREE;
2392 /* The type of the array. */
2393 tree atype = TREE_TYPE (base);
2394 /* The type of an element in the array. */
2395 tree type = TREE_TYPE (atype);
2396 /* The element type reached after removing all outer array
2398 tree inner_elt_type;
2399 /* The type of a pointer to an element in the array. */
2404 tree try_block = NULL_TREE;
2405 int num_initialized_elts = 0;
2408 if (TYPE_DOMAIN (atype))
2409 maxindex = array_type_nelts (atype);
2411 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2412 return error_mark_node;
2414 inner_elt_type = strip_array_types (atype);
2417 ? (!CLASS_TYPE_P (inner_elt_type)
2418 || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2419 : !TYPE_NEEDS_CONSTRUCTING (type))
2420 && ((TREE_CODE (init) == CONSTRUCTOR
2421 /* Don't do this if the CONSTRUCTOR might contain something
2422 that might throw and require us to clean up. */
2423 && (CONSTRUCTOR_ELTS (init) == NULL_TREE
2424 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2427 /* Do non-default initialization of POD arrays resulting from
2428 brace-enclosed initializers. In this case, digest_init and
2429 store_constructor will handle the semantics for us. */
2431 stmt_expr = build2 (INIT_EXPR, atype, base, init);
2435 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2436 ptype = build_pointer_type (type);
2437 size = size_in_bytes (type);
2438 if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
2439 base = cp_convert (ptype, decay_conversion (base));
2441 /* The code we are generating looks like:
2445 ptrdiff_t iterator = maxindex;
2447 for (; iterator != -1; --iterator) {
2448 ... initialize *t1 ...
2452 ... destroy elements that were constructed ...
2457 We can omit the try and catch blocks if we know that the
2458 initialization will never throw an exception, or if the array
2459 elements do not have destructors. We can omit the loop completely if
2460 the elements of the array do not have constructors.
2462 We actually wrap the entire body of the above in a STMT_EXPR, for
2465 When copying from array to another, when the array elements have
2466 only trivial copy constructors, we should use __builtin_memcpy
2467 rather than generating a loop. That way, we could take advantage
2468 of whatever cleverness the back-end has for dealing with copies
2469 of blocks of memory. */
2471 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2472 destroy_temps = stmts_are_full_exprs_p ();
2473 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2474 rval = get_temp_regvar (ptype, base);
2475 base = get_temp_regvar (ptype, rval);
2476 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2478 /* Protect the entire array initialization so that we can destroy
2479 the partially constructed array if an exception is thrown.
2480 But don't do this if we're assigning. */
2481 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2484 try_block = begin_try_block ();
2487 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2489 /* Do non-default initialization of non-POD arrays resulting from
2490 brace-enclosed initializers. */
2495 for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
2497 tree elt = TREE_VALUE (elts);
2498 tree baseref = build1 (INDIRECT_REF, type, base);
2500 num_initialized_elts++;
2502 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2503 if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2504 finish_expr_stmt (build_aggr_init (baseref, elt, 0));
2506 finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
2508 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2510 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2511 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
2514 /* Clear out INIT so that we don't get confused below. */
2517 else if (from_array)
2519 /* If initializing one array from another, initialize element by
2520 element. We rely upon the below calls the do argument
2524 base2 = decay_conversion (init);
2525 itype = TREE_TYPE (base2);
2526 base2 = get_temp_regvar (itype, base2);
2527 itype = TREE_TYPE (itype);
2529 else if (TYPE_LANG_SPECIFIC (type)
2530 && TYPE_NEEDS_CONSTRUCTING (type)
2531 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2533 error ("initializer ends prematurely");
2534 return error_mark_node;
2538 /* Now, default-initialize any remaining elements. We don't need to
2539 do that if a) the type does not need constructing, or b) we've
2540 already initialized all the elements.
2542 We do need to keep going if we're copying an array. */
2545 || (TYPE_NEEDS_CONSTRUCTING (type)
2546 && ! (host_integerp (maxindex, 0)
2547 && (num_initialized_elts
2548 == tree_low_cst (maxindex, 0) + 1))))
2550 /* If the ITERATOR is equal to -1, then we don't have to loop;
2551 we've already initialized all the elements. */
2555 for_stmt = begin_for_stmt ();
2556 finish_for_init_stmt (for_stmt);
2557 finish_for_cond (build2 (NE_EXPR, boolean_type_node,
2558 iterator, integer_minus_one_node),
2560 finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0),
2565 tree to = build1 (INDIRECT_REF, type, base);
2569 from = build1 (INDIRECT_REF, itype, base2);
2573 if (from_array == 2)
2574 elt_init = build_modify_expr (to, NOP_EXPR, from);
2575 else if (TYPE_NEEDS_CONSTRUCTING (type))
2576 elt_init = build_aggr_init (to, from, 0);
2578 elt_init = build_modify_expr (to, NOP_EXPR, from);
2582 else if (TREE_CODE (type) == ARRAY_TYPE)
2586 ("cannot initialize multi-dimensional array with initializer");
2587 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2591 elt_init = build_aggr_init (build1 (INDIRECT_REF, type, base),
2594 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2595 finish_expr_stmt (elt_init);
2596 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2598 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2600 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));
2602 finish_for_stmt (for_stmt);
2605 /* Make sure to cleanup any partially constructed elements. */
2606 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2610 tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);
2612 /* Flatten multi-dimensional array since build_vec_delete only
2613 expects one-dimensional array. */
2614 if (TREE_CODE (type) == ARRAY_TYPE)
2615 m = cp_build_binary_op (MULT_EXPR, m,
2616 array_type_nelts_total (type));
2618 finish_cleanup_try_block (try_block);
2619 e = build_vec_delete_1 (rval, m,
2620 inner_elt_type, sfk_base_destructor,
2621 /*use_global_delete=*/0);
2622 finish_cleanup (e, try_block);
2625 /* The value of the array initialization is the array itself, RVAL
2626 is a pointer to the first element. */
2627 finish_stmt_expr_expr (rval, stmt_expr);
2629 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2631 /* Now convert make the result have the correct type. */
2632 atype = build_pointer_type (atype);
2633 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2634 stmt_expr = build_indirect_ref (stmt_expr, NULL);
2636 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2640 /* Free up storage of type TYPE, at address ADDR.
2642 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2645 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2646 used as the second argument to operator delete. It can include
2647 things like padding and magic size cookies. It has virtual in it,
2648 because if you have a base pointer and you delete through a virtual
2649 destructor, it should be the size of the dynamic object, not the
2650 static object, see Free Store 12.5 ISO C++.
2652 This does not call any destructors. */
2655 build_x_delete (tree addr, int which_delete, tree virtual_size)
2657 int use_global_delete = which_delete & 1;
2658 int use_vec_delete = !!(which_delete & 2);
2659 enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
2661 return build_op_delete_call (code, addr, virtual_size, use_global_delete,
2665 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
2669 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2675 case sfk_complete_destructor:
2676 name = complete_dtor_identifier;
2679 case sfk_base_destructor:
2680 name = base_dtor_identifier;
2683 case sfk_deleting_destructor:
2684 name = deleting_dtor_identifier;
2690 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2691 return build_new_method_call (exp, fn,
2693 /*conversion_path=*/NULL_TREE,
2697 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2698 ADDR is an expression which yields the store to be destroyed.
2699 AUTO_DELETE is the name of the destructor to call, i.e., either
2700 sfk_complete_destructor, sfk_base_destructor, or
2701 sfk_deleting_destructor.
2703 FLAGS is the logical disjunction of zero or more LOOKUP_
2704 flags. See cp-tree.h for more info. */
2707 build_delete (tree type, tree addr, special_function_kind auto_delete,
2708 int flags, int use_global_delete)
2712 if (addr == error_mark_node)
2713 return error_mark_node;
2715 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2716 set to `error_mark_node' before it gets properly cleaned up. */
2717 if (type == error_mark_node)
2718 return error_mark_node;
2720 type = TYPE_MAIN_VARIANT (type);
2722 if (TREE_CODE (type) == POINTER_TYPE)
2724 bool complete_p = true;
2726 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2727 if (TREE_CODE (type) == ARRAY_TYPE)
2730 /* We don't want to warn about delete of void*, only other
2731 incomplete types. Deleting other incomplete types
2732 invokes undefined behavior, but it is not ill-formed, so
2733 compile to something that would even do The Right Thing
2734 (TM) should the type have a trivial dtor and no delete
2736 if (!VOID_TYPE_P (type))
2738 complete_type (type);
2739 if (!COMPLETE_TYPE_P (type))
2741 warning ("possible problem detected in invocation of "
2742 "delete operator:");
2743 cxx_incomplete_type_diagnostic (addr, type, 1);
2744 inform ("neither the destructor nor the class-specific "
2745 "operator delete will be called, even if they are "
2746 "declared when the class is defined.");
2750 if (VOID_TYPE_P (type) || !complete_p || !IS_AGGR_TYPE (type))
2751 /* Call the builtin operator delete. */
2752 return build_builtin_delete_call (addr);
2753 if (TREE_SIDE_EFFECTS (addr))
2754 addr = save_expr (addr);
2756 /* Throw away const and volatile on target type of addr. */
2757 addr = convert_force (build_pointer_type (type), addr, 0);
2759 else if (TREE_CODE (type) == ARRAY_TYPE)
2763 if (TYPE_DOMAIN (type) == NULL_TREE)
2765 error ("unknown array size in delete");
2766 return error_mark_node;
2768 return build_vec_delete (addr, array_type_nelts (type),
2769 auto_delete, use_global_delete);
2773 /* Don't check PROTECT here; leave that decision to the
2774 destructor. If the destructor is accessible, call it,
2775 else report error. */
2776 addr = build_unary_op (ADDR_EXPR, addr, 0);
2777 if (TREE_SIDE_EFFECTS (addr))
2778 addr = save_expr (addr);
2780 addr = convert_force (build_pointer_type (type), addr, 0);
2783 gcc_assert (IS_AGGR_TYPE (type));
2785 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2787 if (auto_delete != sfk_deleting_destructor)
2788 return void_zero_node;
2790 return build_op_delete_call
2791 (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), use_global_delete,
2796 tree do_delete = NULL_TREE;
2799 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
2800 lazily_declare_fn (sfk_destructor, type);
2802 /* For `::delete x', we must not use the deleting destructor
2803 since then we would not be sure to get the global `operator
2805 if (use_global_delete && auto_delete == sfk_deleting_destructor)
2807 /* We will use ADDR multiple times so we must save it. */
2808 addr = save_expr (addr);
2809 /* Delete the object. */
2810 do_delete = build_builtin_delete_call (addr);
2811 /* Otherwise, treat this like a complete object destructor
2813 auto_delete = sfk_complete_destructor;
2815 /* If the destructor is non-virtual, there is no deleting
2816 variant. Instead, we must explicitly call the appropriate
2817 `operator delete' here. */
2818 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
2819 && auto_delete == sfk_deleting_destructor)
2821 /* We will use ADDR multiple times so we must save it. */
2822 addr = save_expr (addr);
2823 /* Build the call. */
2824 do_delete = build_op_delete_call (DELETE_EXPR,
2826 cxx_sizeof_nowarn (type),
2829 /* Call the complete object destructor. */
2830 auto_delete = sfk_complete_destructor;
2832 else if (auto_delete == sfk_deleting_destructor
2833 && TYPE_GETS_REG_DELETE (type))
2835 /* Make sure we have access to the member op delete, even though
2836 we'll actually be calling it from the destructor. */
2837 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2838 /*global_p=*/false, NULL_TREE);
2841 expr = build_dtor_call (build_indirect_ref (addr, NULL),
2842 auto_delete, flags);
2844 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
2846 if (flags & LOOKUP_DESTRUCTOR)
2847 /* Explicit destructor call; don't check for null pointer. */
2848 ifexp = integer_one_node;
2850 /* Handle deleting a null pointer. */
2851 ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
2853 if (ifexp != integer_one_node)
2854 expr = build3 (COND_EXPR, void_type_node,
2855 ifexp, expr, void_zero_node);
2861 /* At the beginning of a destructor, push cleanups that will call the
2862 destructors for our base classes and members.
2864 Called from begin_destructor_body. */
2867 push_base_cleanups (void)
2869 tree binfo, base_binfo;
2875 /* Run destructors for all virtual baseclasses. */
2876 if (CLASSTYPE_VBASECLASSES (current_class_type))
2878 tree cond = (condition_conversion
2879 (build2 (BIT_AND_EXPR, integer_type_node,
2880 current_in_charge_parm,
2881 integer_two_node)));
2883 /* The CLASSTYPE_VBASECLASSES vector is in initialization
2884 order, which is also the right order for pushing cleanups. */
2885 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
2886 VEC_iterate (tree, vbases, i, base_binfo); i++)
2888 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
2890 expr = build_special_member_call (current_class_ref,
2891 base_dtor_identifier,
2895 | LOOKUP_NONVIRTUAL));
2896 expr = build3 (COND_EXPR, void_type_node, cond,
2897 expr, void_zero_node);
2898 finish_decl_cleanup (NULL_TREE, expr);
2903 /* Take care of the remaining baseclasses. */
2904 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2905 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
2907 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
2908 || BINFO_VIRTUAL_P (base_binfo))
2911 expr = build_special_member_call (current_class_ref,
2912 base_dtor_identifier,
2913 NULL_TREE, base_binfo,
2914 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
2915 finish_decl_cleanup (NULL_TREE, expr);
2918 for (member = TYPE_FIELDS (current_class_type); member;
2919 member = TREE_CHAIN (member))
2921 if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
2923 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
2925 tree this_member = (build_class_member_access_expr
2926 (current_class_ref, member,
2927 /*access_path=*/NULL_TREE,
2928 /*preserve_reference=*/false));
2929 tree this_type = TREE_TYPE (member);
2930 expr = build_delete (this_type, this_member,
2931 sfk_complete_destructor,
2932 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
2934 finish_decl_cleanup (NULL_TREE, expr);
2939 /* Build a C++ vector delete expression.
2940 MAXINDEX is the number of elements to be deleted.
2941 ELT_SIZE is the nominal size of each element in the vector.
2942 BASE is the expression that should yield the store to be deleted.
2943 This function expands (or synthesizes) these calls itself.
2944 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
2946 This also calls delete for virtual baseclasses of elements of the vector.
2948 Update: MAXINDEX is no longer needed. The size can be extracted from the
2949 start of the vector for pointers, and from the type for arrays. We still
2950 use MAXINDEX for arrays because it happens to already have one of the
2951 values we'd have to extract. (We could use MAXINDEX with pointers to
2952 confirm the size, and trap if the numbers differ; not clear that it'd
2953 be worth bothering.) */
2956 build_vec_delete (tree base, tree maxindex,
2957 special_function_kind auto_delete_vec, int use_global_delete)
2961 tree base_init = NULL_TREE;
2963 type = TREE_TYPE (base);
2965 if (TREE_CODE (type) == POINTER_TYPE)
2967 /* Step back one from start of vector, and read dimension. */
2970 if (TREE_SIDE_EFFECTS (base))
2972 base_init = get_target_expr (base);
2973 base = TARGET_EXPR_SLOT (base_init);
2975 type = strip_array_types (TREE_TYPE (type));
2976 cookie_addr = build2 (MINUS_EXPR,
2977 build_pointer_type (sizetype),
2979 TYPE_SIZE_UNIT (sizetype));
2980 maxindex = build_indirect_ref (cookie_addr, NULL);
2982 else if (TREE_CODE (type) == ARRAY_TYPE)
2984 /* Get the total number of things in the array, maxindex is a
2986 maxindex = array_type_nelts_total (type);
2987 type = strip_array_types (type);
2988 base = build_unary_op (ADDR_EXPR, base, 1);
2989 if (TREE_SIDE_EFFECTS (base))
2991 base_init = get_target_expr (base);
2992 base = TARGET_EXPR_SLOT (base_init);
2997 if (base != error_mark_node)
2998 error ("type to vector delete is neither pointer or array type");
2999 return error_mark_node;
3002 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3005 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);