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_new_1
PARAMS ((tree
));
53 static tree get_cookie_size
PARAMS ((tree
));
54 static tree build_dtor_call
PARAMS ((tree
, special_function_kind
, int));
55 static tree build_field_list
PARAMS ((tree
, tree
, int *));
56 static tree build_vtbl_address
PARAMS ((tree
));
58 /* Set up local variable for this file. MUST BE CALLED AFTER
59 INIT_DECL_PROCESSING. */
61 static tree BI_header_type
;
63 void init_init_processing ()
67 minus_one_node
= build_int_2 (-1, -1);
69 /* Define the structure that holds header information for
70 arrays allocated via operator new. */
71 BI_header_type
= make_aggr_type (RECORD_TYPE
);
72 fields
[0] = build_decl (FIELD_DECL
, nelts_identifier
, sizetype
);
74 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
77 ggc_add_tree_root (&BI_header_type
, 1);
80 /* We are about to generate some complex initialization code.
81 Conceptually, it is all a single expression. However, we may want
82 to include conditionals, loops, and other such statement-level
83 constructs. Therefore, we build the initialization code inside a
84 statement-expression. This function starts such an expression.
85 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
86 pass them back to finish_init_stmts when the expression is
90 begin_init_stmts (stmt_expr_p
, compound_stmt_p
)
92 tree
*compound_stmt_p
;
94 if (building_stmt_tree ())
95 *stmt_expr_p
= begin_stmt_expr ();
97 *stmt_expr_p
= begin_global_stmt_expr ();
99 if (building_stmt_tree ())
100 *compound_stmt_p
= begin_compound_stmt (/*has_no_scope=*/1);
103 *compound_stmt_p = genrtl_begin_compound_stmt (has_no_scope=1);
107 /* Finish out the statement-expression begun by the previous call to
108 begin_init_stmts. Returns the statement-expression itself. */
111 finish_init_stmts (stmt_expr
, compound_stmt
)
116 if (building_stmt_tree ())
117 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
119 if (building_stmt_tree ())
120 stmt_expr
= finish_stmt_expr (stmt_expr
);
122 stmt_expr
= finish_global_stmt_expr (stmt_expr
);
124 /* To avoid spurious warnings about unused values, we set
127 TREE_USED (stmt_expr
) = 1;
134 /* Called from initialize_vtbl_ptrs via dfs_walk. */
137 dfs_initialize_vtbl_ptrs (binfo
, data
)
141 if (!BINFO_PRIMARY_MARKED_P (binfo
)
142 && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo
)))
144 tree base_ptr
= TREE_VALUE ((tree
) data
);
146 if (TREE_VIA_VIRTUAL (binfo
))
147 base_ptr
= convert_pointer_to_vbase (BINFO_TYPE (binfo
),
151 = build_vbase_path (PLUS_EXPR
,
152 build_pointer_type (BINFO_TYPE (binfo
)),
157 expand_virtual_init (binfo
, base_ptr
);
160 SET_BINFO_MARKED (binfo
);
165 /* Initialize all the vtable pointers in the object pointed to by
169 initialize_vtbl_ptrs (addr
)
175 type
= TREE_TYPE (TREE_TYPE (addr
));
176 list
= build_tree_list (type
, addr
);
178 /* Walk through the hierarchy, initializing the vptr in each base
179 class. We do these in pre-order because under the new ABI we
180 can't find the virtual bases for a class until we've initialized
181 the vtbl for that class. */
182 dfs_walk_real (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
,
183 NULL
, dfs_unmarked_real_bases_queue_p
, list
);
184 dfs_walk (TYPE_BINFO (type
), dfs_unmark
,
185 dfs_marked_real_bases_queue_p
, type
);
187 /* If we're not using thunks, we may need to adjust the deltas in
188 the vtable to handle virtual base classes correctly. When we are
189 using thunks, we either use construction vtables (which are
190 preloaded with the right answers) or nothing (in which case
191 vitual function calls sometimes don't work right.) */
192 if (TYPE_USES_VIRTUAL_BASECLASSES (type
) && !flag_vtable_thunks
)
193 fixup_all_virtual_upcast_offsets (addr
);
196 /* Subroutine of emit_base_init. */
199 perform_member_init (member
, init
, explicit)
204 tree type
= TREE_TYPE (member
);
206 decl
= build_component_ref (current_class_ref
, member
, NULL_TREE
, explicit);
208 if (decl
== error_mark_node
)
211 /* Deal with this here, as we will get confused if we try to call the
212 assignment op for an anonymous union. This can happen in a
213 synthesized copy constructor. */
214 if (ANON_AGGR_TYPE_P (type
))
218 init
= build (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
219 finish_expr_stmt (init
);
222 else if (TYPE_NEEDS_CONSTRUCTING (type
)
223 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
225 /* Since `init' is already a TREE_LIST on the member_init_list,
226 only build it into one if we aren't already a list. */
227 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
228 init
= build_tree_list (NULL_TREE
, init
);
231 && TREE_CODE (type
) == ARRAY_TYPE
233 && TREE_CHAIN (init
) == NULL_TREE
234 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
236 /* Initialization of one array from another. */
238 (build_vec_init (TREE_OPERAND (decl
, 1), decl
,
239 array_type_nelts (type
), TREE_VALUE (init
), 1));
242 finish_expr_stmt (build_aggr_init (decl
, init
, 0));
246 if (init
== NULL_TREE
)
250 /* default-initialization. */
251 if (AGGREGATE_TYPE_P (type
))
253 /* This is a default initialization of an aggregate,
254 but not one of non-POD class type. We cleverly
255 notice that the initialization rules in such a
256 case are the same as for initialization with an
257 empty brace-initialization list. We don't want
258 to call build_modify_expr as that will go looking
259 for constructors and such. */
260 tree e
= build (CONSTRUCTOR
, type
, NULL_TREE
, NULL_TREE
);
261 TREE_SIDE_EFFECTS (e
) = 1;
262 finish_expr_stmt (build (INIT_EXPR
, type
, decl
, e
));
264 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
265 cp_error ("default-initialization of `%#D', which has reference type",
268 init
= integer_zero_node
;
270 /* member traversal: note it leaves init NULL */
271 else if (TREE_CODE (TREE_TYPE (member
)) == REFERENCE_TYPE
)
272 cp_pedwarn ("uninitialized reference member `%D'", member
);
274 else if (TREE_CODE (init
) == TREE_LIST
)
276 /* There was an explicit member initialization. Do some
277 work in that case. */
278 if (TREE_CHAIN (init
))
280 warning ("initializer list treated as compound expression");
281 init
= build_compound_expr (init
);
284 init
= TREE_VALUE (init
);
288 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
291 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
295 expr
= build_component_ref (current_class_ref
, member
, NULL_TREE
,
297 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
298 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
300 if (expr
!= error_mark_node
)
301 finish_subobject (expr
);
305 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
306 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
309 build_field_list (t
, list
, uses_unions_p
)
316 /* Note whether or not T is a union. */
317 if (TREE_CODE (t
) == UNION_TYPE
)
320 for (fields
= TYPE_FIELDS (t
); fields
; fields
= TREE_CHAIN (fields
))
322 /* Skip CONST_DECLs for enumeration constants and so forth. */
323 if (TREE_CODE (fields
) != FIELD_DECL
)
326 /* Keep track of whether or not any fields are unions. */
327 if (TREE_CODE (TREE_TYPE (fields
)) == UNION_TYPE
)
330 /* For an anonymous struct or union, we must recursively
331 consider the fields of the anonymous type. They can be
332 directly initialized from the constructor. */
333 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
335 /* Add this field itself. Synthesized copy constructors
336 initialize the entire aggregate. */
337 list
= tree_cons (fields
, NULL_TREE
, list
);
338 /* And now add the fields in the anonymous aggregate. */
339 list
= build_field_list (TREE_TYPE (fields
), list
,
342 /* Add this field. */
343 else if (DECL_NAME (fields
))
344 list
= tree_cons (fields
, NULL_TREE
, list
);
350 /* The MEMBER_INIT_LIST is a TREE_LIST. The TREE_PURPOSE of each list
351 gives a FIELD_DECL in T that needs initialization. The TREE_VALUE
352 gives the initializer, or list of initializer arguments. Sort the
353 MEMBER_INIT_LIST, returning a version that contains the same
354 information but in the order that the fields should actually be
355 initialized. Perform error-checking in the process. */
358 sort_member_init (t
, member_init_list
)
360 tree member_init_list
;
367 /* Build up a list of the various fields, in sorted order. */
368 init_list
= nreverse (build_field_list (t
, NULL_TREE
, &uses_unions_p
));
370 /* Go through the explicit initializers, adding them to the
372 last_field
= init_list
;
373 for (init
= member_init_list
; init
; init
= TREE_CHAIN (init
))
376 tree initialized_field
;
378 initialized_field
= TREE_PURPOSE (init
);
379 my_friendly_assert (TREE_CODE (initialized_field
) == FIELD_DECL
,
382 /* If the explicit initializers are in sorted order, then the
383 INITIALIZED_FIELD will be for a field following the
385 for (f
= last_field
; f
; f
= TREE_CHAIN (f
))
386 if (TREE_PURPOSE (f
) == initialized_field
)
389 /* Give a warning, if appropriate. */
390 if (warn_reorder
&& !f
)
392 cp_warning_at ("member initializers for `%#D'",
393 TREE_PURPOSE (last_field
));
394 cp_warning_at (" and `%#D'", initialized_field
);
395 warning (" will be re-ordered to match declaration order");
398 /* Look again, from the beginning of the list. We must find the
399 field on this loop. */
403 while (TREE_PURPOSE (f
) != initialized_field
)
407 /* If there was already an explicit initializer for this field,
410 cp_error ("multiple initializations given for member `%D'",
414 /* Mark the field as explicitly initialized. */
415 TREE_TYPE (f
) = error_mark_node
;
416 /* And insert the initializer. */
417 TREE_VALUE (f
) = TREE_VALUE (init
);
420 /* Remember the location of the last explicitly initialized
427 If a ctor-initializer specifies more than one mem-initializer for
428 multiple members of the same union (including members of
429 anonymous unions), the ctor-initializer is ill-formed. */
432 last_field
= NULL_TREE
;
433 for (init
= init_list
; init
; init
= TREE_CHAIN (init
))
439 /* Skip uninitialized members. */
440 if (!TREE_TYPE (init
))
442 /* See if this field is a member of a union, or a member of a
443 structure contained in a union, etc. */
444 field
= TREE_PURPOSE (init
);
445 for (field_type
= DECL_CONTEXT (field
);
446 !same_type_p (field_type
, t
);
447 field_type
= TYPE_CONTEXT (field_type
))
448 if (TREE_CODE (field_type
) == UNION_TYPE
)
450 /* If this field is not a member of a union, skip it. */
451 if (TREE_CODE (field_type
) != UNION_TYPE
)
454 /* It's only an error if we have two initializers for the same
462 /* See if LAST_FIELD and the field initialized by INIT are
463 members of the same union. If so, there's a problem,
464 unless they're actually members of the same structure
465 which is itself a member of a union. For example, given:
467 union { struct { int i; int j; }; };
469 initializing both `i' and `j' makes sense. */
470 field_type
= DECL_CONTEXT (field
);
474 tree last_field_type
;
476 last_field_type
= DECL_CONTEXT (last_field
);
479 if (same_type_p (last_field_type
, field_type
))
481 if (TREE_CODE (field_type
) == UNION_TYPE
)
482 cp_error ("initializations for multiple members of `%T'",
488 if (same_type_p (last_field_type
, t
))
491 last_field_type
= TYPE_CONTEXT (last_field_type
);
494 /* If we've reached the outermost class, then we're
496 if (same_type_p (field_type
, t
))
499 field_type
= TYPE_CONTEXT (field_type
);
510 /* Like sort_member_init, but used for initializers of base classes.
511 *RBASE_PTR is filled in with the initializers for non-virtual bases;
512 vbase_ptr gets the virtual bases. */
515 sort_base_init (t
, base_init_list
, rbase_ptr
, vbase_ptr
)
518 tree
*rbase_ptr
, *vbase_ptr
;
520 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
521 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
527 /* For warn_reorder. */
529 tree last_base
= NULL_TREE
;
531 tree rbases
= NULL_TREE
;
532 tree vbases
= NULL_TREE
;
534 /* First walk through and splice out vbase and invalid initializers.
535 Also replace names with binfos. */
537 last
= tree_cons (NULL_TREE
, NULL_TREE
, base_init_list
);
538 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
540 tree basetype
= TREE_PURPOSE (x
);
541 tree binfo
= NULL_TREE
;
543 if (basetype
== NULL_TREE
)
545 /* Initializer for single base class. Must not
546 use multiple inheritance or this is ambiguous. */
547 switch (n_baseclasses
)
550 cp_error ("`%T' does not have a base class to initialize",
556 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
560 binfo
= TREE_VEC_ELT (binfos
, 0);
562 else if (is_aggr_type (basetype
, 1))
564 binfo
= binfo_or_else (basetype
, t
);
565 if (binfo
== NULL_TREE
)
568 /* Virtual base classes are special cases. Their initializers
569 are recorded with this constructor, and they are used when
570 this constructor is the top-level constructor called. */
571 if (TREE_VIA_VIRTUAL (binfo
))
573 tree v
= binfo_for_vbase (BINFO_TYPE (binfo
), t
);
574 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
579 /* Otherwise, if it is not an immediate base class, complain. */
580 for (i
= n_baseclasses
-1; i
>= 0; i
--)
581 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
585 cp_error ("`%T' is not an immediate base class of `%T'",
586 basetype
, current_class_type
);
592 my_friendly_abort (365);
594 TREE_PURPOSE (x
) = binfo
;
595 TREE_CHAIN (last
) = x
;
598 TREE_CHAIN (last
) = NULL_TREE
;
600 /* Now walk through our regular bases and make sure they're initialized. */
602 for (i
= 0; i
< n_baseclasses
; ++i
)
604 /* The base for which we're currently initializing. */
605 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
606 /* The initializer for BASE_BINFO. */
610 if (TREE_VIA_VIRTUAL (base_binfo
))
613 /* We haven't found the BASE_BINFO yet. */
615 /* Loop through all the explicitly initialized bases, looking
616 for an appropriate initializer. */
617 for (x
= base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
619 tree binfo
= TREE_PURPOSE (x
);
621 if (binfo
== base_binfo
&& !init
)
627 cp_warning_at ("base initializers for `%#T'", last_base
);
628 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
629 warning (" will be re-ordered to match inheritance order");
632 last_base
= BINFO_TYPE (binfo
);
635 /* Make sure we won't try to work on this init again. */
636 TREE_PURPOSE (x
) = NULL_TREE
;
637 init
= build_tree_list (binfo
, TREE_VALUE (x
));
639 else if (binfo
== base_binfo
)
641 cp_error ("base class `%T' already initialized",
647 /* If we didn't find BASE_BINFO in the list, create a dummy entry
648 so the two lists (RBASES and the list of bases) will be
651 init
= build_tree_list (NULL_TREE
, NULL_TREE
);
652 rbases
= chainon (rbases
, init
);
659 /* Perform whatever initializations have yet to be done on the base
660 class, and non-static data members, of the CURRENT_CLASS_TYPE.
661 These actions are given by the BASE_INIT_LIST and MEM_INIT_LIST,
664 If there is a need for a call to a constructor, we must surround
665 that call with a pushlevel/poplevel pair, since we are technically
666 at the PARM level of scope.
668 Note that emit_base_init does *not* initialize virtual base
669 classes. That is done specially, elsewhere. */
672 emit_base_init (mem_init_list
, base_init_list
)
677 tree rbase_init_list
, vbase_init_list
;
678 tree t
= current_class_type
;
679 tree t_binfo
= TYPE_BINFO (t
);
680 tree binfos
= BINFO_BASETYPES (t_binfo
);
682 int n_baseclasses
= BINFO_N_BASETYPES (t_binfo
);
684 mem_init_list
= sort_member_init (t
, mem_init_list
);
685 sort_base_init (t
, base_init_list
, &rbase_init_list
, &vbase_init_list
);
687 /* First, initialize the virtual base classes, if we are
688 constructing the most-derived object. */
689 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
691 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
692 construct_virtual_bases (t
, current_class_ref
, current_class_ptr
,
693 vbase_init_list
, first_arg
);
696 /* Now, perform initialization of non-virtual base classes. */
697 for (i
= 0; i
< n_baseclasses
; i
++)
699 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
700 tree init
= void_list_node
;
702 if (TREE_VIA_VIRTUAL (base_binfo
))
705 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
,
708 if (TREE_PURPOSE (rbase_init_list
))
709 init
= TREE_VALUE (rbase_init_list
);
710 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
714 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
))
715 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
716 BINFO_TYPE (base_binfo
));
719 if (init
!= void_list_node
)
721 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
722 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
723 build_indirect_ref (member
, NULL_PTR
), init
,
727 expand_cleanup_for_base (base_binfo
, NULL_TREE
);
728 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
731 /* Initialize the vtable pointers for the class. */
732 initialize_vtbl_ptrs (current_class_ptr
);
734 while (mem_init_list
)
740 member
= TREE_PURPOSE (mem_init_list
);
742 /* See if we had a user-specified member initialization. */
743 if (TREE_TYPE (mem_init_list
))
745 init
= TREE_VALUE (mem_init_list
);
750 init
= DECL_INITIAL (member
);
753 /* Effective C++ rule 12. */
754 if (warn_ecpp
&& init
== NULL_TREE
755 && !DECL_ARTIFICIAL (member
)
756 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
757 cp_warning ("`%D' should be initialized in the member initialization list", member
);
760 perform_member_init (member
, init
, from_init_list
);
761 mem_init_list
= TREE_CHAIN (mem_init_list
);
765 /* Returns the address of the vtable (i.e., the value that should be
766 assigned to the vptr) for BINFO. */
769 build_vtbl_address (binfo
)
774 /* Figure out what vtable BINFO's vtable is based on, and mark it as
776 vtbl
= get_vtbl_decl_for_binfo (binfo
);
777 assemble_external (vtbl
);
778 TREE_USED (vtbl
) = 1;
780 /* Now compute the address to use when initializing the vptr. */
781 vtbl
= BINFO_VTABLE (binfo
);
782 if (TREE_CODE (vtbl
) == VAR_DECL
)
784 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
785 TREE_CONSTANT (vtbl
) = 1;
791 /* This code sets up the virtual function tables appropriate for
792 the pointer DECL. It is a one-ply initialization.
794 BINFO is the exact type that DECL is supposed to be. In
795 multiple inheritance, this might mean "C's A" if C : A, B. */
798 expand_virtual_init (binfo
, decl
)
801 tree type
= BINFO_TYPE (binfo
);
803 tree vtype
, vtype_binfo
;
806 /* Compute the location of the vtable. */
807 vtype
= DECL_CONTEXT (TYPE_VFIELD (type
));
808 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
810 /* Compute the initializer for vptr. */
811 vtbl
= build_vtbl_address (binfo
);
813 /* Under the new ABI, we may get this vptr from a VTT, if this is a
814 subobject constructor or subobject destructor. */
815 vtt_index
= BINFO_VPTR_INDEX (binfo
);
821 /* Compute the value to use, when there's a VTT. */
822 vtt_parm
= DECL_VTT_PARM (current_function_decl
);
823 vtbl2
= build (PLUS_EXPR
,
824 TREE_TYPE (vtt_parm
),
827 vtbl2
= build1 (INDIRECT_REF
, TREE_TYPE (vtbl
), vtbl2
);
829 /* The actual initializer is the VTT value only in the subobject
830 constructor. In maybe_clone_body we'll substitute NULL for
831 the vtt_parm in the case of the non-subobject constructor. */
832 vtbl
= build (COND_EXPR
,
834 DECL_USE_VTT_PARM (current_function_decl
),
839 /* Compute the location of the vtpr. */
840 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
841 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
842 if (vtbl_ptr
== error_mark_node
)
845 /* Assign the vtable to the vptr. */
846 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
847 finish_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
850 /* If an exception is thrown in a constructor, those base classes already
851 constructed must be destroyed. This function creates the cleanup
852 for BINFO, which has just been constructed. If FLAG is non-NULL,
853 it is a DECL which is non-zero when this base needs to be
857 expand_cleanup_for_base (binfo
, flag
)
863 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
866 /* Call the destructor. */
867 expr
= (build_scoped_method_call
868 (current_class_ref
, binfo
, base_dtor_identifier
, NULL_TREE
));
870 expr
= fold (build (COND_EXPR
, void_type_node
,
871 truthvalue_conversion (flag
),
872 expr
, integer_zero_node
));
874 finish_subobject (expr
);
877 /* Subroutine of `expand_aggr_vbase_init'.
878 BINFO is the binfo of the type that is being initialized.
879 INIT_LIST is the list of initializers for the virtual baseclass. */
882 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
883 tree binfo
, exp
, addr
, init_list
;
885 tree init
= purpose_member (binfo
, init_list
);
886 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
889 init
= TREE_VALUE (init
);
890 /* Call constructors, but don't set up vtables. */
891 expand_aggr_init_1 (binfo
, exp
, ref
, init
, LOOKUP_COMPLAIN
);
894 /* Construct the virtual base-classes of THIS_REF (whose address is
895 THIS_PTR). The object has the indicated TYPE. The construction
896 actually takes place only if FLAG is non-zero. INIT_LIST is list
897 of initializations for constructors to perform. */
900 construct_virtual_bases (type
, this_ref
, this_ptr
, init_list
, flag
)
909 /* If there are no virtual baseclasses, we shouldn't even be here. */
910 my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type
), 19990621);
912 /* First set the pointers in our object that tell us where to find
913 our virtual baseclasses. */
914 if (!vbase_offsets_in_vtable_p ())
919 if_stmt
= begin_if_stmt ();
920 finish_if_stmt_cond (flag
, if_stmt
);
921 result
= init_vbase_pointers (type
, this_ptr
);
923 finish_expr_stmt (build_compound_expr (result
));
924 finish_then_clause (if_stmt
);
928 /* Now, run through the baseclasses, initializing each. */
929 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
930 vbases
= TREE_CHAIN (vbases
))
937 /* If there are virtual base classes with destructors, we need to
938 emit cleanups to destroy them if an exception is thrown during
939 the construction process. These exception regions (i.e., the
940 period during which the cleanups must occur) begin from the time
941 the construction is complete to the end of the function. If we
942 create a conditional block in which to initialize the
943 base-classes, then the cleanup region for the virtual base begins
944 inside a block, and ends outside of that block. This situation
945 confuses the sjlj exception-handling code. Therefore, we do not
946 create a single conditional block, but one for each
947 initialization. (That way the cleanup regions always begin
948 in the outer block.) We trust the back-end to figure out
949 that the FLAG will not change across initializations, and
950 avoid doing multiple tests. */
951 inner_if_stmt
= begin_if_stmt ();
952 finish_if_stmt_cond (flag
, inner_if_stmt
);
953 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/1);
955 /* Compute the location of the virtual base. If we're
956 constructing virtual bases, then we must be the most derived
957 class. Therefore, we don't have to look up the virtual base;
958 we already know where it is. */
959 vbase
= TREE_VALUE (vbases
);
960 exp
= build (PLUS_EXPR
,
961 TREE_TYPE (this_ptr
),
963 fold (build1 (NOP_EXPR
, TREE_TYPE (this_ptr
),
964 BINFO_OFFSET (vbase
))));
965 exp
= build1 (NOP_EXPR
,
966 build_pointer_type (BINFO_TYPE (vbase
)),
969 expand_aggr_vbase_init_1 (vbase
, this_ref
, exp
, init_list
);
970 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
971 finish_then_clause (inner_if_stmt
);
974 expand_cleanup_for_base (vbase
, flag
);
978 /* Find the context in which this FIELD can be initialized. */
981 initializing_context (field
)
984 tree t
= DECL_CONTEXT (field
);
986 /* Anonymous union members can be initialized in the first enclosing
987 non-anonymous union context. */
988 while (t
&& ANON_AGGR_TYPE_P (t
))
989 t
= TYPE_CONTEXT (t
);
993 /* Function to give error message if member initialization specification
994 is erroneous. FIELD is the member we decided to initialize.
995 TYPE is the type for which the initialization is being performed.
996 FIELD must be a member of TYPE.
998 MEMBER_NAME is the name of the member. */
1001 member_init_ok_or_else (field
, type
, member_name
)
1004 const char *member_name
;
1006 if (field
== error_mark_node
)
1008 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
1010 cp_error ("class `%T' does not have any field named `%s'", type
,
1014 if (TREE_STATIC (field
))
1016 cp_error ("field `%#D' is static; only point of initialization is its declaration",
1024 /* If NAME is a viable field name for the aggregate DECL,
1025 and PARMS is a viable parameter list, then expand an _EXPR
1026 which describes this initialization.
1028 Note that we do not need to chase through the class's base classes
1029 to look for NAME, because if it's in that list, it will be handled
1030 by the constructor for that base class.
1032 We do not yet have a fixed-point finder to instantiate types
1033 being fed to overloaded constructors. If there is a unique
1034 constructor, then argument types can be got from that one. */
1037 expand_member_init (exp
, name
, init
)
1038 tree exp
, name
, init
;
1040 tree basetype
= NULL_TREE
, field
;
1043 if (exp
== NULL_TREE
)
1046 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
1048 if (name
&& TYPE_P (name
))
1051 name
= TYPE_IDENTIFIER (name
);
1053 else if (name
&& TREE_CODE (name
) == TYPE_DECL
)
1055 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1056 name
= DECL_NAME (name
);
1059 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
1060 switch (CLASSTYPE_N_BASECLASSES (type
))
1063 error ("base class initializer specified, but no base class to initialize");
1066 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
1069 error ("initializer for unnamed base class ambiguous");
1070 cp_error ("(type `%T' uses multiple inheritance)", type
);
1074 my_friendly_assert (init
!= NULL_TREE
, 0);
1076 /* The grammar should not allow fields which have names that are
1077 TYPENAMEs. Therefore, if the field has a non-NULL TREE_TYPE, we
1078 may assume that this is an attempt to initialize a base class
1079 member of the current type. Otherwise, it is an attempt to
1080 initialize a member field. */
1082 if (init
== void_type_node
)
1085 if (name
== NULL_TREE
|| basetype
)
1087 if (name
== NULL_TREE
)
1091 name
= TYPE_IDENTIFIER (basetype
);
1094 error ("no base class to initialize");
1099 else if (basetype
!= type
1100 && ! current_template_parms
1101 && ! vec_binfo_member (basetype
,
1102 TYPE_BINFO_BASETYPES (type
))
1103 && ! binfo_for_vbase (basetype
, type
))
1105 if (IDENTIFIER_CLASS_VALUE (name
))
1107 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1108 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
1111 cp_error ("type `%T' is not an immediate basetype for `%T'",
1116 init
= build_tree_list (basetype
, init
);
1121 field
= lookup_field (type
, name
, 1, 0);
1123 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
1126 init
= build_tree_list (field
, init
);
1132 /* This is like `expand_member_init', only it stores one aggregate
1135 INIT comes in two flavors: it is either a value which
1136 is to be stored in EXP, or it is a parameter list
1137 to go to a constructor, which will operate on EXP.
1138 If INIT is not a parameter list for a constructor, then set
1139 LOOKUP_ONLYCONVERTING.
1140 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1141 the initializer, if FLAGS is 0, then it is the (init) form.
1142 If `init' is a CONSTRUCTOR, then we emit a warning message,
1143 explaining that such initializations are invalid.
1145 If INIT resolves to a CALL_EXPR which happens to return
1146 something of the type we are looking for, then we know
1147 that we can safely use that call to perform the
1150 The virtual function table pointer cannot be set up here, because
1151 we do not really know its type.
1153 Virtual baseclass pointers are also set up here.
1155 This never calls operator=().
1157 When initializing, nothing is CONST.
1159 A default copy constructor may have to be used to perform the
1162 A constructor or a conversion operator may have to be used to
1163 perform the initialization, but not both, as it would be ambiguous. */
1166 build_aggr_init (exp
, init
, flags
)
1173 tree type
= TREE_TYPE (exp
);
1174 int was_const
= TREE_READONLY (exp
);
1175 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1177 if (init
== error_mark_node
)
1178 return error_mark_node
;
1180 TREE_READONLY (exp
) = 0;
1181 TREE_THIS_VOLATILE (exp
) = 0;
1183 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1184 flags
|= LOOKUP_ONLYCONVERTING
;
1186 if (TREE_CODE (type
) == ARRAY_TYPE
)
1188 /* Must arrange to initialize each element of EXP
1189 from elements of INIT. */
1190 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1194 /* Handle bad initializers like:
1198 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1202 int main(int argc, char **argv) {
1203 COMPLEX zees(1.0, 0.0)[10];
1206 cp_error ("bad array initializer");
1207 return error_mark_node
;
1209 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
1211 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1213 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1215 stmt_expr
= build_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1216 init
&& same_type_p (TREE_TYPE (init
),
1218 TREE_READONLY (exp
) = was_const
;
1219 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1220 TREE_TYPE (exp
) = type
;
1222 TREE_TYPE (init
) = itype
;
1226 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1227 /* just know that we've seen something for this node */
1228 TREE_USED (exp
) = 1;
1230 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1231 begin_init_stmts (&stmt_expr
, &compound_stmt
);
1232 destroy_temps
= stmts_are_full_exprs_p ();
1233 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1234 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1235 init
, LOOKUP_NORMAL
|flags
);
1236 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
1237 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1238 TREE_TYPE (exp
) = type
;
1239 TREE_READONLY (exp
) = was_const
;
1240 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1246 expand_default_init (binfo
, true_exp
, exp
, init
, flags
)
1252 tree type
= TREE_TYPE (exp
);
1255 /* It fails because there may not be a constructor which takes
1256 its own type as the first (or only parameter), but which does
1257 take other types via a conversion. So, if the thing initializing
1258 the expression is a unit element of type X, first try X(X&),
1259 followed by initialization by X. If neither of these work
1260 out, then look hard. */
1264 if (init
&& TREE_CODE (init
) != TREE_LIST
1265 && (flags
& LOOKUP_ONLYCONVERTING
))
1267 /* Base subobjects should only get direct-initialization. */
1268 if (true_exp
!= exp
)
1271 if (flags
& DIRECT_BIND
)
1272 /* Do nothing. We hit this in two cases: Reference initialization,
1273 where we aren't initializing a real variable, so we don't want
1274 to run a new constructor; and catching an exception, where we
1275 have already built up the constructor call so we could wrap it
1276 in an exception region. */;
1277 else if (TREE_CODE (init
) == CONSTRUCTOR
)
1278 /* A brace-enclosed initializer has whatever type is
1279 required. There's no need to convert it. */
1282 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1284 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1285 /* We need to protect the initialization of a catch parm
1286 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1287 around the TARGET_EXPR for the copy constructor. See
1288 expand_start_catch_block. */
1289 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1290 TREE_OPERAND (init
, 0));
1292 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1293 TREE_SIDE_EFFECTS (init
) = 1;
1294 finish_expr_stmt (init
);
1298 if (init
== NULL_TREE
1299 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1303 init
= TREE_VALUE (parms
);
1306 parms
= build_tree_list (NULL_TREE
, init
);
1308 if (true_exp
== exp
)
1309 ctor_name
= complete_ctor_identifier
;
1311 ctor_name
= base_ctor_identifier
;
1313 rval
= build_method_call (exp
, ctor_name
, parms
, binfo
, flags
);
1314 if (TREE_SIDE_EFFECTS (rval
))
1316 if (building_stmt_tree ())
1317 finish_expr_stmt (rval
);
1319 genrtl_expr_stmt (rval
);
1323 /* This function is responsible for initializing EXP with INIT
1326 BINFO is the binfo of the type for who we are performing the
1327 initialization. For example, if W is a virtual base class of A and B,
1329 If we are initializing B, then W must contain B's W vtable, whereas
1330 were we initializing C, W must contain C's W vtable.
1332 TRUE_EXP is nonzero if it is the true expression being initialized.
1333 In this case, it may be EXP, or may just contain EXP. The reason we
1334 need this is because if EXP is a base element of TRUE_EXP, we
1335 don't necessarily know by looking at EXP where its virtual
1336 baseclass fields should really be pointing. But we do know
1337 from TRUE_EXP. In constructors, we don't know anything about
1338 the value being initialized.
1340 FLAGS is just passes to `build_method_call'. See that function for
1344 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, flags
)
1350 tree type
= TREE_TYPE (exp
);
1352 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1354 /* Use a function returning the desired type to initialize EXP for us.
1355 If the function is a constructor, and its first argument is
1356 NULL_TREE, know that it was meant for us--just slide exp on
1357 in and expand the constructor. Constructors now come
1360 if (init
&& TREE_CODE (exp
) == VAR_DECL
1361 && TREE_CODE (init
) == CONSTRUCTOR
1362 && TREE_HAS_CONSTRUCTOR (init
))
1364 /* If store_init_value returns NULL_TREE, the INIT has been
1365 record in the DECL_INITIAL for EXP. That means there's
1366 nothing more we have to do. */
1367 if (!store_init_value (exp
, init
))
1369 if (!building_stmt_tree ())
1370 expand_decl_init (exp
);
1373 finish_expr_stmt (build (INIT_EXPR
, type
, exp
, init
));
1377 /* We know that expand_default_init can handle everything we want
1379 expand_default_init (binfo
, true_exp
, exp
, init
, flags
);
1382 /* Report an error if TYPE is not a user-defined, aggregate type. If
1383 OR_ELSE is nonzero, give an error message. */
1386 is_aggr_type (type
, or_else
)
1390 if (type
== error_mark_node
)
1393 if (! IS_AGGR_TYPE (type
)
1394 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1395 && TREE_CODE (type
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
1398 cp_error ("`%T' is not an aggregate type", type
);
1404 /* Like is_aggr_typedef, but returns typedef if successful. */
1407 get_aggr_from_typedef (name
, or_else
)
1413 if (name
== error_mark_node
)
1416 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1417 type
= IDENTIFIER_TYPE_VALUE (name
);
1421 cp_error ("`%T' fails to be an aggregate typedef", name
);
1425 if (! IS_AGGR_TYPE (type
)
1426 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1427 && TREE_CODE (type
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
1430 cp_error ("type `%T' is of non-aggregate type", type
);
1437 get_type_value (name
)
1440 if (name
== error_mark_node
)
1443 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1444 return IDENTIFIER_TYPE_VALUE (name
);
1450 /* This code could just as well go in `class.c', but is placed here for
1453 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1454 the appropriate function call. */
1457 build_member_call (type
, name
, parmlist
)
1458 tree type
, name
, parmlist
;
1463 tree basetype_path
, decl
;
1465 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
1466 && TREE_CODE (type
) == NAMESPACE_DECL
)
1468 /* 'name' already refers to the decls from the namespace, since we
1469 hit do_identifier for template_ids. */
1470 method_name
= TREE_OPERAND (name
, 0);
1471 /* FIXME: Since we don't do independent names right yet, the
1472 name might also be a LOOKUP_EXPR. Once we resolve this to a
1473 real decl earlier, this can go. This may happen during
1475 if (TREE_CODE (method_name
) == LOOKUP_EXPR
)
1477 method_name
= lookup_namespace_name
1478 (type
, TREE_OPERAND (method_name
, 0));
1479 TREE_OPERAND (name
, 0) = method_name
;
1481 my_friendly_assert (is_overloaded_fn (method_name
), 980519);
1482 return build_x_function_call (name
, parmlist
, current_class_ref
);
1486 name
= DECL_NAME (name
);
1488 if (type
== std_node
)
1489 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1491 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1492 return build_x_function_call (lookup_namespace_name (type
, name
),
1493 parmlist
, current_class_ref
);
1495 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1497 method_name
= TREE_OPERAND (name
, 0);
1498 if (TREE_CODE (method_name
) == COMPONENT_REF
)
1499 method_name
= TREE_OPERAND (method_name
, 1);
1500 if (is_overloaded_fn (method_name
))
1501 method_name
= DECL_NAME (OVL_CURRENT (method_name
));
1502 TREE_OPERAND (name
, 0) = method_name
;
1507 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1509 method_name
= TREE_OPERAND (method_name
, 0);
1513 /* This shouldn't be here, and build_member_call shouldn't appear in
1515 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1516 && get_aggr_from_typedef (type
, 0) == 0)
1518 tree ns
= lookup_name (type
, 0);
1519 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1521 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1525 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1526 return error_mark_node
;
1528 /* An operator we did not like. */
1529 if (name
== NULL_TREE
)
1530 return error_mark_node
;
1534 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1536 return error_mark_node
;
1539 decl
= maybe_dummy_object (type
, &basetype_path
);
1541 /* Convert 'this' to the specified type to disambiguate conversion
1542 to the function's context. Apparently Standard C++ says that we
1543 shouldn't do this. */
1544 if (decl
== current_class_ref
1546 && ACCESSIBLY_UNIQUELY_DERIVED_P (type
, current_class_type
))
1548 tree olddecl
= current_class_ptr
;
1549 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1550 if (oldtype
!= type
)
1552 tree newtype
= build_qualified_type (type
, TYPE_QUALS (oldtype
));
1553 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1554 decl
= build_indirect_ref (decl
, NULL_PTR
);
1558 if (method_name
== constructor_name (type
)
1559 || method_name
== constructor_name_full (type
))
1560 return build_functional_cast (type
, parmlist
);
1561 if (lookup_fnfields (basetype_path
, method_name
, 0))
1562 return build_method_call (decl
,
1563 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1564 ? name
: method_name
,
1565 parmlist
, basetype_path
,
1566 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1567 if (TREE_CODE (name
) == IDENTIFIER_NODE
1568 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1570 if (t
== error_mark_node
)
1571 return error_mark_node
;
1572 if (TREE_CODE (t
) == FIELD_DECL
)
1574 if (is_dummy_object (decl
))
1576 cp_error ("invalid use of non-static field `%D'", t
);
1577 return error_mark_node
;
1579 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1581 else if (TREE_CODE (t
) == VAR_DECL
)
1585 cp_error ("invalid use of member `%D'", t
);
1586 return error_mark_node
;
1588 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1589 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1590 parmlist
, NULL_TREE
);
1591 return build_function_call (decl
, parmlist
);
1595 cp_error ("no method `%T::%D'", type
, name
);
1596 return error_mark_node
;
1600 /* Build a reference to a member of an aggregate. This is not a
1601 C++ `&', but really something which can have its address taken,
1602 and then act as a pointer to member, for example TYPE :: FIELD
1603 can have its address taken by saying & TYPE :: FIELD.
1605 @@ Prints out lousy diagnostics for operator <typename>
1608 @@ This function should be rewritten and placed in search.c. */
1611 build_offset_ref (type
, name
)
1614 tree decl
, t
= error_mark_node
;
1616 tree basebinfo
= NULL_TREE
;
1617 tree orig_name
= name
;
1619 /* class templates can come in as TEMPLATE_DECLs here. */
1620 if (TREE_CODE (name
) == TEMPLATE_DECL
)
1623 if (type
== std_node
)
1624 return do_scoped_id (name
, 0);
1626 if (processing_template_decl
|| uses_template_parms (type
))
1627 return build_min_nt (SCOPE_REF
, type
, name
);
1629 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1631 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1632 something like `a.template f<int>' or the like. For the most
1633 part, we treat this just like a.f. We do remember, however,
1634 the template-id that was used. */
1635 name
= TREE_OPERAND (orig_name
, 0);
1638 name
= DECL_NAME (name
);
1641 if (TREE_CODE (name
) == LOOKUP_EXPR
)
1642 /* This can happen during tsubst'ing. */
1643 name
= TREE_OPERAND (name
, 0);
1646 if (TREE_CODE (name
) == COMPONENT_REF
)
1647 name
= TREE_OPERAND (name
, 1);
1648 if (TREE_CODE (name
) == OVERLOAD
)
1649 name
= DECL_NAME (OVL_CURRENT (name
));
1653 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
1656 if (type
== NULL_TREE
)
1657 return error_mark_node
;
1659 /* Handle namespace names fully here. */
1660 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1662 t
= lookup_namespace_name (type
, name
);
1663 if (t
== error_mark_node
)
1665 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1666 /* Reconstruct the TEMPLATE_ID_EXPR. */
1667 t
= build (TEMPLATE_ID_EXPR
, TREE_TYPE (t
),
1668 t
, TREE_OPERAND (orig_name
, 1));
1669 if (! type_unknown_p (t
))
1672 t
= convert_from_reference (t
);
1677 if (! is_aggr_type (type
, 1))
1678 return error_mark_node
;
1680 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1682 if (! check_dtor_name (type
, name
))
1683 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1684 type
, TREE_OPERAND (name
, 0));
1685 name
= dtor_identifier
;
1688 if (!COMPLETE_TYPE_P (complete_type (type
))
1689 && !TYPE_BEING_DEFINED (type
))
1691 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1693 return error_mark_node
;
1696 decl
= maybe_dummy_object (type
, &basebinfo
);
1698 member
= lookup_member (basebinfo
, name
, 1, 0);
1700 if (member
== error_mark_node
)
1701 return error_mark_node
;
1703 /* A lot of this logic is now handled in lookup_member. */
1704 if (member
&& BASELINK_P (member
))
1706 /* Go from the TREE_BASELINK to the member function info. */
1707 tree fnfields
= member
;
1708 t
= TREE_VALUE (fnfields
);
1710 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1712 /* The FNFIELDS are going to contain functions that aren't
1713 necessarily templates, and templates that don't
1714 necessarily match the explicit template parameters. We
1715 save all the functions, and the explicit parameters, and
1716 then figure out exactly what to instantiate with what
1717 arguments in instantiate_type. */
1719 if (TREE_CODE (t
) != OVERLOAD
)
1720 /* The code in instantiate_type which will process this
1721 expects to encounter OVERLOADs, not raw functions. */
1722 t
= ovl_cons (t
, NULL_TREE
);
1724 t
= build (TEMPLATE_ID_EXPR
, TREE_TYPE (t
), t
,
1725 TREE_OPERAND (orig_name
, 1));
1726 t
= build (OFFSET_REF
, unknown_type_node
, decl
, t
);
1728 PTRMEM_OK_P (t
) = 1;
1733 if (!really_overloaded_fn (t
))
1735 /* Get rid of a potential OVERLOAD around it */
1736 t
= OVL_CURRENT (t
);
1738 /* unique functions are handled easily. */
1739 if (!enforce_access (basebinfo
, t
))
1740 return error_mark_node
;
1742 if (DECL_STATIC_FUNCTION_P (t
))
1744 t
= build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1745 PTRMEM_OK_P (t
) = 1;
1749 TREE_TYPE (fnfields
) = unknown_type_node
;
1751 t
= build (OFFSET_REF
, unknown_type_node
, decl
, fnfields
);
1752 PTRMEM_OK_P (t
) = 1;
1760 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1761 return error_mark_node
;
1764 if (TREE_CODE (t
) == TYPE_DECL
)
1769 /* static class members and class-specific enum
1770 values can be returned without further ado. */
1771 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1774 return convert_from_reference (t
);
1777 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_C_BIT_FIELD (t
))
1779 cp_error ("illegal pointer to bit field `%D'", t
);
1780 return error_mark_node
;
1783 /* static class functions too. */
1784 if (TREE_CODE (t
) == FUNCTION_DECL
1785 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1786 my_friendly_abort (53);
1788 /* In member functions, the form `type::name' is no longer
1789 equivalent to `this->type::name', at least not until
1790 resolve_offset_ref. */
1791 t
= build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1792 PTRMEM_OK_P (t
) = 1;
1796 /* If a OFFSET_REF made it through to here, then it did
1797 not have its address taken. */
1800 resolve_offset_ref (exp
)
1803 tree type
= TREE_TYPE (exp
);
1804 tree base
= NULL_TREE
;
1806 tree basetype
, addr
;
1808 if (TREE_CODE (exp
) == OFFSET_REF
)
1810 member
= TREE_OPERAND (exp
, 1);
1811 base
= TREE_OPERAND (exp
, 0);
1815 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1816 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1818 error ("object missing in use of pointer-to-member construct");
1819 return error_mark_node
;
1822 type
= TREE_TYPE (type
);
1823 base
= current_class_ref
;
1826 if (BASELINK_P (member
) || TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
1827 return build_unary_op (ADDR_EXPR
, exp
, 0);
1829 if (TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1831 if (!flag_ms_extensions
)
1832 /* A single non-static member, make sure we don't allow a
1833 pointer-to-member. */
1834 exp
= ovl_cons (member
, NULL_TREE
);
1836 return build_unary_op (ADDR_EXPR
, exp
, 0);
1839 if ((TREE_CODE (member
) == VAR_DECL
1840 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
))
1841 && ! TYPE_PTRMEM_P (TREE_TYPE (member
)))
1842 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
)
1844 /* These were static members. */
1845 if (mark_addressable (member
) == 0)
1846 return error_mark_node
;
1850 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1851 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1854 /* Syntax error can cause a member which should
1855 have been seen as static to be grok'd as non-static. */
1856 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1858 cp_error_at ("member `%D' is non-static but referenced as a static member",
1860 error ("at this point in file");
1861 return error_mark_node
;
1864 /* The first case is really just a reference to a member of `this'. */
1865 if (TREE_CODE (member
) == FIELD_DECL
1866 && (base
== current_class_ref
|| is_dummy_object (base
)))
1870 basetype
= DECL_CONTEXT (member
);
1872 /* Try to get to basetype from 'this'; if that doesn't work,
1874 base
= current_class_ref
;
1876 /* First convert to the intermediate base specified, if appropriate. */
1877 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1878 base
= build_scoped_ref (base
, TYPE_OFFSET_BASETYPE (type
));
1880 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1881 addr
= convert_pointer_to (basetype
, addr
);
1883 if (addr
== error_mark_node
)
1884 return error_mark_node
;
1886 expr
= build (COMPONENT_REF
, TREE_TYPE (member
),
1887 build_indirect_ref (addr
, NULL_PTR
), member
);
1888 return convert_from_reference (expr
);
1891 /* Ensure that we have an object. */
1892 if (is_dummy_object (base
))
1893 addr
= error_mark_node
;
1895 /* If this is a reference to a member function, then return the
1896 address of the member function (which may involve going
1897 through the object's vtable), otherwise, return an expression
1898 for the dereferenced pointer-to-member construct. */
1899 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1901 if (TYPE_PTRMEM_P (TREE_TYPE (member
)))
1903 if (addr
== error_mark_node
)
1905 cp_error ("object missing in `%E'", exp
);
1906 return error_mark_node
;
1909 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member
)));
1910 addr
= convert_pointer_to (basetype
, addr
);
1911 member
= cp_convert (ptrdiff_type_node
, member
);
1914 /* Pointer to data members are offset by one, so that a null
1915 pointer with a real value of 0 is distinguishable from an
1916 offset of the first member of a structure. */
1917 member
= cp_build_binary_op (MINUS_EXPR
, member
,
1918 cp_convert (ptrdiff_type_node
,
1921 return build1 (INDIRECT_REF
, type
,
1922 build (PLUS_EXPR
, build_pointer_type (type
),
1925 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1927 return get_member_function_from_ptrfunc (&addr
, member
);
1929 my_friendly_abort (56);
1934 /* If DECL is a `const' declaration, and its value is a known
1935 constant, then return that value. */
1938 decl_constant_value (decl
)
1941 if (TREE_READONLY_DECL_P (decl
)
1942 && ! TREE_THIS_VOLATILE (decl
)
1943 && DECL_INITIAL (decl
)
1944 && DECL_INITIAL (decl
) != error_mark_node
1945 /* This is invalid if initial value is not constant.
1946 If it has either a function call, a memory reference,
1947 or a variable, then re-evaluating it could give different results. */
1948 && TREE_CONSTANT (DECL_INITIAL (decl
))
1949 /* Check for cases where this is sub-optimal, even though valid. */
1950 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1951 return DECL_INITIAL (decl
);
1955 /* Common subroutines of build_new and build_vec_delete. */
1957 /* Call the global __builtin_delete to delete ADDR. */
1960 build_builtin_delete_call (addr
)
1963 mark_used (global_delete_fndecl
);
1964 return build_call (global_delete_fndecl
, build_tree_list (NULL_TREE
, addr
));
1967 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1968 (which needs to go through some sort of groktypename) or it
1969 is the name of the class we are newing. INIT is an initialization value.
1970 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1971 If INIT is void_type_node, it means do *not* call a constructor
1974 For types with constructors, the data returned is initialized
1975 by the appropriate constructor.
1977 Whether the type has a constructor or not, if it has a pointer
1978 to a virtual function table, then that pointer is set up
1981 Unless I am mistaken, a call to new () will return initialized
1982 data regardless of whether the constructor itself is private or
1983 not. NOPE; new fails if the constructor is private (jcm).
1985 Note that build_new does nothing to assure that any special
1986 alignment requirements of the type are met. Rather, it leaves
1987 it up to malloc to do the right thing. Otherwise, folding to
1988 the right alignment cal cause problems if the user tries to later
1989 free the memory returned by `new'.
1991 PLACEMENT is the `placement' list for user-defined operator new (). */
1994 build_new (placement
, decl
, init
, use_global_new
)
2000 tree nelts
= NULL_TREE
, t
;
2003 if (decl
== error_mark_node
)
2004 return error_mark_node
;
2006 if (TREE_CODE (decl
) == TREE_LIST
)
2008 tree absdcl
= TREE_VALUE (decl
);
2009 tree last_absdcl
= NULL_TREE
;
2011 if (current_function_decl
2012 && DECL_CONSTRUCTOR_P (current_function_decl
))
2013 my_friendly_assert (immediate_size_expand
== 0, 19990926);
2015 nelts
= integer_one_node
;
2017 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
2018 my_friendly_abort (215);
2019 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2021 last_absdcl
= absdcl
;
2022 absdcl
= TREE_OPERAND (absdcl
, 0);
2025 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2027 /* probably meant to be a vec new */
2030 while (TREE_OPERAND (absdcl
, 0)
2031 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2033 last_absdcl
= absdcl
;
2034 absdcl
= TREE_OPERAND (absdcl
, 0);
2038 this_nelts
= TREE_OPERAND (absdcl
, 1);
2039 if (this_nelts
!= error_mark_node
)
2041 if (this_nelts
== NULL_TREE
)
2042 error ("new of array type fails to specify size");
2043 else if (processing_template_decl
)
2046 absdcl
= TREE_OPERAND (absdcl
, 0);
2050 int flags
= pedantic
? WANT_INT
: (WANT_INT
| WANT_ENUM
);
2051 if (build_expr_type_conversion (flags
, this_nelts
, 0)
2053 pedwarn ("size in array new must have integral type");
2055 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2056 absdcl
= TREE_OPERAND (absdcl
, 0);
2057 if (this_nelts
== integer_zero_node
)
2059 warning ("zero size array reserves no space");
2060 nelts
= integer_zero_node
;
2063 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2067 nelts
= integer_zero_node
;
2071 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2073 TREE_VALUE (decl
) = absdcl
;
2075 type
= groktypename (decl
);
2076 if (! type
|| type
== error_mark_node
)
2077 return error_mark_node
;
2079 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2081 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2083 /* An aggregate type. */
2084 type
= IDENTIFIER_TYPE_VALUE (decl
);
2085 decl
= TYPE_MAIN_DECL (type
);
2089 /* A builtin type. */
2090 decl
= lookup_name (decl
, 1);
2091 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2092 type
= TREE_TYPE (decl
);
2095 else if (TREE_CODE (decl
) == TYPE_DECL
)
2097 type
= TREE_TYPE (decl
);
2102 decl
= TYPE_MAIN_DECL (type
);
2105 if (processing_template_decl
)
2108 t
= tree_cons (tree_cons (NULL_TREE
, type
, NULL_TREE
),
2109 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2114 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2115 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2119 /* ``A reference cannot be created by the new operator. A reference
2120 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2121 returned by new.'' ARM 5.3.3 */
2122 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2124 error ("new cannot be applied to a reference type");
2125 type
= TREE_TYPE (type
);
2128 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2130 error ("new cannot be applied to a function type");
2131 return error_mark_node
;
2134 /* When the object being created is an array, the new-expression yields a
2135 pointer to the initial element (if any) of the array. For example,
2136 both new int and new int[10] return an int*. 5.3.4. */
2137 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2139 nelts
= array_type_nelts_top (type
);
2141 type
= TREE_TYPE (type
);
2145 t
= build_nt (ARRAY_REF
, type
, nelts
);
2149 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2150 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2151 TREE_SIDE_EFFECTS (rval
) = 1;
2152 rval
= build_new_1 (rval
);
2153 if (rval
== error_mark_node
)
2154 return error_mark_node
;
2156 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2157 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2158 TREE_NO_UNUSED_WARNING (rval
) = 1;
2163 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2166 build_java_class_ref (type
)
2169 tree name
, class_decl
;
2170 static tree CL_prefix
= NULL_TREE
;
2171 if (CL_prefix
== NULL_TREE
)
2172 CL_prefix
= get_identifier("_CL_");
2173 if (jclass_node
== NULL_TREE
)
2175 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier("jclass"));
2176 if (jclass_node
== NULL_TREE
)
2177 fatal("call to Java constructor, while `jclass' undefined");
2178 jclass_node
= TREE_TYPE (jclass_node
);
2180 name
= build_overload_with_type (CL_prefix
, type
);
2181 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2182 if (class_decl
== NULL_TREE
)
2184 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2185 TREE_STATIC (class_decl
) = 1;
2186 DECL_EXTERNAL (class_decl
) = 1;
2187 TREE_PUBLIC (class_decl
) = 1;
2188 DECL_ARTIFICIAL (class_decl
) = 1;
2189 DECL_IGNORED_P (class_decl
) = 1;
2190 pushdecl_top_level (class_decl
);
2191 make_decl_rtl (class_decl
, NULL_PTR
, 1);
2196 /* Returns teh size of the cookie to use when allocating an array
2197 whose elements have the indicated TYPE. Assumes that it is already
2198 known that a cookie is needed. */
2201 get_cookie_size (type
)
2208 /* Under the new ABI, we need to allocate an additional max
2209 (sizeof (size_t), alignof (true_type)) bytes. */
2213 sizetype_size
= size_in_bytes (sizetype
);
2214 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
2215 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
2216 cookie_size
= sizetype_size
;
2218 cookie_size
= type_align
;
2222 if (TYPE_ALIGN (type
) > TYPE_ALIGN (BI_header_type
))
2223 return size_int (TYPE_ALIGN_UNIT (type
));
2225 return size_in_bytes (BI_header_type
);
2231 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2232 value is immediately handed to expand_expr. */
2238 tree placement
, init
;
2239 tree type
, true_type
, size
, rval
;
2240 tree nelts
= NULL_TREE
;
2241 tree alloc_expr
, alloc_node
= NULL_TREE
;
2243 enum tree_code code
;
2244 int use_cookie
, nothrow
, check_new
;
2245 /* Nonzero if the user wrote `::new' rather than just `new'. */
2246 int globally_qualified_p
;
2247 /* Nonzero if we're going to call a global operator new, rather than
2248 a class-specific version. */
2250 int use_java_new
= 0;
2251 /* If non-NULL, the number of extra bytes to allocate at the
2252 beginning of the storage allocated for an array-new expression in
2253 order to store the number of elements. */
2254 tree cookie_size
= NULL_TREE
;
2256 placement
= TREE_OPERAND (exp
, 0);
2257 type
= TREE_OPERAND (exp
, 1);
2258 init
= TREE_OPERAND (exp
, 2);
2259 globally_qualified_p
= NEW_EXPR_USE_GLOBAL (exp
);
2261 if (TREE_CODE (type
) == ARRAY_REF
)
2264 nelts
= TREE_OPERAND (type
, 1);
2265 type
= TREE_OPERAND (type
, 0);
2269 code
= has_array
? VEC_NEW_EXPR
: NEW_EXPR
;
2271 if (CP_TYPE_QUALS (type
))
2272 type
= TYPE_MAIN_VARIANT (type
);
2274 /* If our base type is an array, then make sure we know how many elements
2276 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2278 tree this_nelts
= array_type_nelts_top (true_type
);
2279 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2280 true_type
= TREE_TYPE (true_type
);
2283 if (!complete_type_or_else (true_type
, exp
))
2284 return error_mark_node
;
2287 size
= fold (cp_build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2290 size
= size_in_bytes (type
);
2292 if (TREE_CODE (true_type
) == VOID_TYPE
)
2294 error ("invalid type `void' for new");
2295 return error_mark_node
;
2298 if (abstract_virtuals_error (NULL_TREE
, true_type
))
2299 return error_mark_node
;
2301 /* Figure out whether or not we're going to use the global operator
2303 if (!globally_qualified_p
2304 && IS_AGGR_TYPE (true_type
)
2305 && ((!has_array
&& TYPE_HAS_NEW_OPERATOR (true_type
))
2306 || (has_array
&& TYPE_HAS_ARRAY_NEW_OPERATOR (true_type
))))
2311 /* We only need cookies for arrays containing types for which we
2313 if (!has_array
|| !TYPE_VEC_NEW_USES_COOKIE (true_type
))
2315 /* When using placement new, users may not realize that they need
2316 the extra storage. Under the old ABI, we don't allocate the
2317 cookie whenever they use one placement argument of type `void
2318 *'. Under the new ABI, we require that the operator called be
2319 the global placement operator delete[]. */
2320 else if (placement
&& !TREE_CHAIN (placement
)
2321 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2323 use_cookie
= (!flag_new_abi
|| !use_global_new
);
2324 /* Otherwise, we need the cookie. */
2328 /* Compute the number of extra bytes to allocate, now that we know
2329 whether or not we need the cookie. */
2332 cookie_size
= get_cookie_size (true_type
);
2333 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
2336 if (has_array
&& init
&& pedantic
)
2337 cp_pedwarn ("initialization in array new");
2339 /* Allocate the object. */
2341 if (! placement
&& TYPE_FOR_JAVA (true_type
))
2343 tree class_addr
, alloc_decl
;
2344 tree class_decl
= build_java_class_ref (true_type
);
2345 tree class_size
= size_in_bytes (true_type
);
2346 static char alloc_name
[] = "_Jv_AllocObject";
2348 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2349 if (alloc_decl
== NULL_TREE
)
2350 fatal("call to Java constructor, while `%s' undefined", alloc_name
);
2351 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2352 rval
= build_function_call (alloc_decl
,
2353 tree_cons (NULL_TREE
, class_addr
,
2354 build_tree_list (NULL_TREE
,
2356 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2363 args
= tree_cons (NULL_TREE
, size
, placement
);
2364 fnname
= ansi_opname (code
);
2367 rval
= (build_new_function_call
2368 (lookup_function_nonclass (fnname
, args
),
2371 rval
= build_method_call (build_dummy_object (true_type
),
2372 fnname
, args
, NULL_TREE
,
2374 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2377 if (rval
== error_mark_node
)
2378 return error_mark_node
;
2380 /* unless an allocation function is declared with an empty excep-
2381 tion-specification (_except.spec_), throw(), it indicates failure to
2382 allocate storage by throwing a bad_alloc exception (clause _except_,
2383 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2384 cation function is declared with an empty exception-specification,
2385 throw(), it returns null to indicate failure to allocate storage and a
2386 non-null pointer otherwise.
2388 So check for a null exception spec on the op new we just called. */
2393 /* The CALL_EXPR. */
2394 tree t
= TREE_OPERAND (rval
, 0);
2396 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
2397 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (t
));
2399 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2401 if ((check_new
|| flag_exceptions
) && rval
)
2403 alloc_expr
= get_target_expr (rval
);
2404 alloc_node
= rval
= TREE_OPERAND (alloc_expr
, 0);
2407 alloc_expr
= NULL_TREE
;
2409 /* if rval is NULL_TREE I don't have to allocate it, but are we
2410 totally sure we have some extra bytes in that case for the
2411 cookies? And how does that interact with the code below? (mrs) */
2412 /* Finish up some magic for new'ed arrays */
2413 if (use_cookie
&& rval
!= NULL_TREE
)
2416 rval
= convert (string_type_node
, rval
); /* for ptr arithmetic */
2417 rval
= save_expr (cp_build_binary_op (PLUS_EXPR
, rval
, cookie_size
));
2418 /* Store the number of bytes allocated so that we can know how
2419 many elements to destroy later. */
2422 /* Under the new ABI, we use the last sizeof (size_t) bytes
2423 to store the number of elements. */
2424 cookie
= build_indirect_ref (build (MINUS_EXPR
,
2425 build_pointer_type (sizetype
),
2427 size_in_bytes (sizetype
)),
2429 exp1
= build (MODIFY_EXPR
, void_type_node
, cookie
, nelts
);
2434 = build_indirect_ref (build (MINUS_EXPR
,
2435 build_pointer_type (BI_header_type
),
2436 rval
, cookie_size
), NULL_PTR
);
2437 exp1
= build (MODIFY_EXPR
, void_type_node
,
2438 build_component_ref (cookie
, nelts_identifier
,
2443 /* Build `(cookie = nelts, rval)' and use that as the complete
2445 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2446 rval
= build_compound_expr
2447 (tree_cons (NULL_TREE
, exp1
,
2448 build_tree_list (NULL_TREE
, rval
)));
2451 if (rval
== error_mark_node
)
2452 return error_mark_node
;
2454 /* Don't call any constructors or do any initialization. */
2455 if (init
== void_type_node
)
2458 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2460 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2461 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2463 /* We are processing something like `new int (10)', which
2464 means allocate an int, and initialize it with 10. */
2468 /* At present RVAL is a temporary variable, created to hold
2469 the value from the call to `operator new'. We transform
2470 it to (*RVAL = INIT, RVAL). */
2471 rval
= save_expr (rval
);
2472 deref
= build_indirect_ref (rval
, NULL_PTR
);
2474 /* Even for something like `new const int (10)' we must
2475 allow the expression to be non-const while we do the
2477 deref_type
= TREE_TYPE (deref
);
2478 if (CP_TYPE_CONST_P (deref_type
))
2480 = cp_build_qualified_type (deref_type
,
2481 CP_TYPE_QUALS (deref_type
)
2482 & ~TYPE_QUAL_CONST
);
2483 TREE_READONLY (deref
) = 0;
2485 if (TREE_CHAIN (init
) != NULL_TREE
)
2486 pedwarn ("initializer list being treated as compound expression");
2487 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2489 pedwarn ("initializer list appears where operand should be used");
2490 init
= TREE_OPERAND (init
, 1);
2492 init
= build_compound_expr (init
);
2494 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2495 "new", NULL_TREE
, 0);
2496 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2497 build_modify_expr (deref
, NOP_EXPR
, init
),
2499 TREE_NO_UNUSED_WARNING (rval
) = 1;
2500 TREE_SIDE_EFFECTS (rval
) = 1;
2502 else if (! has_array
)
2505 /* Constructors are never virtual. If it has an initialization, we
2506 need to complain if we aren't allowed to use the ctor that took
2508 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2510 rval
= save_expr (rval
);
2513 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2514 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2516 newrval
= build_method_call (newrval
,
2517 complete_ctor_identifier
,
2518 init
, TYPE_BINFO (true_type
), flags
);
2520 if (newrval
== NULL_TREE
|| newrval
== error_mark_node
)
2521 return error_mark_node
;
2523 newrval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), newrval
, rval
);
2525 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2528 rval
= (build_vec_init
2531 cp_build_binary_op (MINUS_EXPR
, nelts
, integer_one_node
),
2535 /* If any part of the object initialization terminates by throwing an
2536 exception and a suitable deallocation function can be found, the
2537 deallocation function is called to free the memory in which the
2538 object was being constructed, after which the exception continues
2539 to propagate in the context of the new-expression. If no
2540 unambiguous matching deallocation function can be found,
2541 propagating the exception does not cause the object's memory to be
2543 if (flag_exceptions
&& alloc_expr
&& ! use_java_new
)
2545 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2546 tree cleanup
, fn
= NULL_TREE
;
2547 int flags
= (LOOKUP_NORMAL
2548 | (globally_qualified_p
* LOOKUP_GLOBAL
));
2550 /* The Standard is unclear here, but the right thing to do
2551 is to use the same method for finding deallocation
2552 functions that we use for finding allocation functions. */
2553 flags
|= LOOKUP_SPECULATIVELY
;
2555 /* We expect alloc_expr to look like a TARGET_EXPR around
2556 a NOP_EXPR around the CALL_EXPR we want. */
2557 fn
= TREE_OPERAND (alloc_expr
, 1);
2558 fn
= TREE_OPERAND (fn
, 0);
2560 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
, fn
);
2562 /* Ack! First we allocate the memory. Then we set our sentry
2563 variable to true, and expand a cleanup that deletes the memory
2564 if sentry is true. Then we run the constructor and store the
2565 returned pointer in buf. Then we clear sentry and return buf. */
2569 tree end
, sentry
, begin
, buf
, t
= TREE_TYPE (rval
);
2571 begin
= get_target_expr (boolean_true_node
);
2572 sentry
= TREE_OPERAND (begin
, 0);
2574 TREE_OPERAND (begin
, 2)
2575 = build (COND_EXPR
, void_type_node
, sentry
,
2576 cleanup
, void_zero_node
);
2578 rval
= get_target_expr (rval
);
2580 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2581 sentry
, boolean_false_node
);
2583 buf
= TREE_OPERAND (rval
, 0);
2585 rval
= build (COMPOUND_EXPR
, t
, begin
,
2586 build (COMPOUND_EXPR
, t
, rval
,
2587 build (COMPOUND_EXPR
, t
, end
, buf
)));
2591 else if (CP_TYPE_CONST_P (true_type
))
2592 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2596 if (alloc_expr
&& rval
== alloc_node
)
2598 rval
= TREE_OPERAND (alloc_expr
, 1);
2599 alloc_expr
= NULL_TREE
;
2602 if (check_new
&& alloc_expr
)
2604 /* Did we modify the storage? */
2605 tree ifexp
= cp_build_binary_op (NE_EXPR
, alloc_node
,
2607 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2611 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2613 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2615 /* The type of new int [3][3] is not int *, but int [3] * */
2616 rval
= build_c_cast (build_pointer_type (type
), rval
);
2623 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, use_global_delete
)
2624 tree base
, maxindex
, type
;
2625 special_function_kind auto_delete_vec
;
2626 int use_global_delete
;
2629 tree ptype
= build_pointer_type (type
= complete_type (type
));
2630 tree size_exp
= size_in_bytes (type
);
2632 /* Temporary variables used by the loop. */
2633 tree tbase
, tbase_init
;
2635 /* This is the body of the loop that implements the deletion of a
2636 single element, and moves temp variables to next elements. */
2639 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2642 /* This is the thing that governs what to do after the loop has run. */
2643 tree deallocate_expr
= 0;
2645 /* This is the BIND_EXPR which holds the outermost iterator of the
2646 loop. It is convenient to set this variable up and test it before
2647 executing any other code in the loop.
2648 This is also the containing expression returned by this function. */
2649 tree controller
= NULL_TREE
;
2651 if (! IS_AGGR_TYPE (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2653 loop
= integer_zero_node
;
2657 /* The below is short by the cookie size. */
2658 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2659 convert (sizetype
, maxindex
));
2661 tbase
= create_temporary_var (ptype
);
2662 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2663 fold (build (PLUS_EXPR
, ptype
,
2666 DECL_REGISTER (tbase
) = 1;
2667 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2668 TREE_SIDE_EFFECTS (controller
) = 1;
2672 body
= tree_cons (NULL_TREE
,
2673 build_delete (ptype
, tbase
, sfk_complete_destructor
,
2674 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2677 body
= tree_cons (NULL_TREE
,
2678 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2681 body
= tree_cons (NULL_TREE
,
2682 build (EXIT_EXPR
, void_type_node
,
2683 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2686 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2688 loop
= tree_cons (NULL_TREE
, tbase_init
,
2689 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2690 loop
= build_compound_expr (loop
);
2693 /* If the delete flag is one, or anything else with the low bit set,
2694 delete the storage. */
2695 deallocate_expr
= integer_zero_node
;
2696 if (auto_delete_vec
!= sfk_base_destructor
)
2700 /* The below is short by the cookie size. */
2701 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2702 convert (sizetype
, maxindex
));
2704 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2711 cookie_size
= get_cookie_size (type
);
2713 = cp_convert (ptype
,
2714 cp_build_binary_op (MINUS_EXPR
,
2715 cp_convert (string_type_node
,
2718 /* True size with header. */
2719 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2722 if (auto_delete_vec
== sfk_deleting_destructor
)
2723 deallocate_expr
= build_x_delete (base_tbd
,
2724 2 | use_global_delete
,
2728 if (loop
&& deallocate_expr
!= integer_zero_node
)
2730 body
= tree_cons (NULL_TREE
, loop
,
2731 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2732 body
= build_compound_expr (body
);
2737 /* Outermost wrapper: If pointer is null, punt. */
2738 body
= fold (build (COND_EXPR
, void_type_node
,
2739 fold (build (NE_EXPR
, boolean_type_node
, base
,
2740 integer_zero_node
)),
2741 body
, integer_zero_node
));
2742 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2746 TREE_OPERAND (controller
, 1) = body
;
2750 return cp_convert (void_type_node
, body
);
2753 /* Create an unnamed variable of the indicated TYPE. */
2756 create_temporary_var (type
)
2761 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2762 TREE_USED (decl
) = 1;
2763 DECL_ARTIFICIAL (decl
) = 1;
2764 DECL_SOURCE_FILE (decl
) = input_filename
;
2765 DECL_SOURCE_LINE (decl
) = lineno
;
2766 DECL_IGNORED_P (decl
) = 1;
2767 DECL_CONTEXT (decl
) = current_function_decl
;
2772 /* Create a new temporary variable of the indicated TYPE, initialized
2775 It is not entered into current_binding_level, because that breaks
2776 things when it comes time to do final cleanups (which take place
2777 "outside" the binding contour of the function). */
2780 get_temp_regvar (type
, init
)
2785 decl
= create_temporary_var (type
);
2786 if (building_stmt_tree ())
2787 add_decl_stmt (decl
);
2788 if (!building_stmt_tree ())
2789 DECL_RTL (decl
) = assign_temp (type
, 2, 0, 1);
2790 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
2795 /* `build_vec_init' returns tree structure that performs
2796 initialization of a vector of aggregate types.
2798 DECL is passed only for error reporting, and provides line number
2799 and source file name information.
2800 BASE is the space where the vector will be. For a vector of Ts,
2801 the type of BASE is `T*'.
2802 MAXINDEX is the maximum index of the array (one less than the
2803 number of elements).
2804 INIT is the (possibly NULL) initializer.
2806 FROM_ARRAY is 0 if we should init everything with INIT
2807 (i.e., every element initialized from INIT).
2808 FROM_ARRAY is 1 if we should index into INIT in parallel
2809 with initialization of DECL.
2810 FROM_ARRAY is 2 if we should index into INIT in parallel,
2811 but use assignment instead of initialization. */
2814 build_vec_init (decl
, base
, maxindex
, init
, from_array
)
2815 tree decl
, base
, maxindex
, init
;
2819 tree base2
= NULL_TREE
;
2821 tree itype
= NULL_TREE
;
2823 /* The type of an element in the array. */
2825 /* The type of a pointer to an element in the array. */
2830 tree try_block
= NULL_TREE
;
2831 tree try_body
= NULL_TREE
;
2832 int num_initialized_elts
= 0;
2834 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2835 if (maxindex
== error_mark_node
)
2836 return error_mark_node
;
2838 type
= TREE_TYPE (TREE_TYPE (base
));
2839 ptype
= build_pointer_type (type
);
2840 size
= size_in_bytes (type
);
2842 /* The code we are generating looks like:
2846 ptrdiff_t iterator = maxindex;
2848 ... initializations from CONSTRUCTOR ...
2849 if (iterator != -1) {
2851 ... initialize *base ...
2853 } while (--iterator != -1);
2856 ... destroy elements that were constructed ...
2859 We can omit the try and catch blocks if we know that the
2860 initialization will never throw an exception, or if the array
2861 elements do not have destructors. If we have a CONSTRUCTOR to
2862 give us initialization information, we emit code to initialize
2863 each of the elements before the loop in the try block, and then
2864 iterate over fewer elements. We can omit the loop completely if
2865 the elements of the array do not have constructors.
2867 We actually wrap the entire body of the above in a STMT_EXPR, for
2870 When copying from array to another, when the array elements have
2871 only trivial copy constructors, we should use __builtin_memcpy
2872 rather than generating a loop. That way, we could take advantage
2873 of whatever cleverness the back-end has for dealing with copies
2874 of blocks of memory. */
2876 begin_init_stmts (&stmt_expr
, &compound_stmt
);
2877 destroy_temps
= stmts_are_full_exprs_p ();
2878 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2879 rval
= get_temp_regvar (ptype
,
2880 cp_convert (ptype
, default_conversion (base
)));
2881 base
= get_temp_regvar (ptype
, rval
);
2882 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2884 /* Protect the entire array initialization so that we can destroy
2885 the partially constructed array if an exception is thrown. */
2886 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2888 try_block
= begin_try_block ();
2889 try_body
= begin_compound_stmt (/*has_no_scope=*/1);
2892 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
2893 && (!decl
|| same_type_p (TREE_TYPE (init
), TREE_TYPE (decl
))))
2895 /* Do non-default initialization resulting from brace-enclosed
2901 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2903 tree elt
= TREE_VALUE (elts
);
2904 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2906 num_initialized_elts
++;
2908 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2909 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0));
2911 finish_expr_stmt (build_modify_expr (baseref
, NOP_EXPR
,
2914 finish_expr_stmt (build_modify_expr
2917 build (PLUS_EXPR
, build_pointer_type (type
),
2919 finish_expr_stmt (build_modify_expr
2922 build (MINUS_EXPR
, ptrdiff_type_node
,
2923 iterator
, integer_one_node
)));
2926 /* Clear out INIT so that we don't get confused below. */
2929 else if (from_array
)
2931 /* If initializing one array from another, initialize element by
2932 element. We rely upon the below calls the do argument
2934 if (decl
== NULL_TREE
)
2936 sorry ("initialization of array from dissimilar array type");
2937 return error_mark_node
;
2941 base2
= default_conversion (init
);
2942 itype
= TREE_TYPE (base2
);
2943 base2
= get_temp_regvar (itype
, base2
);
2944 itype
= TREE_TYPE (itype
);
2946 else if (TYPE_LANG_SPECIFIC (type
)
2947 && TYPE_NEEDS_CONSTRUCTING (type
)
2948 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2950 error ("initializer ends prematurely");
2951 return error_mark_node
;
2955 /* Now, default-initialize any remaining elements. We don't need to
2956 do that if a) the type does not need constructing, or b) we've
2957 already initialized all the elements.
2959 We do need to keep going if we're copying an array. */
2962 || (TYPE_NEEDS_CONSTRUCTING (type
)
2963 && ! (host_integerp (maxindex
, 0)
2964 && (num_initialized_elts
2965 == tree_low_cst (maxindex
, 0) + 1))))
2967 /* If the ITERATOR is equal to -1, then we don't have to loop;
2968 we've already initialized all the elements. */
2974 if_stmt
= begin_if_stmt ();
2975 finish_if_stmt_cond (build (NE_EXPR
, boolean_type_node
,
2976 iterator
, minus_one_node
),
2979 /* Otherwise, loop through the elements. */
2980 do_stmt
= begin_do_stmt ();
2981 do_body
= begin_compound_stmt (/*has_no_scope=*/1);
2983 /* When we're not building a statement-tree, things are a little
2984 complicated. If, when we recursively call build_aggr_init,
2985 an expression containing a TARGET_EXPR is expanded, then it
2986 may get a cleanup. Then, the result of that expression is
2987 passed to finish_expr_stmt, which will call
2988 expand_start_target_temps/expand_end_target_temps. However,
2989 the latter call will not cause the cleanup to run because
2990 that block will still be on the block stack. So, we call
2991 expand_start_target_temps here manually; the corresponding
2992 call to expand_end_target_temps below will cause the cleanup
2994 if (!building_stmt_tree ())
2995 expand_start_target_temps ();
2999 tree to
= build1 (INDIRECT_REF
, type
, base
);
3003 from
= build1 (INDIRECT_REF
, itype
, base2
);
3007 if (from_array
== 2)
3008 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
3009 else if (TYPE_NEEDS_CONSTRUCTING (type
))
3010 elt_init
= build_aggr_init (to
, from
, 0);
3012 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
3014 my_friendly_abort (57);
3016 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3019 sorry ("cannot initialize multi-dimensional array with initializer");
3020 elt_init
= (build_vec_init
3023 build_pointer_type (TREE_TYPE (type
)),
3025 array_type_nelts (type
), 0, 0));
3028 elt_init
= build_aggr_init (build1 (INDIRECT_REF
, type
, base
),
3031 /* The initialization of each array element is a
3033 if (!building_stmt_tree ())
3035 genrtl_expr_stmt (elt_init
);
3036 expand_end_target_temps ();
3040 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
3041 finish_expr_stmt (elt_init
);
3042 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
3045 finish_expr_stmt (build_modify_expr
3048 build (PLUS_EXPR
, build_pointer_type (type
),
3051 finish_expr_stmt (build_modify_expr
3054 build (PLUS_EXPR
, build_pointer_type (type
),
3057 finish_compound_stmt (/*has_no_scope=*/1, do_body
);
3058 finish_do_body (do_stmt
);
3059 finish_do_stmt (build (NE_EXPR
, boolean_type_node
,
3060 build (PREDECREMENT_EXPR
,
3067 finish_then_clause (if_stmt
);
3071 /* Make sure to cleanup any partially constructed elements. */
3072 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3076 finish_compound_stmt (/*has_no_scope=*/1, try_body
);
3077 finish_cleanup_try_block (try_block
);
3078 e
= build_vec_delete_1 (rval
,
3079 cp_build_binary_op (MINUS_EXPR
, maxindex
,
3082 sfk_base_destructor
,
3083 /*use_global_delete=*/0);
3084 finish_cleanup (e
, try_block
);
3087 /* The value of the array initialization is the address of the
3088 first element in the array. */
3089 finish_expr_stmt (rval
);
3091 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
3092 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
3096 /* Free up storage of type TYPE, at address ADDR.
3098 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3101 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3102 used as the second argument to operator delete. It can include
3103 things like padding and magic size cookies. It has virtual in it,
3104 because if you have a base pointer and you delete through a virtual
3105 destructor, it should be the size of the dynamic object, not the
3106 static object, see Free Store 12.5 ISO C++.
3108 This does not call any destructors. */
3111 build_x_delete (addr
, which_delete
, virtual_size
)
3116 int use_global_delete
= which_delete
& 1;
3117 int use_vec_delete
= !!(which_delete
& 2);
3118 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3119 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
3121 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
3124 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3128 build_dtor_call (exp
, dtor_kind
, flags
)
3130 special_function_kind dtor_kind
;
3137 case sfk_complete_destructor
:
3138 name
= complete_dtor_identifier
;
3141 case sfk_base_destructor
:
3142 name
= base_dtor_identifier
;
3145 case sfk_deleting_destructor
:
3146 name
= deleting_dtor_identifier
;
3150 my_friendly_abort (20000524);
3152 return build_method_call (exp
, name
, NULL_TREE
, NULL_TREE
, flags
);
3155 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3156 ADDR is an expression which yields the store to be destroyed.
3157 AUTO_DELETE is the name of the destructor to call, i.e., either
3158 sfk_complete_destructor, sfk_base_destructor, or
3159 sfk_deleting_destructor.
3161 FLAGS is the logical disjunction of zero or more LOOKUP_
3162 flags. See cp-tree.h for more info.
3164 This function does not delete an object's virtual base classes. */
3167 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3169 special_function_kind auto_delete
;
3171 int use_global_delete
;
3177 if (addr
== error_mark_node
)
3178 return error_mark_node
;
3180 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3181 set to `error_mark_node' before it gets properly cleaned up. */
3182 if (type
== error_mark_node
)
3183 return error_mark_node
;
3185 type
= TYPE_MAIN_VARIANT (type
);
3187 if (TREE_CODE (type
) == POINTER_TYPE
)
3189 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3190 if (!VOID_TYPE_P (type
) && !complete_type_or_else (type
, addr
))
3191 return error_mark_node
;
3192 if (TREE_CODE (type
) == ARRAY_TYPE
)
3194 if (! IS_AGGR_TYPE (type
))
3196 /* Call the builtin operator delete. */
3197 return build_builtin_delete_call (addr
);
3199 if (TREE_SIDE_EFFECTS (addr
))
3200 addr
= save_expr (addr
);
3202 /* throw away const and volatile on target type of addr */
3203 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3204 ref
= build_indirect_ref (addr
, NULL_PTR
);
3206 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3209 if (TREE_SIDE_EFFECTS (addr
))
3210 addr
= save_expr (addr
);
3211 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3213 error ("unknown array size in delete");
3214 return error_mark_node
;
3216 return build_vec_delete (addr
, array_type_nelts (type
),
3217 auto_delete
, use_global_delete
);
3221 /* Don't check PROTECT here; leave that decision to the
3222 destructor. If the destructor is accessible, call it,
3223 else report error. */
3224 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3225 if (TREE_SIDE_EFFECTS (addr
))
3226 addr
= save_expr (addr
);
3228 if (TREE_CONSTANT (addr
))
3229 addr
= convert_pointer_to (type
, addr
);
3231 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3233 ref
= build_indirect_ref (addr
, NULL_PTR
);
3236 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3238 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3240 if (auto_delete
== sfk_base_destructor
)
3241 return void_zero_node
;
3243 return build_op_delete_call
3244 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3245 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3249 /* Below, we will reverse the order in which these calls are made.
3250 If we have a destructor, then that destructor will take care
3251 of the base classes; otherwise, we must do that here. */
3252 if (TYPE_HAS_DESTRUCTOR (type
))
3254 tree do_delete
= NULL_TREE
;
3257 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3259 /* Delete the object. */
3260 do_delete
= build_builtin_delete_call (addr
);
3261 /* Otherwise, treat this like a complete object destructor
3263 auto_delete
= sfk_complete_destructor
;
3266 expr
= build_dtor_call (ref
, auto_delete
, flags
);
3268 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3270 if (flags
& LOOKUP_DESTRUCTOR
)
3271 /* Explicit destructor call; don't check for null pointer. */
3272 ifexp
= integer_one_node
;
3274 /* Handle deleting a null pointer. */
3275 ifexp
= fold (cp_build_binary_op (NE_EXPR
, addr
, integer_zero_node
));
3277 if (ifexp
!= integer_one_node
)
3278 expr
= build (COND_EXPR
, void_type_node
,
3279 ifexp
, expr
, void_zero_node
);
3285 /* We only get here from finish_function for a destructor. */
3286 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3287 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (type
);
3288 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3289 tree exprstmt
= NULL_TREE
;
3291 /* Set this again before we call anything, as we might get called
3293 TYPE_HAS_DESTRUCTOR (type
) = 1;
3295 /* If we have member delete or vbases, we call delete in
3297 my_friendly_assert (auto_delete
== sfk_base_destructor
, 20000411);
3299 /* Take care of the remaining baseclasses. */
3300 for (i
= 0; i
< n_baseclasses
; i
++)
3302 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3303 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3304 || TREE_VIA_VIRTUAL (base_binfo
))
3307 expr
= build_scoped_method_call (ref
, base_binfo
,
3308 base_dtor_identifier
,
3311 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3314 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3316 if (TREE_CODE (member
) != FIELD_DECL
)
3318 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member
)))
3320 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3321 tree this_type
= TREE_TYPE (member
);
3322 expr
= build_delete (this_type
, this_member
,
3323 sfk_complete_destructor
, flags
, 0);
3324 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3329 return build_compound_expr (exprstmt
);
3330 /* Virtual base classes make this function do nothing. */
3331 return void_zero_node
;
3335 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3338 build_vbase_delete (type
, decl
)
3341 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3342 tree result
= NULL_TREE
;
3343 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3345 my_friendly_assert (addr
!= error_mark_node
, 222);
3350 = convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases
))),
3352 result
= tree_cons (NULL_TREE
,
3353 build_delete (TREE_TYPE (this_addr
), this_addr
,
3354 sfk_base_destructor
,
3355 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3357 vbases
= TREE_CHAIN (vbases
);
3359 return build_compound_expr (nreverse (result
));
3362 /* Build a C++ vector delete expression.
3363 MAXINDEX is the number of elements to be deleted.
3364 ELT_SIZE is the nominal size of each element in the vector.
3365 BASE is the expression that should yield the store to be deleted.
3366 This function expands (or synthesizes) these calls itself.
3367 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3369 This also calls delete for virtual baseclasses of elements of the vector.
3371 Update: MAXINDEX is no longer needed. The size can be extracted from the
3372 start of the vector for pointers, and from the type for arrays. We still
3373 use MAXINDEX for arrays because it happens to already have one of the
3374 values we'd have to extract. (We could use MAXINDEX with pointers to
3375 confirm the size, and trap if the numbers differ; not clear that it'd
3376 be worth bothering.) */
3379 build_vec_delete (base
, maxindex
, auto_delete_vec
, use_global_delete
)
3380 tree base
, maxindex
;
3381 special_function_kind auto_delete_vec
;
3382 int use_global_delete
;
3386 if (TREE_CODE (base
) == OFFSET_REF
)
3387 base
= resolve_offset_ref (base
);
3389 type
= TREE_TYPE (base
);
3391 base
= stabilize_reference (base
);
3393 /* Since we can use base many times, save_expr it. */
3394 if (TREE_SIDE_EFFECTS (base
))
3395 base
= save_expr (base
);
3397 if (TREE_CODE (type
) == POINTER_TYPE
)
3399 /* Step back one from start of vector, and read dimension. */
3402 type
= strip_array_types (TREE_TYPE (type
));
3405 cookie_addr
= build (MINUS_EXPR
,
3406 build_pointer_type (sizetype
),
3408 TYPE_SIZE_UNIT (sizetype
));
3409 maxindex
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3415 cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3416 base
, get_cookie_size (type
));
3417 cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3418 maxindex
= build_component_ref (cookie
, nelts_identifier
,
3422 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3424 /* get the total number of things in the array, maxindex is a bad name */
3425 maxindex
= array_type_nelts_total (type
);
3426 type
= strip_array_types (type
);
3427 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3431 if (base
!= error_mark_node
)
3432 error ("type to vector delete is neither pointer or array type");
3433 return error_mark_node
;
3436 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,