1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 89, 92-96, 1997 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 extern void compiler_error ();
37 /* In C++, structures with well-defined constructors are initialized by
38 those constructors, unasked. CURRENT_BASE_INIT_LIST
39 holds a list of stmts for a BASE_INIT term in the grammar.
40 This list has one element for each base class which must be
41 initialized. The list elements are [basename, init], with
42 type basetype. This allows the possibly anachronistic form
43 (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
44 where each successive term can be handed down the constructor
45 line. Perhaps this was not intended. */
46 tree current_base_init_list
, current_member_init_list
;
48 static void expand_aggr_vbase_init_1
PROTO((tree
, tree
, tree
, tree
));
49 static void expand_aggr_vbase_init
PROTO((tree
, tree
, tree
, tree
));
50 static void expand_aggr_init_1
PROTO((tree
, tree
, tree
, tree
, int,
52 static void expand_default_init
PROTO((tree
, tree
, tree
, tree
, int,
54 static tree build_vec_delete_1
PROTO((tree
, tree
, tree
, tree
, tree
,
56 static void perform_member_init
PROTO((tree
, tree
, tree
, int));
57 static void sort_base_init
PROTO((tree
, tree
*, tree
*));
58 static tree build_builtin_delete_call
PROTO((tree
));
59 static tree build_array_eh_cleanup
PROTO((tree
, tree
, tree
));
60 static int member_init_ok_or_else
PROTO((tree
, tree
, char *));
61 static void expand_virtual_init
PROTO((tree
, tree
));
62 static tree sort_member_init
PROTO((tree
));
63 static tree build_partial_cleanup_for
PROTO((tree
));
64 static tree initializing_context
PROTO((tree
));
66 /* Cache the identifier nodes for the magic field of a new cookie. */
67 static tree nc_nelts_field_id
;
69 static tree minus_one
;
71 /* Set up local variable for this file. MUST BE CALLED AFTER
72 INIT_DECL_PROCESSING. */
74 static tree BI_header_type
, BI_header_size
;
76 void init_init_processing ()
80 minus_one
= build_int_2 (-1, -1);
82 /* Define the structure that holds header information for
83 arrays allocated via operator new. */
84 BI_header_type
= make_lang_type (RECORD_TYPE
);
85 nc_nelts_field_id
= get_identifier ("nelts");
86 fields
[0] = build_lang_field_decl (FIELD_DECL
, nc_nelts_field_id
, sizetype
);
87 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
89 BI_header_size
= size_in_bytes (BI_header_type
);
92 /* Subroutine of emit_base_init. For BINFO, initialize all the
93 virtual function table pointers, except those that come from
94 virtual base classes. Initialize binfo's vtable pointer, if
95 INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
96 function table pointers in all bases have been initialized already,
97 probably because their constructors have just be run. ADDR is the
98 pointer to the object whos vtables we are going to initialize.
100 REAL_BINFO is usually the same as BINFO, except when addr is not of
101 pointer to the type of the real derived type that we want to
102 initialize for. This is the case when addr is a pointer to a sub
103 object of a complete object, and we only want to do part of the
104 complete object's initialization of vtable pointers. This is done
105 for all virtual table pointers in virtual base classes. REAL_BINFO
106 is used to find the BINFO_VTABLE that we initialize with. BINFO is
107 used for conversions of addr to subobjects.
109 BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
111 Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
115 expand_direct_vtbls_init (real_binfo
, binfo
, init_self
, can_elide
, addr
)
116 tree real_binfo
, binfo
, addr
;
117 int init_self
, can_elide
;
119 tree real_binfos
= BINFO_BASETYPES (real_binfo
);
120 tree binfos
= BINFO_BASETYPES (binfo
);
121 int i
, n_baselinks
= real_binfos
? TREE_VEC_LENGTH (real_binfos
) : 0;
123 for (i
= 0; i
< n_baselinks
; i
++)
125 tree real_base_binfo
= TREE_VEC_ELT (real_binfos
, i
);
126 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
127 int is_not_base_vtable
128 = i
!= CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo
));
129 if (! TREE_VIA_VIRTUAL (real_base_binfo
))
130 expand_direct_vtbls_init (real_base_binfo
, base_binfo
,
131 is_not_base_vtable
, can_elide
, addr
);
134 /* Before turning this on, make sure it is correct. */
135 if (can_elide
&& ! BINFO_MODIFIED (binfo
))
138 /* Should we use something besides CLASSTYPE_VFIELDS? */
139 if (init_self
&& CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo
)))
141 tree base_ptr
= convert_pointer_to_real (binfo
, addr
);
142 expand_virtual_init (real_binfo
, base_ptr
);
147 /* Subroutine of emit_base_init. */
150 perform_member_init (member
, name
, init
, explicit)
151 tree member
, name
, init
;
155 tree type
= TREE_TYPE (member
);
157 expand_start_target_temps ();
159 if (TYPE_NEEDS_CONSTRUCTING (type
)
160 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
162 /* Since `init' is already a TREE_LIST on the current_member_init_list,
163 only build it into one if we aren't already a list. */
164 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
165 init
= build_expr_list (NULL_TREE
, init
);
167 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
170 && TREE_CODE (type
) == ARRAY_TYPE
172 && TREE_CHAIN (init
) == NULL_TREE
173 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
175 /* Initialization of one array from another. */
176 expand_vec_init (TREE_OPERAND (decl
, 1), decl
,
177 array_type_nelts (type
), TREE_VALUE (init
), 1);
180 expand_aggr_init (decl
, init
, 0, 0);
184 if (init
== NULL_TREE
)
188 /* default-initialization. */
189 if (AGGREGATE_TYPE_P (type
))
190 init
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
191 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
193 cp_error ("default-initialization of `%#D', which has reference type",
195 init
= error_mark_node
;
198 init
= integer_zero_node
;
200 /* member traversal: note it leaves init NULL */
201 else if (TREE_CODE (TREE_TYPE (member
)) == REFERENCE_TYPE
)
202 cp_pedwarn ("uninitialized reference member `%D'", member
);
204 else if (TREE_CODE (init
) == TREE_LIST
)
206 /* There was an explicit member initialization. Do some
207 work in that case. */
208 if (TREE_CHAIN (init
))
210 warning ("initializer list treated as compound expression");
211 init
= build_compound_expr (init
);
214 init
= TREE_VALUE (init
);
217 /* We only build this with a null init if we got it from the
218 current_member_init_list. */
219 if (init
|| explicit)
221 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
,
223 expand_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
227 expand_end_target_temps ();
230 if (TYPE_NEEDS_DESTRUCTOR (type
))
234 /* All cleanups must be on the function_obstack. */
235 push_obstacks_nochange ();
236 resume_temporary_allocation ();
238 expr
= build_component_ref (current_class_ref
, name
, NULL_TREE
,
240 expr
= build_delete (type
, expr
, integer_zero_node
,
241 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
243 if (expr
!= error_mark_node
)
244 add_partial_entry (expr
);
250 extern int warn_reorder
;
252 /* Subroutine of emit_member_init. */
258 tree x
, member
, name
, field
;
259 tree init_list
= NULL_TREE
;
261 tree last_field
= NULL_TREE
;
263 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
267 /* member could be, for example, a CONST_DECL for an enumerated
268 tag; we don't want to try to initialize that, since it already
270 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
273 for (x
= current_member_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
275 /* If we cleared this out, then pay no attention to it. */
276 if (TREE_PURPOSE (x
) == NULL_TREE
)
278 name
= TREE_PURPOSE (x
);
281 /* This happens in templates, since the IDENTIFIER is replaced
282 with the COMPONENT_REF in tsubst_expr. */
283 field
= (TREE_CODE (name
) == COMPONENT_REF
284 ? TREE_OPERAND (name
, 1) : IDENTIFIER_CLASS_VALUE (name
));
286 /* Let's find out when this happens. */
287 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 348);
288 field
= IDENTIFIER_CLASS_VALUE (name
);
291 /* If one member shadows another, get the outermost one. */
292 if (TREE_CODE (field
) == TREE_LIST
)
293 field
= TREE_VALUE (field
);
301 cp_warning_at ("member initializers for `%#D'", last_field
);
302 cp_warning_at (" and `%#D'", field
);
303 warning (" will be re-ordered to match declaration order");
309 /* Make sure we won't try to work on this init again. */
310 TREE_PURPOSE (x
) = NULL_TREE
;
311 x
= build_tree_list (name
, TREE_VALUE (x
));
316 /* If we didn't find MEMBER in the list, create a dummy entry
317 so the two lists (INIT_LIST and the list of members) will be
319 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
321 init_list
= chainon (init_list
, x
);
324 /* Initializers for base members go at the end. */
325 for (x
= current_member_init_list
; x
; x
= TREE_CHAIN (x
))
327 name
= TREE_PURPOSE (x
);
330 if (purpose_member (name
, init_list
))
332 cp_error ("multiple initializations given for member `%D'",
333 IDENTIFIER_CLASS_VALUE (name
));
337 init_list
= chainon (init_list
,
338 build_tree_list (name
, TREE_VALUE (x
)));
339 TREE_PURPOSE (x
) = NULL_TREE
;
347 sort_base_init (t
, rbase_ptr
, vbase_ptr
)
348 tree t
, *rbase_ptr
, *vbase_ptr
;
350 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
351 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
357 /* For warn_reorder. */
359 tree last_base
= NULL_TREE
;
361 tree rbases
= NULL_TREE
;
362 tree vbases
= NULL_TREE
;
364 /* First walk through and splice out vbase and invalid initializers.
365 Also replace names with binfos. */
367 last
= tree_cons (NULL_TREE
, NULL_TREE
, current_base_init_list
);
368 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
370 tree basetype
= TREE_PURPOSE (x
);
371 tree binfo
= NULL_TREE
;
373 if (basetype
== NULL_TREE
)
375 /* Initializer for single base class. Must not
376 use multiple inheritance or this is ambiguous. */
377 switch (n_baseclasses
)
380 cp_error ("`%T' does not have a base class to initialize",
386 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
390 binfo
= TREE_VEC_ELT (binfos
, 0);
392 else if (is_aggr_type (basetype
, 1))
394 binfo
= binfo_or_else (basetype
, t
);
395 if (binfo
== NULL_TREE
)
398 /* Virtual base classes are special cases. Their initializers
399 are recorded with this constructor, and they are used when
400 this constructor is the top-level constructor called. */
401 if (TREE_VIA_VIRTUAL (binfo
))
403 tree v
= CLASSTYPE_VBASECLASSES (t
);
404 while (BINFO_TYPE (v
) != BINFO_TYPE (binfo
))
407 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
412 /* Otherwise, if it is not an immediate base class, complain. */
413 for (i
= n_baseclasses
-1; i
>= 0; i
--)
414 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
418 cp_error ("`%T' is not an immediate base class of `%T'",
419 basetype
, current_class_type
);
425 my_friendly_abort (365);
427 TREE_PURPOSE (x
) = binfo
;
428 TREE_CHAIN (last
) = x
;
431 TREE_CHAIN (last
) = NULL_TREE
;
433 /* Now walk through our regular bases and make sure they're initialized. */
435 for (i
= 0; i
< n_baseclasses
; ++i
)
437 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
440 if (TREE_VIA_VIRTUAL (base_binfo
))
443 for (x
= current_base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
445 tree binfo
= TREE_PURPOSE (x
);
447 if (binfo
== NULL_TREE
)
450 if (binfo
== base_binfo
)
456 cp_warning_at ("base initializers for `%#T'", last_base
);
457 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
458 warning (" will be re-ordered to match inheritance order");
461 last_base
= BINFO_TYPE (binfo
);
464 /* Make sure we won't try to work on this init again. */
465 TREE_PURPOSE (x
) = NULL_TREE
;
466 x
= build_tree_list (binfo
, TREE_VALUE (x
));
471 /* If we didn't find BASE_BINFO in the list, create a dummy entry
472 so the two lists (RBASES and the list of bases) will be
474 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
476 rbases
= chainon (rbases
, x
);
483 /* Perform partial cleanups for a base for exception handling. */
486 build_partial_cleanup_for (binfo
)
489 return build_scoped_method_call
490 (current_class_ref
, binfo
, dtor_identifier
,
491 build_expr_list (NULL_TREE
, integer_zero_node
));
494 /* Perform whatever initializations have yet to be done on the base
495 class of the class variable. These actions are in the global
496 variable CURRENT_BASE_INIT_LIST. Such an action could be
497 NULL_TREE, meaning that the user has explicitly called the base
498 class constructor with no arguments.
500 If there is a need for a call to a constructor, we must surround
501 that call with a pushlevel/poplevel pair, since we are technically
502 at the PARM level of scope.
504 Argument IMMEDIATELY, if zero, forces a new sequence to be
505 generated to contain these new insns, so it can be emitted later.
506 This sequence is saved in the global variable BASE_INIT_EXPR.
507 Otherwise, the insns are emitted into the current sequence.
509 Note that emit_base_init does *not* initialize virtual base
510 classes. That is done specially, elsewhere. */
512 extern tree base_init_expr
, rtl_expr_chain
;
515 emit_base_init (t
, immediately
)
521 tree rbase_init_list
, vbase_init_list
;
522 tree t_binfo
= TYPE_BINFO (t
);
523 tree binfos
= BINFO_BASETYPES (t_binfo
);
524 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
525 tree expr
= NULL_TREE
;
530 do_pending_stack_adjust ();
531 /* Make the RTL_EXPR node temporary, not momentary,
532 so that rtl_expr_chain doesn't become garbage. */
533 momentary
= suspend_momentary ();
534 expr
= make_node (RTL_EXPR
);
535 resume_momentary (momentary
);
536 start_sequence_for_rtl_expr (expr
);
539 if (write_symbols
== NO_DEBUG
)
540 /* As a matter of principle, `start_sequence' should do this. */
543 /* Always emit a line number note so we can step into constructors. */
544 emit_line_note_force (DECL_SOURCE_FILE (current_function_decl
),
545 DECL_SOURCE_LINE (current_function_decl
));
547 mem_init_list
= sort_member_init (t
);
548 current_member_init_list
= NULL_TREE
;
550 sort_base_init (t
, &rbase_init_list
, &vbase_init_list
);
551 current_base_init_list
= NULL_TREE
;
553 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
555 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
557 expand_start_cond (first_arg
, 0);
558 expand_aggr_vbase_init (t_binfo
, current_class_ref
, current_class_ptr
,
563 /* Now, perform initialization of non-virtual base classes. */
564 for (i
= 0; i
< n_baseclasses
; i
++)
566 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
567 tree init
= void_list_node
;
569 if (TREE_VIA_VIRTUAL (base_binfo
))
572 #if 0 /* Once unsharing happens soon enough. */
573 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
, 999);
575 BINFO_INHERITANCE_CHAIN (base_binfo
) = t_binfo
;
578 if (TREE_PURPOSE (rbase_init_list
))
579 init
= TREE_VALUE (rbase_init_list
);
580 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
583 if (extra_warnings
&& copy_args_p (current_function_decl
))
584 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
585 BINFO_TYPE (base_binfo
));
588 if (init
!= void_list_node
)
590 expand_start_target_temps ();
592 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
593 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
594 build_indirect_ref (member
, NULL_PTR
), init
,
595 BINFO_OFFSET_ZEROP (base_binfo
), LOOKUP_NORMAL
);
597 expand_end_target_temps ();
601 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
605 /* All cleanups must be on the function_obstack. */
606 push_obstacks_nochange ();
607 resume_temporary_allocation ();
608 expr
= build_partial_cleanup_for (base_binfo
);
610 add_partial_entry (expr
);
613 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
616 /* Initialize all the virtual function table fields that
617 do come from virtual base classes. */
618 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
619 expand_indirect_vtbls_init (t_binfo
, current_class_ref
, current_class_ptr
);
621 /* Initialize all the virtual function table fields that
622 do not come from virtual base classes. */
623 expand_direct_vtbls_init (t_binfo
, t_binfo
, 1, 1, current_class_ptr
);
625 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
630 /* member could be, for example, a CONST_DECL for an enumerated
631 tag; we don't want to try to initialize that, since it already
633 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
636 /* See if we had a user-specified member initialization. */
637 if (TREE_PURPOSE (mem_init_list
))
639 name
= TREE_PURPOSE (mem_init_list
);
640 init
= TREE_VALUE (mem_init_list
);
644 if (TREE_CODE (name
) == COMPONENT_REF
)
645 name
= DECL_NAME (TREE_OPERAND (name
, 1));
647 /* Also see if it's ever a COMPONENT_REF here. If it is, we
648 need to do `expand_assignment (name, init, 0, 0);' and
650 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 349);
655 name
= DECL_NAME (member
);
656 init
= DECL_INITIAL (member
);
660 /* Effective C++ rule 12. */
661 if (warn_ecpp
&& init
== NULL_TREE
662 && !DECL_ARTIFICIAL (member
)
663 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
664 cp_warning ("`%D' should be initialized in the member initialization list", member
);
667 perform_member_init (member
, name
, init
, from_init_list
);
668 mem_init_list
= TREE_CHAIN (mem_init_list
);
671 /* Now initialize any members from our bases. */
672 while (mem_init_list
)
674 tree name
, init
, field
;
676 if (TREE_PURPOSE (mem_init_list
))
678 name
= TREE_PURPOSE (mem_init_list
);
679 init
= TREE_VALUE (mem_init_list
);
680 /* XXX: this may need the COMPONENT_REF operand 0 check if
681 it turns out we actually get them. */
682 field
= IDENTIFIER_CLASS_VALUE (name
);
684 /* If one member shadows another, get the outermost one. */
685 if (TREE_CODE (field
) == TREE_LIST
)
687 field
= TREE_VALUE (field
);
688 if (decl_type_context (field
) != current_class_type
)
689 cp_error ("field `%D' not in immediate context", field
);
693 /* It turns out if you have an anonymous union in the
694 class, a member from it can end up not being on the
695 list of fields (rather, the type is), and therefore
696 won't be seen by the for loop above. */
698 /* The code in this for loop is derived from a general loop
699 which had this check in it. Theoretically, we've hit
700 every initialization for the list of members in T, so
701 we shouldn't have anything but these left in this list. */
702 my_friendly_assert (DECL_FIELD_CONTEXT (field
) != t
, 351);
705 perform_member_init (field
, name
, init
, 1);
707 mem_init_list
= TREE_CHAIN (mem_init_list
);
712 do_pending_stack_adjust ();
713 my_friendly_assert (base_init_expr
== 0, 207);
714 base_init_expr
= expr
;
715 TREE_TYPE (expr
) = void_type_node
;
716 RTL_EXPR_RTL (expr
) = const0_rtx
;
717 RTL_EXPR_SEQUENCE (expr
) = get_insns ();
718 rtl_expr_chain
= tree_cons (NULL_TREE
, expr
, rtl_expr_chain
);
720 TREE_SIDE_EFFECTS (expr
) = 1;
723 /* All the implicit try blocks we built up will be zapped
724 when we come to a real binding contour boundary. */
727 /* Check that all fields are properly initialized after
728 an assignment to `this'. */
735 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
736 if (DECL_NAME (member
) && TREE_USED (member
))
737 cp_error ("field `%D' used before initialized (after assignment to `this')",
741 /* This code sets up the virtual function tables appropriate for
742 the pointer DECL. It is a one-ply initialization.
744 BINFO is the exact type that DECL is supposed to be. In
745 multiple inheritance, this might mean "C's A" if C : A, B. */
748 expand_virtual_init (binfo
, decl
)
751 tree type
= BINFO_TYPE (binfo
);
753 tree vtype
, vtype_binfo
;
755 /* This code is crusty. Should be simple, like:
756 vtbl = BINFO_VTABLE (binfo);
758 vtype
= DECL_CONTEXT (CLASSTYPE_VFIELD (type
));
759 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
760 vtbl
= BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type
)), binfo
));
761 assemble_external (vtbl
);
762 TREE_USED (vtbl
) = 1;
763 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
764 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
765 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
766 if (vtbl_ptr
== error_mark_node
)
769 /* Have to convert VTBL since array sizes may be different. */
770 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
771 expand_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
774 /* Subroutine of `expand_aggr_vbase_init'.
775 BINFO is the binfo of the type that is being initialized.
776 INIT_LIST is the list of initializers for the virtual baseclass. */
779 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
780 tree binfo
, exp
, addr
, init_list
;
782 tree init
= purpose_member (binfo
, init_list
);
783 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
785 expand_start_target_temps ();
788 init
= TREE_VALUE (init
);
789 /* Call constructors, but don't set up vtables. */
790 expand_aggr_init_1 (binfo
, exp
, ref
, init
, 0, LOOKUP_COMPLAIN
);
792 expand_end_target_temps ();
796 /* Initialize this object's virtual base class pointers. This must be
797 done only at the top-level of the object being constructed.
799 INIT_LIST is list of initialization for constructor to perform. */
802 expand_aggr_vbase_init (binfo
, exp
, addr
, init_list
)
808 tree type
= BINFO_TYPE (binfo
);
810 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
812 tree result
= init_vbase_pointers (type
, addr
);
816 expand_expr_stmt (build_compound_expr (result
));
818 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
819 vbases
= TREE_CHAIN (vbases
))
821 tree tmp
= purpose_member (vbases
, result
);
822 expand_aggr_vbase_init_1 (vbases
, exp
,
823 TREE_OPERAND (TREE_VALUE (tmp
), 0),
829 /* Find the context in which this FIELD can be initialized. */
832 initializing_context (field
)
835 tree t
= DECL_CONTEXT (field
);
837 /* Anonymous union members can be initialized in the first enclosing
838 non-anonymous union context. */
839 while (t
&& ANON_UNION_TYPE_P (t
))
840 t
= TYPE_CONTEXT (t
);
844 /* Function to give error message if member initialization specification
845 is erroneous. FIELD is the member we decided to initialize.
846 TYPE is the type for which the initialization is being performed.
847 FIELD must be a member of TYPE.
849 MEMBER_NAME is the name of the member. */
852 member_init_ok_or_else (field
, type
, member_name
)
857 if (field
== error_mark_node
)
859 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
861 cp_error ("class `%T' does not have any field named `%s'", type
,
865 if (TREE_STATIC (field
))
867 cp_error ("field `%#D' is static; only point of initialization is its declaration",
875 /* If NAME is a viable field name for the aggregate DECL,
876 and PARMS is a viable parameter list, then expand an _EXPR
877 which describes this initialization.
879 Note that we do not need to chase through the class's base classes
880 to look for NAME, because if it's in that list, it will be handled
881 by the constructor for that base class.
883 We do not yet have a fixed-point finder to instantiate types
884 being fed to overloaded constructors. If there is a unique
885 constructor, then argument types can be got from that one.
887 If INIT is non-NULL, then it the initialization should
888 be placed in `current_base_init_list', where it will be processed
889 by `emit_base_init'. */
892 expand_member_init (exp
, name
, init
)
893 tree exp
, name
, init
;
895 tree basetype
= NULL_TREE
, field
;
898 if (exp
== NULL_TREE
)
899 return; /* complain about this later */
901 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
903 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
905 basetype
= TREE_TYPE (name
);
906 name
= DECL_NAME (name
);
909 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
910 switch (CLASSTYPE_N_BASECLASSES (type
))
913 error ("base class initializer specified, but no base class to initialize");
916 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
919 error ("initializer for unnamed base class ambiguous");
920 cp_error ("(type `%T' uses multiple inheritance)", type
);
924 my_friendly_assert (init
!= NULL_TREE
, 0);
926 /* The grammar should not allow fields which have names that are
927 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
928 may assume that this is an attempt to initialize a base class
929 member of the current type. Otherwise, it is an attempt to
930 initialize a member field. */
932 if (init
== void_type_node
)
935 if (name
== NULL_TREE
|| basetype
)
939 if (name
== NULL_TREE
)
943 name
= TYPE_IDENTIFIER (basetype
);
946 error ("no base class to initialize");
951 else if (basetype
!= type
952 && ! current_template_parms
953 && ! vec_binfo_member (basetype
,
954 TYPE_BINFO_BASETYPES (type
))
955 && ! binfo_member (basetype
, CLASSTYPE_VBASECLASSES (type
)))
957 if (IDENTIFIER_CLASS_VALUE (name
))
959 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
960 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
963 cp_error ("type `%T' is not an immediate basetype for `%T'",
968 if (purpose_member (basetype
, current_base_init_list
))
970 cp_error ("base class `%T' already initialized", basetype
);
974 if (warn_reorder
&& current_member_init_list
)
976 cp_warning ("base initializer for `%T'", basetype
);
977 warning (" will be re-ordered to precede member initializations");
980 base_init
= build_tree_list (basetype
, init
);
981 current_base_init_list
= chainon (current_base_init_list
, base_init
);
988 field
= lookup_field (type
, name
, 1, 0);
990 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
993 if (purpose_member (name
, current_member_init_list
))
995 cp_error ("field `%D' already initialized", field
);
999 member_init
= build_tree_list (name
, init
);
1000 current_member_init_list
= chainon (current_member_init_list
, member_init
);
1004 /* This is like `expand_member_init', only it stores one aggregate
1007 INIT comes in two flavors: it is either a value which
1008 is to be stored in EXP, or it is a parameter list
1009 to go to a constructor, which will operate on EXP.
1010 If INIT is not a parameter list for a constructor, then set
1011 LOOKUP_ONLYCONVERTING.
1012 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1013 the initializer, if FLAGS is 0, then it is the (init) form.
1014 If `init' is a CONSTRUCTOR, then we emit a warning message,
1015 explaining that such initializations are invalid.
1017 ALIAS_THIS is nonzero iff we are initializing something which is
1018 essentially an alias for current_class_ref. In this case, the base
1019 constructor may move it on us, and we must keep track of such
1022 If INIT resolves to a CALL_EXPR which happens to return
1023 something of the type we are looking for, then we know
1024 that we can safely use that call to perform the
1027 The virtual function table pointer cannot be set up here, because
1028 we do not really know its type.
1030 Virtual baseclass pointers are also set up here.
1032 This never calls operator=().
1034 When initializing, nothing is CONST.
1036 A default copy constructor may have to be used to perform the
1039 A constructor or a conversion operator may have to be used to
1040 perform the initialization, but not both, as it would be ambiguous. */
1043 expand_aggr_init (exp
, init
, alias_this
, 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
)
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 (TYPE_READONLY (TREE_TYPE (type
)) || TYPE_VOLATILE (TREE_TYPE (type
)))
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");
1089 expand_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1090 init
&& comptypes (TREE_TYPE (init
), TREE_TYPE (exp
), 1));
1091 TREE_READONLY (exp
) = was_const
;
1092 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1093 TREE_TYPE (exp
) = type
;
1095 TREE_TYPE (init
) = itype
;
1099 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1100 /* just know that we've seen something for this node */
1101 TREE_USED (exp
) = 1;
1104 /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1105 constructor as parameters to an implicit GNU C++ constructor. */
1106 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
1107 && TYPE_HAS_CONSTRUCTOR (type
)
1108 && TREE_TYPE (init
) == type
)
1109 init
= CONSTRUCTOR_ELTS (init
);
1112 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1113 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1114 init
, alias_this
, LOOKUP_NORMAL
|flags
);
1115 TREE_TYPE (exp
) = type
;
1116 TREE_READONLY (exp
) = was_const
;
1117 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1121 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1128 tree type
= TREE_TYPE (exp
);
1130 /* It fails because there may not be a constructor which takes
1131 its own type as the first (or only parameter), but which does
1132 take other types via a conversion. So, if the thing initializing
1133 the expression is a unit element of type X, first try X(X&),
1134 followed by initialization by X. If neither of these work
1135 out, then look hard. */
1139 if (init
&& TREE_CODE (init
) != TREE_LIST
1140 && (flags
& LOOKUP_ONLYCONVERTING
))
1142 /* Base subobjects should only get direct-initialization. */
1143 if (true_exp
!= exp
)
1146 /* We special-case TARGET_EXPRs here to avoid an error about
1147 private copy constructors for temporaries bound to reference vars.
1148 If the TARGET_EXPR represents a call to a function that has
1149 permission to create such objects, a reference can bind directly
1150 to the return value. An object variable must be initialized
1151 via the copy constructor, even if the call is elided. */
1152 if (! (TREE_CODE (exp
) == VAR_DECL
&& DECL_ARTIFICIAL (exp
)
1153 && TREE_CODE (init
) == TARGET_EXPR
&& TREE_TYPE (init
) == type
))
1154 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1156 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1157 /* We need to protect the initialization of a catch parm
1158 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1159 around the TARGET_EXPR for the copy constructor. See
1160 expand_start_catch_block. */
1161 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1162 TREE_OPERAND (init
, 0));
1164 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1165 TREE_SIDE_EFFECTS (init
) = 1;
1166 expand_expr_stmt (init
);
1170 if (init
== NULL_TREE
1171 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1175 init
= TREE_VALUE (parms
);
1178 parms
= build_expr_list (NULL_TREE
, init
);
1180 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1182 if (true_exp
== exp
)
1183 parms
= expr_tree_cons (NULL_TREE
, integer_one_node
, parms
);
1185 parms
= expr_tree_cons (NULL_TREE
, integer_zero_node
, parms
);
1186 flags
|= LOOKUP_HAS_IN_CHARGE
;
1189 rval
= build_method_call (exp
, ctor_identifier
,
1190 parms
, binfo
, flags
);
1191 if (TREE_SIDE_EFFECTS (rval
))
1192 expand_expr_stmt (rval
);
1195 /* This function is responsible for initializing EXP with INIT
1198 BINFO is the binfo of the type for who we are performing the
1199 initialization. For example, if W is a virtual base class of A and B,
1201 If we are initializing B, then W must contain B's W vtable, whereas
1202 were we initializing C, W must contain C's W vtable.
1204 TRUE_EXP is nonzero if it is the true expression being initialized.
1205 In this case, it may be EXP, or may just contain EXP. The reason we
1206 need this is because if EXP is a base element of TRUE_EXP, we
1207 don't necessarily know by looking at EXP where its virtual
1208 baseclass fields should really be pointing. But we do know
1209 from TRUE_EXP. In constructors, we don't know anything about
1210 the value being initialized.
1212 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1214 FLAGS is just passes to `build_method_call'. See that function for
1218 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, alias_this
, 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 tree t
= store_init_value (exp
, init
);
1242 expand_decl_init (exp
);
1245 t
= build (INIT_EXPR
, type
, exp
, init
);
1246 TREE_SIDE_EFFECTS (t
) = 1;
1247 expand_expr_stmt (t
);
1251 /* We know that expand_default_init can handle everything we want
1253 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
);
1256 /* Report an error if NAME is not the name of a user-defined,
1257 aggregate type. If OR_ELSE is nonzero, give an error message. */
1260 is_aggr_typedef (name
, or_else
)
1266 if (name
== error_mark_node
)
1269 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1270 type
= IDENTIFIER_TYPE_VALUE (name
);
1274 cp_error ("`%T' is not an aggregate typedef", name
);
1278 if (! IS_AGGR_TYPE (type
)
1279 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1280 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1283 cp_error ("`%T' is not an aggregate type", type
);
1289 /* Report an error if TYPE is not a user-defined, aggregate type. If
1290 OR_ELSE is nonzero, give an error message. */
1293 is_aggr_type (type
, or_else
)
1297 if (type
== error_mark_node
)
1300 if (! IS_AGGR_TYPE (type
)
1301 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1302 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1305 cp_error ("`%T' is not an aggregate type", type
);
1311 /* Like is_aggr_typedef, but returns typedef if successful. */
1314 get_aggr_from_typedef (name
, or_else
)
1320 if (name
== error_mark_node
)
1323 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1324 type
= IDENTIFIER_TYPE_VALUE (name
);
1328 cp_error ("`%T' fails to be an aggregate typedef", name
);
1332 if (! IS_AGGR_TYPE (type
)
1333 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1334 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1337 cp_error ("type `%T' is of non-aggregate type", type
);
1344 get_type_value (name
)
1347 if (name
== error_mark_node
)
1350 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1351 return IDENTIFIER_TYPE_VALUE (name
);
1357 /* This code could just as well go in `class.c', but is placed here for
1360 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1361 the appropriate function call. */
1364 build_member_call (type
, name
, parmlist
)
1365 tree type
, name
, parmlist
;
1370 int dont_use_this
= 0;
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 my_friendly_assert (is_overloaded_fn (TREE_OPERAND (name
, 0)), 980519);
1379 return build_x_function_call (name
, parmlist
, current_class_ref
);
1382 if (type
== std_node
)
1383 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1385 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1386 return build_x_function_call (lookup_namespace_name (type
, name
),
1387 parmlist
, current_class_ref
);
1389 if (TREE_CODE (name
) != TEMPLATE_ID_EXPR
)
1392 method_name
= TREE_OPERAND (name
, 0);
1394 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1396 method_name
= TREE_OPERAND (method_name
, 0);
1400 /* This shouldn't be here, and build_member_call shouldn't appear in
1402 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1403 && get_aggr_from_typedef (type
, 0) == 0)
1405 tree ns
= lookup_name (type
, 0);
1406 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1408 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1412 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1413 return error_mark_node
;
1415 /* An operator we did not like. */
1416 if (name
== NULL_TREE
)
1417 return error_mark_node
;
1421 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1423 return error_mark_node
;
1426 /* No object? Then just fake one up, and let build_method_call
1427 figure out what to do. */
1428 if (current_class_type
== 0
1429 || get_base_distance (type
, current_class_type
, 0, &basetype_path
) == -1)
1434 basetype_path
= TYPE_BINFO (type
);
1435 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1437 else if (current_class_ptr
== 0)
1440 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1444 tree olddecl
= current_class_ptr
;
1445 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1446 if (oldtype
!= type
)
1448 tree newtype
= build_type_variant (type
, TYPE_READONLY (oldtype
),
1449 TYPE_VOLATILE (oldtype
));
1450 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1456 decl
= build_indirect_ref (decl
, NULL_PTR
);
1458 if (method_name
== constructor_name (type
)
1459 || method_name
== constructor_name_full (type
))
1460 return build_functional_cast (type
, parmlist
);
1461 if ((t
= lookup_fnfields (basetype_path
, method_name
, 0)))
1462 return build_method_call (decl
,
1463 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1464 ? name
: method_name
,
1465 parmlist
, basetype_path
,
1466 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1467 if (TREE_CODE (name
) == IDENTIFIER_NODE
1468 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1470 if (t
== error_mark_node
)
1471 return error_mark_node
;
1472 if (TREE_CODE (t
) == FIELD_DECL
)
1476 cp_error ("invalid use of non-static field `%D'", t
);
1477 return error_mark_node
;
1479 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1481 else if (TREE_CODE (t
) == VAR_DECL
)
1485 cp_error ("invalid use of member `%D'", t
);
1486 return error_mark_node
;
1488 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1489 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1490 parmlist
, NULL_TREE
);
1491 return build_function_call (decl
, parmlist
);
1495 cp_error ("no method `%T::%D'", type
, name
);
1496 return error_mark_node
;
1500 /* Build a reference to a member of an aggregate. This is not a
1501 C++ `&', but really something which can have its address taken,
1502 and then act as a pointer to member, for example TYPE :: FIELD
1503 can have its address taken by saying & TYPE :: FIELD.
1505 @@ Prints out lousy diagnostics for operator <typename>
1508 @@ This function should be rewritten and placed in search.c. */
1511 build_offset_ref (type
, name
)
1514 tree decl
, fnfields
, fields
, t
= error_mark_node
;
1515 tree basebinfo
= NULL_TREE
;
1516 tree orig_name
= name
;
1518 /* class templates can come in as TEMPLATE_DECLs here. */
1519 if (TREE_CODE (name
) == TEMPLATE_DECL
)
1522 if (type
== std_node
)
1523 return do_scoped_id (name
, 0);
1525 if (processing_template_decl
|| uses_template_parms (type
))
1526 return build_min_nt (SCOPE_REF
, type
, name
);
1528 /* Handle namespace names fully here. */
1529 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1531 t
= lookup_namespace_name (type
, name
);
1532 if (t
!= error_mark_node
&& ! type_unknown_p (t
))
1535 t
= convert_from_reference (t
);
1540 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1541 return error_mark_node
;
1543 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1545 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1546 something like `a.template f<int>' or the like. For the most
1547 part, we treat this just like a.f. We do remember, however,
1548 the template-id that was used. */
1549 name
= TREE_OPERAND (orig_name
, 0);
1551 if (TREE_CODE (name
) == LOOKUP_EXPR
)
1552 /* This can happen during tsubst'ing. */
1553 name
= TREE_OPERAND (name
, 0);
1555 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
1558 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1560 if (! check_dtor_name (type
, name
))
1561 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1562 type
, TREE_OPERAND (name
, 0));
1563 name
= dtor_identifier
;
1566 /* I think this is wrong, but the draft is unclear. --jason 6/15/98 */
1567 else if (name
== constructor_name_full (type
)
1568 || name
== constructor_name (type
))
1569 name
= ctor_identifier
;
1572 if (TYPE_SIZE (complete_type (type
)) == 0)
1574 if (type
== current_class_type
)
1575 t
= IDENTIFIER_CLASS_VALUE (name
);
1580 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1582 return error_mark_node
;
1584 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == VAR_DECL
1585 || TREE_CODE (t
) == CONST_DECL
)
1590 if (TREE_CODE (t
) == FIELD_DECL
)
1591 sorry ("use of member in incomplete aggregate type");
1592 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1593 sorry ("use of member function in incomplete aggregate type");
1595 my_friendly_abort (52);
1596 return error_mark_node
;
1599 if (current_class_type
== 0
1600 || get_base_distance (type
, current_class_type
, 0, &basebinfo
) == -1)
1602 basebinfo
= TYPE_BINFO (type
);
1603 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1605 else if (current_class_ptr
== 0)
1606 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1608 decl
= current_class_ref
;
1610 fnfields
= lookup_fnfields (basebinfo
, name
, 1);
1611 fields
= lookup_field (basebinfo
, name
, 0, 0);
1613 if (fields
== error_mark_node
|| fnfields
== error_mark_node
)
1614 return error_mark_node
;
1616 /* A lot of this logic is now handled in lookup_field and
1620 extern int flag_save_memoized_contexts
;
1622 /* Go from the TREE_BASELINK to the member function info. */
1623 t
= TREE_VALUE (fnfields
);
1625 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1627 /* The FNFIELDS are going to contain functions that aren't
1628 necessarily templates, and templates that don't
1629 necessarily match the explicit template parameters. We
1630 save all the functions, and the explicit parameters, and
1631 then figure out exactly what to instantiate with what
1632 arguments in instantiate_type. */
1634 if (TREE_CODE (t
) != OVERLOAD
)
1635 /* The code in instantiate_type which will process this
1636 expects to encounter OVERLOADs, not raw functions. */
1637 t
= ovl_cons (t
, NULL_TREE
);
1639 return build (OFFSET_REF
,
1640 build_offset_type (type
, unknown_type_node
),
1642 build (TEMPLATE_ID_EXPR
,
1645 TREE_OPERAND (orig_name
, 1)));
1648 if (!really_overloaded_fn (t
))
1652 /* Get rid of a potential OVERLOAD around it */
1653 t
= OVL_CURRENT (t
);
1655 /* unique functions are handled easily. */
1656 basebinfo
= TREE_PURPOSE (fnfields
);
1657 access
= compute_access (basebinfo
, t
);
1658 if (access
== access_protected_node
)
1660 cp_error_at ("member function `%#D' is protected", t
);
1661 error ("in this context");
1662 return error_mark_node
;
1664 if (access
== access_private_node
)
1666 cp_error_at ("member function `%#D' is private", t
);
1667 error ("in this context");
1668 return error_mark_node
;
1671 return build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1674 /* FNFIELDS is most likely allocated on the search_obstack,
1675 which will go away after this class scope. If we need
1676 to save this value for later (either for memoization
1677 or for use as an initializer for a static variable), then
1680 ??? The smart thing to do for the case of saving initializers
1681 is to resolve them before we're done with this scope. */
1682 if (!TREE_PERMANENT (fnfields
)
1683 && ((flag_save_memoized_contexts
&& toplevel_bindings_p ())
1684 || ! allocation_temporary_p ()))
1685 fnfields
= copy_list (fnfields
);
1687 t
= build_tree_list (error_mark_node
, fnfields
);
1688 TREE_TYPE (t
) = build_offset_type (type
, unknown_type_node
);
1692 /* Now that we know we are looking for a field, see if we
1693 have access to that field. Lookup_field will give us the
1696 t
= lookup_field (basebinfo
, name
, 1, 0);
1698 if (t
== error_mark_node
)
1699 return error_mark_node
;
1703 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1704 return error_mark_node
;
1707 if (TREE_CODE (t
) == TYPE_DECL
)
1712 /* static class members and class-specific enum
1713 values can be returned without further ado. */
1714 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1717 return convert_from_reference (t
);
1720 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_BIT_FIELD (t
))
1722 cp_error ("illegal pointer to bit field `%D'", t
);
1723 return error_mark_node
;
1726 /* static class functions too. */
1727 if (TREE_CODE (t
) == FUNCTION_DECL
1728 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1729 my_friendly_abort (53);
1731 /* In member functions, the form `type::name' is no longer
1732 equivalent to `this->type::name', at least not until
1733 resolve_offset_ref. */
1734 return build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1737 /* If a OFFSET_REF made it through to here, then it did
1738 not have its address taken. */
1741 resolve_offset_ref (exp
)
1744 tree type
= TREE_TYPE (exp
);
1745 tree base
= NULL_TREE
;
1747 tree basetype
, addr
;
1749 if (TREE_CODE (exp
) == TREE_LIST
)
1751 cp_pedwarn ("assuming & on overloaded member function");
1752 return build_unary_op (ADDR_EXPR
, exp
, 0);
1755 if (TREE_CODE (exp
) == OFFSET_REF
)
1757 member
= TREE_OPERAND (exp
, 1);
1758 base
= TREE_OPERAND (exp
, 0);
1762 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1763 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1765 error ("object missing in use of pointer-to-member construct");
1766 return error_mark_node
;
1769 type
= TREE_TYPE (type
);
1770 base
= current_class_ref
;
1773 if ((TREE_CODE (member
) == VAR_DECL
1774 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1775 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
1776 || TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1778 /* These were static members. */
1779 if (mark_addressable (member
) == 0)
1780 return error_mark_node
;
1784 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1785 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1788 /* Syntax error can cause a member which should
1789 have been seen as static to be grok'd as non-static. */
1790 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1792 if (TREE_ADDRESSABLE (member
) == 0)
1794 cp_error_at ("member `%D' is non-static but referenced as a static member",
1796 error ("at this point in file");
1797 TREE_ADDRESSABLE (member
) = 1;
1799 return error_mark_node
;
1802 /* The first case is really just a reference to a member of `this'. */
1803 if (TREE_CODE (member
) == FIELD_DECL
1804 && (base
== current_class_ref
1805 || (TREE_CODE (base
) == NOP_EXPR
1806 && TREE_OPERAND (base
, 0) == error_mark_node
)))
1808 tree basetype_path
, access
;
1810 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1811 basetype
= TYPE_OFFSET_BASETYPE (type
);
1813 basetype
= DECL_CONTEXT (member
);
1815 base
= current_class_ptr
;
1817 if (get_base_distance (basetype
, TREE_TYPE (TREE_TYPE (base
)), 0, &basetype_path
) < 0)
1819 error_not_base_type (basetype
, TREE_TYPE (TREE_TYPE (base
)));
1820 return error_mark_node
;
1822 /* Kludge: we need to use basetype_path now, because
1823 convert_pointer_to will bash it. */
1824 access
= compute_access (basetype_path
, member
);
1825 addr
= convert_pointer_to (basetype
, base
);
1826 if (access
== access_public_node
)
1827 return build (COMPONENT_REF
, TREE_TYPE (member
),
1828 build_indirect_ref (addr
, NULL_PTR
), member
);
1829 if (access
== access_protected_node
)
1831 cp_error_at ("member `%D' is protected", member
);
1832 error ("in this context");
1833 return error_mark_node
;
1835 if (access
== access_private_node
)
1837 cp_error_at ("member `%D' is private", member
);
1838 error ("in this context");
1839 return error_mark_node
;
1841 my_friendly_abort (55);
1844 /* Ensure that we have an object. */
1845 if (TREE_CODE (base
) == NOP_EXPR
1846 && TREE_OPERAND (base
, 0) == error_mark_node
)
1847 addr
= error_mark_node
;
1850 /* If this is a reference to a member function, then return the
1851 address of the member function (which may involve going
1852 through the object's vtable), otherwise, return an expression
1853 for the dereferenced pointer-to-member construct. */
1854 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1857 if (TREE_CODE (TREE_TYPE (member
)) == OFFSET_TYPE
)
1859 if (addr
== error_mark_node
)
1861 cp_error ("object missing in `%E'", exp
);
1862 return error_mark_node
;
1865 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (member
));
1866 addr
= convert_pointer_to (basetype
, addr
);
1867 member
= cp_convert (ptrdiff_type_node
,
1868 build_unary_op (ADDR_EXPR
, member
, 0));
1870 /* Pointer to data members are offset by one, so that a null
1871 pointer with a real value of 0 is distinguishable from an
1872 offset of the first member of a structure. */
1873 member
= build_binary_op (MINUS_EXPR
, member
,
1874 cp_convert (ptrdiff_type_node
, integer_one_node
),
1877 return build1 (INDIRECT_REF
, type
,
1878 build (PLUS_EXPR
, build_pointer_type (type
),
1881 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1883 return get_member_function_from_ptrfunc (&addr
, member
);
1885 my_friendly_abort (56);
1890 /* Return either DECL or its known constant value (if it has one). */
1893 decl_constant_value (decl
)
1896 if (! TREE_THIS_VOLATILE (decl
)
1898 /* These may be necessary for C, but they break C++. */
1899 ! TREE_PUBLIC (decl
)
1900 /* Don't change a variable array bound or initial value to a constant
1901 in a place where a variable is invalid. */
1904 && DECL_INITIAL (decl
) != 0
1905 && DECL_INITIAL (decl
) != error_mark_node
1906 /* This is invalid if initial value is not constant.
1907 If it has either a function call, a memory reference,
1908 or a variable, then re-evaluating it could give different results. */
1909 && TREE_CONSTANT (DECL_INITIAL (decl
))
1910 /* Check for cases where this is sub-optimal, even though valid. */
1911 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
1913 /* We must allow this to work outside of functions so that
1914 static constants can be used for array sizes. */
1915 && current_function_decl
!= 0
1916 && DECL_MODE (decl
) != BLKmode
1919 return DECL_INITIAL (decl
);
1923 /* Common subroutines of build_new and build_vec_delete. */
1925 /* Call the global __builtin_delete to delete ADDR. */
1928 build_builtin_delete_call (addr
)
1931 tree BID
= get_first_fn
1932 (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) DELETE_EXPR
]));
1934 assemble_external (BID
);
1935 return build_call (BID
, void_type_node
, build_expr_list (NULL_TREE
, addr
));
1938 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1939 (which needs to go through some sort of groktypename) or it
1940 is the name of the class we are newing. INIT is an initialization value.
1941 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1942 If INIT is void_type_node, it means do *not* call a constructor
1945 For types with constructors, the data returned is initialized
1946 by the appropriate constructor.
1948 Whether the type has a constructor or not, if it has a pointer
1949 to a virtual function table, then that pointer is set up
1952 Unless I am mistaken, a call to new () will return initialized
1953 data regardless of whether the constructor itself is private or
1954 not. NOPE; new fails if the constructor is private (jcm).
1956 Note that build_new does nothing to assure that any special
1957 alignment requirements of the type are met. Rather, it leaves
1958 it up to malloc to do the right thing. Otherwise, folding to
1959 the right alignment cal cause problems if the user tries to later
1960 free the memory returned by `new'.
1962 PLACEMENT is the `placement' list for user-defined operator new (). */
1964 extern int flag_check_new
;
1967 build_new (placement
, decl
, init
, use_global_new
)
1973 tree nelts
= NULL_TREE
, t
;
1976 tree pending_sizes
= NULL_TREE
;
1978 if (decl
== error_mark_node
)
1979 return error_mark_node
;
1981 if (TREE_CODE (decl
) == TREE_LIST
)
1983 tree absdcl
= TREE_VALUE (decl
);
1984 tree last_absdcl
= NULL_TREE
;
1985 int old_immediate_size_expand
= 0;
1987 if (current_function_decl
1988 && DECL_CONSTRUCTOR_P (current_function_decl
))
1990 old_immediate_size_expand
= immediate_size_expand
;
1991 immediate_size_expand
= 0;
1994 nelts
= integer_one_node
;
1996 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
1997 my_friendly_abort (215);
1998 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2000 last_absdcl
= absdcl
;
2001 absdcl
= TREE_OPERAND (absdcl
, 0);
2004 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2006 /* probably meant to be a vec new */
2009 while (TREE_OPERAND (absdcl
, 0)
2010 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2012 last_absdcl
= absdcl
;
2013 absdcl
= TREE_OPERAND (absdcl
, 0);
2017 this_nelts
= TREE_OPERAND (absdcl
, 1);
2018 if (this_nelts
!= error_mark_node
)
2020 if (this_nelts
== NULL_TREE
)
2021 error ("new of array type fails to specify size");
2022 else if (processing_template_decl
)
2025 absdcl
= TREE_OPERAND (absdcl
, 0);
2029 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2030 absdcl
= TREE_OPERAND (absdcl
, 0);
2031 if (this_nelts
== integer_zero_node
)
2033 warning ("zero size array reserves no space");
2034 nelts
= integer_zero_node
;
2037 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2041 nelts
= integer_zero_node
;
2045 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2047 TREE_VALUE (decl
) = absdcl
;
2049 type
= groktypename (decl
);
2050 if (! type
|| type
== error_mark_node
)
2052 immediate_size_expand
= old_immediate_size_expand
;
2053 return error_mark_node
;
2056 if (current_function_decl
2057 && DECL_CONSTRUCTOR_P (current_function_decl
))
2059 pending_sizes
= get_pending_sizes ();
2060 immediate_size_expand
= old_immediate_size_expand
;
2063 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2065 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2067 /* An aggregate type. */
2068 type
= IDENTIFIER_TYPE_VALUE (decl
);
2069 decl
= TYPE_MAIN_DECL (type
);
2073 /* A builtin type. */
2074 decl
= lookup_name (decl
, 1);
2075 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2076 type
= TREE_TYPE (decl
);
2079 else if (TREE_CODE (decl
) == TYPE_DECL
)
2081 type
= TREE_TYPE (decl
);
2086 decl
= TYPE_MAIN_DECL (type
);
2089 if (processing_template_decl
)
2092 t
= min_tree_cons (min_tree_cons (NULL_TREE
, type
, NULL_TREE
),
2093 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2098 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2099 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2103 /* ``A reference cannot be created by the new operator. A reference
2104 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2105 returned by new.'' ARM 5.3.3 */
2106 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2108 error ("new cannot be applied to a reference type");
2109 type
= TREE_TYPE (type
);
2112 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2114 error ("new cannot be applied to a function type");
2115 return error_mark_node
;
2118 /* When the object being created is an array, the new-expression yields a
2119 pointer to the initial element (if any) of the array. For example,
2120 both new int and new int[10] return an int*. 5.3.4. */
2121 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2123 nelts
= array_type_nelts_top (type
);
2125 type
= TREE_TYPE (type
);
2129 t
= build_nt (ARRAY_REF
, type
, nelts
);
2133 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2134 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2135 TREE_SIDE_EFFECTS (rval
) = 1;
2137 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2138 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2139 TREE_NO_UNUSED_WARNING (rval
) = 1;
2142 rval
= build_compound_expr (chainon (pending_sizes
,
2143 build_expr_list (NULL_TREE
, rval
)));
2148 /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */
2150 static tree jclass_node
= NULL_TREE
;
2152 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2155 build_java_class_ref (type
)
2158 tree name
, class_decl
;
2159 static tree CL_prefix
= NULL_TREE
;
2160 if (CL_prefix
== NULL_TREE
)
2161 CL_prefix
= get_identifier("_CL_");
2162 if (jclass_node
== NULL_TREE
)
2164 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2165 if (jclass_node
== NULL_TREE
)
2166 fatal("call to Java constructor, while `jclass' undefined");
2167 jclass_node
= TREE_TYPE (jclass_node
);
2169 name
= build_overload_with_type (CL_prefix
, type
);
2170 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2171 if (class_decl
== NULL_TREE
)
2173 push_obstacks_nochange ();
2174 end_temporary_allocation ();
2175 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2176 TREE_STATIC (class_decl
) = 1;
2177 DECL_EXTERNAL (class_decl
) = 1;
2178 TREE_PUBLIC (class_decl
) = 1;
2179 DECL_ARTIFICIAL (class_decl
) = 1;
2180 DECL_IGNORED_P (class_decl
) = 1;
2181 pushdecl_top_level (class_decl
);
2182 make_decl_rtl (class_decl
, NULL_PTR
, 1);
2188 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2189 value is immediately handed to expand_expr. */
2195 tree placement
, init
;
2196 tree type
, true_type
, size
, rval
;
2197 tree nelts
= NULL_TREE
;
2198 tree alloc_expr
, alloc_node
= NULL_TREE
;
2200 enum tree_code code
= NEW_EXPR
;
2201 int use_cookie
, nothrow
, check_new
;
2203 int use_java_new
= 0;
2205 placement
= TREE_OPERAND (exp
, 0);
2206 type
= TREE_OPERAND (exp
, 1);
2207 init
= TREE_OPERAND (exp
, 2);
2208 use_global_new
= NEW_EXPR_USE_GLOBAL (exp
);
2210 if (TREE_CODE (type
) == ARRAY_REF
)
2213 nelts
= TREE_OPERAND (type
, 1);
2214 type
= TREE_OPERAND (type
, 0);
2218 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
))
2219 type
= TYPE_MAIN_VARIANT (type
);
2221 /* If our base type is an array, then make sure we know how many elements
2223 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2225 tree this_nelts
= array_type_nelts_top (true_type
);
2226 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2227 true_type
= TREE_TYPE (true_type
);
2230 if (!complete_type_or_else (true_type
))
2231 return error_mark_node
;
2234 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2237 size
= size_in_bytes (type
);
2239 if (TREE_CODE (true_type
) == VOID_TYPE
)
2241 error ("invalid type `void' for new");
2242 return error_mark_node
;
2245 if (TYPE_LANG_SPECIFIC (true_type
)
2246 && CLASSTYPE_ABSTRACT_VIRTUALS (true_type
))
2248 abstract_virtuals_error (NULL_TREE
, true_type
);
2249 return error_mark_node
;
2252 if (TYPE_LANG_SPECIFIC (true_type
) && IS_SIGNATURE (true_type
))
2254 signature_error (NULL_TREE
, true_type
);
2255 return error_mark_node
;
2259 /* Get a little extra space to store a couple of things before the new'ed
2260 array, if this isn't the default placement new. */
2262 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2263 && ! (placement
&& ! TREE_CHAIN (placement
)
2264 && TREE_TYPE (TREE_VALUE (placement
)) == ptr_type_node
));
2266 /* Get a little extra space to store a couple of things before the new'ed
2267 array, if this is either non-placement new or new (nothrow). */
2269 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2270 && (! placement
|| nothrow
));
2275 tree extra
= BI_header_size
;
2277 size
= size_binop (PLUS_EXPR
, size
, extra
);
2282 code
= VEC_NEW_EXPR
;
2284 if (init
&& pedantic
)
2285 cp_pedwarn ("initialization in array new");
2288 /* Allocate the object. */
2290 if (! has_array
&& ! placement
&& flag_this_is_variable
> 0
2291 && TYPE_NEEDS_CONSTRUCTING (true_type
) && init
!= void_type_node
)
2293 if (init
== NULL_TREE
|| TREE_CODE (init
) == TREE_LIST
)
2297 error ("constructors take parameter lists");
2298 return error_mark_node
;
2301 else if (! placement
&& TYPE_FOR_JAVA (true_type
))
2303 tree class_addr
, alloc_decl
;
2304 tree class_decl
= build_java_class_ref (true_type
);
2305 tree class_size
= size_in_bytes (true_type
);
2306 static char alloc_name
[] = "_Jv_AllocObject";
2308 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2309 if (alloc_decl
== NULL_TREE
)
2310 fatal("call to Java constructor, while `%s' undefined", alloc_name
);
2311 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2312 rval
= build_function_call (alloc_decl
,
2313 tree_cons (NULL_TREE
, class_addr
,
2314 build_tree_list (NULL_TREE
,
2316 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2322 if (flag_exceptions
)
2323 /* We will use RVAL when generating an exception handler for
2324 this new-expression, so we must save it. */
2325 susp
= suspend_momentary ();
2327 rval
= build_op_new_call
2328 (code
, true_type
, expr_tree_cons (NULL_TREE
, size
, placement
),
2329 LOOKUP_NORMAL
| (use_global_new
* LOOKUP_GLOBAL
));
2330 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2332 if (flag_exceptions
)
2333 resume_momentary (susp
);
2336 /* unless an allocation function is declared with an empty excep-
2337 tion-specification (_except.spec_), throw(), it indicates failure to
2338 allocate storage by throwing a bad_alloc exception (clause _except_,
2339 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2340 cation function is declared with an empty exception-specification,
2341 throw(), it returns null to indicate failure to allocate storage and a
2342 non-null pointer otherwise.
2344 So check for a null exception spec on the op new we just called. */
2349 /* The CALL_EXPR. */
2350 tree t
= TREE_OPERAND (rval
, 0);
2352 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
2353 t
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
2355 if (t
&& TREE_VALUE (t
) == NULL_TREE
)
2358 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2360 if ((check_new
|| flag_exceptions
) && rval
)
2362 alloc_expr
= get_target_expr (rval
);
2363 alloc_node
= rval
= TREE_OPERAND (alloc_expr
, 0);
2366 alloc_expr
= NULL_TREE
;
2368 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2369 sure we have some extra bytes in that case for the BI_header_size
2370 cookies? And how does that interact with the code below? (mrs) */
2371 /* Finish up some magic for new'ed arrays */
2372 if (use_cookie
&& rval
!= NULL_TREE
)
2374 tree extra
= BI_header_size
;
2376 rval
= convert (string_type_node
, rval
); /* for ptr arithmetic */
2377 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, extra
, 1));
2378 /* Store header info. */
2379 cookie
= build_indirect_ref (build (MINUS_EXPR
,
2380 build_pointer_type (BI_header_type
),
2381 rval
, extra
), NULL_PTR
);
2382 exp1
= build (MODIFY_EXPR
, void_type_node
,
2383 build_component_ref (cookie
, nc_nelts_field_id
,
2386 TREE_SIDE_EFFECTS (exp1
) = 1;
2387 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2388 rval
= build_compound_expr
2389 (expr_tree_cons (NULL_TREE
, exp1
,
2390 build_expr_list (NULL_TREE
, rval
)));
2393 if (rval
== error_mark_node
)
2394 return error_mark_node
;
2396 /* Don't call any constructors or do any initialization. */
2397 if (init
== void_type_node
)
2400 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2402 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2403 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2405 /* New 2.0 interpretation: `new int (10)' means
2406 allocate an int, and initialize it with 10. */
2409 rval
= save_expr (rval
);
2410 deref
= build_indirect_ref (rval
, NULL_PTR
);
2411 TREE_READONLY (deref
) = 0;
2413 if (TREE_CHAIN (init
) != NULL_TREE
)
2414 pedwarn ("initializer list being treated as compound expression");
2415 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2417 pedwarn ("initializer list appears where operand should be used");
2418 init
= TREE_OPERAND (init
, 1);
2420 init
= build_compound_expr (init
);
2422 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2423 "new", NULL_TREE
, 0);
2424 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2425 build_modify_expr (deref
, NOP_EXPR
, init
),
2427 TREE_NO_UNUSED_WARNING (rval
) = 1;
2428 TREE_SIDE_EFFECTS (rval
) = 1;
2430 else if (! has_array
)
2433 /* Constructors are never virtual. If it has an initialization, we
2434 need to complain if we aren't allowed to use the ctor that took
2436 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2438 if (rval
&& TYPE_USES_VIRTUAL_BASECLASSES (true_type
))
2440 init
= expr_tree_cons (NULL_TREE
, integer_one_node
, init
);
2441 flags
|= LOOKUP_HAS_IN_CHARGE
;
2445 rval
= save_expr (rval
);
2448 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2449 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2451 newrval
= build_method_call (newrval
, ctor_identifier
,
2452 init
, TYPE_BINFO (true_type
), flags
);
2454 if (newrval
== NULL_TREE
|| newrval
== error_mark_node
)
2455 return error_mark_node
;
2457 /* Java constructors compiled by jc1 do not return this. */
2459 newrval
= build (COMPOUND_EXPR
, TREE_TYPE (newrval
),
2462 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2465 rval
= build (VEC_INIT_EXPR
, TREE_TYPE (rval
),
2466 save_expr (rval
), init
, nelts
);
2468 /* If any part of the object initialization terminates by throwing
2469 an exception and the new-expression does not contain a
2470 new-placement, then the deallocation function is called to free
2471 the memory in which the object was being constructed. */
2472 if (flag_exceptions
&& alloc_expr
&& ! use_java_new
)
2474 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2475 tree cleanup
, fn
= NULL_TREE
;
2476 int flags
= LOOKUP_NORMAL
| (use_global_new
* LOOKUP_GLOBAL
);
2478 /* All cleanups must last longer than normal. */
2479 int yes
= suspend_momentary ();
2483 flags
|= LOOKUP_SPECULATIVELY
;
2485 /* We expect alloc_expr to look like a TARGET_EXPR around
2486 a NOP_EXPR around the CALL_EXPR we want. */
2487 fn
= TREE_OPERAND (alloc_expr
, 1);
2488 fn
= TREE_OPERAND (fn
, 0);
2491 /* Copy size to the saveable obstack. */
2492 size
= copy_node (size
);
2494 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
, fn
);
2496 resume_momentary (yes
);
2498 /* Ack! First we allocate the memory. Then we set our sentry
2499 variable to true, and expand a cleanup that deletes the memory
2500 if sentry is true. Then we run the constructor and store the
2501 returned pointer in buf. Then we clear sentry and return buf. */
2506 /* Disable this until flow is fixed so that it doesn't
2507 think the initialization of sentry is a dead write. */
2508 tree end
, sentry
, begin
, buf
, t
= TREE_TYPE (rval
);
2510 begin
= get_target_expr (boolean_true_node
);
2511 sentry
= TREE_OPERAND (begin
, 0);
2513 yes
= suspend_momentary ();
2514 TREE_OPERAND (begin
, 2)
2515 = build (COND_EXPR
, void_type_node
, sentry
,
2516 cleanup
, void_zero_node
);
2517 resume_momentary (yes
);
2519 rval
= get_target_expr (rval
);
2521 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2522 sentry
, boolean_false_node
);
2523 TREE_SIDE_EFFECTS (end
) = 1;
2525 buf
= TREE_OPERAND (rval
, 0);
2527 rval
= build (COMPOUND_EXPR
, t
, begin
,
2528 build (COMPOUND_EXPR
, t
, rval
,
2529 build (COMPOUND_EXPR
, t
, end
, buf
)));
2531 /* FIXME: this is a workaround for a crash due to overlapping
2532 exception regions. Cleanups shouldn't really happen here. */
2533 rval
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (rval
), rval
);
2535 rval
= build (TRY_CATCH_EXPR
, TREE_TYPE (rval
), rval
, cleanup
);
2536 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2541 else if (TYPE_READONLY (true_type
))
2542 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2546 if (alloc_expr
&& rval
== alloc_node
)
2548 rval
= TREE_OPERAND (alloc_expr
, 1);
2549 alloc_expr
= NULL_TREE
;
2552 if (check_new
&& alloc_expr
)
2554 /* Did we modify the storage? */
2555 tree ifexp
= build_binary_op (NE_EXPR
, alloc_node
,
2556 integer_zero_node
, 1);
2557 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2561 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2563 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2565 /* The type of new int [3][3] is not int *, but int [3] * */
2566 rval
= build_c_cast (build_pointer_type (type
), rval
);
2573 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,
2575 tree base
, maxindex
, type
;
2576 tree auto_delete_vec
, auto_delete
;
2577 int use_global_delete
;
2580 tree ptype
= build_pointer_type (type
= complete_type (type
));
2581 tree size_exp
= size_in_bytes (type
);
2583 /* Temporary variables used by the loop. */
2584 tree tbase
, tbase_init
;
2586 /* This is the body of the loop that implements the deletion of a
2587 single element, and moves temp variables to next elements. */
2590 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2593 /* This is the thing that governs what to do after the loop has run. */
2594 tree deallocate_expr
= 0;
2596 /* This is the BIND_EXPR which holds the outermost iterator of the
2597 loop. It is convenient to set this variable up and test it before
2598 executing any other code in the loop.
2599 This is also the containing expression returned by this function. */
2600 tree controller
= NULL_TREE
;
2602 if (! IS_AGGR_TYPE (type
) || ! TYPE_NEEDS_DESTRUCTOR (type
))
2604 loop
= integer_zero_node
;
2608 /* The below is short by BI_header_size */
2609 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2611 tbase
= build_decl (VAR_DECL
, NULL_TREE
, ptype
);
2612 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2613 fold (build (PLUS_EXPR
, ptype
,
2616 DECL_REGISTER (tbase
) = 1;
2617 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2618 TREE_SIDE_EFFECTS (controller
) = 1;
2620 if (auto_delete
!= integer_zero_node
2621 && auto_delete
!= integer_two_node
)
2623 tree base_tbd
= cp_convert (ptype
,
2624 build_binary_op (MINUS_EXPR
,
2625 cp_convert (ptr_type_node
, base
),
2628 /* This is the real size */
2629 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2630 body
= build_expr_list (NULL_TREE
,
2631 build_x_delete (ptype
, base_tbd
,
2632 2 | use_global_delete
,
2634 body
= build (COND_EXPR
, void_type_node
,
2635 build (BIT_AND_EXPR
, integer_type_node
,
2636 auto_delete
, integer_one_node
),
2637 body
, integer_zero_node
);
2642 body
= expr_tree_cons (NULL_TREE
,
2643 build_delete (ptype
, tbase
, auto_delete
,
2644 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2647 body
= expr_tree_cons (NULL_TREE
,
2648 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2651 body
= expr_tree_cons (NULL_TREE
,
2652 build (EXIT_EXPR
, void_type_node
,
2653 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2656 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2658 loop
= expr_tree_cons (NULL_TREE
, tbase_init
,
2659 expr_tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2660 loop
= build_compound_expr (loop
);
2663 /* If the delete flag is one, or anything else with the low bit set,
2664 delete the storage. */
2665 if (auto_delete_vec
== integer_zero_node
2666 || auto_delete_vec
== integer_two_node
)
2667 deallocate_expr
= integer_zero_node
;
2672 /* The below is short by BI_header_size */
2673 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2675 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2680 base_tbd
= cp_convert (ptype
,
2681 build_binary_op (MINUS_EXPR
,
2682 cp_convert (string_type_node
, base
),
2685 /* True size with header. */
2686 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2688 deallocate_expr
= build_x_delete (ptype
, base_tbd
,
2689 2 | use_global_delete
,
2691 if (auto_delete_vec
!= integer_one_node
)
2692 deallocate_expr
= build (COND_EXPR
, void_type_node
,
2693 build (BIT_AND_EXPR
, integer_type_node
,
2694 auto_delete_vec
, integer_one_node
),
2695 deallocate_expr
, integer_zero_node
);
2698 if (loop
&& deallocate_expr
!= integer_zero_node
)
2700 body
= expr_tree_cons (NULL_TREE
, loop
,
2701 expr_tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2702 body
= build_compound_expr (body
);
2707 /* Outermost wrapper: If pointer is null, punt. */
2708 body
= build (COND_EXPR
, void_type_node
,
2709 build (NE_EXPR
, boolean_type_node
, base
, integer_zero_node
),
2710 body
, integer_zero_node
);
2711 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2715 TREE_OPERAND (controller
, 1) = body
;
2719 return cp_convert (void_type_node
, body
);
2722 /* Build a tree to cleanup partially built arrays.
2723 BASE is that starting address of the array.
2724 COUNT is the count of objects that have been built, that need destroying.
2725 TYPE is the type of elements in the array. */
2728 build_array_eh_cleanup (base
, count
, type
)
2729 tree base
, count
, type
;
2731 tree expr
= build_vec_delete_1 (base
, count
, type
, integer_two_node
,
2732 integer_zero_node
, 0);
2736 /* `expand_vec_init' performs initialization of a vector of aggregate
2739 DECL is passed only for error reporting, and provides line number
2740 and source file name information.
2741 BASE is the space where the vector will be.
2742 MAXINDEX is the maximum index of the array (one less than the
2743 number of elements).
2744 INIT is the (possibly NULL) initializer.
2746 FROM_ARRAY is 0 if we should init everything with INIT
2747 (i.e., every element initialized from INIT).
2748 FROM_ARRAY is 1 if we should index into INIT in parallel
2749 with initialization of DECL.
2750 FROM_ARRAY is 2 if we should index into INIT in parallel,
2751 but use assignment instead of initialization. */
2754 expand_vec_init (decl
, base
, maxindex
, init
, from_array
)
2755 tree decl
, base
, maxindex
, init
;
2759 tree iterator
, base2
= NULL_TREE
;
2760 tree type
= TREE_TYPE (TREE_TYPE (base
));
2763 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2764 if (maxindex
== error_mark_node
)
2765 return error_mark_node
;
2767 if (current_function_decl
== NULL_TREE
)
2769 rval
= make_tree_vec (3);
2770 TREE_VEC_ELT (rval
, 0) = base
;
2771 TREE_VEC_ELT (rval
, 1) = maxindex
;
2772 TREE_VEC_ELT (rval
, 2) = init
;
2776 size
= size_in_bytes (type
);
2778 /* Set to zero in case size is <= 0. Optimizer will delete this if
2779 it is not needed. */
2780 rval
= get_temp_regvar (build_pointer_type (type
),
2781 cp_convert (build_pointer_type (type
), null_pointer_node
));
2782 base
= default_conversion (base
);
2783 base
= cp_convert (build_pointer_type (type
), base
);
2784 expand_assignment (rval
, base
, 0, 0);
2785 base
= get_temp_regvar (build_pointer_type (type
), base
);
2787 if (init
!= NULL_TREE
2788 && TREE_CODE (init
) == CONSTRUCTOR
2789 && (! decl
|| TREE_TYPE (init
) == TREE_TYPE (decl
)))
2791 /* Initialization of array from {...}. */
2792 tree elts
= CONSTRUCTOR_ELTS (init
);
2793 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2794 tree baseinc
= build (PLUS_EXPR
, build_pointer_type (type
), base
, size
);
2795 int host_i
= TREE_INT_CST_LOW (maxindex
);
2797 if (IS_AGGR_TYPE (type
))
2802 expand_aggr_init (baseref
, TREE_VALUE (elts
), 0, 0);
2804 expand_assignment (base
, baseinc
, 0, 0);
2805 elts
= TREE_CHAIN (elts
);
2807 /* Initialize any elements by default if possible. */
2810 if (TYPE_NEEDS_CONSTRUCTING (type
) == 0)
2813 use_variable (DECL_RTL (base
));
2817 iterator
= get_temp_regvar (ptrdiff_type_node
,
2818 build_int_2 (host_i
, 0));
2820 goto init_by_default
;
2826 expand_assignment (baseref
, TREE_VALUE (elts
), 0, 0);
2828 expand_assignment (base
, baseinc
, 0, 0);
2829 elts
= TREE_CHAIN (elts
);
2833 use_variable (DECL_RTL (base
));
2839 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2844 /* If initializing one array from another,
2845 initialize element by element. */
2848 /* We rely upon the below calls the do argument checking */
2849 if (decl
== NULL_TREE
)
2851 sorry ("initialization of array from dissimilar array type");
2852 return error_mark_node
;
2856 base2
= default_conversion (init
);
2857 itype
= TREE_TYPE (base2
);
2858 base2
= get_temp_regvar (itype
, base2
);
2859 itype
= TREE_TYPE (itype
);
2861 else if (TYPE_LANG_SPECIFIC (type
)
2862 && TYPE_NEEDS_CONSTRUCTING (type
)
2863 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2865 error ("initializer ends prematurely");
2866 return error_mark_node
;
2870 expand_start_cond (build (GE_EXPR
, boolean_type_node
,
2871 iterator
, integer_zero_node
), 0);
2872 if (TYPE_NEEDS_DESTRUCTOR (type
))
2873 expand_eh_region_start ();
2874 expand_start_loop_continue_elsewhere (1);
2876 /* The initialization of each array element is a full-expression. */
2877 expand_start_target_temps ();
2881 tree to
= build1 (INDIRECT_REF
, type
, base
);
2885 from
= build1 (INDIRECT_REF
, itype
, base2
);
2889 if (from_array
== 2)
2890 expand_expr_stmt (build_modify_expr (to
, NOP_EXPR
, from
));
2891 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2892 expand_aggr_init (to
, from
, 0, 0);
2894 expand_assignment (to
, from
, 0, 0);
2896 my_friendly_abort (57);
2898 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2901 sorry ("cannot initialize multi-dimensional array with initializer");
2902 expand_vec_init (decl
, build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), base
),
2903 array_type_nelts (type
), 0, 0);
2906 expand_aggr_init (build1 (INDIRECT_REF
, type
, base
), init
, 0, 0);
2908 expand_assignment (base
,
2909 build (PLUS_EXPR
, build_pointer_type (type
), base
, size
),
2912 expand_assignment (base2
,
2913 build (PLUS_EXPR
, build_pointer_type (type
), base2
, size
), 0, 0);
2915 /* Cleanup any temporaries needed for the initial value. */
2916 expand_end_target_temps ();
2918 expand_loop_continue_here ();
2919 expand_exit_loop_if_false (0, build (NE_EXPR
, boolean_type_node
,
2920 build (PREDECREMENT_EXPR
, ptrdiff_type_node
, iterator
, integer_one_node
), minus_one
));
2924 use_variable (DECL_RTL (base
));
2926 use_variable (DECL_RTL (base2
));
2929 if (TYPE_NEEDS_DESTRUCTOR (type
) && flag_exceptions
)
2931 /* We have to ensure that this can live to the cleanup
2932 expansion time, since we know it is only ever needed
2933 once, generate code now. */
2934 push_obstacks_nochange ();
2935 resume_temporary_allocation ();
2937 tree e1
, cleanup
= make_node (RTL_EXPR
);
2938 TREE_TYPE (cleanup
) = void_type_node
;
2939 RTL_EXPR_RTL (cleanup
) = const0_rtx
;
2940 TREE_SIDE_EFFECTS (cleanup
) = 1;
2941 do_pending_stack_adjust ();
2942 start_sequence_for_rtl_expr (cleanup
);
2944 e1
= build_array_eh_cleanup
2946 build_binary_op (MINUS_EXPR
, maxindex
, iterator
, 1),
2948 expand_expr (e1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2949 do_pending_stack_adjust ();
2950 RTL_EXPR_SEQUENCE (cleanup
) = get_insns ();
2953 cleanup
= protect_with_terminate (cleanup
);
2954 expand_eh_region_end (cleanup
);
2960 use_variable (DECL_RTL (iterator
));
2965 use_variable (DECL_RTL (rval
));
2969 /* Free up storage of type TYPE, at address ADDR.
2971 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2974 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2975 used as the second argument to operator delete. It can include
2976 things like padding and magic size cookies. It has virtual in it,
2977 because if you have a base pointer and you delete through a virtual
2978 destructor, it should be the size of the dynamic object, not the
2979 static object, see Free Store 12.5 ANSI C++ WP.
2981 This does not call any destructors. */
2984 build_x_delete (type
, addr
, which_delete
, virtual_size
)
2989 int use_global_delete
= which_delete
& 1;
2990 int use_vec_delete
= !!(which_delete
& 2);
2991 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2992 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
2994 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
2997 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2998 ADDR is an expression which yields the store to be destroyed.
2999 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
3000 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
3001 virtual baseclasses.
3002 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
3004 FLAGS is the logical disjunction of zero or more LOOKUP_
3005 flags. See cp-tree.h for more info.
3007 This function does not delete an object's virtual base classes. */
3010 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3014 int use_global_delete
;
3020 if (addr
== error_mark_node
)
3021 return error_mark_node
;
3023 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3024 set to `error_mark_node' before it gets properly cleaned up. */
3025 if (type
== error_mark_node
)
3026 return error_mark_node
;
3028 type
= TYPE_MAIN_VARIANT (type
);
3030 if (TREE_CODE (type
) == POINTER_TYPE
)
3032 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3033 if (!complete_type_or_else (type
))
3034 return error_mark_node
;
3035 if (TREE_CODE (type
) == ARRAY_TYPE
)
3037 if (! IS_AGGR_TYPE (type
))
3039 /* Call the builtin operator delete. */
3040 return build_builtin_delete_call (addr
);
3042 if (TREE_SIDE_EFFECTS (addr
))
3043 addr
= save_expr (addr
);
3045 /* throw away const and volatile on target type of addr */
3046 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3047 ref
= build_indirect_ref (addr
, NULL_PTR
);
3049 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3052 if (TREE_SIDE_EFFECTS (addr
))
3053 addr
= save_expr (addr
);
3054 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3056 error ("unknown array size in delete");
3057 return error_mark_node
;
3059 return build_vec_delete (addr
, array_type_nelts (type
),
3060 auto_delete
, integer_two_node
,
3065 /* Don't check PROTECT here; leave that decision to the
3066 destructor. If the destructor is accessible, call it,
3067 else report error. */
3068 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3069 if (TREE_SIDE_EFFECTS (addr
))
3070 addr
= save_expr (addr
);
3072 if (TREE_CONSTANT (addr
))
3073 addr
= convert_pointer_to (type
, addr
);
3075 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3077 ref
= build_indirect_ref (addr
, NULL_PTR
);
3080 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3082 if (! TYPE_NEEDS_DESTRUCTOR (type
))
3084 if (auto_delete
== integer_zero_node
)
3085 return void_zero_node
;
3087 return build_op_delete_call
3088 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3089 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3093 /* Below, we will reverse the order in which these calls are made.
3094 If we have a destructor, then that destructor will take care
3095 of the base classes; otherwise, we must do that here. */
3096 if (TYPE_HAS_DESTRUCTOR (type
))
3098 tree passed_auto_delete
;
3099 tree do_delete
= NULL_TREE
;
3102 if (use_global_delete
)
3104 tree cond
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3105 auto_delete
, integer_one_node
));
3106 tree call
= build_builtin_delete_call (addr
);
3108 cond
= fold (build (COND_EXPR
, void_type_node
, cond
,
3109 call
, void_zero_node
));
3110 if (cond
!= void_zero_node
)
3113 passed_auto_delete
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3114 auto_delete
, integer_two_node
));
3117 passed_auto_delete
= auto_delete
;
3119 expr
= build_method_call
3120 (ref
, dtor_identifier
, build_expr_list (NULL_TREE
, passed_auto_delete
),
3124 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3126 if (flags
& LOOKUP_DESTRUCTOR
)
3127 /* Explicit destructor call; don't check for null pointer. */
3128 ifexp
= integer_one_node
;
3130 /* Handle deleting a null pointer. */
3131 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
, 1));
3133 if (ifexp
!= integer_one_node
)
3134 expr
= build (COND_EXPR
, void_type_node
,
3135 ifexp
, expr
, void_zero_node
);
3141 /* We only get here from finish_function for a destructor. */
3142 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3143 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3144 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3145 tree exprstmt
= NULL_TREE
;
3146 tree parent_auto_delete
= auto_delete
;
3149 /* If we have member delete or vbases, we call delete in
3151 if (auto_delete
== integer_zero_node
)
3153 else if (base_binfo
== NULL_TREE
3154 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3156 cond
= build (COND_EXPR
, void_type_node
,
3157 build (BIT_AND_EXPR
, integer_type_node
, auto_delete
, integer_one_node
),
3158 build_builtin_delete_call (addr
),
3165 exprstmt
= build_expr_list (NULL_TREE
, cond
);
3168 && ! TREE_VIA_VIRTUAL (base_binfo
)
3169 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3171 tree this_auto_delete
;
3173 if (BINFO_OFFSET_ZEROP (base_binfo
))
3174 this_auto_delete
= parent_auto_delete
;
3176 this_auto_delete
= integer_zero_node
;
3178 expr
= build_scoped_method_call
3179 (ref
, base_binfo
, dtor_identifier
,
3180 build_expr_list (NULL_TREE
, this_auto_delete
));
3181 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3184 /* Take care of the remaining baseclasses. */
3185 for (i
= 1; i
< n_baseclasses
; i
++)
3187 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3188 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3189 || TREE_VIA_VIRTUAL (base_binfo
))
3192 expr
= build_scoped_method_call
3193 (ref
, base_binfo
, dtor_identifier
,
3194 build_expr_list (NULL_TREE
, integer_zero_node
));
3196 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3199 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3201 if (TREE_CODE (member
) != FIELD_DECL
)
3203 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member
)))
3205 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3206 tree this_type
= TREE_TYPE (member
);
3207 expr
= build_delete (this_type
, this_member
, integer_two_node
, flags
, 0);
3208 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3213 return build_compound_expr (exprstmt
);
3214 /* Virtual base classes make this function do nothing. */
3215 return void_zero_node
;
3219 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3222 build_vbase_delete (type
, decl
)
3225 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3226 tree result
= NULL_TREE
;
3227 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3229 my_friendly_assert (addr
!= error_mark_node
, 222);
3233 tree this_addr
= convert_force (build_pointer_type (BINFO_TYPE (vbases
)),
3235 result
= expr_tree_cons (NULL_TREE
,
3236 build_delete (TREE_TYPE (this_addr
), this_addr
,
3238 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3240 vbases
= TREE_CHAIN (vbases
);
3242 return build_compound_expr (nreverse (result
));
3245 /* Build a C++ vector delete expression.
3246 MAXINDEX is the number of elements to be deleted.
3247 ELT_SIZE is the nominal size of each element in the vector.
3248 BASE is the expression that should yield the store to be deleted.
3249 This function expands (or synthesizes) these calls itself.
3250 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3251 AUTO_DELETE say whether each item in the container should be deallocated.
3253 This also calls delete for virtual baseclasses of elements of the vector.
3255 Update: MAXINDEX is no longer needed. The size can be extracted from the
3256 start of the vector for pointers, and from the type for arrays. We still
3257 use MAXINDEX for arrays because it happens to already have one of the
3258 values we'd have to extract. (We could use MAXINDEX with pointers to
3259 confirm the size, and trap if the numbers differ; not clear that it'd
3260 be worth bothering.) */
3263 build_vec_delete (base
, maxindex
, auto_delete_vec
, auto_delete
,
3265 tree base
, maxindex
;
3266 tree auto_delete_vec
, auto_delete
;
3267 int use_global_delete
;
3271 if (TREE_CODE (base
) == OFFSET_REF
)
3272 base
= resolve_offset_ref (base
);
3274 type
= TREE_TYPE (base
);
3276 base
= stabilize_reference (base
);
3278 /* Since we can use base many times, save_expr it. */
3279 if (TREE_SIDE_EFFECTS (base
))
3280 base
= save_expr (base
);
3282 if (TREE_CODE (type
) == POINTER_TYPE
)
3284 /* Step back one from start of vector, and read dimension. */
3285 tree cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3286 base
, BI_header_size
);
3287 tree cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3288 maxindex
= build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0);
3290 type
= TREE_TYPE (type
);
3291 while (TREE_CODE (type
) == ARRAY_TYPE
);
3293 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3295 /* get the total number of things in the array, maxindex is a bad name */
3296 maxindex
= array_type_nelts_total (type
);
3297 while (TREE_CODE (type
) == ARRAY_TYPE
)
3298 type
= TREE_TYPE (type
);
3299 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3303 if (base
!= error_mark_node
)
3304 error ("type to vector delete is neither pointer or array type");
3305 return error_mark_node
;
3308 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,