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
);
1958 /* Pointer to data members are offset by one, so that a null
1959 pointer with a real value of 0 is distinguishable from an
1960 offset of the first member of a structure. */
1961 member
= cp_build_binary_op (MINUS_EXPR
, member
,
1962 cp_convert (ptrdiff_type_node
,
1965 return build1 (INDIRECT_REF
, type
,
1966 build (PLUS_EXPR
, build_pointer_type (type
),
1969 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1971 return get_member_function_from_ptrfunc (&addr
, member
);
1973 my_friendly_abort (56);
1978 /* If DECL is a `const' declaration, and its value is a known
1979 constant, then return that value. */
1982 decl_constant_value (decl
)
1985 if (TREE_READONLY_DECL_P (decl
)
1986 && ! TREE_THIS_VOLATILE (decl
)
1987 && DECL_INITIAL (decl
)
1988 && DECL_INITIAL (decl
) != error_mark_node
1989 /* This is invalid if initial value is not constant.
1990 If it has either a function call, a memory reference,
1991 or a variable, then re-evaluating it could give different results. */
1992 && TREE_CONSTANT (DECL_INITIAL (decl
))
1993 /* Check for cases where this is sub-optimal, even though valid. */
1994 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1995 return DECL_INITIAL (decl
);
1999 /* Common subroutines of build_new and build_vec_delete. */
2001 /* Call the global __builtin_delete to delete ADDR. */
2004 build_builtin_delete_call (addr
)
2007 mark_used (global_delete_fndecl
);
2008 return build_call (global_delete_fndecl
, build_tree_list (NULL_TREE
, addr
));
2011 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
2012 (which needs to go through some sort of groktypename) or it
2013 is the name of the class we are newing. INIT is an initialization value.
2014 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
2015 If INIT is void_type_node, it means do *not* call a constructor
2018 For types with constructors, the data returned is initialized
2019 by the appropriate constructor.
2021 Whether the type has a constructor or not, if it has a pointer
2022 to a virtual function table, then that pointer is set up
2025 Unless I am mistaken, a call to new () will return initialized
2026 data regardless of whether the constructor itself is private or
2027 not. NOPE; new fails if the constructor is private (jcm).
2029 Note that build_new does nothing to assure that any special
2030 alignment requirements of the type are met. Rather, it leaves
2031 it up to malloc to do the right thing. Otherwise, folding to
2032 the right alignment cal cause problems if the user tries to later
2033 free the memory returned by `new'.
2035 PLACEMENT is the `placement' list for user-defined operator new (). */
2038 build_new (placement
, decl
, init
, use_global_new
)
2044 tree nelts
= NULL_TREE
, t
;
2047 if (decl
== error_mark_node
)
2048 return error_mark_node
;
2050 if (TREE_CODE (decl
) == TREE_LIST
)
2052 tree absdcl
= TREE_VALUE (decl
);
2053 tree last_absdcl
= NULL_TREE
;
2055 if (current_function_decl
2056 && DECL_CONSTRUCTOR_P (current_function_decl
))
2057 my_friendly_assert (immediate_size_expand
== 0, 19990926);
2059 nelts
= integer_one_node
;
2061 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
2062 my_friendly_abort (215);
2063 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2065 last_absdcl
= absdcl
;
2066 absdcl
= TREE_OPERAND (absdcl
, 0);
2069 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2071 /* probably meant to be a vec new */
2074 while (TREE_OPERAND (absdcl
, 0)
2075 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2077 last_absdcl
= absdcl
;
2078 absdcl
= TREE_OPERAND (absdcl
, 0);
2082 this_nelts
= TREE_OPERAND (absdcl
, 1);
2083 if (this_nelts
!= error_mark_node
)
2085 if (this_nelts
== NULL_TREE
)
2086 error ("new of array type fails to specify size");
2087 else if (processing_template_decl
)
2090 absdcl
= TREE_OPERAND (absdcl
, 0);
2094 int flags
= pedantic
? WANT_INT
: (WANT_INT
| WANT_ENUM
);
2095 if (build_expr_type_conversion (flags
, this_nelts
, 0)
2097 pedwarn ("size in array new must have integral type");
2099 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2100 absdcl
= TREE_OPERAND (absdcl
, 0);
2101 if (this_nelts
== integer_zero_node
)
2103 warning ("zero size array reserves no space");
2104 nelts
= integer_zero_node
;
2107 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2111 nelts
= integer_zero_node
;
2115 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2117 TREE_VALUE (decl
) = absdcl
;
2119 type
= groktypename (decl
);
2120 if (! type
|| type
== error_mark_node
)
2121 return error_mark_node
;
2123 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2125 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2127 /* An aggregate type. */
2128 type
= IDENTIFIER_TYPE_VALUE (decl
);
2129 decl
= TYPE_MAIN_DECL (type
);
2133 /* A builtin type. */
2134 decl
= lookup_name (decl
, 1);
2135 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2136 type
= TREE_TYPE (decl
);
2139 else if (TREE_CODE (decl
) == TYPE_DECL
)
2141 type
= TREE_TYPE (decl
);
2146 decl
= TYPE_MAIN_DECL (type
);
2149 if (processing_template_decl
)
2152 t
= tree_cons (tree_cons (NULL_TREE
, type
, NULL_TREE
),
2153 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2158 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2159 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2163 /* ``A reference cannot be created by the new operator. A reference
2164 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2165 returned by new.'' ARM 5.3.3 */
2166 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2168 error ("new cannot be applied to a reference type");
2169 type
= TREE_TYPE (type
);
2172 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2174 error ("new cannot be applied to a function type");
2175 return error_mark_node
;
2178 /* When the object being created is an array, the new-expression yields a
2179 pointer to the initial element (if any) of the array. For example,
2180 both new int and new int[10] return an int*. 5.3.4. */
2181 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2183 nelts
= array_type_nelts_top (type
);
2185 type
= TREE_TYPE (type
);
2189 t
= build_nt (ARRAY_REF
, type
, nelts
);
2193 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2194 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2195 TREE_SIDE_EFFECTS (rval
) = 1;
2196 rval
= build_new_1 (rval
);
2197 if (rval
== error_mark_node
)
2198 return error_mark_node
;
2200 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2201 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2202 TREE_NO_UNUSED_WARNING (rval
) = 1;
2207 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2210 build_java_class_ref (type
)
2213 tree name
, class_decl
;
2214 static tree CL_suffix
= NULL_TREE
;
2215 if (CL_suffix
== NULL_TREE
)
2216 CL_suffix
= get_identifier("class$");
2217 if (jclass_node
== NULL_TREE
)
2219 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2220 if (jclass_node
== NULL_TREE
)
2221 fatal_error ("call to Java constructor, while `jclass' undefined");
2223 jclass_node
= TREE_TYPE (jclass_node
);
2226 /* Mangle the class$ field, new and old ABI */
2230 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2231 if (DECL_NAME (field
) == CL_suffix
)
2233 name
= mangle_decl (field
);
2237 internal_error ("Can't find class$");
2240 name
= build_static_name (type
, CL_suffix
);
2242 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2243 if (class_decl
== NULL_TREE
)
2245 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2246 TREE_STATIC (class_decl
) = 1;
2247 DECL_EXTERNAL (class_decl
) = 1;
2248 TREE_PUBLIC (class_decl
) = 1;
2249 DECL_ARTIFICIAL (class_decl
) = 1;
2250 DECL_IGNORED_P (class_decl
) = 1;
2251 pushdecl_top_level (class_decl
);
2252 make_decl_rtl (class_decl
, NULL_PTR
);
2257 /* Returns the size of the cookie to use when allocating an array
2258 whose elements have the indicated TYPE. Assumes that it is already
2259 known that a cookie is needed. */
2262 get_cookie_size (type
)
2269 /* Under the new ABI, we need to allocate an additional max
2270 (sizeof (size_t), alignof (true_type)) bytes. */
2274 sizetype_size
= size_in_bytes (sizetype
);
2275 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
2276 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
2277 cookie_size
= sizetype_size
;
2279 cookie_size
= type_align
;
2283 if (TYPE_ALIGN (type
) > TYPE_ALIGN (BI_header_type
))
2284 return size_int (TYPE_ALIGN_UNIT (type
));
2286 return size_in_bytes (BI_header_type
);
2292 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2293 value is immediately handed to expand_expr. */
2299 tree placement
, init
;
2300 tree type
, true_type
, size
, rval
, t
;
2302 tree nelts
= NULL_TREE
;
2303 tree alloc_call
, alloc_expr
, alloc_node
;
2304 tree cookie_expr
, init_expr
;
2306 enum tree_code code
;
2307 int use_cookie
, nothrow
, check_new
;
2308 /* Nonzero if the user wrote `::new' rather than just `new'. */
2309 int globally_qualified_p
;
2310 /* Nonzero if we're going to call a global operator new, rather than
2311 a class-specific version. */
2313 int use_java_new
= 0;
2314 /* If non-NULL, the number of extra bytes to allocate at the
2315 beginning of the storage allocated for an array-new expression in
2316 order to store the number of elements. */
2317 tree cookie_size
= NULL_TREE
;
2319 placement
= TREE_OPERAND (exp
, 0);
2320 type
= TREE_OPERAND (exp
, 1);
2321 init
= TREE_OPERAND (exp
, 2);
2322 globally_qualified_p
= NEW_EXPR_USE_GLOBAL (exp
);
2324 if (TREE_CODE (type
) == ARRAY_REF
)
2327 nelts
= TREE_OPERAND (type
, 1);
2328 type
= TREE_OPERAND (type
, 0);
2330 full_type
= cp_build_binary_op (MINUS_EXPR
, nelts
, integer_one_node
);
2331 full_type
= build_index_type (full_type
);
2332 full_type
= build_cplus_array_type (type
, full_type
);
2339 code
= has_array
? VEC_NEW_EXPR
: NEW_EXPR
;
2341 /* If our base type is an array, then make sure we know how many elements
2343 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2345 tree this_nelts
= array_type_nelts_top (true_type
);
2346 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2347 true_type
= TREE_TYPE (true_type
);
2350 if (!complete_type_or_else (true_type
, exp
))
2351 return error_mark_node
;
2353 size
= size_in_bytes (true_type
);
2355 size
= fold (cp_build_binary_op (MULT_EXPR
, size
, nelts
));
2357 if (TREE_CODE (true_type
) == VOID_TYPE
)
2359 error ("invalid type `void' for new");
2360 return error_mark_node
;
2363 if (abstract_virtuals_error (NULL_TREE
, true_type
))
2364 return error_mark_node
;
2366 /* Figure out whether or not we're going to use the global operator
2368 if (!globally_qualified_p
2369 && IS_AGGR_TYPE (true_type
)
2371 ? TYPE_HAS_ARRAY_NEW_OPERATOR (true_type
)
2372 : TYPE_HAS_NEW_OPERATOR (true_type
)))
2377 /* We only need cookies for arrays containing types for which we
2379 if (!has_array
|| !TYPE_VEC_NEW_USES_COOKIE (true_type
))
2381 /* When using placement new, users may not realize that they need
2382 the extra storage. Under the old ABI, we don't allocate the
2383 cookie whenever they use one placement argument of type `void
2384 *'. Under the new ABI, we require that the operator called be
2385 the global placement operator delete[]. */
2386 else if (placement
&& !TREE_CHAIN (placement
)
2387 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2389 use_cookie
= (!flag_new_abi
|| !use_global_new
);
2390 /* Otherwise, we need the cookie. */
2394 /* Compute the number of extra bytes to allocate, now that we know
2395 whether or not we need the cookie. */
2398 cookie_size
= get_cookie_size (true_type
);
2399 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
2402 /* Allocate the object. */
2404 if (! placement
&& TYPE_FOR_JAVA (true_type
))
2406 tree class_addr
, alloc_decl
;
2407 tree class_decl
= build_java_class_ref (true_type
);
2408 tree class_size
= size_in_bytes (true_type
);
2409 static char alloc_name
[] = "_Jv_AllocObject";
2411 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2412 if (alloc_decl
== NULL_TREE
)
2413 fatal_error ("call to Java constructor with `%s' undefined",
2416 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2417 alloc_call
= (build_function_call
2419 tree_cons (NULL_TREE
, class_addr
,
2420 build_tree_list (NULL_TREE
, class_size
))));
2427 args
= tree_cons (NULL_TREE
, size
, placement
);
2428 fnname
= ansi_opname (code
);
2431 alloc_call
= (build_new_function_call
2432 (lookup_function_nonclass (fnname
, args
),
2435 alloc_call
= build_method_call (build_dummy_object (true_type
),
2436 fnname
, args
, NULL_TREE
,
2440 if (alloc_call
== error_mark_node
)
2441 return error_mark_node
;
2443 if (alloc_call
== NULL_TREE
)
2446 /* unless an allocation function is declared with an empty excep-
2447 tion-specification (_except.spec_), throw(), it indicates failure to
2448 allocate storage by throwing a bad_alloc exception (clause _except_,
2449 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2450 cation function is declared with an empty exception-specification,
2451 throw(), it returns null to indicate failure to allocate storage and a
2452 non-null pointer otherwise.
2454 So check for a null exception spec on the op new we just called. */
2456 /* The ADDR_EXPR. */
2457 t
= TREE_OPERAND (alloc_call
, 0);
2459 t
= TREE_OPERAND (t
, 0);
2460 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (t
));
2461 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2463 alloc_expr
= alloc_call
;
2466 /* Adjust so we're pointing to the start of the object. */
2467 alloc_expr
= build (PLUS_EXPR
, TREE_TYPE (alloc_expr
),
2468 alloc_expr
, cookie_size
);
2470 /* While we're working, use a pointer to the type we've actually
2472 alloc_expr
= convert (build_pointer_type (full_type
), alloc_expr
);
2474 /* Now save the allocation expression so we only evaluate it once. */
2475 alloc_expr
= get_target_expr (alloc_expr
);
2476 alloc_node
= TREE_OPERAND (alloc_expr
, 0);
2478 /* Now initialize the cookie. */
2483 /* Store the number of bytes allocated so that we can know how
2484 many elements to destroy later. */
2487 /* Under the new ABI, we use the last sizeof (size_t) bytes
2488 to store the number of elements. */
2489 cookie
= build (MINUS_EXPR
, build_pointer_type (sizetype
),
2490 alloc_node
, size_in_bytes (sizetype
));
2491 cookie
= build_indirect_ref (cookie
, NULL_PTR
);
2495 cookie
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
2496 alloc_node
, cookie_size
);
2497 cookie
= build_indirect_ref (cookie
, NULL_PTR
);
2498 cookie
= build_component_ref (cookie
, nelts_identifier
,
2501 cookie_expr
= build (MODIFY_EXPR
, void_type_node
, cookie
, nelts
);
2502 TREE_SIDE_EFFECTS (cookie_expr
) = 1;
2505 cookie_expr
= NULL_TREE
;
2507 /* Now initialize the allocated object. */
2508 init_expr
= NULL_TREE
;
2509 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2511 init_expr
= build_indirect_ref (alloc_node
, NULL_PTR
);
2513 if (init
== void_zero_node
)
2514 init
= build_default_init (full_type
);
2515 else if (init
&& pedantic
&& has_array
)
2516 cp_pedwarn ("ISO C++ forbids initialization in array new");
2519 init_expr
= build_vec_init (init_expr
, init
, 0);
2520 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2521 init_expr
= build_method_call (init_expr
,
2522 complete_ctor_identifier
,
2523 init
, TYPE_BINFO (true_type
),
2527 /* We are processing something like `new int (10)', which
2528 means allocate an int, and initialize it with 10. */
2530 if (TREE_CODE (init
) == TREE_LIST
)
2532 if (TREE_CHAIN (init
) != NULL_TREE
)
2534 ("initializer list being treated as compound expression");
2535 init
= build_compound_expr (init
);
2537 else if (TREE_CODE (init
) == CONSTRUCTOR
2538 && TREE_TYPE (init
) == NULL_TREE
)
2540 pedwarn ("ISO C++ forbids aggregate initializer to new");
2541 init
= digest_init (type
, init
, 0);
2544 init_expr
= build_modify_expr (init_expr
, INIT_EXPR
, init
);
2547 if (init_expr
== error_mark_node
)
2548 return error_mark_node
;
2550 /* If any part of the object initialization terminates by throwing an
2551 exception and a suitable deallocation function can be found, the
2552 deallocation function is called to free the memory in which the
2553 object was being constructed, after which the exception continues
2554 to propagate in the context of the new-expression. If no
2555 unambiguous matching deallocation function can be found,
2556 propagating the exception does not cause the object's memory to be
2558 if (flag_exceptions
&& ! use_java_new
)
2560 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2562 int flags
= (LOOKUP_NORMAL
2563 | (globally_qualified_p
* LOOKUP_GLOBAL
));
2565 /* The Standard is unclear here, but the right thing to do
2566 is to use the same method for finding deallocation
2567 functions that we use for finding allocation functions. */
2568 flags
|= LOOKUP_SPECULATIVELY
;
2570 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
,
2573 /* Ack! First we allocate the memory. Then we set our sentry
2574 variable to true, and expand a cleanup that deletes the memory
2575 if sentry is true. Then we run the constructor, and finally
2578 It would be nice to be able to handle this without the sentry
2579 variable, perhaps with a TRY_CATCH_EXPR, but this doesn't
2580 work. We allocate the space first, so if there are any
2581 temporaries with cleanups in the constructor args we need this
2582 EH region to extend until end of full-expression to preserve
2585 If the backend had some mechanism so that we could force the
2586 allocation to be expanded after all the other args to the
2587 constructor, that would fix the nesting problem and we could
2588 do away with this complexity. But that would complicate other
2589 things; in particular, it would make it difficult to bail out
2590 if the allocation function returns null. */
2594 tree end
, sentry
, begin
;
2596 begin
= get_target_expr (boolean_true_node
);
2597 sentry
= TREE_OPERAND (begin
, 0);
2599 TREE_OPERAND (begin
, 2)
2600 = build (COND_EXPR
, void_type_node
, sentry
,
2601 cleanup
, void_zero_node
);
2603 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2604 sentry
, boolean_false_node
);
2607 = build (COMPOUND_EXPR
, void_type_node
, begin
,
2608 build (COMPOUND_EXPR
, void_type_node
, init_expr
,
2613 else if (CP_TYPE_CONST_P (true_type
))
2614 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2616 /* Now build up the return value in reverse order. */
2621 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
2623 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
2625 if (rval
== alloc_node
)
2626 /* If we didn't modify anything, strip the TARGET_EXPR and return the
2628 rval
= TREE_OPERAND (alloc_expr
, 1);
2633 tree ifexp
= cp_build_binary_op (NE_EXPR
, alloc_node
,
2635 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2638 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2641 /* Now strip the outer ARRAY_TYPE, so we return a pointer to the first
2643 rval
= convert (build_pointer_type (type
), rval
);
2649 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, use_global_delete
)
2650 tree base
, maxindex
, type
;
2651 special_function_kind auto_delete_vec
;
2652 int use_global_delete
;
2655 tree ptype
= build_pointer_type (type
= complete_type (type
));
2656 tree size_exp
= size_in_bytes (type
);
2658 /* Temporary variables used by the loop. */
2659 tree tbase
, tbase_init
;
2661 /* This is the body of the loop that implements the deletion of a
2662 single element, and moves temp variables to next elements. */
2665 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2668 /* This is the thing that governs what to do after the loop has run. */
2669 tree deallocate_expr
= 0;
2671 /* This is the BIND_EXPR which holds the outermost iterator of the
2672 loop. It is convenient to set this variable up and test it before
2673 executing any other code in the loop.
2674 This is also the containing expression returned by this function. */
2675 tree controller
= NULL_TREE
;
2677 if (! IS_AGGR_TYPE (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2679 loop
= integer_zero_node
;
2683 /* The below is short by the cookie size. */
2684 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2685 convert (sizetype
, maxindex
));
2687 tbase
= create_temporary_var (ptype
);
2688 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2689 fold (build (PLUS_EXPR
, ptype
,
2692 DECL_REGISTER (tbase
) = 1;
2693 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2694 TREE_SIDE_EFFECTS (controller
) = 1;
2698 body
= tree_cons (NULL_TREE
,
2699 build_delete (ptype
, tbase
, sfk_complete_destructor
,
2700 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2703 body
= tree_cons (NULL_TREE
,
2704 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2707 body
= tree_cons (NULL_TREE
,
2708 build (EXIT_EXPR
, void_type_node
,
2709 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2712 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2714 loop
= tree_cons (NULL_TREE
, tbase_init
,
2715 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2716 loop
= build_compound_expr (loop
);
2719 /* If the delete flag is one, or anything else with the low bit set,
2720 delete the storage. */
2721 deallocate_expr
= integer_zero_node
;
2722 if (auto_delete_vec
!= sfk_base_destructor
)
2726 /* The below is short by the cookie size. */
2727 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2728 convert (sizetype
, maxindex
));
2730 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2737 cookie_size
= get_cookie_size (type
);
2739 = cp_convert (ptype
,
2740 cp_build_binary_op (MINUS_EXPR
,
2741 cp_convert (string_type_node
,
2744 /* True size with header. */
2745 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2748 if (auto_delete_vec
== sfk_deleting_destructor
)
2749 deallocate_expr
= build_x_delete (base_tbd
,
2750 2 | use_global_delete
,
2754 if (loop
&& deallocate_expr
!= integer_zero_node
)
2756 body
= tree_cons (NULL_TREE
, loop
,
2757 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2758 body
= build_compound_expr (body
);
2763 /* Outermost wrapper: If pointer is null, punt. */
2764 body
= fold (build (COND_EXPR
, void_type_node
,
2765 fold (build (NE_EXPR
, boolean_type_node
, base
,
2766 integer_zero_node
)),
2767 body
, integer_zero_node
));
2768 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2772 TREE_OPERAND (controller
, 1) = body
;
2776 return cp_convert (void_type_node
, body
);
2779 /* Create an unnamed variable of the indicated TYPE. */
2782 create_temporary_var (type
)
2787 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2788 TREE_USED (decl
) = 1;
2789 DECL_ARTIFICIAL (decl
) = 1;
2790 DECL_SOURCE_FILE (decl
) = input_filename
;
2791 DECL_SOURCE_LINE (decl
) = lineno
;
2792 DECL_IGNORED_P (decl
) = 1;
2793 DECL_CONTEXT (decl
) = current_function_decl
;
2798 /* Create a new temporary variable of the indicated TYPE, initialized
2801 It is not entered into current_binding_level, because that breaks
2802 things when it comes time to do final cleanups (which take place
2803 "outside" the binding contour of the function). */
2806 get_temp_regvar (type
, init
)
2811 decl
= create_temporary_var (type
);
2812 if (building_stmt_tree ())
2813 add_decl_stmt (decl
);
2814 if (!building_stmt_tree ())
2815 DECL_RTL (decl
) = assign_temp (type
, 2, 0, 1);
2816 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
2821 /* `build_vec_init' returns tree structure that performs
2822 initialization of a vector of aggregate types.
2824 BASE is a reference to the vector, of ARRAY_TYPE.
2825 INIT is the (possibly NULL) initializer.
2827 FROM_ARRAY is 0 if we should init everything with INIT
2828 (i.e., every element initialized from INIT).
2829 FROM_ARRAY is 1 if we should index into INIT in parallel
2830 with initialization of DECL.
2831 FROM_ARRAY is 2 if we should index into INIT in parallel,
2832 but use assignment instead of initialization. */
2835 build_vec_init (base
, init
, from_array
)
2840 tree base2
= NULL_TREE
;
2842 tree itype
= NULL_TREE
;
2844 /* The type of the array. */
2845 tree atype
= TREE_TYPE (base
);
2846 /* The type of an element in the array. */
2847 tree type
= TREE_TYPE (atype
);
2848 /* The type of a pointer to an element in the array. */
2853 tree try_block
= NULL_TREE
;
2854 tree try_body
= NULL_TREE
;
2855 int num_initialized_elts
= 0;
2856 tree maxindex
= array_type_nelts (TREE_TYPE (base
));
2858 if (maxindex
== error_mark_node
)
2859 return error_mark_node
;
2861 /* For g++.ext/arrnew.C. */
2862 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == NULL_TREE
)
2863 init
= digest_init (atype
, init
, 0);
2865 if (init
&& !TYPE_NEEDS_CONSTRUCTING (type
)
2866 && ((TREE_CODE (init
) == CONSTRUCTOR
2867 /* Don't do this if the CONSTRUCTOR might contain something
2868 that might throw and require us to clean up. */
2869 && (CONSTRUCTOR_ELTS (init
) == NULL_TREE
2870 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type
))))
2873 /* Do non-default initialization of POD arrays resulting from
2874 brace-enclosed initializers. In this case, digest_init and
2875 store_constructor will handle the semantics for us. */
2877 stmt_expr
= build (INIT_EXPR
, atype
, base
, init
);
2878 TREE_SIDE_EFFECTS (stmt_expr
) = 1;
2882 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2883 ptype
= build_pointer_type (type
);
2884 size
= size_in_bytes (type
);
2885 if (TREE_CODE (TREE_TYPE (base
)) == ARRAY_TYPE
)
2886 base
= cp_convert (ptype
, default_conversion (base
));
2888 /* The code we are generating looks like:
2892 ptrdiff_t iterator = maxindex;
2895 ... initialize *t1 ...
2897 } while (--iterator != -1);
2899 ... destroy elements that were constructed ...
2903 We can omit the try and catch blocks if we know that the
2904 initialization will never throw an exception, or if the array
2905 elements do not have destructors. We can omit the loop completely if
2906 the elements of the array do not have constructors.
2908 We actually wrap the entire body of the above in a STMT_EXPR, for
2911 When copying from array to another, when the array elements have
2912 only trivial copy constructors, we should use __builtin_memcpy
2913 rather than generating a loop. That way, we could take advantage
2914 of whatever cleverness the back-end has for dealing with copies
2915 of blocks of memory. */
2917 begin_init_stmts (&stmt_expr
, &compound_stmt
);
2918 destroy_temps
= stmts_are_full_exprs_p ();
2919 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2920 rval
= get_temp_regvar (ptype
, base
);
2921 base
= get_temp_regvar (ptype
, rval
);
2922 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2924 /* Protect the entire array initialization so that we can destroy
2925 the partially constructed array if an exception is thrown.
2926 But don't do this if we're assigning. */
2927 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2930 try_block
= begin_try_block ();
2931 try_body
= begin_compound_stmt (/*has_no_scope=*/1);
2934 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
2936 /* Do non-default initialization of non-POD arrays resulting from
2937 brace-enclosed initializers. */
2942 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2944 tree elt
= TREE_VALUE (elts
);
2945 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2947 num_initialized_elts
++;
2949 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2950 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0));
2952 finish_expr_stmt (build_modify_expr (baseref
, NOP_EXPR
,
2955 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base
, 0));
2956 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR
, iterator
, 0));
2959 /* Clear out INIT so that we don't get confused below. */
2962 else if (from_array
)
2964 /* If initializing one array from another, initialize element by
2965 element. We rely upon the below calls the do argument
2969 base2
= default_conversion (init
);
2970 itype
= TREE_TYPE (base2
);
2971 base2
= get_temp_regvar (itype
, base2
);
2972 itype
= TREE_TYPE (itype
);
2974 else if (TYPE_LANG_SPECIFIC (type
)
2975 && TYPE_NEEDS_CONSTRUCTING (type
)
2976 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2978 error ("initializer ends prematurely");
2979 return error_mark_node
;
2983 /* Now, default-initialize any remaining elements. We don't need to
2984 do that if a) the type does not need constructing, or b) we've
2985 already initialized all the elements.
2987 We do need to keep going if we're copying an array. */
2990 || (TYPE_NEEDS_CONSTRUCTING (type
)
2991 && ! (host_integerp (maxindex
, 0)
2992 && (num_initialized_elts
2993 == tree_low_cst (maxindex
, 0) + 1))))
2995 /* If the ITERATOR is equal to -1, then we don't have to loop;
2996 we've already initialized all the elements. */
3002 if_stmt
= begin_if_stmt ();
3003 finish_if_stmt_cond (build (NE_EXPR
, boolean_type_node
,
3004 iterator
, integer_minus_one_node
),
3007 /* Otherwise, loop through the elements. */
3008 do_stmt
= begin_do_stmt ();
3009 do_body
= begin_compound_stmt (/*has_no_scope=*/1);
3011 /* When we're not building a statement-tree, things are a little
3012 complicated. If, when we recursively call build_aggr_init,
3013 an expression containing a TARGET_EXPR is expanded, then it
3014 may get a cleanup. Then, the result of that expression is
3015 passed to finish_expr_stmt, which will call
3016 expand_start_target_temps/expand_end_target_temps. However,
3017 the latter call will not cause the cleanup to run because
3018 that block will still be on the block stack. So, we call
3019 expand_start_target_temps here manually; the corresponding
3020 call to expand_end_target_temps below will cause the cleanup
3022 if (!building_stmt_tree ())
3023 expand_start_target_temps ();
3027 tree to
= build1 (INDIRECT_REF
, type
, base
);
3031 from
= build1 (INDIRECT_REF
, itype
, base2
);
3035 if (from_array
== 2)
3036 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
3037 else if (TYPE_NEEDS_CONSTRUCTING (type
))
3038 elt_init
= build_aggr_init (to
, from
, 0);
3040 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
3042 my_friendly_abort (57);
3044 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3048 ("cannot initialize multi-dimensional array with initializer");
3049 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
3053 elt_init
= build_aggr_init (build1 (INDIRECT_REF
, type
, base
),
3056 /* The initialization of each array element is a
3057 full-expression, as per core issue 124. */
3058 if (!building_stmt_tree ())
3060 genrtl_expr_stmt (elt_init
);
3061 expand_end_target_temps ();
3065 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
3066 finish_expr_stmt (elt_init
);
3067 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
3070 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base
, 0));
3072 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base2
, 0));
3074 finish_compound_stmt (/*has_no_scope=*/1, do_body
);
3075 finish_do_body (do_stmt
);
3076 finish_do_stmt (build (NE_EXPR
, boolean_type_node
,
3077 build_unary_op (PREDECREMENT_EXPR
, iterator
, 0),
3078 integer_minus_one_node
),
3081 finish_then_clause (if_stmt
);
3085 /* Make sure to cleanup any partially constructed elements. */
3086 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
3091 finish_compound_stmt (/*has_no_scope=*/1, try_body
);
3092 finish_cleanup_try_block (try_block
);
3093 e
= build_vec_delete_1 (rval
,
3094 cp_build_binary_op (MINUS_EXPR
, maxindex
,
3097 sfk_base_destructor
,
3098 /*use_global_delete=*/0);
3099 finish_cleanup (e
, try_block
);
3102 /* The value of the array initialization is the address of the
3103 first element in the array. */
3104 finish_expr_stmt (rval
);
3106 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
3107 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
3111 /* Free up storage of type TYPE, at address ADDR.
3113 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3116 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3117 used as the second argument to operator delete. It can include
3118 things like padding and magic size cookies. It has virtual in it,
3119 because if you have a base pointer and you delete through a virtual
3120 destructor, it should be the size of the dynamic object, not the
3121 static object, see Free Store 12.5 ISO C++.
3123 This does not call any destructors. */
3126 build_x_delete (addr
, which_delete
, virtual_size
)
3131 int use_global_delete
= which_delete
& 1;
3132 int use_vec_delete
= !!(which_delete
& 2);
3133 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3134 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
3136 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
3139 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3143 build_dtor_call (exp
, dtor_kind
, flags
)
3145 special_function_kind dtor_kind
;
3152 case sfk_complete_destructor
:
3153 name
= complete_dtor_identifier
;
3156 case sfk_base_destructor
:
3157 name
= base_dtor_identifier
;
3160 case sfk_deleting_destructor
:
3161 name
= deleting_dtor_identifier
;
3165 my_friendly_abort (20000524);
3167 return build_method_call (exp
, name
, NULL_TREE
, NULL_TREE
, flags
);
3170 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3171 ADDR is an expression which yields the store to be destroyed.
3172 AUTO_DELETE is the name of the destructor to call, i.e., either
3173 sfk_complete_destructor, sfk_base_destructor, or
3174 sfk_deleting_destructor.
3176 FLAGS is the logical disjunction of zero or more LOOKUP_
3177 flags. See cp-tree.h for more info.
3179 This function does not delete an object's virtual base classes. */
3182 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3184 special_function_kind auto_delete
;
3186 int use_global_delete
;
3192 if (addr
== error_mark_node
)
3193 return error_mark_node
;
3195 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3196 set to `error_mark_node' before it gets properly cleaned up. */
3197 if (type
== error_mark_node
)
3198 return error_mark_node
;
3200 type
= TYPE_MAIN_VARIANT (type
);
3202 if (TREE_CODE (type
) == POINTER_TYPE
)
3204 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3205 if (!VOID_TYPE_P (type
) && !complete_type_or_else (type
, addr
))
3206 return error_mark_node
;
3207 if (TREE_CODE (type
) == ARRAY_TYPE
)
3209 if (! IS_AGGR_TYPE (type
))
3211 /* Call the builtin operator delete. */
3212 return build_builtin_delete_call (addr
);
3214 if (TREE_SIDE_EFFECTS (addr
))
3215 addr
= save_expr (addr
);
3217 /* throw away const and volatile on target type of addr */
3218 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3219 ref
= build_indirect_ref (addr
, NULL_PTR
);
3221 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3224 if (TREE_SIDE_EFFECTS (addr
))
3225 addr
= save_expr (addr
);
3226 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3228 error ("unknown array size in delete");
3229 return error_mark_node
;
3231 return build_vec_delete (addr
, array_type_nelts (type
),
3232 auto_delete
, use_global_delete
);
3236 /* Don't check PROTECT here; leave that decision to the
3237 destructor. If the destructor is accessible, call it,
3238 else report error. */
3239 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3240 if (TREE_SIDE_EFFECTS (addr
))
3241 addr
= save_expr (addr
);
3243 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3245 ref
= build_indirect_ref (addr
, NULL_PTR
);
3248 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3250 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3252 if (auto_delete
!= sfk_deleting_destructor
)
3253 return void_zero_node
;
3255 return build_op_delete_call
3256 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3257 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3261 /* Below, we will reverse the order in which these calls are made.
3262 If we have a destructor, then that destructor will take care
3263 of the base classes; otherwise, we must do that here. */
3264 if (TYPE_HAS_DESTRUCTOR (type
))
3266 tree do_delete
= NULL_TREE
;
3269 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3271 /* Delete the object. */
3272 do_delete
= build_builtin_delete_call (addr
);
3273 /* Otherwise, treat this like a complete object destructor
3275 auto_delete
= sfk_complete_destructor
;
3278 expr
= build_dtor_call (ref
, auto_delete
, flags
);
3280 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3282 if (flags
& LOOKUP_DESTRUCTOR
)
3283 /* Explicit destructor call; don't check for null pointer. */
3284 ifexp
= integer_one_node
;
3286 /* Handle deleting a null pointer. */
3287 ifexp
= fold (cp_build_binary_op (NE_EXPR
, addr
, integer_zero_node
));
3289 if (ifexp
!= integer_one_node
)
3290 expr
= build (COND_EXPR
, void_type_node
,
3291 ifexp
, expr
, void_zero_node
);
3297 /* We only get here from finish_function for a destructor. */
3298 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3299 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (type
);
3300 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3301 tree exprstmt
= NULL_TREE
;
3303 /* Set this again before we call anything, as we might get called
3305 TYPE_HAS_DESTRUCTOR (type
) = 1;
3307 /* If we have member delete or vbases, we call delete in
3309 my_friendly_assert (auto_delete
== sfk_base_destructor
, 20000411);
3311 /* Take care of the remaining baseclasses. */
3312 for (i
= 0; i
< n_baseclasses
; i
++)
3314 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3315 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3316 || TREE_VIA_VIRTUAL (base_binfo
))
3319 expr
= build_scoped_method_call (ref
, base_binfo
,
3320 base_dtor_identifier
,
3323 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3326 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3328 if (TREE_CODE (member
) != FIELD_DECL
)
3330 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member
)))
3332 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3333 tree this_type
= TREE_TYPE (member
);
3334 expr
= build_delete (this_type
, this_member
,
3335 sfk_complete_destructor
, flags
, 0);
3336 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3341 return build_compound_expr (exprstmt
);
3342 /* Virtual base classes make this function do nothing. */
3343 return void_zero_node
;
3347 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3350 build_vbase_delete (type
, decl
)
3353 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3354 tree result
= NULL_TREE
;
3355 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3357 my_friendly_assert (addr
!= error_mark_node
, 222);
3362 = convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases
))),
3364 result
= tree_cons (NULL_TREE
,
3365 build_delete (TREE_TYPE (this_addr
), this_addr
,
3366 sfk_base_destructor
,
3367 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3369 vbases
= TREE_CHAIN (vbases
);
3371 return build_compound_expr (nreverse (result
));
3374 /* Build a C++ vector delete expression.
3375 MAXINDEX is the number of elements to be deleted.
3376 ELT_SIZE is the nominal size of each element in the vector.
3377 BASE is the expression that should yield the store to be deleted.
3378 This function expands (or synthesizes) these calls itself.
3379 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3381 This also calls delete for virtual baseclasses of elements of the vector.
3383 Update: MAXINDEX is no longer needed. The size can be extracted from the
3384 start of the vector for pointers, and from the type for arrays. We still
3385 use MAXINDEX for arrays because it happens to already have one of the
3386 values we'd have to extract. (We could use MAXINDEX with pointers to
3387 confirm the size, and trap if the numbers differ; not clear that it'd
3388 be worth bothering.) */
3391 build_vec_delete (base
, maxindex
, auto_delete_vec
, use_global_delete
)
3392 tree base
, maxindex
;
3393 special_function_kind auto_delete_vec
;
3394 int use_global_delete
;
3398 if (TREE_CODE (base
) == OFFSET_REF
)
3399 base
= resolve_offset_ref (base
);
3401 type
= TREE_TYPE (base
);
3403 base
= stabilize_reference (base
);
3405 /* Since we can use base many times, save_expr it. */
3406 if (TREE_SIDE_EFFECTS (base
))
3407 base
= save_expr (base
);
3409 if (TREE_CODE (type
) == POINTER_TYPE
)
3411 /* Step back one from start of vector, and read dimension. */
3414 type
= strip_array_types (TREE_TYPE (type
));
3417 cookie_addr
= build (MINUS_EXPR
,
3418 build_pointer_type (sizetype
),
3420 TYPE_SIZE_UNIT (sizetype
));
3421 maxindex
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3427 cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3428 base
, get_cookie_size (type
));
3429 cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3430 maxindex
= build_component_ref (cookie
, nelts_identifier
,
3434 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3436 /* get the total number of things in the array, maxindex is a bad name */
3437 maxindex
= array_type_nelts_total (type
);
3438 type
= strip_array_types (type
);
3439 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3443 if (base
!= error_mark_node
)
3444 error ("type to vector delete is neither pointer or array type");
3445 return error_mark_node
;
3448 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,