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. */
35 /* In C++, structures with well-defined constructors are initialized by
36 those constructors, unasked. CURRENT_BASE_INIT_LIST
37 holds a list of stmts for a BASE_INIT term in the grammar.
38 This list has one element for each base class which must be
39 initialized. The list elements are [basename, init], with
40 type basetype. This allows the possibly anachronistic form
41 (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
42 where each successive term can be handed down the constructor
43 line. Perhaps this was not intended. */
44 tree current_base_init_list, current_member_init_list;
46 static void expand_aggr_vbase_init_1 PROTO((tree, tree, tree, tree));
47 static void construct_virtual_bases PROTO((tree, tree, tree, tree, tree));
48 static void expand_aggr_init_1 PROTO((tree, tree, tree, tree, int));
49 static void expand_default_init PROTO((tree, tree, tree, tree, int));
50 static tree build_vec_delete_1 PROTO((tree, tree, tree, tree, tree,
52 static void perform_member_init PROTO((tree, tree, tree, int));
53 static void sort_base_init PROTO((tree, tree *, tree *));
54 static tree build_builtin_delete_call PROTO((tree));
55 static int member_init_ok_or_else PROTO((tree, tree, const char *));
56 static void expand_virtual_init PROTO((tree, tree));
57 static tree sort_member_init PROTO((tree));
58 static tree initializing_context PROTO((tree));
59 static void expand_vec_init_try_block PROTO((tree));
60 static void expand_vec_init_catch_clause PROTO((tree, tree, tree, tree));
61 static tree build_java_class_ref PROTO((tree));
62 static void expand_cleanup_for_base PROTO((tree, tree));
64 /* Cache the identifier nodes for the magic field of a new cookie. */
65 static tree nc_nelts_field_id;
67 static tree minus_one;
69 /* Set up local variable for this file. MUST BE CALLED AFTER
70 INIT_DECL_PROCESSING. */
72 static tree BI_header_type, BI_header_size;
74 void init_init_processing ()
78 minus_one = build_int_2 (-1, -1);
80 /* Define the structure that holds header information for
81 arrays allocated via operator new. */
82 BI_header_type = make_lang_type (RECORD_TYPE);
83 nc_nelts_field_id = get_identifier ("nelts");
84 fields[0] = build_lang_field_decl (FIELD_DECL, nc_nelts_field_id, sizetype);
85 finish_builtin_type (BI_header_type, "__new_cookie", fields,
87 BI_header_size = size_in_bytes (BI_header_type);
90 /* Subroutine of emit_base_init. For BINFO, initialize all the
91 virtual function table pointers, except those that come from
92 virtual base classes. Initialize binfo's vtable pointer, if
93 INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
94 function table pointers in all bases have been initialized already,
95 probably because their constructors have just be run. ADDR is the
96 pointer to the object whos vtables we are going to initialize.
98 REAL_BINFO is usually the same as BINFO, except when addr is not of
99 pointer to the type of the real derived type that we want to
100 initialize for. This is the case when addr is a pointer to a sub
101 object of a complete object, and we only want to do part of the
102 complete object's initialization of vtable pointers. This is done
103 for all virtual table pointers in virtual base classes. REAL_BINFO
104 is used to find the BINFO_VTABLE that we initialize with. BINFO is
105 used for conversions of addr to subobjects.
107 BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
109 Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
113 expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr)
114 tree real_binfo, binfo, addr;
115 int init_self, can_elide;
117 tree real_binfos = BINFO_BASETYPES (real_binfo);
118 tree binfos = BINFO_BASETYPES (binfo);
119 int i, n_baselinks = real_binfos ? TREE_VEC_LENGTH (real_binfos) : 0;
121 for (i = 0; i < n_baselinks; i++)
123 tree real_base_binfo = TREE_VEC_ELT (real_binfos, i);
124 tree base_binfo = TREE_VEC_ELT (binfos, i);
125 int is_not_base_vtable
126 = i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo));
127 if (! TREE_VIA_VIRTUAL (real_base_binfo))
128 expand_direct_vtbls_init (real_base_binfo, base_binfo,
129 is_not_base_vtable, can_elide, addr);
132 /* Before turning this on, make sure it is correct. */
133 if (can_elide && ! BINFO_MODIFIED (binfo))
136 /* Should we use something besides CLASSTYPE_VFIELDS? */
137 if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo)))
139 tree base_ptr = convert_pointer_to_real (binfo, addr);
140 expand_virtual_init (real_binfo, base_ptr);
145 /* Subroutine of emit_base_init. */
148 perform_member_init (member, name, init, explicit)
149 tree member, name, init;
153 tree type = TREE_TYPE (member);
155 expand_start_target_temps ();
157 if (TYPE_NEEDS_CONSTRUCTING (type)
158 || (init && TYPE_HAS_CONSTRUCTOR (type)))
160 /* Since `init' is already a TREE_LIST on the current_member_init_list,
161 only build it into one if we aren't already a list. */
162 if (init != NULL_TREE && TREE_CODE (init) != TREE_LIST)
163 init = build_expr_list (NULL_TREE, init);
165 decl = build_component_ref (current_class_ref, name, NULL_TREE, explicit);
168 && TREE_CODE (type) == ARRAY_TYPE
170 && TREE_CHAIN (init) == NULL_TREE
171 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
173 /* Initialization of one array from another. */
174 expand_vec_init (TREE_OPERAND (decl, 1), decl,
175 array_type_nelts (type), TREE_VALUE (init), 1);
178 expand_aggr_init (decl, init, 0);
182 if (init == NULL_TREE)
186 /* default-initialization. */
187 if (AGGREGATE_TYPE_P (type))
188 init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
189 else if (TREE_CODE (type) == REFERENCE_TYPE)
191 cp_error ("default-initialization of `%#D', which has reference type",
193 init = error_mark_node;
196 init = integer_zero_node;
198 /* member traversal: note it leaves init NULL */
199 else if (TREE_CODE (TREE_TYPE (member)) == REFERENCE_TYPE)
200 cp_pedwarn ("uninitialized reference member `%D'", member);
202 else if (TREE_CODE (init) == TREE_LIST)
204 /* There was an explicit member initialization. Do some
205 work in that case. */
206 if (TREE_CHAIN (init))
208 warning ("initializer list treated as compound expression");
209 init = build_compound_expr (init);
212 init = TREE_VALUE (init);
215 /* We only build this with a null init if we got it from the
216 current_member_init_list. */
217 if (init || explicit)
219 decl = build_component_ref (current_class_ref, name, NULL_TREE,
221 expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
225 expand_end_target_temps ();
228 if (TYPE_NEEDS_DESTRUCTOR (type))
232 /* All cleanups must be on the function_obstack. */
233 push_obstacks_nochange ();
234 resume_temporary_allocation ();
236 expr = build_component_ref (current_class_ref, name, NULL_TREE,
238 expr = build_delete (type, expr, integer_zero_node,
239 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
241 if (expr != error_mark_node)
242 add_partial_entry (expr);
248 extern int warn_reorder;
250 /* Subroutine of emit_member_init. */
256 tree x, member, name, field;
257 tree init_list = NULL_TREE;
259 tree last_field = NULL_TREE;
261 for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member))
265 /* member could be, for example, a CONST_DECL for an enumerated
266 tag; we don't want to try to initialize that, since it already
268 if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
271 for (x = current_member_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
273 /* If we cleared this out, then pay no attention to it. */
274 if (TREE_PURPOSE (x) == NULL_TREE)
276 name = TREE_PURPOSE (x);
279 /* This happens in templates, since the IDENTIFIER is replaced
280 with the COMPONENT_REF in tsubst_expr. */
281 field = (TREE_CODE (name) == COMPONENT_REF
282 ? TREE_OPERAND (name, 1) : IDENTIFIER_CLASS_VALUE (name));
284 /* Let's find out when this happens. */
285 my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 348);
286 field = IDENTIFIER_CLASS_VALUE (name);
289 /* If one member shadows another, get the outermost one. */
290 if (TREE_CODE (field) == TREE_LIST)
291 field = TREE_VALUE (field);
299 cp_warning_at ("member initializers for `%#D'", last_field);
300 cp_warning_at (" and `%#D'", field);
301 warning (" will be re-ordered to match declaration order");
307 /* Make sure we won't try to work on this init again. */
308 TREE_PURPOSE (x) = NULL_TREE;
309 x = build_tree_list (name, TREE_VALUE (x));
314 /* If we didn't find MEMBER in the list, create a dummy entry
315 so the two lists (INIT_LIST and the list of members) will be
317 x = build_tree_list (NULL_TREE, NULL_TREE);
319 init_list = chainon (init_list, x);
322 /* Initializers for base members go at the end. */
323 for (x = current_member_init_list ; x ; x = TREE_CHAIN (x))
325 name = TREE_PURPOSE (x);
328 if (purpose_member (name, init_list))
330 cp_error ("multiple initializations given for member `%D'",
331 IDENTIFIER_CLASS_VALUE (name));
335 init_list = chainon (init_list,
336 build_tree_list (name, TREE_VALUE (x)));
337 TREE_PURPOSE (x) = NULL_TREE;
345 sort_base_init (t, rbase_ptr, vbase_ptr)
346 tree t, *rbase_ptr, *vbase_ptr;
348 tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
349 int n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
355 /* For warn_reorder. */
357 tree last_base = NULL_TREE;
359 tree rbases = NULL_TREE;
360 tree vbases = NULL_TREE;
362 /* First walk through and splice out vbase and invalid initializers.
363 Also replace names with binfos. */
365 last = tree_cons (NULL_TREE, NULL_TREE, current_base_init_list);
366 for (x = TREE_CHAIN (last); x; x = TREE_CHAIN (x))
368 tree basetype = TREE_PURPOSE (x);
369 tree binfo = NULL_TREE;
371 if (basetype == NULL_TREE)
373 /* Initializer for single base class. Must not
374 use multiple inheritance or this is ambiguous. */
375 switch (n_baseclasses)
378 cp_error ("`%T' does not have a base class to initialize",
384 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
388 binfo = TREE_VEC_ELT (binfos, 0);
390 else if (is_aggr_type (basetype, 1))
392 binfo = binfo_or_else (basetype, t);
393 if (binfo == NULL_TREE)
396 /* Virtual base classes are special cases. Their initializers
397 are recorded with this constructor, and they are used when
398 this constructor is the top-level constructor called. */
399 if (TREE_VIA_VIRTUAL (binfo))
401 tree v = CLASSTYPE_VBASECLASSES (t);
402 while (BINFO_TYPE (v) != BINFO_TYPE (binfo))
405 vbases = tree_cons (v, TREE_VALUE (x), vbases);
410 /* Otherwise, if it is not an immediate base class, complain. */
411 for (i = n_baseclasses-1; i >= 0; i--)
412 if (BINFO_TYPE (binfo) == BINFO_TYPE (TREE_VEC_ELT (binfos, i)))
416 cp_error ("`%T' is not an immediate base class of `%T'",
417 basetype, current_class_type);
423 my_friendly_abort (365);
425 TREE_PURPOSE (x) = binfo;
426 TREE_CHAIN (last) = x;
429 TREE_CHAIN (last) = NULL_TREE;
431 /* Now walk through our regular bases and make sure they're initialized. */
433 for (i = 0; i < n_baseclasses; ++i)
435 tree base_binfo = TREE_VEC_ELT (binfos, i);
438 if (TREE_VIA_VIRTUAL (base_binfo))
441 for (x = current_base_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos)
443 tree binfo = TREE_PURPOSE (x);
445 if (binfo == NULL_TREE)
448 if (binfo == base_binfo)
454 cp_warning_at ("base initializers for `%#T'", last_base);
455 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo));
456 warning (" will be re-ordered to match inheritance order");
459 last_base = BINFO_TYPE (binfo);
462 /* Make sure we won't try to work on this init again. */
463 TREE_PURPOSE (x) = NULL_TREE;
464 x = build_tree_list (binfo, TREE_VALUE (x));
469 /* If we didn't find BASE_BINFO in the list, create a dummy entry
470 so the two lists (RBASES and the list of bases) will be
472 x = build_tree_list (NULL_TREE, NULL_TREE);
474 rbases = chainon (rbases, x);
481 /* Perform whatever initializations have yet to be done on the base
482 class of the class variable. These actions are in the global
483 variable CURRENT_BASE_INIT_LIST. Such an action could be
484 NULL_TREE, meaning that the user has explicitly called the base
485 class constructor with no arguments.
487 If there is a need for a call to a constructor, we must surround
488 that call with a pushlevel/poplevel pair, since we are technically
489 at the PARM level of scope.
491 Argument IMMEDIATELY, if zero, forces a new sequence to be
492 generated to contain these new insns, so it can be emitted later.
493 This sequence is saved in the global variable BASE_INIT_EXPR.
494 Otherwise, the insns are emitted into the current sequence.
496 Note that emit_base_init does *not* initialize virtual base
497 classes. That is done specially, elsewhere. */
499 extern tree base_init_expr, rtl_expr_chain;
502 emit_base_init (t, immediately)
508 tree rbase_init_list, vbase_init_list;
509 tree t_binfo = TYPE_BINFO (t);
510 tree binfos = BINFO_BASETYPES (t_binfo);
511 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
512 tree expr = NULL_TREE;
517 do_pending_stack_adjust ();
518 /* Make the RTL_EXPR node temporary, not momentary,
519 so that rtl_expr_chain doesn't become garbage. */
520 momentary = suspend_momentary ();
521 expr = make_node (RTL_EXPR);
522 resume_momentary (momentary);
523 start_sequence_for_rtl_expr (expr);
526 if (write_symbols == NO_DEBUG)
527 /* As a matter of principle, `start_sequence' should do this. */
530 /* Always emit a line number note so we can step into constructors. */
531 emit_line_note_force (DECL_SOURCE_FILE (current_function_decl),
532 DECL_SOURCE_LINE (current_function_decl));
534 mem_init_list = sort_member_init (t);
535 current_member_init_list = NULL_TREE;
537 sort_base_init (t, &rbase_init_list, &vbase_init_list);
538 current_base_init_list = NULL_TREE;
540 /* First, initialize the virtual base classes, if we are
541 constructing the most-derived object. */
542 if (TYPE_USES_VIRTUAL_BASECLASSES (t))
544 tree first_arg = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
545 construct_virtual_bases (t, current_class_ref, current_class_ptr,
546 vbase_init_list, first_arg);
549 /* Now, perform initialization of non-virtual base classes. */
550 for (i = 0; i < n_baseclasses; i++)
552 tree base_binfo = TREE_VEC_ELT (binfos, i);
553 tree init = void_list_node;
555 if (TREE_VIA_VIRTUAL (base_binfo))
558 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo) == t_binfo,
561 if (TREE_PURPOSE (rbase_init_list))
562 init = TREE_VALUE (rbase_init_list);
563 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo)))
566 if (extra_warnings && copy_args_p (current_function_decl))
567 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
568 BINFO_TYPE (base_binfo));
571 if (init != void_list_node)
573 expand_start_target_temps ();
575 member = convert_pointer_to_real (base_binfo, current_class_ptr);
576 expand_aggr_init_1 (base_binfo, NULL_TREE,
577 build_indirect_ref (member, NULL_PTR), init,
580 expand_end_target_temps ();
584 expand_cleanup_for_base (base_binfo, NULL_TREE);
585 rbase_init_list = TREE_CHAIN (rbase_init_list);
588 /* Initialize all the virtual function table fields that
589 do come from virtual base classes. */
590 if (TYPE_USES_VIRTUAL_BASECLASSES (t))
591 expand_indirect_vtbls_init (t_binfo, current_class_ref, current_class_ptr);
593 /* Initialize all the virtual function table fields that
594 do not come from virtual base classes. */
595 expand_direct_vtbls_init (t_binfo, t_binfo, 1, 1, current_class_ptr);
597 for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
602 /* member could be, for example, a CONST_DECL for an enumerated
603 tag; we don't want to try to initialize that, since it already
605 if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member))
608 /* See if we had a user-specified member initialization. */
609 if (TREE_PURPOSE (mem_init_list))
611 name = TREE_PURPOSE (mem_init_list);
612 init = TREE_VALUE (mem_init_list);
616 if (TREE_CODE (name) == COMPONENT_REF)
617 name = DECL_NAME (TREE_OPERAND (name, 1));
619 /* Also see if it's ever a COMPONENT_REF here. If it is, we
620 need to do `expand_assignment (name, init, 0, 0);' and
622 my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 349);
627 name = DECL_NAME (member);
628 init = DECL_INITIAL (member);
632 /* Effective C++ rule 12. */
633 if (warn_ecpp && init == NULL_TREE
634 && !DECL_ARTIFICIAL (member)
635 && TREE_CODE (TREE_TYPE (member)) != ARRAY_TYPE)
636 cp_warning ("`%D' should be initialized in the member initialization list", member);
639 perform_member_init (member, name, init, from_init_list);
640 mem_init_list = TREE_CHAIN (mem_init_list);
643 /* Now initialize any members from our bases. */
644 while (mem_init_list)
646 tree name, init, field;
648 if (TREE_PURPOSE (mem_init_list))
650 name = TREE_PURPOSE (mem_init_list);
651 init = TREE_VALUE (mem_init_list);
652 /* XXX: this may need the COMPONENT_REF operand 0 check if
653 it turns out we actually get them. */
654 field = IDENTIFIER_CLASS_VALUE (name);
656 /* If one member shadows another, get the outermost one. */
657 if (TREE_CODE (field) == TREE_LIST)
659 field = TREE_VALUE (field);
660 if (decl_type_context (field) != current_class_type)
661 cp_error ("field `%D' not in immediate context", field);
665 /* It turns out if you have an anonymous union in the
666 class, a member from it can end up not being on the
667 list of fields (rather, the type is), and therefore
668 won't be seen by the for loop above. */
670 /* The code in this for loop is derived from a general loop
671 which had this check in it. Theoretically, we've hit
672 every initialization for the list of members in T, so
673 we shouldn't have anything but these left in this list. */
674 my_friendly_assert (DECL_FIELD_CONTEXT (field) != t, 351);
677 perform_member_init (field, name, init, 1);
679 mem_init_list = TREE_CHAIN (mem_init_list);
684 do_pending_stack_adjust ();
685 my_friendly_assert (base_init_expr == 0, 207);
686 base_init_expr = expr;
687 TREE_TYPE (expr) = void_type_node;
688 RTL_EXPR_RTL (expr) = const0_rtx;
689 RTL_EXPR_SEQUENCE (expr) = get_insns ();
690 rtl_expr_chain = tree_cons (NULL_TREE, expr, rtl_expr_chain);
692 TREE_SIDE_EFFECTS (expr) = 1;
695 /* All the implicit try blocks we built up will be zapped
696 when we come to a real binding contour boundary. */
699 /* Check that all fields are properly initialized after
700 an assignment to `this'. */
707 for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member))
708 if (DECL_NAME (member) && TREE_USED (member))
709 cp_error ("field `%D' used before initialized (after assignment to `this')",
713 /* This code sets up the virtual function tables appropriate for
714 the pointer DECL. It is a one-ply initialization.
716 BINFO is the exact type that DECL is supposed to be. In
717 multiple inheritance, this might mean "C's A" if C : A, B. */
720 expand_virtual_init (binfo, decl)
723 tree type = BINFO_TYPE (binfo);
725 tree vtype, vtype_binfo;
727 /* This code is crusty. Should be simple, like:
728 vtbl = BINFO_VTABLE (binfo);
730 vtype = DECL_CONTEXT (CLASSTYPE_VFIELD (type));
731 vtype_binfo = get_binfo (vtype, TREE_TYPE (TREE_TYPE (decl)), 0);
732 vtbl = BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type)), binfo));
733 assemble_external (vtbl);
734 TREE_USED (vtbl) = 1;
735 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
736 decl = convert_pointer_to_real (vtype_binfo, decl);
737 vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL_PTR), vtype);
738 if (vtbl_ptr == error_mark_node)
741 /* Have to convert VTBL since array sizes may be different. */
742 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
743 expand_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
746 /* If an exception is thrown in a constructor, those base classes already
747 constructed must be destroyed. This function creates the cleanup
748 for BINFO, which has just been constructed. If FLAG is non-NULL,
749 it is a DECL which is non-zero when this base needs to be
753 expand_cleanup_for_base (binfo, flag)
759 if (!TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (binfo)))
762 /* All cleanups must be on the function_obstack. */
763 push_obstacks_nochange ();
764 resume_temporary_allocation ();
766 /* Call the destructor. */
767 expr = (build_scoped_method_call
768 (current_class_ref, binfo, dtor_identifier,
769 build_expr_list (NULL_TREE, integer_zero_node)));
771 expr = fold (build (COND_EXPR, void_type_node,
772 truthvalue_conversion (flag),
773 expr, integer_zero_node));
776 add_partial_entry (expr);
779 /* Subroutine of `expand_aggr_vbase_init'.
780 BINFO is the binfo of the type that is being initialized.
781 INIT_LIST is the list of initializers for the virtual baseclass. */
784 expand_aggr_vbase_init_1 (binfo, exp, addr, init_list)
785 tree binfo, exp, addr, init_list;
787 tree init = purpose_member (binfo, init_list);
788 tree ref = build_indirect_ref (addr, NULL_PTR);
790 expand_start_target_temps ();
793 init = TREE_VALUE (init);
794 /* Call constructors, but don't set up vtables. */
795 expand_aggr_init_1 (binfo, exp, ref, init, LOOKUP_COMPLAIN);
797 expand_end_target_temps ();
801 /* Construct the virtual base-classes of THIS_REF (whose address is
802 THIS_PTR). The object has the indicated TYPE. The construction
803 actually takes place only if FLAG is non-zero. INIT_LIST is list
804 of initialization for constructor to perform. */
807 construct_virtual_bases (type, this_ref, this_ptr, init_list, flag)
817 /* If there are no virtual baseclasses, we shouldn't even be here. */
818 my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type), 19990621);
820 /* First set the pointers in our object that tell us where to find
821 our virtual baseclasses. */
822 expand_start_cond (flag, 0);
823 result = init_vbase_pointers (type, this_ptr);
825 expand_expr_stmt (build_compound_expr (result));
828 /* Now, run through the baseclasses, initializing each. */
829 for (vbases = CLASSTYPE_VBASECLASSES (type); vbases;
830 vbases = TREE_CHAIN (vbases))
832 tree tmp = purpose_member (vbases, result);
834 /* If there are virtual base classes with destructors, we need to
835 emit cleanups to destroy them if an exception is thrown during
836 the construction process. These exception regions (i.e., the
837 period during which the cleanups must occur) begin from the time
838 the construction is complete to the end of the function. If we
839 create a conditional block in which to initialize the
840 base-classes, then the cleanup region for the virtual base begins
841 inside a block, and ends outside of that block. This situation
842 confuses the sjlj exception-handling code. Therefore, we do not
843 create a single conditional block, but one for each
844 initialization. (That way the cleanup regions always begin
845 in the outer block.) We trust the back-end to figure out
846 that the FLAG will not change across initializations, and
847 avoid doing multiple tests. */
848 expand_start_cond (flag, 0);
849 expand_aggr_vbase_init_1 (vbases, this_ref,
850 TREE_OPERAND (TREE_VALUE (tmp), 0),
854 expand_cleanup_for_base (vbases, flag);
858 /* Find the context in which this FIELD can be initialized. */
861 initializing_context (field)
864 tree t = DECL_CONTEXT (field);
866 /* Anonymous union members can be initialized in the first enclosing
867 non-anonymous union context. */
868 while (t && ANON_UNION_TYPE_P (t))
869 t = TYPE_CONTEXT (t);
873 /* Function to give error message if member initialization specification
874 is erroneous. FIELD is the member we decided to initialize.
875 TYPE is the type for which the initialization is being performed.
876 FIELD must be a member of TYPE.
878 MEMBER_NAME is the name of the member. */
881 member_init_ok_or_else (field, type, member_name)
884 const char *member_name;
886 if (field == error_mark_node)
888 if (field == NULL_TREE || initializing_context (field) != type)
890 cp_error ("class `%T' does not have any field named `%s'", type,
894 if (TREE_STATIC (field))
896 cp_error ("field `%#D' is static; only point of initialization is its declaration",
904 /* If NAME is a viable field name for the aggregate DECL,
905 and PARMS is a viable parameter list, then expand an _EXPR
906 which describes this initialization.
908 Note that we do not need to chase through the class's base classes
909 to look for NAME, because if it's in that list, it will be handled
910 by the constructor for that base class.
912 We do not yet have a fixed-point finder to instantiate types
913 being fed to overloaded constructors. If there is a unique
914 constructor, then argument types can be got from that one.
916 If INIT is non-NULL, then it the initialization should
917 be placed in `current_base_init_list', where it will be processed
918 by `emit_base_init'. */
921 expand_member_init (exp, name, init)
922 tree exp, name, init;
924 tree basetype = NULL_TREE, field;
927 if (exp == NULL_TREE)
928 return; /* complain about this later */
930 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
932 if (name && TREE_CODE (name) == TYPE_DECL)
934 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
935 name = DECL_NAME (name);
938 if (name == NULL_TREE && IS_AGGR_TYPE (type))
939 switch (CLASSTYPE_N_BASECLASSES (type))
942 error ("base class initializer specified, but no base class to initialize");
945 basetype = TYPE_BINFO_BASETYPE (type, 0);
948 error ("initializer for unnamed base class ambiguous");
949 cp_error ("(type `%T' uses multiple inheritance)", type);
953 my_friendly_assert (init != NULL_TREE, 0);
955 /* The grammar should not allow fields which have names that are
956 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
957 may assume that this is an attempt to initialize a base class
958 member of the current type. Otherwise, it is an attempt to
959 initialize a member field. */
961 if (init == void_type_node)
964 if (name == NULL_TREE || basetype)
968 if (name == NULL_TREE)
972 name = TYPE_IDENTIFIER (basetype);
975 error ("no base class to initialize");
980 else if (basetype != type
981 && ! current_template_parms
982 && ! vec_binfo_member (basetype,
983 TYPE_BINFO_BASETYPES (type))
984 && ! binfo_member (basetype, CLASSTYPE_VBASECLASSES (type)))
986 if (IDENTIFIER_CLASS_VALUE (name))
988 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
989 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
992 cp_error ("type `%T' is not an immediate basetype for `%T'",
997 if (purpose_member (basetype, current_base_init_list))
999 cp_error ("base class `%T' already initialized", basetype);
1003 if (warn_reorder && current_member_init_list)
1005 cp_warning ("base initializer for `%T'", basetype);
1006 warning (" will be re-ordered to precede member initializations");
1009 base_init = build_tree_list (basetype, init);
1010 current_base_init_list = chainon (current_base_init_list, base_init);
1017 field = lookup_field (type, name, 1, 0);
1019 if (! member_init_ok_or_else (field, type, IDENTIFIER_POINTER (name)))
1022 if (purpose_member (name, current_member_init_list))
1024 cp_error ("field `%D' already initialized", field);
1028 member_init = build_tree_list (name, init);
1029 current_member_init_list = chainon (current_member_init_list, member_init);
1033 /* This is like `expand_member_init', only it stores one aggregate
1036 INIT comes in two flavors: it is either a value which
1037 is to be stored in EXP, or it is a parameter list
1038 to go to a constructor, which will operate on EXP.
1039 If INIT is not a parameter list for a constructor, then set
1040 LOOKUP_ONLYCONVERTING.
1041 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1042 the initializer, if FLAGS is 0, then it is the (init) form.
1043 If `init' is a CONSTRUCTOR, then we emit a warning message,
1044 explaining that such initializations are invalid.
1046 ALIAS_THIS is nonzero iff we are initializing something which is
1047 essentially an alias for current_class_ref. In this case, the base
1048 constructor may move it on us, and we must keep track of such
1051 If INIT resolves to a CALL_EXPR which happens to return
1052 something of the type we are looking for, then we know
1053 that we can safely use that call to perform the
1056 The virtual function table pointer cannot be set up here, because
1057 we do not really know its type.
1059 Virtual baseclass pointers are also set up here.
1061 This never calls operator=().
1063 When initializing, nothing is CONST.
1065 A default copy constructor may have to be used to perform the
1068 A constructor or a conversion operator may have to be used to
1069 perform the initialization, but not both, as it would be ambiguous. */
1072 expand_aggr_init (exp, init, flags)
1076 tree type = TREE_TYPE (exp);
1077 int was_const = TREE_READONLY (exp);
1078 int was_volatile = TREE_THIS_VOLATILE (exp);
1080 if (init == error_mark_node)
1083 TREE_READONLY (exp) = 0;
1084 TREE_THIS_VOLATILE (exp) = 0;
1086 if (init && TREE_CODE (init) != TREE_LIST)
1087 flags |= LOOKUP_ONLYCONVERTING;
1089 if (TREE_CODE (type) == ARRAY_TYPE)
1091 /* Must arrange to initialize each element of EXP
1092 from elements of INIT. */
1093 tree itype = init ? TREE_TYPE (init) : NULL_TREE;
1094 if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
1096 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1098 TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1100 if (init && TREE_TYPE (init) == NULL_TREE)
1102 /* Handle bad initializers like:
1106 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1110 int main(int argc, char **argv) {
1111 COMPLEX zees(1.0, 0.0)[10];
1114 error ("bad array initializer");
1117 expand_vec_init (exp, exp, array_type_nelts (type), init,
1118 init && same_type_p (TREE_TYPE (init),
1120 TREE_READONLY (exp) = was_const;
1121 TREE_THIS_VOLATILE (exp) = was_volatile;
1122 TREE_TYPE (exp) = type;
1124 TREE_TYPE (init) = itype;
1128 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1129 /* just know that we've seen something for this node */
1130 TREE_USED (exp) = 1;
1133 /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1134 constructor as parameters to an implicit GNU C++ constructor. */
1135 if (init && TREE_CODE (init) == CONSTRUCTOR
1136 && TYPE_HAS_CONSTRUCTOR (type)
1137 && TREE_TYPE (init) == type)
1138 init = CONSTRUCTOR_ELTS (init);
1141 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1142 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1143 init, LOOKUP_NORMAL|flags);
1144 TREE_TYPE (exp) = type;
1145 TREE_READONLY (exp) = was_const;
1146 TREE_THIS_VOLATILE (exp) = was_volatile;
1150 expand_default_init (binfo, true_exp, exp, init, flags)
1156 tree type = TREE_TYPE (exp);
1158 /* It fails because there may not be a constructor which takes
1159 its own type as the first (or only parameter), but which does
1160 take other types via a conversion. So, if the thing initializing
1161 the expression is a unit element of type X, first try X(X&),
1162 followed by initialization by X. If neither of these work
1163 out, then look hard. */
1167 if (init && TREE_CODE (init) != TREE_LIST
1168 && (flags & LOOKUP_ONLYCONVERTING))
1170 /* Base subobjects should only get direct-initialization. */
1171 if (true_exp != exp)
1174 if (flags & DIRECT_BIND)
1175 /* Do nothing. We hit this in two cases: Reference initialization,
1176 where we aren't initializing a real variable, so we don't want
1177 to run a new constructor; and catching an exception, where we
1178 have already built up the constructor call so we could wrap it
1179 in an exception region. */;
1181 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1183 if (TREE_CODE (init) == TRY_CATCH_EXPR)
1184 /* We need to protect the initialization of a catch parm
1185 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1186 around the TARGET_EXPR for the copy constructor. See
1187 expand_start_catch_block. */
1188 TREE_OPERAND (init, 0) = build (INIT_EXPR, TREE_TYPE (exp), exp,
1189 TREE_OPERAND (init, 0));
1191 init = build (INIT_EXPR, TREE_TYPE (exp), exp, init);
1192 TREE_SIDE_EFFECTS (init) = 1;
1193 expand_expr_stmt (init);
1197 if (init == NULL_TREE
1198 || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1202 init = TREE_VALUE (parms);
1205 parms = build_expr_list (NULL_TREE, init);
1207 if (TYPE_USES_VIRTUAL_BASECLASSES (type))
1209 if (true_exp == exp)
1210 parms = expr_tree_cons (NULL_TREE, integer_one_node, parms);
1212 parms = expr_tree_cons (NULL_TREE, integer_zero_node, parms);
1213 flags |= LOOKUP_HAS_IN_CHARGE;
1216 rval = build_method_call (exp, ctor_identifier,
1217 parms, binfo, flags);
1218 if (TREE_SIDE_EFFECTS (rval))
1219 expand_expr_stmt (rval);
1222 /* This function is responsible for initializing EXP with INIT
1225 BINFO is the binfo of the type for who we are performing the
1226 initialization. For example, if W is a virtual base class of A and B,
1228 If we are initializing B, then W must contain B's W vtable, whereas
1229 were we initializing C, W must contain C's W vtable.
1231 TRUE_EXP is nonzero if it is the true expression being initialized.
1232 In this case, it may be EXP, or may just contain EXP. The reason we
1233 need this is because if EXP is a base element of TRUE_EXP, we
1234 don't necessarily know by looking at EXP where its virtual
1235 baseclass fields should really be pointing. But we do know
1236 from TRUE_EXP. In constructors, we don't know anything about
1237 the value being initialized.
1239 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1241 FLAGS is just passes to `build_method_call'. See that function for
1245 expand_aggr_init_1 (binfo, true_exp, exp, init, flags)
1251 tree type = TREE_TYPE (exp);
1253 my_friendly_assert (init != error_mark_node && type != error_mark_node, 211);
1255 /* Use a function returning the desired type to initialize EXP for us.
1256 If the function is a constructor, and its first argument is
1257 NULL_TREE, know that it was meant for us--just slide exp on
1258 in and expand the constructor. Constructors now come
1261 if (init && TREE_CODE (exp) == VAR_DECL
1262 && TREE_CODE (init) == CONSTRUCTOR
1263 && TREE_HAS_CONSTRUCTOR (init))
1265 tree t = store_init_value (exp, init);
1268 expand_decl_init (exp);
1271 t = build (INIT_EXPR, type, exp, init);
1272 TREE_SIDE_EFFECTS (t) = 1;
1273 expand_expr_stmt (t);
1277 /* We know that expand_default_init can handle everything we want
1279 expand_default_init (binfo, true_exp, exp, init, flags);
1282 /* Report an error if NAME is not the name of a user-defined,
1283 aggregate type. If OR_ELSE is nonzero, give an error message. */
1286 is_aggr_typedef (name, or_else)
1292 if (name == error_mark_node)
1295 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1296 type = IDENTIFIER_TYPE_VALUE (name);
1300 cp_error ("`%T' is not an aggregate typedef", name);
1304 if (! IS_AGGR_TYPE (type)
1305 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1306 && TREE_CODE (type) != TEMPLATE_TEMPLATE_PARM)
1309 cp_error ("`%T' is not an aggregate type", type);
1315 /* Report an error if TYPE is not a user-defined, aggregate type. If
1316 OR_ELSE is nonzero, give an error message. */
1319 is_aggr_type (type, or_else)
1323 if (type == error_mark_node)
1326 if (! IS_AGGR_TYPE (type)
1327 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1328 && TREE_CODE (type) != TEMPLATE_TEMPLATE_PARM)
1331 cp_error ("`%T' is not an aggregate type", type);
1337 /* Like is_aggr_typedef, but returns typedef if successful. */
1340 get_aggr_from_typedef (name, or_else)
1346 if (name == error_mark_node)
1349 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1350 type = IDENTIFIER_TYPE_VALUE (name);
1354 cp_error ("`%T' fails to be an aggregate typedef", name);
1358 if (! IS_AGGR_TYPE (type)
1359 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1360 && TREE_CODE (type) != TEMPLATE_TEMPLATE_PARM)
1363 cp_error ("type `%T' is of non-aggregate type", type);
1370 get_type_value (name)
1373 if (name == error_mark_node)
1376 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1377 return IDENTIFIER_TYPE_VALUE (name);
1383 /* This code could just as well go in `class.c', but is placed here for
1386 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1387 the appropriate function call. */
1390 build_member_call (type, name, parmlist)
1391 tree type, name, parmlist;
1396 tree basetype_path, decl;
1398 if (TREE_CODE (name) == TEMPLATE_ID_EXPR
1399 && TREE_CODE (type) == NAMESPACE_DECL)
1401 /* 'name' already refers to the decls from the namespace, since we
1402 hit do_identifier for template_ids. */
1403 method_name = TREE_OPERAND (name, 0);
1404 /* FIXME: Since we don't do independent names right yet, the
1405 name might also be a LOOKUP_EXPR. Once we resolve this to a
1406 real decl earlier, this can go. This may happen during
1408 if (TREE_CODE (method_name) == LOOKUP_EXPR)
1410 method_name = lookup_namespace_name
1411 (type, TREE_OPERAND (method_name, 0));
1412 TREE_OPERAND (name, 0) = method_name;
1414 my_friendly_assert (is_overloaded_fn (method_name), 980519);
1415 return build_x_function_call (name, parmlist, current_class_ref);
1418 if (type == std_node)
1419 return build_x_function_call (do_scoped_id (name, 0), parmlist,
1421 if (TREE_CODE (type) == NAMESPACE_DECL)
1422 return build_x_function_call (lookup_namespace_name (type, name),
1423 parmlist, current_class_ref);
1425 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1427 method_name = TREE_OPERAND (name, 0);
1428 if (TREE_CODE (method_name) == COMPONENT_REF)
1429 method_name = TREE_OPERAND (method_name, 1);
1430 if (is_overloaded_fn (method_name))
1431 method_name = DECL_NAME (OVL_CURRENT (method_name));
1432 TREE_OPERAND (name, 0) = method_name;
1437 if (TREE_CODE (method_name) == BIT_NOT_EXPR)
1439 method_name = TREE_OPERAND (method_name, 0);
1443 /* This shouldn't be here, and build_member_call shouldn't appear in
1445 if (type && TREE_CODE (type) == IDENTIFIER_NODE
1446 && get_aggr_from_typedef (type, 0) == 0)
1448 tree ns = lookup_name (type, 0);
1449 if (ns && TREE_CODE (ns) == NAMESPACE_DECL)
1451 return build_x_function_call (build_offset_ref (type, name), parmlist, current_class_ref);
1455 if (type == NULL_TREE || ! is_aggr_type (type, 1))
1456 return error_mark_node;
1458 /* An operator we did not like. */
1459 if (name == NULL_TREE)
1460 return error_mark_node;
1464 cp_error ("cannot call destructor `%T::~%T' without object", type,
1466 return error_mark_node;
1469 decl = maybe_dummy_object (type, &basetype_path);
1471 /* Convert 'this' to the specified type to disambiguate conversion
1472 to the function's context. Apparently Standard C++ says that we
1473 shouldn't do this. */
1474 if (decl == current_class_ref
1476 && ACCESSIBLY_UNIQUELY_DERIVED_P (type, current_class_type))
1478 tree olddecl = current_class_ptr;
1479 tree oldtype = TREE_TYPE (TREE_TYPE (olddecl));
1480 if (oldtype != type)
1482 tree newtype = build_qualified_type (type, TYPE_QUALS (oldtype));
1483 decl = convert_force (build_pointer_type (newtype), olddecl, 0);
1484 decl = build_indirect_ref (decl, NULL_PTR);
1488 if (method_name == constructor_name (type)
1489 || method_name == constructor_name_full (type))
1490 return build_functional_cast (type, parmlist);
1491 if (lookup_fnfields (basetype_path, method_name, 0))
1492 return build_method_call (decl,
1493 TREE_CODE (name) == TEMPLATE_ID_EXPR
1494 ? name : method_name,
1495 parmlist, basetype_path,
1496 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL);
1497 if (TREE_CODE (name) == IDENTIFIER_NODE
1498 && ((t = lookup_field (TYPE_BINFO (type), name, 1, 0))))
1500 if (t == error_mark_node)
1501 return error_mark_node;
1502 if (TREE_CODE (t) == FIELD_DECL)
1504 if (is_dummy_object (decl))
1506 cp_error ("invalid use of non-static field `%D'", t);
1507 return error_mark_node;
1509 decl = build (COMPONENT_REF, TREE_TYPE (t), decl, t);
1511 else if (TREE_CODE (t) == VAR_DECL)
1515 cp_error ("invalid use of member `%D'", t);
1516 return error_mark_node;
1518 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl)))
1519 return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl,
1520 parmlist, NULL_TREE);
1521 return build_function_call (decl, parmlist);
1525 cp_error ("no method `%T::%D'", type, name);
1526 return error_mark_node;
1530 /* Build a reference to a member of an aggregate. This is not a
1531 C++ `&', but really something which can have its address taken,
1532 and then act as a pointer to member, for example TYPE :: FIELD
1533 can have its address taken by saying & TYPE :: FIELD.
1535 @@ Prints out lousy diagnostics for operator <typename>
1538 @@ This function should be rewritten and placed in search.c. */
1541 build_offset_ref (type, name)
1544 tree decl, t = error_mark_node;
1546 tree basebinfo = NULL_TREE;
1547 tree orig_name = name;
1549 /* class templates can come in as TEMPLATE_DECLs here. */
1550 if (TREE_CODE (name) == TEMPLATE_DECL)
1553 if (type == std_node)
1554 return do_scoped_id (name, 0);
1556 if (processing_template_decl || uses_template_parms (type))
1557 return build_min_nt (SCOPE_REF, type, name);
1559 /* Handle namespace names fully here. */
1560 if (TREE_CODE (type) == NAMESPACE_DECL)
1562 t = lookup_namespace_name (type, name);
1563 if (t != error_mark_node && ! type_unknown_p (t))
1566 t = convert_from_reference (t);
1571 if (type == NULL_TREE || ! is_aggr_type (type, 1))
1572 return error_mark_node;
1574 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1576 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1577 something like `a.template f<int>' or the like. For the most
1578 part, we treat this just like a.f. We do remember, however,
1579 the template-id that was used. */
1580 name = TREE_OPERAND (orig_name, 0);
1582 if (TREE_CODE (name) == LOOKUP_EXPR)
1583 /* This can happen during tsubst'ing. */
1584 name = TREE_OPERAND (name, 0);
1586 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
1589 if (TREE_CODE (name) == BIT_NOT_EXPR)
1591 if (! check_dtor_name (type, name))
1592 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1593 type, TREE_OPERAND (name, 0));
1594 name = dtor_identifier;
1597 /* I think this is wrong, but the draft is unclear. --jason 6/15/98 */
1598 else if (name == constructor_name_full (type)
1599 || name == constructor_name (type))
1600 name = ctor_identifier;
1603 if (TYPE_SIZE (complete_type (type)) == 0
1604 && !TYPE_BEING_DEFINED (type))
1606 cp_error ("incomplete type `%T' does not have member `%D'", type,
1608 return error_mark_node;
1611 decl = maybe_dummy_object (type, &basebinfo);
1613 member = lookup_member (basebinfo, name, 1, 0);
1615 if (member == error_mark_node)
1616 return error_mark_node;
1618 /* A lot of this logic is now handled in lookup_field and
1620 if (member && BASELINK_P (member))
1622 /* Go from the TREE_BASELINK to the member function info. */
1623 tree fnfields = member;
1624 t = TREE_VALUE (fnfields);
1626 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1628 /* The FNFIELDS are going to contain functions that aren't
1629 necessarily templates, and templates that don't
1630 necessarily match the explicit template parameters. We
1631 save all the functions, and the explicit parameters, and
1632 then figure out exactly what to instantiate with what
1633 arguments in instantiate_type. */
1635 if (TREE_CODE (t) != OVERLOAD)
1636 /* The code in instantiate_type which will process this
1637 expects to encounter OVERLOADs, not raw functions. */
1638 t = ovl_cons (t, NULL_TREE);
1640 return build (OFFSET_REF,
1643 build (TEMPLATE_ID_EXPR,
1646 TREE_OPERAND (orig_name, 1)));
1649 if (!really_overloaded_fn (t))
1651 /* Get rid of a potential OVERLOAD around it */
1652 t = OVL_CURRENT (t);
1654 /* unique functions are handled easily. */
1655 basebinfo = TREE_PURPOSE (fnfields);
1656 if (!enforce_access (basebinfo, t))
1657 return error_mark_node;
1659 if (DECL_STATIC_FUNCTION_P (t))
1661 return build (OFFSET_REF, TREE_TYPE (t), decl, t);
1664 /* FNFIELDS is most likely allocated on the search_obstack,
1665 which will go away after this class scope. If we need
1666 to save this value for later (i.e. for use as an initializer
1667 for a static variable), then do so here.
1669 ??? The smart thing to do for the case of saving initializers
1670 is to resolve them before we're done with this scope. */
1671 if (!TREE_PERMANENT (fnfields)
1672 && ! allocation_temporary_p ())
1673 fnfields = copy_list (fnfields);
1675 TREE_TYPE (fnfields) = unknown_type_node;
1676 return build (OFFSET_REF, unknown_type_node, decl, fnfields);
1683 cp_error ("`%D' is not a member of type `%T'", name, type);
1684 return error_mark_node;
1687 if (TREE_CODE (t) == TYPE_DECL)
1692 /* static class members and class-specific enum
1693 values can be returned without further ado. */
1694 if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == CONST_DECL)
1697 return convert_from_reference (t);
1700 if (TREE_CODE (t) == FIELD_DECL && DECL_C_BIT_FIELD (t))
1702 cp_error ("illegal pointer to bit field `%D'", t);
1703 return error_mark_node;
1706 /* static class functions too. */
1707 if (TREE_CODE (t) == FUNCTION_DECL
1708 && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
1709 my_friendly_abort (53);
1711 /* In member functions, the form `type::name' is no longer
1712 equivalent to `this->type::name', at least not until
1713 resolve_offset_ref. */
1714 return build (OFFSET_REF, build_offset_type (type, TREE_TYPE (t)), decl, t);
1717 /* If a OFFSET_REF made it through to here, then it did
1718 not have its address taken. */
1721 resolve_offset_ref (exp)
1724 tree type = TREE_TYPE (exp);
1725 tree base = NULL_TREE;
1727 tree basetype, addr;
1729 if (TREE_CODE (exp) == OFFSET_REF)
1731 member = TREE_OPERAND (exp, 1);
1732 base = TREE_OPERAND (exp, 0);
1736 my_friendly_assert (TREE_CODE (type) == OFFSET_TYPE, 214);
1737 if (TYPE_OFFSET_BASETYPE (type) != current_class_type)
1739 error ("object missing in use of pointer-to-member construct");
1740 return error_mark_node;
1743 type = TREE_TYPE (type);
1744 base = current_class_ref;
1747 if (BASELINK_P (member))
1749 cp_pedwarn ("assuming & on overloaded member function");
1750 return build_unary_op (ADDR_EXPR, exp, 0);
1753 if (TREE_CODE (TREE_TYPE (member)) == METHOD_TYPE)
1755 cp_pedwarn ("assuming & on `%E'", member);
1756 return build_unary_op (ADDR_EXPR, exp, 0);
1759 if ((TREE_CODE (member) == VAR_DECL
1760 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member))
1761 && ! TYPE_PTRMEM_P (TREE_TYPE (member)))
1762 || TREE_CODE (TREE_TYPE (member)) == FUNCTION_TYPE)
1764 /* These were static members. */
1765 if (mark_addressable (member) == 0)
1766 return error_mark_node;
1770 if (TREE_CODE (TREE_TYPE (member)) == POINTER_TYPE
1771 && TREE_CODE (TREE_TYPE (TREE_TYPE (member))) == METHOD_TYPE)
1774 /* Syntax error can cause a member which should
1775 have been seen as static to be grok'd as non-static. */
1776 if (TREE_CODE (member) == FIELD_DECL && current_class_ref == NULL_TREE)
1778 if (TREE_ADDRESSABLE (member) == 0)
1780 cp_error_at ("member `%D' is non-static but referenced as a static member",
1782 error ("at this point in file");
1783 TREE_ADDRESSABLE (member) = 1;
1785 return error_mark_node;
1788 /* The first case is really just a reference to a member of `this'. */
1789 if (TREE_CODE (member) == FIELD_DECL
1790 && (base == current_class_ref || is_dummy_object (base)))
1795 if (TREE_CODE (exp) == OFFSET_REF && TREE_CODE (type) == OFFSET_TYPE)
1796 basetype = TYPE_OFFSET_BASETYPE (type);
1798 basetype = DECL_CONTEXT (member);
1800 base = current_class_ptr;
1802 if (get_base_distance (basetype, TREE_TYPE (TREE_TYPE (base)), 0, &basetype_path) < 0)
1804 error_not_base_type (basetype, TREE_TYPE (TREE_TYPE (base)));
1805 return error_mark_node;
1807 /* Kludge: we need to use basetype_path now, because
1808 convert_pointer_to will bash it. */
1809 enforce_access (basetype_path, member);
1810 addr = convert_pointer_to (basetype, base);
1812 /* Even in the case of illegal access, we form the
1813 COMPONENT_REF; that will allow better error recovery than
1814 just feeding back error_mark_node. */
1815 expr = build (COMPONENT_REF, TREE_TYPE (member),
1816 build_indirect_ref (addr, NULL_PTR), member);
1817 return convert_from_reference (expr);
1820 /* Ensure that we have an object. */
1821 if (is_dummy_object (base))
1822 addr = error_mark_node;
1824 /* If this is a reference to a member function, then return the
1825 address of the member function (which may involve going
1826 through the object's vtable), otherwise, return an expression
1827 for the dereferenced pointer-to-member construct. */
1828 addr = build_unary_op (ADDR_EXPR, base, 0);
1830 if (TYPE_PTRMEM_P (TREE_TYPE (member)))
1832 if (addr == error_mark_node)
1834 cp_error ("object missing in `%E'", exp);
1835 return error_mark_node;
1838 basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member)));
1839 addr = convert_pointer_to (basetype, addr);
1840 member = cp_convert (ptrdiff_type_node, member);
1842 /* Pointer to data members are offset by one, so that a null
1843 pointer with a real value of 0 is distinguishable from an
1844 offset of the first member of a structure. */
1845 member = build_binary_op (MINUS_EXPR, member,
1846 cp_convert (ptrdiff_type_node, integer_one_node));
1848 return build1 (INDIRECT_REF, type,
1849 build (PLUS_EXPR, build_pointer_type (type),
1852 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member)))
1854 return get_member_function_from_ptrfunc (&addr, member);
1856 my_friendly_abort (56);
1861 /* Return either DECL or its known constant value (if it has one). */
1864 decl_constant_value (decl)
1867 if (! TREE_THIS_VOLATILE (decl)
1868 && DECL_INITIAL (decl)
1869 && DECL_INITIAL (decl) != error_mark_node
1870 /* This is invalid if initial value is not constant.
1871 If it has either a function call, a memory reference,
1872 or a variable, then re-evaluating it could give different results. */
1873 && TREE_CONSTANT (DECL_INITIAL (decl))
1874 /* Check for cases where this is sub-optimal, even though valid. */
1875 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1876 return DECL_INITIAL (decl);
1880 /* Common subroutines of build_new and build_vec_delete. */
1882 /* Call the global __builtin_delete to delete ADDR. */
1885 build_builtin_delete_call (addr)
1888 mark_used (global_delete_fndecl);
1889 return build_call (global_delete_fndecl,
1890 void_type_node, build_expr_list (NULL_TREE, addr));
1893 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1894 (which needs to go through some sort of groktypename) or it
1895 is the name of the class we are newing. INIT is an initialization value.
1896 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1897 If INIT is void_type_node, it means do *not* call a constructor
1900 For types with constructors, the data returned is initialized
1901 by the appropriate constructor.
1903 Whether the type has a constructor or not, if it has a pointer
1904 to a virtual function table, then that pointer is set up
1907 Unless I am mistaken, a call to new () will return initialized
1908 data regardless of whether the constructor itself is private or
1909 not. NOPE; new fails if the constructor is private (jcm).
1911 Note that build_new does nothing to assure that any special
1912 alignment requirements of the type are met. Rather, it leaves
1913 it up to malloc to do the right thing. Otherwise, folding to
1914 the right alignment cal cause problems if the user tries to later
1915 free the memory returned by `new'.
1917 PLACEMENT is the `placement' list for user-defined operator new (). */
1919 extern int flag_check_new;
1922 build_new (placement, decl, init, use_global_new)
1928 tree nelts = NULL_TREE, t;
1931 tree pending_sizes = NULL_TREE;
1933 if (decl == error_mark_node)
1934 return error_mark_node;
1936 if (TREE_CODE (decl) == TREE_LIST)
1938 tree absdcl = TREE_VALUE (decl);
1939 tree last_absdcl = NULL_TREE;
1940 int old_immediate_size_expand = 0;
1942 if (current_function_decl
1943 && DECL_CONSTRUCTOR_P (current_function_decl))
1945 old_immediate_size_expand = immediate_size_expand;
1946 immediate_size_expand = 0;
1949 nelts = integer_one_node;
1951 if (absdcl && TREE_CODE (absdcl) == CALL_EXPR)
1952 my_friendly_abort (215);
1953 while (absdcl && TREE_CODE (absdcl) == INDIRECT_REF)
1955 last_absdcl = absdcl;
1956 absdcl = TREE_OPERAND (absdcl, 0);
1959 if (absdcl && TREE_CODE (absdcl) == ARRAY_REF)
1961 /* probably meant to be a vec new */
1964 while (TREE_OPERAND (absdcl, 0)
1965 && TREE_CODE (TREE_OPERAND (absdcl, 0)) == ARRAY_REF)
1967 last_absdcl = absdcl;
1968 absdcl = TREE_OPERAND (absdcl, 0);
1972 this_nelts = TREE_OPERAND (absdcl, 1);
1973 if (this_nelts != error_mark_node)
1975 if (this_nelts == NULL_TREE)
1976 error ("new of array type fails to specify size");
1977 else if (processing_template_decl)
1980 absdcl = TREE_OPERAND (absdcl, 0);
1984 int flags = pedantic ? WANT_INT : (WANT_INT | WANT_ENUM);
1985 if (build_expr_type_conversion (flags, this_nelts, 0)
1987 pedwarn ("size in array new must have integral type");
1989 this_nelts = save_expr (cp_convert (sizetype, this_nelts));
1990 absdcl = TREE_OPERAND (absdcl, 0);
1991 if (this_nelts == integer_zero_node)
1993 warning ("zero size array reserves no space");
1994 nelts = integer_zero_node;
1997 nelts = build_binary_op (MULT_EXPR, nelts, this_nelts);
2001 nelts = integer_zero_node;
2005 TREE_OPERAND (last_absdcl, 0) = absdcl;
2007 TREE_VALUE (decl) = absdcl;
2009 type = groktypename (decl);
2010 if (! type || type == error_mark_node)
2012 immediate_size_expand = old_immediate_size_expand;
2013 return error_mark_node;
2016 if (current_function_decl
2017 && DECL_CONSTRUCTOR_P (current_function_decl))
2019 pending_sizes = get_pending_sizes ();
2020 immediate_size_expand = old_immediate_size_expand;
2023 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
2025 if (IDENTIFIER_HAS_TYPE_VALUE (decl))
2027 /* An aggregate type. */
2028 type = IDENTIFIER_TYPE_VALUE (decl);
2029 decl = TYPE_MAIN_DECL (type);
2033 /* A builtin type. */
2034 decl = lookup_name (decl, 1);
2035 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 215);
2036 type = TREE_TYPE (decl);
2039 else if (TREE_CODE (decl) == TYPE_DECL)
2041 type = TREE_TYPE (decl);
2046 decl = TYPE_MAIN_DECL (type);
2049 if (processing_template_decl)
2052 t = min_tree_cons (min_tree_cons (NULL_TREE, type, NULL_TREE),
2053 build_min_nt (ARRAY_REF, NULL_TREE, nelts),
2058 rval = build_min_nt (NEW_EXPR, placement, t, init);
2059 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
2063 /* ``A reference cannot be created by the new operator. A reference
2064 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2065 returned by new.'' ARM 5.3.3 */
2066 if (TREE_CODE (type) == REFERENCE_TYPE)
2068 error ("new cannot be applied to a reference type");
2069 type = TREE_TYPE (type);
2072 if (TREE_CODE (type) == FUNCTION_TYPE)
2074 error ("new cannot be applied to a function type");
2075 return error_mark_node;
2078 /* When the object being created is an array, the new-expression yields a
2079 pointer to the initial element (if any) of the array. For example,
2080 both new int and new int[10] return an int*. 5.3.4. */
2081 if (TREE_CODE (type) == ARRAY_TYPE && has_array == 0)
2083 nelts = array_type_nelts_top (type);
2085 type = TREE_TYPE (type);
2089 t = build_nt (ARRAY_REF, type, nelts);
2093 rval = build (NEW_EXPR, build_pointer_type (type), placement, t, init);
2094 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
2095 TREE_SIDE_EFFECTS (rval) = 1;
2097 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2098 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2099 TREE_NO_UNUSED_WARNING (rval) = 1;
2102 rval = build_compound_expr (chainon (pending_sizes,
2103 build_expr_list (NULL_TREE, rval)));
2108 /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */
2110 static tree jclass_node = NULL_TREE;
2112 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2115 build_java_class_ref (type)
2118 tree name, class_decl;
2119 static tree CL_prefix = NULL_TREE;
2120 if (CL_prefix == NULL_TREE)
2121 CL_prefix = get_identifier("_CL_");
2122 if (jclass_node == NULL_TREE)
2124 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2125 if (jclass_node == NULL_TREE)
2126 fatal("call to Java constructor, while `jclass' undefined");
2127 jclass_node = TREE_TYPE (jclass_node);
2129 name = build_overload_with_type (CL_prefix, type);
2130 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2131 if (class_decl == NULL_TREE)
2133 push_obstacks_nochange ();
2134 end_temporary_allocation ();
2135 class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
2136 TREE_STATIC (class_decl) = 1;
2137 DECL_EXTERNAL (class_decl) = 1;
2138 TREE_PUBLIC (class_decl) = 1;
2139 DECL_ARTIFICIAL (class_decl) = 1;
2140 DECL_IGNORED_P (class_decl) = 1;
2141 pushdecl_top_level (class_decl);
2142 make_decl_rtl (class_decl, NULL_PTR, 1);
2148 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2149 value is immediately handed to expand_expr. */
2155 tree placement, init;
2156 tree type, true_type, size, rval;
2157 tree nelts = NULL_TREE;
2158 tree alloc_expr, alloc_node = NULL_TREE;
2160 enum tree_code code = NEW_EXPR;
2161 int use_cookie, nothrow, check_new;
2163 int use_java_new = 0;
2165 placement = TREE_OPERAND (exp, 0);
2166 type = TREE_OPERAND (exp, 1);
2167 init = TREE_OPERAND (exp, 2);
2168 use_global_new = NEW_EXPR_USE_GLOBAL (exp);
2170 if (TREE_CODE (type) == ARRAY_REF)
2173 nelts = TREE_OPERAND (type, 1);
2174 type = TREE_OPERAND (type, 0);
2178 if (CP_TYPE_QUALS (type))
2179 type = TYPE_MAIN_VARIANT (type);
2181 /* If our base type is an array, then make sure we know how many elements
2183 while (TREE_CODE (true_type) == ARRAY_TYPE)
2185 tree this_nelts = array_type_nelts_top (true_type);
2186 nelts = build_binary_op (MULT_EXPR, nelts, this_nelts);
2187 true_type = TREE_TYPE (true_type);
2190 if (!complete_type_or_else (true_type, exp))
2191 return error_mark_node;
2194 size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type),
2197 size = size_in_bytes (type);
2199 if (TREE_CODE (true_type) == VOID_TYPE)
2201 error ("invalid type `void' for new");
2202 return error_mark_node;
2205 if (TYPE_LANG_SPECIFIC (true_type)
2206 && CLASSTYPE_ABSTRACT_VIRTUALS (true_type))
2208 abstract_virtuals_error (NULL_TREE, true_type);
2209 return error_mark_node;
2212 if (TYPE_LANG_SPECIFIC (true_type) && IS_SIGNATURE (true_type))
2214 signature_error (NULL_TREE, true_type);
2215 return error_mark_node;
2218 /* When we allocate an array, and the corresponding deallocation
2219 function takes a second argument of type size_t, and that's the
2220 "usual deallocation function", we allocate some extra space at
2221 the beginning of the array to store the size of the array.
2223 Well, that's what we should do. For backwards compatibility, we
2224 have to do this whenever there's a two-argument array-delete
2227 FIXME: For -fnew-abi, we don't have to maintain backwards
2228 compatibility and we should fix this. */
2229 use_cookie = (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type)
2230 && ! (placement && ! TREE_CHAIN (placement)
2231 && TREE_TYPE (TREE_VALUE (placement)) == ptr_type_node));
2235 tree extra = BI_header_size;
2237 size = size_binop (PLUS_EXPR, size, extra);
2242 code = VEC_NEW_EXPR;
2244 if (init && pedantic)
2245 cp_pedwarn ("initialization in array new");
2248 /* Allocate the object. */
2250 if (! has_array && ! placement && flag_this_is_variable > 0
2251 && TYPE_NEEDS_CONSTRUCTING (true_type) && init != void_type_node)
2253 if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST)
2257 error ("constructors take parameter lists");
2258 return error_mark_node;
2261 else if (! placement && TYPE_FOR_JAVA (true_type))
2263 tree class_addr, alloc_decl;
2264 tree class_decl = build_java_class_ref (true_type);
2265 tree class_size = size_in_bytes (true_type);
2266 static char alloc_name[] = "_Jv_AllocObject";
2268 alloc_decl = IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name));
2269 if (alloc_decl == NULL_TREE)
2270 fatal("call to Java constructor, while `%s' undefined", alloc_name);
2271 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2272 rval = build_function_call (alloc_decl,
2273 tree_cons (NULL_TREE, class_addr,
2274 build_tree_list (NULL_TREE,
2276 rval = cp_convert (build_pointer_type (true_type), rval);
2282 if (flag_exceptions)
2283 /* We will use RVAL when generating an exception handler for
2284 this new-expression, so we must save it. */
2285 susp = suspend_momentary ();
2287 rval = build_op_new_call
2288 (code, true_type, expr_tree_cons (NULL_TREE, size, placement),
2289 LOOKUP_NORMAL | (use_global_new * LOOKUP_GLOBAL));
2290 rval = cp_convert (build_pointer_type (true_type), rval);
2292 if (flag_exceptions)
2293 resume_momentary (susp);
2296 /* unless an allocation function is declared with an empty excep-
2297 tion-specification (_except.spec_), throw(), it indicates failure to
2298 allocate storage by throwing a bad_alloc exception (clause _except_,
2299 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2300 cation function is declared with an empty exception-specification,
2301 throw(), it returns null to indicate failure to allocate storage and a
2302 non-null pointer otherwise.
2304 So check for a null exception spec on the op new we just called. */
2309 /* The CALL_EXPR. */
2310 tree t = TREE_OPERAND (rval, 0);
2312 t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
2313 nothrow = TYPE_NOTHROW_P (TREE_TYPE (t));
2315 check_new = (flag_check_new || nothrow) && ! use_java_new;
2317 if ((check_new || flag_exceptions) && rval)
2319 alloc_expr = get_target_expr (rval);
2320 alloc_node = rval = TREE_OPERAND (alloc_expr, 0);
2323 alloc_expr = NULL_TREE;
2325 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2326 sure we have some extra bytes in that case for the BI_header_size
2327 cookies? And how does that interact with the code below? (mrs) */
2328 /* Finish up some magic for new'ed arrays */
2329 if (use_cookie && rval != NULL_TREE)
2331 tree extra = BI_header_size;
2333 rval = convert (string_type_node, rval); /* for ptr arithmetic */
2334 rval = save_expr (build_binary_op (PLUS_EXPR, rval, extra));
2335 /* Store header info. */
2336 cookie = build_indirect_ref (build (MINUS_EXPR,
2337 build_pointer_type (BI_header_type),
2338 rval, extra), NULL_PTR);
2339 exp1 = build (MODIFY_EXPR, void_type_node,
2340 build_component_ref (cookie, nc_nelts_field_id,
2343 TREE_SIDE_EFFECTS (exp1) = 1;
2344 rval = cp_convert (build_pointer_type (true_type), rval);
2345 rval = build_compound_expr
2346 (expr_tree_cons (NULL_TREE, exp1,
2347 build_expr_list (NULL_TREE, rval)));
2350 if (rval == error_mark_node)
2351 return error_mark_node;
2353 /* Don't call any constructors or do any initialization. */
2354 if (init == void_type_node)
2357 if (TYPE_NEEDS_CONSTRUCTING (type) || init)
2359 if (! TYPE_NEEDS_CONSTRUCTING (type)
2360 && ! IS_AGGR_TYPE (type) && ! has_array)
2362 /* We are processing something like `new int (10)', which
2363 means allocate an int, and initialize it with 10. */
2367 /* At present RVAL is a temporary variable, created to hold
2368 the value from the call to `operator new'. We transform
2369 it to (*RVAL = INIT, RVAL). */
2370 rval = save_expr (rval);
2371 deref = build_indirect_ref (rval, NULL_PTR);
2373 /* Even for something like `new const int (10)' we must
2374 allow the expression to be non-const while we do the
2376 deref_type = TREE_TYPE (deref);
2377 if (CP_TYPE_CONST_P (deref_type))
2379 = cp_build_qualified_type (deref_type,
2380 CP_TYPE_QUALS (deref_type)
2381 & ~TYPE_QUAL_CONST);
2382 TREE_READONLY (deref) = 0;
2384 if (TREE_CHAIN (init) != NULL_TREE)
2385 pedwarn ("initializer list being treated as compound expression");
2386 else if (TREE_CODE (init) == CONSTRUCTOR)
2388 pedwarn ("initializer list appears where operand should be used");
2389 init = TREE_OPERAND (init, 1);
2391 init = build_compound_expr (init);
2393 init = convert_for_initialization (deref, type, init, LOOKUP_NORMAL,
2394 "new", NULL_TREE, 0);
2395 rval = build (COMPOUND_EXPR, TREE_TYPE (rval),
2396 build_modify_expr (deref, NOP_EXPR, init),
2398 TREE_NO_UNUSED_WARNING (rval) = 1;
2399 TREE_SIDE_EFFECTS (rval) = 1;
2401 else if (! has_array)
2404 /* Constructors are never virtual. If it has an initialization, we
2405 need to complain if we aren't allowed to use the ctor that took
2407 int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_COMPLAIN;
2409 if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type))
2411 init = expr_tree_cons (NULL_TREE, integer_one_node, init);
2412 flags |= LOOKUP_HAS_IN_CHARGE;
2416 rval = save_expr (rval);
2419 if (newrval && TREE_CODE (TREE_TYPE (newrval)) == POINTER_TYPE)
2420 newrval = build_indirect_ref (newrval, NULL_PTR);
2422 newrval = build_method_call (newrval, ctor_identifier,
2423 init, TYPE_BINFO (true_type), flags);
2425 if (newrval == NULL_TREE || newrval == error_mark_node)
2426 return error_mark_node;
2428 /* Java constructors compiled by jc1 do not return this. */
2430 newrval = build (COMPOUND_EXPR, TREE_TYPE (newrval),
2433 TREE_HAS_CONSTRUCTOR (rval) = 1;
2436 rval = build (VEC_INIT_EXPR, TREE_TYPE (rval),
2437 save_expr (rval), init, nelts);
2439 /* If any part of the object initialization terminates by throwing an
2440 exception and a suitable deallocation function can be found, the
2441 deallocation function is called to free the memory in which the
2442 object was being constructed, after which the exception continues
2443 to propagate in the context of the new-expression. If no
2444 unambiguous matching deallocation function can be found,
2445 propagating the exception does not cause the object's memory to be
2447 if (flag_exceptions && alloc_expr && ! use_java_new)
2449 enum tree_code dcode = has_array ? VEC_DELETE_EXPR : DELETE_EXPR;
2450 tree cleanup, fn = NULL_TREE;
2451 int flags = LOOKUP_NORMAL | (use_global_new * LOOKUP_GLOBAL);
2453 /* All cleanups must last longer than normal. */
2454 int yes = suspend_momentary ();
2458 flags |= LOOKUP_SPECULATIVELY;
2460 /* We expect alloc_expr to look like a TARGET_EXPR around
2461 a NOP_EXPR around the CALL_EXPR we want. */
2462 fn = TREE_OPERAND (alloc_expr, 1);
2463 fn = TREE_OPERAND (fn, 0);
2466 /* Copy size to the saveable obstack. */
2467 size = mapcar (size, permanent_p);
2469 cleanup = build_op_delete_call (dcode, alloc_node, size, flags, fn);
2471 resume_momentary (yes);
2473 /* Ack! First we allocate the memory. Then we set our sentry
2474 variable to true, and expand a cleanup that deletes the memory
2475 if sentry is true. Then we run the constructor and store the
2476 returned pointer in buf. Then we clear sentry and return buf. */
2480 tree end, sentry, begin, buf, t = TREE_TYPE (rval);
2482 begin = get_target_expr (boolean_true_node);
2483 sentry = TREE_OPERAND (begin, 0);
2485 yes = suspend_momentary ();
2486 TREE_OPERAND (begin, 2)
2487 = build (COND_EXPR, void_type_node, sentry,
2488 cleanup, void_zero_node);
2489 resume_momentary (yes);
2491 rval = get_target_expr (rval);
2493 end = build (MODIFY_EXPR, TREE_TYPE (sentry),
2494 sentry, boolean_false_node);
2495 TREE_SIDE_EFFECTS (end) = 1;
2497 buf = TREE_OPERAND (rval, 0);
2499 rval = build (COMPOUND_EXPR, t, begin,
2500 build (COMPOUND_EXPR, t, rval,
2501 build (COMPOUND_EXPR, t, end, buf)));
2505 else if (CP_TYPE_CONST_P (true_type))
2506 cp_error ("uninitialized const in `new' of `%#T'", true_type);
2510 if (alloc_expr && rval == alloc_node)
2512 rval = TREE_OPERAND (alloc_expr, 1);
2513 alloc_expr = NULL_TREE;
2516 if (check_new && alloc_expr)
2518 /* Did we modify the storage? */
2519 tree ifexp = build_binary_op (NE_EXPR, alloc_node,
2521 rval = build_conditional_expr (ifexp, rval, alloc_node);
2525 rval = build (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2527 if (rval && TREE_TYPE (rval) != build_pointer_type (type))
2529 /* The type of new int [3][3] is not int *, but int [3] * */
2530 rval = build_c_cast (build_pointer_type (type), rval);
2537 build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
2539 tree base, maxindex, type;
2540 tree auto_delete_vec, auto_delete;
2541 int use_global_delete;
2544 tree ptype = build_pointer_type (type = complete_type (type));
2545 tree size_exp = size_in_bytes (type);
2547 /* Temporary variables used by the loop. */
2548 tree tbase, tbase_init;
2550 /* This is the body of the loop that implements the deletion of a
2551 single element, and moves temp variables to next elements. */
2554 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2557 /* This is the thing that governs what to do after the loop has run. */
2558 tree deallocate_expr = 0;
2560 /* This is the BIND_EXPR which holds the outermost iterator of the
2561 loop. It is convenient to set this variable up and test it before
2562 executing any other code in the loop.
2563 This is also the containing expression returned by this function. */
2564 tree controller = NULL_TREE;
2566 if (! IS_AGGR_TYPE (type) || ! TYPE_NEEDS_DESTRUCTOR (type))
2568 loop = integer_zero_node;
2572 /* The below is short by BI_header_size */
2573 virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
2575 tbase = build_decl (VAR_DECL, NULL_TREE, ptype);
2576 tbase_init = build_modify_expr (tbase, NOP_EXPR,
2577 fold (build (PLUS_EXPR, ptype,
2580 DECL_REGISTER (tbase) = 1;
2581 controller = build (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE);
2582 TREE_SIDE_EFFECTS (controller) = 1;
2584 if (auto_delete != integer_zero_node
2585 && auto_delete != integer_two_node)
2587 tree base_tbd = cp_convert (ptype,
2588 build_binary_op (MINUS_EXPR,
2589 cp_convert (ptr_type_node, base),
2591 /* This is the real size */
2592 virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
2593 body = build_expr_list (NULL_TREE,
2594 build_x_delete (base_tbd,
2595 2 | use_global_delete,
2597 body = build (COND_EXPR, void_type_node,
2598 build (BIT_AND_EXPR, integer_type_node,
2599 auto_delete, integer_one_node),
2600 body, integer_zero_node);
2605 body = expr_tree_cons (NULL_TREE,
2606 build_delete (ptype, tbase, auto_delete,
2607 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1),
2610 body = expr_tree_cons (NULL_TREE,
2611 build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)),
2614 body = expr_tree_cons (NULL_TREE,
2615 build (EXIT_EXPR, void_type_node,
2616 build (EQ_EXPR, boolean_type_node, base, tbase)),
2619 loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body));
2621 loop = expr_tree_cons (NULL_TREE, tbase_init,
2622 expr_tree_cons (NULL_TREE, loop, NULL_TREE));
2623 loop = build_compound_expr (loop);
2626 /* If the delete flag is one, or anything else with the low bit set,
2627 delete the storage. */
2628 if (auto_delete_vec == integer_zero_node)
2629 deallocate_expr = integer_zero_node;
2634 /* The below is short by BI_header_size */
2635 virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex));
2637 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2642 base_tbd = cp_convert (ptype,
2643 build_binary_op (MINUS_EXPR,
2644 cp_convert (string_type_node, base),
2646 /* True size with header. */
2647 virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
2649 deallocate_expr = build_x_delete (base_tbd,
2650 2 | use_global_delete,
2652 if (auto_delete_vec != integer_one_node)
2653 deallocate_expr = build (COND_EXPR, void_type_node,
2654 build (BIT_AND_EXPR, integer_type_node,
2655 auto_delete_vec, integer_one_node),
2656 deallocate_expr, integer_zero_node);
2659 if (loop && deallocate_expr != integer_zero_node)
2661 body = expr_tree_cons (NULL_TREE, loop,
2662 expr_tree_cons (NULL_TREE, deallocate_expr, NULL_TREE));
2663 body = build_compound_expr (body);
2668 /* Outermost wrapper: If pointer is null, punt. */
2669 body = build (COND_EXPR, void_type_node,
2670 build (NE_EXPR, boolean_type_node, base, integer_zero_node),
2671 body, integer_zero_node);
2672 body = build1 (NOP_EXPR, void_type_node, body);
2676 TREE_OPERAND (controller, 1) = body;
2680 return cp_convert (void_type_node, body);
2683 /* Protect the vector initialization with a try-block so that we can
2684 destroy the first few elements if constructing a later element
2685 causes an exception to be thrown. TYPE is the type of the array
2689 expand_vec_init_try_block (type)
2692 if (!TYPE_NEEDS_DESTRUCTOR (type) || !flag_exceptions)
2695 /* The code we generate looks like:
2698 // Initialize the vector.
2700 // Destory the elements that need destroying.
2704 Here we're just beginning the `try'. */
2706 expand_eh_region_start ();
2709 /* Add code to destroy the array elements constructed so far if the
2710 construction of some element in the array causes an exception to be
2711 thrown. RVAL is the address of the last element in the array.
2712 TYPE is the type of the array elements. MAXINDEX is the maximum
2713 allowable index into the array. ITERATOR is an integer variable
2714 indicating how many elements remain to be constructed. */
2717 expand_vec_init_catch_clause (rval, type, maxindex, iterator)
2726 if (!TYPE_NEEDS_DESTRUCTOR (type) || !flag_exceptions)
2729 /* We have to ensure that this can live to the cleanup expansion
2730 time, since we know it is only ever needed once, generate code
2732 push_obstacks_nochange ();
2733 resume_temporary_allocation ();
2735 cleanup = make_node (RTL_EXPR);
2736 TREE_TYPE (cleanup) = void_type_node;
2737 RTL_EXPR_RTL (cleanup) = const0_rtx;
2738 TREE_SIDE_EFFECTS (cleanup) = 1;
2739 do_pending_stack_adjust ();
2740 start_sequence_for_rtl_expr (cleanup);
2742 e = build_vec_delete_1 (rval,
2743 build_binary_op (MINUS_EXPR, maxindex,
2746 /*auto_delete_vec=*/integer_zero_node,
2747 /*auto_delete=*/integer_zero_node,
2748 /*use_global_delete=*/0);
2749 expand_expr (e, const0_rtx, VOIDmode, EXPAND_NORMAL);
2751 do_pending_stack_adjust ();
2752 RTL_EXPR_SEQUENCE (cleanup) = get_insns ();
2754 cleanup = protect_with_terminate (cleanup);
2755 expand_eh_region_end (cleanup);
2759 /* `expand_vec_init' performs initialization of a vector of aggregate
2762 DECL is passed only for error reporting, and provides line number
2763 and source file name information.
2764 BASE is the space where the vector will be.
2765 MAXINDEX is the maximum index of the array (one less than the
2766 number of elements).
2767 INIT is the (possibly NULL) initializer.
2769 FROM_ARRAY is 0 if we should init everything with INIT
2770 (i.e., every element initialized from INIT).
2771 FROM_ARRAY is 1 if we should index into INIT in parallel
2772 with initialization of DECL.
2773 FROM_ARRAY is 2 if we should index into INIT in parallel,
2774 but use assignment instead of initialization. */
2777 expand_vec_init (decl, base, maxindex, init, from_array)
2778 tree decl, base, maxindex, init;
2782 tree base2 = NULL_TREE;
2783 tree type = TREE_TYPE (TREE_TYPE (base));
2785 tree itype = NULL_TREE;
2787 int num_initialized_elts = 0;
2789 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2790 if (maxindex == error_mark_node)
2791 return error_mark_node;
2793 if (current_function_decl == NULL_TREE)
2795 rval = make_tree_vec (3);
2796 TREE_VEC_ELT (rval, 0) = base;
2797 TREE_VEC_ELT (rval, 1) = maxindex;
2798 TREE_VEC_ELT (rval, 2) = init;
2802 size = size_in_bytes (type);
2804 base = default_conversion (base);
2805 base = cp_convert (build_pointer_type (type), base);
2806 rval = get_temp_regvar (build_pointer_type (type), base);
2807 base = get_temp_regvar (build_pointer_type (type), base);
2808 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2810 /* Protect the entire array initialization so that we can destroy
2811 the partially constructed array if an exception is thrown. */
2812 expand_vec_init_try_block (type);
2814 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR
2815 && (!decl || same_type_p (TREE_TYPE (init), TREE_TYPE (decl))))
2817 /* Do non-default initialization resulting from brace-enclosed
2821 tree baseref = build1 (INDIRECT_REF, type, base);
2825 for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
2827 tree elt = TREE_VALUE (elts);
2829 num_initialized_elts++;
2831 if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2832 expand_aggr_init (baseref, elt, 0);
2834 expand_assignment (baseref, elt, 0, 0);
2836 expand_assignment (base,
2837 build (PLUS_EXPR, build_pointer_type (type),
2840 expand_assignment (iterator,
2841 build (MINUS_EXPR, ptrdiff_type_node,
2842 iterator, integer_one_node),
2846 /* Clear out INIT so that we don't get confused below. */
2850 use_variable (DECL_RTL (base));
2852 else if (from_array)
2854 /* If initializing one array from another, initialize element by
2855 element. We rely upon the below calls the do argument
2857 if (decl == NULL_TREE)
2859 sorry ("initialization of array from dissimilar array type");
2860 return error_mark_node;
2864 base2 = default_conversion (init);
2865 itype = TREE_TYPE (base2);
2866 base2 = get_temp_regvar (itype, base2);
2867 itype = TREE_TYPE (itype);
2869 else if (TYPE_LANG_SPECIFIC (type)
2870 && TYPE_NEEDS_CONSTRUCTING (type)
2871 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2873 error ("initializer ends prematurely");
2874 return error_mark_node;
2878 /* Now, default-initialize any remaining elements. We don't need to
2879 do that if a) the type does not need constructing, or b) we've
2880 already initialized all the elements.
2882 We do need to keep going if we're copying an array. */
2885 || (TYPE_NEEDS_CONSTRUCTING (type)
2886 && !(TREE_CODE (maxindex) == INTEGER_CST
2887 && num_initialized_elts == TREE_INT_CST_LOW (maxindex) + 1)))
2889 /* If the ITERATOR is equal to -1, then we don't have to loop;
2890 we've already initialized all the elements. */
2891 expand_start_cond (build (NE_EXPR, boolean_type_node,
2892 iterator, minus_one),
2895 /* Otherwise, loop through the elements. */
2896 expand_start_loop_continue_elsewhere (1);
2898 /* The initialization of each array element is a full-expression. */
2899 expand_start_target_temps ();
2903 tree to = build1 (INDIRECT_REF, type, base);
2907 from = build1 (INDIRECT_REF, itype, base2);
2911 if (from_array == 2)
2912 expand_expr_stmt (build_modify_expr (to, NOP_EXPR, from));
2913 else if (TYPE_NEEDS_CONSTRUCTING (type))
2914 expand_aggr_init (to, from, 0);
2916 expand_assignment (to, from, 0, 0);
2918 my_friendly_abort (57);
2920 else if (TREE_CODE (type) == ARRAY_TYPE)
2923 sorry ("cannot initialize multi-dimensional array with initializer");
2924 expand_vec_init (decl,
2926 build_pointer_type (TREE_TYPE
2929 array_type_nelts (type), 0, 0);
2932 expand_aggr_init (build1 (INDIRECT_REF, type, base), init, 0);
2934 expand_assignment (base,
2935 build (PLUS_EXPR, build_pointer_type (type),
2938 expand_assignment (base2,
2939 build (PLUS_EXPR, build_pointer_type (type),
2940 base2, size), 0, 0);
2942 /* Cleanup any temporaries needed for the initial value. */
2943 expand_end_target_temps ();
2945 expand_loop_continue_here ();
2946 expand_exit_loop_if_false (0, build (NE_EXPR, boolean_type_node,
2947 build (PREDECREMENT_EXPR,
2955 use_variable (DECL_RTL (base));
2957 use_variable (DECL_RTL (base2));
2964 /* Make sure to cleanup any partially constructed elements. */
2965 expand_vec_init_catch_clause (rval, type, maxindex, iterator);
2969 use_variable (DECL_RTL (iterator));
2970 use_variable (DECL_RTL (rval));
2976 /* Free up storage of type TYPE, at address ADDR.
2978 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2981 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2982 used as the second argument to operator delete. It can include
2983 things like padding and magic size cookies. It has virtual in it,
2984 because if you have a base pointer and you delete through a virtual
2985 destructor, it should be the size of the dynamic object, not the
2986 static object, see Free Store 12.5 ANSI C++ WP.
2988 This does not call any destructors. */
2991 build_x_delete (addr, which_delete, virtual_size)
2996 int use_global_delete = which_delete & 1;
2997 int use_vec_delete = !!(which_delete & 2);
2998 enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
2999 int flags = LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL);
3001 return build_op_delete_call (code, addr, virtual_size, flags, NULL_TREE);
3004 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3005 ADDR is an expression which yields the store to be destroyed.
3006 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
3007 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
3008 virtual baseclasses.
3009 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
3011 FLAGS is the logical disjunction of zero or more LOOKUP_
3012 flags. See cp-tree.h for more info.
3014 This function does not delete an object's virtual base classes. */
3017 build_delete (type, addr, auto_delete, flags, use_global_delete)
3021 int use_global_delete;
3027 if (addr == error_mark_node)
3028 return error_mark_node;
3030 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3031 set to `error_mark_node' before it gets properly cleaned up. */
3032 if (type == error_mark_node)
3033 return error_mark_node;
3035 type = TYPE_MAIN_VARIANT (type);
3037 if (TREE_CODE (type) == POINTER_TYPE)
3039 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3040 if (type != void_type_node && !complete_type_or_else (type, addr))
3041 return error_mark_node;
3042 if (TREE_CODE (type) == ARRAY_TYPE)
3044 if (! IS_AGGR_TYPE (type))
3046 /* Call the builtin operator delete. */
3047 return build_builtin_delete_call (addr);
3049 if (TREE_SIDE_EFFECTS (addr))
3050 addr = save_expr (addr);
3052 /* throw away const and volatile on target type of addr */
3053 addr = convert_force (build_pointer_type (type), addr, 0);
3054 ref = build_indirect_ref (addr, NULL_PTR);
3056 else if (TREE_CODE (type) == ARRAY_TYPE)
3059 if (TREE_SIDE_EFFECTS (addr))
3060 addr = save_expr (addr);
3061 if (TYPE_DOMAIN (type) == NULL_TREE)
3063 error ("unknown array size in delete");
3064 return error_mark_node;
3066 return build_vec_delete (addr, array_type_nelts (type),
3067 auto_delete, integer_zero_node,
3072 /* Don't check PROTECT here; leave that decision to the
3073 destructor. If the destructor is accessible, call it,
3074 else report error. */
3075 addr = build_unary_op (ADDR_EXPR, addr, 0);
3076 if (TREE_SIDE_EFFECTS (addr))
3077 addr = save_expr (addr);
3079 if (TREE_CONSTANT (addr))
3080 addr = convert_pointer_to (type, addr);
3082 addr = convert_force (build_pointer_type (type), addr, 0);
3084 ref = build_indirect_ref (addr, NULL_PTR);
3087 my_friendly_assert (IS_AGGR_TYPE (type), 220);
3089 if (! TYPE_NEEDS_DESTRUCTOR (type))
3091 if (auto_delete == integer_zero_node)
3092 return void_zero_node;
3094 return build_op_delete_call
3095 (DELETE_EXPR, addr, c_sizeof_nowarn (type),
3096 LOOKUP_NORMAL | (use_global_delete * LOOKUP_GLOBAL),
3100 /* Below, we will reverse the order in which these calls are made.
3101 If we have a destructor, then that destructor will take care
3102 of the base classes; otherwise, we must do that here. */
3103 if (TYPE_HAS_DESTRUCTOR (type))
3105 tree passed_auto_delete;
3106 tree do_delete = NULL_TREE;
3109 if (use_global_delete)
3111 tree cond = fold (build (BIT_AND_EXPR, integer_type_node,
3112 auto_delete, integer_one_node));
3113 tree call = build_builtin_delete_call (addr);
3115 cond = fold (build (COND_EXPR, void_type_node, cond,
3116 call, void_zero_node));
3117 if (cond != void_zero_node)
3120 passed_auto_delete = fold (build (BIT_AND_EXPR, integer_type_node,
3121 auto_delete, integer_two_node));
3124 passed_auto_delete = auto_delete;
3126 expr = build_method_call
3127 (ref, dtor_identifier, build_expr_list (NULL_TREE, passed_auto_delete),
3131 expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete);
3133 if (flags & LOOKUP_DESTRUCTOR)
3134 /* Explicit destructor call; don't check for null pointer. */
3135 ifexp = integer_one_node;
3137 /* Handle deleting a null pointer. */
3138 ifexp = fold (build_binary_op (NE_EXPR, addr, integer_zero_node));
3140 if (ifexp != integer_one_node)
3141 expr = build (COND_EXPR, void_type_node,
3142 ifexp, expr, void_zero_node);
3148 /* We only get here from finish_function for a destructor. */
3149 tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
3150 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
3151 tree base_binfo = n_baseclasses > 0 ? TREE_VEC_ELT (binfos, 0) : NULL_TREE;
3152 tree exprstmt = NULL_TREE;
3153 tree parent_auto_delete = auto_delete;
3156 /* Set this again before we call anything, as we might get called
3158 TYPE_HAS_DESTRUCTOR (type) = 1;
3160 /* If we have member delete or vbases, we call delete in
3162 if (auto_delete == integer_zero_node)
3164 else if (base_binfo == NULL_TREE
3165 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3167 cond = build (COND_EXPR, void_type_node,
3168 build (BIT_AND_EXPR, integer_type_node, auto_delete, integer_one_node),
3169 build_builtin_delete_call (addr),
3176 exprstmt = build_expr_list (NULL_TREE, cond);
3179 && ! TREE_VIA_VIRTUAL (base_binfo)
3180 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3182 tree this_auto_delete;
3184 if (BINFO_OFFSET_ZEROP (base_binfo))
3185 this_auto_delete = parent_auto_delete;
3187 this_auto_delete = integer_zero_node;
3189 expr = build_scoped_method_call
3190 (ref, base_binfo, dtor_identifier,
3191 build_expr_list (NULL_TREE, this_auto_delete));
3192 exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
3195 /* Take care of the remaining baseclasses. */
3196 for (i = 1; i < n_baseclasses; i++)
3198 base_binfo = TREE_VEC_ELT (binfos, i);
3199 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo))
3200 || TREE_VIA_VIRTUAL (base_binfo))
3203 expr = build_scoped_method_call
3204 (ref, base_binfo, dtor_identifier,
3205 build_expr_list (NULL_TREE, integer_zero_node));
3207 exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
3210 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
3212 if (TREE_CODE (member) != FIELD_DECL)
3214 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member)))
3216 tree this_member = build_component_ref (ref, DECL_NAME (member), NULL_TREE, 0);
3217 tree this_type = TREE_TYPE (member);
3218 expr = build_delete (this_type, this_member, integer_two_node, flags, 0);
3219 exprstmt = expr_tree_cons (NULL_TREE, expr, exprstmt);
3224 return build_compound_expr (exprstmt);
3225 /* Virtual base classes make this function do nothing. */
3226 return void_zero_node;
3230 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3233 build_vbase_delete (type, decl)
3236 tree vbases = CLASSTYPE_VBASECLASSES (type);
3237 tree result = NULL_TREE;
3238 tree addr = build_unary_op (ADDR_EXPR, decl, 0);
3240 my_friendly_assert (addr != error_mark_node, 222);
3244 tree this_addr = convert_force (build_pointer_type (BINFO_TYPE (vbases)),
3246 result = expr_tree_cons (NULL_TREE,
3247 build_delete (TREE_TYPE (this_addr), this_addr,
3249 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0),
3251 vbases = TREE_CHAIN (vbases);
3253 return build_compound_expr (nreverse (result));
3256 /* Build a C++ vector delete expression.
3257 MAXINDEX is the number of elements to be deleted.
3258 ELT_SIZE is the nominal size of each element in the vector.
3259 BASE is the expression that should yield the store to be deleted.
3260 This function expands (or synthesizes) these calls itself.
3261 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3262 AUTO_DELETE say whether each item in the container should be deallocated.
3264 This also calls delete for virtual baseclasses of elements of the vector.
3266 Update: MAXINDEX is no longer needed. The size can be extracted from the
3267 start of the vector for pointers, and from the type for arrays. We still
3268 use MAXINDEX for arrays because it happens to already have one of the
3269 values we'd have to extract. (We could use MAXINDEX with pointers to
3270 confirm the size, and trap if the numbers differ; not clear that it'd
3271 be worth bothering.) */
3274 build_vec_delete (base, maxindex, auto_delete_vec, auto_delete,
3276 tree base, maxindex;
3277 tree auto_delete_vec, auto_delete;
3278 int use_global_delete;
3282 if (TREE_CODE (base) == OFFSET_REF)
3283 base = resolve_offset_ref (base);
3285 type = TREE_TYPE (base);
3287 base = stabilize_reference (base);
3289 /* Since we can use base many times, save_expr it. */
3290 if (TREE_SIDE_EFFECTS (base))
3291 base = save_expr (base);
3293 if (TREE_CODE (type) == POINTER_TYPE)
3295 /* Step back one from start of vector, and read dimension. */
3296 tree cookie_addr = build (MINUS_EXPR, build_pointer_type (BI_header_type),
3297 base, BI_header_size);
3298 tree cookie = build_indirect_ref (cookie_addr, NULL_PTR);
3299 maxindex = build_component_ref (cookie, nc_nelts_field_id, NULL_TREE, 0);
3301 type = TREE_TYPE (type);
3302 while (TREE_CODE (type) == ARRAY_TYPE);
3304 else if (TREE_CODE (type) == ARRAY_TYPE)
3306 /* get the total number of things in the array, maxindex is a bad name */
3307 maxindex = array_type_nelts_total (type);
3308 while (TREE_CODE (type) == ARRAY_TYPE)
3309 type = TREE_TYPE (type);
3310 base = build_unary_op (ADDR_EXPR, base, 1);
3314 if (base != error_mark_node)
3315 error ("type to vector delete is neither pointer or array type");
3316 return error_mark_node;
3319 return build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,