1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 89, 92-96, 1997 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* High-level class interface. */
35 extern void compiler_error ();
37 /* In C++, structures with well-defined constructors are initialized by
38 those constructors, unasked. CURRENT_BASE_INIT_LIST
39 holds a list of stmts for a BASE_INIT term in the grammar.
40 This list has one element for each base class which must be
41 initialized. The list elements are [basename, init], with
42 type basetype. This allows the possibly anachronistic form
43 (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
44 where each successive term can be handed down the constructor
45 line. Perhaps this was not intended. */
46 tree current_base_init_list
, current_member_init_list
;
48 static void expand_aggr_vbase_init_1
PROTO((tree
, tree
, tree
, tree
));
49 static void expand_aggr_vbase_init
PROTO((tree
, tree
, tree
, tree
));
50 static void expand_aggr_init_1
PROTO((tree
, tree
, tree
, tree
, int,
52 static void expand_default_init
PROTO((tree
, tree
, tree
, tree
, int,
54 static tree build_vec_delete_1
PROTO((tree
, tree
, tree
, tree
, tree
,
56 static void perform_member_init
PROTO((tree
, tree
, tree
, int));
57 static void sort_base_init
PROTO((tree
, tree
*, tree
*));
58 static tree build_builtin_call
PROTO((tree
, tree
, tree
));
59 static tree build_array_eh_cleanup
PROTO((tree
, tree
, tree
));
60 static int member_init_ok_or_else
PROTO((tree
, tree
, char *));
61 static void expand_virtual_init
PROTO((tree
, tree
));
62 static tree sort_member_init
PROTO((tree
));
63 static tree build_partial_cleanup_for
PROTO((tree
));
64 static tree initializing_context
PROTO((tree
));
66 /* Cache _builtin_new and _builtin_delete exprs. */
67 static tree BIN
, BID
, BIVN
, BIVD
;
69 /* Cache the identifier nodes for the magic field of a new cookie. */
70 static tree nc_nelts_field_id
;
72 static tree minus_one
;
74 /* Set up local variable for this file. MUST BE CALLED AFTER
75 INIT_DECL_PROCESSING. */
77 static tree BI_header_type
, BI_header_size
;
79 void init_init_processing ()
83 /* Define implicit `operator new' and `operator delete' functions. */
84 BIN
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) NEW_EXPR
])));
85 TREE_USED (TREE_OPERAND (BIN
, 0)) = 0;
86 BID
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) DELETE_EXPR
])));
87 TREE_USED (TREE_OPERAND (BID
, 0)) = 0;
88 BIVN
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) VEC_NEW_EXPR
])));
89 TREE_USED (TREE_OPERAND (BIVN
, 0)) = 0;
90 BIVD
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) VEC_DELETE_EXPR
])));
91 TREE_USED (TREE_OPERAND (BIVD
, 0)) = 0;
92 minus_one
= build_int_2 (-1, -1);
94 /* Define the structure that holds header information for
95 arrays allocated via operator new. */
96 BI_header_type
= make_lang_type (RECORD_TYPE
);
97 nc_nelts_field_id
= get_identifier ("nelts");
98 fields
[0] = build_lang_field_decl (FIELD_DECL
, nc_nelts_field_id
, sizetype
);
99 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
100 0, double_type_node
);
101 BI_header_size
= size_in_bytes (BI_header_type
);
104 /* Subroutine of emit_base_init. For BINFO, initialize all the
105 virtual function table pointers, except those that come from
106 virtual base classes. Initialize binfo's vtable pointer, if
107 INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
108 function table pointers in all bases have been initialized already,
109 probably because their constructors have just be run. ADDR is the
110 pointer to the object whos vtables we are going to initialize.
112 REAL_BINFO is usually the same as BINFO, except when addr is not of
113 pointer to the type of the real derived type that we want to
114 initialize for. This is the case when addr is a pointer to a sub
115 object of a complete object, and we only want to do part of the
116 complete object's initialization of vtable pointers. This is done
117 for all virtual table pointers in virtual base classes. REAL_BINFO
118 is used to find the BINFO_VTABLE that we initialize with. BINFO is
119 used for conversions of addr to subobjects.
121 BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
123 Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
127 expand_direct_vtbls_init (real_binfo
, binfo
, init_self
, can_elide
, addr
)
128 tree real_binfo
, binfo
, addr
;
129 int init_self
, can_elide
;
131 tree real_binfos
= BINFO_BASETYPES (real_binfo
);
132 tree binfos
= BINFO_BASETYPES (binfo
);
133 int i
, n_baselinks
= real_binfos
? TREE_VEC_LENGTH (real_binfos
) : 0;
135 for (i
= 0; i
< n_baselinks
; i
++)
137 tree real_base_binfo
= TREE_VEC_ELT (real_binfos
, i
);
138 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
139 int is_not_base_vtable
140 = i
!= CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo
));
141 if (! TREE_VIA_VIRTUAL (real_base_binfo
))
142 expand_direct_vtbls_init (real_base_binfo
, base_binfo
,
143 is_not_base_vtable
, can_elide
, addr
);
146 /* Before turning this on, make sure it is correct. */
147 if (can_elide
&& ! BINFO_MODIFIED (binfo
))
150 /* Should we use something besides CLASSTYPE_VFIELDS? */
151 if (init_self
&& CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo
)))
153 tree base_ptr
= convert_pointer_to_real (binfo
, addr
);
154 expand_virtual_init (real_binfo
, base_ptr
);
159 /* Subroutine of emit_base_init. */
162 perform_member_init (member
, name
, init
, explicit)
163 tree member
, name
, init
;
167 tree type
= TREE_TYPE (member
);
169 expand_start_target_temps ();
171 if (TYPE_NEEDS_CONSTRUCTING (type
)
172 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
174 /* Since `init' is already a TREE_LIST on the current_member_init_list,
175 only build it into one if we aren't already a list. */
176 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
177 init
= build_expr_list (NULL_TREE
, init
);
179 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
182 && TREE_CODE (type
) == ARRAY_TYPE
184 && TREE_CHAIN (init
) == NULL_TREE
185 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
187 /* Initialization of one array from another. */
188 expand_vec_init (TREE_OPERAND (decl
, 1), decl
,
189 array_type_nelts (type
), TREE_VALUE (init
), 1);
192 expand_aggr_init (decl
, init
, 0, 0);
196 if (init
== NULL_TREE
)
200 cp_error ("incomplete initializer for member `%D' of class `%T' which has no constructor",
201 member
, current_class_type
);
202 init
= error_mark_node
;
204 /* member traversal: note it leaves init NULL */
205 else if (TREE_CODE (TREE_TYPE (member
)) == REFERENCE_TYPE
)
206 cp_pedwarn ("uninitialized reference member `%D'", member
);
208 else if (TREE_CODE (init
) == TREE_LIST
)
210 /* There was an explicit member initialization. Do some
211 work in that case. */
212 if (TREE_CHAIN (init
))
214 warning ("initializer list treated as compound expression");
215 init
= build_compound_expr (init
);
218 init
= TREE_VALUE (init
);
221 /* We only build this with a null init if we got it from the
222 current_member_init_list. */
223 if (init
|| explicit)
225 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
226 expand_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
230 expand_end_target_temps ();
233 if (TYPE_NEEDS_DESTRUCTOR (type
))
237 /* All cleanups must be on the function_obstack. */
238 push_obstacks_nochange ();
239 resume_temporary_allocation ();
241 expr
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
242 expr
= build_delete (type
, expr
, integer_zero_node
,
243 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
245 if (expr
!= error_mark_node
)
246 add_partial_entry (expr
);
252 extern int warn_reorder
;
254 /* Subroutine of emit_member_init. */
260 tree x
, member
, name
, field
;
261 tree init_list
= NULL_TREE
;
263 tree last_field
= NULL_TREE
;
265 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
269 /* member could be, for example, a CONST_DECL for an enumerated
270 tag; we don't want to try to initialize that, since it already
272 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
275 for (x
= current_member_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
277 /* If we cleared this out, then pay no attention to it. */
278 if (TREE_PURPOSE (x
) == NULL_TREE
)
280 name
= TREE_PURPOSE (x
);
283 /* This happens in templates, since the IDENTIFIER is replaced
284 with the COMPONENT_REF in tsubst_expr. */
285 field
= (TREE_CODE (name
) == COMPONENT_REF
286 ? TREE_OPERAND (name
, 1) : IDENTIFIER_CLASS_VALUE (name
));
288 /* Let's find out when this happens. */
289 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 348);
290 field
= IDENTIFIER_CLASS_VALUE (name
);
293 /* If one member shadows another, get the outermost one. */
294 if (TREE_CODE (field
) == TREE_LIST
)
295 field
= TREE_VALUE (field
);
303 cp_warning_at ("member initializers for `%#D'", last_field
);
304 cp_warning_at (" and `%#D'", field
);
305 warning (" will be re-ordered to match declaration order");
311 /* Make sure we won't try to work on this init again. */
312 TREE_PURPOSE (x
) = NULL_TREE
;
313 x
= build_tree_list (name
, TREE_VALUE (x
));
318 /* If we didn't find MEMBER in the list, create a dummy entry
319 so the two lists (INIT_LIST and the list of members) will be
321 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
323 init_list
= chainon (init_list
, x
);
326 /* Initializers for base members go at the end. */
327 for (x
= current_member_init_list
; x
; x
= TREE_CHAIN (x
))
329 name
= TREE_PURPOSE (x
);
332 if (purpose_member (name
, init_list
))
334 cp_error ("multiple initializations given for member `%D'",
335 IDENTIFIER_CLASS_VALUE (name
));
339 init_list
= chainon (init_list
,
340 build_tree_list (name
, TREE_VALUE (x
)));
341 TREE_PURPOSE (x
) = NULL_TREE
;
349 sort_base_init (t
, rbase_ptr
, vbase_ptr
)
350 tree t
, *rbase_ptr
, *vbase_ptr
;
352 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
353 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
359 /* For warn_reorder. */
361 tree last_base
= NULL_TREE
;
363 tree rbases
= NULL_TREE
;
364 tree vbases
= NULL_TREE
;
366 /* First walk through and splice out vbase and invalid initializers.
367 Also replace names with binfos. */
369 last
= tree_cons (NULL_TREE
, NULL_TREE
, current_base_init_list
);
370 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
372 tree basetype
= TREE_PURPOSE (x
);
373 tree binfo
= NULL_TREE
;
375 if (basetype
== NULL_TREE
)
377 /* Initializer for single base class. Must not
378 use multiple inheritance or this is ambiguous. */
379 switch (n_baseclasses
)
382 cp_error ("`%T' does not have a base class to initialize",
388 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
392 binfo
= TREE_VEC_ELT (binfos
, 0);
394 else if (is_aggr_type (basetype
, 1))
396 binfo
= binfo_or_else (basetype
, t
);
397 if (binfo
== NULL_TREE
)
400 /* Virtual base classes are special cases. Their initializers
401 are recorded with this constructor, and they are used when
402 this constructor is the top-level constructor called. */
403 if (TREE_VIA_VIRTUAL (binfo
))
405 tree v
= CLASSTYPE_VBASECLASSES (t
);
406 while (BINFO_TYPE (v
) != BINFO_TYPE (binfo
))
409 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
414 /* Otherwise, if it is not an immediate base class, complain. */
415 for (i
= n_baseclasses
-1; i
>= 0; i
--)
416 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
420 cp_error ("`%T' is not an immediate base class of `%T'",
421 basetype
, current_class_type
);
427 my_friendly_abort (365);
429 TREE_PURPOSE (x
) = binfo
;
430 TREE_CHAIN (last
) = x
;
433 TREE_CHAIN (last
) = NULL_TREE
;
435 /* Now walk through our regular bases and make sure they're initialized. */
437 for (i
= 0; i
< n_baseclasses
; ++i
)
439 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
442 if (TREE_VIA_VIRTUAL (base_binfo
))
445 for (x
= current_base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
447 tree binfo
= TREE_PURPOSE (x
);
449 if (binfo
== NULL_TREE
)
452 if (binfo
== base_binfo
)
458 cp_warning_at ("base initializers for `%#T'", last_base
);
459 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
460 warning (" will be re-ordered to match inheritance order");
463 last_base
= BINFO_TYPE (binfo
);
466 /* Make sure we won't try to work on this init again. */
467 TREE_PURPOSE (x
) = NULL_TREE
;
468 x
= build_tree_list (binfo
, TREE_VALUE (x
));
473 /* If we didn't find BASE_BINFO in the list, create a dummy entry
474 so the two lists (RBASES and the list of bases) will be
476 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
478 rbases
= chainon (rbases
, x
);
485 /* Perform partial cleanups for a base for exception handling. */
488 build_partial_cleanup_for (binfo
)
491 return build_scoped_method_call
492 (current_class_ref
, binfo
, dtor_identifier
,
493 build_expr_list (NULL_TREE
, integer_zero_node
));
496 /* Perform whatever initializations have yet to be done on the base
497 class of the class variable. These actions are in the global
498 variable CURRENT_BASE_INIT_LIST. Such an action could be
499 NULL_TREE, meaning that the user has explicitly called the base
500 class constructor with no arguments.
502 If there is a need for a call to a constructor, we must surround
503 that call with a pushlevel/poplevel pair, since we are technically
504 at the PARM level of scope.
506 Argument IMMEDIATELY, if zero, forces a new sequence to be
507 generated to contain these new insns, so it can be emitted later.
508 This sequence is saved in the global variable BASE_INIT_EXPR.
509 Otherwise, the insns are emitted into the current sequence.
511 Note that emit_base_init does *not* initialize virtual base
512 classes. That is done specially, elsewhere. */
514 extern tree base_init_expr
, rtl_expr_chain
;
517 emit_base_init (t
, immediately
)
523 tree rbase_init_list
, vbase_init_list
;
524 tree t_binfo
= TYPE_BINFO (t
);
525 tree binfos
= BINFO_BASETYPES (t_binfo
);
526 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
527 tree expr
= NULL_TREE
;
532 do_pending_stack_adjust ();
533 /* Make the RTL_EXPR node temporary, not momentary,
534 so that rtl_expr_chain doesn't become garbage. */
535 momentary
= suspend_momentary ();
536 expr
= make_node (RTL_EXPR
);
537 resume_momentary (momentary
);
538 start_sequence_for_rtl_expr (expr
);
541 if (write_symbols
== NO_DEBUG
)
542 /* As a matter of principle, `start_sequence' should do this. */
545 /* Always emit a line number note so we can step into constructors. */
546 emit_line_note_force (DECL_SOURCE_FILE (current_function_decl
),
547 DECL_SOURCE_LINE (current_function_decl
));
549 mem_init_list
= sort_member_init (t
);
550 current_member_init_list
= NULL_TREE
;
552 sort_base_init (t
, &rbase_init_list
, &vbase_init_list
);
553 current_base_init_list
= NULL_TREE
;
555 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
557 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
559 expand_start_cond (first_arg
, 0);
560 expand_aggr_vbase_init (t_binfo
, current_class_ref
, current_class_ptr
,
565 /* Now, perform initialization of non-virtual base classes. */
566 for (i
= 0; i
< n_baseclasses
; i
++)
568 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
569 tree init
= void_list_node
;
571 if (TREE_VIA_VIRTUAL (base_binfo
))
574 #if 0 /* Once unsharing happens soon enough. */
575 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
, 999);
577 BINFO_INHERITANCE_CHAIN (base_binfo
) = t_binfo
;
580 if (TREE_PURPOSE (rbase_init_list
))
581 init
= TREE_VALUE (rbase_init_list
);
582 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
585 if (extra_warnings
&& copy_args_p (current_function_decl
))
586 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
587 BINFO_TYPE (base_binfo
));
590 if (init
!= void_list_node
)
592 expand_start_target_temps ();
594 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
595 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
596 build_indirect_ref (member
, NULL_PTR
), init
,
597 BINFO_OFFSET_ZEROP (base_binfo
), LOOKUP_NORMAL
);
599 expand_end_target_temps ();
603 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
607 /* All cleanups must be on the function_obstack. */
608 push_obstacks_nochange ();
609 resume_temporary_allocation ();
610 expr
= build_partial_cleanup_for (base_binfo
);
612 add_partial_entry (expr
);
615 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
618 /* Initialize all the virtual function table fields that
619 do come from virtual base classes. */
620 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
621 expand_indirect_vtbls_init (t_binfo
, current_class_ref
, current_class_ptr
);
623 /* Initialize all the virtual function table fields that
624 do not come from virtual base classes. */
625 expand_direct_vtbls_init (t_binfo
, t_binfo
, 1, 1, current_class_ptr
);
627 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
632 /* member could be, for example, a CONST_DECL for an enumerated
633 tag; we don't want to try to initialize that, since it already
635 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
638 /* See if we had a user-specified member initialization. */
639 if (TREE_PURPOSE (mem_init_list
))
641 name
= TREE_PURPOSE (mem_init_list
);
642 init
= TREE_VALUE (mem_init_list
);
646 if (TREE_CODE (name
) == COMPONENT_REF
)
647 name
= DECL_NAME (TREE_OPERAND (name
, 1));
649 /* Also see if it's ever a COMPONENT_REF here. If it is, we
650 need to do `expand_assignment (name, init, 0, 0);' and
652 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 349);
657 name
= DECL_NAME (member
);
658 init
= DECL_INITIAL (member
);
662 /* Effective C++ rule 12. */
663 if (warn_ecpp
&& init
== NULL_TREE
664 && !DECL_ARTIFICIAL (member
)
665 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
666 cp_warning ("`%D' should be initialized in the member initialization list", member
);
669 perform_member_init (member
, name
, init
, from_init_list
);
670 mem_init_list
= TREE_CHAIN (mem_init_list
);
673 /* Now initialize any members from our bases. */
674 while (mem_init_list
)
676 tree name
, init
, field
;
678 if (TREE_PURPOSE (mem_init_list
))
680 name
= TREE_PURPOSE (mem_init_list
);
681 init
= TREE_VALUE (mem_init_list
);
682 /* XXX: this may need the COMPONENT_REF operand 0 check if
683 it turns out we actually get them. */
684 field
= IDENTIFIER_CLASS_VALUE (name
);
686 /* If one member shadows another, get the outermost one. */
687 if (TREE_CODE (field
) == TREE_LIST
)
689 field
= TREE_VALUE (field
);
690 if (decl_type_context (field
) != current_class_type
)
691 cp_error ("field `%D' not in immediate context", field
);
695 /* It turns out if you have an anonymous union in the
696 class, a member from it can end up not being on the
697 list of fields (rather, the type is), and therefore
698 won't be seen by the for loop above. */
700 /* The code in this for loop is derived from a general loop
701 which had this check in it. Theoretically, we've hit
702 every initialization for the list of members in T, so
703 we shouldn't have anything but these left in this list. */
704 my_friendly_assert (DECL_FIELD_CONTEXT (field
) != t
, 351);
707 perform_member_init (field
, name
, init
, 1);
709 mem_init_list
= TREE_CHAIN (mem_init_list
);
714 do_pending_stack_adjust ();
715 my_friendly_assert (base_init_expr
== 0, 207);
716 base_init_expr
= expr
;
717 TREE_TYPE (expr
) = void_type_node
;
718 RTL_EXPR_RTL (expr
) = const0_rtx
;
719 RTL_EXPR_SEQUENCE (expr
) = get_insns ();
720 rtl_expr_chain
= tree_cons (NULL_TREE
, expr
, rtl_expr_chain
);
722 TREE_SIDE_EFFECTS (expr
) = 1;
725 /* All the implicit try blocks we built up will be zapped
726 when we come to a real binding contour boundary. */
729 /* Check that all fields are properly initialized after
730 an assignment to `this'. */
737 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
738 if (DECL_NAME (member
) && TREE_USED (member
))
739 cp_error ("field `%D' used before initialized (after assignment to `this')",
743 /* This code sets up the virtual function tables appropriate for
744 the pointer DECL. It is a one-ply initialization.
746 BINFO is the exact type that DECL is supposed to be. In
747 multiple inheritance, this might mean "C's A" if C : A, B. */
750 expand_virtual_init (binfo
, decl
)
753 tree type
= BINFO_TYPE (binfo
);
755 tree vtype
, vtype_binfo
;
757 /* This code is crusty. Should be simple, like:
758 vtbl = BINFO_VTABLE (binfo);
760 vtype
= DECL_CONTEXT (CLASSTYPE_VFIELD (type
));
761 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
762 vtbl
= BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type
)), binfo
));
763 assemble_external (vtbl
);
764 TREE_USED (vtbl
) = 1;
765 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
766 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
767 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
768 if (vtbl_ptr
== error_mark_node
)
771 /* Have to convert VTBL since array sizes may be different. */
772 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
773 expand_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
776 /* Subroutine of `expand_aggr_vbase_init'.
777 BINFO is the binfo of the type that is being initialized.
778 INIT_LIST is the list of initializers for the virtual baseclass. */
781 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
782 tree binfo
, exp
, addr
, init_list
;
784 tree init
= purpose_member (binfo
, init_list
);
785 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
787 expand_start_target_temps ();
790 init
= TREE_VALUE (init
);
791 /* Call constructors, but don't set up vtables. */
792 expand_aggr_init_1 (binfo
, exp
, ref
, init
, 0, LOOKUP_COMPLAIN
);
794 expand_end_target_temps ();
798 /* Initialize this object's virtual base class pointers. This must be
799 done only at the top-level of the object being constructed.
801 INIT_LIST is list of initialization for constructor to perform. */
804 expand_aggr_vbase_init (binfo
, exp
, addr
, init_list
)
810 tree type
= BINFO_TYPE (binfo
);
812 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
814 tree result
= init_vbase_pointers (type
, addr
);
818 expand_expr_stmt (build_compound_expr (result
));
820 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
821 vbases
= TREE_CHAIN (vbases
))
823 tree tmp
= purpose_member (vbases
, result
);
824 expand_aggr_vbase_init_1 (vbases
, exp
,
825 TREE_OPERAND (TREE_VALUE (tmp
), 0),
831 /* Subroutine to perform parser actions for member initialization.
832 S_ID is the scoped identifier.
833 NAME is the name of the member.
834 INIT is the initializer, or `void_type_node' if none. */
837 do_member_init (s_id
, name
, init
)
838 tree s_id
, name
, init
;
842 if (current_class_type
== NULL_TREE
843 || ! is_aggr_typedef (s_id
, 1))
845 binfo
= get_binfo (IDENTIFIER_TYPE_VALUE (s_id
),
846 current_class_type
, 1);
847 if (binfo
== error_mark_node
)
851 error_not_base_type (IDENTIFIER_TYPE_VALUE (s_id
), current_class_type
);
855 base
= convert_pointer_to (binfo
, current_class_ptr
);
856 expand_member_init (build_indirect_ref (base
, NULL_PTR
), name
, init
);
859 /* Find the context in which this FIELD can be initialized. */
862 initializing_context (field
)
865 tree t
= DECL_CONTEXT (field
);
867 /* Anonymous union members can be initialized in the first enclosing
868 non-anonymous union context. */
869 while (t
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
870 t
= TYPE_CONTEXT (t
);
874 /* Function to give error message if member initialization specification
875 is erroneous. FIELD is the member we decided to initialize.
876 TYPE is the type for which the initialization is being performed.
877 FIELD must be a member of TYPE.
879 MEMBER_NAME is the name of the member. */
882 member_init_ok_or_else (field
, type
, member_name
)
887 if (field
== error_mark_node
)
889 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
891 cp_error ("class `%T' does not have any field named `%s'", type
,
895 if (TREE_STATIC (field
))
897 cp_error ("field `%#D' is static; only point of initialization is its declaration",
905 /* If NAME is a viable field name for the aggregate DECL,
906 and PARMS is a viable parameter list, then expand an _EXPR
907 which describes this initialization.
909 Note that we do not need to chase through the class's base classes
910 to look for NAME, because if it's in that list, it will be handled
911 by the constructor for that base class.
913 We do not yet have a fixed-point finder to instantiate types
914 being fed to overloaded constructors. If there is a unique
915 constructor, then argument types can be got from that one.
917 If INIT is non-NULL, then it the initialization should
918 be placed in `current_base_init_list', where it will be processed
919 by `emit_base_init'. */
922 expand_member_init (exp
, name
, init
)
923 tree exp
, name
, init
;
925 extern tree ptr_type_node
; /* should be in tree.h */
927 tree basetype
= NULL_TREE
, field
;
929 tree rval
= NULL_TREE
, type
;
931 if (exp
== NULL_TREE
)
932 return; /* complain about this later */
934 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
936 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
938 basetype
= TREE_TYPE (name
);
939 name
= DECL_NAME (name
);
942 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
943 switch (CLASSTYPE_N_BASECLASSES (type
))
946 error ("base class initializer specified, but no base class to initialize");
949 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
952 error ("initializer for unnamed base class ambiguous");
953 cp_error ("(type `%T' uses multiple inheritance)", type
);
959 /* The grammar should not allow fields which have names
960 that are TYPENAMEs. Therefore, if the field has
961 a non-NULL TREE_TYPE, we may assume that this is an
962 attempt to initialize a base class member of the current
963 type. Otherwise, it is an attempt to initialize a
966 if (init
== void_type_node
)
969 if (name
== NULL_TREE
|| basetype
)
973 if (name
== NULL_TREE
)
977 name
= TYPE_IDENTIFIER (basetype
);
980 error ("no base class to initialize");
985 else if (basetype
!= type
986 && ! current_template_parms
987 && ! vec_binfo_member (basetype
,
988 TYPE_BINFO_BASETYPES (type
))
989 && ! binfo_member (basetype
, CLASSTYPE_VBASECLASSES (type
)))
991 if (IDENTIFIER_CLASS_VALUE (name
))
993 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
994 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
997 cp_error ("type `%T' is not an immediate basetype for `%T'",
1002 if (purpose_member (basetype
, current_base_init_list
))
1004 cp_error ("base class `%T' already initialized", basetype
);
1008 if (warn_reorder
&& current_member_init_list
)
1010 cp_warning ("base initializer for `%T'", basetype
);
1011 warning (" will be re-ordered to precede member initializations");
1014 base_init
= build_tree_list (basetype
, init
);
1015 current_base_init_list
= chainon (current_base_init_list
, base_init
);
1022 field
= lookup_field (type
, name
, 1, 0);
1024 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
1027 if (purpose_member (name
, current_member_init_list
))
1029 cp_error ("field `%D' already initialized", field
);
1033 member_init
= build_tree_list (name
, init
);
1034 current_member_init_list
= chainon (current_member_init_list
, member_init
);
1038 else if (name
== NULL_TREE
)
1040 compiler_error ("expand_member_init: name == NULL_TREE");
1045 field
= lookup_field (basetype
, name
, 0, 0);
1047 if (! member_init_ok_or_else (field
, basetype
, IDENTIFIER_POINTER (name
)))
1050 /* now see if there is a constructor for this type
1051 which will take these args. */
1053 if (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (field
)))
1055 tree parmtypes
, fndecl
;
1057 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1059 /* just know that we've seen something for this node */
1060 DECL_INITIAL (exp
) = error_mark_node
;
1061 TREE_USED (exp
) = 1;
1063 type
= TYPE_MAIN_VARIANT (TREE_TYPE (field
));
1064 parm
= build_component_ref (exp
, name
, NULL_TREE
, 0);
1066 /* Now get to the constructors. */
1067 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), 0);
1070 my_friendly_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
, 209);
1072 parmtypes
= NULL_TREE
;
1075 init
= convert_arguments (parm
, parmtypes
, NULL_TREE
, fndecl
, LOOKUP_NORMAL
);
1076 if (init
== NULL_TREE
|| TREE_TYPE (init
) != error_mark_node
)
1077 rval
= build_method_call (NULL_TREE
, ctor_identifier
, init
,
1078 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1082 if (rval
!= error_mark_node
)
1084 /* Now, fill in the first parm with our guy */
1085 TREE_VALUE (TREE_OPERAND (rval
, 1))
1086 = build_unary_op (ADDR_EXPR
, parm
, 0);
1087 TREE_TYPE (rval
) = ptr_type_node
;
1088 TREE_SIDE_EFFECTS (rval
) = 1;
1091 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
1093 parm
= build_component_ref (exp
, name
, NULL_TREE
, 0);
1094 expand_aggr_init (parm
, NULL_TREE
, 0, 0);
1095 rval
= error_mark_node
;
1098 /* Now initialize the member. It does not have to
1099 be of aggregate type to receive initialization. */
1100 if (rval
!= error_mark_node
)
1101 expand_expr_stmt (rval
);
1104 /* This is like `expand_member_init', only it stores one aggregate
1107 INIT comes in two flavors: it is either a value which
1108 is to be stored in EXP, or it is a parameter list
1109 to go to a constructor, which will operate on EXP.
1110 If INIT is not a parameter list for a constructor, then set
1111 LOOKUP_ONLYCONVERTING.
1112 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1113 the initializer, if FLAGS is 0, then it is the (init) form.
1114 If `init' is a CONSTRUCTOR, then we emit a warning message,
1115 explaining that such initializations are invalid.
1117 ALIAS_THIS is nonzero iff we are initializing something which is
1118 essentially an alias for current_class_ref. In this case, the base
1119 constructor may move it on us, and we must keep track of such
1122 If INIT resolves to a CALL_EXPR which happens to return
1123 something of the type we are looking for, then we know
1124 that we can safely use that call to perform the
1127 The virtual function table pointer cannot be set up here, because
1128 we do not really know its type.
1130 Virtual baseclass pointers are also set up here.
1132 This never calls operator=().
1134 When initializing, nothing is CONST.
1136 A default copy constructor may have to be used to perform the
1139 A constructor or a conversion operator may have to be used to
1140 perform the initialization, but not both, as it would be ambiguous. */
1143 expand_aggr_init (exp
, init
, alias_this
, flags
)
1148 tree type
= TREE_TYPE (exp
);
1149 int was_const
= TREE_READONLY (exp
);
1150 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1152 if (init
== error_mark_node
)
1155 TREE_READONLY (exp
) = 0;
1156 TREE_THIS_VOLATILE (exp
) = 0;
1158 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1159 flags
|= LOOKUP_ONLYCONVERTING
;
1161 if (TREE_CODE (type
) == ARRAY_TYPE
)
1163 /* Must arrange to initialize each element of EXP
1164 from elements of INIT. */
1165 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1166 if (TYPE_READONLY (TREE_TYPE (type
)) || TYPE_VOLATILE (TREE_TYPE (type
)))
1168 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1170 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1172 if (init
&& TREE_TYPE (init
) == NULL_TREE
)
1174 /* Handle bad initializers like:
1178 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1182 int main(int argc, char **argv) {
1183 COMPLEX zees(1.0, 0.0)[10];
1186 error ("bad array initializer");
1189 expand_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1190 init
&& comptypes (TREE_TYPE (init
), TREE_TYPE (exp
), 1));
1191 TREE_READONLY (exp
) = was_const
;
1192 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1193 TREE_TYPE (exp
) = type
;
1195 TREE_TYPE (init
) = itype
;
1199 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1200 /* just know that we've seen something for this node */
1201 TREE_USED (exp
) = 1;
1204 /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1205 constructor as parameters to an implicit GNU C++ constructor. */
1206 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
1207 && TYPE_HAS_CONSTRUCTOR (type
)
1208 && TREE_TYPE (init
) == type
)
1209 init
= CONSTRUCTOR_ELTS (init
);
1212 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1213 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1214 init
, alias_this
, LOOKUP_NORMAL
|flags
);
1215 TREE_TYPE (exp
) = type
;
1216 TREE_READONLY (exp
) = was_const
;
1217 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1221 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1228 tree type
= TREE_TYPE (exp
);
1230 /* It fails because there may not be a constructor which takes
1231 its own type as the first (or only parameter), but which does
1232 take other types via a conversion. So, if the thing initializing
1233 the expression is a unit element of type X, first try X(X&),
1234 followed by initialization by X. If neither of these work
1235 out, then look hard. */
1239 if (init
&& TREE_CODE (init
) != TREE_LIST
1240 && (flags
& LOOKUP_ONLYCONVERTING
))
1242 /* Base subobjects should only get direct-initialization. */
1243 if (true_exp
!= exp
)
1246 /* We special-case TARGET_EXPRs here to avoid an error about
1247 private copy constructors for temporaries bound to reference vars.
1248 If the TARGET_EXPR represents a call to a function that has
1249 permission to create such objects, a reference can bind directly
1250 to the return value. An object variable must be initialized
1251 via the copy constructor, even if the call is elided. */
1252 if (! (TREE_CODE (exp
) == VAR_DECL
&& DECL_ARTIFICIAL (exp
)
1253 && TREE_CODE (init
) == TARGET_EXPR
&& TREE_TYPE (init
) == type
))
1254 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1256 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1257 /* We need to protect the initialization of a catch parm
1258 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1259 around the TARGET_EXPR for the copy constructor. See
1260 expand_start_catch_block. */
1261 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1262 TREE_OPERAND (init
, 0));
1264 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1265 TREE_SIDE_EFFECTS (init
) = 1;
1266 expand_expr_stmt (init
);
1270 if (init
== NULL_TREE
1271 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1275 init
= TREE_VALUE (parms
);
1278 parms
= build_expr_list (NULL_TREE
, init
);
1280 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1282 if (true_exp
== exp
)
1283 parms
= expr_tree_cons (NULL_TREE
, integer_one_node
, parms
);
1285 parms
= expr_tree_cons (NULL_TREE
, integer_zero_node
, parms
);
1286 flags
|= LOOKUP_HAS_IN_CHARGE
;
1289 rval
= build_method_call (exp
, ctor_identifier
,
1290 parms
, binfo
, flags
);
1291 expand_expr_stmt (rval
);
1294 /* This function is responsible for initializing EXP with INIT
1297 BINFO is the binfo of the type for who we are performing the
1298 initialization. For example, if W is a virtual base class of A and B,
1300 If we are initializing B, then W must contain B's W vtable, whereas
1301 were we initializing C, W must contain C's W vtable.
1303 TRUE_EXP is nonzero if it is the true expression being initialized.
1304 In this case, it may be EXP, or may just contain EXP. The reason we
1305 need this is because if EXP is a base element of TRUE_EXP, we
1306 don't necessarily know by looking at EXP where its virtual
1307 baseclass fields should really be pointing. But we do know
1308 from TRUE_EXP. In constructors, we don't know anything about
1309 the value being initialized.
1311 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1313 FLAGS is just passes to `build_method_call'. See that function for
1317 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1324 tree type
= TREE_TYPE (exp
);
1326 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1328 /* Use a function returning the desired type to initialize EXP for us.
1329 If the function is a constructor, and its first argument is
1330 NULL_TREE, know that it was meant for us--just slide exp on
1331 in and expand the constructor. Constructors now come
1334 if (init
&& TREE_CODE (exp
) == VAR_DECL
1335 && TREE_CODE (init
) == CONSTRUCTOR
1336 && TREE_HAS_CONSTRUCTOR (init
))
1338 tree t
= store_init_value (exp
, init
);
1341 expand_decl_init (exp
);
1344 t
= build (INIT_EXPR
, type
, exp
, init
);
1345 TREE_SIDE_EFFECTS (t
) = 1;
1346 expand_expr_stmt (t
);
1350 /* We know that expand_default_init can handle everything we want
1352 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
);
1355 /* Report an error if NAME is not the name of a user-defined,
1356 aggregate type. If OR_ELSE is nonzero, give an error message. */
1359 is_aggr_typedef (name
, or_else
)
1365 if (name
== error_mark_node
)
1368 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1369 type
= IDENTIFIER_TYPE_VALUE (name
);
1373 cp_error ("`%T' is not an aggregate typedef", name
);
1377 if (! IS_AGGR_TYPE (type
)
1378 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1379 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1382 cp_error ("`%T' is not an aggregate type", type
);
1388 /* Report an error if TYPE is not a user-defined, aggregate type. If
1389 OR_ELSE is nonzero, give an error message. */
1392 is_aggr_type (type
, or_else
)
1396 if (type
== error_mark_node
)
1399 if (! IS_AGGR_TYPE (type
)
1400 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1401 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1404 cp_error ("`%T' is not an aggregate type", type
);
1410 /* Like is_aggr_typedef, but returns typedef if successful. */
1413 get_aggr_from_typedef (name
, or_else
)
1419 if (name
== error_mark_node
)
1422 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1423 type
= IDENTIFIER_TYPE_VALUE (name
);
1427 cp_error ("`%T' fails to be an aggregate typedef", name
);
1431 if (! IS_AGGR_TYPE (type
)
1432 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1433 && TREE_CODE (type
) != TEMPLATE_TEMPLATE_PARM
)
1436 cp_error ("type `%T' is of non-aggregate type", type
);
1443 get_type_value (name
)
1446 if (name
== error_mark_node
)
1449 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1450 return IDENTIFIER_TYPE_VALUE (name
);
1456 /* This code could just as well go in `class.c', but is placed here for
1459 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1460 the appropriate function call. */
1463 build_member_call (type
, name
, parmlist
)
1464 tree type
, name
, parmlist
;
1469 int dont_use_this
= 0;
1470 tree basetype_path
, decl
;
1472 if (type
== std_node
)
1473 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1475 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1476 return build_x_function_call (lookup_namespace_name (type
, name
),
1477 parmlist
, current_class_ref
);
1479 if (TREE_CODE (name
) != TEMPLATE_ID_EXPR
)
1482 method_name
= TREE_OPERAND (name
, 0);
1484 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1486 method_name
= TREE_OPERAND (method_name
, 0);
1490 /* This shouldn't be here, and build_member_call shouldn't appear in
1492 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1493 && get_aggr_from_typedef (type
, 0) == 0)
1495 tree ns
= lookup_name (type
, 0);
1496 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1498 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1502 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1503 return error_mark_node
;
1505 /* An operator we did not like. */
1506 if (name
== NULL_TREE
)
1507 return error_mark_node
;
1511 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1513 return error_mark_node
;
1516 /* No object? Then just fake one up, and let build_method_call
1517 figure out what to do. */
1518 if (current_class_type
== 0
1519 || get_base_distance (type
, current_class_type
, 0, &basetype_path
) == -1)
1524 basetype_path
= TYPE_BINFO (type
);
1525 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1527 else if (current_class_ptr
== 0)
1530 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1534 tree olddecl
= current_class_ptr
;
1535 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1536 if (oldtype
!= type
)
1538 tree newtype
= build_type_variant (type
, TYPE_READONLY (oldtype
),
1539 TYPE_VOLATILE (oldtype
));
1540 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1546 decl
= build_indirect_ref (decl
, NULL_PTR
);
1548 if (method_name
== constructor_name (type
)
1549 || method_name
== constructor_name_full (type
))
1550 return build_functional_cast (type
, parmlist
);
1551 if ((t
= lookup_fnfields (basetype_path
, method_name
, 0)))
1552 return build_method_call (decl
,
1553 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1554 ? name
: method_name
,
1555 parmlist
, basetype_path
,
1556 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1557 if (TREE_CODE (name
) == IDENTIFIER_NODE
1558 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1560 if (t
== error_mark_node
)
1561 return error_mark_node
;
1562 if (TREE_CODE (t
) == FIELD_DECL
)
1566 cp_error ("invalid use of non-static field `%D'", t
);
1567 return error_mark_node
;
1569 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1571 else if (TREE_CODE (t
) == VAR_DECL
)
1575 cp_error ("invalid use of member `%D'", t
);
1576 return error_mark_node
;
1578 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
)))
1579 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
,
1580 parmlist
, NULL_TREE
);
1581 return build_function_call (decl
, parmlist
);
1585 cp_error ("no method `%T::%D'", type
, name
);
1586 return error_mark_node
;
1590 /* Build a reference to a member of an aggregate. This is not a
1591 C++ `&', but really something which can have its address taken,
1592 and then act as a pointer to member, for example TYPE :: FIELD
1593 can have its address taken by saying & TYPE :: FIELD.
1595 @@ Prints out lousy diagnostics for operator <typename>
1598 @@ This function should be rewritten and placed in search.c. */
1601 build_offset_ref (type
, name
)
1604 tree decl
, fnfields
, fields
, t
= error_mark_node
;
1605 tree basebinfo
= NULL_TREE
;
1608 /* class templates can come in as TEMPLATE_DECLs here. */
1609 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
1612 if (type
== std_node
)
1613 return do_scoped_id (name
, 0);
1615 if (processing_template_decl
|| uses_template_parms (type
))
1616 return build_min_nt (SCOPE_REF
, type
, name
);
1618 /* Handle namespace names fully here. */
1619 if (TREE_CODE (type
) == NAMESPACE_DECL
)
1620 return lookup_namespace_name (type
, name
);
1622 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1623 return error_mark_node
;
1625 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1628 name
= TREE_OPERAND (name
, 0);
1631 if (name
== constructor_name_full (type
))
1632 name
= constructor_name (type
);
1634 if (TYPE_SIZE (complete_type (type
)) == 0)
1636 if (type
== current_class_type
)
1637 t
= IDENTIFIER_CLASS_VALUE (name
);
1642 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1644 return error_mark_node
;
1646 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == VAR_DECL
1647 || TREE_CODE (t
) == CONST_DECL
)
1652 if (TREE_CODE (t
) == FIELD_DECL
)
1653 sorry ("use of member in incomplete aggregate type");
1654 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1655 sorry ("use of member function in incomplete aggregate type");
1657 my_friendly_abort (52);
1658 return error_mark_node
;
1661 if (current_class_type
== 0
1662 || get_base_distance (type
, current_class_type
, 0, &basebinfo
) == -1)
1664 basebinfo
= TYPE_BINFO (type
);
1665 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1667 else if (current_class_ptr
== 0)
1668 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1670 decl
= current_class_ref
;
1672 if (constructor_name (BINFO_TYPE (basebinfo
)) == name
)
1675 name
= dtor_identifier
;
1677 name
= ctor_identifier
;
1681 my_friendly_abort (999);
1684 fnfields
= lookup_fnfields (basebinfo
, name
, 1);
1685 fields
= lookup_field (basebinfo
, name
, 0, 0);
1687 if (fields
== error_mark_node
|| fnfields
== error_mark_node
)
1688 return error_mark_node
;
1690 /* A lot of this logic is now handled in lookup_field and
1694 extern int flag_save_memoized_contexts
;
1695 basebinfo
= TREE_PURPOSE (fnfields
);
1697 /* Go from the TREE_BASELINK to the member function info. */
1698 t
= TREE_VALUE (fnfields
);
1700 if (!really_overloaded_fn (t
))
1704 /* Get rid of a potential OVERLOAD around it */
1705 t
= OVL_CURRENT (t
);
1707 /* unique functions are handled easily. */
1708 access
= compute_access (basebinfo
, t
);
1709 if (access
== access_protected_node
)
1711 cp_error_at ("member function `%#D' is protected", t
);
1712 error ("in this context");
1713 return error_mark_node
;
1715 if (access
== access_private_node
)
1717 cp_error_at ("member function `%#D' is private", t
);
1718 error ("in this context");
1719 return error_mark_node
;
1722 return build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1725 /* FNFIELDS is most likely allocated on the search_obstack,
1726 which will go away after this class scope. If we need
1727 to save this value for later (either for memoization
1728 or for use as an initializer for a static variable), then
1731 ??? The smart thing to do for the case of saving initializers
1732 is to resolve them before we're done with this scope. */
1733 if (!TREE_PERMANENT (fnfields
)
1734 && ((flag_save_memoized_contexts
&& toplevel_bindings_p ())
1735 || ! allocation_temporary_p ()))
1736 fnfields
= copy_list (fnfields
);
1738 t
= build_tree_list (error_mark_node
, fnfields
);
1739 TREE_TYPE (t
) = build_offset_type (type
, unknown_type_node
);
1743 /* Now that we know we are looking for a field, see if we
1744 have access to that field. Lookup_field will give us the
1747 t
= lookup_field (basebinfo
, name
, 1, 0);
1749 if (t
== error_mark_node
)
1750 return error_mark_node
;
1754 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1755 return error_mark_node
;
1758 if (TREE_CODE (t
) == TYPE_DECL
)
1763 /* static class members and class-specific enum
1764 values can be returned without further ado. */
1765 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1768 return convert_from_reference (t
);
1771 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_BIT_FIELD (t
))
1773 cp_error ("illegal pointer to bit field `%D'", t
);
1774 return error_mark_node
;
1777 /* static class functions too. */
1778 if (TREE_CODE (t
) == FUNCTION_DECL
1779 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1780 my_friendly_abort (53);
1782 /* In member functions, the form `type::name' is no longer
1783 equivalent to `this->type::name', at least not until
1784 resolve_offset_ref. */
1785 return build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1788 /* If a OFFSET_REF made it through to here, then it did
1789 not have its address taken. */
1792 resolve_offset_ref (exp
)
1795 tree type
= TREE_TYPE (exp
);
1796 tree base
= NULL_TREE
;
1798 tree basetype
, addr
;
1800 if (TREE_CODE (exp
) == TREE_LIST
)
1802 cp_pedwarn ("assuming & on overloaded member function");
1803 return build_unary_op (ADDR_EXPR
, exp
, 0);
1806 if (TREE_CODE (exp
) == OFFSET_REF
)
1808 member
= TREE_OPERAND (exp
, 1);
1809 base
= TREE_OPERAND (exp
, 0);
1813 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
1814 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
1816 error ("object missing in use of pointer-to-member construct");
1817 return error_mark_node
;
1820 type
= TREE_TYPE (type
);
1821 base
= current_class_ref
;
1824 if ((TREE_CODE (member
) == VAR_DECL
1825 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1826 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
1827 || TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
1829 /* These were static members. */
1830 if (mark_addressable (member
) == 0)
1831 return error_mark_node
;
1835 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
1836 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
1839 /* Syntax error can cause a member which should
1840 have been seen as static to be grok'd as non-static. */
1841 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
1843 if (TREE_ADDRESSABLE (member
) == 0)
1845 cp_error_at ("member `%D' is non-static but referenced as a static member",
1847 error ("at this point in file");
1848 TREE_ADDRESSABLE (member
) = 1;
1850 return error_mark_node
;
1853 /* The first case is really just a reference to a member of `this'. */
1854 if (TREE_CODE (member
) == FIELD_DECL
1855 && (base
== current_class_ref
1856 || (TREE_CODE (base
) == NOP_EXPR
1857 && TREE_OPERAND (base
, 0) == error_mark_node
)))
1859 tree basetype_path
, access
;
1861 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
1862 basetype
= TYPE_OFFSET_BASETYPE (type
);
1864 basetype
= DECL_CONTEXT (member
);
1866 base
= current_class_ptr
;
1868 if (get_base_distance (basetype
, TREE_TYPE (TREE_TYPE (base
)), 0, &basetype_path
) < 0)
1870 error_not_base_type (basetype
, TREE_TYPE (TREE_TYPE (base
)));
1871 return error_mark_node
;
1873 /* Kludge: we need to use basetype_path now, because
1874 convert_pointer_to will bash it. */
1875 access
= compute_access (basetype_path
, member
);
1876 addr
= convert_pointer_to (basetype
, base
);
1877 if (access
== access_public_node
)
1878 return build (COMPONENT_REF
, TREE_TYPE (member
),
1879 build_indirect_ref (addr
, NULL_PTR
), member
);
1880 if (access
== access_protected_node
)
1882 cp_error_at ("member `%D' is protected", member
);
1883 error ("in this context");
1884 return error_mark_node
;
1886 if (access
== access_private_node
)
1888 cp_error_at ("member `%D' is private", member
);
1889 error ("in this context");
1890 return error_mark_node
;
1892 my_friendly_abort (55);
1895 /* Ensure that we have an object. */
1896 if (TREE_CODE (base
) == NOP_EXPR
1897 && TREE_OPERAND (base
, 0) == error_mark_node
)
1898 addr
= error_mark_node
;
1901 /* If this is a reference to a member function, then return the
1902 address of the member function (which may involve going
1903 through the object's vtable), otherwise, return an expression
1904 for the dereferenced pointer-to-member construct. */
1905 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
1908 if (TREE_CODE (TREE_TYPE (member
)) == OFFSET_TYPE
)
1910 if (addr
== error_mark_node
)
1912 cp_error ("object missing in `%E'", exp
);
1913 return error_mark_node
;
1916 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (member
));
1917 addr
= convert_pointer_to (basetype
, addr
);
1918 member
= cp_convert (ptrdiff_type_node
,
1919 build_unary_op (ADDR_EXPR
, member
, 0));
1921 /* Pointer to data members are offset by one, so that a null
1922 pointer with a real value of 0 is distinguishable from an
1923 offset of the first member of a structure. */
1924 member
= build_binary_op (MINUS_EXPR
, member
,
1925 cp_convert (ptrdiff_type_node
, integer_one_node
),
1928 return build1 (INDIRECT_REF
, type
,
1929 build (PLUS_EXPR
, build_pointer_type (type
),
1932 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
1934 return get_member_function_from_ptrfunc (&addr
, member
);
1936 my_friendly_abort (56);
1941 /* Return either DECL or its known constant value (if it has one). */
1944 decl_constant_value (decl
)
1947 if (! TREE_THIS_VOLATILE (decl
)
1949 /* These may be necessary for C, but they break C++. */
1950 ! TREE_PUBLIC (decl
)
1951 /* Don't change a variable array bound or initial value to a constant
1952 in a place where a variable is invalid. */
1955 && DECL_INITIAL (decl
) != 0
1956 && DECL_INITIAL (decl
) != error_mark_node
1957 /* This is invalid if initial value is not constant.
1958 If it has either a function call, a memory reference,
1959 or a variable, then re-evaluating it could give different results. */
1960 && TREE_CONSTANT (DECL_INITIAL (decl
))
1961 /* Check for cases where this is sub-optimal, even though valid. */
1962 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
1964 /* We must allow this to work outside of functions so that
1965 static constants can be used for array sizes. */
1966 && current_function_decl
!= 0
1967 && DECL_MODE (decl
) != BLKmode
1970 return DECL_INITIAL (decl
);
1974 /* Common subroutines of build_new and build_vec_delete. */
1976 /* Common interface for calling "builtin" functions that are not
1980 build_builtin_call (type
, node
, arglist
)
1985 tree rval
= build (CALL_EXPR
, type
, node
, arglist
, NULL_TREE
);
1986 TREE_SIDE_EFFECTS (rval
) = 1;
1987 assemble_external (TREE_OPERAND (node
, 0));
1988 TREE_USED (TREE_OPERAND (node
, 0)) = 1;
1992 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1993 (which needs to go through some sort of groktypename) or it
1994 is the name of the class we are newing. INIT is an initialization value.
1995 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1996 If INIT is void_type_node, it means do *not* call a constructor
1999 For types with constructors, the data returned is initialized
2000 by the appropriate constructor.
2002 Whether the type has a constructor or not, if it has a pointer
2003 to a virtual function table, then that pointer is set up
2006 Unless I am mistaken, a call to new () will return initialized
2007 data regardless of whether the constructor itself is private or
2008 not. NOPE; new fails if the constructor is private (jcm).
2010 Note that build_new does nothing to assure that any special
2011 alignment requirements of the type are met. Rather, it leaves
2012 it up to malloc to do the right thing. Otherwise, folding to
2013 the right alignment cal cause problems if the user tries to later
2014 free the memory returned by `new'.
2016 PLACEMENT is the `placement' list for user-defined operator new (). */
2018 extern int flag_check_new
;
2021 build_new (placement
, decl
, init
, use_global_new
)
2027 tree nelts
= NULL_TREE
, t
;
2030 tree pending_sizes
= NULL_TREE
;
2032 if (decl
== error_mark_node
)
2033 return error_mark_node
;
2035 if (TREE_CODE (decl
) == TREE_LIST
)
2037 tree absdcl
= TREE_VALUE (decl
);
2038 tree last_absdcl
= NULL_TREE
;
2039 int old_immediate_size_expand
= 0;
2041 if (current_function_decl
2042 && DECL_CONSTRUCTOR_P (current_function_decl
))
2044 old_immediate_size_expand
= immediate_size_expand
;
2045 immediate_size_expand
= 0;
2048 nelts
= integer_one_node
;
2050 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
2051 my_friendly_abort (215);
2052 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2054 last_absdcl
= absdcl
;
2055 absdcl
= TREE_OPERAND (absdcl
, 0);
2058 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2060 /* probably meant to be a vec new */
2063 while (TREE_OPERAND (absdcl
, 0)
2064 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2066 last_absdcl
= absdcl
;
2067 absdcl
= TREE_OPERAND (absdcl
, 0);
2071 this_nelts
= TREE_OPERAND (absdcl
, 1);
2072 if (this_nelts
!= error_mark_node
)
2074 if (this_nelts
== NULL_TREE
)
2075 error ("new of array type fails to specify size");
2076 else if (processing_template_decl
)
2079 absdcl
= TREE_OPERAND (absdcl
, 0);
2083 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2084 absdcl
= TREE_OPERAND (absdcl
, 0);
2085 if (this_nelts
== integer_zero_node
)
2087 warning ("zero size array reserves no space");
2088 nelts
= integer_zero_node
;
2091 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2095 nelts
= integer_zero_node
;
2099 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2101 TREE_VALUE (decl
) = absdcl
;
2103 type
= groktypename (decl
);
2104 if (! type
|| type
== error_mark_node
)
2106 immediate_size_expand
= old_immediate_size_expand
;
2107 return error_mark_node
;
2110 if (current_function_decl
2111 && DECL_CONSTRUCTOR_P (current_function_decl
))
2113 pending_sizes
= get_pending_sizes ();
2114 immediate_size_expand
= old_immediate_size_expand
;
2117 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2119 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2121 /* An aggregate type. */
2122 type
= IDENTIFIER_TYPE_VALUE (decl
);
2123 decl
= TYPE_MAIN_DECL (type
);
2127 /* A builtin type. */
2128 decl
= lookup_name (decl
, 1);
2129 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2130 type
= TREE_TYPE (decl
);
2133 else if (TREE_CODE (decl
) == TYPE_DECL
)
2135 type
= TREE_TYPE (decl
);
2140 decl
= TYPE_MAIN_DECL (type
);
2143 if (processing_template_decl
)
2146 t
= min_tree_cons (min_tree_cons (NULL_TREE
, type
, NULL_TREE
),
2147 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2152 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2153 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2157 /* ``A reference cannot be created by the new operator. A reference
2158 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2159 returned by new.'' ARM 5.3.3 */
2160 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2162 error ("new cannot be applied to a reference type");
2163 type
= TREE_TYPE (type
);
2166 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2168 error ("new cannot be applied to a function type");
2169 return error_mark_node
;
2172 /* When the object being created is an array, the new-expression yields a
2173 pointer to the initial element (if any) of the array. For example,
2174 both new int and new int[10] return an int*. 5.3.4. */
2175 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2177 nelts
= array_type_nelts_top (type
);
2179 type
= TREE_TYPE (type
);
2183 t
= build_nt (ARRAY_REF
, type
, nelts
);
2187 rval
= build (NEW_EXPR
, build_pointer_type (type
), placement
, t
, init
);
2188 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2189 TREE_SIDE_EFFECTS (rval
) = 1;
2191 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2192 rval
= build1 (NOP_EXPR
, TREE_TYPE (rval
), rval
);
2193 TREE_NO_UNUSED_WARNING (rval
) = 1;
2196 rval
= build_compound_expr (chainon (pending_sizes
,
2197 build_expr_list (NULL_TREE
, rval
)));
2202 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
2203 value is immediately handed to expand_expr. */
2209 tree placement
, init
;
2210 tree type
, true_type
, size
, rval
;
2211 tree nelts
= NULL_TREE
;
2212 tree alloc_expr
, alloc_node
= NULL_TREE
;
2214 enum tree_code code
= NEW_EXPR
;
2215 int use_cookie
, nothrow
, check_new
;
2218 placement
= TREE_OPERAND (exp
, 0);
2219 type
= TREE_OPERAND (exp
, 1);
2220 init
= TREE_OPERAND (exp
, 2);
2221 use_global_new
= NEW_EXPR_USE_GLOBAL (exp
);
2223 if (TREE_CODE (type
) == ARRAY_REF
)
2226 nelts
= TREE_OPERAND (type
, 1);
2227 type
= TREE_OPERAND (type
, 0);
2231 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
))
2232 type
= TYPE_MAIN_VARIANT (type
);
2234 /* If our base type is an array, then make sure we know how many elements
2236 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2238 tree this_nelts
= array_type_nelts_top (true_type
);
2239 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2240 true_type
= TREE_TYPE (true_type
);
2243 if (TYPE_SIZE (complete_type (true_type
)) == 0)
2245 incomplete_type_error (0, true_type
);
2246 return error_mark_node
;
2250 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2253 size
= size_in_bytes (type
);
2255 if (true_type
== void_type_node
)
2257 error ("invalid type `void' for new");
2258 return error_mark_node
;
2261 if (TYPE_LANG_SPECIFIC (true_type
)
2262 && CLASSTYPE_ABSTRACT_VIRTUALS (true_type
))
2264 abstract_virtuals_error (NULL_TREE
, true_type
);
2265 return error_mark_node
;
2268 if (TYPE_LANG_SPECIFIC (true_type
) && IS_SIGNATURE (true_type
))
2270 signature_error (NULL_TREE
, true_type
);
2271 return error_mark_node
;
2275 /* Get a little extra space to store a couple of things before the new'ed
2276 array, if this isn't the default placement new. */
2278 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2279 && ! (placement
&& ! TREE_CHAIN (placement
)
2280 && TREE_TYPE (TREE_VALUE (placement
)) == ptr_type_node
));
2282 /* Get a little extra space to store a couple of things before the new'ed
2283 array, if this is either non-placement new or new (nothrow). */
2285 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2286 && (! placement
|| nothrow
));
2291 tree extra
= BI_header_size
;
2293 size
= size_binop (PLUS_EXPR
, size
, extra
);
2298 code
= VEC_NEW_EXPR
;
2300 if (init
&& pedantic
)
2301 cp_pedwarn ("initialization in array new");
2304 /* Allocate the object. */
2306 if (! has_array
&& ! placement
&& flag_this_is_variable
> 0
2307 && TYPE_NEEDS_CONSTRUCTING (true_type
) && init
!= void_type_node
)
2309 if (init
== NULL_TREE
|| TREE_CODE (init
) == TREE_LIST
)
2313 error ("constructors take parameter lists");
2314 return error_mark_node
;
2321 if (flag_exceptions
)
2322 /* We will use RVAL when generating an exception handler for
2323 this new-expression, so we must save it. */
2324 susp
= suspend_momentary ();
2326 rval
= build_op_new_call
2327 (code
, true_type
, expr_tree_cons (NULL_TREE
, size
, placement
),
2328 LOOKUP_NORMAL
| (use_global_new
* LOOKUP_GLOBAL
));
2329 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2331 if (flag_exceptions
)
2332 resume_momentary (susp
);
2335 /* unless an allocation function is declared with an empty excep-
2336 tion-specification (_except.spec_), throw(), it indicates failure to
2337 allocate storage by throwing a bad_alloc exception (clause _except_,
2338 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2339 cation function is declared with an empty exception-specification,
2340 throw(), it returns null to indicate failure to allocate storage and a
2341 non-null pointer otherwise.
2343 So check for a null exception spec on the op new we just called. */
2348 /* The CALL_EXPR. */
2349 tree t
= TREE_OPERAND (rval
, 0);
2351 t
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
2352 t
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t
));
2354 if (t
&& TREE_VALUE (t
) == NULL_TREE
)
2357 check_new
= flag_check_new
|| nothrow
;
2359 if ((check_new
|| flag_exceptions
) && rval
)
2361 alloc_expr
= get_target_expr (rval
);
2362 alloc_node
= rval
= TREE_OPERAND (alloc_expr
, 0);
2365 alloc_expr
= NULL_TREE
;
2367 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2368 sure we have some extra bytes in that case for the BI_header_size
2369 cookies? And how does that interact with the code below? (mrs) */
2370 /* Finish up some magic for new'ed arrays */
2371 if (use_cookie
&& rval
!= NULL_TREE
)
2373 tree extra
= BI_header_size
;
2375 rval
= convert (string_type_node
, rval
); /* for ptr arithmetic */
2376 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, extra
, 1));
2377 /* Store header info. */
2378 cookie
= build_indirect_ref (build (MINUS_EXPR
,
2379 build_pointer_type (BI_header_type
),
2380 rval
, extra
), NULL_PTR
);
2381 exp1
= build (MODIFY_EXPR
, void_type_node
,
2382 build_component_ref (cookie
, nc_nelts_field_id
,
2385 TREE_SIDE_EFFECTS (exp1
) = 1;
2386 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2387 rval
= build_compound_expr
2388 (expr_tree_cons (NULL_TREE
, exp1
,
2389 build_expr_list (NULL_TREE
, rval
)));
2392 if (rval
== error_mark_node
)
2393 return error_mark_node
;
2395 /* Don't call any constructors or do any initialization. */
2396 if (init
== void_type_node
)
2399 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2401 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2402 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2404 /* New 2.0 interpretation: `new int (10)' means
2405 allocate an int, and initialize it with 10. */
2408 rval
= save_expr (rval
);
2409 deref
= build_indirect_ref (rval
, NULL_PTR
);
2410 TREE_READONLY (deref
) = 0;
2412 if (TREE_CHAIN (init
) != NULL_TREE
)
2413 pedwarn ("initializer list being treated as compound expression");
2414 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2416 pedwarn ("initializer list appears where operand should be used");
2417 init
= TREE_OPERAND (init
, 1);
2419 init
= build_compound_expr (init
);
2421 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2422 "new", NULL_TREE
, 0);
2423 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2424 build_modify_expr (deref
, NOP_EXPR
, init
),
2426 TREE_NO_UNUSED_WARNING (rval
) = 1;
2427 TREE_SIDE_EFFECTS (rval
) = 1;
2429 else if (! has_array
)
2432 /* Constructors are never virtual. If it has an initialization, we
2433 need to complain if we aren't allowed to use the ctor that took
2435 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2437 if (rval
&& TYPE_USES_VIRTUAL_BASECLASSES (true_type
))
2439 init
= expr_tree_cons (NULL_TREE
, integer_one_node
, init
);
2440 flags
|= LOOKUP_HAS_IN_CHARGE
;
2445 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2446 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2448 newrval
= build_method_call (newrval
, ctor_identifier
,
2449 init
, TYPE_BINFO (true_type
), flags
);
2451 if (newrval
== NULL_TREE
|| newrval
== error_mark_node
)
2452 return error_mark_node
;
2455 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2458 rval
= build (VEC_INIT_EXPR
, TREE_TYPE (rval
),
2459 save_expr (rval
), init
, nelts
);
2461 /* If any part of the object initialization terminates by throwing
2462 an exception and the new-expression does not contain a
2463 new-placement, then the deallocation function is called to free
2464 the memory in which the object was being constructed. */
2465 if (flag_exceptions
&& alloc_expr
)
2467 enum tree_code dcode
= has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2469 int flags
= LOOKUP_NORMAL
| (use_global_new
* LOOKUP_GLOBAL
);
2471 /* All cleanups must last longer than normal. */
2472 int yes
= suspend_momentary ();
2475 flags
|= LOOKUP_SPECULATIVELY
;
2477 /* Copy size to the saveable obstack. */
2478 size
= copy_node (size
);
2480 /* If we have a new-placement, we need to pass the alloc TARGET_EXPR
2481 to build_op_delete_call so it can extract the args. */
2482 cleanup
= build_op_delete_call
2483 (dcode
, placement
? alloc_expr
: alloc_node
, size
, flags
);
2485 resume_momentary (yes
);
2487 /* Ack! First we allocate the memory. Then we set our sentry
2488 variable to true, and expand a cleanup that deletes the memory
2489 if sentry is true. Then we run the constructor and store the
2490 returned pointer in buf. Then we clear sentry and return buf. */
2495 /* Disable this until flow is fixed so that it doesn't
2496 think the initialization of sentry is a dead write. */
2497 tree end
, sentry
, begin
, buf
, t
= TREE_TYPE (rval
);
2499 begin
= get_target_expr (boolean_true_node
);
2500 sentry
= TREE_OPERAND (begin
, 0);
2502 yes
= suspend_momentary ();
2503 TREE_OPERAND (begin
, 2)
2504 = build (COND_EXPR
, void_type_node
, sentry
,
2505 cleanup
, void_zero_node
);
2506 resume_momentary (yes
);
2508 rval
= get_target_expr (rval
);
2510 end
= build (MODIFY_EXPR
, TREE_TYPE (sentry
),
2511 sentry
, boolean_false_node
);
2512 TREE_SIDE_EFFECTS (end
) = 1;
2514 buf
= TREE_OPERAND (rval
, 0);
2516 rval
= build (COMPOUND_EXPR
, t
, begin
,
2517 build (COMPOUND_EXPR
, t
, rval
,
2518 build (COMPOUND_EXPR
, t
, end
, buf
)));
2520 /* FIXME: this is a workaround for a crash due to overlapping
2521 exception regions. Cleanups shouldn't really happen here. */
2522 rval
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (rval
), rval
);
2524 rval
= build (TRY_CATCH_EXPR
, TREE_TYPE (rval
), rval
, cleanup
);
2525 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2530 else if (TYPE_READONLY (true_type
))
2531 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2535 if (alloc_expr
&& rval
== alloc_node
)
2537 rval
= TREE_OPERAND (alloc_expr
, 1);
2538 alloc_expr
= NULL_TREE
;
2541 if (check_new
&& alloc_expr
)
2543 /* Did we modify the storage? */
2544 tree ifexp
= build_binary_op (NE_EXPR
, alloc_node
,
2545 integer_zero_node
, 1);
2546 rval
= build_conditional_expr (ifexp
, rval
, alloc_node
);
2550 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2552 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2554 /* The type of new int [3][3] is not int *, but int [3] * */
2555 rval
= build_c_cast (build_pointer_type (type
), rval
);
2562 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,
2564 tree base
, maxindex
, type
;
2565 tree auto_delete_vec
, auto_delete
;
2566 int use_global_delete
;
2569 tree ptype
= build_pointer_type (type
= complete_type (type
));
2570 tree size_exp
= size_in_bytes (type
);
2572 /* Temporary variables used by the loop. */
2573 tree tbase
, tbase_init
;
2575 /* This is the body of the loop that implements the deletion of a
2576 single element, and moves temp variables to next elements. */
2579 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2582 /* This is the thing that governs what to do after the loop has run. */
2583 tree deallocate_expr
= 0;
2585 /* This is the BIND_EXPR which holds the outermost iterator of the
2586 loop. It is convenient to set this variable up and test it before
2587 executing any other code in the loop.
2588 This is also the containing expression returned by this function. */
2589 tree controller
= NULL_TREE
;
2591 if (! IS_AGGR_TYPE (type
) || ! TYPE_NEEDS_DESTRUCTOR (type
))
2593 loop
= integer_zero_node
;
2597 /* The below is short by BI_header_size */
2598 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2600 tbase
= build_decl (VAR_DECL
, NULL_TREE
, ptype
);
2601 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2602 fold (build (PLUS_EXPR
, ptype
,
2605 DECL_REGISTER (tbase
) = 1;
2606 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2607 TREE_SIDE_EFFECTS (controller
) = 1;
2609 if (auto_delete
!= integer_zero_node
2610 && auto_delete
!= integer_two_node
)
2612 tree base_tbd
= cp_convert (ptype
,
2613 build_binary_op (MINUS_EXPR
,
2614 cp_convert (ptr_type_node
, base
),
2617 /* This is the real size */
2618 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2619 body
= build_expr_list (NULL_TREE
,
2620 build_x_delete (ptype
, base_tbd
,
2621 2 | use_global_delete
,
2623 body
= build (COND_EXPR
, void_type_node
,
2624 build (BIT_AND_EXPR
, integer_type_node
,
2625 auto_delete
, integer_one_node
),
2626 body
, integer_zero_node
);
2631 body
= expr_tree_cons (NULL_TREE
,
2632 build_delete (ptype
, tbase
, auto_delete
,
2633 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2636 body
= expr_tree_cons (NULL_TREE
,
2637 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2640 body
= expr_tree_cons (NULL_TREE
,
2641 build (EXIT_EXPR
, void_type_node
,
2642 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2645 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2647 loop
= expr_tree_cons (NULL_TREE
, tbase_init
,
2648 expr_tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2649 loop
= build_compound_expr (loop
);
2652 /* If the delete flag is one, or anything else with the low bit set,
2653 delete the storage. */
2654 if (auto_delete_vec
== integer_zero_node
2655 || auto_delete_vec
== integer_two_node
)
2656 deallocate_expr
= integer_zero_node
;
2661 /* The below is short by BI_header_size */
2662 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2664 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2669 base_tbd
= cp_convert (ptype
,
2670 build_binary_op (MINUS_EXPR
,
2671 cp_convert (string_type_node
, base
),
2674 /* True size with header. */
2675 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2677 deallocate_expr
= build_x_delete (ptype
, base_tbd
,
2678 2 | use_global_delete
,
2680 if (auto_delete_vec
!= integer_one_node
)
2681 deallocate_expr
= build (COND_EXPR
, void_type_node
,
2682 build (BIT_AND_EXPR
, integer_type_node
,
2683 auto_delete_vec
, integer_one_node
),
2684 deallocate_expr
, integer_zero_node
);
2687 if (loop
&& deallocate_expr
!= integer_zero_node
)
2689 body
= expr_tree_cons (NULL_TREE
, loop
,
2690 expr_tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2691 body
= build_compound_expr (body
);
2696 /* Outermost wrapper: If pointer is null, punt. */
2697 body
= build (COND_EXPR
, void_type_node
,
2698 build (NE_EXPR
, boolean_type_node
, base
, integer_zero_node
),
2699 body
, integer_zero_node
);
2700 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2704 TREE_OPERAND (controller
, 1) = body
;
2708 return cp_convert (void_type_node
, body
);
2711 /* Build a tree to cleanup partially built arrays.
2712 BASE is that starting address of the array.
2713 COUNT is the count of objects that have been built, that need destroying.
2714 TYPE is the type of elements in the array. */
2717 build_array_eh_cleanup (base
, count
, type
)
2718 tree base
, count
, type
;
2720 tree expr
= build_vec_delete_1 (base
, count
, type
, integer_two_node
,
2721 integer_zero_node
, 0);
2725 /* `expand_vec_init' performs initialization of a vector of aggregate
2728 DECL is passed only for error reporting, and provides line number
2729 and source file name information.
2730 BASE is the space where the vector will be.
2731 MAXINDEX is the maximum index of the array (one less than the
2732 number of elements).
2733 INIT is the (possibly NULL) initializer.
2735 FROM_ARRAY is 0 if we should init everything with INIT
2736 (i.e., every element initialized from INIT).
2737 FROM_ARRAY is 1 if we should index into INIT in parallel
2738 with initialization of DECL.
2739 FROM_ARRAY is 2 if we should index into INIT in parallel,
2740 but use assignment instead of initialization. */
2743 expand_vec_init (decl
, base
, maxindex
, init
, from_array
)
2744 tree decl
, base
, maxindex
, init
;
2748 tree iterator
, base2
= NULL_TREE
;
2749 tree type
= TREE_TYPE (TREE_TYPE (base
));
2752 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2753 if (maxindex
== error_mark_node
)
2754 return error_mark_node
;
2756 if (current_function_decl
== NULL_TREE
)
2758 rval
= make_tree_vec (3);
2759 TREE_VEC_ELT (rval
, 0) = base
;
2760 TREE_VEC_ELT (rval
, 1) = maxindex
;
2761 TREE_VEC_ELT (rval
, 2) = init
;
2765 size
= size_in_bytes (type
);
2767 /* Set to zero in case size is <= 0. Optimizer will delete this if
2768 it is not needed. */
2769 rval
= get_temp_regvar (build_pointer_type (type
),
2770 cp_convert (build_pointer_type (type
), null_pointer_node
));
2771 base
= default_conversion (base
);
2772 base
= cp_convert (build_pointer_type (type
), base
);
2773 expand_assignment (rval
, base
, 0, 0);
2774 base
= get_temp_regvar (build_pointer_type (type
), base
);
2776 if (init
!= NULL_TREE
2777 && TREE_CODE (init
) == CONSTRUCTOR
2778 && (! decl
|| TREE_TYPE (init
) == TREE_TYPE (decl
)))
2780 /* Initialization of array from {...}. */
2781 tree elts
= CONSTRUCTOR_ELTS (init
);
2782 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2783 tree baseinc
= build (PLUS_EXPR
, build_pointer_type (type
), base
, size
);
2784 int host_i
= TREE_INT_CST_LOW (maxindex
);
2786 if (IS_AGGR_TYPE (type
))
2791 expand_aggr_init (baseref
, TREE_VALUE (elts
), 0, 0);
2793 expand_assignment (base
, baseinc
, 0, 0);
2794 elts
= TREE_CHAIN (elts
);
2796 /* Initialize any elements by default if possible. */
2799 if (TYPE_NEEDS_CONSTRUCTING (type
) == 0)
2802 use_variable (DECL_RTL (base
));
2806 iterator
= get_temp_regvar (ptrdiff_type_node
,
2807 build_int_2 (host_i
, 0));
2809 goto init_by_default
;
2815 expand_assignment (baseref
, TREE_VALUE (elts
), 0, 0);
2817 expand_assignment (base
, baseinc
, 0, 0);
2818 elts
= TREE_CHAIN (elts
);
2822 use_variable (DECL_RTL (base
));
2828 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2833 /* If initializing one array from another,
2834 initialize element by element. */
2837 /* We rely upon the below calls the do argument checking */
2838 if (decl
== NULL_TREE
)
2840 sorry ("initialization of array from dissimilar array type");
2841 return error_mark_node
;
2845 base2
= default_conversion (init
);
2846 itype
= TREE_TYPE (base2
);
2847 base2
= get_temp_regvar (itype
, base2
);
2848 itype
= TREE_TYPE (itype
);
2850 else if (TYPE_LANG_SPECIFIC (type
)
2851 && TYPE_NEEDS_CONSTRUCTING (type
)
2852 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2854 error ("initializer ends prematurely");
2855 return error_mark_node
;
2859 expand_start_cond (build (GE_EXPR
, boolean_type_node
,
2860 iterator
, integer_zero_node
), 0);
2861 if (TYPE_NEEDS_DESTRUCTOR (type
))
2862 expand_eh_region_start ();
2863 expand_start_loop_continue_elsewhere (1);
2865 /* The initialization of each array element is a full-expression. */
2866 expand_start_target_temps ();
2870 tree to
= build1 (INDIRECT_REF
, type
, base
);
2874 from
= build1 (INDIRECT_REF
, itype
, base2
);
2878 if (from_array
== 2)
2879 expand_expr_stmt (build_modify_expr (to
, NOP_EXPR
, from
));
2880 else if (TYPE_NEEDS_CONSTRUCTING (type
))
2881 expand_aggr_init (to
, from
, 0, 0);
2883 expand_assignment (to
, from
, 0, 0);
2885 my_friendly_abort (57);
2887 else if (TREE_CODE (type
) == ARRAY_TYPE
)
2890 sorry ("cannot initialize multi-dimensional array with initializer");
2891 expand_vec_init (decl
, build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), base
),
2892 array_type_nelts (type
), 0, 0);
2895 expand_aggr_init (build1 (INDIRECT_REF
, type
, base
), init
, 0, 0);
2897 expand_assignment (base
,
2898 build (PLUS_EXPR
, build_pointer_type (type
), base
, size
),
2901 expand_assignment (base2
,
2902 build (PLUS_EXPR
, build_pointer_type (type
), base2
, size
), 0, 0);
2904 /* Cleanup any temporaries needed for the initial value. */
2905 expand_end_target_temps ();
2907 expand_loop_continue_here ();
2908 expand_exit_loop_if_false (0, build (NE_EXPR
, boolean_type_node
,
2909 build (PREDECREMENT_EXPR
, ptrdiff_type_node
, iterator
, integer_one_node
), minus_one
));
2913 use_variable (DECL_RTL (base
));
2915 use_variable (DECL_RTL (base2
));
2918 if (TYPE_NEEDS_DESTRUCTOR (type
) && flag_exceptions
)
2920 /* We have to ensure that this can live to the cleanup
2921 expansion time, since we know it is only ever needed
2922 once, generate code now. */
2923 push_obstacks_nochange ();
2924 resume_temporary_allocation ();
2926 tree e1
, cleanup
= make_node (RTL_EXPR
);
2927 TREE_TYPE (cleanup
) = void_type_node
;
2928 RTL_EXPR_RTL (cleanup
) = const0_rtx
;
2929 TREE_SIDE_EFFECTS (cleanup
) = 1;
2930 do_pending_stack_adjust ();
2931 start_sequence_for_rtl_expr (cleanup
);
2933 e1
= build_array_eh_cleanup
2935 build_binary_op (MINUS_EXPR
, maxindex
, iterator
, 1),
2937 expand_expr (e1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2938 do_pending_stack_adjust ();
2939 RTL_EXPR_SEQUENCE (cleanup
) = get_insns ();
2942 cleanup
= protect_with_terminate (cleanup
);
2943 expand_eh_region_end (cleanup
);
2949 use_variable (DECL_RTL (iterator
));
2954 use_variable (DECL_RTL (rval
));
2958 /* Free up storage of type TYPE, at address ADDR.
2960 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2963 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2964 used as the second argument to operator delete. It can include
2965 things like padding and magic size cookies. It has virtual in it,
2966 because if you have a base pointer and you delete through a virtual
2967 destructor, it should be the size of the dynamic object, not the
2968 static object, see Free Store 12.5 ANSI C++ WP.
2970 This does not call any destructors. */
2973 build_x_delete (type
, addr
, which_delete
, virtual_size
)
2978 int use_global_delete
= which_delete
& 1;
2979 int use_vec_delete
= !!(which_delete
& 2);
2980 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
2981 int flags
= LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
);
2983 return build_op_delete_call (code
, addr
, virtual_size
, flags
);
2986 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2987 ADDR is an expression which yields the store to be destroyed.
2988 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
2989 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
2990 virtual baseclasses.
2991 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
2993 FLAGS is the logical disjunction of zero or more LOOKUP_
2994 flags. See cp-tree.h for more info.
2996 This function does not delete an object's virtual base classes. */
2999 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3003 int use_global_delete
;
3009 if (addr
== error_mark_node
)
3010 return error_mark_node
;
3012 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3013 set to `error_mark_node' before it gets properly cleaned up. */
3014 if (type
== error_mark_node
)
3015 return error_mark_node
;
3017 type
= TYPE_MAIN_VARIANT (type
);
3019 if (TREE_CODE (type
) == POINTER_TYPE
)
3021 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3022 if (TYPE_SIZE (complete_type (type
)) == 0)
3024 incomplete_type_error (0, type
);
3025 return error_mark_node
;
3027 if (TREE_CODE (type
) == ARRAY_TYPE
)
3029 if (! IS_AGGR_TYPE (type
))
3031 /* Call the builtin operator delete. */
3032 return build_builtin_call (void_type_node
, BID
,
3033 build_expr_list (NULL_TREE
, addr
));
3035 if (TREE_SIDE_EFFECTS (addr
))
3036 addr
= save_expr (addr
);
3038 /* throw away const and volatile on target type of addr */
3039 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3040 ref
= build_indirect_ref (addr
, NULL_PTR
);
3042 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3045 if (TREE_SIDE_EFFECTS (addr
))
3046 addr
= save_expr (addr
);
3047 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3049 error ("unknown array size in delete");
3050 return error_mark_node
;
3052 return build_vec_delete (addr
, array_type_nelts (type
),
3053 auto_delete
, integer_two_node
,
3058 /* Don't check PROTECT here; leave that decision to the
3059 destructor. If the destructor is accessible, call it,
3060 else report error. */
3061 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3062 if (TREE_SIDE_EFFECTS (addr
))
3063 addr
= save_expr (addr
);
3065 if (TREE_CONSTANT (addr
))
3066 addr
= convert_pointer_to (type
, addr
);
3068 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3070 ref
= build_indirect_ref (addr
, NULL_PTR
);
3073 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3075 if (! TYPE_NEEDS_DESTRUCTOR (type
))
3077 if (auto_delete
== integer_zero_node
)
3078 return void_zero_node
;
3080 return build_op_delete_call
3081 (DELETE_EXPR
, addr
, c_sizeof_nowarn (type
),
3082 LOOKUP_NORMAL
| (use_global_delete
* LOOKUP_GLOBAL
));
3085 /* Below, we will reverse the order in which these calls are made.
3086 If we have a destructor, then that destructor will take care
3087 of the base classes; otherwise, we must do that here. */
3088 if (TYPE_HAS_DESTRUCTOR (type
))
3090 tree passed_auto_delete
;
3091 tree do_delete
= NULL_TREE
;
3094 if (use_global_delete
)
3096 tree cond
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3097 auto_delete
, integer_one_node
));
3098 tree call
= build_builtin_call
3099 (void_type_node
, BID
, build_expr_list (NULL_TREE
, addr
));
3101 cond
= fold (build (COND_EXPR
, void_type_node
, cond
,
3102 call
, void_zero_node
));
3103 if (cond
!= void_zero_node
)
3106 passed_auto_delete
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3107 auto_delete
, integer_two_node
));
3110 passed_auto_delete
= auto_delete
;
3112 expr
= build_method_call
3113 (ref
, dtor_identifier
, build_expr_list (NULL_TREE
, passed_auto_delete
),
3117 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3119 if (flags
& LOOKUP_DESTRUCTOR
)
3120 /* Explicit destructor call; don't check for null pointer. */
3121 ifexp
= integer_one_node
;
3123 /* Handle deleting a null pointer. */
3124 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
, 1));
3126 if (ifexp
!= integer_one_node
)
3127 expr
= build (COND_EXPR
, void_type_node
,
3128 ifexp
, expr
, void_zero_node
);
3134 /* We only get here from finish_function for a destructor. */
3135 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3136 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3137 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3138 tree exprstmt
= NULL_TREE
;
3139 tree parent_auto_delete
= auto_delete
;
3142 /* If we have member delete or vbases, we call delete in
3144 if (auto_delete
== integer_zero_node
)
3146 else if (base_binfo
== NULL_TREE
3147 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3149 cond
= build (COND_EXPR
, void_type_node
,
3150 build (BIT_AND_EXPR
, integer_type_node
, auto_delete
, integer_one_node
),
3151 build_builtin_call (void_type_node
, BID
,
3152 build_expr_list (NULL_TREE
, addr
)),
3159 exprstmt
= build_expr_list (NULL_TREE
, cond
);
3162 && ! TREE_VIA_VIRTUAL (base_binfo
)
3163 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3165 tree this_auto_delete
;
3167 if (BINFO_OFFSET_ZEROP (base_binfo
))
3168 this_auto_delete
= parent_auto_delete
;
3170 this_auto_delete
= integer_zero_node
;
3172 expr
= build_scoped_method_call
3173 (ref
, base_binfo
, dtor_identifier
,
3174 build_expr_list (NULL_TREE
, this_auto_delete
));
3175 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3178 /* Take care of the remaining baseclasses. */
3179 for (i
= 1; i
< n_baseclasses
; i
++)
3181 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3182 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3183 || TREE_VIA_VIRTUAL (base_binfo
))
3186 expr
= build_scoped_method_call
3187 (ref
, base_binfo
, dtor_identifier
,
3188 build_expr_list (NULL_TREE
, integer_zero_node
));
3190 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3193 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3195 if (TREE_CODE (member
) != FIELD_DECL
)
3197 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member
)))
3199 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3200 tree this_type
= TREE_TYPE (member
);
3201 expr
= build_delete (this_type
, this_member
, integer_two_node
, flags
, 0);
3202 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3207 return build_compound_expr (exprstmt
);
3208 /* Virtual base classes make this function do nothing. */
3209 return void_zero_node
;
3213 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3216 build_vbase_delete (type
, decl
)
3219 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3220 tree result
= NULL_TREE
;
3221 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3223 my_friendly_assert (addr
!= error_mark_node
, 222);
3227 tree this_addr
= convert_force (build_pointer_type (BINFO_TYPE (vbases
)),
3229 result
= expr_tree_cons (NULL_TREE
,
3230 build_delete (TREE_TYPE (this_addr
), this_addr
,
3232 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3234 vbases
= TREE_CHAIN (vbases
);
3236 return build_compound_expr (nreverse (result
));
3239 /* Build a C++ vector delete expression.
3240 MAXINDEX is the number of elements to be deleted.
3241 ELT_SIZE is the nominal size of each element in the vector.
3242 BASE is the expression that should yield the store to be deleted.
3243 This function expands (or synthesizes) these calls itself.
3244 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3245 AUTO_DELETE say whether each item in the container should be deallocated.
3247 This also calls delete for virtual baseclasses of elements of the vector.
3249 Update: MAXINDEX is no longer needed. The size can be extracted from the
3250 start of the vector for pointers, and from the type for arrays. We still
3251 use MAXINDEX for arrays because it happens to already have one of the
3252 values we'd have to extract. (We could use MAXINDEX with pointers to
3253 confirm the size, and trap if the numbers differ; not clear that it'd
3254 be worth bothering.) */
3257 build_vec_delete (base
, maxindex
, auto_delete_vec
, auto_delete
,
3259 tree base
, maxindex
;
3260 tree auto_delete_vec
, auto_delete
;
3261 int use_global_delete
;
3265 if (TREE_CODE (base
) == OFFSET_REF
)
3266 base
= resolve_offset_ref (base
);
3268 type
= TREE_TYPE (base
);
3270 base
= stabilize_reference (base
);
3272 /* Since we can use base many times, save_expr it. */
3273 if (TREE_SIDE_EFFECTS (base
))
3274 base
= save_expr (base
);
3276 if (TREE_CODE (type
) == POINTER_TYPE
)
3278 /* Step back one from start of vector, and read dimension. */
3279 tree cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3280 base
, BI_header_size
);
3281 tree cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3282 maxindex
= build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0);
3284 type
= TREE_TYPE (type
);
3285 while (TREE_CODE (type
) == ARRAY_TYPE
);
3287 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3289 /* get the total number of things in the array, maxindex is a bad name */
3290 maxindex
= array_type_nelts_total (type
);
3291 while (TREE_CODE (type
) == ARRAY_TYPE
)
3292 type
= TREE_TYPE (type
);
3293 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3297 if (base
!= error_mark_node
)
3298 error ("type to vector delete is neither pointer or array type");
3299 return error_mark_node
;
3302 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,