1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 89, 92, 93, 94, 95, 1996 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. */
31 /* In C++, structures with well-defined constructors are initialized by
32 those constructors, unasked. CURRENT_BASE_INIT_LIST
33 holds a list of stmts for a BASE_INIT term in the grammar.
34 This list has one element for each base class which must be
35 initialized. The list elements are [basename, init], with
36 type basetype. This allows the possibly anachronistic form
37 (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
38 where each successive term can be handed down the constructor
39 line. Perhaps this was not intended. */
40 tree current_base_init_list
, current_member_init_list
;
42 extern tree cleanups_this_call
;
44 void emit_base_init ();
45 void check_base_init ();
46 static void expand_aggr_vbase_init ();
47 void expand_member_init ();
48 void expand_aggr_init ();
50 static void expand_aggr_init_1
PROTO((tree
, tree
, tree
, tree
, int, int));
51 static void expand_virtual_init
PROTO((tree
, tree
));
52 tree
expand_vec_init ();
54 /* Cache _builtin_new and _builtin_delete exprs. */
55 static tree BIN
, BID
, BIVN
, BIVD
;
57 /* Cache the identifier nodes for the magic field of a new cookie. */
58 static tree nc_nelts_field_id
;
60 static tree minus_one
;
62 /* Set up local variable for this file. MUST BE CALLED AFTER
63 INIT_DECL_PROCESSING. */
65 static tree BI_header_type
, BI_header_size
;
67 void init_init_processing ()
71 /* Define implicit `operator new' and `operator delete' functions. */
72 BIN
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) NEW_EXPR
])));
73 TREE_USED (TREE_OPERAND (BIN
, 0)) = 0;
74 BID
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) DELETE_EXPR
])));
75 TREE_USED (TREE_OPERAND (BID
, 0)) = 0;
76 BIVN
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) VEC_NEW_EXPR
])));
77 TREE_USED (TREE_OPERAND (BIVN
, 0)) = 0;
78 BIVD
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) VEC_DELETE_EXPR
])));
79 TREE_USED (TREE_OPERAND (BIVD
, 0)) = 0;
80 minus_one
= build_int_2 (-1, -1);
82 /* Define the structure that holds header information for
83 arrays allocated via operator new. */
84 BI_header_type
= make_lang_type (RECORD_TYPE
);
85 nc_nelts_field_id
= get_identifier ("nelts");
86 fields
[0] = build_lang_field_decl (FIELD_DECL
, nc_nelts_field_id
, sizetype
);
87 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
89 BI_header_size
= size_in_bytes (BI_header_type
);
92 /* Subroutine of emit_base_init. For BINFO, initialize all the
93 virtual function table pointers, except those that come from
94 virtual base classes. Initialize binfo's vtable pointer, if
95 INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
96 function table pointers in all bases have been initialized already,
97 probably because their constructors have just be run. ADDR is the
98 pointer to the object whos vtables we are going to initialize.
100 REAL_BINFO is usually the same as BINFO, except when addr is not of
101 pointer to the type of the real derived type that we want to
102 initialize for. This is the case when addr is a pointer to a sub
103 object of a complete object, and we only want to do part of the
104 complete object's initialization of vtable pointers. This is done
105 for all virtual table pointers in virtual base classes. REAL_BINFO
106 is used to find the BINFO_VTABLE that we initialize with. BINFO is
107 used for conversions of addr to subobjects.
109 BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
111 Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
115 expand_direct_vtbls_init (real_binfo
, binfo
, init_self
, can_elide
, addr
)
116 tree real_binfo
, binfo
, addr
;
117 int init_self
, can_elide
;
119 tree real_binfos
= BINFO_BASETYPES (real_binfo
);
120 tree binfos
= BINFO_BASETYPES (binfo
);
121 int i
, n_baselinks
= real_binfos
? TREE_VEC_LENGTH (real_binfos
) : 0;
123 for (i
= 0; i
< n_baselinks
; i
++)
125 tree real_base_binfo
= TREE_VEC_ELT (real_binfos
, i
);
126 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
127 int is_not_base_vtable
=
128 i
!= CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo
));
129 if (! TREE_VIA_VIRTUAL (real_base_binfo
))
130 expand_direct_vtbls_init (real_base_binfo
, base_binfo
,
131 is_not_base_vtable
, can_elide
, addr
);
134 /* Before turning this on, make sure it is correct. */
135 if (can_elide
&& ! BINFO_MODIFIED (binfo
))
138 /* Should we use something besides CLASSTYPE_VFIELDS? */
139 if (init_self
&& CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo
)))
141 tree base_ptr
= convert_pointer_to_real (binfo
, addr
);
142 expand_virtual_init (real_binfo
, base_ptr
);
147 /* Subroutine of emit_base_init. */
150 perform_member_init (member
, name
, init
, explicit)
151 tree member
, name
, init
;
155 tree type
= TREE_TYPE (member
);
156 extern int temp_slot_level
;
157 extern int target_temp_slot_level
;
158 tree old_cleanups
= cleanups_this_call
;
159 int old_temp_level
= target_temp_slot_level
;
162 target_temp_slot_level
= temp_slot_level
;
164 if (TYPE_NEEDS_CONSTRUCTING (type
)
165 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
167 /* Since `init' is already a TREE_LIST on the current_member_init_list,
168 only build it into one if we aren't already a list. */
169 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
170 init
= build_tree_list (NULL_TREE
, init
);
172 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
175 && TREE_CODE (type
) == ARRAY_TYPE
177 && TREE_CHAIN (init
) == NULL_TREE
178 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
180 /* Initialization of one array from another. */
181 expand_vec_init (TREE_OPERAND (decl
, 1), decl
,
182 array_type_nelts (type
), TREE_VALUE (init
), 1);
185 expand_aggr_init (decl
, init
, 0, 0);
189 if (init
== NULL_TREE
)
193 cp_error ("incomplete initializer for member `%D' of class `%T' which has no constructor",
194 member
, current_class_type
);
195 init
= error_mark_node
;
197 /* member traversal: note it leaves init NULL */
198 else if (TREE_CODE (TREE_TYPE (member
)) == REFERENCE_TYPE
)
199 cp_pedwarn ("uninitialized reference member `%D'", member
);
201 else if (TREE_CODE (init
) == TREE_LIST
)
203 /* There was an explicit member initialization. Do some
204 work in that case. */
205 if (TREE_CHAIN (init
))
207 warning ("initializer list treated as compound expression");
208 init
= build_compound_expr (init
);
211 init
= TREE_VALUE (init
);
214 /* We only build this with a null init if we got it from the
215 current_member_init_list. */
216 if (init
|| explicit)
218 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
219 expand_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
222 expand_cleanups_to (old_cleanups
);
225 target_temp_slot_level
= old_temp_level
;
226 /* There might something left from building the trees. */
227 if (cleanups_this_call
)
229 expand_cleanups_to (NULL_TREE
);
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
;
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
);
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_tree_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 extern int temp_slot_level
;
593 extern int target_temp_slot_level
;
594 tree old_cleanups
= cleanups_this_call
;
595 int old_temp_level
= target_temp_slot_level
;
598 target_temp_slot_level
= temp_slot_level
;
600 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
601 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
602 build_indirect_ref (member
, NULL_PTR
), init
,
603 BINFO_OFFSET_ZEROP (base_binfo
), LOOKUP_NORMAL
);
604 expand_cleanups_to (old_cleanups
);
607 target_temp_slot_level
= old_temp_level
;
608 /* There might something left from building the trees. */
609 if (cleanups_this_call
)
611 expand_cleanups_to (NULL_TREE
);
616 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
620 /* All cleanups must be on the function_obstack. */
621 push_obstacks_nochange ();
622 resume_temporary_allocation ();
623 expr
= build_partial_cleanup_for (base_binfo
);
625 add_partial_entry (expr
);
628 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
631 /* Initialize all the virtual function table fields that
632 do come from virtual base classes. */
633 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
634 expand_indirect_vtbls_init (t_binfo
, current_class_ref
, current_class_ptr
);
636 /* Initialize all the virtual function table fields that
637 do not come from virtual base classes. */
638 expand_direct_vtbls_init (t_binfo
, t_binfo
, 1, 1, current_class_ptr
);
640 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
645 /* member could be, for example, a CONST_DECL for an enumerated
646 tag; we don't want to try to initialize that, since it already
648 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
651 /* See if we had a user-specified member initialization. */
652 if (TREE_PURPOSE (mem_init_list
))
654 name
= TREE_PURPOSE (mem_init_list
);
655 init
= TREE_VALUE (mem_init_list
);
659 if (TREE_CODE (name
) == COMPONENT_REF
)
660 name
= DECL_NAME (TREE_OPERAND (name
, 1));
662 /* Also see if it's ever a COMPONENT_REF here. If it is, we
663 need to do `expand_assignment (name, init, 0, 0);' and
665 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 349);
670 name
= DECL_NAME (member
);
671 init
= DECL_INITIAL (member
);
675 /* Effective C++ rule 12. */
676 if (extra_warnings
&& init
== NULL_TREE
677 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
678 cp_warning ("`%D' should be initialized in the member initialization list", member
);
681 perform_member_init (member
, name
, init
, from_init_list
);
682 mem_init_list
= TREE_CHAIN (mem_init_list
);
685 /* Now initialize any members from our bases. */
686 while (mem_init_list
)
688 tree name
, init
, field
;
690 if (TREE_PURPOSE (mem_init_list
))
692 name
= TREE_PURPOSE (mem_init_list
);
693 init
= TREE_VALUE (mem_init_list
);
694 /* XXX: this may need the COMPONENT_REF operand 0 check if
695 it turns out we actually get them. */
696 field
= IDENTIFIER_CLASS_VALUE (name
);
698 /* If one member shadows another, get the outermost one. */
699 if (TREE_CODE (field
) == TREE_LIST
)
701 field
= TREE_VALUE (field
);
702 if (decl_type_context (field
) != current_class_type
)
703 cp_error ("field `%D' not in immediate context", field
);
707 /* It turns out if you have an anonymous union in the
708 class, a member from it can end up not being on the
709 list of fields (rather, the type is), and therefore
710 won't be seen by the for loop above. */
712 /* The code in this for loop is derived from a general loop
713 which had this check in it. Theoretically, we've hit
714 every initialization for the list of members in T, so
715 we shouldn't have anything but these left in this list. */
716 my_friendly_assert (DECL_FIELD_CONTEXT (field
) != t
, 351);
719 perform_member_init (field
, name
, init
, 1);
721 mem_init_list
= TREE_CHAIN (mem_init_list
);
726 do_pending_stack_adjust ();
727 my_friendly_assert (base_init_expr
== 0, 207);
728 base_init_expr
= expr
;
729 TREE_TYPE (expr
) = void_type_node
;
730 RTL_EXPR_RTL (expr
) = const0_rtx
;
731 RTL_EXPR_SEQUENCE (expr
) = get_insns ();
732 rtl_expr_chain
= tree_cons (NULL_TREE
, expr
, rtl_expr_chain
);
734 TREE_SIDE_EFFECTS (expr
) = 1;
737 /* All the implicit try blocks we built up will be zapped
738 when we come to a real binding contour boundary. */
741 /* Check that all fields are properly initialized after
742 an assignment to `this'. */
749 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
750 if (DECL_NAME (member
) && TREE_USED (member
))
751 cp_error ("field `%D' used before initialized (after assignment to `this')",
755 /* This code sets up the virtual function tables appropriate for
756 the pointer DECL. It is a one-ply initialization.
758 BINFO is the exact type that DECL is supposed to be. In
759 multiple inheritance, this might mean "C's A" if C : A, B. */
762 expand_virtual_init (binfo
, decl
)
765 tree type
= BINFO_TYPE (binfo
);
767 tree vtype
, vtype_binfo
;
769 /* This code is crusty. Should be simple, like:
770 vtbl = BINFO_VTABLE (binfo);
772 vtype
= DECL_CONTEXT (CLASSTYPE_VFIELD (type
));
773 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
774 vtbl
= BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type
)), binfo
));
775 assemble_external (vtbl
);
776 TREE_USED (vtbl
) = 1;
777 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
778 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
779 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
780 if (vtbl_ptr
== error_mark_node
)
783 /* Have to convert VTBL since array sizes may be different. */
784 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
785 expand_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
788 /* Subroutine of `expand_aggr_vbase_init'.
789 BINFO is the binfo of the type that is being initialized.
790 INIT_LIST is the list of initializers for the virtual baseclass. */
793 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
794 tree binfo
, exp
, addr
, init_list
;
796 tree init
= purpose_member (binfo
, init_list
);
797 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
799 extern int temp_slot_level
;
800 extern int target_temp_slot_level
;
801 tree old_cleanups
= cleanups_this_call
;
802 int old_temp_level
= target_temp_slot_level
;
805 target_temp_slot_level
= temp_slot_level
;
808 init
= TREE_VALUE (init
);
809 /* Call constructors, but don't set up vtables. */
810 expand_aggr_init_1 (binfo
, exp
, ref
, init
, 0, LOOKUP_COMPLAIN
);
812 expand_cleanups_to (old_cleanups
);
815 target_temp_slot_level
= old_temp_level
;
816 /* There might something left from building the trees. */
817 if (cleanups_this_call
)
819 expand_cleanups_to (NULL_TREE
);
824 /* Initialize this object's virtual base class pointers. This must be
825 done only at the top-level of the object being constructed.
827 INIT_LIST is list of initialization for constructor to perform. */
830 expand_aggr_vbase_init (binfo
, exp
, addr
, init_list
)
836 tree type
= BINFO_TYPE (binfo
);
838 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
840 tree result
= init_vbase_pointers (type
, addr
);
844 expand_expr_stmt (build_compound_expr (result
));
846 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
847 vbases
= TREE_CHAIN (vbases
))
849 tree tmp
= purpose_member (vbases
, result
);
850 expand_aggr_vbase_init_1 (vbases
, exp
,
851 TREE_OPERAND (TREE_VALUE (tmp
), 0),
857 /* Subroutine to perform parser actions for member initialization.
858 S_ID is the scoped identifier.
859 NAME is the name of the member.
860 INIT is the initializer, or `void_type_node' if none. */
863 do_member_init (s_id
, name
, init
)
864 tree s_id
, name
, init
;
868 if (current_class_type
== NULL_TREE
869 || ! is_aggr_typedef (s_id
, 1))
871 binfo
= get_binfo (IDENTIFIER_TYPE_VALUE (s_id
),
872 current_class_type
, 1);
873 if (binfo
== error_mark_node
)
877 error_not_base_type (IDENTIFIER_TYPE_VALUE (s_id
), current_class_type
);
881 base
= convert_pointer_to (binfo
, current_class_ptr
);
882 expand_member_init (build_indirect_ref (base
, NULL_PTR
), name
, init
);
885 /* Find the context in which this FIELD can be initialized. */
888 initializing_context (field
)
891 tree t
= DECL_CONTEXT (field
);
893 /* Anonymous union members can be initialized in the first enclosing
894 non-anonymous union context. */
895 while (t
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
896 t
= TYPE_CONTEXT (t
);
900 /* Function to give error message if member initialization specification
901 is erroneous. FIELD is the member we decided to initialize.
902 TYPE is the type for which the initialization is being performed.
903 FIELD must be a member of TYPE.
905 MEMBER_NAME is the name of the member. */
908 member_init_ok_or_else (field
, type
, member_name
)
913 if (field
== error_mark_node
)
915 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
917 cp_error ("class `%T' does not have any field named `%s'", type
,
921 if (TREE_STATIC (field
))
923 cp_error ("field `%#D' is static; only point of initialization is its declaration",
931 /* If NAME is a viable field name for the aggregate DECL,
932 and PARMS is a viable parameter list, then expand an _EXPR
933 which describes this initialization.
935 Note that we do not need to chase through the class's base classes
936 to look for NAME, because if it's in that list, it will be handled
937 by the constructor for that base class.
939 We do not yet have a fixed-point finder to instantiate types
940 being fed to overloaded constructors. If there is a unique
941 constructor, then argument types can be got from that one.
943 If INIT is non-NULL, then it the initialization should
944 be placed in `current_base_init_list', where it will be processed
945 by `emit_base_init'. */
948 expand_member_init (exp
, name
, init
)
949 tree exp
, name
, init
;
951 extern tree ptr_type_node
; /* should be in tree.h */
953 tree basetype
= NULL_TREE
, field
;
957 if (exp
== NULL_TREE
)
958 return; /* complain about this later */
960 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
962 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
964 basetype
= TREE_TYPE (name
);
965 name
= DECL_NAME (name
);
968 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
969 switch (CLASSTYPE_N_BASECLASSES (type
))
972 error ("base class initializer specified, but no base class to initialize");
975 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
978 error ("initializer for unnamed base class ambiguous");
979 cp_error ("(type `%T' uses multiple inheritance)", type
);
985 /* The grammar should not allow fields which have names
986 that are TYPENAMEs. Therefore, if the field has
987 a non-NULL TREE_TYPE, we may assume that this is an
988 attempt to initialize a base class member of the current
989 type. Otherwise, it is an attempt to initialize a
992 if (init
== void_type_node
)
995 if (name
== NULL_TREE
|| basetype
)
999 if (name
== NULL_TREE
)
1003 name
= TYPE_IDENTIFIER (basetype
);
1006 error ("no base class to initialize");
1011 else if (basetype
!= type
1012 && ! current_template_parms
1013 && ! vec_binfo_member (basetype
,
1014 TYPE_BINFO_BASETYPES (type
))
1015 && ! binfo_member (basetype
, CLASSTYPE_VBASECLASSES (type
)))
1017 if (IDENTIFIER_CLASS_VALUE (name
))
1019 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1020 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
1023 cp_error ("type `%T' is not an immediate basetype for `%T'",
1028 if (purpose_member (basetype
, current_base_init_list
))
1030 cp_error ("base class `%T' already initialized", basetype
);
1034 if (warn_reorder
&& current_member_init_list
)
1036 cp_warning ("base initializer for `%T'", basetype
);
1037 warning (" will be re-ordered to precede member initializations");
1040 base_init
= build_tree_list (basetype
, init
);
1041 current_base_init_list
= chainon (current_base_init_list
, base_init
);
1048 field
= lookup_field (type
, name
, 1, 0);
1050 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
1053 if (purpose_member (name
, current_member_init_list
))
1055 cp_error ("field `%D' already initialized", field
);
1059 member_init
= build_tree_list (name
, init
);
1060 current_member_init_list
= chainon (current_member_init_list
, member_init
);
1064 else if (name
== NULL_TREE
)
1066 compiler_error ("expand_member_init: name == NULL_TREE");
1071 field
= lookup_field (basetype
, name
, 0, 0);
1073 if (! member_init_ok_or_else (field
, basetype
, IDENTIFIER_POINTER (name
)))
1076 /* now see if there is a constructor for this type
1077 which will take these args. */
1079 if (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (field
)))
1081 tree parmtypes
, fndecl
;
1083 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1085 /* just know that we've seen something for this node */
1086 DECL_INITIAL (exp
) = error_mark_node
;
1087 TREE_USED (exp
) = 1;
1089 type
= TYPE_MAIN_VARIANT (TREE_TYPE (field
));
1090 parm
= build_component_ref (exp
, name
, NULL_TREE
, 0);
1092 /* Now get to the constructors. */
1093 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), 0);
1096 my_friendly_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
, 209);
1098 /* If the field is unique, we can use the parameter
1099 types to guide possible type instantiation. */
1100 if (DECL_CHAIN (fndecl
) == NULL_TREE
)
1102 /* There was a confusion here between
1103 FIELD and FNDECL. The following code
1104 should be correct, but abort is here
1106 my_friendly_abort (48);
1107 parmtypes
= FUNCTION_ARG_CHAIN (fndecl
);
1111 parmtypes
= NULL_TREE
;
1115 init
= convert_arguments (parm
, parmtypes
, NULL_TREE
, fndecl
, LOOKUP_NORMAL
);
1116 if (init
== NULL_TREE
|| TREE_TYPE (init
) != error_mark_node
)
1117 rval
= build_method_call (NULL_TREE
, ctor_identifier
, init
,
1118 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1122 if (rval
!= error_mark_node
)
1124 /* Now, fill in the first parm with our guy */
1125 TREE_VALUE (TREE_OPERAND (rval
, 1))
1126 = build_unary_op (ADDR_EXPR
, parm
, 0);
1127 TREE_TYPE (rval
) = ptr_type_node
;
1128 TREE_SIDE_EFFECTS (rval
) = 1;
1131 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
1133 parm
= build_component_ref (exp
, name
, NULL_TREE
, 0);
1134 expand_aggr_init (parm
, NULL_TREE
, 0, 0);
1135 rval
= error_mark_node
;
1138 /* Now initialize the member. It does not have to
1139 be of aggregate type to receive initialization. */
1140 if (rval
!= error_mark_node
)
1141 expand_expr_stmt (rval
);
1144 /* This is like `expand_member_init', only it stores one aggregate
1147 INIT comes in two flavors: it is either a value which
1148 is to be stored in EXP, or it is a parameter list
1149 to go to a constructor, which will operate on EXP.
1150 If INIT is not a parameter list for a constructor, then set
1151 LOOKUP_ONLYCONVERTING.
1152 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1153 the initializer, if FLAGS is 0, then it is the (init) form.
1154 If `init' is a CONSTRUCTOR, then we emit a warning message,
1155 explaining that such initializations are invalid.
1157 ALIAS_THIS is nonzero iff we are initializing something which is
1158 essentially an alias for current_class_ref. In this case, the base
1159 constructor may move it on us, and we must keep track of such
1162 If INIT resolves to a CALL_EXPR which happens to return
1163 something of the type we are looking for, then we know
1164 that we can safely use that call to perform the
1167 The virtual function table pointer cannot be set up here, because
1168 we do not really know its type.
1170 Virtual baseclass pointers are also set up here.
1172 This never calls operator=().
1174 When initializing, nothing is CONST.
1176 A default copy constructor may have to be used to perform the
1179 A constructor or a conversion operator may have to be used to
1180 perform the initialization, but not both, as it would be ambiguous. */
1183 expand_aggr_init (exp
, init
, alias_this
, flags
)
1188 tree type
= TREE_TYPE (exp
);
1189 int was_const
= TREE_READONLY (exp
);
1190 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1192 if (init
== error_mark_node
)
1195 TREE_READONLY (exp
) = 0;
1196 TREE_THIS_VOLATILE (exp
) = 0;
1198 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1199 flags
|= LOOKUP_ONLYCONVERTING
;
1201 if (TREE_CODE (type
) == ARRAY_TYPE
)
1203 /* Must arrange to initialize each element of EXP
1204 from elements of INIT. */
1205 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1206 if (TYPE_READONLY (TREE_TYPE (type
)) || TYPE_VOLATILE (TREE_TYPE (type
)))
1208 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1210 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1212 if (init
&& TREE_TYPE (init
) == NULL_TREE
)
1214 /* Handle bad initializers like:
1218 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1222 int main(int argc, char **argv) {
1223 COMPLEX zees(1.0, 0.0)[10];
1226 error ("bad array initializer");
1229 expand_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1230 init
&& comptypes (TREE_TYPE (init
), TREE_TYPE (exp
), 1));
1231 TREE_READONLY (exp
) = was_const
;
1232 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1233 TREE_TYPE (exp
) = type
;
1235 TREE_TYPE (init
) = itype
;
1239 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1240 /* just know that we've seen something for this node */
1241 TREE_USED (exp
) = 1;
1244 /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1245 constructor as parameters to an implicit GNU C++ constructor. */
1246 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
1247 && TYPE_HAS_CONSTRUCTOR (type
)
1248 && TREE_TYPE (init
) == type
)
1249 init
= CONSTRUCTOR_ELTS (init
);
1252 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1253 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1254 init
, alias_this
, LOOKUP_NORMAL
|flags
);
1255 TREE_TYPE (exp
) = type
;
1256 TREE_READONLY (exp
) = was_const
;
1257 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1261 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1268 tree type
= TREE_TYPE (exp
);
1270 /* It fails because there may not be a constructor which takes
1271 its own type as the first (or only parameter), but which does
1272 take other types via a conversion. So, if the thing initializing
1273 the expression is a unit element of type X, first try X(X&),
1274 followed by initialization by X. If neither of these work
1275 out, then look hard. */
1279 if (flag_ansi_overloading
&& init
&& TREE_CODE (init
) != TREE_LIST
1280 && (flags
& LOOKUP_ONLYCONVERTING
))
1282 /* Base subobjects should only get direct-initialization. */
1283 if (true_exp
!= exp
)
1286 /* We special-case TARGET_EXPRs here to avoid an error about
1287 private copy constructors for temporaries bound to reference vars.
1288 If the TARGET_EXPR represents a call to a function that has
1289 permission to create such objects, a reference can bind directly
1290 to the return value. An object variable must be initialized
1291 via the copy constructor, even if the call is elided. */
1292 if (! (TREE_CODE (exp
) == VAR_DECL
&& DECL_ARTIFICIAL (exp
)
1293 && TREE_CODE (init
) == TARGET_EXPR
&& TREE_TYPE (init
) == type
))
1294 init
= cp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1296 expand_assignment (exp
, init
, 0, 0);
1300 if (init
== NULL_TREE
1301 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1305 init
= TREE_VALUE (parms
);
1307 else if (! flag_ansi_overloading
1308 && TREE_CODE (init
) == INDIRECT_REF
&& TREE_HAS_CONSTRUCTOR (init
)
1309 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (init
)))
1311 rval
= convert_for_initialization (exp
, type
, init
, 0, 0, 0, 0);
1312 TREE_USED (rval
) = 1;
1313 expand_expr_stmt (rval
);
1317 parms
= build_tree_list (NULL_TREE
, init
);
1319 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1321 if (true_exp
== exp
)
1322 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
1324 parms
= tree_cons (NULL_TREE
, integer_zero_node
, parms
);
1325 flags
|= LOOKUP_HAS_IN_CHARGE
;
1328 if (flag_ansi_overloading
)
1330 rval
= build_method_call (exp
, ctor_identifier
,
1331 parms
, binfo
, flags
);
1332 expand_expr_stmt (rval
);
1336 if (init
&& TREE_CHAIN (parms
) == NULL_TREE
1337 && TYPE_HAS_TRIVIAL_INIT_REF (type
)
1338 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (init
)))
1340 rval
= build (INIT_EXPR
, type
, exp
, init
);
1341 TREE_SIDE_EFFECTS (rval
) = 1;
1342 expand_expr_stmt (rval
);
1346 if (flags
& LOOKUP_ONLYCONVERTING
)
1347 flags
|= LOOKUP_NO_CONVERSION
;
1348 rval
= build_method_call (exp
, ctor_identifier
,
1349 parms
, binfo
, flags
);
1351 /* Private, protected, or otherwise unavailable. */
1352 if (rval
== error_mark_node
)
1354 if (flags
& LOOKUP_COMPLAIN
)
1355 cp_error ("in base initialization for %sclass `%T'",
1356 TREE_VIA_VIRTUAL (binfo
) ? "virtual base " : "",
1359 else if (rval
== NULL_TREE
)
1360 my_friendly_abort (361);
1363 /* p. 222: if the base class assigns to `this', then that
1364 value is used in the derived class. */
1365 if ((flag_this_is_variable
& 1) && alias_this
)
1367 TREE_TYPE (rval
) = TREE_TYPE (current_class_ptr
);
1368 expand_assignment (current_class_ptr
, rval
, 0, 0);
1371 expand_expr_stmt (rval
);
1376 /* This function is responsible for initializing EXP with INIT
1379 BINFO is the binfo of the type for who we are performing the
1380 initialization. For example, if W is a virtual base class of A and B,
1382 If we are initializing B, then W must contain B's W vtable, whereas
1383 were we initializing C, W must contain C's W vtable.
1385 TRUE_EXP is nonzero if it is the true expression being initialized.
1386 In this case, it may be EXP, or may just contain EXP. The reason we
1387 need this is because if EXP is a base element of TRUE_EXP, we
1388 don't necessarily know by looking at EXP where its virtual
1389 baseclass fields should really be pointing. But we do know
1390 from TRUE_EXP. In constructors, we don't know anything about
1391 the value being initialized.
1393 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1395 FLAGS is just passes to `build_method_call'. See that function for
1399 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1406 tree type
= TREE_TYPE (exp
);
1407 tree init_type
= NULL_TREE
;
1409 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1411 /* Use a function returning the desired type to initialize EXP for us.
1412 If the function is a constructor, and its first argument is
1413 NULL_TREE, know that it was meant for us--just slide exp on
1414 in and expand the constructor. Constructors now come
1417 if (init
&& TREE_CODE (exp
) == VAR_DECL
1418 && TREE_CODE (init
) == CONSTRUCTOR
1419 && TREE_HAS_CONSTRUCTOR (init
))
1421 tree t
= store_init_value (exp
, init
);
1424 expand_decl_init (exp
);
1427 t
= build (INIT_EXPR
, type
, exp
, init
);
1428 TREE_SIDE_EFFECTS (t
) = 1;
1429 expand_expr_stmt (t
);
1433 if (init
&& ! flag_ansi_overloading
)
1435 tree init_list
= NULL_TREE
;
1437 if (TREE_CODE (init
) == TREE_LIST
)
1440 if (TREE_CHAIN (init
) == NULL_TREE
)
1441 init
= TREE_VALUE (init
);
1444 init_type
= TREE_TYPE (init
);
1446 if (TREE_CODE (init
) != TREE_LIST
)
1448 if (init_type
== error_mark_node
)
1451 /* This happens when we use C++'s functional cast notation.
1452 If the types match, then just use the TARGET_EXPR
1453 directly. Otherwise, we need to create the initializer
1454 separately from the object being initialized. */
1455 if (TREE_CODE (init
) == TARGET_EXPR
)
1457 if (TYPE_MAIN_VARIANT (init_type
) == TYPE_MAIN_VARIANT (type
))
1459 if (TREE_CODE (exp
) == VAR_DECL
1460 || TREE_CODE (exp
) == RESULT_DECL
)
1461 /* Unify the initialization targets. */
1462 DECL_RTL (TREE_OPERAND (init
, 0)) = DECL_RTL (exp
);
1464 DECL_RTL (TREE_OPERAND (init
, 0)) = expand_expr (exp
, NULL_RTX
, VOIDmode
, 0);
1466 expand_expr_stmt (init
);
1471 if (init_type
== type
&& TREE_CODE (init
) == CALL_EXPR
)
1473 /* A CALL_EXPR is a legitimate form of initialization, so
1474 we should not print this warning message. */
1476 expand_assignment (exp
, init
, 0, 0);
1477 if (exp
== DECL_RESULT (current_function_decl
))
1479 /* Failing this assertion means that the return value
1480 from receives multiple initializations. */
1481 my_friendly_assert (DECL_INITIAL (exp
) == NULL_TREE
1482 || DECL_INITIAL (exp
) == error_mark_node
,
1484 DECL_INITIAL (exp
) = init
;
1488 else if (init_type
== type
1489 && TREE_CODE (init
) == COND_EXPR
)
1491 /* Push value to be initialized into the cond, where possible.
1492 Avoid spurious warning messages when initializing the
1493 result of this function. */
1494 TREE_OPERAND (init
, 1)
1495 = build_modify_expr (exp
, INIT_EXPR
, TREE_OPERAND (init
, 1));
1496 if (exp
== DECL_RESULT (current_function_decl
))
1497 DECL_INITIAL (exp
) = NULL_TREE
;
1498 TREE_OPERAND (init
, 2)
1499 = build_modify_expr (exp
, INIT_EXPR
, TREE_OPERAND (init
, 2));
1500 if (exp
== DECL_RESULT (current_function_decl
))
1501 DECL_INITIAL (exp
) = init
;
1502 TREE_SIDE_EFFECTS (init
) = 1;
1503 expand_expr (init
, const0_rtx
, VOIDmode
, 0);
1509 /* We did not know what we were initializing before. Now we do. */
1510 if (TREE_CODE (init
) == TARGET_EXPR
)
1512 tree tmp
= TREE_OPERAND (TREE_OPERAND (init
, 1), 1);
1514 if (tmp
&& TREE_CODE (TREE_VALUE (tmp
)) == NOP_EXPR
1515 && TREE_OPERAND (TREE_VALUE (tmp
), 0) == integer_zero_node
)
1517 /* In order for this to work for RESULT_DECLs, if their
1518 type has a constructor, then they must be BLKmode
1519 so that they will be meaningfully addressable. */
1520 tree arg
= build_unary_op (ADDR_EXPR
, exp
, 0);
1521 init
= TREE_OPERAND (init
, 1);
1522 init
= build (CALL_EXPR
, build_pointer_type (TREE_TYPE (init
)),
1523 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), NULL_TREE
);
1524 TREE_SIDE_EFFECTS (init
) = 1;
1525 TREE_VALUE (TREE_OPERAND (init
, 1))
1526 = convert_pointer_to (TREE_TYPE (TREE_TYPE (TREE_VALUE (tmp
))), arg
);
1530 expand_assignment (current_function_decl
, init
, 0, 0);
1533 if (exp
== DECL_RESULT (current_function_decl
))
1535 if (DECL_INITIAL (DECL_RESULT (current_function_decl
)))
1536 fatal ("return value from function receives multiple initializations");
1537 DECL_INITIAL (exp
) = init
;
1539 expand_expr_stmt (init
);
1544 /* Handle this case: when calling a constructor: xyzzy foo(bar);
1545 which really means: xyzzy foo = bar; Ugh!
1547 More useful for this case: xyzzy *foo = new xyzzy (bar); */
1549 if (! TYPE_NEEDS_CONSTRUCTING (type
) && ! IS_AGGR_TYPE (type
))
1551 if (init_list
&& TREE_CHAIN (init_list
))
1553 warning ("initializer list being treated as compound expression");
1554 init
= convert (type
, build_compound_expr (init_list
));
1555 if (init
== error_mark_node
)
1559 expand_assignment (exp
, init
, 0, 0);
1564 /* If this is copy-initialization, see whether we can go through a
1565 type conversion operator. */
1566 if (TREE_CODE (init
) != TREE_LIST
&& (flags
& LOOKUP_ONLYCONVERTING
))
1568 tree ttype
= TREE_CODE (init_type
) == REFERENCE_TYPE
1569 ? TREE_TYPE (init_type
) : init_type
;
1571 if (ttype
!= type
&& IS_AGGR_TYPE (ttype
))
1573 tree rval
= build_type_conversion (CONVERT_EXPR
, type
, init
, 1);
1577 /* See if there is a constructor for``type'' that takes a
1578 ``ttype''-typed object. */
1579 tree parms
= build_tree_list (NULL_TREE
, init
);
1580 tree as_cons
= NULL_TREE
;
1581 if (TYPE_HAS_CONSTRUCTOR (type
))
1582 as_cons
= build_method_call (exp
, ctor_identifier
,
1584 LOOKUP_SPECULATIVELY
|LOOKUP_NO_CONVERSION
);
1585 if (as_cons
!= NULL_TREE
&& as_cons
!= error_mark_node
)
1586 /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */
1587 cp_error ("ambiguity between conversion to `%T' and constructor",
1590 if (rval
!= error_mark_node
)
1591 expand_aggr_init_1 (binfo
, true_exp
, exp
, rval
, alias_this
, flags
);
1598 /* We know that expand_default_init can handle everything we want
1600 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
);
1603 /* Report an error if NAME is not the name of a user-defined,
1604 aggregate type. If OR_ELSE is nonzero, give an error message. */
1607 is_aggr_typedef (name
, or_else
)
1613 if (name
== error_mark_node
)
1616 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1617 type
= IDENTIFIER_TYPE_VALUE (name
);
1621 cp_error ("`%T' is not an aggregate typedef", name
);
1625 if (! IS_AGGR_TYPE (type
)
1626 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1629 cp_error ("`%T' is not an aggregate type", type
);
1635 /* Report an error if TYPE is not a user-defined, aggregate type. If
1636 OR_ELSE is nonzero, give an error message. */
1639 is_aggr_type (type
, or_else
)
1643 if (type
== error_mark_node
)
1646 if (! IS_AGGR_TYPE (type
)
1647 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1650 cp_error ("`%T' is not an aggregate type", type
);
1656 /* Like is_aggr_typedef, but returns typedef if successful. */
1659 get_aggr_from_typedef (name
, or_else
)
1665 if (name
== error_mark_node
)
1668 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1669 type
= IDENTIFIER_TYPE_VALUE (name
);
1673 cp_error ("`%T' fails to be an aggregate typedef", name
);
1677 if (! IS_AGGR_TYPE (type
)
1678 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1681 cp_error ("type `%T' is of non-aggregate type", type
);
1688 get_type_value (name
)
1691 if (name
== error_mark_node
)
1694 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1695 return IDENTIFIER_TYPE_VALUE (name
);
1701 /* This code could just as well go in `class.c', but is placed here for
1704 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1705 the appropriate function call. */
1708 build_member_call (type
, name
, parmlist
)
1709 tree type
, name
, parmlist
;
1712 tree method_name
= name
;
1714 int dont_use_this
= 0;
1715 tree basetype_path
, decl
;
1717 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1719 method_name
= TREE_OPERAND (method_name
, 0);
1723 /* This shouldn't be here, and build_member_call shouldn't appear in
1725 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1726 && get_aggr_from_typedef (type
, 0) == 0)
1728 tree ns
= lookup_name (type
, 0);
1729 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1731 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1735 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1736 return error_mark_node
;
1738 /* An operator we did not like. */
1739 if (name
== NULL_TREE
)
1740 return error_mark_node
;
1744 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1746 return error_mark_node
;
1749 /* No object? Then just fake one up, and let build_method_call
1750 figure out what to do. */
1751 if (current_class_type
== 0
1752 || get_base_distance (type
, current_class_type
, 0, &basetype_path
) == -1)
1757 basetype_path
= TYPE_BINFO (type
);
1758 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1760 else if (current_class_ptr
== 0)
1763 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1767 tree olddecl
= current_class_ptr
;
1768 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1769 if (oldtype
!= type
)
1771 tree newtype
= build_type_variant (type
, TYPE_READONLY (oldtype
),
1772 TYPE_VOLATILE (oldtype
));
1773 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1779 decl
= build_indirect_ref (decl
, NULL_PTR
);
1781 if (method_name
== constructor_name (type
)
1782 || method_name
== constructor_name_full (type
))
1783 return build_functional_cast (type
, parmlist
);
1784 if (t
= lookup_fnfields (basetype_path
, method_name
, 0))
1785 return build_method_call (decl
, method_name
, parmlist
, basetype_path
,
1786 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1787 if (TREE_CODE (name
) == IDENTIFIER_NODE
1788 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1790 if (t
== error_mark_node
)
1791 return error_mark_node
;
1792 if (TREE_CODE (t
) == FIELD_DECL
)
1796 cp_error ("invalid use of non-static field `%D'", t
);
1797 return error_mark_node
;
1799 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1801 else if (TREE_CODE (t
) == VAR_DECL
)
1805 cp_error ("invalid use of member `%D'", t
);
1806 return error_mark_node
;
1808 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
))
1809 && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (decl
)))
1810 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
, parmlist
, NULL_TREE
);
1811 return build_function_call (decl
, parmlist
);
1815 cp_error ("no method `%T::%D'", type
, name
);
1816 return error_mark_node
;
1820 /* Build a reference to a member of an aggregate. This is not a
1821 C++ `&', but really something which can have its address taken,
1822 and then act as a pointer to member, for example TYPE :: FIELD
1823 can have its address taken by saying & TYPE :: FIELD.
1825 @@ Prints out lousy diagnostics for operator <typename>
1828 @@ This function should be rewritten and placed in search.c. */
1831 build_offset_ref (type
, name
)
1834 tree decl
, fnfields
, fields
, t
= error_mark_node
;
1835 tree basebinfo
= NULL_TREE
;
1838 if (processing_template_decl
)
1839 return build_min_nt (SCOPE_REF
, type
, name
);
1841 /* Handle namespace names fully here. */
1842 if (TREE_CODE (type
) == IDENTIFIER_NODE
1843 && get_aggr_from_typedef (type
, 0) == 0)
1845 tree ns
= lookup_name (type
, 0);
1847 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1849 val
= lookup_namespace_name (ns
, name
);
1852 cp_error ("namespace `%D' has no member named `%D'", ns
, name
);
1853 return error_mark_node
;
1857 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1858 return error_mark_node
;
1860 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1863 name
= TREE_OPERAND (name
, 0);
1866 if (name
== constructor_name_full (type
))
1867 name
= constructor_name (type
);
1869 if (TYPE_SIZE (complete_type (type
)) == 0)
1871 if (type
== current_class_type
)
1872 t
= IDENTIFIER_CLASS_VALUE (name
);
1877 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1879 return error_mark_node
;
1881 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == VAR_DECL
1882 || TREE_CODE (t
) == CONST_DECL
)
1887 if (TREE_CODE (t
) == FIELD_DECL
)
1888 sorry ("use of member in incomplete aggregate type");
1889 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1890 sorry ("use of member function in incomplete aggregate type");
1892 my_friendly_abort (52);
1893 return error_mark_node
;
1896 if (current_class_type
== 0
1897 || get_base_distance (type
, current_class_type
, 0, &basebinfo
) == -1)
1899 basebinfo
= TYPE_BINFO (type
);
1900 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1902 else if (current_class_ptr
== 0)
1903 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1905 decl
= current_class_ref
;
1907 if (constructor_name (BINFO_TYPE (basebinfo
)) == name
)
1909 name
= dtor_identifier
;
1911 name
= ctor_identifier
;
1914 my_friendly_abort (999);
1917 fnfields
= lookup_fnfields (basebinfo
, name
, 1);
1918 fields
= lookup_field (basebinfo
, name
, 0, 0);
1920 if (fields
== error_mark_node
|| fnfields
== error_mark_node
)
1921 return error_mark_node
;
1923 /* A lot of this logic is now handled in lookup_field and
1927 extern int flag_save_memoized_contexts
;
1928 basebinfo
= TREE_PURPOSE (fnfields
);
1930 /* Go from the TREE_BASELINK to the member function info. */
1931 t
= TREE_VALUE (fnfields
);
1933 if (DECL_CHAIN (t
) == NULL_TREE
)
1937 /* unique functions are handled easily. */
1939 access
= compute_access (basebinfo
, t
);
1940 if (access
== access_protected_node
)
1942 cp_error_at ("member function `%#D' is protected", t
);
1943 error ("in this context");
1944 return error_mark_node
;
1946 if (access
== access_private_node
)
1948 cp_error_at ("member function `%#D' is private", t
);
1949 error ("in this context");
1950 return error_mark_node
;
1953 return build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1956 /* FNFIELDS is most likely allocated on the search_obstack,
1957 which will go away after this class scope. If we need
1958 to save this value for later (either for memoization
1959 or for use as an initializer for a static variable), then
1962 ??? The smart thing to do for the case of saving initializers
1963 is to resolve them before we're done with this scope. */
1964 if (!TREE_PERMANENT (fnfields
)
1965 && ((flag_save_memoized_contexts
&& global_bindings_p ())
1966 || ! allocation_temporary_p ()))
1967 fnfields
= copy_list (fnfields
);
1969 t
= build_tree_list (error_mark_node
, fnfields
);
1970 TREE_TYPE (t
) = build_offset_type (type
, unknown_type_node
);
1974 /* Now that we know we are looking for a field, see if we
1975 have access to that field. Lookup_field will give us the
1978 t
= lookup_field (basebinfo
, name
, 1, 0);
1980 if (t
== error_mark_node
)
1981 return error_mark_node
;
1985 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1986 return error_mark_node
;
1989 if (TREE_CODE (t
) == TYPE_DECL
)
1994 /* static class members and class-specific enum
1995 values can be returned without further ado. */
1996 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
2002 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_BIT_FIELD (t
))
2004 cp_error ("illegal pointer to bit field `%D'", t
);
2005 return error_mark_node
;
2008 /* static class functions too. */
2009 if (TREE_CODE (t
) == FUNCTION_DECL
2010 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
2011 my_friendly_abort (53);
2013 /* In member functions, the form `type::name' is no longer
2014 equivalent to `this->type::name', at least not until
2015 resolve_offset_ref. */
2016 return build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
2019 /* If a OFFSET_REF made it through to here, then it did
2020 not have its address taken. */
2023 resolve_offset_ref (exp
)
2026 tree type
= TREE_TYPE (exp
);
2027 tree base
= NULL_TREE
;
2029 tree basetype
, addr
;
2031 if (TREE_CODE (exp
) == TREE_LIST
)
2032 return build_unary_op (ADDR_EXPR
, exp
, 0);
2034 if (TREE_CODE (exp
) == OFFSET_REF
)
2036 member
= TREE_OPERAND (exp
, 1);
2037 base
= TREE_OPERAND (exp
, 0);
2041 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
2042 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
2044 error ("object missing in use of pointer-to-member construct");
2045 return error_mark_node
;
2048 type
= TREE_TYPE (type
);
2049 base
= current_class_ref
;
2052 if ((TREE_CODE (member
) == VAR_DECL
2053 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
2054 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
2055 || TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
2057 /* These were static members. */
2058 if (mark_addressable (member
) == 0)
2059 return error_mark_node
;
2063 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
2064 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
2067 /* Syntax error can cause a member which should
2068 have been seen as static to be grok'd as non-static. */
2069 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
2071 if (TREE_ADDRESSABLE (member
) == 0)
2073 cp_error_at ("member `%D' is non-static but referenced as a static member",
2075 error ("at this point in file");
2076 TREE_ADDRESSABLE (member
) = 1;
2078 return error_mark_node
;
2081 /* The first case is really just a reference to a member of `this'. */
2082 if (TREE_CODE (member
) == FIELD_DECL
2083 && (base
== current_class_ref
2084 || (TREE_CODE (base
) == NOP_EXPR
2085 && TREE_OPERAND (base
, 0) == error_mark_node
)))
2087 tree basetype_path
, access
;
2089 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
2090 basetype
= TYPE_OFFSET_BASETYPE (type
);
2092 basetype
= DECL_CONTEXT (member
);
2094 base
= current_class_ptr
;
2096 if (get_base_distance (basetype
, TREE_TYPE (TREE_TYPE (base
)), 0, &basetype_path
) < 0)
2098 error_not_base_type (basetype
, TREE_TYPE (TREE_TYPE (base
)));
2099 return error_mark_node
;
2101 addr
= convert_pointer_to (basetype
, base
);
2102 access
= compute_access (basetype_path
, member
);
2103 if (access
== access_public_node
)
2104 return build (COMPONENT_REF
, TREE_TYPE (member
),
2105 build_indirect_ref (addr
, NULL_PTR
), member
);
2106 if (access
== access_protected_node
)
2108 cp_error_at ("member `%D' is protected", member
);
2109 error ("in this context");
2110 return error_mark_node
;
2112 if (access
== access_private_node
)
2114 cp_error_at ("member `%D' is private", member
);
2115 error ("in this context");
2116 return error_mark_node
;
2118 my_friendly_abort (55);
2121 /* Ensure that we have an object. */
2122 if (TREE_CODE (base
) == NOP_EXPR
2123 && TREE_OPERAND (base
, 0) == error_mark_node
)
2124 addr
= error_mark_node
;
2127 /* If this is a reference to a member function, then return the
2128 address of the member function (which may involve going
2129 through the object's vtable), otherwise, return an expression
2130 for the dereferenced pointer-to-member construct. */
2131 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
2134 if (TREE_CODE (TREE_TYPE (member
)) == OFFSET_TYPE
)
2136 if (addr
== error_mark_node
)
2138 cp_error ("object missing in `%E'", exp
);
2139 return error_mark_node
;
2142 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (member
));
2143 addr
= convert_pointer_to (basetype
, addr
);
2144 member
= convert (ptrdiff_type_node
,
2145 build_unary_op (ADDR_EXPR
, member
, 0));
2147 /* Pointer to data mebers are offset by one, so that a null
2148 pointer with a real value of 0 is distinguishable from an
2149 offset of the first member of a structure. */
2150 member
= build_binary_op (MINUS_EXPR
, member
,
2151 convert (ptrdiff_type_node
, integer_one_node
),
2154 return build1 (INDIRECT_REF
, type
,
2155 build (PLUS_EXPR
, build_pointer_type (type
),
2158 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
2160 return get_member_function_from_ptrfunc (&addr
, member
);
2162 my_friendly_abort (56);
2167 /* Return either DECL or its known constant value (if it has one). */
2170 decl_constant_value (decl
)
2173 if (! TREE_THIS_VOLATILE (decl
)
2175 /* These may be necessary for C, but they break C++. */
2176 ! TREE_PUBLIC (decl
)
2177 /* Don't change a variable array bound or initial value to a constant
2178 in a place where a variable is invalid. */
2181 && DECL_INITIAL (decl
) != 0
2182 && DECL_INITIAL (decl
) != error_mark_node
2183 /* This is invalid if initial value is not constant.
2184 If it has either a function call, a memory reference,
2185 or a variable, then re-evaluating it could give different results. */
2186 && TREE_CONSTANT (DECL_INITIAL (decl
))
2187 /* Check for cases where this is sub-optimal, even though valid. */
2188 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
2190 /* We must allow this to work outside of functions so that
2191 static constants can be used for array sizes. */
2192 && current_function_decl
!= 0
2193 && DECL_MODE (decl
) != BLKmode
2196 return DECL_INITIAL (decl
);
2200 /* Common subroutines of build_new and build_vec_delete. */
2202 /* Common interface for calling "builtin" functions that are not
2206 build_builtin_call (type
, node
, arglist
)
2211 tree rval
= build (CALL_EXPR
, type
, node
, arglist
, NULL_TREE
);
2212 TREE_SIDE_EFFECTS (rval
) = 1;
2213 assemble_external (TREE_OPERAND (node
, 0));
2214 TREE_USED (TREE_OPERAND (node
, 0)) = 1;
2218 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
2219 (which needs to go through some sort of groktypename) or it
2220 is the name of the class we are newing. INIT is an initialization value.
2221 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
2222 If INIT is void_type_node, it means do *not* call a constructor
2225 For types with constructors, the data returned is initialized
2226 by the appropriate constructor.
2228 Whether the type has a constructor or not, if it has a pointer
2229 to a virtual function table, then that pointer is set up
2232 Unless I am mistaken, a call to new () will return initialized
2233 data regardless of whether the constructor itself is private or
2234 not. NOPE; new fails if the constructor is private (jcm).
2236 Note that build_new does nothing to assure that any special
2237 alignment requirements of the type are met. Rather, it leaves
2238 it up to malloc to do the right thing. Otherwise, folding to
2239 the right alignment cal cause problems if the user tries to later
2240 free the memory returned by `new'.
2242 PLACEMENT is the `placement' list for user-defined operator new (). */
2244 extern int flag_check_new
;
2247 build_new (placement
, decl
, init
, use_global_new
)
2252 tree type
, true_type
, size
, rval
;
2256 enum tree_code code
= NEW_EXPR
;
2257 int use_cookie
, nothrow
, check_new
;
2259 tree pending_sizes
= NULL_TREE
;
2261 if (decl
== error_mark_node
)
2262 return error_mark_node
;
2264 if (TREE_CODE (decl
) == TREE_LIST
)
2266 tree absdcl
= TREE_VALUE (decl
);
2267 tree last_absdcl
= NULL_TREE
;
2268 int old_immediate_size_expand
;
2270 if (current_function_decl
2271 && DECL_CONSTRUCTOR_P (current_function_decl
))
2273 old_immediate_size_expand
= immediate_size_expand
;
2274 immediate_size_expand
= 0;
2277 nelts
= integer_one_node
;
2279 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
2280 my_friendly_abort (215);
2281 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2283 last_absdcl
= absdcl
;
2284 absdcl
= TREE_OPERAND (absdcl
, 0);
2287 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2289 /* probably meant to be a vec new */
2292 while (TREE_OPERAND (absdcl
, 0)
2293 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2295 last_absdcl
= absdcl
;
2296 absdcl
= TREE_OPERAND (absdcl
, 0);
2300 this_nelts
= TREE_OPERAND (absdcl
, 1);
2301 if (this_nelts
!= error_mark_node
)
2303 if (this_nelts
== NULL_TREE
)
2304 error ("new of array type fails to specify size");
2305 else if (processing_template_decl
)
2308 absdcl
= TREE_OPERAND (absdcl
, 0);
2312 this_nelts
= save_expr (convert (sizetype
, this_nelts
));
2313 absdcl
= TREE_OPERAND (absdcl
, 0);
2314 if (this_nelts
== integer_zero_node
)
2316 warning ("zero size array reserves no space");
2317 nelts
= integer_zero_node
;
2320 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2324 nelts
= integer_zero_node
;
2328 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2330 TREE_VALUE (decl
) = absdcl
;
2332 type
= true_type
= groktypename (decl
);
2333 if (! type
|| type
== error_mark_node
)
2335 immediate_size_expand
= old_immediate_size_expand
;
2336 return error_mark_node
;
2339 if (current_function_decl
2340 && DECL_CONSTRUCTOR_P (current_function_decl
))
2342 pending_sizes
= get_pending_sizes ();
2343 immediate_size_expand
= old_immediate_size_expand
;
2346 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2348 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2350 /* An aggregate type. */
2351 type
= IDENTIFIER_TYPE_VALUE (decl
);
2352 decl
= TYPE_MAIN_DECL (type
);
2356 /* A builtin type. */
2357 decl
= lookup_name (decl
, 1);
2358 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2359 type
= TREE_TYPE (decl
);
2363 else if (TREE_CODE (decl
) == TYPE_DECL
)
2365 type
= TREE_TYPE (decl
);
2372 decl
= TYPE_MAIN_DECL (type
);
2375 if (processing_template_decl
)
2379 t
= min_tree_cons (min_tree_cons (NULL_TREE
, type
, NULL_TREE
),
2380 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2385 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2386 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2390 /* ``A reference cannot be created by the new operator. A reference
2391 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2392 returned by new.'' ARM 5.3.3 */
2393 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2395 error ("new cannot be applied to a reference type");
2396 type
= true_type
= TREE_TYPE (type
);
2399 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2401 error ("new cannot be applied to a function type");
2402 return error_mark_node
;
2405 /* When the object being created is an array, the new-expression yields a
2406 pointer to the initial element (if any) of the array. For example,
2407 both new int and new int[10] return an int*. 5.3.4. */
2408 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2410 nelts
= array_type_nelts_top (type
);
2412 type
= true_type
= TREE_TYPE (type
);
2415 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
))
2416 type
= TYPE_MAIN_VARIANT (type
);
2418 /* If our base type is an array, then make sure we know how many elements
2420 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2422 tree this_nelts
= array_type_nelts_top (true_type
);
2423 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2424 true_type
= TREE_TYPE (true_type
);
2427 if (TYPE_SIZE (complete_type (true_type
)) == 0)
2429 incomplete_type_error (0, true_type
);
2430 return error_mark_node
;
2434 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2437 size
= size_in_bytes (type
);
2439 if (true_type
== void_type_node
)
2441 error ("invalid type `void' for new");
2442 return error_mark_node
;
2445 if (TYPE_LANG_SPECIFIC (true_type
)
2446 && CLASSTYPE_ABSTRACT_VIRTUALS (true_type
))
2448 abstract_virtuals_error (NULL_TREE
, true_type
);
2449 return error_mark_node
;
2452 if (TYPE_LANG_SPECIFIC (true_type
) && IS_SIGNATURE (true_type
))
2454 signature_error (NULL_TREE
, true_type
);
2455 return error_mark_node
;
2458 nothrow
= (placement
2459 && TREE_TYPE (placement
)
2460 && IS_AGGR_TYPE (TREE_TYPE (placement
))
2461 && (TYPE_IDENTIFIER (TREE_TYPE (placement
))
2462 == get_identifier ("nothrow_t")));
2464 check_new
= flag_check_new
|| nothrow
;
2467 /* Get a little extra space to store a couple of things before the new'ed
2468 array, if this isn't the default placement new. */
2470 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2471 && ! (placement
&& ! TREE_CHAIN (placement
)
2472 && TREE_TYPE (TREE_VALUE (placement
)) == ptr_type_node
));
2474 /* Get a little extra space to store a couple of things before the new'ed
2475 array, if this is either non-placement new or new (nothrow). */
2477 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2478 && (! placement
|| nothrow
));
2483 tree extra
= BI_header_size
;
2485 size
= size_binop (PLUS_EXPR
, size
, extra
);
2490 code
= VEC_NEW_EXPR
;
2492 if (init
&& pedantic
)
2493 cp_pedwarn ("initialization in array new");
2496 /* Allocate the object. */
2497 if (! use_global_new
&& TYPE_LANG_SPECIFIC (true_type
)
2498 && (TYPE_GETS_NEW (true_type
) & (1 << has_array
)))
2499 rval
= build_opfncall (code
, LOOKUP_NORMAL
,
2500 build_pointer_type (true_type
), size
, placement
);
2503 rval
= build_opfncall (code
, LOOKUP_GLOBAL
|LOOKUP_COMPLAIN
,
2504 ptr_type_node
, size
, placement
);
2505 rval
= convert (build_pointer_type (true_type
), rval
);
2507 else if (! has_array
&& flag_this_is_variable
> 0
2508 && TYPE_NEEDS_CONSTRUCTING (true_type
) && init
!= void_type_node
)
2510 if (init
== NULL_TREE
|| TREE_CODE (init
) == TREE_LIST
)
2514 error ("constructors take parameter lists");
2515 return error_mark_node
;
2520 rval
= build_builtin_call (build_pointer_type (true_type
),
2521 has_array
? BIVN
: BIN
,
2522 build_tree_list (NULL_TREE
, size
));
2523 TREE_CALLS_NEW (rval
) = 1;
2526 if (check_new
&& rval
)
2527 alloc_expr
= rval
= save_expr (rval
);
2529 alloc_expr
= NULL_TREE
;
2531 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2532 sure we have some extra bytes in that case for the BI_header_size
2533 cookies? And how does that interact with the code below? (mrs) */
2534 /* Finish up some magic for new'ed arrays */
2535 if (use_cookie
&& rval
!= NULL_TREE
)
2537 tree extra
= BI_header_size
;
2539 rval
= convert (ptr_type_node
, rval
); /* convert to void * first */
2540 rval
= convert (string_type_node
, rval
); /* lets not add void* and ints */
2541 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, extra
, 1));
2542 /* Store header info. */
2543 cookie
= build_indirect_ref (build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
2544 rval
, extra
), NULL_PTR
);
2545 exp1
= build (MODIFY_EXPR
, void_type_node
,
2546 build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0),
2548 TREE_SIDE_EFFECTS (exp1
) = 1;
2549 rval
= convert (build_pointer_type (true_type
), rval
);
2550 TREE_CALLS_NEW (rval
) = 1;
2551 TREE_SIDE_EFFECTS (rval
) = 1;
2552 rval
= build_compound_expr (tree_cons (NULL_TREE
, exp1
,
2553 build_tree_list (NULL_TREE
, rval
)));
2556 if (rval
== error_mark_node
)
2557 return error_mark_node
;
2559 /* Don't call any constructors or do any initialization. */
2560 if (init
== void_type_node
)
2563 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2565 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2566 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2568 /* New 2.0 interpretation: `new int (10)' means
2569 allocate an int, and initialize it with 10. */
2572 rval
= save_expr (rval
);
2573 deref
= build_indirect_ref (rval
, NULL_PTR
);
2574 TREE_READONLY (deref
) = 0;
2576 if (TREE_CHAIN (init
) != NULL_TREE
)
2577 pedwarn ("initializer list being treated as compound expression");
2578 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2580 pedwarn ("initializer list appears where operand should be used");
2581 init
= TREE_OPERAND (init
, 1);
2583 init
= build_compound_expr (init
);
2585 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2586 "new", NULL_TREE
, 0);
2587 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2588 build_modify_expr (deref
, NOP_EXPR
, init
),
2590 TREE_NO_UNUSED_WARNING (rval
) = 1;
2591 TREE_SIDE_EFFECTS (rval
) = 1;
2592 TREE_CALLS_NEW (rval
) = 1;
2594 else if (! has_array
)
2597 /* Constructors are never virtual. If it has an initialization, we
2598 need to complain if we aren't allowed to use the ctor that took
2600 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2602 if (rval
&& TYPE_USES_VIRTUAL_BASECLASSES (true_type
))
2604 init
= tree_cons (NULL_TREE
, integer_one_node
, init
);
2605 flags
|= LOOKUP_HAS_IN_CHARGE
;
2610 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2611 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2613 newrval
= build_method_call (newrval
, ctor_identifier
,
2614 init
, TYPE_BINFO (true_type
), flags
);
2619 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2622 rval
= error_mark_node
;
2625 rval
= build (VEC_INIT_EXPR
, TREE_TYPE (rval
),
2626 save_expr (rval
), init
, nelts
);
2628 else if (current_function_decl
== NULL_TREE
)
2630 extern tree static_aggregates
;
2632 /* In case of static initialization, SAVE_EXPR is good enough. */
2633 rval
= save_expr (rval
);
2634 rval
= copy_to_permanent (rval
);
2635 init
= copy_to_permanent (init
);
2636 init
= expand_vec_init (decl
, rval
,
2637 build_binary_op (MINUS_EXPR
, nelts
,
2638 integer_one_node
, 1),
2640 init
= copy_to_permanent (init
);
2641 static_aggregates
= perm_tree_cons (init
, rval
, static_aggregates
);
2645 /* Have to wrap this in RTL_EXPR for two cases:
2646 in base or member initialization and if we
2647 are a branch of a ?: operator. Since we
2648 can't easily know the latter, just do it always. */
2649 tree xval
= make_node (RTL_EXPR
);
2651 /* If we want to check the value of the allocation expression,
2652 and the number of elements in the array is not a constant, we
2653 *must* expand the SAVE_EXPR for nelts in alloc_expr before we
2654 expand it in the actual initialization. So we need to build up
2655 an RTL_EXPR for alloc_expr. Sigh. */
2656 if (alloc_expr
&& ! TREE_CONSTANT (nelts
))
2658 tree xval
= make_node (RTL_EXPR
);
2660 TREE_TYPE (xval
) = TREE_TYPE (alloc_expr
);
2661 do_pending_stack_adjust ();
2662 start_sequence_for_rtl_expr (xval
);
2664 rtxval
= expand_expr (alloc_expr
, NULL_RTX
, VOIDmode
, 0);
2665 do_pending_stack_adjust ();
2666 TREE_SIDE_EFFECTS (xval
) = 1;
2667 RTL_EXPR_SEQUENCE (xval
) = get_insns ();
2669 RTL_EXPR_RTL (xval
) = rtxval
;
2670 TREE_TYPE (xval
) = TREE_TYPE (alloc_expr
);
2674 TREE_TYPE (xval
) = TREE_TYPE (rval
);
2675 do_pending_stack_adjust ();
2676 start_sequence_for_rtl_expr (xval
);
2678 /* As a matter of principle, `start_sequence' should do this. */
2681 rval
= save_expr (rval
);
2682 rval
= expand_vec_init (decl
, rval
,
2683 build_binary_op (MINUS_EXPR
, nelts
,
2684 integer_one_node
, 1),
2687 do_pending_stack_adjust ();
2689 TREE_SIDE_EFFECTS (xval
) = 1;
2690 TREE_CALLS_NEW (xval
) = 1;
2691 RTL_EXPR_SEQUENCE (xval
) = get_insns ();
2694 if (TREE_CODE (rval
) == SAVE_EXPR
)
2696 /* Errors may cause this to not get evaluated. */
2697 if (SAVE_EXPR_RTL (rval
) == 0)
2698 SAVE_EXPR_RTL (rval
) = const0_rtx
;
2699 RTL_EXPR_RTL (xval
) = SAVE_EXPR_RTL (rval
);
2703 my_friendly_assert (TREE_CODE (rval
) == VAR_DECL
, 217);
2704 RTL_EXPR_RTL (xval
) = DECL_RTL (rval
);
2710 else if (TYPE_READONLY (true_type
))
2711 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2715 if (alloc_expr
&& rval
!= alloc_expr
)
2717 /* Did we modify the storage? */
2718 tree ifexp
= build_binary_op (NE_EXPR
, alloc_expr
,
2719 integer_zero_node
, 1);
2720 rval
= build_conditional_expr (ifexp
, rval
, alloc_expr
);
2723 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2725 /* The type of new int [3][3] is not int *, but int [3] * */
2726 rval
= build_c_cast (build_pointer_type (type
), rval
);
2730 rval
= build_compound_expr (chainon (pending_sizes
,
2731 build_tree_list (NULL_TREE
, rval
)));
2737 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,
2739 tree base
, maxindex
, type
;
2740 tree auto_delete_vec
, auto_delete
;
2741 int use_global_delete
;
2744 tree ptype
= build_pointer_type (type
= complete_type (type
));
2745 tree size_exp
= size_in_bytes (type
);
2747 /* Temporary variables used by the loop. */
2748 tree tbase
, tbase_init
;
2750 /* This is the body of the loop that implements the deletion of a
2751 single element, and moves temp variables to next elements. */
2754 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2757 /* This is the thing that governs what to do after the loop has run. */
2758 tree deallocate_expr
= 0;
2760 /* This is the BIND_EXPR which holds the outermost iterator of the
2761 loop. It is convenient to set this variable up and test it before
2762 executing any other code in the loop.
2763 This is also the containing expression returned by this function. */
2764 tree controller
= NULL_TREE
;
2766 /* This is the BLOCK to record the symbol binding for debugging. */
2769 if (! IS_AGGR_TYPE (type
) || ! TYPE_NEEDS_DESTRUCTOR (type
))
2771 loop
= integer_zero_node
;
2775 /* The below is short by BI_header_size */
2776 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2778 tbase
= build_decl (VAR_DECL
, NULL_TREE
, ptype
);
2779 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2780 fold (build (PLUS_EXPR
, ptype
,
2783 DECL_REGISTER (tbase
) = 1;
2784 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2785 TREE_SIDE_EFFECTS (controller
) = 1;
2786 block
= build_block (tbase
, NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
2787 add_block_current_level (block
);
2789 if (auto_delete
!= integer_zero_node
2790 && auto_delete
!= integer_two_node
)
2792 tree base_tbd
= convert (ptype
,
2793 build_binary_op (MINUS_EXPR
,
2794 convert (ptr_type_node
, base
),
2797 /* This is the real size */
2798 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2799 body
= build_tree_list (NULL_TREE
,
2800 build_x_delete (ptype
, base_tbd
,
2801 2 | use_global_delete
,
2803 body
= build (COND_EXPR
, void_type_node
,
2804 build (BIT_AND_EXPR
, integer_type_node
,
2805 auto_delete
, integer_one_node
),
2806 body
, integer_zero_node
);
2811 body
= tree_cons (NULL_TREE
,
2812 build_delete (ptype
, tbase
, auto_delete
,
2813 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2816 body
= tree_cons (NULL_TREE
,
2817 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2820 body
= tree_cons (NULL_TREE
,
2821 build (EXIT_EXPR
, void_type_node
,
2822 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2825 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2827 loop
= tree_cons (NULL_TREE
, tbase_init
,
2828 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2829 loop
= build_compound_expr (loop
);
2832 /* If the delete flag is one, or anything else with the low bit set,
2833 delete the storage. */
2834 if (auto_delete_vec
== integer_zero_node
2835 || auto_delete_vec
== integer_two_node
)
2836 deallocate_expr
= integer_zero_node
;
2841 /* The below is short by BI_header_size */
2842 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2844 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2849 base_tbd
= convert (ptype
,
2850 build_binary_op (MINUS_EXPR
,
2851 convert (string_type_node
, base
),
2854 /* True size with header. */
2855 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2857 deallocate_expr
= build_x_delete (ptype
, base_tbd
,
2858 2 | use_global_delete
,
2860 if (auto_delete_vec
!= integer_one_node
)
2861 deallocate_expr
= build (COND_EXPR
, void_type_node
,
2862 build (BIT_AND_EXPR
, integer_type_node
,
2863 auto_delete_vec
, integer_one_node
),
2864 deallocate_expr
, integer_zero_node
);
2867 if (loop
&& deallocate_expr
!= integer_zero_node
)
2869 body
= tree_cons (NULL_TREE
, loop
,
2870 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2871 body
= build_compound_expr (body
);
2876 /* Outermost wrapper: If pointer is null, punt. */
2877 body
= build (COND_EXPR
, void_type_node
,
2878 build (NE_EXPR
, boolean_type_node
, base
, integer_zero_node
),
2879 body
, integer_zero_node
);
2880 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2884 TREE_OPERAND (controller
, 1) = body
;
2888 return convert (void_type_node
, body
);
2891 /* Build a tree to cleanup partially built arrays.
2892 BASE is that starting address of the array.
2893 COUNT is the count of objects that have been built, that need destroying.
2894 TYPE is the type of elements in the array. */
2897 build_array_eh_cleanup (base
, count
, type
)
2898 tree base
, count
, type
;
2900 tree expr
= build_vec_delete_1 (base
, count
, type
, integer_two_node
,
2901 integer_zero_node
, 0);
2905 /* `expand_vec_init' performs initialization of a vector of aggregate
2908 DECL is passed only for error reporting, and provides line number
2909 and source file name information.
2910 BASE is the space where the vector will be.
2911 MAXINDEX is the maximum index of the array (one less than the
2912 number of elements).
2913 INIT is the (possibly NULL) initializer.
2915 FROM_ARRAY is 0 if we should init everything with INIT
2916 (i.e., every element initialized from INIT).
2917 FROM_ARRAY is 1 if we should index into INIT in parallel
2918 with initialization of DECL.
2919 FROM_ARRAY is 2 if we should index into INIT in parallel,
2920 but use assignment instead of initialization. */
2923 expand_vec_init (decl
, base
, maxindex
, init
, from_array
)
2924 tree decl
, base
, maxindex
, init
;
2928 tree iterator
, base2
= NULL_TREE
;
2929 tree type
= TREE_TYPE (TREE_TYPE (base
));
2932 maxindex
= convert (ptrdiff_type_node
, maxindex
);
2933 if (maxindex
== error_mark_node
)
2934 return error_mark_node
;
2936 if (current_function_decl
== NULL_TREE
)
2938 rval
= make_tree_vec (3);
2939 TREE_VEC_ELT (rval
, 0) = base
;
2940 TREE_VEC_ELT (rval
, 1) = maxindex
;
2941 TREE_VEC_ELT (rval
, 2) = init
;
2945 size
= size_in_bytes (type
);
2947 /* Set to zero in case size is <= 0. Optimizer will delete this if
2948 it is not needed. */
2949 rval
= get_temp_regvar (build_pointer_type (type
),
2950 convert (build_pointer_type (type
), null_pointer_node
));
2951 base
= default_conversion (base
);
2952 base
= convert (build_pointer_type (type
), base
);
2953 expand_assignment (rval
, base
, 0, 0);
2954 base
= get_temp_regvar (build_pointer_type (type
), base
);
2956 if (init
!= NULL_TREE
&& TREE_CODE (init
) == TREE_LIST
)
2957 init
= build_compound_expr (init
);
2959 if (init
!= NULL_TREE
2960 && TREE_CODE (init
) == CONSTRUCTOR
2961 && (! decl
|| TREE_TYPE (init
) == TREE_TYPE (decl
)))
2963 /* Initialization of array from {...}. */
2964 tree elts
= CONSTRUCTOR_ELTS (init
);
2965 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2966 tree baseinc
= build (PLUS_EXPR
, build_pointer_type (type
), base
, size
);
2967 int host_i
= TREE_INT_CST_LOW (maxindex
);
2969 if (IS_AGGR_TYPE (type
))
2974 expand_aggr_init (baseref
, TREE_VALUE (elts
), 0, 0);
2976 expand_assignment (base
, baseinc
, 0, 0);
2977 elts
= TREE_CHAIN (elts
);
2979 /* Initialize any elements by default if possible. */
2982 if (TYPE_NEEDS_CONSTRUCTING (type
) == 0)
2985 use_variable (DECL_RTL (base
));
2989 iterator
= get_temp_regvar (ptrdiff_type_node
,
2990 build_int_2 (host_i
, 0));
2992 goto init_by_default
;
2998 expand_assignment (baseref
, TREE_VALUE (elts
), 0, 0);
3000 expand_assignment (base
, baseinc
, 0, 0);
3001 elts
= TREE_CHAIN (elts
);
3005 use_variable (DECL_RTL (base
));
3011 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
3015 /* If initializing one array from another,
3016 initialize element by element. */
3019 /* We rely upon the below calls the do argument checking */
3020 if (decl
== NULL_TREE
)
3022 sorry ("initialization of array from dissimilar array type");
3023 return error_mark_node
;
3027 base2
= default_conversion (init
);
3028 itype
= TREE_TYPE (base2
);
3029 base2
= get_temp_regvar (itype
, base2
);
3030 itype
= TREE_TYPE (itype
);
3032 else if (TYPE_LANG_SPECIFIC (type
)
3033 && TYPE_NEEDS_CONSTRUCTING (type
)
3034 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
3036 error ("initializer ends prematurely");
3037 return error_mark_node
;
3041 expand_start_cond (build (GE_EXPR
, boolean_type_node
,
3042 iterator
, integer_zero_node
), 0);
3043 if (TYPE_NEEDS_DESTRUCTOR (type
))
3044 expand_eh_region_start ();
3045 expand_start_loop_continue_elsewhere (1);
3049 tree to
= build1 (INDIRECT_REF
, type
, base
);
3053 from
= build1 (INDIRECT_REF
, itype
, base2
);
3057 if (from_array
== 2)
3058 expand_expr_stmt (build_modify_expr (to
, NOP_EXPR
, from
));
3059 else if (TYPE_NEEDS_CONSTRUCTING (type
))
3060 expand_aggr_init (to
, from
, 0, 0);
3062 expand_assignment (to
, from
, 0, 0);
3064 my_friendly_abort (57);
3066 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3069 sorry ("cannot initialize multi-dimensional array with initializer");
3070 expand_vec_init (decl
, build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), base
),
3071 array_type_nelts (type
), 0, 0);
3075 tree targ
= build1 (INDIRECT_REF
, type
, base
);
3079 rhs
= convert_for_initialization (targ
, type
, init
, LOOKUP_NORMAL
,
3080 "initialization", NULL_TREE
, 0);
3084 expand_aggr_init (targ
, rhs
, 0, 0);
3087 expand_assignment (base
,
3088 build (PLUS_EXPR
, build_pointer_type (type
), base
, size
),
3091 expand_assignment (base2
,
3092 build (PLUS_EXPR
, build_pointer_type (type
), base2
, size
), 0, 0);
3093 expand_loop_continue_here ();
3094 expand_exit_loop_if_false (0, build (NE_EXPR
, boolean_type_node
,
3095 build (PREDECREMENT_EXPR
, ptrdiff_type_node
, iterator
, integer_one_node
), minus_one
));
3099 use_variable (DECL_RTL (base
));
3101 use_variable (DECL_RTL (base2
));
3104 if (TYPE_NEEDS_DESTRUCTOR (type
) && flag_exceptions
)
3106 /* We have to ensure that this can live to the cleanup
3107 expansion time, since we know it is only ever needed
3108 once, generate code now. */
3109 push_obstacks_nochange ();
3110 resume_temporary_allocation ();
3112 tree e1
, e2
= make_node (RTL_EXPR
);
3113 TREE_TYPE (e2
) = void_type_node
;
3114 RTL_EXPR_RTL (e2
) = const0_rtx
;
3115 TREE_SIDE_EFFECTS (e2
) = 1;
3116 start_sequence_for_rtl_expr (e2
);
3118 e1
= build_array_eh_cleanup
3120 build_binary_op (MINUS_EXPR
, maxindex
, iterator
, 1),
3122 expand_expr (e1
, const0_rtx
, VOIDmode
, 0);
3123 RTL_EXPR_SEQUENCE (e2
) = get_insns ();
3125 expand_eh_region_end (e2
);
3131 use_variable (DECL_RTL (iterator
));
3136 use_variable (DECL_RTL (rval
));
3140 /* Free up storage of type TYPE, at address ADDR.
3142 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3145 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3146 used as the second argument to operator delete. It can include
3147 things like padding and magic size cookies. It has virtual in it,
3148 because if you have a base pointer and you delete through a virtual
3149 destructor, it should be the size of the dynamic object, not the
3150 static object, see Free Store 12.5 ANSI C++ WP.
3152 This does not call any destructors. */
3155 build_x_delete (type
, addr
, which_delete
, virtual_size
)
3160 int use_global_delete
= which_delete
& 1;
3161 int use_vec_delete
= !!(which_delete
& 2);
3163 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3165 if (! use_global_delete
&& TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
3166 && (TYPE_GETS_DELETE (TREE_TYPE (type
)) & (1 << use_vec_delete
)))
3167 rval
= build_opfncall (code
, LOOKUP_NORMAL
, addr
, virtual_size
, NULL_TREE
);
3169 rval
= build_builtin_call (void_type_node
, use_vec_delete
? BIVD
: BID
,
3170 build_tree_list (NULL_TREE
, addr
));
3174 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3175 ADDR is an expression which yields the store to be destroyed.
3176 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
3177 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
3178 virtual baseclasses.
3179 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
3181 FLAGS is the logical disjunction of zero or more LOOKUP_
3182 flags. See cp-tree.h for more info.
3184 This function does not delete an object's virtual base classes. */
3187 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3191 int use_global_delete
;
3199 if (addr
== error_mark_node
)
3200 return error_mark_node
;
3202 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3203 set to `error_mark_node' before it gets properly cleaned up. */
3204 if (type
== error_mark_node
)
3205 return error_mark_node
;
3207 type
= TYPE_MAIN_VARIANT (type
);
3209 if (TREE_CODE (type
) == POINTER_TYPE
)
3211 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3212 if (TYPE_SIZE (complete_type (type
)) == 0)
3214 incomplete_type_error (0, type
);
3215 return error_mark_node
;
3217 if (TREE_CODE (type
) == ARRAY_TYPE
)
3219 if (! IS_AGGR_TYPE (type
))
3221 /* Call the builtin operator delete. */
3222 return build_builtin_call (void_type_node
, BID
,
3223 build_tree_list (NULL_TREE
, addr
));
3225 if (TREE_SIDE_EFFECTS (addr
))
3226 addr
= save_expr (addr
);
3228 /* throw away const and volatile on target type of addr */
3229 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3230 ref
= build_indirect_ref (addr
, NULL_PTR
);
3233 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3236 if (TREE_SIDE_EFFECTS (addr
))
3237 addr
= save_expr (addr
);
3238 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3240 error ("unknown array size in delete");
3241 return error_mark_node
;
3243 return build_vec_delete (addr
, array_type_nelts (type
),
3244 auto_delete
, integer_two_node
,
3249 /* Don't check PROTECT here; leave that decision to the
3250 destructor. If the destructor is accessible, call it,
3251 else report error. */
3252 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3253 if (TREE_SIDE_EFFECTS (addr
))
3254 addr
= save_expr (addr
);
3256 if (TREE_CONSTANT (addr
))
3257 addr
= convert_pointer_to (type
, addr
);
3259 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3261 ref
= build_indirect_ref (addr
, NULL_PTR
);
3265 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3267 if (! TYPE_NEEDS_DESTRUCTOR (type
))
3269 if (auto_delete
== integer_zero_node
)
3270 return void_zero_node
;
3272 /* Pass the size of the object down to the operator delete() in
3273 addition to the ADDR. */
3274 if (TYPE_GETS_REG_DELETE (type
) && !use_global_delete
)
3276 tree virtual_size
= c_sizeof_nowarn (type
);
3277 return build_opfncall (DELETE_EXPR
, LOOKUP_NORMAL
, addr
,
3278 virtual_size
, NULL_TREE
);
3281 /* Call the builtin operator delete. */
3282 return build_builtin_call (void_type_node
, BID
,
3283 build_tree_list (NULL_TREE
, addr
));
3286 /* Below, we will reverse the order in which these calls are made.
3287 If we have a destructor, then that destructor will take care
3288 of the base classes; otherwise, we must do that here. */
3289 if (TYPE_HAS_DESTRUCTOR (type
))
3291 tree parms
= build_tree_list (NULL_TREE
, addr
);
3292 tree dtor
= DECL_MAIN_VARIANT (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), 1));
3293 tree passed_auto_delete
;
3294 tree do_delete
= NULL_TREE
;
3298 if (use_global_delete
)
3300 tree cond
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3301 auto_delete
, integer_one_node
));
3302 tree call
= build_builtin_call
3303 (void_type_node
, BID
, build_tree_list (NULL_TREE
, addr
));
3305 cond
= fold (build (COND_EXPR
, void_type_node
, cond
,
3306 call
, void_zero_node
));
3307 if (cond
!= void_zero_node
)
3310 passed_auto_delete
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3311 auto_delete
, integer_two_node
));
3314 passed_auto_delete
= auto_delete
;
3316 expr
= build_method_call
3317 (ref
, dtor_identifier
, build_tree_list (NULL_TREE
, passed_auto_delete
),
3321 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3323 if (flags
& LOOKUP_DESTRUCTOR
)
3324 /* Explicit destructor call; don't check for null pointer. */
3325 ifexp
= integer_one_node
;
3327 /* Handle deleting a null pointer. */
3328 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
, 1));
3330 if (ifexp
!= integer_one_node
)
3331 expr
= build (COND_EXPR
, void_type_node
,
3332 ifexp
, expr
, void_zero_node
);
3338 /* We only get here from finish_function for a destructor. */
3339 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3340 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3341 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3342 tree exprstmt
= NULL_TREE
;
3343 tree parent_auto_delete
= auto_delete
;
3346 /* If we have member delete or vbases, we call delete in
3348 if (auto_delete
== integer_zero_node
)
3350 else if (base_binfo
== NULL_TREE
3351 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3353 cond
= build (COND_EXPR
, void_type_node
,
3354 build (BIT_AND_EXPR
, integer_type_node
, auto_delete
, integer_one_node
),
3355 build_builtin_call (void_type_node
, BID
,
3356 build_tree_list (NULL_TREE
, addr
)),
3363 exprstmt
= build_tree_list (NULL_TREE
, cond
);
3366 && ! TREE_VIA_VIRTUAL (base_binfo
)
3367 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3369 tree this_auto_delete
;
3371 if (BINFO_OFFSET_ZEROP (base_binfo
))
3372 this_auto_delete
= parent_auto_delete
;
3374 this_auto_delete
= integer_zero_node
;
3376 expr
= build_scoped_method_call
3377 (ref
, base_binfo
, dtor_identifier
,
3378 build_tree_list (NULL_TREE
, this_auto_delete
));
3379 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3382 /* Take care of the remaining baseclasses. */
3383 for (i
= 1; i
< n_baseclasses
; i
++)
3385 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3386 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3387 || TREE_VIA_VIRTUAL (base_binfo
))
3390 expr
= build_scoped_method_call
3391 (ref
, base_binfo
, dtor_identifier
,
3392 build_tree_list (NULL_TREE
, integer_zero_node
));
3394 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3397 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3399 if (TREE_CODE (member
) != FIELD_DECL
)
3401 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member
)))
3403 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3404 tree this_type
= TREE_TYPE (member
);
3405 expr
= build_delete (this_type
, this_member
, integer_two_node
, flags
, 0);
3406 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3411 return build_compound_expr (exprstmt
);
3412 /* Virtual base classes make this function do nothing. */
3413 return void_zero_node
;
3417 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3420 build_vbase_delete (type
, decl
)
3423 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3424 tree result
= NULL_TREE
;
3425 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3427 my_friendly_assert (addr
!= error_mark_node
, 222);
3431 tree this_addr
= convert_force (build_pointer_type (BINFO_TYPE (vbases
)),
3433 result
= tree_cons (NULL_TREE
,
3434 build_delete (TREE_TYPE (this_addr
), this_addr
,
3436 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3438 vbases
= TREE_CHAIN (vbases
);
3440 return build_compound_expr (nreverse (result
));
3443 /* Build a C++ vector delete expression.
3444 MAXINDEX is the number of elements to be deleted.
3445 ELT_SIZE is the nominal size of each element in the vector.
3446 BASE is the expression that should yield the store to be deleted.
3447 This function expands (or synthesizes) these calls itself.
3448 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3449 AUTO_DELETE say whether each item in the container should be deallocated.
3451 This also calls delete for virtual baseclasses of elements of the vector.
3453 Update: MAXINDEX is no longer needed. The size can be extracted from the
3454 start of the vector for pointers, and from the type for arrays. We still
3455 use MAXINDEX for arrays because it happens to already have one of the
3456 values we'd have to extract. (We could use MAXINDEX with pointers to
3457 confirm the size, and trap if the numbers differ; not clear that it'd
3458 be worth bothering.) */
3461 build_vec_delete (base
, maxindex
, auto_delete_vec
, auto_delete
,
3463 tree base
, maxindex
;
3464 tree auto_delete_vec
, auto_delete
;
3465 int use_global_delete
;
3469 if (TREE_CODE (base
) == OFFSET_REF
)
3470 base
= resolve_offset_ref (base
);
3472 type
= TREE_TYPE (base
);
3474 base
= stabilize_reference (base
);
3476 /* Since we can use base many times, save_expr it. */
3477 if (TREE_SIDE_EFFECTS (base
))
3478 base
= save_expr (base
);
3480 if (TREE_CODE (type
) == POINTER_TYPE
)
3482 /* Step back one from start of vector, and read dimension. */
3483 tree cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3484 base
, BI_header_size
);
3485 tree cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3486 maxindex
= build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0);
3488 type
= TREE_TYPE (type
);
3489 while (TREE_CODE (type
) == ARRAY_TYPE
);
3491 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3493 /* get the total number of things in the array, maxindex is a bad name */
3494 maxindex
= array_type_nelts_total (type
);
3495 while (TREE_CODE (type
) == ARRAY_TYPE
)
3496 type
= TREE_TYPE (type
);
3497 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3501 if (base
!= error_mark_node
)
3502 error ("type to vector delete is neither pointer or array type");
3503 return error_mark_node
;
3506 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,