1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* High-level class interface. */
37 static void expand_aggr_vbase_init_1
PARAMS ((tree
, tree
, tree
, tree
));
38 static void construct_virtual_bases
PARAMS ((tree
, tree
, tree
, tree
, tree
));
39 static void expand_aggr_init_1
PARAMS ((tree
, tree
, tree
, tree
, int));
40 static void expand_default_init
PARAMS ((tree
, tree
, tree
, tree
, int));
41 static tree build_vec_delete_1
PARAMS ((tree
, tree
, tree
, special_function_kind
, int));
42 static void perform_member_init
PARAMS ((tree
, tree
, int));
43 static void sort_base_init
PARAMS ((tree
, tree
*, tree
*));
44 static tree build_builtin_delete_call
PARAMS ((tree
));
45 static int member_init_ok_or_else
PARAMS ((tree
, tree
, const char *));
46 static void expand_virtual_init
PARAMS ((tree
, tree
));
47 static tree sort_member_init
PARAMS ((tree
));
48 static tree initializing_context
PARAMS ((tree
));
49 static void expand_cleanup_for_base
PARAMS ((tree
, tree
));
50 static tree get_temp_regvar
PARAMS ((tree
, tree
));
51 static tree dfs_initialize_vtbl_ptrs
PARAMS ((tree
, void *));
52 static tree build_new_1
PARAMS ((tree
));
53 static tree get_cookie_size
PARAMS ((tree
));
54 static tree build_dtor_call
PARAMS ((tree
, special_function_kind
, int));
55 static tree build_field_list
PARAMS ((tree
, tree
, int *));
56 static tree build_vtbl_address
PARAMS ((tree
));
58 /* Set up local variable for this file. MUST BE CALLED AFTER
59 INIT_DECL_PROCESSING. */
61 static tree BI_header_type
, BI_header_size
;
63 void init_init_processing ()
67 minus_one_node
= build_int_2 (-1, -1);
69 /* Define the structure that holds header information for
70 arrays allocated via operator new. */
71 BI_header_type
= make_aggr_type (RECORD_TYPE
);
72 fields
[0] = build_decl (FIELD_DECL
, nelts_identifier
, sizetype
);
74 /* Use the biggest alignment supported by the target to prevent operator
75 new from returning misaligned pointers. */
76 TYPE_ALIGN (BI_header_type
) = BIGGEST_ALIGNMENT
;
77 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
79 BI_header_size
= size_in_bytes (BI_header_type
);
81 ggc_add_tree_root (&BI_header_type
, 1);
82 ggc_add_tree_root (&BI_header_size
, 1);
85 /* We are about to generate some complex initialization code.
86 Conceptually, it is all a single expression. However, we may want
87 to include conditionals, loops, and other such statement-level
88 constructs. Therefore, we build the initialization code inside a
89 statement-expression. This function starts such an expression.
90 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
91 pass them back to finish_init_stmts when the expression is
95 begin_init_stmts (stmt_expr_p
, compound_stmt_p
)
97 tree
*compound_stmt_p
;
99 *stmt_expr_p
= begin_stmt_expr ();
100 *compound_stmt_p
= begin_compound_stmt (/*has_no_scope=*/1);
103 /* Finish out the statement-expression begun by the previous call to
104 begin_init_stmts. Returns the statement-expression itself. */
107 finish_init_stmts (stmt_expr
, compound_stmt
)
111 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
112 stmt_expr
= finish_stmt_expr (stmt_expr
);
114 /* To avoid spurious warnings about unused values, we set
117 TREE_USED (stmt_expr
) = 1;
124 /* Called from initialize_vtbl_ptrs via dfs_walk. */
127 dfs_initialize_vtbl_ptrs (binfo
, data
)
131 if (!BINFO_PRIMARY_MARKED_P (binfo
)
132 && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo
)))
134 tree base_ptr
= TREE_VALUE ((tree
) data
);
136 if (TREE_VIA_VIRTUAL (binfo
))
137 base_ptr
= convert_pointer_to_vbase (BINFO_TYPE (binfo
),
141 = build_vbase_path (PLUS_EXPR
,
142 build_pointer_type (BINFO_TYPE (binfo
)),
147 expand_virtual_init (binfo
, base_ptr
);
150 SET_BINFO_MARKED (binfo
);
155 /* Initialize all the vtable pointers in the object pointed to by
159 initialize_vtbl_ptrs (addr
)
165 type
= TREE_TYPE (TREE_TYPE (addr
));
166 list
= build_tree_list (type
, addr
);
168 /* Walk through the hierarchy, initializing the vptr in each base
169 class. We do these in pre-order because under the new ABI we
170 can't find the virtual bases for a class until we've initialized
171 the vtbl for that class. */
172 dfs_walk_real (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
,
173 NULL
, dfs_unmarked_real_bases_queue_p
, list
);
174 dfs_walk (TYPE_BINFO (type
), dfs_unmark
,
175 dfs_marked_real_bases_queue_p
, type
);
177 /* If we're not using thunks, we may need to adjust the deltas in
178 the vtable to handle virtual base classes correctly. When we are
179 using thunks, we either use construction vtables (which are
180 preloaded with the right answers) or nothing (in which case
181 vitual function calls sometimes don't work right.) */
182 if (TYPE_USES_VIRTUAL_BASECLASSES (type
) && !flag_vtable_thunks
)
183 fixup_all_virtual_upcast_offsets (addr
);
186 /* Subroutine of emit_base_init. */
189 perform_member_init (member
, init
, explicit)
194 tree type
= TREE_TYPE (member
);
196 decl
= build_component_ref (current_class_ref
, member
, NULL_TREE
, explicit);
198 if (decl
== error_mark_node
)
201 /* Deal with this here, as we will get confused if we try to call the
202 assignment op for an anonymous union. This can happen in a
203 synthesized copy constructor. */
204 if (ANON_AGGR_TYPE_P (type
))
208 init
= build (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
209 finish_expr_stmt (init
);
212 else if (TYPE_NEEDS_CONSTRUCTING (type
)
213 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
215 /* Since `init' is already a TREE_LIST on the current_member_init_list,
216 only build it into one if we aren't already a list. */
217 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
218 init
= build_tree_list (NULL_TREE
, init
);
221 && TREE_CODE (type
) == ARRAY_TYPE
223 && TREE_CHAIN (init
) == NULL_TREE
224 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
226 /* Initialization of one array from another. */
228 (build_vec_init (TREE_OPERAND (decl
, 1), decl
,
229 array_type_nelts (type
), TREE_VALUE (init
), 1));
232 finish_expr_stmt (build_aggr_init (decl
, init
, 0));
236 if (init
== NULL_TREE
)
240 /* default-initialization. */
241 if (AGGREGATE_TYPE_P (type
))
243 /* This is a default initialization of an aggregate,
244 but not one of non-POD class type. We cleverly
245 notice that the initialization rules in such a
246 case are the same as for initialization with an
247 empty brace-initialization list. We don't want
248 to call build_modify_expr as that will go looking
249 for constructors and such. */
250 tree e
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
251 TREE_SIDE_EFFECTS (e
) = 1;
252 finish_expr_stmt (build (INIT_EXPR
, type
, decl
, e
));
254 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
255 cp_error ("default-initialization of `%#D', which has reference type",
258 init
= integer_zero_node
;
260 /* member traversal: note it leaves init NULL */
261 else if (TREE_CODE (TREE_TYPE (member
)) == REFERENCE_TYPE
)
262 cp_pedwarn ("uninitialized reference member `%D'", member
);
264 else if (TREE_CODE (init
) == TREE_LIST
)
266 /* There was an explicit member initialization. Do some
267 work in that case. */
268 if (TREE_CHAIN (init
))
270 warning ("initializer list treated as compound expression");
271 init
= build_compound_expr (init
);
274 init
= TREE_VALUE (init
);
278 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
281 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
285 expr
= build_component_ref (current_class_ref
, member
, NULL_TREE
,
287 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
288 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
290 if (expr
!= error_mark_node
)
291 finish_subobject (expr
);
295 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
296 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
299 build_field_list (t
, list
, uses_unions_p
)
306 /* Note whether or not T is a union. */
307 if (TREE_CODE (t
) == UNION_TYPE
)
310 for (fields
= TYPE_FIELDS (t
); fields
; fields
= TREE_CHAIN (fields
))
312 /* Skip CONST_DECLs for enumeration constants and so forth. */
313 if (TREE_CODE (fields
) != FIELD_DECL
)
316 /* Keep track of whether or not any fields are unions. */
317 if (TREE_CODE (TREE_TYPE (fields
)) == UNION_TYPE
)
320 /* For an anonymous struct or union, we must recursively
321 consider the fields of the anonymous type. They can be
322 directly initialized from the constructor. */
323 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
325 /* Add this field itself. Synthesized copy constructors
326 initialize the entire aggregate. */
327 list
= tree_cons (fields
, NULL_TREE
, list
);
328 /* And now add the fields in the anonymous aggregate. */
329 list
= build_field_list (TREE_TYPE (fields
), list
,
332 /* Add this field. */
333 else if (DECL_NAME (fields
))
334 list
= tree_cons (fields
, NULL_TREE
, list
);
340 /* Subroutine of emit_member_init. */
351 /* Build up a list of the various fields, in sorted order. */
352 init_list
= nreverse (build_field_list (t
, NULL_TREE
, &uses_unions_p
));
354 /* Go through the explicit initializers, adding them to the
356 last_field
= init_list
;
357 for (init
= current_member_init_list
; init
; init
= TREE_CHAIN (init
))
360 tree initialized_field
;
362 initialized_field
= TREE_PURPOSE (init
);
363 my_friendly_assert (TREE_CODE (initialized_field
) == FIELD_DECL
,
366 /* If the explicit initializers are in sorted order, then the
367 INITIALIZED_FIELD will be for a field following the
369 for (f
= last_field
; f
; f
= TREE_CHAIN (f
))
370 if (TREE_PURPOSE (f
) == initialized_field
)
373 /* Give a warning, if appropriate. */
374 if (warn_reorder
&& !f
)
376 cp_warning_at ("member initializers for `%#D'",
377 TREE_PURPOSE (last_field
));
378 cp_warning_at (" and `%#D'", initialized_field
);
379 warning (" will be re-ordered to match declaration order");
382 /* Look again, from the beginning of the list. We must find the
383 field on this loop. */
387 while (TREE_PURPOSE (f
) != initialized_field
)
391 /* If there was already an explicit initializer for this field,
394 cp_error ("multiple initializations given for member `%D'",
398 /* Mark the field as explicitly initialized. */
399 TREE_TYPE (f
) = error_mark_node
;
400 /* And insert the initializer. */
401 TREE_VALUE (f
) = TREE_VALUE (init
);
404 /* Remember the location of the last explicitly initialized
411 If a ctor-initializer specifies more than one mem-initializer for
412 multiple members of the same union (including members of
413 anonymous unions), the ctor-initializer is ill-formed. */
416 last_field
= NULL_TREE
;
417 for (init
= init_list
; init
; init
= TREE_CHAIN (init
))
423 /* Skip uninitialized members. */
424 if (!TREE_TYPE (init
))
426 /* See if this field is a member of a union, or a member of a
427 structure contained in a union, etc. */
428 field
= TREE_PURPOSE (init
);
429 for (field_type
= DECL_CONTEXT (field
);
430 !same_type_p (field_type
, t
);
431 field_type
= TYPE_CONTEXT (field_type
))
432 if (TREE_CODE (field_type
) == UNION_TYPE
)
434 /* If this field is not a member of a union, skip it. */
435 if (TREE_CODE (field_type
) != UNION_TYPE
)
438 /* It's only an error if we have two initializers for the same
446 /* See if LAST_FIELD and the field initialized by INIT are
447 members of the same union. If so, there's a problem,
448 unless they're actually members of the same structure
449 which is itself a member of a union. For example, given:
451 union { struct { int i; int j; }; };
453 initializing both `i' and `j' makes sense. */
454 field_type
= DECL_CONTEXT (field
);
458 tree last_field_type
;
460 last_field_type
= DECL_CONTEXT (last_field
);
463 if (same_type_p (last_field_type
, field_type
))
465 if (TREE_CODE (field_type
) == UNION_TYPE
)
466 cp_error ("initializations for multiple members of `%T'",
472 if (same_type_p (last_field_type
, t
))
475 last_field_type
= TYPE_CONTEXT (last_field_type
);
478 /* If we've reached the outermost class, then we're
480 if (same_type_p (field_type
, t
))
483 field_type
= TYPE_CONTEXT (field_type
);
495 sort_base_init (t
, rbase_ptr
, vbase_ptr
)
496 tree t
, *rbase_ptr
, *vbase_ptr
;
498 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
499 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
505 /* For warn_reorder. */
507 tree last_base
= NULL_TREE
;
509 tree rbases
= NULL_TREE
;
510 tree vbases
= NULL_TREE
;
512 /* First walk through and splice out vbase and invalid initializers.
513 Also replace names with binfos. */
515 last
= tree_cons (NULL_TREE
, NULL_TREE
, current_base_init_list
);
516 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
518 tree basetype
= TREE_PURPOSE (x
);
519 tree binfo
= NULL_TREE
;
521 if (basetype
== NULL_TREE
)
523 /* Initializer for single base class. Must not
524 use multiple inheritance or this is ambiguous. */
525 switch (n_baseclasses
)
528 cp_error ("`%T' does not have a base class to initialize",
534 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
538 binfo
= TREE_VEC_ELT (binfos
, 0);
540 else if (is_aggr_type (basetype
, 1))
542 binfo
= binfo_or_else (basetype
, t
);
543 if (binfo
== NULL_TREE
)
546 /* Virtual base classes are special cases. Their initializers
547 are recorded with this constructor, and they are used when
548 this constructor is the top-level constructor called. */
549 if (TREE_VIA_VIRTUAL (binfo
))
551 tree v
= binfo_for_vbase (BINFO_TYPE (binfo
), t
);
552 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
557 /* Otherwise, if it is not an immediate base class, complain. */
558 for (i
= n_baseclasses
-1; i
>= 0; i
--)
559 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
563 cp_error ("`%T' is not an immediate base class of `%T'",
564 basetype
, current_class_type
);
570 my_friendly_abort (365);
572 TREE_PURPOSE (x
) = binfo
;
573 TREE_CHAIN (last
) = x
;
576 TREE_CHAIN (last
) = NULL_TREE
;
578 /* Now walk through our regular bases and make sure they're initialized. */
580 for (i
= 0; i
< n_baseclasses
; ++i
)
582 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
585 if (TREE_VIA_VIRTUAL (base_binfo
))
588 for (x
= current_base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
590 tree binfo
= TREE_PURPOSE (x
);
592 if (binfo
== NULL_TREE
)
595 if (binfo
== base_binfo
)
601 cp_warning_at ("base initializers for `%#T'", last_base
);
602 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
603 warning (" will be re-ordered to match inheritance order");
606 last_base
= BINFO_TYPE (binfo
);
609 /* Make sure we won't try to work on this init again. */
610 TREE_PURPOSE (x
) = NULL_TREE
;
611 x
= build_tree_list (binfo
, TREE_VALUE (x
));
616 /* If we didn't find BASE_BINFO in the list, create a dummy entry
617 so the two lists (RBASES and the list of bases) will be
619 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
621 rbases
= chainon (rbases
, x
);
628 /* Perform whatever initializations have yet to be done on the base
629 class of the class variable. These actions are in the global
630 variable CURRENT_BASE_INIT_LIST. Such an action could be
631 NULL_TREE, meaning that the user has explicitly called the base
632 class constructor with no arguments.
634 If there is a need for a call to a constructor, we must surround
635 that call with a pushlevel/poplevel pair, since we are technically
636 at the PARM level of scope.
638 Note that emit_base_init does *not* initialize virtual base
639 classes. That is done specially, elsewhere. */
646 tree rbase_init_list
, vbase_init_list
;
647 tree t
= current_class_type
;
648 tree t_binfo
= TYPE_BINFO (t
);
649 tree binfos
= BINFO_BASETYPES (t_binfo
);
651 int n_baseclasses
= BINFO_N_BASETYPES (t_binfo
);
653 mem_init_list
= sort_member_init (t
);
654 current_member_init_list
= NULL_TREE
;
656 sort_base_init (t
, &rbase_init_list
, &vbase_init_list
);
657 current_base_init_list
= NULL_TREE
;
659 /* First, initialize the virtual base classes, if we are
660 constructing the most-derived object. */
661 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
663 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
664 construct_virtual_bases (t
, current_class_ref
, current_class_ptr
,
665 vbase_init_list
, first_arg
);
668 /* Now, perform initialization of non-virtual base classes. */
669 for (i
= 0; i
< n_baseclasses
; i
++)
671 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
672 tree init
= void_list_node
;
674 if (TREE_VIA_VIRTUAL (base_binfo
))
677 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
,
680 if (TREE_PURPOSE (rbase_init_list
))
681 init
= TREE_VALUE (rbase_init_list
);
682 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
686 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
))
687 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
688 BINFO_TYPE (base_binfo
));
691 if (init
!= void_list_node
)
693 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
694 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
695 build_indirect_ref (member
, NULL_PTR
), init
,
699 expand_cleanup_for_base (base_binfo
, NULL_TREE
);
700 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
703 /* Initialize the vtable pointers for the class. */
704 initialize_vtbl_ptrs (current_class_ptr
);
706 while (mem_init_list
)
712 member
= TREE_PURPOSE (mem_init_list
);
714 /* See if we had a user-specified member initialization. */
715 if (TREE_TYPE (mem_init_list
))
717 init
= TREE_VALUE (mem_init_list
);
722 init
= DECL_INITIAL (member
);
725 /* Effective C++ rule 12. */
726 if (warn_ecpp
&& init
== NULL_TREE
727 && !DECL_ARTIFICIAL (member
)
728 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
729 cp_warning ("`%D' should be initialized in the member initialization list", member
);
732 perform_member_init (member
, init
, from_init_list
);
733 mem_init_list
= TREE_CHAIN (mem_init_list
);
737 /* Returns the address of the vtable (i.e., the value that should be
738 assigned to the vptr) for BINFO. */
741 build_vtbl_address (binfo
)
746 /* Figure out what vtable BINFO's vtable is based on, and mark it as
748 vtbl
= get_vtbl_decl_for_binfo (binfo
);
749 assemble_external (vtbl
);
750 TREE_USED (vtbl
) = 1;
752 /* Now compute the address to use when initializing the vptr. */
753 vtbl
= BINFO_VTABLE (binfo
);
754 if (TREE_CODE (vtbl
) == VAR_DECL
)
756 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
757 TREE_CONSTANT (vtbl
) = 1;
763 /* This code sets up the virtual function tables appropriate for
764 the pointer DECL. It is a one-ply initialization.
766 BINFO is the exact type that DECL is supposed to be. In
767 multiple inheritance, this might mean "C's A" if C : A, B. */
770 expand_virtual_init (binfo
, decl
)
773 tree type
= BINFO_TYPE (binfo
);
775 tree vtype
, vtype_binfo
;
778 /* Compute the location of the vtable. */
779 vtype
= DECL_CONTEXT (TYPE_VFIELD (type
));
780 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
782 /* Compute the initializer for vptr. */
783 vtbl
= build_vtbl_address (binfo
);
785 /* Under the new ABI, we may get this vptr from a VTT, if this is a
786 subobject constructor or subobject destructor. */
787 vtt_index
= BINFO_VPTR_INDEX (binfo
);
793 /* Compute the value to use, when there's a VTT. */
794 vtt_parm
= DECL_VTT_PARM (current_function_decl
);
795 vtbl2
= build (PLUS_EXPR
,
796 TREE_TYPE (vtt_parm
),
799 vtbl2
= build1 (INDIRECT_REF
, TREE_TYPE (vtbl
), vtbl2
);
801 /* The actual initializer is the VTT value only in the subobject
802 constructor. In maybe_clone_body we'll substitute NULL for
803 the vtt_parm in the case of the non-subobject constructor. */
804 vtbl
= build (COND_EXPR
,
806 DECL_USE_VTT_PARM (current_function_decl
),
811 /* Compute the location of the vtpr. */
812 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
813 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
814 if (vtbl_ptr
== error_mark_node
)
817 /* Assign the vtable to the vptr. */
818 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
819 finish_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
822 /* If an exception is thrown in a constructor, those base classes already
823 constructed must be destroyed. This function creates the cleanup
824 for BINFO, which has just been constructed. If FLAG is non-NULL,
825 it is a DECL which is non-zero when this base needs to be
829 expand_cleanup_for_base (binfo
, flag
)
835 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
838 /* Call the destructor. */
839 expr
= (build_scoped_method_call
840 (current_class_ref
, binfo
, base_dtor_identifier
, NULL_TREE
));
842 expr
= fold (build (COND_EXPR
, void_type_node
,
843 truthvalue_conversion (flag
),
844 expr
, integer_zero_node
));
846 finish_subobject (expr
);
849 /* Subroutine of `expand_aggr_vbase_init'.
850 BINFO is the binfo of the type that is being initialized.
851 INIT_LIST is the list of initializers for the virtual baseclass. */
854 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
855 tree binfo
, exp
, addr
, init_list
;
857 tree init
= purpose_member (binfo
, init_list
);
858 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
861 init
= TREE_VALUE (init
);
862 /* Call constructors, but don't set up vtables. */
863 expand_aggr_init_1 (binfo
, exp
, ref
, init
, LOOKUP_COMPLAIN
);
866 /* Construct the virtual base-classes of THIS_REF (whose address is
867 THIS_PTR). The object has the indicated TYPE. The construction
868 actually takes place only if FLAG is non-zero. INIT_LIST is list
869 of initializations for constructors to perform. */
872 construct_virtual_bases (type
, this_ref
, this_ptr
, init_list
, flag
)
881 /* If there are no virtual baseclasses, we shouldn't even be here. */
882 my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type
), 19990621);
884 /* First set the pointers in our object that tell us where to find
885 our virtual baseclasses. */
886 if (!vbase_offsets_in_vtable_p ())
891 if_stmt
= begin_if_stmt ();
892 finish_if_stmt_cond (flag
, if_stmt
);
893 result
= init_vbase_pointers (type
, this_ptr
);
895 finish_expr_stmt (build_compound_expr (result
));
896 finish_then_clause (if_stmt
);
900 /* Now, run through the baseclasses, initializing each. */
901 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
902 vbases
= TREE_CHAIN (vbases
))
909 /* If there are virtual base classes with destructors, we need to
910 emit cleanups to destroy them if an exception is thrown during
911 the construction process. These exception regions (i.e., the
912 period during which the cleanups must occur) begin from the time
913 the construction is complete to the end of the function. If we
914 create a conditional block in which to initialize the
915 base-classes, then the cleanup region for the virtual base begins
916 inside a block, and ends outside of that block. This situation
917 confuses the sjlj exception-handling code. Therefore, we do not
918 create a single conditional block, but one for each
919 initialization. (That way the cleanup regions always begin
920 in the outer block.) We trust the back-end to figure out
921 that the FLAG will not change across initializations, and
922 avoid doing multiple tests. */
923 inner_if_stmt
= begin_if_stmt ();
924 finish_if_stmt_cond (flag
, inner_if_stmt
);
925 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/1);
927 /* Compute the location of the virtual base. If we're
928 constructing virtual bases, then we must be the most derived
929 class. Therefore, we don't have to look up the virtual base;
930 we already know where it is. */
931 vbase
= TREE_VALUE (vbases
);
932 exp
= build (PLUS_EXPR
,
933 TREE_TYPE (this_ptr
),
935 fold (build1 (NOP_EXPR
, TREE_TYPE (this_ptr
),
936 BINFO_OFFSET (vbase
))));
937 exp
= build1 (NOP_EXPR
,
938 build_pointer_type (BINFO_TYPE (vbase
)),
941 expand_aggr_vbase_init_1 (vbase
, this_ref
, exp
, init_list
);
942 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
943 finish_then_clause (inner_if_stmt
);
946 expand_cleanup_for_base (vbase
, flag
);
950 /* Find the context in which this FIELD can be initialized. */
953 initializing_context (field
)
956 tree t
= DECL_CONTEXT (field
);
958 /* Anonymous union members can be initialized in the first enclosing
959 non-anonymous union context. */
960 while (t
&& ANON_AGGR_TYPE_P (t
))
961 t
= TYPE_CONTEXT (t
);
965 /* Function to give error message if member initialization specification
966 is erroneous. FIELD is the member we decided to initialize.
967 TYPE is the type for which the initialization is being performed.
968 FIELD must be a member of TYPE.
970 MEMBER_NAME is the name of the member. */
973 member_init_ok_or_else (field
, type
, member_name
)
976 const char *member_name
;
978 if (field
== error_mark_node
)
980 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
982 cp_error ("class `%T' does not have any field named `%s'", type
,
986 if (TREE_STATIC (field
))
988 cp_error ("field `%#D' is static; only point of initialization is its declaration",
996 /* If NAME is a viable field name for the aggregate DECL,
997 and PARMS is a viable parameter list, then expand an _EXPR
998 which describes this initialization.
1000 Note that we do not need to chase through the class's base classes
1001 to look for NAME, because if it's in that list, it will be handled
1002 by the constructor for that base class.
1004 We do not yet have a fixed-point finder to instantiate types
1005 being fed to overloaded constructors. If there is a unique
1006 constructor, then argument types can be got from that one.
1008 If INIT is non-NULL, then it the initialization should
1009 be placed in `current_base_init_list', where it will be processed
1010 by `emit_base_init'. */
1013 expand_member_init (exp
, name
, init
)
1014 tree exp
, name
, init
;
1016 tree basetype
= NULL_TREE
, field
;
1019 if (exp
== NULL_TREE
)
1020 return; /* complain about this later */
1022 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
1024 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
1026 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1027 name
= DECL_NAME (name
);
1030 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
1031 switch (CLASSTYPE_N_BASECLASSES (type
))
1034 error ("base class initializer specified, but no base class to initialize");
1037 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
1040 error ("initializer for unnamed base class ambiguous");
1041 cp_error ("(type `%T' uses multiple inheritance)", type
);
1045 my_friendly_assert (init
!= NULL_TREE
, 0);
1047 /* The grammar should not allow fields which have names that are
1048 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
1049 may assume that this is an attempt to initialize a base class
1050 member of the current type. Otherwise, it is an attempt to
1051 initialize a member field. */
1053 if (init
== void_type_node
)
1056 if (name
== NULL_TREE
|| basetype
)
1060 if (name
== NULL_TREE
)
1064 name
= TYPE_IDENTIFIER (basetype
);
1067 error ("no base class to initialize");
1072 else if (basetype
!= type
1073 && ! current_template_parms
1074 && ! vec_binfo_member (basetype
,
1075 TYPE_BINFO_BASETYPES (type
))
1076 && ! binfo_for_vbase (basetype
, type
))
1078 if (IDENTIFIER_CLASS_VALUE (name
))
1080 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1081 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
1084 cp_error ("type `%T' is not an immediate basetype for `%T'",
1089 if (purpose_member (basetype
, current_base_init_list
))
1091 cp_error ("base class `%T' already initialized", basetype
);
1095 if (warn_reorder
&& current_member_init_list
)
1097 cp_warning ("base initializer for `%T'", basetype
);
1098 warning (" will be re-ordered to precede member initializations");
1101 base_init
= build_tree_list (basetype
, init
);
1102 current_base_init_list
= chainon (current_base_init_list
, base_init
);
1109 field
= lookup_field (type
, name
, 1, 0);
1111 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
1114 if (purpose_member (name
, current_member_init_list
))
1116 cp_error ("field `%D' already initialized", field
);
1120 member_init
= build_tree_list (field
, init
);
1121 current_member_init_list
= chainon (current_member_init_list
, member_init
);
1125 /* This is like `expand_member_init', only it stores one aggregate
1128 INIT comes in two flavors: it is either a value which
1129 is to be stored in EXP, or it is a parameter list
1130 to go to a constructor, which will operate on EXP.
1131 If INIT is not a parameter list for a constructor, then set
1132 LOOKUP_ONLYCONVERTING.
1133 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1134 the initializer, if FLAGS is 0, then it is the (init) form.
1135 If `init' is a CONSTRUCTOR, then we emit a warning message,
1136 explaining that such initializations are invalid.
1138 If INIT resolves to a CALL_EXPR which happens to return
1139 something of the type we are looking for, then we know
1140 that we can safely use that call to perform the
1143 The virtual function table pointer cannot be set up here, because
1144 we do not really know its type.
1146 Virtual baseclass pointers are also set up here.
1148 This never calls operator=().
1150 When initializing, nothing is CONST.
1152 A default copy constructor may have to be used to perform the
1155 A constructor or a conversion operator may have to be used to
1156 perform the initialization, but not both, as it would be ambiguous. */
1159 build_aggr_init (exp
, init
, flags
)
1166 tree type
= TREE_TYPE (exp
);
1167 int was_const
= TREE_READONLY (exp
);
1168 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1170 if (init
== error_mark_node
)
1171 return error_mark_node
;
1173 TREE_READONLY (exp
) = 0;
1174 TREE_THIS_VOLATILE (exp
) = 0;
1176 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1177 flags
|= LOOKUP_ONLYCONVERTING
;
1179 if (TREE_CODE (type
) == ARRAY_TYPE
)
1181 /* Must arrange to initialize each element of EXP
1182 from elements of INIT. */
1183 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1184 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
1186 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1188 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1190 if (init
&& TREE_TYPE (init
) == NULL_TREE
)
1192 /* Handle bad initializers like:
1196 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1200 int main(int argc, char **argv) {
1201 COMPLEX zees(1.0, 0.0)[10];
1204 error ("bad array initializer");
1205 return error_mark_node
;
1207 stmt_expr
= build_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1208 init
&& same_type_p (TREE_TYPE (init
),
1210 TREE_READONLY (exp
) = was_const
;
1211 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1212 TREE_TYPE (exp
) = type
;
1214 TREE_TYPE (init
) = itype
;
1218 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1219 /* just know that we've seen something for this node */
1220 TREE_USED (exp
) = 1;
1222 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1223 begin_init_stmts (&stmt_expr
, &compound_stmt
);
1224 destroy_temps
= stmts_are_full_exprs_p
;
1225 stmts_are_full_exprs_p
= 0;
1226 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1227 init
, LOOKUP_NORMAL
|flags
);
1228 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
1229 stmts_are_full_exprs_p
= destroy_temps
;
1230 TREE_TYPE (exp
) = type
;
1231 TREE_READONLY (exp
) = was_const
;
1232 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1238 expand_default_init (binfo
, true_exp
, exp
, init
, flags
)
1244 tree type
= TREE_TYPE (exp
);
1247 /* It fails because there may not be a constructor which takes
1248 its own type as the first (or only parameter), but which does
1249 take other types via a conversion. So, if the thing initializing
1250 the expression is a unit element of type X, first try X(X&),
1251 followed by initialization by X. If neither of these work
1252 out, then look hard. */
1256 if (init
&& TREE_CODE (init
) != TREE_LIST
1257 && (flags
& LOOKUP_ONLYCONVERTING
))
1259 /* Base subobjects should only get direct-initialization. */
1260 if (true_exp
!= exp
)
1263 if (flags
& DIRECT_BIND
)
1264 /* Do nothing. We hit this in two cases: Reference initialization,
1265 where we aren't initializing a real variable, so we don't want
1266 to run a new constructor; and catching an exception, where we
1267 have already built up the constructor call so we could wrap it
1268 in an exception region. */;
1269 else if (TREE_CODE (init
) == CONSTRUCTOR
)
1270 /* A brace-enclosed initializer has whatever type is
1271 required. There's no need to convert it. */
1274 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1276 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1277 /* We need to protect the initialization of a catch parm
1278 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1279 around the TARGET_EXPR for the copy constructor. See
1280 expand_start_catch_block. */
1281 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1282 TREE_OPERAND (init
, 0));
1284 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1285 TREE_SIDE_EFFECTS (init
) = 1;
1286 finish_expr_stmt (init
);
1290 if (init
== NULL_TREE
1291 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1295 init
= TREE_VALUE (parms
);
1298 parms
= build_tree_list (NULL_TREE
, init
);
1300 if (true_exp
== exp
)
1301 ctor_name
= complete_ctor_identifier
;
1303 ctor_name
= base_ctor_identifier
;
1305 rval
= build_method_call (exp
, ctor_name
, parms
, binfo
, flags
);
1306 if (TREE_SIDE_EFFECTS (rval
))
1307 finish_expr_stmt (rval
);
1310 /* This function is responsible for initializing EXP with INIT
1313 BINFO is the binfo of the type for who we are performing the
1314 initialization. For example, if W is a virtual base class of A and B,
1316 If we are initializing B, then W must contain B's W vtable, whereas
1317 were we initializing C, W must contain C's W vtable.
1319 TRUE_EXP is nonzero if it is the true expression being initialized.
1320 In this case, it may be EXP, or may just contain EXP. The reason we
1321 need this is because if EXP is a base element of TRUE_EXP, we
1322 don't necessarily know by looking at EXP where its virtual
1323 baseclass fields should really be pointing. But we do know
1324 from TRUE_EXP. In constructors, we don't know anything about
1325 the value being initialized.
1327 FLAGS is just passes to `build_method_call'. See that function for
1331 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, flags
)
1337 tree type
= TREE_TYPE (exp
);
1339 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1341 /* Use a function returning the desired type to initialize EXP for us.
1342 If the function is a constructor, and its first argument is
1343 NULL_TREE, know that it was meant for us--just slide exp on
1344 in and expand the constructor. Constructors now come
1347 if (init
&& TREE_CODE (exp
) == VAR_DECL
1348 && TREE_CODE (init
) == CONSTRUCTOR
1349 && TREE_HAS_CONSTRUCTOR (init
))
1351 /* If store_init_value returns NULL_TREE, the INIT has been
1352 record in the DECL_INITIAL for EXP. That means there's
1353 nothing more we have to do. */
1354 if (!store_init_value (exp
, init
))
1356 if (!building_stmt_tree ())
1357 expand_decl_init (exp
);
1360 finish_expr_stmt (build (INIT_EXPR
, type
, exp
, init
));
1364 /* We know that expand_default_init can handle everything we want
1366 expand_default_init (binfo
, true_exp
, exp
, init
, flags
);
1369 /* Report an error if TYPE is not a user-defined, aggregate type. If
1370 OR_ELSE is nonzero, give an error message. */
1373 is_aggr_type (type
, or_else
)
1377 if (type
== error_mark_node
)
1380 if (! IS_AGGR_TYPE (type
)
1381 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1382 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1385 cp_error ("`%T' is not an aggregate type", type
);
1391 /* Like is_aggr_typedef, but returns typedef if successful. */
1394 get_aggr_from_typedef (name
, or_else
)
1400 if (name
== error_mark_node
)
1403 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1404 type
= IDENTIFIER_TYPE_VALUE (name
);
1408 cp_error ("`%T' fails to be an aggregate typedef", name
);
1412 if (! IS_AGGR_TYPE (type
)
1413 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1414 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1417 cp_error ("type `%T' is of non-aggregate type", type
);
1424 get_type_value (name
)
1427 if (name
== error_mark_node
)
1430 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1431 return IDENTIFIER_TYPE_VALUE (name
);
1437 /* This code could just as well go in `class.c', but is placed here for
1440 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1441 the appropriate function call. */
1444 build_member_call (type
, name
, parmlist
)
1445 tree type
, name
, parmlist
;
1450 tree basetype_path
, decl
;
1452 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
1453 && TREE_CODE (type
) == NAMESPACE_DECL
)
1455 /* 'name' already refers to the decls from the namespace, since we
1456 hit do_identifier for template_ids. */
1457 method_name
= TREE_OPERAND (name
, 0);
1458 /* FIXME: Since we don't do independent names right yet, the
1459 name might also be a LOOKUP_EXPR. Once we resolve this to a
1460 real decl earlier, this can go. This may happen during
1462 if (TREE_CODE (method_name
) == LOOKUP_EXPR
)
1464 method_name
= lookup_namespace_name
1465 (type
, TREE_OPERAND (method_name
, 0));
1466 TREE_OPERAND (name
, 0) = method_name
;
1468 my_friendly_assert (is_overloaded_fn (method_name
), 980519);
1469 return build_x_function_call (name
, parmlist
, current_class_ref
);
1472 if (type
== std_node
)
1473 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1475 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1476 return build_x_function_call (lookup_namespace_name (type
, name
),
1477 parmlist
, current_class_ref
);
1479 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1481 method_name
= TREE_OPERAND (name
, 0);
1482 if (TREE_CODE (method_name
) == COMPONENT_REF
)
1483 method_name
= TREE_OPERAND (method_name
, 1);
1484 if (is_overloaded_fn (method_name
))
1485 method_name
= DECL_NAME (OVL_CURRENT (method_name
));
1486 TREE_OPERAND (name
, 0) = method_name
;
1491 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1493 method_name
= TREE_OPERAND (method_name
, 0);
1497 /* This shouldn't be here, and build_member_call shouldn't appear in
1499 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1500 && get_aggr_from_typedef (type
, 0) == 0)
1502 tree ns
= lookup_name (type
, 0);
1503 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1505 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1509 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1510 return error_mark_node
;
1512 /* An operator we did not like. */
1513 if (name
== NULL_TREE
)
1514 return error_mark_node
;
1518 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1520 return error_mark_node
;
1523 decl
= maybe_dummy_object (type
, &basetype_path
);
1525 /* Convert 'this' to the specified type to disambiguate conversion
1526 to the function's context. Apparently Standard C++ says that we
1527 shouldn't do this. */
1528 if (decl
== current_class_ref
1530 && ACCESSIBLY_UNIQUELY_DERIVED_P (type
, current_class_type
))
1532 tree olddecl
= current_class_ptr
;
1533 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1534 if (oldtype
!= type
)
1536 tree newtype
= build_qualified_type (type
, TYPE_QUALS (oldtype
));
1537 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1538 decl
= build_indirect_ref (decl
, NULL_PTR
);
1542 if (method_name
== constructor_name (type
)
1543 || method_name
== constructor_name_full (type
))
1544 return build_functional_cast (type
, parmlist
);
1545 if (lookup_fnfields (basetype_path
, method_name
, 0))
1546 return build_method_call (decl
,
1547 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1548 ? name
: method_name
,
1549 parmlist
, basetype_path
,
1550 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1551 if (TREE_CODE (name
) == IDENTIFIER_NODE
1552 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1554 if (t
== error_mark_node
)
1555 return error_mark_node
;
1556 if (TREE_CODE (t
) == FIELD_DECL
)
1558 if (is_dummy_object (decl
))
1560 cp_error ("invalid use of non-static field `%D'", t
);
1561 return error_mark_node
;
1563 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1565 else if (TREE_CODE (t
) == VAR_DECL
)
1569 cp_error ("invalid use of member `%D'", t
);
1570 return error_mark_node
;
1572 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1573 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1574 parmlist
, NULL_TREE
);
1575 return build_function_call (decl
, parmlist
);
1579 cp_error ("no method `%T::%D'", type
, name
);
1580 return error_mark_node
;
1584 /* Build a reference to a member of an aggregate. This is not a
1585 C++ `&', but really something which can have its address taken,
1586 and then act as a pointer to member, for example TYPE :: FIELD
1587 can have its address taken by saying & TYPE :: FIELD.
1589 @@ Prints out lousy diagnostics for operator <typename>
1592 @@ This function should be rewritten and placed in search.c. */
1595 build_offset_ref (type
, name
)
1598 tree decl
, t
= error_mark_node
;
1600 tree basebinfo
= NULL_TREE
;
1601 tree orig_name
= name
;
1603 /* class templates can come in as TEMPLATE_DECLs here. */
1604 if (TREE_CODE (name
) == TEMPLATE_DECL
)
1607 if (type
== std_node
)
1608 return do_scoped_id (name
, 0);
1610 if (processing_template_decl
|| uses_template_parms (type
))
1611 return build_min_nt (SCOPE_REF
, type
, name
);
1613 /* Handle namespace names fully here. */
1614 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1616 t
= lookup_namespace_name (type
, name
);
1617 if (t
!= error_mark_node
&& ! type_unknown_p (t
))
1620 t
= convert_from_reference (t
);
1625 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1626 return error_mark_node
;
1628 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1630 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1631 something like `a.template f<int>' or the like. For the most
1632 part, we treat this just like a.f. We do remember, however,
1633 the template-id that was used. */
1634 name
= TREE_OPERAND (orig_name
, 0);
1637 name
= DECL_NAME (name
);
1640 if (TREE_CODE (name
) == LOOKUP_EXPR
)
1641 /* This can happen during tsubst'ing. */
1642 name
= TREE_OPERAND (name
, 0);
1645 if (TREE_CODE (name
) == COMPONENT_REF
)
1646 name
= TREE_OPERAND (name
, 1);
1647 if (TREE_CODE (name
) == OVERLOAD
)
1648 name
= DECL_NAME (OVL_CURRENT (name
));
1652 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
1655 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1657 if (! check_dtor_name (type
, name
))
1658 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1659 type
, TREE_OPERAND (name
, 0));
1660 name
= dtor_identifier
;
1663 if (!COMPLETE_TYPE_P (complete_type (type
))
1664 && !TYPE_BEING_DEFINED (type
))
1666 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1668 return error_mark_node
;
1671 decl
= maybe_dummy_object (type
, &basebinfo
);
1673 member
= lookup_member (basebinfo
, name
, 1, 0);
1675 if (member
== error_mark_node
)
1676 return error_mark_node
;
1678 /* A lot of this logic is now handled in lookup_member. */
1679 if (member
&& BASELINK_P (member
))
1681 /* Go from the TREE_BASELINK to the member function info. */
1682 tree fnfields
= member
;
1683 t
= TREE_VALUE (fnfields
);
1685 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1687 /* The FNFIELDS are going to contain functions that aren't
1688 necessarily templates, and templates that don't
1689 necessarily match the explicit template parameters. We
1690 save all the functions, and the explicit parameters, and
1691 then figure out exactly what to instantiate with what
1692 arguments in instantiate_type. */
1694 if (TREE_CODE (t
) != OVERLOAD
)
1695 /* The code in instantiate_type which will process this
1696 expects to encounter OVERLOADs, not raw functions. */
1697 t
= ovl_cons (t
, NULL_TREE
);
1699 return build (OFFSET_REF
,
1702 build (TEMPLATE_ID_EXPR
,
1705 TREE_OPERAND (orig_name
, 1)));
1708 if (!really_overloaded_fn (t
))
1710 /* Get rid of a potential OVERLOAD around it */
1711 t
= OVL_CURRENT (t
);
1713 /* unique functions are handled easily. */
1714 if (!enforce_access (basebinfo
, t
))
1715 return error_mark_node
;
1717 if (DECL_STATIC_FUNCTION_P (t
))
1719 return build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1722 TREE_TYPE (fnfields
) = unknown_type_node
;
1723 return build (OFFSET_REF
, unknown_type_node
, decl
, fnfields
);
1730 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1731 return error_mark_node
;
1734 if (TREE_CODE (t
) == TYPE_DECL
)
1739 /* static class members and class-specific enum
1740 values can be returned without further ado. */
1741 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1744 return convert_from_reference (t
);
1747 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_C_BIT_FIELD (t
))
1749 cp_error ("illegal pointer to bit field `%D'", t
);
1750 return error_mark_node
;
1753 /* static class functions too. */
1754 if (TREE_CODE (t
) == FUNCTION_DECL
1755 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1756 my_friendly_abort (53);
1758 /* In member functions, the form `type::name' is no longer
1759 equivalent to `this->type::name', at least not until
1760 resolve_offset_ref. */
1761 return build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1764 /* If a OFFSET_REF made it through to here, then it did
1765 not have its address taken. */
1768 resolve_offset_ref (exp
)
1771 tree type
= TREE_TYPE (exp
);
1772 tree base
= NULL_TREE
;
1774 tree basetype
, addr
;
1776 if (TREE_CODE (exp
) == OFFSET_REF
)
1778 member
= TREE_OPERAND (exp
, 1);
1779 base
= TREE_OPERAND (exp
, 0);
1783 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1784 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1786 error ("object missing in use of pointer-to-member construct");
1787 return error_mark_node
;
1790 type
= TREE_TYPE (type
);
1791 base
= current_class_ref
;
1794 if (BASELINK_P (member
))
1796 if (! flag_ms_extensions
)
1797 cp_pedwarn ("assuming & on overloaded member function");
1798 return build_unary_op (ADDR_EXPR
, exp
, 0);
1801 if (TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1803 if (! flag_ms_extensions
)
1804 cp_pedwarn ("assuming & on `%E'", member
);
1805 return build_unary_op (ADDR_EXPR
, exp
, 0);
1808 if ((TREE_CODE (member
) == VAR_DECL
1809 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
))
1810 && ! TYPE_PTRMEM_P (TREE_TYPE (member
)))
1811 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
)
1813 /* These were static members. */
1814 if (mark_addressable (member
) == 0)
1815 return error_mark_node
;
1819 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1820 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1823 /* Syntax error can cause a member which should
1824 have been seen as static to be grok'd as non-static. */
1825 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1827 cp_error_at ("member `%D' is non-static but referenced as a static member",
1829 error ("at this point in file");
1830 return error_mark_node
;
1833 /* The first case is really just a reference to a member of `this'. */
1834 if (TREE_CODE (member
) == FIELD_DECL
1835 && (base
== current_class_ref
|| is_dummy_object (base
)))
1839 basetype
= DECL_CONTEXT (member
);
1841 /* Try to get to basetype from 'this'; if that doesn't work,
1843 base
= current_class_ref
;
1845 /* First convert to the intermediate base specified, if appropriate. */
1846 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1847 base
= build_scoped_ref (base
, TYPE_OFFSET_BASETYPE (type
));
1849 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1850 addr
= convert_pointer_to (basetype
, addr
);
1852 if (addr
== error_mark_node
)
1853 return error_mark_node
;
1855 expr
= build (COMPONENT_REF
, TREE_TYPE (member
),
1856 build_indirect_ref (addr
, NULL_PTR
), member
);
1857 return convert_from_reference (expr
);
1860 /* Ensure that we have an object. */
1861 if (is_dummy_object (base
))
1862 addr
= error_mark_node
;
1864 /* If this is a reference to a member function, then return the
1865 address of the member function (which may involve going
1866 through the object's vtable), otherwise, return an expression
1867 for the dereferenced pointer-to-member construct. */
1868 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1870 if (TYPE_PTRMEM_P (TREE_TYPE (member
)))
1872 if (addr
== error_mark_node
)
1874 cp_error ("object missing in `%E'", exp
);
1875 return error_mark_node
;
1878 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member
)));
1879 addr
= convert_pointer_to (basetype
, addr
);
1880 member
= cp_convert (ptrdiff_type_node
, member
);
1883 /* Pointer to data members are offset by one, so that a null
1884 pointer with a real value of 0 is distinguishable from an
1885 offset of the first member of a structure. */
1886 member
= build_binary_op (MINUS_EXPR
, member
,
1887 cp_convert (ptrdiff_type_node
,
1890 return build1 (INDIRECT_REF
, type
,
1891 build (PLUS_EXPR
, build_pointer_type (type
),
1894 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1896 return get_member_function_from_ptrfunc (&addr
, member
);
1898 my_friendly_abort (56);
1903 /* If DECL is a `const' declaration, and its value is a known
1904 constant, then return that value. */
1907 decl_constant_value (decl
)
1910 if (TREE_READONLY_DECL_P (decl
)
1911 && ! TREE_THIS_VOLATILE (decl
)
1912 && DECL_INITIAL (decl
)
1913 && DECL_INITIAL (decl
) != error_mark_node
1914 /* This is invalid if initial value is not constant.
1915 If it has either a function call, a memory reference,
1916 or a variable, then re-evaluating it could give different results. */
1917 && TREE_CONSTANT (DECL_INITIAL (decl
))
1918 /* Check for cases where this is sub-optimal, even though valid. */
1919 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1920 return DECL_INITIAL (decl
);
1924 /* Common subroutines of build_new and build_vec_delete. */
1926 /* Call the global __builtin_delete to delete ADDR. */
1929 build_builtin_delete_call (addr
)
1932 mark_used (global_delete_fndecl
);
1933 return build_call (global_delete_fndecl
, build_tree_list (NULL_TREE
, addr
));
1936 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1937 (which needs to go through some sort of groktypename) or it
1938 is the name of the class we are newing. INIT is an initialization value.
1939 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1940 If INIT is void_type_node, it means do *not* call a constructor
1943 For types with constructors, the data returned is initialized
1944 by the appropriate constructor.
1946 Whether the type has a constructor or not, if it has a pointer
1947 to a virtual function table, then that pointer is set up
1950 Unless I am mistaken, a call to new () will return initialized
1951 data regardless of whether the constructor itself is private or
1952 not. NOPE; new fails if the constructor is private (jcm).
1954 Note that build_new does nothing to assure that any special
1955 alignment requirements of the type are met. Rather, it leaves
1956 it up to malloc to do the right thing. Otherwise, folding to
1957 the right alignment cal cause problems if the user tries to later
1958 free the memory returned by `new'.
1960 PLACEMENT is the `placement' list for user-defined operator new (). */
1962 extern int flag_check_new
;
1965 build_new (placement
, decl
, init
, use_global_new
)
1971 tree nelts
= NULL_TREE
, t
;
1974 if (decl
== error_mark_node
)
1975 return error_mark_node
;
1977 if (TREE_CODE (decl
) == TREE_LIST
)
1979 tree absdcl
= TREE_VALUE (decl
);
1980 tree last_absdcl
= NULL_TREE
;
1982 if (current_function_decl
1983 && DECL_CONSTRUCTOR_P (current_function_decl
))
1984 my_friendly_assert (immediate_size_expand
== 0, 19990926);
1986 nelts
= integer_one_node
;
1988 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
1989 my_friendly_abort (215);
1990 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
1992 last_absdcl
= absdcl
;
1993 absdcl
= TREE_OPERAND (absdcl
, 0);
1996 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
1998 /* probably meant to be a vec new */
2001 while (TREE_OPERAND (absdcl
, 0)
2002 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2004 last_absdcl
= absdcl
;
2005 absdcl
= TREE_OPERAND (absdcl
, 0);
2009 this_nelts
= TREE_OPERAND (absdcl
, 1);
2010 if (this_nelts
!= error_mark_node
)
2012 if (this_nelts
== NULL_TREE
)
2013 error ("new of array type fails to specify size");
2014 else if (processing_template_decl
)
2017 absdcl
= TREE_OPERAND (absdcl
, 0);
2021 int flags
= pedantic
? WANT_INT
: (WANT_INT
| WANT_ENUM
);
2022 if (build_expr_type_conversion (flags
, this_nelts
, 0)
2024 pedwarn ("size in array new must have integral type");
2026 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2027 absdcl
= TREE_OPERAND (absdcl
, 0);
2028 if (this_nelts
== integer_zero_node
)
2030 warning ("zero size array reserves no space");
2031 nelts
= integer_zero_node
;
2034 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2038 nelts
= integer_zero_node
;
2042 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2044 TREE_VALUE (decl
) = absdcl
;
2046 type
= groktypename (decl
);
2047 if (! type
|| type
== error_mark_node
)
2048 return error_mark_node
;
2050 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2052 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2054 /* An aggregate type. */
2055 type
= IDENTIFIER_TYPE_VALUE (decl
);
2056 decl
= TYPE_MAIN_DECL (type
);
2060 /* A builtin type. */
2061 decl
= lookup_name (decl
, 1);
2062 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2063 type
= TREE_TYPE (decl
);
2066 else if (TREE_CODE (decl
) == TYPE_DECL
)
2068 type
= TREE_TYPE (decl
);
2073 decl
= TYPE_MAIN_DECL (type
);
2076 if (processing_template_decl
)
2079 t
= tree_cons (tree_cons (NULL_TREE
, type
, NULL_TREE
),
2080 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2085 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2086 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2090 /* ``A reference cannot be created by the new operator. A reference
2091 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2092 returned by new.'' ARM 5.3.3 */
2093 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2095 error ("new cannot be applied to a reference type");
2096 type
= TREE_TYPE (type
);
2099 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2101 error ("new cannot be applied to a function type");
2102 return error_mark_node
;
2105 /* When the object being created is an array, the new-expression yields a
2106 pointer to the initial element (if any) of the array. For example,
2107 both new int and new int[10] return an int*. 5.3.4. */
2108 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2110 nelts
= array_type_nelts_top (type
);
2112 type
= TREE_TYPE (type
);
2116 t
= build_nt (ARRAY_REF
, type
, nelts
);
2120 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2121 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2122 TREE_SIDE_EFFECTS (rval
) = 1;
2123 rval
= build_new_1 (rval
);
2124 if (rval
== error_mark_node
)
2125 return error_mark_node
;
2127 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2128 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2129 TREE_NO_UNUSED_WARNING (rval
) = 1;
2134 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2137 build_java_class_ref (type
)
2140 tree name
, class_decl
;
2141 static tree CL_prefix
= NULL_TREE
;
2142 if (CL_prefix
== NULL_TREE
)
2143 CL_prefix
= get_identifier("_CL_");
2144 if (jclass_node
== NULL_TREE
)
2146 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2147 if (jclass_node
== NULL_TREE
)
2148 fatal("call to Java constructor, while `jclass' undefined");
2149 jclass_node
= TREE_TYPE (jclass_node
);
2151 name
= build_overload_with_type (CL_prefix
, type
);
2152 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2153 if (class_decl
== NULL_TREE
)
2155 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2156 TREE_STATIC (class_decl
) = 1;
2157 DECL_EXTERNAL (class_decl
) = 1;
2158 TREE_PUBLIC (class_decl
) = 1;
2159 DECL_ARTIFICIAL (class_decl
) = 1;
2160 DECL_IGNORED_P (class_decl
) = 1;
2161 pushdecl_top_level (class_decl
);
2162 make_decl_rtl (class_decl
, NULL_PTR
, 1);
2167 /* Returns teh size of the cookie to use when allocating an array
2168 whose elements have the indicated TYPE. Assumes that it is already
2169 known that a cookie is needed. */
2172 get_cookie_size (type
)
2179 /* Under the new ABI, we need to allocate an additional max
2180 (sizeof (size_t), alignof (true_type)) bytes. */
2184 sizetype_size
= size_in_bytes (sizetype
);
2185 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
2186 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
2187 cookie_size
= sizetype_size
;
2189 cookie_size
= type_align
;
2192 cookie_size
= BI_header_size
;
2197 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2198 value is immediately handed to expand_expr. */
2204 tree placement
, init
;
2205 tree type
, true_type
, size
, rval
;
2206 tree nelts
= NULL_TREE
;
2207 tree alloc_expr
, alloc_node
= NULL_TREE
;
2209 enum tree_code code
;
2210 int use_cookie
, nothrow
, check_new
;
2211 /* Nonzero if the user wrote `::new' rather than just `new'. */
2212 int globally_qualified_p
;
2213 /* Nonzero if we're going to call a global operator new, rather than
2214 a class-specific version. */
2216 int use_java_new
= 0;
2217 /* If non-NULL, the number of extra bytes to allocate at the
2218 beginning of the storage allocated for an array-new expression in
2219 order to store the number of elements. */
2220 tree cookie_size
= NULL_TREE
;
2222 placement
= TREE_OPERAND (exp
, 0);
2223 type
= TREE_OPERAND (exp
, 1);
2224 init
= TREE_OPERAND (exp
, 2);
2225 globally_qualified_p
= NEW_EXPR_USE_GLOBAL (exp
);
2227 if (TREE_CODE (type
) == ARRAY_REF
)
2230 nelts
= TREE_OPERAND (type
, 1);
2231 type
= TREE_OPERAND (type
, 0);
2235 code
= has_array
? VEC_NEW_EXPR
: NEW_EXPR
;
2237 if (CP_TYPE_QUALS (type
))
2238 type
= TYPE_MAIN_VARIANT (type
);
2240 /* If our base type is an array, then make sure we know how many elements
2242 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2244 tree this_nelts
= array_type_nelts_top (true_type
);
2245 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2246 true_type
= TREE_TYPE (true_type
);
2249 if (!complete_type_or_else (true_type
, exp
))
2250 return error_mark_node
;
2253 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2256 size
= size_in_bytes (type
);
2258 if (TREE_CODE (true_type
) == VOID_TYPE
)
2260 error ("invalid type `void' for new");
2261 return error_mark_node
;
2264 if (abstract_virtuals_error (NULL_TREE
, true_type
))
2265 return error_mark_node
;
2267 /* Figure out whether or not we're going to use the global operator
2269 if (!globally_qualified_p
2270 && IS_AGGR_TYPE (true_type
)
2271 && ((!has_array
&& TYPE_HAS_NEW_OPERATOR (true_type
))
2272 || (has_array
&& TYPE_HAS_ARRAY_NEW_OPERATOR (true_type
))))
2277 /* We only need cookies for arrays containing types for which we
2279 if (!has_array
|| !TYPE_VEC_NEW_USES_COOKIE (true_type
))
2281 /* When using placement new, users may not realize that they need
2282 the extra storage. Under the old ABI, we don't allocate the
2283 cookie whenever they use one placement argument of type `void
2284 *'. Under the new ABI, we require that the operator called be
2285 the global placement operator delete[]. */
2286 else if (placement
&& !TREE_CHAIN (placement
)
2287 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2289 use_cookie
= (!flag_new_abi
|| !use_global_new
);
2290 /* Otherwise, we need the cookie. */
2294 /* Compute the number of extra bytes to allocate, now that we know
2295 whether or not we need the cookie. */
2298 cookie_size
= get_cookie_size (true_type
);
2299 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
2302 if (has_array
&& init
&& pedantic
)
2303 cp_pedwarn ("initialization in array new");
2305 /* Allocate the object. */
2307 if (! placement
&& TYPE_FOR_JAVA (true_type
))
2309 tree class_addr
, alloc_decl
;
2310 tree class_decl
= build_java_class_ref (true_type
);
2311 tree class_size
= size_in_bytes (true_type
);
2312 static char alloc_name
[] = "_Jv_AllocObject";
2314 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2315 if (alloc_decl
== NULL_TREE
)
2316 fatal("call to Java constructor, while `%s' undefined", alloc_name
);
2317 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2318 rval
= build_function_call (alloc_decl
,
2319 tree_cons (NULL_TREE
, class_addr
,
2320 build_tree_list (NULL_TREE
,
2322 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2329 args
= tree_cons (NULL_TREE
, size
, placement
);
2330 fnname
= ansi_opname (code
);
2333 rval
= (build_new_function_call
2334 (lookup_function_nonclass (fnname
, args
),
2337 rval
= build_method_call (build_dummy_object (true_type
),
2338 fnname
, args
, NULL_TREE
,
2340 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2343 /* unless an allocation function is declared with an empty excep-
2344 tion-specification (_except.spec_), throw(), it indicates failure to
2345 allocate storage by throwing a bad_alloc exception (clause _except_,
2346 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2347 cation function is declared with an empty exception-specification,
2348 throw(), it returns null to indicate failure to allocate storage and a
2349 non-null pointer otherwise.
2351 So check for a null exception spec on the op new we just called. */
2356 /* The CALL_EXPR. */
2357 tree t
= TREE_OPERAND (rval
, 0);
2359 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
2360 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (t
));
2362 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2364 if ((check_new
|| flag_exceptions
) && rval
)
2366 alloc_expr
= get_target_expr (rval
);
2367 alloc_node
= rval
= TREE_OPERAND (alloc_expr
, 0);
2370 alloc_expr
= NULL_TREE
;
2372 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2373 sure we have some extra bytes in that case for the BI_header_size
2374 cookies? And how does that interact with the code below? (mrs) */
2375 /* Finish up some magic for new'ed arrays */
2376 if (use_cookie
&& rval
!= NULL_TREE
)
2379 rval
= convert (string_type_node
, rval
); /* for ptr arithmetic */
2380 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, cookie_size
));
2381 /* Store the number of bytes allocated so that we can know how
2382 many elements to destroy later. */
2385 /* Under the new ABI, we use the last sizeof (size_t) bytes
2386 to store the number of elements. */
2387 cookie
= build_indirect_ref (build (MINUS_EXPR
,
2388 build_pointer_type (sizetype
),
2390 size_in_bytes (sizetype
)),
2392 exp1
= build (MODIFY_EXPR
, void_type_node
, cookie
, nelts
);
2397 = build_indirect_ref (build (MINUS_EXPR
,
2398 build_pointer_type (BI_header_type
),
2399 rval
, cookie_size
), NULL_PTR
);
2400 exp1
= build (MODIFY_EXPR
, void_type_node
,
2401 build_component_ref (cookie
, nelts_identifier
,
2406 /* Build `(cookie = nelts, rval)' and use that as the complete
2408 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2409 rval
= build_compound_expr
2410 (tree_cons (NULL_TREE
, exp1
,
2411 build_tree_list (NULL_TREE
, rval
)));
2414 if (rval
== error_mark_node
)
2415 return error_mark_node
;
2417 /* Don't call any constructors or do any initialization. */
2418 if (init
== void_type_node
)
2421 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2423 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2424 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2426 /* We are processing something like `new int (10)', which
2427 means allocate an int, and initialize it with 10. */
2431 /* At present RVAL is a temporary variable, created to hold
2432 the value from the call to `operator new'. We transform
2433 it to (*RVAL = INIT, RVAL). */
2434 rval
= save_expr (rval
);
2435 deref
= build_indirect_ref (rval
, NULL_PTR
);
2437 /* Even for something like `new const int (10)' we must
2438 allow the expression to be non-const while we do the
2440 deref_type
= TREE_TYPE (deref
);
2441 if (CP_TYPE_CONST_P (deref_type
))
2443 = cp_build_qualified_type (deref_type
,
2444 CP_TYPE_QUALS (deref_type
)
2445 & ~TYPE_QUAL_CONST
);
2446 TREE_READONLY (deref
) = 0;
2448 if (TREE_CHAIN (init
) != NULL_TREE
)
2449 pedwarn ("initializer list being treated as compound expression");
2450 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2452 pedwarn ("initializer list appears where operand should be used");
2453 init
= TREE_OPERAND (init
, 1);
2455 init
= build_compound_expr (init
);
2457 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2458 "new", NULL_TREE
, 0);
2459 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2460 build_modify_expr (deref
, NOP_EXPR
, init
),
2462 TREE_NO_UNUSED_WARNING (rval
) = 1;
2463 TREE_SIDE_EFFECTS (rval
) = 1;
2465 else if (! has_array
)
2468 /* Constructors are never virtual. If it has an initialization, we
2469 need to complain if we aren't allowed to use the ctor that took
2471 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2473 rval
= save_expr (rval
);
2476 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2477 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2479 newrval
= build_method_call (newrval
,
2480 complete_ctor_identifier
,
2481 init
, TYPE_BINFO (true_type
), flags
);
2483 if (newrval
== NULL_TREE
|| newrval
== error_mark_node
)
2484 return error_mark_node
;
2486 newrval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), newrval
, rval
);
2488 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2491 rval
= (build_vec_init
2494 build_binary_op (MINUS_EXPR
, nelts
, integer_one_node
),
2498 /* If any part of the object initialization terminates by throwing an
2499 exception and a suitable deallocation function can be found, the
2500 deallocation function is called to free the memory in which the
2501 object was being constructed, after which the exception continues
2502 to propagate in the context of the new-expression. If no
2503 unambiguous matching deallocation function can be found,
2504 propagating the exception does not cause the object's memory to be
2506 if (flag_exceptions
&& alloc_expr
&& ! use_java_new
)
2508 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2509 tree cleanup
, fn
= NULL_TREE
;
2510 int flags
= (LOOKUP_NORMAL
2511 | (globally_qualified_p
* LOOKUP_GLOBAL
));
2513 /* The Standard is unclear here, but the right thing to do
2514 is to use the same method for finding deallocation
2515 functions that we use for finding allocation functions. */
2516 flags
|= LOOKUP_SPECULATIVELY
;
2518 /* We expect alloc_expr to look like a TARGET_EXPR around
2519 a NOP_EXPR around the CALL_EXPR we want. */
2520 fn
= TREE_OPERAND (alloc_expr
, 1);
2521 fn
= TREE_OPERAND (fn
, 0);
2523 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
, fn
);
2525 /* Ack! First we allocate the memory. Then we set our sentry
2526 variable to true, and expand a cleanup that deletes the memory
2527 if sentry is true. Then we run the constructor and store the
2528 returned pointer in buf. Then we clear sentry and return buf. */
2532 tree end
, sentry
, begin
, buf
, t
= TREE_TYPE (rval
);
2534 begin
= get_target_expr (boolean_true_node
);
2535 sentry
= TREE_OPERAND (begin
, 0);
2537 TREE_OPERAND (begin
, 2)
2538 = build (COND_EXPR
, void_type_node
, sentry
,
2539 cleanup
, void_zero_node
);
2541 rval
= get_target_expr (rval
);
2543 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2544 sentry
, boolean_false_node
);
2546 buf
= TREE_OPERAND (rval
, 0);
2548 rval
= build (COMPOUND_EXPR
, t
, begin
,
2549 build (COMPOUND_EXPR
, t
, rval
,
2550 build (COMPOUND_EXPR
, t
, end
, buf
)));
2554 else if (CP_TYPE_CONST_P (true_type
))
2555 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2559 if (alloc_expr
&& rval
== alloc_node
)
2561 rval
= TREE_OPERAND (alloc_expr
, 1);
2562 alloc_expr
= NULL_TREE
;
2565 if (check_new
&& alloc_expr
)
2567 /* Did we modify the storage? */
2568 tree ifexp
= build_binary_op (NE_EXPR
, alloc_node
,
2570 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2574 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2576 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2578 /* The type of new int [3][3] is not int *, but int [3] * */
2579 rval
= build_c_cast (build_pointer_type (type
), rval
);
2586 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, use_global_delete
)
2587 tree base
, maxindex
, type
;
2588 special_function_kind auto_delete_vec
;
2589 int use_global_delete
;
2592 tree ptype
= build_pointer_type (type
= complete_type (type
));
2593 tree size_exp
= size_in_bytes (type
);
2595 /* Temporary variables used by the loop. */
2596 tree tbase
, tbase_init
;
2598 /* This is the body of the loop that implements the deletion of a
2599 single element, and moves temp variables to next elements. */
2602 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2605 /* This is the thing that governs what to do after the loop has run. */
2606 tree deallocate_expr
= 0;
2608 /* This is the BIND_EXPR which holds the outermost iterator of the
2609 loop. It is convenient to set this variable up and test it before
2610 executing any other code in the loop.
2611 This is also the containing expression returned by this function. */
2612 tree controller
= NULL_TREE
;
2614 if (! IS_AGGR_TYPE (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2616 loop
= integer_zero_node
;
2620 /* The below is short by BI_header_size */
2621 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2622 convert (sizetype
, maxindex
));
2624 tbase
= create_temporary_var (ptype
);
2625 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2626 fold (build (PLUS_EXPR
, ptype
,
2629 DECL_REGISTER (tbase
) = 1;
2630 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2631 TREE_SIDE_EFFECTS (controller
) = 1;
2635 body
= tree_cons (NULL_TREE
,
2636 build_delete (ptype
, tbase
, sfk_complete_destructor
,
2637 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2640 body
= tree_cons (NULL_TREE
,
2641 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2644 body
= tree_cons (NULL_TREE
,
2645 build (EXIT_EXPR
, void_type_node
,
2646 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2649 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2651 loop
= tree_cons (NULL_TREE
, tbase_init
,
2652 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2653 loop
= build_compound_expr (loop
);
2656 /* If the delete flag is one, or anything else with the low bit set,
2657 delete the storage. */
2658 deallocate_expr
= integer_zero_node
;
2659 if (auto_delete_vec
!= sfk_base_destructor
)
2663 /* The below is short by BI_header_size */
2664 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2665 convert (sizetype
, maxindex
));
2667 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2674 cookie_size
= get_cookie_size (type
);
2676 = cp_convert (ptype
,
2677 build_binary_op (MINUS_EXPR
,
2678 cp_convert (string_type_node
, base
),
2680 /* True size with header. */
2681 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2684 if (auto_delete_vec
== sfk_deleting_destructor
)
2685 deallocate_expr
= build_x_delete (base_tbd
,
2686 2 | use_global_delete
,
2690 if (loop
&& deallocate_expr
!= integer_zero_node
)
2692 body
= tree_cons (NULL_TREE
, loop
,
2693 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2694 body
= build_compound_expr (body
);
2699 /* Outermost wrapper: If pointer is null, punt. */
2700 body
= fold (build (COND_EXPR
, void_type_node
,
2701 fold (build (NE_EXPR
, boolean_type_node
, base
,
2702 integer_zero_node
)),
2703 body
, integer_zero_node
));
2704 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2708 TREE_OPERAND (controller
, 1) = body
;
2712 return cp_convert (void_type_node
, body
);
2716 create_temporary_var (type
)
2721 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2722 TREE_USED (decl
) = 1;
2723 DECL_ARTIFICIAL (decl
) = 1;
2724 DECL_SOURCE_FILE (decl
) = input_filename
;
2725 DECL_SOURCE_LINE (decl
) = lineno
;
2726 DECL_IGNORED_P (decl
) = 1;
2727 DECL_CONTEXT (decl
) = current_function_decl
;
2732 /* Create a new temporary variable of the indicated TYPE, initialized
2735 It is not entered into current_binding_level, because that breaks
2736 things when it comes time to do final cleanups (which take place
2737 "outside" the binding contour of the function). */
2740 get_temp_regvar (type
, init
)
2745 decl
= create_temporary_var (type
);
2746 if (building_stmt_tree ())
2747 add_decl_stmt (decl
);
2748 if (!building_stmt_tree ())
2749 DECL_RTL (decl
) = assign_temp (type
, 2, 0, 1);
2750 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
2755 /* `build_vec_init' returns tree structure that performs
2756 initialization of a vector of aggregate types.
2758 DECL is passed only for error reporting, and provides line number
2759 and source file name information.
2760 BASE is the space where the vector will be. For a vector of Ts,
2761 the type of BASE is `T*'.
2762 MAXINDEX is the maximum index of the array (one less than the
2763 number of elements).
2764 INIT is the (possibly NULL) initializer.
2766 FROM_ARRAY is 0 if we should init everything with INIT
2767 (i.e., every element initialized from INIT).
2768 FROM_ARRAY is 1 if we should index into INIT in parallel
2769 with initialization of DECL.
2770 FROM_ARRAY is 2 if we should index into INIT in parallel,
2771 but use assignment instead of initialization. */
2774 build_vec_init (decl
, base
, maxindex
, init
, from_array
)
2775 tree decl
, base
, maxindex
, init
;
2779 tree base2
= NULL_TREE
;
2781 tree itype
= NULL_TREE
;
2783 /* The type of an element in the array. */
2785 /* The type of a pointer to an element in the array. */
2790 tree try_block
= NULL_TREE
;
2791 tree try_body
= NULL_TREE
;
2792 int num_initialized_elts
= 0;
2794 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2795 if (maxindex
== error_mark_node
)
2796 return error_mark_node
;
2798 type
= TREE_TYPE (TREE_TYPE (base
));
2799 ptype
= build_pointer_type (type
);
2800 size
= size_in_bytes (type
);
2802 /* The code we are generating looks like:
2806 ptrdiff_t iterator = maxindex;
2808 ... initializations from CONSTRUCTOR ...
2809 if (iterator != -1) {
2811 ... initialize *base ...
2813 } while (--iterator != -1);
2816 ... destroy elements that were constructed ...
2819 We can omit the try and catch blocks if we know that the
2820 initialization will never throw an exception, or if the array
2821 elements do not have destructors. If we have a CONSTRUCTOR to
2822 give us initialization information, we emit code to initialize
2823 each of the elements before the loop in the try block, and then
2824 iterate over fewer elements. We can omit the loop completely if
2825 the elements of the array do not have constructors.
2827 We actually wrap the entire body of the above in a STMT_EXPR, for
2830 When copying from array to another, when the array elements have
2831 only trivial copy constructors, we should use __builtin_memcpy
2832 rather than generating a loop. That way, we could take advantage
2833 of whatever cleverness the back-end has for dealing with copies
2834 of blocks of memory. */
2836 begin_init_stmts (&stmt_expr
, &compound_stmt
);
2837 destroy_temps
= stmts_are_full_exprs_p
;
2838 stmts_are_full_exprs_p
= 0;
2839 rval
= get_temp_regvar (ptype
,
2840 cp_convert (ptype
, default_conversion (base
)));
2841 base
= get_temp_regvar (ptype
, rval
);
2842 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2844 /* Protect the entire array initialization so that we can destroy
2845 the partially constructed array if an exception is thrown. */
2846 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2848 try_block
= begin_try_block ();
2849 try_body
= begin_compound_stmt (/*has_no_scope=*/1);
2852 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
2853 && (!decl
|| same_type_p (TREE_TYPE (init
), TREE_TYPE (decl
))))
2855 /* Do non-default initialization resulting from brace-enclosed
2861 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2863 tree elt
= TREE_VALUE (elts
);
2864 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2866 num_initialized_elts
++;
2868 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2869 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0));
2871 finish_expr_stmt (build_modify_expr (baseref
, NOP_EXPR
,
2874 finish_expr_stmt (build_modify_expr
2877 build (PLUS_EXPR
, build_pointer_type (type
),
2879 finish_expr_stmt (build_modify_expr
2882 build (MINUS_EXPR
, ptrdiff_type_node
,
2883 iterator
, integer_one_node
)));
2886 /* Clear out INIT so that we don't get confused below. */
2889 else if (from_array
)
2891 /* If initializing one array from another, initialize element by
2892 element. We rely upon the below calls the do argument
2894 if (decl
== NULL_TREE
)
2896 sorry ("initialization of array from dissimilar array type");
2897 return error_mark_node
;
2901 base2
= default_conversion (init
);
2902 itype
= TREE_TYPE (base2
);
2903 base2
= get_temp_regvar (itype
, base2
);
2904 itype
= TREE_TYPE (itype
);
2906 else if (TYPE_LANG_SPECIFIC (type
)
2907 && TYPE_NEEDS_CONSTRUCTING (type
)
2908 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2910 error ("initializer ends prematurely");
2911 return error_mark_node
;
2915 /* Now, default-initialize any remaining elements. We don't need to
2916 do that if a) the type does not need constructing, or b) we've
2917 already initialized all the elements.
2919 We do need to keep going if we're copying an array. */
2922 || (TYPE_NEEDS_CONSTRUCTING (type
)
2923 && ! (host_integerp (maxindex
, 0)
2924 && (num_initialized_elts
2925 == tree_low_cst (maxindex
, 0) + 1))))
2927 /* If the ITERATOR is equal to -1, then we don't have to loop;
2928 we've already initialized all the elements. */
2934 if_stmt
= begin_if_stmt ();
2935 finish_if_stmt_cond (build (NE_EXPR
, boolean_type_node
,
2936 iterator
, minus_one_node
),
2939 /* Otherwise, loop through the elements. */
2940 do_stmt
= begin_do_stmt ();
2941 do_body
= begin_compound_stmt (/*has_no_scope=*/1);
2943 /* When we're not building a statement-tree, things are a little
2944 complicated. If, when we recursively call build_aggr_init,
2945 an expression containing a TARGET_EXPR is expanded, then it
2946 may get a cleanup. Then, the result of that expression is
2947 passed to finish_expr_stmt, which will call
2948 expand_start_target_temps/expand_end_target_temps. However,
2949 the latter call will not cause the cleanup to run because
2950 that block will still be on the block stack. So, we call
2951 expand_start_target_temps here manually; the corresponding
2952 call to expand_end_target_temps below will cause the cleanup
2954 if (!building_stmt_tree ())
2955 expand_start_target_temps ();
2959 tree to
= build1 (INDIRECT_REF
, type
, base
);
2963 from
= build1 (INDIRECT_REF
, itype
, base2
);
2967 if (from_array
== 2)
2968 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
2969 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2970 elt_init
= build_aggr_init (to
, from
, 0);
2972 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
2974 my_friendly_abort (57);
2976 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2979 sorry ("cannot initialize multi-dimensional array with initializer");
2980 elt_init
= (build_vec_init
2983 build_pointer_type (TREE_TYPE (type
)),
2985 array_type_nelts (type
), 0, 0));
2988 elt_init
= build_aggr_init (build1 (INDIRECT_REF
, type
, base
),
2991 /* The initialization of each array element is a
2993 if (!building_stmt_tree ())
2995 finish_expr_stmt (elt_init
);
2996 expand_end_target_temps ();
3000 stmts_are_full_exprs_p
= 1;
3001 finish_expr_stmt (elt_init
);
3002 stmts_are_full_exprs_p
= 0;
3005 finish_expr_stmt (build_modify_expr
3008 build (PLUS_EXPR
, build_pointer_type (type
),
3011 finish_expr_stmt (build_modify_expr
3014 build (PLUS_EXPR
, build_pointer_type (type
),
3017 finish_compound_stmt (/*has_no_scope=*/1, do_body
);
3018 finish_do_body (do_stmt
);
3019 finish_do_stmt (build (NE_EXPR
, boolean_type_node
,
3020 build (PREDECREMENT_EXPR
,
3027 finish_then_clause (if_stmt
);
3031 /* Make sure to cleanup any partially constructed elements. */
3032 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3036 finish_compound_stmt (/*has_no_scope=*/1, try_body
);
3037 finish_cleanup_try_block (try_block
);
3038 e
= build_vec_delete_1 (rval
,
3039 build_binary_op (MINUS_EXPR
, maxindex
,
3042 sfk_base_destructor
,
3043 /*use_global_delete=*/0);
3044 finish_cleanup (e
, try_block
);
3047 /* The value of the array initialization is the address of the
3048 first element in the array. */
3049 finish_expr_stmt (rval
);
3051 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
3052 stmts_are_full_exprs_p
= destroy_temps
;
3056 /* Free up storage of type TYPE, at address ADDR.
3058 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3061 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3062 used as the second argument to operator delete. It can include
3063 things like padding and magic size cookies. It has virtual in it,
3064 because if you have a base pointer and you delete through a virtual
3065 destructor, it should be the size of the dynamic object, not the
3066 static object, see Free Store 12.5 ISO C++.
3068 This does not call any destructors. */
3071 build_x_delete (addr
, which_delete
, virtual_size
)
3076 int use_global_delete
= which_delete
& 1;
3077 int use_vec_delete
= !!(which_delete
& 2);
3078 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3079 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
3081 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
3084 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3088 build_dtor_call (exp
, dtor_kind
, flags
)
3090 special_function_kind dtor_kind
;
3097 case sfk_complete_destructor
:
3098 name
= complete_dtor_identifier
;
3101 case sfk_base_destructor
:
3102 name
= base_dtor_identifier
;
3105 case sfk_deleting_destructor
:
3106 name
= deleting_dtor_identifier
;
3110 my_friendly_abort (20000524);
3112 return build_method_call (exp
, name
, NULL_TREE
, NULL_TREE
, flags
);
3115 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3116 ADDR is an expression which yields the store to be destroyed.
3117 AUTO_DELETE is the name of the destructor to call, i.e., either
3118 sfk_complete_destructor, sfk_base_destructor, or
3119 sfk_deleting_destructor.
3121 FLAGS is the logical disjunction of zero or more LOOKUP_
3122 flags. See cp-tree.h for more info.
3124 This function does not delete an object's virtual base classes. */
3127 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3129 special_function_kind auto_delete
;
3131 int use_global_delete
;
3137 if (addr
== error_mark_node
)
3138 return error_mark_node
;
3140 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3141 set to `error_mark_node' before it gets properly cleaned up. */
3142 if (type
== error_mark_node
)
3143 return error_mark_node
;
3145 type
= TYPE_MAIN_VARIANT (type
);
3147 if (TREE_CODE (type
) == POINTER_TYPE
)
3149 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3150 if (type
!= void_type_node
&& !complete_type_or_else (type
, addr
))
3151 return error_mark_node
;
3152 if (TREE_CODE (type
) == ARRAY_TYPE
)
3154 if (! IS_AGGR_TYPE (type
))
3156 /* Call the builtin operator delete. */
3157 return build_builtin_delete_call (addr
);
3159 if (TREE_SIDE_EFFECTS (addr
))
3160 addr
= save_expr (addr
);
3162 /* throw away const and volatile on target type of addr */
3163 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3164 ref
= build_indirect_ref (addr
, NULL_PTR
);
3166 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3169 if (TREE_SIDE_EFFECTS (addr
))
3170 addr
= save_expr (addr
);
3171 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3173 error ("unknown array size in delete");
3174 return error_mark_node
;
3176 return build_vec_delete (addr
, array_type_nelts (type
),
3177 auto_delete
, use_global_delete
);
3181 /* Don't check PROTECT here; leave that decision to the
3182 destructor. If the destructor is accessible, call it,
3183 else report error. */
3184 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3185 if (TREE_SIDE_EFFECTS (addr
))
3186 addr
= save_expr (addr
);
3188 if (TREE_CONSTANT (addr
))
3189 addr
= convert_pointer_to (type
, addr
);
3191 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3193 ref
= build_indirect_ref (addr
, NULL_PTR
);
3196 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3198 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3200 if (auto_delete
== sfk_base_destructor
)
3201 return void_zero_node
;
3203 return build_op_delete_call
3204 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3205 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3209 /* Below, we will reverse the order in which these calls are made.
3210 If we have a destructor, then that destructor will take care
3211 of the base classes; otherwise, we must do that here. */
3212 if (TYPE_HAS_DESTRUCTOR (type
))
3214 tree do_delete
= NULL_TREE
;
3217 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3219 /* Delete the object. */
3220 do_delete
= build_builtin_delete_call (addr
);
3221 /* Otherwise, treat this like a complete object destructor
3223 auto_delete
= sfk_complete_destructor
;
3226 expr
= build_dtor_call (ref
, auto_delete
, flags
);
3228 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3230 if (flags
& LOOKUP_DESTRUCTOR
)
3231 /* Explicit destructor call; don't check for null pointer. */
3232 ifexp
= integer_one_node
;
3234 /* Handle deleting a null pointer. */
3235 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
));
3237 if (ifexp
!= integer_one_node
)
3238 expr
= build (COND_EXPR
, void_type_node
,
3239 ifexp
, expr
, void_zero_node
);
3245 /* We only get here from finish_function for a destructor. */
3246 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3247 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (type
);
3248 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3249 tree exprstmt
= NULL_TREE
;
3251 /* Set this again before we call anything, as we might get called
3253 TYPE_HAS_DESTRUCTOR (type
) = 1;
3255 /* If we have member delete or vbases, we call delete in
3257 my_friendly_assert (auto_delete
== sfk_base_destructor
, 20000411);
3259 /* Take care of the remaining baseclasses. */
3260 for (i
= 0; i
< n_baseclasses
; i
++)
3262 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3263 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3264 || TREE_VIA_VIRTUAL (base_binfo
))
3267 expr
= build_scoped_method_call (ref
, base_binfo
,
3268 base_dtor_identifier
,
3271 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3274 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3276 if (TREE_CODE (member
) != FIELD_DECL
)
3278 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member
)))
3280 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3281 tree this_type
= TREE_TYPE (member
);
3282 expr
= build_delete (this_type
, this_member
,
3283 sfk_complete_destructor
, flags
, 0);
3284 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3289 return build_compound_expr (exprstmt
);
3290 /* Virtual base classes make this function do nothing. */
3291 return void_zero_node
;
3295 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3298 build_vbase_delete (type
, decl
)
3301 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3302 tree result
= NULL_TREE
;
3303 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3305 my_friendly_assert (addr
!= error_mark_node
, 222);
3310 = convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases
))),
3312 result
= tree_cons (NULL_TREE
,
3313 build_delete (TREE_TYPE (this_addr
), this_addr
,
3314 sfk_base_destructor
,
3315 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3317 vbases
= TREE_CHAIN (vbases
);
3319 return build_compound_expr (nreverse (result
));
3322 /* Build a C++ vector delete expression.
3323 MAXINDEX is the number of elements to be deleted.
3324 ELT_SIZE is the nominal size of each element in the vector.
3325 BASE is the expression that should yield the store to be deleted.
3326 This function expands (or synthesizes) these calls itself.
3327 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3329 This also calls delete for virtual baseclasses of elements of the vector.
3331 Update: MAXINDEX is no longer needed. The size can be extracted from the
3332 start of the vector for pointers, and from the type for arrays. We still
3333 use MAXINDEX for arrays because it happens to already have one of the
3334 values we'd have to extract. (We could use MAXINDEX with pointers to
3335 confirm the size, and trap if the numbers differ; not clear that it'd
3336 be worth bothering.) */
3339 build_vec_delete (base
, maxindex
, auto_delete_vec
, use_global_delete
)
3340 tree base
, maxindex
;
3341 special_function_kind auto_delete_vec
;
3342 int use_global_delete
;
3346 if (TREE_CODE (base
) == OFFSET_REF
)
3347 base
= resolve_offset_ref (base
);
3349 type
= TREE_TYPE (base
);
3351 base
= stabilize_reference (base
);
3353 /* Since we can use base many times, save_expr it. */
3354 if (TREE_SIDE_EFFECTS (base
))
3355 base
= save_expr (base
);
3357 if (TREE_CODE (type
) == POINTER_TYPE
)
3359 /* Step back one from start of vector, and read dimension. */
3364 cookie_addr
= build (MINUS_EXPR
,
3365 build_pointer_type (sizetype
),
3367 TYPE_SIZE_UNIT (sizetype
));
3368 maxindex
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3374 cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3375 base
, BI_header_size
);
3376 cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3377 maxindex
= build_component_ref (cookie
, nelts_identifier
,
3381 type
= strip_array_types (TREE_TYPE (type
));
3383 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3385 /* get the total number of things in the array, maxindex is a bad name */
3386 maxindex
= array_type_nelts_total (type
);
3387 type
= strip_array_types (type
);
3388 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3392 if (base
!= error_mark_node
)
3393 error ("type to vector delete is neither pointer or array type");
3394 return error_mark_node
;
3397 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,