1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* High-level class interface. */
37 static void expand_aggr_vbase_init_1
PARAMS ((tree
, tree
, tree
, tree
));
38 static void construct_virtual_bases
PARAMS ((tree
, tree
, tree
, tree
, tree
));
39 static void expand_aggr_init_1
PARAMS ((tree
, tree
, tree
, tree
, int));
40 static void expand_default_init
PARAMS ((tree
, tree
, tree
, tree
, int));
41 static tree build_vec_delete_1
PARAMS ((tree
, tree
, tree
, special_function_kind
, int));
42 static void perform_member_init
PARAMS ((tree
, tree
, int));
43 static void sort_base_init
PARAMS ((tree
, tree
, tree
*, tree
*));
44 static tree build_builtin_delete_call
PARAMS ((tree
));
45 static int member_init_ok_or_else
PARAMS ((tree
, tree
, tree
));
46 static void expand_virtual_init
PARAMS ((tree
, tree
));
47 static tree sort_member_init
PARAMS ((tree
, tree
));
48 static tree initializing_context
PARAMS ((tree
));
49 static void expand_cleanup_for_base
PARAMS ((tree
, tree
));
50 static tree get_temp_regvar
PARAMS ((tree
, tree
));
51 static tree dfs_initialize_vtbl_ptrs
PARAMS ((tree
, void *));
52 static tree build_default_init
PARAMS ((tree
));
53 static tree build_new_1
PARAMS ((tree
));
54 static tree get_cookie_size
PARAMS ((tree
));
55 static tree build_dtor_call
PARAMS ((tree
, special_function_kind
, int));
56 static tree build_field_list
PARAMS ((tree
, tree
, int *));
57 static tree build_vtbl_address
PARAMS ((tree
));
59 /* Set up local variable for this file. MUST BE CALLED AFTER
60 INIT_DECL_PROCESSING. */
62 static tree BI_header_type
;
64 void init_init_processing ()
68 /* Define the structure that holds header information for
69 arrays allocated via operator new. */
70 BI_header_type
= make_aggr_type (RECORD_TYPE
);
71 fields
[0] = build_decl (FIELD_DECL
, nelts_identifier
, sizetype
);
73 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
76 ggc_add_tree_root (&BI_header_type
, 1);
79 /* We are about to generate some complex initialization code.
80 Conceptually, it is all a single expression. However, we may want
81 to include conditionals, loops, and other such statement-level
82 constructs. Therefore, we build the initialization code inside a
83 statement-expression. This function starts such an expression.
84 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
85 pass them back to finish_init_stmts when the expression is
89 begin_init_stmts (stmt_expr_p
, compound_stmt_p
)
91 tree
*compound_stmt_p
;
93 if (building_stmt_tree ())
94 *stmt_expr_p
= begin_stmt_expr ();
96 *stmt_expr_p
= begin_global_stmt_expr ();
98 if (building_stmt_tree ())
99 *compound_stmt_p
= begin_compound_stmt (/*has_no_scope=*/1);
102 *compound_stmt_p = genrtl_begin_compound_stmt (has_no_scope=1);
106 /* Finish out the statement-expression begun by the previous call to
107 begin_init_stmts. Returns the statement-expression itself. */
110 finish_init_stmts (stmt_expr
, compound_stmt
)
115 if (building_stmt_tree ())
116 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
118 if (building_stmt_tree ())
119 stmt_expr
= finish_stmt_expr (stmt_expr
);
121 stmt_expr
= finish_global_stmt_expr (stmt_expr
);
123 /* To avoid spurious warnings about unused values, we set
126 TREE_USED (stmt_expr
) = 1;
133 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
134 which we want to initialize the vtable pointer for, DATA is
135 TREE_LIST whose TREE_VALUE is the this ptr expression. */
138 dfs_initialize_vtbl_ptrs (binfo
, data
)
142 if ((!BINFO_PRIMARY_P (binfo
) || TREE_VIA_VIRTUAL (binfo
))
143 && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo
)))
145 tree base_ptr
= TREE_VALUE ((tree
) data
);
147 base_ptr
= build_base_path (PLUS_EXPR
, base_ptr
, binfo
, /*nonnull=*/1);
149 expand_virtual_init (binfo
, base_ptr
);
152 SET_BINFO_MARKED (binfo
);
157 /* Initialize all the vtable pointers in the object pointed to by
161 initialize_vtbl_ptrs (addr
)
167 type
= TREE_TYPE (TREE_TYPE (addr
));
168 list
= build_tree_list (type
, addr
);
170 /* Walk through the hierarchy, initializing the vptr in each base
171 class. We do these in pre-order because can't find the virtual
172 bases for a class until we've initialized the vtbl for that
174 dfs_walk_real (TYPE_BINFO (type
), dfs_initialize_vtbl_ptrs
,
175 NULL
, dfs_unmarked_real_bases_queue_p
, list
);
176 dfs_walk (TYPE_BINFO (type
), dfs_unmark
,
177 dfs_marked_real_bases_queue_p
, type
);
182 To default-initialize an object of type T means:
184 --if T is a non-POD class type (clause _class_), the default construc-
185 tor for T is called (and the initialization is ill-formed if T has
186 no accessible default constructor);
188 --if T is an array type, each element is default-initialized;
190 --otherwise, the storage for the object is zero-initialized.
192 A program that calls for default-initialization of an entity of refer-
193 ence type is ill-formed. */
196 build_default_init (type
)
199 tree init
= NULL_TREE
;
201 if (TYPE_NEEDS_CONSTRUCTING (type
))
202 /* Other code will handle running the default constructor. We can't do
203 anything with a CONSTRUCTOR for arrays here, as that would imply
204 copy-initialization. */
206 else if (AGGREGATE_TYPE_P (type
) && !TYPE_PTRMEMFUNC_P (type
))
208 /* This is a default initialization of an aggregate, but not one of
209 non-POD class type. We cleverly notice that the initialization
210 rules in such a case are the same as for initialization with an
211 empty brace-initialization list. */
212 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
214 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
215 /* --if T is a reference type, no initialization is performed. */
219 init
= integer_zero_node
;
221 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
222 /* We must make enumeral types the right type. */
223 init
= fold (build1 (NOP_EXPR
, type
, init
));
226 init
= digest_init (type
, init
, 0);
230 /* Subroutine of emit_base_init. */
233 perform_member_init (member
, init
, explicit)
238 tree type
= TREE_TYPE (member
);
240 decl
= build_component_ref (current_class_ref
, member
, NULL_TREE
, explicit);
242 if (decl
== error_mark_node
)
245 /* Deal with this here, as we will get confused if we try to call the
246 assignment op for an anonymous union. This can happen in a
247 synthesized copy constructor. */
248 if (ANON_AGGR_TYPE_P (type
))
252 init
= build (INIT_EXPR
, type
, decl
, TREE_VALUE (init
));
253 finish_expr_stmt (init
);
256 else if (TYPE_NEEDS_CONSTRUCTING (type
)
257 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
259 /* Since `init' is already a TREE_LIST on the member_init_list,
260 only build it into one if we aren't already a list. */
261 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
262 init
= build_tree_list (NULL_TREE
, init
);
265 && TREE_CODE (type
) == ARRAY_TYPE
267 && TREE_CHAIN (init
) == NULL_TREE
268 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
270 /* Initialization of one array from another. */
271 finish_expr_stmt (build_vec_init (decl
, TREE_VALUE (init
), 1));
274 finish_expr_stmt (build_aggr_init (decl
, init
, 0));
278 if (init
== NULL_TREE
)
282 init
= build_default_init (type
);
283 if (TREE_CODE (type
) == REFERENCE_TYPE
)
285 ("default-initialization of `%#D', which has reference type",
288 /* member traversal: note it leaves init NULL */
289 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
290 cp_pedwarn ("uninitialized reference member `%D'", member
);
292 else if (TREE_CODE (init
) == TREE_LIST
)
294 /* There was an explicit member initialization. Do some
295 work in that case. */
296 if (TREE_CHAIN (init
))
298 warning ("initializer list treated as compound expression");
299 init
= build_compound_expr (init
);
302 init
= TREE_VALUE (init
);
306 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
309 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
313 expr
= build_component_ref (current_class_ref
, member
, NULL_TREE
,
315 expr
= build_delete (type
, expr
, sfk_complete_destructor
,
316 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
318 if (expr
!= error_mark_node
)
319 finish_subobject (expr
);
323 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
324 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
327 build_field_list (t
, list
, uses_unions_p
)
334 /* Note whether or not T is a union. */
335 if (TREE_CODE (t
) == UNION_TYPE
)
338 for (fields
= TYPE_FIELDS (t
); fields
; fields
= TREE_CHAIN (fields
))
340 /* Skip CONST_DECLs for enumeration constants and so forth. */
341 if (TREE_CODE (fields
) != FIELD_DECL
)
344 /* Keep track of whether or not any fields are unions. */
345 if (TREE_CODE (TREE_TYPE (fields
)) == UNION_TYPE
)
348 /* For an anonymous struct or union, we must recursively
349 consider the fields of the anonymous type. They can be
350 directly initialized from the constructor. */
351 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields
)))
353 /* Add this field itself. Synthesized copy constructors
354 initialize the entire aggregate. */
355 list
= tree_cons (fields
, NULL_TREE
, list
);
356 /* And now add the fields in the anonymous aggregate. */
357 list
= build_field_list (TREE_TYPE (fields
), list
,
360 /* Add this field. */
361 else if (DECL_NAME (fields
))
362 list
= tree_cons (fields
, NULL_TREE
, list
);
368 /* The MEMBER_INIT_LIST is a TREE_LIST. The TREE_PURPOSE of each list
369 gives a FIELD_DECL in T that needs initialization. The TREE_VALUE
370 gives the initializer, or list of initializer arguments. Sort the
371 MEMBER_INIT_LIST, returning a version that contains the same
372 information but in the order that the fields should actually be
373 initialized. Perform error-checking in the process. */
376 sort_member_init (t
, member_init_list
)
378 tree member_init_list
;
385 /* Build up a list of the various fields, in sorted order. */
386 init_list
= nreverse (build_field_list (t
, NULL_TREE
, &uses_unions_p
));
388 /* Go through the explicit initializers, adding them to the
390 last_field
= init_list
;
391 for (init
= member_init_list
; init
; init
= TREE_CHAIN (init
))
394 tree initialized_field
;
396 initialized_field
= TREE_PURPOSE (init
);
397 my_friendly_assert (TREE_CODE (initialized_field
) == FIELD_DECL
,
400 /* If the explicit initializers are in sorted order, then the
401 INITIALIZED_FIELD will be for a field following the
403 for (f
= last_field
; f
; f
= TREE_CHAIN (f
))
404 if (TREE_PURPOSE (f
) == initialized_field
)
407 /* Give a warning, if appropriate. */
408 if (warn_reorder
&& !f
)
410 cp_warning_at ("member initializers for `%#D'",
411 TREE_PURPOSE (last_field
));
412 cp_warning_at (" and `%#D'", initialized_field
);
413 warning (" will be re-ordered to match declaration order");
416 /* Look again, from the beginning of the list. We must find the
417 field on this loop. */
421 while (TREE_PURPOSE (f
) != initialized_field
)
425 /* If there was already an explicit initializer for this field,
428 cp_error ("multiple initializations given for member `%D'",
432 /* Mark the field as explicitly initialized. */
433 TREE_TYPE (f
) = error_mark_node
;
434 /* And insert the initializer. */
435 TREE_VALUE (f
) = TREE_VALUE (init
);
438 /* Remember the location of the last explicitly initialized
445 If a ctor-initializer specifies more than one mem-initializer for
446 multiple members of the same union (including members of
447 anonymous unions), the ctor-initializer is ill-formed. */
450 last_field
= NULL_TREE
;
451 for (init
= init_list
; init
; init
= TREE_CHAIN (init
))
457 /* Skip uninitialized members. */
458 if (!TREE_TYPE (init
))
460 /* See if this field is a member of a union, or a member of a
461 structure contained in a union, etc. */
462 field
= TREE_PURPOSE (init
);
463 for (field_type
= DECL_CONTEXT (field
);
464 !same_type_p (field_type
, t
);
465 field_type
= TYPE_CONTEXT (field_type
))
466 if (TREE_CODE (field_type
) == UNION_TYPE
)
468 /* If this field is not a member of a union, skip it. */
469 if (TREE_CODE (field_type
) != UNION_TYPE
)
472 /* It's only an error if we have two initializers for the same
480 /* See if LAST_FIELD and the field initialized by INIT are
481 members of the same union. If so, there's a problem,
482 unless they're actually members of the same structure
483 which is itself a member of a union. For example, given:
485 union { struct { int i; int j; }; };
487 initializing both `i' and `j' makes sense. */
488 field_type
= DECL_CONTEXT (field
);
492 tree last_field_type
;
494 last_field_type
= DECL_CONTEXT (last_field
);
497 if (same_type_p (last_field_type
, field_type
))
499 if (TREE_CODE (field_type
) == UNION_TYPE
)
500 cp_error ("initializations for multiple members of `%T'",
506 if (same_type_p (last_field_type
, t
))
509 last_field_type
= TYPE_CONTEXT (last_field_type
);
512 /* If we've reached the outermost class, then we're
514 if (same_type_p (field_type
, t
))
517 field_type
= TYPE_CONTEXT (field_type
);
528 /* Like sort_member_init, but used for initializers of base classes.
529 *RBASE_PTR is filled in with the initializers for non-virtual bases;
530 vbase_ptr gets the virtual bases. */
533 sort_base_init (t
, base_init_list
, rbase_ptr
, vbase_ptr
)
536 tree
*rbase_ptr
, *vbase_ptr
;
538 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
539 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
545 /* For warn_reorder. */
547 tree last_base
= NULL_TREE
;
549 tree rbases
= NULL_TREE
;
550 tree vbases
= NULL_TREE
;
552 /* First walk through and splice out vbase and invalid initializers.
553 Also replace types with binfos. */
555 last
= tree_cons (NULL_TREE
, NULL_TREE
, base_init_list
);
556 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
558 tree basetype
= TREE_PURPOSE (x
);
559 tree binfo
= binfo_or_else (basetype
, t
);
561 if (binfo
== NULL_TREE
)
562 /* BASETYPE might be an inaccessible direct base (because it
563 is also an indirect base). */
566 if (TREE_VIA_VIRTUAL (binfo
))
568 /* Virtual base classes are special cases. Their
569 initializers are recorded with this constructor, and they
570 are used when this constructor is the top-level
571 constructor called. */
572 tree v
= binfo_for_vbase (BINFO_TYPE (binfo
), t
);
573 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
577 /* Otherwise, it must be an immediate base class. */
579 (same_type_p (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo
)),
582 TREE_PURPOSE (x
) = binfo
;
583 TREE_CHAIN (last
) = x
;
587 TREE_CHAIN (last
) = NULL_TREE
;
589 /* Now walk through our regular bases and make sure they're initialized. */
591 for (i
= 0; i
< n_baseclasses
; ++i
)
593 /* The base for which we're currently initializing. */
594 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
595 /* The initializer for BASE_BINFO. */
599 if (TREE_VIA_VIRTUAL (base_binfo
))
602 /* We haven't found the BASE_BINFO yet. */
604 /* Loop through all the explicitly initialized bases, looking
605 for an appropriate initializer. */
606 for (x
= base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
608 tree binfo
= TREE_PURPOSE (x
);
610 if (binfo
== base_binfo
&& !init
)
616 cp_warning_at ("base initializers for `%#T'", last_base
);
617 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
618 warning (" will be re-ordered to match inheritance order");
621 last_base
= BINFO_TYPE (binfo
);
624 /* Make sure we won't try to work on this init again. */
625 TREE_PURPOSE (x
) = NULL_TREE
;
626 init
= build_tree_list (binfo
, TREE_VALUE (x
));
628 else if (binfo
== base_binfo
)
630 cp_error ("base class `%T' already initialized",
636 /* If we didn't find BASE_BINFO in the list, create a dummy entry
637 so the two lists (RBASES and the list of bases) will be
640 init
= build_tree_list (NULL_TREE
, NULL_TREE
);
641 rbases
= chainon (rbases
, init
);
648 /* Perform whatever initializations have yet to be done on the base
649 class, and non-static data members, of the CURRENT_CLASS_TYPE.
650 These actions are given by the BASE_INIT_LIST and MEM_INIT_LIST,
653 If there is a need for a call to a constructor, we must surround
654 that call with a pushlevel/poplevel pair, since we are technically
655 at the PARM level of scope. */
658 emit_base_init (mem_init_list
, base_init_list
)
663 tree rbase_init_list
, vbase_init_list
;
664 tree t
= current_class_type
;
665 tree t_binfo
= TYPE_BINFO (t
);
666 tree binfos
= BINFO_BASETYPES (t_binfo
);
668 int n_baseclasses
= BINFO_N_BASETYPES (t_binfo
);
670 mem_init_list
= sort_member_init (t
, mem_init_list
);
671 sort_base_init (t
, base_init_list
, &rbase_init_list
, &vbase_init_list
);
673 /* First, initialize the virtual base classes, if we are
674 constructing the most-derived object. */
675 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
677 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
678 construct_virtual_bases (t
, current_class_ref
, current_class_ptr
,
679 vbase_init_list
, first_arg
);
682 /* Now, perform initialization of non-virtual base classes. */
683 for (i
= 0; i
< n_baseclasses
; i
++)
685 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
686 tree init
= void_list_node
;
688 if (TREE_VIA_VIRTUAL (base_binfo
))
691 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
,
694 if (TREE_PURPOSE (rbase_init_list
))
695 init
= TREE_VALUE (rbase_init_list
);
696 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
700 && DECL_COPY_CONSTRUCTOR_P (current_function_decl
))
701 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
702 BINFO_TYPE (base_binfo
));
705 if (init
!= void_list_node
)
707 member
= build_base_path (PLUS_EXPR
, current_class_ptr
,
709 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
710 build_indirect_ref (member
, NULL
), init
,
714 expand_cleanup_for_base (base_binfo
, NULL_TREE
);
715 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
718 /* Initialize the vtable pointers for the class. */
719 initialize_vtbl_ptrs (current_class_ptr
);
721 while (mem_init_list
)
727 member
= TREE_PURPOSE (mem_init_list
);
729 /* See if we had a user-specified member initialization. */
730 if (TREE_TYPE (mem_init_list
))
732 init
= TREE_VALUE (mem_init_list
);
737 init
= DECL_INITIAL (member
);
740 /* Effective C++ rule 12. */
741 if (warn_ecpp
&& init
== NULL_TREE
742 && !DECL_ARTIFICIAL (member
)
743 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
744 cp_warning ("`%D' should be initialized in the member initialization list", member
);
747 perform_member_init (member
, init
, from_init_list
);
748 mem_init_list
= TREE_CHAIN (mem_init_list
);
752 /* Returns the address of the vtable (i.e., the value that should be
753 assigned to the vptr) for BINFO. */
756 build_vtbl_address (binfo
)
759 tree binfo_for
= binfo
;
762 if (BINFO_VPTR_INDEX (binfo
) && TREE_VIA_VIRTUAL (binfo
)
763 && BINFO_PRIMARY_P (binfo
))
764 /* If this is a virtual primary base, then the vtable we want to store
765 is that for the base this is being used as the primary base of. We
766 can't simply skip the initialization, because we may be expanding the
767 inits of a subobject constructor where the virtual base layout
769 while (BINFO_PRIMARY_BASE_OF (binfo_for
))
770 binfo_for
= BINFO_PRIMARY_BASE_OF (binfo_for
);
772 /* Figure out what vtable BINFO's vtable is based on, and mark it as
774 vtbl
= get_vtbl_decl_for_binfo (binfo_for
);
775 assemble_external (vtbl
);
776 TREE_USED (vtbl
) = 1;
778 /* Now compute the address to use when initializing the vptr. */
779 vtbl
= BINFO_VTABLE (binfo_for
);
780 if (TREE_CODE (vtbl
) == VAR_DECL
)
782 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
783 TREE_CONSTANT (vtbl
) = 1;
789 /* This code sets up the virtual function tables appropriate for
790 the pointer DECL. It is a one-ply initialization.
792 BINFO is the exact type that DECL is supposed to be. In
793 multiple inheritance, this might mean "C's A" if C : A, B. */
796 expand_virtual_init (binfo
, decl
)
802 /* Compute the initializer for vptr. */
803 vtbl
= build_vtbl_address (binfo
);
805 /* We may get this vptr from a VTT, if this is a subobject
806 constructor or subobject destructor. */
807 vtt_index
= BINFO_VPTR_INDEX (binfo
);
813 /* Compute the value to use, when there's a VTT. */
814 vtt_parm
= current_vtt_parm
;
815 vtbl2
= build (PLUS_EXPR
,
816 TREE_TYPE (vtt_parm
),
819 vtbl2
= build1 (INDIRECT_REF
, TREE_TYPE (vtbl
), vtbl2
);
821 /* The actual initializer is the VTT value only in the subobject
822 constructor. In maybe_clone_body we'll substitute NULL for
823 the vtt_parm in the case of the non-subobject constructor. */
824 vtbl
= build (COND_EXPR
,
826 build (EQ_EXPR
, boolean_type_node
,
827 current_in_charge_parm
, integer_zero_node
),
832 /* Compute the location of the vtpr. */
833 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL
),
835 my_friendly_assert (vtbl_ptr
!= error_mark_node
, 20010730);
837 /* Assign the vtable to the vptr. */
838 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
839 finish_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
842 /* If an exception is thrown in a constructor, those base classes already
843 constructed must be destroyed. This function creates the cleanup
844 for BINFO, which has just been constructed. If FLAG is non-NULL,
845 it is a DECL which is non-zero when this base needs to be
849 expand_cleanup_for_base (binfo
, flag
)
855 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo
)))
858 /* Call the destructor. */
859 expr
= (build_scoped_method_call
860 (current_class_ref
, binfo
, base_dtor_identifier
, NULL_TREE
));
862 expr
= fold (build (COND_EXPR
, void_type_node
,
863 truthvalue_conversion (flag
),
864 expr
, integer_zero_node
));
866 finish_subobject (expr
);
869 /* Subroutine of `expand_aggr_vbase_init'.
870 BINFO is the binfo of the type that is being initialized.
871 INIT_LIST is the list of initializers for the virtual baseclass. */
874 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
875 tree binfo
, exp
, addr
, init_list
;
877 tree init
= purpose_member (binfo
, init_list
);
878 tree ref
= build_indirect_ref (addr
, NULL
);
881 init
= TREE_VALUE (init
);
882 /* Call constructors, but don't set up vtables. */
883 expand_aggr_init_1 (binfo
, exp
, ref
, init
, LOOKUP_COMPLAIN
);
886 /* Construct the virtual base-classes of THIS_REF (whose address is
887 THIS_PTR). The object has the indicated TYPE. The construction
888 actually takes place only if FLAG is non-zero. INIT_LIST is list
889 of initializations for constructors to perform. */
892 construct_virtual_bases (type
, this_ref
, this_ptr
, init_list
, flag
)
901 /* If there are no virtual baseclasses, we shouldn't even be here. */
902 my_friendly_assert (TYPE_USES_VIRTUAL_BASECLASSES (type
), 19990621);
904 /* Now, run through the baseclasses, initializing each. */
905 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
906 vbases
= TREE_CHAIN (vbases
))
913 /* If there are virtual base classes with destructors, we need to
914 emit cleanups to destroy them if an exception is thrown during
915 the construction process. These exception regions (i.e., the
916 period during which the cleanups must occur) begin from the time
917 the construction is complete to the end of the function. If we
918 create a conditional block in which to initialize the
919 base-classes, then the cleanup region for the virtual base begins
920 inside a block, and ends outside of that block. This situation
921 confuses the sjlj exception-handling code. Therefore, we do not
922 create a single conditional block, but one for each
923 initialization. (That way the cleanup regions always begin
924 in the outer block.) We trust the back-end to figure out
925 that the FLAG will not change across initializations, and
926 avoid doing multiple tests. */
927 inner_if_stmt
= begin_if_stmt ();
928 finish_if_stmt_cond (flag
, inner_if_stmt
);
929 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/1);
931 /* Compute the location of the virtual base. If we're
932 constructing virtual bases, then we must be the most derived
933 class. Therefore, we don't have to look up the virtual base;
934 we already know where it is. */
935 vbase
= TREE_VALUE (vbases
);
936 exp
= build (PLUS_EXPR
,
937 TREE_TYPE (this_ptr
),
939 fold (build1 (NOP_EXPR
, TREE_TYPE (this_ptr
),
940 BINFO_OFFSET (vbase
))));
941 exp
= build1 (NOP_EXPR
,
942 build_pointer_type (BINFO_TYPE (vbase
)),
945 expand_aggr_vbase_init_1 (vbase
, this_ref
, exp
, init_list
);
946 finish_compound_stmt (/*has_no_scope=*/1, compound_stmt
);
947 finish_then_clause (inner_if_stmt
);
950 expand_cleanup_for_base (vbase
, flag
);
954 /* Find the context in which this FIELD can be initialized. */
957 initializing_context (field
)
960 tree t
= DECL_CONTEXT (field
);
962 /* Anonymous union members can be initialized in the first enclosing
963 non-anonymous union context. */
964 while (t
&& ANON_AGGR_TYPE_P (t
))
965 t
= TYPE_CONTEXT (t
);
969 /* Function to give error message if member initialization specification
970 is erroneous. FIELD is the member we decided to initialize.
971 TYPE is the type for which the initialization is being performed.
972 FIELD must be a member of TYPE.
974 MEMBER_NAME is the name of the member. */
977 member_init_ok_or_else (field
, type
, member_name
)
982 if (field
== error_mark_node
)
984 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
986 cp_error ("class `%T' does not have any field named `%D'", type
,
990 if (TREE_STATIC (field
))
992 cp_error ("field `%#D' is static; the only point of initialization is its definition",
1000 /* EXP is an expression of aggregate type. NAME is an IDENTIFIER_NODE
1001 which names a field, or it is a _TYPE node or TYPE_DECL which names
1002 a base for that type. INIT is a parameter list for that field's or
1003 base's constructor. Check the validity of NAME, and return a
1004 TREE_LIST of the base _TYPE or FIELD_DECL and the INIT. EXP is used
1005 only to get its type. If NAME is invalid, return NULL_TREE and
1008 An old style unnamed direct single base construction is permitted,
1009 where NAME is NULL. */
1012 expand_member_init (exp
, name
, init
)
1013 tree exp
, name
, init
;
1015 tree basetype
= NULL_TREE
, field
;
1018 if (exp
== NULL_TREE
)
1021 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
1022 my_friendly_assert (IS_AGGR_TYPE (type
), 20011113);
1026 /* This is an obsolete unnamed base class initializer. The
1027 parser will already have warned about its use. */
1028 switch (CLASSTYPE_N_BASECLASSES (type
))
1031 cp_error ("unnamed initializer for `%T', which has no base classes",
1035 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
1038 cp_error ("unnamed initializer for `%T', which uses multiple inheritance",
1043 else if (TYPE_P (name
))
1046 name
= TYPE_NAME (name
);
1048 else if (TREE_CODE (name
) == TYPE_DECL
)
1049 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (name
));
1051 my_friendly_assert (init
!= NULL_TREE
, 0);
1053 if (init
== void_type_node
)
1058 if (current_template_parms
)
1060 else if (vec_binfo_member (basetype
, TYPE_BINFO_BASETYPES (type
)))
1061 /* A direct base. */;
1062 else if (binfo_for_vbase (basetype
, type
))
1063 /* A virtual base. */;
1066 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1067 cp_error ("type `%D' is not a direct or virtual base of `%T'",
1070 cp_error ("type `%D' is not a direct base of `%T'",
1075 init
= build_tree_list (basetype
, init
);
1079 field
= lookup_field (type
, name
, 1, 0);
1081 if (! member_init_ok_or_else (field
, type
, name
))
1084 init
= build_tree_list (field
, init
);
1090 /* This is like `expand_member_init', only it stores one aggregate
1093 INIT comes in two flavors: it is either a value which
1094 is to be stored in EXP, or it is a parameter list
1095 to go to a constructor, which will operate on EXP.
1096 If INIT is not a parameter list for a constructor, then set
1097 LOOKUP_ONLYCONVERTING.
1098 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1099 the initializer, if FLAGS is 0, then it is the (init) form.
1100 If `init' is a CONSTRUCTOR, then we emit a warning message,
1101 explaining that such initializations are invalid.
1103 If INIT resolves to a CALL_EXPR which happens to return
1104 something of the type we are looking for, then we know
1105 that we can safely use that call to perform the
1108 The virtual function table pointer cannot be set up here, because
1109 we do not really know its type.
1111 Virtual baseclass pointers are also set up here.
1113 This never calls operator=().
1115 When initializing, nothing is CONST.
1117 A default copy constructor may have to be used to perform the
1120 A constructor or a conversion operator may have to be used to
1121 perform the initialization, but not both, as it would be ambiguous. */
1124 build_aggr_init (exp
, init
, flags
)
1131 tree type
= TREE_TYPE (exp
);
1132 int was_const
= TREE_READONLY (exp
);
1133 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1135 if (init
== error_mark_node
)
1136 return error_mark_node
;
1138 TREE_READONLY (exp
) = 0;
1139 TREE_THIS_VOLATILE (exp
) = 0;
1141 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1142 flags
|= LOOKUP_ONLYCONVERTING
;
1144 if (TREE_CODE (type
) == ARRAY_TYPE
)
1146 /* Must arrange to initialize each element of EXP
1147 from elements of INIT. */
1148 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1152 /* Handle bad initializers like:
1156 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1160 int main(int argc, char **argv) {
1161 COMPLEX zees(1.0, 0.0)[10];
1164 cp_error ("bad array initializer");
1165 return error_mark_node
;
1167 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
1169 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1171 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1173 stmt_expr
= build_vec_init (exp
, init
,
1174 init
&& same_type_p (TREE_TYPE (init
),
1176 TREE_READONLY (exp
) = was_const
;
1177 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1178 TREE_TYPE (exp
) = type
;
1180 TREE_TYPE (init
) = itype
;
1184 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1185 /* just know that we've seen something for this node */
1186 TREE_USED (exp
) = 1;
1188 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1189 begin_init_stmts (&stmt_expr
, &compound_stmt
);
1190 destroy_temps
= stmts_are_full_exprs_p ();
1191 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
1192 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1193 init
, LOOKUP_NORMAL
|flags
);
1194 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
1195 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
1196 TREE_TYPE (exp
) = type
;
1197 TREE_READONLY (exp
) = was_const
;
1198 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1204 expand_default_init (binfo
, true_exp
, exp
, init
, flags
)
1210 tree type
= TREE_TYPE (exp
);
1213 /* It fails because there may not be a constructor which takes
1214 its own type as the first (or only parameter), but which does
1215 take other types via a conversion. So, if the thing initializing
1216 the expression is a unit element of type X, first try X(X&),
1217 followed by initialization by X. If neither of these work
1218 out, then look hard. */
1222 if (init
&& TREE_CODE (init
) != TREE_LIST
1223 && (flags
& LOOKUP_ONLYCONVERTING
))
1225 /* Base subobjects should only get direct-initialization. */
1226 if (true_exp
!= exp
)
1229 if (flags
& DIRECT_BIND
)
1230 /* Do nothing. We hit this in two cases: Reference initialization,
1231 where we aren't initializing a real variable, so we don't want
1232 to run a new constructor; and catching an exception, where we
1233 have already built up the constructor call so we could wrap it
1234 in an exception region. */;
1235 else if (TREE_CODE (init
) == CONSTRUCTOR
)
1236 /* A brace-enclosed initializer has whatever type is
1237 required. There's no need to convert it. */
1240 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1242 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1243 /* We need to protect the initialization of a catch parm
1244 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1245 around the TARGET_EXPR for the copy constructor. See
1246 expand_start_catch_block. */
1247 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1248 TREE_OPERAND (init
, 0));
1250 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1251 TREE_SIDE_EFFECTS (init
) = 1;
1252 finish_expr_stmt (init
);
1256 if (init
== NULL_TREE
1257 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1261 init
= TREE_VALUE (parms
);
1264 parms
= build_tree_list (NULL_TREE
, init
);
1266 if (true_exp
== exp
)
1267 ctor_name
= complete_ctor_identifier
;
1269 ctor_name
= base_ctor_identifier
;
1271 rval
= build_method_call (exp
, ctor_name
, parms
, binfo
, flags
);
1272 if (TREE_SIDE_EFFECTS (rval
))
1274 if (building_stmt_tree ())
1275 finish_expr_stmt (rval
);
1277 genrtl_expr_stmt (rval
);
1281 /* This function is responsible for initializing EXP with INIT
1284 BINFO is the binfo of the type for who we are performing the
1285 initialization. For example, if W is a virtual base class of A and B,
1287 If we are initializing B, then W must contain B's W vtable, whereas
1288 were we initializing C, W must contain C's W vtable.
1290 TRUE_EXP is nonzero if it is the true expression being initialized.
1291 In this case, it may be EXP, or may just contain EXP. The reason we
1292 need this is because if EXP is a base element of TRUE_EXP, we
1293 don't necessarily know by looking at EXP where its virtual
1294 baseclass fields should really be pointing. But we do know
1295 from TRUE_EXP. In constructors, we don't know anything about
1296 the value being initialized.
1298 FLAGS is just passes to `build_method_call'. See that function for
1302 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, flags
)
1308 tree type
= TREE_TYPE (exp
);
1310 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1312 /* Use a function returning the desired type to initialize EXP for us.
1313 If the function is a constructor, and its first argument is
1314 NULL_TREE, know that it was meant for us--just slide exp on
1315 in and expand the constructor. Constructors now come
1318 if (init
&& TREE_CODE (exp
) == VAR_DECL
1319 && TREE_CODE (init
) == CONSTRUCTOR
1320 && TREE_HAS_CONSTRUCTOR (init
))
1322 /* If store_init_value returns NULL_TREE, the INIT has been
1323 record in the DECL_INITIAL for EXP. That means there's
1324 nothing more we have to do. */
1325 if (!store_init_value (exp
, init
))
1327 if (!building_stmt_tree ())
1328 expand_decl_init (exp
);
1331 finish_expr_stmt (build (INIT_EXPR
, type
, exp
, init
));
1335 /* We know that expand_default_init can handle everything we want
1337 expand_default_init (binfo
, true_exp
, exp
, init
, flags
);
1340 /* Report an error if TYPE is not a user-defined, aggregate type. If
1341 OR_ELSE is nonzero, give an error message. */
1344 is_aggr_type (type
, or_else
)
1348 if (type
== error_mark_node
)
1351 if (! IS_AGGR_TYPE (type
)
1352 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1353 && TREE_CODE (type
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
1356 cp_error ("`%T' is not an aggregate type", type
);
1362 /* Like is_aggr_typedef, but returns typedef if successful. */
1365 get_aggr_from_typedef (name
, or_else
)
1371 if (name
== error_mark_node
)
1374 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1375 type
= IDENTIFIER_TYPE_VALUE (name
);
1379 cp_error ("`%T' fails to be an aggregate typedef", name
);
1383 if (! IS_AGGR_TYPE (type
)
1384 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1385 && TREE_CODE (type
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
1388 cp_error ("type `%T' is of non-aggregate type", type
);
1395 get_type_value (name
)
1398 if (name
== error_mark_node
)
1401 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1402 return IDENTIFIER_TYPE_VALUE (name
);
1408 /* This code could just as well go in `class.c', but is placed here for
1411 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1412 the appropriate function call. */
1415 build_member_call (type
, name
, parmlist
)
1416 tree type
, name
, parmlist
;
1421 tree basetype_path
, decl
;
1423 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
1424 && TREE_CODE (type
) == NAMESPACE_DECL
)
1426 /* 'name' already refers to the decls from the namespace, since we
1427 hit do_identifier for template_ids. */
1428 method_name
= TREE_OPERAND (name
, 0);
1429 /* FIXME: Since we don't do independent names right yet, the
1430 name might also be a LOOKUP_EXPR. Once we resolve this to a
1431 real decl earlier, this can go. This may happen during
1433 if (TREE_CODE (method_name
) == LOOKUP_EXPR
)
1435 method_name
= lookup_namespace_name
1436 (type
, TREE_OPERAND (method_name
, 0));
1437 TREE_OPERAND (name
, 0) = method_name
;
1439 my_friendly_assert (is_overloaded_fn (method_name
), 980519);
1440 return build_x_function_call (name
, parmlist
, current_class_ref
);
1444 name
= DECL_NAME (name
);
1446 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1447 return build_x_function_call (lookup_namespace_name (type
, name
),
1448 parmlist
, current_class_ref
);
1450 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1452 method_name
= TREE_OPERAND (name
, 0);
1453 if (TREE_CODE (method_name
) == COMPONENT_REF
)
1454 method_name
= TREE_OPERAND (method_name
, 1);
1455 if (is_overloaded_fn (method_name
))
1456 method_name
= DECL_NAME (OVL_CURRENT (method_name
));
1457 TREE_OPERAND (name
, 0) = method_name
;
1462 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1464 method_name
= TREE_OPERAND (method_name
, 0);
1468 /* This shouldn't be here, and build_member_call shouldn't appear in
1470 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1471 && get_aggr_from_typedef (type
, 0) == 0)
1473 tree ns
= lookup_name (type
, 0);
1474 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1476 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1480 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1481 return error_mark_node
;
1483 /* An operator we did not like. */
1484 if (name
== NULL_TREE
)
1485 return error_mark_node
;
1489 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1491 return error_mark_node
;
1494 decl
= maybe_dummy_object (type
, &basetype_path
);
1496 /* Convert 'this' to the specified type to disambiguate conversion
1497 to the function's context. Apparently Standard C++ says that we
1498 shouldn't do this. */
1499 if (decl
== current_class_ref
1501 && ACCESSIBLY_UNIQUELY_DERIVED_P (type
, current_class_type
))
1503 tree olddecl
= current_class_ptr
;
1504 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1505 if (oldtype
!= type
)
1507 tree newtype
= build_qualified_type (type
, TYPE_QUALS (oldtype
));
1508 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1509 decl
= build_indirect_ref (decl
, NULL
);
1513 if (method_name
== constructor_name (type
)
1514 || method_name
== constructor_name_full (type
))
1515 return build_functional_cast (type
, parmlist
);
1516 if (lookup_fnfields (basetype_path
, method_name
, 0))
1517 return build_method_call (decl
,
1518 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1519 ? name
: method_name
,
1520 parmlist
, basetype_path
,
1521 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1522 if (TREE_CODE (name
) == IDENTIFIER_NODE
1523 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1525 if (t
== error_mark_node
)
1526 return error_mark_node
;
1527 if (TREE_CODE (t
) == FIELD_DECL
)
1529 if (is_dummy_object (decl
))
1531 cp_error ("invalid use of non-static field `%D'", t
);
1532 return error_mark_node
;
1534 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1536 else if (TREE_CODE (t
) == VAR_DECL
)
1540 cp_error ("invalid use of member `%D'", t
);
1541 return error_mark_node
;
1543 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1544 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1545 parmlist
, NULL_TREE
);
1546 return build_function_call (decl
, parmlist
);
1550 cp_error ("no method `%T::%D'", type
, name
);
1551 return error_mark_node
;
1555 /* Build a reference to a member of an aggregate. This is not a
1556 C++ `&', but really something which can have its address taken,
1557 and then act as a pointer to member, for example TYPE :: FIELD
1558 can have its address taken by saying & TYPE :: FIELD.
1560 @@ Prints out lousy diagnostics for operator <typename>
1563 @@ This function should be rewritten and placed in search.c. */
1566 build_offset_ref (type
, name
)
1569 tree decl
, t
= error_mark_node
;
1571 tree basebinfo
= NULL_TREE
;
1572 tree orig_name
= name
;
1574 /* class templates can come in as TEMPLATE_DECLs here. */
1575 if (TREE_CODE (name
) == TEMPLATE_DECL
)
1578 if (processing_template_decl
|| uses_template_parms (type
))
1579 return build_min_nt (SCOPE_REF
, type
, name
);
1581 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
1583 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1584 something like `a.template f<int>' or the like. For the most
1585 part, we treat this just like a.f. We do remember, however,
1586 the template-id that was used. */
1587 name
= TREE_OPERAND (orig_name
, 0);
1590 name
= DECL_NAME (name
);
1593 if (TREE_CODE (name
) == LOOKUP_EXPR
)
1594 /* This can happen during tsubst'ing. */
1595 name
= TREE_OPERAND (name
, 0);
1598 if (TREE_CODE (name
) == COMPONENT_REF
)
1599 name
= TREE_OPERAND (name
, 1);
1600 if (TREE_CODE (name
) == OVERLOAD
)
1601 name
= DECL_NAME (OVL_CURRENT (name
));
1605 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
1608 if (type
== NULL_TREE
)
1609 return error_mark_node
;
1611 /* Handle namespace names fully here. */
1612 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1614 t
= lookup_namespace_name (type
, name
);
1615 if (t
== error_mark_node
)
1617 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1618 /* Reconstruct the TEMPLATE_ID_EXPR. */
1619 t
= build (TEMPLATE_ID_EXPR
, TREE_TYPE (t
),
1620 t
, TREE_OPERAND (orig_name
, 1));
1621 if (! type_unknown_p (t
))
1624 t
= convert_from_reference (t
);
1629 if (! is_aggr_type (type
, 1))
1630 return error_mark_node
;
1632 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1634 if (! check_dtor_name (type
, name
))
1635 cp_error ("qualified type `%T' does not match destructor name `~%T'",
1636 type
, TREE_OPERAND (name
, 0));
1637 name
= dtor_identifier
;
1640 if (!COMPLETE_TYPE_P (complete_type (type
))
1641 && !TYPE_BEING_DEFINED (type
))
1643 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1645 return error_mark_node
;
1648 decl
= maybe_dummy_object (type
, &basebinfo
);
1650 member
= lookup_member (basebinfo
, name
, 1, 0);
1652 if (member
== error_mark_node
)
1653 return error_mark_node
;
1655 /* A lot of this logic is now handled in lookup_member. */
1656 if (member
&& BASELINK_P (member
))
1658 /* Go from the TREE_BASELINK to the member function info. */
1659 tree fnfields
= member
;
1660 t
= TREE_VALUE (fnfields
);
1662 if (TREE_CODE (orig_name
) == TEMPLATE_ID_EXPR
)
1664 /* The FNFIELDS are going to contain functions that aren't
1665 necessarily templates, and templates that don't
1666 necessarily match the explicit template parameters. We
1667 save all the functions, and the explicit parameters, and
1668 then figure out exactly what to instantiate with what
1669 arguments in instantiate_type. */
1671 if (TREE_CODE (t
) != OVERLOAD
)
1672 /* The code in instantiate_type which will process this
1673 expects to encounter OVERLOADs, not raw functions. */
1674 t
= ovl_cons (t
, NULL_TREE
);
1676 t
= build (TEMPLATE_ID_EXPR
, TREE_TYPE (t
), t
,
1677 TREE_OPERAND (orig_name
, 1));
1678 t
= build (OFFSET_REF
, unknown_type_node
, decl
, t
);
1680 PTRMEM_OK_P (t
) = 1;
1685 if (!really_overloaded_fn (t
))
1687 /* Get rid of a potential OVERLOAD around it */
1688 t
= OVL_CURRENT (t
);
1690 /* unique functions are handled easily. */
1691 if (!enforce_access (basebinfo
, t
))
1692 return error_mark_node
;
1694 if (DECL_STATIC_FUNCTION_P (t
))
1696 t
= build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1697 PTRMEM_OK_P (t
) = 1;
1701 TREE_TYPE (fnfields
) = unknown_type_node
;
1703 t
= build (OFFSET_REF
, unknown_type_node
, decl
, fnfields
);
1704 PTRMEM_OK_P (t
) = 1;
1712 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1713 return error_mark_node
;
1716 if (TREE_CODE (t
) == TYPE_DECL
)
1721 /* static class members and class-specific enum
1722 values can be returned without further ado. */
1723 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1726 return convert_from_reference (t
);
1729 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_C_BIT_FIELD (t
))
1731 cp_error ("illegal pointer to bit field `%D'", t
);
1732 return error_mark_node
;
1735 /* static class functions too. */
1736 if (TREE_CODE (t
) == FUNCTION_DECL
1737 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1738 my_friendly_abort (53);
1740 /* In member functions, the form `type::name' is no longer
1741 equivalent to `this->type::name', at least not until
1742 resolve_offset_ref. */
1743 t
= build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1744 PTRMEM_OK_P (t
) = 1;
1748 /* If a OFFSET_REF made it through to here, then it did
1749 not have its address taken. */
1752 resolve_offset_ref (exp
)
1755 tree type
= TREE_TYPE (exp
);
1756 tree base
= NULL_TREE
;
1758 tree basetype
, addr
;
1760 if (TREE_CODE (exp
) == OFFSET_REF
)
1762 member
= TREE_OPERAND (exp
, 1);
1763 base
= TREE_OPERAND (exp
, 0);
1767 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1768 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1770 error ("object missing in use of pointer-to-member construct");
1771 return error_mark_node
;
1774 type
= TREE_TYPE (type
);
1775 base
= current_class_ref
;
1778 if (BASELINK_P (member
) || TREE_CODE (member
) == TEMPLATE_ID_EXPR
)
1779 return build_unary_op (ADDR_EXPR
, exp
, 0);
1781 if (TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1783 if (!flag_ms_extensions
)
1784 /* A single non-static member, make sure we don't allow a
1785 pointer-to-member. */
1786 exp
= ovl_cons (member
, NULL_TREE
);
1788 return build_unary_op (ADDR_EXPR
, exp
, 0);
1791 if ((TREE_CODE (member
) == VAR_DECL
1792 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
))
1793 && ! TYPE_PTRMEM_P (TREE_TYPE (member
)))
1794 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
)
1796 /* These were static members. */
1797 if (mark_addressable (member
) == 0)
1798 return error_mark_node
;
1802 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1803 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1806 /* Syntax error can cause a member which should
1807 have been seen as static to be grok'd as non-static. */
1808 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1810 cp_error_at ("member `%D' is non-static but referenced as a static member",
1812 error ("at this point in file");
1813 return error_mark_node
;
1816 /* The first case is really just a reference to a member of `this'. */
1817 if (TREE_CODE (member
) == FIELD_DECL
1818 && (base
== current_class_ref
|| is_dummy_object (base
)))
1822 basetype
= DECL_CONTEXT (member
);
1824 /* Try to get to basetype from 'this'; if that doesn't work,
1826 base
= current_class_ref
;
1828 /* First convert to the intermediate base specified, if appropriate. */
1829 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1830 base
= build_scoped_ref (base
, TYPE_OFFSET_BASETYPE (type
));
1832 basetype
= lookup_base (TREE_TYPE (base
), basetype
, ba_check
, NULL
);
1833 expr
= build_base_path (PLUS_EXPR
, base
, basetype
, 1);
1835 if (expr
== error_mark_node
)
1836 return error_mark_node
;
1838 expr
= build (COMPONENT_REF
, TREE_TYPE (member
),
1840 return convert_from_reference (expr
);
1843 /* Ensure that we have an object. */
1844 if (is_dummy_object (base
))
1845 addr
= error_mark_node
;
1847 /* If this is a reference to a member function, then return the
1848 address of the member function (which may involve going
1849 through the object's vtable), otherwise, return an expression
1850 for the dereferenced pointer-to-member construct. */
1851 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1853 if (TYPE_PTRMEM_P (TREE_TYPE (member
)))
1855 if (addr
== error_mark_node
)
1857 cp_error ("object missing in `%E'", exp
);
1858 return error_mark_node
;
1861 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (TREE_TYPE (member
)));
1862 basetype
= lookup_base (TREE_TYPE (TREE_TYPE (addr
)),
1863 basetype
, ba_check
, NULL
);
1864 addr
= build_base_path (PLUS_EXPR
, addr
, basetype
, 1);
1866 member
= cp_convert (ptrdiff_type_node
, member
);
1868 return build1 (INDIRECT_REF
, type
,
1869 build (PLUS_EXPR
, build_pointer_type (type
),
1872 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1874 return get_member_function_from_ptrfunc (&addr
, member
);
1876 my_friendly_abort (56);
1881 /* If DECL is a `const' declaration, and its value is a known
1882 constant, then return that value. */
1885 decl_constant_value (decl
)
1888 if (TREE_READONLY_DECL_P (decl
)
1889 && ! TREE_THIS_VOLATILE (decl
)
1890 && DECL_INITIAL (decl
)
1891 && DECL_INITIAL (decl
) != error_mark_node
1892 /* This is invalid if initial value is not constant.
1893 If it has either a function call, a memory reference,
1894 or a variable, then re-evaluating it could give different results. */
1895 && TREE_CONSTANT (DECL_INITIAL (decl
))
1896 /* Check for cases where this is sub-optimal, even though valid. */
1897 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1898 return DECL_INITIAL (decl
);
1902 /* Common subroutines of build_new and build_vec_delete. */
1904 /* Call the global __builtin_delete to delete ADDR. */
1907 build_builtin_delete_call (addr
)
1910 mark_used (global_delete_fndecl
);
1911 return build_call (global_delete_fndecl
, build_tree_list (NULL_TREE
, addr
));
1914 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1915 (which needs to go through some sort of groktypename) or it
1916 is the name of the class we are newing. INIT is an initialization value.
1917 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1918 If INIT is void_type_node, it means do *not* call a constructor
1921 For types with constructors, the data returned is initialized
1922 by the appropriate constructor.
1924 Whether the type has a constructor or not, if it has a pointer
1925 to a virtual function table, then that pointer is set up
1928 Unless I am mistaken, a call to new () will return initialized
1929 data regardless of whether the constructor itself is private or
1930 not. NOPE; new fails if the constructor is private (jcm).
1932 Note that build_new does nothing to assure that any special
1933 alignment requirements of the type are met. Rather, it leaves
1934 it up to malloc to do the right thing. Otherwise, folding to
1935 the right alignment cal cause problems if the user tries to later
1936 free the memory returned by `new'.
1938 PLACEMENT is the `placement' list for user-defined operator new (). */
1941 build_new (placement
, decl
, init
, use_global_new
)
1947 tree nelts
= NULL_TREE
, t
;
1950 if (decl
== error_mark_node
)
1951 return error_mark_node
;
1953 if (TREE_CODE (decl
) == TREE_LIST
)
1955 tree absdcl
= TREE_VALUE (decl
);
1956 tree last_absdcl
= NULL_TREE
;
1958 if (current_function_decl
1959 && DECL_CONSTRUCTOR_P (current_function_decl
))
1960 my_friendly_assert (immediate_size_expand
== 0, 19990926);
1962 nelts
= integer_one_node
;
1964 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
1965 my_friendly_abort (215);
1966 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
1968 last_absdcl
= absdcl
;
1969 absdcl
= TREE_OPERAND (absdcl
, 0);
1972 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
1974 /* probably meant to be a vec new */
1977 while (TREE_OPERAND (absdcl
, 0)
1978 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
1980 last_absdcl
= absdcl
;
1981 absdcl
= TREE_OPERAND (absdcl
, 0);
1985 this_nelts
= TREE_OPERAND (absdcl
, 1);
1986 if (this_nelts
!= error_mark_node
)
1988 if (this_nelts
== NULL_TREE
)
1989 error ("new of array type fails to specify size");
1990 else if (processing_template_decl
)
1993 absdcl
= TREE_OPERAND (absdcl
, 0);
1997 if (build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
2000 pedwarn ("size in array new must have integral type");
2002 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2003 absdcl
= TREE_OPERAND (absdcl
, 0);
2004 if (this_nelts
== integer_zero_node
)
2006 warning ("zero size array reserves no space");
2007 nelts
= integer_zero_node
;
2010 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2014 nelts
= integer_zero_node
;
2018 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2020 TREE_VALUE (decl
) = absdcl
;
2022 type
= groktypename (decl
);
2023 if (! type
|| type
== error_mark_node
)
2024 return error_mark_node
;
2026 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2028 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2030 /* An aggregate type. */
2031 type
= IDENTIFIER_TYPE_VALUE (decl
);
2032 decl
= TYPE_MAIN_DECL (type
);
2036 /* A builtin type. */
2037 decl
= lookup_name (decl
, 1);
2038 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2039 type
= TREE_TYPE (decl
);
2042 else if (TREE_CODE (decl
) == TYPE_DECL
)
2044 type
= TREE_TYPE (decl
);
2049 decl
= TYPE_MAIN_DECL (type
);
2052 if (processing_template_decl
)
2055 t
= tree_cons (tree_cons (NULL_TREE
, type
, NULL_TREE
),
2056 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2061 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2062 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2066 /* ``A reference cannot be created by the new operator. A reference
2067 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2068 returned by new.'' ARM 5.3.3 */
2069 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2071 error ("new cannot be applied to a reference type");
2072 type
= TREE_TYPE (type
);
2075 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2077 error ("new cannot be applied to a function type");
2078 return error_mark_node
;
2081 /* When the object being created is an array, the new-expression yields a
2082 pointer to the initial element (if any) of the array. For example,
2083 both new int and new int[10] return an int*. 5.3.4. */
2084 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2086 nelts
= array_type_nelts_top (type
);
2088 type
= TREE_TYPE (type
);
2092 t
= build_nt (ARRAY_REF
, type
, nelts
);
2096 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2097 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2098 TREE_SIDE_EFFECTS (rval
) = 1;
2099 rval
= build_new_1 (rval
);
2100 if (rval
== error_mark_node
)
2101 return error_mark_node
;
2103 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2104 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2105 TREE_NO_UNUSED_WARNING (rval
) = 1;
2110 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2113 build_java_class_ref (type
)
2116 tree name
= NULL_TREE
, class_decl
;
2117 static tree CL_suffix
= NULL_TREE
;
2118 if (CL_suffix
== NULL_TREE
)
2119 CL_suffix
= get_identifier("class$");
2120 if (jclass_node
== NULL_TREE
)
2122 jclass_node
= IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2123 if (jclass_node
== NULL_TREE
)
2124 fatal_error ("call to Java constructor, while `jclass' undefined");
2126 jclass_node
= TREE_TYPE (jclass_node
);
2129 /* Mangle the class$ field */
2132 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
2133 if (DECL_NAME (field
) == CL_suffix
)
2135 mangle_decl (field
);
2136 name
= DECL_ASSEMBLER_NAME (field
);
2140 internal_error ("Can't find class$");
2143 class_decl
= IDENTIFIER_GLOBAL_VALUE (name
);
2144 if (class_decl
== NULL_TREE
)
2146 class_decl
= build_decl (VAR_DECL
, name
, TREE_TYPE (jclass_node
));
2147 TREE_STATIC (class_decl
) = 1;
2148 DECL_EXTERNAL (class_decl
) = 1;
2149 TREE_PUBLIC (class_decl
) = 1;
2150 DECL_ARTIFICIAL (class_decl
) = 1;
2151 DECL_IGNORED_P (class_decl
) = 1;
2152 pushdecl_top_level (class_decl
);
2153 make_decl_rtl (class_decl
, NULL
);
2158 /* Returns the size of the cookie to use when allocating an array
2159 whose elements have the indicated TYPE. Assumes that it is already
2160 known that a cookie is needed. */
2163 get_cookie_size (type
)
2168 /* We need to allocate an additional max (sizeof (size_t), alignof
2169 (true_type)) bytes. */
2173 sizetype_size
= size_in_bytes (sizetype
);
2174 type_align
= size_int (TYPE_ALIGN_UNIT (type
));
2175 if (INT_CST_LT_UNSIGNED (type_align
, sizetype_size
))
2176 cookie_size
= sizetype_size
;
2178 cookie_size
= type_align
;
2183 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2184 value is immediately handed to expand_expr. */
2190 tree placement
, init
;
2191 tree type
, true_type
, size
, rval
, t
;
2193 tree nelts
= NULL_TREE
;
2194 tree alloc_call
, alloc_expr
, alloc_node
;
2195 tree cookie_expr
, init_expr
;
2197 enum tree_code code
;
2198 int use_cookie
, nothrow
, check_new
;
2199 /* Nonzero if the user wrote `::new' rather than just `new'. */
2200 int globally_qualified_p
;
2201 /* Nonzero if we're going to call a global operator new, rather than
2202 a class-specific version. */
2204 int use_java_new
= 0;
2205 /* If non-NULL, the number of extra bytes to allocate at the
2206 beginning of the storage allocated for an array-new expression in
2207 order to store the number of elements. */
2208 tree cookie_size
= NULL_TREE
;
2209 /* True if the function we are calling is a placement allocation
2211 bool placement_allocation_fn_p
;
2213 placement
= TREE_OPERAND (exp
, 0);
2214 type
= TREE_OPERAND (exp
, 1);
2215 init
= TREE_OPERAND (exp
, 2);
2216 globally_qualified_p
= NEW_EXPR_USE_GLOBAL (exp
);
2218 if (TREE_CODE (type
) == ARRAY_REF
)
2221 nelts
= TREE_OPERAND (type
, 1);
2222 type
= TREE_OPERAND (type
, 0);
2224 full_type
= cp_build_binary_op (MINUS_EXPR
, nelts
, integer_one_node
);
2225 full_type
= build_index_type (full_type
);
2226 full_type
= build_cplus_array_type (type
, full_type
);
2233 code
= has_array
? VEC_NEW_EXPR
: NEW_EXPR
;
2235 /* If our base type is an array, then make sure we know how many elements
2237 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2239 tree this_nelts
= array_type_nelts_top (true_type
);
2240 nelts
= cp_build_binary_op (MULT_EXPR
, nelts
, this_nelts
);
2241 true_type
= TREE_TYPE (true_type
);
2244 if (!complete_type_or_else (true_type
, exp
))
2245 return error_mark_node
;
2247 size
= size_in_bytes (true_type
);
2249 size
= fold (cp_build_binary_op (MULT_EXPR
, size
, nelts
));
2251 if (TREE_CODE (true_type
) == VOID_TYPE
)
2253 error ("invalid type `void' for new");
2254 return error_mark_node
;
2257 if (abstract_virtuals_error (NULL_TREE
, true_type
))
2258 return error_mark_node
;
2260 /* Figure out whether or not we're going to use the global operator
2262 if (!globally_qualified_p
2263 && IS_AGGR_TYPE (true_type
)
2265 ? TYPE_HAS_ARRAY_NEW_OPERATOR (true_type
)
2266 : TYPE_HAS_NEW_OPERATOR (true_type
)))
2271 /* We only need cookies for arrays containing types for which we
2273 if (!has_array
|| !TYPE_VEC_NEW_USES_COOKIE (true_type
))
2275 /* When using placement new, users may not realize that they need
2276 the extra storage. We require that the operator called be
2277 the global placement operator delete[]. */
2278 else if (placement
&& !TREE_CHAIN (placement
)
2279 && same_type_p (TREE_TYPE (TREE_VALUE (placement
)),
2281 use_cookie
= !use_global_new
;
2282 /* Otherwise, we need the cookie. */
2286 /* Compute the number of extra bytes to allocate, now that we know
2287 whether or not we need the cookie. */
2290 cookie_size
= get_cookie_size (true_type
);
2291 size
= size_binop (PLUS_EXPR
, size
, cookie_size
);
2294 /* Allocate the object. */
2296 if (! placement
&& TYPE_FOR_JAVA (true_type
))
2298 tree class_addr
, alloc_decl
;
2299 tree class_decl
= build_java_class_ref (true_type
);
2300 tree class_size
= size_in_bytes (true_type
);
2301 static const char alloc_name
[] = "_Jv_AllocObject";
2303 alloc_decl
= IDENTIFIER_GLOBAL_VALUE (get_identifier (alloc_name
));
2304 if (alloc_decl
== NULL_TREE
)
2305 fatal_error ("call to Java constructor with `%s' undefined",
2308 class_addr
= build1 (ADDR_EXPR
, jclass_node
, class_decl
);
2309 alloc_call
= (build_function_call
2311 tree_cons (NULL_TREE
, class_addr
,
2312 build_tree_list (NULL_TREE
, class_size
))));
2319 args
= tree_cons (NULL_TREE
, size
, placement
);
2320 fnname
= ansi_opname (code
);
2323 alloc_call
= (build_new_function_call
2324 (lookup_function_nonclass (fnname
, args
),
2327 alloc_call
= build_method_call (build_dummy_object (true_type
),
2328 fnname
, args
, NULL_TREE
,
2332 if (alloc_call
== error_mark_node
)
2333 return error_mark_node
;
2335 /* The ALLOC_CALL should be a CALL_EXPR, and the first operand
2336 should be the address of a known FUNCTION_DECL. */
2337 my_friendly_assert (TREE_CODE (alloc_call
) == CALL_EXPR
, 20000521);
2338 t
= TREE_OPERAND (alloc_call
, 0);
2339 my_friendly_assert (TREE_CODE (t
) == ADDR_EXPR
, 20000521);
2340 t
= TREE_OPERAND (t
, 0);
2341 my_friendly_assert (TREE_CODE (t
) == FUNCTION_DECL
, 20000521);
2342 /* Now, check to see if this function is actually a placement
2343 allocation function. This can happen even when PLACEMENT is NULL
2344 because we might have something like:
2346 struct S { void* operator new (size_t, int i = 0); };
2348 A call to `new S' will get this allocation function, even though
2349 there is no explicit placement argument. If there is more than
2350 one argument, or there are variable arguments, then this is a
2351 placement allocation function. */
2352 placement_allocation_fn_p
2353 = (type_num_arguments (TREE_TYPE (t
)) > 1 || varargs_function_p (t
));
2355 /* unless an allocation function is declared with an empty excep-
2356 tion-specification (_except.spec_), throw(), it indicates failure to
2357 allocate storage by throwing a bad_alloc exception (clause _except_,
2358 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2359 cation function is declared with an empty exception-specification,
2360 throw(), it returns null to indicate failure to allocate storage and a
2361 non-null pointer otherwise.
2363 So check for a null exception spec on the op new we just called. */
2365 /* The ADDR_EXPR. */
2366 t
= TREE_OPERAND (alloc_call
, 0);
2368 t
= TREE_OPERAND (t
, 0);
2369 nothrow
= TYPE_NOTHROW_P (TREE_TYPE (t
));
2370 check_new
= (flag_check_new
|| nothrow
) && ! use_java_new
;
2372 alloc_expr
= alloc_call
;
2375 /* Adjust so we're pointing to the start of the object. */
2376 alloc_expr
= build (PLUS_EXPR
, TREE_TYPE (alloc_expr
),
2377 alloc_expr
, cookie_size
);
2379 /* While we're working, use a pointer to the type we've actually
2381 alloc_expr
= convert (build_pointer_type (full_type
), alloc_expr
);
2383 /* Now save the allocation expression so we only evaluate it once. */
2384 alloc_expr
= get_target_expr (alloc_expr
);
2385 alloc_node
= TREE_OPERAND (alloc_expr
, 0);
2387 /* Now initialize the cookie. */
2392 /* Store the number of bytes allocated so that we can know how
2393 many elements to destroy later. We use the last sizeof
2394 (size_t) bytes to store the number of elements. */
2395 cookie
= build (MINUS_EXPR
, build_pointer_type (sizetype
),
2396 alloc_node
, size_in_bytes (sizetype
));
2397 cookie
= build_indirect_ref (cookie
, NULL
);
2399 cookie_expr
= build (MODIFY_EXPR
, void_type_node
, cookie
, nelts
);
2400 TREE_SIDE_EFFECTS (cookie_expr
) = 1;
2403 cookie_expr
= NULL_TREE
;
2405 /* Now initialize the allocated object. */
2406 init_expr
= NULL_TREE
;
2407 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2409 init_expr
= build_indirect_ref (alloc_node
, NULL
);
2411 if (init
== void_zero_node
)
2412 init
= build_default_init (full_type
);
2413 else if (init
&& pedantic
&& has_array
)
2414 cp_pedwarn ("ISO C++ forbids initialization in array new");
2417 init_expr
= build_vec_init (init_expr
, init
, 0);
2418 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2419 init_expr
= build_method_call (init_expr
,
2420 complete_ctor_identifier
,
2421 init
, TYPE_BINFO (true_type
),
2425 /* We are processing something like `new int (10)', which
2426 means allocate an int, and initialize it with 10. */
2428 if (TREE_CODE (init
) == TREE_LIST
)
2430 if (TREE_CHAIN (init
) != NULL_TREE
)
2432 ("initializer list being treated as compound expression");
2433 init
= build_compound_expr (init
);
2435 else if (TREE_CODE (init
) == CONSTRUCTOR
2436 && TREE_TYPE (init
) == NULL_TREE
)
2438 pedwarn ("ISO C++ forbids aggregate initializer to new");
2439 init
= digest_init (type
, init
, 0);
2442 init_expr
= build_modify_expr (init_expr
, INIT_EXPR
, init
);
2445 if (init_expr
== error_mark_node
)
2446 return error_mark_node
;
2448 /* If any part of the object initialization terminates by throwing an
2449 exception and a suitable deallocation function can be found, the
2450 deallocation function is called to free the memory in which the
2451 object was being constructed, after which the exception continues
2452 to propagate in the context of the new-expression. If no
2453 unambiguous matching deallocation function can be found,
2454 propagating the exception does not cause the object's memory to be
2456 if (flag_exceptions
&& ! use_java_new
)
2458 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2460 int flags
= (LOOKUP_NORMAL
2461 | (globally_qualified_p
* LOOKUP_GLOBAL
));
2463 /* The Standard is unclear here, but the right thing to do
2464 is to use the same method for finding deallocation
2465 functions that we use for finding allocation functions. */
2466 flags
|= LOOKUP_SPECULATIVELY
;
2468 cleanup
= build_op_delete_call (dcode
, alloc_node
, size
, flags
,
2469 (placement_allocation_fn_p
2470 ? alloc_call
: NULL_TREE
));
2472 /* Ack! First we allocate the memory. Then we set our sentry
2473 variable to true, and expand a cleanup that deletes the memory
2474 if sentry is true. Then we run the constructor, and finally
2477 It would be nice to be able to handle this without the sentry
2478 variable, perhaps with a TRY_CATCH_EXPR, but this doesn't
2479 work. We allocate the space first, so if there are any
2480 temporaries with cleanups in the constructor args we need this
2481 EH region to extend until end of full-expression to preserve
2484 If the backend had some mechanism so that we could force the
2485 allocation to be expanded after all the other args to the
2486 constructor, that would fix the nesting problem and we could
2487 do away with this complexity. But that would complicate other
2488 things; in particular, it would make it difficult to bail out
2489 if the allocation function returns null. */
2493 tree end
, sentry
, begin
;
2495 begin
= get_target_expr (boolean_true_node
);
2496 sentry
= TREE_OPERAND (begin
, 0);
2498 TREE_OPERAND (begin
, 2)
2499 = build (COND_EXPR
, void_type_node
, sentry
,
2500 cleanup
, void_zero_node
);
2502 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2503 sentry
, boolean_false_node
);
2506 = build (COMPOUND_EXPR
, void_type_node
, begin
,
2507 build (COMPOUND_EXPR
, void_type_node
, init_expr
,
2512 else if (CP_TYPE_CONST_P (true_type
))
2513 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2515 /* Now build up the return value in reverse order. */
2520 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), init_expr
, rval
);
2522 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), cookie_expr
, rval
);
2524 if (rval
== alloc_node
)
2525 /* If we didn't modify anything, strip the TARGET_EXPR and return the
2527 rval
= TREE_OPERAND (alloc_expr
, 1);
2532 tree ifexp
= cp_build_binary_op (NE_EXPR
, alloc_node
,
2534 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2537 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2540 /* Now strip the outer ARRAY_TYPE, so we return a pointer to the first
2542 rval
= convert (build_pointer_type (type
), rval
);
2548 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, use_global_delete
)
2549 tree base
, maxindex
, type
;
2550 special_function_kind auto_delete_vec
;
2551 int use_global_delete
;
2554 tree ptype
= build_pointer_type (type
= complete_type (type
));
2555 tree size_exp
= size_in_bytes (type
);
2557 /* Temporary variables used by the loop. */
2558 tree tbase
, tbase_init
;
2560 /* This is the body of the loop that implements the deletion of a
2561 single element, and moves temp variables to next elements. */
2564 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2567 /* This is the thing that governs what to do after the loop has run. */
2568 tree deallocate_expr
= 0;
2570 /* This is the BIND_EXPR which holds the outermost iterator of the
2571 loop. It is convenient to set this variable up and test it before
2572 executing any other code in the loop.
2573 This is also the containing expression returned by this function. */
2574 tree controller
= NULL_TREE
;
2576 if (! IS_AGGR_TYPE (type
) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
2578 loop
= integer_zero_node
;
2582 /* The below is short by the cookie size. */
2583 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2584 convert (sizetype
, maxindex
));
2586 tbase
= create_temporary_var (ptype
);
2587 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2588 fold (build (PLUS_EXPR
, ptype
,
2591 DECL_REGISTER (tbase
) = 1;
2592 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2593 TREE_SIDE_EFFECTS (controller
) = 1;
2597 body
= tree_cons (NULL_TREE
,
2598 build_delete (ptype
, tbase
, sfk_complete_destructor
,
2599 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2602 body
= tree_cons (NULL_TREE
,
2603 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2606 body
= tree_cons (NULL_TREE
,
2607 build (EXIT_EXPR
, void_type_node
,
2608 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2611 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2613 loop
= tree_cons (NULL_TREE
, tbase_init
,
2614 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2615 loop
= build_compound_expr (loop
);
2618 /* If the delete flag is one, or anything else with the low bit set,
2619 delete the storage. */
2620 deallocate_expr
= integer_zero_node
;
2621 if (auto_delete_vec
!= sfk_base_destructor
)
2625 /* The below is short by the cookie size. */
2626 virtual_size
= size_binop (MULT_EXPR
, size_exp
,
2627 convert (sizetype
, maxindex
));
2629 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2636 cookie_size
= get_cookie_size (type
);
2638 = cp_convert (ptype
,
2639 cp_build_binary_op (MINUS_EXPR
,
2640 cp_convert (string_type_node
,
2643 /* True size with header. */
2644 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, cookie_size
);
2647 if (auto_delete_vec
== sfk_deleting_destructor
)
2648 deallocate_expr
= build_x_delete (base_tbd
,
2649 2 | use_global_delete
,
2653 if (loop
&& deallocate_expr
!= integer_zero_node
)
2655 body
= tree_cons (NULL_TREE
, loop
,
2656 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2657 body
= build_compound_expr (body
);
2662 /* Outermost wrapper: If pointer is null, punt. */
2663 body
= fold (build (COND_EXPR
, void_type_node
,
2664 fold (build (NE_EXPR
, boolean_type_node
, base
,
2665 integer_zero_node
)),
2666 body
, integer_zero_node
));
2667 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2671 TREE_OPERAND (controller
, 1) = body
;
2675 return cp_convert (void_type_node
, body
);
2678 /* Create an unnamed variable of the indicated TYPE. */
2681 create_temporary_var (type
)
2686 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2687 TREE_USED (decl
) = 1;
2688 DECL_ARTIFICIAL (decl
) = 1;
2689 DECL_SOURCE_FILE (decl
) = input_filename
;
2690 DECL_SOURCE_LINE (decl
) = lineno
;
2691 DECL_IGNORED_P (decl
) = 1;
2692 DECL_CONTEXT (decl
) = current_function_decl
;
2697 /* Create a new temporary variable of the indicated TYPE, initialized
2700 It is not entered into current_binding_level, because that breaks
2701 things when it comes time to do final cleanups (which take place
2702 "outside" the binding contour of the function). */
2705 get_temp_regvar (type
, init
)
2710 decl
= create_temporary_var (type
);
2711 if (building_stmt_tree ())
2712 add_decl_stmt (decl
);
2713 if (!building_stmt_tree ())
2714 SET_DECL_RTL (decl
, assign_temp (type
, 2, 0, 1));
2715 finish_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
2720 /* `build_vec_init' returns tree structure that performs
2721 initialization of a vector of aggregate types.
2723 BASE is a reference to the vector, of ARRAY_TYPE.
2724 INIT is the (possibly NULL) initializer.
2726 FROM_ARRAY is 0 if we should init everything with INIT
2727 (i.e., every element initialized from INIT).
2728 FROM_ARRAY is 1 if we should index into INIT in parallel
2729 with initialization of DECL.
2730 FROM_ARRAY is 2 if we should index into INIT in parallel,
2731 but use assignment instead of initialization. */
2734 build_vec_init (base
, init
, from_array
)
2739 tree base2
= NULL_TREE
;
2741 tree itype
= NULL_TREE
;
2743 /* The type of the array. */
2744 tree atype
= TREE_TYPE (base
);
2745 /* The type of an element in the array. */
2746 tree type
= TREE_TYPE (atype
);
2747 /* The type of a pointer to an element in the array. */
2752 tree try_block
= NULL_TREE
;
2753 tree try_body
= NULL_TREE
;
2754 int num_initialized_elts
= 0;
2755 tree maxindex
= array_type_nelts (TREE_TYPE (base
));
2757 if (maxindex
== error_mark_node
)
2758 return error_mark_node
;
2760 /* For g++.ext/arrnew.C. */
2761 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
&& TREE_TYPE (init
) == NULL_TREE
)
2762 init
= digest_init (atype
, init
, 0);
2764 if (init
&& !TYPE_NEEDS_CONSTRUCTING (type
)
2765 && ((TREE_CODE (init
) == CONSTRUCTOR
2766 /* Don't do this if the CONSTRUCTOR might contain something
2767 that might throw and require us to clean up. */
2768 && (CONSTRUCTOR_ELTS (init
) == NULL_TREE
2769 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type
))))
2772 /* Do non-default initialization of POD arrays resulting from
2773 brace-enclosed initializers. In this case, digest_init and
2774 store_constructor will handle the semantics for us. */
2776 stmt_expr
= build (INIT_EXPR
, atype
, base
, init
);
2777 TREE_SIDE_EFFECTS (stmt_expr
) = 1;
2781 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2782 ptype
= build_pointer_type (type
);
2783 size
= size_in_bytes (type
);
2784 if (TREE_CODE (TREE_TYPE (base
)) == ARRAY_TYPE
)
2785 base
= cp_convert (ptype
, default_conversion (base
));
2787 /* The code we are generating looks like:
2791 ptrdiff_t iterator = maxindex;
2794 ... initialize *t1 ...
2796 } while (--iterator != -1);
2798 ... destroy elements that were constructed ...
2802 We can omit the try and catch blocks if we know that the
2803 initialization will never throw an exception, or if the array
2804 elements do not have destructors. We can omit the loop completely if
2805 the elements of the array do not have constructors.
2807 We actually wrap the entire body of the above in a STMT_EXPR, for
2810 When copying from array to another, when the array elements have
2811 only trivial copy constructors, we should use __builtin_memcpy
2812 rather than generating a loop. That way, we could take advantage
2813 of whatever cleverness the back-end has for dealing with copies
2814 of blocks of memory. */
2816 begin_init_stmts (&stmt_expr
, &compound_stmt
);
2817 destroy_temps
= stmts_are_full_exprs_p ();
2818 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2819 rval
= get_temp_regvar (ptype
, base
);
2820 base
= get_temp_regvar (ptype
, rval
);
2821 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2823 /* Protect the entire array initialization so that we can destroy
2824 the partially constructed array if an exception is thrown.
2825 But don't do this if we're assigning. */
2826 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2829 try_block
= begin_try_block ();
2830 try_body
= begin_compound_stmt (/*has_no_scope=*/1);
2833 if (init
!= NULL_TREE
&& TREE_CODE (init
) == CONSTRUCTOR
)
2835 /* Do non-default initialization of non-POD arrays resulting from
2836 brace-enclosed initializers. */
2841 for (elts
= CONSTRUCTOR_ELTS (init
); elts
; elts
= TREE_CHAIN (elts
))
2843 tree elt
= TREE_VALUE (elts
);
2844 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2846 num_initialized_elts
++;
2848 if (IS_AGGR_TYPE (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
2849 finish_expr_stmt (build_aggr_init (baseref
, elt
, 0));
2851 finish_expr_stmt (build_modify_expr (baseref
, NOP_EXPR
,
2854 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base
, 0));
2855 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR
, iterator
, 0));
2858 /* Clear out INIT so that we don't get confused below. */
2861 else if (from_array
)
2863 /* If initializing one array from another, initialize element by
2864 element. We rely upon the below calls the do argument
2868 base2
= default_conversion (init
);
2869 itype
= TREE_TYPE (base2
);
2870 base2
= get_temp_regvar (itype
, base2
);
2871 itype
= TREE_TYPE (itype
);
2873 else if (TYPE_LANG_SPECIFIC (type
)
2874 && TYPE_NEEDS_CONSTRUCTING (type
)
2875 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2877 error ("initializer ends prematurely");
2878 return error_mark_node
;
2882 /* Now, default-initialize any remaining elements. We don't need to
2883 do that if a) the type does not need constructing, or b) we've
2884 already initialized all the elements.
2886 We do need to keep going if we're copying an array. */
2889 || (TYPE_NEEDS_CONSTRUCTING (type
)
2890 && ! (host_integerp (maxindex
, 0)
2891 && (num_initialized_elts
2892 == tree_low_cst (maxindex
, 0) + 1))))
2894 /* If the ITERATOR is equal to -1, then we don't have to loop;
2895 we've already initialized all the elements. */
2901 if_stmt
= begin_if_stmt ();
2902 finish_if_stmt_cond (build (NE_EXPR
, boolean_type_node
,
2903 iterator
, integer_minus_one_node
),
2906 /* Otherwise, loop through the elements. */
2907 do_stmt
= begin_do_stmt ();
2908 do_body
= begin_compound_stmt (/*has_no_scope=*/1);
2910 /* When we're not building a statement-tree, things are a little
2911 complicated. If, when we recursively call build_aggr_init,
2912 an expression containing a TARGET_EXPR is expanded, then it
2913 may get a cleanup. Then, the result of that expression is
2914 passed to finish_expr_stmt, which will call
2915 expand_start_target_temps/expand_end_target_temps. However,
2916 the latter call will not cause the cleanup to run because
2917 that block will still be on the block stack. So, we call
2918 expand_start_target_temps here manually; the corresponding
2919 call to expand_end_target_temps below will cause the cleanup
2921 if (!building_stmt_tree ())
2922 expand_start_target_temps ();
2926 tree to
= build1 (INDIRECT_REF
, type
, base
);
2930 from
= build1 (INDIRECT_REF
, itype
, base2
);
2934 if (from_array
== 2)
2935 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
2936 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2937 elt_init
= build_aggr_init (to
, from
, 0);
2939 elt_init
= build_modify_expr (to
, NOP_EXPR
, from
);
2941 my_friendly_abort (57);
2943 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2947 ("cannot initialize multi-dimensional array with initializer");
2948 elt_init
= build_vec_init (build1 (INDIRECT_REF
, type
, base
),
2952 elt_init
= build_aggr_init (build1 (INDIRECT_REF
, type
, base
),
2955 /* The initialization of each array element is a
2956 full-expression, as per core issue 124. */
2957 if (!building_stmt_tree ())
2959 genrtl_expr_stmt (elt_init
);
2960 expand_end_target_temps ();
2964 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
2965 finish_expr_stmt (elt_init
);
2966 current_stmt_tree ()->stmts_are_full_exprs_p
= 0;
2969 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base
, 0));
2971 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR
, base2
, 0));
2973 finish_compound_stmt (/*has_no_scope=*/1, do_body
);
2974 finish_do_body (do_stmt
);
2975 finish_do_stmt (build (NE_EXPR
, boolean_type_node
,
2976 build_unary_op (PREDECREMENT_EXPR
, iterator
, 0),
2977 integer_minus_one_node
),
2980 finish_then_clause (if_stmt
);
2984 /* Make sure to cleanup any partially constructed elements. */
2985 if (flag_exceptions
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
2990 finish_compound_stmt (/*has_no_scope=*/1, try_body
);
2991 finish_cleanup_try_block (try_block
);
2992 e
= build_vec_delete_1 (rval
,
2993 cp_build_binary_op (MINUS_EXPR
, maxindex
,
2996 sfk_base_destructor
,
2997 /*use_global_delete=*/0);
2998 finish_cleanup (e
, try_block
);
3001 /* The value of the array initialization is the address of the
3002 first element in the array. */
3003 finish_expr_stmt (rval
);
3005 stmt_expr
= finish_init_stmts (stmt_expr
, compound_stmt
);
3006 current_stmt_tree ()->stmts_are_full_exprs_p
= destroy_temps
;
3010 /* Free up storage of type TYPE, at address ADDR.
3012 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3015 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3016 used as the second argument to operator delete. It can include
3017 things like padding and magic size cookies. It has virtual in it,
3018 because if you have a base pointer and you delete through a virtual
3019 destructor, it should be the size of the dynamic object, not the
3020 static object, see Free Store 12.5 ISO C++.
3022 This does not call any destructors. */
3025 build_x_delete (addr
, which_delete
, virtual_size
)
3030 int use_global_delete
= which_delete
& 1;
3031 int use_vec_delete
= !!(which_delete
& 2);
3032 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3033 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
3035 return build_op_delete_call (code
, addr
, virtual_size
, flags
, NULL_TREE
);
3038 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3042 build_dtor_call (exp
, dtor_kind
, flags
)
3044 special_function_kind dtor_kind
;
3051 case sfk_complete_destructor
:
3052 name
= complete_dtor_identifier
;
3055 case sfk_base_destructor
:
3056 name
= base_dtor_identifier
;
3059 case sfk_deleting_destructor
:
3060 name
= deleting_dtor_identifier
;
3064 my_friendly_abort (20000524);
3066 return build_method_call (exp
, name
, NULL_TREE
, NULL_TREE
, flags
);
3069 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3070 ADDR is an expression which yields the store to be destroyed.
3071 AUTO_DELETE is the name of the destructor to call, i.e., either
3072 sfk_complete_destructor, sfk_base_destructor, or
3073 sfk_deleting_destructor.
3075 FLAGS is the logical disjunction of zero or more LOOKUP_
3076 flags. See cp-tree.h for more info.
3078 This function does not delete an object's virtual base classes. */
3081 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3083 special_function_kind auto_delete
;
3085 int use_global_delete
;
3090 if (addr
== error_mark_node
)
3091 return error_mark_node
;
3093 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3094 set to `error_mark_node' before it gets properly cleaned up. */
3095 if (type
== error_mark_node
)
3096 return error_mark_node
;
3098 type
= TYPE_MAIN_VARIANT (type
);
3100 if (TREE_CODE (type
) == POINTER_TYPE
)
3102 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3103 if (!VOID_TYPE_P (type
) && !complete_type_or_else (type
, addr
))
3104 return error_mark_node
;
3105 if (TREE_CODE (type
) == ARRAY_TYPE
)
3107 if (! IS_AGGR_TYPE (type
))
3109 /* Call the builtin operator delete. */
3110 return build_builtin_delete_call (addr
);
3112 if (TREE_SIDE_EFFECTS (addr
))
3113 addr
= save_expr (addr
);
3115 /* throw away const and volatile on target type of addr */
3116 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3118 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3121 if (TREE_SIDE_EFFECTS (addr
))
3122 addr
= save_expr (addr
);
3123 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3125 error ("unknown array size in delete");
3126 return error_mark_node
;
3128 return build_vec_delete (addr
, array_type_nelts (type
),
3129 auto_delete
, use_global_delete
);
3133 /* Don't check PROTECT here; leave that decision to the
3134 destructor. If the destructor is accessible, call it,
3135 else report error. */
3136 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3137 if (TREE_SIDE_EFFECTS (addr
))
3138 addr
= save_expr (addr
);
3140 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3143 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3145 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
3147 if (auto_delete
!= sfk_deleting_destructor
)
3148 return void_zero_node
;
3150 return build_op_delete_call
3151 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3152 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
),
3156 /* Below, we will reverse the order in which these calls are made.
3157 If we have a destructor, then that destructor will take care
3158 of the base classes; otherwise, we must do that here. */
3159 if (TYPE_HAS_DESTRUCTOR (type
))
3161 tree do_delete
= NULL_TREE
;
3164 /* For `::delete x', we must not use the deleting destructor
3165 since then we would not be sure to get the global `operator
3167 if (use_global_delete
&& auto_delete
== sfk_deleting_destructor
)
3169 /* We will use ADDR multiple times so we must save it. */
3170 addr
= save_expr (addr
);
3171 /* Delete the object. */
3172 do_delete
= build_builtin_delete_call (addr
);
3173 /* Otherwise, treat this like a complete object destructor
3175 auto_delete
= sfk_complete_destructor
;
3177 /* If the destructor is non-virtual, there is no deleting
3178 variant. Instead, we must explicitly call the appropriate
3179 `operator delete' here. */
3180 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type
))
3181 && auto_delete
== sfk_deleting_destructor
)
3183 /* We will use ADDR multiple times so we must save it. */
3184 addr
= save_expr (addr
);
3185 /* Build the call. */
3186 do_delete
= build_op_delete_call (DELETE_EXPR
,
3188 c_sizeof_nowarn (type
),
3191 /* Call the complete object destructor. */
3192 auto_delete
= sfk_complete_destructor
;
3195 expr
= build_dtor_call (build_indirect_ref (addr
, NULL
),
3196 auto_delete
, flags
);
3198 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3200 if (flags
& LOOKUP_DESTRUCTOR
)
3201 /* Explicit destructor call; don't check for null pointer. */
3202 ifexp
= integer_one_node
;
3204 /* Handle deleting a null pointer. */
3205 ifexp
= fold (cp_build_binary_op (NE_EXPR
, addr
, integer_zero_node
));
3207 if (ifexp
!= integer_one_node
)
3208 expr
= build (COND_EXPR
, void_type_node
,
3209 ifexp
, expr
, void_zero_node
);
3215 /* We only get here from finish_function for a destructor. */
3216 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3217 int i
, n_baseclasses
= CLASSTYPE_N_BASECLASSES (type
);
3218 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3219 tree exprstmt
= NULL_TREE
;
3220 tree ref
= build_indirect_ref (addr
, NULL
);
3222 /* Set this again before we call anything, as we might get called
3224 TYPE_HAS_DESTRUCTOR (type
) = 1;
3226 /* If we have member delete or vbases, we call delete in
3228 my_friendly_assert (auto_delete
== sfk_base_destructor
, 20000411);
3230 /* Take care of the remaining baseclasses. */
3231 for (i
= 0; i
< n_baseclasses
; i
++)
3233 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3234 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3235 || TREE_VIA_VIRTUAL (base_binfo
))
3238 expr
= build_scoped_method_call (ref
, base_binfo
,
3239 base_dtor_identifier
,
3242 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3245 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3247 if (TREE_CODE (member
) != FIELD_DECL
)
3249 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member
)))
3251 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3252 tree this_type
= TREE_TYPE (member
);
3253 expr
= build_delete (this_type
, this_member
,
3254 sfk_complete_destructor
, flags
, 0);
3255 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3260 return build_compound_expr (exprstmt
);
3261 /* Virtual base classes make this function do nothing. */
3262 return void_zero_node
;
3266 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3269 build_vbase_delete (type
, decl
)
3272 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3273 tree result
= NULL_TREE
;
3274 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3276 my_friendly_assert (addr
!= error_mark_node
, 222);
3281 = convert_force (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases
))),
3283 result
= tree_cons (NULL_TREE
,
3284 build_delete (TREE_TYPE (this_addr
), this_addr
,
3285 sfk_base_destructor
,
3286 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3288 vbases
= TREE_CHAIN (vbases
);
3290 return build_compound_expr (nreverse (result
));
3293 /* Build a C++ vector delete expression.
3294 MAXINDEX is the number of elements to be deleted.
3295 ELT_SIZE is the nominal size of each element in the vector.
3296 BASE is the expression that should yield the store to be deleted.
3297 This function expands (or synthesizes) these calls itself.
3298 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3300 This also calls delete for virtual baseclasses of elements of the vector.
3302 Update: MAXINDEX is no longer needed. The size can be extracted from the
3303 start of the vector for pointers, and from the type for arrays. We still
3304 use MAXINDEX for arrays because it happens to already have one of the
3305 values we'd have to extract. (We could use MAXINDEX with pointers to
3306 confirm the size, and trap if the numbers differ; not clear that it'd
3307 be worth bothering.) */
3310 build_vec_delete (base
, maxindex
, auto_delete_vec
, use_global_delete
)
3311 tree base
, maxindex
;
3312 special_function_kind auto_delete_vec
;
3313 int use_global_delete
;
3317 if (TREE_CODE (base
) == OFFSET_REF
)
3318 base
= resolve_offset_ref (base
);
3320 type
= TREE_TYPE (base
);
3322 base
= stabilize_reference (base
);
3324 /* Since we can use base many times, save_expr it. */
3325 if (TREE_SIDE_EFFECTS (base
))
3326 base
= save_expr (base
);
3328 if (TREE_CODE (type
) == POINTER_TYPE
)
3330 /* Step back one from start of vector, and read dimension. */
3333 type
= strip_array_types (TREE_TYPE (type
));
3334 cookie_addr
= build (MINUS_EXPR
,
3335 build_pointer_type (sizetype
),
3337 TYPE_SIZE_UNIT (sizetype
));
3338 maxindex
= build_indirect_ref (cookie_addr
, NULL
);
3340 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3342 /* get the total number of things in the array, maxindex is a bad name */
3343 maxindex
= array_type_nelts_total (type
);
3344 type
= strip_array_types (type
);
3345 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3349 if (base
!= error_mark_node
)
3350 error ("type to vector delete is neither pointer or array type");
3351 return error_mark_node
;
3354 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
,