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 static void expand_aggr_vbase_init_1
PROTO((tree
, tree
, tree
, tree
));
37 static void construct_virtual_bases
PROTO((tree
, tree
, tree
, tree
, tree
));
38 static void expand_aggr_init_1
PROTO((tree
, tree
, tree
, tree
, int));
39 static void expand_default_init
PROTO((tree
, tree
, tree
, tree
, int));
40 static tree build_vec_delete_1
PROTO((tree
, tree
, tree
, tree
, int));
41 static void perform_member_init
PROTO((tree
, tree
, tree
, int));
42 static void sort_base_init
PROTO((tree
, tree
*, tree
*));
43 static tree build_builtin_delete_call
PROTO((tree
));
44 static int member_init_ok_or_else
PROTO((tree
, tree
, const char *));
45 static void expand_virtual_init
PROTO((tree
, tree
));
46 static tree sort_member_init
PROTO((tree
));
47 static tree initializing_context
PROTO((tree
));
48 static tree build_java_class_ref
PROTO((tree
));
49 static void expand_cleanup_for_base
PROTO((tree
, tree
));
50 static tree get_temp_regvar
PROTO((tree
, tree
));
52 /* Set up local variable for this file. MUST BE CALLED AFTER
53 INIT_DECL_PROCESSING. */
55 static tree BI_header_type
, BI_header_size
;
57 void init_init_processing ()
61 minus_one_node
= build_int_2 (-1, -1);
63 /* Define the structure that holds header information for
64 arrays allocated via operator new. */
65 BI_header_type
= make_aggr_type (RECORD_TYPE
);
66 nelts_identifier
= get_identifier ("nelts");
67 fields
[0] = build_lang_decl (FIELD_DECL
, nelts_identifier
, sizetype
);
69 /* Use the biggest alignment supported by the target to prevent operator
70 new from returning misaligned pointers. */
71 TYPE_ALIGN (BI_header_type
) = BIGGEST_ALIGNMENT
;
72 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
74 BI_header_size
= size_in_bytes (BI_header_type
);
76 ggc_add_tree_root (&BI_header_type
, 1);
77 ggc_add_tree_root (&BI_header_size
, 1);
80 /* Subroutine of emit_base_init. For BINFO, initialize all the
81 virtual function table pointers, except those that come from
82 virtual base classes. Initialize binfo's vtable pointer, if
83 INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
84 function table pointers in all bases have been initialized already,
85 probably because their constructors have just be run. ADDR is the
86 pointer to the object whos vtables we are going to initialize.
88 REAL_BINFO is usually the same as BINFO, except when addr is not of
89 pointer to the type of the real derived type that we want to
90 initialize for. This is the case when addr is a pointer to a sub
91 object of a complete object, and we only want to do part of the
92 complete object's initialization of vtable pointers. This is done
93 for all virtual table pointers in virtual base classes. REAL_BINFO
94 is used to find the BINFO_VTABLE that we initialize with. BINFO is
95 used for conversions of addr to subobjects.
97 BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
99 Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
103 expand_direct_vtbls_init (real_binfo
, binfo
, init_self
, can_elide
, addr
)
104 tree real_binfo
, binfo
, addr
;
105 int init_self
, can_elide
;
107 tree real_binfos
= BINFO_BASETYPES (real_binfo
);
108 tree binfos
= BINFO_BASETYPES (binfo
);
109 int i
, n_baselinks
= real_binfos
? TREE_VEC_LENGTH (real_binfos
) : 0;
111 for (i
= 0; i
< n_baselinks
; i
++)
113 tree real_base_binfo
= TREE_VEC_ELT (real_binfos
, i
);
114 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
115 int is_not_base_vtable
116 = i
!= CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo
));
117 if (! TREE_VIA_VIRTUAL (real_base_binfo
))
118 expand_direct_vtbls_init (real_base_binfo
, base_binfo
,
119 is_not_base_vtable
, can_elide
, addr
);
122 /* Before turning this on, make sure it is correct. */
123 if (can_elide
&& ! BINFO_MODIFIED (binfo
))
126 /* Should we use something besides CLASSTYPE_VFIELDS? */
127 if (init_self
&& CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo
)))
129 tree base_ptr
= convert_pointer_to_real (binfo
, addr
);
130 expand_virtual_init (real_binfo
, base_ptr
);
135 /* Subroutine of emit_base_init. */
138 perform_member_init (member
, name
, init
, explicit)
139 tree member
, name
, init
;
143 tree type
= TREE_TYPE (member
);
145 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
147 if (decl
== error_mark_node
)
150 /* Deal with this here, as we will get confused if we try to call the
151 assignment op for an anonymous union. This can happen in a
152 synthesized copy constructor. */
153 if (ANON_AGGR_TYPE_P (type
))
155 init
= build (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
156 finish_expr_stmt (init
);
158 else if (TYPE_NEEDS_CONSTRUCTING (type
)
159 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
161 /* Since `init' is already a TREE_LIST on the current_member_init_list,
162 only build it into one if we aren't already a list. */
163 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
164 init
= build_expr_list (NULL_TREE
, init
);
167 && TREE_CODE (type
) == ARRAY_TYPE
169 && TREE_CHAIN (init
) == NULL_TREE
170 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
172 /* Initialization of one array from another. */
174 (build_vec_init (TREE_OPERAND (decl
, 1), decl
,
175 array_type_nelts (type
), TREE_VALUE (init
), 1));
178 finish_expr_stmt (build_aggr_init (decl
, init
, 0));
182 if (init
== NULL_TREE
)
186 /* default-initialization. */
187 if (AGGREGATE_TYPE_P (type
))
189 /* This is a default initialization of an aggregate,
190 but not one of non-POD class type. We cleverly
191 notice that the initialization rules in such a
192 case are the same as for initialization with an
193 empty brace-initialization list. We don't want
194 to call build_modify_expr as that will go looking
195 for constructors and such. */
196 tree e
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
197 TREE_SIDE_EFFECTS (e
) = 1;
198 finish_expr_stmt (build (INIT_EXPR
, type
, decl
, e
));
200 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
201 cp_error ("default-initialization of `%#D', which has reference type",
204 init
= integer_zero_node
;
206 /* member traversal: note it leaves init NULL */
207 else if (TREE_CODE (TREE_TYPE (member
)) == REFERENCE_TYPE
)
208 cp_pedwarn ("uninitialized reference member `%D'", member
);
210 else if (TREE_CODE (init
) == TREE_LIST
)
212 /* There was an explicit member initialization. Do some
213 work in that case. */
214 if (TREE_CHAIN (init
))
216 warning ("initializer list treated as compound expression");
217 init
= build_compound_expr (init
);
220 init
= TREE_VALUE (init
);
224 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
227 if (TYPE_NEEDS_DESTRUCTOR (type
))
231 expr
= build_component_ref (current_class_ref
, name
, NULL_TREE
,
233 expr
= build_delete (type
, expr
, integer_zero_node
,
234 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
236 if (expr
!= error_mark_node
)
237 finish_subobject (expr
);
241 extern int warn_reorder
;
243 /* Subroutine of emit_member_init. */
249 tree x
, member
, name
, field
;
250 tree init_list
= NULL_TREE
;
252 tree last_field
= NULL_TREE
;
254 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
258 /* member could be, for example, a CONST_DECL for an enumerated
259 tag; we don't want to try to initialize that, since it already
261 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
264 for (x
= current_member_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
266 /* If we cleared this out, then pay no attention to it. */
267 if (TREE_PURPOSE (x
) == NULL_TREE
)
269 name
= TREE_PURPOSE (x
);
271 if (TREE_CODE (name
) == IDENTIFIER_NODE
)
272 field
= IDENTIFIER_CLASS_VALUE (name
);
275 my_friendly_assert (TREE_CODE (name
) == FIELD_DECL
, 348);
279 /* If one member shadows another, get the outermost one. */
280 if (TREE_CODE (field
) == TREE_LIST
)
281 field
= TREE_VALUE (field
);
289 cp_warning_at ("member initializers for `%#D'", last_field
);
290 cp_warning_at (" and `%#D'", field
);
291 warning (" will be re-ordered to match declaration order");
297 /* Make sure we won't try to work on this init again. */
298 TREE_PURPOSE (x
) = NULL_TREE
;
299 x
= build_tree_list (name
, TREE_VALUE (x
));
304 /* If we didn't find MEMBER in the list, create a dummy entry
305 so the two lists (INIT_LIST and the list of members) will be
307 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
309 init_list
= chainon (init_list
, x
);
312 /* Initializers for base members go at the end. */
313 for (x
= current_member_init_list
; x
; x
= TREE_CHAIN (x
))
315 name
= TREE_PURPOSE (x
);
318 if (purpose_member (name
, init_list
))
320 cp_error ("multiple initializations given for member `%D'",
321 IDENTIFIER_CLASS_VALUE (name
));
325 init_list
= chainon (init_list
,
326 build_tree_list (name
, TREE_VALUE (x
)));
327 TREE_PURPOSE (x
) = NULL_TREE
;
335 sort_base_init (t
, rbase_ptr
, vbase_ptr
)
336 tree t
, *rbase_ptr
, *vbase_ptr
;
338 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
339 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
345 /* For warn_reorder. */
347 tree last_base
= NULL_TREE
;
349 tree rbases
= NULL_TREE
;
350 tree vbases
= NULL_TREE
;
352 /* First walk through and splice out vbase and invalid initializers.
353 Also replace names with binfos. */
355 last
= tree_cons (NULL_TREE
, NULL_TREE
, current_base_init_list
);
356 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
358 tree basetype
= TREE_PURPOSE (x
);
359 tree binfo
= NULL_TREE
;
361 if (basetype
== NULL_TREE
)
363 /* Initializer for single base class. Must not
364 use multiple inheritance or this is ambiguous. */
365 switch (n_baseclasses
)
368 cp_error ("`%T' does not have a base class to initialize",
374 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
378 binfo
= TREE_VEC_ELT (binfos
, 0);
380 else if (is_aggr_type (basetype
, 1))
382 binfo
= binfo_or_else (basetype
, t
);
383 if (binfo
== NULL_TREE
)
386 /* Virtual base classes are special cases. Their initializers
387 are recorded with this constructor, and they are used when
388 this constructor is the top-level constructor called. */
389 if (TREE_VIA_VIRTUAL (binfo
))
391 tree v
= BINFO_FOR_VBASE (BINFO_TYPE (binfo
), t
);
392 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
397 /* Otherwise, if it is not an immediate base class, complain. */
398 for (i
= n_baseclasses
-1; i
>= 0; i
--)
399 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
403 cp_error ("`%T' is not an immediate base class of `%T'",
404 basetype
, current_class_type
);
410 my_friendly_abort (365);
412 TREE_PURPOSE (x
) = binfo
;
413 TREE_CHAIN (last
) = x
;
416 TREE_CHAIN (last
) = NULL_TREE
;
418 /* Now walk through our regular bases and make sure they're initialized. */
420 for (i
= 0; i
< n_baseclasses
; ++i
)
422 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
425 if (TREE_VIA_VIRTUAL (base_binfo
))
428 for (x
= current_base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
430 tree binfo
= TREE_PURPOSE (x
);
432 if (binfo
== NULL_TREE
)
435 if (binfo
== base_binfo
)
441 cp_warning_at ("base initializers for `%#T'", last_base
);
442 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
443 warning (" will be re-ordered to match inheritance order");
446 last_base
= BINFO_TYPE (binfo
);
449 /* Make sure we won't try to work on this init again. */
450 TREE_PURPOSE (x
) = NULL_TREE
;
451 x
= build_tree_list (binfo
, TREE_VALUE (x
));
456 /* If we didn't find BASE_BINFO in the list, create a dummy entry
457 so the two lists (RBASES and the list of bases) will be
459 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
461 rbases
= chainon (rbases
, x
);
468 /* Perform whatever initializations have yet to be done on the base
469 class of the class variable. These actions are in the global
470 variable CURRENT_BASE_INIT_LIST. Such an action could be
471 NULL_TREE, meaning that the user has explicitly called the base
472 class constructor with no arguments.
474 If there is a need for a call to a constructor, we must surround
475 that call with a pushlevel/poplevel pair, since we are technically
476 at the PARM level of scope.
478 Argument IMMEDIATELY, if zero, forces a new sequence to be
479 generated to contain these new insns, so it can be emitted later.
480 This sequence is saved in the global variable BASE_INIT_EXPR.
481 Otherwise, the insns are emitted into the current sequence.
483 Note that emit_base_init does *not* initialize virtual base
484 classes. That is done specially, elsewhere. */
492 tree rbase_init_list
, vbase_init_list
;
493 tree t_binfo
= TYPE_BINFO (t
);
494 tree binfos
= BINFO_BASETYPES (t_binfo
);
495 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
499 mem_init_list
= sort_member_init (t
);
500 current_member_init_list
= NULL_TREE
;
502 sort_base_init (t
, &rbase_init_list
, &vbase_init_list
);
503 current_base_init_list
= NULL_TREE
;
505 begin_init_stmts (&stmt_expr
, &compound_stmt
);
507 /* First, initialize the virtual base classes, if we are
508 constructing the most-derived object. */
509 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
511 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
512 construct_virtual_bases (t
, current_class_ref
, current_class_ptr
,
513 vbase_init_list
, first_arg
);
516 /* Now, perform initialization of non-virtual base classes. */
517 for (i
= 0; i
< n_baseclasses
; i
++)
519 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
520 tree init
= void_list_node
;
522 if (TREE_VIA_VIRTUAL (base_binfo
))
525 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
,
528 if (TREE_PURPOSE (rbase_init_list
))
529 init
= TREE_VALUE (rbase_init_list
);
530 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
533 if (extra_warnings
&& copy_args_p (current_function_decl
))
534 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
535 BINFO_TYPE (base_binfo
));
538 if (init
!= void_list_node
)
540 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
541 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
542 build_indirect_ref (member
, NULL_PTR
), init
,
546 expand_cleanup_for_base (base_binfo
, NULL_TREE
);
547 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
550 /* Initialize all the virtual function table fields that
551 do come from virtual base classes. */
552 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
553 expand_indirect_vtbls_init (t_binfo
, current_class_ref
, current_class_ptr
);
555 /* Initialize all the virtual function table fields that
556 do not come from virtual base classes. */
557 expand_direct_vtbls_init (t_binfo
, t_binfo
, 1, 1, current_class_ptr
);
559 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
564 /* member could be, for example, a CONST_DECL for an enumerated
565 tag; we don't want to try to initialize that, since it already
567 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
570 /* See if we had a user-specified member initialization. */
571 if (TREE_PURPOSE (mem_init_list
))
573 name
= TREE_PURPOSE (mem_init_list
);
574 init
= TREE_VALUE (mem_init_list
);
577 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
578 || TREE_CODE (name
) == FIELD_DECL
, 349);
582 name
= DECL_NAME (member
);
583 init
= DECL_INITIAL (member
);
587 /* Effective C++ rule 12. */
588 if (warn_ecpp
&& init
== NULL_TREE
589 && !DECL_ARTIFICIAL (member
)
590 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
591 cp_warning ("`%D' should be initialized in the member initialization list", member
);
594 perform_member_init (member
, name
, init
, from_init_list
);
595 mem_init_list
= TREE_CHAIN (mem_init_list
);
598 /* Now initialize any members from our bases. */
599 while (mem_init_list
)
601 tree name
, init
, field
;
603 if (TREE_PURPOSE (mem_init_list
))
605 name
= TREE_PURPOSE (mem_init_list
);
606 init
= TREE_VALUE (mem_init_list
);
608 if (TREE_CODE (name
) == IDENTIFIER_NODE
)
609 field
= IDENTIFIER_CLASS_VALUE (name
);
613 /* If one member shadows another, get the outermost one. */
614 if (TREE_CODE (field
) == TREE_LIST
)
616 field
= TREE_VALUE (field
);
617 if (decl_type_context (field
) != current_class_type
)
618 cp_error ("field `%D' not in immediate context", field
);
621 perform_member_init (field
, name
, init
, 1);
623 mem_init_list
= TREE_CHAIN (mem_init_list
);
626 /* All the implicit try blocks we built up will be zapped
627 when we come to a real binding contour boundary. */
628 return finish_init_stmts (stmt_expr
, compound_stmt
);
631 /* Check that all fields are properly initialized after
632 an assignment to `this'. Called only when such an assignment
633 is actually noted. */
640 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
641 if (DECL_NAME (member
) && TREE_USED (member
))
642 cp_error ("field `%D' used before initialized (after assignment to `this')",
646 /* This code sets up the virtual function tables appropriate for
647 the pointer DECL. It is a one-ply initialization.
649 BINFO is the exact type that DECL is supposed to be. In
650 multiple inheritance, this might mean "C's A" if C : A, B. */
653 expand_virtual_init (binfo
, decl
)
656 tree type
= BINFO_TYPE (binfo
);
658 tree vtype
, vtype_binfo
;
660 /* This code is crusty. Should be simple, like:
661 vtbl = BINFO_VTABLE (binfo);
663 vtype
= DECL_CONTEXT (TYPE_VFIELD (type
));
664 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
665 vtbl
= BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (TYPE_VFIELD (type
)), binfo
));
666 assemble_external (vtbl
);
667 TREE_USED (vtbl
) = 1;
668 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
669 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
670 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
671 if (vtbl_ptr
== error_mark_node
)
674 /* Have to convert VTBL since array sizes may be different. */
675 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
676 finish_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
679 /* If an exception is thrown in a constructor, those base classes already
680 constructed must be destroyed. This function creates the cleanup
681 for BINFO, which has just been constructed. If FLAG is non-NULL,
682 it is a DECL which is non-zero when this base needs to be
686 expand_cleanup_for_base (binfo
, flag
)
692 if (!TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (binfo
)))
695 /* Call the destructor. */
696 expr
= (build_scoped_method_call
697 (current_class_ref
, binfo
, dtor_identifier
,
698 build_expr_list (NULL_TREE
, integer_zero_node
)));
700 expr
= fold (build (COND_EXPR
, void_type_node
,
701 truthvalue_conversion (flag
),
702 expr
, integer_zero_node
));
704 finish_subobject (expr
);
707 /* Subroutine of `expand_aggr_vbase_init'.
708 BINFO is the binfo of the type that is being initialized.
709 INIT_LIST is the list of initializers for the virtual baseclass. */
712 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
713 tree binfo
, exp
, addr
, init_list
;
715 tree init
= purpose_member (binfo
, init_list
);
716 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
719 init
= TREE_VALUE (init
);
720 /* Call constructors, but don't set up vtables. */
721 expand_aggr_init_1 (binfo
, exp
, ref
, init
, LOOKUP_COMPLAIN
);
724 /* Construct the virtual base-classes of THIS_REF (whose address is
725 THIS_PTR). The object has the indicated TYPE. The construction
726 actually takes place only if FLAG is non-zero. INIT_LIST is list
727 of initialization for constructor to perform. */
730 construct_virtual_bases (type
, this_ref
, this_ptr
, init_list
, flag
)
741 /* If there are no virtual baseclasses, we shouldn't even be here. */
742 my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type
), 19990621);
744 /* First set the pointers in our object that tell us where to find
745 our virtual baseclasses. */
746 if_stmt
= begin_if_stmt ();
747 finish_if_stmt_cond (flag
, if_stmt
);
748 result
= init_vbase_pointers (type
, this_ptr
);
750 finish_expr_stmt (build_compound_expr (result
));
751 finish_then_clause (if_stmt
);
754 /* Now, run through the baseclasses, initializing each. */
755 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
756 vbases
= TREE_CHAIN (vbases
))
758 tree tmp
= purpose_member (vbases
, result
);
762 /* If there are virtual base classes with destructors, we need to
763 emit cleanups to destroy them if an exception is thrown during
764 the construction process. These exception regions (i.e., the
765 period during which the cleanups must occur) begin from the time
766 the construction is complete to the end of the function. If we
767 create a conditional block in which to initialize the
768 base-classes, then the cleanup region for the virtual base begins
769 inside a block, and ends outside of that block. This situation
770 confuses the sjlj exception-handling code. Therefore, we do not
771 create a single conditional block, but one for each
772 initialization. (That way the cleanup regions always begin
773 in the outer block.) We trust the back-end to figure out
774 that the FLAG will not change across initializations, and
775 avoid doing multiple tests. */
776 inner_if_stmt
= begin_if_stmt ();
777 finish_if_stmt_cond (flag
, inner_if_stmt
);
778 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/1);
779 expand_aggr_vbase_init_1 (vbases
, this_ref
,
780 TREE_OPERAND (TREE_VALUE (tmp
), 0),
782 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
783 finish_then_clause (inner_if_stmt
);
786 expand_cleanup_for_base (vbases
, flag
);
790 /* Find the context in which this FIELD can be initialized. */
793 initializing_context (field
)
796 tree t
= DECL_CONTEXT (field
);
798 /* Anonymous union members can be initialized in the first enclosing
799 non-anonymous union context. */
800 while (t
&& ANON_AGGR_TYPE_P (t
))
801 t
= TYPE_CONTEXT (t
);
805 /* Function to give error message if member initialization specification
806 is erroneous. FIELD is the member we decided to initialize.
807 TYPE is the type for which the initialization is being performed.
808 FIELD must be a member of TYPE.
810 MEMBER_NAME is the name of the member. */
813 member_init_ok_or_else (field
, type
, member_name
)
816 const char *member_name
;
818 if (field
== error_mark_node
)
820 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
822 cp_error ("class `%T' does not have any field named `%s'", type
,
826 if (TREE_STATIC (field
))
828 cp_error ("field `%#D' is static; only point of initialization is its declaration",
836 /* If NAME is a viable field name for the aggregate DECL,
837 and PARMS is a viable parameter list, then expand an _EXPR
838 which describes this initialization.
840 Note that we do not need to chase through the class's base classes
841 to look for NAME, because if it's in that list, it will be handled
842 by the constructor for that base class.
844 We do not yet have a fixed-point finder to instantiate types
845 being fed to overloaded constructors. If there is a unique
846 constructor, then argument types can be got from that one.
848 If INIT is non-NULL, then it the initialization should
849 be placed in `current_base_init_list', where it will be processed
850 by `emit_base_init'. */
853 expand_member_init (exp
, name
, init
)
854 tree exp
, name
, init
;
856 tree basetype
= NULL_TREE
, field
;
859 if (exp
== NULL_TREE
)
860 return; /* complain about this later */
862 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
864 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
866 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
867 name
= DECL_NAME (name
);
870 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
871 switch (CLASSTYPE_N_BASECLASSES (type
))
874 error ("base class initializer specified, but no base class to initialize");
877 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
880 error ("initializer for unnamed base class ambiguous");
881 cp_error ("(type `%T' uses multiple inheritance)", type
);
885 my_friendly_assert (init
!= NULL_TREE
, 0);
887 /* The grammar should not allow fields which have names that are
888 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
889 may assume that this is an attempt to initialize a base class
890 member of the current type. Otherwise, it is an attempt to
891 initialize a member field. */
893 if (init
== void_type_node
)
896 if (name
== NULL_TREE
|| basetype
)
900 if (name
== NULL_TREE
)
904 name
= TYPE_IDENTIFIER (basetype
);
907 error ("no base class to initialize");
912 else if (basetype
!= type
913 && ! current_template_parms
914 && ! vec_binfo_member (basetype
,
915 TYPE_BINFO_BASETYPES (type
))
916 && ! BINFO_FOR_VBASE (basetype
, type
))
918 if (IDENTIFIER_CLASS_VALUE (name
))
920 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
921 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
924 cp_error ("type `%T' is not an immediate basetype for `%T'",
929 if (purpose_member (basetype
, current_base_init_list
))
931 cp_error ("base class `%T' already initialized", basetype
);
935 if (warn_reorder
&& current_member_init_list
)
937 cp_warning ("base initializer for `%T'", basetype
);
938 warning (" will be re-ordered to precede member initializations");
941 base_init
= build_tree_list (basetype
, init
);
942 current_base_init_list
= chainon (current_base_init_list
, base_init
);
949 field
= lookup_field (type
, name
, 1, 0);
951 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
954 if (purpose_member (name
, current_member_init_list
))
956 cp_error ("field `%D' already initialized", field
);
960 member_init
= build_tree_list (name
, init
);
961 current_member_init_list
= chainon (current_member_init_list
, member_init
);
965 /* We are about to generate some complex initialization code.
966 Conceptually, it is all a single expression. However, we may want
967 to include conditionals, loops, and other such statement-level
968 constructs. Therefore, we build the initialization code inside a
969 statement-expression. This function starts such an expression.
970 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
971 pass them back to finish_init_stmts when the expression is
975 begin_init_stmts (stmt_expr_p
, compound_stmt_p
)
977 tree
*compound_stmt_p
;
979 *stmt_expr_p
= begin_stmt_expr ();
980 *compound_stmt_p
= begin_compound_stmt (/*has_no_scope=*/1);
983 /* Finish out the statement-expression begun by the previous call to
984 begin_init_stmts. Returns the statement-expression itself. */
987 finish_init_stmts (stmt_expr
, compound_stmt
)
991 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
992 stmt_expr
= finish_stmt_expr (stmt_expr
);
994 /* To avoid spurious warnings about unused values, we set
997 TREE_USED (stmt_expr
) = 1;
1002 /* This is like `expand_member_init', only it stores one aggregate
1005 INIT comes in two flavors: it is either a value which
1006 is to be stored in EXP, or it is a parameter list
1007 to go to a constructor, which will operate on EXP.
1008 If INIT is not a parameter list for a constructor, then set
1009 LOOKUP_ONLYCONVERTING.
1010 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1011 the initializer, if FLAGS is 0, then it is the (init) form.
1012 If `init' is a CONSTRUCTOR, then we emit a warning message,
1013 explaining that such initializations are invalid.
1015 ALIAS_THIS is nonzero iff we are initializing something which is
1016 essentially an alias for current_class_ref. In this case, the base
1017 constructor may move it on us, and we must keep track of such
1020 If INIT resolves to a CALL_EXPR which happens to return
1021 something of the type we are looking for, then we know
1022 that we can safely use that call to perform the
1025 The virtual function table pointer cannot be set up here, because
1026 we do not really know its type.
1028 Virtual baseclass pointers are also set up here.
1030 This never calls operator=().
1032 When initializing, nothing is CONST.
1034 A default copy constructor may have to be used to perform the
1037 A constructor or a conversion operator may have to be used to
1038 perform the initialization, but not both, as it would be ambiguous. */
1041 build_aggr_init (exp
, init
, flags
)
1048 tree type
= TREE_TYPE (exp
);
1049 int was_const
= TREE_READONLY (exp
);
1050 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1052 if (init
== error_mark_node
)
1053 return error_mark_node
;
1055 TREE_READONLY (exp
) = 0;
1056 TREE_THIS_VOLATILE (exp
) = 0;
1058 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1059 flags
|= LOOKUP_ONLYCONVERTING
;
1061 if (TREE_CODE (type
) == ARRAY_TYPE
)
1063 /* Must arrange to initialize each element of EXP
1064 from elements of INIT. */
1065 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1066 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
1068 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1070 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1072 if (init
&& TREE_TYPE (init
) == NULL_TREE
)
1074 /* Handle bad initializers like:
1078 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1082 int main(int argc, char **argv) {
1083 COMPLEX zees(1.0, 0.0)[10];
1086 error ("bad array initializer");
1087 return error_mark_node
;
1089 stmt_expr
= build_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1090 init
&& same_type_p (TREE_TYPE (init
),
1092 TREE_READONLY (exp
) = was_const
;
1093 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1094 TREE_TYPE (exp
) = type
;
1096 TREE_TYPE (init
) = itype
;
1100 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1101 /* just know that we've seen something for this node */
1102 TREE_USED (exp
) = 1;
1104 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1105 begin_init_stmts (&stmt_expr
, &compound_stmt
);
1106 destroy_temps
= stmts_are_full_exprs_p
;
1107 stmts_are_full_exprs_p
= 0;
1108 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1109 init
, LOOKUP_NORMAL
|flags
);
1110 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
1111 stmts_are_full_exprs_p
= destroy_temps
;
1112 TREE_TYPE (exp
) = type
;
1113 TREE_READONLY (exp
) = was_const
;
1114 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1120 expand_default_init (binfo
, true_exp
, exp
, init
, flags
)
1126 tree type
= TREE_TYPE (exp
);
1128 /* It fails because there may not be a constructor which takes
1129 its own type as the first (or only parameter), but which does
1130 take other types via a conversion. So, if the thing initializing
1131 the expression is a unit element of type X, first try X(X&),
1132 followed by initialization by X. If neither of these work
1133 out, then look hard. */
1137 if (init
&& TREE_CODE (init
) != TREE_LIST
1138 && (flags
& LOOKUP_ONLYCONVERTING
))
1140 /* Base subobjects should only get direct-initialization. */
1141 if (true_exp
!= exp
)
1144 if (flags
& DIRECT_BIND
)
1145 /* Do nothing. We hit this in two cases: Reference initialization,
1146 where we aren't initializing a real variable, so we don't want
1147 to run a new constructor; and catching an exception, where we
1148 have already built up the constructor call so we could wrap it
1149 in an exception region. */;
1150 else if (TREE_CODE (init
) == CONSTRUCTOR
)
1151 /* A brace-enclosed initializer has whatever type is
1152 required. There's no need to convert it. */
1155 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1157 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1158 /* We need to protect the initialization of a catch parm
1159 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1160 around the TARGET_EXPR for the copy constructor. See
1161 expand_start_catch_block. */
1162 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1163 TREE_OPERAND (init
, 0));
1165 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1166 TREE_SIDE_EFFECTS (init
) = 1;
1167 finish_expr_stmt (init
);
1171 if (init
== NULL_TREE
1172 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1176 init
= TREE_VALUE (parms
);
1179 parms
= build_expr_list (NULL_TREE
, init
);
1181 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1183 if (true_exp
== exp
)
1184 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
1186 parms
= tree_cons (NULL_TREE
, integer_zero_node
, parms
);
1187 flags
|= LOOKUP_HAS_IN_CHARGE
;
1190 rval
= build_method_call (exp
, ctor_identifier
,
1191 parms
, binfo
, flags
);
1192 if (TREE_SIDE_EFFECTS (rval
))
1193 finish_expr_stmt (rval
);
1196 /* This function is responsible for initializing EXP with INIT
1199 BINFO is the binfo of the type for who we are performing the
1200 initialization. For example, if W is a virtual base class of A and B,
1202 If we are initializing B, then W must contain B's W vtable, whereas
1203 were we initializing C, W must contain C's W vtable.
1205 TRUE_EXP is nonzero if it is the true expression being initialized.
1206 In this case, it may be EXP, or may just contain EXP. The reason we
1207 need this is because if EXP is a base element of TRUE_EXP, we
1208 don't necessarily know by looking at EXP where its virtual
1209 baseclass fields should really be pointing. But we do know
1210 from TRUE_EXP. In constructors, we don't know anything about
1211 the value being initialized.
1213 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1215 FLAGS is just passes to `build_method_call'. See that function for
1219 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, flags
)
1225 tree type
= TREE_TYPE (exp
);
1227 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1229 /* Use a function returning the desired type to initialize EXP for us.
1230 If the function is a constructor, and its first argument is
1231 NULL_TREE, know that it was meant for us--just slide exp on
1232 in and expand the constructor. Constructors now come
1235 if (init
&& TREE_CODE (exp
) == VAR_DECL
1236 && TREE_CODE (init
) == CONSTRUCTOR
1237 && TREE_HAS_CONSTRUCTOR (init
))
1239 /* If store_init_value returns NULL_TREE, the INIT has been
1240 record in the DECL_INITIAL for EXP. That means there's
1241 nothing more we have to do. */
1242 if (!store_init_value (exp
, init
))
1244 if (!building_stmt_tree ())
1245 expand_decl_init (exp
);
1248 finish_expr_stmt (build (INIT_EXPR
, type
, exp
, init
));
1252 /* We know that expand_default_init can handle everything we want
1254 expand_default_init (binfo
, true_exp
, exp
, init
, flags
);
1257 /* Report an error if NAME is not the name of a user-defined,
1258 aggregate type. If OR_ELSE is nonzero, give an error message. */
1261 is_aggr_typedef (name
, or_else
)
1267 if (name
== error_mark_node
)
1270 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1271 type
= IDENTIFIER_TYPE_VALUE (name
);
1275 cp_error ("`%T' is not an aggregate typedef", name
);
1279 if (! IS_AGGR_TYPE (type
)
1280 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1281 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1284 cp_error ("`%T' is not an aggregate type", type
);
1290 /* Report an error if TYPE is not a user-defined, aggregate type. If
1291 OR_ELSE is nonzero, give an error message. */
1294 is_aggr_type (type
, or_else
)
1298 if (type
== error_mark_node
)
1301 if (! IS_AGGR_TYPE (type
)
1302 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1303 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1306 cp_error ("`%T' is not an aggregate type", type
);
1312 /* Like is_aggr_typedef, but returns typedef if successful. */
1315 get_aggr_from_typedef (name
, or_else
)
1321 if (name
== error_mark_node
)
1324 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1325 type
= IDENTIFIER_TYPE_VALUE (name
);
1329 cp_error ("`%T' fails to be an aggregate typedef", name
);
1333 if (! IS_AGGR_TYPE (type
)
1334 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1335 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1338 cp_error ("type `%T' is of non-aggregate type", type
);
1345 get_type_value (name
)
1348 if (name
== error_mark_node
)
1351 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1352 return IDENTIFIER_TYPE_VALUE (name
);
1358 /* This code could just as well go in `class.c', but is placed here for
1361 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1362 the appropriate function call. */
1365 build_member_call (type
, name
, parmlist
)
1366 tree type
, name
, parmlist
;
1371 tree basetype_path
, decl
;
1373 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
1374 && TREE_CODE (type
) == NAMESPACE_DECL
)
1376 /* 'name' already refers to the decls from the namespace, since we
1377 hit do_identifier for template_ids. */
1378 method_name
= TREE_OPERAND (name
, 0);
1379 /* FIXME: Since we don't do independent names right yet, the
1380 name might also be a LOOKUP_EXPR. Once we resolve this to a
1381 real decl earlier, this can go. This may happen during
1383 if (TREE_CODE (method_name
) == LOOKUP_EXPR
)
1385 method_name
= lookup_namespace_name
1386 (type
, TREE_OPERAND (method_name
, 0));
1387 TREE_OPERAND (name
, 0) = method_name
;
1389 my_friendly_assert (is_overloaded_fn (method_name
), 980519);
1390 return build_x_function_call (name
, parmlist
, current_class_ref
);
1393 if (type
== std_node
)
1394 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1396 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1397 return build_x_function_call (lookup_namespace_name (type
, name
),
1398 parmlist
, current_class_ref
);
1400 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1402 method_name
= TREE_OPERAND (name
, 0);
1403 if (TREE_CODE (method_name
) == COMPONENT_REF
)
1404 method_name
= TREE_OPERAND (method_name
, 1);
1405 if (is_overloaded_fn (method_name
))
1406 method_name
= DECL_NAME (OVL_CURRENT (method_name
));
1407 TREE_OPERAND (name
, 0) = method_name
;
1412 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1414 method_name
= TREE_OPERAND (method_name
, 0);
1418 /* This shouldn't be here, and build_member_call shouldn't appear in
1420 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1421 && get_aggr_from_typedef (type
, 0) == 0)
1423 tree ns
= lookup_name (type
, 0);
1424 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1426 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1430 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1431 return error_mark_node
;
1433 /* An operator we did not like. */
1434 if (name
== NULL_TREE
)
1435 return error_mark_node
;
1439 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1441 return error_mark_node
;
1444 decl
= maybe_dummy_object (type
, &basetype_path
);
1446 /* Convert 'this' to the specified type to disambiguate conversion
1447 to the function's context. Apparently Standard C++ says that we
1448 shouldn't do this. */
1449 if (decl
== current_class_ref
1451 && ACCESSIBLY_UNIQUELY_DERIVED_P (type
, current_class_type
))
1453 tree olddecl
= current_class_ptr
;
1454 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1455 if (oldtype
!= type
)
1457 tree newtype
= build_qualified_type (type
, TYPE_QUALS (oldtype
));
1458 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1459 decl
= build_indirect_ref (decl
, NULL_PTR
);
1463 if (method_name
== constructor_name (type
)
1464 || method_name
== constructor_name_full (type
))
1465 return build_functional_cast (type
, parmlist
);
1466 if (lookup_fnfields (basetype_path
, method_name
, 0))
1467 return build_method_call (decl
,
1468 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1469 ? name
: method_name
,
1470 parmlist
, basetype_path
,
1471 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1472 if (TREE_CODE (name
) == IDENTIFIER_NODE
1473 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1475 if (t
== error_mark_node
)
1476 return error_mark_node
;
1477 if (TREE_CODE (t
) == FIELD_DECL
)
1479 if (is_dummy_object (decl
))
1481 cp_error ("invalid use of non-static field `%D'", t
);
1482 return error_mark_node
;
1484 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1486 else if (TREE_CODE (t
) == VAR_DECL
)
1490 cp_error ("invalid use of member `%D'", t
);
1491 return error_mark_node
;
1493 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1494 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1495 parmlist
, NULL_TREE
);
1496 return build_function_call (decl
, parmlist
);
1500 cp_error ("no method `%T::%D'", type
, name
);
1501 return error_mark_node
;
1505 /* Build a reference to a member of an aggregate. This is not a
1506 C++ `&', but really something which can have its address taken,
1507 and then act as a pointer to member, for example TYPE :: FIELD
1508 can have its address taken by saying & TYPE :: FIELD.
1510 @@ Prints out lousy diagnostics for operator <typename>
1513 @@ This function should be rewritten and placed in search.c. */
1516 build_offset_ref (type
, name
)
1519 tree decl
, t
= error_mark_node
;
1521 tree basebinfo
= NULL_TREE
;
1522 tree orig_name
= name
;
1524 /* class templates can come in as TEMPLATE_DECLs here. */
1525 if (TREE_CODE (name
) == TEMPLATE_DECL
)
1528 if (type
== std_node
)
1529 return do_scoped_id (name
, 0);
1531 if (processing_template_decl
|| uses_template_parms (type
))
1532 return build_min_nt (SCOPE_REF
, type
, name
);
1534 /* Handle namespace names fully here. */
1535 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1537 t
= lookup_namespace_name (type
, name
);
1538 if (t
!= error_mark_node
&& ! type_unknown_p (t
))
1541 t
= convert_from_reference (t
);
1546 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1547 return error_mark_node
;
1549 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1551 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1552 something like `a.template f<int>' or the like. For the most
1553 part, we treat this just like a.f. We do remember, however,
1554 the template-id that was used. */
1555 name
= TREE_OPERAND (orig_name
, 0);
1557 if (TREE_CODE (name
) == LOOKUP_EXPR
)
1558 /* This can happen during tsubst'ing. */
1559 name
= TREE_OPERAND (name
, 0);
1561 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
1564 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1566 if (! check_dtor_name (type
, name
))
1567 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1568 type
, TREE_OPERAND (name
, 0));
1569 name
= dtor_identifier
;
1572 /* I think this is wrong, but the draft is unclear. --jason 6/15/98 */
1573 else if (name
== constructor_name_full (type
)
1574 || name
== constructor_name (type
))
1575 name
= ctor_identifier
;
1578 if (TYPE_SIZE (complete_type (type
)) == 0
1579 && !TYPE_BEING_DEFINED (type
))
1581 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1583 return error_mark_node
;
1586 decl
= maybe_dummy_object (type
, &basebinfo
);
1588 member
= lookup_member (basebinfo
, name
, 1, 0);
1590 if (member
== error_mark_node
)
1591 return error_mark_node
;
1593 /* A lot of this logic is now handled in lookup_field and
1595 if (member
&& BASELINK_P (member
))
1597 /* Go from the TREE_BASELINK to the member function info. */
1598 tree fnfields
= member
;
1599 t
= TREE_VALUE (fnfields
);
1601 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1603 /* The FNFIELDS are going to contain functions that aren't
1604 necessarily templates, and templates that don't
1605 necessarily match the explicit template parameters. We
1606 save all the functions, and the explicit parameters, and
1607 then figure out exactly what to instantiate with what
1608 arguments in instantiate_type. */
1610 if (TREE_CODE (t
) != OVERLOAD
)
1611 /* The code in instantiate_type which will process this
1612 expects to encounter OVERLOADs, not raw functions. */
1613 t
= ovl_cons (t
, NULL_TREE
);
1615 return build (OFFSET_REF
,
1618 build (TEMPLATE_ID_EXPR
,
1621 TREE_OPERAND (orig_name
, 1)));
1624 if (!really_overloaded_fn (t
))
1626 /* Get rid of a potential OVERLOAD around it */
1627 t
= OVL_CURRENT (t
);
1629 /* unique functions are handled easily. */
1630 basebinfo
= TREE_PURPOSE (fnfields
);
1631 if (!enforce_access (basebinfo
, t
))
1632 return error_mark_node
;
1634 if (DECL_STATIC_FUNCTION_P (t
))
1636 return build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1639 TREE_TYPE (fnfields
) = unknown_type_node
;
1640 return build (OFFSET_REF
, unknown_type_node
, decl
, fnfields
);
1647 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1648 return error_mark_node
;
1651 if (TREE_CODE (t
) == TYPE_DECL
)
1656 /* static class members and class-specific enum
1657 values can be returned without further ado. */
1658 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1661 return convert_from_reference (t
);
1664 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_C_BIT_FIELD (t
))
1666 cp_error ("illegal pointer to bit field `%D'", t
);
1667 return error_mark_node
;
1670 /* static class functions too. */
1671 if (TREE_CODE (t
) == FUNCTION_DECL
1672 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1673 my_friendly_abort (53);
1675 /* In member functions, the form `type::name' is no longer
1676 equivalent to `this->type::name', at least not until
1677 resolve_offset_ref. */
1678 return build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1681 /* If a OFFSET_REF made it through to here, then it did
1682 not have its address taken. */
1685 resolve_offset_ref (exp
)
1688 tree type
= TREE_TYPE (exp
);
1689 tree base
= NULL_TREE
;
1691 tree basetype
, addr
;
1693 if (TREE_CODE (exp
) == OFFSET_REF
)
1695 member
= TREE_OPERAND (exp
, 1);
1696 base
= TREE_OPERAND (exp
, 0);
1700 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1701 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1703 error ("object missing in use of pointer-to-member construct");
1704 return error_mark_node
;
1707 type
= TREE_TYPE (type
);
1708 base
= current_class_ref
;
1711 if (BASELINK_P (member
))
1713 if (! flag_ms_extensions
)
1714 cp_pedwarn ("assuming & on overloaded member function");
1715 return build_unary_op (ADDR_EXPR
, exp
, 0);
1718 if (TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1720 if (! flag_ms_extensions
)
1721 cp_pedwarn ("assuming & on `%E'", member
);
1722 return build_unary_op (ADDR_EXPR
, exp
, 0);
1725 if ((TREE_CODE (member
) == VAR_DECL
1726 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
))
1727 && ! TYPE_PTRMEM_P (TREE_TYPE (member
)))
1728 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
)
1730 /* These were static members. */
1731 if (mark_addressable (member
) == 0)
1732 return error_mark_node
;
1736 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1737 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1740 /* Syntax error can cause a member which should
1741 have been seen as static to be grok'd as non-static. */
1742 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1744 if (TREE_ADDRESSABLE (member
) == 0)
1746 cp_error_at ("member `%D' is non-static but referenced as a static member",
1748 error ("at this point in file");
1749 TREE_ADDRESSABLE (member
) = 1;
1751 return error_mark_node
;
1754 /* The first case is really just a reference to a member of `this'. */
1755 if (TREE_CODE (member
) == FIELD_DECL
1756 && (base
== current_class_ref
|| is_dummy_object (base
)))
1761 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1762 basetype
= TYPE_OFFSET_BASETYPE (type
);
1764 basetype
= DECL_CONTEXT (member
);
1766 base
= current_class_ptr
;
1768 if (get_base_distance (basetype
, TREE_TYPE (TREE_TYPE (base
)), 0, &basetype_path
) < 0)
1770 error_not_base_type (basetype
, TREE_TYPE (TREE_TYPE (base
)));
1771 return error_mark_node
;
1773 /* Kludge: we need to use basetype_path now, because
1774 convert_pointer_to will bash it. */
1775 enforce_access (basetype_path
, member
);
1776 addr
= convert_pointer_to (basetype
, base
);
1778 /* Even in the case of illegal access, we form the
1779 COMPONENT_REF; that will allow better error recovery than
1780 just feeding back error_mark_node. */
1781 expr
= build (COMPONENT_REF
, TREE_TYPE (member
),
1782 build_indirect_ref (addr
, NULL_PTR
), member
);
1783 return convert_from_reference (expr
);
1786 /* Ensure that we have an object. */
1787 if (is_dummy_object (base
))
1788 addr
= error_mark_node
;
1790 /* If this is a reference to a member function, then return the
1791 address of the member function (which may involve going
1792 through the object's vtable), otherwise, return an expression
1793 for the dereferenced pointer-to-member construct. */
1794 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1796 if (TYPE_PTRMEM_P (TREE_TYPE (member
)))
1798 if (addr
== error_mark_node
)
1800 cp_error ("object missing in `%E'", exp
);
1801 return error_mark_node
;
1804 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member
)));
1805 addr
= convert_pointer_to (basetype
, addr
);
1806 member
= cp_convert (ptrdiff_type_node
, member
);
1808 /* Pointer to data members are offset by one, so that a null
1809 pointer with a real value of 0 is distinguishable from an
1810 offset of the first member of a structure. */
1811 member
= build_binary_op (MINUS_EXPR
, member
,
1812 cp_convert (ptrdiff_type_node
, integer_one_node
));
1814 return build1 (INDIRECT_REF
, type
,
1815 build (PLUS_EXPR
, build_pointer_type (type
),
1818 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1820 return get_member_function_from_ptrfunc (&addr
, member
);
1822 my_friendly_abort (56);
1827 /* Return either DECL or its known constant value (if it has one). */
1830 decl_constant_value (decl
)
1833 if (! TREE_THIS_VOLATILE (decl
)
1834 && DECL_INITIAL (decl
)
1835 && DECL_INITIAL (decl
) != error_mark_node
1836 /* This is invalid if initial value is not constant.
1837 If it has either a function call, a memory reference,
1838 or a variable, then re-evaluating it could give different results. */
1839 && TREE_CONSTANT (DECL_INITIAL (decl
))
1840 /* Check for cases where this is sub-optimal, even though valid. */
1841 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1842 return DECL_INITIAL (decl
);
1846 /* Common subroutines of build_new and build_vec_delete. */
1848 /* Call the global __builtin_delete to delete ADDR. */
1851 build_builtin_delete_call (addr
)
1854 mark_used (global_delete_fndecl
);
1855 return build_call (global_delete_fndecl
,
1856 void_type_node
, build_expr_list (NULL_TREE
, addr
));
1859 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1860 (which needs to go through some sort of groktypename) or it
1861 is the name of the class we are newing. INIT is an initialization value.
1862 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1863 If INIT is void_type_node, it means do *not* call a constructor
1866 For types with constructors, the data returned is initialized
1867 by the appropriate constructor.
1869 Whether the type has a constructor or not, if it has a pointer
1870 to a virtual function table, then that pointer is set up
1873 Unless I am mistaken, a call to new () will return initialized
1874 data regardless of whether the constructor itself is private or
1875 not. NOPE; new fails if the constructor is private (jcm).
1877 Note that build_new does nothing to assure that any special
1878 alignment requirements of the type are met. Rather, it leaves
1879 it up to malloc to do the right thing. Otherwise, folding to
1880 the right alignment cal cause problems if the user tries to later
1881 free the memory returned by `new'.
1883 PLACEMENT is the `placement' list for user-defined operator new (). */
1885 extern int flag_check_new
;
1888 build_new (placement
, decl
, init
, use_global_new
)
1894 tree nelts
= NULL_TREE
, t
;
1897 if (decl
== error_mark_node
)
1898 return error_mark_node
;
1900 if (TREE_CODE (decl
) == TREE_LIST
)
1902 tree absdcl
= TREE_VALUE (decl
);
1903 tree last_absdcl
= NULL_TREE
;
1905 if (current_function_decl
1906 && DECL_CONSTRUCTOR_P (current_function_decl
))
1907 my_friendly_assert (immediate_size_expand
== 0, 19990926);
1909 nelts
= integer_one_node
;
1911 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
1912 my_friendly_abort (215);
1913 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
1915 last_absdcl
= absdcl
;
1916 absdcl
= TREE_OPERAND (absdcl
, 0);
1919 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
1921 /* probably meant to be a vec new */
1924 while (TREE_OPERAND (absdcl
, 0)
1925 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
1927 last_absdcl
= absdcl
;
1928 absdcl
= TREE_OPERAND (absdcl
, 0);
1932 this_nelts
= TREE_OPERAND (absdcl
, 1);
1933 if (this_nelts
!= error_mark_node
)
1935 if (this_nelts
== NULL_TREE
)
1936 error ("new of array type fails to specify size");
1937 else if (processing_template_decl
)
1940 absdcl
= TREE_OPERAND (absdcl
, 0);
1944 int flags
= pedantic
? WANT_INT
: (WANT_INT
| WANT_ENUM
);
1945 if (build_expr_type_conversion (flags
, this_nelts
, 0)
1947 pedwarn ("size in array new must have integral type");
1949 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
1950 absdcl
= TREE_OPERAND (absdcl
, 0);
1951 if (this_nelts
== integer_zero_node
)
1953 warning ("zero size array reserves no space");
1954 nelts
= integer_zero_node
;
1957 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
1961 nelts
= integer_zero_node
;
1965 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
1967 TREE_VALUE (decl
) = absdcl
;
1969 type
= groktypename (decl
);
1970 if (! type
|| type
== error_mark_node
)
1971 return error_mark_node
;
1973 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
1975 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
1977 /* An aggregate type. */
1978 type
= IDENTIFIER_TYPE_VALUE (decl
);
1979 decl
= TYPE_MAIN_DECL (type
);
1983 /* A builtin type. */
1984 decl
= lookup_name (decl
, 1);
1985 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
1986 type
= TREE_TYPE (decl
);
1989 else if (TREE_CODE (decl
) == TYPE_DECL
)
1991 type
= TREE_TYPE (decl
);
1996 decl
= TYPE_MAIN_DECL (type
);
1999 if (processing_template_decl
)
2002 t
= tree_cons (tree_cons (NULL_TREE
, type
, NULL_TREE
),
2003 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2008 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2009 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2013 /* ``A reference cannot be created by the new operator. A reference
2014 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2015 returned by new.'' ARM 5.3.3 */
2016 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2018 error ("new cannot be applied to a reference type");
2019 type
= TREE_TYPE (type
);
2022 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2024 error ("new cannot be applied to a function type");
2025 return error_mark_node
;
2028 /* When the object being created is an array, the new-expression yields a
2029 pointer to the initial element (if any) of the array. For example,
2030 both new int and new int[10] return an int*. 5.3.4. */
2031 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2033 nelts
= array_type_nelts_top (type
);
2035 type
= TREE_TYPE (type
);
2039 t
= build_nt (ARRAY_REF
, type
, nelts
);
2043 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2044 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2045 TREE_SIDE_EFFECTS (rval
) = 1;
2046 rval
= build_new_1 (rval
);
2047 if (rval
== error_mark_node
)
2048 return error_mark_node
;
2050 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2051 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2052 TREE_NO_UNUSED_WARNING (rval
) = 1;
2057 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2060 build_java_class_ref (type
)
2063 tree name
, class_decl
;
2064 static tree CL_prefix
= NULL_TREE
;
2065 if (CL_prefix
== NULL_TREE
)
2066 CL_prefix
= get_identifier("_CL_");
2067 if (jclass_node
== NULL_TREE
)
2069 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2070 if (jclass_node
== NULL_TREE
)
2071 fatal("call to Java constructor, while `jclass' undefined");
2072 jclass_node
= TREE_TYPE (jclass_node
);
2074 name
= build_overload_with_type (CL_prefix
, type
);
2075 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2076 if (class_decl
== NULL_TREE
)
2078 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2079 TREE_STATIC (class_decl
) = 1;
2080 DECL_EXTERNAL (class_decl
) = 1;
2081 TREE_PUBLIC (class_decl
) = 1;
2082 DECL_ARTIFICIAL (class_decl
) = 1;
2083 DECL_IGNORED_P (class_decl
) = 1;
2084 pushdecl_top_level (class_decl
);
2085 make_decl_rtl (class_decl
, NULL_PTR
, 1);
2090 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2091 value is immediately handed to expand_expr. */
2097 tree placement
, init
;
2098 tree type
, true_type
, size
, rval
;
2099 tree nelts
= NULL_TREE
;
2100 tree alloc_expr
, alloc_node
= NULL_TREE
;
2102 enum tree_code code
= NEW_EXPR
;
2103 int use_cookie
, nothrow
, check_new
;
2105 int use_java_new
= 0;
2107 placement
= TREE_OPERAND (exp
, 0);
2108 type
= TREE_OPERAND (exp
, 1);
2109 init
= TREE_OPERAND (exp
, 2);
2110 use_global_new
= NEW_EXPR_USE_GLOBAL (exp
);
2112 if (TREE_CODE (type
) == ARRAY_REF
)
2115 nelts
= TREE_OPERAND (type
, 1);
2116 type
= TREE_OPERAND (type
, 0);
2120 if (CP_TYPE_QUALS (type
))
2121 type
= TYPE_MAIN_VARIANT (type
);
2123 /* If our base type is an array, then make sure we know how many elements
2125 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2127 tree this_nelts
= array_type_nelts_top (true_type
);
2128 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2129 true_type
= TREE_TYPE (true_type
);
2132 if (!complete_type_or_else (true_type
, exp
))
2133 return error_mark_node
;
2136 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2139 size
= size_in_bytes (type
);
2141 if (TREE_CODE (true_type
) == VOID_TYPE
)
2143 error ("invalid type `void' for new");
2144 return error_mark_node
;
2147 if (abstract_virtuals_error (NULL_TREE
, true_type
))
2148 return error_mark_node
;
2150 /* When we allocate an array, and the corresponding deallocation
2151 function takes a second argument of type size_t, and that's the
2152 "usual deallocation function", we allocate some extra space at
2153 the beginning of the array to store the size of the array.
2155 Well, that's what we should do. For backwards compatibility, we
2156 have to do this whenever there's a two-argument array-delete
2159 FIXME: For -fnew-abi, we don't have to maintain backwards
2160 compatibility and we should fix this. */
2161 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2162 && ! (placement
&& ! TREE_CHAIN (placement
)
2163 && TREE_TYPE (TREE_VALUE (placement
)) == ptr_type_node
));
2166 size
= size_binop (PLUS_EXPR
, size
, BI_header_size
);
2170 code
= VEC_NEW_EXPR
;
2172 if (init
&& pedantic
)
2173 cp_pedwarn ("initialization in array new");
2176 /* Allocate the object. */
2178 if (! placement
&& TYPE_FOR_JAVA (true_type
))
2180 tree class_addr
, alloc_decl
;
2181 tree class_decl
= build_java_class_ref (true_type
);
2182 tree class_size
= size_in_bytes (true_type
);
2183 static char alloc_name
[] = "_Jv_AllocObject";
2185 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2186 if (alloc_decl
== NULL_TREE
)
2187 fatal("call to Java constructor, while `%s' undefined", alloc_name
);
2188 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2189 rval
= build_function_call (alloc_decl
,
2190 tree_cons (NULL_TREE
, class_addr
,
2191 build_tree_list (NULL_TREE
,
2193 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2197 rval
= build_op_new_call
2198 (code
, true_type
, tree_cons (NULL_TREE
, size
, placement
),
2199 LOOKUP_NORMAL
| (use_global_new
* LOOKUP_GLOBAL
));
2200 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2203 /* unless an allocation function is declared with an empty excep-
2204 tion-specification (_except.spec_), throw(), it indicates failure to
2205 allocate storage by throwing a bad_alloc exception (clause _except_,
2206 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2207 cation function is declared with an empty exception-specification,
2208 throw(), it returns null to indicate failure to allocate storage and a
2209 non-null pointer otherwise.
2211 So check for a null exception spec on the op new we just called. */
2216 /* The CALL_EXPR. */
2217 tree t
= TREE_OPERAND (rval
, 0);
2219 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
2220 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (t
));
2222 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2224 if ((check_new
|| flag_exceptions
) && rval
)
2226 alloc_expr
= get_target_expr (rval
);
2227 alloc_node
= rval
= TREE_OPERAND (alloc_expr
, 0);
2230 alloc_expr
= NULL_TREE
;
2232 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2233 sure we have some extra bytes in that case for the BI_header_size
2234 cookies? And how does that interact with the code below? (mrs) */
2235 /* Finish up some magic for new'ed arrays */
2236 if (use_cookie
&& rval
!= NULL_TREE
)
2238 tree extra
= BI_header_size
;
2240 rval
= convert (string_type_node
, rval
); /* for ptr arithmetic */
2241 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, extra
));
2242 /* Store header info. */
2243 cookie
= build_indirect_ref (build (MINUS_EXPR
,
2244 build_pointer_type (BI_header_type
),
2245 rval
, extra
), NULL_PTR
);
2246 exp1
= build (MODIFY_EXPR
, void_type_node
,
2247 build_component_ref (cookie
, nelts_identifier
,
2250 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2251 rval
= build_compound_expr
2252 (tree_cons (NULL_TREE
, exp1
,
2253 build_expr_list (NULL_TREE
, rval
)));
2256 if (rval
== error_mark_node
)
2257 return error_mark_node
;
2259 /* Don't call any constructors or do any initialization. */
2260 if (init
== void_type_node
)
2263 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2265 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2266 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2268 /* We are processing something like `new int (10)', which
2269 means allocate an int, and initialize it with 10. */
2273 /* At present RVAL is a temporary variable, created to hold
2274 the value from the call to `operator new'. We transform
2275 it to (*RVAL = INIT, RVAL). */
2276 rval
= save_expr (rval
);
2277 deref
= build_indirect_ref (rval
, NULL_PTR
);
2279 /* Even for something like `new const int (10)' we must
2280 allow the expression to be non-const while we do the
2282 deref_type
= TREE_TYPE (deref
);
2283 if (CP_TYPE_CONST_P (deref_type
))
2285 = cp_build_qualified_type (deref_type
,
2286 CP_TYPE_QUALS (deref_type
)
2287 & ~TYPE_QUAL_CONST
);
2288 TREE_READONLY (deref
) = 0;
2290 if (TREE_CHAIN (init
) != NULL_TREE
)
2291 pedwarn ("initializer list being treated as compound expression");
2292 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2294 pedwarn ("initializer list appears where operand should be used");
2295 init
= TREE_OPERAND (init
, 1);
2297 init
= build_compound_expr (init
);
2299 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2300 "new", NULL_TREE
, 0);
2301 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2302 build_modify_expr (deref
, NOP_EXPR
, init
),
2304 TREE_NO_UNUSED_WARNING (rval
) = 1;
2305 TREE_SIDE_EFFECTS (rval
) = 1;
2307 else if (! has_array
)
2310 /* Constructors are never virtual. If it has an initialization, we
2311 need to complain if we aren't allowed to use the ctor that took
2313 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2315 if (rval
&& TYPE_USES_VIRTUAL_BASECLASSES (true_type
))
2317 init
= tree_cons (NULL_TREE
, integer_one_node
, init
);
2318 flags
|= LOOKUP_HAS_IN_CHARGE
;
2322 rval
= save_expr (rval
);
2325 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2326 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2328 newrval
= build_method_call (newrval
, ctor_identifier
,
2329 init
, TYPE_BINFO (true_type
), flags
);
2331 if (newrval
== NULL_TREE
|| newrval
== error_mark_node
)
2332 return error_mark_node
;
2334 /* Java constructors compiled by jc1 do not return this. */
2336 newrval
= build (COMPOUND_EXPR
, TREE_TYPE (newrval
),
2339 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2342 rval
= (build_vec_init
2345 build_binary_op (MINUS_EXPR
, nelts
, integer_one_node
),
2349 /* If any part of the object initialization terminates by throwing an
2350 exception and a suitable deallocation function can be found, the
2351 deallocation function is called to free the memory in which the
2352 object was being constructed, after which the exception continues
2353 to propagate in the context of the new-expression. If no
2354 unambiguous matching deallocation function can be found,
2355 propagating the exception does not cause the object's memory to be
2357 if (flag_exceptions
&& alloc_expr
&& ! use_java_new
)
2359 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2360 tree cleanup
, fn
= NULL_TREE
;
2361 int flags
= LOOKUP_NORMAL
| (use_global_new
* LOOKUP_GLOBAL
);
2363 /* The Standard is unclear here, but the right thing to do
2364 is to use the same method for finding deallocation
2365 functions that we use for finding allocation functions. */
2366 flags
|= LOOKUP_SPECULATIVELY
;
2368 /* We expect alloc_expr to look like a TARGET_EXPR around
2369 a NOP_EXPR around the CALL_EXPR we want. */
2370 fn
= TREE_OPERAND (alloc_expr
, 1);
2371 fn
= TREE_OPERAND (fn
, 0);
2373 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
, fn
);
2375 /* Ack! First we allocate the memory. Then we set our sentry
2376 variable to true, and expand a cleanup that deletes the memory
2377 if sentry is true. Then we run the constructor and store the
2378 returned pointer in buf. Then we clear sentry and return buf. */
2382 tree end
, sentry
, begin
, buf
, t
= TREE_TYPE (rval
);
2384 begin
= get_target_expr (boolean_true_node
);
2385 sentry
= TREE_OPERAND (begin
, 0);
2387 TREE_OPERAND (begin
, 2)
2388 = build (COND_EXPR
, void_type_node
, sentry
,
2389 cleanup
, void_zero_node
);
2391 rval
= get_target_expr (rval
);
2393 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2394 sentry
, boolean_false_node
);
2396 buf
= TREE_OPERAND (rval
, 0);
2398 rval
= build (COMPOUND_EXPR
, t
, begin
,
2399 build (COMPOUND_EXPR
, t
, rval
,
2400 build (COMPOUND_EXPR
, t
, end
, buf
)));
2404 else if (CP_TYPE_CONST_P (true_type
))
2405 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2409 if (alloc_expr
&& rval
== alloc_node
)
2411 rval
= TREE_OPERAND (alloc_expr
, 1);
2412 alloc_expr
= NULL_TREE
;
2415 if (check_new
&& alloc_expr
)
2417 /* Did we modify the storage? */
2418 tree ifexp
= build_binary_op (NE_EXPR
, alloc_node
,
2420 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2424 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2426 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2428 /* The type of new int [3][3] is not int *, but int [3] * */
2429 rval
= build_c_cast (build_pointer_type (type
), rval
);
2436 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, use_global_delete
)
2437 tree base
, maxindex
, type
;
2438 tree auto_delete_vec
;
2439 int use_global_delete
;
2442 tree ptype
= build_pointer_type (type
= complete_type (type
));
2443 tree size_exp
= size_in_bytes (type
);
2445 /* Temporary variables used by the loop. */
2446 tree tbase
, tbase_init
;
2448 /* This is the body of the loop that implements the deletion of a
2449 single element, and moves temp variables to next elements. */
2452 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2455 /* This is the thing that governs what to do after the loop has run. */
2456 tree deallocate_expr
= 0;
2458 /* This is the BIND_EXPR which holds the outermost iterator of the
2459 loop. It is convenient to set this variable up and test it before
2460 executing any other code in the loop.
2461 This is also the containing expression returned by this function. */
2462 tree controller
= NULL_TREE
;
2464 if (! IS_AGGR_TYPE (type
) || ! TYPE_NEEDS_DESTRUCTOR (type
))
2466 loop
= integer_zero_node
;
2470 /* The below is short by BI_header_size */
2471 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2473 tbase
= create_temporary_var (ptype
);
2474 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2475 fold (build (PLUS_EXPR
, ptype
,
2478 DECL_REGISTER (tbase
) = 1;
2479 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2480 TREE_SIDE_EFFECTS (controller
) = 1;
2484 body
= tree_cons (NULL_TREE
,
2485 build_delete (ptype
, tbase
, integer_two_node
,
2486 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2489 body
= tree_cons (NULL_TREE
,
2490 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2493 body
= tree_cons (NULL_TREE
,
2494 build (EXIT_EXPR
, void_type_node
,
2495 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2498 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2500 loop
= tree_cons (NULL_TREE
, tbase_init
,
2501 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2502 loop
= build_compound_expr (loop
);
2505 /* If the delete flag is one, or anything else with the low bit set,
2506 delete the storage. */
2507 if (auto_delete_vec
== integer_zero_node
)
2508 deallocate_expr
= integer_zero_node
;
2513 /* The below is short by BI_header_size */
2514 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2516 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2521 base_tbd
= cp_convert (ptype
,
2522 build_binary_op (MINUS_EXPR
,
2523 cp_convert (string_type_node
, base
),
2525 /* True size with header. */
2526 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2528 deallocate_expr
= build_x_delete (base_tbd
,
2529 2 | use_global_delete
,
2531 deallocate_expr
= fold (build (COND_EXPR
, void_type_node
,
2532 fold (build (BIT_AND_EXPR
,
2536 deallocate_expr
, integer_zero_node
));
2539 if (loop
&& deallocate_expr
!= integer_zero_node
)
2541 body
= tree_cons (NULL_TREE
, loop
,
2542 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2543 body
= build_compound_expr (body
);
2548 /* Outermost wrapper: If pointer is null, punt. */
2549 body
= fold (build (COND_EXPR
, void_type_node
,
2550 fold (build (NE_EXPR
, boolean_type_node
, base
,
2551 integer_zero_node
)),
2552 body
, integer_zero_node
));
2553 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2557 TREE_OPERAND (controller
, 1) = body
;
2561 return cp_convert (void_type_node
, body
);
2565 create_temporary_var (type
)
2570 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2571 TREE_USED (decl
) = 1;
2572 DECL_ARTIFICIAL (decl
) = 1;
2573 DECL_SOURCE_FILE (decl
) = input_filename
;
2574 DECL_SOURCE_LINE (decl
) = lineno
;
2575 DECL_IGNORED_P (decl
) = 1;
2576 DECL_CONTEXT (decl
) = current_function_decl
;
2581 /* Create a new temporary variable of the indicated TYPE, initialized
2584 It is not entered into current_binding_level, because that breaks
2585 things when it comes time to do final cleanups (which take place
2586 "outside" the binding contour of the function). */
2589 get_temp_regvar (type
, init
)
2594 decl
= create_temporary_var (type
);
2595 if (building_stmt_tree ())
2596 add_decl_stmt (decl
);
2597 if (!building_stmt_tree ())
2598 DECL_RTL (decl
) = assign_temp (type
, 2, 0, 1);
2599 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
2604 /* `build_vec_init' returns tree structure that performs
2605 initialization of a vector of aggregate types.
2607 DECL is passed only for error reporting, and provides line number
2608 and source file name information.
2609 BASE is the space where the vector will be. For a vector of Ts,
2610 the type of BASE is `T*'.
2611 MAXINDEX is the maximum index of the array (one less than the
2612 number of elements).
2613 INIT is the (possibly NULL) initializer.
2615 FROM_ARRAY is 0 if we should init everything with INIT
2616 (i.e., every element initialized from INIT).
2617 FROM_ARRAY is 1 if we should index into INIT in parallel
2618 with initialization of DECL.
2619 FROM_ARRAY is 2 if we should index into INIT in parallel,
2620 but use assignment instead of initialization. */
2623 build_vec_init (decl
, base
, maxindex
, init
, from_array
)
2624 tree decl
, base
, maxindex
, init
;
2628 tree base2
= NULL_TREE
;
2630 tree itype
= NULL_TREE
;
2632 /* The type of an element in the array. */
2634 /* The type of a pointer to an element in the array. */
2639 tree try_block
= NULL_TREE
;
2640 tree try_body
= NULL_TREE
;
2641 int num_initialized_elts
= 0;
2643 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2644 if (maxindex
== error_mark_node
)
2645 return error_mark_node
;
2647 type
= TREE_TYPE (TREE_TYPE (base
));
2648 ptype
= build_pointer_type (type
);
2649 size
= size_in_bytes (type
);
2651 /* The code we are generating looks like:
2655 ptrdiff_t iterator = maxindex;
2657 ... initializations from CONSTRUCTOR ...
2658 if (iterator != -1) {
2660 ... initialize *base ...
2662 } while (--iterator != -1);
2665 ... destroy elements that were constructed ...
2668 We can omit the try and catch blocks if we know that the
2669 initialization will never throw an exception, or if the array
2670 elements do not have destructors. If we have a CONSTRUCTOR to
2671 give us initialization information, we emit code to initialize
2672 each of the elements before the loop in the try block, and then
2673 iterate over fewer elements. We can omit the loop completely if
2674 the elements of the array do not have constructors.
2676 We actually wrap the entire body of the above in a STMT_EXPR, for
2679 When copying from array to another, when the array elements have
2680 only trivial copy constructors, we should use __builtin_memcpy
2681 rather than generating a loop. That way, we could take advantage
2682 of whatever cleverness the back-end has for dealing with copies
2683 of blocks of memory. */
2685 begin_init_stmts (&stmt_expr
, &compound_stmt
);
2686 destroy_temps
= stmts_are_full_exprs_p
;
2687 stmts_are_full_exprs_p
= 0;
2688 rval
= get_temp_regvar (ptype
,
2689 cp_convert (ptype
, default_conversion (base
)));
2690 base
= get_temp_regvar (ptype
, rval
);
2691 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2693 /* Protect the entire array initialization so that we can destroy
2694 the partially constructed array if an exception is thrown. */
2695 if (flag_exceptions
&& TYPE_NEEDS_DESTRUCTOR (type
))
2697 try_block
= begin_try_block ();
2698 try_body
= begin_compound_stmt (/*has_no_scope=*/1);
2701 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
2702 && (!decl
|| same_type_p (TREE_TYPE (init
), TREE_TYPE (decl
))))
2704 /* Do non-default initialization resulting from brace-enclosed
2710 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2712 tree elt
= TREE_VALUE (elts
);
2713 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2715 num_initialized_elts
++;
2717 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2718 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0));
2720 finish_expr_stmt (build_modify_expr (baseref
, NOP_EXPR
,
2723 finish_expr_stmt (build_modify_expr
2726 build (PLUS_EXPR
, build_pointer_type (type
),
2728 finish_expr_stmt (build_modify_expr
2731 build (MINUS_EXPR
, ptrdiff_type_node
,
2732 iterator
, integer_one_node
)));
2735 /* Clear out INIT so that we don't get confused below. */
2738 else if (from_array
)
2740 /* If initializing one array from another, initialize element by
2741 element. We rely upon the below calls the do argument
2743 if (decl
== NULL_TREE
)
2745 sorry ("initialization of array from dissimilar array type");
2746 return error_mark_node
;
2750 base2
= default_conversion (init
);
2751 itype
= TREE_TYPE (base2
);
2752 base2
= get_temp_regvar (itype
, base2
);
2753 itype
= TREE_TYPE (itype
);
2755 else if (TYPE_LANG_SPECIFIC (type
)
2756 && TYPE_NEEDS_CONSTRUCTING (type
)
2757 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2759 error ("initializer ends prematurely");
2760 return error_mark_node
;
2764 /* Now, default-initialize any remaining elements. We don't need to
2765 do that if a) the type does not need constructing, or b) we've
2766 already initialized all the elements.
2768 We do need to keep going if we're copying an array. */
2771 || (TYPE_NEEDS_CONSTRUCTING (type
)
2772 && !(TREE_CODE (maxindex
) == INTEGER_CST
2773 && num_initialized_elts
== TREE_INT_CST_LOW (maxindex
) + 1)))
2775 /* If the ITERATOR is equal to -1, then we don't have to loop;
2776 we've already initialized all the elements. */
2782 if_stmt
= begin_if_stmt ();
2783 finish_if_stmt_cond (build (NE_EXPR
, boolean_type_node
,
2784 iterator
, minus_one_node
),
2787 /* Otherwise, loop through the elements. */
2788 do_stmt
= begin_do_stmt ();
2789 do_body
= begin_compound_stmt (/*has_no_scope=*/1);
2791 /* When we're not building a statement-tree, things are a little
2792 complicated. If, when we recursively call build_aggr_init,
2793 an expression containing a TARGET_EXPR is expanded, then it
2794 may get a cleanup. Then, the result of that expression is
2795 passed to finish_expr_stmt, which will call
2796 expand_start_target_temps/expand_end_target_temps. However,
2797 the latter call will not cause the cleanup to run because
2798 that block will still be on the block stack. So, we call
2799 expand_start_target_temps here manually; the corresponding
2800 call to expand_end_target_temps below will cause the cleanup
2802 if (!building_stmt_tree ())
2803 expand_start_target_temps ();
2807 tree to
= build1 (INDIRECT_REF
, type
, base
);
2811 from
= build1 (INDIRECT_REF
, itype
, base2
);
2815 if (from_array
== 2)
2816 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
2817 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2818 elt_init
= build_aggr_init (to
, from
, 0);
2820 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
2822 my_friendly_abort (57);
2824 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2827 sorry ("cannot initialize multi-dimensional array with initializer");
2828 elt_init
= (build_vec_init
2831 build_pointer_type (TREE_TYPE (type
)),
2833 array_type_nelts (type
), 0, 0));
2836 elt_init
= build_aggr_init (build1 (INDIRECT_REF
, type
, base
),
2839 /* The initialization of each array element is a
2841 if (!building_stmt_tree ())
2843 finish_expr_stmt (elt_init
);
2844 expand_end_target_temps ();
2848 stmts_are_full_exprs_p
= 1;
2849 finish_expr_stmt (elt_init
);
2850 stmts_are_full_exprs_p
= 0;
2853 finish_expr_stmt (build_modify_expr
2856 build (PLUS_EXPR
, build_pointer_type (type
),
2859 finish_expr_stmt (build_modify_expr
2862 build (PLUS_EXPR
, build_pointer_type (type
),
2865 finish_compound_stmt (/*has_no_scope=*/1, do_body
);
2866 finish_do_body (do_stmt
);
2867 finish_do_stmt (build (NE_EXPR
, boolean_type_node
,
2868 build (PREDECREMENT_EXPR
,
2875 finish_then_clause (if_stmt
);
2879 /* Make sure to cleanup any partially constructed elements. */
2880 if (flag_exceptions
&& TYPE_NEEDS_DESTRUCTOR (type
))
2884 finish_compound_stmt (/*has_no_scope=*/1, try_body
);
2885 finish_cleanup_try_block (try_block
);
2886 e
= build_vec_delete_1 (rval
,
2887 build_binary_op (MINUS_EXPR
, maxindex
,
2890 /*auto_delete_vec=*/integer_zero_node
,
2891 /*use_global_delete=*/0);
2892 finish_cleanup (e
, try_block
);
2895 /* The value of the array initialization is the address of the
2896 first element in the array. */
2897 finish_expr_stmt (rval
);
2899 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
2900 stmts_are_full_exprs_p
= destroy_temps
;
2904 /* Free up storage of type TYPE, at address ADDR.
2906 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2909 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2910 used as the second argument to operator delete. It can include
2911 things like padding and magic size cookies. It has virtual in it,
2912 because if you have a base pointer and you delete through a virtual
2913 destructor, it should be the size of the dynamic object, not the
2914 static object, see Free Store 12.5 ANSI C++ WP.
2916 This does not call any destructors. */
2919 build_x_delete (addr
, which_delete
, virtual_size
)
2924 int use_global_delete
= which_delete
& 1;
2925 int use_vec_delete
= !!(which_delete
& 2);
2926 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2927 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
2929 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
2932 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2933 ADDR is an expression which yields the store to be destroyed.
2934 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
2935 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
2936 virtual baseclasses.
2937 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
2939 FLAGS is the logical disjunction of zero or more LOOKUP_
2940 flags. See cp-tree.h for more info.
2942 This function does not delete an object's virtual base classes. */
2945 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
2949 int use_global_delete
;
2955 if (addr
== error_mark_node
)
2956 return error_mark_node
;
2958 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2959 set to `error_mark_node' before it gets properly cleaned up. */
2960 if (type
== error_mark_node
)
2961 return error_mark_node
;
2963 type
= TYPE_MAIN_VARIANT (type
);
2965 if (TREE_CODE (type
) == POINTER_TYPE
)
2967 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
2968 if (type
!= void_type_node
&& !complete_type_or_else (type
, addr
))
2969 return error_mark_node
;
2970 if (TREE_CODE (type
) == ARRAY_TYPE
)
2972 if (! IS_AGGR_TYPE (type
))
2974 /* Call the builtin operator delete. */
2975 return build_builtin_delete_call (addr
);
2977 if (TREE_SIDE_EFFECTS (addr
))
2978 addr
= save_expr (addr
);
2980 /* throw away const and volatile on target type of addr */
2981 addr
= convert_force (build_pointer_type (type
), addr
, 0);
2982 ref
= build_indirect_ref (addr
, NULL_PTR
);
2984 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2987 if (TREE_SIDE_EFFECTS (addr
))
2988 addr
= save_expr (addr
);
2989 if (TYPE_DOMAIN (type
) == NULL_TREE
)
2991 error ("unknown array size in delete");
2992 return error_mark_node
;
2994 return build_vec_delete (addr
, array_type_nelts (type
),
2995 auto_delete
, use_global_delete
);
2999 /* Don't check PROTECT here; leave that decision to the
3000 destructor. If the destructor is accessible, call it,
3001 else report error. */
3002 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3003 if (TREE_SIDE_EFFECTS (addr
))
3004 addr
= save_expr (addr
);
3006 if (TREE_CONSTANT (addr
))
3007 addr
= convert_pointer_to (type
, addr
);
3009 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3011 ref
= build_indirect_ref (addr
, NULL_PTR
);
3014 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3016 if (! TYPE_NEEDS_DESTRUCTOR (type
))
3018 if (auto_delete
== integer_zero_node
)
3019 return void_zero_node
;
3021 return build_op_delete_call
3022 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3023 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3027 /* Below, we will reverse the order in which these calls are made.
3028 If we have a destructor, then that destructor will take care
3029 of the base classes; otherwise, we must do that here. */
3030 if (TYPE_HAS_DESTRUCTOR (type
))
3032 tree passed_auto_delete
;
3033 tree do_delete
= NULL_TREE
;
3036 if (use_global_delete
)
3038 tree cond
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3039 auto_delete
, integer_one_node
));
3040 tree call
= build_builtin_delete_call (addr
);
3042 cond
= fold (build (COND_EXPR
, void_type_node
, cond
,
3043 call
, void_zero_node
));
3044 if (cond
!= void_zero_node
)
3047 passed_auto_delete
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3048 auto_delete
, integer_two_node
));
3051 passed_auto_delete
= auto_delete
;
3053 expr
= build_method_call
3054 (ref
, dtor_identifier
, build_expr_list (NULL_TREE
, passed_auto_delete
),
3058 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3060 if (flags
& LOOKUP_DESTRUCTOR
)
3061 /* Explicit destructor call; don't check for null pointer. */
3062 ifexp
= integer_one_node
;
3064 /* Handle deleting a null pointer. */
3065 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
));
3067 if (ifexp
!= integer_one_node
)
3068 expr
= build (COND_EXPR
, void_type_node
,
3069 ifexp
, expr
, void_zero_node
);
3075 /* We only get here from finish_function for a destructor. */
3076 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3077 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3078 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3079 tree exprstmt
= NULL_TREE
;
3080 tree parent_auto_delete
= auto_delete
;
3083 /* Set this again before we call anything, as we might get called
3085 TYPE_HAS_DESTRUCTOR (type
) = 1;
3087 /* If we have member delete or vbases, we call delete in
3089 if (auto_delete
== integer_zero_node
)
3091 else if (base_binfo
== NULL_TREE
3092 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3094 cond
= build (COND_EXPR
, void_type_node
,
3095 build (BIT_AND_EXPR
, integer_type_node
, auto_delete
, integer_one_node
),
3096 build_builtin_delete_call (addr
),
3103 exprstmt
= build_expr_list (NULL_TREE
, cond
);
3106 && ! TREE_VIA_VIRTUAL (base_binfo
)
3107 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3109 tree this_auto_delete
;
3111 if (BINFO_OFFSET_ZEROP (base_binfo
))
3112 this_auto_delete
= parent_auto_delete
;
3114 this_auto_delete
= integer_zero_node
;
3116 expr
= build_scoped_method_call
3117 (ref
, base_binfo
, dtor_identifier
,
3118 build_expr_list (NULL_TREE
, this_auto_delete
));
3119 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3122 /* Take care of the remaining baseclasses. */
3123 for (i
= 1; i
< n_baseclasses
; i
++)
3125 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3126 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3127 || TREE_VIA_VIRTUAL (base_binfo
))
3130 expr
= build_scoped_method_call
3131 (ref
, base_binfo
, dtor_identifier
,
3132 build_expr_list (NULL_TREE
, integer_zero_node
));
3134 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3137 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3139 if (TREE_CODE (member
) != FIELD_DECL
)
3141 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member
)))
3143 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3144 tree this_type
= TREE_TYPE (member
);
3145 expr
= build_delete (this_type
, this_member
, integer_two_node
, flags
, 0);
3146 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3151 return build_compound_expr (exprstmt
);
3152 /* Virtual base classes make this function do nothing. */
3153 return void_zero_node
;
3157 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3160 build_vbase_delete (type
, decl
)
3163 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3164 tree result
= NULL_TREE
;
3165 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3167 my_friendly_assert (addr
!= error_mark_node
, 222);
3171 tree this_addr
= convert_force (build_pointer_type (BINFO_TYPE (vbases
)),
3173 result
= tree_cons (NULL_TREE
,
3174 build_delete (TREE_TYPE (this_addr
), this_addr
,
3176 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3178 vbases
= TREE_CHAIN (vbases
);
3180 return build_compound_expr (nreverse (result
));
3183 /* Build a C++ vector delete expression.
3184 MAXINDEX is the number of elements to be deleted.
3185 ELT_SIZE is the nominal size of each element in the vector.
3186 BASE is the expression that should yield the store to be deleted.
3187 This function expands (or synthesizes) these calls itself.
3188 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3190 This also calls delete for virtual baseclasses of elements of the vector.
3192 Update: MAXINDEX is no longer needed. The size can be extracted from the
3193 start of the vector for pointers, and from the type for arrays. We still
3194 use MAXINDEX for arrays because it happens to already have one of the
3195 values we'd have to extract. (We could use MAXINDEX with pointers to
3196 confirm the size, and trap if the numbers differ; not clear that it'd
3197 be worth bothering.) */
3200 build_vec_delete (base
, maxindex
, auto_delete_vec
, use_global_delete
)
3201 tree base
, maxindex
;
3202 tree auto_delete_vec
;
3203 int use_global_delete
;
3207 if (TREE_CODE (base
) == OFFSET_REF
)
3208 base
= resolve_offset_ref (base
);
3210 type
= TREE_TYPE (base
);
3212 base
= stabilize_reference (base
);
3214 /* Since we can use base many times, save_expr it. */
3215 if (TREE_SIDE_EFFECTS (base
))
3216 base
= save_expr (base
);
3218 if (TREE_CODE (type
) == POINTER_TYPE
)
3220 /* Step back one from start of vector, and read dimension. */
3221 tree cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3222 base
, BI_header_size
);
3223 tree cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3224 maxindex
= build_component_ref (cookie
, nelts_identifier
, NULL_TREE
, 0);
3226 type
= TREE_TYPE (type
);
3227 while (TREE_CODE (type
) == ARRAY_TYPE
);
3229 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3231 /* get the total number of things in the array, maxindex is a bad name */
3232 maxindex
= array_type_nelts_total (type
);
3233 while (TREE_CODE (type
) == ARRAY_TYPE
)
3234 type
= TREE_TYPE (type
);
3235 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3239 if (base
!= error_mark_node
)
3240 error ("type to vector delete is neither pointer or array type");
3241 return error_mark_node
;
3244 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,