1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* High-level class interface. */
37 static void expand_aggr_vbase_init_1
PARAMS ((tree
, tree
, tree
, tree
));
38 static void construct_virtual_bases
PARAMS ((tree
, tree
, tree
, tree
, tree
));
39 static void expand_aggr_init_1
PARAMS ((tree
, tree
, tree
, tree
, int));
40 static void expand_default_init
PARAMS ((tree
, tree
, tree
, tree
, int));
41 static tree build_vec_delete_1
PARAMS ((tree
, tree
, tree
, special_function_kind
, int));
42 static void perform_member_init
PARAMS ((tree
, tree
, int));
43 static void sort_base_init
PARAMS ((tree
, tree
, tree
*, 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 minus_one_node
= build_int_2 (-1, -1);
70 /* Define the structure that holds header information for
71 arrays allocated via operator new. */
72 BI_header_type
= make_aggr_type (RECORD_TYPE
);
73 fields
[0] = build_decl (FIELD_DECL
, nelts_identifier
, sizetype
);
75 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
78 ggc_add_tree_root (&BI_header_type
, 1);
81 /* We are about to generate some complex initialization code.
82 Conceptually, it is all a single expression. However, we may want
83 to include conditionals, loops, and other such statement-level
84 constructs. Therefore, we build the initialization code inside a
85 statement-expression. This function starts such an expression.
86 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
87 pass them back to finish_init_stmts when the expression is
91 begin_init_stmts (stmt_expr_p
, compound_stmt_p
)
93 tree
*compound_stmt_p
;
95 if (building_stmt_tree ())
96 *stmt_expr_p
= begin_stmt_expr ();
98 *stmt_expr_p
= begin_global_stmt_expr ();
100 if (building_stmt_tree ())
101 *compound_stmt_p
= begin_compound_stmt (/*has_no_scope=*/1);
104 *compound_stmt_p = genrtl_begin_compound_stmt (has_no_scope=1);
108 /* Finish out the statement-expression begun by the previous call to
109 begin_init_stmts. Returns the statement-expression itself. */
112 finish_init_stmts (stmt_expr
, compound_stmt
)
117 if (building_stmt_tree ())
118 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
120 if (building_stmt_tree ())
121 stmt_expr
= finish_stmt_expr (stmt_expr
);
123 stmt_expr
= finish_global_stmt_expr (stmt_expr
);
125 /* To avoid spurious warnings about unused values, we set
128 TREE_USED (stmt_expr
) = 1;
135 /* Called from initialize_vtbl_ptrs via dfs_walk. */
138 dfs_initialize_vtbl_ptrs (binfo
, data
)
142 if (!BINFO_PRIMARY_MARKED_P (binfo
)
143 && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo
)))
145 tree base_ptr
= TREE_VALUE ((tree
) data
);
147 if (TREE_VIA_VIRTUAL (binfo
))
148 base_ptr
= convert_pointer_to_vbase (BINFO_TYPE (binfo
),
152 = build_vbase_path (PLUS_EXPR
,
153 build_pointer_type (BINFO_TYPE (binfo
)),
158 expand_virtual_init (binfo
, base_ptr
);
161 SET_BINFO_MARKED (binfo
);
166 /* Initialize all the vtable pointers in the object pointed to by
170 initialize_vtbl_ptrs (addr
)
176 type
= TREE_TYPE (TREE_TYPE (addr
));
177 list
= build_tree_list (type
, addr
);
179 /* Walk through the hierarchy, initializing the vptr in each base
180 class. We do these in pre-order because under the new ABI we
181 can't find the virtual bases for a class until we've initialized
182 the vtbl for that class. */
183 dfs_walk_real (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
,
184 NULL
, dfs_unmarked_real_bases_queue_p
, list
);
185 dfs_walk (TYPE_BINFO (type
), dfs_unmark
,
186 dfs_marked_real_bases_queue_p
, type
);
188 /* If we're not using thunks, we may need to adjust the deltas in
189 the vtable to handle virtual base classes correctly. When we are
190 using thunks, we either use construction vtables (which are
191 preloaded with the right answers) or nothing (in which case
192 vitual function calls sometimes don't work right.) */
193 if (TYPE_USES_VIRTUAL_BASECLASSES (type
) && !flag_vtable_thunks
)
194 fixup_all_virtual_upcast_offsets (addr
);
199 To default-initialize an object of type T means:
201 --if T is a non-POD class type (clause _class_), the default construc-
202 tor for T is called (and the initialization is ill-formed if T has
203 no accessible default constructor);
205 --if T is an array type, each element is default-initialized;
207 --otherwise, the storage for the object is zero-initialized.
209 A program that calls for default-initialization of an entity of refer-
210 ence type is ill-formed. */
213 build_default_init (type
)
216 tree init
= NULL_TREE
;
218 if (TYPE_NEEDS_CONSTRUCTING (type
))
219 /* Other code will handle running the default constructor. We can't do
220 anything with a CONSTRUCTOR for arrays here, as that would imply
221 copy-initialization. */
223 else if (AGGREGATE_TYPE_P (type
))
225 /* This is a default initialization of an aggregate, but not one of
226 non-POD class type. We cleverly notice that the initialization
227 rules in such a case are the same as for initialization with an
228 empty brace-initialization list. */
229 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
231 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
232 /* --if T is a reference type, no initialization is performed. */
235 init
= integer_zero_node
;
237 init
= digest_init (type
, init
, 0);
241 /* Subroutine of emit_base_init. */
244 perform_member_init (member
, init
, explicit)
249 tree type
= TREE_TYPE (member
);
251 decl
= build_component_ref (current_class_ref
, member
, NULL_TREE
, explicit);
253 if (decl
== error_mark_node
)
256 /* Deal with this here, as we will get confused if we try to call the
257 assignment op for an anonymous union. This can happen in a
258 synthesized copy constructor. */
259 if (ANON_AGGR_TYPE_P (type
))
263 init
= build (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
264 finish_expr_stmt (init
);
267 else if (TYPE_NEEDS_CONSTRUCTING (type
)
268 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
270 /* Since `init' is already a TREE_LIST on the member_init_list,
271 only build it into one if we aren't already a list. */
272 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
273 init
= build_tree_list (NULL_TREE
, init
);
276 && TREE_CODE (type
) == ARRAY_TYPE
278 && TREE_CHAIN (init
) == NULL_TREE
279 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
281 /* Initialization of one array from another. */
282 finish_expr_stmt (build_vec_init (decl
, TREE_VALUE (init
), 1));
285 finish_expr_stmt (build_aggr_init (decl
, init
, 0));
289 if (init
== NULL_TREE
)
293 init
= build_default_init (type
);
294 if (TREE_CODE (type
) == REFERENCE_TYPE
)
296 ("default-initialization of `%#D', which has reference type",
299 /* member traversal: note it leaves init NULL */
300 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
301 cp_pedwarn ("uninitialized reference member `%D'", member
);
303 else if (TREE_CODE (init
) == TREE_LIST
)
305 /* There was an explicit member initialization. Do some
306 work in that case. */
307 if (TREE_CHAIN (init
))
309 warning ("initializer list treated as compound expression");
310 init
= build_compound_expr (init
);
313 init
= TREE_VALUE (init
);
317 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
320 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
324 expr
= build_component_ref (current_class_ref
, member
, NULL_TREE
,
326 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
327 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
329 if (expr
!= error_mark_node
)
330 finish_subobject (expr
);
334 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
335 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
338 build_field_list (t
, list
, uses_unions_p
)
345 /* Note whether or not T is a union. */
346 if (TREE_CODE (t
) == UNION_TYPE
)
349 for (fields
= TYPE_FIELDS (t
); fields
; fields
= TREE_CHAIN (fields
))
351 /* Skip CONST_DECLs for enumeration constants and so forth. */
352 if (TREE_CODE (fields
) != FIELD_DECL
)
355 /* Keep track of whether or not any fields are unions. */
356 if (TREE_CODE (TREE_TYPE (fields
)) == UNION_TYPE
)
359 /* For an anonymous struct or union, we must recursively
360 consider the fields of the anonymous type. They can be
361 directly initialized from the constructor. */
362 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
364 /* Add this field itself. Synthesized copy constructors
365 initialize the entire aggregate. */
366 list
= tree_cons (fields
, NULL_TREE
, list
);
367 /* And now add the fields in the anonymous aggregate. */
368 list
= build_field_list (TREE_TYPE (fields
), list
,
371 /* Add this field. */
372 else if (DECL_NAME (fields
))
373 list
= tree_cons (fields
, NULL_TREE
, list
);
379 /* The MEMBER_INIT_LIST is a TREE_LIST. The TREE_PURPOSE of each list
380 gives a FIELD_DECL in T that needs initialization. The TREE_VALUE
381 gives the initializer, or list of initializer arguments. Sort the
382 MEMBER_INIT_LIST, returning a version that contains the same
383 information but in the order that the fields should actually be
384 initialized. Perform error-checking in the process. */
387 sort_member_init (t
, member_init_list
)
389 tree member_init_list
;
396 /* Build up a list of the various fields, in sorted order. */
397 init_list
= nreverse (build_field_list (t
, NULL_TREE
, &uses_unions_p
));
399 /* Go through the explicit initializers, adding them to the
401 last_field
= init_list
;
402 for (init
= member_init_list
; init
; init
= TREE_CHAIN (init
))
405 tree initialized_field
;
407 initialized_field
= TREE_PURPOSE (init
);
408 my_friendly_assert (TREE_CODE (initialized_field
) == FIELD_DECL
,
411 /* If the explicit initializers are in sorted order, then the
412 INITIALIZED_FIELD will be for a field following the
414 for (f
= last_field
; f
; f
= TREE_CHAIN (f
))
415 if (TREE_PURPOSE (f
) == initialized_field
)
418 /* Give a warning, if appropriate. */
419 if (warn_reorder
&& !f
)
421 cp_warning_at ("member initializers for `%#D'",
422 TREE_PURPOSE (last_field
));
423 cp_warning_at (" and `%#D'", initialized_field
);
424 warning (" will be re-ordered to match declaration order");
427 /* Look again, from the beginning of the list. We must find the
428 field on this loop. */
432 while (TREE_PURPOSE (f
) != initialized_field
)
436 /* If there was already an explicit initializer for this field,
439 cp_error ("multiple initializations given for member `%D'",
443 /* Mark the field as explicitly initialized. */
444 TREE_TYPE (f
) = error_mark_node
;
445 /* And insert the initializer. */
446 TREE_VALUE (f
) = TREE_VALUE (init
);
449 /* Remember the location of the last explicitly initialized
456 If a ctor-initializer specifies more than one mem-initializer for
457 multiple members of the same union (including members of
458 anonymous unions), the ctor-initializer is ill-formed. */
461 last_field
= NULL_TREE
;
462 for (init
= init_list
; init
; init
= TREE_CHAIN (init
))
468 /* Skip uninitialized members. */
469 if (!TREE_TYPE (init
))
471 /* See if this field is a member of a union, or a member of a
472 structure contained in a union, etc. */
473 field
= TREE_PURPOSE (init
);
474 for (field_type
= DECL_CONTEXT (field
);
475 !same_type_p (field_type
, t
);
476 field_type
= TYPE_CONTEXT (field_type
))
477 if (TREE_CODE (field_type
) == UNION_TYPE
)
479 /* If this field is not a member of a union, skip it. */
480 if (TREE_CODE (field_type
) != UNION_TYPE
)
483 /* It's only an error if we have two initializers for the same
491 /* See if LAST_FIELD and the field initialized by INIT are
492 members of the same union. If so, there's a problem,
493 unless they're actually members of the same structure
494 which is itself a member of a union. For example, given:
496 union { struct { int i; int j; }; };
498 initializing both `i' and `j' makes sense. */
499 field_type
= DECL_CONTEXT (field
);
503 tree last_field_type
;
505 last_field_type
= DECL_CONTEXT (last_field
);
508 if (same_type_p (last_field_type
, field_type
))
510 if (TREE_CODE (field_type
) == UNION_TYPE
)
511 cp_error ("initializations for multiple members of `%T'",
517 if (same_type_p (last_field_type
, t
))
520 last_field_type
= TYPE_CONTEXT (last_field_type
);
523 /* If we've reached the outermost class, then we're
525 if (same_type_p (field_type
, t
))
528 field_type
= TYPE_CONTEXT (field_type
);
539 /* Like sort_member_init, but used for initializers of base classes.
540 *RBASE_PTR is filled in with the initializers for non-virtual bases;
541 vbase_ptr gets the virtual bases. */
544 sort_base_init (t
, base_init_list
, rbase_ptr
, vbase_ptr
)
547 tree
*rbase_ptr
, *vbase_ptr
;
549 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
550 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
556 /* For warn_reorder. */
558 tree last_base
= NULL_TREE
;
560 tree rbases
= NULL_TREE
;
561 tree vbases
= NULL_TREE
;
563 /* First walk through and splice out vbase and invalid initializers.
564 Also replace names with binfos. */
566 last
= tree_cons (NULL_TREE
, NULL_TREE
, base_init_list
);
567 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
569 tree basetype
= TREE_PURPOSE (x
);
570 tree binfo
= NULL_TREE
;
572 if (basetype
== NULL_TREE
)
574 /* Initializer for single base class. Must not
575 use multiple inheritance or this is ambiguous. */
576 switch (n_baseclasses
)
579 cp_error ("`%T' does not have a base class to initialize",
585 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
589 binfo
= TREE_VEC_ELT (binfos
, 0);
591 else if (is_aggr_type (basetype
, 1))
593 binfo
= binfo_or_else (basetype
, t
);
594 if (binfo
== NULL_TREE
)
597 /* Virtual base classes are special cases. Their initializers
598 are recorded with this constructor, and they are used when
599 this constructor is the top-level constructor called. */
600 if (TREE_VIA_VIRTUAL (binfo
))
602 tree v
= binfo_for_vbase (BINFO_TYPE (binfo
), t
);
603 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
608 /* Otherwise, if it is not an immediate base class, complain. */
609 for (i
= n_baseclasses
-1; i
>= 0; i
--)
610 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
614 cp_error ("`%T' is not an immediate base class of `%T'",
615 basetype
, current_class_type
);
621 my_friendly_abort (365);
623 TREE_PURPOSE (x
) = binfo
;
624 TREE_CHAIN (last
) = x
;
627 TREE_CHAIN (last
) = NULL_TREE
;
629 /* Now walk through our regular bases and make sure they're initialized. */
631 for (i
= 0; i
< n_baseclasses
; ++i
)
633 /* The base for which we're currently initializing. */
634 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
635 /* The initializer for BASE_BINFO. */
639 if (TREE_VIA_VIRTUAL (base_binfo
))
642 /* We haven't found the BASE_BINFO yet. */
644 /* Loop through all the explicitly initialized bases, looking
645 for an appropriate initializer. */
646 for (x
= base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
648 tree binfo
= TREE_PURPOSE (x
);
650 if (binfo
== base_binfo
&& !init
)
656 cp_warning_at ("base initializers for `%#T'", last_base
);
657 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
658 warning (" will be re-ordered to match inheritance order");
661 last_base
= BINFO_TYPE (binfo
);
664 /* Make sure we won't try to work on this init again. */
665 TREE_PURPOSE (x
) = NULL_TREE
;
666 init
= build_tree_list (binfo
, TREE_VALUE (x
));
668 else if (binfo
== base_binfo
)
670 cp_error ("base class `%T' already initialized",
676 /* If we didn't find BASE_BINFO in the list, create a dummy entry
677 so the two lists (RBASES and the list of bases) will be
680 init
= build_tree_list (NULL_TREE
, NULL_TREE
);
681 rbases
= chainon (rbases
, init
);
688 /* Perform whatever initializations have yet to be done on the base
689 class, and non-static data members, of the CURRENT_CLASS_TYPE.
690 These actions are given by the BASE_INIT_LIST and MEM_INIT_LIST,
693 If there is a need for a call to a constructor, we must surround
694 that call with a pushlevel/poplevel pair, since we are technically
695 at the PARM level of scope.
697 Note that emit_base_init does *not* initialize virtual base
698 classes. That is done specially, elsewhere. */
701 emit_base_init (mem_init_list
, base_init_list
)
706 tree rbase_init_list
, vbase_init_list
;
707 tree t
= current_class_type
;
708 tree t_binfo
= TYPE_BINFO (t
);
709 tree binfos
= BINFO_BASETYPES (t_binfo
);
711 int n_baseclasses
= BINFO_N_BASETYPES (t_binfo
);
713 mem_init_list
= sort_member_init (t
, mem_init_list
);
714 sort_base_init (t
, base_init_list
, &rbase_init_list
, &vbase_init_list
);
716 /* First, initialize the virtual base classes, if we are
717 constructing the most-derived object. */
718 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
720 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
721 construct_virtual_bases (t
, current_class_ref
, current_class_ptr
,
722 vbase_init_list
, first_arg
);
725 /* Now, perform initialization of non-virtual base classes. */
726 for (i
= 0; i
< n_baseclasses
; i
++)
728 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
729 tree init
= void_list_node
;
731 if (TREE_VIA_VIRTUAL (base_binfo
))
734 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
,
737 if (TREE_PURPOSE (rbase_init_list
))
738 init
= TREE_VALUE (rbase_init_list
);
739 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
743 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
))
744 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
745 BINFO_TYPE (base_binfo
));
748 if (init
!= void_list_node
)
750 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
751 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
752 build_indirect_ref (member
, NULL_PTR
), init
,
756 expand_cleanup_for_base (base_binfo
, NULL_TREE
);
757 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
760 /* Initialize the vtable pointers for the class. */
761 initialize_vtbl_ptrs (current_class_ptr
);
763 while (mem_init_list
)
769 member
= TREE_PURPOSE (mem_init_list
);
771 /* See if we had a user-specified member initialization. */
772 if (TREE_TYPE (mem_init_list
))
774 init
= TREE_VALUE (mem_init_list
);
779 init
= DECL_INITIAL (member
);
782 /* Effective C++ rule 12. */
783 if (warn_ecpp
&& init
== NULL_TREE
784 && !DECL_ARTIFICIAL (member
)
785 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
786 cp_warning ("`%D' should be initialized in the member initialization list", member
);
789 perform_member_init (member
, init
, from_init_list
);
790 mem_init_list
= TREE_CHAIN (mem_init_list
);
794 /* Returns the address of the vtable (i.e., the value that should be
795 assigned to the vptr) for BINFO. */
798 build_vtbl_address (binfo
)
803 /* Figure out what vtable BINFO's vtable is based on, and mark it as
805 vtbl
= get_vtbl_decl_for_binfo (binfo
);
806 assemble_external (vtbl
);
807 TREE_USED (vtbl
) = 1;
809 /* Now compute the address to use when initializing the vptr. */
810 vtbl
= BINFO_VTABLE (binfo
);
811 if (TREE_CODE (vtbl
) == VAR_DECL
)
813 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
814 TREE_CONSTANT (vtbl
) = 1;
820 /* This code sets up the virtual function tables appropriate for
821 the pointer DECL. It is a one-ply initialization.
823 BINFO is the exact type that DECL is supposed to be. In
824 multiple inheritance, this might mean "C's A" if C : A, B. */
827 expand_virtual_init (binfo
, decl
)
830 tree type
= BINFO_TYPE (binfo
);
832 tree vtype
, vtype_binfo
;
835 /* Compute the location of the vtable. */
836 vtype
= DECL_CONTEXT (TYPE_VFIELD (type
));
837 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
839 /* Compute the initializer for vptr. */
840 vtbl
= build_vtbl_address (binfo
);
842 /* Under the new ABI, we may get this vptr from a VTT, if this is a
843 subobject constructor or subobject destructor. */
844 vtt_index
= BINFO_VPTR_INDEX (binfo
);
850 /* Compute the value to use, when there's a VTT. */
851 vtt_parm
= DECL_VTT_PARM (current_function_decl
);
852 vtbl2
= build (PLUS_EXPR
,
853 TREE_TYPE (vtt_parm
),
856 vtbl2
= build1 (INDIRECT_REF
, TREE_TYPE (vtbl
), vtbl2
);
858 /* The actual initializer is the VTT value only in the subobject
859 constructor. In maybe_clone_body we'll substitute NULL for
860 the vtt_parm in the case of the non-subobject constructor. */
861 vtbl
= build (COND_EXPR
,
863 DECL_USE_VTT_PARM (current_function_decl
),
868 /* Compute the location of the vtpr. */
869 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
870 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
871 if (vtbl_ptr
== error_mark_node
)
874 /* Assign the vtable to the vptr. */
875 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
876 finish_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
879 /* If an exception is thrown in a constructor, those base classes already
880 constructed must be destroyed. This function creates the cleanup
881 for BINFO, which has just been constructed. If FLAG is non-NULL,
882 it is a DECL which is non-zero when this base needs to be
886 expand_cleanup_for_base (binfo
, flag
)
892 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
895 /* Call the destructor. */
896 expr
= (build_scoped_method_call
897 (current_class_ref
, binfo
, base_dtor_identifier
, NULL_TREE
));
899 expr
= fold (build (COND_EXPR
, void_type_node
,
900 truthvalue_conversion (flag
),
901 expr
, integer_zero_node
));
903 finish_subobject (expr
);
906 /* Subroutine of `expand_aggr_vbase_init'.
907 BINFO is the binfo of the type that is being initialized.
908 INIT_LIST is the list of initializers for the virtual baseclass. */
911 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
912 tree binfo
, exp
, addr
, init_list
;
914 tree init
= purpose_member (binfo
, init_list
);
915 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
918 init
= TREE_VALUE (init
);
919 /* Call constructors, but don't set up vtables. */
920 expand_aggr_init_1 (binfo
, exp
, ref
, init
, LOOKUP_COMPLAIN
);
923 /* Construct the virtual base-classes of THIS_REF (whose address is
924 THIS_PTR). The object has the indicated TYPE. The construction
925 actually takes place only if FLAG is non-zero. INIT_LIST is list
926 of initializations for constructors to perform. */
929 construct_virtual_bases (type
, this_ref
, this_ptr
, init_list
, flag
)
938 /* If there are no virtual baseclasses, we shouldn't even be here. */
939 my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type
), 19990621);
941 /* First set the pointers in our object that tell us where to find
942 our virtual baseclasses. */
943 if (!vbase_offsets_in_vtable_p ())
948 if_stmt
= begin_if_stmt ();
949 finish_if_stmt_cond (flag
, if_stmt
);
950 result
= init_vbase_pointers (type
, this_ptr
);
952 finish_expr_stmt (build_compound_expr (result
));
953 finish_then_clause (if_stmt
);
957 /* Now, run through the baseclasses, initializing each. */
958 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
959 vbases
= TREE_CHAIN (vbases
))
966 /* If there are virtual base classes with destructors, we need to
967 emit cleanups to destroy them if an exception is thrown during
968 the construction process. These exception regions (i.e., the
969 period during which the cleanups must occur) begin from the time
970 the construction is complete to the end of the function. If we
971 create a conditional block in which to initialize the
972 base-classes, then the cleanup region for the virtual base begins
973 inside a block, and ends outside of that block. This situation
974 confuses the sjlj exception-handling code. Therefore, we do not
975 create a single conditional block, but one for each
976 initialization. (That way the cleanup regions always begin
977 in the outer block.) We trust the back-end to figure out
978 that the FLAG will not change across initializations, and
979 avoid doing multiple tests. */
980 inner_if_stmt
= begin_if_stmt ();
981 finish_if_stmt_cond (flag
, inner_if_stmt
);
982 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/1);
984 /* Compute the location of the virtual base. If we're
985 constructing virtual bases, then we must be the most derived
986 class. Therefore, we don't have to look up the virtual base;
987 we already know where it is. */
988 vbase
= TREE_VALUE (vbases
);
989 exp
= build (PLUS_EXPR
,
990 TREE_TYPE (this_ptr
),
992 fold (build1 (NOP_EXPR
, TREE_TYPE (this_ptr
),
993 BINFO_OFFSET (vbase
))));
994 exp
= build1 (NOP_EXPR
,
995 build_pointer_type (BINFO_TYPE (vbase
)),
998 expand_aggr_vbase_init_1 (vbase
, this_ref
, exp
, init_list
);
999 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
1000 finish_then_clause (inner_if_stmt
);
1003 expand_cleanup_for_base (vbase
, flag
);
1007 /* Find the context in which this FIELD can be initialized. */
1010 initializing_context (field
)
1013 tree t
= DECL_CONTEXT (field
);
1015 /* Anonymous union members can be initialized in the first enclosing
1016 non-anonymous union context. */
1017 while (t
&& ANON_AGGR_TYPE_P (t
))
1018 t
= TYPE_CONTEXT (t
);
1022 /* Function to give error message if member initialization specification
1023 is erroneous. FIELD is the member we decided to initialize.
1024 TYPE is the type for which the initialization is being performed.
1025 FIELD must be a member of TYPE.
1027 MEMBER_NAME is the name of the member. */
1030 member_init_ok_or_else (field
, type
, member_name
)
1033 const char *member_name
;
1035 if (field
== error_mark_node
)
1037 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
1039 cp_error ("class `%T' does not have any field named `%s'", type
,
1043 if (TREE_STATIC (field
))
1045 cp_error ("field `%#D' is static; only point of initialization is its declaration",
1053 /* If NAME is a viable field name for the aggregate DECL,
1054 and PARMS is a viable parameter list, then expand an _EXPR
1055 which describes this initialization.
1057 Note that we do not need to chase through the class's base classes
1058 to look for NAME, because if it's in that list, it will be handled
1059 by the constructor for that base class.
1061 We do not yet have a fixed-point finder to instantiate types
1062 being fed to overloaded constructors. If there is a unique
1063 constructor, then argument types can be got from that one. */
1066 expand_member_init (exp
, name
, init
)
1067 tree exp
, name
, init
;
1069 tree basetype
= NULL_TREE
, field
;
1072 if (exp
== NULL_TREE
)
1075 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
1077 if (name
&& TYPE_P (name
))
1080 name
= TYPE_IDENTIFIER (name
);
1082 else if (name
&& TREE_CODE (name
) == TYPE_DECL
)
1084 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1085 name
= DECL_NAME (name
);
1088 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
1089 switch (CLASSTYPE_N_BASECLASSES (type
))
1092 error ("base class initializer specified, but no base class to initialize");
1095 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
1098 error ("initializer for unnamed base class ambiguous");
1099 cp_error ("(type `%T' uses multiple inheritance)", type
);
1103 my_friendly_assert (init
!= NULL_TREE
, 0);
1105 /* The grammar should not allow fields which have names that are
1106 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
1107 may assume that this is an attempt to initialize a base class
1108 member of the current type. Otherwise, it is an attempt to
1109 initialize a member field. */
1111 if (init
== void_type_node
)
1114 if (name
== NULL_TREE
|| basetype
)
1116 if (name
== NULL_TREE
)
1120 name
= TYPE_IDENTIFIER (basetype
);
1123 error ("no base class to initialize");
1128 else if (basetype
!= type
1129 && ! current_template_parms
1130 && ! vec_binfo_member (basetype
,
1131 TYPE_BINFO_BASETYPES (type
))
1132 && ! binfo_for_vbase (basetype
, type
))
1134 if (IDENTIFIER_CLASS_VALUE (name
))
1136 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1137 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
1140 cp_error ("type `%T' is not an immediate basetype for `%T'",
1145 init
= build_tree_list (basetype
, init
);
1150 field
= lookup_field (type
, name
, 1, 0);
1152 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
1155 init
= build_tree_list (field
, init
);
1161 /* This is like `expand_member_init', only it stores one aggregate
1164 INIT comes in two flavors: it is either a value which
1165 is to be stored in EXP, or it is a parameter list
1166 to go to a constructor, which will operate on EXP.
1167 If INIT is not a parameter list for a constructor, then set
1168 LOOKUP_ONLYCONVERTING.
1169 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1170 the initializer, if FLAGS is 0, then it is the (init) form.
1171 If `init' is a CONSTRUCTOR, then we emit a warning message,
1172 explaining that such initializations are invalid.
1174 If INIT resolves to a CALL_EXPR which happens to return
1175 something of the type we are looking for, then we know
1176 that we can safely use that call to perform the
1179 The virtual function table pointer cannot be set up here, because
1180 we do not really know its type.
1182 Virtual baseclass pointers are also set up here.
1184 This never calls operator=().
1186 When initializing, nothing is CONST.
1188 A default copy constructor may have to be used to perform the
1191 A constructor or a conversion operator may have to be used to
1192 perform the initialization, but not both, as it would be ambiguous. */
1195 build_aggr_init (exp
, init
, flags
)
1202 tree type
= TREE_TYPE (exp
);
1203 int was_const
= TREE_READONLY (exp
);
1204 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1206 if (init
== error_mark_node
)
1207 return error_mark_node
;
1209 TREE_READONLY (exp
) = 0;
1210 TREE_THIS_VOLATILE (exp
) = 0;
1212 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1213 flags
|= LOOKUP_ONLYCONVERTING
;
1215 if (TREE_CODE (type
) == ARRAY_TYPE
)
1217 /* Must arrange to initialize each element of EXP
1218 from elements of INIT. */
1219 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1223 /* Handle bad initializers like:
1227 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1231 int main(int argc, char **argv) {
1232 COMPLEX zees(1.0, 0.0)[10];
1235 cp_error ("bad array initializer");
1236 return error_mark_node
;
1238 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
1240 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1242 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1244 stmt_expr
= build_vec_init (exp
, init
,
1245 init
&& same_type_p (TREE_TYPE (init
),
1247 TREE_READONLY (exp
) = was_const
;
1248 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1249 TREE_TYPE (exp
) = type
;
1251 TREE_TYPE (init
) = itype
;
1255 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1256 /* just know that we've seen something for this node */
1257 TREE_USED (exp
) = 1;
1259 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1260 begin_init_stmts (&stmt_expr
, &compound_stmt
);
1261 destroy_temps
= stmts_are_full_exprs_p ();
1262 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1263 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1264 init
, LOOKUP_NORMAL
|flags
);
1265 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
1266 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1267 TREE_TYPE (exp
) = type
;
1268 TREE_READONLY (exp
) = was_const
;
1269 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1275 expand_default_init (binfo
, true_exp
, exp
, init
, flags
)
1281 tree type
= TREE_TYPE (exp
);
1284 /* It fails because there may not be a constructor which takes
1285 its own type as the first (or only parameter), but which does
1286 take other types via a conversion. So, if the thing initializing
1287 the expression is a unit element of type X, first try X(X&),
1288 followed by initialization by X. If neither of these work
1289 out, then look hard. */
1293 if (init
&& TREE_CODE (init
) != TREE_LIST
1294 && (flags
& LOOKUP_ONLYCONVERTING
))
1296 /* Base subobjects should only get direct-initialization. */
1297 if (true_exp
!= exp
)
1300 if (flags
& DIRECT_BIND
)
1301 /* Do nothing. We hit this in two cases: Reference initialization,
1302 where we aren't initializing a real variable, so we don't want
1303 to run a new constructor; and catching an exception, where we
1304 have already built up the constructor call so we could wrap it
1305 in an exception region. */;
1306 else if (TREE_CODE (init
) == CONSTRUCTOR
)
1307 /* A brace-enclosed initializer has whatever type is
1308 required. There's no need to convert it. */
1311 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1313 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1314 /* We need to protect the initialization of a catch parm
1315 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1316 around the TARGET_EXPR for the copy constructor. See
1317 expand_start_catch_block. */
1318 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1319 TREE_OPERAND (init
, 0));
1321 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1322 TREE_SIDE_EFFECTS (init
) = 1;
1323 finish_expr_stmt (init
);
1327 if (init
== NULL_TREE
1328 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1332 init
= TREE_VALUE (parms
);
1335 parms
= build_tree_list (NULL_TREE
, init
);
1337 if (true_exp
== exp
)
1338 ctor_name
= complete_ctor_identifier
;
1340 ctor_name
= base_ctor_identifier
;
1342 rval
= build_method_call (exp
, ctor_name
, parms
, binfo
, flags
);
1343 if (TREE_SIDE_EFFECTS (rval
))
1345 if (building_stmt_tree ())
1346 finish_expr_stmt (rval
);
1348 genrtl_expr_stmt (rval
);
1352 /* This function is responsible for initializing EXP with INIT
1355 BINFO is the binfo of the type for who we are performing the
1356 initialization. For example, if W is a virtual base class of A and B,
1358 If we are initializing B, then W must contain B's W vtable, whereas
1359 were we initializing C, W must contain C's W vtable.
1361 TRUE_EXP is nonzero if it is the true expression being initialized.
1362 In this case, it may be EXP, or may just contain EXP. The reason we
1363 need this is because if EXP is a base element of TRUE_EXP, we
1364 don't necessarily know by looking at EXP where its virtual
1365 baseclass fields should really be pointing. But we do know
1366 from TRUE_EXP. In constructors, we don't know anything about
1367 the value being initialized.
1369 FLAGS is just passes to `build_method_call'. See that function for
1373 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, flags
)
1379 tree type
= TREE_TYPE (exp
);
1381 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1383 /* Use a function returning the desired type to initialize EXP for us.
1384 If the function is a constructor, and its first argument is
1385 NULL_TREE, know that it was meant for us--just slide exp on
1386 in and expand the constructor. Constructors now come
1389 if (init
&& TREE_CODE (exp
) == VAR_DECL
1390 && TREE_CODE (init
) == CONSTRUCTOR
1391 && TREE_HAS_CONSTRUCTOR (init
))
1393 /* If store_init_value returns NULL_TREE, the INIT has been
1394 record in the DECL_INITIAL for EXP. That means there's
1395 nothing more we have to do. */
1396 if (!store_init_value (exp
, init
))
1398 if (!building_stmt_tree ())
1399 expand_decl_init (exp
);
1402 finish_expr_stmt (build (INIT_EXPR
, type
, exp
, init
));
1406 /* We know that expand_default_init can handle everything we want
1408 expand_default_init (binfo
, true_exp
, exp
, init
, flags
);
1411 /* Report an error if TYPE is not a user-defined, aggregate type. If
1412 OR_ELSE is nonzero, give an error message. */
1415 is_aggr_type (type
, or_else
)
1419 if (type
== error_mark_node
)
1422 if (! IS_AGGR_TYPE (type
)
1423 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1424 && TREE_CODE (type
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
1427 cp_error ("`%T' is not an aggregate type", type
);
1433 /* Like is_aggr_typedef, but returns typedef if successful. */
1436 get_aggr_from_typedef (name
, or_else
)
1442 if (name
== error_mark_node
)
1445 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1446 type
= IDENTIFIER_TYPE_VALUE (name
);
1450 cp_error ("`%T' fails to be an aggregate typedef", name
);
1454 if (! IS_AGGR_TYPE (type
)
1455 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1456 && TREE_CODE (type
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
1459 cp_error ("type `%T' is of non-aggregate type", type
);
1466 get_type_value (name
)
1469 if (name
== error_mark_node
)
1472 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1473 return IDENTIFIER_TYPE_VALUE (name
);
1479 /* This code could just as well go in `class.c', but is placed here for
1482 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1483 the appropriate function call. */
1486 build_member_call (type
, name
, parmlist
)
1487 tree type
, name
, parmlist
;
1492 tree basetype_path
, decl
;
1494 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
1495 && TREE_CODE (type
) == NAMESPACE_DECL
)
1497 /* 'name' already refers to the decls from the namespace, since we
1498 hit do_identifier for template_ids. */
1499 method_name
= TREE_OPERAND (name
, 0);
1500 /* FIXME: Since we don't do independent names right yet, the
1501 name might also be a LOOKUP_EXPR. Once we resolve this to a
1502 real decl earlier, this can go. This may happen during
1504 if (TREE_CODE (method_name
) == LOOKUP_EXPR
)
1506 method_name
= lookup_namespace_name
1507 (type
, TREE_OPERAND (method_name
, 0));
1508 TREE_OPERAND (name
, 0) = method_name
;
1510 my_friendly_assert (is_overloaded_fn (method_name
), 980519);
1511 return build_x_function_call (name
, parmlist
, current_class_ref
);
1515 name
= DECL_NAME (name
);
1517 if (type
== fake_std_node
)
1518 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1520 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1521 return build_x_function_call (lookup_namespace_name (type
, name
),
1522 parmlist
, current_class_ref
);
1524 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1526 method_name
= TREE_OPERAND (name
, 0);
1527 if (TREE_CODE (method_name
) == COMPONENT_REF
)
1528 method_name
= TREE_OPERAND (method_name
, 1);
1529 if (is_overloaded_fn (method_name
))
1530 method_name
= DECL_NAME (OVL_CURRENT (method_name
));
1531 TREE_OPERAND (name
, 0) = method_name
;
1536 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1538 method_name
= TREE_OPERAND (method_name
, 0);
1542 /* This shouldn't be here, and build_member_call shouldn't appear in
1544 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1545 && get_aggr_from_typedef (type
, 0) == 0)
1547 tree ns
= lookup_name (type
, 0);
1548 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1550 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1554 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1555 return error_mark_node
;
1557 /* An operator we did not like. */
1558 if (name
== NULL_TREE
)
1559 return error_mark_node
;
1563 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1565 return error_mark_node
;
1568 decl
= maybe_dummy_object (type
, &basetype_path
);
1570 /* Convert 'this' to the specified type to disambiguate conversion
1571 to the function's context. Apparently Standard C++ says that we
1572 shouldn't do this. */
1573 if (decl
== current_class_ref
1575 && ACCESSIBLY_UNIQUELY_DERIVED_P (type
, current_class_type
))
1577 tree olddecl
= current_class_ptr
;
1578 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1579 if (oldtype
!= type
)
1581 tree newtype
= build_qualified_type (type
, TYPE_QUALS (oldtype
));
1582 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1583 decl
= build_indirect_ref (decl
, NULL_PTR
);
1587 if (method_name
== constructor_name (type
)
1588 || method_name
== constructor_name_full (type
))
1589 return build_functional_cast (type
, parmlist
);
1590 if (lookup_fnfields (basetype_path
, method_name
, 0))
1591 return build_method_call (decl
,
1592 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1593 ? name
: method_name
,
1594 parmlist
, basetype_path
,
1595 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1596 if (TREE_CODE (name
) == IDENTIFIER_NODE
1597 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1599 if (t
== error_mark_node
)
1600 return error_mark_node
;
1601 if (TREE_CODE (t
) == FIELD_DECL
)
1603 if (is_dummy_object (decl
))
1605 cp_error ("invalid use of non-static field `%D'", t
);
1606 return error_mark_node
;
1608 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1610 else if (TREE_CODE (t
) == VAR_DECL
)
1614 cp_error ("invalid use of member `%D'", t
);
1615 return error_mark_node
;
1617 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1618 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1619 parmlist
, NULL_TREE
);
1620 return build_function_call (decl
, parmlist
);
1624 cp_error ("no method `%T::%D'", type
, name
);
1625 return error_mark_node
;
1629 /* Build a reference to a member of an aggregate. This is not a
1630 C++ `&', but really something which can have its address taken,
1631 and then act as a pointer to member, for example TYPE :: FIELD
1632 can have its address taken by saying & TYPE :: FIELD.
1634 @@ Prints out lousy diagnostics for operator <typename>
1637 @@ This function should be rewritten and placed in search.c. */
1640 build_offset_ref (type
, name
)
1643 tree decl
, t
= error_mark_node
;
1645 tree basebinfo
= NULL_TREE
;
1646 tree orig_name
= name
;
1648 /* class templates can come in as TEMPLATE_DECLs here. */
1649 if (TREE_CODE (name
) == TEMPLATE_DECL
)
1652 if (type
== fake_std_node
)
1653 return do_scoped_id (name
, 0);
1655 if (processing_template_decl
|| uses_template_parms (type
))
1656 return build_min_nt (SCOPE_REF
, type
, name
);
1658 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1660 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1661 something like `a.template f<int>' or the like. For the most
1662 part, we treat this just like a.f. We do remember, however,
1663 the template-id that was used. */
1664 name
= TREE_OPERAND (orig_name
, 0);
1667 name
= DECL_NAME (name
);
1670 if (TREE_CODE (name
) == LOOKUP_EXPR
)
1671 /* This can happen during tsubst'ing. */
1672 name
= TREE_OPERAND (name
, 0);
1675 if (TREE_CODE (name
) == COMPONENT_REF
)
1676 name
= TREE_OPERAND (name
, 1);
1677 if (TREE_CODE (name
) == OVERLOAD
)
1678 name
= DECL_NAME (OVL_CURRENT (name
));
1682 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
1685 if (type
== NULL_TREE
)
1686 return error_mark_node
;
1688 /* Handle namespace names fully here. */
1689 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1691 t
= lookup_namespace_name (type
, name
);
1692 if (t
== error_mark_node
)
1694 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1695 /* Reconstruct the TEMPLATE_ID_EXPR. */
1696 t
= build (TEMPLATE_ID_EXPR
, TREE_TYPE (t
),
1697 t
, TREE_OPERAND (orig_name
, 1));
1698 if (! type_unknown_p (t
))
1701 t
= convert_from_reference (t
);
1706 if (! is_aggr_type (type
, 1))
1707 return error_mark_node
;
1709 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1711 if (! check_dtor_name (type
, name
))
1712 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1713 type
, TREE_OPERAND (name
, 0));
1714 name
= dtor_identifier
;
1717 if (!COMPLETE_TYPE_P (complete_type (type
))
1718 && !TYPE_BEING_DEFINED (type
))
1720 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1722 return error_mark_node
;
1725 decl
= maybe_dummy_object (type
, &basebinfo
);
1727 member
= lookup_member (basebinfo
, name
, 1, 0);
1729 if (member
== error_mark_node
)
1730 return error_mark_node
;
1732 /* A lot of this logic is now handled in lookup_member. */
1733 if (member
&& BASELINK_P (member
))
1735 /* Go from the TREE_BASELINK to the member function info. */
1736 tree fnfields
= member
;
1737 t
= TREE_VALUE (fnfields
);
1739 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1741 /* The FNFIELDS are going to contain functions that aren't
1742 necessarily templates, and templates that don't
1743 necessarily match the explicit template parameters. We
1744 save all the functions, and the explicit parameters, and
1745 then figure out exactly what to instantiate with what
1746 arguments in instantiate_type. */
1748 if (TREE_CODE (t
) != OVERLOAD
)
1749 /* The code in instantiate_type which will process this
1750 expects to encounter OVERLOADs, not raw functions. */
1751 t
= ovl_cons (t
, NULL_TREE
);
1753 t
= build (TEMPLATE_ID_EXPR
, TREE_TYPE (t
), t
,
1754 TREE_OPERAND (orig_name
, 1));
1755 t
= build (OFFSET_REF
, unknown_type_node
, decl
, t
);
1757 PTRMEM_OK_P (t
) = 1;
1762 if (!really_overloaded_fn (t
))
1764 /* Get rid of a potential OVERLOAD around it */
1765 t
= OVL_CURRENT (t
);
1767 /* unique functions are handled easily. */
1768 if (!enforce_access (basebinfo
, t
))
1769 return error_mark_node
;
1771 if (DECL_STATIC_FUNCTION_P (t
))
1773 t
= build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1774 PTRMEM_OK_P (t
) = 1;
1778 TREE_TYPE (fnfields
) = unknown_type_node
;
1780 t
= build (OFFSET_REF
, unknown_type_node
, decl
, fnfields
);
1781 PTRMEM_OK_P (t
) = 1;
1789 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1790 return error_mark_node
;
1793 if (TREE_CODE (t
) == TYPE_DECL
)
1798 /* static class members and class-specific enum
1799 values can be returned without further ado. */
1800 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1803 return convert_from_reference (t
);
1806 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_C_BIT_FIELD (t
))
1808 cp_error ("illegal pointer to bit field `%D'", t
);
1809 return error_mark_node
;
1812 /* static class functions too. */
1813 if (TREE_CODE (t
) == FUNCTION_DECL
1814 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1815 my_friendly_abort (53);
1817 /* In member functions, the form `type::name' is no longer
1818 equivalent to `this->type::name', at least not until
1819 resolve_offset_ref. */
1820 t
= build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1821 PTRMEM_OK_P (t
) = 1;
1825 /* If a OFFSET_REF made it through to here, then it did
1826 not have its address taken. */
1829 resolve_offset_ref (exp
)
1832 tree type
= TREE_TYPE (exp
);
1833 tree base
= NULL_TREE
;
1835 tree basetype
, addr
;
1837 if (TREE_CODE (exp
) == OFFSET_REF
)
1839 member
= TREE_OPERAND (exp
, 1);
1840 base
= TREE_OPERAND (exp
, 0);
1844 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1845 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1847 error ("object missing in use of pointer-to-member construct");
1848 return error_mark_node
;
1851 type
= TREE_TYPE (type
);
1852 base
= current_class_ref
;
1855 if (BASELINK_P (member
) || TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
1856 return build_unary_op (ADDR_EXPR
, exp
, 0);
1858 if (TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1860 if (!flag_ms_extensions
)
1861 /* A single non-static member, make sure we don't allow a
1862 pointer-to-member. */
1863 exp
= ovl_cons (member
, NULL_TREE
);
1865 return build_unary_op (ADDR_EXPR
, exp
, 0);
1868 if ((TREE_CODE (member
) == VAR_DECL
1869 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
))
1870 && ! TYPE_PTRMEM_P (TREE_TYPE (member
)))
1871 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
)
1873 /* These were static members. */
1874 if (mark_addressable (member
) == 0)
1875 return error_mark_node
;
1879 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1880 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1883 /* Syntax error can cause a member which should
1884 have been seen as static to be grok'd as non-static. */
1885 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1887 cp_error_at ("member `%D' is non-static but referenced as a static member",
1889 error ("at this point in file");
1890 return error_mark_node
;
1893 /* The first case is really just a reference to a member of `this'. */
1894 if (TREE_CODE (member
) == FIELD_DECL
1895 && (base
== current_class_ref
|| is_dummy_object (base
)))
1899 basetype
= DECL_CONTEXT (member
);
1901 /* Try to get to basetype from 'this'; if that doesn't work,
1903 base
= current_class_ref
;
1905 /* First convert to the intermediate base specified, if appropriate. */
1906 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1907 base
= build_scoped_ref (base
, TYPE_OFFSET_BASETYPE (type
));
1909 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1910 addr
= convert_pointer_to (basetype
, addr
);
1912 if (addr
== error_mark_node
)
1913 return error_mark_node
;
1915 expr
= build (COMPONENT_REF
, TREE_TYPE (member
),
1916 build_indirect_ref (addr
, NULL_PTR
), member
);
1917 return convert_from_reference (expr
);
1920 /* Ensure that we have an object. */
1921 if (is_dummy_object (base
))
1922 addr
= error_mark_node
;
1924 /* If this is a reference to a member function, then return the
1925 address of the member function (which may involve going
1926 through the object's vtable), otherwise, return an expression
1927 for the dereferenced pointer-to-member construct. */
1928 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1930 if (TYPE_PTRMEM_P (TREE_TYPE (member
)))
1932 if (addr
== error_mark_node
)
1934 cp_error ("object missing in `%E'", exp
);
1935 return error_mark_node
;
1938 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member
)));
1939 addr
= convert_pointer_to (basetype
, addr
);
1940 member
= cp_convert (ptrdiff_type_node
, member
);
1943 /* Pointer to data members are offset by one, so that a null
1944 pointer with a real value of 0 is distinguishable from an
1945 offset of the first member of a structure. */
1946 member
= cp_build_binary_op (MINUS_EXPR
, member
,
1947 cp_convert (ptrdiff_type_node
,
1950 return build1 (INDIRECT_REF
, type
,
1951 build (PLUS_EXPR
, build_pointer_type (type
),
1954 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1956 return get_member_function_from_ptrfunc (&addr
, member
);
1958 my_friendly_abort (56);
1963 /* If DECL is a `const' declaration, and its value is a known
1964 constant, then return that value. */
1967 decl_constant_value (decl
)
1970 if (TREE_READONLY_DECL_P (decl
)
1971 && ! TREE_THIS_VOLATILE (decl
)
1972 && DECL_INITIAL (decl
)
1973 && DECL_INITIAL (decl
) != error_mark_node
1974 /* This is invalid if initial value is not constant.
1975 If it has either a function call, a memory reference,
1976 or a variable, then re-evaluating it could give different results. */
1977 && TREE_CONSTANT (DECL_INITIAL (decl
))
1978 /* Check for cases where this is sub-optimal, even though valid. */
1979 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1980 return DECL_INITIAL (decl
);
1984 /* Common subroutines of build_new and build_vec_delete. */
1986 /* Call the global __builtin_delete to delete ADDR. */
1989 build_builtin_delete_call (addr
)
1992 mark_used (global_delete_fndecl
);
1993 return build_call (global_delete_fndecl
, build_tree_list (NULL_TREE
, addr
));
1996 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1997 (which needs to go through some sort of groktypename) or it
1998 is the name of the class we are newing. INIT is an initialization value.
1999 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
2000 If INIT is void_type_node, it means do *not* call a constructor
2003 For types with constructors, the data returned is initialized
2004 by the appropriate constructor.
2006 Whether the type has a constructor or not, if it has a pointer
2007 to a virtual function table, then that pointer is set up
2010 Unless I am mistaken, a call to new () will return initialized
2011 data regardless of whether the constructor itself is private or
2012 not. NOPE; new fails if the constructor is private (jcm).
2014 Note that build_new does nothing to assure that any special
2015 alignment requirements of the type are met. Rather, it leaves
2016 it up to malloc to do the right thing. Otherwise, folding to
2017 the right alignment cal cause problems if the user tries to later
2018 free the memory returned by `new'.
2020 PLACEMENT is the `placement' list for user-defined operator new (). */
2023 build_new (placement
, decl
, init
, use_global_new
)
2029 tree nelts
= NULL_TREE
, t
;
2032 if (decl
== error_mark_node
)
2033 return error_mark_node
;
2035 if (TREE_CODE (decl
) == TREE_LIST
)
2037 tree absdcl
= TREE_VALUE (decl
);
2038 tree last_absdcl
= NULL_TREE
;
2040 if (current_function_decl
2041 && DECL_CONSTRUCTOR_P (current_function_decl
))
2042 my_friendly_assert (immediate_size_expand
== 0, 19990926);
2044 nelts
= integer_one_node
;
2046 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
2047 my_friendly_abort (215);
2048 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2050 last_absdcl
= absdcl
;
2051 absdcl
= TREE_OPERAND (absdcl
, 0);
2054 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2056 /* probably meant to be a vec new */
2059 while (TREE_OPERAND (absdcl
, 0)
2060 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2062 last_absdcl
= absdcl
;
2063 absdcl
= TREE_OPERAND (absdcl
, 0);
2067 this_nelts
= TREE_OPERAND (absdcl
, 1);
2068 if (this_nelts
!= error_mark_node
)
2070 if (this_nelts
== NULL_TREE
)
2071 error ("new of array type fails to specify size");
2072 else if (processing_template_decl
)
2075 absdcl
= TREE_OPERAND (absdcl
, 0);
2079 int flags
= pedantic
? WANT_INT
: (WANT_INT
| WANT_ENUM
);
2080 if (build_expr_type_conversion (flags
, this_nelts
, 0)
2082 pedwarn ("size in array new must have integral type");
2084 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2085 absdcl
= TREE_OPERAND (absdcl
, 0);
2086 if (this_nelts
== integer_zero_node
)
2088 warning ("zero size array reserves no space");
2089 nelts
= integer_zero_node
;
2092 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2096 nelts
= integer_zero_node
;
2100 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2102 TREE_VALUE (decl
) = absdcl
;
2104 type
= groktypename (decl
);
2105 if (! type
|| type
== error_mark_node
)
2106 return error_mark_node
;
2108 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2110 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2112 /* An aggregate type. */
2113 type
= IDENTIFIER_TYPE_VALUE (decl
);
2114 decl
= TYPE_MAIN_DECL (type
);
2118 /* A builtin type. */
2119 decl
= lookup_name (decl
, 1);
2120 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2121 type
= TREE_TYPE (decl
);
2124 else if (TREE_CODE (decl
) == TYPE_DECL
)
2126 type
= TREE_TYPE (decl
);
2131 decl
= TYPE_MAIN_DECL (type
);
2134 if (processing_template_decl
)
2137 t
= tree_cons (tree_cons (NULL_TREE
, type
, NULL_TREE
),
2138 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2143 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2144 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2148 /* ``A reference cannot be created by the new operator. A reference
2149 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2150 returned by new.'' ARM 5.3.3 */
2151 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2153 error ("new cannot be applied to a reference type");
2154 type
= TREE_TYPE (type
);
2157 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2159 error ("new cannot be applied to a function type");
2160 return error_mark_node
;
2163 /* When the object being created is an array, the new-expression yields a
2164 pointer to the initial element (if any) of the array. For example,
2165 both new int and new int[10] return an int*. 5.3.4. */
2166 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2168 nelts
= array_type_nelts_top (type
);
2170 type
= TREE_TYPE (type
);
2174 t
= build_nt (ARRAY_REF
, type
, nelts
);
2178 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2179 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2180 TREE_SIDE_EFFECTS (rval
) = 1;
2181 rval
= build_new_1 (rval
);
2182 if (rval
== error_mark_node
)
2183 return error_mark_node
;
2185 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2186 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2187 TREE_NO_UNUSED_WARNING (rval
) = 1;
2192 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2195 build_java_class_ref (type
)
2198 tree name
, class_decl
;
2199 static tree CL_suffix
= NULL_TREE
;
2200 if (CL_suffix
== NULL_TREE
)
2201 CL_suffix
= get_identifier("class$");
2202 if (jclass_node
== NULL_TREE
)
2204 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2205 if (jclass_node
== NULL_TREE
)
2206 fatal("call to Java constructor, while `jclass' undefined");
2207 jclass_node
= TREE_TYPE (jclass_node
);
2210 /* Mangle the class$ field, new and old ABI */
2214 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2215 if (DECL_NAME (field
) == CL_suffix
)
2217 name
= mangle_decl (field
);
2221 fatal ("Can't find class$");
2224 name
= build_static_name (type
, CL_suffix
);
2226 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2227 if (class_decl
== NULL_TREE
)
2229 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2230 TREE_STATIC (class_decl
) = 1;
2231 DECL_EXTERNAL (class_decl
) = 1;
2232 TREE_PUBLIC (class_decl
) = 1;
2233 DECL_ARTIFICIAL (class_decl
) = 1;
2234 DECL_IGNORED_P (class_decl
) = 1;
2235 pushdecl_top_level (class_decl
);
2236 make_decl_rtl (class_decl
, NULL_PTR
);
2241 /* Returns the size of the cookie to use when allocating an array
2242 whose elements have the indicated TYPE. Assumes that it is already
2243 known that a cookie is needed. */
2246 get_cookie_size (type
)
2253 /* Under the new ABI, we need to allocate an additional max
2254 (sizeof (size_t), alignof (true_type)) bytes. */
2258 sizetype_size
= size_in_bytes (sizetype
);
2259 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
2260 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
2261 cookie_size
= sizetype_size
;
2263 cookie_size
= type_align
;
2267 if (TYPE_ALIGN (type
) > TYPE_ALIGN (BI_header_type
))
2268 return size_int (TYPE_ALIGN_UNIT (type
));
2270 return size_in_bytes (BI_header_type
);
2276 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2277 value is immediately handed to expand_expr. */
2283 tree placement
, init
;
2284 tree type
, true_type
, size
, rval
, t
;
2286 tree nelts
= NULL_TREE
;
2287 tree alloc_call
, alloc_expr
, alloc_node
;
2288 tree cookie_expr
, init_expr
;
2290 enum tree_code code
;
2291 int use_cookie
, nothrow
, check_new
;
2292 /* Nonzero if the user wrote `::new' rather than just `new'. */
2293 int globally_qualified_p
;
2294 /* Nonzero if we're going to call a global operator new, rather than
2295 a class-specific version. */
2297 int use_java_new
= 0;
2298 /* If non-NULL, the number of extra bytes to allocate at the
2299 beginning of the storage allocated for an array-new expression in
2300 order to store the number of elements. */
2301 tree cookie_size
= NULL_TREE
;
2303 placement
= TREE_OPERAND (exp
, 0);
2304 type
= TREE_OPERAND (exp
, 1);
2305 init
= TREE_OPERAND (exp
, 2);
2306 globally_qualified_p
= NEW_EXPR_USE_GLOBAL (exp
);
2308 if (TREE_CODE (type
) == ARRAY_REF
)
2311 nelts
= TREE_OPERAND (type
, 1);
2312 type
= TREE_OPERAND (type
, 0);
2314 full_type
= cp_build_binary_op (MINUS_EXPR
, nelts
, integer_one_node
);
2315 full_type
= build_index_type (full_type
);
2316 full_type
= build_cplus_array_type (type
, full_type
);
2323 code
= has_array
? VEC_NEW_EXPR
: NEW_EXPR
;
2325 /* If our base type is an array, then make sure we know how many elements
2327 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2329 tree this_nelts
= array_type_nelts_top (true_type
);
2330 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2331 true_type
= TREE_TYPE (true_type
);
2334 if (!complete_type_or_else (true_type
, exp
))
2335 return error_mark_node
;
2337 size
= size_in_bytes (true_type
);
2339 size
= fold (cp_build_binary_op (MULT_EXPR
, size
, nelts
));
2341 if (TREE_CODE (true_type
) == VOID_TYPE
)
2343 error ("invalid type `void' for new");
2344 return error_mark_node
;
2347 if (abstract_virtuals_error (NULL_TREE
, true_type
))
2348 return error_mark_node
;
2350 /* Figure out whether or not we're going to use the global operator
2352 if (!globally_qualified_p
2353 && IS_AGGR_TYPE (true_type
)
2355 ? TYPE_HAS_ARRAY_NEW_OPERATOR (true_type
)
2356 : TYPE_HAS_NEW_OPERATOR (true_type
)))
2361 /* We only need cookies for arrays containing types for which we
2363 if (!has_array
|| !TYPE_VEC_NEW_USES_COOKIE (true_type
))
2365 /* When using placement new, users may not realize that they need
2366 the extra storage. Under the old ABI, we don't allocate the
2367 cookie whenever they use one placement argument of type `void
2368 *'. Under the new ABI, we require that the operator called be
2369 the global placement operator delete[]. */
2370 else if (placement
&& !TREE_CHAIN (placement
)
2371 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2373 use_cookie
= (!flag_new_abi
|| !use_global_new
);
2374 /* Otherwise, we need the cookie. */
2378 /* Compute the number of extra bytes to allocate, now that we know
2379 whether or not we need the cookie. */
2382 cookie_size
= get_cookie_size (true_type
);
2383 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
2386 /* Allocate the object. */
2388 if (! placement
&& TYPE_FOR_JAVA (true_type
))
2390 tree class_addr
, alloc_decl
;
2391 tree class_decl
= build_java_class_ref (true_type
);
2392 tree class_size
= size_in_bytes (true_type
);
2393 static char alloc_name
[] = "_Jv_AllocObject";
2395 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2396 if (alloc_decl
== NULL_TREE
)
2397 fatal("call to Java constructor, while `%s' undefined", alloc_name
);
2398 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2399 alloc_call
= (build_function_call
2401 tree_cons (NULL_TREE
, class_addr
,
2402 build_tree_list (NULL_TREE
, class_size
))));
2409 args
= tree_cons (NULL_TREE
, size
, placement
);
2410 fnname
= ansi_opname (code
);
2413 alloc_call
= (build_new_function_call
2414 (lookup_function_nonclass (fnname
, args
),
2417 alloc_call
= build_method_call (build_dummy_object (true_type
),
2418 fnname
, args
, NULL_TREE
,
2422 if (alloc_call
== error_mark_node
)
2423 return error_mark_node
;
2425 if (alloc_call
== NULL_TREE
)
2428 /* unless an allocation function is declared with an empty excep-
2429 tion-specification (_except.spec_), throw(), it indicates failure to
2430 allocate storage by throwing a bad_alloc exception (clause _except_,
2431 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2432 cation function is declared with an empty exception-specification,
2433 throw(), it returns null to indicate failure to allocate storage and a
2434 non-null pointer otherwise.
2436 So check for a null exception spec on the op new we just called. */
2438 /* The ADDR_EXPR. */
2439 t
= TREE_OPERAND (alloc_call
, 0);
2441 t
= TREE_OPERAND (t
, 0);
2442 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (t
));
2443 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2445 alloc_expr
= alloc_call
;
2448 /* Adjust so we're pointing to the start of the object. */
2449 alloc_expr
= build (PLUS_EXPR
, TREE_TYPE (alloc_expr
),
2450 alloc_expr
, cookie_size
);
2452 /* While we're working, use a pointer to the type we've actually
2454 alloc_expr
= convert (build_pointer_type (full_type
), alloc_expr
);
2456 /* Now save the allocation expression so we only evaluate it once. */
2457 alloc_expr
= get_target_expr (alloc_expr
);
2458 alloc_node
= TREE_OPERAND (alloc_expr
, 0);
2460 /* Now initialize the cookie. */
2465 /* Store the number of bytes allocated so that we can know how
2466 many elements to destroy later. */
2469 /* Under the new ABI, we use the last sizeof (size_t) bytes
2470 to store the number of elements. */
2471 cookie
= build (MINUS_EXPR
, build_pointer_type (sizetype
),
2472 alloc_node
, size_in_bytes (sizetype
));
2473 cookie
= build_indirect_ref (cookie
, NULL_PTR
);
2477 cookie
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
2478 alloc_node
, cookie_size
);
2479 cookie
= build_indirect_ref (cookie
, NULL_PTR
);
2480 cookie
= build_component_ref (cookie
, nelts_identifier
,
2483 cookie_expr
= build (MODIFY_EXPR
, void_type_node
, cookie
, nelts
);
2484 TREE_SIDE_EFFECTS (cookie_expr
) = 1;
2487 cookie_expr
= NULL_TREE
;
2489 /* Now initialize the allocated object. */
2490 init_expr
= NULL_TREE
;
2491 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2493 init_expr
= build_indirect_ref (alloc_node
, NULL_PTR
);
2495 if (init
== void_zero_node
)
2496 init
= build_default_init (full_type
);
2497 else if (init
&& pedantic
&& has_array
)
2498 cp_pedwarn ("ISO C++ forbids initialization in array new");
2501 init_expr
= build_vec_init (init_expr
, init
, 0);
2502 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2503 init_expr
= build_method_call (init_expr
,
2504 complete_ctor_identifier
,
2505 init
, TYPE_BINFO (true_type
),
2509 /* We are processing something like `new int (10)', which
2510 means allocate an int, and initialize it with 10. */
2512 if (TREE_CODE (init
) == TREE_LIST
)
2514 if (TREE_CHAIN (init
) != NULL_TREE
)
2516 ("initializer list being treated as compound expression");
2517 init
= build_compound_expr (init
);
2519 else if (TREE_CODE (init
) == CONSTRUCTOR
2520 && TREE_TYPE (init
) == NULL_TREE
)
2522 pedwarn ("ISO C++ forbids aggregate initializer to new");
2523 init
= digest_init (type
, init
, 0);
2526 init_expr
= build_modify_expr (init_expr
, INIT_EXPR
, init
);
2529 if (init_expr
== error_mark_node
)
2530 return error_mark_node
;
2532 /* If any part of the object initialization terminates by throwing an
2533 exception and a suitable deallocation function can be found, the
2534 deallocation function is called to free the memory in which the
2535 object was being constructed, after which the exception continues
2536 to propagate in the context of the new-expression. If no
2537 unambiguous matching deallocation function can be found,
2538 propagating the exception does not cause the object's memory to be
2540 if (flag_exceptions
&& ! use_java_new
)
2542 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2544 int flags
= (LOOKUP_NORMAL
2545 | (globally_qualified_p
* LOOKUP_GLOBAL
));
2547 /* The Standard is unclear here, but the right thing to do
2548 is to use the same method for finding deallocation
2549 functions that we use for finding allocation functions. */
2550 flags
|= LOOKUP_SPECULATIVELY
;
2552 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
,
2555 /* Ack! First we allocate the memory. Then we set our sentry
2556 variable to true, and expand a cleanup that deletes the memory
2557 if sentry is true. Then we run the constructor, and finally
2560 It would be nice to be able to handle this without the sentry
2561 variable, perhaps with a TRY_CATCH_EXPR, but this doesn't
2562 work. We allocate the space first, so if there are any
2563 temporaries with cleanups in the constructor args we need this
2564 EH region to extend until end of full-expression to preserve
2567 If the backend had some mechanism so that we could force the
2568 allocation to be expanded after all the other args to the
2569 constructor, that would fix the nesting problem and we could
2570 do away with this complexity. But that would complicate other
2571 things; in particular, it would make it difficult to bail out
2572 if the allocation function returns null. */
2576 tree end
, sentry
, begin
;
2578 begin
= get_target_expr (boolean_true_node
);
2579 sentry
= TREE_OPERAND (begin
, 0);
2581 TREE_OPERAND (begin
, 2)
2582 = build (COND_EXPR
, void_type_node
, sentry
,
2583 cleanup
, void_zero_node
);
2585 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2586 sentry
, boolean_false_node
);
2589 = build (COMPOUND_EXPR
, void_type_node
, begin
,
2590 build (COMPOUND_EXPR
, void_type_node
, init_expr
,
2595 else if (CP_TYPE_CONST_P (true_type
))
2596 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2598 /* Now build up the return value in reverse order. */
2603 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
2605 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
2607 if (rval
== alloc_node
)
2608 /* If we didn't modify anything, strip the TARGET_EXPR and return the
2610 rval
= TREE_OPERAND (alloc_expr
, 1);
2615 tree ifexp
= cp_build_binary_op (NE_EXPR
, alloc_node
,
2617 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2620 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2623 /* Now strip the outer ARRAY_TYPE, so we return a pointer to the first
2625 rval
= convert (build_pointer_type (type
), rval
);
2631 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, use_global_delete
)
2632 tree base
, maxindex
, type
;
2633 special_function_kind auto_delete_vec
;
2634 int use_global_delete
;
2637 tree ptype
= build_pointer_type (type
= complete_type (type
));
2638 tree size_exp
= size_in_bytes (type
);
2640 /* Temporary variables used by the loop. */
2641 tree tbase
, tbase_init
;
2643 /* This is the body of the loop that implements the deletion of a
2644 single element, and moves temp variables to next elements. */
2647 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2650 /* This is the thing that governs what to do after the loop has run. */
2651 tree deallocate_expr
= 0;
2653 /* This is the BIND_EXPR which holds the outermost iterator of the
2654 loop. It is convenient to set this variable up and test it before
2655 executing any other code in the loop.
2656 This is also the containing expression returned by this function. */
2657 tree controller
= NULL_TREE
;
2659 if (! IS_AGGR_TYPE (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2661 loop
= integer_zero_node
;
2665 /* The below is short by the cookie size. */
2666 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2667 convert (sizetype
, maxindex
));
2669 tbase
= create_temporary_var (ptype
);
2670 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2671 fold (build (PLUS_EXPR
, ptype
,
2674 DECL_REGISTER (tbase
) = 1;
2675 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2676 TREE_SIDE_EFFECTS (controller
) = 1;
2680 body
= tree_cons (NULL_TREE
,
2681 build_delete (ptype
, tbase
, sfk_complete_destructor
,
2682 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2685 body
= tree_cons (NULL_TREE
,
2686 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2689 body
= tree_cons (NULL_TREE
,
2690 build (EXIT_EXPR
, void_type_node
,
2691 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2694 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2696 loop
= tree_cons (NULL_TREE
, tbase_init
,
2697 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2698 loop
= build_compound_expr (loop
);
2701 /* If the delete flag is one, or anything else with the low bit set,
2702 delete the storage. */
2703 deallocate_expr
= integer_zero_node
;
2704 if (auto_delete_vec
!= sfk_base_destructor
)
2708 /* The below is short by the cookie size. */
2709 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2710 convert (sizetype
, maxindex
));
2712 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2719 cookie_size
= get_cookie_size (type
);
2721 = cp_convert (ptype
,
2722 cp_build_binary_op (MINUS_EXPR
,
2723 cp_convert (string_type_node
,
2726 /* True size with header. */
2727 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2730 if (auto_delete_vec
== sfk_deleting_destructor
)
2731 deallocate_expr
= build_x_delete (base_tbd
,
2732 2 | use_global_delete
,
2736 if (loop
&& deallocate_expr
!= integer_zero_node
)
2738 body
= tree_cons (NULL_TREE
, loop
,
2739 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2740 body
= build_compound_expr (body
);
2745 /* Outermost wrapper: If pointer is null, punt. */
2746 body
= fold (build (COND_EXPR
, void_type_node
,
2747 fold (build (NE_EXPR
, boolean_type_node
, base
,
2748 integer_zero_node
)),
2749 body
, integer_zero_node
));
2750 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2754 TREE_OPERAND (controller
, 1) = body
;
2758 return cp_convert (void_type_node
, body
);
2761 /* Create an unnamed variable of the indicated TYPE. */
2764 create_temporary_var (type
)
2769 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2770 TREE_USED (decl
) = 1;
2771 DECL_ARTIFICIAL (decl
) = 1;
2772 DECL_SOURCE_FILE (decl
) = input_filename
;
2773 DECL_SOURCE_LINE (decl
) = lineno
;
2774 DECL_IGNORED_P (decl
) = 1;
2775 DECL_CONTEXT (decl
) = current_function_decl
;
2780 /* Create a new temporary variable of the indicated TYPE, initialized
2783 It is not entered into current_binding_level, because that breaks
2784 things when it comes time to do final cleanups (which take place
2785 "outside" the binding contour of the function). */
2788 get_temp_regvar (type
, init
)
2793 decl
= create_temporary_var (type
);
2794 if (building_stmt_tree ())
2795 add_decl_stmt (decl
);
2796 if (!building_stmt_tree ())
2797 DECL_RTL (decl
) = assign_temp (type
, 2, 0, 1);
2798 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
2803 /* `build_vec_init' returns tree structure that performs
2804 initialization of a vector of aggregate types.
2806 BASE is a reference to the vector, of ARRAY_TYPE.
2807 INIT is the (possibly NULL) initializer.
2809 FROM_ARRAY is 0 if we should init everything with INIT
2810 (i.e., every element initialized from INIT).
2811 FROM_ARRAY is 1 if we should index into INIT in parallel
2812 with initialization of DECL.
2813 FROM_ARRAY is 2 if we should index into INIT in parallel,
2814 but use assignment instead of initialization. */
2817 build_vec_init (base
, init
, from_array
)
2822 tree base2
= NULL_TREE
;
2824 tree itype
= NULL_TREE
;
2826 /* The type of the array. */
2827 tree atype
= TREE_TYPE (base
);
2828 /* The type of an element in the array. */
2829 tree type
= TREE_TYPE (atype
);
2830 /* The type of a pointer to an element in the array. */
2835 tree try_block
= NULL_TREE
;
2836 tree try_body
= NULL_TREE
;
2837 int num_initialized_elts
= 0;
2838 tree maxindex
= array_type_nelts (TREE_TYPE (base
));
2840 if (maxindex
== error_mark_node
)
2841 return error_mark_node
;
2843 /* For g++.ext/arrnew.C. */
2844 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == NULL_TREE
)
2845 init
= digest_init (atype
, init
, 0);
2847 if (init
&& !TYPE_NEEDS_CONSTRUCTING (type
)
2848 && ((TREE_CODE (init
) == CONSTRUCTOR
2849 /* Don't do this if the CONSTRUCTOR might contain something
2850 that might throw and require us to clean up. */
2851 && (CONSTRUCTOR_ELTS (init
) == NULL_TREE
2852 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type
))))
2855 /* Do non-default initialization of POD arrays resulting from
2856 brace-enclosed initializers. In this case, digest_init and
2857 store_constructor will handle the semantics for us. */
2859 stmt_expr
= build (INIT_EXPR
, atype
, base
, init
);
2860 TREE_SIDE_EFFECTS (stmt_expr
) = 1;
2864 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2865 ptype
= build_pointer_type (type
);
2866 size
= size_in_bytes (type
);
2867 if (TREE_CODE (TREE_TYPE (base
)) == ARRAY_TYPE
)
2868 base
= cp_convert (ptype
, default_conversion (base
));
2870 /* The code we are generating looks like:
2874 ptrdiff_t iterator = maxindex;
2877 ... initialize *t1 ...
2879 } while (--iterator != -1);
2881 ... destroy elements that were constructed ...
2885 We can omit the try and catch blocks if we know that the
2886 initialization will never throw an exception, or if the array
2887 elements do not have destructors. We can omit the loop completely if
2888 the elements of the array do not have constructors.
2890 We actually wrap the entire body of the above in a STMT_EXPR, for
2893 When copying from array to another, when the array elements have
2894 only trivial copy constructors, we should use __builtin_memcpy
2895 rather than generating a loop. That way, we could take advantage
2896 of whatever cleverness the back-end has for dealing with copies
2897 of blocks of memory. */
2899 begin_init_stmts (&stmt_expr
, &compound_stmt
);
2900 destroy_temps
= stmts_are_full_exprs_p ();
2901 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2902 rval
= get_temp_regvar (ptype
, base
);
2903 base
= get_temp_regvar (ptype
, rval
);
2904 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2906 /* Protect the entire array initialization so that we can destroy
2907 the partially constructed array if an exception is thrown.
2908 But don't do this if we're assigning. */
2909 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2912 try_block
= begin_try_block ();
2913 try_body
= begin_compound_stmt (/*has_no_scope=*/1);
2916 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
2918 /* Do non-default initialization of non-POD arrays resulting from
2919 brace-enclosed initializers. */
2924 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2926 tree elt
= TREE_VALUE (elts
);
2927 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2929 num_initialized_elts
++;
2931 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2932 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0));
2934 finish_expr_stmt (build_modify_expr (baseref
, NOP_EXPR
,
2937 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base
, 0));
2938 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR
, iterator
, 0));
2941 /* Clear out INIT so that we don't get confused below. */
2944 else if (from_array
)
2946 /* If initializing one array from another, initialize element by
2947 element. We rely upon the below calls the do argument
2951 base2
= default_conversion (init
);
2952 itype
= TREE_TYPE (base2
);
2953 base2
= get_temp_regvar (itype
, base2
);
2954 itype
= TREE_TYPE (itype
);
2956 else if (TYPE_LANG_SPECIFIC (type
)
2957 && TYPE_NEEDS_CONSTRUCTING (type
)
2958 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2960 error ("initializer ends prematurely");
2961 return error_mark_node
;
2965 /* Now, default-initialize any remaining elements. We don't need to
2966 do that if a) the type does not need constructing, or b) we've
2967 already initialized all the elements.
2969 We do need to keep going if we're copying an array. */
2972 || (TYPE_NEEDS_CONSTRUCTING (type
)
2973 && ! (host_integerp (maxindex
, 0)
2974 && (num_initialized_elts
2975 == tree_low_cst (maxindex
, 0) + 1))))
2977 /* If the ITERATOR is equal to -1, then we don't have to loop;
2978 we've already initialized all the elements. */
2984 if_stmt
= begin_if_stmt ();
2985 finish_if_stmt_cond (build (NE_EXPR
, boolean_type_node
,
2986 iterator
, minus_one_node
),
2989 /* Otherwise, loop through the elements. */
2990 do_stmt
= begin_do_stmt ();
2991 do_body
= begin_compound_stmt (/*has_no_scope=*/1);
2993 /* When we're not building a statement-tree, things are a little
2994 complicated. If, when we recursively call build_aggr_init,
2995 an expression containing a TARGET_EXPR is expanded, then it
2996 may get a cleanup. Then, the result of that expression is
2997 passed to finish_expr_stmt, which will call
2998 expand_start_target_temps/expand_end_target_temps. However,
2999 the latter call will not cause the cleanup to run because
3000 that block will still be on the block stack. So, we call
3001 expand_start_target_temps here manually; the corresponding
3002 call to expand_end_target_temps below will cause the cleanup
3004 if (!building_stmt_tree ())
3005 expand_start_target_temps ();
3009 tree to
= build1 (INDIRECT_REF
, type
, base
);
3013 from
= build1 (INDIRECT_REF
, itype
, base2
);
3017 if (from_array
== 2)
3018 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
3019 else if (TYPE_NEEDS_CONSTRUCTING (type
))
3020 elt_init
= build_aggr_init (to
, from
, 0);
3022 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
3024 my_friendly_abort (57);
3026 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3030 ("cannot initialize multi-dimensional array with initializer");
3031 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
3035 elt_init
= build_aggr_init (build1 (INDIRECT_REF
, type
, base
),
3038 /* The initialization of each array element is a
3039 full-expression, as per core issue 124. */
3040 if (!building_stmt_tree ())
3042 genrtl_expr_stmt (elt_init
);
3043 expand_end_target_temps ();
3047 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
3048 finish_expr_stmt (elt_init
);
3049 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
3052 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base
, 0));
3054 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base2
, 0));
3056 finish_compound_stmt (/*has_no_scope=*/1, do_body
);
3057 finish_do_body (do_stmt
);
3058 finish_do_stmt (build (NE_EXPR
, boolean_type_node
,
3059 build_unary_op (PREDECREMENT_EXPR
, iterator
, 0),
3063 finish_then_clause (if_stmt
);
3067 /* Make sure to cleanup any partially constructed elements. */
3068 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
3073 finish_compound_stmt (/*has_no_scope=*/1, try_body
);
3074 finish_cleanup_try_block (try_block
);
3075 e
= build_vec_delete_1 (rval
,
3076 cp_build_binary_op (MINUS_EXPR
, maxindex
,
3079 sfk_base_destructor
,
3080 /*use_global_delete=*/0);
3081 finish_cleanup (e
, try_block
);
3084 /* The value of the array initialization is the address of the
3085 first element in the array. */
3086 finish_expr_stmt (rval
);
3088 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
3089 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
3093 /* Free up storage of type TYPE, at address ADDR.
3095 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3098 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3099 used as the second argument to operator delete. It can include
3100 things like padding and magic size cookies. It has virtual in it,
3101 because if you have a base pointer and you delete through a virtual
3102 destructor, it should be the size of the dynamic object, not the
3103 static object, see Free Store 12.5 ISO C++.
3105 This does not call any destructors. */
3108 build_x_delete (addr
, which_delete
, virtual_size
)
3113 int use_global_delete
= which_delete
& 1;
3114 int use_vec_delete
= !!(which_delete
& 2);
3115 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3116 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
3118 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
3121 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3125 build_dtor_call (exp
, dtor_kind
, flags
)
3127 special_function_kind dtor_kind
;
3134 case sfk_complete_destructor
:
3135 name
= complete_dtor_identifier
;
3138 case sfk_base_destructor
:
3139 name
= base_dtor_identifier
;
3142 case sfk_deleting_destructor
:
3143 name
= deleting_dtor_identifier
;
3147 my_friendly_abort (20000524);
3149 return build_method_call (exp
, name
, NULL_TREE
, NULL_TREE
, flags
);
3152 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3153 ADDR is an expression which yields the store to be destroyed.
3154 AUTO_DELETE is the name of the destructor to call, i.e., either
3155 sfk_complete_destructor, sfk_base_destructor, or
3156 sfk_deleting_destructor.
3158 FLAGS is the logical disjunction of zero or more LOOKUP_
3159 flags. See cp-tree.h for more info.
3161 This function does not delete an object's virtual base classes. */
3164 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3166 special_function_kind auto_delete
;
3168 int use_global_delete
;
3174 if (addr
== error_mark_node
)
3175 return error_mark_node
;
3177 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3178 set to `error_mark_node' before it gets properly cleaned up. */
3179 if (type
== error_mark_node
)
3180 return error_mark_node
;
3182 type
= TYPE_MAIN_VARIANT (type
);
3184 if (TREE_CODE (type
) == POINTER_TYPE
)
3186 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3187 if (!VOID_TYPE_P (type
) && !complete_type_or_else (type
, addr
))
3188 return error_mark_node
;
3189 if (TREE_CODE (type
) == ARRAY_TYPE
)
3191 if (! IS_AGGR_TYPE (type
))
3193 /* Call the builtin operator delete. */
3194 return build_builtin_delete_call (addr
);
3196 if (TREE_SIDE_EFFECTS (addr
))
3197 addr
= save_expr (addr
);
3199 /* throw away const and volatile on target type of addr */
3200 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3201 ref
= build_indirect_ref (addr
, NULL_PTR
);
3203 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3206 if (TREE_SIDE_EFFECTS (addr
))
3207 addr
= save_expr (addr
);
3208 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3210 error ("unknown array size in delete");
3211 return error_mark_node
;
3213 return build_vec_delete (addr
, array_type_nelts (type
),
3214 auto_delete
, use_global_delete
);
3218 /* Don't check PROTECT here; leave that decision to the
3219 destructor. If the destructor is accessible, call it,
3220 else report error. */
3221 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3222 if (TREE_SIDE_EFFECTS (addr
))
3223 addr
= save_expr (addr
);
3225 if (TREE_CONSTANT (addr
))
3226 addr
= convert_pointer_to (type
, addr
);
3228 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3230 ref
= build_indirect_ref (addr
, NULL_PTR
);
3233 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3235 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3237 if (auto_delete
== sfk_base_destructor
)
3238 return void_zero_node
;
3240 return build_op_delete_call
3241 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3242 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3246 /* Below, we will reverse the order in which these calls are made.
3247 If we have a destructor, then that destructor will take care
3248 of the base classes; otherwise, we must do that here. */
3249 if (TYPE_HAS_DESTRUCTOR (type
))
3251 tree do_delete
= NULL_TREE
;
3254 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3256 /* Delete the object. */
3257 do_delete
= build_builtin_delete_call (addr
);
3258 /* Otherwise, treat this like a complete object destructor
3260 auto_delete
= sfk_complete_destructor
;
3263 expr
= build_dtor_call (ref
, auto_delete
, flags
);
3265 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3267 if (flags
& LOOKUP_DESTRUCTOR
)
3268 /* Explicit destructor call; don't check for null pointer. */
3269 ifexp
= integer_one_node
;
3271 /* Handle deleting a null pointer. */
3272 ifexp
= fold (cp_build_binary_op (NE_EXPR
, addr
, integer_zero_node
));
3274 if (ifexp
!= integer_one_node
)
3275 expr
= build (COND_EXPR
, void_type_node
,
3276 ifexp
, expr
, void_zero_node
);
3282 /* We only get here from finish_function for a destructor. */
3283 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3284 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (type
);
3285 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3286 tree exprstmt
= NULL_TREE
;
3288 /* Set this again before we call anything, as we might get called
3290 TYPE_HAS_DESTRUCTOR (type
) = 1;
3292 /* If we have member delete or vbases, we call delete in
3294 my_friendly_assert (auto_delete
== sfk_base_destructor
, 20000411);
3296 /* Take care of the remaining baseclasses. */
3297 for (i
= 0; i
< n_baseclasses
; i
++)
3299 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3300 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3301 || TREE_VIA_VIRTUAL (base_binfo
))
3304 expr
= build_scoped_method_call (ref
, base_binfo
,
3305 base_dtor_identifier
,
3308 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3311 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3313 if (TREE_CODE (member
) != FIELD_DECL
)
3315 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member
)))
3317 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3318 tree this_type
= TREE_TYPE (member
);
3319 expr
= build_delete (this_type
, this_member
,
3320 sfk_complete_destructor
, flags
, 0);
3321 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3326 return build_compound_expr (exprstmt
);
3327 /* Virtual base classes make this function do nothing. */
3328 return void_zero_node
;
3332 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3335 build_vbase_delete (type
, decl
)
3338 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3339 tree result
= NULL_TREE
;
3340 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3342 my_friendly_assert (addr
!= error_mark_node
, 222);
3347 = convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases
))),
3349 result
= tree_cons (NULL_TREE
,
3350 build_delete (TREE_TYPE (this_addr
), this_addr
,
3351 sfk_base_destructor
,
3352 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3354 vbases
= TREE_CHAIN (vbases
);
3356 return build_compound_expr (nreverse (result
));
3359 /* Build a C++ vector delete expression.
3360 MAXINDEX is the number of elements to be deleted.
3361 ELT_SIZE is the nominal size of each element in the vector.
3362 BASE is the expression that should yield the store to be deleted.
3363 This function expands (or synthesizes) these calls itself.
3364 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3366 This also calls delete for virtual baseclasses of elements of the vector.
3368 Update: MAXINDEX is no longer needed. The size can be extracted from the
3369 start of the vector for pointers, and from the type for arrays. We still
3370 use MAXINDEX for arrays because it happens to already have one of the
3371 values we'd have to extract. (We could use MAXINDEX with pointers to
3372 confirm the size, and trap if the numbers differ; not clear that it'd
3373 be worth bothering.) */
3376 build_vec_delete (base
, maxindex
, auto_delete_vec
, use_global_delete
)
3377 tree base
, maxindex
;
3378 special_function_kind auto_delete_vec
;
3379 int use_global_delete
;
3383 if (TREE_CODE (base
) == OFFSET_REF
)
3384 base
= resolve_offset_ref (base
);
3386 type
= TREE_TYPE (base
);
3388 base
= stabilize_reference (base
);
3390 /* Since we can use base many times, save_expr it. */
3391 if (TREE_SIDE_EFFECTS (base
))
3392 base
= save_expr (base
);
3394 if (TREE_CODE (type
) == POINTER_TYPE
)
3396 /* Step back one from start of vector, and read dimension. */
3399 type
= strip_array_types (TREE_TYPE (type
));
3402 cookie_addr
= build (MINUS_EXPR
,
3403 build_pointer_type (sizetype
),
3405 TYPE_SIZE_UNIT (sizetype
));
3406 maxindex
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3412 cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3413 base
, get_cookie_size (type
));
3414 cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3415 maxindex
= build_component_ref (cookie
, nelts_identifier
,
3419 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3421 /* get the total number of things in the array, maxindex is a bad name */
3422 maxindex
= array_type_nelts_total (type
);
3423 type
= strip_array_types (type
);
3424 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3428 if (base
!= error_mark_node
)
3429 error ("type to vector delete is neither pointer or array type");
3430 return error_mark_node
;
3433 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,