1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 89, 92-98, 1999 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* High-level class interface. */
36 /* In C++, structures with well-defined constructors are initialized by
37 those constructors, unasked. CURRENT_BASE_INIT_LIST
38 holds a list of stmts for a BASE_INIT term in the grammar.
39 This list has one element for each base class which must be
40 initialized. The list elements are [basename, init], with
41 type basetype. This allows the possibly anachronistic form
42 (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
43 where each successive term can be handed down the constructor
44 line. Perhaps this was not intended. */
45 tree current_base_init_list, current_member_init_list;
47 static void expand_aggr_vbase_init_1 PROTO((tree, tree, tree, tree));
48 static void construct_virtual_bases PROTO((tree, tree, tree, tree, tree));
49 static void expand_aggr_init_1 PROTO((tree, tree, tree, tree, int));
50 static void expand_default_init PROTO((tree, tree, tree, tree, int));
51 static tree build_vec_delete_1 PROTO((tree, tree, tree, tree, tree,
53 static void perform_member_init PROTO((tree, tree, tree, int));
54 static void sort_base_init PROTO((tree, tree *, tree *));
55 static tree build_builtin_delete_call PROTO((tree));
56 static int member_init_ok_or_else PROTO((tree, tree, const char *));
57 static void expand_virtual_init PROTO((tree, tree));
58 static tree sort_member_init PROTO((tree));
59 static tree initializing_context PROTO((tree));
60 static void expand_vec_init_try_block PROTO((tree));
61 static void expand_vec_init_catch_clause PROTO((tree, tree, tree, tree));
62 static tree build_java_class_ref PROTO((tree));
63 static void expand_cleanup_for_base PROTO((tree, tree));
65 /* Cache the identifier nodes for the magic field of a new cookie. */
66 static tree nc_nelts_field_id;
68 static tree minus_one;
70 /* Set up local variable for this file. MUST BE CALLED AFTER
71 INIT_DECL_PROCESSING. */
73 static tree BI_header_type, BI_header_size;
75 void init_init_processing ()
79 minus_one = build_int_2 (-1, -1);
81 /* Define the structure that holds header information for
82 arrays allocated via operator new. */
83 BI_header_type = make_lang_type (RECORD_TYPE);
84 nc_nelts_field_id = get_identifier ("nelts");
85 fields[0] = build_lang_field_decl (FIELD_DECL, nc_nelts_field_id, sizetype);
86 finish_builtin_type (BI_header_type, "__new_cookie", fields,
88 BI_header_size = size_in_bytes (BI_header_type);
91 /* Subroutine of emit_base_init. For BINFO, initialize all the
92 virtual function table pointers, except those that come from
93 virtual base classes. Initialize binfo's vtable pointer, if
94 INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
95 function table pointers in all bases have been initialized already,
96 probably because their constructors have just be run. ADDR is the
97 pointer to the object whos vtables we are going to initialize.
99 REAL_BINFO is usually the same as BINFO, except when addr is not of
100 pointer to the type of the real derived type that we want to
101 initialize for. This is the case when addr is a pointer to a sub
102 object of a complete object, and we only want to do part of the
103 complete object's initialization of vtable pointers. This is done
104 for all virtual table pointers in virtual base classes. REAL_BINFO
105 is used to find the BINFO_VTABLE that we initialize with. BINFO is
106 used for conversions of addr to subobjects.
108 BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
110 Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
114 expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr)
115 tree real_binfo, binfo, addr;
116 int init_self, can_elide;
118 tree real_binfos = BINFO_BASETYPES (real_binfo);
119 tree binfos = BINFO_BASETYPES (binfo);
120 int i, n_baselinks = real_binfos ? TREE_VEC_LENGTH (real_binfos) : 0;
122 for (i = 0; i < n_baselinks; i++)
124 tree real_base_binfo = TREE_VEC_ELT (real_binfos, i);
125 tree base_binfo = TREE_VEC_ELT (binfos, i);
126 int is_not_base_vtable
127 = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo));
128 if (! TREE_VIA_VIRTUAL (real_base_binfo))
129 expand_direct_vtbls_init (real_base_binfo, base_binfo,
130 is_not_base_vtable, can_elide, addr);
133 /* Before turning this on, make sure it is correct. */
134 if (can_elide && ! BINFO_MODIFIED (binfo))
137 /* Should we use something besides CLASSTYPE_VFIELDS? */
138 if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo)))
140 tree base_ptr = convert_pointer_to_real (binfo, addr);
141 expand_virtual_init (real_binfo, base_ptr);
146 /* Subroutine of emit_base_init. */
149 perform_member_init (member, name, init, explicit)
150 tree member, name, init;
154 tree type = TREE_TYPE (member);
156 expand_start_target_temps ();
158 decl = build_component_ref (current_class_ref, name, NULL_TREE, explicit);
160 /* Deal with this here, as we will get confused if we try to call the
161 assignment op for an anonymous union. This can happen in a
162 synthesized copy constructor. */
163 if (ANON_AGGR_TYPE_P (type))
165 init = build (INIT_EXPR, type, decl, TREE_VALUE (init));
166 TREE_SIDE_EFFECTS (init) = 1;
167 expand_expr_stmt (init);
169 else if (TYPE_NEEDS_CONSTRUCTING (type)
170 || (init && TYPE_HAS_CONSTRUCTOR (type)))
172 /* Since `init' is already a TREE_LIST on the current_member_init_list,
173 only build it into one if we aren't already a list. */
174 if (init != NULL_TREE && TREE_CODE (init) != TREE_LIST)
175 init = build_expr_list (NULL_TREE, init);
178 && TREE_CODE (type) == ARRAY_TYPE
180 && TREE_CHAIN (init) == NULL_TREE
181 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
183 /* Initialization of one array from another. */
184 expand_vec_init (TREE_OPERAND (decl, 1), decl,
185 array_type_nelts (type), TREE_VALUE (init), 1);
188 expand_aggr_init (decl, init, 0);
192 if (init == NULL_TREE)
196 /* default-initialization. */
197 if (AGGREGATE_TYPE_P (type))
199 /* This is a default initialization of an aggregate,
200 but not one of non-POD class type. We cleverly
201 notice that the initialization rules in such a
202 case are the same as for initialization with an
203 empty brace-initialization list. We don't want
204 to call build_modify_expr as that will go looking
205 for constructors and such. */
206 tree e = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
207 TREE_SIDE_EFFECTS (e) = 1;
208 expand_expr_stmt (build (INIT_EXPR, type, decl, e));
210 else if (TREE_CODE (type) == REFERENCE_TYPE)
211 cp_error ("default-initialization of `%#D', which has reference type",
214 init = integer_zero_node;
216 /* member traversal: note it leaves init NULL */
217 else if (TREE_CODE (TREE_TYPE (member)) == REFERENCE_TYPE)
218 cp_pedwarn ("uninitialized reference member `%D'", member);
220 else if (TREE_CODE (init) == TREE_LIST)
222 /* There was an explicit member initialization. Do some
223 work in that case. */
224 if (TREE_CHAIN (init))
226 warning ("initializer list treated as compound expression");
227 init = build_compound_expr (init);
230 init = TREE_VALUE (init);
234 expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
237 expand_end_target_temps ();
240 if (TYPE_NEEDS_DESTRUCTOR (type))
244 /* All cleanups must be on the function_obstack. */
245 push_obstacks_nochange ();
246 resume_temporary_allocation ();
248 expr = build_component_ref (current_class_ref, name, NULL_TREE,
250 expr = build_delete (type, expr, integer_zero_node,
251 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
253 if (expr != error_mark_node)
254 add_partial_entry (expr);
260 extern int warn_reorder;
262 /* Subroutine of emit_member_init. */
268 tree x, member, name, field;
269 tree init_list = NULL_TREE;
271 tree last_field = NULL_TREE;
273 for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member))
277 /* member could be, for example, a CONST_DECL for an enumerated
278 tag; we don't want to try to initialize that, since it already
280 if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
283 for (x = current_member_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
285 /* If we cleared this out, then pay no attention to it. */
286 if (TREE_PURPOSE (x) == NULL_TREE)
288 name = TREE_PURPOSE (x);
290 if (TREE_CODE (name) == IDENTIFIER_NODE)
291 field = IDENTIFIER_CLASS_VALUE (name);
294 my_friendly_assert (TREE_CODE (name) == FIELD_DECL, 348);
298 /* If one member shadows another, get the outermost one. */
299 if (TREE_CODE (field) == TREE_LIST)
300 field = TREE_VALUE (field);
308 cp_warning_at ("member initializers for `%#D'", last_field);
309 cp_warning_at (" and `%#D'", field);
310 warning (" will be re-ordered to match declaration order");
316 /* Make sure we won't try to work on this init again. */
317 TREE_PURPOSE (x) = NULL_TREE;
318 x = build_tree_list (name, TREE_VALUE (x));
323 /* If we didn't find MEMBER in the list, create a dummy entry
324 so the two lists (INIT_LIST and the list of members) will be
326 x = build_tree_list (NULL_TREE, NULL_TREE);
328 init_list = chainon (init_list, x);
331 /* Initializers for base members go at the end. */
332 for (x = current_member_init_list ; x ; x = TREE_CHAIN (x))
334 name = TREE_PURPOSE (x);
337 if (purpose_member (name, init_list))
339 cp_error ("multiple initializations given for member `%D'",
340 IDENTIFIER_CLASS_VALUE (name));
344 init_list = chainon (init_list,
345 build_tree_list (name, TREE_VALUE (x)));
346 TREE_PURPOSE (x) = NULL_TREE;
354 sort_base_init (t, rbase_ptr, vbase_ptr)
355 tree t, *rbase_ptr, *vbase_ptr;
357 tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
358 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
364 /* For warn_reorder. */
366 tree last_base = NULL_TREE;
368 tree rbases = NULL_TREE;
369 tree vbases = NULL_TREE;
371 /* First walk through and splice out vbase and invalid initializers.
372 Also replace names with binfos. */
374 last = tree_cons (NULL_TREE, NULL_TREE, current_base_init_list);
375 for (x = TREE_CHAIN (last); x; x = TREE_CHAIN (x))
377 tree basetype = TREE_PURPOSE (x);
378 tree binfo = NULL_TREE;
380 if (basetype == NULL_TREE)
382 /* Initializer for single base class. Must not
383 use multiple inheritance or this is ambiguous. */
384 switch (n_baseclasses)
387 cp_error ("`%T' does not have a base class to initialize",
393 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
397 binfo = TREE_VEC_ELT (binfos, 0);
399 else if (is_aggr_type (basetype, 1))
401 binfo = binfo_or_else (basetype, t);
402 if (binfo == NULL_TREE)
405 /* Virtual base classes are special cases. Their initializers
406 are recorded with this constructor, and they are used when
407 this constructor is the top-level constructor called. */
408 if (TREE_VIA_VIRTUAL (binfo))
410 tree v = CLASSTYPE_VBASECLASSES (t);
411 while (BINFO_TYPE (v) != BINFO_TYPE (binfo))
414 vbases = tree_cons (v, TREE_VALUE (x), vbases);
419 /* Otherwise, if it is not an immediate base class, complain. */
420 for (i = n_baseclasses-1; i >= 0; i--)
421 if (BINFO_TYPE (binfo) == BINFO_TYPE (TREE_VEC_ELT (binfos, i)))
425 cp_error ("`%T' is not an immediate base class of `%T'",
426 basetype, current_class_type);
432 my_friendly_abort (365);
434 TREE_PURPOSE (x) = binfo;
435 TREE_CHAIN (last) = x;
438 TREE_CHAIN (last) = NULL_TREE;
440 /* Now walk through our regular bases and make sure they're initialized. */
442 for (i = 0; i < n_baseclasses; ++i)
444 tree base_binfo = TREE_VEC_ELT (binfos, i);
447 if (TREE_VIA_VIRTUAL (base_binfo))
450 for (x = current_base_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
452 tree binfo = TREE_PURPOSE (x);
454 if (binfo == NULL_TREE)
457 if (binfo == base_binfo)
463 cp_warning_at ("base initializers for `%#T'", last_base);
464 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo));
465 warning (" will be re-ordered to match inheritance order");
468 last_base = BINFO_TYPE (binfo);
471 /* Make sure we won't try to work on this init again. */
472 TREE_PURPOSE (x) = NULL_TREE;
473 x = build_tree_list (binfo, TREE_VALUE (x));
478 /* If we didn't find BASE_BINFO in the list, create a dummy entry
479 so the two lists (RBASES and the list of bases) will be
481 x = build_tree_list (NULL_TREE, NULL_TREE);
483 rbases = chainon (rbases, x);
490 /* Perform whatever initializations have yet to be done on the base
491 class of the class variable. These actions are in the global
492 variable CURRENT_BASE_INIT_LIST. Such an action could be
493 NULL_TREE, meaning that the user has explicitly called the base
494 class constructor with no arguments.
496 If there is a need for a call to a constructor, we must surround
497 that call with a pushlevel/poplevel pair, since we are technically
498 at the PARM level of scope.
500 Argument IMMEDIATELY, if zero, forces a new sequence to be
501 generated to contain these new insns, so it can be emitted later.
502 This sequence is saved in the global variable BASE_INIT_EXPR.
503 Otherwise, the insns are emitted into the current sequence.
505 Note that emit_base_init does *not* initialize virtual base
506 classes. That is done specially, elsewhere. */
508 extern tree base_init_expr;
511 emit_base_init (t, immediately)
517 tree rbase_init_list, vbase_init_list;
518 tree t_binfo = TYPE_BINFO (t);
519 tree binfos = BINFO_BASETYPES (t_binfo);
520 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
521 tree expr = NULL_TREE;
526 do_pending_stack_adjust ();
527 /* Make the RTL_EXPR node temporary, not momentary,
528 so that rtl_expr_chain doesn't become garbage. */
529 momentary = suspend_momentary ();
530 expr = make_node (RTL_EXPR);
531 resume_momentary (momentary);
532 start_sequence_for_rtl_expr (expr);
535 if (write_symbols == NO_DEBUG)
536 /* As a matter of principle, `start_sequence' should do this. */
539 /* Always emit a line number note so we can step into constructors. */
540 emit_line_note_force (DECL_SOURCE_FILE (current_function_decl),
541 DECL_SOURCE_LINE (current_function_decl));
543 mem_init_list = sort_member_init (t);
544 current_member_init_list = NULL_TREE;
546 sort_base_init (t, &rbase_init_list, &vbase_init_list);
547 current_base_init_list = NULL_TREE;
549 /* First, initialize the virtual base classes, if we are
550 constructing the most-derived object. */
551 if (TYPE_USES_VIRTUAL_BASECLASSES (t))
553 tree first_arg = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
554 construct_virtual_bases (t, current_class_ref, current_class_ptr,
555 vbase_init_list, first_arg);
558 /* Now, perform initialization of non-virtual base classes. */
559 for (i = 0; i < n_baseclasses; i++)
561 tree base_binfo = TREE_VEC_ELT (binfos, i);
562 tree init = void_list_node;
564 if (TREE_VIA_VIRTUAL (base_binfo))
567 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo) == t_binfo,
570 if (TREE_PURPOSE (rbase_init_list))
571 init = TREE_VALUE (rbase_init_list);
572 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo)))
575 if (extra_warnings && copy_args_p (current_function_decl))
576 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
577 BINFO_TYPE (base_binfo));
580 if (init != void_list_node)
582 expand_start_target_temps ();
584 member = convert_pointer_to_real (base_binfo, current_class_ptr);
585 expand_aggr_init_1 (base_binfo, NULL_TREE,
586 build_indirect_ref (member, NULL_PTR), init,
589 expand_end_target_temps ();
593 expand_cleanup_for_base (base_binfo, NULL_TREE);
594 rbase_init_list = TREE_CHAIN (rbase_init_list);
597 /* Initialize all the virtual function table fields that
598 do come from virtual base classes. */
599 if (TYPE_USES_VIRTUAL_BASECLASSES (t))
600 expand_indirect_vtbls_init (t_binfo, current_class_ref, current_class_ptr);
602 /* Initialize all the virtual function table fields that
603 do not come from virtual base classes. */
604 expand_direct_vtbls_init (t_binfo, t_binfo, 1, 1, current_class_ptr);
606 for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
611 /* member could be, for example, a CONST_DECL for an enumerated
612 tag; we don't want to try to initialize that, since it already
614 if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
617 /* See if we had a user-specified member initialization. */
618 if (TREE_PURPOSE (mem_init_list))
620 name = TREE_PURPOSE (mem_init_list);
621 init = TREE_VALUE (mem_init_list);
624 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE
625 || TREE_CODE (name) == FIELD_DECL, 349);
629 name = DECL_NAME (member);
630 init = DECL_INITIAL (member);
634 /* Effective C++ rule 12. */
635 if (warn_ecpp && init == NULL_TREE
636 && !DECL_ARTIFICIAL (member)
637 && TREE_CODE (TREE_TYPE (member)) != ARRAY_TYPE)
638 cp_warning ("`%D' should be initialized in the member initialization list", member);
641 perform_member_init (member, name, init, from_init_list);
642 mem_init_list = TREE_CHAIN (mem_init_list);
645 /* Now initialize any members from our bases. */
646 while (mem_init_list)
648 tree name, init, field;
650 if (TREE_PURPOSE (mem_init_list))
652 name = TREE_PURPOSE (mem_init_list);
653 init = TREE_VALUE (mem_init_list);
655 if (TREE_CODE (name) == IDENTIFIER_NODE)
656 field = IDENTIFIER_CLASS_VALUE (name);
660 /* If one member shadows another, get the outermost one. */
661 if (TREE_CODE (field) == TREE_LIST)
663 field = TREE_VALUE (field);
664 if (decl_type_context (field) != current_class_type)
665 cp_error ("field `%D' not in immediate context", field);
669 /* It turns out if you have an anonymous union in the
670 class, a member from it can end up not being on the
671 list of fields (rather, the type is), and therefore
672 won't be seen by the for loop above. */
674 /* The code in this for loop is derived from a general loop
675 which had this check in it. Theoretically, we've hit
676 every initialization for the list of members in T, so
677 we shouldn't have anything but these left in this list. */
678 my_friendly_assert (DECL_FIELD_CONTEXT (field) != t, 351);
681 perform_member_init (field, name, init, 1);
683 mem_init_list = TREE_CHAIN (mem_init_list);
688 do_pending_stack_adjust ();
689 my_friendly_assert (base_init_expr == 0, 207);
690 base_init_expr = expr;
691 TREE_TYPE (expr) = void_type_node;
692 RTL_EXPR_RTL (expr) = const0_rtx;
693 RTL_EXPR_SEQUENCE (expr) = get_insns ();
694 rtl_expr_chain = tree_cons (NULL_TREE, expr, rtl_expr_chain);
696 TREE_SIDE_EFFECTS (expr) = 1;
699 /* All the implicit try blocks we built up will be zapped
700 when we come to a real binding contour boundary. */
703 /* Check that all fields are properly initialized after
704 an assignment to `this'. Called only when such an assignment
705 is actually noted. */
712 for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
713 if (DECL_NAME (member) && TREE_USED (member))
714 cp_error ("field `%D' used before initialized (after assignment to `this')",
718 /* This code sets up the virtual function tables appropriate for
719 the pointer DECL. It is a one-ply initialization.
721 BINFO is the exact type that DECL is supposed to be. In
722 multiple inheritance, this might mean "C's A" if C : A, B. */
725 expand_virtual_init (binfo, decl)
728 tree type = BINFO_TYPE (binfo);
730 tree vtype, vtype_binfo;
732 /* This code is crusty. Should be simple, like:
733 vtbl = BINFO_VTABLE (binfo);
735 vtype = DECL_CONTEXT (CLASSTYPE_VFIELD (type));
736 vtype_binfo = get_binfo (vtype, TREE_TYPE (TREE_TYPE (decl)), 0);
737 vtbl = BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type)), binfo));
738 assemble_external (vtbl);
739 TREE_USED (vtbl) = 1;
740 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
741 decl = convert_pointer_to_real (vtype_binfo, decl);
742 vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL_PTR), vtype);
743 if (vtbl_ptr == error_mark_node)
746 /* Have to convert VTBL since array sizes may be different. */
747 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
748 expand_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
751 /* If an exception is thrown in a constructor, those base classes already
752 constructed must be destroyed. This function creates the cleanup
753 for BINFO, which has just been constructed. If FLAG is non-NULL,
754 it is a DECL which is non-zero when this base needs to be
758 expand_cleanup_for_base (binfo, flag)
764 if (!TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (binfo)))
767 /* All cleanups must be on the function_obstack. */
768 push_obstacks_nochange ();
769 resume_temporary_allocation ();
771 /* Call the destructor. */
772 expr = (build_scoped_method_call
773 (current_class_ref, binfo, dtor_identifier,
774 build_expr_list (NULL_TREE, integer_zero_node)));
776 expr = fold (build (COND_EXPR, void_type_node,
777 truthvalue_conversion (flag),
778 expr, integer_zero_node));
781 add_partial_entry (expr);
784 /* Subroutine of `expand_aggr_vbase_init'.
785 BINFO is the binfo of the type that is being initialized.
786 INIT_LIST is the list of initializers for the virtual baseclass. */
789 expand_aggr_vbase_init_1 (binfo, exp, addr, init_list)
790 tree binfo, exp, addr, init_list;
792 tree init = purpose_member (binfo, init_list);
793 tree ref = build_indirect_ref (addr, NULL_PTR);
795 expand_start_target_temps ();
798 init = TREE_VALUE (init);
799 /* Call constructors, but don't set up vtables. */
800 expand_aggr_init_1 (binfo, exp, ref, init, LOOKUP_COMPLAIN);
802 expand_end_target_temps ();
806 /* Construct the virtual base-classes of THIS_REF (whose address is
807 THIS_PTR). The object has the indicated TYPE. The construction
808 actually takes place only if FLAG is non-zero. INIT_LIST is list
809 of initialization for constructor to perform. */
812 construct_virtual_bases (type, this_ref, this_ptr, init_list, flag)
822 /* If there are no virtual baseclasses, we shouldn't even be here. */
823 my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type), 19990621);
825 /* First set the pointers in our object that tell us where to find
826 our virtual baseclasses. */
827 expand_start_cond (flag, 0);
828 result = init_vbase_pointers (type, this_ptr);
830 expand_expr_stmt (build_compound_expr (result));
833 /* Now, run through the baseclasses, initializing each. */
834 for (vbases = CLASSTYPE_VBASECLASSES (type); vbases;
835 vbases = TREE_CHAIN (vbases))
837 tree tmp = purpose_member (vbases, result);
839 /* If there are virtual base classes with destructors, we need to
840 emit cleanups to destroy them if an exception is thrown during
841 the construction process. These exception regions (i.e., the
842 period during which the cleanups must occur) begin from the time
843 the construction is complete to the end of the function. If we
844 create a conditional block in which to initialize the
845 base-classes, then the cleanup region for the virtual base begins
846 inside a block, and ends outside of that block. This situation
847 confuses the sjlj exception-handling code. Therefore, we do not
848 create a single conditional block, but one for each
849 initialization. (That way the cleanup regions always begin
850 in the outer block.) We trust the back-end to figure out
851 that the FLAG will not change across initializations, and
852 avoid doing multiple tests. */
853 expand_start_cond (flag, 0);
854 expand_aggr_vbase_init_1 (vbases, this_ref,
855 TREE_OPERAND (TREE_VALUE (tmp), 0),
859 expand_cleanup_for_base (vbases, flag);
863 /* Find the context in which this FIELD can be initialized. */
866 initializing_context (field)
869 tree t = DECL_CONTEXT (field);
871 /* Anonymous union members can be initialized in the first enclosing
872 non-anonymous union context. */
873 while (t && ANON_AGGR_TYPE_P (t))
874 t = TYPE_CONTEXT (t);
878 /* Function to give error message if member initialization specification
879 is erroneous. FIELD is the member we decided to initialize.
880 TYPE is the type for which the initialization is being performed.
881 FIELD must be a member of TYPE.
883 MEMBER_NAME is the name of the member. */
886 member_init_ok_or_else (field, type, member_name)
889 const char *member_name;
891 if (field == error_mark_node)
893 if (field == NULL_TREE || initializing_context (field) != type)
895 cp_error ("class `%T' does not have any field named `%s'", type,
899 if (TREE_STATIC (field))
901 cp_error ("field `%#D' is static; only point of initialization is its declaration",
909 /* If NAME is a viable field name for the aggregate DECL,
910 and PARMS is a viable parameter list, then expand an _EXPR
911 which describes this initialization.
913 Note that we do not need to chase through the class's base classes
914 to look for NAME, because if it's in that list, it will be handled
915 by the constructor for that base class.
917 We do not yet have a fixed-point finder to instantiate types
918 being fed to overloaded constructors. If there is a unique
919 constructor, then argument types can be got from that one.
921 If INIT is non-NULL, then it the initialization should
922 be placed in `current_base_init_list', where it will be processed
923 by `emit_base_init'. */
926 expand_member_init (exp, name, init)
927 tree exp, name, init;
929 tree basetype = NULL_TREE, field;
932 if (exp == NULL_TREE)
933 return; /* complain about this later */
935 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
937 if (name && TREE_CODE (name) == TYPE_DECL)
939 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
940 name = DECL_NAME (name);
943 if (name == NULL_TREE && IS_AGGR_TYPE (type))
944 switch (CLASSTYPE_N_BASECLASSES (type))
947 error ("base class initializer specified, but no base class to initialize");
950 basetype = TYPE_BINFO_BASETYPE (type, 0);
953 error ("initializer for unnamed base class ambiguous");
954 cp_error ("(type `%T' uses multiple inheritance)", type);
958 my_friendly_assert (init != NULL_TREE, 0);
960 /* The grammar should not allow fields which have names that are
961 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
962 may assume that this is an attempt to initialize a base class
963 member of the current type. Otherwise, it is an attempt to
964 initialize a member field. */
966 if (init == void_type_node)
969 if (name == NULL_TREE || basetype)
973 if (name == NULL_TREE)
977 name = TYPE_IDENTIFIER (basetype);
980 error ("no base class to initialize");
985 else if (basetype != type
986 && ! current_template_parms
987 && ! vec_binfo_member (basetype,
988 TYPE_BINFO_BASETYPES (type))
989 && ! binfo_member (basetype, CLASSTYPE_VBASECLASSES (type)))
991 if (IDENTIFIER_CLASS_VALUE (name))
993 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
994 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
997 cp_error ("type `%T' is not an immediate basetype for `%T'",
1002 if (purpose_member (basetype, current_base_init_list))
1004 cp_error ("base class `%T' already initialized", basetype);
1008 if (warn_reorder && current_member_init_list)
1010 cp_warning ("base initializer for `%T'", basetype);
1011 warning (" will be re-ordered to precede member initializations");
1014 base_init = build_tree_list (basetype, init);
1015 current_base_init_list = chainon (current_base_init_list, base_init);
1022 field = lookup_field (type, name, 1, 0);
1024 if (! member_init_ok_or_else (field, type, IDENTIFIER_POINTER (name)))
1027 if (purpose_member (name, current_member_init_list))
1029 cp_error ("field `%D' already initialized", field);
1033 member_init = build_tree_list (name, init);
1034 current_member_init_list = chainon (current_member_init_list, member_init);
1038 /* This is like `expand_member_init', only it stores one aggregate
1041 INIT comes in two flavors: it is either a value which
1042 is to be stored in EXP, or it is a parameter list
1043 to go to a constructor, which will operate on EXP.
1044 If INIT is not a parameter list for a constructor, then set
1045 LOOKUP_ONLYCONVERTING.
1046 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1047 the initializer, if FLAGS is 0, then it is the (init) form.
1048 If `init' is a CONSTRUCTOR, then we emit a warning message,
1049 explaining that such initializations are invalid.
1051 ALIAS_THIS is nonzero iff we are initializing something which is
1052 essentially an alias for current_class_ref. In this case, the base
1053 constructor may move it on us, and we must keep track of such
1056 If INIT resolves to a CALL_EXPR which happens to return
1057 something of the type we are looking for, then we know
1058 that we can safely use that call to perform the
1061 The virtual function table pointer cannot be set up here, because
1062 we do not really know its type.
1064 Virtual baseclass pointers are also set up here.
1066 This never calls operator=().
1068 When initializing, nothing is CONST.
1070 A default copy constructor may have to be used to perform the
1073 A constructor or a conversion operator may have to be used to
1074 perform the initialization, but not both, as it would be ambiguous. */
1077 expand_aggr_init (exp, init, flags)
1081 tree type = TREE_TYPE (exp);
1082 int was_const = TREE_READONLY (exp);
1083 int was_volatile = TREE_THIS_VOLATILE (exp);
1085 if (init == error_mark_node)
1088 TREE_READONLY (exp) = 0;
1089 TREE_THIS_VOLATILE (exp) = 0;
1091 if (init && TREE_CODE (init) != TREE_LIST)
1092 flags |= LOOKUP_ONLYCONVERTING;
1094 if (TREE_CODE (type) == ARRAY_TYPE)
1096 /* Must arrange to initialize each element of EXP
1097 from elements of INIT. */
1098 tree itype = init ? TREE_TYPE (init) : NULL_TREE;
1099 if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
1101 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1103 TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1105 if (init && TREE_TYPE (init) == NULL_TREE)
1107 /* Handle bad initializers like:
1111 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1115 int main(int argc, char **argv) {
1116 COMPLEX zees(1.0, 0.0)[10];
1119 error ("bad array initializer");
1122 expand_vec_init (exp, exp, array_type_nelts (type), init,
1123 init && same_type_p (TREE_TYPE (init),
1125 TREE_READONLY (exp) = was_const;
1126 TREE_THIS_VOLATILE (exp) = was_volatile;
1127 TREE_TYPE (exp) = type;
1129 TREE_TYPE (init) = itype;
1133 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1134 /* just know that we've seen something for this node */
1135 TREE_USED (exp) = 1;
1138 /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1139 constructor as parameters to an implicit GNU C++ constructor. */
1140 if (init && TREE_CODE (init) == CONSTRUCTOR
1141 && TYPE_HAS_CONSTRUCTOR (type)
1142 && TREE_TYPE (init) == type)
1143 init = CONSTRUCTOR_ELTS (init);
1146 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1147 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1148 init, LOOKUP_NORMAL|flags);
1149 TREE_TYPE (exp) = type;
1150 TREE_READONLY (exp) = was_const;
1151 TREE_THIS_VOLATILE (exp) = was_volatile;
1155 expand_default_init (binfo, true_exp, exp, init, flags)
1161 tree type = TREE_TYPE (exp);
1163 /* It fails because there may not be a constructor which takes
1164 its own type as the first (or only parameter), but which does
1165 take other types via a conversion. So, if the thing initializing
1166 the expression is a unit element of type X, first try X(X&),
1167 followed by initialization by X. If neither of these work
1168 out, then look hard. */
1172 if (init && TREE_CODE (init) != TREE_LIST
1173 && (flags & LOOKUP_ONLYCONVERTING))
1175 /* Base subobjects should only get direct-initialization. */
1176 if (true_exp != exp)
1179 if (flags & DIRECT_BIND)
1180 /* Do nothing. We hit this in two cases: Reference initialization,
1181 where we aren't initializing a real variable, so we don't want
1182 to run a new constructor; and catching an exception, where we
1183 have already built up the constructor call so we could wrap it
1184 in an exception region. */;
1185 else if (TREE_CODE (init) == CONSTRUCTOR)
1186 /* A brace-enclosed initializer has whatever type is
1187 required. There's no need to convert it. */
1190 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1192 if (TREE_CODE (init) == TRY_CATCH_EXPR)
1193 /* We need to protect the initialization of a catch parm
1194 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1195 around the TARGET_EXPR for the copy constructor. See
1196 expand_start_catch_block. */
1197 TREE_OPERAND (init, 0) = build (INIT_EXPR, TREE_TYPE (exp), exp,
1198 TREE_OPERAND (init, 0));
1200 init = build (INIT_EXPR, TREE_TYPE (exp), exp, init);
1201 TREE_SIDE_EFFECTS (init) = 1;
1202 expand_expr_stmt (init);
1206 if (init == NULL_TREE
1207 || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1211 init = TREE_VALUE (parms);
1214 parms = build_expr_list (NULL_TREE, init);
1216 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
1218 if (true_exp == exp)
1219 parms = expr_tree_cons (NULL_TREE, integer_one_node, parms);
1221 parms = expr_tree_cons (NULL_TREE, integer_zero_node, parms);
1222 flags |= LOOKUP_HAS_IN_CHARGE;
1225 rval = build_method_call (exp, ctor_identifier,
1226 parms, binfo, flags);
1227 if (TREE_SIDE_EFFECTS (rval))
1228 expand_expr_stmt (rval);
1231 /* This function is responsible for initializing EXP with INIT
1234 BINFO is the binfo of the type for who we are performing the
1235 initialization. For example, if W is a virtual base class of A and B,
1237 If we are initializing B, then W must contain B's W vtable, whereas
1238 were we initializing C, W must contain C's W vtable.
1240 TRUE_EXP is nonzero if it is the true expression being initialized.
1241 In this case, it may be EXP, or may just contain EXP. The reason we
1242 need this is because if EXP is a base element of TRUE_EXP, we
1243 don't necessarily know by looking at EXP where its virtual
1244 baseclass fields should really be pointing. But we do know
1245 from TRUE_EXP. In constructors, we don't know anything about
1246 the value being initialized.
1248 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1250 FLAGS is just passes to `build_method_call'. See that function for
1254 expand_aggr_init_1 (binfo, true_exp, exp, init, flags)
1260 tree type = TREE_TYPE (exp);
1262 my_friendly_assert (init != error_mark_node && type != error_mark_node, 211);
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 tree t = store_init_value (exp, init);
1277 expand_decl_init (exp);
1280 t = build (INIT_EXPR, type, exp, init);
1281 TREE_SIDE_EFFECTS (t) = 1;
1282 expand_expr_stmt (t);
1286 /* We know that expand_default_init can handle everything we want
1288 expand_default_init (binfo, true_exp, exp, init, flags);
1291 /* Report an error if NAME is not the name of a user-defined,
1292 aggregate type. If OR_ELSE is nonzero, give an error message. */
1295 is_aggr_typedef (name, or_else)
1301 if (name == error_mark_node)
1304 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1305 type = IDENTIFIER_TYPE_VALUE (name);
1309 cp_error ("`%T' is not an aggregate typedef", name);
1313 if (! IS_AGGR_TYPE (type)
1314 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1315 && TREE_CODE (type) != TEMPLATE_TEMPLATE_PARM)
1318 cp_error ("`%T' is not an aggregate type", type);
1324 /* Report an error if TYPE is not a user-defined, aggregate type. If
1325 OR_ELSE is nonzero, give an error message. */
1328 is_aggr_type (type, or_else)
1332 if (type == error_mark_node)
1335 if (! IS_AGGR_TYPE (type)
1336 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1337 && TREE_CODE (type) != TEMPLATE_TEMPLATE_PARM)
1340 cp_error ("`%T' is not an aggregate type", type);
1346 /* Like is_aggr_typedef, but returns typedef if successful. */
1349 get_aggr_from_typedef (name, or_else)
1355 if (name == error_mark_node)
1358 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1359 type = IDENTIFIER_TYPE_VALUE (name);
1363 cp_error ("`%T' fails to be an aggregate typedef", name);
1367 if (! IS_AGGR_TYPE (type)
1368 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1369 && TREE_CODE (type) != TEMPLATE_TEMPLATE_PARM)
1372 cp_error ("type `%T' is of non-aggregate type", type);
1379 get_type_value (name)
1382 if (name == error_mark_node)
1385 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1386 return IDENTIFIER_TYPE_VALUE (name);
1392 /* This code could just as well go in `class.c', but is placed here for
1395 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1396 the appropriate function call. */
1399 build_member_call (type, name, parmlist)
1400 tree type, name, parmlist;
1405 tree basetype_path, decl;
1407 if (TREE_CODE (name) == TEMPLATE_ID_EXPR
1408 && TREE_CODE (type) == NAMESPACE_DECL)
1410 /* 'name' already refers to the decls from the namespace, since we
1411 hit do_identifier for template_ids. */
1412 method_name = TREE_OPERAND (name, 0);
1413 /* FIXME: Since we don't do independent names right yet, the
1414 name might also be a LOOKUP_EXPR. Once we resolve this to a
1415 real decl earlier, this can go. This may happen during
1417 if (TREE_CODE (method_name) == LOOKUP_EXPR)
1419 method_name = lookup_namespace_name
1420 (type, TREE_OPERAND (method_name, 0));
1421 TREE_OPERAND (name, 0) = method_name;
1423 my_friendly_assert (is_overloaded_fn (method_name), 980519);
1424 return build_x_function_call (name, parmlist, current_class_ref);
1427 if (type == std_node)
1428 return build_x_function_call (do_scoped_id (name, 0), parmlist,
1430 if (TREE_CODE (type) == NAMESPACE_DECL)
1431 return build_x_function_call (lookup_namespace_name (type, name),
1432 parmlist, current_class_ref);
1434 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1436 method_name = TREE_OPERAND (name, 0);
1437 if (TREE_CODE (method_name) == COMPONENT_REF)
1438 method_name = TREE_OPERAND (method_name, 1);
1439 if (is_overloaded_fn (method_name))
1440 method_name = DECL_NAME (OVL_CURRENT (method_name));
1441 TREE_OPERAND (name, 0) = method_name;
1446 if (TREE_CODE (method_name) == BIT_NOT_EXPR)
1448 method_name = TREE_OPERAND (method_name, 0);
1452 /* This shouldn't be here, and build_member_call shouldn't appear in
1454 if (type && TREE_CODE (type) == IDENTIFIER_NODE
1455 && get_aggr_from_typedef (type, 0) == 0)
1457 tree ns = lookup_name (type, 0);
1458 if (ns && TREE_CODE (ns) == NAMESPACE_DECL)
1460 return build_x_function_call (build_offset_ref (type, name), parmlist, current_class_ref);
1464 if (type == NULL_TREE || ! is_aggr_type (type, 1))
1465 return error_mark_node;
1467 /* An operator we did not like. */
1468 if (name == NULL_TREE)
1469 return error_mark_node;
1473 cp_error ("cannot call destructor `%T::~%T' without object", type,
1475 return error_mark_node;
1478 decl = maybe_dummy_object (type, &basetype_path);
1480 /* Convert 'this' to the specified type to disambiguate conversion
1481 to the function's context. Apparently Standard C++ says that we
1482 shouldn't do this. */
1483 if (decl == current_class_ref
1485 && ACCESSIBLY_UNIQUELY_DERIVED_P (type, current_class_type))
1487 tree olddecl = current_class_ptr;
1488 tree oldtype = TREE_TYPE (TREE_TYPE (olddecl));
1489 if (oldtype != type)
1491 tree newtype = build_qualified_type (type, TYPE_QUALS (oldtype));
1492 decl = convert_force (build_pointer_type (newtype), olddecl, 0);
1493 decl = build_indirect_ref (decl, NULL_PTR);
1497 if (method_name == constructor_name (type)
1498 || method_name == constructor_name_full (type))
1499 return build_functional_cast (type, parmlist);
1500 if (lookup_fnfields (basetype_path, method_name, 0))
1501 return build_method_call (decl,
1502 TREE_CODE (name) == TEMPLATE_ID_EXPR
1503 ? name : method_name,
1504 parmlist, basetype_path,
1505 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
1506 if (TREE_CODE (name) == IDENTIFIER_NODE
1507 && ((t = lookup_field (TYPE_BINFO (type), name, 1, 0))))
1509 if (t == error_mark_node)
1510 return error_mark_node;
1511 if (TREE_CODE (t) == FIELD_DECL)
1513 if (is_dummy_object (decl))
1515 cp_error ("invalid use of non-static field `%D'", t);
1516 return error_mark_node;
1518 decl = build (COMPONENT_REF, TREE_TYPE (t), decl, t);
1520 else if (TREE_CODE (t) == VAR_DECL)
1524 cp_error ("invalid use of member `%D'", t);
1525 return error_mark_node;
1527 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl)))
1528 return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl,
1529 parmlist, NULL_TREE);
1530 return build_function_call (decl, parmlist);
1534 cp_error ("no method `%T::%D'", type, name);
1535 return error_mark_node;
1539 /* Build a reference to a member of an aggregate. This is not a
1540 C++ `&', but really something which can have its address taken,
1541 and then act as a pointer to member, for example TYPE :: FIELD
1542 can have its address taken by saying & TYPE :: FIELD.
1544 @@ Prints out lousy diagnostics for operator <typename>
1547 @@ This function should be rewritten and placed in search.c. */
1550 build_offset_ref (type, name)
1553 tree decl, t = error_mark_node;
1555 tree basebinfo = NULL_TREE;
1556 tree orig_name = name;
1558 /* class templates can come in as TEMPLATE_DECLs here. */
1559 if (TREE_CODE (name) == TEMPLATE_DECL)
1562 if (type == std_node)
1563 return do_scoped_id (name, 0);
1565 if (processing_template_decl || uses_template_parms (type))
1566 return build_min_nt (SCOPE_REF, type, name);
1568 /* Handle namespace names fully here. */
1569 if (TREE_CODE (type) == NAMESPACE_DECL)
1571 t = lookup_namespace_name (type, name);
1572 if (t != error_mark_node && ! type_unknown_p (t))
1575 t = convert_from_reference (t);
1580 if (type == NULL_TREE || ! is_aggr_type (type, 1))
1581 return error_mark_node;
1583 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1585 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1586 something like `a.template f<int>' or the like. For the most
1587 part, we treat this just like a.f. We do remember, however,
1588 the template-id that was used. */
1589 name = TREE_OPERAND (orig_name, 0);
1591 if (TREE_CODE (name) == LOOKUP_EXPR)
1592 /* This can happen during tsubst'ing. */
1593 name = TREE_OPERAND (name, 0);
1595 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
1598 if (TREE_CODE (name) == BIT_NOT_EXPR)
1600 if (! check_dtor_name (type, name))
1601 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1602 type, TREE_OPERAND (name, 0));
1603 name = dtor_identifier;
1606 /* I think this is wrong, but the draft is unclear. --jason 6/15/98 */
1607 else if (name == constructor_name_full (type)
1608 || name == constructor_name (type))
1609 name = ctor_identifier;
1612 if (TYPE_SIZE (complete_type (type)) == 0
1613 && !TYPE_BEING_DEFINED (type))
1615 cp_error ("incomplete type `%T' does not have member `%D'", type,
1617 return error_mark_node;
1620 decl = maybe_dummy_object (type, &basebinfo);
1622 member = lookup_member (basebinfo, name, 1, 0);
1624 if (member == error_mark_node)
1625 return error_mark_node;
1627 /* A lot of this logic is now handled in lookup_field and
1629 if (member && BASELINK_P (member))
1631 /* Go from the TREE_BASELINK to the member function info. */
1632 tree fnfields = member;
1633 t = TREE_VALUE (fnfields);
1635 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1637 /* The FNFIELDS are going to contain functions that aren't
1638 necessarily templates, and templates that don't
1639 necessarily match the explicit template parameters. We
1640 save all the functions, and the explicit parameters, and
1641 then figure out exactly what to instantiate with what
1642 arguments in instantiate_type. */
1644 if (TREE_CODE (t) != OVERLOAD)
1645 /* The code in instantiate_type which will process this
1646 expects to encounter OVERLOADs, not raw functions. */
1647 t = ovl_cons (t, NULL_TREE);
1649 return build (OFFSET_REF,
1652 build (TEMPLATE_ID_EXPR,
1655 TREE_OPERAND (orig_name, 1)));
1658 if (!really_overloaded_fn (t))
1660 /* Get rid of a potential OVERLOAD around it */
1661 t = OVL_CURRENT (t);
1663 /* unique functions are handled easily. */
1664 basebinfo = TREE_PURPOSE (fnfields);
1665 if (!enforce_access (basebinfo, t))
1666 return error_mark_node;
1668 if (DECL_STATIC_FUNCTION_P (t))
1670 return build (OFFSET_REF, TREE_TYPE (t), decl, t);
1673 /* FNFIELDS is most likely allocated on the search_obstack,
1674 which will go away after this class scope. If we need
1675 to save this value for later (i.e. for use as an initializer
1676 for a static variable), then do so here.
1678 ??? The smart thing to do for the case of saving initializers
1679 is to resolve them before we're done with this scope. */
1680 if (!TREE_PERMANENT (fnfields)
1681 && ! allocation_temporary_p ())
1682 fnfields = copy_list (fnfields);
1684 TREE_TYPE (fnfields) = unknown_type_node;
1685 return build (OFFSET_REF, unknown_type_node, decl, fnfields);
1692 cp_error ("`%D' is not a member of type `%T'", name, type);
1693 return error_mark_node;
1696 if (TREE_CODE (t) == TYPE_DECL)
1701 /* static class members and class-specific enum
1702 values can be returned without further ado. */
1703 if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == CONST_DECL)
1706 return convert_from_reference (t);
1709 if (TREE_CODE (t) == FIELD_DECL && DECL_C_BIT_FIELD (t))
1711 cp_error ("illegal pointer to bit field `%D'", t);
1712 return error_mark_node;
1715 /* static class functions too. */
1716 if (TREE_CODE (t) == FUNCTION_DECL
1717 && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1718 my_friendly_abort (53);
1720 /* In member functions, the form `type::name' is no longer
1721 equivalent to `this->type::name', at least not until
1722 resolve_offset_ref. */
1723 return build (OFFSET_REF, build_offset_type (type, TREE_TYPE (t)), decl, t);
1726 /* If a OFFSET_REF made it through to here, then it did
1727 not have its address taken. */
1730 resolve_offset_ref (exp)
1733 tree type = TREE_TYPE (exp);
1734 tree base = NULL_TREE;
1736 tree basetype, addr;
1738 if (TREE_CODE (exp) == OFFSET_REF)
1740 member = TREE_OPERAND (exp, 1);
1741 base = TREE_OPERAND (exp, 0);
1745 my_friendly_assert (TREE_CODE (type) == OFFSET_TYPE, 214);
1746 if (TYPE_OFFSET_BASETYPE (type) != current_class_type)
1748 error ("object missing in use of pointer-to-member construct");
1749 return error_mark_node;
1752 type = TREE_TYPE (type);
1753 base = current_class_ref;
1756 if (BASELINK_P (member))
1758 if (! flag_ms_extensions)
1759 cp_pedwarn ("assuming & on overloaded member function");
1760 return build_unary_op (ADDR_EXPR, exp, 0);
1763 if (TREE_CODE (TREE_TYPE (member)) == METHOD_TYPE)
1765 if (! flag_ms_extensions)
1766 cp_pedwarn ("assuming & on `%E'", member);
1767 return build_unary_op (ADDR_EXPR, exp, 0);
1770 if ((TREE_CODE (member) == VAR_DECL
1771 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member))
1772 && ! TYPE_PTRMEM_P (TREE_TYPE (member)))
1773 || TREE_CODE (TREE_TYPE (member)) == FUNCTION_TYPE)
1775 /* These were static members. */
1776 if (mark_addressable (member) == 0)
1777 return error_mark_node;
1781 if (TREE_CODE (TREE_TYPE (member)) == POINTER_TYPE
1782 && TREE_CODE (TREE_TYPE (TREE_TYPE (member))) == METHOD_TYPE)
1785 /* Syntax error can cause a member which should
1786 have been seen as static to be grok'd as non-static. */
1787 if (TREE_CODE (member) == FIELD_DECL && current_class_ref == NULL_TREE)
1789 if (TREE_ADDRESSABLE (member) == 0)
1791 cp_error_at ("member `%D' is non-static but referenced as a static member",
1793 error ("at this point in file");
1794 TREE_ADDRESSABLE (member) = 1;
1796 return error_mark_node;
1799 /* The first case is really just a reference to a member of `this'. */
1800 if (TREE_CODE (member) == FIELD_DECL
1801 && (base == current_class_ref || is_dummy_object (base)))
1806 if (TREE_CODE (exp) == OFFSET_REF && TREE_CODE (type) == OFFSET_TYPE)
1807 basetype = TYPE_OFFSET_BASETYPE (type);
1809 basetype = DECL_CONTEXT (member);
1811 base = current_class_ptr;
1813 if (get_base_distance (basetype, TREE_TYPE (TREE_TYPE (base)), 0, &basetype_path) < 0)
1815 error_not_base_type (basetype, TREE_TYPE (TREE_TYPE (base)));
1816 return error_mark_node;
1818 /* Kludge: we need to use basetype_path now, because
1819 convert_pointer_to will bash it. */
1820 enforce_access (basetype_path, member);
1821 addr = convert_pointer_to (basetype, base);
1823 /* Even in the case of illegal access, we form the
1824 COMPONENT_REF; that will allow better error recovery than
1825 just feeding back error_mark_node. */
1826 expr = build (COMPONENT_REF, TREE_TYPE (member),
1827 build_indirect_ref (addr, NULL_PTR), member);
1828 return convert_from_reference (expr);
1831 /* Ensure that we have an object. */
1832 if (is_dummy_object (base))
1833 addr = error_mark_node;
1835 /* If this is a reference to a member function, then return the
1836 address of the member function (which may involve going
1837 through the object's vtable), otherwise, return an expression
1838 for the dereferenced pointer-to-member construct. */
1839 addr = build_unary_op (ADDR_EXPR, base, 0);
1841 if (TYPE_PTRMEM_P (TREE_TYPE (member)))
1843 if (addr == error_mark_node)
1845 cp_error ("object missing in `%E'", exp);
1846 return error_mark_node;
1849 basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member)));
1850 addr = convert_pointer_to (basetype, addr);
1851 member = cp_convert (ptrdiff_type_node, member);
1853 /* Pointer to data members are offset by one, so that a null
1854 pointer with a real value of 0 is distinguishable from an
1855 offset of the first member of a structure. */
1856 member = build_binary_op (MINUS_EXPR, member,
1857 cp_convert (ptrdiff_type_node, integer_one_node));
1859 return build1 (INDIRECT_REF, type,
1860 build (PLUS_EXPR, build_pointer_type (type),
1863 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
1865 return get_member_function_from_ptrfunc (&addr, member);
1867 my_friendly_abort (56);
1872 /* Return either DECL or its known constant value (if it has one). */
1875 decl_constant_value (decl)
1878 if (! TREE_THIS_VOLATILE (decl)
1879 && DECL_INITIAL (decl)
1880 && DECL_INITIAL (decl) != error_mark_node
1881 /* This is invalid if initial value is not constant.
1882 If it has either a function call, a memory reference,
1883 or a variable, then re-evaluating it could give different results. */
1884 && TREE_CONSTANT (DECL_INITIAL (decl))
1885 /* Check for cases where this is sub-optimal, even though valid. */
1886 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1887 return DECL_INITIAL (decl);
1891 /* Common subroutines of build_new and build_vec_delete. */
1893 /* Call the global __builtin_delete to delete ADDR. */
1896 build_builtin_delete_call (addr)
1899 mark_used (global_delete_fndecl);
1900 return build_call (global_delete_fndecl,
1901 void_type_node, build_expr_list (NULL_TREE, addr));
1904 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1905 (which needs to go through some sort of groktypename) or it
1906 is the name of the class we are newing. INIT is an initialization value.
1907 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1908 If INIT is void_type_node, it means do *not* call a constructor
1911 For types with constructors, the data returned is initialized
1912 by the appropriate constructor.
1914 Whether the type has a constructor or not, if it has a pointer
1915 to a virtual function table, then that pointer is set up
1918 Unless I am mistaken, a call to new () will return initialized
1919 data regardless of whether the constructor itself is private or
1920 not. NOPE; new fails if the constructor is private (jcm).
1922 Note that build_new does nothing to assure that any special
1923 alignment requirements of the type are met. Rather, it leaves
1924 it up to malloc to do the right thing. Otherwise, folding to
1925 the right alignment cal cause problems if the user tries to later
1926 free the memory returned by `new'.
1928 PLACEMENT is the `placement' list for user-defined operator new (). */
1930 extern int flag_check_new;
1933 build_new (placement, decl, init, use_global_new)
1939 tree nelts = NULL_TREE, t;
1942 tree pending_sizes = NULL_TREE;
1944 if (decl == error_mark_node)
1945 return error_mark_node;
1947 if (TREE_CODE (decl) == TREE_LIST)
1949 tree absdcl = TREE_VALUE (decl);
1950 tree last_absdcl = NULL_TREE;
1951 int old_immediate_size_expand = 0;
1953 if (current_function_decl
1954 && DECL_CONSTRUCTOR_P (current_function_decl))
1956 old_immediate_size_expand = immediate_size_expand;
1957 immediate_size_expand = 0;
1960 nelts = integer_one_node;
1962 if (absdcl && TREE_CODE (absdcl) == CALL_EXPR)
1963 my_friendly_abort (215);
1964 while (absdcl && TREE_CODE (absdcl) == INDIRECT_REF)
1966 last_absdcl = absdcl;
1967 absdcl = TREE_OPERAND (absdcl, 0);
1970 if (absdcl && TREE_CODE (absdcl) == ARRAY_REF)
1972 /* probably meant to be a vec new */
1975 while (TREE_OPERAND (absdcl, 0)
1976 && TREE_CODE (TREE_OPERAND (absdcl, 0)) == ARRAY_REF)
1978 last_absdcl = absdcl;
1979 absdcl = TREE_OPERAND (absdcl, 0);
1983 this_nelts = TREE_OPERAND (absdcl, 1);
1984 if (this_nelts != error_mark_node)
1986 if (this_nelts == NULL_TREE)
1987 error ("new of array type fails to specify size");
1988 else if (processing_template_decl)
1991 absdcl = TREE_OPERAND (absdcl, 0);
1995 int flags = pedantic ? WANT_INT : (WANT_INT | WANT_ENUM);
1996 if (build_expr_type_conversion (flags, this_nelts, 0)
1998 pedwarn ("size in array new must have integral type");
2000 this_nelts = save_expr (cp_convert (sizetype, this_nelts));
2001 absdcl = TREE_OPERAND (absdcl, 0);
2002 if (this_nelts == integer_zero_node)
2004 warning ("zero size array reserves no space");
2005 nelts = integer_zero_node;
2008 nelts = build_binary_op (MULT_EXPR, nelts, this_nelts);
2012 nelts = integer_zero_node;
2016 TREE_OPERAND (last_absdcl, 0) = absdcl;
2018 TREE_VALUE (decl) = absdcl;
2020 type = groktypename (decl);
2021 if (! type || type == error_mark_node)
2023 immediate_size_expand = old_immediate_size_expand;
2024 return error_mark_node;
2027 if (current_function_decl
2028 && DECL_CONSTRUCTOR_P (current_function_decl))
2030 pending_sizes = get_pending_sizes ();
2031 immediate_size_expand = old_immediate_size_expand;
2034 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
2036 if (IDENTIFIER_HAS_TYPE_VALUE (decl))
2038 /* An aggregate type. */
2039 type = IDENTIFIER_TYPE_VALUE (decl);
2040 decl = TYPE_MAIN_DECL (type);
2044 /* A builtin type. */
2045 decl = lookup_name (decl, 1);
2046 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 215);
2047 type = TREE_TYPE (decl);
2050 else if (TREE_CODE (decl) == TYPE_DECL)
2052 type = TREE_TYPE (decl);
2057 decl = TYPE_MAIN_DECL (type);
2060 if (processing_template_decl)
2063 t = min_tree_cons (min_tree_cons (NULL_TREE, type, NULL_TREE),
2064 build_min_nt (ARRAY_REF, NULL_TREE, nelts),
2069 rval = build_min_nt (NEW_EXPR, placement, t, init);
2070 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
2074 /* ``A reference cannot be created by the new operator. A reference
2075 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2076 returned by new.'' ARM 5.3.3 */
2077 if (TREE_CODE (type) == REFERENCE_TYPE)
2079 error ("new cannot be applied to a reference type");
2080 type = TREE_TYPE (type);
2083 if (TREE_CODE (type) == FUNCTION_TYPE)
2085 error ("new cannot be applied to a function type");
2086 return error_mark_node;
2089 /* When the object being created is an array, the new-expression yields a
2090 pointer to the initial element (if any) of the array. For example,
2091 both new int and new int[10] return an int*. 5.3.4. */
2092 if (TREE_CODE (type) == ARRAY_TYPE && has_array == 0)
2094 nelts = array_type_nelts_top (type);
2096 type = TREE_TYPE (type);
2100 t = build_nt (ARRAY_REF, type, nelts);
2104 rval = build (NEW_EXPR, build_pointer_type (type), placement, t, init);
2105 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
2106 TREE_SIDE_EFFECTS (rval) = 1;
2108 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2109 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2110 TREE_NO_UNUSED_WARNING (rval) = 1;
2113 rval = build_compound_expr (chainon (pending_sizes,
2114 build_expr_list (NULL_TREE, rval)));
2119 /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */
2121 static tree jclass_node = NULL_TREE;
2123 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2126 build_java_class_ref (type)
2129 tree name, class_decl;
2130 static tree CL_prefix = NULL_TREE;
2131 if (CL_prefix == NULL_TREE)
2132 CL_prefix = get_identifier("_CL_");
2133 if (jclass_node == NULL_TREE)
2135 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2136 if (jclass_node == NULL_TREE)
2137 fatal("call to Java constructor, while `jclass' undefined");
2138 jclass_node = TREE_TYPE (jclass_node);
2140 name = build_overload_with_type (CL_prefix, type);
2141 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2142 if (class_decl == NULL_TREE)
2144 push_obstacks_nochange ();
2145 end_temporary_allocation ();
2146 class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
2147 TREE_STATIC (class_decl) = 1;
2148 DECL_EXTERNAL (class_decl) = 1;
2149 TREE_PUBLIC (class_decl) = 1;
2150 DECL_ARTIFICIAL (class_decl) = 1;
2151 DECL_IGNORED_P (class_decl) = 1;
2152 pushdecl_top_level (class_decl);
2153 make_decl_rtl (class_decl, NULL_PTR, 1);
2159 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2160 value is immediately handed to expand_expr. */
2166 tree placement, init;
2167 tree type, true_type, size, rval;
2168 tree nelts = NULL_TREE;
2169 tree alloc_expr, alloc_node = NULL_TREE;
2171 enum tree_code code = NEW_EXPR;
2172 int use_cookie, nothrow, check_new;
2174 int use_java_new = 0;
2176 placement = TREE_OPERAND (exp, 0);
2177 type = TREE_OPERAND (exp, 1);
2178 init = TREE_OPERAND (exp, 2);
2179 use_global_new = NEW_EXPR_USE_GLOBAL (exp);
2181 if (TREE_CODE (type) == ARRAY_REF)
2184 nelts = TREE_OPERAND (type, 1);
2185 type = TREE_OPERAND (type, 0);
2189 if (CP_TYPE_QUALS (type))
2190 type = TYPE_MAIN_VARIANT (type);
2192 /* If our base type is an array, then make sure we know how many elements
2194 while (TREE_CODE (true_type) == ARRAY_TYPE)
2196 tree this_nelts = array_type_nelts_top (true_type);
2197 nelts = build_binary_op (MULT_EXPR, nelts, this_nelts);
2198 true_type = TREE_TYPE (true_type);
2201 if (!complete_type_or_else (true_type, exp))
2202 return error_mark_node;
2205 size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type),
2208 size = size_in_bytes (type);
2210 if (TREE_CODE (true_type) == VOID_TYPE)
2212 error ("invalid type `void' for new");
2213 return error_mark_node;
2216 if (abstract_virtuals_error (NULL_TREE, true_type))
2217 return error_mark_node;
2219 /* When we allocate an array, and the corresponding deallocation
2220 function takes a second argument of type size_t, and that's the
2221 "usual deallocation function", we allocate some extra space at
2222 the beginning of the array to store the size of the array.
2224 Well, that's what we should do. For backwards compatibility, we
2225 have to do this whenever there's a two-argument array-delete
2228 FIXME: For -fnew-abi, we don't have to maintain backwards
2229 compatibility and we should fix this. */
2230 use_cookie = (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type)
2231 && ! (placement && ! TREE_CHAIN (placement)
2232 && TREE_TYPE (TREE_VALUE (placement)) == ptr_type_node));
2236 tree extra = BI_header_size;
2238 size = size_binop (PLUS_EXPR, size, extra);
2243 code = VEC_NEW_EXPR;
2245 if (init && pedantic)
2246 cp_pedwarn ("initialization in array new");
2249 /* Allocate the object. */
2251 if (! has_array && ! placement && flag_this_is_variable > 0
2252 && TYPE_NEEDS_CONSTRUCTING (true_type) && init != void_type_node)
2254 if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST)
2258 error ("constructors take parameter lists");
2259 return error_mark_node;
2262 else if (! placement && TYPE_FOR_JAVA (true_type))
2264 tree class_addr, alloc_decl;
2265 tree class_decl = build_java_class_ref (true_type);
2266 tree class_size = size_in_bytes (true_type);
2267 static char alloc_name[] = "_Jv_AllocObject";
2269 alloc_decl = IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name));
2270 if (alloc_decl == NULL_TREE)
2271 fatal("call to Java constructor, while `%s' undefined", alloc_name);
2272 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2273 rval = build_function_call (alloc_decl,
2274 tree_cons (NULL_TREE, class_addr,
2275 build_tree_list (NULL_TREE,
2277 rval = cp_convert (build_pointer_type (true_type), rval);
2283 if (flag_exceptions)
2284 /* We will use RVAL when generating an exception handler for
2285 this new-expression, so we must save it. */
2286 susp = suspend_momentary ();
2288 rval = build_op_new_call
2289 (code, true_type, expr_tree_cons (NULL_TREE, size, placement),
2290 LOOKUP_NORMAL | (use_global_new * LOOKUP_GLOBAL));
2291 rval = cp_convert (build_pointer_type (true_type), rval);
2293 if (flag_exceptions)
2294 resume_momentary (susp);
2297 /* unless an allocation function is declared with an empty excep-
2298 tion-specification (_except.spec_), throw(), it indicates failure to
2299 allocate storage by throwing a bad_alloc exception (clause _except_,
2300 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2301 cation function is declared with an empty exception-specification,
2302 throw(), it returns null to indicate failure to allocate storage and a
2303 non-null pointer otherwise.
2305 So check for a null exception spec on the op new we just called. */
2310 /* The CALL_EXPR. */
2311 tree t = TREE_OPERAND (rval, 0);
2313 t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
2314 nothrow = TYPE_NOTHROW_P (TREE_TYPE (t));
2316 check_new = (flag_check_new || nothrow) && ! use_java_new;
2318 if ((check_new || flag_exceptions) && rval)
2320 alloc_expr = get_target_expr (rval);
2321 alloc_node = rval = TREE_OPERAND (alloc_expr, 0);
2324 alloc_expr = NULL_TREE;
2326 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2327 sure we have some extra bytes in that case for the BI_header_size
2328 cookies? And how does that interact with the code below? (mrs) */
2329 /* Finish up some magic for new'ed arrays */
2330 if (use_cookie && rval != NULL_TREE)
2332 tree extra = BI_header_size;
2334 rval = convert (string_type_node, rval); /* for ptr arithmetic */
2335 rval = save_expr (build_binary_op (PLUS_EXPR, rval, extra));
2336 /* Store header info. */
2337 cookie = build_indirect_ref (build (MINUS_EXPR,
2338 build_pointer_type (BI_header_type),
2339 rval, extra), NULL_PTR);
2340 exp1 = build (MODIFY_EXPR, void_type_node,
2341 build_component_ref (cookie, nc_nelts_field_id,
2344 TREE_SIDE_EFFECTS (exp1) = 1;
2345 rval = cp_convert (build_pointer_type (true_type), rval);
2346 rval = build_compound_expr
2347 (expr_tree_cons (NULL_TREE, exp1,
2348 build_expr_list (NULL_TREE, rval)));
2351 if (rval == error_mark_node)
2352 return error_mark_node;
2354 /* Don't call any constructors or do any initialization. */
2355 if (init == void_type_node)
2358 if (TYPE_NEEDS_CONSTRUCTING (type) || init)
2360 if (! TYPE_NEEDS_CONSTRUCTING (type)
2361 && ! IS_AGGR_TYPE (type) && ! has_array)
2363 /* We are processing something like `new int (10)', which
2364 means allocate an int, and initialize it with 10. */
2368 /* At present RVAL is a temporary variable, created to hold
2369 the value from the call to `operator new'. We transform
2370 it to (*RVAL = INIT, RVAL). */
2371 rval = save_expr (rval);
2372 deref = build_indirect_ref (rval, NULL_PTR);
2374 /* Even for something like `new const int (10)' we must
2375 allow the expression to be non-const while we do the
2377 deref_type = TREE_TYPE (deref);
2378 if (CP_TYPE_CONST_P (deref_type))
2380 = cp_build_qualified_type (deref_type,
2381 CP_TYPE_QUALS (deref_type)
2382 & ~TYPE_QUAL_CONST);
2383 TREE_READONLY (deref) = 0;
2385 if (TREE_CHAIN (init) != NULL_TREE)
2386 pedwarn ("initializer list being treated as compound expression");
2387 else if (TREE_CODE (init) == CONSTRUCTOR)
2389 pedwarn ("initializer list appears where operand should be used");
2390 init = TREE_OPERAND (init, 1);
2392 init = build_compound_expr (init);
2394 init = convert_for_initialization (deref, type, init, LOOKUP_NORMAL,
2395 "new", NULL_TREE, 0);
2396 rval = build (COMPOUND_EXPR, TREE_TYPE (rval),
2397 build_modify_expr (deref, NOP_EXPR, init),
2399 TREE_NO_UNUSED_WARNING (rval) = 1;
2400 TREE_SIDE_EFFECTS (rval) = 1;
2402 else if (! has_array)
2405 /* Constructors are never virtual. If it has an initialization, we
2406 need to complain if we aren't allowed to use the ctor that took
2408 int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_COMPLAIN;
2410 if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type))
2412 init = expr_tree_cons (NULL_TREE, integer_one_node, init);
2413 flags |= LOOKUP_HAS_IN_CHARGE;
2417 rval = save_expr (rval);
2420 if (newrval && TREE_CODE (TREE_TYPE (newrval)) == POINTER_TYPE)
2421 newrval = build_indirect_ref (newrval, NULL_PTR);
2423 newrval = build_method_call (newrval, ctor_identifier,
2424 init, TYPE_BINFO (true_type), flags);
2426 if (newrval == NULL_TREE || newrval == error_mark_node)
2427 return error_mark_node;
2429 /* Java constructors compiled by jc1 do not return this. */
2431 newrval = build (COMPOUND_EXPR, TREE_TYPE (newrval),
2434 TREE_HAS_CONSTRUCTOR (rval) = 1;
2437 rval = build (VEC_INIT_EXPR, TREE_TYPE (rval),
2438 save_expr (rval), init, nelts);
2440 /* If any part of the object initialization terminates by throwing an
2441 exception and a suitable deallocation function can be found, the
2442 deallocation function is called to free the memory in which the
2443 object was being constructed, after which the exception continues
2444 to propagate in the context of the new-expression. If no
2445 unambiguous matching deallocation function can be found,
2446 propagating the exception does not cause the object's memory to be
2448 if (flag_exceptions && alloc_expr && ! use_java_new)
2450 enum tree_code dcode = has_array ? VEC_DELETE_EXPR : DELETE_EXPR;
2451 tree cleanup, fn = NULL_TREE;
2452 int flags = LOOKUP_NORMAL | (use_global_new * LOOKUP_GLOBAL);
2454 /* All cleanups must last longer than normal. */
2455 int yes = suspend_momentary ();
2457 /* The Standard is unclear here, but the right thing to do
2458 is to use the same method for finding deallocation
2459 functions that we use for finding allocation functions. */
2460 flags |= LOOKUP_SPECULATIVELY;
2462 /* We expect alloc_expr to look like a TARGET_EXPR around
2463 a NOP_EXPR around the CALL_EXPR we want. */
2464 fn = TREE_OPERAND (alloc_expr, 1);
2465 fn = TREE_OPERAND (fn, 0);
2467 /* Copy size to the saveable obstack. */
2468 size = mapcar (size, permanent_p);
2470 cleanup = build_op_delete_call (dcode, alloc_node, size, flags, fn);
2472 resume_momentary (yes);
2474 /* Ack! First we allocate the memory. Then we set our sentry
2475 variable to true, and expand a cleanup that deletes the memory
2476 if sentry is true. Then we run the constructor and store the
2477 returned pointer in buf. Then we clear sentry and return buf. */
2481 tree end, sentry, begin, buf, t = TREE_TYPE (rval);
2483 begin = get_target_expr (boolean_true_node);
2484 sentry = TREE_OPERAND (begin, 0);
2486 yes = suspend_momentary ();
2487 TREE_OPERAND (begin, 2)
2488 = build (COND_EXPR, void_type_node, sentry,
2489 cleanup, void_zero_node);
2490 resume_momentary (yes);
2492 rval = get_target_expr (rval);
2494 end = build (MODIFY_EXPR, TREE_TYPE (sentry),
2495 sentry, boolean_false_node);
2496 TREE_SIDE_EFFECTS (end) = 1;
2498 buf = TREE_OPERAND (rval, 0);
2500 rval = build (COMPOUND_EXPR, t, begin,
2501 build (COMPOUND_EXPR, t, rval,
2502 build (COMPOUND_EXPR, t, end, buf)));
2506 else if (CP_TYPE_CONST_P (true_type))
2507 cp_error ("uninitialized const in `new' of `%#T'", true_type);
2511 if (alloc_expr && rval == alloc_node)
2513 rval = TREE_OPERAND (alloc_expr, 1);
2514 alloc_expr = NULL_TREE;
2517 if (check_new && alloc_expr)
2519 /* Did we modify the storage? */
2520 tree ifexp = build_binary_op (NE_EXPR, alloc_node,
2522 rval = build_conditional_expr (ifexp, rval, alloc_node);
2526 rval = build (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2528 if (rval && TREE_TYPE (rval) != build_pointer_type (type))
2530 /* The type of new int [3][3] is not int *, but int [3] * */
2531 rval = build_c_cast (build_pointer_type (type), rval);
2538 build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
2540 tree base, maxindex, type;
2541 tree auto_delete_vec, auto_delete;
2542 int use_global_delete;
2545 tree ptype = build_pointer_type (type = complete_type (type));
2546 tree size_exp = size_in_bytes (type);
2548 /* Temporary variables used by the loop. */
2549 tree tbase, tbase_init;
2551 /* This is the body of the loop that implements the deletion of a
2552 single element, and moves temp variables to next elements. */
2555 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2558 /* This is the thing that governs what to do after the loop has run. */
2559 tree deallocate_expr = 0;
2561 /* This is the BIND_EXPR which holds the outermost iterator of the
2562 loop. It is convenient to set this variable up and test it before
2563 executing any other code in the loop.
2564 This is also the containing expression returned by this function. */
2565 tree controller = NULL_TREE;
2567 if (! IS_AGGR_TYPE (type) || ! TYPE_NEEDS_DESTRUCTOR (type))
2569 loop = integer_zero_node;
2573 /* The below is short by BI_header_size */
2574 virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
2576 tbase = build_decl (VAR_DECL, NULL_TREE, ptype);
2577 tbase_init = build_modify_expr (tbase, NOP_EXPR,
2578 fold (build (PLUS_EXPR, ptype,
2581 DECL_REGISTER (tbase) = 1;
2582 controller = build (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE);
2583 TREE_SIDE_EFFECTS (controller) = 1;
2585 if (auto_delete != integer_zero_node
2586 && auto_delete != integer_two_node)
2588 tree base_tbd = cp_convert (ptype,
2589 build_binary_op (MINUS_EXPR,
2590 cp_convert (ptr_type_node, base),
2592 /* This is the real size */
2593 virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
2594 body = build_expr_list (NULL_TREE,
2595 build_x_delete (base_tbd,
2596 2 | use_global_delete,
2598 body = build (COND_EXPR, void_type_node,
2599 build (BIT_AND_EXPR, integer_type_node,
2600 auto_delete, integer_one_node),
2601 body, integer_zero_node);
2606 body = expr_tree_cons (NULL_TREE,
2607 build_delete (ptype, tbase, auto_delete,
2608 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1),
2611 body = expr_tree_cons (NULL_TREE,
2612 build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
2615 body = expr_tree_cons (NULL_TREE,
2616 build (EXIT_EXPR, void_type_node,
2617 build (EQ_EXPR, boolean_type_node, base, tbase)),
2620 loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body));
2622 loop = expr_tree_cons (NULL_TREE, tbase_init,
2623 expr_tree_cons (NULL_TREE, loop, NULL_TREE));
2624 loop = build_compound_expr (loop);
2627 /* If the delete flag is one, or anything else with the low bit set,
2628 delete the storage. */
2629 if (auto_delete_vec == integer_zero_node)
2630 deallocate_expr = integer_zero_node;
2635 /* The below is short by BI_header_size */
2636 virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
2638 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2643 base_tbd = cp_convert (ptype,
2644 build_binary_op (MINUS_EXPR,
2645 cp_convert (string_type_node, base),
2647 /* True size with header. */
2648 virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
2650 deallocate_expr = build_x_delete (base_tbd,
2651 2 | use_global_delete,
2653 if (auto_delete_vec != integer_one_node)
2654 deallocate_expr = build (COND_EXPR, void_type_node,
2655 build (BIT_AND_EXPR, integer_type_node,
2656 auto_delete_vec, integer_one_node),
2657 deallocate_expr, integer_zero_node);
2660 if (loop && deallocate_expr != integer_zero_node)
2662 body = expr_tree_cons (NULL_TREE, loop,
2663 expr_tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
2664 body = build_compound_expr (body);
2669 /* Outermost wrapper: If pointer is null, punt. */
2670 body = build (COND_EXPR, void_type_node,
2671 build (NE_EXPR, boolean_type_node, base, integer_zero_node),
2672 body, integer_zero_node);
2673 body = build1 (NOP_EXPR, void_type_node, body);
2677 TREE_OPERAND (controller, 1) = body;
2681 return cp_convert (void_type_node, body);
2684 /* Protect the vector initialization with a try-block so that we can
2685 destroy the first few elements if constructing a later element
2686 causes an exception to be thrown. TYPE is the type of the array
2690 expand_vec_init_try_block (type)
2693 if (!TYPE_NEEDS_DESTRUCTOR (type) || !flag_exceptions)
2696 /* The code we generate looks like:
2699 // Initialize the vector.
2701 // Destory the elements that need destroying.
2705 Here we're just beginning the `try'. */
2707 expand_eh_region_start ();
2710 /* Add code to destroy the array elements constructed so far if the
2711 construction of some element in the array causes an exception to be
2712 thrown. RVAL is the address of the last element in the array.
2713 TYPE is the type of the array elements. MAXINDEX is the maximum
2714 allowable index into the array. ITERATOR is an integer variable
2715 indicating how many elements remain to be constructed. */
2718 expand_vec_init_catch_clause (rval, type, maxindex, iterator)
2727 if (!TYPE_NEEDS_DESTRUCTOR (type) || !flag_exceptions)
2730 /* We have to ensure that this can live to the cleanup expansion
2731 time, since we know it is only ever needed once, generate code
2733 push_obstacks_nochange ();
2734 resume_temporary_allocation ();
2736 cleanup = make_node (RTL_EXPR);
2737 TREE_TYPE (cleanup) = void_type_node;
2738 RTL_EXPR_RTL (cleanup) = const0_rtx;
2739 TREE_SIDE_EFFECTS (cleanup) = 1;
2740 do_pending_stack_adjust ();
2741 start_sequence_for_rtl_expr (cleanup);
2743 e = build_vec_delete_1 (rval,
2744 build_binary_op (MINUS_EXPR, maxindex,
2747 /*auto_delete_vec=*/integer_zero_node,
2748 /*auto_delete=*/integer_zero_node,
2749 /*use_global_delete=*/0);
2750 expand_expr (e, const0_rtx, VOIDmode, EXPAND_NORMAL);
2752 do_pending_stack_adjust ();
2753 RTL_EXPR_SEQUENCE (cleanup) = get_insns ();
2755 cleanup = protect_with_terminate (cleanup);
2756 expand_eh_region_end (cleanup);
2760 /* `expand_vec_init' performs initialization of a vector of aggregate
2763 DECL is passed only for error reporting, and provides line number
2764 and source file name information.
2765 BASE is the space where the vector will be.
2766 MAXINDEX is the maximum index of the array (one less than the
2767 number of elements).
2768 INIT is the (possibly NULL) initializer.
2770 FROM_ARRAY is 0 if we should init everything with INIT
2771 (i.e., every element initialized from INIT).
2772 FROM_ARRAY is 1 if we should index into INIT in parallel
2773 with initialization of DECL.
2774 FROM_ARRAY is 2 if we should index into INIT in parallel,
2775 but use assignment instead of initialization. */
2778 expand_vec_init (decl, base, maxindex, init, from_array)
2779 tree decl, base, maxindex, init;
2783 tree base2 = NULL_TREE;
2784 tree type = TREE_TYPE (TREE_TYPE (base));
2786 tree itype = NULL_TREE;
2788 int num_initialized_elts = 0;
2790 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2791 if (maxindex == error_mark_node)
2792 return error_mark_node;
2794 if (current_function_decl == NULL_TREE)
2796 rval = make_tree_vec (3);
2797 TREE_VEC_ELT (rval, 0) = base;
2798 TREE_VEC_ELT (rval, 1) = maxindex;
2799 TREE_VEC_ELT (rval, 2) = init;
2803 size = size_in_bytes (type);
2805 base = default_conversion (base);
2806 base = cp_convert (build_pointer_type (type), base);
2807 rval = get_temp_regvar (build_pointer_type (type), base);
2808 base = get_temp_regvar (build_pointer_type (type), base);
2809 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2811 /* Protect the entire array initialization so that we can destroy
2812 the partially constructed array if an exception is thrown. */
2813 expand_vec_init_try_block (type);
2815 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR
2816 && (!decl || same_type_p (TREE_TYPE (init), TREE_TYPE (decl))))
2818 /* Do non-default initialization resulting from brace-enclosed
2822 tree baseref = build1 (INDIRECT_REF, type, base);
2826 for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
2828 tree elt = TREE_VALUE (elts);
2830 num_initialized_elts++;
2832 if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2833 expand_aggr_init (baseref, elt, 0);
2835 expand_assignment (baseref, elt, 0, 0);
2837 expand_assignment (base,
2838 build (PLUS_EXPR, build_pointer_type (type),
2841 expand_assignment (iterator,
2842 build (MINUS_EXPR, ptrdiff_type_node,
2843 iterator, integer_one_node),
2847 /* Clear out INIT so that we don't get confused below. */
2851 use_variable (DECL_RTL (base));
2853 else if (from_array)
2855 /* If initializing one array from another, initialize element by
2856 element. We rely upon the below calls the do argument
2858 if (decl == NULL_TREE)
2860 sorry ("initialization of array from dissimilar array type");
2861 return error_mark_node;
2865 base2 = default_conversion (init);
2866 itype = TREE_TYPE (base2);
2867 base2 = get_temp_regvar (itype, base2);
2868 itype = TREE_TYPE (itype);
2870 else if (TYPE_LANG_SPECIFIC (type)
2871 && TYPE_NEEDS_CONSTRUCTING (type)
2872 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2874 error ("initializer ends prematurely");
2875 return error_mark_node;
2879 /* Now, default-initialize any remaining elements. We don't need to
2880 do that if a) the type does not need constructing, or b) we've
2881 already initialized all the elements.
2883 We do need to keep going if we're copying an array. */
2886 || (TYPE_NEEDS_CONSTRUCTING (type)
2887 && !(TREE_CODE (maxindex) == INTEGER_CST
2888 && num_initialized_elts == TREE_INT_CST_LOW (maxindex) + 1)))
2890 /* If the ITERATOR is equal to -1, then we don't have to loop;
2891 we've already initialized all the elements. */
2892 expand_start_cond (build (NE_EXPR, boolean_type_node,
2893 iterator, minus_one),
2896 /* Otherwise, loop through the elements. */
2897 expand_start_loop_continue_elsewhere (1);
2899 /* The initialization of each array element is a full-expression. */
2900 expand_start_target_temps ();
2904 tree to = build1 (INDIRECT_REF, type, base);
2908 from = build1 (INDIRECT_REF, itype, base2);
2912 if (from_array == 2)
2913 expand_expr_stmt (build_modify_expr (to, NOP_EXPR, from));
2914 else if (TYPE_NEEDS_CONSTRUCTING (type))
2915 expand_aggr_init (to, from, 0);
2917 expand_assignment (to, from, 0, 0);
2919 my_friendly_abort (57);
2921 else if (TREE_CODE (type) == ARRAY_TYPE)
2924 sorry ("cannot initialize multi-dimensional array with initializer");
2925 expand_vec_init (decl,
2927 build_pointer_type (TREE_TYPE
2930 array_type_nelts (type), 0, 0);
2933 expand_aggr_init (build1 (INDIRECT_REF, type, base), init, 0);
2935 expand_assignment (base,
2936 build (PLUS_EXPR, build_pointer_type (type),
2939 expand_assignment (base2,
2940 build (PLUS_EXPR, build_pointer_type (type),
2941 base2, size), 0, 0);
2943 /* Cleanup any temporaries needed for the initial value. */
2944 expand_end_target_temps ();
2946 expand_loop_continue_here ();
2947 expand_exit_loop_if_false (0, build (NE_EXPR, boolean_type_node,
2948 build (PREDECREMENT_EXPR,
2956 use_variable (DECL_RTL (base));
2958 use_variable (DECL_RTL (base2));
2965 /* Make sure to cleanup any partially constructed elements. */
2966 expand_vec_init_catch_clause (rval, type, maxindex, iterator);
2970 use_variable (DECL_RTL (iterator));
2971 use_variable (DECL_RTL (rval));
2977 /* Free up storage of type TYPE, at address ADDR.
2979 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2982 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2983 used as the second argument to operator delete. It can include
2984 things like padding and magic size cookies. It has virtual in it,
2985 because if you have a base pointer and you delete through a virtual
2986 destructor, it should be the size of the dynamic object, not the
2987 static object, see Free Store 12.5 ANSI C++ WP.
2989 This does not call any destructors. */
2992 build_x_delete (addr, which_delete, virtual_size)
2997 int use_global_delete = which_delete & 1;
2998 int use_vec_delete = !!(which_delete & 2);
2999 enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
3000 int flags = LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL);
3002 return build_op_delete_call (code, addr, virtual_size, flags, NULL_TREE);
3005 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3006 ADDR is an expression which yields the store to be destroyed.
3007 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
3008 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
3009 virtual baseclasses.
3010 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
3012 FLAGS is the logical disjunction of zero or more LOOKUP_
3013 flags. See cp-tree.h for more info.
3015 This function does not delete an object's virtual base classes. */
3018 build_delete (type, addr, auto_delete, flags, use_global_delete)
3022 int use_global_delete;
3028 if (addr == error_mark_node)
3029 return error_mark_node;
3031 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3032 set to `error_mark_node' before it gets properly cleaned up. */
3033 if (type == error_mark_node)
3034 return error_mark_node;
3036 type = TYPE_MAIN_VARIANT (type);
3038 if (TREE_CODE (type) == POINTER_TYPE)
3040 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3041 if (type != void_type_node && !complete_type_or_else (type, addr))
3042 return error_mark_node;
3043 if (TREE_CODE (type) == ARRAY_TYPE)
3045 if (! IS_AGGR_TYPE (type))
3047 /* Call the builtin operator delete. */
3048 return build_builtin_delete_call (addr);
3050 if (TREE_SIDE_EFFECTS (addr))
3051 addr = save_expr (addr);
3053 /* throw away const and volatile on target type of addr */
3054 addr = convert_force (build_pointer_type (type), addr, 0);
3055 ref = build_indirect_ref (addr, NULL_PTR);
3057 else if (TREE_CODE (type) == ARRAY_TYPE)
3060 if (TREE_SIDE_EFFECTS (addr))
3061 addr = save_expr (addr);
3062 if (TYPE_DOMAIN (type) == NULL_TREE)
3064 error ("unknown array size in delete");
3065 return error_mark_node;
3067 return build_vec_delete (addr, array_type_nelts (type),
3068 auto_delete, integer_zero_node,
3073 /* Don't check PROTECT here; leave that decision to the
3074 destructor. If the destructor is accessible, call it,
3075 else report error. */
3076 addr = build_unary_op (ADDR_EXPR, addr, 0);
3077 if (TREE_SIDE_EFFECTS (addr))
3078 addr = save_expr (addr);
3080 if (TREE_CONSTANT (addr))
3081 addr = convert_pointer_to (type, addr);
3083 addr = convert_force (build_pointer_type (type), addr, 0);
3085 ref = build_indirect_ref (addr, NULL_PTR);
3088 my_friendly_assert (IS_AGGR_TYPE (type), 220);
3090 if (! TYPE_NEEDS_DESTRUCTOR (type))
3092 if (auto_delete == integer_zero_node)
3093 return void_zero_node;
3095 return build_op_delete_call
3096 (DELETE_EXPR, addr, c_sizeof_nowarn (type),
3097 LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL),
3101 /* Below, we will reverse the order in which these calls are made.
3102 If we have a destructor, then that destructor will take care
3103 of the base classes; otherwise, we must do that here. */
3104 if (TYPE_HAS_DESTRUCTOR (type))
3106 tree passed_auto_delete;
3107 tree do_delete = NULL_TREE;
3110 if (use_global_delete)
3112 tree cond = fold (build (BIT_AND_EXPR, integer_type_node,
3113 auto_delete, integer_one_node));
3114 tree call = build_builtin_delete_call (addr);
3116 cond = fold (build (COND_EXPR, void_type_node, cond,
3117 call, void_zero_node));
3118 if (cond != void_zero_node)
3121 passed_auto_delete = fold (build (BIT_AND_EXPR, integer_type_node,
3122 auto_delete, integer_two_node));
3125 passed_auto_delete = auto_delete;
3127 expr = build_method_call
3128 (ref, dtor_identifier, build_expr_list (NULL_TREE, passed_auto_delete),
3132 expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete);
3134 if (flags & LOOKUP_DESTRUCTOR)
3135 /* Explicit destructor call; don't check for null pointer. */
3136 ifexp = integer_one_node;
3138 /* Handle deleting a null pointer. */
3139 ifexp = fold (build_binary_op (NE_EXPR, addr, integer_zero_node));
3141 if (ifexp != integer_one_node)
3142 expr = build (COND_EXPR, void_type_node,
3143 ifexp, expr, void_zero_node);
3149 /* We only get here from finish_function for a destructor. */
3150 tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
3151 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
3152 tree base_binfo = n_baseclasses > 0 ? TREE_VEC_ELT (binfos, 0) : NULL_TREE;
3153 tree exprstmt = NULL_TREE;
3154 tree parent_auto_delete = auto_delete;
3157 /* Set this again before we call anything, as we might get called
3159 TYPE_HAS_DESTRUCTOR (type) = 1;
3161 /* If we have member delete or vbases, we call delete in
3163 if (auto_delete == integer_zero_node)
3165 else if (base_binfo == NULL_TREE
3166 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3168 cond = build (COND_EXPR, void_type_node,
3169 build (BIT_AND_EXPR, integer_type_node, auto_delete, integer_one_node),
3170 build_builtin_delete_call (addr),
3177 exprstmt = build_expr_list (NULL_TREE, cond);
3180 && ! TREE_VIA_VIRTUAL (base_binfo)
3181 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3183 tree this_auto_delete;
3185 if (BINFO_OFFSET_ZEROP (base_binfo))
3186 this_auto_delete = parent_auto_delete;
3188 this_auto_delete = integer_zero_node;
3190 expr = build_scoped_method_call
3191 (ref, base_binfo, dtor_identifier,
3192 build_expr_list (NULL_TREE, this_auto_delete));
3193 exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
3196 /* Take care of the remaining baseclasses. */
3197 for (i = 1; i < n_baseclasses; i++)
3199 base_binfo = TREE_VEC_ELT (binfos, i);
3200 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo))
3201 || TREE_VIA_VIRTUAL (base_binfo))
3204 expr = build_scoped_method_call
3205 (ref, base_binfo, dtor_identifier,
3206 build_expr_list (NULL_TREE, integer_zero_node));
3208 exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
3211 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
3213 if (TREE_CODE (member) != FIELD_DECL)
3215 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member)))
3217 tree this_member = build_component_ref (ref, DECL_NAME (member), NULL_TREE, 0);
3218 tree this_type = TREE_TYPE (member);
3219 expr = build_delete (this_type, this_member, integer_two_node, flags, 0);
3220 exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
3225 return build_compound_expr (exprstmt);
3226 /* Virtual base classes make this function do nothing. */
3227 return void_zero_node;
3231 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3234 build_vbase_delete (type, decl)
3237 tree vbases = CLASSTYPE_VBASECLASSES (type);
3238 tree result = NULL_TREE;
3239 tree addr = build_unary_op (ADDR_EXPR, decl, 0);
3241 my_friendly_assert (addr != error_mark_node, 222);
3245 tree this_addr = convert_force (build_pointer_type (BINFO_TYPE (vbases)),
3247 result = expr_tree_cons (NULL_TREE,
3248 build_delete (TREE_TYPE (this_addr), this_addr,
3250 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0),
3252 vbases = TREE_CHAIN (vbases);
3254 return build_compound_expr (nreverse (result));
3257 /* Build a C++ vector delete expression.
3258 MAXINDEX is the number of elements to be deleted.
3259 ELT_SIZE is the nominal size of each element in the vector.
3260 BASE is the expression that should yield the store to be deleted.
3261 This function expands (or synthesizes) these calls itself.
3262 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3263 AUTO_DELETE say whether each item in the container should be deallocated.
3265 This also calls delete for virtual baseclasses of elements of the vector.
3267 Update: MAXINDEX is no longer needed. The size can be extracted from the
3268 start of the vector for pointers, and from the type for arrays. We still
3269 use MAXINDEX for arrays because it happens to already have one of the
3270 values we'd have to extract. (We could use MAXINDEX with pointers to
3271 confirm the size, and trap if the numbers differ; not clear that it'd
3272 be worth bothering.) */
3275 build_vec_delete (base, maxindex, auto_delete_vec, auto_delete,
3277 tree base, maxindex;
3278 tree auto_delete_vec, auto_delete;
3279 int use_global_delete;
3283 if (TREE_CODE (base) == OFFSET_REF)
3284 base = resolve_offset_ref (base);
3286 type = TREE_TYPE (base);
3288 base = stabilize_reference (base);
3290 /* Since we can use base many times, save_expr it. */
3291 if (TREE_SIDE_EFFECTS (base))
3292 base = save_expr (base);
3294 if (TREE_CODE (type) == POINTER_TYPE)
3296 /* Step back one from start of vector, and read dimension. */
3297 tree cookie_addr = build (MINUS_EXPR, build_pointer_type (BI_header_type),
3298 base, BI_header_size);
3299 tree cookie = build_indirect_ref (cookie_addr, NULL_PTR);
3300 maxindex = build_component_ref (cookie, nc_nelts_field_id, NULL_TREE, 0);
3302 type = TREE_TYPE (type);
3303 while (TREE_CODE (type) == ARRAY_TYPE);
3305 else if (TREE_CODE (type) == ARRAY_TYPE)
3307 /* get the total number of things in the array, maxindex is a bad name */
3308 maxindex = array_type_nelts_total (type);
3309 while (TREE_CODE (type) == ARRAY_TYPE)
3310 type = TREE_TYPE (type);
3311 base = build_unary_op (ADDR_EXPR, base, 1);
3315 if (base != error_mark_node)
3316 error ("type to vector delete is neither pointer or array type");
3317 return error_mark_node;
3320 return build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,