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 if (TREE_ADDRESSABLE (member
) == 0)
1829 cp_error_at ("member `%D' is non-static but referenced as a static member",
1831 error ("at this point in file");
1832 TREE_ADDRESSABLE (member
) = 1;
1834 return error_mark_node
;
1837 /* The first case is really just a reference to a member of `this'. */
1838 if (TREE_CODE (member
) == FIELD_DECL
1839 && (base
== current_class_ref
|| is_dummy_object (base
)))
1843 basetype
= DECL_CONTEXT (member
);
1845 /* Try to get to basetype from 'this'; if that doesn't work,
1847 base
= current_class_ref
;
1849 /* First convert to the intermediate base specified, if appropriate. */
1850 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1851 base
= build_scoped_ref (base
, TYPE_OFFSET_BASETYPE (type
));
1853 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1854 addr
= convert_pointer_to (basetype
, addr
);
1856 if (addr
== error_mark_node
)
1857 return error_mark_node
;
1859 expr
= build (COMPONENT_REF
, TREE_TYPE (member
),
1860 build_indirect_ref (addr
, NULL_PTR
), member
);
1861 return convert_from_reference (expr
);
1864 /* Ensure that we have an object. */
1865 if (is_dummy_object (base
))
1866 addr
= error_mark_node
;
1868 /* If this is a reference to a member function, then return the
1869 address of the member function (which may involve going
1870 through the object's vtable), otherwise, return an expression
1871 for the dereferenced pointer-to-member construct. */
1872 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1874 if (TYPE_PTRMEM_P (TREE_TYPE (member
)))
1876 if (addr
== error_mark_node
)
1878 cp_error ("object missing in `%E'", exp
);
1879 return error_mark_node
;
1882 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member
)));
1883 addr
= convert_pointer_to (basetype
, addr
);
1884 member
= cp_convert (ptrdiff_type_node
, member
);
1887 /* Pointer to data members are offset by one, so that a null
1888 pointer with a real value of 0 is distinguishable from an
1889 offset of the first member of a structure. */
1890 member
= build_binary_op (MINUS_EXPR
, member
,
1891 cp_convert (ptrdiff_type_node
,
1894 return build1 (INDIRECT_REF
, type
,
1895 build (PLUS_EXPR
, build_pointer_type (type
),
1898 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1900 return get_member_function_from_ptrfunc (&addr
, member
);
1902 my_friendly_abort (56);
1907 /* If DECL is a `const' declaration, and its value is a known
1908 constant, then return that value. */
1911 decl_constant_value (decl
)
1914 if (TREE_READONLY_DECL_P (decl
)
1915 && ! TREE_THIS_VOLATILE (decl
)
1916 && DECL_INITIAL (decl
)
1917 && DECL_INITIAL (decl
) != error_mark_node
1918 /* This is invalid if initial value is not constant.
1919 If it has either a function call, a memory reference,
1920 or a variable, then re-evaluating it could give different results. */
1921 && TREE_CONSTANT (DECL_INITIAL (decl
))
1922 /* Check for cases where this is sub-optimal, even though valid. */
1923 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1924 return DECL_INITIAL (decl
);
1928 /* Common subroutines of build_new and build_vec_delete. */
1930 /* Call the global __builtin_delete to delete ADDR. */
1933 build_builtin_delete_call (addr
)
1936 mark_used (global_delete_fndecl
);
1937 return build_call (global_delete_fndecl
, build_tree_list (NULL_TREE
, addr
));
1940 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1941 (which needs to go through some sort of groktypename) or it
1942 is the name of the class we are newing. INIT is an initialization value.
1943 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1944 If INIT is void_type_node, it means do *not* call a constructor
1947 For types with constructors, the data returned is initialized
1948 by the appropriate constructor.
1950 Whether the type has a constructor or not, if it has a pointer
1951 to a virtual function table, then that pointer is set up
1954 Unless I am mistaken, a call to new () will return initialized
1955 data regardless of whether the constructor itself is private or
1956 not. NOPE; new fails if the constructor is private (jcm).
1958 Note that build_new does nothing to assure that any special
1959 alignment requirements of the type are met. Rather, it leaves
1960 it up to malloc to do the right thing. Otherwise, folding to
1961 the right alignment cal cause problems if the user tries to later
1962 free the memory returned by `new'.
1964 PLACEMENT is the `placement' list for user-defined operator new (). */
1966 extern int flag_check_new
;
1969 build_new (placement
, decl
, init
, use_global_new
)
1975 tree nelts
= NULL_TREE
, t
;
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
;
1986 if (current_function_decl
1987 && DECL_CONSTRUCTOR_P (current_function_decl
))
1988 my_friendly_assert (immediate_size_expand
== 0, 19990926);
1990 nelts
= integer_one_node
;
1992 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
1993 my_friendly_abort (215);
1994 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
1996 last_absdcl
= absdcl
;
1997 absdcl
= TREE_OPERAND (absdcl
, 0);
2000 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2002 /* probably meant to be a vec new */
2005 while (TREE_OPERAND (absdcl
, 0)
2006 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2008 last_absdcl
= absdcl
;
2009 absdcl
= TREE_OPERAND (absdcl
, 0);
2013 this_nelts
= TREE_OPERAND (absdcl
, 1);
2014 if (this_nelts
!= error_mark_node
)
2016 if (this_nelts
== NULL_TREE
)
2017 error ("new of array type fails to specify size");
2018 else if (processing_template_decl
)
2021 absdcl
= TREE_OPERAND (absdcl
, 0);
2025 int flags
= pedantic
? WANT_INT
: (WANT_INT
| WANT_ENUM
);
2026 if (build_expr_type_conversion (flags
, this_nelts
, 0)
2028 pedwarn ("size in array new must have integral type");
2030 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2031 absdcl
= TREE_OPERAND (absdcl
, 0);
2032 if (this_nelts
== integer_zero_node
)
2034 warning ("zero size array reserves no space");
2035 nelts
= integer_zero_node
;
2038 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2042 nelts
= integer_zero_node
;
2046 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2048 TREE_VALUE (decl
) = absdcl
;
2050 type
= groktypename (decl
);
2051 if (! type
|| type
== error_mark_node
)
2052 return error_mark_node
;
2054 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2056 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2058 /* An aggregate type. */
2059 type
= IDENTIFIER_TYPE_VALUE (decl
);
2060 decl
= TYPE_MAIN_DECL (type
);
2064 /* A builtin type. */
2065 decl
= lookup_name (decl
, 1);
2066 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2067 type
= TREE_TYPE (decl
);
2070 else if (TREE_CODE (decl
) == TYPE_DECL
)
2072 type
= TREE_TYPE (decl
);
2077 decl
= TYPE_MAIN_DECL (type
);
2080 if (processing_template_decl
)
2083 t
= tree_cons (tree_cons (NULL_TREE
, type
, NULL_TREE
),
2084 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2089 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2090 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2094 /* ``A reference cannot be created by the new operator. A reference
2095 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2096 returned by new.'' ARM 5.3.3 */
2097 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2099 error ("new cannot be applied to a reference type");
2100 type
= TREE_TYPE (type
);
2103 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2105 error ("new cannot be applied to a function type");
2106 return error_mark_node
;
2109 /* When the object being created is an array, the new-expression yields a
2110 pointer to the initial element (if any) of the array. For example,
2111 both new int and new int[10] return an int*. 5.3.4. */
2112 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2114 nelts
= array_type_nelts_top (type
);
2116 type
= TREE_TYPE (type
);
2120 t
= build_nt (ARRAY_REF
, type
, nelts
);
2124 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2125 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2126 TREE_SIDE_EFFECTS (rval
) = 1;
2127 rval
= build_new_1 (rval
);
2128 if (rval
== error_mark_node
)
2129 return error_mark_node
;
2131 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2132 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2133 TREE_NO_UNUSED_WARNING (rval
) = 1;
2138 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2141 build_java_class_ref (type
)
2144 tree name
, class_decl
;
2145 static tree CL_prefix
= NULL_TREE
;
2146 if (CL_prefix
== NULL_TREE
)
2147 CL_prefix
= get_identifier("_CL_");
2148 if (jclass_node
== NULL_TREE
)
2150 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2151 if (jclass_node
== NULL_TREE
)
2152 fatal("call to Java constructor, while `jclass' undefined");
2153 jclass_node
= TREE_TYPE (jclass_node
);
2155 name
= build_overload_with_type (CL_prefix
, type
);
2156 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2157 if (class_decl
== NULL_TREE
)
2159 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2160 TREE_STATIC (class_decl
) = 1;
2161 DECL_EXTERNAL (class_decl
) = 1;
2162 TREE_PUBLIC (class_decl
) = 1;
2163 DECL_ARTIFICIAL (class_decl
) = 1;
2164 DECL_IGNORED_P (class_decl
) = 1;
2165 pushdecl_top_level (class_decl
);
2166 make_decl_rtl (class_decl
, NULL_PTR
, 1);
2171 /* Returns teh size of the cookie to use when allocating an array
2172 whose elements have the indicated TYPE. Assumes that it is already
2173 known that a cookie is needed. */
2176 get_cookie_size (type
)
2183 /* Under the new ABI, we need to allocate an additional max
2184 (sizeof (size_t), alignof (true_type)) bytes. */
2188 sizetype_size
= size_in_bytes (sizetype
);
2189 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
2190 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
2191 cookie_size
= sizetype_size
;
2193 cookie_size
= type_align
;
2196 cookie_size
= BI_header_size
;
2201 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2202 value is immediately handed to expand_expr. */
2208 tree placement
, init
;
2209 tree type
, true_type
, size
, rval
;
2210 tree nelts
= NULL_TREE
;
2211 tree alloc_expr
, alloc_node
= NULL_TREE
;
2213 enum tree_code code
;
2214 int use_cookie
, nothrow
, check_new
;
2215 /* Nonzero if the user wrote `::new' rather than just `new'. */
2216 int globally_qualified_p
;
2217 /* Nonzero if we're going to call a global operator new, rather than
2218 a class-specific version. */
2220 int use_java_new
= 0;
2221 /* If non-NULL, the number of extra bytes to allocate at the
2222 beginning of the storage allocated for an array-new expression in
2223 order to store the number of elements. */
2224 tree cookie_size
= NULL_TREE
;
2226 placement
= TREE_OPERAND (exp
, 0);
2227 type
= TREE_OPERAND (exp
, 1);
2228 init
= TREE_OPERAND (exp
, 2);
2229 globally_qualified_p
= NEW_EXPR_USE_GLOBAL (exp
);
2231 if (TREE_CODE (type
) == ARRAY_REF
)
2234 nelts
= TREE_OPERAND (type
, 1);
2235 type
= TREE_OPERAND (type
, 0);
2239 code
= has_array
? VEC_NEW_EXPR
: NEW_EXPR
;
2241 if (CP_TYPE_QUALS (type
))
2242 type
= TYPE_MAIN_VARIANT (type
);
2244 /* If our base type is an array, then make sure we know how many elements
2246 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2248 tree this_nelts
= array_type_nelts_top (true_type
);
2249 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2250 true_type
= TREE_TYPE (true_type
);
2253 if (!complete_type_or_else (true_type
, exp
))
2254 return error_mark_node
;
2257 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2260 size
= size_in_bytes (type
);
2262 if (TREE_CODE (true_type
) == VOID_TYPE
)
2264 error ("invalid type `void' for new");
2265 return error_mark_node
;
2268 if (abstract_virtuals_error (NULL_TREE
, true_type
))
2269 return error_mark_node
;
2271 /* Figure out whether or not we're going to use the global operator
2273 if (!globally_qualified_p
2274 && IS_AGGR_TYPE (true_type
)
2275 && ((!has_array
&& TYPE_HAS_NEW_OPERATOR (true_type
))
2276 || (has_array
&& TYPE_HAS_ARRAY_NEW_OPERATOR (true_type
))))
2281 /* We only need cookies for arrays containing types for which we
2283 if (!has_array
|| !TYPE_VEC_NEW_USES_COOKIE (true_type
))
2285 /* When using placement new, users may not realize that they need
2286 the extra storage. Under the old ABI, we don't allocate the
2287 cookie whenever they use one placement argument of type `void
2288 *'. Under the new ABI, we require that the operator called be
2289 the global placement operator delete[]. */
2290 else if (placement
&& !TREE_CHAIN (placement
)
2291 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2293 use_cookie
= (!flag_new_abi
|| !use_global_new
);
2294 /* Otherwise, we need the cookie. */
2298 /* Compute the number of extra bytes to allocate, now that we know
2299 whether or not we need the cookie. */
2302 cookie_size
= get_cookie_size (true_type
);
2303 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
2306 if (has_array
&& init
&& pedantic
)
2307 cp_pedwarn ("initialization in array new");
2309 /* Allocate the object. */
2311 if (! placement
&& TYPE_FOR_JAVA (true_type
))
2313 tree class_addr
, alloc_decl
;
2314 tree class_decl
= build_java_class_ref (true_type
);
2315 tree class_size
= size_in_bytes (true_type
);
2316 static char alloc_name
[] = "_Jv_AllocObject";
2318 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2319 if (alloc_decl
== NULL_TREE
)
2320 fatal("call to Java constructor, while `%s' undefined", alloc_name
);
2321 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2322 rval
= build_function_call (alloc_decl
,
2323 tree_cons (NULL_TREE
, class_addr
,
2324 build_tree_list (NULL_TREE
,
2326 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2333 args
= tree_cons (NULL_TREE
, size
, placement
);
2334 fnname
= ansi_opname
[code
];
2337 rval
= (build_new_function_call
2338 (lookup_function_nonclass (fnname
, args
),
2341 rval
= build_method_call (build_dummy_object (true_type
),
2342 fnname
, args
, NULL_TREE
,
2344 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2347 /* unless an allocation function is declared with an empty excep-
2348 tion-specification (_except.spec_), throw(), it indicates failure to
2349 allocate storage by throwing a bad_alloc exception (clause _except_,
2350 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2351 cation function is declared with an empty exception-specification,
2352 throw(), it returns null to indicate failure to allocate storage and a
2353 non-null pointer otherwise.
2355 So check for a null exception spec on the op new we just called. */
2360 /* The CALL_EXPR. */
2361 tree t
= TREE_OPERAND (rval
, 0);
2363 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
2364 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (t
));
2366 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2368 if ((check_new
|| flag_exceptions
) && rval
)
2370 alloc_expr
= get_target_expr (rval
);
2371 alloc_node
= rval
= TREE_OPERAND (alloc_expr
, 0);
2374 alloc_expr
= NULL_TREE
;
2376 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2377 sure we have some extra bytes in that case for the BI_header_size
2378 cookies? And how does that interact with the code below? (mrs) */
2379 /* Finish up some magic for new'ed arrays */
2380 if (use_cookie
&& rval
!= NULL_TREE
)
2383 rval
= convert (string_type_node
, rval
); /* for ptr arithmetic */
2384 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, cookie_size
));
2385 /* Store the number of bytes allocated so that we can know how
2386 many elements to destroy later. */
2389 /* Under the new ABI, we use the last sizeof (size_t) bytes
2390 to store the number of elements. */
2391 cookie
= build_indirect_ref (build (MINUS_EXPR
,
2392 build_pointer_type (sizetype
),
2394 size_in_bytes (sizetype
)),
2396 exp1
= build (MODIFY_EXPR
, void_type_node
, cookie
, nelts
);
2401 = build_indirect_ref (build (MINUS_EXPR
,
2402 build_pointer_type (BI_header_type
),
2403 rval
, cookie_size
), NULL_PTR
);
2404 exp1
= build (MODIFY_EXPR
, void_type_node
,
2405 build_component_ref (cookie
, nelts_identifier
,
2410 /* Build `(cookie = nelts, rval)' and use that as the complete
2412 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2413 rval
= build_compound_expr
2414 (tree_cons (NULL_TREE
, exp1
,
2415 build_tree_list (NULL_TREE
, rval
)));
2418 if (rval
== error_mark_node
)
2419 return error_mark_node
;
2421 /* Don't call any constructors or do any initialization. */
2422 if (init
== void_type_node
)
2425 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2427 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2428 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2430 /* We are processing something like `new int (10)', which
2431 means allocate an int, and initialize it with 10. */
2435 /* At present RVAL is a temporary variable, created to hold
2436 the value from the call to `operator new'. We transform
2437 it to (*RVAL = INIT, RVAL). */
2438 rval
= save_expr (rval
);
2439 deref
= build_indirect_ref (rval
, NULL_PTR
);
2441 /* Even for something like `new const int (10)' we must
2442 allow the expression to be non-const while we do the
2444 deref_type
= TREE_TYPE (deref
);
2445 if (CP_TYPE_CONST_P (deref_type
))
2447 = cp_build_qualified_type (deref_type
,
2448 CP_TYPE_QUALS (deref_type
)
2449 & ~TYPE_QUAL_CONST
);
2450 TREE_READONLY (deref
) = 0;
2452 if (TREE_CHAIN (init
) != NULL_TREE
)
2453 pedwarn ("initializer list being treated as compound expression");
2454 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2456 pedwarn ("initializer list appears where operand should be used");
2457 init
= TREE_OPERAND (init
, 1);
2459 init
= build_compound_expr (init
);
2461 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2462 "new", NULL_TREE
, 0);
2463 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2464 build_modify_expr (deref
, NOP_EXPR
, init
),
2466 TREE_NO_UNUSED_WARNING (rval
) = 1;
2467 TREE_SIDE_EFFECTS (rval
) = 1;
2469 else if (! has_array
)
2472 /* Constructors are never virtual. If it has an initialization, we
2473 need to complain if we aren't allowed to use the ctor that took
2475 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2477 rval
= save_expr (rval
);
2480 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2481 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2483 newrval
= build_method_call (newrval
,
2484 complete_ctor_identifier
,
2485 init
, TYPE_BINFO (true_type
), flags
);
2487 if (newrval
== NULL_TREE
|| newrval
== error_mark_node
)
2488 return error_mark_node
;
2490 newrval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), newrval
, rval
);
2492 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2495 rval
= (build_vec_init
2498 build_binary_op (MINUS_EXPR
, nelts
, integer_one_node
),
2502 /* If any part of the object initialization terminates by throwing an
2503 exception and a suitable deallocation function can be found, the
2504 deallocation function is called to free the memory in which the
2505 object was being constructed, after which the exception continues
2506 to propagate in the context of the new-expression. If no
2507 unambiguous matching deallocation function can be found,
2508 propagating the exception does not cause the object's memory to be
2510 if (flag_exceptions
&& alloc_expr
&& ! use_java_new
)
2512 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2513 tree cleanup
, fn
= NULL_TREE
;
2514 int flags
= (LOOKUP_NORMAL
2515 | (globally_qualified_p
* LOOKUP_GLOBAL
));
2517 /* The Standard is unclear here, but the right thing to do
2518 is to use the same method for finding deallocation
2519 functions that we use for finding allocation functions. */
2520 flags
|= LOOKUP_SPECULATIVELY
;
2522 /* We expect alloc_expr to look like a TARGET_EXPR around
2523 a NOP_EXPR around the CALL_EXPR we want. */
2524 fn
= TREE_OPERAND (alloc_expr
, 1);
2525 fn
= TREE_OPERAND (fn
, 0);
2527 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
, fn
);
2529 /* Ack! First we allocate the memory. Then we set our sentry
2530 variable to true, and expand a cleanup that deletes the memory
2531 if sentry is true. Then we run the constructor and store the
2532 returned pointer in buf. Then we clear sentry and return buf. */
2536 tree end
, sentry
, begin
, buf
, t
= TREE_TYPE (rval
);
2538 begin
= get_target_expr (boolean_true_node
);
2539 sentry
= TREE_OPERAND (begin
, 0);
2541 TREE_OPERAND (begin
, 2)
2542 = build (COND_EXPR
, void_type_node
, sentry
,
2543 cleanup
, void_zero_node
);
2545 rval
= get_target_expr (rval
);
2547 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2548 sentry
, boolean_false_node
);
2550 buf
= TREE_OPERAND (rval
, 0);
2552 rval
= build (COMPOUND_EXPR
, t
, begin
,
2553 build (COMPOUND_EXPR
, t
, rval
,
2554 build (COMPOUND_EXPR
, t
, end
, buf
)));
2558 else if (CP_TYPE_CONST_P (true_type
))
2559 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2563 if (alloc_expr
&& rval
== alloc_node
)
2565 rval
= TREE_OPERAND (alloc_expr
, 1);
2566 alloc_expr
= NULL_TREE
;
2569 if (check_new
&& alloc_expr
)
2571 /* Did we modify the storage? */
2572 tree ifexp
= build_binary_op (NE_EXPR
, alloc_node
,
2574 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2578 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2580 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2582 /* The type of new int [3][3] is not int *, but int [3] * */
2583 rval
= build_c_cast (build_pointer_type (type
), rval
);
2590 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, use_global_delete
)
2591 tree base
, maxindex
, type
;
2592 special_function_kind auto_delete_vec
;
2593 int use_global_delete
;
2596 tree ptype
= build_pointer_type (type
= complete_type (type
));
2597 tree size_exp
= size_in_bytes (type
);
2599 /* Temporary variables used by the loop. */
2600 tree tbase
, tbase_init
;
2602 /* This is the body of the loop that implements the deletion of a
2603 single element, and moves temp variables to next elements. */
2606 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2609 /* This is the thing that governs what to do after the loop has run. */
2610 tree deallocate_expr
= 0;
2612 /* This is the BIND_EXPR which holds the outermost iterator of the
2613 loop. It is convenient to set this variable up and test it before
2614 executing any other code in the loop.
2615 This is also the containing expression returned by this function. */
2616 tree controller
= NULL_TREE
;
2618 if (! IS_AGGR_TYPE (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2620 loop
= integer_zero_node
;
2624 /* The below is short by BI_header_size */
2625 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2626 convert (sizetype
, maxindex
));
2628 tbase
= create_temporary_var (ptype
);
2629 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2630 fold (build (PLUS_EXPR
, ptype
,
2633 DECL_REGISTER (tbase
) = 1;
2634 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2635 TREE_SIDE_EFFECTS (controller
) = 1;
2639 body
= tree_cons (NULL_TREE
,
2640 build_delete (ptype
, tbase
, sfk_complete_destructor
,
2641 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2644 body
= tree_cons (NULL_TREE
,
2645 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2648 body
= tree_cons (NULL_TREE
,
2649 build (EXIT_EXPR
, void_type_node
,
2650 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2653 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2655 loop
= tree_cons (NULL_TREE
, tbase_init
,
2656 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2657 loop
= build_compound_expr (loop
);
2660 /* If the delete flag is one, or anything else with the low bit set,
2661 delete the storage. */
2662 deallocate_expr
= integer_zero_node
;
2663 if (auto_delete_vec
!= sfk_base_destructor
)
2667 /* The below is short by BI_header_size */
2668 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2669 convert (sizetype
, maxindex
));
2671 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2678 cookie_size
= get_cookie_size (type
);
2680 = cp_convert (ptype
,
2681 build_binary_op (MINUS_EXPR
,
2682 cp_convert (string_type_node
, base
),
2684 /* True size with header. */
2685 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2688 if (auto_delete_vec
== sfk_deleting_destructor
)
2689 deallocate_expr
= build_x_delete (base_tbd
,
2690 2 | use_global_delete
,
2694 if (loop
&& deallocate_expr
!= integer_zero_node
)
2696 body
= tree_cons (NULL_TREE
, loop
,
2697 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2698 body
= build_compound_expr (body
);
2703 /* Outermost wrapper: If pointer is null, punt. */
2704 body
= fold (build (COND_EXPR
, void_type_node
,
2705 fold (build (NE_EXPR
, boolean_type_node
, base
,
2706 integer_zero_node
)),
2707 body
, integer_zero_node
));
2708 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2712 TREE_OPERAND (controller
, 1) = body
;
2716 return cp_convert (void_type_node
, body
);
2720 create_temporary_var (type
)
2725 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2726 TREE_USED (decl
) = 1;
2727 DECL_ARTIFICIAL (decl
) = 1;
2728 DECL_SOURCE_FILE (decl
) = input_filename
;
2729 DECL_SOURCE_LINE (decl
) = lineno
;
2730 DECL_IGNORED_P (decl
) = 1;
2731 DECL_CONTEXT (decl
) = current_function_decl
;
2736 /* Create a new temporary variable of the indicated TYPE, initialized
2739 It is not entered into current_binding_level, because that breaks
2740 things when it comes time to do final cleanups (which take place
2741 "outside" the binding contour of the function). */
2744 get_temp_regvar (type
, init
)
2749 decl
= create_temporary_var (type
);
2750 if (building_stmt_tree ())
2751 add_decl_stmt (decl
);
2752 if (!building_stmt_tree ())
2753 DECL_RTL (decl
) = assign_temp (type
, 2, 0, 1);
2754 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
2759 /* `build_vec_init' returns tree structure that performs
2760 initialization of a vector of aggregate types.
2762 DECL is passed only for error reporting, and provides line number
2763 and source file name information.
2764 BASE is the space where the vector will be. For a vector of Ts,
2765 the type of BASE is `T*'.
2766 MAXINDEX is the maximum index of the array (one less than the
2767 number of elements).
2768 INIT is the (possibly NULL) initializer.
2770 FROM_ARRAY is 0 if we should init everything with INIT
2771 (i.e., every element initialized from INIT).
2772 FROM_ARRAY is 1 if we should index into INIT in parallel
2773 with initialization of DECL.
2774 FROM_ARRAY is 2 if we should index into INIT in parallel,
2775 but use assignment instead of initialization. */
2778 build_vec_init (decl
, base
, maxindex
, init
, from_array
)
2779 tree decl
, base
, maxindex
, init
;
2783 tree base2
= NULL_TREE
;
2785 tree itype
= NULL_TREE
;
2787 /* The type of an element in the array. */
2789 /* The type of a pointer to an element in the array. */
2794 tree try_block
= NULL_TREE
;
2795 tree try_body
= NULL_TREE
;
2796 int num_initialized_elts
= 0;
2798 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2799 if (maxindex
== error_mark_node
)
2800 return error_mark_node
;
2802 type
= TREE_TYPE (TREE_TYPE (base
));
2803 ptype
= build_pointer_type (type
);
2804 size
= size_in_bytes (type
);
2806 /* The code we are generating looks like:
2810 ptrdiff_t iterator = maxindex;
2812 ... initializations from CONSTRUCTOR ...
2813 if (iterator != -1) {
2815 ... initialize *base ...
2817 } while (--iterator != -1);
2820 ... destroy elements that were constructed ...
2823 We can omit the try and catch blocks if we know that the
2824 initialization will never throw an exception, or if the array
2825 elements do not have destructors. If we have a CONSTRUCTOR to
2826 give us initialization information, we emit code to initialize
2827 each of the elements before the loop in the try block, and then
2828 iterate over fewer elements. We can omit the loop completely if
2829 the elements of the array do not have constructors.
2831 We actually wrap the entire body of the above in a STMT_EXPR, for
2834 When copying from array to another, when the array elements have
2835 only trivial copy constructors, we should use __builtin_memcpy
2836 rather than generating a loop. That way, we could take advantage
2837 of whatever cleverness the back-end has for dealing with copies
2838 of blocks of memory. */
2840 begin_init_stmts (&stmt_expr
, &compound_stmt
);
2841 destroy_temps
= stmts_are_full_exprs_p
;
2842 stmts_are_full_exprs_p
= 0;
2843 rval
= get_temp_regvar (ptype
,
2844 cp_convert (ptype
, default_conversion (base
)));
2845 base
= get_temp_regvar (ptype
, rval
);
2846 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2848 /* Protect the entire array initialization so that we can destroy
2849 the partially constructed array if an exception is thrown. */
2850 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2852 try_block
= begin_try_block ();
2853 try_body
= begin_compound_stmt (/*has_no_scope=*/1);
2856 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
2857 && (!decl
|| same_type_p (TREE_TYPE (init
), TREE_TYPE (decl
))))
2859 /* Do non-default initialization resulting from brace-enclosed
2865 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2867 tree elt
= TREE_VALUE (elts
);
2868 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2870 num_initialized_elts
++;
2872 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2873 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0));
2875 finish_expr_stmt (build_modify_expr (baseref
, NOP_EXPR
,
2878 finish_expr_stmt (build_modify_expr
2881 build (PLUS_EXPR
, build_pointer_type (type
),
2883 finish_expr_stmt (build_modify_expr
2886 build (MINUS_EXPR
, ptrdiff_type_node
,
2887 iterator
, integer_one_node
)));
2890 /* Clear out INIT so that we don't get confused below. */
2893 else if (from_array
)
2895 /* If initializing one array from another, initialize element by
2896 element. We rely upon the below calls the do argument
2898 if (decl
== NULL_TREE
)
2900 sorry ("initialization of array from dissimilar array type");
2901 return error_mark_node
;
2905 base2
= default_conversion (init
);
2906 itype
= TREE_TYPE (base2
);
2907 base2
= get_temp_regvar (itype
, base2
);
2908 itype
= TREE_TYPE (itype
);
2910 else if (TYPE_LANG_SPECIFIC (type
)
2911 && TYPE_NEEDS_CONSTRUCTING (type
)
2912 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2914 error ("initializer ends prematurely");
2915 return error_mark_node
;
2919 /* Now, default-initialize any remaining elements. We don't need to
2920 do that if a) the type does not need constructing, or b) we've
2921 already initialized all the elements.
2923 We do need to keep going if we're copying an array. */
2926 || (TYPE_NEEDS_CONSTRUCTING (type
)
2927 && ! (host_integerp (maxindex
, 0)
2928 && (num_initialized_elts
2929 == tree_low_cst (maxindex
, 0) + 1))))
2931 /* If the ITERATOR is equal to -1, then we don't have to loop;
2932 we've already initialized all the elements. */
2938 if_stmt
= begin_if_stmt ();
2939 finish_if_stmt_cond (build (NE_EXPR
, boolean_type_node
,
2940 iterator
, minus_one_node
),
2943 /* Otherwise, loop through the elements. */
2944 do_stmt
= begin_do_stmt ();
2945 do_body
= begin_compound_stmt (/*has_no_scope=*/1);
2947 /* When we're not building a statement-tree, things are a little
2948 complicated. If, when we recursively call build_aggr_init,
2949 an expression containing a TARGET_EXPR is expanded, then it
2950 may get a cleanup. Then, the result of that expression is
2951 passed to finish_expr_stmt, which will call
2952 expand_start_target_temps/expand_end_target_temps. However,
2953 the latter call will not cause the cleanup to run because
2954 that block will still be on the block stack. So, we call
2955 expand_start_target_temps here manually; the corresponding
2956 call to expand_end_target_temps below will cause the cleanup
2958 if (!building_stmt_tree ())
2959 expand_start_target_temps ();
2963 tree to
= build1 (INDIRECT_REF
, type
, base
);
2967 from
= build1 (INDIRECT_REF
, itype
, base2
);
2971 if (from_array
== 2)
2972 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
2973 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2974 elt_init
= build_aggr_init (to
, from
, 0);
2976 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
2978 my_friendly_abort (57);
2980 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2983 sorry ("cannot initialize multi-dimensional array with initializer");
2984 elt_init
= (build_vec_init
2987 build_pointer_type (TREE_TYPE (type
)),
2989 array_type_nelts (type
), 0, 0));
2992 elt_init
= build_aggr_init (build1 (INDIRECT_REF
, type
, base
),
2995 /* The initialization of each array element is a
2997 if (!building_stmt_tree ())
2999 finish_expr_stmt (elt_init
);
3000 expand_end_target_temps ();
3004 stmts_are_full_exprs_p
= 1;
3005 finish_expr_stmt (elt_init
);
3006 stmts_are_full_exprs_p
= 0;
3009 finish_expr_stmt (build_modify_expr
3012 build (PLUS_EXPR
, build_pointer_type (type
),
3015 finish_expr_stmt (build_modify_expr
3018 build (PLUS_EXPR
, build_pointer_type (type
),
3021 finish_compound_stmt (/*has_no_scope=*/1, do_body
);
3022 finish_do_body (do_stmt
);
3023 finish_do_stmt (build (NE_EXPR
, boolean_type_node
,
3024 build (PREDECREMENT_EXPR
,
3031 finish_then_clause (if_stmt
);
3035 /* Make sure to cleanup any partially constructed elements. */
3036 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3040 finish_compound_stmt (/*has_no_scope=*/1, try_body
);
3041 finish_cleanup_try_block (try_block
);
3042 e
= build_vec_delete_1 (rval
,
3043 build_binary_op (MINUS_EXPR
, maxindex
,
3046 sfk_base_destructor
,
3047 /*use_global_delete=*/0);
3048 finish_cleanup (e
, try_block
);
3051 /* The value of the array initialization is the address of the
3052 first element in the array. */
3053 finish_expr_stmt (rval
);
3055 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
3056 stmts_are_full_exprs_p
= destroy_temps
;
3060 /* Free up storage of type TYPE, at address ADDR.
3062 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3065 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3066 used as the second argument to operator delete. It can include
3067 things like padding and magic size cookies. It has virtual in it,
3068 because if you have a base pointer and you delete through a virtual
3069 destructor, it should be the size of the dynamic object, not the
3070 static object, see Free Store 12.5 ISO C++.
3072 This does not call any destructors. */
3075 build_x_delete (addr
, which_delete
, virtual_size
)
3080 int use_global_delete
= which_delete
& 1;
3081 int use_vec_delete
= !!(which_delete
& 2);
3082 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3083 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
3085 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
3088 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3092 build_dtor_call (exp
, dtor_kind
, flags
)
3094 special_function_kind dtor_kind
;
3101 case sfk_complete_destructor
:
3102 name
= complete_dtor_identifier
;
3105 case sfk_base_destructor
:
3106 name
= base_dtor_identifier
;
3109 case sfk_deleting_destructor
:
3110 name
= deleting_dtor_identifier
;
3114 my_friendly_abort (20000524);
3116 return build_method_call (exp
, name
, NULL_TREE
, NULL_TREE
, flags
);
3119 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3120 ADDR is an expression which yields the store to be destroyed.
3121 AUTO_DELETE is the name of the destructor to call, i.e., either
3122 sfk_complete_destructor, sfk_base_destructor, or
3123 sfk_deleting_destructor.
3125 FLAGS is the logical disjunction of zero or more LOOKUP_
3126 flags. See cp-tree.h for more info.
3128 This function does not delete an object's virtual base classes. */
3131 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3133 special_function_kind auto_delete
;
3135 int use_global_delete
;
3141 if (addr
== error_mark_node
)
3142 return error_mark_node
;
3144 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3145 set to `error_mark_node' before it gets properly cleaned up. */
3146 if (type
== error_mark_node
)
3147 return error_mark_node
;
3149 type
= TYPE_MAIN_VARIANT (type
);
3151 if (TREE_CODE (type
) == POINTER_TYPE
)
3153 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3154 if (type
!= void_type_node
&& !complete_type_or_else (type
, addr
))
3155 return error_mark_node
;
3156 if (TREE_CODE (type
) == ARRAY_TYPE
)
3158 if (! IS_AGGR_TYPE (type
))
3160 /* Call the builtin operator delete. */
3161 return build_builtin_delete_call (addr
);
3163 if (TREE_SIDE_EFFECTS (addr
))
3164 addr
= save_expr (addr
);
3166 /* throw away const and volatile on target type of addr */
3167 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3168 ref
= build_indirect_ref (addr
, NULL_PTR
);
3170 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3173 if (TREE_SIDE_EFFECTS (addr
))
3174 addr
= save_expr (addr
);
3175 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3177 error ("unknown array size in delete");
3178 return error_mark_node
;
3180 return build_vec_delete (addr
, array_type_nelts (type
),
3181 auto_delete
, use_global_delete
);
3185 /* Don't check PROTECT here; leave that decision to the
3186 destructor. If the destructor is accessible, call it,
3187 else report error. */
3188 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3189 if (TREE_SIDE_EFFECTS (addr
))
3190 addr
= save_expr (addr
);
3192 if (TREE_CONSTANT (addr
))
3193 addr
= convert_pointer_to (type
, addr
);
3195 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3197 ref
= build_indirect_ref (addr
, NULL_PTR
);
3200 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3202 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3204 if (auto_delete
== sfk_base_destructor
)
3205 return void_zero_node
;
3207 return build_op_delete_call
3208 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3209 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3213 /* Below, we will reverse the order in which these calls are made.
3214 If we have a destructor, then that destructor will take care
3215 of the base classes; otherwise, we must do that here. */
3216 if (TYPE_HAS_DESTRUCTOR (type
))
3218 tree do_delete
= NULL_TREE
;
3221 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3223 /* Delete the object. */
3224 do_delete
= build_builtin_delete_call (addr
);
3225 /* Otherwise, treat this like a complete object destructor
3227 auto_delete
= sfk_complete_destructor
;
3230 expr
= build_dtor_call (ref
, auto_delete
, flags
);
3232 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3234 if (flags
& LOOKUP_DESTRUCTOR
)
3235 /* Explicit destructor call; don't check for null pointer. */
3236 ifexp
= integer_one_node
;
3238 /* Handle deleting a null pointer. */
3239 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
));
3241 if (ifexp
!= integer_one_node
)
3242 expr
= build (COND_EXPR
, void_type_node
,
3243 ifexp
, expr
, void_zero_node
);
3249 /* We only get here from finish_function for a destructor. */
3250 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3251 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (type
);
3252 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3253 tree exprstmt
= NULL_TREE
;
3255 /* Set this again before we call anything, as we might get called
3257 TYPE_HAS_DESTRUCTOR (type
) = 1;
3259 /* If we have member delete or vbases, we call delete in
3261 my_friendly_assert (auto_delete
== sfk_base_destructor
, 20000411);
3263 /* Take care of the remaining baseclasses. */
3264 for (i
= 0; i
< n_baseclasses
; i
++)
3266 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3267 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3268 || TREE_VIA_VIRTUAL (base_binfo
))
3271 expr
= build_scoped_method_call (ref
, base_binfo
,
3272 base_dtor_identifier
,
3275 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3278 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3280 if (TREE_CODE (member
) != FIELD_DECL
)
3282 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member
)))
3284 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3285 tree this_type
= TREE_TYPE (member
);
3286 expr
= build_delete (this_type
, this_member
,
3287 sfk_complete_destructor
, flags
, 0);
3288 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3293 return build_compound_expr (exprstmt
);
3294 /* Virtual base classes make this function do nothing. */
3295 return void_zero_node
;
3299 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3302 build_vbase_delete (type
, decl
)
3305 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3306 tree result
= NULL_TREE
;
3307 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3309 my_friendly_assert (addr
!= error_mark_node
, 222);
3314 = convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases
))),
3316 result
= tree_cons (NULL_TREE
,
3317 build_delete (TREE_TYPE (this_addr
), this_addr
,
3318 sfk_base_destructor
,
3319 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3321 vbases
= TREE_CHAIN (vbases
);
3323 return build_compound_expr (nreverse (result
));
3326 /* Build a C++ vector delete expression.
3327 MAXINDEX is the number of elements to be deleted.
3328 ELT_SIZE is the nominal size of each element in the vector.
3329 BASE is the expression that should yield the store to be deleted.
3330 This function expands (or synthesizes) these calls itself.
3331 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3333 This also calls delete for virtual baseclasses of elements of the vector.
3335 Update: MAXINDEX is no longer needed. The size can be extracted from the
3336 start of the vector for pointers, and from the type for arrays. We still
3337 use MAXINDEX for arrays because it happens to already have one of the
3338 values we'd have to extract. (We could use MAXINDEX with pointers to
3339 confirm the size, and trap if the numbers differ; not clear that it'd
3340 be worth bothering.) */
3343 build_vec_delete (base
, maxindex
, auto_delete_vec
, use_global_delete
)
3344 tree base
, maxindex
;
3345 special_function_kind auto_delete_vec
;
3346 int use_global_delete
;
3350 if (TREE_CODE (base
) == OFFSET_REF
)
3351 base
= resolve_offset_ref (base
);
3353 type
= TREE_TYPE (base
);
3355 base
= stabilize_reference (base
);
3357 /* Since we can use base many times, save_expr it. */
3358 if (TREE_SIDE_EFFECTS (base
))
3359 base
= save_expr (base
);
3361 if (TREE_CODE (type
) == POINTER_TYPE
)
3363 /* Step back one from start of vector, and read dimension. */
3368 cookie_addr
= build (MINUS_EXPR
,
3369 build_pointer_type (sizetype
),
3371 TYPE_SIZE_UNIT (sizetype
));
3372 maxindex
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3378 cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3379 base
, BI_header_size
);
3380 cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3381 maxindex
= build_component_ref (cookie
, nelts_identifier
,
3385 type
= strip_array_types (TREE_TYPE (type
));
3387 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3389 /* get the total number of things in the array, maxindex is a bad name */
3390 maxindex
= array_type_nelts_total (type
);
3391 type
= strip_array_types (type
);
3392 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3396 if (base
!= error_mark_node
)
3397 error ("type to vector delete is neither pointer or array type");
3398 return error_mark_node
;
3401 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,