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 expand_aggr_vbase_init
PROTO((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 build_partial_cleanup_for
PROTO((tree
));
59 static tree initializing_context
PROTO((tree
));
60 static void expand_vec_init_try_block
PROTO((tree
));
61 static void expand_vec_init_catch_clause
PROTO((tree
, tree
, tree
, tree
));
62 static tree build_java_class_ref
PROTO((tree
));
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 partial cleanups for a base for exception handling. */
484 build_partial_cleanup_for (binfo
)
487 return build_scoped_method_call
488 (current_class_ref
, binfo
, dtor_identifier
,
489 build_expr_list (NULL_TREE
, integer_zero_node
));
492 /* Perform whatever initializations have yet to be done on the base
493 class of the class variable. These actions are in the global
494 variable CURRENT_BASE_INIT_LIST. Such an action could be
495 NULL_TREE, meaning that the user has explicitly called the base
496 class constructor with no arguments.
498 If there is a need for a call to a constructor, we must surround
499 that call with a pushlevel/poplevel pair, since we are technically
500 at the PARM level of scope.
502 Argument IMMEDIATELY, if zero, forces a new sequence to be
503 generated to contain these new insns, so it can be emitted later.
504 This sequence is saved in the global variable BASE_INIT_EXPR.
505 Otherwise, the insns are emitted into the current sequence.
507 Note that emit_base_init does *not* initialize virtual base
508 classes. That is done specially, elsewhere. */
510 extern tree base_init_expr
, rtl_expr_chain
;
513 emit_base_init (t
, immediately
)
519 tree rbase_init_list
, vbase_init_list
;
520 tree t_binfo
= TYPE_BINFO (t
);
521 tree binfos
= BINFO_BASETYPES (t_binfo
);
522 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
523 tree expr
= NULL_TREE
;
528 do_pending_stack_adjust ();
529 /* Make the RTL_EXPR node temporary, not momentary,
530 so that rtl_expr_chain doesn't become garbage. */
531 momentary
= suspend_momentary ();
532 expr
= make_node (RTL_EXPR
);
533 resume_momentary (momentary
);
534 start_sequence_for_rtl_expr (expr
);
537 if (write_symbols
== NO_DEBUG
)
538 /* As a matter of principle, `start_sequence' should do this. */
541 /* Always emit a line number note so we can step into constructors. */
542 emit_line_note_force (DECL_SOURCE_FILE (current_function_decl
),
543 DECL_SOURCE_LINE (current_function_decl
));
545 mem_init_list
= sort_member_init (t
);
546 current_member_init_list
= NULL_TREE
;
548 sort_base_init (t
, &rbase_init_list
, &vbase_init_list
);
549 current_base_init_list
= NULL_TREE
;
551 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
553 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
555 expand_start_cond (first_arg
, 0);
556 expand_aggr_vbase_init (t_binfo
, current_class_ref
, current_class_ptr
,
561 /* Now, perform initialization of non-virtual base classes. */
562 for (i
= 0; i
< n_baseclasses
; i
++)
564 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
565 tree init
= void_list_node
;
567 if (TREE_VIA_VIRTUAL (base_binfo
))
570 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
,
573 if (TREE_PURPOSE (rbase_init_list
))
574 init
= TREE_VALUE (rbase_init_list
);
575 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
578 if (extra_warnings
&& copy_args_p (current_function_decl
))
579 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
580 BINFO_TYPE (base_binfo
));
583 if (init
!= void_list_node
)
585 expand_start_target_temps ();
587 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
588 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
589 build_indirect_ref (member
, NULL_PTR
), init
,
592 expand_end_target_temps ();
596 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
600 /* All cleanups must be on the function_obstack. */
601 push_obstacks_nochange ();
602 resume_temporary_allocation ();
603 expr
= build_partial_cleanup_for (base_binfo
);
605 add_partial_entry (expr
);
608 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
611 /* Initialize all the virtual function table fields that
612 do come from virtual base classes. */
613 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
614 expand_indirect_vtbls_init (t_binfo
, current_class_ref
, current_class_ptr
);
616 /* Initialize all the virtual function table fields that
617 do not come from virtual base classes. */
618 expand_direct_vtbls_init (t_binfo
, t_binfo
, 1, 1, current_class_ptr
);
620 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
625 /* member could be, for example, a CONST_DECL for an enumerated
626 tag; we don't want to try to initialize that, since it already
628 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
631 /* See if we had a user-specified member initialization. */
632 if (TREE_PURPOSE (mem_init_list
))
634 name
= TREE_PURPOSE (mem_init_list
);
635 init
= TREE_VALUE (mem_init_list
);
639 if (TREE_CODE (name
) == COMPONENT_REF
)
640 name
= DECL_NAME (TREE_OPERAND (name
, 1));
642 /* Also see if it's ever a COMPONENT_REF here. If it is, we
643 need to do `expand_assignment (name, init, 0, 0);' and
645 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 349);
650 name
= DECL_NAME (member
);
651 init
= DECL_INITIAL (member
);
655 /* Effective C++ rule 12. */
656 if (warn_ecpp
&& init
== NULL_TREE
657 && !DECL_ARTIFICIAL (member
)
658 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
659 cp_warning ("`%D' should be initialized in the member initialization list", member
);
662 perform_member_init (member
, name
, init
, from_init_list
);
663 mem_init_list
= TREE_CHAIN (mem_init_list
);
666 /* Now initialize any members from our bases. */
667 while (mem_init_list
)
669 tree name
, init
, field
;
671 if (TREE_PURPOSE (mem_init_list
))
673 name
= TREE_PURPOSE (mem_init_list
);
674 init
= TREE_VALUE (mem_init_list
);
675 /* XXX: this may need the COMPONENT_REF operand 0 check if
676 it turns out we actually get them. */
677 field
= IDENTIFIER_CLASS_VALUE (name
);
679 /* If one member shadows another, get the outermost one. */
680 if (TREE_CODE (field
) == TREE_LIST
)
682 field
= TREE_VALUE (field
);
683 if (decl_type_context (field
) != current_class_type
)
684 cp_error ("field `%D' not in immediate context", field
);
688 /* It turns out if you have an anonymous union in the
689 class, a member from it can end up not being on the
690 list of fields (rather, the type is), and therefore
691 won't be seen by the for loop above. */
693 /* The code in this for loop is derived from a general loop
694 which had this check in it. Theoretically, we've hit
695 every initialization for the list of members in T, so
696 we shouldn't have anything but these left in this list. */
697 my_friendly_assert (DECL_FIELD_CONTEXT (field
) != t
, 351);
700 perform_member_init (field
, name
, init
, 1);
702 mem_init_list
= TREE_CHAIN (mem_init_list
);
707 do_pending_stack_adjust ();
708 my_friendly_assert (base_init_expr
== 0, 207);
709 base_init_expr
= expr
;
710 TREE_TYPE (expr
) = void_type_node
;
711 RTL_EXPR_RTL (expr
) = const0_rtx
;
712 RTL_EXPR_SEQUENCE (expr
) = get_insns ();
713 rtl_expr_chain
= tree_cons (NULL_TREE
, expr
, rtl_expr_chain
);
715 TREE_SIDE_EFFECTS (expr
) = 1;
718 /* All the implicit try blocks we built up will be zapped
719 when we come to a real binding contour boundary. */
722 /* Check that all fields are properly initialized after
723 an assignment to `this'. */
730 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
731 if (DECL_NAME (member
) && TREE_USED (member
))
732 cp_error ("field `%D' used before initialized (after assignment to `this')",
736 /* This code sets up the virtual function tables appropriate for
737 the pointer DECL. It is a one-ply initialization.
739 BINFO is the exact type that DECL is supposed to be. In
740 multiple inheritance, this might mean "C's A" if C : A, B. */
743 expand_virtual_init (binfo
, decl
)
746 tree type
= BINFO_TYPE (binfo
);
748 tree vtype
, vtype_binfo
;
750 /* This code is crusty. Should be simple, like:
751 vtbl = BINFO_VTABLE (binfo);
753 vtype
= DECL_CONTEXT (CLASSTYPE_VFIELD (type
));
754 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
755 vtbl
= BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type
)), binfo
));
756 assemble_external (vtbl
);
757 TREE_USED (vtbl
) = 1;
758 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
759 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
760 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
761 if (vtbl_ptr
== error_mark_node
)
764 /* Have to convert VTBL since array sizes may be different. */
765 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
766 expand_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
769 /* Subroutine of `expand_aggr_vbase_init'.
770 BINFO is the binfo of the type that is being initialized.
771 INIT_LIST is the list of initializers for the virtual baseclass. */
774 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
775 tree binfo
, exp
, addr
, init_list
;
777 tree init
= purpose_member (binfo
, init_list
);
778 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
780 expand_start_target_temps ();
783 init
= TREE_VALUE (init
);
784 /* Call constructors, but don't set up vtables. */
785 expand_aggr_init_1 (binfo
, exp
, ref
, init
, LOOKUP_COMPLAIN
);
787 expand_end_target_temps ();
791 /* Initialize this object's virtual base class pointers. This must be
792 done only at the top-level of the object being constructed.
794 INIT_LIST is list of initialization for constructor to perform. */
797 expand_aggr_vbase_init (binfo
, exp
, addr
, init_list
)
803 tree type
= BINFO_TYPE (binfo
);
805 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
807 tree result
= init_vbase_pointers (type
, addr
);
811 expand_expr_stmt (build_compound_expr (result
));
813 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
814 vbases
= TREE_CHAIN (vbases
))
816 tree tmp
= purpose_member (vbases
, result
);
817 expand_aggr_vbase_init_1 (vbases
, exp
,
818 TREE_OPERAND (TREE_VALUE (tmp
), 0),
824 /* Find the context in which this FIELD can be initialized. */
827 initializing_context (field
)
830 tree t
= DECL_CONTEXT (field
);
832 /* Anonymous union members can be initialized in the first enclosing
833 non-anonymous union context. */
834 while (t
&& ANON_UNION_TYPE_P (t
))
835 t
= TYPE_CONTEXT (t
);
839 /* Function to give error message if member initialization specification
840 is erroneous. FIELD is the member we decided to initialize.
841 TYPE is the type for which the initialization is being performed.
842 FIELD must be a member of TYPE.
844 MEMBER_NAME is the name of the member. */
847 member_init_ok_or_else (field
, type
, member_name
)
850 const char *member_name
;
852 if (field
== error_mark_node
)
854 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
856 cp_error ("class `%T' does not have any field named `%s'", type
,
860 if (TREE_STATIC (field
))
862 cp_error ("field `%#D' is static; only point of initialization is its declaration",
870 /* If NAME is a viable field name for the aggregate DECL,
871 and PARMS is a viable parameter list, then expand an _EXPR
872 which describes this initialization.
874 Note that we do not need to chase through the class's base classes
875 to look for NAME, because if it's in that list, it will be handled
876 by the constructor for that base class.
878 We do not yet have a fixed-point finder to instantiate types
879 being fed to overloaded constructors. If there is a unique
880 constructor, then argument types can be got from that one.
882 If INIT is non-NULL, then it the initialization should
883 be placed in `current_base_init_list', where it will be processed
884 by `emit_base_init'. */
887 expand_member_init (exp
, name
, init
)
888 tree exp
, name
, init
;
890 tree basetype
= NULL_TREE
, field
;
893 if (exp
== NULL_TREE
)
894 return; /* complain about this later */
896 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
898 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
900 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
901 name
= DECL_NAME (name
);
904 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
905 switch (CLASSTYPE_N_BASECLASSES (type
))
908 error ("base class initializer specified, but no base class to initialize");
911 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
914 error ("initializer for unnamed base class ambiguous");
915 cp_error ("(type `%T' uses multiple inheritance)", type
);
919 my_friendly_assert (init
!= NULL_TREE
, 0);
921 /* The grammar should not allow fields which have names that are
922 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
923 may assume that this is an attempt to initialize a base class
924 member of the current type. Otherwise, it is an attempt to
925 initialize a member field. */
927 if (init
== void_type_node
)
930 if (name
== NULL_TREE
|| basetype
)
934 if (name
== NULL_TREE
)
938 name
= TYPE_IDENTIFIER (basetype
);
941 error ("no base class to initialize");
946 else if (basetype
!= type
947 && ! current_template_parms
948 && ! vec_binfo_member (basetype
,
949 TYPE_BINFO_BASETYPES (type
))
950 && ! binfo_member (basetype
, CLASSTYPE_VBASECLASSES (type
)))
952 if (IDENTIFIER_CLASS_VALUE (name
))
954 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
955 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
958 cp_error ("type `%T' is not an immediate basetype for `%T'",
963 if (purpose_member (basetype
, current_base_init_list
))
965 cp_error ("base class `%T' already initialized", basetype
);
969 if (warn_reorder
&& current_member_init_list
)
971 cp_warning ("base initializer for `%T'", basetype
);
972 warning (" will be re-ordered to precede member initializations");
975 base_init
= build_tree_list (basetype
, init
);
976 current_base_init_list
= chainon (current_base_init_list
, base_init
);
983 field
= lookup_field (type
, name
, 1, 0);
985 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
988 if (purpose_member (name
, current_member_init_list
))
990 cp_error ("field `%D' already initialized", field
);
994 member_init
= build_tree_list (name
, init
);
995 current_member_init_list
= chainon (current_member_init_list
, member_init
);
999 /* This is like `expand_member_init', only it stores one aggregate
1002 INIT comes in two flavors: it is either a value which
1003 is to be stored in EXP, or it is a parameter list
1004 to go to a constructor, which will operate on EXP.
1005 If INIT is not a parameter list for a constructor, then set
1006 LOOKUP_ONLYCONVERTING.
1007 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1008 the initializer, if FLAGS is 0, then it is the (init) form.
1009 If `init' is a CONSTRUCTOR, then we emit a warning message,
1010 explaining that such initializations are invalid.
1012 ALIAS_THIS is nonzero iff we are initializing something which is
1013 essentially an alias for current_class_ref. In this case, the base
1014 constructor may move it on us, and we must keep track of such
1017 If INIT resolves to a CALL_EXPR which happens to return
1018 something of the type we are looking for, then we know
1019 that we can safely use that call to perform the
1022 The virtual function table pointer cannot be set up here, because
1023 we do not really know its type.
1025 Virtual baseclass pointers are also set up here.
1027 This never calls operator=().
1029 When initializing, nothing is CONST.
1031 A default copy constructor may have to be used to perform the
1034 A constructor or a conversion operator may have to be used to
1035 perform the initialization, but not both, as it would be ambiguous. */
1038 expand_aggr_init (exp
, init
, flags
)
1042 tree type
= TREE_TYPE (exp
);
1043 int was_const
= TREE_READONLY (exp
);
1044 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1046 if (init
== error_mark_node
)
1049 TREE_READONLY (exp
) = 0;
1050 TREE_THIS_VOLATILE (exp
) = 0;
1052 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1053 flags
|= LOOKUP_ONLYCONVERTING
;
1055 if (TREE_CODE (type
) == ARRAY_TYPE
)
1057 /* Must arrange to initialize each element of EXP
1058 from elements of INIT. */
1059 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1060 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
1062 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1064 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1066 if (init
&& TREE_TYPE (init
) == NULL_TREE
)
1068 /* Handle bad initializers like:
1072 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1076 int main(int argc, char **argv) {
1077 COMPLEX zees(1.0, 0.0)[10];
1080 error ("bad array initializer");
1083 expand_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1084 init
&& same_type_p (TREE_TYPE (init
),
1086 TREE_READONLY (exp
) = was_const
;
1087 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1088 TREE_TYPE (exp
) = type
;
1090 TREE_TYPE (init
) = itype
;
1094 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1095 /* just know that we've seen something for this node */
1096 TREE_USED (exp
) = 1;
1099 /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1100 constructor as parameters to an implicit GNU C++ constructor. */
1101 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
1102 && TYPE_HAS_CONSTRUCTOR (type
)
1103 && TREE_TYPE (init
) == type
)
1104 init
= CONSTRUCTOR_ELTS (init
);
1107 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1108 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1109 init
, LOOKUP_NORMAL
|flags
);
1110 TREE_TYPE (exp
) = type
;
1111 TREE_READONLY (exp
) = was_const
;
1112 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1116 expand_default_init (binfo
, true_exp
, exp
, init
, flags
)
1122 tree type
= TREE_TYPE (exp
);
1124 /* It fails because there may not be a constructor which takes
1125 its own type as the first (or only parameter), but which does
1126 take other types via a conversion. So, if the thing initializing
1127 the expression is a unit element of type X, first try X(X&),
1128 followed by initialization by X. If neither of these work
1129 out, then look hard. */
1133 if (init
&& TREE_CODE (init
) != TREE_LIST
1134 && (flags
& LOOKUP_ONLYCONVERTING
))
1136 /* Base subobjects should only get direct-initialization. */
1137 if (true_exp
!= exp
)
1140 if (flags
& DIRECT_BIND
)
1141 /* Do nothing. We hit this in two cases: Reference initialization,
1142 where we aren't initializing a real variable, so we don't want
1143 to run a new constructor; and catching an exception, where we
1144 have already built up the constructor call so we could wrap it
1145 in an exception region. */;
1147 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1149 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1150 /* We need to protect the initialization of a catch parm
1151 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1152 around the TARGET_EXPR for the copy constructor. See
1153 expand_start_catch_block. */
1154 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1155 TREE_OPERAND (init
, 0));
1157 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1158 TREE_SIDE_EFFECTS (init
) = 1;
1159 expand_expr_stmt (init
);
1163 if (init
== NULL_TREE
1164 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1168 init
= TREE_VALUE (parms
);
1171 parms
= build_expr_list (NULL_TREE
, init
);
1173 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1175 if (true_exp
== exp
)
1176 parms
= expr_tree_cons (NULL_TREE
, integer_one_node
, parms
);
1178 parms
= expr_tree_cons (NULL_TREE
, integer_zero_node
, parms
);
1179 flags
|= LOOKUP_HAS_IN_CHARGE
;
1182 rval
= build_method_call (exp
, ctor_identifier
,
1183 parms
, binfo
, flags
);
1184 if (TREE_SIDE_EFFECTS (rval
))
1185 expand_expr_stmt (rval
);
1188 /* This function is responsible for initializing EXP with INIT
1191 BINFO is the binfo of the type for who we are performing the
1192 initialization. For example, if W is a virtual base class of A and B,
1194 If we are initializing B, then W must contain B's W vtable, whereas
1195 were we initializing C, W must contain C's W vtable.
1197 TRUE_EXP is nonzero if it is the true expression being initialized.
1198 In this case, it may be EXP, or may just contain EXP. The reason we
1199 need this is because if EXP is a base element of TRUE_EXP, we
1200 don't necessarily know by looking at EXP where its virtual
1201 baseclass fields should really be pointing. But we do know
1202 from TRUE_EXP. In constructors, we don't know anything about
1203 the value being initialized.
1205 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1207 FLAGS is just passes to `build_method_call'. See that function for
1211 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, flags
)
1217 tree type
= TREE_TYPE (exp
);
1219 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1221 /* Use a function returning the desired type to initialize EXP for us.
1222 If the function is a constructor, and its first argument is
1223 NULL_TREE, know that it was meant for us--just slide exp on
1224 in and expand the constructor. Constructors now come
1227 if (init
&& TREE_CODE (exp
) == VAR_DECL
1228 && TREE_CODE (init
) == CONSTRUCTOR
1229 && TREE_HAS_CONSTRUCTOR (init
))
1231 tree t
= store_init_value (exp
, init
);
1234 expand_decl_init (exp
);
1237 t
= build (INIT_EXPR
, type
, exp
, init
);
1238 TREE_SIDE_EFFECTS (t
) = 1;
1239 expand_expr_stmt (t
);
1243 /* We know that expand_default_init can handle everything we want
1245 expand_default_init (binfo
, true_exp
, exp
, init
, flags
);
1248 /* Report an error if NAME is not the name of a user-defined,
1249 aggregate type. If OR_ELSE is nonzero, give an error message. */
1252 is_aggr_typedef (name
, or_else
)
1258 if (name
== error_mark_node
)
1261 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1262 type
= IDENTIFIER_TYPE_VALUE (name
);
1266 cp_error ("`%T' is not an aggregate typedef", name
);
1270 if (! IS_AGGR_TYPE (type
)
1271 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1272 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1275 cp_error ("`%T' is not an aggregate type", type
);
1281 /* Report an error if TYPE is not a user-defined, aggregate type. If
1282 OR_ELSE is nonzero, give an error message. */
1285 is_aggr_type (type
, or_else
)
1289 if (type
== error_mark_node
)
1292 if (! IS_AGGR_TYPE (type
)
1293 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1294 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1297 cp_error ("`%T' is not an aggregate type", type
);
1303 /* Like is_aggr_typedef, but returns typedef if successful. */
1306 get_aggr_from_typedef (name
, or_else
)
1312 if (name
== error_mark_node
)
1315 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1316 type
= IDENTIFIER_TYPE_VALUE (name
);
1320 cp_error ("`%T' fails to be an aggregate typedef", name
);
1324 if (! IS_AGGR_TYPE (type
)
1325 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1326 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1329 cp_error ("type `%T' is of non-aggregate type", type
);
1336 get_type_value (name
)
1339 if (name
== error_mark_node
)
1342 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1343 return IDENTIFIER_TYPE_VALUE (name
);
1349 /* This code could just as well go in `class.c', but is placed here for
1352 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1353 the appropriate function call. */
1356 build_member_call (type
, name
, parmlist
)
1357 tree type
, name
, parmlist
;
1362 tree basetype_path
, decl
;
1364 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
1365 && TREE_CODE (type
) == NAMESPACE_DECL
)
1367 /* 'name' already refers to the decls from the namespace, since we
1368 hit do_identifier for template_ids. */
1369 my_friendly_assert (is_overloaded_fn (TREE_OPERAND (name
, 0)), 980519);
1370 return build_x_function_call (name
, parmlist
, current_class_ref
);
1373 if (type
== std_node
)
1374 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1376 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1377 return build_x_function_call (lookup_namespace_name (type
, name
),
1378 parmlist
, current_class_ref
);
1380 if (TREE_CODE (name
) != TEMPLATE_ID_EXPR
)
1384 method_name
= TREE_OPERAND (name
, 0);
1385 if (is_overloaded_fn (method_name
))
1386 method_name
= DECL_NAME (OVL_CURRENT (method_name
));
1389 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1391 method_name
= TREE_OPERAND (method_name
, 0);
1395 /* This shouldn't be here, and build_member_call shouldn't appear in
1397 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1398 && get_aggr_from_typedef (type
, 0) == 0)
1400 tree ns
= lookup_name (type
, 0);
1401 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1403 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1407 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1408 return error_mark_node
;
1410 /* An operator we did not like. */
1411 if (name
== NULL_TREE
)
1412 return error_mark_node
;
1416 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1418 return error_mark_node
;
1421 decl
= maybe_dummy_object (type
, &basetype_path
);
1423 /* Convert 'this' to the specified type to disambiguate conversion
1424 to the function's context. Apparently Standard C++ says that we
1425 shouldn't do this. */
1426 if (decl
== current_class_ref
1428 && ACCESSIBLY_UNIQUELY_DERIVED_P (type
, current_class_type
))
1430 tree olddecl
= current_class_ptr
;
1431 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1432 if (oldtype
!= type
)
1434 tree newtype
= build_qualified_type (type
, TYPE_QUALS (oldtype
));
1435 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1436 decl
= build_indirect_ref (decl
, NULL_PTR
);
1440 if (method_name
== constructor_name (type
)
1441 || method_name
== constructor_name_full (type
))
1442 return build_functional_cast (type
, parmlist
);
1443 if ((t
= lookup_fnfields (basetype_path
, method_name
, 0)))
1444 return build_method_call (decl
,
1445 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1446 ? name
: method_name
,
1447 parmlist
, basetype_path
,
1448 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1449 if (TREE_CODE (name
) == IDENTIFIER_NODE
1450 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1452 if (t
== error_mark_node
)
1453 return error_mark_node
;
1454 if (TREE_CODE (t
) == FIELD_DECL
)
1456 if (is_dummy_object (decl
))
1458 cp_error ("invalid use of non-static field `%D'", t
);
1459 return error_mark_node
;
1461 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1463 else if (TREE_CODE (t
) == VAR_DECL
)
1467 cp_error ("invalid use of member `%D'", t
);
1468 return error_mark_node
;
1470 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1471 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1472 parmlist
, NULL_TREE
);
1473 return build_function_call (decl
, parmlist
);
1477 cp_error ("no method `%T::%D'", type
, name
);
1478 return error_mark_node
;
1482 /* Build a reference to a member of an aggregate. This is not a
1483 C++ `&', but really something which can have its address taken,
1484 and then act as a pointer to member, for example TYPE :: FIELD
1485 can have its address taken by saying & TYPE :: FIELD.
1487 @@ Prints out lousy diagnostics for operator <typename>
1490 @@ This function should be rewritten and placed in search.c. */
1493 build_offset_ref (type
, name
)
1496 tree decl
, t
= error_mark_node
;
1498 tree basebinfo
= NULL_TREE
;
1499 tree orig_name
= name
;
1501 /* class templates can come in as TEMPLATE_DECLs here. */
1502 if (TREE_CODE (name
) == TEMPLATE_DECL
)
1505 if (type
== std_node
)
1506 return do_scoped_id (name
, 0);
1508 if (processing_template_decl
|| uses_template_parms (type
))
1509 return build_min_nt (SCOPE_REF
, type
, name
);
1511 /* Handle namespace names fully here. */
1512 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1514 t
= lookup_namespace_name (type
, name
);
1515 if (t
!= error_mark_node
&& ! type_unknown_p (t
))
1518 t
= convert_from_reference (t
);
1523 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1524 return error_mark_node
;
1526 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1528 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1529 something like `a.template f<int>' or the like. For the most
1530 part, we treat this just like a.f. We do remember, however,
1531 the template-id that was used. */
1532 name
= TREE_OPERAND (orig_name
, 0);
1534 if (TREE_CODE (name
) == LOOKUP_EXPR
)
1535 /* This can happen during tsubst'ing. */
1536 name
= TREE_OPERAND (name
, 0);
1538 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
1541 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1543 if (! check_dtor_name (type
, name
))
1544 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1545 type
, TREE_OPERAND (name
, 0));
1546 name
= dtor_identifier
;
1549 /* I think this is wrong, but the draft is unclear. --jason 6/15/98 */
1550 else if (name
== constructor_name_full (type
)
1551 || name
== constructor_name (type
))
1552 name
= ctor_identifier
;
1555 if (TYPE_SIZE (complete_type (type
)) == 0
1556 && !TYPE_BEING_DEFINED (type
))
1558 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1560 return error_mark_node
;
1563 decl
= maybe_dummy_object (type
, &basebinfo
);
1565 member
= lookup_member (basebinfo
, name
, 1, 0);
1567 if (member
== error_mark_node
)
1568 return error_mark_node
;
1570 /* A lot of this logic is now handled in lookup_field and
1572 if (member
&& TREE_CODE (member
) == TREE_LIST
)
1574 /* Go from the TREE_BASELINK to the member function info. */
1575 tree fnfields
= member
;
1576 t
= TREE_VALUE (fnfields
);
1578 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1580 /* The FNFIELDS are going to contain functions that aren't
1581 necessarily templates, and templates that don't
1582 necessarily match the explicit template parameters. We
1583 save all the functions, and the explicit parameters, and
1584 then figure out exactly what to instantiate with what
1585 arguments in instantiate_type. */
1587 if (TREE_CODE (t
) != OVERLOAD
)
1588 /* The code in instantiate_type which will process this
1589 expects to encounter OVERLOADs, not raw functions. */
1590 t
= ovl_cons (t
, NULL_TREE
);
1592 return build (OFFSET_REF
,
1593 build_offset_type (type
, unknown_type_node
),
1595 build (TEMPLATE_ID_EXPR
,
1598 TREE_OPERAND (orig_name
, 1)));
1601 if (!really_overloaded_fn (t
))
1603 /* Get rid of a potential OVERLOAD around it */
1604 t
= OVL_CURRENT (t
);
1606 /* unique functions are handled easily. */
1607 basebinfo
= TREE_PURPOSE (fnfields
);
1608 if (!enforce_access (basebinfo
, t
))
1609 return error_mark_node
;
1611 if (DECL_STATIC_FUNCTION_P (t
))
1613 return build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1616 /* FNFIELDS is most likely allocated on the search_obstack,
1617 which will go away after this class scope. If we need
1618 to save this value for later (i.e. for use as an initializer
1619 for a static variable), then do so here.
1621 ??? The smart thing to do for the case of saving initializers
1622 is to resolve them before we're done with this scope. */
1623 if (!TREE_PERMANENT (fnfields
)
1624 && ! allocation_temporary_p ())
1625 fnfields
= copy_list (fnfields
);
1627 t
= build_tree_list (error_mark_node
, fnfields
);
1628 TREE_TYPE (t
) = build_offset_type (type
, unknown_type_node
);
1636 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1637 return error_mark_node
;
1640 if (TREE_CODE (t
) == TYPE_DECL
)
1645 /* static class members and class-specific enum
1646 values can be returned without further ado. */
1647 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1650 return convert_from_reference (t
);
1653 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_C_BIT_FIELD (t
))
1655 cp_error ("illegal pointer to bit field `%D'", t
);
1656 return error_mark_node
;
1659 /* static class functions too. */
1660 if (TREE_CODE (t
) == FUNCTION_DECL
1661 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1662 my_friendly_abort (53);
1664 /* In member functions, the form `type::name' is no longer
1665 equivalent to `this->type::name', at least not until
1666 resolve_offset_ref. */
1667 return build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1670 /* If a OFFSET_REF made it through to here, then it did
1671 not have its address taken. */
1674 resolve_offset_ref (exp
)
1677 tree type
= TREE_TYPE (exp
);
1678 tree base
= NULL_TREE
;
1680 tree basetype
, addr
;
1682 if (TREE_CODE (exp
) == TREE_LIST
)
1684 cp_pedwarn ("assuming & on overloaded member function");
1685 return build_unary_op (ADDR_EXPR
, exp
, 0);
1688 if (TREE_CODE (exp
) == OFFSET_REF
)
1690 member
= TREE_OPERAND (exp
, 1);
1691 base
= TREE_OPERAND (exp
, 0);
1695 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1696 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1698 error ("object missing in use of pointer-to-member construct");
1699 return error_mark_node
;
1702 type
= TREE_TYPE (type
);
1703 base
= current_class_ref
;
1706 if ((TREE_CODE (member
) == VAR_DECL
1707 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
))
1708 && ! TYPE_PTRMEM_P (TREE_TYPE (member
)))
1709 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
1710 || TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1712 /* These were static members. */
1713 if (mark_addressable (member
) == 0)
1714 return error_mark_node
;
1718 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1719 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1722 /* Syntax error can cause a member which should
1723 have been seen as static to be grok'd as non-static. */
1724 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1726 if (TREE_ADDRESSABLE (member
) == 0)
1728 cp_error_at ("member `%D' is non-static but referenced as a static member",
1730 error ("at this point in file");
1731 TREE_ADDRESSABLE (member
) = 1;
1733 return error_mark_node
;
1736 /* The first case is really just a reference to a member of `this'. */
1737 if (TREE_CODE (member
) == FIELD_DECL
1738 && (base
== current_class_ref
|| is_dummy_object (base
)))
1743 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1744 basetype
= TYPE_OFFSET_BASETYPE (type
);
1746 basetype
= DECL_CONTEXT (member
);
1748 base
= current_class_ptr
;
1750 if (get_base_distance (basetype
, TREE_TYPE (TREE_TYPE (base
)), 0, &basetype_path
) < 0)
1752 error_not_base_type (basetype
, TREE_TYPE (TREE_TYPE (base
)));
1753 return error_mark_node
;
1755 /* Kludge: we need to use basetype_path now, because
1756 convert_pointer_to will bash it. */
1757 enforce_access (basetype_path
, member
);
1758 addr
= convert_pointer_to (basetype
, base
);
1760 /* Even in the case of illegal access, we form the
1761 COMPONENT_REF; that will allow better error recovery than
1762 just feeding back error_mark_node. */
1763 expr
= build (COMPONENT_REF
, TREE_TYPE (member
),
1764 build_indirect_ref (addr
, NULL_PTR
), member
);
1765 return convert_from_reference (expr
);
1768 /* Ensure that we have an object. */
1769 if (is_dummy_object (base
))
1770 addr
= error_mark_node
;
1772 /* If this is a reference to a member function, then return the
1773 address of the member function (which may involve going
1774 through the object's vtable), otherwise, return an expression
1775 for the dereferenced pointer-to-member construct. */
1776 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1778 if (TYPE_PTRMEM_P (TREE_TYPE (member
)))
1780 if (addr
== error_mark_node
)
1782 cp_error ("object missing in `%E'", exp
);
1783 return error_mark_node
;
1786 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member
)));
1787 addr
= convert_pointer_to (basetype
, addr
);
1788 member
= cp_convert (ptrdiff_type_node
, member
);
1790 /* Pointer to data members are offset by one, so that a null
1791 pointer with a real value of 0 is distinguishable from an
1792 offset of the first member of a structure. */
1793 member
= build_binary_op (MINUS_EXPR
, member
,
1794 cp_convert (ptrdiff_type_node
, integer_one_node
),
1797 return build1 (INDIRECT_REF
, type
,
1798 build (PLUS_EXPR
, build_pointer_type (type
),
1801 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1803 return get_member_function_from_ptrfunc (&addr
, member
);
1805 my_friendly_abort (56);
1810 /* Return either DECL or its known constant value (if it has one). */
1813 decl_constant_value (decl
)
1816 if (! TREE_THIS_VOLATILE (decl
)
1817 && DECL_INITIAL (decl
)
1818 && DECL_INITIAL (decl
) != error_mark_node
1819 /* This is invalid if initial value is not constant.
1820 If it has either a function call, a memory reference,
1821 or a variable, then re-evaluating it could give different results. */
1822 && TREE_CONSTANT (DECL_INITIAL (decl
))
1823 /* Check for cases where this is sub-optimal, even though valid. */
1824 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1825 return DECL_INITIAL (decl
);
1829 /* Common subroutines of build_new and build_vec_delete. */
1831 /* Call the global __builtin_delete to delete ADDR. */
1834 build_builtin_delete_call (addr
)
1837 mark_used (global_delete_fndecl
);
1838 return build_call (global_delete_fndecl
,
1839 void_type_node
, build_expr_list (NULL_TREE
, addr
));
1842 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1843 (which needs to go through some sort of groktypename) or it
1844 is the name of the class we are newing. INIT is an initialization value.
1845 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1846 If INIT is void_type_node, it means do *not* call a constructor
1849 For types with constructors, the data returned is initialized
1850 by the appropriate constructor.
1852 Whether the type has a constructor or not, if it has a pointer
1853 to a virtual function table, then that pointer is set up
1856 Unless I am mistaken, a call to new () will return initialized
1857 data regardless of whether the constructor itself is private or
1858 not. NOPE; new fails if the constructor is private (jcm).
1860 Note that build_new does nothing to assure that any special
1861 alignment requirements of the type are met. Rather, it leaves
1862 it up to malloc to do the right thing. Otherwise, folding to
1863 the right alignment cal cause problems if the user tries to later
1864 free the memory returned by `new'.
1866 PLACEMENT is the `placement' list for user-defined operator new (). */
1868 extern int flag_check_new
;
1871 build_new (placement
, decl
, init
, use_global_new
)
1877 tree nelts
= NULL_TREE
, t
;
1880 tree pending_sizes
= NULL_TREE
;
1882 if (decl
== error_mark_node
)
1883 return error_mark_node
;
1885 if (TREE_CODE (decl
) == TREE_LIST
)
1887 tree absdcl
= TREE_VALUE (decl
);
1888 tree last_absdcl
= NULL_TREE
;
1889 int old_immediate_size_expand
= 0;
1891 if (current_function_decl
1892 && DECL_CONSTRUCTOR_P (current_function_decl
))
1894 old_immediate_size_expand
= immediate_size_expand
;
1895 immediate_size_expand
= 0;
1898 nelts
= integer_one_node
;
1900 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
1901 my_friendly_abort (215);
1902 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
1904 last_absdcl
= absdcl
;
1905 absdcl
= TREE_OPERAND (absdcl
, 0);
1908 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
1910 /* probably meant to be a vec new */
1913 while (TREE_OPERAND (absdcl
, 0)
1914 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
1916 last_absdcl
= absdcl
;
1917 absdcl
= TREE_OPERAND (absdcl
, 0);
1921 this_nelts
= TREE_OPERAND (absdcl
, 1);
1922 if (this_nelts
!= error_mark_node
)
1924 if (this_nelts
== NULL_TREE
)
1925 error ("new of array type fails to specify size");
1926 else if (processing_template_decl
)
1929 absdcl
= TREE_OPERAND (absdcl
, 0);
1933 int flags
= pedantic
? WANT_INT
: (WANT_INT
| WANT_ENUM
);
1934 if (build_expr_type_conversion (flags
, this_nelts
, 0)
1936 pedwarn ("size in array new must have integral type");
1938 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
1939 absdcl
= TREE_OPERAND (absdcl
, 0);
1940 if (this_nelts
== integer_zero_node
)
1942 warning ("zero size array reserves no space");
1943 nelts
= integer_zero_node
;
1946 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
1950 nelts
= integer_zero_node
;
1954 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
1956 TREE_VALUE (decl
) = absdcl
;
1958 type
= groktypename (decl
);
1959 if (! type
|| type
== error_mark_node
)
1961 immediate_size_expand
= old_immediate_size_expand
;
1962 return error_mark_node
;
1965 if (current_function_decl
1966 && DECL_CONSTRUCTOR_P (current_function_decl
))
1968 pending_sizes
= get_pending_sizes ();
1969 immediate_size_expand
= old_immediate_size_expand
;
1972 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
1974 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
1976 /* An aggregate type. */
1977 type
= IDENTIFIER_TYPE_VALUE (decl
);
1978 decl
= TYPE_MAIN_DECL (type
);
1982 /* A builtin type. */
1983 decl
= lookup_name (decl
, 1);
1984 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
1985 type
= TREE_TYPE (decl
);
1988 else if (TREE_CODE (decl
) == TYPE_DECL
)
1990 type
= TREE_TYPE (decl
);
1995 decl
= TYPE_MAIN_DECL (type
);
1998 if (processing_template_decl
)
2001 t
= min_tree_cons (min_tree_cons (NULL_TREE
, type
, NULL_TREE
),
2002 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2007 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2008 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2012 /* ``A reference cannot be created by the new operator. A reference
2013 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2014 returned by new.'' ARM 5.3.3 */
2015 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2017 error ("new cannot be applied to a reference type");
2018 type
= TREE_TYPE (type
);
2021 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2023 error ("new cannot be applied to a function type");
2024 return error_mark_node
;
2027 /* When the object being created is an array, the new-expression yields a
2028 pointer to the initial element (if any) of the array. For example,
2029 both new int and new int[10] return an int*. 5.3.4. */
2030 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2032 nelts
= array_type_nelts_top (type
);
2034 type
= TREE_TYPE (type
);
2038 t
= build_nt (ARRAY_REF
, type
, nelts
);
2042 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2043 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2044 TREE_SIDE_EFFECTS (rval
) = 1;
2046 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2047 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2048 TREE_NO_UNUSED_WARNING (rval
) = 1;
2051 rval
= build_compound_expr (chainon (pending_sizes
,
2052 build_expr_list (NULL_TREE
, rval
)));
2057 /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */
2059 static tree jclass_node
= NULL_TREE
;
2061 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2064 build_java_class_ref (type
)
2067 tree name
, class_decl
;
2068 static tree CL_prefix
= NULL_TREE
;
2069 if (CL_prefix
== NULL_TREE
)
2070 CL_prefix
= get_identifier("_CL_");
2071 if (jclass_node
== NULL_TREE
)
2073 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2074 if (jclass_node
== NULL_TREE
)
2075 fatal("call to Java constructor, while `jclass' undefined");
2076 jclass_node
= TREE_TYPE (jclass_node
);
2078 name
= build_overload_with_type (CL_prefix
, type
);
2079 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2080 if (class_decl
== NULL_TREE
)
2082 push_obstacks_nochange ();
2083 end_temporary_allocation ();
2084 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2085 TREE_STATIC (class_decl
) = 1;
2086 DECL_EXTERNAL (class_decl
) = 1;
2087 TREE_PUBLIC (class_decl
) = 1;
2088 DECL_ARTIFICIAL (class_decl
) = 1;
2089 DECL_IGNORED_P (class_decl
) = 1;
2090 pushdecl_top_level (class_decl
);
2091 make_decl_rtl (class_decl
, NULL_PTR
, 1);
2097 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2098 value is immediately handed to expand_expr. */
2104 tree placement
, init
;
2105 tree type
, true_type
, size
, rval
;
2106 tree nelts
= NULL_TREE
;
2107 tree alloc_expr
, alloc_node
= NULL_TREE
;
2109 enum tree_code code
= NEW_EXPR
;
2110 int use_cookie
, nothrow
, check_new
;
2112 int use_java_new
= 0;
2114 placement
= TREE_OPERAND (exp
, 0);
2115 type
= TREE_OPERAND (exp
, 1);
2116 init
= TREE_OPERAND (exp
, 2);
2117 use_global_new
= NEW_EXPR_USE_GLOBAL (exp
);
2119 if (TREE_CODE (type
) == ARRAY_REF
)
2122 nelts
= TREE_OPERAND (type
, 1);
2123 type
= TREE_OPERAND (type
, 0);
2127 if (CP_TYPE_QUALS (type
))
2128 type
= TYPE_MAIN_VARIANT (type
);
2130 /* If our base type is an array, then make sure we know how many elements
2132 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2134 tree this_nelts
= array_type_nelts_top (true_type
);
2135 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2136 true_type
= TREE_TYPE (true_type
);
2139 if (!complete_type_or_else (true_type
, exp
))
2140 return error_mark_node
;
2143 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2146 size
= size_in_bytes (type
);
2148 if (TREE_CODE (true_type
) == VOID_TYPE
)
2150 error ("invalid type `void' for new");
2151 return error_mark_node
;
2154 if (TYPE_LANG_SPECIFIC (true_type
)
2155 && CLASSTYPE_ABSTRACT_VIRTUALS (true_type
))
2157 abstract_virtuals_error (NULL_TREE
, true_type
);
2158 return error_mark_node
;
2161 if (TYPE_LANG_SPECIFIC (true_type
) && IS_SIGNATURE (true_type
))
2163 signature_error (NULL_TREE
, true_type
);
2164 return error_mark_node
;
2168 /* Get a little extra space to store a couple of things before the new'ed
2169 array, if this isn't the default placement new. */
2171 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2172 && ! (placement
&& ! TREE_CHAIN (placement
)
2173 && TREE_TYPE (TREE_VALUE (placement
)) == ptr_type_node
));
2175 /* Get a little extra space to store a couple of things before the new'ed
2176 array, if this is either non-placement new or new (nothrow). */
2178 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2179 && (! placement
|| nothrow
));
2184 tree extra
= BI_header_size
;
2186 size
= size_binop (PLUS_EXPR
, size
, extra
);
2191 code
= VEC_NEW_EXPR
;
2193 if (init
&& pedantic
)
2194 cp_pedwarn ("initialization in array new");
2197 /* Allocate the object. */
2199 if (! has_array
&& ! placement
&& flag_this_is_variable
> 0
2200 && TYPE_NEEDS_CONSTRUCTING (true_type
) && init
!= void_type_node
)
2202 if (init
== NULL_TREE
|| TREE_CODE (init
) == TREE_LIST
)
2206 error ("constructors take parameter lists");
2207 return error_mark_node
;
2210 else if (! placement
&& TYPE_FOR_JAVA (true_type
))
2212 tree class_addr
, alloc_decl
;
2213 tree class_decl
= build_java_class_ref (true_type
);
2214 tree class_size
= size_in_bytes (true_type
);
2215 static char alloc_name
[] = "_Jv_AllocObject";
2217 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2218 if (alloc_decl
== NULL_TREE
)
2219 fatal("call to Java constructor, while `%s' undefined", alloc_name
);
2220 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2221 rval
= build_function_call (alloc_decl
,
2222 tree_cons (NULL_TREE
, class_addr
,
2223 build_tree_list (NULL_TREE
,
2225 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2231 if (flag_exceptions
)
2232 /* We will use RVAL when generating an exception handler for
2233 this new-expression, so we must save it. */
2234 susp
= suspend_momentary ();
2236 rval
= build_op_new_call
2237 (code
, true_type
, expr_tree_cons (NULL_TREE
, size
, placement
),
2238 LOOKUP_NORMAL
| (use_global_new
* LOOKUP_GLOBAL
));
2239 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2241 if (flag_exceptions
)
2242 resume_momentary (susp
);
2245 /* unless an allocation function is declared with an empty excep-
2246 tion-specification (_except.spec_), throw(), it indicates failure to
2247 allocate storage by throwing a bad_alloc exception (clause _except_,
2248 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2249 cation function is declared with an empty exception-specification,
2250 throw(), it returns null to indicate failure to allocate storage and a
2251 non-null pointer otherwise.
2253 So check for a null exception spec on the op new we just called. */
2258 /* The CALL_EXPR. */
2259 tree t
= TREE_OPERAND (rval
, 0);
2261 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
2262 t
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
2264 if (t
&& TREE_VALUE (t
) == NULL_TREE
)
2267 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2269 if ((check_new
|| flag_exceptions
) && rval
)
2271 alloc_expr
= get_target_expr (rval
);
2272 alloc_node
= rval
= TREE_OPERAND (alloc_expr
, 0);
2275 alloc_expr
= NULL_TREE
;
2277 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2278 sure we have some extra bytes in that case for the BI_header_size
2279 cookies? And how does that interact with the code below? (mrs) */
2280 /* Finish up some magic for new'ed arrays */
2281 if (use_cookie
&& rval
!= NULL_TREE
)
2283 tree extra
= BI_header_size
;
2285 rval
= convert (string_type_node
, rval
); /* for ptr arithmetic */
2286 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, extra
, 1));
2287 /* Store header info. */
2288 cookie
= build_indirect_ref (build (MINUS_EXPR
,
2289 build_pointer_type (BI_header_type
),
2290 rval
, extra
), NULL_PTR
);
2291 exp1
= build (MODIFY_EXPR
, void_type_node
,
2292 build_component_ref (cookie
, nc_nelts_field_id
,
2295 TREE_SIDE_EFFECTS (exp1
) = 1;
2296 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2297 rval
= build_compound_expr
2298 (expr_tree_cons (NULL_TREE
, exp1
,
2299 build_expr_list (NULL_TREE
, rval
)));
2302 if (rval
== error_mark_node
)
2303 return error_mark_node
;
2305 /* Don't call any constructors or do any initialization. */
2306 if (init
== void_type_node
)
2309 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2311 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2312 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2314 /* We are processing something like `new int (10)', which
2315 means allocate an int, and initialize it with 10. */
2319 /* At present RVAL is a temporary variable, created to hold
2320 the value from the call to `operator new'. We transform
2321 it to (*RVAL = INIT, RVAL). */
2322 rval
= save_expr (rval
);
2323 deref
= build_indirect_ref (rval
, NULL_PTR
);
2325 /* Even for something like `new const int (10)' we must
2326 allow the expression to be non-const while we do the
2328 deref_type
= TREE_TYPE (deref
);
2329 if (CP_TYPE_CONST_P (deref_type
))
2331 = cp_build_qualified_type (deref_type
,
2332 CP_TYPE_QUALS (deref_type
)
2333 & ~TYPE_QUAL_CONST
);
2334 TREE_READONLY (deref
) = 0;
2336 if (TREE_CHAIN (init
) != NULL_TREE
)
2337 pedwarn ("initializer list being treated as compound expression");
2338 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2340 pedwarn ("initializer list appears where operand should be used");
2341 init
= TREE_OPERAND (init
, 1);
2343 init
= build_compound_expr (init
);
2345 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2346 "new", NULL_TREE
, 0);
2347 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2348 build_modify_expr (deref
, NOP_EXPR
, init
),
2350 TREE_NO_UNUSED_WARNING (rval
) = 1;
2351 TREE_SIDE_EFFECTS (rval
) = 1;
2353 else if (! has_array
)
2356 /* Constructors are never virtual. If it has an initialization, we
2357 need to complain if we aren't allowed to use the ctor that took
2359 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2361 if (rval
&& TYPE_USES_VIRTUAL_BASECLASSES (true_type
))
2363 init
= expr_tree_cons (NULL_TREE
, integer_one_node
, init
);
2364 flags
|= LOOKUP_HAS_IN_CHARGE
;
2368 rval
= save_expr (rval
);
2371 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2372 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2374 newrval
= build_method_call (newrval
, ctor_identifier
,
2375 init
, TYPE_BINFO (true_type
), flags
);
2377 if (newrval
== NULL_TREE
|| newrval
== error_mark_node
)
2378 return error_mark_node
;
2380 /* Java constructors compiled by jc1 do not return this. */
2382 newrval
= build (COMPOUND_EXPR
, TREE_TYPE (newrval
),
2385 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2388 rval
= build (VEC_INIT_EXPR
, TREE_TYPE (rval
),
2389 save_expr (rval
), init
, nelts
);
2391 /* If any part of the object initialization terminates by throwing
2392 an exception and the new-expression does not contain a
2393 new-placement, then the deallocation function is called to free
2394 the memory in which the object was being constructed. */
2395 if (flag_exceptions
&& alloc_expr
&& ! use_java_new
)
2397 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2398 tree cleanup
, fn
= NULL_TREE
;
2399 int flags
= LOOKUP_NORMAL
| (use_global_new
* LOOKUP_GLOBAL
);
2401 /* All cleanups must last longer than normal. */
2402 int yes
= suspend_momentary ();
2406 flags
|= LOOKUP_SPECULATIVELY
;
2408 /* We expect alloc_expr to look like a TARGET_EXPR around
2409 a NOP_EXPR around the CALL_EXPR we want. */
2410 fn
= TREE_OPERAND (alloc_expr
, 1);
2411 fn
= TREE_OPERAND (fn
, 0);
2414 /* Copy size to the saveable obstack. */
2415 size
= copy_node (size
);
2417 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
, fn
);
2419 resume_momentary (yes
);
2421 /* Ack! First we allocate the memory. Then we set our sentry
2422 variable to true, and expand a cleanup that deletes the memory
2423 if sentry is true. Then we run the constructor and store the
2424 returned pointer in buf. Then we clear sentry and return buf. */
2428 tree end
, sentry
, begin
, buf
, t
= TREE_TYPE (rval
);
2430 begin
= get_target_expr (boolean_true_node
);
2431 sentry
= TREE_OPERAND (begin
, 0);
2433 yes
= suspend_momentary ();
2434 TREE_OPERAND (begin
, 2)
2435 = build (COND_EXPR
, void_type_node
, sentry
,
2436 cleanup
, void_zero_node
);
2437 resume_momentary (yes
);
2439 rval
= get_target_expr (rval
);
2441 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2442 sentry
, boolean_false_node
);
2443 TREE_SIDE_EFFECTS (end
) = 1;
2445 buf
= TREE_OPERAND (rval
, 0);
2447 rval
= build (COMPOUND_EXPR
, t
, begin
,
2448 build (COMPOUND_EXPR
, t
, rval
,
2449 build (COMPOUND_EXPR
, t
, end
, buf
)));
2453 else if (CP_TYPE_CONST_P (true_type
))
2454 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2458 if (alloc_expr
&& rval
== alloc_node
)
2460 rval
= TREE_OPERAND (alloc_expr
, 1);
2461 alloc_expr
= NULL_TREE
;
2464 if (check_new
&& alloc_expr
)
2466 /* Did we modify the storage? */
2467 tree ifexp
= build_binary_op (NE_EXPR
, alloc_node
,
2468 integer_zero_node
, 1);
2469 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2473 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2475 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2477 /* The type of new int [3][3] is not int *, but int [3] * */
2478 rval
= build_c_cast (build_pointer_type (type
), rval
);
2485 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,
2487 tree base
, maxindex
, type
;
2488 tree auto_delete_vec
, auto_delete
;
2489 int use_global_delete
;
2492 tree ptype
= build_pointer_type (type
= complete_type (type
));
2493 tree size_exp
= size_in_bytes (type
);
2495 /* Temporary variables used by the loop. */
2496 tree tbase
, tbase_init
;
2498 /* This is the body of the loop that implements the deletion of a
2499 single element, and moves temp variables to next elements. */
2502 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2505 /* This is the thing that governs what to do after the loop has run. */
2506 tree deallocate_expr
= 0;
2508 /* This is the BIND_EXPR which holds the outermost iterator of the
2509 loop. It is convenient to set this variable up and test it before
2510 executing any other code in the loop.
2511 This is also the containing expression returned by this function. */
2512 tree controller
= NULL_TREE
;
2514 if (! IS_AGGR_TYPE (type
) || ! TYPE_NEEDS_DESTRUCTOR (type
))
2516 loop
= integer_zero_node
;
2520 /* The below is short by BI_header_size */
2521 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2523 tbase
= build_decl (VAR_DECL
, NULL_TREE
, ptype
);
2524 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2525 fold (build (PLUS_EXPR
, ptype
,
2528 DECL_REGISTER (tbase
) = 1;
2529 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2530 TREE_SIDE_EFFECTS (controller
) = 1;
2532 if (auto_delete
!= integer_zero_node
2533 && auto_delete
!= integer_two_node
)
2535 tree base_tbd
= cp_convert (ptype
,
2536 build_binary_op (MINUS_EXPR
,
2537 cp_convert (ptr_type_node
, base
),
2540 /* This is the real size */
2541 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2542 body
= build_expr_list (NULL_TREE
,
2543 build_x_delete (base_tbd
,
2544 2 | use_global_delete
,
2546 body
= build (COND_EXPR
, void_type_node
,
2547 build (BIT_AND_EXPR
, integer_type_node
,
2548 auto_delete
, integer_one_node
),
2549 body
, integer_zero_node
);
2554 body
= expr_tree_cons (NULL_TREE
,
2555 build_delete (ptype
, tbase
, auto_delete
,
2556 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2559 body
= expr_tree_cons (NULL_TREE
,
2560 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2563 body
= expr_tree_cons (NULL_TREE
,
2564 build (EXIT_EXPR
, void_type_node
,
2565 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2568 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2570 loop
= expr_tree_cons (NULL_TREE
, tbase_init
,
2571 expr_tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2572 loop
= build_compound_expr (loop
);
2575 /* If the delete flag is one, or anything else with the low bit set,
2576 delete the storage. */
2577 if (auto_delete_vec
== integer_zero_node
)
2578 deallocate_expr
= integer_zero_node
;
2583 /* The below is short by BI_header_size */
2584 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2586 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2591 base_tbd
= cp_convert (ptype
,
2592 build_binary_op (MINUS_EXPR
,
2593 cp_convert (string_type_node
, base
),
2596 /* True size with header. */
2597 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2599 deallocate_expr
= build_x_delete (base_tbd
,
2600 2 | use_global_delete
,
2602 if (auto_delete_vec
!= integer_one_node
)
2603 deallocate_expr
= build (COND_EXPR
, void_type_node
,
2604 build (BIT_AND_EXPR
, integer_type_node
,
2605 auto_delete_vec
, integer_one_node
),
2606 deallocate_expr
, integer_zero_node
);
2609 if (loop
&& deallocate_expr
!= integer_zero_node
)
2611 body
= expr_tree_cons (NULL_TREE
, loop
,
2612 expr_tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2613 body
= build_compound_expr (body
);
2618 /* Outermost wrapper: If pointer is null, punt. */
2619 body
= build (COND_EXPR
, void_type_node
,
2620 build (NE_EXPR
, boolean_type_node
, base
, integer_zero_node
),
2621 body
, integer_zero_node
);
2622 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2626 TREE_OPERAND (controller
, 1) = body
;
2630 return cp_convert (void_type_node
, body
);
2633 /* Protect the vector initialization with a try-block so that we can
2634 destroy the first few elements if constructing a later element
2635 causes an exception to be thrown. TYPE is the type of the array
2639 expand_vec_init_try_block (type
)
2642 if (!TYPE_NEEDS_DESTRUCTOR (type
) || !flag_exceptions
)
2645 /* The code we generate looks like:
2648 // Initialize the vector.
2650 // Destory the elements that need destroying.
2654 Here we're just beginning the `try'. */
2656 expand_eh_region_start ();
2659 /* Add code to destroy the array elements constructed so far if the
2660 construction of some element in the array causes an exception to be
2661 thrown. RVAL is the address of the last element in the array.
2662 TYPE is the type of the array elements. MAXINDEX is the maximum
2663 allowable index into the array. ITERATOR is an integer variable
2664 indicating how many elements remain to be constructed. */
2667 expand_vec_init_catch_clause (rval
, type
, maxindex
, iterator
)
2676 if (!TYPE_NEEDS_DESTRUCTOR (type
) || !flag_exceptions
)
2679 /* We have to ensure that this can live to the cleanup expansion
2680 time, since we know it is only ever needed once, generate code
2682 push_obstacks_nochange ();
2683 resume_temporary_allocation ();
2685 cleanup
= make_node (RTL_EXPR
);
2686 TREE_TYPE (cleanup
) = void_type_node
;
2687 RTL_EXPR_RTL (cleanup
) = const0_rtx
;
2688 TREE_SIDE_EFFECTS (cleanup
) = 1;
2689 do_pending_stack_adjust ();
2690 start_sequence_for_rtl_expr (cleanup
);
2692 e
= build_vec_delete_1 (rval
,
2693 build_binary_op (MINUS_EXPR
, maxindex
,
2696 /*auto_delete_vec=*/integer_zero_node
,
2697 /*auto_delete=*/integer_zero_node
,
2698 /*use_global_delete=*/0);
2699 expand_expr (e
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2701 do_pending_stack_adjust ();
2702 RTL_EXPR_SEQUENCE (cleanup
) = get_insns ();
2704 cleanup
= protect_with_terminate (cleanup
);
2705 expand_eh_region_end (cleanup
);
2709 /* `expand_vec_init' performs initialization of a vector of aggregate
2712 DECL is passed only for error reporting, and provides line number
2713 and source file name information.
2714 BASE is the space where the vector will be.
2715 MAXINDEX is the maximum index of the array (one less than the
2716 number of elements).
2717 INIT is the (possibly NULL) initializer.
2719 FROM_ARRAY is 0 if we should init everything with INIT
2720 (i.e., every element initialized from INIT).
2721 FROM_ARRAY is 1 if we should index into INIT in parallel
2722 with initialization of DECL.
2723 FROM_ARRAY is 2 if we should index into INIT in parallel,
2724 but use assignment instead of initialization. */
2727 expand_vec_init (decl
, base
, maxindex
, init
, from_array
)
2728 tree decl
, base
, maxindex
, init
;
2732 tree base2
= NULL_TREE
;
2733 tree type
= TREE_TYPE (TREE_TYPE (base
));
2735 tree itype
= NULL_TREE
;
2737 int num_initialized_elts
= 0;
2739 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2740 if (maxindex
== error_mark_node
)
2741 return error_mark_node
;
2743 if (current_function_decl
== NULL_TREE
)
2745 rval
= make_tree_vec (3);
2746 TREE_VEC_ELT (rval
, 0) = base
;
2747 TREE_VEC_ELT (rval
, 1) = maxindex
;
2748 TREE_VEC_ELT (rval
, 2) = init
;
2752 size
= size_in_bytes (type
);
2754 base
= default_conversion (base
);
2755 base
= cp_convert (build_pointer_type (type
), base
);
2756 rval
= get_temp_regvar (build_pointer_type (type
), base
);
2757 base
= get_temp_regvar (build_pointer_type (type
), base
);
2758 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2760 /* Protect the entire array initialization so that we can destroy
2761 the partially constructed array if an exception is thrown. */
2762 expand_vec_init_try_block (type
);
2764 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
2765 && (!decl
|| same_type_p (TREE_TYPE (init
), TREE_TYPE (decl
))))
2767 /* Do non-default initialization resulting from brace-enclosed
2771 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2775 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2777 tree elt
= TREE_VALUE (elts
);
2779 num_initialized_elts
++;
2781 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2782 expand_aggr_init (baseref
, elt
, 0);
2784 expand_assignment (baseref
, elt
, 0, 0);
2786 expand_assignment (base
,
2787 build (PLUS_EXPR
, build_pointer_type (type
),
2790 expand_assignment (iterator
,
2791 build (MINUS_EXPR
, ptrdiff_type_node
,
2792 iterator
, integer_one_node
),
2796 /* Clear out INIT so that we don't get confused below. */
2800 use_variable (DECL_RTL (base
));
2802 else if (from_array
)
2804 /* If initializing one array from another, initialize element by
2805 element. We rely upon the below calls the do argument
2807 if (decl
== NULL_TREE
)
2809 sorry ("initialization of array from dissimilar array type");
2810 return error_mark_node
;
2814 base2
= default_conversion (init
);
2815 itype
= TREE_TYPE (base2
);
2816 base2
= get_temp_regvar (itype
, base2
);
2817 itype
= TREE_TYPE (itype
);
2819 else if (TYPE_LANG_SPECIFIC (type
)
2820 && TYPE_NEEDS_CONSTRUCTING (type
)
2821 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2823 error ("initializer ends prematurely");
2824 return error_mark_node
;
2828 /* Now, default-initialize any remaining elements. We don't need to
2829 do that if a) the type does not need constructing, or b) we've
2830 already initialized all the elements.
2832 We do need to keep going if we're copying an array. */
2835 || (TYPE_NEEDS_CONSTRUCTING (type
)
2836 && !(TREE_CODE (maxindex
) == INTEGER_CST
2837 && num_initialized_elts
== TREE_INT_CST_LOW (maxindex
) + 1)))
2839 /* If the ITERATOR is equal to -1, then we don't have to loop;
2840 we've already initialized all the elements. */
2841 expand_start_cond (build (NE_EXPR
, boolean_type_node
,
2842 iterator
, minus_one
),
2845 /* Otherwise, loop through the elements. */
2846 expand_start_loop_continue_elsewhere (1);
2848 /* The initialization of each array element is a full-expression. */
2849 expand_start_target_temps ();
2853 tree to
= build1 (INDIRECT_REF
, type
, base
);
2857 from
= build1 (INDIRECT_REF
, itype
, base2
);
2861 if (from_array
== 2)
2862 expand_expr_stmt (build_modify_expr (to
, NOP_EXPR
, from
));
2863 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2864 expand_aggr_init (to
, from
, 0);
2866 expand_assignment (to
, from
, 0, 0);
2868 my_friendly_abort (57);
2870 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2873 sorry ("cannot initialize multi-dimensional array with initializer");
2874 expand_vec_init (decl
,
2876 build_pointer_type (TREE_TYPE
2879 array_type_nelts (type
), 0, 0);
2882 expand_aggr_init (build1 (INDIRECT_REF
, type
, base
), init
, 0);
2884 expand_assignment (base
,
2885 build (PLUS_EXPR
, build_pointer_type (type
),
2888 expand_assignment (base2
,
2889 build (PLUS_EXPR
, build_pointer_type (type
),
2890 base2
, size
), 0, 0);
2892 /* Cleanup any temporaries needed for the initial value. */
2893 expand_end_target_temps ();
2895 expand_loop_continue_here ();
2896 expand_exit_loop_if_false (0, build (NE_EXPR
, boolean_type_node
,
2897 build (PREDECREMENT_EXPR
,
2905 use_variable (DECL_RTL (base
));
2907 use_variable (DECL_RTL (base2
));
2914 /* Make sure to cleanup any partially constructed elements. */
2915 expand_vec_init_catch_clause (rval
, type
, maxindex
, iterator
);
2919 use_variable (DECL_RTL (iterator
));
2920 use_variable (DECL_RTL (rval
));
2926 /* Free up storage of type TYPE, at address ADDR.
2928 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2931 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2932 used as the second argument to operator delete. It can include
2933 things like padding and magic size cookies. It has virtual in it,
2934 because if you have a base pointer and you delete through a virtual
2935 destructor, it should be the size of the dynamic object, not the
2936 static object, see Free Store 12.5 ANSI C++ WP.
2938 This does not call any destructors. */
2941 build_x_delete (addr
, which_delete
, virtual_size
)
2946 int use_global_delete
= which_delete
& 1;
2947 int use_vec_delete
= !!(which_delete
& 2);
2948 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2949 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
2951 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
2954 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2955 ADDR is an expression which yields the store to be destroyed.
2956 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
2957 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
2958 virtual baseclasses.
2959 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
2961 FLAGS is the logical disjunction of zero or more LOOKUP_
2962 flags. See cp-tree.h for more info.
2964 This function does not delete an object's virtual base classes. */
2967 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
2971 int use_global_delete
;
2977 if (addr
== error_mark_node
)
2978 return error_mark_node
;
2980 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2981 set to `error_mark_node' before it gets properly cleaned up. */
2982 if (type
== error_mark_node
)
2983 return error_mark_node
;
2985 type
= TYPE_MAIN_VARIANT (type
);
2987 if (TREE_CODE (type
) == POINTER_TYPE
)
2989 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
2990 if (type
!= void_type_node
&& !complete_type_or_else (type
, addr
))
2991 return error_mark_node
;
2992 if (TREE_CODE (type
) == ARRAY_TYPE
)
2994 if (! IS_AGGR_TYPE (type
))
2996 /* Call the builtin operator delete. */
2997 return build_builtin_delete_call (addr
);
2999 if (TREE_SIDE_EFFECTS (addr
))
3000 addr
= save_expr (addr
);
3002 /* throw away const and volatile on target type of addr */
3003 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3004 ref
= build_indirect_ref (addr
, NULL_PTR
);
3006 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3009 if (TREE_SIDE_EFFECTS (addr
))
3010 addr
= save_expr (addr
);
3011 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3013 error ("unknown array size in delete");
3014 return error_mark_node
;
3016 return build_vec_delete (addr
, array_type_nelts (type
),
3017 auto_delete
, integer_zero_node
,
3022 /* Don't check PROTECT here; leave that decision to the
3023 destructor. If the destructor is accessible, call it,
3024 else report error. */
3025 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3026 if (TREE_SIDE_EFFECTS (addr
))
3027 addr
= save_expr (addr
);
3029 if (TREE_CONSTANT (addr
))
3030 addr
= convert_pointer_to (type
, addr
);
3032 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3034 ref
= build_indirect_ref (addr
, NULL_PTR
);
3037 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3039 if (! TYPE_NEEDS_DESTRUCTOR (type
))
3041 if (auto_delete
== integer_zero_node
)
3042 return void_zero_node
;
3044 return build_op_delete_call
3045 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3046 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3050 /* Below, we will reverse the order in which these calls are made.
3051 If we have a destructor, then that destructor will take care
3052 of the base classes; otherwise, we must do that here. */
3053 if (TYPE_HAS_DESTRUCTOR (type
))
3055 tree passed_auto_delete
;
3056 tree do_delete
= NULL_TREE
;
3059 if (use_global_delete
)
3061 tree cond
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3062 auto_delete
, integer_one_node
));
3063 tree call
= build_builtin_delete_call (addr
);
3065 cond
= fold (build (COND_EXPR
, void_type_node
, cond
,
3066 call
, void_zero_node
));
3067 if (cond
!= void_zero_node
)
3070 passed_auto_delete
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3071 auto_delete
, integer_two_node
));
3074 passed_auto_delete
= auto_delete
;
3076 expr
= build_method_call
3077 (ref
, dtor_identifier
, build_expr_list (NULL_TREE
, passed_auto_delete
),
3081 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3083 if (flags
& LOOKUP_DESTRUCTOR
)
3084 /* Explicit destructor call; don't check for null pointer. */
3085 ifexp
= integer_one_node
;
3087 /* Handle deleting a null pointer. */
3088 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
, 1));
3090 if (ifexp
!= integer_one_node
)
3091 expr
= build (COND_EXPR
, void_type_node
,
3092 ifexp
, expr
, void_zero_node
);
3098 /* We only get here from finish_function for a destructor. */
3099 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3100 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3101 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3102 tree exprstmt
= NULL_TREE
;
3103 tree parent_auto_delete
= auto_delete
;
3106 /* Set this again before we call anything, as we might get called
3108 TYPE_HAS_DESTRUCTOR (type
) = 1;
3110 /* If we have member delete or vbases, we call delete in
3112 if (auto_delete
== integer_zero_node
)
3114 else if (base_binfo
== NULL_TREE
3115 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3117 cond
= build (COND_EXPR
, void_type_node
,
3118 build (BIT_AND_EXPR
, integer_type_node
, auto_delete
, integer_one_node
),
3119 build_builtin_delete_call (addr
),
3126 exprstmt
= build_expr_list (NULL_TREE
, cond
);
3129 && ! TREE_VIA_VIRTUAL (base_binfo
)
3130 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3132 tree this_auto_delete
;
3134 if (BINFO_OFFSET_ZEROP (base_binfo
))
3135 this_auto_delete
= parent_auto_delete
;
3137 this_auto_delete
= integer_zero_node
;
3139 expr
= build_scoped_method_call
3140 (ref
, base_binfo
, dtor_identifier
,
3141 build_expr_list (NULL_TREE
, this_auto_delete
));
3142 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3145 /* Take care of the remaining baseclasses. */
3146 for (i
= 1; i
< n_baseclasses
; i
++)
3148 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3149 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3150 || TREE_VIA_VIRTUAL (base_binfo
))
3153 expr
= build_scoped_method_call
3154 (ref
, base_binfo
, dtor_identifier
,
3155 build_expr_list (NULL_TREE
, integer_zero_node
));
3157 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3160 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3162 if (TREE_CODE (member
) != FIELD_DECL
)
3164 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member
)))
3166 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3167 tree this_type
= TREE_TYPE (member
);
3168 expr
= build_delete (this_type
, this_member
, integer_two_node
, flags
, 0);
3169 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3174 return build_compound_expr (exprstmt
);
3175 /* Virtual base classes make this function do nothing. */
3176 return void_zero_node
;
3180 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3183 build_vbase_delete (type
, decl
)
3186 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3187 tree result
= NULL_TREE
;
3188 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3190 my_friendly_assert (addr
!= error_mark_node
, 222);
3194 tree this_addr
= convert_force (build_pointer_type (BINFO_TYPE (vbases
)),
3196 result
= expr_tree_cons (NULL_TREE
,
3197 build_delete (TREE_TYPE (this_addr
), this_addr
,
3199 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3201 vbases
= TREE_CHAIN (vbases
);
3203 return build_compound_expr (nreverse (result
));
3206 /* Build a C++ vector delete expression.
3207 MAXINDEX is the number of elements to be deleted.
3208 ELT_SIZE is the nominal size of each element in the vector.
3209 BASE is the expression that should yield the store to be deleted.
3210 This function expands (or synthesizes) these calls itself.
3211 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3212 AUTO_DELETE say whether each item in the container should be deallocated.
3214 This also calls delete for virtual baseclasses of elements of the vector.
3216 Update: MAXINDEX is no longer needed. The size can be extracted from the
3217 start of the vector for pointers, and from the type for arrays. We still
3218 use MAXINDEX for arrays because it happens to already have one of the
3219 values we'd have to extract. (We could use MAXINDEX with pointers to
3220 confirm the size, and trap if the numbers differ; not clear that it'd
3221 be worth bothering.) */
3224 build_vec_delete (base
, maxindex
, auto_delete_vec
, auto_delete
,
3226 tree base
, maxindex
;
3227 tree auto_delete_vec
, auto_delete
;
3228 int use_global_delete
;
3232 if (TREE_CODE (base
) == OFFSET_REF
)
3233 base
= resolve_offset_ref (base
);
3235 type
= TREE_TYPE (base
);
3237 base
= stabilize_reference (base
);
3239 /* Since we can use base many times, save_expr it. */
3240 if (TREE_SIDE_EFFECTS (base
))
3241 base
= save_expr (base
);
3243 if (TREE_CODE (type
) == POINTER_TYPE
)
3245 /* Step back one from start of vector, and read dimension. */
3246 tree cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3247 base
, BI_header_size
);
3248 tree cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3249 maxindex
= build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0);
3251 type
= TREE_TYPE (type
);
3252 while (TREE_CODE (type
) == ARRAY_TYPE
);
3254 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3256 /* get the total number of things in the array, maxindex is a bad name */
3257 maxindex
= array_type_nelts_total (type
);
3258 while (TREE_CODE (type
) == ARRAY_TYPE
)
3259 type
= TREE_TYPE (type
);
3260 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3264 if (base
!= error_mark_node
)
3265 error ("type to vector delete is neither pointer or array type");
3266 return error_mark_node
;
3269 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,