1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 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
*, 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
, 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_default_init
PARAMS ((tree
));
53 static tree build_new_1
PARAMS ((tree
));
54 static tree get_cookie_size
PARAMS ((tree
));
55 static tree build_dtor_call
PARAMS ((tree
, special_function_kind
, int));
56 static tree build_field_list
PARAMS ((tree
, tree
, int *));
57 static tree build_vtbl_address
PARAMS ((tree
));
59 /* Set up local variable for this file. MUST BE CALLED AFTER
60 INIT_DECL_PROCESSING. */
62 static tree BI_header_type
;
64 void init_init_processing ()
68 /* Define the structure that holds header information for
69 arrays allocated via operator new. */
70 BI_header_type
= make_aggr_type (RECORD_TYPE
);
71 fields
[0] = build_decl (FIELD_DECL
, nelts_identifier
, sizetype
);
73 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
76 ggc_add_tree_root (&BI_header_type
, 1);
79 /* We are about to generate some complex initialization code.
80 Conceptually, it is all a single expression. However, we may want
81 to include conditionals, loops, and other such statement-level
82 constructs. Therefore, we build the initialization code inside a
83 statement-expression. This function starts such an expression.
84 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
85 pass them back to finish_init_stmts when the expression is
89 begin_init_stmts (stmt_expr_p
, compound_stmt_p
)
91 tree
*compound_stmt_p
;
93 if (building_stmt_tree ())
94 *stmt_expr_p
= begin_stmt_expr ();
96 *stmt_expr_p
= begin_global_stmt_expr ();
98 if (building_stmt_tree ())
99 *compound_stmt_p
= begin_compound_stmt (/*has_no_scope=*/1);
102 *compound_stmt_p = genrtl_begin_compound_stmt (has_no_scope=1);
106 /* Finish out the statement-expression begun by the previous call to
107 begin_init_stmts. Returns the statement-expression itself. */
110 finish_init_stmts (stmt_expr
, compound_stmt
)
115 if (building_stmt_tree ())
116 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
118 if (building_stmt_tree ())
119 stmt_expr
= finish_stmt_expr (stmt_expr
);
121 stmt_expr
= finish_global_stmt_expr (stmt_expr
);
123 /* To avoid spurious warnings about unused values, we set
126 TREE_USED (stmt_expr
) = 1;
133 /* Called from initialize_vtbl_ptrs via dfs_walk. */
136 dfs_initialize_vtbl_ptrs (binfo
, data
)
140 if ((!BINFO_PRIMARY_P (binfo
) || TREE_VIA_VIRTUAL (binfo
))
141 && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo
)))
143 tree base_ptr
= TREE_VALUE ((tree
) data
);
145 if (TREE_VIA_VIRTUAL (binfo
))
146 base_ptr
= convert_pointer_to_vbase (BINFO_TYPE (binfo
),
150 = build_vbase_path (PLUS_EXPR
,
151 build_pointer_type (BINFO_TYPE (binfo
)),
156 expand_virtual_init (binfo
, base_ptr
);
159 SET_BINFO_MARKED (binfo
);
164 /* Initialize all the vtable pointers in the object pointed to by
168 initialize_vtbl_ptrs (addr
)
174 type
= TREE_TYPE (TREE_TYPE (addr
));
175 list
= build_tree_list (type
, addr
);
177 /* Walk through the hierarchy, initializing the vptr in each base
178 class. We do these in pre-order because under the new ABI we
179 can't find the virtual bases for a class until we've initialized
180 the vtbl for that class. */
181 dfs_walk_real (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
,
182 NULL
, dfs_unmarked_real_bases_queue_p
, list
);
183 dfs_walk (TYPE_BINFO (type
), dfs_unmark
,
184 dfs_marked_real_bases_queue_p
, type
);
186 /* If we're not using thunks, we may need to adjust the deltas in
187 the vtable to handle virtual base classes correctly. When we are
188 using thunks, we either use construction vtables (which are
189 preloaded with the right answers) or nothing (in which case
190 vitual function calls sometimes don't work right.) */
191 if (TYPE_USES_VIRTUAL_BASECLASSES (type
) && !flag_vtable_thunks
)
192 fixup_all_virtual_upcast_offsets (addr
);
197 To default-initialize an object of type T means:
199 --if T is a non-POD class type (clause _class_), the default construc-
200 tor for T is called (and the initialization is ill-formed if T has
201 no accessible default constructor);
203 --if T is an array type, each element is default-initialized;
205 --otherwise, the storage for the object is zero-initialized.
207 A program that calls for default-initialization of an entity of refer-
208 ence type is ill-formed. */
211 build_default_init (type
)
214 tree init
= NULL_TREE
;
216 if (TYPE_NEEDS_CONSTRUCTING (type
))
217 /* Other code will handle running the default constructor. We can't do
218 anything with a CONSTRUCTOR for arrays here, as that would imply
219 copy-initialization. */
221 else if (AGGREGATE_TYPE_P (type
))
223 /* This is a default initialization of an aggregate, but not one of
224 non-POD class type. We cleverly notice that the initialization
225 rules in such a case are the same as for initialization with an
226 empty brace-initialization list. */
227 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
229 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
230 /* --if T is a reference type, no initialization is performed. */
234 init
= integer_zero_node
;
236 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
237 /* We must make enumeral types the right type. */
238 init
= fold (build1 (NOP_EXPR
, type
, init
));
241 init
= digest_init (type
, init
, 0);
245 /* Subroutine of emit_base_init. */
248 perform_member_init (member
, init
, explicit)
253 tree type
= TREE_TYPE (member
);
255 decl
= build_component_ref (current_class_ref
, member
, NULL_TREE
, explicit);
257 if (decl
== error_mark_node
)
260 /* Deal with this here, as we will get confused if we try to call the
261 assignment op for an anonymous union. This can happen in a
262 synthesized copy constructor. */
263 if (ANON_AGGR_TYPE_P (type
))
267 init
= build (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
268 finish_expr_stmt (init
);
271 else if (TYPE_NEEDS_CONSTRUCTING (type
)
272 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
274 /* Since `init' is already a TREE_LIST on the member_init_list,
275 only build it into one if we aren't already a list. */
276 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
277 init
= build_tree_list (NULL_TREE
, init
);
280 && TREE_CODE (type
) == ARRAY_TYPE
282 && TREE_CHAIN (init
) == NULL_TREE
283 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
285 /* Initialization of one array from another. */
286 finish_expr_stmt (build_vec_init (decl
, TREE_VALUE (init
), 1));
289 finish_expr_stmt (build_aggr_init (decl
, init
, 0));
293 if (init
== NULL_TREE
)
297 init
= build_default_init (type
);
298 if (TREE_CODE (type
) == REFERENCE_TYPE
)
300 ("default-initialization of `%#D', which has reference type",
303 /* member traversal: note it leaves init NULL */
304 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
305 cp_pedwarn ("uninitialized reference member `%D'", member
);
307 else if (TREE_CODE (init
) == TREE_LIST
)
309 /* There was an explicit member initialization. Do some
310 work in that case. */
311 if (TREE_CHAIN (init
))
313 warning ("initializer list treated as compound expression");
314 init
= build_compound_expr (init
);
317 init
= TREE_VALUE (init
);
321 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
324 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
328 expr
= build_component_ref (current_class_ref
, member
, NULL_TREE
,
330 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
331 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
333 if (expr
!= error_mark_node
)
334 finish_subobject (expr
);
338 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
339 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
342 build_field_list (t
, list
, uses_unions_p
)
349 /* Note whether or not T is a union. */
350 if (TREE_CODE (t
) == UNION_TYPE
)
353 for (fields
= TYPE_FIELDS (t
); fields
; fields
= TREE_CHAIN (fields
))
355 /* Skip CONST_DECLs for enumeration constants and so forth. */
356 if (TREE_CODE (fields
) != FIELD_DECL
)
359 /* Keep track of whether or not any fields are unions. */
360 if (TREE_CODE (TREE_TYPE (fields
)) == UNION_TYPE
)
363 /* For an anonymous struct or union, we must recursively
364 consider the fields of the anonymous type. They can be
365 directly initialized from the constructor. */
366 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
368 /* Add this field itself. Synthesized copy constructors
369 initialize the entire aggregate. */
370 list
= tree_cons (fields
, NULL_TREE
, list
);
371 /* And now add the fields in the anonymous aggregate. */
372 list
= build_field_list (TREE_TYPE (fields
), list
,
375 /* Add this field. */
376 else if (DECL_NAME (fields
))
377 list
= tree_cons (fields
, NULL_TREE
, list
);
383 /* The MEMBER_INIT_LIST is a TREE_LIST. The TREE_PURPOSE of each list
384 gives a FIELD_DECL in T that needs initialization. The TREE_VALUE
385 gives the initializer, or list of initializer arguments. Sort the
386 MEMBER_INIT_LIST, returning a version that contains the same
387 information but in the order that the fields should actually be
388 initialized. Perform error-checking in the process. */
391 sort_member_init (t
, member_init_list
)
393 tree member_init_list
;
400 /* Build up a list of the various fields, in sorted order. */
401 init_list
= nreverse (build_field_list (t
, NULL_TREE
, &uses_unions_p
));
403 /* Go through the explicit initializers, adding them to the
405 last_field
= init_list
;
406 for (init
= member_init_list
; init
; init
= TREE_CHAIN (init
))
409 tree initialized_field
;
411 initialized_field
= TREE_PURPOSE (init
);
412 my_friendly_assert (TREE_CODE (initialized_field
) == FIELD_DECL
,
415 /* If the explicit initializers are in sorted order, then the
416 INITIALIZED_FIELD will be for a field following the
418 for (f
= last_field
; f
; f
= TREE_CHAIN (f
))
419 if (TREE_PURPOSE (f
) == initialized_field
)
422 /* Give a warning, if appropriate. */
423 if (warn_reorder
&& !f
)
425 cp_warning_at ("member initializers for `%#D'",
426 TREE_PURPOSE (last_field
));
427 cp_warning_at (" and `%#D'", initialized_field
);
428 warning (" will be re-ordered to match declaration order");
431 /* Look again, from the beginning of the list. We must find the
432 field on this loop. */
436 while (TREE_PURPOSE (f
) != initialized_field
)
440 /* If there was already an explicit initializer for this field,
443 cp_error ("multiple initializations given for member `%D'",
447 /* Mark the field as explicitly initialized. */
448 TREE_TYPE (f
) = error_mark_node
;
449 /* And insert the initializer. */
450 TREE_VALUE (f
) = TREE_VALUE (init
);
453 /* Remember the location of the last explicitly initialized
460 If a ctor-initializer specifies more than one mem-initializer for
461 multiple members of the same union (including members of
462 anonymous unions), the ctor-initializer is ill-formed. */
465 last_field
= NULL_TREE
;
466 for (init
= init_list
; init
; init
= TREE_CHAIN (init
))
472 /* Skip uninitialized members. */
473 if (!TREE_TYPE (init
))
475 /* See if this field is a member of a union, or a member of a
476 structure contained in a union, etc. */
477 field
= TREE_PURPOSE (init
);
478 for (field_type
= DECL_CONTEXT (field
);
479 !same_type_p (field_type
, t
);
480 field_type
= TYPE_CONTEXT (field_type
))
481 if (TREE_CODE (field_type
) == UNION_TYPE
)
483 /* If this field is not a member of a union, skip it. */
484 if (TREE_CODE (field_type
) != UNION_TYPE
)
487 /* It's only an error if we have two initializers for the same
495 /* See if LAST_FIELD and the field initialized by INIT are
496 members of the same union. If so, there's a problem,
497 unless they're actually members of the same structure
498 which is itself a member of a union. For example, given:
500 union { struct { int i; int j; }; };
502 initializing both `i' and `j' makes sense. */
503 field_type
= DECL_CONTEXT (field
);
507 tree last_field_type
;
509 last_field_type
= DECL_CONTEXT (last_field
);
512 if (same_type_p (last_field_type
, field_type
))
514 if (TREE_CODE (field_type
) == UNION_TYPE
)
515 cp_error ("initializations for multiple members of `%T'",
521 if (same_type_p (last_field_type
, t
))
524 last_field_type
= TYPE_CONTEXT (last_field_type
);
527 /* If we've reached the outermost class, then we're
529 if (same_type_p (field_type
, t
))
532 field_type
= TYPE_CONTEXT (field_type
);
543 /* Like sort_member_init, but used for initializers of base classes.
544 *RBASE_PTR is filled in with the initializers for non-virtual bases;
545 vbase_ptr gets the virtual bases. */
548 sort_base_init (t
, base_init_list
, rbase_ptr
, vbase_ptr
)
551 tree
*rbase_ptr
, *vbase_ptr
;
553 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
554 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
560 /* For warn_reorder. */
562 tree last_base
= NULL_TREE
;
564 tree rbases
= NULL_TREE
;
565 tree vbases
= NULL_TREE
;
567 /* First walk through and splice out vbase and invalid initializers.
568 Also replace names with binfos. */
570 last
= tree_cons (NULL_TREE
, NULL_TREE
, base_init_list
);
571 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
573 tree basetype
= TREE_PURPOSE (x
);
574 tree binfo
= NULL_TREE
;
576 if (basetype
== NULL_TREE
)
578 /* Initializer for single base class. Must not
579 use multiple inheritance or this is ambiguous. */
580 switch (n_baseclasses
)
583 cp_error ("`%T' does not have a base class to initialize",
589 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
593 binfo
= TREE_VEC_ELT (binfos
, 0);
595 else if (is_aggr_type (basetype
, 1))
597 binfo
= binfo_or_else (basetype
, t
);
598 if (binfo
== NULL_TREE
)
601 /* Virtual base classes are special cases. Their initializers
602 are recorded with this constructor, and they are used when
603 this constructor is the top-level constructor called. */
604 if (TREE_VIA_VIRTUAL (binfo
))
606 tree v
= binfo_for_vbase (BINFO_TYPE (binfo
), t
);
607 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
612 /* Otherwise, if it is not an immediate base class, complain. */
613 for (i
= n_baseclasses
-1; i
>= 0; i
--)
614 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
618 cp_error ("`%T' is not an immediate base class of `%T'",
619 basetype
, current_class_type
);
625 my_friendly_abort (365);
627 TREE_PURPOSE (x
) = binfo
;
628 TREE_CHAIN (last
) = x
;
631 TREE_CHAIN (last
) = NULL_TREE
;
633 /* Now walk through our regular bases and make sure they're initialized. */
635 for (i
= 0; i
< n_baseclasses
; ++i
)
637 /* The base for which we're currently initializing. */
638 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
639 /* The initializer for BASE_BINFO. */
643 if (TREE_VIA_VIRTUAL (base_binfo
))
646 /* We haven't found the BASE_BINFO yet. */
648 /* Loop through all the explicitly initialized bases, looking
649 for an appropriate initializer. */
650 for (x
= base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
652 tree binfo
= TREE_PURPOSE (x
);
654 if (binfo
== base_binfo
&& !init
)
660 cp_warning_at ("base initializers for `%#T'", last_base
);
661 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
662 warning (" will be re-ordered to match inheritance order");
665 last_base
= BINFO_TYPE (binfo
);
668 /* Make sure we won't try to work on this init again. */
669 TREE_PURPOSE (x
) = NULL_TREE
;
670 init
= build_tree_list (binfo
, TREE_VALUE (x
));
672 else if (binfo
== base_binfo
)
674 cp_error ("base class `%T' already initialized",
680 /* If we didn't find BASE_BINFO in the list, create a dummy entry
681 so the two lists (RBASES and the list of bases) will be
684 init
= build_tree_list (NULL_TREE
, NULL_TREE
);
685 rbases
= chainon (rbases
, init
);
692 /* Perform whatever initializations have yet to be done on the base
693 class, and non-static data members, of the CURRENT_CLASS_TYPE.
694 These actions are given by the BASE_INIT_LIST and MEM_INIT_LIST,
697 If there is a need for a call to a constructor, we must surround
698 that call with a pushlevel/poplevel pair, since we are technically
699 at the PARM level of scope.
701 Note that emit_base_init does *not* initialize virtual base
702 classes. That is done specially, elsewhere. */
705 emit_base_init (mem_init_list
, base_init_list
)
710 tree rbase_init_list
, vbase_init_list
;
711 tree t
= current_class_type
;
712 tree t_binfo
= TYPE_BINFO (t
);
713 tree binfos
= BINFO_BASETYPES (t_binfo
);
715 int n_baseclasses
= BINFO_N_BASETYPES (t_binfo
);
717 mem_init_list
= sort_member_init (t
, mem_init_list
);
718 sort_base_init (t
, base_init_list
, &rbase_init_list
, &vbase_init_list
);
720 /* First, initialize the virtual base classes, if we are
721 constructing the most-derived object. */
722 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
724 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
725 construct_virtual_bases (t
, current_class_ref
, current_class_ptr
,
726 vbase_init_list
, first_arg
);
729 /* Now, perform initialization of non-virtual base classes. */
730 for (i
= 0; i
< n_baseclasses
; i
++)
732 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
733 tree init
= void_list_node
;
735 if (TREE_VIA_VIRTUAL (base_binfo
))
738 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
,
741 if (TREE_PURPOSE (rbase_init_list
))
742 init
= TREE_VALUE (rbase_init_list
);
743 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
747 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
))
748 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
749 BINFO_TYPE (base_binfo
));
752 if (init
!= void_list_node
)
754 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
755 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
756 build_indirect_ref (member
, NULL_PTR
), init
,
760 expand_cleanup_for_base (base_binfo
, NULL_TREE
);
761 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
764 /* Initialize the vtable pointers for the class. */
765 initialize_vtbl_ptrs (current_class_ptr
);
767 while (mem_init_list
)
773 member
= TREE_PURPOSE (mem_init_list
);
775 /* See if we had a user-specified member initialization. */
776 if (TREE_TYPE (mem_init_list
))
778 init
= TREE_VALUE (mem_init_list
);
783 init
= DECL_INITIAL (member
);
786 /* Effective C++ rule 12. */
787 if (warn_ecpp
&& init
== NULL_TREE
788 && !DECL_ARTIFICIAL (member
)
789 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
790 cp_warning ("`%D' should be initialized in the member initialization list", member
);
793 perform_member_init (member
, init
, from_init_list
);
794 mem_init_list
= TREE_CHAIN (mem_init_list
);
798 /* Returns the address of the vtable (i.e., the value that should be
799 assigned to the vptr) for BINFO. */
802 build_vtbl_address (binfo
)
805 tree binfo_for
= binfo
;
808 if (BINFO_VPTR_INDEX (binfo
) && TREE_VIA_VIRTUAL (binfo
)
809 && BINFO_PRIMARY_P (binfo
))
810 /* If this is a virtual primary base, then the vtable we want to store
811 is that for the base this is being used as the primary base of. We
812 can't simply skip the initialization, because we may be expanding the
813 inits of a subobject constructor where the virtual base layout
815 while (BINFO_PRIMARY_BASE_OF (binfo_for
))
816 binfo_for
= BINFO_PRIMARY_BASE_OF (binfo_for
);
818 /* Figure out what vtable BINFO's vtable is based on, and mark it as
820 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
821 assemble_external (vtbl
);
822 TREE_USED (vtbl
) = 1;
824 /* Now compute the address to use when initializing the vptr. */
825 vtbl
= BINFO_VTABLE (binfo_for
);
826 if (TREE_CODE (vtbl
) == VAR_DECL
)
828 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
829 TREE_CONSTANT (vtbl
) = 1;
835 /* This code sets up the virtual function tables appropriate for
836 the pointer DECL. It is a one-ply initialization.
838 BINFO is the exact type that DECL is supposed to be. In
839 multiple inheritance, this might mean "C's A" if C : A, B. */
842 expand_virtual_init (binfo
, decl
)
845 tree type
= BINFO_TYPE (binfo
);
847 tree vtype
, vtype_binfo
;
850 /* Compute the location of the vtable. */
851 vtype
= DECL_CONTEXT (TYPE_VFIELD (type
));
852 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
854 /* Compute the initializer for vptr. */
855 vtbl
= build_vtbl_address (binfo
);
857 /* Under the new ABI, we may get this vptr from a VTT, if this is a
858 subobject constructor or subobject destructor. */
859 vtt_index
= BINFO_VPTR_INDEX (binfo
);
865 /* Compute the value to use, when there's a VTT. */
866 vtt_parm
= DECL_VTT_PARM (current_function_decl
);
867 vtbl2
= build (PLUS_EXPR
,
868 TREE_TYPE (vtt_parm
),
871 vtbl2
= build1 (INDIRECT_REF
, TREE_TYPE (vtbl
), vtbl2
);
873 /* The actual initializer is the VTT value only in the subobject
874 constructor. In maybe_clone_body we'll substitute NULL for
875 the vtt_parm in the case of the non-subobject constructor. */
876 vtbl
= build (COND_EXPR
,
878 DECL_USE_VTT_PARM (current_function_decl
),
883 /* Compute the location of the vtpr. */
884 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
885 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
886 if (vtbl_ptr
== error_mark_node
)
889 /* Assign the vtable to the vptr. */
890 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
891 finish_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
894 /* If an exception is thrown in a constructor, those base classes already
895 constructed must be destroyed. This function creates the cleanup
896 for BINFO, which has just been constructed. If FLAG is non-NULL,
897 it is a DECL which is non-zero when this base needs to be
901 expand_cleanup_for_base (binfo
, flag
)
907 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
910 /* Call the destructor. */
911 expr
= (build_scoped_method_call
912 (current_class_ref
, binfo
, base_dtor_identifier
, NULL_TREE
));
914 expr
= fold (build (COND_EXPR
, void_type_node
,
915 truthvalue_conversion (flag
),
916 expr
, integer_zero_node
));
918 finish_subobject (expr
);
921 /* Subroutine of `expand_aggr_vbase_init'.
922 BINFO is the binfo of the type that is being initialized.
923 INIT_LIST is the list of initializers for the virtual baseclass. */
926 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
927 tree binfo
, exp
, addr
, init_list
;
929 tree init
= purpose_member (binfo
, init_list
);
930 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
933 init
= TREE_VALUE (init
);
934 /* Call constructors, but don't set up vtables. */
935 expand_aggr_init_1 (binfo
, exp
, ref
, init
, LOOKUP_COMPLAIN
);
938 /* Construct the virtual base-classes of THIS_REF (whose address is
939 THIS_PTR). The object has the indicated TYPE. The construction
940 actually takes place only if FLAG is non-zero. INIT_LIST is list
941 of initializations for constructors to perform. */
944 construct_virtual_bases (type
, this_ref
, this_ptr
, init_list
, flag
)
953 /* If there are no virtual baseclasses, we shouldn't even be here. */
954 my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type
), 19990621);
956 /* First set the pointers in our object that tell us where to find
957 our virtual baseclasses. */
958 if (!vbase_offsets_in_vtable_p ())
963 if_stmt
= begin_if_stmt ();
964 finish_if_stmt_cond (flag
, if_stmt
);
965 result
= init_vbase_pointers (type
, this_ptr
);
967 finish_expr_stmt (build_compound_expr (result
));
968 finish_then_clause (if_stmt
);
972 /* Now, run through the baseclasses, initializing each. */
973 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
974 vbases
= TREE_CHAIN (vbases
))
981 /* If there are virtual base classes with destructors, we need to
982 emit cleanups to destroy them if an exception is thrown during
983 the construction process. These exception regions (i.e., the
984 period during which the cleanups must occur) begin from the time
985 the construction is complete to the end of the function. If we
986 create a conditional block in which to initialize the
987 base-classes, then the cleanup region for the virtual base begins
988 inside a block, and ends outside of that block. This situation
989 confuses the sjlj exception-handling code. Therefore, we do not
990 create a single conditional block, but one for each
991 initialization. (That way the cleanup regions always begin
992 in the outer block.) We trust the back-end to figure out
993 that the FLAG will not change across initializations, and
994 avoid doing multiple tests. */
995 inner_if_stmt
= begin_if_stmt ();
996 finish_if_stmt_cond (flag
, inner_if_stmt
);
997 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/1);
999 /* Compute the location of the virtual base. If we're
1000 constructing virtual bases, then we must be the most derived
1001 class. Therefore, we don't have to look up the virtual base;
1002 we already know where it is. */
1003 vbase
= TREE_VALUE (vbases
);
1004 exp
= build (PLUS_EXPR
,
1005 TREE_TYPE (this_ptr
),
1007 fold (build1 (NOP_EXPR
, TREE_TYPE (this_ptr
),
1008 BINFO_OFFSET (vbase
))));
1009 exp
= build1 (NOP_EXPR
,
1010 build_pointer_type (BINFO_TYPE (vbase
)),
1013 expand_aggr_vbase_init_1 (vbase
, this_ref
, exp
, init_list
);
1014 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
1015 finish_then_clause (inner_if_stmt
);
1018 expand_cleanup_for_base (vbase
, flag
);
1022 /* Find the context in which this FIELD can be initialized. */
1025 initializing_context (field
)
1028 tree t
= DECL_CONTEXT (field
);
1030 /* Anonymous union members can be initialized in the first enclosing
1031 non-anonymous union context. */
1032 while (t
&& ANON_AGGR_TYPE_P (t
))
1033 t
= TYPE_CONTEXT (t
);
1037 /* Function to give error message if member initialization specification
1038 is erroneous. FIELD is the member we decided to initialize.
1039 TYPE is the type for which the initialization is being performed.
1040 FIELD must be a member of TYPE.
1042 MEMBER_NAME is the name of the member. */
1045 member_init_ok_or_else (field
, type
, member_name
)
1048 const char *member_name
;
1050 if (field
== error_mark_node
)
1052 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
1054 cp_error ("class `%T' does not have any field named `%s'", type
,
1058 if (TREE_STATIC (field
))
1060 cp_error ("field `%#D' is static; only point of initialization is its declaration",
1068 /* If NAME is a viable field name for the aggregate DECL,
1069 and PARMS is a viable parameter list, then expand an _EXPR
1070 which describes this initialization.
1072 Note that we do not need to chase through the class's base classes
1073 to look for NAME, because if it's in that list, it will be handled
1074 by the constructor for that base class.
1076 We do not yet have a fixed-point finder to instantiate types
1077 being fed to overloaded constructors. If there is a unique
1078 constructor, then argument types can be got from that one. */
1081 expand_member_init (exp
, name
, init
)
1082 tree exp
, name
, init
;
1084 tree basetype
= NULL_TREE
, field
;
1087 if (exp
== NULL_TREE
)
1090 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
1092 if (name
&& TYPE_P (name
))
1095 name
= TYPE_IDENTIFIER (name
);
1097 else if (name
&& TREE_CODE (name
) == TYPE_DECL
)
1099 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1100 name
= DECL_NAME (name
);
1103 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
1104 switch (CLASSTYPE_N_BASECLASSES (type
))
1107 error ("base class initializer specified, but no base class to initialize");
1110 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
1113 error ("initializer for unnamed base class ambiguous");
1114 cp_error ("(type `%T' uses multiple inheritance)", type
);
1118 my_friendly_assert (init
!= NULL_TREE
, 0);
1120 /* The grammar should not allow fields which have names that are
1121 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
1122 may assume that this is an attempt to initialize a base class
1123 member of the current type. Otherwise, it is an attempt to
1124 initialize a member field. */
1126 if (init
== void_type_node
)
1129 if (name
== NULL_TREE
|| basetype
)
1131 if (name
== NULL_TREE
)
1135 name
= TYPE_IDENTIFIER (basetype
);
1138 error ("no base class to initialize");
1143 else if (basetype
!= type
1144 && ! current_template_parms
1145 && ! vec_binfo_member (basetype
,
1146 TYPE_BINFO_BASETYPES (type
))
1147 && ! binfo_for_vbase (basetype
, type
))
1149 if (IDENTIFIER_CLASS_VALUE (name
))
1151 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1152 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
1155 cp_error ("type `%T' is not an immediate basetype for `%T'",
1160 init
= build_tree_list (basetype
, init
);
1165 field
= lookup_field (type
, name
, 1, 0);
1167 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
1170 init
= build_tree_list (field
, init
);
1176 /* This is like `expand_member_init', only it stores one aggregate
1179 INIT comes in two flavors: it is either a value which
1180 is to be stored in EXP, or it is a parameter list
1181 to go to a constructor, which will operate on EXP.
1182 If INIT is not a parameter list for a constructor, then set
1183 LOOKUP_ONLYCONVERTING.
1184 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1185 the initializer, if FLAGS is 0, then it is the (init) form.
1186 If `init' is a CONSTRUCTOR, then we emit a warning message,
1187 explaining that such initializations are invalid.
1189 If INIT resolves to a CALL_EXPR which happens to return
1190 something of the type we are looking for, then we know
1191 that we can safely use that call to perform the
1194 The virtual function table pointer cannot be set up here, because
1195 we do not really know its type.
1197 Virtual baseclass pointers are also set up here.
1199 This never calls operator=().
1201 When initializing, nothing is CONST.
1203 A default copy constructor may have to be used to perform the
1206 A constructor or a conversion operator may have to be used to
1207 perform the initialization, but not both, as it would be ambiguous. */
1210 build_aggr_init (exp
, init
, flags
)
1217 tree type
= TREE_TYPE (exp
);
1218 int was_const
= TREE_READONLY (exp
);
1219 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1221 if (init
== error_mark_node
)
1222 return error_mark_node
;
1224 TREE_READONLY (exp
) = 0;
1225 TREE_THIS_VOLATILE (exp
) = 0;
1227 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1228 flags
|= LOOKUP_ONLYCONVERTING
;
1230 if (TREE_CODE (type
) == ARRAY_TYPE
)
1232 /* Must arrange to initialize each element of EXP
1233 from elements of INIT. */
1234 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1238 /* Handle bad initializers like:
1242 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1246 int main(int argc, char **argv) {
1247 COMPLEX zees(1.0, 0.0)[10];
1250 cp_error ("bad array initializer");
1251 return error_mark_node
;
1253 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
1255 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1257 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1259 stmt_expr
= build_vec_init (exp
, init
,
1260 init
&& same_type_p (TREE_TYPE (init
),
1262 TREE_READONLY (exp
) = was_const
;
1263 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1264 TREE_TYPE (exp
) = type
;
1266 TREE_TYPE (init
) = itype
;
1270 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1271 /* just know that we've seen something for this node */
1272 TREE_USED (exp
) = 1;
1274 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1275 begin_init_stmts (&stmt_expr
, &compound_stmt
);
1276 destroy_temps
= stmts_are_full_exprs_p ();
1277 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1278 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1279 init
, LOOKUP_NORMAL
|flags
);
1280 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
1281 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1282 TREE_TYPE (exp
) = type
;
1283 TREE_READONLY (exp
) = was_const
;
1284 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1290 expand_default_init (binfo
, true_exp
, exp
, init
, flags
)
1296 tree type
= TREE_TYPE (exp
);
1299 /* It fails because there may not be a constructor which takes
1300 its own type as the first (or only parameter), but which does
1301 take other types via a conversion. So, if the thing initializing
1302 the expression is a unit element of type X, first try X(X&),
1303 followed by initialization by X. If neither of these work
1304 out, then look hard. */
1308 if (init
&& TREE_CODE (init
) != TREE_LIST
1309 && (flags
& LOOKUP_ONLYCONVERTING
))
1311 /* Base subobjects should only get direct-initialization. */
1312 if (true_exp
!= exp
)
1315 if (flags
& DIRECT_BIND
)
1316 /* Do nothing. We hit this in two cases: Reference initialization,
1317 where we aren't initializing a real variable, so we don't want
1318 to run a new constructor; and catching an exception, where we
1319 have already built up the constructor call so we could wrap it
1320 in an exception region. */;
1321 else if (TREE_CODE (init
) == CONSTRUCTOR
)
1322 /* A brace-enclosed initializer has whatever type is
1323 required. There's no need to convert it. */
1326 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1328 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1329 /* We need to protect the initialization of a catch parm
1330 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1331 around the TARGET_EXPR for the copy constructor. See
1332 expand_start_catch_block. */
1333 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1334 TREE_OPERAND (init
, 0));
1336 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1337 TREE_SIDE_EFFECTS (init
) = 1;
1338 finish_expr_stmt (init
);
1342 if (init
== NULL_TREE
1343 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1347 init
= TREE_VALUE (parms
);
1350 parms
= build_tree_list (NULL_TREE
, init
);
1352 if (true_exp
== exp
)
1353 ctor_name
= complete_ctor_identifier
;
1355 ctor_name
= base_ctor_identifier
;
1357 rval
= build_method_call (exp
, ctor_name
, parms
, binfo
, flags
);
1358 if (TREE_SIDE_EFFECTS (rval
))
1360 if (building_stmt_tree ())
1361 finish_expr_stmt (rval
);
1363 genrtl_expr_stmt (rval
);
1367 /* This function is responsible for initializing EXP with INIT
1370 BINFO is the binfo of the type for who we are performing the
1371 initialization. For example, if W is a virtual base class of A and B,
1373 If we are initializing B, then W must contain B's W vtable, whereas
1374 were we initializing C, W must contain C's W vtable.
1376 TRUE_EXP is nonzero if it is the true expression being initialized.
1377 In this case, it may be EXP, or may just contain EXP. The reason we
1378 need this is because if EXP is a base element of TRUE_EXP, we
1379 don't necessarily know by looking at EXP where its virtual
1380 baseclass fields should really be pointing. But we do know
1381 from TRUE_EXP. In constructors, we don't know anything about
1382 the value being initialized.
1384 FLAGS is just passes to `build_method_call'. See that function for
1388 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, flags
)
1394 tree type
= TREE_TYPE (exp
);
1396 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1398 /* Use a function returning the desired type to initialize EXP for us.
1399 If the function is a constructor, and its first argument is
1400 NULL_TREE, know that it was meant for us--just slide exp on
1401 in and expand the constructor. Constructors now come
1404 if (init
&& TREE_CODE (exp
) == VAR_DECL
1405 && TREE_CODE (init
) == CONSTRUCTOR
1406 && TREE_HAS_CONSTRUCTOR (init
))
1408 /* If store_init_value returns NULL_TREE, the INIT has been
1409 record in the DECL_INITIAL for EXP. That means there's
1410 nothing more we have to do. */
1411 if (!store_init_value (exp
, init
))
1413 if (!building_stmt_tree ())
1414 expand_decl_init (exp
);
1417 finish_expr_stmt (build (INIT_EXPR
, type
, exp
, init
));
1421 /* We know that expand_default_init can handle everything we want
1423 expand_default_init (binfo
, true_exp
, exp
, init
, flags
);
1426 /* Report an error if TYPE is not a user-defined, aggregate type. If
1427 OR_ELSE is nonzero, give an error message. */
1430 is_aggr_type (type
, or_else
)
1434 if (type
== error_mark_node
)
1437 if (! IS_AGGR_TYPE (type
)
1438 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1439 && TREE_CODE (type
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
1442 cp_error ("`%T' is not an aggregate type", type
);
1448 /* Like is_aggr_typedef, but returns typedef if successful. */
1451 get_aggr_from_typedef (name
, or_else
)
1457 if (name
== error_mark_node
)
1460 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1461 type
= IDENTIFIER_TYPE_VALUE (name
);
1465 cp_error ("`%T' fails to be an aggregate typedef", name
);
1469 if (! IS_AGGR_TYPE (type
)
1470 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1471 && TREE_CODE (type
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
1474 cp_error ("type `%T' is of non-aggregate type", type
);
1481 get_type_value (name
)
1484 if (name
== error_mark_node
)
1487 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1488 return IDENTIFIER_TYPE_VALUE (name
);
1494 /* This code could just as well go in `class.c', but is placed here for
1497 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1498 the appropriate function call. */
1501 build_member_call (type
, name
, parmlist
)
1502 tree type
, name
, parmlist
;
1507 tree basetype_path
, decl
;
1509 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
1510 && TREE_CODE (type
) == NAMESPACE_DECL
)
1512 /* 'name' already refers to the decls from the namespace, since we
1513 hit do_identifier for template_ids. */
1514 method_name
= TREE_OPERAND (name
, 0);
1515 /* FIXME: Since we don't do independent names right yet, the
1516 name might also be a LOOKUP_EXPR. Once we resolve this to a
1517 real decl earlier, this can go. This may happen during
1519 if (TREE_CODE (method_name
) == LOOKUP_EXPR
)
1521 method_name
= lookup_namespace_name
1522 (type
, TREE_OPERAND (method_name
, 0));
1523 TREE_OPERAND (name
, 0) = method_name
;
1525 my_friendly_assert (is_overloaded_fn (method_name
), 980519);
1526 return build_x_function_call (name
, parmlist
, current_class_ref
);
1530 name
= DECL_NAME (name
);
1532 if (type
== fake_std_node
)
1533 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1535 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1536 return build_x_function_call (lookup_namespace_name (type
, name
),
1537 parmlist
, current_class_ref
);
1539 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1541 method_name
= TREE_OPERAND (name
, 0);
1542 if (TREE_CODE (method_name
) == COMPONENT_REF
)
1543 method_name
= TREE_OPERAND (method_name
, 1);
1544 if (is_overloaded_fn (method_name
))
1545 method_name
= DECL_NAME (OVL_CURRENT (method_name
));
1546 TREE_OPERAND (name
, 0) = method_name
;
1551 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1553 method_name
= TREE_OPERAND (method_name
, 0);
1557 /* This shouldn't be here, and build_member_call shouldn't appear in
1559 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1560 && get_aggr_from_typedef (type
, 0) == 0)
1562 tree ns
= lookup_name (type
, 0);
1563 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1565 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1569 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1570 return error_mark_node
;
1572 /* An operator we did not like. */
1573 if (name
== NULL_TREE
)
1574 return error_mark_node
;
1578 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1580 return error_mark_node
;
1583 decl
= maybe_dummy_object (type
, &basetype_path
);
1585 /* Convert 'this' to the specified type to disambiguate conversion
1586 to the function's context. Apparently Standard C++ says that we
1587 shouldn't do this. */
1588 if (decl
== current_class_ref
1590 && ACCESSIBLY_UNIQUELY_DERIVED_P (type
, current_class_type
))
1592 tree olddecl
= current_class_ptr
;
1593 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1594 if (oldtype
!= type
)
1596 tree newtype
= build_qualified_type (type
, TYPE_QUALS (oldtype
));
1597 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1598 decl
= build_indirect_ref (decl
, NULL_PTR
);
1602 if (method_name
== constructor_name (type
)
1603 || method_name
== constructor_name_full (type
))
1604 return build_functional_cast (type
, parmlist
);
1605 if (lookup_fnfields (basetype_path
, method_name
, 0))
1606 return build_method_call (decl
,
1607 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1608 ? name
: method_name
,
1609 parmlist
, basetype_path
,
1610 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1611 if (TREE_CODE (name
) == IDENTIFIER_NODE
1612 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1614 if (t
== error_mark_node
)
1615 return error_mark_node
;
1616 if (TREE_CODE (t
) == FIELD_DECL
)
1618 if (is_dummy_object (decl
))
1620 cp_error ("invalid use of non-static field `%D'", t
);
1621 return error_mark_node
;
1623 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1625 else if (TREE_CODE (t
) == VAR_DECL
)
1629 cp_error ("invalid use of member `%D'", t
);
1630 return error_mark_node
;
1632 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1633 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1634 parmlist
, NULL_TREE
);
1635 return build_function_call (decl
, parmlist
);
1639 cp_error ("no method `%T::%D'", type
, name
);
1640 return error_mark_node
;
1644 /* Build a reference to a member of an aggregate. This is not a
1645 C++ `&', but really something which can have its address taken,
1646 and then act as a pointer to member, for example TYPE :: FIELD
1647 can have its address taken by saying & TYPE :: FIELD.
1649 @@ Prints out lousy diagnostics for operator <typename>
1652 @@ This function should be rewritten and placed in search.c. */
1655 build_offset_ref (type
, name
)
1658 tree decl
, t
= error_mark_node
;
1660 tree basebinfo
= NULL_TREE
;
1661 tree orig_name
= name
;
1663 /* class templates can come in as TEMPLATE_DECLs here. */
1664 if (TREE_CODE (name
) == TEMPLATE_DECL
)
1667 if (type
== fake_std_node
)
1668 return do_scoped_id (name
, 0);
1670 if (processing_template_decl
|| uses_template_parms (type
))
1671 return build_min_nt (SCOPE_REF
, type
, name
);
1673 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1675 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1676 something like `a.template f<int>' or the like. For the most
1677 part, we treat this just like a.f. We do remember, however,
1678 the template-id that was used. */
1679 name
= TREE_OPERAND (orig_name
, 0);
1682 name
= DECL_NAME (name
);
1685 if (TREE_CODE (name
) == LOOKUP_EXPR
)
1686 /* This can happen during tsubst'ing. */
1687 name
= TREE_OPERAND (name
, 0);
1690 if (TREE_CODE (name
) == COMPONENT_REF
)
1691 name
= TREE_OPERAND (name
, 1);
1692 if (TREE_CODE (name
) == OVERLOAD
)
1693 name
= DECL_NAME (OVL_CURRENT (name
));
1697 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
1700 if (type
== NULL_TREE
)
1701 return error_mark_node
;
1703 /* Handle namespace names fully here. */
1704 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1706 t
= lookup_namespace_name (type
, name
);
1707 if (t
== error_mark_node
)
1709 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1710 /* Reconstruct the TEMPLATE_ID_EXPR. */
1711 t
= build (TEMPLATE_ID_EXPR
, TREE_TYPE (t
),
1712 t
, TREE_OPERAND (orig_name
, 1));
1713 if (! type_unknown_p (t
))
1716 t
= convert_from_reference (t
);
1721 if (! is_aggr_type (type
, 1))
1722 return error_mark_node
;
1724 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1726 if (! check_dtor_name (type
, name
))
1727 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1728 type
, TREE_OPERAND (name
, 0));
1729 name
= dtor_identifier
;
1732 if (!COMPLETE_TYPE_P (complete_type (type
))
1733 && !TYPE_BEING_DEFINED (type
))
1735 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1737 return error_mark_node
;
1740 decl
= maybe_dummy_object (type
, &basebinfo
);
1742 member
= lookup_member (basebinfo
, name
, 1, 0);
1744 if (member
== error_mark_node
)
1745 return error_mark_node
;
1747 /* A lot of this logic is now handled in lookup_member. */
1748 if (member
&& BASELINK_P (member
))
1750 /* Go from the TREE_BASELINK to the member function info. */
1751 tree fnfields
= member
;
1752 t
= TREE_VALUE (fnfields
);
1754 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1756 /* The FNFIELDS are going to contain functions that aren't
1757 necessarily templates, and templates that don't
1758 necessarily match the explicit template parameters. We
1759 save all the functions, and the explicit parameters, and
1760 then figure out exactly what to instantiate with what
1761 arguments in instantiate_type. */
1763 if (TREE_CODE (t
) != OVERLOAD
)
1764 /* The code in instantiate_type which will process this
1765 expects to encounter OVERLOADs, not raw functions. */
1766 t
= ovl_cons (t
, NULL_TREE
);
1768 t
= build (TEMPLATE_ID_EXPR
, TREE_TYPE (t
), t
,
1769 TREE_OPERAND (orig_name
, 1));
1770 t
= build (OFFSET_REF
, unknown_type_node
, decl
, t
);
1772 PTRMEM_OK_P (t
) = 1;
1777 if (!really_overloaded_fn (t
))
1779 /* Get rid of a potential OVERLOAD around it */
1780 t
= OVL_CURRENT (t
);
1782 /* unique functions are handled easily. */
1783 if (!enforce_access (basebinfo
, t
))
1784 return error_mark_node
;
1786 if (DECL_STATIC_FUNCTION_P (t
))
1788 t
= build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1789 PTRMEM_OK_P (t
) = 1;
1793 TREE_TYPE (fnfields
) = unknown_type_node
;
1795 t
= build (OFFSET_REF
, unknown_type_node
, decl
, fnfields
);
1796 PTRMEM_OK_P (t
) = 1;
1804 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1805 return error_mark_node
;
1808 if (TREE_CODE (t
) == TYPE_DECL
)
1813 /* static class members and class-specific enum
1814 values can be returned without further ado. */
1815 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1818 return convert_from_reference (t
);
1821 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_C_BIT_FIELD (t
))
1823 cp_error ("illegal pointer to bit field `%D'", t
);
1824 return error_mark_node
;
1827 /* static class functions too. */
1828 if (TREE_CODE (t
) == FUNCTION_DECL
1829 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1830 my_friendly_abort (53);
1832 /* In member functions, the form `type::name' is no longer
1833 equivalent to `this->type::name', at least not until
1834 resolve_offset_ref. */
1835 t
= build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1836 PTRMEM_OK_P (t
) = 1;
1840 /* If a OFFSET_REF made it through to here, then it did
1841 not have its address taken. */
1844 resolve_offset_ref (exp
)
1847 tree type
= TREE_TYPE (exp
);
1848 tree base
= NULL_TREE
;
1850 tree basetype
, addr
;
1852 if (TREE_CODE (exp
) == OFFSET_REF
)
1854 member
= TREE_OPERAND (exp
, 1);
1855 base
= TREE_OPERAND (exp
, 0);
1859 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1860 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1862 error ("object missing in use of pointer-to-member construct");
1863 return error_mark_node
;
1866 type
= TREE_TYPE (type
);
1867 base
= current_class_ref
;
1870 if (BASELINK_P (member
) || TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
1871 return build_unary_op (ADDR_EXPR
, exp
, 0);
1873 if (TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1875 if (!flag_ms_extensions
)
1876 /* A single non-static member, make sure we don't allow a
1877 pointer-to-member. */
1878 exp
= ovl_cons (member
, NULL_TREE
);
1880 return build_unary_op (ADDR_EXPR
, exp
, 0);
1883 if ((TREE_CODE (member
) == VAR_DECL
1884 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
))
1885 && ! TYPE_PTRMEM_P (TREE_TYPE (member
)))
1886 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
)
1888 /* These were static members. */
1889 if (mark_addressable (member
) == 0)
1890 return error_mark_node
;
1894 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1895 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1898 /* Syntax error can cause a member which should
1899 have been seen as static to be grok'd as non-static. */
1900 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1902 cp_error_at ("member `%D' is non-static but referenced as a static member",
1904 error ("at this point in file");
1905 return error_mark_node
;
1908 /* The first case is really just a reference to a member of `this'. */
1909 if (TREE_CODE (member
) == FIELD_DECL
1910 && (base
== current_class_ref
|| is_dummy_object (base
)))
1914 basetype
= DECL_CONTEXT (member
);
1916 /* Try to get to basetype from 'this'; if that doesn't work,
1918 base
= current_class_ref
;
1920 /* First convert to the intermediate base specified, if appropriate. */
1921 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1922 base
= build_scoped_ref (base
, TYPE_OFFSET_BASETYPE (type
));
1924 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1925 addr
= convert_pointer_to (basetype
, addr
);
1927 if (addr
== error_mark_node
)
1928 return error_mark_node
;
1930 expr
= build (COMPONENT_REF
, TREE_TYPE (member
),
1931 build_indirect_ref (addr
, NULL_PTR
), member
);
1932 return convert_from_reference (expr
);
1935 /* Ensure that we have an object. */
1936 if (is_dummy_object (base
))
1937 addr
= error_mark_node
;
1939 /* If this is a reference to a member function, then return the
1940 address of the member function (which may involve going
1941 through the object's vtable), otherwise, return an expression
1942 for the dereferenced pointer-to-member construct. */
1943 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1945 if (TYPE_PTRMEM_P (TREE_TYPE (member
)))
1947 if (addr
== error_mark_node
)
1949 cp_error ("object missing in `%E'", exp
);
1950 return error_mark_node
;
1953 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member
)));
1954 addr
= convert_pointer_to (basetype
, addr
);
1955 member
= cp_convert (ptrdiff_type_node
, member
);
1957 return build1 (INDIRECT_REF
, type
,
1958 build (PLUS_EXPR
, build_pointer_type (type
),
1961 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1963 return get_member_function_from_ptrfunc (&addr
, member
);
1965 my_friendly_abort (56);
1970 /* If DECL is a `const' declaration, and its value is a known
1971 constant, then return that value. */
1974 decl_constant_value (decl
)
1977 if (TREE_READONLY_DECL_P (decl
)
1978 && ! TREE_THIS_VOLATILE (decl
)
1979 && DECL_INITIAL (decl
)
1980 && DECL_INITIAL (decl
) != error_mark_node
1981 /* This is invalid if initial value is not constant.
1982 If it has either a function call, a memory reference,
1983 or a variable, then re-evaluating it could give different results. */
1984 && TREE_CONSTANT (DECL_INITIAL (decl
))
1985 /* Check for cases where this is sub-optimal, even though valid. */
1986 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1987 return DECL_INITIAL (decl
);
1991 /* Common subroutines of build_new and build_vec_delete. */
1993 /* Call the global __builtin_delete to delete ADDR. */
1996 build_builtin_delete_call (addr
)
1999 mark_used (global_delete_fndecl
);
2000 return build_call (global_delete_fndecl
, build_tree_list (NULL_TREE
, addr
));
2003 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
2004 (which needs to go through some sort of groktypename) or it
2005 is the name of the class we are newing. INIT is an initialization value.
2006 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
2007 If INIT is void_type_node, it means do *not* call a constructor
2010 For types with constructors, the data returned is initialized
2011 by the appropriate constructor.
2013 Whether the type has a constructor or not, if it has a pointer
2014 to a virtual function table, then that pointer is set up
2017 Unless I am mistaken, a call to new () will return initialized
2018 data regardless of whether the constructor itself is private or
2019 not. NOPE; new fails if the constructor is private (jcm).
2021 Note that build_new does nothing to assure that any special
2022 alignment requirements of the type are met. Rather, it leaves
2023 it up to malloc to do the right thing. Otherwise, folding to
2024 the right alignment cal cause problems if the user tries to later
2025 free the memory returned by `new'.
2027 PLACEMENT is the `placement' list for user-defined operator new (). */
2030 build_new (placement
, decl
, init
, use_global_new
)
2036 tree nelts
= NULL_TREE
, t
;
2039 if (decl
== error_mark_node
)
2040 return error_mark_node
;
2042 if (TREE_CODE (decl
) == TREE_LIST
)
2044 tree absdcl
= TREE_VALUE (decl
);
2045 tree last_absdcl
= NULL_TREE
;
2047 if (current_function_decl
2048 && DECL_CONSTRUCTOR_P (current_function_decl
))
2049 my_friendly_assert (immediate_size_expand
== 0, 19990926);
2051 nelts
= integer_one_node
;
2053 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
2054 my_friendly_abort (215);
2055 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2057 last_absdcl
= absdcl
;
2058 absdcl
= TREE_OPERAND (absdcl
, 0);
2061 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2063 /* probably meant to be a vec new */
2066 while (TREE_OPERAND (absdcl
, 0)
2067 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2069 last_absdcl
= absdcl
;
2070 absdcl
= TREE_OPERAND (absdcl
, 0);
2074 this_nelts
= TREE_OPERAND (absdcl
, 1);
2075 if (this_nelts
!= error_mark_node
)
2077 if (this_nelts
== NULL_TREE
)
2078 error ("new of array type fails to specify size");
2079 else if (processing_template_decl
)
2082 absdcl
= TREE_OPERAND (absdcl
, 0);
2086 int flags
= pedantic
? WANT_INT
: (WANT_INT
| WANT_ENUM
);
2087 if (build_expr_type_conversion (flags
, this_nelts
, 0)
2089 pedwarn ("size in array new must have integral type");
2091 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2092 absdcl
= TREE_OPERAND (absdcl
, 0);
2093 if (this_nelts
== integer_zero_node
)
2095 warning ("zero size array reserves no space");
2096 nelts
= integer_zero_node
;
2099 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2103 nelts
= integer_zero_node
;
2107 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2109 TREE_VALUE (decl
) = absdcl
;
2111 type
= groktypename (decl
);
2112 if (! type
|| type
== error_mark_node
)
2113 return error_mark_node
;
2115 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2117 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2119 /* An aggregate type. */
2120 type
= IDENTIFIER_TYPE_VALUE (decl
);
2121 decl
= TYPE_MAIN_DECL (type
);
2125 /* A builtin type. */
2126 decl
= lookup_name (decl
, 1);
2127 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2128 type
= TREE_TYPE (decl
);
2131 else if (TREE_CODE (decl
) == TYPE_DECL
)
2133 type
= TREE_TYPE (decl
);
2138 decl
= TYPE_MAIN_DECL (type
);
2141 if (processing_template_decl
)
2144 t
= tree_cons (tree_cons (NULL_TREE
, type
, NULL_TREE
),
2145 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2150 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2151 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2155 /* ``A reference cannot be created by the new operator. A reference
2156 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2157 returned by new.'' ARM 5.3.3 */
2158 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2160 error ("new cannot be applied to a reference type");
2161 type
= TREE_TYPE (type
);
2164 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2166 error ("new cannot be applied to a function type");
2167 return error_mark_node
;
2170 /* When the object being created is an array, the new-expression yields a
2171 pointer to the initial element (if any) of the array. For example,
2172 both new int and new int[10] return an int*. 5.3.4. */
2173 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2175 nelts
= array_type_nelts_top (type
);
2177 type
= TREE_TYPE (type
);
2181 t
= build_nt (ARRAY_REF
, type
, nelts
);
2185 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2186 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2187 TREE_SIDE_EFFECTS (rval
) = 1;
2188 rval
= build_new_1 (rval
);
2189 if (rval
== error_mark_node
)
2190 return error_mark_node
;
2192 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2193 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2194 TREE_NO_UNUSED_WARNING (rval
) = 1;
2199 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2202 build_java_class_ref (type
)
2205 tree name
, class_decl
;
2206 static tree CL_suffix
= NULL_TREE
;
2207 if (CL_suffix
== NULL_TREE
)
2208 CL_suffix
= get_identifier("class$");
2209 if (jclass_node
== NULL_TREE
)
2211 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2212 if (jclass_node
== NULL_TREE
)
2213 fatal_error ("call to Java constructor, while `jclass' undefined");
2215 jclass_node
= TREE_TYPE (jclass_node
);
2218 /* Mangle the class$ field, new and old ABI */
2221 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2222 if (DECL_NAME (field
) == CL_suffix
)
2224 name
= mangle_decl (field
);
2228 internal_error ("Can't find class$");
2231 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2232 if (class_decl
== NULL_TREE
)
2234 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2235 TREE_STATIC (class_decl
) = 1;
2236 DECL_EXTERNAL (class_decl
) = 1;
2237 TREE_PUBLIC (class_decl
) = 1;
2238 DECL_ARTIFICIAL (class_decl
) = 1;
2239 DECL_IGNORED_P (class_decl
) = 1;
2240 pushdecl_top_level (class_decl
);
2241 make_decl_rtl (class_decl
, NULL_PTR
);
2246 /* Returns the size of the cookie to use when allocating an array
2247 whose elements have the indicated TYPE. Assumes that it is already
2248 known that a cookie is needed. */
2251 get_cookie_size (type
)
2256 /* Under the new ABI, we need to allocate an additional max
2257 (sizeof (size_t), alignof (true_type)) bytes. */
2261 sizetype_size
= size_in_bytes (sizetype
);
2262 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
2263 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
2264 cookie_size
= sizetype_size
;
2266 cookie_size
= type_align
;
2271 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2272 value is immediately handed to expand_expr. */
2278 tree placement
, init
;
2279 tree type
, true_type
, size
, rval
, t
;
2281 tree nelts
= NULL_TREE
;
2282 tree alloc_call
, alloc_expr
, alloc_node
;
2283 tree cookie_expr
, init_expr
;
2285 enum tree_code code
;
2286 int use_cookie
, nothrow
, check_new
;
2287 /* Nonzero if the user wrote `::new' rather than just `new'. */
2288 int globally_qualified_p
;
2289 /* Nonzero if we're going to call a global operator new, rather than
2290 a class-specific version. */
2292 int use_java_new
= 0;
2293 /* If non-NULL, the number of extra bytes to allocate at the
2294 beginning of the storage allocated for an array-new expression in
2295 order to store the number of elements. */
2296 tree cookie_size
= NULL_TREE
;
2298 placement
= TREE_OPERAND (exp
, 0);
2299 type
= TREE_OPERAND (exp
, 1);
2300 init
= TREE_OPERAND (exp
, 2);
2301 globally_qualified_p
= NEW_EXPR_USE_GLOBAL (exp
);
2303 if (TREE_CODE (type
) == ARRAY_REF
)
2306 nelts
= TREE_OPERAND (type
, 1);
2307 type
= TREE_OPERAND (type
, 0);
2309 full_type
= cp_build_binary_op (MINUS_EXPR
, nelts
, integer_one_node
);
2310 full_type
= build_index_type (full_type
);
2311 full_type
= build_cplus_array_type (type
, full_type
);
2318 code
= has_array
? VEC_NEW_EXPR
: NEW_EXPR
;
2320 /* If our base type is an array, then make sure we know how many elements
2322 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2324 tree this_nelts
= array_type_nelts_top (true_type
);
2325 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2326 true_type
= TREE_TYPE (true_type
);
2329 if (!complete_type_or_else (true_type
, exp
))
2330 return error_mark_node
;
2332 size
= size_in_bytes (true_type
);
2334 size
= fold (cp_build_binary_op (MULT_EXPR
, size
, nelts
));
2336 if (TREE_CODE (true_type
) == VOID_TYPE
)
2338 error ("invalid type `void' for new");
2339 return error_mark_node
;
2342 if (abstract_virtuals_error (NULL_TREE
, true_type
))
2343 return error_mark_node
;
2345 /* Figure out whether or not we're going to use the global operator
2347 if (!globally_qualified_p
2348 && IS_AGGR_TYPE (true_type
)
2350 ? TYPE_HAS_ARRAY_NEW_OPERATOR (true_type
)
2351 : TYPE_HAS_NEW_OPERATOR (true_type
)))
2356 /* We only need cookies for arrays containing types for which we
2358 if (!has_array
|| !TYPE_VEC_NEW_USES_COOKIE (true_type
))
2360 /* When using placement new, users may not realize that they need
2361 the extra storage. Under the old ABI, we don't allocate the
2362 cookie whenever they use one placement argument of type `void
2363 *'. Under the new ABI, we require that the operator called be
2364 the global placement operator delete[]. */
2365 else if (placement
&& !TREE_CHAIN (placement
)
2366 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2368 use_cookie
= !use_global_new
;
2369 /* Otherwise, we need the cookie. */
2373 /* Compute the number of extra bytes to allocate, now that we know
2374 whether or not we need the cookie. */
2377 cookie_size
= get_cookie_size (true_type
);
2378 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
2381 /* Allocate the object. */
2383 if (! placement
&& TYPE_FOR_JAVA (true_type
))
2385 tree class_addr
, alloc_decl
;
2386 tree class_decl
= build_java_class_ref (true_type
);
2387 tree class_size
= size_in_bytes (true_type
);
2388 static char alloc_name
[] = "_Jv_AllocObject";
2390 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2391 if (alloc_decl
== NULL_TREE
)
2392 fatal_error ("call to Java constructor with `%s' undefined",
2395 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2396 alloc_call
= (build_function_call
2398 tree_cons (NULL_TREE
, class_addr
,
2399 build_tree_list (NULL_TREE
, class_size
))));
2406 args
= tree_cons (NULL_TREE
, size
, placement
);
2407 fnname
= ansi_opname (code
);
2410 alloc_call
= (build_new_function_call
2411 (lookup_function_nonclass (fnname
, args
),
2414 alloc_call
= build_method_call (build_dummy_object (true_type
),
2415 fnname
, args
, NULL_TREE
,
2419 if (alloc_call
== error_mark_node
)
2420 return error_mark_node
;
2422 if (alloc_call
== NULL_TREE
)
2425 /* unless an allocation function is declared with an empty excep-
2426 tion-specification (_except.spec_), throw(), it indicates failure to
2427 allocate storage by throwing a bad_alloc exception (clause _except_,
2428 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2429 cation function is declared with an empty exception-specification,
2430 throw(), it returns null to indicate failure to allocate storage and a
2431 non-null pointer otherwise.
2433 So check for a null exception spec on the op new we just called. */
2435 /* The ADDR_EXPR. */
2436 t
= TREE_OPERAND (alloc_call
, 0);
2438 t
= TREE_OPERAND (t
, 0);
2439 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (t
));
2440 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2442 alloc_expr
= alloc_call
;
2445 /* Adjust so we're pointing to the start of the object. */
2446 alloc_expr
= build (PLUS_EXPR
, TREE_TYPE (alloc_expr
),
2447 alloc_expr
, cookie_size
);
2449 /* While we're working, use a pointer to the type we've actually
2451 alloc_expr
= convert (build_pointer_type (full_type
), alloc_expr
);
2453 /* Now save the allocation expression so we only evaluate it once. */
2454 alloc_expr
= get_target_expr (alloc_expr
);
2455 alloc_node
= TREE_OPERAND (alloc_expr
, 0);
2457 /* Now initialize the cookie. */
2462 /* Store the number of bytes allocated so that we can know how
2463 many elements to destroy later. Under the new ABI, we use
2464 the last sizeof (size_t) bytes to store the number of
2466 cookie
= build (MINUS_EXPR
, build_pointer_type (sizetype
),
2467 alloc_node
, size_in_bytes (sizetype
));
2468 cookie
= build_indirect_ref (cookie
, NULL_PTR
);
2470 cookie_expr
= build (MODIFY_EXPR
, void_type_node
, cookie
, nelts
);
2471 TREE_SIDE_EFFECTS (cookie_expr
) = 1;
2474 cookie_expr
= NULL_TREE
;
2476 /* Now initialize the allocated object. */
2477 init_expr
= NULL_TREE
;
2478 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2480 init_expr
= build_indirect_ref (alloc_node
, NULL_PTR
);
2482 if (init
== void_zero_node
)
2483 init
= build_default_init (full_type
);
2484 else if (init
&& pedantic
&& has_array
)
2485 cp_pedwarn ("ISO C++ forbids initialization in array new");
2488 init_expr
= build_vec_init (init_expr
, init
, 0);
2489 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2490 init_expr
= build_method_call (init_expr
,
2491 complete_ctor_identifier
,
2492 init
, TYPE_BINFO (true_type
),
2496 /* We are processing something like `new int (10)', which
2497 means allocate an int, and initialize it with 10. */
2499 if (TREE_CODE (init
) == TREE_LIST
)
2501 if (TREE_CHAIN (init
) != NULL_TREE
)
2503 ("initializer list being treated as compound expression");
2504 init
= build_compound_expr (init
);
2506 else if (TREE_CODE (init
) == CONSTRUCTOR
2507 && TREE_TYPE (init
) == NULL_TREE
)
2509 pedwarn ("ISO C++ forbids aggregate initializer to new");
2510 init
= digest_init (type
, init
, 0);
2513 init_expr
= build_modify_expr (init_expr
, INIT_EXPR
, init
);
2516 if (init_expr
== error_mark_node
)
2517 return error_mark_node
;
2519 /* If any part of the object initialization terminates by throwing an
2520 exception and a suitable deallocation function can be found, the
2521 deallocation function is called to free the memory in which the
2522 object was being constructed, after which the exception continues
2523 to propagate in the context of the new-expression. If no
2524 unambiguous matching deallocation function can be found,
2525 propagating the exception does not cause the object's memory to be
2527 if (flag_exceptions
&& ! use_java_new
)
2529 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2531 int flags
= (LOOKUP_NORMAL
2532 | (globally_qualified_p
* LOOKUP_GLOBAL
));
2534 /* The Standard is unclear here, but the right thing to do
2535 is to use the same method for finding deallocation
2536 functions that we use for finding allocation functions. */
2537 flags
|= LOOKUP_SPECULATIVELY
;
2539 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
,
2542 /* Ack! First we allocate the memory. Then we set our sentry
2543 variable to true, and expand a cleanup that deletes the memory
2544 if sentry is true. Then we run the constructor, and finally
2547 It would be nice to be able to handle this without the sentry
2548 variable, perhaps with a TRY_CATCH_EXPR, but this doesn't
2549 work. We allocate the space first, so if there are any
2550 temporaries with cleanups in the constructor args we need this
2551 EH region to extend until end of full-expression to preserve
2554 If the backend had some mechanism so that we could force the
2555 allocation to be expanded after all the other args to the
2556 constructor, that would fix the nesting problem and we could
2557 do away with this complexity. But that would complicate other
2558 things; in particular, it would make it difficult to bail out
2559 if the allocation function returns null. */
2563 tree end
, sentry
, begin
;
2565 begin
= get_target_expr (boolean_true_node
);
2566 sentry
= TREE_OPERAND (begin
, 0);
2568 TREE_OPERAND (begin
, 2)
2569 = build (COND_EXPR
, void_type_node
, sentry
,
2570 cleanup
, void_zero_node
);
2572 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2573 sentry
, boolean_false_node
);
2576 = build (COMPOUND_EXPR
, void_type_node
, begin
,
2577 build (COMPOUND_EXPR
, void_type_node
, init_expr
,
2582 else if (CP_TYPE_CONST_P (true_type
))
2583 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2585 /* Now build up the return value in reverse order. */
2590 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
2592 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
2594 if (rval
== alloc_node
)
2595 /* If we didn't modify anything, strip the TARGET_EXPR and return the
2597 rval
= TREE_OPERAND (alloc_expr
, 1);
2602 tree ifexp
= cp_build_binary_op (NE_EXPR
, alloc_node
,
2604 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2607 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2610 /* Now strip the outer ARRAY_TYPE, so we return a pointer to the first
2612 rval
= convert (build_pointer_type (type
), rval
);
2618 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, use_global_delete
)
2619 tree base
, maxindex
, type
;
2620 special_function_kind auto_delete_vec
;
2621 int use_global_delete
;
2624 tree ptype
= build_pointer_type (type
= complete_type (type
));
2625 tree size_exp
= size_in_bytes (type
);
2627 /* Temporary variables used by the loop. */
2628 tree tbase
, tbase_init
;
2630 /* This is the body of the loop that implements the deletion of a
2631 single element, and moves temp variables to next elements. */
2634 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2637 /* This is the thing that governs what to do after the loop has run. */
2638 tree deallocate_expr
= 0;
2640 /* This is the BIND_EXPR which holds the outermost iterator of the
2641 loop. It is convenient to set this variable up and test it before
2642 executing any other code in the loop.
2643 This is also the containing expression returned by this function. */
2644 tree controller
= NULL_TREE
;
2646 if (! IS_AGGR_TYPE (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2648 loop
= integer_zero_node
;
2652 /* The below is short by the cookie size. */
2653 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2654 convert (sizetype
, maxindex
));
2656 tbase
= create_temporary_var (ptype
);
2657 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2658 fold (build (PLUS_EXPR
, ptype
,
2661 DECL_REGISTER (tbase
) = 1;
2662 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2663 TREE_SIDE_EFFECTS (controller
) = 1;
2667 body
= tree_cons (NULL_TREE
,
2668 build_delete (ptype
, tbase
, sfk_complete_destructor
,
2669 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2672 body
= tree_cons (NULL_TREE
,
2673 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2676 body
= tree_cons (NULL_TREE
,
2677 build (EXIT_EXPR
, void_type_node
,
2678 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2681 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2683 loop
= tree_cons (NULL_TREE
, tbase_init
,
2684 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2685 loop
= build_compound_expr (loop
);
2688 /* If the delete flag is one, or anything else with the low bit set,
2689 delete the storage. */
2690 deallocate_expr
= integer_zero_node
;
2691 if (auto_delete_vec
!= sfk_base_destructor
)
2695 /* The below is short by the cookie size. */
2696 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2697 convert (sizetype
, maxindex
));
2699 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2706 cookie_size
= get_cookie_size (type
);
2708 = cp_convert (ptype
,
2709 cp_build_binary_op (MINUS_EXPR
,
2710 cp_convert (string_type_node
,
2713 /* True size with header. */
2714 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2717 if (auto_delete_vec
== sfk_deleting_destructor
)
2718 deallocate_expr
= build_x_delete (base_tbd
,
2719 2 | use_global_delete
,
2723 if (loop
&& deallocate_expr
!= integer_zero_node
)
2725 body
= tree_cons (NULL_TREE
, loop
,
2726 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2727 body
= build_compound_expr (body
);
2732 /* Outermost wrapper: If pointer is null, punt. */
2733 body
= fold (build (COND_EXPR
, void_type_node
,
2734 fold (build (NE_EXPR
, boolean_type_node
, base
,
2735 integer_zero_node
)),
2736 body
, integer_zero_node
));
2737 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2741 TREE_OPERAND (controller
, 1) = body
;
2745 return cp_convert (void_type_node
, body
);
2748 /* Create an unnamed variable of the indicated TYPE. */
2751 create_temporary_var (type
)
2756 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2757 TREE_USED (decl
) = 1;
2758 DECL_ARTIFICIAL (decl
) = 1;
2759 DECL_SOURCE_FILE (decl
) = input_filename
;
2760 DECL_SOURCE_LINE (decl
) = lineno
;
2761 DECL_IGNORED_P (decl
) = 1;
2762 DECL_CONTEXT (decl
) = current_function_decl
;
2767 /* Create a new temporary variable of the indicated TYPE, initialized
2770 It is not entered into current_binding_level, because that breaks
2771 things when it comes time to do final cleanups (which take place
2772 "outside" the binding contour of the function). */
2775 get_temp_regvar (type
, init
)
2780 decl
= create_temporary_var (type
);
2781 if (building_stmt_tree ())
2782 add_decl_stmt (decl
);
2783 if (!building_stmt_tree ())
2784 DECL_RTL (decl
) = assign_temp (type
, 2, 0, 1);
2785 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
2790 /* `build_vec_init' returns tree structure that performs
2791 initialization of a vector of aggregate types.
2793 BASE is a reference to the vector, of ARRAY_TYPE.
2794 INIT is the (possibly NULL) initializer.
2796 FROM_ARRAY is 0 if we should init everything with INIT
2797 (i.e., every element initialized from INIT).
2798 FROM_ARRAY is 1 if we should index into INIT in parallel
2799 with initialization of DECL.
2800 FROM_ARRAY is 2 if we should index into INIT in parallel,
2801 but use assignment instead of initialization. */
2804 build_vec_init (base
, init
, from_array
)
2809 tree base2
= NULL_TREE
;
2811 tree itype
= NULL_TREE
;
2813 /* The type of the array. */
2814 tree atype
= TREE_TYPE (base
);
2815 /* The type of an element in the array. */
2816 tree type
= TREE_TYPE (atype
);
2817 /* The type of a pointer to an element in the array. */
2822 tree try_block
= NULL_TREE
;
2823 tree try_body
= NULL_TREE
;
2824 int num_initialized_elts
= 0;
2825 tree maxindex
= array_type_nelts (TREE_TYPE (base
));
2827 if (maxindex
== error_mark_node
)
2828 return error_mark_node
;
2830 /* For g++.ext/arrnew.C. */
2831 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == NULL_TREE
)
2832 init
= digest_init (atype
, init
, 0);
2834 if (init
&& !TYPE_NEEDS_CONSTRUCTING (type
)
2835 && ((TREE_CODE (init
) == CONSTRUCTOR
2836 /* Don't do this if the CONSTRUCTOR might contain something
2837 that might throw and require us to clean up. */
2838 && (CONSTRUCTOR_ELTS (init
) == NULL_TREE
2839 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type
))))
2842 /* Do non-default initialization of POD arrays resulting from
2843 brace-enclosed initializers. In this case, digest_init and
2844 store_constructor will handle the semantics for us. */
2846 stmt_expr
= build (INIT_EXPR
, atype
, base
, init
);
2847 TREE_SIDE_EFFECTS (stmt_expr
) = 1;
2851 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2852 ptype
= build_pointer_type (type
);
2853 size
= size_in_bytes (type
);
2854 if (TREE_CODE (TREE_TYPE (base
)) == ARRAY_TYPE
)
2855 base
= cp_convert (ptype
, default_conversion (base
));
2857 /* The code we are generating looks like:
2861 ptrdiff_t iterator = maxindex;
2864 ... initialize *t1 ...
2866 } while (--iterator != -1);
2868 ... destroy elements that were constructed ...
2872 We can omit the try and catch blocks if we know that the
2873 initialization will never throw an exception, or if the array
2874 elements do not have destructors. We can omit the loop completely if
2875 the elements of the array do not have constructors.
2877 We actually wrap the entire body of the above in a STMT_EXPR, for
2880 When copying from array to another, when the array elements have
2881 only trivial copy constructors, we should use __builtin_memcpy
2882 rather than generating a loop. That way, we could take advantage
2883 of whatever cleverness the back-end has for dealing with copies
2884 of blocks of memory. */
2886 begin_init_stmts (&stmt_expr
, &compound_stmt
);
2887 destroy_temps
= stmts_are_full_exprs_p ();
2888 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2889 rval
= get_temp_regvar (ptype
, base
);
2890 base
= get_temp_regvar (ptype
, rval
);
2891 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2893 /* Protect the entire array initialization so that we can destroy
2894 the partially constructed array if an exception is thrown.
2895 But don't do this if we're assigning. */
2896 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2899 try_block
= begin_try_block ();
2900 try_body
= begin_compound_stmt (/*has_no_scope=*/1);
2903 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
2905 /* Do non-default initialization of non-POD arrays resulting from
2906 brace-enclosed initializers. */
2911 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2913 tree elt
= TREE_VALUE (elts
);
2914 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2916 num_initialized_elts
++;
2918 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2919 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0));
2921 finish_expr_stmt (build_modify_expr (baseref
, NOP_EXPR
,
2924 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base
, 0));
2925 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR
, iterator
, 0));
2928 /* Clear out INIT so that we don't get confused below. */
2931 else if (from_array
)
2933 /* If initializing one array from another, initialize element by
2934 element. We rely upon the below calls the do argument
2938 base2
= default_conversion (init
);
2939 itype
= TREE_TYPE (base2
);
2940 base2
= get_temp_regvar (itype
, base2
);
2941 itype
= TREE_TYPE (itype
);
2943 else if (TYPE_LANG_SPECIFIC (type
)
2944 && TYPE_NEEDS_CONSTRUCTING (type
)
2945 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2947 error ("initializer ends prematurely");
2948 return error_mark_node
;
2952 /* Now, default-initialize any remaining elements. We don't need to
2953 do that if a) the type does not need constructing, or b) we've
2954 already initialized all the elements.
2956 We do need to keep going if we're copying an array. */
2959 || (TYPE_NEEDS_CONSTRUCTING (type
)
2960 && ! (host_integerp (maxindex
, 0)
2961 && (num_initialized_elts
2962 == tree_low_cst (maxindex
, 0) + 1))))
2964 /* If the ITERATOR is equal to -1, then we don't have to loop;
2965 we've already initialized all the elements. */
2971 if_stmt
= begin_if_stmt ();
2972 finish_if_stmt_cond (build (NE_EXPR
, boolean_type_node
,
2973 iterator
, integer_minus_one_node
),
2976 /* Otherwise, loop through the elements. */
2977 do_stmt
= begin_do_stmt ();
2978 do_body
= begin_compound_stmt (/*has_no_scope=*/1);
2980 /* When we're not building a statement-tree, things are a little
2981 complicated. If, when we recursively call build_aggr_init,
2982 an expression containing a TARGET_EXPR is expanded, then it
2983 may get a cleanup. Then, the result of that expression is
2984 passed to finish_expr_stmt, which will call
2985 expand_start_target_temps/expand_end_target_temps. However,
2986 the latter call will not cause the cleanup to run because
2987 that block will still be on the block stack. So, we call
2988 expand_start_target_temps here manually; the corresponding
2989 call to expand_end_target_temps below will cause the cleanup
2991 if (!building_stmt_tree ())
2992 expand_start_target_temps ();
2996 tree to
= build1 (INDIRECT_REF
, type
, base
);
3000 from
= build1 (INDIRECT_REF
, itype
, base2
);
3004 if (from_array
== 2)
3005 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
3006 else if (TYPE_NEEDS_CONSTRUCTING (type
))
3007 elt_init
= build_aggr_init (to
, from
, 0);
3009 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
3011 my_friendly_abort (57);
3013 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3017 ("cannot initialize multi-dimensional array with initializer");
3018 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
3022 elt_init
= build_aggr_init (build1 (INDIRECT_REF
, type
, base
),
3025 /* The initialization of each array element is a
3026 full-expression, as per core issue 124. */
3027 if (!building_stmt_tree ())
3029 genrtl_expr_stmt (elt_init
);
3030 expand_end_target_temps ();
3034 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
3035 finish_expr_stmt (elt_init
);
3036 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
3039 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base
, 0));
3041 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base2
, 0));
3043 finish_compound_stmt (/*has_no_scope=*/1, do_body
);
3044 finish_do_body (do_stmt
);
3045 finish_do_stmt (build (NE_EXPR
, boolean_type_node
,
3046 build_unary_op (PREDECREMENT_EXPR
, iterator
, 0),
3047 integer_minus_one_node
),
3050 finish_then_clause (if_stmt
);
3054 /* Make sure to cleanup any partially constructed elements. */
3055 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
3060 finish_compound_stmt (/*has_no_scope=*/1, try_body
);
3061 finish_cleanup_try_block (try_block
);
3062 e
= build_vec_delete_1 (rval
,
3063 cp_build_binary_op (MINUS_EXPR
, maxindex
,
3066 sfk_base_destructor
,
3067 /*use_global_delete=*/0);
3068 finish_cleanup (e
, try_block
);
3071 /* The value of the array initialization is the address of the
3072 first element in the array. */
3073 finish_expr_stmt (rval
);
3075 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
3076 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
3080 /* Free up storage of type TYPE, at address ADDR.
3082 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3085 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3086 used as the second argument to operator delete. It can include
3087 things like padding and magic size cookies. It has virtual in it,
3088 because if you have a base pointer and you delete through a virtual
3089 destructor, it should be the size of the dynamic object, not the
3090 static object, see Free Store 12.5 ISO C++.
3092 This does not call any destructors. */
3095 build_x_delete (addr
, which_delete
, virtual_size
)
3100 int use_global_delete
= which_delete
& 1;
3101 int use_vec_delete
= !!(which_delete
& 2);
3102 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3103 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
3105 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
3108 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3112 build_dtor_call (exp
, dtor_kind
, flags
)
3114 special_function_kind dtor_kind
;
3121 case sfk_complete_destructor
:
3122 name
= complete_dtor_identifier
;
3125 case sfk_base_destructor
:
3126 name
= base_dtor_identifier
;
3129 case sfk_deleting_destructor
:
3130 name
= deleting_dtor_identifier
;
3134 my_friendly_abort (20000524);
3136 return build_method_call (exp
, name
, NULL_TREE
, NULL_TREE
, flags
);
3139 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3140 ADDR is an expression which yields the store to be destroyed.
3141 AUTO_DELETE is the name of the destructor to call, i.e., either
3142 sfk_complete_destructor, sfk_base_destructor, or
3143 sfk_deleting_destructor.
3145 FLAGS is the logical disjunction of zero or more LOOKUP_
3146 flags. See cp-tree.h for more info.
3148 This function does not delete an object's virtual base classes. */
3151 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3153 special_function_kind auto_delete
;
3155 int use_global_delete
;
3161 if (addr
== error_mark_node
)
3162 return error_mark_node
;
3164 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3165 set to `error_mark_node' before it gets properly cleaned up. */
3166 if (type
== error_mark_node
)
3167 return error_mark_node
;
3169 type
= TYPE_MAIN_VARIANT (type
);
3171 if (TREE_CODE (type
) == POINTER_TYPE
)
3173 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3174 if (!VOID_TYPE_P (type
) && !complete_type_or_else (type
, addr
))
3175 return error_mark_node
;
3176 if (TREE_CODE (type
) == ARRAY_TYPE
)
3178 if (! IS_AGGR_TYPE (type
))
3180 /* Call the builtin operator delete. */
3181 return build_builtin_delete_call (addr
);
3183 if (TREE_SIDE_EFFECTS (addr
))
3184 addr
= save_expr (addr
);
3186 /* throw away const and volatile on target type of addr */
3187 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3188 ref
= build_indirect_ref (addr
, NULL_PTR
);
3190 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3193 if (TREE_SIDE_EFFECTS (addr
))
3194 addr
= save_expr (addr
);
3195 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3197 error ("unknown array size in delete");
3198 return error_mark_node
;
3200 return build_vec_delete (addr
, array_type_nelts (type
),
3201 auto_delete
, use_global_delete
);
3205 /* Don't check PROTECT here; leave that decision to the
3206 destructor. If the destructor is accessible, call it,
3207 else report error. */
3208 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3209 if (TREE_SIDE_EFFECTS (addr
))
3210 addr
= save_expr (addr
);
3212 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3214 ref
= build_indirect_ref (addr
, NULL_PTR
);
3217 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3219 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3221 if (auto_delete
!= sfk_deleting_destructor
)
3222 return void_zero_node
;
3224 return build_op_delete_call
3225 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3226 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3230 /* Below, we will reverse the order in which these calls are made.
3231 If we have a destructor, then that destructor will take care
3232 of the base classes; otherwise, we must do that here. */
3233 if (TYPE_HAS_DESTRUCTOR (type
))
3235 tree do_delete
= NULL_TREE
;
3238 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3240 /* Delete the object. */
3241 do_delete
= build_builtin_delete_call (addr
);
3242 /* Otherwise, treat this like a complete object destructor
3244 auto_delete
= sfk_complete_destructor
;
3247 expr
= build_dtor_call (ref
, auto_delete
, flags
);
3249 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3251 if (flags
& LOOKUP_DESTRUCTOR
)
3252 /* Explicit destructor call; don't check for null pointer. */
3253 ifexp
= integer_one_node
;
3255 /* Handle deleting a null pointer. */
3256 ifexp
= fold (cp_build_binary_op (NE_EXPR
, addr
, integer_zero_node
));
3258 if (ifexp
!= integer_one_node
)
3259 expr
= build (COND_EXPR
, void_type_node
,
3260 ifexp
, expr
, void_zero_node
);
3266 /* We only get here from finish_function for a destructor. */
3267 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3268 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (type
);
3269 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3270 tree exprstmt
= NULL_TREE
;
3272 /* Set this again before we call anything, as we might get called
3274 TYPE_HAS_DESTRUCTOR (type
) = 1;
3276 /* If we have member delete or vbases, we call delete in
3278 my_friendly_assert (auto_delete
== sfk_base_destructor
, 20000411);
3280 /* Take care of the remaining baseclasses. */
3281 for (i
= 0; i
< n_baseclasses
; i
++)
3283 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3284 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3285 || TREE_VIA_VIRTUAL (base_binfo
))
3288 expr
= build_scoped_method_call (ref
, base_binfo
,
3289 base_dtor_identifier
,
3292 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3295 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3297 if (TREE_CODE (member
) != FIELD_DECL
)
3299 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member
)))
3301 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3302 tree this_type
= TREE_TYPE (member
);
3303 expr
= build_delete (this_type
, this_member
,
3304 sfk_complete_destructor
, flags
, 0);
3305 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3310 return build_compound_expr (exprstmt
);
3311 /* Virtual base classes make this function do nothing. */
3312 return void_zero_node
;
3316 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3319 build_vbase_delete (type
, decl
)
3322 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3323 tree result
= NULL_TREE
;
3324 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3326 my_friendly_assert (addr
!= error_mark_node
, 222);
3331 = convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases
))),
3333 result
= tree_cons (NULL_TREE
,
3334 build_delete (TREE_TYPE (this_addr
), this_addr
,
3335 sfk_base_destructor
,
3336 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3338 vbases
= TREE_CHAIN (vbases
);
3340 return build_compound_expr (nreverse (result
));
3343 /* Build a C++ vector delete expression.
3344 MAXINDEX is the number of elements to be deleted.
3345 ELT_SIZE is the nominal size of each element in the vector.
3346 BASE is the expression that should yield the store to be deleted.
3347 This function expands (or synthesizes) these calls itself.
3348 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3350 This also calls delete for virtual baseclasses of elements of the vector.
3352 Update: MAXINDEX is no longer needed. The size can be extracted from the
3353 start of the vector for pointers, and from the type for arrays. We still
3354 use MAXINDEX for arrays because it happens to already have one of the
3355 values we'd have to extract. (We could use MAXINDEX with pointers to
3356 confirm the size, and trap if the numbers differ; not clear that it'd
3357 be worth bothering.) */
3360 build_vec_delete (base
, maxindex
, auto_delete_vec
, use_global_delete
)
3361 tree base
, maxindex
;
3362 special_function_kind auto_delete_vec
;
3363 int use_global_delete
;
3367 if (TREE_CODE (base
) == OFFSET_REF
)
3368 base
= resolve_offset_ref (base
);
3370 type
= TREE_TYPE (base
);
3372 base
= stabilize_reference (base
);
3374 /* Since we can use base many times, save_expr it. */
3375 if (TREE_SIDE_EFFECTS (base
))
3376 base
= save_expr (base
);
3378 if (TREE_CODE (type
) == POINTER_TYPE
)
3380 /* Step back one from start of vector, and read dimension. */
3383 type
= strip_array_types (TREE_TYPE (type
));
3384 cookie_addr
= build (MINUS_EXPR
,
3385 build_pointer_type (sizetype
),
3387 TYPE_SIZE_UNIT (sizetype
));
3388 maxindex
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3390 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3392 /* get the total number of things in the array, maxindex is a bad name */
3393 maxindex
= array_type_nelts_total (type
);
3394 type
= strip_array_types (type
);
3395 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3399 if (base
!= error_mark_node
)
3400 error ("type to vector delete is neither pointer or array type");
3401 return error_mark_node
;
3404 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,