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. */
34 extern void compiler_error ();
36 /* In C++, structures with well-defined constructors are initialized by
37 those constructors, unasked. CURRENT_BASE_INIT_LIST
38 holds a list of stmts for a BASE_INIT term in the grammar.
39 This list has one element for each base class which must be
40 initialized. The list elements are [basename, init], with
41 type basetype. This allows the possibly anachronistic form
42 (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)"
43 where each successive term can be handed down the constructor
44 line. Perhaps this was not intended. */
45 tree current_base_init_list
, current_member_init_list
;
47 static void expand_aggr_vbase_init_1
PROTO((tree
, tree
, tree
, tree
));
48 static void expand_aggr_vbase_init
PROTO((tree
, tree
, tree
, tree
));
49 static void expand_aggr_init_1
PROTO((tree
, tree
, tree
, tree
, int,
51 static void expand_default_init
PROTO((tree
, tree
, tree
, tree
, int,
53 static tree build_vec_delete_1
PROTO((tree
, tree
, tree
, tree
, tree
,
55 static void perform_member_init
PROTO((tree
, tree
, tree
, int));
56 static void sort_base_init
PROTO((tree
, tree
*, tree
*));
57 static tree build_builtin_call
PROTO((tree
, tree
, tree
));
58 static tree build_array_eh_cleanup
PROTO((tree
, tree
, tree
));
59 static int member_init_ok_or_else
PROTO((tree
, tree
, char *));
60 static void expand_virtual_init
PROTO((tree
, tree
));
61 static tree sort_member_init
PROTO((tree
));
62 static tree build_partial_cleanup_for
PROTO((tree
));
63 static tree initializing_context
PROTO((tree
));
65 /* Cache _builtin_new and _builtin_delete exprs. */
66 static tree BIN
, BID
, BIVN
, BIVD
;
68 /* Cache the identifier nodes for the magic field of a new cookie. */
69 static tree nc_nelts_field_id
;
71 static tree minus_one
;
73 /* Set up local variable for this file. MUST BE CALLED AFTER
74 INIT_DECL_PROCESSING. */
76 static tree BI_header_type
, BI_header_size
;
78 void init_init_processing ()
82 /* Define implicit `operator new' and `operator delete' functions. */
83 BIN
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) NEW_EXPR
])));
84 TREE_USED (TREE_OPERAND (BIN
, 0)) = 0;
85 BID
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) DELETE_EXPR
])));
86 TREE_USED (TREE_OPERAND (BID
, 0)) = 0;
87 BIVN
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) VEC_NEW_EXPR
])));
88 TREE_USED (TREE_OPERAND (BIVN
, 0)) = 0;
89 BIVD
= default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname
[(int) VEC_DELETE_EXPR
])));
90 TREE_USED (TREE_OPERAND (BIVD
, 0)) = 0;
91 minus_one
= build_int_2 (-1, -1);
93 /* Define the structure that holds header information for
94 arrays allocated via operator new. */
95 BI_header_type
= make_lang_type (RECORD_TYPE
);
96 nc_nelts_field_id
= get_identifier ("nelts");
97 fields
[0] = build_lang_field_decl (FIELD_DECL
, nc_nelts_field_id
, sizetype
);
98 finish_builtin_type (BI_header_type
, "__new_cookie", fields
,
100 BI_header_size
= size_in_bytes (BI_header_type
);
103 /* Subroutine of emit_base_init. For BINFO, initialize all the
104 virtual function table pointers, except those that come from
105 virtual base classes. Initialize binfo's vtable pointer, if
106 INIT_SELF is true. CAN_ELIDE is true when we know that all virtual
107 function table pointers in all bases have been initialized already,
108 probably because their constructors have just be run. ADDR is the
109 pointer to the object whos vtables we are going to initialize.
111 REAL_BINFO is usually the same as BINFO, except when addr is not of
112 pointer to the type of the real derived type that we want to
113 initialize for. This is the case when addr is a pointer to a sub
114 object of a complete object, and we only want to do part of the
115 complete object's initialization of vtable pointers. This is done
116 for all virtual table pointers in virtual base classes. REAL_BINFO
117 is used to find the BINFO_VTABLE that we initialize with. BINFO is
118 used for conversions of addr to subobjects.
120 BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo).
122 Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE
126 expand_direct_vtbls_init (real_binfo
, binfo
, init_self
, can_elide
, addr
)
127 tree real_binfo
, binfo
, addr
;
128 int init_self
, can_elide
;
130 tree real_binfos
= BINFO_BASETYPES (real_binfo
);
131 tree binfos
= BINFO_BASETYPES (binfo
);
132 int i
, n_baselinks
= real_binfos
? TREE_VEC_LENGTH (real_binfos
) : 0;
134 for (i
= 0; i
< n_baselinks
; i
++)
136 tree real_base_binfo
= TREE_VEC_ELT (real_binfos
, i
);
137 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
138 int is_not_base_vtable
139 = i
!= CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo
));
140 if (! TREE_VIA_VIRTUAL (real_base_binfo
))
141 expand_direct_vtbls_init (real_base_binfo
, base_binfo
,
142 is_not_base_vtable
, can_elide
, addr
);
145 /* Before turning this on, make sure it is correct. */
146 if (can_elide
&& ! BINFO_MODIFIED (binfo
))
149 /* Should we use something besides CLASSTYPE_VFIELDS? */
150 if (init_self
&& CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo
)))
152 tree base_ptr
= convert_pointer_to_real (binfo
, addr
);
153 expand_virtual_init (real_binfo
, base_ptr
);
158 /* Subroutine of emit_base_init. */
161 perform_member_init (member
, name
, init
, explicit)
162 tree member
, name
, init
;
166 tree type
= TREE_TYPE (member
);
168 expand_start_target_temps ();
170 if (TYPE_NEEDS_CONSTRUCTING (type
)
171 || (init
&& TYPE_HAS_CONSTRUCTOR (type
)))
173 /* Since `init' is already a TREE_LIST on the current_member_init_list,
174 only build it into one if we aren't already a list. */
175 if (init
!= NULL_TREE
&& TREE_CODE (init
) != TREE_LIST
)
176 init
= build_expr_list (NULL_TREE
, init
);
178 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
181 && TREE_CODE (type
) == ARRAY_TYPE
183 && TREE_CHAIN (init
) == NULL_TREE
184 && TREE_CODE (TREE_TYPE (TREE_VALUE (init
))) == ARRAY_TYPE
)
186 /* Initialization of one array from another. */
187 expand_vec_init (TREE_OPERAND (decl
, 1), decl
,
188 array_type_nelts (type
), TREE_VALUE (init
), 1);
191 expand_aggr_init (decl
, init
, 0, 0);
195 if (init
== NULL_TREE
)
199 cp_error ("incomplete initializer for member `%D' of class `%T' which has no constructor",
200 member
, current_class_type
);
201 init
= error_mark_node
;
203 /* member traversal: note it leaves init NULL */
204 else if (TREE_CODE (TREE_TYPE (member
)) == REFERENCE_TYPE
)
205 cp_pedwarn ("uninitialized reference member `%D'", member
);
207 else if (TREE_CODE (init
) == TREE_LIST
)
209 /* There was an explicit member initialization. Do some
210 work in that case. */
211 if (TREE_CHAIN (init
))
213 warning ("initializer list treated as compound expression");
214 init
= build_compound_expr (init
);
217 init
= TREE_VALUE (init
);
220 /* We only build this with a null init if we got it from the
221 current_member_init_list. */
222 if (init
|| explicit)
224 decl
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
225 expand_expr_stmt (build_modify_expr (decl
, INIT_EXPR
, init
));
229 expand_end_target_temps ();
232 if (TYPE_NEEDS_DESTRUCTOR (type
))
236 /* All cleanups must be on the function_obstack. */
237 push_obstacks_nochange ();
238 resume_temporary_allocation ();
240 expr
= build_component_ref (current_class_ref
, name
, NULL_TREE
, explicit);
241 expr
= build_delete (type
, expr
, integer_zero_node
,
242 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
244 if (expr
!= error_mark_node
)
245 add_partial_entry (expr
);
251 extern int warn_reorder
;
253 /* Subroutine of emit_member_init. */
259 tree x
, member
, name
, field
;
260 tree init_list
= NULL_TREE
;
264 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
268 /* member could be, for example, a CONST_DECL for an enumerated
269 tag; we don't want to try to initialize that, since it already
271 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
274 for (x
= current_member_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
276 /* If we cleared this out, then pay no attention to it. */
277 if (TREE_PURPOSE (x
) == NULL_TREE
)
279 name
= TREE_PURPOSE (x
);
282 /* This happens in templates, since the IDENTIFIER is replaced
283 with the COMPONENT_REF in tsubst_expr. */
284 field
= (TREE_CODE (name
) == COMPONENT_REF
285 ? TREE_OPERAND (name
, 1) : IDENTIFIER_CLASS_VALUE (name
));
287 /* Let's find out when this happens. */
288 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 348);
289 field
= IDENTIFIER_CLASS_VALUE (name
);
292 /* If one member shadows another, get the outermost one. */
293 if (TREE_CODE (field
) == TREE_LIST
)
294 field
= TREE_VALUE (field
);
302 cp_warning_at ("member initializers for `%#D'", last_field
);
303 cp_warning_at (" and `%#D'", field
);
304 warning (" will be re-ordered to match declaration order");
310 /* Make sure we won't try to work on this init again. */
311 TREE_PURPOSE (x
) = NULL_TREE
;
312 x
= build_tree_list (name
, TREE_VALUE (x
));
317 /* If we didn't find MEMBER in the list, create a dummy entry
318 so the two lists (INIT_LIST and the list of members) will be
320 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
322 init_list
= chainon (init_list
, x
);
325 /* Initializers for base members go at the end. */
326 for (x
= current_member_init_list
; x
; x
= TREE_CHAIN (x
))
328 name
= TREE_PURPOSE (x
);
331 if (purpose_member (name
, init_list
))
333 cp_error ("multiple initializations given for member `%D'",
334 IDENTIFIER_CLASS_VALUE (name
));
338 init_list
= chainon (init_list
,
339 build_tree_list (name
, TREE_VALUE (x
)));
340 TREE_PURPOSE (x
) = NULL_TREE
;
348 sort_base_init (t
, rbase_ptr
, vbase_ptr
)
349 tree t
, *rbase_ptr
, *vbase_ptr
;
351 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (t
));
352 int n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
358 /* For warn_reorder. */
360 tree last_base
= NULL_TREE
;
362 tree rbases
= NULL_TREE
;
363 tree vbases
= NULL_TREE
;
365 /* First walk through and splice out vbase and invalid initializers.
366 Also replace names with binfos. */
368 last
= tree_cons (NULL_TREE
, NULL_TREE
, current_base_init_list
);
369 for (x
= TREE_CHAIN (last
); x
; x
= TREE_CHAIN (x
))
371 tree basetype
= TREE_PURPOSE (x
);
374 if (basetype
== NULL_TREE
)
376 /* Initializer for single base class. Must not
377 use multiple inheritance or this is ambiguous. */
378 switch (n_baseclasses
)
381 cp_error ("`%T' does not have a base class to initialize",
387 cp_error ("unnamed initializer ambiguous for `%T' which uses multiple inheritance",
391 binfo
= TREE_VEC_ELT (binfos
, 0);
393 else if (is_aggr_type (basetype
, 1))
395 binfo
= binfo_or_else (basetype
, t
);
396 if (binfo
== NULL_TREE
)
399 /* Virtual base classes are special cases. Their initializers
400 are recorded with this constructor, and they are used when
401 this constructor is the top-level constructor called. */
402 if (TREE_VIA_VIRTUAL (binfo
))
404 tree v
= CLASSTYPE_VBASECLASSES (t
);
405 while (BINFO_TYPE (v
) != BINFO_TYPE (binfo
))
408 vbases
= tree_cons (v
, TREE_VALUE (x
), vbases
);
413 /* Otherwise, if it is not an immediate base class, complain. */
414 for (i
= n_baseclasses
-1; i
>= 0; i
--)
415 if (BINFO_TYPE (binfo
) == BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)))
419 cp_error ("`%T' is not an immediate base class of `%T'",
420 basetype
, current_class_type
);
426 my_friendly_abort (365);
428 TREE_PURPOSE (x
) = binfo
;
429 TREE_CHAIN (last
) = x
;
432 TREE_CHAIN (last
) = NULL_TREE
;
434 /* Now walk through our regular bases and make sure they're initialized. */
436 for (i
= 0; i
< n_baseclasses
; ++i
)
438 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
441 if (TREE_VIA_VIRTUAL (base_binfo
))
444 for (x
= current_base_init_list
, pos
= 0; x
; x
= TREE_CHAIN (x
), ++pos
)
446 tree binfo
= TREE_PURPOSE (x
);
448 if (binfo
== NULL_TREE
)
451 if (binfo
== base_binfo
)
457 cp_warning_at ("base initializers for `%#T'", last_base
);
458 cp_warning_at (" and `%#T'", BINFO_TYPE (binfo
));
459 warning (" will be re-ordered to match inheritance order");
462 last_base
= BINFO_TYPE (binfo
);
465 /* Make sure we won't try to work on this init again. */
466 TREE_PURPOSE (x
) = NULL_TREE
;
467 x
= build_tree_list (binfo
, TREE_VALUE (x
));
472 /* If we didn't find BASE_BINFO in the list, create a dummy entry
473 so the two lists (RBASES and the list of bases) will be
475 x
= build_tree_list (NULL_TREE
, NULL_TREE
);
477 rbases
= chainon (rbases
, x
);
484 /* Perform partial cleanups for a base for exception handling. */
487 build_partial_cleanup_for (binfo
)
490 return build_scoped_method_call
491 (current_class_ref
, binfo
, dtor_identifier
,
492 build_expr_list (NULL_TREE
, integer_zero_node
));
495 /* Perform whatever initializations have yet to be done on the base
496 class of the class variable. These actions are in the global
497 variable CURRENT_BASE_INIT_LIST. Such an action could be
498 NULL_TREE, meaning that the user has explicitly called the base
499 class constructor with no arguments.
501 If there is a need for a call to a constructor, we must surround
502 that call with a pushlevel/poplevel pair, since we are technically
503 at the PARM level of scope.
505 Argument IMMEDIATELY, if zero, forces a new sequence to be
506 generated to contain these new insns, so it can be emitted later.
507 This sequence is saved in the global variable BASE_INIT_EXPR.
508 Otherwise, the insns are emitted into the current sequence.
510 Note that emit_base_init does *not* initialize virtual base
511 classes. That is done specially, elsewhere. */
513 extern tree base_init_expr
, rtl_expr_chain
;
516 emit_base_init (t
, immediately
)
522 tree rbase_init_list
, vbase_init_list
;
523 tree t_binfo
= TYPE_BINFO (t
);
524 tree binfos
= BINFO_BASETYPES (t_binfo
);
525 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
526 tree expr
= NULL_TREE
;
531 do_pending_stack_adjust ();
532 /* Make the RTL_EXPR node temporary, not momentary,
533 so that rtl_expr_chain doesn't become garbage. */
534 momentary
= suspend_momentary ();
535 expr
= make_node (RTL_EXPR
);
536 resume_momentary (momentary
);
537 start_sequence_for_rtl_expr (expr
);
540 if (write_symbols
== NO_DEBUG
)
541 /* As a matter of principle, `start_sequence' should do this. */
544 /* Always emit a line number note so we can step into constructors. */
545 emit_line_note_force (DECL_SOURCE_FILE (current_function_decl
),
546 DECL_SOURCE_LINE (current_function_decl
));
548 mem_init_list
= sort_member_init (t
);
549 current_member_init_list
= NULL_TREE
;
551 sort_base_init (t
, &rbase_init_list
, &vbase_init_list
);
552 current_base_init_list
= NULL_TREE
;
554 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
556 tree first_arg
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
558 expand_start_cond (first_arg
, 0);
559 expand_aggr_vbase_init (t_binfo
, current_class_ref
, current_class_ptr
,
564 /* Now, perform initialization of non-virtual base classes. */
565 for (i
= 0; i
< n_baseclasses
; i
++)
567 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
568 tree init
= void_list_node
;
570 if (TREE_VIA_VIRTUAL (base_binfo
))
573 #if 0 /* Once unsharing happens soon enough. */
574 my_friendly_assert (BINFO_INHERITANCE_CHAIN (base_binfo
) == t_binfo
, 999);
576 BINFO_INHERITANCE_CHAIN (base_binfo
) = t_binfo
;
579 if (TREE_PURPOSE (rbase_init_list
))
580 init
= TREE_VALUE (rbase_init_list
);
581 else if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo
)))
584 if (extra_warnings
&& copy_args_p (current_function_decl
))
585 cp_warning ("base class `%#T' should be explicitly initialized in the copy constructor",
586 BINFO_TYPE (base_binfo
));
589 if (init
!= void_list_node
)
591 expand_start_target_temps ();
593 member
= convert_pointer_to_real (base_binfo
, current_class_ptr
);
594 expand_aggr_init_1 (base_binfo
, NULL_TREE
,
595 build_indirect_ref (member
, NULL_PTR
), init
,
596 BINFO_OFFSET_ZEROP (base_binfo
), LOOKUP_NORMAL
);
598 expand_end_target_temps ();
602 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
606 /* All cleanups must be on the function_obstack. */
607 push_obstacks_nochange ();
608 resume_temporary_allocation ();
609 expr
= build_partial_cleanup_for (base_binfo
);
611 add_partial_entry (expr
);
614 rbase_init_list
= TREE_CHAIN (rbase_init_list
);
617 /* Initialize all the virtual function table fields that
618 do come from virtual base classes. */
619 if (TYPE_USES_VIRTUAL_BASECLASSES (t
))
620 expand_indirect_vtbls_init (t_binfo
, current_class_ref
, current_class_ptr
);
622 /* Initialize all the virtual function table fields that
623 do not come from virtual base classes. */
624 expand_direct_vtbls_init (t_binfo
, t_binfo
, 1, 1, current_class_ptr
);
626 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
631 /* member could be, for example, a CONST_DECL for an enumerated
632 tag; we don't want to try to initialize that, since it already
634 if (TREE_CODE (member
) != FIELD_DECL
|| !DECL_NAME (member
))
637 /* See if we had a user-specified member initialization. */
638 if (TREE_PURPOSE (mem_init_list
))
640 name
= TREE_PURPOSE (mem_init_list
);
641 init
= TREE_VALUE (mem_init_list
);
645 if (TREE_CODE (name
) == COMPONENT_REF
)
646 name
= DECL_NAME (TREE_OPERAND (name
, 1));
648 /* Also see if it's ever a COMPONENT_REF here. If it is, we
649 need to do `expand_assignment (name, init, 0, 0);' and
651 my_friendly_assert (TREE_CODE (name
) != COMPONENT_REF
, 349);
656 name
= DECL_NAME (member
);
657 init
= DECL_INITIAL (member
);
661 /* Effective C++ rule 12. */
662 if (warn_ecpp
&& init
== NULL_TREE
663 && !DECL_ARTIFICIAL (member
)
664 && TREE_CODE (TREE_TYPE (member
)) != ARRAY_TYPE
)
665 cp_warning ("`%D' should be initialized in the member initialization list", member
);
668 perform_member_init (member
, name
, init
, from_init_list
);
669 mem_init_list
= TREE_CHAIN (mem_init_list
);
672 /* Now initialize any members from our bases. */
673 while (mem_init_list
)
675 tree name
, init
, field
;
677 if (TREE_PURPOSE (mem_init_list
))
679 name
= TREE_PURPOSE (mem_init_list
);
680 init
= TREE_VALUE (mem_init_list
);
681 /* XXX: this may need the COMPONENT_REF operand 0 check if
682 it turns out we actually get them. */
683 field
= IDENTIFIER_CLASS_VALUE (name
);
685 /* If one member shadows another, get the outermost one. */
686 if (TREE_CODE (field
) == TREE_LIST
)
688 field
= TREE_VALUE (field
);
689 if (decl_type_context (field
) != current_class_type
)
690 cp_error ("field `%D' not in immediate context", field
);
694 /* It turns out if you have an anonymous union in the
695 class, a member from it can end up not being on the
696 list of fields (rather, the type is), and therefore
697 won't be seen by the for loop above. */
699 /* The code in this for loop is derived from a general loop
700 which had this check in it. Theoretically, we've hit
701 every initialization for the list of members in T, so
702 we shouldn't have anything but these left in this list. */
703 my_friendly_assert (DECL_FIELD_CONTEXT (field
) != t
, 351);
706 perform_member_init (field
, name
, init
, 1);
708 mem_init_list
= TREE_CHAIN (mem_init_list
);
713 do_pending_stack_adjust ();
714 my_friendly_assert (base_init_expr
== 0, 207);
715 base_init_expr
= expr
;
716 TREE_TYPE (expr
) = void_type_node
;
717 RTL_EXPR_RTL (expr
) = const0_rtx
;
718 RTL_EXPR_SEQUENCE (expr
) = get_insns ();
719 rtl_expr_chain
= tree_cons (NULL_TREE
, expr
, rtl_expr_chain
);
721 TREE_SIDE_EFFECTS (expr
) = 1;
724 /* All the implicit try blocks we built up will be zapped
725 when we come to a real binding contour boundary. */
728 /* Check that all fields are properly initialized after
729 an assignment to `this'. */
736 for (member
= TYPE_FIELDS (t
); member
; member
= TREE_CHAIN (member
))
737 if (DECL_NAME (member
) && TREE_USED (member
))
738 cp_error ("field `%D' used before initialized (after assignment to `this')",
742 /* This code sets up the virtual function tables appropriate for
743 the pointer DECL. It is a one-ply initialization.
745 BINFO is the exact type that DECL is supposed to be. In
746 multiple inheritance, this might mean "C's A" if C : A, B. */
749 expand_virtual_init (binfo
, decl
)
752 tree type
= BINFO_TYPE (binfo
);
754 tree vtype
, vtype_binfo
;
756 /* This code is crusty. Should be simple, like:
757 vtbl = BINFO_VTABLE (binfo);
759 vtype
= DECL_CONTEXT (CLASSTYPE_VFIELD (type
));
760 vtype_binfo
= get_binfo (vtype
, TREE_TYPE (TREE_TYPE (decl
)), 0);
761 vtbl
= BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type
)), binfo
));
762 assemble_external (vtbl
);
763 TREE_USED (vtbl
) = 1;
764 vtbl
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (vtbl
)), vtbl
);
765 decl
= convert_pointer_to_real (vtype_binfo
, decl
);
766 vtbl_ptr
= build_vfield_ref (build_indirect_ref (decl
, NULL_PTR
), vtype
);
767 if (vtbl_ptr
== error_mark_node
)
770 /* Have to convert VTBL since array sizes may be different. */
771 vtbl
= convert_force (TREE_TYPE (vtbl_ptr
), vtbl
, 0);
772 expand_expr_stmt (build_modify_expr (vtbl_ptr
, NOP_EXPR
, vtbl
));
775 /* Subroutine of `expand_aggr_vbase_init'.
776 BINFO is the binfo of the type that is being initialized.
777 INIT_LIST is the list of initializers for the virtual baseclass. */
780 expand_aggr_vbase_init_1 (binfo
, exp
, addr
, init_list
)
781 tree binfo
, exp
, addr
, init_list
;
783 tree init
= purpose_member (binfo
, init_list
);
784 tree ref
= build_indirect_ref (addr
, NULL_PTR
);
786 expand_start_target_temps ();
789 init
= TREE_VALUE (init
);
790 /* Call constructors, but don't set up vtables. */
791 expand_aggr_init_1 (binfo
, exp
, ref
, init
, 0, LOOKUP_COMPLAIN
);
793 expand_end_target_temps ();
797 /* Initialize this object's virtual base class pointers. This must be
798 done only at the top-level of the object being constructed.
800 INIT_LIST is list of initialization for constructor to perform. */
803 expand_aggr_vbase_init (binfo
, exp
, addr
, init_list
)
809 tree type
= BINFO_TYPE (binfo
);
811 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
813 tree result
= init_vbase_pointers (type
, addr
);
817 expand_expr_stmt (build_compound_expr (result
));
819 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
;
820 vbases
= TREE_CHAIN (vbases
))
822 tree tmp
= purpose_member (vbases
, result
);
823 expand_aggr_vbase_init_1 (vbases
, exp
,
824 TREE_OPERAND (TREE_VALUE (tmp
), 0),
830 /* Subroutine to perform parser actions for member initialization.
831 S_ID is the scoped identifier.
832 NAME is the name of the member.
833 INIT is the initializer, or `void_type_node' if none. */
836 do_member_init (s_id
, name
, init
)
837 tree s_id
, name
, init
;
841 if (current_class_type
== NULL_TREE
842 || ! is_aggr_typedef (s_id
, 1))
844 binfo
= get_binfo (IDENTIFIER_TYPE_VALUE (s_id
),
845 current_class_type
, 1);
846 if (binfo
== error_mark_node
)
850 error_not_base_type (IDENTIFIER_TYPE_VALUE (s_id
), current_class_type
);
854 base
= convert_pointer_to (binfo
, current_class_ptr
);
855 expand_member_init (build_indirect_ref (base
, NULL_PTR
), name
, init
);
858 /* Find the context in which this FIELD can be initialized. */
861 initializing_context (field
)
864 tree t
= DECL_CONTEXT (field
);
866 /* Anonymous union members can be initialized in the first enclosing
867 non-anonymous union context. */
868 while (t
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
869 t
= TYPE_CONTEXT (t
);
873 /* Function to give error message if member initialization specification
874 is erroneous. FIELD is the member we decided to initialize.
875 TYPE is the type for which the initialization is being performed.
876 FIELD must be a member of TYPE.
878 MEMBER_NAME is the name of the member. */
881 member_init_ok_or_else (field
, type
, member_name
)
886 if (field
== error_mark_node
)
888 if (field
== NULL_TREE
|| initializing_context (field
) != type
)
890 cp_error ("class `%T' does not have any field named `%s'", type
,
894 if (TREE_STATIC (field
))
896 cp_error ("field `%#D' is static; only point of initialization is its declaration",
904 /* If NAME is a viable field name for the aggregate DECL,
905 and PARMS is a viable parameter list, then expand an _EXPR
906 which describes this initialization.
908 Note that we do not need to chase through the class's base classes
909 to look for NAME, because if it's in that list, it will be handled
910 by the constructor for that base class.
912 We do not yet have a fixed-point finder to instantiate types
913 being fed to overloaded constructors. If there is a unique
914 constructor, then argument types can be got from that one.
916 If INIT is non-NULL, then it the initialization should
917 be placed in `current_base_init_list', where it will be processed
918 by `emit_base_init'. */
921 expand_member_init (exp
, name
, init
)
922 tree exp
, name
, init
;
924 extern tree ptr_type_node
; /* should be in tree.h */
926 tree basetype
= NULL_TREE
, field
;
930 if (exp
== NULL_TREE
)
931 return; /* complain about this later */
933 type
= TYPE_MAIN_VARIANT (TREE_TYPE (exp
));
935 if (name
&& TREE_CODE (name
) == TYPE_DECL
)
937 basetype
= TREE_TYPE (name
);
938 name
= DECL_NAME (name
);
941 if (name
== NULL_TREE
&& IS_AGGR_TYPE (type
))
942 switch (CLASSTYPE_N_BASECLASSES (type
))
945 error ("base class initializer specified, but no base class to initialize");
948 basetype
= TYPE_BINFO_BASETYPE (type
, 0);
951 error ("initializer for unnamed base class ambiguous");
952 cp_error ("(type `%T' uses multiple inheritance)", type
);
958 /* The grammar should not allow fields which have names
959 that are TYPENAMEs. Therefore, if the field has
960 a non-NULL TREE_TYPE, we may assume that this is an
961 attempt to initialize a base class member of the current
962 type. Otherwise, it is an attempt to initialize a
965 if (init
== void_type_node
)
968 if (name
== NULL_TREE
|| basetype
)
972 if (name
== NULL_TREE
)
976 name
= TYPE_IDENTIFIER (basetype
);
979 error ("no base class to initialize");
984 else if (basetype
!= type
985 && ! current_template_parms
986 && ! vec_binfo_member (basetype
,
987 TYPE_BINFO_BASETYPES (type
))
988 && ! binfo_member (basetype
, CLASSTYPE_VBASECLASSES (type
)))
990 if (IDENTIFIER_CLASS_VALUE (name
))
992 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
993 cp_error ("type `%T' is not an immediate or virtual basetype for `%T'",
996 cp_error ("type `%T' is not an immediate basetype for `%T'",
1001 if (purpose_member (basetype
, current_base_init_list
))
1003 cp_error ("base class `%T' already initialized", basetype
);
1007 if (warn_reorder
&& current_member_init_list
)
1009 cp_warning ("base initializer for `%T'", basetype
);
1010 warning (" will be re-ordered to precede member initializations");
1013 base_init
= build_tree_list (basetype
, init
);
1014 current_base_init_list
= chainon (current_base_init_list
, base_init
);
1021 field
= lookup_field (type
, name
, 1, 0);
1023 if (! member_init_ok_or_else (field
, type
, IDENTIFIER_POINTER (name
)))
1026 if (purpose_member (name
, current_member_init_list
))
1028 cp_error ("field `%D' already initialized", field
);
1032 member_init
= build_tree_list (name
, init
);
1033 current_member_init_list
= chainon (current_member_init_list
, member_init
);
1037 else if (name
== NULL_TREE
)
1039 compiler_error ("expand_member_init: name == NULL_TREE");
1044 field
= lookup_field (basetype
, name
, 0, 0);
1046 if (! member_init_ok_or_else (field
, basetype
, IDENTIFIER_POINTER (name
)))
1049 /* now see if there is a constructor for this type
1050 which will take these args. */
1052 if (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (field
)))
1054 tree parmtypes
, fndecl
;
1056 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1058 /* just know that we've seen something for this node */
1059 DECL_INITIAL (exp
) = error_mark_node
;
1060 TREE_USED (exp
) = 1;
1062 type
= TYPE_MAIN_VARIANT (TREE_TYPE (field
));
1063 parm
= build_component_ref (exp
, name
, NULL_TREE
, 0);
1065 /* Now get to the constructors. */
1066 fndecl
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), 0);
1069 my_friendly_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
, 209);
1071 /* If the field is unique, we can use the parameter
1072 types to guide possible type instantiation. */
1073 if (DECL_CHAIN (fndecl
) == NULL_TREE
)
1075 /* There was a confusion here between
1076 FIELD and FNDECL. The following code
1077 should be correct, but abort is here
1079 my_friendly_abort (48);
1080 parmtypes
= FUNCTION_ARG_CHAIN (fndecl
);
1084 parmtypes
= NULL_TREE
;
1088 init
= convert_arguments (parm
, parmtypes
, NULL_TREE
, fndecl
, LOOKUP_NORMAL
);
1089 if (init
== NULL_TREE
|| TREE_TYPE (init
) != error_mark_node
)
1090 rval
= build_method_call (NULL_TREE
, ctor_identifier
, init
,
1091 TYPE_BINFO (type
), LOOKUP_NORMAL
);
1095 if (rval
!= error_mark_node
)
1097 /* Now, fill in the first parm with our guy */
1098 TREE_VALUE (TREE_OPERAND (rval
, 1))
1099 = build_unary_op (ADDR_EXPR
, parm
, 0);
1100 TREE_TYPE (rval
) = ptr_type_node
;
1101 TREE_SIDE_EFFECTS (rval
) = 1;
1104 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field
)))
1106 parm
= build_component_ref (exp
, name
, NULL_TREE
, 0);
1107 expand_aggr_init (parm
, NULL_TREE
, 0, 0);
1108 rval
= error_mark_node
;
1111 /* Now initialize the member. It does not have to
1112 be of aggregate type to receive initialization. */
1113 if (rval
!= error_mark_node
)
1114 expand_expr_stmt (rval
);
1117 /* This is like `expand_member_init', only it stores one aggregate
1120 INIT comes in two flavors: it is either a value which
1121 is to be stored in EXP, or it is a parameter list
1122 to go to a constructor, which will operate on EXP.
1123 If INIT is not a parameter list for a constructor, then set
1124 LOOKUP_ONLYCONVERTING.
1125 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1126 the initializer, if FLAGS is 0, then it is the (init) form.
1127 If `init' is a CONSTRUCTOR, then we emit a warning message,
1128 explaining that such initializations are invalid.
1130 ALIAS_THIS is nonzero iff we are initializing something which is
1131 essentially an alias for current_class_ref. In this case, the base
1132 constructor may move it on us, and we must keep track of such
1135 If INIT resolves to a CALL_EXPR which happens to return
1136 something of the type we are looking for, then we know
1137 that we can safely use that call to perform the
1140 The virtual function table pointer cannot be set up here, because
1141 we do not really know its type.
1143 Virtual baseclass pointers are also set up here.
1145 This never calls operator=().
1147 When initializing, nothing is CONST.
1149 A default copy constructor may have to be used to perform the
1152 A constructor or a conversion operator may have to be used to
1153 perform the initialization, but not both, as it would be ambiguous. */
1156 expand_aggr_init (exp
, init
, alias_this
, flags
)
1161 tree type
= TREE_TYPE (exp
);
1162 int was_const
= TREE_READONLY (exp
);
1163 int was_volatile
= TREE_THIS_VOLATILE (exp
);
1165 if (init
== error_mark_node
)
1168 TREE_READONLY (exp
) = 0;
1169 TREE_THIS_VOLATILE (exp
) = 0;
1171 if (init
&& TREE_CODE (init
) != TREE_LIST
)
1172 flags
|= LOOKUP_ONLYCONVERTING
;
1174 if (TREE_CODE (type
) == ARRAY_TYPE
)
1176 /* Must arrange to initialize each element of EXP
1177 from elements of INIT. */
1178 tree itype
= init
? TREE_TYPE (init
) : NULL_TREE
;
1179 if (TYPE_READONLY (TREE_TYPE (type
)) || TYPE_VOLATILE (TREE_TYPE (type
)))
1181 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1183 TREE_TYPE (init
) = TYPE_MAIN_VARIANT (itype
);
1185 if (init
&& TREE_TYPE (init
) == NULL_TREE
)
1187 /* Handle bad initializers like:
1191 COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;};
1195 int main(int argc, char **argv) {
1196 COMPLEX zees(1.0, 0.0)[10];
1199 error ("bad array initializer");
1202 expand_vec_init (exp
, exp
, array_type_nelts (type
), init
,
1203 init
&& comptypes (TREE_TYPE (init
), TREE_TYPE (exp
), 1));
1204 TREE_READONLY (exp
) = was_const
;
1205 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1206 TREE_TYPE (exp
) = type
;
1208 TREE_TYPE (init
) = itype
;
1212 if (TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == PARM_DECL
)
1213 /* just know that we've seen something for this node */
1214 TREE_USED (exp
) = 1;
1217 /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the
1218 constructor as parameters to an implicit GNU C++ constructor. */
1219 if (init
&& TREE_CODE (init
) == CONSTRUCTOR
1220 && TYPE_HAS_CONSTRUCTOR (type
)
1221 && TREE_TYPE (init
) == type
)
1222 init
= CONSTRUCTOR_ELTS (init
);
1225 TREE_TYPE (exp
) = TYPE_MAIN_VARIANT (type
);
1226 expand_aggr_init_1 (TYPE_BINFO (type
), exp
, exp
,
1227 init
, alias_this
, LOOKUP_NORMAL
|flags
);
1228 TREE_TYPE (exp
) = type
;
1229 TREE_READONLY (exp
) = was_const
;
1230 TREE_THIS_VOLATILE (exp
) = was_volatile
;
1234 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1241 tree type
= TREE_TYPE (exp
);
1243 /* It fails because there may not be a constructor which takes
1244 its own type as the first (or only parameter), but which does
1245 take other types via a conversion. So, if the thing initializing
1246 the expression is a unit element of type X, first try X(X&),
1247 followed by initialization by X. If neither of these work
1248 out, then look hard. */
1252 if (flag_ansi_overloading
&& init
&& TREE_CODE (init
) != TREE_LIST
1253 && (flags
& LOOKUP_ONLYCONVERTING
))
1255 /* Base subobjects should only get direct-initialization. */
1256 if (true_exp
!= exp
)
1259 /* We special-case TARGET_EXPRs here to avoid an error about
1260 private copy constructors for temporaries bound to reference vars.
1261 If the TARGET_EXPR represents a call to a function that has
1262 permission to create such objects, a reference can bind directly
1263 to the return value. An object variable must be initialized
1264 via the copy constructor, even if the call is elided. */
1265 if (! (TREE_CODE (exp
) == VAR_DECL
&& DECL_ARTIFICIAL (exp
)
1266 && TREE_CODE (init
) == TARGET_EXPR
&& TREE_TYPE (init
) == type
))
1267 init
= ocp_convert (type
, init
, CONV_IMPLICIT
|CONV_FORCE_TEMP
, flags
);
1269 if (TREE_CODE (init
) == TRY_CATCH_EXPR
)
1270 /* We need to protect the initialization of a catch parm
1271 with a call to terminate(), which shows up as a TRY_CATCH_EXPR
1272 around the TARGET_EXPR for the copy constructor. See
1273 expand_start_catch_block. */
1274 TREE_OPERAND (init
, 0) = build (INIT_EXPR
, TREE_TYPE (exp
), exp
,
1275 TREE_OPERAND (init
, 0));
1277 init
= build (INIT_EXPR
, TREE_TYPE (exp
), exp
, init
);
1278 TREE_SIDE_EFFECTS (init
) = 1;
1279 expand_expr_stmt (init
);
1283 if (init
== NULL_TREE
1284 || (TREE_CODE (init
) == TREE_LIST
&& ! TREE_TYPE (init
)))
1288 init
= TREE_VALUE (parms
);
1290 else if (! flag_ansi_overloading
1291 && TREE_CODE (init
) == INDIRECT_REF
&& TREE_HAS_CONSTRUCTOR (init
)
1292 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (init
)))
1294 rval
= convert_for_initialization (exp
, type
, init
, 0, 0, 0, 0);
1295 TREE_USED (rval
) = 1;
1296 expand_expr_stmt (rval
);
1300 parms
= build_expr_list (NULL_TREE
, init
);
1302 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
1304 if (true_exp
== exp
)
1305 parms
= expr_tree_cons (NULL_TREE
, integer_one_node
, parms
);
1307 parms
= expr_tree_cons (NULL_TREE
, integer_zero_node
, parms
);
1308 flags
|= LOOKUP_HAS_IN_CHARGE
;
1311 if (flag_ansi_overloading
)
1313 rval
= build_method_call (exp
, ctor_identifier
,
1314 parms
, binfo
, flags
);
1315 expand_expr_stmt (rval
);
1319 if (init
&& TREE_CHAIN (parms
) == NULL_TREE
1320 && TYPE_HAS_TRIVIAL_INIT_REF (type
)
1321 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (TREE_TYPE (init
)))
1323 rval
= build (INIT_EXPR
, type
, exp
, init
);
1324 TREE_SIDE_EFFECTS (rval
) = 1;
1325 expand_expr_stmt (rval
);
1329 if (flags
& LOOKUP_ONLYCONVERTING
)
1330 flags
|= LOOKUP_NO_CONVERSION
;
1331 rval
= build_method_call (exp
, ctor_identifier
,
1332 parms
, binfo
, flags
);
1334 /* Private, protected, or otherwise unavailable. */
1335 if (rval
== error_mark_node
)
1337 if (flags
& LOOKUP_COMPLAIN
)
1338 cp_error ("in base initialization for %sclass `%T'",
1339 TREE_VIA_VIRTUAL (binfo
) ? "virtual base " : "",
1342 else if (rval
== NULL_TREE
)
1343 my_friendly_abort (361);
1346 /* p. 222: if the base class assigns to `this', then that
1347 value is used in the derived class. */
1348 if ((flag_this_is_variable
& 1) && alias_this
)
1350 TREE_TYPE (rval
) = TREE_TYPE (current_class_ptr
);
1351 expand_assignment (current_class_ptr
, rval
, 0, 0);
1354 expand_expr_stmt (rval
);
1359 /* This function is responsible for initializing EXP with INIT
1362 BINFO is the binfo of the type for who we are performing the
1363 initialization. For example, if W is a virtual base class of A and B,
1365 If we are initializing B, then W must contain B's W vtable, whereas
1366 were we initializing C, W must contain C's W vtable.
1368 TRUE_EXP is nonzero if it is the true expression being initialized.
1369 In this case, it may be EXP, or may just contain EXP. The reason we
1370 need this is because if EXP is a base element of TRUE_EXP, we
1371 don't necessarily know by looking at EXP where its virtual
1372 baseclass fields should really be pointing. But we do know
1373 from TRUE_EXP. In constructors, we don't know anything about
1374 the value being initialized.
1376 ALIAS_THIS serves the same purpose it serves for expand_aggr_init.
1378 FLAGS is just passes to `build_method_call'. See that function for
1382 expand_aggr_init_1 (binfo
, true_exp
, exp
, init
, alias_this
, flags
)
1389 tree type
= TREE_TYPE (exp
);
1390 tree init_type
= NULL_TREE
;
1392 my_friendly_assert (init
!= error_mark_node
&& type
!= error_mark_node
, 211);
1394 /* Use a function returning the desired type to initialize EXP for us.
1395 If the function is a constructor, and its first argument is
1396 NULL_TREE, know that it was meant for us--just slide exp on
1397 in and expand the constructor. Constructors now come
1400 if (init
&& TREE_CODE (exp
) == VAR_DECL
1401 && TREE_CODE (init
) == CONSTRUCTOR
1402 && TREE_HAS_CONSTRUCTOR (init
))
1404 tree t
= store_init_value (exp
, init
);
1407 expand_decl_init (exp
);
1410 t
= build (INIT_EXPR
, type
, exp
, init
);
1411 TREE_SIDE_EFFECTS (t
) = 1;
1412 expand_expr_stmt (t
);
1416 if (init
&& ! flag_ansi_overloading
)
1418 tree init_list
= NULL_TREE
;
1420 if (TREE_CODE (init
) == TREE_LIST
)
1423 if (TREE_CHAIN (init
) == NULL_TREE
)
1424 init
= TREE_VALUE (init
);
1427 init_type
= TREE_TYPE (init
);
1429 if (TREE_CODE (init
) != TREE_LIST
)
1431 if (init_type
== error_mark_node
)
1434 /* This happens when we use C++'s functional cast notation.
1435 If the types match, then just use the TARGET_EXPR
1436 directly. Otherwise, we need to create the initializer
1437 separately from the object being initialized. */
1438 if (TREE_CODE (init
) == TARGET_EXPR
)
1440 if (TYPE_MAIN_VARIANT (init_type
) == TYPE_MAIN_VARIANT (type
))
1442 if (TREE_CODE (exp
) == VAR_DECL
1443 || TREE_CODE (exp
) == RESULT_DECL
)
1444 /* Unify the initialization targets. */
1445 DECL_RTL (TREE_OPERAND (init
, 0)) = DECL_RTL (exp
);
1447 DECL_RTL (TREE_OPERAND (init
, 0)) = expand_expr (exp
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
1449 expand_expr_stmt (init
);
1454 if (init_type
== type
&& TREE_CODE (init
) == CALL_EXPR
)
1456 /* A CALL_EXPR is a legitimate form of initialization, so
1457 we should not print this warning message. */
1459 expand_assignment (exp
, init
, 0, 0);
1460 if (exp
== DECL_RESULT (current_function_decl
))
1462 /* Failing this assertion means that the return value
1463 from receives multiple initializations. */
1464 my_friendly_assert (DECL_INITIAL (exp
) == NULL_TREE
1465 || DECL_INITIAL (exp
) == error_mark_node
,
1467 DECL_INITIAL (exp
) = init
;
1471 else if (init_type
== type
1472 && TREE_CODE (init
) == COND_EXPR
)
1474 /* Push value to be initialized into the cond, where possible.
1475 Avoid spurious warning messages when initializing the
1476 result of this function. */
1477 TREE_OPERAND (init
, 1)
1478 = build_modify_expr (exp
, INIT_EXPR
, TREE_OPERAND (init
, 1));
1479 if (exp
== DECL_RESULT (current_function_decl
))
1480 DECL_INITIAL (exp
) = NULL_TREE
;
1481 TREE_OPERAND (init
, 2)
1482 = build_modify_expr (exp
, INIT_EXPR
, TREE_OPERAND (init
, 2));
1483 if (exp
== DECL_RESULT (current_function_decl
))
1484 DECL_INITIAL (exp
) = init
;
1485 TREE_SIDE_EFFECTS (init
) = 1;
1486 expand_expr (init
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
1492 /* We did not know what we were initializing before. Now we do. */
1493 if (TREE_CODE (init
) == TARGET_EXPR
)
1495 tree tmp
= TREE_OPERAND (TREE_OPERAND (init
, 1), 1);
1497 if (tmp
&& TREE_CODE (TREE_VALUE (tmp
)) == NOP_EXPR
1498 && TREE_OPERAND (TREE_VALUE (tmp
), 0) == integer_zero_node
)
1500 /* In order for this to work for RESULT_DECLs, if their
1501 type has a constructor, then they must be BLKmode
1502 so that they will be meaningfully addressable. */
1503 tree arg
= build_unary_op (ADDR_EXPR
, exp
, 0);
1504 init
= TREE_OPERAND (init
, 1);
1505 init
= build (CALL_EXPR
, build_pointer_type (TREE_TYPE (init
)),
1506 TREE_OPERAND (init
, 0), TREE_OPERAND (init
, 1), NULL_TREE
);
1507 TREE_SIDE_EFFECTS (init
) = 1;
1508 TREE_VALUE (TREE_OPERAND (init
, 1))
1509 = convert_pointer_to (TREE_TYPE (TREE_TYPE (TREE_VALUE (tmp
))), arg
);
1513 expand_assignment (current_function_decl
, init
, 0, 0);
1516 if (exp
== DECL_RESULT (current_function_decl
))
1518 if (DECL_INITIAL (DECL_RESULT (current_function_decl
)))
1519 fatal ("return value from function receives multiple initializations");
1520 DECL_INITIAL (exp
) = init
;
1522 expand_expr_stmt (init
);
1527 /* Handle this case: when calling a constructor: xyzzy foo(bar);
1528 which really means: xyzzy foo = bar; Ugh!
1530 More useful for this case: xyzzy *foo = new xyzzy (bar); */
1532 if (! TYPE_NEEDS_CONSTRUCTING (type
) && ! IS_AGGR_TYPE (type
))
1534 if (init_list
&& TREE_CHAIN (init_list
))
1536 warning ("initializer list being treated as compound expression");
1537 init
= cp_convert (type
, build_compound_expr (init_list
));
1538 if (init
== error_mark_node
)
1542 expand_assignment (exp
, init
, 0, 0);
1547 /* If this is copy-initialization, see whether we can go through a
1548 type conversion operator. */
1549 if (TREE_CODE (init
) != TREE_LIST
&& (flags
& LOOKUP_ONLYCONVERTING
))
1551 tree ttype
= TREE_CODE (init_type
) == REFERENCE_TYPE
1552 ? TREE_TYPE (init_type
) : init_type
;
1554 if (ttype
!= type
&& IS_AGGR_TYPE (ttype
))
1556 tree rval
= build_type_conversion (CONVERT_EXPR
, type
, init
, 1);
1560 /* See if there is a constructor for``type'' that takes a
1561 ``ttype''-typed object. */
1562 tree parms
= build_expr_list (NULL_TREE
, init
);
1563 tree as_cons
= NULL_TREE
;
1564 if (TYPE_HAS_CONSTRUCTOR (type
))
1565 as_cons
= build_method_call (exp
, ctor_identifier
,
1567 LOOKUP_SPECULATIVELY
|LOOKUP_NO_CONVERSION
);
1568 if (as_cons
!= NULL_TREE
&& as_cons
!= error_mark_node
)
1569 /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */
1570 cp_error ("ambiguity between conversion to `%T' and constructor",
1573 if (rval
!= error_mark_node
)
1574 expand_aggr_init_1 (binfo
, true_exp
, exp
, rval
, alias_this
, flags
);
1581 /* We know that expand_default_init can handle everything we want
1583 expand_default_init (binfo
, true_exp
, exp
, init
, alias_this
, flags
);
1586 /* Report an error if NAME is not the name of a user-defined,
1587 aggregate type. If OR_ELSE is nonzero, give an error message. */
1590 is_aggr_typedef (name
, or_else
)
1596 if (name
== error_mark_node
)
1599 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1600 type
= IDENTIFIER_TYPE_VALUE (name
);
1604 cp_error ("`%T' is not an aggregate typedef", name
);
1608 if (! IS_AGGR_TYPE (type
)
1609 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1612 cp_error ("`%T' is not an aggregate type", type
);
1618 /* Report an error if TYPE is not a user-defined, aggregate type. If
1619 OR_ELSE is nonzero, give an error message. */
1622 is_aggr_type (type
, or_else
)
1626 if (type
== error_mark_node
)
1629 if (! IS_AGGR_TYPE (type
)
1630 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1633 cp_error ("`%T' is not an aggregate type", type
);
1639 /* Like is_aggr_typedef, but returns typedef if successful. */
1642 get_aggr_from_typedef (name
, or_else
)
1648 if (name
== error_mark_node
)
1651 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1652 type
= IDENTIFIER_TYPE_VALUE (name
);
1656 cp_error ("`%T' fails to be an aggregate typedef", name
);
1660 if (! IS_AGGR_TYPE (type
)
1661 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
)
1664 cp_error ("type `%T' is of non-aggregate type", type
);
1671 get_type_value (name
)
1674 if (name
== error_mark_node
)
1677 if (IDENTIFIER_HAS_TYPE_VALUE (name
))
1678 return IDENTIFIER_TYPE_VALUE (name
);
1684 /* This code could just as well go in `class.c', but is placed here for
1687 /* For an expression of the form TYPE :: NAME (PARMLIST), build
1688 the appropriate function call. */
1691 build_member_call (type
, name
, parmlist
)
1692 tree type
, name
, parmlist
;
1697 int dont_use_this
= 0;
1698 tree basetype_path
, decl
;
1700 if (type
== std_node
)
1701 return build_x_function_call (do_scoped_id (name
, 0), parmlist
,
1704 if (TREE_CODE (name
) != TEMPLATE_ID_EXPR
)
1707 method_name
= TREE_OPERAND (name
, 0);
1709 if (TREE_CODE (method_name
) == BIT_NOT_EXPR
)
1711 method_name
= TREE_OPERAND (method_name
, 0);
1715 /* This shouldn't be here, and build_member_call shouldn't appear in
1717 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
1718 && get_aggr_from_typedef (type
, 0) == 0)
1720 tree ns
= lookup_name (type
, 0);
1721 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1723 return build_x_function_call (build_offset_ref (type
, name
), parmlist
, current_class_ref
);
1727 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1728 return error_mark_node
;
1730 /* An operator we did not like. */
1731 if (name
== NULL_TREE
)
1732 return error_mark_node
;
1736 cp_error ("cannot call destructor `%T::~%T' without object", type
,
1738 return error_mark_node
;
1741 /* No object? Then just fake one up, and let build_method_call
1742 figure out what to do. */
1743 if (current_class_type
== 0
1744 || get_base_distance (type
, current_class_type
, 0, &basetype_path
) == -1)
1749 basetype_path
= TYPE_BINFO (type
);
1750 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1752 else if (current_class_ptr
== 0)
1755 decl
= build1 (NOP_EXPR
, build_pointer_type (type
), error_mark_node
);
1759 tree olddecl
= current_class_ptr
;
1760 tree oldtype
= TREE_TYPE (TREE_TYPE (olddecl
));
1761 if (oldtype
!= type
)
1763 tree newtype
= build_type_variant (type
, TYPE_READONLY (oldtype
),
1764 TYPE_VOLATILE (oldtype
));
1765 decl
= convert_force (build_pointer_type (newtype
), olddecl
, 0);
1771 decl
= build_indirect_ref (decl
, NULL_PTR
);
1773 if (method_name
== constructor_name (type
)
1774 || method_name
== constructor_name_full (type
))
1775 return build_functional_cast (type
, parmlist
);
1776 if (t
= lookup_fnfields (basetype_path
, method_name
, 0))
1777 return build_method_call (decl
,
1778 TREE_CODE (name
) == TEMPLATE_ID_EXPR
1779 ? name
: method_name
,
1780 parmlist
, basetype_path
,
1781 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
);
1782 if (TREE_CODE (name
) == IDENTIFIER_NODE
1783 && ((t
= lookup_field (TYPE_BINFO (type
), name
, 1, 0))))
1785 if (t
== error_mark_node
)
1786 return error_mark_node
;
1787 if (TREE_CODE (t
) == FIELD_DECL
)
1791 cp_error ("invalid use of non-static field `%D'", t
);
1792 return error_mark_node
;
1794 decl
= build (COMPONENT_REF
, TREE_TYPE (t
), decl
, t
);
1796 else if (TREE_CODE (t
) == VAR_DECL
)
1800 cp_error ("invalid use of member `%D'", t
);
1801 return error_mark_node
;
1803 if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl
))
1804 && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (decl
)))
1805 return build_opfncall (CALL_EXPR
, LOOKUP_NORMAL
, decl
, parmlist
, NULL_TREE
);
1806 return build_function_call (decl
, parmlist
);
1810 cp_error ("no method `%T::%D'", type
, name
);
1811 return error_mark_node
;
1815 /* Build a reference to a member of an aggregate. This is not a
1816 C++ `&', but really something which can have its address taken,
1817 and then act as a pointer to member, for example TYPE :: FIELD
1818 can have its address taken by saying & TYPE :: FIELD.
1820 @@ Prints out lousy diagnostics for operator <typename>
1823 @@ This function should be rewritten and placed in search.c. */
1826 build_offset_ref (type
, name
)
1829 tree decl
, fnfields
, fields
, t
= error_mark_node
;
1830 tree basebinfo
= NULL_TREE
;
1833 if (type
== std_node
)
1834 return do_scoped_id (name
, 0);
1836 if (processing_template_decl
)
1837 return build_min_nt (SCOPE_REF
, type
, name
);
1839 /* Handle namespace names fully here. */
1840 if (TREE_CODE (type
) == IDENTIFIER_NODE
1841 && get_aggr_from_typedef (type
, 0) == 0)
1843 tree ns
= lookup_name (type
, 0);
1845 if (ns
&& TREE_CODE (ns
) == NAMESPACE_DECL
)
1847 val
= lookup_namespace_name (ns
, name
);
1850 cp_error ("namespace `%D' has no member named `%D'", ns
, name
);
1851 return error_mark_node
;
1855 if (type
== NULL_TREE
|| ! is_aggr_type (type
, 1))
1856 return error_mark_node
;
1858 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
1861 name
= TREE_OPERAND (name
, 0);
1864 if (name
== constructor_name_full (type
))
1865 name
= constructor_name (type
);
1867 if (TYPE_SIZE (complete_type (type
)) == 0)
1869 if (type
== current_class_type
)
1870 t
= IDENTIFIER_CLASS_VALUE (name
);
1875 cp_error ("incomplete type `%T' does not have member `%D'", type
,
1877 return error_mark_node
;
1879 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == VAR_DECL
1880 || TREE_CODE (t
) == CONST_DECL
)
1885 if (TREE_CODE (t
) == FIELD_DECL
)
1886 sorry ("use of member in incomplete aggregate type");
1887 else if (TREE_CODE (t
) == FUNCTION_DECL
)
1888 sorry ("use of member function in incomplete aggregate type");
1890 my_friendly_abort (52);
1891 return error_mark_node
;
1894 if (current_class_type
== 0
1895 || get_base_distance (type
, current_class_type
, 0, &basebinfo
) == -1)
1897 basebinfo
= TYPE_BINFO (type
);
1898 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1900 else if (current_class_ptr
== 0)
1901 decl
= build1 (NOP_EXPR
, type
, error_mark_node
);
1903 decl
= current_class_ref
;
1905 if (constructor_name (BINFO_TYPE (basebinfo
)) == name
)
1907 name
= dtor_identifier
;
1909 name
= ctor_identifier
;
1912 my_friendly_abort (999);
1915 fnfields
= lookup_fnfields (basebinfo
, name
, 1);
1916 fields
= lookup_field (basebinfo
, name
, 0, 0);
1918 if (fields
== error_mark_node
|| fnfields
== error_mark_node
)
1919 return error_mark_node
;
1921 /* A lot of this logic is now handled in lookup_field and
1925 extern int flag_save_memoized_contexts
;
1926 basebinfo
= TREE_PURPOSE (fnfields
);
1928 /* Go from the TREE_BASELINK to the member function info. */
1929 t
= TREE_VALUE (fnfields
);
1931 if (DECL_CHAIN (t
) == NULL_TREE
)
1935 /* unique functions are handled easily. */
1936 access
= compute_access (basebinfo
, t
);
1937 if (access
== access_protected_node
)
1939 cp_error_at ("member function `%#D' is protected", t
);
1940 error ("in this context");
1941 return error_mark_node
;
1943 if (access
== access_private_node
)
1945 cp_error_at ("member function `%#D' is private", t
);
1946 error ("in this context");
1947 return error_mark_node
;
1950 return build (OFFSET_REF
, TREE_TYPE (t
), decl
, t
);
1953 /* FNFIELDS is most likely allocated on the search_obstack,
1954 which will go away after this class scope. If we need
1955 to save this value for later (either for memoization
1956 or for use as an initializer for a static variable), then
1959 ??? The smart thing to do for the case of saving initializers
1960 is to resolve them before we're done with this scope. */
1961 if (!TREE_PERMANENT (fnfields
)
1962 && ((flag_save_memoized_contexts
&& global_bindings_p ())
1963 || ! allocation_temporary_p ()))
1964 fnfields
= copy_list (fnfields
);
1966 t
= build_tree_list (error_mark_node
, fnfields
);
1967 TREE_TYPE (t
) = build_offset_type (type
, unknown_type_node
);
1971 /* Now that we know we are looking for a field, see if we
1972 have access to that field. Lookup_field will give us the
1975 t
= lookup_field (basebinfo
, name
, 1, 0);
1977 if (t
== error_mark_node
)
1978 return error_mark_node
;
1982 cp_error ("`%D' is not a member of type `%T'", name
, type
);
1983 return error_mark_node
;
1986 if (TREE_CODE (t
) == TYPE_DECL
)
1991 /* static class members and class-specific enum
1992 values can be returned without further ado. */
1993 if (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == CONST_DECL
)
1996 return convert_from_reference (t
);
1999 if (TREE_CODE (t
) == FIELD_DECL
&& DECL_BIT_FIELD (t
))
2001 cp_error ("illegal pointer to bit field `%D'", t
);
2002 return error_mark_node
;
2005 /* static class functions too. */
2006 if (TREE_CODE (t
) == FUNCTION_DECL
2007 && TREE_CODE (TREE_TYPE (t
)) == FUNCTION_TYPE
)
2008 my_friendly_abort (53);
2010 /* In member functions, the form `type::name' is no longer
2011 equivalent to `this->type::name', at least not until
2012 resolve_offset_ref. */
2013 return build (OFFSET_REF
, build_offset_type (type
, TREE_TYPE (t
)), decl
, t
);
2016 /* If a OFFSET_REF made it through to here, then it did
2017 not have its address taken. */
2020 resolve_offset_ref (exp
)
2023 tree type
= TREE_TYPE (exp
);
2024 tree base
= NULL_TREE
;
2026 tree basetype
, addr
;
2028 if (TREE_CODE (exp
) == TREE_LIST
)
2029 return build_unary_op (ADDR_EXPR
, exp
, 0);
2031 if (TREE_CODE (exp
) == OFFSET_REF
)
2033 member
= TREE_OPERAND (exp
, 1);
2034 base
= TREE_OPERAND (exp
, 0);
2038 my_friendly_assert (TREE_CODE (type
) == OFFSET_TYPE
, 214);
2039 if (TYPE_OFFSET_BASETYPE (type
) != current_class_type
)
2041 error ("object missing in use of pointer-to-member construct");
2042 return error_mark_node
;
2045 type
= TREE_TYPE (type
);
2046 base
= current_class_ref
;
2049 if ((TREE_CODE (member
) == VAR_DECL
2050 && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
2051 || TREE_CODE (TREE_TYPE (member
)) == FUNCTION_TYPE
2052 || TREE_CODE (TREE_TYPE (member
)) == METHOD_TYPE
)
2054 /* These were static members. */
2055 if (mark_addressable (member
) == 0)
2056 return error_mark_node
;
2060 if (TREE_CODE (TREE_TYPE (member
)) == POINTER_TYPE
2061 && TREE_CODE (TREE_TYPE (TREE_TYPE (member
))) == METHOD_TYPE
)
2064 /* Syntax error can cause a member which should
2065 have been seen as static to be grok'd as non-static. */
2066 if (TREE_CODE (member
) == FIELD_DECL
&& current_class_ref
== NULL_TREE
)
2068 if (TREE_ADDRESSABLE (member
) == 0)
2070 cp_error_at ("member `%D' is non-static but referenced as a static member",
2072 error ("at this point in file");
2073 TREE_ADDRESSABLE (member
) = 1;
2075 return error_mark_node
;
2078 /* The first case is really just a reference to a member of `this'. */
2079 if (TREE_CODE (member
) == FIELD_DECL
2080 && (base
== current_class_ref
2081 || (TREE_CODE (base
) == NOP_EXPR
2082 && TREE_OPERAND (base
, 0) == error_mark_node
)))
2084 tree basetype_path
, access
;
2086 if (TREE_CODE (exp
) == OFFSET_REF
&& TREE_CODE (type
) == OFFSET_TYPE
)
2087 basetype
= TYPE_OFFSET_BASETYPE (type
);
2089 basetype
= DECL_CONTEXT (member
);
2091 base
= current_class_ptr
;
2093 if (get_base_distance (basetype
, TREE_TYPE (TREE_TYPE (base
)), 0, &basetype_path
) < 0)
2095 error_not_base_type (basetype
, TREE_TYPE (TREE_TYPE (base
)));
2096 return error_mark_node
;
2098 addr
= convert_pointer_to (basetype
, base
);
2099 access
= compute_access (basetype_path
, member
);
2100 if (access
== access_public_node
)
2101 return build (COMPONENT_REF
, TREE_TYPE (member
),
2102 build_indirect_ref (addr
, NULL_PTR
), member
);
2103 if (access
== access_protected_node
)
2105 cp_error_at ("member `%D' is protected", member
);
2106 error ("in this context");
2107 return error_mark_node
;
2109 if (access
== access_private_node
)
2111 cp_error_at ("member `%D' is private", member
);
2112 error ("in this context");
2113 return error_mark_node
;
2115 my_friendly_abort (55);
2118 /* Ensure that we have an object. */
2119 if (TREE_CODE (base
) == NOP_EXPR
2120 && TREE_OPERAND (base
, 0) == error_mark_node
)
2121 addr
= error_mark_node
;
2124 /* If this is a reference to a member function, then return the
2125 address of the member function (which may involve going
2126 through the object's vtable), otherwise, return an expression
2127 for the dereferenced pointer-to-member construct. */
2128 addr
= build_unary_op (ADDR_EXPR
, base
, 0);
2131 if (TREE_CODE (TREE_TYPE (member
)) == OFFSET_TYPE
)
2133 if (addr
== error_mark_node
)
2135 cp_error ("object missing in `%E'", exp
);
2136 return error_mark_node
;
2139 basetype
= TYPE_OFFSET_BASETYPE (TREE_TYPE (member
));
2140 addr
= convert_pointer_to (basetype
, addr
);
2141 member
= cp_convert (ptrdiff_type_node
,
2142 build_unary_op (ADDR_EXPR
, member
, 0));
2144 /* Pointer to data members are offset by one, so that a null
2145 pointer with a real value of 0 is distinguishable from an
2146 offset of the first member of a structure. */
2147 member
= build_binary_op (MINUS_EXPR
, member
,
2148 cp_convert (ptrdiff_type_node
, integer_one_node
),
2151 return build1 (INDIRECT_REF
, type
,
2152 build (PLUS_EXPR
, build_pointer_type (type
),
2155 else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member
)))
2157 return get_member_function_from_ptrfunc (&addr
, member
);
2159 my_friendly_abort (56);
2164 /* Return either DECL or its known constant value (if it has one). */
2167 decl_constant_value (decl
)
2170 if (! TREE_THIS_VOLATILE (decl
)
2172 /* These may be necessary for C, but they break C++. */
2173 ! TREE_PUBLIC (decl
)
2174 /* Don't change a variable array bound or initial value to a constant
2175 in a place where a variable is invalid. */
2178 && DECL_INITIAL (decl
) != 0
2179 && DECL_INITIAL (decl
) != error_mark_node
2180 /* This is invalid if initial value is not constant.
2181 If it has either a function call, a memory reference,
2182 or a variable, then re-evaluating it could give different results. */
2183 && TREE_CONSTANT (DECL_INITIAL (decl
))
2184 /* Check for cases where this is sub-optimal, even though valid. */
2185 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
2187 /* We must allow this to work outside of functions so that
2188 static constants can be used for array sizes. */
2189 && current_function_decl
!= 0
2190 && DECL_MODE (decl
) != BLKmode
2193 return DECL_INITIAL (decl
);
2197 /* Common subroutines of build_new and build_vec_delete. */
2199 /* Common interface for calling "builtin" functions that are not
2203 build_builtin_call (type
, node
, arglist
)
2208 tree rval
= build (CALL_EXPR
, type
, node
, arglist
, NULL_TREE
);
2209 TREE_SIDE_EFFECTS (rval
) = 1;
2210 assemble_external (TREE_OPERAND (node
, 0));
2211 TREE_USED (TREE_OPERAND (node
, 0)) = 1;
2215 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
2216 (which needs to go through some sort of groktypename) or it
2217 is the name of the class we are newing. INIT is an initialization value.
2218 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
2219 If INIT is void_type_node, it means do *not* call a constructor
2222 For types with constructors, the data returned is initialized
2223 by the appropriate constructor.
2225 Whether the type has a constructor or not, if it has a pointer
2226 to a virtual function table, then that pointer is set up
2229 Unless I am mistaken, a call to new () will return initialized
2230 data regardless of whether the constructor itself is private or
2231 not. NOPE; new fails if the constructor is private (jcm).
2233 Note that build_new does nothing to assure that any special
2234 alignment requirements of the type are met. Rather, it leaves
2235 it up to malloc to do the right thing. Otherwise, folding to
2236 the right alignment cal cause problems if the user tries to later
2237 free the memory returned by `new'.
2239 PLACEMENT is the `placement' list for user-defined operator new (). */
2241 extern int flag_check_new
;
2244 build_new (placement
, decl
, init
, use_global_new
)
2249 tree type
, true_type
, size
, rval
;
2253 enum tree_code code
= NEW_EXPR
;
2254 int use_cookie
, nothrow
, check_new
;
2256 tree pending_sizes
= NULL_TREE
;
2258 if (decl
== error_mark_node
)
2259 return error_mark_node
;
2261 if (TREE_CODE (decl
) == TREE_LIST
)
2263 tree absdcl
= TREE_VALUE (decl
);
2264 tree last_absdcl
= NULL_TREE
;
2265 int old_immediate_size_expand
;
2267 if (current_function_decl
2268 && DECL_CONSTRUCTOR_P (current_function_decl
))
2270 old_immediate_size_expand
= immediate_size_expand
;
2271 immediate_size_expand
= 0;
2274 nelts
= integer_one_node
;
2276 if (absdcl
&& TREE_CODE (absdcl
) == CALL_EXPR
)
2277 my_friendly_abort (215);
2278 while (absdcl
&& TREE_CODE (absdcl
) == INDIRECT_REF
)
2280 last_absdcl
= absdcl
;
2281 absdcl
= TREE_OPERAND (absdcl
, 0);
2284 if (absdcl
&& TREE_CODE (absdcl
) == ARRAY_REF
)
2286 /* probably meant to be a vec new */
2289 while (TREE_OPERAND (absdcl
, 0)
2290 && TREE_CODE (TREE_OPERAND (absdcl
, 0)) == ARRAY_REF
)
2292 last_absdcl
= absdcl
;
2293 absdcl
= TREE_OPERAND (absdcl
, 0);
2297 this_nelts
= TREE_OPERAND (absdcl
, 1);
2298 if (this_nelts
!= error_mark_node
)
2300 if (this_nelts
== NULL_TREE
)
2301 error ("new of array type fails to specify size");
2302 else if (processing_template_decl
)
2305 absdcl
= TREE_OPERAND (absdcl
, 0);
2309 this_nelts
= save_expr (cp_convert (sizetype
, this_nelts
));
2310 absdcl
= TREE_OPERAND (absdcl
, 0);
2311 if (this_nelts
== integer_zero_node
)
2313 warning ("zero size array reserves no space");
2314 nelts
= integer_zero_node
;
2317 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2321 nelts
= integer_zero_node
;
2325 TREE_OPERAND (last_absdcl
, 0) = absdcl
;
2327 TREE_VALUE (decl
) = absdcl
;
2329 type
= true_type
= groktypename (decl
);
2330 if (! type
|| type
== error_mark_node
)
2332 immediate_size_expand
= old_immediate_size_expand
;
2333 return error_mark_node
;
2336 if (current_function_decl
2337 && DECL_CONSTRUCTOR_P (current_function_decl
))
2339 pending_sizes
= get_pending_sizes ();
2340 immediate_size_expand
= old_immediate_size_expand
;
2343 else if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
2345 if (IDENTIFIER_HAS_TYPE_VALUE (decl
))
2347 /* An aggregate type. */
2348 type
= IDENTIFIER_TYPE_VALUE (decl
);
2349 decl
= TYPE_MAIN_DECL (type
);
2353 /* A builtin type. */
2354 decl
= lookup_name (decl
, 1);
2355 my_friendly_assert (TREE_CODE (decl
) == TYPE_DECL
, 215);
2356 type
= TREE_TYPE (decl
);
2360 else if (TREE_CODE (decl
) == TYPE_DECL
)
2362 type
= TREE_TYPE (decl
);
2369 decl
= TYPE_MAIN_DECL (type
);
2372 if (processing_template_decl
)
2376 t
= min_tree_cons (min_tree_cons (NULL_TREE
, type
, NULL_TREE
),
2377 build_min_nt (ARRAY_REF
, NULL_TREE
, nelts
),
2382 rval
= build_min_nt (NEW_EXPR
, placement
, t
, init
);
2383 NEW_EXPR_USE_GLOBAL (rval
) = use_global_new
;
2387 /* ``A reference cannot be created by the new operator. A reference
2388 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2389 returned by new.'' ARM 5.3.3 */
2390 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2392 error ("new cannot be applied to a reference type");
2393 type
= true_type
= TREE_TYPE (type
);
2396 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2398 error ("new cannot be applied to a function type");
2399 return error_mark_node
;
2402 /* When the object being created is an array, the new-expression yields a
2403 pointer to the initial element (if any) of the array. For example,
2404 both new int and new int[10] return an int*. 5.3.4. */
2405 if (TREE_CODE (type
) == ARRAY_TYPE
&& has_array
== 0)
2407 nelts
= array_type_nelts_top (type
);
2409 type
= true_type
= TREE_TYPE (type
);
2412 if (TYPE_READONLY (type
) || TYPE_VOLATILE (type
))
2413 type
= TYPE_MAIN_VARIANT (type
);
2415 /* If our base type is an array, then make sure we know how many elements
2417 while (TREE_CODE (true_type
) == ARRAY_TYPE
)
2419 tree this_nelts
= array_type_nelts_top (true_type
);
2420 nelts
= build_binary_op (MULT_EXPR
, nelts
, this_nelts
, 1);
2421 true_type
= TREE_TYPE (true_type
);
2424 if (TYPE_SIZE (complete_type (true_type
)) == 0)
2426 incomplete_type_error (0, true_type
);
2427 return error_mark_node
;
2431 size
= fold (build_binary_op (MULT_EXPR
, size_in_bytes (true_type
),
2434 size
= size_in_bytes (type
);
2436 if (true_type
== void_type_node
)
2438 error ("invalid type `void' for new");
2439 return error_mark_node
;
2442 if (TYPE_LANG_SPECIFIC (true_type
)
2443 && CLASSTYPE_ABSTRACT_VIRTUALS (true_type
))
2445 abstract_virtuals_error (NULL_TREE
, true_type
);
2446 return error_mark_node
;
2449 if (TYPE_LANG_SPECIFIC (true_type
) && IS_SIGNATURE (true_type
))
2451 signature_error (NULL_TREE
, true_type
);
2452 return error_mark_node
;
2455 /* If the first placement arg is of type nothrow_t, it's allowed to
2456 return 0 on allocation failure. */
2457 nothrow
= (placement
&& TREE_VALUE (placement
)
2458 && TREE_TYPE (TREE_VALUE (placement
))
2459 && IS_AGGR_TYPE (TREE_TYPE (TREE_VALUE (placement
)))
2460 && (TYPE_IDENTIFIER (TREE_TYPE (TREE_VALUE (placement
)))
2461 == get_identifier ("nothrow_t")));
2463 check_new
= flag_check_new
|| nothrow
;
2466 /* Get a little extra space to store a couple of things before the new'ed
2467 array, if this isn't the default placement new. */
2469 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2470 && ! (placement
&& ! TREE_CHAIN (placement
)
2471 && TREE_TYPE (TREE_VALUE (placement
)) == ptr_type_node
));
2473 /* Get a little extra space to store a couple of things before the new'ed
2474 array, if this is either non-placement new or new (nothrow). */
2476 use_cookie
= (has_array
&& TYPE_VEC_NEW_USES_COOKIE (true_type
)
2477 && (! placement
|| nothrow
));
2482 tree extra
= BI_header_size
;
2484 size
= size_binop (PLUS_EXPR
, size
, extra
);
2489 code
= VEC_NEW_EXPR
;
2491 if (init
&& pedantic
)
2492 cp_pedwarn ("initialization in array new");
2495 /* Allocate the object. */
2496 if (! use_global_new
&& TYPE_LANG_SPECIFIC (true_type
)
2497 && (TYPE_GETS_NEW (true_type
) & (1 << has_array
)))
2498 rval
= build_opfncall (code
, LOOKUP_NORMAL
,
2499 build_pointer_type (true_type
), size
, placement
);
2502 rval
= build_opfncall (code
, LOOKUP_GLOBAL
|LOOKUP_COMPLAIN
,
2503 ptr_type_node
, size
, placement
);
2504 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2506 else if (! has_array
&& flag_this_is_variable
> 0
2507 && TYPE_NEEDS_CONSTRUCTING (true_type
) && init
!= void_type_node
)
2509 if (init
== NULL_TREE
|| TREE_CODE (init
) == TREE_LIST
)
2513 error ("constructors take parameter lists");
2514 return error_mark_node
;
2519 rval
= build_builtin_call (build_pointer_type (true_type
),
2520 has_array
? BIVN
: BIN
,
2521 build_expr_list (NULL_TREE
, size
));
2522 TREE_CALLS_NEW (rval
) = 1;
2525 if ((flag_exceptions
|| check_new
) && rval
)
2526 alloc_expr
= rval
= save_expr (rval
);
2528 alloc_expr
= NULL_TREE
;
2530 /* if rval is NULL_TREE I don't have to allocate it, but are we totally
2531 sure we have some extra bytes in that case for the BI_header_size
2532 cookies? And how does that interact with the code below? (mrs) */
2533 /* Finish up some magic for new'ed arrays */
2534 if (use_cookie
&& rval
!= NULL_TREE
)
2536 tree extra
= BI_header_size
;
2538 rval
= cp_convert (ptr_type_node
, rval
); /* convert to void * first */
2539 rval
= cp_convert (string_type_node
, rval
); /* lets not add void* and ints */
2540 rval
= save_expr (build_binary_op (PLUS_EXPR
, rval
, extra
, 1));
2541 /* Store header info. */
2542 cookie
= build_indirect_ref (build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
2543 rval
, extra
), NULL_PTR
);
2544 exp1
= build (MODIFY_EXPR
, void_type_node
,
2545 build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0),
2547 TREE_SIDE_EFFECTS (exp1
) = 1;
2548 rval
= cp_convert (build_pointer_type (true_type
), rval
);
2549 TREE_CALLS_NEW (rval
) = 1;
2550 TREE_SIDE_EFFECTS (rval
) = 1;
2551 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, exp1
,
2552 build_expr_list (NULL_TREE
, rval
)));
2555 if (rval
== error_mark_node
)
2556 return error_mark_node
;
2558 /* Don't call any constructors or do any initialization. */
2559 if (init
== void_type_node
)
2562 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
)
2564 if (! TYPE_NEEDS_CONSTRUCTING (type
)
2565 && ! IS_AGGR_TYPE (type
) && ! has_array
)
2567 /* New 2.0 interpretation: `new int (10)' means
2568 allocate an int, and initialize it with 10. */
2571 rval
= save_expr (rval
);
2572 deref
= build_indirect_ref (rval
, NULL_PTR
);
2573 TREE_READONLY (deref
) = 0;
2575 if (TREE_CHAIN (init
) != NULL_TREE
)
2576 pedwarn ("initializer list being treated as compound expression");
2577 else if (TREE_CODE (init
) == CONSTRUCTOR
)
2579 pedwarn ("initializer list appears where operand should be used");
2580 init
= TREE_OPERAND (init
, 1);
2582 init
= build_compound_expr (init
);
2584 init
= convert_for_initialization (deref
, type
, init
, LOOKUP_NORMAL
,
2585 "new", NULL_TREE
, 0);
2586 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
),
2587 build_modify_expr (deref
, NOP_EXPR
, init
),
2589 TREE_NO_UNUSED_WARNING (rval
) = 1;
2590 TREE_SIDE_EFFECTS (rval
) = 1;
2591 TREE_CALLS_NEW (rval
) = 1;
2593 else if (! has_array
)
2596 /* Constructors are never virtual. If it has an initialization, we
2597 need to complain if we aren't allowed to use the ctor that took
2599 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_COMPLAIN
;
2601 if (rval
&& TYPE_USES_VIRTUAL_BASECLASSES (true_type
))
2603 init
= expr_tree_cons (NULL_TREE
, integer_one_node
, init
);
2604 flags
|= LOOKUP_HAS_IN_CHARGE
;
2609 if (newrval
&& TREE_CODE (TREE_TYPE (newrval
)) == POINTER_TYPE
)
2610 newrval
= build_indirect_ref (newrval
, NULL_PTR
);
2612 newrval
= build_method_call (newrval
, ctor_identifier
,
2613 init
, TYPE_BINFO (true_type
), flags
);
2618 TREE_HAS_CONSTRUCTOR (rval
) = 1;
2621 rval
= error_mark_node
;
2624 rval
= build (VEC_INIT_EXPR
, TREE_TYPE (rval
),
2625 save_expr (rval
), init
, nelts
);
2627 else if (current_function_decl
== NULL_TREE
)
2629 extern tree static_aggregates
;
2631 /* In case of static initialization, SAVE_EXPR is good enough. */
2632 rval
= save_expr (rval
);
2633 rval
= copy_to_permanent (rval
);
2634 init
= copy_to_permanent (init
);
2635 init
= expand_vec_init (decl
, rval
,
2636 build_binary_op (MINUS_EXPR
, nelts
,
2637 integer_one_node
, 1),
2639 init
= copy_to_permanent (init
);
2640 static_aggregates
= perm_tree_cons (init
, rval
, static_aggregates
);
2644 /* Have to wrap this in RTL_EXPR for two cases:
2645 in base or member initialization and if we
2646 are a branch of a ?: operator. Since we
2647 can't easily know the latter, just do it always. */
2648 tree xval
= make_node (RTL_EXPR
);
2650 /* If we want to check the value of the allocation expression,
2651 and the number of elements in the array is not a constant, we
2652 *must* expand the SAVE_EXPR for nelts in alloc_expr before we
2653 expand it in the actual initialization. So we need to build up
2654 an RTL_EXPR for alloc_expr. Sigh. */
2655 if (alloc_expr
&& ! TREE_CONSTANT (nelts
))
2657 tree xval
= make_node (RTL_EXPR
);
2659 TREE_TYPE (xval
) = TREE_TYPE (alloc_expr
);
2660 do_pending_stack_adjust ();
2661 start_sequence_for_rtl_expr (xval
);
2663 rtxval
= expand_expr (alloc_expr
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
);
2664 do_pending_stack_adjust ();
2665 TREE_SIDE_EFFECTS (xval
) = 1;
2666 RTL_EXPR_SEQUENCE (xval
) = get_insns ();
2668 RTL_EXPR_RTL (xval
) = rtxval
;
2669 TREE_TYPE (xval
) = TREE_TYPE (alloc_expr
);
2673 TREE_TYPE (xval
) = TREE_TYPE (rval
);
2674 do_pending_stack_adjust ();
2675 start_sequence_for_rtl_expr (xval
);
2677 /* As a matter of principle, `start_sequence' should do this. */
2680 rval
= save_expr (rval
);
2681 rval
= expand_vec_init (decl
, rval
,
2682 build_binary_op (MINUS_EXPR
, nelts
,
2683 integer_one_node
, 1),
2686 do_pending_stack_adjust ();
2688 TREE_SIDE_EFFECTS (xval
) = 1;
2689 TREE_CALLS_NEW (xval
) = 1;
2690 RTL_EXPR_SEQUENCE (xval
) = get_insns ();
2693 if (TREE_CODE (rval
) == SAVE_EXPR
)
2695 /* Errors may cause this to not get evaluated. */
2696 if (SAVE_EXPR_RTL (rval
) == 0)
2697 SAVE_EXPR_RTL (rval
) = const0_rtx
;
2698 RTL_EXPR_RTL (xval
) = SAVE_EXPR_RTL (rval
);
2702 my_friendly_assert (TREE_CODE (rval
) == VAR_DECL
, 217);
2703 RTL_EXPR_RTL (xval
) = DECL_RTL (rval
);
2709 /* If any part of the object initialization terminates by throwing
2710 an exception and the new-expression does not contain a
2711 new-placement, then the deallocation function is called to free
2712 the memory in which the object was being constructed. */
2713 /* FIXME: handle placement delete. */
2714 if (flag_exceptions
&& ! placement
)
2719 cleanup
= build (MINUS_EXPR
, TREE_TYPE (alloc_expr
),
2720 alloc_expr
, BI_header_size
);
2722 cleanup
= alloc_expr
;
2724 if (! use_global_new
&& TYPE_LANG_SPECIFIC (true_type
)
2725 && (TYPE_GETS_DELETE (true_type
) & (1 << has_array
)))
2726 cleanup
= build_opfncall (has_array
? VEC_DELETE_EXPR
: DELETE_EXPR
,
2727 LOOKUP_NORMAL
, cleanup
, size
, NULL_TREE
);
2729 cleanup
= build_builtin_call
2730 (void_type_node
, has_array
? BIVD
: BID
,
2731 build_expr_list (NULL_TREE
, cleanup
));
2733 rval
= build (TRY_CATCH_EXPR
, TREE_TYPE (rval
), rval
, cleanup
);
2734 rval
= build (COMPOUND_EXPR
, TREE_TYPE (rval
), alloc_expr
, rval
);
2737 else if (TYPE_READONLY (true_type
))
2738 cp_error ("uninitialized const in `new' of `%#T'", true_type
);
2742 if (check_new
&& alloc_expr
&& rval
!= alloc_expr
)
2744 /* Did we modify the storage? */
2745 tree ifexp
= build_binary_op (NE_EXPR
, alloc_expr
,
2746 integer_zero_node
, 1);
2747 rval
= build_conditional_expr (ifexp
, rval
, alloc_expr
);
2750 if (rval
&& TREE_TYPE (rval
) != build_pointer_type (type
))
2752 /* The type of new int [3][3] is not int *, but int [3] * */
2753 rval
= build_c_cast (build_pointer_type (type
), rval
);
2757 rval
= build_compound_expr (chainon (pending_sizes
,
2758 build_expr_list (NULL_TREE
, rval
)));
2764 build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,
2766 tree base
, maxindex
, type
;
2767 tree auto_delete_vec
, auto_delete
;
2768 int use_global_delete
;
2771 tree ptype
= build_pointer_type (type
= complete_type (type
));
2772 tree size_exp
= size_in_bytes (type
);
2774 /* Temporary variables used by the loop. */
2775 tree tbase
, tbase_init
;
2777 /* This is the body of the loop that implements the deletion of a
2778 single element, and moves temp variables to next elements. */
2781 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2784 /* This is the thing that governs what to do after the loop has run. */
2785 tree deallocate_expr
= 0;
2787 /* This is the BIND_EXPR which holds the outermost iterator of the
2788 loop. It is convenient to set this variable up and test it before
2789 executing any other code in the loop.
2790 This is also the containing expression returned by this function. */
2791 tree controller
= NULL_TREE
;
2793 /* This is the BLOCK to record the symbol binding for debugging. */
2796 if (! IS_AGGR_TYPE (type
) || ! TYPE_NEEDS_DESTRUCTOR (type
))
2798 loop
= integer_zero_node
;
2802 /* The below is short by BI_header_size */
2803 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2805 tbase
= build_decl (VAR_DECL
, NULL_TREE
, ptype
);
2806 tbase_init
= build_modify_expr (tbase
, NOP_EXPR
,
2807 fold (build (PLUS_EXPR
, ptype
,
2810 DECL_REGISTER (tbase
) = 1;
2811 controller
= build (BIND_EXPR
, void_type_node
, tbase
, NULL_TREE
, NULL_TREE
);
2812 TREE_SIDE_EFFECTS (controller
) = 1;
2814 if (auto_delete
!= integer_zero_node
2815 && auto_delete
!= integer_two_node
)
2817 tree base_tbd
= cp_convert (ptype
,
2818 build_binary_op (MINUS_EXPR
,
2819 cp_convert (ptr_type_node
, base
),
2822 /* This is the real size */
2823 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2824 body
= build_expr_list (NULL_TREE
,
2825 build_x_delete (ptype
, base_tbd
,
2826 2 | use_global_delete
,
2828 body
= build (COND_EXPR
, void_type_node
,
2829 build (BIT_AND_EXPR
, integer_type_node
,
2830 auto_delete
, integer_one_node
),
2831 body
, integer_zero_node
);
2836 body
= expr_tree_cons (NULL_TREE
,
2837 build_delete (ptype
, tbase
, auto_delete
,
2838 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 1),
2841 body
= expr_tree_cons (NULL_TREE
,
2842 build_modify_expr (tbase
, NOP_EXPR
, build (MINUS_EXPR
, ptype
, tbase
, size_exp
)),
2845 body
= expr_tree_cons (NULL_TREE
,
2846 build (EXIT_EXPR
, void_type_node
,
2847 build (EQ_EXPR
, boolean_type_node
, base
, tbase
)),
2850 loop
= build (LOOP_EXPR
, void_type_node
, build_compound_expr (body
));
2852 loop
= expr_tree_cons (NULL_TREE
, tbase_init
,
2853 expr_tree_cons (NULL_TREE
, loop
, NULL_TREE
));
2854 loop
= build_compound_expr (loop
);
2857 /* If the delete flag is one, or anything else with the low bit set,
2858 delete the storage. */
2859 if (auto_delete_vec
== integer_zero_node
2860 || auto_delete_vec
== integer_two_node
)
2861 deallocate_expr
= integer_zero_node
;
2866 /* The below is short by BI_header_size */
2867 virtual_size
= fold (size_binop (MULT_EXPR
, size_exp
, maxindex
));
2869 if (! TYPE_VEC_NEW_USES_COOKIE (type
))
2874 base_tbd
= cp_convert (ptype
,
2875 build_binary_op (MINUS_EXPR
,
2876 cp_convert (string_type_node
, base
),
2879 /* True size with header. */
2880 virtual_size
= size_binop (PLUS_EXPR
, virtual_size
, BI_header_size
);
2882 deallocate_expr
= build_x_delete (ptype
, base_tbd
,
2883 2 | use_global_delete
,
2885 if (auto_delete_vec
!= integer_one_node
)
2886 deallocate_expr
= build (COND_EXPR
, void_type_node
,
2887 build (BIT_AND_EXPR
, integer_type_node
,
2888 auto_delete_vec
, integer_one_node
),
2889 deallocate_expr
, integer_zero_node
);
2892 if (loop
&& deallocate_expr
!= integer_zero_node
)
2894 body
= expr_tree_cons (NULL_TREE
, loop
,
2895 expr_tree_cons (NULL_TREE
, deallocate_expr
, NULL_TREE
));
2896 body
= build_compound_expr (body
);
2901 /* Outermost wrapper: If pointer is null, punt. */
2902 body
= build (COND_EXPR
, void_type_node
,
2903 build (NE_EXPR
, boolean_type_node
, base
, integer_zero_node
),
2904 body
, integer_zero_node
);
2905 body
= build1 (NOP_EXPR
, void_type_node
, body
);
2909 TREE_OPERAND (controller
, 1) = body
;
2913 return cp_convert (void_type_node
, body
);
2916 /* Build a tree to cleanup partially built arrays.
2917 BASE is that starting address of the array.
2918 COUNT is the count of objects that have been built, that need destroying.
2919 TYPE is the type of elements in the array. */
2922 build_array_eh_cleanup (base
, count
, type
)
2923 tree base
, count
, type
;
2925 tree expr
= build_vec_delete_1 (base
, count
, type
, integer_two_node
,
2926 integer_zero_node
, 0);
2930 /* `expand_vec_init' performs initialization of a vector of aggregate
2933 DECL is passed only for error reporting, and provides line number
2934 and source file name information.
2935 BASE is the space where the vector will be.
2936 MAXINDEX is the maximum index of the array (one less than the
2937 number of elements).
2938 INIT is the (possibly NULL) initializer.
2940 FROM_ARRAY is 0 if we should init everything with INIT
2941 (i.e., every element initialized from INIT).
2942 FROM_ARRAY is 1 if we should index into INIT in parallel
2943 with initialization of DECL.
2944 FROM_ARRAY is 2 if we should index into INIT in parallel,
2945 but use assignment instead of initialization. */
2948 expand_vec_init (decl
, base
, maxindex
, init
, from_array
)
2949 tree decl
, base
, maxindex
, init
;
2953 tree iterator
, base2
= NULL_TREE
;
2954 tree type
= TREE_TYPE (TREE_TYPE (base
));
2957 maxindex
= cp_convert (ptrdiff_type_node
, maxindex
);
2958 if (maxindex
== error_mark_node
)
2959 return error_mark_node
;
2961 if (current_function_decl
== NULL_TREE
)
2963 rval
= make_tree_vec (3);
2964 TREE_VEC_ELT (rval
, 0) = base
;
2965 TREE_VEC_ELT (rval
, 1) = maxindex
;
2966 TREE_VEC_ELT (rval
, 2) = init
;
2970 size
= size_in_bytes (type
);
2972 /* Set to zero in case size is <= 0. Optimizer will delete this if
2973 it is not needed. */
2974 rval
= get_temp_regvar (build_pointer_type (type
),
2975 cp_convert (build_pointer_type (type
), null_pointer_node
));
2976 base
= default_conversion (base
);
2977 base
= cp_convert (build_pointer_type (type
), base
);
2978 expand_assignment (rval
, base
, 0, 0);
2979 base
= get_temp_regvar (build_pointer_type (type
), base
);
2981 if (init
!= NULL_TREE
&& TREE_CODE (init
) == TREE_LIST
)
2982 init
= build_compound_expr (init
);
2984 if (init
!= NULL_TREE
2985 && TREE_CODE (init
) == CONSTRUCTOR
2986 && (! decl
|| TREE_TYPE (init
) == TREE_TYPE (decl
)))
2988 /* Initialization of array from {...}. */
2989 tree elts
= CONSTRUCTOR_ELTS (init
);
2990 tree baseref
= build1 (INDIRECT_REF
, type
, base
);
2991 tree baseinc
= build (PLUS_EXPR
, build_pointer_type (type
), base
, size
);
2992 int host_i
= TREE_INT_CST_LOW (maxindex
);
2994 if (IS_AGGR_TYPE (type
))
2999 expand_aggr_init (baseref
, TREE_VALUE (elts
), 0, 0);
3001 expand_assignment (base
, baseinc
, 0, 0);
3002 elts
= TREE_CHAIN (elts
);
3004 /* Initialize any elements by default if possible. */
3007 if (TYPE_NEEDS_CONSTRUCTING (type
) == 0)
3010 use_variable (DECL_RTL (base
));
3014 iterator
= get_temp_regvar (ptrdiff_type_node
,
3015 build_int_2 (host_i
, 0));
3017 goto init_by_default
;
3023 expand_assignment (baseref
, TREE_VALUE (elts
), 0, 0);
3025 expand_assignment (base
, baseinc
, 0, 0);
3026 elts
= TREE_CHAIN (elts
);
3030 use_variable (DECL_RTL (base
));
3036 iterator
= get_temp_regvar (ptrdiff_type_node
, maxindex
);
3040 /* If initializing one array from another,
3041 initialize element by element. */
3044 /* We rely upon the below calls the do argument checking */
3045 if (decl
== NULL_TREE
)
3047 sorry ("initialization of array from dissimilar array type");
3048 return error_mark_node
;
3052 base2
= default_conversion (init
);
3053 itype
= TREE_TYPE (base2
);
3054 base2
= get_temp_regvar (itype
, base2
);
3055 itype
= TREE_TYPE (itype
);
3057 else if (TYPE_LANG_SPECIFIC (type
)
3058 && TYPE_NEEDS_CONSTRUCTING (type
)
3059 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
3061 error ("initializer ends prematurely");
3062 return error_mark_node
;
3066 expand_start_cond (build (GE_EXPR
, boolean_type_node
,
3067 iterator
, integer_zero_node
), 0);
3068 if (TYPE_NEEDS_DESTRUCTOR (type
))
3069 expand_eh_region_start ();
3070 expand_start_loop_continue_elsewhere (1);
3074 tree to
= build1 (INDIRECT_REF
, type
, base
);
3078 from
= build1 (INDIRECT_REF
, itype
, base2
);
3082 if (from_array
== 2)
3083 expand_expr_stmt (build_modify_expr (to
, NOP_EXPR
, from
));
3084 else if (TYPE_NEEDS_CONSTRUCTING (type
))
3085 expand_aggr_init (to
, from
, 0, 0);
3087 expand_assignment (to
, from
, 0, 0);
3089 my_friendly_abort (57);
3091 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3094 sorry ("cannot initialize multi-dimensional array with initializer");
3095 expand_vec_init (decl
, build1 (NOP_EXPR
, build_pointer_type (TREE_TYPE (type
)), base
),
3096 array_type_nelts (type
), 0, 0);
3100 tree targ
= build1 (INDIRECT_REF
, type
, base
);
3104 rhs
= convert_for_initialization (targ
, type
, init
, LOOKUP_NORMAL
,
3105 "initialization", NULL_TREE
, 0);
3109 expand_aggr_init (targ
, rhs
, 0, 0);
3112 expand_assignment (base
,
3113 build (PLUS_EXPR
, build_pointer_type (type
), base
, size
),
3116 expand_assignment (base2
,
3117 build (PLUS_EXPR
, build_pointer_type (type
), base2
, size
), 0, 0);
3118 expand_loop_continue_here ();
3119 expand_exit_loop_if_false (0, build (NE_EXPR
, boolean_type_node
,
3120 build (PREDECREMENT_EXPR
, ptrdiff_type_node
, iterator
, integer_one_node
), minus_one
));
3124 use_variable (DECL_RTL (base
));
3126 use_variable (DECL_RTL (base2
));
3129 if (TYPE_NEEDS_DESTRUCTOR (type
) && flag_exceptions
)
3131 /* We have to ensure that this can live to the cleanup
3132 expansion time, since we know it is only ever needed
3133 once, generate code now. */
3134 push_obstacks_nochange ();
3135 resume_temporary_allocation ();
3137 tree e1
, cleanup
= make_node (RTL_EXPR
);
3138 TREE_TYPE (cleanup
) = void_type_node
;
3139 RTL_EXPR_RTL (cleanup
) = const0_rtx
;
3140 TREE_SIDE_EFFECTS (cleanup
) = 1;
3141 start_sequence_for_rtl_expr (cleanup
);
3143 e1
= build_array_eh_cleanup
3145 build_binary_op (MINUS_EXPR
, maxindex
, iterator
, 1),
3147 expand_expr (e1
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3148 RTL_EXPR_SEQUENCE (cleanup
) = get_insns ();
3151 cleanup
= protect_with_terminate (cleanup
);
3152 expand_eh_region_end (cleanup
);
3158 use_variable (DECL_RTL (iterator
));
3163 use_variable (DECL_RTL (rval
));
3167 /* Free up storage of type TYPE, at address ADDR.
3169 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
3172 VIRTUAL_SIZE is the amount of storage that was allocated, and is
3173 used as the second argument to operator delete. It can include
3174 things like padding and magic size cookies. It has virtual in it,
3175 because if you have a base pointer and you delete through a virtual
3176 destructor, it should be the size of the dynamic object, not the
3177 static object, see Free Store 12.5 ANSI C++ WP.
3179 This does not call any destructors. */
3182 build_x_delete (type
, addr
, which_delete
, virtual_size
)
3187 int use_global_delete
= which_delete
& 1;
3188 int use_vec_delete
= !!(which_delete
& 2);
3190 enum tree_code code
= use_vec_delete
? VEC_DELETE_EXPR
: DELETE_EXPR
;
3192 if (! use_global_delete
&& TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
3193 && (TYPE_GETS_DELETE (TREE_TYPE (type
)) & (1 << use_vec_delete
)))
3194 rval
= build_opfncall (code
, LOOKUP_NORMAL
, addr
, virtual_size
, NULL_TREE
);
3196 rval
= build_builtin_call (void_type_node
, use_vec_delete
? BIVD
: BID
,
3197 build_expr_list (NULL_TREE
, addr
));
3201 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3202 ADDR is an expression which yields the store to be destroyed.
3203 AUTO_DELETE is nonzero if a call to DELETE should be made or not.
3204 If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the
3205 virtual baseclasses.
3206 If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate.
3208 FLAGS is the logical disjunction of zero or more LOOKUP_
3209 flags. See cp-tree.h for more info.
3211 This function does not delete an object's virtual base classes. */
3214 build_delete (type
, addr
, auto_delete
, flags
, use_global_delete
)
3218 int use_global_delete
;
3224 if (addr
== error_mark_node
)
3225 return error_mark_node
;
3227 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3228 set to `error_mark_node' before it gets properly cleaned up. */
3229 if (type
== error_mark_node
)
3230 return error_mark_node
;
3232 type
= TYPE_MAIN_VARIANT (type
);
3234 if (TREE_CODE (type
) == POINTER_TYPE
)
3236 type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
3237 if (TYPE_SIZE (complete_type (type
)) == 0)
3239 incomplete_type_error (0, type
);
3240 return error_mark_node
;
3242 if (TREE_CODE (type
) == ARRAY_TYPE
)
3244 if (! IS_AGGR_TYPE (type
))
3246 /* Call the builtin operator delete. */
3247 return build_builtin_call (void_type_node
, BID
,
3248 build_expr_list (NULL_TREE
, addr
));
3250 if (TREE_SIDE_EFFECTS (addr
))
3251 addr
= save_expr (addr
);
3253 /* throw away const and volatile on target type of addr */
3254 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3255 ref
= build_indirect_ref (addr
, NULL_PTR
);
3257 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3260 if (TREE_SIDE_EFFECTS (addr
))
3261 addr
= save_expr (addr
);
3262 if (TYPE_DOMAIN (type
) == NULL_TREE
)
3264 error ("unknown array size in delete");
3265 return error_mark_node
;
3267 return build_vec_delete (addr
, array_type_nelts (type
),
3268 auto_delete
, integer_two_node
,
3273 /* Don't check PROTECT here; leave that decision to the
3274 destructor. If the destructor is accessible, call it,
3275 else report error. */
3276 addr
= build_unary_op (ADDR_EXPR
, addr
, 0);
3277 if (TREE_SIDE_EFFECTS (addr
))
3278 addr
= save_expr (addr
);
3280 if (TREE_CONSTANT (addr
))
3281 addr
= convert_pointer_to (type
, addr
);
3283 addr
= convert_force (build_pointer_type (type
), addr
, 0);
3285 ref
= build_indirect_ref (addr
, NULL_PTR
);
3288 my_friendly_assert (IS_AGGR_TYPE (type
), 220);
3290 if (! TYPE_NEEDS_DESTRUCTOR (type
))
3292 if (auto_delete
== integer_zero_node
)
3293 return void_zero_node
;
3295 /* Pass the size of the object down to the operator delete() in
3296 addition to the ADDR. */
3297 if (TYPE_GETS_REG_DELETE (type
) && !use_global_delete
)
3299 tree virtual_size
= c_sizeof_nowarn (type
);
3300 return build_opfncall (DELETE_EXPR
, LOOKUP_NORMAL
, addr
,
3301 virtual_size
, NULL_TREE
);
3304 /* Call the builtin operator delete. */
3305 return build_builtin_call (void_type_node
, BID
,
3306 build_expr_list (NULL_TREE
, addr
));
3309 /* Below, we will reverse the order in which these calls are made.
3310 If we have a destructor, then that destructor will take care
3311 of the base classes; otherwise, we must do that here. */
3312 if (TYPE_HAS_DESTRUCTOR (type
))
3314 tree passed_auto_delete
;
3315 tree do_delete
= NULL_TREE
;
3318 if (use_global_delete
)
3320 tree cond
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3321 auto_delete
, integer_one_node
));
3322 tree call
= build_builtin_call
3323 (void_type_node
, BID
, build_expr_list (NULL_TREE
, addr
));
3325 cond
= fold (build (COND_EXPR
, void_type_node
, cond
,
3326 call
, void_zero_node
));
3327 if (cond
!= void_zero_node
)
3330 passed_auto_delete
= fold (build (BIT_AND_EXPR
, integer_type_node
,
3331 auto_delete
, integer_two_node
));
3334 passed_auto_delete
= auto_delete
;
3336 expr
= build_method_call
3337 (ref
, dtor_identifier
, build_expr_list (NULL_TREE
, passed_auto_delete
),
3341 expr
= build (COMPOUND_EXPR
, void_type_node
, expr
, do_delete
);
3343 if (flags
& LOOKUP_DESTRUCTOR
)
3344 /* Explicit destructor call; don't check for null pointer. */
3345 ifexp
= integer_one_node
;
3347 /* Handle deleting a null pointer. */
3348 ifexp
= fold (build_binary_op (NE_EXPR
, addr
, integer_zero_node
, 1));
3350 if (ifexp
!= integer_one_node
)
3351 expr
= build (COND_EXPR
, void_type_node
,
3352 ifexp
, expr
, void_zero_node
);
3358 /* We only get here from finish_function for a destructor. */
3359 tree binfos
= BINFO_BASETYPES (TYPE_BINFO (type
));
3360 int i
, n_baseclasses
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3361 tree base_binfo
= n_baseclasses
> 0 ? TREE_VEC_ELT (binfos
, 0) : NULL_TREE
;
3362 tree exprstmt
= NULL_TREE
;
3363 tree parent_auto_delete
= auto_delete
;
3366 /* If we have member delete or vbases, we call delete in
3368 if (auto_delete
== integer_zero_node
)
3370 else if (base_binfo
== NULL_TREE
3371 || ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3373 cond
= build (COND_EXPR
, void_type_node
,
3374 build (BIT_AND_EXPR
, integer_type_node
, auto_delete
, integer_one_node
),
3375 build_builtin_call (void_type_node
, BID
,
3376 build_expr_list (NULL_TREE
, addr
)),
3383 exprstmt
= build_expr_list (NULL_TREE
, cond
);
3386 && ! TREE_VIA_VIRTUAL (base_binfo
)
3387 && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
)))
3389 tree this_auto_delete
;
3391 if (BINFO_OFFSET_ZEROP (base_binfo
))
3392 this_auto_delete
= parent_auto_delete
;
3394 this_auto_delete
= integer_zero_node
;
3396 expr
= build_scoped_method_call
3397 (ref
, base_binfo
, dtor_identifier
,
3398 build_expr_list (NULL_TREE
, this_auto_delete
));
3399 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3402 /* Take care of the remaining baseclasses. */
3403 for (i
= 1; i
< n_baseclasses
; i
++)
3405 base_binfo
= TREE_VEC_ELT (binfos
, i
);
3406 if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo
))
3407 || TREE_VIA_VIRTUAL (base_binfo
))
3410 expr
= build_scoped_method_call
3411 (ref
, base_binfo
, dtor_identifier
,
3412 build_expr_list (NULL_TREE
, integer_zero_node
));
3414 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3417 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
3419 if (TREE_CODE (member
) != FIELD_DECL
)
3421 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member
)))
3423 tree this_member
= build_component_ref (ref
, DECL_NAME (member
), NULL_TREE
, 0);
3424 tree this_type
= TREE_TYPE (member
);
3425 expr
= build_delete (this_type
, this_member
, integer_two_node
, flags
, 0);
3426 exprstmt
= expr_tree_cons (NULL_TREE
, expr
, exprstmt
);
3431 return build_compound_expr (exprstmt
);
3432 /* Virtual base classes make this function do nothing. */
3433 return void_zero_node
;
3437 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3440 build_vbase_delete (type
, decl
)
3443 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
3444 tree result
= NULL_TREE
;
3445 tree addr
= build_unary_op (ADDR_EXPR
, decl
, 0);
3447 my_friendly_assert (addr
!= error_mark_node
, 222);
3451 tree this_addr
= convert_force (build_pointer_type (BINFO_TYPE (vbases
)),
3453 result
= expr_tree_cons (NULL_TREE
,
3454 build_delete (TREE_TYPE (this_addr
), this_addr
,
3456 LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
, 0),
3458 vbases
= TREE_CHAIN (vbases
);
3460 return build_compound_expr (nreverse (result
));
3463 /* Build a C++ vector delete expression.
3464 MAXINDEX is the number of elements to be deleted.
3465 ELT_SIZE is the nominal size of each element in the vector.
3466 BASE is the expression that should yield the store to be deleted.
3467 This function expands (or synthesizes) these calls itself.
3468 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3469 AUTO_DELETE say whether each item in the container should be deallocated.
3471 This also calls delete for virtual baseclasses of elements of the vector.
3473 Update: MAXINDEX is no longer needed. The size can be extracted from the
3474 start of the vector for pointers, and from the type for arrays. We still
3475 use MAXINDEX for arrays because it happens to already have one of the
3476 values we'd have to extract. (We could use MAXINDEX with pointers to
3477 confirm the size, and trap if the numbers differ; not clear that it'd
3478 be worth bothering.) */
3481 build_vec_delete (base
, maxindex
, auto_delete_vec
, auto_delete
,
3483 tree base
, maxindex
;
3484 tree auto_delete_vec
, auto_delete
;
3485 int use_global_delete
;
3489 if (TREE_CODE (base
) == OFFSET_REF
)
3490 base
= resolve_offset_ref (base
);
3492 type
= TREE_TYPE (base
);
3494 base
= stabilize_reference (base
);
3496 /* Since we can use base many times, save_expr it. */
3497 if (TREE_SIDE_EFFECTS (base
))
3498 base
= save_expr (base
);
3500 if (TREE_CODE (type
) == POINTER_TYPE
)
3502 /* Step back one from start of vector, and read dimension. */
3503 tree cookie_addr
= build (MINUS_EXPR
, build_pointer_type (BI_header_type
),
3504 base
, BI_header_size
);
3505 tree cookie
= build_indirect_ref (cookie_addr
, NULL_PTR
);
3506 maxindex
= build_component_ref (cookie
, nc_nelts_field_id
, NULL_TREE
, 0);
3508 type
= TREE_TYPE (type
);
3509 while (TREE_CODE (type
) == ARRAY_TYPE
);
3511 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3513 /* get the total number of things in the array, maxindex is a bad name */
3514 maxindex
= array_type_nelts_total (type
);
3515 while (TREE_CODE (type
) == ARRAY_TYPE
)
3516 type
= TREE_TYPE (type
);
3517 base
= build_unary_op (ADDR_EXPR
, base
, 1);
3521 if (base
!= error_mark_node
)
3522 error ("type to vector delete is neither pointer or array type");
3523 return error_mark_node
;
3526 return build_vec_delete_1 (base
, maxindex
, type
, auto_delete_vec
, auto_delete
,