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. */
32 /* In C++, structures with well-defined constructors are initialized by
33 those constructors, unasked. CURRENT_BASE_INIT_LIST
34 holds a list of stmts for a BASE_INIT term in the grammar.
35 This list has one element for each base class which must be
36 initialized. The list elements are [basename, init], with
37 type basetype. This allows the possibly anachronistic form
38 (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
39 where each successive term can be handed down the constructor
40 line. Perhaps this was not intended. */
41 tree current_base_init_list
, current_member_init_list
;
43 void emit_base_init ();
44 void check_base_init ();
45 static void expand_aggr_vbase_init ();
46 void expand_member_init ();
47 void expand_aggr_init ();
49 static void expand_aggr_init_1
PROTO((tree
, tree
, tree
, tree
, int, int));
50 static void expand_virtual_init
PROTO((tree
, tree
));
51 tree
expand_vec_init ();
53 /* Cache _builtin_new and _builtin_delete exprs. */
54 static tree BIN
, BID
, BIVN
, BIVD
;
56 /* Cache the identifier nodes for the magic field of a new cookie. */
57 static tree nc_nelts_field_id
;
59 static tree minus_one
;
61 /* Set up local variable for this file. MUST BE CALLED AFTER
62 INIT_DECL_PROCESSING. */
64 static tree BI_header_type
, BI_header_size
;
66 void init_init_processing ()
70 /* Define implicit `operator new' and `operator delete' functions. */
71 BIN
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) NEW_EXPR
])));
72 TREE_USED (TREE_OPERAND (BIN
, 0)) = 0;
73 BID
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) DELETE_EXPR
])));
74 TREE_USED (TREE_OPERAND (BID
, 0)) = 0;
75 BIVN
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) VEC_NEW_EXPR
])));
76 TREE_USED (TREE_OPERAND (BIVN
, 0)) = 0;
77 BIVD
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) VEC_DELETE_EXPR
])));
78 TREE_USED (TREE_OPERAND (BIVD
, 0)) = 0;
79 minus_one
= build_int_2 (-1, -1);
81 /* Define the structure that holds header information for
82 arrays allocated via operator new. */
83 BI_header_type
= make_lang_type (RECORD_TYPE
);
84 nc_nelts_field_id
= get_identifier ("nelts");
85 fields
[0] = build_lang_field_decl (FIELD_DECL
, nc_nelts_field_id
, sizetype
);
86 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
88 BI_header_size
= size_in_bytes (BI_header_type
);
91 /* Subroutine of emit_base_init. For BINFO, initialize all the
92 virtual function table pointers, except those that come from
93 virtual base classes. Initialize binfo's vtable pointer, if
94 INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
95 function table pointers in all bases have been initialized already,
96 probably because their constructors have just be run. ADDR is the
97 pointer to the object whos vtables we are going to initialize.
99 REAL_BINFO is usually the same as BINFO, except when addr is not of
100 pointer to the type of the real derived type that we want to
101 initialize for. This is the case when addr is a pointer to a sub
102 object of a complete object, and we only want to do part of the
103 complete object's initialization of vtable pointers. This is done
104 for all virtual table pointers in virtual base classes. REAL_BINFO
105 is used to find the BINFO_VTABLE that we initialize with. BINFO is
106 used for conversions of addr to subobjects.
108 BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
110 Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
114 expand_direct_vtbls_init (real_binfo
, binfo
, init_self
, can_elide
, addr
)
115 tree real_binfo
, binfo
, addr
;
116 int init_self
, can_elide
;
118 tree real_binfos
= BINFO_BASETYPES (real_binfo
);
119 tree binfos
= BINFO_BASETYPES (binfo
);
120 int i
, n_baselinks
= real_binfos
? TREE_VEC_LENGTH (real_binfos
) : 0;
122 for (i
= 0; i
< n_baselinks
; i
++)
124 tree real_base_binfo
= TREE_VEC_ELT (real_binfos
, i
);
125 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
126 int is_not_base_vtable
127 = i
!= CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo
));
128 if (! TREE_VIA_VIRTUAL (real_base_binfo
))
129 expand_direct_vtbls_init (real_base_binfo
, base_binfo
,
130 is_not_base_vtable
, can_elide
, addr
);
133 /* Before turning this on, make sure it is correct. */
134 if (can_elide
&& ! BINFO_MODIFIED (binfo
))
137 /* Should we use something besides CLASSTYPE_VFIELDS? */
138 if (init_self
&& CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo
)))
140 tree base_ptr
= convert_pointer_to_real (binfo
, addr
);
141 expand_virtual_init (real_binfo
, base_ptr
);
146 /* Subroutine of emit_base_init. */
149 perform_member_init (member
, name
, init
, explicit)
150 tree member
, name
, init
;
154 tree type
= TREE_TYPE (member
);
156 expand_start_target_temps ();
158 if (TYPE_NEEDS_CONSTRUCTING (type
)
159 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
161 /* Since `init' is already a TREE_LIST on the current_member_init_list,
162 only build it into one if we aren't already a list. */
163 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
164 init
= build_tree_list (NULL_TREE
, init
);
166 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
169 && TREE_CODE (type
) == ARRAY_TYPE
171 && TREE_CHAIN (init
) == NULL_TREE
172 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
174 /* Initialization of one array from another. */
175 expand_vec_init (TREE_OPERAND (decl
, 1), decl
,
176 array_type_nelts (type
), TREE_VALUE (init
), 1);
179 expand_aggr_init (decl
, init
, 0, 0);
183 if (init
== NULL_TREE
)
187 cp_error ("incomplete initializer for member `%D' of class `%T' which has no constructor",
188 member
, current_class_type
);
189 init
= error_mark_node
;
191 /* member traversal: note it leaves init NULL */
192 else if (TREE_CODE (TREE_TYPE (member
)) == REFERENCE_TYPE
)
193 cp_pedwarn ("uninitialized reference member `%D'", member
);
195 else if (TREE_CODE (init
) == TREE_LIST
)
197 /* There was an explicit member initialization. Do some
198 work in that case. */
199 if (TREE_CHAIN (init
))
201 warning ("initializer list treated as compound expression");
202 init
= build_compound_expr (init
);
205 init
= TREE_VALUE (init
);
208 /* We only build this with a null init if we got it from the
209 current_member_init_list. */
210 if (init
|| explicit)
212 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
213 expand_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
217 expand_end_target_temps ();
220 if (TYPE_NEEDS_DESTRUCTOR (type
))
224 /* All cleanups must be on the function_obstack. */
225 push_obstacks_nochange ();
226 resume_temporary_allocation ();
228 expr
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
229 expr
= build_delete (type
, expr
, integer_zero_node
,
230 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
232 if (expr
!= error_mark_node
)
233 add_partial_entry (expr
);
239 extern int warn_reorder
;
241 /* Subroutine of emit_member_init. */
247 tree x
, member
, name
, field
;
248 tree init_list
= NULL_TREE
;
252 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
256 /* member could be, for example, a CONST_DECL for an enumerated
257 tag; we don't want to try to initialize that, since it already
259 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
262 for (x
= current_member_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
264 /* If we cleared this out, then pay no attention to it. */
265 if (TREE_PURPOSE (x
) == NULL_TREE
)
267 name
= TREE_PURPOSE (x
);
270 /* This happens in templates, since the IDENTIFIER is replaced
271 with the COMPONENT_REF in tsubst_expr. */
272 field
= (TREE_CODE (name
) == COMPONENT_REF
273 ? TREE_OPERAND (name
, 1) : IDENTIFIER_CLASS_VALUE (name
));
275 /* Let's find out when this happens. */
276 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 348);
277 field
= IDENTIFIER_CLASS_VALUE (name
);
280 /* If one member shadows another, get the outermost one. */
281 if (TREE_CODE (field
) == TREE_LIST
)
282 field
= TREE_VALUE (field
);
290 cp_warning_at ("member initializers for `%#D'", last_field
);
291 cp_warning_at (" and `%#D'", field
);
292 warning (" will be re-ordered to match declaration order");
298 /* Make sure we won't try to work on this init again. */
299 TREE_PURPOSE (x
) = NULL_TREE
;
300 x
= build_tree_list (name
, TREE_VALUE (x
));
305 /* If we didn't find MEMBER in the list, create a dummy entry
306 so the two lists (INIT_LIST and the list of members) will be
308 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
310 init_list
= chainon (init_list
, x
);
313 /* Initializers for base members go at the end. */
314 for (x
= current_member_init_list
; x
; x
= TREE_CHAIN (x
))
316 name
= TREE_PURPOSE (x
);
319 if (purpose_member (name
, init_list
))
321 cp_error ("multiple initializations given for member `%D'",
322 IDENTIFIER_CLASS_VALUE (name
));
326 init_list
= chainon (init_list
,
327 build_tree_list (name
, TREE_VALUE (x
)));
328 TREE_PURPOSE (x
) = NULL_TREE
;
336 sort_base_init (t
, rbase_ptr
, vbase_ptr
)
337 tree t
, *rbase_ptr
, *vbase_ptr
;
339 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
340 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
346 /* For warn_reorder. */
348 tree last_base
= NULL_TREE
;
350 tree rbases
= NULL_TREE
;
351 tree vbases
= NULL_TREE
;
353 /* First walk through and splice out vbase and invalid initializers.
354 Also replace names with binfos. */
356 last
= tree_cons (NULL_TREE
, NULL_TREE
, current_base_init_list
);
357 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
359 tree basetype
= TREE_PURPOSE (x
);
362 if (basetype
== NULL_TREE
)
364 /* Initializer for single base class. Must not
365 use multiple inheritance or this is ambiguous. */
366 switch (n_baseclasses
)
369 cp_error ("`%T' does not have a base class to initialize",
375 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
379 binfo
= TREE_VEC_ELT (binfos
, 0);
381 else if (is_aggr_type (basetype
, 1))
383 binfo
= binfo_or_else (basetype
, t
);
384 if (binfo
== NULL_TREE
)
387 /* Virtual base classes are special cases. Their initializers
388 are recorded with this constructor, and they are used when
389 this constructor is the top-level constructor called. */
390 if (TREE_VIA_VIRTUAL (binfo
))
392 tree v
= CLASSTYPE_VBASECLASSES (t
);
393 while (BINFO_TYPE (v
) != BINFO_TYPE (binfo
))
396 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
401 /* Otherwise, if it is not an immediate base class, complain. */
402 for (i
= n_baseclasses
-1; i
>= 0; i
--)
403 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
407 cp_error ("`%T' is not an immediate base class of `%T'",
408 basetype
, current_class_type
);
414 my_friendly_abort (365);
416 TREE_PURPOSE (x
) = binfo
;
417 TREE_CHAIN (last
) = x
;
420 TREE_CHAIN (last
) = NULL_TREE
;
422 /* Now walk through our regular bases and make sure they're initialized. */
424 for (i
= 0; i
< n_baseclasses
; ++i
)
426 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
429 if (TREE_VIA_VIRTUAL (base_binfo
))
432 for (x
= current_base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
434 tree binfo
= TREE_PURPOSE (x
);
436 if (binfo
== NULL_TREE
)
439 if (binfo
== base_binfo
)
445 cp_warning_at ("base initializers for `%#T'", last_base
);
446 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
447 warning (" will be re-ordered to match inheritance order");
450 last_base
= BINFO_TYPE (binfo
);
453 /* Make sure we won't try to work on this init again. */
454 TREE_PURPOSE (x
) = NULL_TREE
;
455 x
= build_tree_list (binfo
, TREE_VALUE (x
));
460 /* If we didn't find BASE_BINFO in the list, create a dummy entry
461 so the two lists (RBASES and the list of bases) will be
463 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
465 rbases
= chainon (rbases
, x
);
472 /* Perform partial cleanups for a base for exception handling. */
475 build_partial_cleanup_for (binfo
)
478 return build_scoped_method_call
479 (current_class_ref
, binfo
, dtor_identifier
,
480 build_tree_list (NULL_TREE
, integer_zero_node
));
483 /* Perform whatever initializations have yet to be done on the base
484 class of the class variable. These actions are in the global
485 variable CURRENT_BASE_INIT_LIST. Such an action could be
486 NULL_TREE, meaning that the user has explicitly called the base
487 class constructor with no arguments.
489 If there is a need for a call to a constructor, we must surround
490 that call with a pushlevel/poplevel pair, since we are technically
491 at the PARM level of scope.
493 Argument IMMEDIATELY, if zero, forces a new sequence to be
494 generated to contain these new insns, so it can be emitted later.
495 This sequence is saved in the global variable BASE_INIT_EXPR.
496 Otherwise, the insns are emitted into the current sequence.
498 Note that emit_base_init does *not* initialize virtual base
499 classes. That is done specially, elsewhere. */
501 extern tree base_init_expr
, rtl_expr_chain
;
504 emit_base_init (t
, immediately
)
510 tree rbase_init_list
, vbase_init_list
;
511 tree t_binfo
= TYPE_BINFO (t
);
512 tree binfos
= BINFO_BASETYPES (t_binfo
);
513 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
514 tree expr
= NULL_TREE
;
519 do_pending_stack_adjust ();
520 /* Make the RTL_EXPR node temporary, not momentary,
521 so that rtl_expr_chain doesn't become garbage. */
522 momentary
= suspend_momentary ();
523 expr
= make_node (RTL_EXPR
);
524 resume_momentary (momentary
);
525 start_sequence_for_rtl_expr (expr
);
528 if (write_symbols
== NO_DEBUG
)
529 /* As a matter of principle, `start_sequence' should do this. */
532 /* Always emit a line number note so we can step into constructors. */
533 emit_line_note_force (DECL_SOURCE_FILE (current_function_decl
),
534 DECL_SOURCE_LINE (current_function_decl
));
536 mem_init_list
= sort_member_init (t
);
537 current_member_init_list
= NULL_TREE
;
539 sort_base_init (t
, &rbase_init_list
, &vbase_init_list
);
540 current_base_init_list
= NULL_TREE
;
542 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
544 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
546 expand_start_cond (first_arg
, 0);
547 expand_aggr_vbase_init (t_binfo
, current_class_ref
, current_class_ptr
,
552 /* Now, perform initialization of non-virtual base classes. */
553 for (i
= 0; i
< n_baseclasses
; i
++)
555 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
556 tree init
= void_list_node
;
558 if (TREE_VIA_VIRTUAL (base_binfo
))
561 #if 0 /* Once unsharing happens soon enough. */
562 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
, 999);
564 BINFO_INHERITANCE_CHAIN (base_binfo
) = t_binfo
;
567 if (TREE_PURPOSE (rbase_init_list
))
568 init
= TREE_VALUE (rbase_init_list
);
569 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
572 if (extra_warnings
&& copy_args_p (current_function_decl
))
573 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
574 BINFO_TYPE (base_binfo
));
577 if (init
!= void_list_node
)
579 expand_start_target_temps ();
581 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
582 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
583 build_indirect_ref (member
, NULL_PTR
), init
,
584 BINFO_OFFSET_ZEROP (base_binfo
), LOOKUP_NORMAL
);
586 expand_end_target_temps ();
590 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
594 /* All cleanups must be on the function_obstack. */
595 push_obstacks_nochange ();
596 resume_temporary_allocation ();
597 expr
= build_partial_cleanup_for (base_binfo
);
599 add_partial_entry (expr
);
602 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
605 /* Initialize all the virtual function table fields that
606 do come from virtual base classes. */
607 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
608 expand_indirect_vtbls_init (t_binfo
, current_class_ref
, current_class_ptr
);
610 /* Initialize all the virtual function table fields that
611 do not come from virtual base classes. */
612 expand_direct_vtbls_init (t_binfo
, t_binfo
, 1, 1, current_class_ptr
);
614 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
619 /* member could be, for example, a CONST_DECL for an enumerated
620 tag; we don't want to try to initialize that, since it already
622 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
625 /* See if we had a user-specified member initialization. */
626 if (TREE_PURPOSE (mem_init_list
))
628 name
= TREE_PURPOSE (mem_init_list
);
629 init
= TREE_VALUE (mem_init_list
);
633 if (TREE_CODE (name
) == COMPONENT_REF
)
634 name
= DECL_NAME (TREE_OPERAND (name
, 1));
636 /* Also see if it's ever a COMPONENT_REF here. If it is, we
637 need to do `expand_assignment (name, init, 0, 0);' and
639 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 349);
644 name
= DECL_NAME (member
);
645 init
= DECL_INITIAL (member
);
649 /* Effective C++ rule 12. */
650 if (warn_ecpp
&& init
== NULL_TREE
651 && !DECL_ARTIFICIAL (member
)
652 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
653 cp_warning ("`%D' should be initialized in the member initialization list", member
);
656 perform_member_init (member
, name
, init
, from_init_list
);
657 mem_init_list
= TREE_CHAIN (mem_init_list
);
660 /* Now initialize any members from our bases. */
661 while (mem_init_list
)
663 tree name
, init
, field
;
665 if (TREE_PURPOSE (mem_init_list
))
667 name
= TREE_PURPOSE (mem_init_list
);
668 init
= TREE_VALUE (mem_init_list
);
669 /* XXX: this may need the COMPONENT_REF operand 0 check if
670 it turns out we actually get them. */
671 field
= IDENTIFIER_CLASS_VALUE (name
);
673 /* If one member shadows another, get the outermost one. */
674 if (TREE_CODE (field
) == TREE_LIST
)
676 field
= TREE_VALUE (field
);
677 if (decl_type_context (field
) != current_class_type
)
678 cp_error ("field `%D' not in immediate context", field
);
682 /* It turns out if you have an anonymous union in the
683 class, a member from it can end up not being on the
684 list of fields (rather, the type is), and therefore
685 won't be seen by the for loop above. */
687 /* The code in this for loop is derived from a general loop
688 which had this check in it. Theoretically, we've hit
689 every initialization for the list of members in T, so
690 we shouldn't have anything but these left in this list. */
691 my_friendly_assert (DECL_FIELD_CONTEXT (field
) != t
, 351);
694 perform_member_init (field
, name
, init
, 1);
696 mem_init_list
= TREE_CHAIN (mem_init_list
);
701 do_pending_stack_adjust ();
702 my_friendly_assert (base_init_expr
== 0, 207);
703 base_init_expr
= expr
;
704 TREE_TYPE (expr
) = void_type_node
;
705 RTL_EXPR_RTL (expr
) = const0_rtx
;
706 RTL_EXPR_SEQUENCE (expr
) = get_insns ();
707 rtl_expr_chain
= tree_cons (NULL_TREE
, expr
, rtl_expr_chain
);
709 TREE_SIDE_EFFECTS (expr
) = 1;
712 /* All the implicit try blocks we built up will be zapped
713 when we come to a real binding contour boundary. */
716 /* Check that all fields are properly initialized after
717 an assignment to `this'. */
724 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
725 if (DECL_NAME (member
) && TREE_USED (member
))
726 cp_error ("field `%D' used before initialized (after assignment to `this')",
730 /* This code sets up the virtual function tables appropriate for
731 the pointer DECL. It is a one-ply initialization.
733 BINFO is the exact type that DECL is supposed to be. In
734 multiple inheritance, this might mean "C's A" if C : A, B. */
737 expand_virtual_init (binfo
, decl
)
740 tree type
= BINFO_TYPE (binfo
);
742 tree vtype
, vtype_binfo
;
744 /* This code is crusty. Should be simple, like:
745 vtbl = BINFO_VTABLE (binfo);
747 vtype
= DECL_CONTEXT (CLASSTYPE_VFIELD (type
));
748 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
749 vtbl
= BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type
)), binfo
));
750 assemble_external (vtbl
);
751 TREE_USED (vtbl
) = 1;
752 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
753 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
754 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
755 if (vtbl_ptr
== error_mark_node
)
758 /* Have to convert VTBL since array sizes may be different. */
759 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
760 expand_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
763 /* Subroutine of `expand_aggr_vbase_init'.
764 BINFO is the binfo of the type that is being initialized.
765 INIT_LIST is the list of initializers for the virtual baseclass. */
768 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
769 tree binfo
, exp
, addr
, init_list
;
771 tree init
= purpose_member (binfo
, init_list
);
772 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
774 expand_start_target_temps ();
777 init
= TREE_VALUE (init
);
778 /* Call constructors, but don't set up vtables. */
779 expand_aggr_init_1 (binfo
, exp
, ref
, init
, 0, LOOKUP_COMPLAIN
);
781 expand_end_target_temps ();
785 /* Initialize this object's virtual base class pointers. This must be
786 done only at the top-level of the object being constructed.
788 INIT_LIST is list of initialization for constructor to perform. */
791 expand_aggr_vbase_init (binfo
, exp
, addr
, init_list
)
797 tree type
= BINFO_TYPE (binfo
);
799 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
801 tree result
= init_vbase_pointers (type
, addr
);
805 expand_expr_stmt (build_compound_expr (result
));
807 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
808 vbases
= TREE_CHAIN (vbases
))
810 tree tmp
= purpose_member (vbases
, result
);
811 expand_aggr_vbase_init_1 (vbases
, exp
,
812 TREE_OPERAND (TREE_VALUE (tmp
), 0),
818 /* Subroutine to perform parser actions for member initialization.
819 S_ID is the scoped identifier.
820 NAME is the name of the member.
821 INIT is the initializer, or `void_type_node' if none. */
824 do_member_init (s_id
, name
, init
)
825 tree s_id
, name
, init
;
829 if (current_class_type
== NULL_TREE
830 || ! is_aggr_typedef (s_id
, 1))
832 binfo
= get_binfo (IDENTIFIER_TYPE_VALUE (s_id
),
833 current_class_type
, 1);
834 if (binfo
== error_mark_node
)
838 error_not_base_type (IDENTIFIER_TYPE_VALUE (s_id
), current_class_type
);
842 base
= convert_pointer_to (binfo
, current_class_ptr
);
843 expand_member_init (build_indirect_ref (base
, NULL_PTR
), name
, init
);
846 /* Find the context in which this FIELD can be initialized. */
849 initializing_context (field
)
852 tree t
= DECL_CONTEXT (field
);
854 /* Anonymous union members can be initialized in the first enclosing
855 non-anonymous union context. */
856 while (t
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
857 t
= TYPE_CONTEXT (t
);
861 /* Function to give error message if member initialization specification
862 is erroneous. FIELD is the member we decided to initialize.
863 TYPE is the type for which the initialization is being performed.
864 FIELD must be a member of TYPE.
866 MEMBER_NAME is the name of the member. */
869 member_init_ok_or_else (field
, type
, member_name
)
874 if (field
== error_mark_node
)
876 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
878 cp_error ("class `%T' does not have any field named `%s'", type
,
882 if (TREE_STATIC (field
))
884 cp_error ("field `%#D' is static; only point of initialization is its declaration",
892 /* If NAME is a viable field name for the aggregate DECL,
893 and PARMS is a viable parameter list, then expand an _EXPR
894 which describes this initialization.
896 Note that we do not need to chase through the class's base classes
897 to look for NAME, because if it's in that list, it will be handled
898 by the constructor for that base class.
900 We do not yet have a fixed-point finder to instantiate types
901 being fed to overloaded constructors. If there is a unique
902 constructor, then argument types can be got from that one.
904 If INIT is non-NULL, then it the initialization should
905 be placed in `current_base_init_list', where it will be processed
906 by `emit_base_init'. */
909 expand_member_init (exp
, name
, init
)
910 tree exp
, name
, init
;
912 extern tree ptr_type_node
; /* should be in tree.h */
914 tree basetype
= NULL_TREE
, field
;
918 if (exp
== NULL_TREE
)
919 return; /* complain about this later */
921 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
923 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
925 basetype
= TREE_TYPE (name
);
926 name
= DECL_NAME (name
);
929 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
930 switch (CLASSTYPE_N_BASECLASSES (type
))
933 error ("base class initializer specified, but no base class to initialize");
936 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
939 error ("initializer for unnamed base class ambiguous");
940 cp_error ("(type `%T' uses multiple inheritance)", type
);
946 /* The grammar should not allow fields which have names
947 that are TYPENAMEs. Therefore, if the field has
948 a non-NULL TREE_TYPE, we may assume that this is an
949 attempt to initialize a base class member of the current
950 type. Otherwise, it is an attempt to initialize a
953 if (init
== void_type_node
)
956 if (name
== NULL_TREE
|| basetype
)
960 if (name
== NULL_TREE
)
964 name
= TYPE_IDENTIFIER (basetype
);
967 error ("no base class to initialize");
972 else if (basetype
!= type
973 && ! current_template_parms
974 && ! vec_binfo_member (basetype
,
975 TYPE_BINFO_BASETYPES (type
))
976 && ! binfo_member (basetype
, CLASSTYPE_VBASECLASSES (type
)))
978 if (IDENTIFIER_CLASS_VALUE (name
))
980 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
981 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
984 cp_error ("type `%T' is not an immediate basetype for `%T'",
989 if (purpose_member (basetype
, current_base_init_list
))
991 cp_error ("base class `%T' already initialized", basetype
);
995 if (warn_reorder
&& current_member_init_list
)
997 cp_warning ("base initializer for `%T'", basetype
);
998 warning (" will be re-ordered to precede member initializations");
1001 base_init
= build_tree_list (basetype
, init
);
1002 current_base_init_list
= chainon (current_base_init_list
, base_init
);
1009 field
= lookup_field (type
, name
, 1, 0);
1011 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
1014 if (purpose_member (name
, current_member_init_list
))
1016 cp_error ("field `%D' already initialized", field
);
1020 member_init
= build_tree_list (name
, init
);
1021 current_member_init_list
= chainon (current_member_init_list
, member_init
);
1025 else if (name
== NULL_TREE
)
1027 compiler_error ("expand_member_init: name == NULL_TREE");
1032 field
= lookup_field (basetype
, name
, 0, 0);
1034 if (! member_init_ok_or_else (field
, basetype
, IDENTIFIER_POINTER (name
)))
1037 /* now see if there is a constructor for this type
1038 which will take these args. */
1040 if (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (field
)))
1042 tree parmtypes
, fndecl
;
1044 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1046 /* just know that we've seen something for this node */
1047 DECL_INITIAL (exp
) = error_mark_node
;
1048 TREE_USED (exp
) = 1;
1050 type
= TYPE_MAIN_VARIANT (TREE_TYPE (field
));
1051 parm
= build_component_ref (exp
, name
, NULL_TREE
, 0);
1053 /* Now get to the constructors. */
1054 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), 0);
1057 my_friendly_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
, 209);
1059 /* If the field is unique, we can use the parameter
1060 types to guide possible type instantiation. */
1061 if (DECL_CHAIN (fndecl
) == NULL_TREE
)
1063 /* There was a confusion here between
1064 FIELD and FNDECL. The following code
1065 should be correct, but abort is here
1067 my_friendly_abort (48);
1068 parmtypes
= FUNCTION_ARG_CHAIN (fndecl
);
1072 parmtypes
= NULL_TREE
;
1076 init
= convert_arguments (parm
, parmtypes
, NULL_TREE
, fndecl
, LOOKUP_NORMAL
);
1077 if (init
== NULL_TREE
|| TREE_TYPE (init
) != error_mark_node
)
1078 rval
= build_method_call (NULL_TREE
, ctor_identifier
, init
,
1079 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1083 if (rval
!= error_mark_node
)
1085 /* Now, fill in the first parm with our guy */
1086 TREE_VALUE (TREE_OPERAND (rval
, 1))
1087 = build_unary_op (ADDR_EXPR
, parm
, 0);
1088 TREE_TYPE (rval
) = ptr_type_node
;
1089 TREE_SIDE_EFFECTS (rval
) = 1;
1092 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
1094 parm
= build_component_ref (exp
, name
, NULL_TREE
, 0);
1095 expand_aggr_init (parm
, NULL_TREE
, 0, 0);
1096 rval
= error_mark_node
;
1099 /* Now initialize the member. It does not have to
1100 be of aggregate type to receive initialization. */
1101 if (rval
!= error_mark_node
)
1102 expand_expr_stmt (rval
);
1105 /* This is like `expand_member_init', only it stores one aggregate
1108 INIT comes in two flavors: it is either a value which
1109 is to be stored in EXP, or it is a parameter list
1110 to go to a constructor, which will operate on EXP.
1111 If INIT is not a parameter list for a constructor, then set
1112 LOOKUP_ONLYCONVERTING.
1113 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1114 the initializer, if FLAGS is 0, then it is the (init) form.
1115 If `init' is a CONSTRUCTOR, then we emit a warning message,
1116 explaining that such initializations are invalid.
1118 ALIAS_THIS is nonzero iff we are initializing something which is
1119 essentially an alias for current_class_ref. In this case, the base
1120 constructor may move it on us, and we must keep track of such
1123 If INIT resolves to a CALL_EXPR which happens to return
1124 something of the type we are looking for, then we know
1125 that we can safely use that call to perform the
1128 The virtual function table pointer cannot be set up here, because
1129 we do not really know its type.
1131 Virtual baseclass pointers are also set up here.
1133 This never calls operator=().
1135 When initializing, nothing is CONST.
1137 A default copy constructor may have to be used to perform the
1140 A constructor or a conversion operator may have to be used to
1141 perform the initialization, but not both, as it would be ambiguous. */
1144 expand_aggr_init (exp
, init
, alias_this
, flags
)
1149 tree type
= TREE_TYPE (exp
);
1150 int was_const
= TREE_READONLY (exp
);
1151 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1153 if (init
== error_mark_node
)
1156 TREE_READONLY (exp
) = 0;
1157 TREE_THIS_VOLATILE (exp
) = 0;
1159 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1160 flags
|= LOOKUP_ONLYCONVERTING
;
1162 if (TREE_CODE (type
) == ARRAY_TYPE
)
1164 /* Must arrange to initialize each element of EXP
1165 from elements of INIT. */
1166 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1167 if (TYPE_READONLY (TREE_TYPE (type
)) || TYPE_VOLATILE (TREE_TYPE (type
)))
1169 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1171 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1173 if (init
&& TREE_TYPE (init
) == NULL_TREE
)
1175 /* Handle bad initializers like:
1179 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1183 int main(int argc, char **argv) {
1184 COMPLEX zees(1.0, 0.0)[10];
1187 error ("bad array initializer");
1190 expand_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1191 init
&& comptypes (TREE_TYPE (init
), TREE_TYPE (exp
), 1));
1192 TREE_READONLY (exp
) = was_const
;
1193 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1194 TREE_TYPE (exp
) = type
;
1196 TREE_TYPE (init
) = itype
;
1200 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1201 /* just know that we've seen something for this node */
1202 TREE_USED (exp
) = 1;
1205 /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1206 constructor as parameters to an implicit GNU C++ constructor. */
1207 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
1208 && TYPE_HAS_CONSTRUCTOR (type
)
1209 && TREE_TYPE (init
) == type
)
1210 init
= CONSTRUCTOR_ELTS (init
);
1213 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1214 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1215 init
, alias_this
, LOOKUP_NORMAL
|flags
);
1216 TREE_TYPE (exp
) = type
;
1217 TREE_READONLY (exp
) = was_const
;
1218 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1222 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1229 tree type
= TREE_TYPE (exp
);
1231 /* It fails because there may not be a constructor which takes
1232 its own type as the first (or only parameter), but which does
1233 take other types via a conversion. So, if the thing initializing
1234 the expression is a unit element of type X, first try X(X&),
1235 followed by initialization by X. If neither of these work
1236 out, then look hard. */
1240 if (flag_ansi_overloading
&& init
&& TREE_CODE (init
) != TREE_LIST
1241 && (flags
& LOOKUP_ONLYCONVERTING
))
1243 /* Base subobjects should only get direct-initialization. */
1244 if (true_exp
!= exp
)
1247 /* We special-case TARGET_EXPRs here to avoid an error about
1248 private copy constructors for temporaries bound to reference vars.
1249 If the TARGET_EXPR represents a call to a function that has
1250 permission to create such objects, a reference can bind directly
1251 to the return value. An object variable must be initialized
1252 via the copy constructor, even if the call is elided. */
1253 if (! (TREE_CODE (exp
) == VAR_DECL
&& DECL_ARTIFICIAL (exp
)
1254 && TREE_CODE (init
) == TARGET_EXPR
&& TREE_TYPE (init
) == type
))
1255 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1257 expand_assignment (exp
, init
, 0, 0);
1261 if (init
== NULL_TREE
1262 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1266 init
= TREE_VALUE (parms
);
1268 else if (! flag_ansi_overloading
1269 && TREE_CODE (init
) == INDIRECT_REF
&& TREE_HAS_CONSTRUCTOR (init
)
1270 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (init
)))
1272 rval
= convert_for_initialization (exp
, type
, init
, 0, 0, 0, 0);
1273 TREE_USED (rval
) = 1;
1274 expand_expr_stmt (rval
);
1278 parms
= build_tree_list (NULL_TREE
, init
);
1280 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1282 if (true_exp
== exp
)
1283 parms
= tree_cons (NULL_TREE
, integer_one_node
, parms
);
1285 parms
= tree_cons (NULL_TREE
, integer_zero_node
, parms
);
1286 flags
|= LOOKUP_HAS_IN_CHARGE
;
1289 if (flag_ansi_overloading
)
1291 rval
= build_method_call (exp
, ctor_identifier
,
1292 parms
, binfo
, flags
);
1293 expand_expr_stmt (rval
);
1297 if (init
&& TREE_CHAIN (parms
) == NULL_TREE
1298 && TYPE_HAS_TRIVIAL_INIT_REF (type
)
1299 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (init
)))
1301 rval
= build (INIT_EXPR
, type
, exp
, init
);
1302 TREE_SIDE_EFFECTS (rval
) = 1;
1303 expand_expr_stmt (rval
);
1307 if (flags
& LOOKUP_ONLYCONVERTING
)
1308 flags
|= LOOKUP_NO_CONVERSION
;
1309 rval
= build_method_call (exp
, ctor_identifier
,
1310 parms
, binfo
, flags
);
1312 /* Private, protected, or otherwise unavailable. */
1313 if (rval
== error_mark_node
)
1315 if (flags
& LOOKUP_COMPLAIN
)
1316 cp_error ("in base initialization for %sclass `%T'",
1317 TREE_VIA_VIRTUAL (binfo
) ? "virtual base " : "",
1320 else if (rval
== NULL_TREE
)
1321 my_friendly_abort (361);
1324 /* p. 222: if the base class assigns to `this', then that
1325 value is used in the derived class. */
1326 if ((flag_this_is_variable
& 1) && alias_this
)
1328 TREE_TYPE (rval
) = TREE_TYPE (current_class_ptr
);
1329 expand_assignment (current_class_ptr
, rval
, 0, 0);
1332 expand_expr_stmt (rval
);
1337 /* This function is responsible for initializing EXP with INIT
1340 BINFO is the binfo of the type for who we are performing the
1341 initialization. For example, if W is a virtual base class of A and B,
1343 If we are initializing B, then W must contain B's W vtable, whereas
1344 were we initializing C, W must contain C's W vtable.
1346 TRUE_EXP is nonzero if it is the true expression being initialized.
1347 In this case, it may be EXP, or may just contain EXP. The reason we
1348 need this is because if EXP is a base element of TRUE_EXP, we
1349 don't necessarily know by looking at EXP where its virtual
1350 baseclass fields should really be pointing. But we do know
1351 from TRUE_EXP. In constructors, we don't know anything about
1352 the value being initialized.
1354 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1356 FLAGS is just passes to `build_method_call'. See that function for
1360 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1367 tree type
= TREE_TYPE (exp
);
1368 tree init_type
= NULL_TREE
;
1370 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1372 /* Use a function returning the desired type to initialize EXP for us.
1373 If the function is a constructor, and its first argument is
1374 NULL_TREE, know that it was meant for us--just slide exp on
1375 in and expand the constructor. Constructors now come
1378 if (init
&& TREE_CODE (exp
) == VAR_DECL
1379 && TREE_CODE (init
) == CONSTRUCTOR
1380 && TREE_HAS_CONSTRUCTOR (init
))
1382 tree t
= store_init_value (exp
, init
);
1385 expand_decl_init (exp
);
1388 t
= build (INIT_EXPR
, type
, exp
, init
);
1389 TREE_SIDE_EFFECTS (t
) = 1;
1390 expand_expr_stmt (t
);
1394 if (init
&& ! flag_ansi_overloading
)
1396 tree init_list
= NULL_TREE
;
1398 if (TREE_CODE (init
) == TREE_LIST
)
1401 if (TREE_CHAIN (init
) == NULL_TREE
)
1402 init
= TREE_VALUE (init
);
1405 init_type
= TREE_TYPE (init
);
1407 if (TREE_CODE (init
) != TREE_LIST
)
1409 if (init_type
== error_mark_node
)
1412 /* This happens when we use C++'s functional cast notation.
1413 If the types match, then just use the TARGET_EXPR
1414 directly. Otherwise, we need to create the initializer
1415 separately from the object being initialized. */
1416 if (TREE_CODE (init
) == TARGET_EXPR
)
1418 if (TYPE_MAIN_VARIANT (init_type
) == TYPE_MAIN_VARIANT (type
))
1420 if (TREE_CODE (exp
) == VAR_DECL
1421 || TREE_CODE (exp
) == RESULT_DECL
)
1422 /* Unify the initialization targets. */
1423 DECL_RTL (TREE_OPERAND (init
, 0)) = DECL_RTL (exp
);
1425 DECL_RTL (TREE_OPERAND (init
, 0)) = expand_expr (exp
, NULL_RTX
, VOIDmode
, 0);
1427 expand_expr_stmt (init
);
1432 if (init_type
== type
&& TREE_CODE (init
) == CALL_EXPR
)
1434 /* A CALL_EXPR is a legitimate form of initialization, so
1435 we should not print this warning message. */
1437 expand_assignment (exp
, init
, 0, 0);
1438 if (exp
== DECL_RESULT (current_function_decl
))
1440 /* Failing this assertion means that the return value
1441 from receives multiple initializations. */
1442 my_friendly_assert (DECL_INITIAL (exp
) == NULL_TREE
1443 || DECL_INITIAL (exp
) == error_mark_node
,
1445 DECL_INITIAL (exp
) = init
;
1449 else if (init_type
== type
1450 && TREE_CODE (init
) == COND_EXPR
)
1452 /* Push value to be initialized into the cond, where possible.
1453 Avoid spurious warning messages when initializing the
1454 result of this function. */
1455 TREE_OPERAND (init
, 1)
1456 = build_modify_expr (exp
, INIT_EXPR
, TREE_OPERAND (init
, 1));
1457 if (exp
== DECL_RESULT (current_function_decl
))
1458 DECL_INITIAL (exp
) = NULL_TREE
;
1459 TREE_OPERAND (init
, 2)
1460 = build_modify_expr (exp
, INIT_EXPR
, TREE_OPERAND (init
, 2));
1461 if (exp
== DECL_RESULT (current_function_decl
))
1462 DECL_INITIAL (exp
) = init
;
1463 TREE_SIDE_EFFECTS (init
) = 1;
1464 expand_expr (init
, const0_rtx
, VOIDmode
, 0);
1470 /* We did not know what we were initializing before. Now we do. */
1471 if (TREE_CODE (init
) == TARGET_EXPR
)
1473 tree tmp
= TREE_OPERAND (TREE_OPERAND (init
, 1), 1);
1475 if (tmp
&& TREE_CODE (TREE_VALUE (tmp
)) == NOP_EXPR
1476 && TREE_OPERAND (TREE_VALUE (tmp
), 0) == integer_zero_node
)
1478 /* In order for this to work for RESULT_DECLs, if their
1479 type has a constructor, then they must be BLKmode
1480 so that they will be meaningfully addressable. */
1481 tree arg
= build_unary_op (ADDR_EXPR
, exp
, 0);
1482 init
= TREE_OPERAND (init
, 1);
1483 init
= build (CALL_EXPR
, build_pointer_type (TREE_TYPE (init
)),
1484 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), NULL_TREE
);
1485 TREE_SIDE_EFFECTS (init
) = 1;
1486 TREE_VALUE (TREE_OPERAND (init
, 1))
1487 = convert_pointer_to (TREE_TYPE (TREE_TYPE (TREE_VALUE (tmp
))), arg
);
1491 expand_assignment (current_function_decl
, init
, 0, 0);
1494 if (exp
== DECL_RESULT (current_function_decl
))
1496 if (DECL_INITIAL (DECL_RESULT (current_function_decl
)))
1497 fatal ("return value from function receives multiple initializations");
1498 DECL_INITIAL (exp
) = init
;
1500 expand_expr_stmt (init
);
1505 /* Handle this case: when calling a constructor: xyzzy foo(bar);
1506 which really means: xyzzy foo = bar; Ugh!
1508 More useful for this case: xyzzy *foo = new xyzzy (bar); */
1510 if (! TYPE_NEEDS_CONSTRUCTING (type
) && ! IS_AGGR_TYPE (type
))
1512 if (init_list
&& TREE_CHAIN (init_list
))
1514 warning ("initializer list being treated as compound expression");
1515 init
= cp_convert (type
, build_compound_expr (init_list
));
1516 if (init
== error_mark_node
)
1520 expand_assignment (exp
, init
, 0, 0);
1525 /* If this is copy-initialization, see whether we can go through a
1526 type conversion operator. */
1527 if (TREE_CODE (init
) != TREE_LIST
&& (flags
& LOOKUP_ONLYCONVERTING
))
1529 tree ttype
= TREE_CODE (init_type
) == REFERENCE_TYPE
1530 ? TREE_TYPE (init_type
) : init_type
;
1532 if (ttype
!= type
&& IS_AGGR_TYPE (ttype
))
1534 tree rval
= build_type_conversion (CONVERT_EXPR
, type
, init
, 1);
1538 /* See if there is a constructor for``type'' that takes a
1539 ``ttype''-typed object. */
1540 tree parms
= build_tree_list (NULL_TREE
, init
);
1541 tree as_cons
= NULL_TREE
;
1542 if (TYPE_HAS_CONSTRUCTOR (type
))
1543 as_cons
= build_method_call (exp
, ctor_identifier
,
1545 LOOKUP_SPECULATIVELY
|LOOKUP_NO_CONVERSION
);
1546 if (as_cons
!= NULL_TREE
&& as_cons
!= error_mark_node
)
1547 /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */
1548 cp_error ("ambiguity between conversion to `%T' and constructor",
1551 if (rval
!= error_mark_node
)
1552 expand_aggr_init_1 (binfo
, true_exp
, exp
, rval
, alias_this
, flags
);
1559 /* We know that expand_default_init can handle everything we want
1561 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
);
1564 /* Report an error if NAME is not the name of a user-defined,
1565 aggregate type. If OR_ELSE is nonzero, give an error message. */
1568 is_aggr_typedef (name
, or_else
)
1574 if (name
== error_mark_node
)
1577 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1578 type
= IDENTIFIER_TYPE_VALUE (name
);
1582 cp_error ("`%T' is not an aggregate typedef", name
);
1586 if (! IS_AGGR_TYPE (type
)
1587 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1590 cp_error ("`%T' is not an aggregate type", type
);
1596 /* Report an error if TYPE is not a user-defined, aggregate type. If
1597 OR_ELSE is nonzero, give an error message. */
1600 is_aggr_type (type
, or_else
)
1604 if (type
== error_mark_node
)
1607 if (! IS_AGGR_TYPE (type
)
1608 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1611 cp_error ("`%T' is not an aggregate type", type
);
1617 /* Like is_aggr_typedef, but returns typedef if successful. */
1620 get_aggr_from_typedef (name
, or_else
)
1626 if (name
== error_mark_node
)
1629 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1630 type
= IDENTIFIER_TYPE_VALUE (name
);
1634 cp_error ("`%T' fails to be an aggregate typedef", name
);
1638 if (! IS_AGGR_TYPE (type
)
1639 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1642 cp_error ("type `%T' is of non-aggregate type", type
);
1649 get_type_value (name
)
1652 if (name
== error_mark_node
)
1655 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1656 return IDENTIFIER_TYPE_VALUE (name
);
1662 /* This code could just as well go in `class.c', but is placed here for
1665 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1666 the appropriate function call. */
1669 build_member_call (type
, name
, parmlist
)
1670 tree type
, name
, parmlist
;
1673 tree method_name
= name
;
1675 int dont_use_this
= 0;
1676 tree basetype_path
, decl
;
1678 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1680 method_name
= TREE_OPERAND (method_name
, 0);
1684 /* This shouldn't be here, and build_member_call shouldn't appear in
1686 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1687 && get_aggr_from_typedef (type
, 0) == 0)
1689 tree ns
= lookup_name (type
, 0);
1690 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1692 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1696 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1697 return error_mark_node
;
1699 /* An operator we did not like. */
1700 if (name
== NULL_TREE
)
1701 return error_mark_node
;
1705 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1707 return error_mark_node
;
1710 /* No object? Then just fake one up, and let build_method_call
1711 figure out what to do. */
1712 if (current_class_type
== 0
1713 || get_base_distance (type
, current_class_type
, 0, &basetype_path
) == -1)
1718 basetype_path
= TYPE_BINFO (type
);
1719 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1721 else if (current_class_ptr
== 0)
1724 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1728 tree olddecl
= current_class_ptr
;
1729 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1730 if (oldtype
!= type
)
1732 tree newtype
= build_type_variant (type
, TYPE_READONLY (oldtype
),
1733 TYPE_VOLATILE (oldtype
));
1734 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1740 decl
= build_indirect_ref (decl
, NULL_PTR
);
1742 if (method_name
== constructor_name (type
)
1743 || method_name
== constructor_name_full (type
))
1744 return build_functional_cast (type
, parmlist
);
1745 if (t
= lookup_fnfields (basetype_path
, method_name
, 0))
1746 return build_method_call (decl
, method_name
, parmlist
, basetype_path
,
1747 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1748 if (TREE_CODE (name
) == IDENTIFIER_NODE
1749 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1751 if (t
== error_mark_node
)
1752 return error_mark_node
;
1753 if (TREE_CODE (t
) == FIELD_DECL
)
1757 cp_error ("invalid use of non-static field `%D'", t
);
1758 return error_mark_node
;
1760 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1762 else if (TREE_CODE (t
) == VAR_DECL
)
1766 cp_error ("invalid use of member `%D'", t
);
1767 return error_mark_node
;
1769 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
))
1770 && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (decl
)))
1771 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
, parmlist
, NULL_TREE
);
1772 return build_function_call (decl
, parmlist
);
1776 cp_error ("no method `%T::%D'", type
, name
);
1777 return error_mark_node
;
1781 /* Build a reference to a member of an aggregate. This is not a
1782 C++ `&', but really something which can have its address taken,
1783 and then act as a pointer to member, for example TYPE :: FIELD
1784 can have its address taken by saying & TYPE :: FIELD.
1786 @@ Prints out lousy diagnostics for operator <typename>
1789 @@ This function should be rewritten and placed in search.c. */
1792 build_offset_ref (type
, name
)
1795 tree decl
, fnfields
, fields
, t
= error_mark_node
;
1796 tree basebinfo
= NULL_TREE
;
1799 if (processing_template_decl
)
1800 return build_min_nt (SCOPE_REF
, type
, name
);
1802 /* Handle namespace names fully here. */
1803 if (TREE_CODE (type
) == IDENTIFIER_NODE
1804 && get_aggr_from_typedef (type
, 0) == 0)
1806 tree ns
= lookup_name (type
, 0);
1808 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1810 val
= lookup_namespace_name (ns
, name
);
1813 cp_error ("namespace `%D' has no member named `%D'", ns
, name
);
1814 return error_mark_node
;
1818 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1819 return error_mark_node
;
1821 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1824 name
= TREE_OPERAND (name
, 0);
1827 if (name
== constructor_name_full (type
))
1828 name
= constructor_name (type
);
1830 if (TYPE_SIZE (complete_type (type
)) == 0)
1832 if (type
== current_class_type
)
1833 t
= IDENTIFIER_CLASS_VALUE (name
);
1838 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1840 return error_mark_node
;
1842 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == VAR_DECL
1843 || TREE_CODE (t
) == CONST_DECL
)
1848 if (TREE_CODE (t
) == FIELD_DECL
)
1849 sorry ("use of member in incomplete aggregate type");
1850 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1851 sorry ("use of member function in incomplete aggregate type");
1853 my_friendly_abort (52);
1854 return error_mark_node
;
1857 if (current_class_type
== 0
1858 || get_base_distance (type
, current_class_type
, 0, &basebinfo
) == -1)
1860 basebinfo
= TYPE_BINFO (type
);
1861 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1863 else if (current_class_ptr
== 0)
1864 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1866 decl
= current_class_ref
;
1868 if (constructor_name (BINFO_TYPE (basebinfo
)) == name
)
1870 name
= dtor_identifier
;
1872 name
= ctor_identifier
;
1875 my_friendly_abort (999);
1878 fnfields
= lookup_fnfields (basebinfo
, name
, 1);
1879 fields
= lookup_field (basebinfo
, name
, 0, 0);
1881 if (fields
== error_mark_node
|| fnfields
== error_mark_node
)
1882 return error_mark_node
;
1884 /* A lot of this logic is now handled in lookup_field and
1888 extern int flag_save_memoized_contexts
;
1889 basebinfo
= TREE_PURPOSE (fnfields
);
1891 /* Go from the TREE_BASELINK to the member function info. */
1892 t
= TREE_VALUE (fnfields
);
1894 if (DECL_CHAIN (t
) == NULL_TREE
)
1898 /* unique functions are handled easily. */
1899 access
= compute_access (basebinfo
, t
);
1900 if (access
== access_protected_node
)
1902 cp_error_at ("member function `%#D' is protected", t
);
1903 error ("in this context");
1904 return error_mark_node
;
1906 if (access
== access_private_node
)
1908 cp_error_at ("member function `%#D' is private", t
);
1909 error ("in this context");
1910 return error_mark_node
;
1913 return build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1916 /* FNFIELDS is most likely allocated on the search_obstack,
1917 which will go away after this class scope. If we need
1918 to save this value for later (either for memoization
1919 or for use as an initializer for a static variable), then
1922 ??? The smart thing to do for the case of saving initializers
1923 is to resolve them before we're done with this scope. */
1924 if (!TREE_PERMANENT (fnfields
)
1925 && ((flag_save_memoized_contexts
&& global_bindings_p ())
1926 || ! allocation_temporary_p ()))
1927 fnfields
= copy_list (fnfields
);
1929 t
= build_tree_list (error_mark_node
, fnfields
);
1930 TREE_TYPE (t
) = build_offset_type (type
, unknown_type_node
);
1934 /* Now that we know we are looking for a field, see if we
1935 have access to that field. Lookup_field will give us the
1938 t
= lookup_field (basebinfo
, name
, 1, 0);
1940 if (t
== error_mark_node
)
1941 return error_mark_node
;
1945 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1946 return error_mark_node
;
1949 if (TREE_CODE (t
) == TYPE_DECL
)
1954 /* static class members and class-specific enum
1955 values can be returned without further ado. */
1956 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1962 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_BIT_FIELD (t
))
1964 cp_error ("illegal pointer to bit field `%D'", t
);
1965 return error_mark_node
;
1968 /* static class functions too. */
1969 if (TREE_CODE (t
) == FUNCTION_DECL
1970 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
1971 my_friendly_abort (53);
1973 /* In member functions, the form `type::name' is no longer
1974 equivalent to `this->type::name', at least not until
1975 resolve_offset_ref. */
1976 return build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
1979 /* If a OFFSET_REF made it through to here, then it did
1980 not have its address taken. */
1983 resolve_offset_ref (exp
)
1986 tree type
= TREE_TYPE (exp
);
1987 tree base
= NULL_TREE
;
1989 tree basetype
, addr
;
1991 if (TREE_CODE (exp
) == TREE_LIST
)
1992 return build_unary_op (ADDR_EXPR
, exp
, 0);
1994 if (TREE_CODE (exp
) == OFFSET_REF
)
1996 member
= TREE_OPERAND (exp
, 1);
1997 base
= TREE_OPERAND (exp
, 0);
2001 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
2002 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
2004 error ("object missing in use of pointer-to-member construct");
2005 return error_mark_node
;
2008 type
= TREE_TYPE (type
);
2009 base
= current_class_ref
;
2012 if ((TREE_CODE (member
) == VAR_DECL
2013 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
2014 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
2015 || TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
2017 /* These were static members. */
2018 if (mark_addressable (member
) == 0)
2019 return error_mark_node
;
2023 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
2024 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
2027 /* Syntax error can cause a member which should
2028 have been seen as static to be grok'd as non-static. */
2029 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
2031 if (TREE_ADDRESSABLE (member
) == 0)
2033 cp_error_at ("member `%D' is non-static but referenced as a static member",
2035 error ("at this point in file");
2036 TREE_ADDRESSABLE (member
) = 1;
2038 return error_mark_node
;
2041 /* The first case is really just a reference to a member of `this'. */
2042 if (TREE_CODE (member
) == FIELD_DECL
2043 && (base
== current_class_ref
2044 || (TREE_CODE (base
) == NOP_EXPR
2045 && TREE_OPERAND (base
, 0) == error_mark_node
)))
2047 tree basetype_path
, access
;
2049 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
2050 basetype
= TYPE_OFFSET_BASETYPE (type
);
2052 basetype
= DECL_CONTEXT (member
);
2054 base
= current_class_ptr
;
2056 if (get_base_distance (basetype
, TREE_TYPE (TREE_TYPE (base
)), 0, &basetype_path
) < 0)
2058 error_not_base_type (basetype
, TREE_TYPE (TREE_TYPE (base
)));
2059 return error_mark_node
;
2061 addr
= convert_pointer_to (basetype
, base
);
2062 access
= compute_access (basetype_path
, member
);
2063 if (access
== access_public_node
)
2064 return build (COMPONENT_REF
, TREE_TYPE (member
),
2065 build_indirect_ref (addr
, NULL_PTR
), member
);
2066 if (access
== access_protected_node
)
2068 cp_error_at ("member `%D' is protected", member
);
2069 error ("in this context");
2070 return error_mark_node
;
2072 if (access
== access_private_node
)
2074 cp_error_at ("member `%D' is private", member
);
2075 error ("in this context");
2076 return error_mark_node
;
2078 my_friendly_abort (55);
2081 /* Ensure that we have an object. */
2082 if (TREE_CODE (base
) == NOP_EXPR
2083 && TREE_OPERAND (base
, 0) == error_mark_node
)
2084 addr
= error_mark_node
;
2087 /* If this is a reference to a member function, then return the
2088 address of the member function (which may involve going
2089 through the object's vtable), otherwise, return an expression
2090 for the dereferenced pointer-to-member construct. */
2091 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
2094 if (TREE_CODE (TREE_TYPE (member
)) == OFFSET_TYPE
)
2096 if (addr
== error_mark_node
)
2098 cp_error ("object missing in `%E'", exp
);
2099 return error_mark_node
;
2102 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (member
));
2103 addr
= convert_pointer_to (basetype
, addr
);
2104 member
= cp_convert (ptrdiff_type_node
,
2105 build_unary_op (ADDR_EXPR
, member
, 0));
2107 /* Pointer to data mebers are offset by one, so that a null
2108 pointer with a real value of 0 is distinguishable from an
2109 offset of the first member of a structure. */
2110 member
= build_binary_op (MINUS_EXPR
, member
,
2111 cp_convert (ptrdiff_type_node
, integer_one_node
),
2114 return build1 (INDIRECT_REF
, type
,
2115 build (PLUS_EXPR
, build_pointer_type (type
),
2118 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
2120 return get_member_function_from_ptrfunc (&addr
, member
);
2122 my_friendly_abort (56);
2127 /* Return either DECL or its known constant value (if it has one). */
2130 decl_constant_value (decl
)
2133 if (! TREE_THIS_VOLATILE (decl
)
2135 /* These may be necessary for C, but they break C++. */
2136 ! TREE_PUBLIC (decl
)
2137 /* Don't change a variable array bound or initial value to a constant
2138 in a place where a variable is invalid. */
2141 && DECL_INITIAL (decl
) != 0
2142 && DECL_INITIAL (decl
) != error_mark_node
2143 /* This is invalid if initial value is not constant.
2144 If it has either a function call, a memory reference,
2145 or a variable, then re-evaluating it could give different results. */
2146 && TREE_CONSTANT (DECL_INITIAL (decl
))
2147 /* Check for cases where this is sub-optimal, even though valid. */
2148 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
2150 /* We must allow this to work outside of functions so that
2151 static constants can be used for array sizes. */
2152 && current_function_decl
!= 0
2153 && DECL_MODE (decl
) != BLKmode
2156 return DECL_INITIAL (decl
);
2160 /* Common subroutines of build_new and build_vec_delete. */
2162 /* Common interface for calling "builtin" functions that are not
2166 build_builtin_call (type
, node
, arglist
)
2171 tree rval
= build (CALL_EXPR
, type
, node
, arglist
, NULL_TREE
);
2172 TREE_SIDE_EFFECTS (rval
) = 1;
2173 assemble_external (TREE_OPERAND (node
, 0));
2174 TREE_USED (TREE_OPERAND (node
, 0)) = 1;
2178 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
2179 (which needs to go through some sort of groktypename) or it
2180 is the name of the class we are newing. INIT is an initialization value.
2181 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
2182 If INIT is void_type_node, it means do *not* call a constructor
2185 For types with constructors, the data returned is initialized
2186 by the appropriate constructor.
2188 Whether the type has a constructor or not, if it has a pointer
2189 to a virtual function table, then that pointer is set up
2192 Unless I am mistaken, a call to new () will return initialized
2193 data regardless of whether the constructor itself is private or
2194 not. NOPE; new fails if the constructor is private (jcm).
2196 Note that build_new does nothing to assure that any special
2197 alignment requirements of the type are met. Rather, it leaves
2198 it up to malloc to do the right thing. Otherwise, folding to
2199 the right alignment cal cause problems if the user tries to later
2200 free the memory returned by `new'.
2202 PLACEMENT is the `placement' list for user-defined operator new (). */
2204 extern int flag_check_new
;
2207 build_new (placement
, decl
, init
, use_global_new
)
2212 tree type
, true_type
, size
, rval
;
2216 enum tree_code code
= NEW_EXPR
;
2217 int use_cookie
, nothrow
, check_new
;
2219 tree pending_sizes
= NULL_TREE
;
2221 if (decl
== error_mark_node
)
2222 return error_mark_node
;
2224 if (TREE_CODE (decl
) == TREE_LIST
)
2226 tree absdcl
= TREE_VALUE (decl
);
2227 tree last_absdcl
= NULL_TREE
;
2228 int old_immediate_size_expand
;
2230 if (current_function_decl
2231 && DECL_CONSTRUCTOR_P (current_function_decl
))
2233 old_immediate_size_expand
= immediate_size_expand
;
2234 immediate_size_expand
= 0;
2237 nelts
= integer_one_node
;
2239 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
2240 my_friendly_abort (215);
2241 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2243 last_absdcl
= absdcl
;
2244 absdcl
= TREE_OPERAND (absdcl
, 0);
2247 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2249 /* probably meant to be a vec new */
2252 while (TREE_OPERAND (absdcl
, 0)
2253 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2255 last_absdcl
= absdcl
;
2256 absdcl
= TREE_OPERAND (absdcl
, 0);
2260 this_nelts
= TREE_OPERAND (absdcl
, 1);
2261 if (this_nelts
!= error_mark_node
)
2263 if (this_nelts
== NULL_TREE
)
2264 error ("new of array type fails to specify size");
2265 else if (processing_template_decl
)
2268 absdcl
= TREE_OPERAND (absdcl
, 0);
2272 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2273 absdcl
= TREE_OPERAND (absdcl
, 0);
2274 if (this_nelts
== integer_zero_node
)
2276 warning ("zero size array reserves no space");
2277 nelts
= integer_zero_node
;
2280 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2284 nelts
= integer_zero_node
;
2288 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2290 TREE_VALUE (decl
) = absdcl
;
2292 type
= true_type
= groktypename (decl
);
2293 if (! type
|| type
== error_mark_node
)
2295 immediate_size_expand
= old_immediate_size_expand
;
2296 return error_mark_node
;
2299 if (current_function_decl
2300 && DECL_CONSTRUCTOR_P (current_function_decl
))
2302 pending_sizes
= get_pending_sizes ();
2303 immediate_size_expand
= old_immediate_size_expand
;
2306 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2308 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2310 /* An aggregate type. */
2311 type
= IDENTIFIER_TYPE_VALUE (decl
);
2312 decl
= TYPE_MAIN_DECL (type
);
2316 /* A builtin type. */
2317 decl
= lookup_name (decl
, 1);
2318 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2319 type
= TREE_TYPE (decl
);
2323 else if (TREE_CODE (decl
) == TYPE_DECL
)
2325 type
= TREE_TYPE (decl
);
2332 decl
= TYPE_MAIN_DECL (type
);
2335 if (processing_template_decl
)
2339 t
= min_tree_cons (min_tree_cons (NULL_TREE
, type
, NULL_TREE
),
2340 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2345 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2346 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2350 /* ``A reference cannot be created by the new operator. A reference
2351 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2352 returned by new.'' ARM 5.3.3 */
2353 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2355 error ("new cannot be applied to a reference type");
2356 type
= true_type
= TREE_TYPE (type
);
2359 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2361 error ("new cannot be applied to a function type");
2362 return error_mark_node
;
2365 /* When the object being created is an array, the new-expression yields a
2366 pointer to the initial element (if any) of the array. For example,
2367 both new int and new int[10] return an int*. 5.3.4. */
2368 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2370 nelts
= array_type_nelts_top (type
);
2372 type
= true_type
= TREE_TYPE (type
);
2375 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
))
2376 type
= TYPE_MAIN_VARIANT (type
);
2378 /* If our base type is an array, then make sure we know how many elements
2380 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2382 tree this_nelts
= array_type_nelts_top (true_type
);
2383 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2384 true_type
= TREE_TYPE (true_type
);
2387 if (TYPE_SIZE (complete_type (true_type
)) == 0)
2389 incomplete_type_error (0, true_type
);
2390 return error_mark_node
;
2394 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2397 size
= size_in_bytes (type
);
2399 if (true_type
== void_type_node
)
2401 error ("invalid type `void' for new");
2402 return error_mark_node
;
2405 if (TYPE_LANG_SPECIFIC (true_type
)
2406 && CLASSTYPE_ABSTRACT_VIRTUALS (true_type
))
2408 abstract_virtuals_error (NULL_TREE
, true_type
);
2409 return error_mark_node
;
2412 if (TYPE_LANG_SPECIFIC (true_type
) && IS_SIGNATURE (true_type
))
2414 signature_error (NULL_TREE
, true_type
);
2415 return error_mark_node
;
2418 /* If the first placement arg is of type nothrow_t, it's allowed to
2419 return 0 on allocation failure. */
2420 nothrow
= (placement
&& TREE_VALUE (placement
)
2421 && TREE_TYPE (TREE_VALUE (placement
))
2422 && IS_AGGR_TYPE (TREE_TYPE (TREE_VALUE (placement
)))
2423 && (TYPE_IDENTIFIER (TREE_TYPE (TREE_VALUE (placement
)))
2424 == get_identifier ("nothrow_t")));
2426 check_new
= flag_check_new
|| nothrow
;
2429 /* Get a little extra space to store a couple of things before the new'ed
2430 array, if this isn't the default placement new. */
2432 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2433 && ! (placement
&& ! TREE_CHAIN (placement
)
2434 && TREE_TYPE (TREE_VALUE (placement
)) == ptr_type_node
));
2436 /* Get a little extra space to store a couple of things before the new'ed
2437 array, if this is either non-placement new or new (nothrow). */
2439 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2440 && (! placement
|| nothrow
));
2445 tree extra
= BI_header_size
;
2447 size
= size_binop (PLUS_EXPR
, size
, extra
);
2452 code
= VEC_NEW_EXPR
;
2454 if (init
&& pedantic
)
2455 cp_pedwarn ("initialization in array new");
2458 /* Allocate the object. */
2459 if (! use_global_new
&& TYPE_LANG_SPECIFIC (true_type
)
2460 && (TYPE_GETS_NEW (true_type
) & (1 << has_array
)))
2461 rval
= build_opfncall (code
, LOOKUP_NORMAL
,
2462 build_pointer_type (true_type
), size
, placement
);
2465 rval
= build_opfncall (code
, LOOKUP_GLOBAL
|LOOKUP_COMPLAIN
,
2466 ptr_type_node
, size
, placement
);
2467 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2469 else if (! has_array
&& flag_this_is_variable
> 0
2470 && TYPE_NEEDS_CONSTRUCTING (true_type
) && init
!= void_type_node
)
2472 if (init
== NULL_TREE
|| TREE_CODE (init
) == TREE_LIST
)
2476 error ("constructors take parameter lists");
2477 return error_mark_node
;
2482 rval
= build_builtin_call (build_pointer_type (true_type
),
2483 has_array
? BIVN
: BIN
,
2484 build_tree_list (NULL_TREE
, size
));
2485 TREE_CALLS_NEW (rval
) = 1;
2488 if (check_new
&& rval
)
2489 alloc_expr
= rval
= save_expr (rval
);
2491 alloc_expr
= NULL_TREE
;
2493 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2494 sure we have some extra bytes in that case for the BI_header_size
2495 cookies? And how does that interact with the code below? (mrs) */
2496 /* Finish up some magic for new'ed arrays */
2497 if (use_cookie
&& rval
!= NULL_TREE
)
2499 tree extra
= BI_header_size
;
2501 rval
= cp_convert (ptr_type_node
, rval
); /* convert to void * first */
2502 rval
= cp_convert (string_type_node
, rval
); /* lets not add void* and ints */
2503 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, extra
, 1));
2504 /* Store header info. */
2505 cookie
= build_indirect_ref (build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
2506 rval
, extra
), NULL_PTR
);
2507 exp1
= build (MODIFY_EXPR
, void_type_node
,
2508 build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0),
2510 TREE_SIDE_EFFECTS (exp1
) = 1;
2511 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2512 TREE_CALLS_NEW (rval
) = 1;
2513 TREE_SIDE_EFFECTS (rval
) = 1;
2514 rval
= build_compound_expr (tree_cons (NULL_TREE
, exp1
,
2515 build_tree_list (NULL_TREE
, rval
)));
2518 if (rval
== error_mark_node
)
2519 return error_mark_node
;
2521 /* Don't call any constructors or do any initialization. */
2522 if (init
== void_type_node
)
2525 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2527 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2528 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2530 /* New 2.0 interpretation: `new int (10)' means
2531 allocate an int, and initialize it with 10. */
2534 rval
= save_expr (rval
);
2535 deref
= build_indirect_ref (rval
, NULL_PTR
);
2536 TREE_READONLY (deref
) = 0;
2538 if (TREE_CHAIN (init
) != NULL_TREE
)
2539 pedwarn ("initializer list being treated as compound expression");
2540 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2542 pedwarn ("initializer list appears where operand should be used");
2543 init
= TREE_OPERAND (init
, 1);
2545 init
= build_compound_expr (init
);
2547 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2548 "new", NULL_TREE
, 0);
2549 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2550 build_modify_expr (deref
, NOP_EXPR
, init
),
2552 TREE_NO_UNUSED_WARNING (rval
) = 1;
2553 TREE_SIDE_EFFECTS (rval
) = 1;
2554 TREE_CALLS_NEW (rval
) = 1;
2556 else if (! has_array
)
2559 /* Constructors are never virtual. If it has an initialization, we
2560 need to complain if we aren't allowed to use the ctor that took
2562 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2564 if (rval
&& TYPE_USES_VIRTUAL_BASECLASSES (true_type
))
2566 init
= tree_cons (NULL_TREE
, integer_one_node
, init
);
2567 flags
|= LOOKUP_HAS_IN_CHARGE
;
2572 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2573 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2575 newrval
= build_method_call (newrval
, ctor_identifier
,
2576 init
, TYPE_BINFO (true_type
), flags
);
2581 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2584 rval
= error_mark_node
;
2587 rval
= build (VEC_INIT_EXPR
, TREE_TYPE (rval
),
2588 save_expr (rval
), init
, nelts
);
2590 else if (current_function_decl
== NULL_TREE
)
2592 extern tree static_aggregates
;
2594 /* In case of static initialization, SAVE_EXPR is good enough. */
2595 rval
= save_expr (rval
);
2596 rval
= copy_to_permanent (rval
);
2597 init
= copy_to_permanent (init
);
2598 init
= expand_vec_init (decl
, rval
,
2599 build_binary_op (MINUS_EXPR
, nelts
,
2600 integer_one_node
, 1),
2602 init
= copy_to_permanent (init
);
2603 static_aggregates
= perm_tree_cons (init
, rval
, static_aggregates
);
2607 /* Have to wrap this in RTL_EXPR for two cases:
2608 in base or member initialization and if we
2609 are a branch of a ?: operator. Since we
2610 can't easily know the latter, just do it always. */
2611 tree xval
= make_node (RTL_EXPR
);
2613 /* If we want to check the value of the allocation expression,
2614 and the number of elements in the array is not a constant, we
2615 *must* expand the SAVE_EXPR for nelts in alloc_expr before we
2616 expand it in the actual initialization. So we need to build up
2617 an RTL_EXPR for alloc_expr. Sigh. */
2618 if (alloc_expr
&& ! TREE_CONSTANT (nelts
))
2620 tree xval
= make_node (RTL_EXPR
);
2622 TREE_TYPE (xval
) = TREE_TYPE (alloc_expr
);
2623 do_pending_stack_adjust ();
2624 start_sequence_for_rtl_expr (xval
);
2626 rtxval
= expand_expr (alloc_expr
, NULL_RTX
, VOIDmode
, 0);
2627 do_pending_stack_adjust ();
2628 TREE_SIDE_EFFECTS (xval
) = 1;
2629 RTL_EXPR_SEQUENCE (xval
) = get_insns ();
2631 RTL_EXPR_RTL (xval
) = rtxval
;
2632 TREE_TYPE (xval
) = TREE_TYPE (alloc_expr
);
2636 TREE_TYPE (xval
) = TREE_TYPE (rval
);
2637 do_pending_stack_adjust ();
2638 start_sequence_for_rtl_expr (xval
);
2640 /* As a matter of principle, `start_sequence' should do this. */
2643 rval
= save_expr (rval
);
2644 rval
= expand_vec_init (decl
, rval
,
2645 build_binary_op (MINUS_EXPR
, nelts
,
2646 integer_one_node
, 1),
2649 do_pending_stack_adjust ();
2651 TREE_SIDE_EFFECTS (xval
) = 1;
2652 TREE_CALLS_NEW (xval
) = 1;
2653 RTL_EXPR_SEQUENCE (xval
) = get_insns ();
2656 if (TREE_CODE (rval
) == SAVE_EXPR
)
2658 /* Errors may cause this to not get evaluated. */
2659 if (SAVE_EXPR_RTL (rval
) == 0)
2660 SAVE_EXPR_RTL (rval
) = const0_rtx
;
2661 RTL_EXPR_RTL (xval
) = SAVE_EXPR_RTL (rval
);
2665 my_friendly_assert (TREE_CODE (rval
) == VAR_DECL
, 217);
2666 RTL_EXPR_RTL (xval
) = DECL_RTL (rval
);
2672 else if (TYPE_READONLY (true_type
))
2673 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2677 if (alloc_expr
&& rval
!= alloc_expr
)
2679 /* Did we modify the storage? */
2680 tree ifexp
= build_binary_op (NE_EXPR
, alloc_expr
,
2681 integer_zero_node
, 1);
2682 rval
= build_conditional_expr (ifexp
, rval
, alloc_expr
);
2685 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2687 /* The type of new int [3][3] is not int *, but int [3] * */
2688 rval
= build_c_cast (build_pointer_type (type
), rval
);
2692 rval
= build_compound_expr (chainon (pending_sizes
,
2693 build_tree_list (NULL_TREE
, rval
)));
2699 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,
2701 tree base
, maxindex
, type
;
2702 tree auto_delete_vec
, auto_delete
;
2703 int use_global_delete
;
2706 tree ptype
= build_pointer_type (type
= complete_type (type
));
2707 tree size_exp
= size_in_bytes (type
);
2709 /* Temporary variables used by the loop. */
2710 tree tbase
, tbase_init
;
2712 /* This is the body of the loop that implements the deletion of a
2713 single element, and moves temp variables to next elements. */
2716 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2719 /* This is the thing that governs what to do after the loop has run. */
2720 tree deallocate_expr
= 0;
2722 /* This is the BIND_EXPR which holds the outermost iterator of the
2723 loop. It is convenient to set this variable up and test it before
2724 executing any other code in the loop.
2725 This is also the containing expression returned by this function. */
2726 tree controller
= NULL_TREE
;
2728 /* This is the BLOCK to record the symbol binding for debugging. */
2731 if (! IS_AGGR_TYPE (type
) || ! TYPE_NEEDS_DESTRUCTOR (type
))
2733 loop
= integer_zero_node
;
2737 /* The below is short by BI_header_size */
2738 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2740 tbase
= build_decl (VAR_DECL
, NULL_TREE
, ptype
);
2741 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2742 fold (build (PLUS_EXPR
, ptype
,
2745 DECL_REGISTER (tbase
) = 1;
2746 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2747 TREE_SIDE_EFFECTS (controller
) = 1;
2748 block
= build_block (tbase
, NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
2749 add_block_current_level (block
);
2751 if (auto_delete
!= integer_zero_node
2752 && auto_delete
!= integer_two_node
)
2754 tree base_tbd
= cp_convert (ptype
,
2755 build_binary_op (MINUS_EXPR
,
2756 cp_convert (ptr_type_node
, base
),
2759 /* This is the real size */
2760 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2761 body
= build_tree_list (NULL_TREE
,
2762 build_x_delete (ptype
, base_tbd
,
2763 2 | use_global_delete
,
2765 body
= build (COND_EXPR
, void_type_node
,
2766 build (BIT_AND_EXPR
, integer_type_node
,
2767 auto_delete
, integer_one_node
),
2768 body
, integer_zero_node
);
2773 body
= tree_cons (NULL_TREE
,
2774 build_delete (ptype
, tbase
, auto_delete
,
2775 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2778 body
= tree_cons (NULL_TREE
,
2779 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2782 body
= tree_cons (NULL_TREE
,
2783 build (EXIT_EXPR
, void_type_node
,
2784 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2787 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2789 loop
= tree_cons (NULL_TREE
, tbase_init
,
2790 tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2791 loop
= build_compound_expr (loop
);
2794 /* If the delete flag is one, or anything else with the low bit set,
2795 delete the storage. */
2796 if (auto_delete_vec
== integer_zero_node
2797 || auto_delete_vec
== integer_two_node
)
2798 deallocate_expr
= integer_zero_node
;
2803 /* The below is short by BI_header_size */
2804 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2806 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2811 base_tbd
= cp_convert (ptype
,
2812 build_binary_op (MINUS_EXPR
,
2813 cp_convert (string_type_node
, base
),
2816 /* True size with header. */
2817 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2819 deallocate_expr
= build_x_delete (ptype
, base_tbd
,
2820 2 | use_global_delete
,
2822 if (auto_delete_vec
!= integer_one_node
)
2823 deallocate_expr
= build (COND_EXPR
, void_type_node
,
2824 build (BIT_AND_EXPR
, integer_type_node
,
2825 auto_delete_vec
, integer_one_node
),
2826 deallocate_expr
, integer_zero_node
);
2829 if (loop
&& deallocate_expr
!= integer_zero_node
)
2831 body
= tree_cons (NULL_TREE
, loop
,
2832 tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2833 body
= build_compound_expr (body
);
2838 /* Outermost wrapper: If pointer is null, punt. */
2839 body
= build (COND_EXPR
, void_type_node
,
2840 build (NE_EXPR
, boolean_type_node
, base
, integer_zero_node
),
2841 body
, integer_zero_node
);
2842 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2846 TREE_OPERAND (controller
, 1) = body
;
2850 return cp_convert (void_type_node
, body
);
2853 /* Build a tree to cleanup partially built arrays.
2854 BASE is that starting address of the array.
2855 COUNT is the count of objects that have been built, that need destroying.
2856 TYPE is the type of elements in the array. */
2859 build_array_eh_cleanup (base
, count
, type
)
2860 tree base
, count
, type
;
2862 tree expr
= build_vec_delete_1 (base
, count
, type
, integer_two_node
,
2863 integer_zero_node
, 0);
2867 /* `expand_vec_init' performs initialization of a vector of aggregate
2870 DECL is passed only for error reporting, and provides line number
2871 and source file name information.
2872 BASE is the space where the vector will be.
2873 MAXINDEX is the maximum index of the array (one less than the
2874 number of elements).
2875 INIT is the (possibly NULL) initializer.
2877 FROM_ARRAY is 0 if we should init everything with INIT
2878 (i.e., every element initialized from INIT).
2879 FROM_ARRAY is 1 if we should index into INIT in parallel
2880 with initialization of DECL.
2881 FROM_ARRAY is 2 if we should index into INIT in parallel,
2882 but use assignment instead of initialization. */
2885 expand_vec_init (decl
, base
, maxindex
, init
, from_array
)
2886 tree decl
, base
, maxindex
, init
;
2890 tree iterator
, base2
= NULL_TREE
;
2891 tree type
= TREE_TYPE (TREE_TYPE (base
));
2894 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2895 if (maxindex
== error_mark_node
)
2896 return error_mark_node
;
2898 if (current_function_decl
== NULL_TREE
)
2900 rval
= make_tree_vec (3);
2901 TREE_VEC_ELT (rval
, 0) = base
;
2902 TREE_VEC_ELT (rval
, 1) = maxindex
;
2903 TREE_VEC_ELT (rval
, 2) = init
;
2907 size
= size_in_bytes (type
);
2909 /* Set to zero in case size is <= 0. Optimizer will delete this if
2910 it is not needed. */
2911 rval
= get_temp_regvar (build_pointer_type (type
),
2912 cp_convert (build_pointer_type (type
), null_pointer_node
));
2913 base
= default_conversion (base
);
2914 base
= cp_convert (build_pointer_type (type
), base
);
2915 expand_assignment (rval
, base
, 0, 0);
2916 base
= get_temp_regvar (build_pointer_type (type
), base
);
2918 if (init
!= NULL_TREE
&& TREE_CODE (init
) == TREE_LIST
)
2919 init
= build_compound_expr (init
);
2921 if (init
!= NULL_TREE
2922 && TREE_CODE (init
) == CONSTRUCTOR
2923 && (! decl
|| TREE_TYPE (init
) == TREE_TYPE (decl
)))
2925 /* Initialization of array from {...}. */
2926 tree elts
= CONSTRUCTOR_ELTS (init
);
2927 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2928 tree baseinc
= build (PLUS_EXPR
, build_pointer_type (type
), base
, size
);
2929 int host_i
= TREE_INT_CST_LOW (maxindex
);
2931 if (IS_AGGR_TYPE (type
))
2936 expand_aggr_init (baseref
, TREE_VALUE (elts
), 0, 0);
2938 expand_assignment (base
, baseinc
, 0, 0);
2939 elts
= TREE_CHAIN (elts
);
2941 /* Initialize any elements by default if possible. */
2944 if (TYPE_NEEDS_CONSTRUCTING (type
) == 0)
2947 use_variable (DECL_RTL (base
));
2951 iterator
= get_temp_regvar (ptrdiff_type_node
,
2952 build_int_2 (host_i
, 0));
2954 goto init_by_default
;
2960 expand_assignment (baseref
, TREE_VALUE (elts
), 0, 0);
2962 expand_assignment (base
, baseinc
, 0, 0);
2963 elts
= TREE_CHAIN (elts
);
2967 use_variable (DECL_RTL (base
));
2973 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
2977 /* If initializing one array from another,
2978 initialize element by element. */
2981 /* We rely upon the below calls the do argument checking */
2982 if (decl
== NULL_TREE
)
2984 sorry ("initialization of array from dissimilar array type");
2985 return error_mark_node
;
2989 base2
= default_conversion (init
);
2990 itype
= TREE_TYPE (base2
);
2991 base2
= get_temp_regvar (itype
, base2
);
2992 itype
= TREE_TYPE (itype
);
2994 else if (TYPE_LANG_SPECIFIC (type
)
2995 && TYPE_NEEDS_CONSTRUCTING (type
)
2996 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2998 error ("initializer ends prematurely");
2999 return error_mark_node
;
3003 expand_start_cond (build (GE_EXPR
, boolean_type_node
,
3004 iterator
, integer_zero_node
), 0);
3005 if (TYPE_NEEDS_DESTRUCTOR (type
))
3006 expand_eh_region_start ();
3007 expand_start_loop_continue_elsewhere (1);
3011 tree to
= build1 (INDIRECT_REF
, type
, base
);
3015 from
= build1 (INDIRECT_REF
, itype
, base2
);
3019 if (from_array
== 2)
3020 expand_expr_stmt (build_modify_expr (to
, NOP_EXPR
, from
));
3021 else if (TYPE_NEEDS_CONSTRUCTING (type
))
3022 expand_aggr_init (to
, from
, 0, 0);
3024 expand_assignment (to
, from
, 0, 0);
3026 my_friendly_abort (57);
3028 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3031 sorry ("cannot initialize multi-dimensional array with initializer");
3032 expand_vec_init (decl
, build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), base
),
3033 array_type_nelts (type
), 0, 0);
3037 tree targ
= build1 (INDIRECT_REF
, type
, base
);
3041 rhs
= convert_for_initialization (targ
, type
, init
, LOOKUP_NORMAL
,
3042 "initialization", NULL_TREE
, 0);
3046 expand_aggr_init (targ
, rhs
, 0, 0);
3049 expand_assignment (base
,
3050 build (PLUS_EXPR
, build_pointer_type (type
), base
, size
),
3053 expand_assignment (base2
,
3054 build (PLUS_EXPR
, build_pointer_type (type
), base2
, size
), 0, 0);
3055 expand_loop_continue_here ();
3056 expand_exit_loop_if_false (0, build (NE_EXPR
, boolean_type_node
,
3057 build (PREDECREMENT_EXPR
, ptrdiff_type_node
, iterator
, integer_one_node
), minus_one
));
3061 use_variable (DECL_RTL (base
));
3063 use_variable (DECL_RTL (base2
));
3066 if (TYPE_NEEDS_DESTRUCTOR (type
) && flag_exceptions
)
3068 /* We have to ensure that this can live to the cleanup
3069 expansion time, since we know it is only ever needed
3070 once, generate code now. */
3071 push_obstacks_nochange ();
3072 resume_temporary_allocation ();
3074 tree e1
, cleanup
= make_node (RTL_EXPR
);
3075 TREE_TYPE (cleanup
) = void_type_node
;
3076 RTL_EXPR_RTL (cleanup
) = const0_rtx
;
3077 TREE_SIDE_EFFECTS (cleanup
) = 1;
3078 start_sequence_for_rtl_expr (cleanup
);
3080 e1
= build_array_eh_cleanup
3082 build_binary_op (MINUS_EXPR
, maxindex
, iterator
, 1),
3084 expand_expr (e1
, const0_rtx
, VOIDmode
, 0);
3085 RTL_EXPR_SEQUENCE (cleanup
) = get_insns ();
3088 cleanup
= protect_with_terminate (cleanup
);
3089 expand_eh_region_end (cleanup
);
3095 use_variable (DECL_RTL (iterator
));
3100 use_variable (DECL_RTL (rval
));
3104 /* Free up storage of type TYPE, at address ADDR.
3106 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3109 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3110 used as the second argument to operator delete. It can include
3111 things like padding and magic size cookies. It has virtual in it,
3112 because if you have a base pointer and you delete through a virtual
3113 destructor, it should be the size of the dynamic object, not the
3114 static object, see Free Store 12.5 ANSI C++ WP.
3116 This does not call any destructors. */
3119 build_x_delete (type
, addr
, which_delete
, virtual_size
)
3124 int use_global_delete
= which_delete
& 1;
3125 int use_vec_delete
= !!(which_delete
& 2);
3127 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3129 if (! use_global_delete
&& TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
3130 && (TYPE_GETS_DELETE (TREE_TYPE (type
)) & (1 << use_vec_delete
)))
3131 rval
= build_opfncall (code
, LOOKUP_NORMAL
, addr
, virtual_size
, NULL_TREE
);
3133 rval
= build_builtin_call (void_type_node
, use_vec_delete
? BIVD
: BID
,
3134 build_tree_list (NULL_TREE
, addr
));
3138 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3139 ADDR is an expression which yields the store to be destroyed.
3140 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
3141 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
3142 virtual baseclasses.
3143 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
3145 FLAGS is the logical disjunction of zero or more LOOKUP_
3146 flags. See cp-tree.h for more info.
3148 This function does not delete an object's virtual base classes. */
3151 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3155 int use_global_delete
;
3161 if (addr
== error_mark_node
)
3162 return error_mark_node
;
3164 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3165 set to `error_mark_node' before it gets properly cleaned up. */
3166 if (type
== error_mark_node
)
3167 return error_mark_node
;
3169 type
= TYPE_MAIN_VARIANT (type
);
3171 if (TREE_CODE (type
) == POINTER_TYPE
)
3173 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3174 if (TYPE_SIZE (complete_type (type
)) == 0)
3176 incomplete_type_error (0, type
);
3177 return error_mark_node
;
3179 if (TREE_CODE (type
) == ARRAY_TYPE
)
3181 if (! IS_AGGR_TYPE (type
))
3183 /* Call the builtin operator delete. */
3184 return build_builtin_call (void_type_node
, BID
,
3185 build_tree_list (NULL_TREE
, addr
));
3187 if (TREE_SIDE_EFFECTS (addr
))
3188 addr
= save_expr (addr
);
3190 /* throw away const and volatile on target type of addr */
3191 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3192 ref
= build_indirect_ref (addr
, NULL_PTR
);
3194 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3197 if (TREE_SIDE_EFFECTS (addr
))
3198 addr
= save_expr (addr
);
3199 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3201 error ("unknown array size in delete");
3202 return error_mark_node
;
3204 return build_vec_delete (addr
, array_type_nelts (type
),
3205 auto_delete
, integer_two_node
,
3210 /* Don't check PROTECT here; leave that decision to the
3211 destructor. If the destructor is accessible, call it,
3212 else report error. */
3213 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3214 if (TREE_SIDE_EFFECTS (addr
))
3215 addr
= save_expr (addr
);
3217 if (TREE_CONSTANT (addr
))
3218 addr
= convert_pointer_to (type
, addr
);
3220 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3222 ref
= build_indirect_ref (addr
, NULL_PTR
);
3225 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3227 if (! TYPE_NEEDS_DESTRUCTOR (type
))
3229 if (auto_delete
== integer_zero_node
)
3230 return void_zero_node
;
3232 /* Pass the size of the object down to the operator delete() in
3233 addition to the ADDR. */
3234 if (TYPE_GETS_REG_DELETE (type
) && !use_global_delete
)
3236 tree virtual_size
= c_sizeof_nowarn (type
);
3237 return build_opfncall (DELETE_EXPR
, LOOKUP_NORMAL
, addr
,
3238 virtual_size
, NULL_TREE
);
3241 /* Call the builtin operator delete. */
3242 return build_builtin_call (void_type_node
, BID
,
3243 build_tree_list (NULL_TREE
, addr
));
3246 /* Below, we will reverse the order in which these calls are made.
3247 If we have a destructor, then that destructor will take care
3248 of the base classes; otherwise, we must do that here. */
3249 if (TYPE_HAS_DESTRUCTOR (type
))
3251 tree passed_auto_delete
;
3252 tree do_delete
= NULL_TREE
;
3255 if (use_global_delete
)
3257 tree cond
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3258 auto_delete
, integer_one_node
));
3259 tree call
= build_builtin_call
3260 (void_type_node
, BID
, build_tree_list (NULL_TREE
, addr
));
3262 cond
= fold (build (COND_EXPR
, void_type_node
, cond
,
3263 call
, void_zero_node
));
3264 if (cond
!= void_zero_node
)
3267 passed_auto_delete
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3268 auto_delete
, integer_two_node
));
3271 passed_auto_delete
= auto_delete
;
3273 expr
= build_method_call
3274 (ref
, dtor_identifier
, build_tree_list (NULL_TREE
, passed_auto_delete
),
3278 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3280 if (flags
& LOOKUP_DESTRUCTOR
)
3281 /* Explicit destructor call; don't check for null pointer. */
3282 ifexp
= integer_one_node
;
3284 /* Handle deleting a null pointer. */
3285 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
, 1));
3287 if (ifexp
!= integer_one_node
)
3288 expr
= build (COND_EXPR
, void_type_node
,
3289 ifexp
, expr
, void_zero_node
);
3295 /* We only get here from finish_function for a destructor. */
3296 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3297 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3298 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3299 tree exprstmt
= NULL_TREE
;
3300 tree parent_auto_delete
= auto_delete
;
3303 /* If we have member delete or vbases, we call delete in
3305 if (auto_delete
== integer_zero_node
)
3307 else if (base_binfo
== NULL_TREE
3308 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3310 cond
= build (COND_EXPR
, void_type_node
,
3311 build (BIT_AND_EXPR
, integer_type_node
, auto_delete
, integer_one_node
),
3312 build_builtin_call (void_type_node
, BID
,
3313 build_tree_list (NULL_TREE
, addr
)),
3320 exprstmt
= build_tree_list (NULL_TREE
, cond
);
3323 && ! TREE_VIA_VIRTUAL (base_binfo
)
3324 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3326 tree this_auto_delete
;
3328 if (BINFO_OFFSET_ZEROP (base_binfo
))
3329 this_auto_delete
= parent_auto_delete
;
3331 this_auto_delete
= integer_zero_node
;
3333 expr
= build_scoped_method_call
3334 (ref
, base_binfo
, dtor_identifier
,
3335 build_tree_list (NULL_TREE
, this_auto_delete
));
3336 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3339 /* Take care of the remaining baseclasses. */
3340 for (i
= 1; i
< n_baseclasses
; i
++)
3342 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3343 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3344 || TREE_VIA_VIRTUAL (base_binfo
))
3347 expr
= build_scoped_method_call
3348 (ref
, base_binfo
, dtor_identifier
,
3349 build_tree_list (NULL_TREE
, integer_zero_node
));
3351 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3354 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3356 if (TREE_CODE (member
) != FIELD_DECL
)
3358 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member
)))
3360 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3361 tree this_type
= TREE_TYPE (member
);
3362 expr
= build_delete (this_type
, this_member
, integer_two_node
, flags
, 0);
3363 exprstmt
= tree_cons (NULL_TREE
, expr
, exprstmt
);
3368 return build_compound_expr (exprstmt
);
3369 /* Virtual base classes make this function do nothing. */
3370 return void_zero_node
;
3374 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3377 build_vbase_delete (type
, decl
)
3380 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3381 tree result
= NULL_TREE
;
3382 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3384 my_friendly_assert (addr
!= error_mark_node
, 222);
3388 tree this_addr
= convert_force (build_pointer_type (BINFO_TYPE (vbases
)),
3390 result
= tree_cons (NULL_TREE
,
3391 build_delete (TREE_TYPE (this_addr
), this_addr
,
3393 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3395 vbases
= TREE_CHAIN (vbases
);
3397 return build_compound_expr (nreverse (result
));
3400 /* Build a C++ vector delete expression.
3401 MAXINDEX is the number of elements to be deleted.
3402 ELT_SIZE is the nominal size of each element in the vector.
3403 BASE is the expression that should yield the store to be deleted.
3404 This function expands (or synthesizes) these calls itself.
3405 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3406 AUTO_DELETE say whether each item in the container should be deallocated.
3408 This also calls delete for virtual baseclasses of elements of the vector.
3410 Update: MAXINDEX is no longer needed. The size can be extracted from the
3411 start of the vector for pointers, and from the type for arrays. We still
3412 use MAXINDEX for arrays because it happens to already have one of the
3413 values we'd have to extract. (We could use MAXINDEX with pointers to
3414 confirm the size, and trap if the numbers differ; not clear that it'd
3415 be worth bothering.) */
3418 build_vec_delete (base
, maxindex
, auto_delete_vec
, auto_delete
,
3420 tree base
, maxindex
;
3421 tree auto_delete_vec
, auto_delete
;
3422 int use_global_delete
;
3426 if (TREE_CODE (base
) == OFFSET_REF
)
3427 base
= resolve_offset_ref (base
);
3429 type
= TREE_TYPE (base
);
3431 base
= stabilize_reference (base
);
3433 /* Since we can use base many times, save_expr it. */
3434 if (TREE_SIDE_EFFECTS (base
))
3435 base
= save_expr (base
);
3437 if (TREE_CODE (type
) == POINTER_TYPE
)
3439 /* Step back one from start of vector, and read dimension. */
3440 tree cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3441 base
, BI_header_size
);
3442 tree cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3443 maxindex
= build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0);
3445 type
= TREE_TYPE (type
);
3446 while (TREE_CODE (type
) == ARRAY_TYPE
);
3448 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3450 /* get the total number of things in the array, maxindex is a bad name */
3451 maxindex
= array_type_nelts_total (type
);
3452 while (TREE_CODE (type
) == ARRAY_TYPE
)
3453 type
= TREE_TYPE (type
);
3454 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3458 if (base
!= error_mark_node
)
3459 error ("type to vector delete is neither pointer or array type");
3460 return error_mark_node
;
3463 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,