1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* High-level class interface. */
28 #include "coretypes.h"
39 #include "tree-dump.h"
41 /* The number of nested classes being processed. If we are not in the
42 scope of any class, this is zero. */
44 int current_class_depth
;
46 /* In order to deal with nested classes, we keep a stack of classes.
47 The topmost entry is the innermost class, and is the entry at index
48 CURRENT_CLASS_DEPTH */
50 typedef struct class_stack_node
{
51 /* The name of the class. */
54 /* The _TYPE node for the class. */
57 /* The access specifier pending for new declarations in the scope of
61 /* If were defining TYPE, the names used in this class. */
62 splay_tree names_used
;
64 /* Nonzero if this class is no longer open, because of a call to
67 }* class_stack_node_t
;
69 typedef struct vtbl_init_data_s
71 /* The base for which we're building initializers. */
73 /* The type of the most-derived type. */
75 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
76 unless ctor_vtbl_p is true. */
78 /* The negative-index vtable initializers built up so far. These
79 are in order from least negative index to most negative index. */
81 /* The last (i.e., most negative) entry in INITS. */
83 /* The binfo for the virtual base for which we're building
84 vcall offset initializers. */
86 /* The functions in vbase for which we have already provided vcall
89 /* The vtable index of the next vcall or vbase offset. */
91 /* Nonzero if we are building the initializer for the primary
94 /* Nonzero if we are building the initializer for a construction
97 /* True when adding vcall offset entries to the vtable. False when
98 merely computing the indices. */
99 bool generate_vcall_entries
;
102 /* The type of a function passed to walk_subobject_offsets. */
103 typedef int (*subobject_offset_fn
) (tree
, tree
, splay_tree
);
105 /* The stack itself. This is a dynamically resized array. The
106 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
107 static int current_class_stack_size
;
108 static class_stack_node_t current_class_stack
;
110 /* The size of the largest empty class seen in this translation unit. */
111 static GTY (()) tree sizeof_biggest_empty_class
;
113 /* An array of all local classes present in this translation unit, in
114 declaration order. */
115 VEC(tree
,gc
) *local_classes
;
117 static tree
get_vfield_name (tree
);
118 static void finish_struct_anon (tree
);
119 static tree
get_vtable_name (tree
);
120 static tree
get_basefndecls (tree
, tree
);
121 static int build_primary_vtable (tree
, tree
);
122 static int build_secondary_vtable (tree
);
123 static void finish_vtbls (tree
);
124 static void modify_vtable_entry (tree
, tree
, tree
, tree
, tree
*);
125 static void finish_struct_bits (tree
);
126 static int alter_access (tree
, tree
, tree
);
127 static void handle_using_decl (tree
, tree
);
128 static tree
dfs_modify_vtables (tree
, void *);
129 static tree
modify_all_vtables (tree
, tree
);
130 static void determine_primary_bases (tree
);
131 static void finish_struct_methods (tree
);
132 static void maybe_warn_about_overly_private_class (tree
);
133 static int method_name_cmp (const void *, const void *);
134 static int resort_method_name_cmp (const void *, const void *);
135 static void add_implicitly_declared_members (tree
, int, int);
136 static tree
fixed_type_or_null (tree
, int *, int *);
137 static tree
build_simple_base_path (tree expr
, tree binfo
);
138 static tree
build_vtbl_ref_1 (tree
, tree
);
139 static tree
build_vtbl_initializer (tree
, tree
, tree
, tree
, int *);
140 static int count_fields (tree
);
141 static int add_fields_to_record_type (tree
, struct sorted_fields_type
*, int);
142 static bool check_bitfield_decl (tree
);
143 static void check_field_decl (tree
, tree
, int *, int *, int *);
144 static void check_field_decls (tree
, tree
*, int *, int *);
145 static tree
*build_base_field (record_layout_info
, tree
, splay_tree
, tree
*);
146 static void build_base_fields (record_layout_info
, splay_tree
, tree
*);
147 static void check_methods (tree
);
148 static void remove_zero_width_bit_fields (tree
);
149 static void check_bases (tree
, int *, int *);
150 static void check_bases_and_members (tree
);
151 static tree
create_vtable_ptr (tree
, tree
*);
152 static void include_empty_classes (record_layout_info
);
153 static void layout_class_type (tree
, tree
*);
154 static void propagate_binfo_offsets (tree
, tree
);
155 static void layout_virtual_bases (record_layout_info
, splay_tree
);
156 static void build_vbase_offset_vtbl_entries (tree
, vtbl_init_data
*);
157 static void add_vcall_offset_vtbl_entries_r (tree
, vtbl_init_data
*);
158 static void add_vcall_offset_vtbl_entries_1 (tree
, vtbl_init_data
*);
159 static void build_vcall_offset_vtbl_entries (tree
, vtbl_init_data
*);
160 static void add_vcall_offset (tree
, tree
, vtbl_init_data
*);
161 static void layout_vtable_decl (tree
, int);
162 static tree
dfs_find_final_overrider_pre (tree
, void *);
163 static tree
dfs_find_final_overrider_post (tree
, void *);
164 static tree
find_final_overrider (tree
, tree
, tree
);
165 static int make_new_vtable (tree
, tree
);
166 static tree
get_primary_binfo (tree
);
167 static int maybe_indent_hierarchy (FILE *, int, int);
168 static tree
dump_class_hierarchy_r (FILE *, int, tree
, tree
, int);
169 static void dump_class_hierarchy (tree
);
170 static void dump_class_hierarchy_1 (FILE *, int, tree
);
171 static void dump_array (FILE *, tree
);
172 static void dump_vtable (tree
, tree
, tree
);
173 static void dump_vtt (tree
, tree
);
174 static void dump_thunk (FILE *, int, tree
);
175 static tree
build_vtable (tree
, tree
, tree
);
176 static void initialize_vtable (tree
, tree
);
177 static void layout_nonempty_base_or_field (record_layout_info
,
178 tree
, tree
, splay_tree
);
179 static tree
end_of_class (tree
, int);
180 static bool layout_empty_base (record_layout_info
, tree
, tree
, splay_tree
);
181 static void accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
);
182 static tree
dfs_accumulate_vtbl_inits (tree
, tree
, tree
, tree
,
184 static void build_rtti_vtbl_entries (tree
, vtbl_init_data
*);
185 static void build_vcall_and_vbase_vtbl_entries (tree
, vtbl_init_data
*);
186 static void clone_constructors_and_destructors (tree
);
187 static tree
build_clone (tree
, tree
);
188 static void update_vtable_entry_for_fn (tree
, tree
, tree
, tree
*, unsigned);
189 static void build_ctor_vtbl_group (tree
, tree
);
190 static void build_vtt (tree
);
191 static tree
binfo_ctor_vtable (tree
);
192 static tree
*build_vtt_inits (tree
, tree
, tree
*, tree
*);
193 static tree
dfs_build_secondary_vptr_vtt_inits (tree
, void *);
194 static tree
dfs_fixup_binfo_vtbls (tree
, void *);
195 static int record_subobject_offset (tree
, tree
, splay_tree
);
196 static int check_subobject_offset (tree
, tree
, splay_tree
);
197 static int walk_subobject_offsets (tree
, subobject_offset_fn
,
198 tree
, splay_tree
, tree
, int);
199 static void record_subobject_offsets (tree
, tree
, splay_tree
, bool);
200 static int layout_conflict_p (tree
, tree
, splay_tree
, int);
201 static int splay_tree_compare_integer_csts (splay_tree_key k1
,
203 static void warn_about_ambiguous_bases (tree
);
204 static bool type_requires_array_cookie (tree
);
205 static bool contains_empty_class_p (tree
);
206 static bool base_derived_from (tree
, tree
);
207 static int empty_base_at_nonzero_offset_p (tree
, tree
, splay_tree
);
208 static tree
end_of_base (tree
);
209 static tree
get_vcall_index (tree
, tree
);
211 /* Variables shared between class.c and call.c. */
213 #ifdef GATHER_STATISTICS
215 int n_vtable_entries
= 0;
216 int n_vtable_searches
= 0;
217 int n_vtable_elems
= 0;
218 int n_convert_harshness
= 0;
219 int n_compute_conversion_costs
= 0;
220 int n_inner_fields_searched
= 0;
223 /* Convert to or from a base subobject. EXPR is an expression of type
224 `A' or `A*', an expression of type `B' or `B*' is returned. To
225 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
226 the B base instance within A. To convert base A to derived B, CODE
227 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
228 In this latter case, A must not be a morally virtual base of B.
229 NONNULL is true if EXPR is known to be non-NULL (this is only
230 needed when EXPR is of pointer type). CV qualifiers are preserved
234 build_base_path (enum tree_code code
,
239 tree v_binfo
= NULL_TREE
;
240 tree d_binfo
= NULL_TREE
;
244 tree null_test
= NULL
;
245 tree ptr_target_type
;
247 int want_pointer
= TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
;
248 bool has_empty
= false;
251 if (expr
== error_mark_node
|| binfo
== error_mark_node
|| !binfo
)
252 return error_mark_node
;
254 for (probe
= binfo
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
257 if (is_empty_class (BINFO_TYPE (probe
)))
259 if (!v_binfo
&& BINFO_VIRTUAL_P (probe
))
263 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
265 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (probe
));
267 gcc_assert ((code
== MINUS_EXPR
268 && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), probe
))
269 || (code
== PLUS_EXPR
270 && SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo
), probe
)));
272 if (binfo
== d_binfo
)
276 if (code
== MINUS_EXPR
&& v_binfo
)
278 error ("cannot convert from base %qT to derived type %qT via virtual base %qT",
279 BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
), BINFO_TYPE (v_binfo
));
280 return error_mark_node
;
284 /* This must happen before the call to save_expr. */
285 expr
= cp_build_unary_op (ADDR_EXPR
, expr
, 0, tf_warning_or_error
);
287 offset
= BINFO_OFFSET (binfo
);
288 fixed_type_p
= resolves_to_fixed_type_p (expr
, &nonnull
);
289 target_type
= code
== PLUS_EXPR
? BINFO_TYPE (binfo
) : BINFO_TYPE (d_binfo
);
291 /* Do we need to look in the vtable for the real offset? */
292 virtual_access
= (v_binfo
&& fixed_type_p
<= 0);
294 /* Don't bother with the calculations inside sizeof; they'll ICE if the
295 source type is incomplete and the pointer value doesn't matter. */
296 if (cp_unevaluated_operand
!= 0)
298 expr
= build_nop (build_pointer_type (target_type
), expr
);
300 expr
= build_indirect_ref (EXPR_LOCATION (expr
), expr
, RO_NULL
);
304 /* Do we need to check for a null pointer? */
305 if (want_pointer
&& !nonnull
)
307 /* If we know the conversion will not actually change the value
308 of EXPR, then we can avoid testing the expression for NULL.
309 We have to avoid generating a COMPONENT_REF for a base class
310 field, because other parts of the compiler know that such
311 expressions are always non-NULL. */
312 if (!virtual_access
&& integer_zerop (offset
))
315 /* TARGET_TYPE has been extracted from BINFO, and, is
316 therefore always cv-unqualified. Extract the
317 cv-qualifiers from EXPR so that the expression returned
318 matches the input. */
319 class_type
= TREE_TYPE (TREE_TYPE (expr
));
321 = cp_build_qualified_type (target_type
,
322 cp_type_quals (class_type
));
323 return build_nop (build_pointer_type (target_type
), expr
);
325 null_test
= error_mark_node
;
328 /* Protect against multiple evaluation if necessary. */
329 if (TREE_SIDE_EFFECTS (expr
) && (null_test
|| virtual_access
))
330 expr
= save_expr (expr
);
332 /* Now that we've saved expr, build the real null test. */
335 tree zero
= cp_convert (TREE_TYPE (expr
), integer_zero_node
);
336 null_test
= fold_build2_loc (input_location
, NE_EXPR
, boolean_type_node
,
340 /* If this is a simple base reference, express it as a COMPONENT_REF. */
341 if (code
== PLUS_EXPR
&& !virtual_access
342 /* We don't build base fields for empty bases, and they aren't very
343 interesting to the optimizers anyway. */
346 expr
= cp_build_indirect_ref (expr
, RO_NULL
, tf_warning_or_error
);
347 expr
= build_simple_base_path (expr
, binfo
);
349 expr
= build_address (expr
);
350 target_type
= TREE_TYPE (expr
);
356 /* Going via virtual base V_BINFO. We need the static offset
357 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
358 V_BINFO. That offset is an entry in D_BINFO's vtable. */
361 if (fixed_type_p
< 0 && in_base_initializer
)
363 /* In a base member initializer, we cannot rely on the
364 vtable being set up. We have to indirect via the
368 t
= TREE_TYPE (TYPE_VFIELD (current_class_type
));
369 t
= build_pointer_type (t
);
370 v_offset
= convert (t
, current_vtt_parm
);
371 v_offset
= cp_build_indirect_ref (v_offset
, RO_NULL
,
372 tf_warning_or_error
);
375 v_offset
= build_vfield_ref (cp_build_indirect_ref (expr
, RO_NULL
,
376 tf_warning_or_error
),
377 TREE_TYPE (TREE_TYPE (expr
)));
379 v_offset
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (v_offset
),
380 v_offset
, fold_convert (sizetype
, BINFO_VPTR_FIELD (v_binfo
)));
381 v_offset
= build1 (NOP_EXPR
,
382 build_pointer_type (ptrdiff_type_node
),
384 v_offset
= cp_build_indirect_ref (v_offset
, RO_NULL
, tf_warning_or_error
);
385 TREE_CONSTANT (v_offset
) = 1;
387 offset
= convert_to_integer (ptrdiff_type_node
,
388 size_diffop_loc (input_location
, offset
,
389 BINFO_OFFSET (v_binfo
)));
391 if (!integer_zerop (offset
))
392 v_offset
= build2 (code
, ptrdiff_type_node
, v_offset
, offset
);
394 if (fixed_type_p
< 0)
395 /* Negative fixed_type_p means this is a constructor or destructor;
396 virtual base layout is fixed in in-charge [cd]tors, but not in
398 offset
= build3 (COND_EXPR
, ptrdiff_type_node
,
399 build2 (EQ_EXPR
, boolean_type_node
,
400 current_in_charge_parm
, integer_zero_node
),
402 convert_to_integer (ptrdiff_type_node
,
403 BINFO_OFFSET (binfo
)));
408 target_type
= cp_build_qualified_type
409 (target_type
, cp_type_quals (TREE_TYPE (TREE_TYPE (expr
))));
410 ptr_target_type
= build_pointer_type (target_type
);
412 target_type
= ptr_target_type
;
414 expr
= build1 (NOP_EXPR
, ptr_target_type
, expr
);
416 if (!integer_zerop (offset
))
418 offset
= fold_convert (sizetype
, offset
);
419 if (code
== MINUS_EXPR
)
420 offset
= fold_build1_loc (input_location
, NEGATE_EXPR
, sizetype
, offset
);
421 expr
= build2 (POINTER_PLUS_EXPR
, ptr_target_type
, expr
, offset
);
427 expr
= cp_build_indirect_ref (expr
, RO_NULL
, tf_warning_or_error
);
431 expr
= fold_build3_loc (input_location
, COND_EXPR
, target_type
, null_test
, expr
,
432 fold_build1_loc (input_location
, NOP_EXPR
, target_type
,
438 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
439 Perform a derived-to-base conversion by recursively building up a
440 sequence of COMPONENT_REFs to the appropriate base fields. */
443 build_simple_base_path (tree expr
, tree binfo
)
445 tree type
= BINFO_TYPE (binfo
);
446 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
449 if (d_binfo
== NULL_TREE
)
453 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)) == type
);
455 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
456 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
457 an lvalue in the front end; only _DECLs and _REFs are lvalues
459 temp
= unary_complex_lvalue (ADDR_EXPR
, expr
);
461 expr
= cp_build_indirect_ref (temp
, RO_NULL
, tf_warning_or_error
);
467 expr
= build_simple_base_path (expr
, d_binfo
);
469 for (field
= TYPE_FIELDS (BINFO_TYPE (d_binfo
));
470 field
; field
= TREE_CHAIN (field
))
471 /* Is this the base field created by build_base_field? */
472 if (TREE_CODE (field
) == FIELD_DECL
473 && DECL_FIELD_IS_BASE (field
)
474 && TREE_TYPE (field
) == type
)
476 /* We don't use build_class_member_access_expr here, as that
477 has unnecessary checks, and more importantly results in
478 recursive calls to dfs_walk_once. */
479 int type_quals
= cp_type_quals (TREE_TYPE (expr
));
481 expr
= build3 (COMPONENT_REF
,
482 cp_build_qualified_type (type
, type_quals
),
483 expr
, field
, NULL_TREE
);
484 expr
= fold_if_not_in_template (expr
);
486 /* Mark the expression const or volatile, as appropriate.
487 Even though we've dealt with the type above, we still have
488 to mark the expression itself. */
489 if (type_quals
& TYPE_QUAL_CONST
)
490 TREE_READONLY (expr
) = 1;
491 if (type_quals
& TYPE_QUAL_VOLATILE
)
492 TREE_THIS_VOLATILE (expr
) = 1;
497 /* Didn't find the base field?!? */
501 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
502 type is a class type or a pointer to a class type. In the former
503 case, TYPE is also a class type; in the latter it is another
504 pointer type. If CHECK_ACCESS is true, an error message is emitted
505 if TYPE is inaccessible. If OBJECT has pointer type, the value is
506 assumed to be non-NULL. */
509 convert_to_base (tree object
, tree type
, bool check_access
, bool nonnull
,
510 tsubst_flags_t complain
)
516 if (TYPE_PTR_P (TREE_TYPE (object
)))
518 object_type
= TREE_TYPE (TREE_TYPE (object
));
519 type
= TREE_TYPE (type
);
522 object_type
= TREE_TYPE (object
);
524 access
= check_access
? ba_check
: ba_unique
;
525 if (!(complain
& tf_error
))
527 binfo
= lookup_base (object_type
, type
,
530 if (!binfo
|| binfo
== error_mark_node
)
531 return error_mark_node
;
533 return build_base_path (PLUS_EXPR
, object
, binfo
, nonnull
);
536 /* EXPR is an expression with unqualified class type. BASE is a base
537 binfo of that class type. Returns EXPR, converted to the BASE
538 type. This function assumes that EXPR is the most derived class;
539 therefore virtual bases can be found at their static offsets. */
542 convert_to_base_statically (tree expr
, tree base
)
546 expr_type
= TREE_TYPE (expr
);
547 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base
), expr_type
))
551 pointer_type
= build_pointer_type (expr_type
);
553 /* We use fold_build2 and fold_convert below to simplify the trees
554 provided to the optimizers. It is not safe to call these functions
555 when processing a template because they do not handle C++-specific
557 gcc_assert (!processing_template_decl
);
558 expr
= cp_build_unary_op (ADDR_EXPR
, expr
, /*noconvert=*/1,
559 tf_warning_or_error
);
560 if (!integer_zerop (BINFO_OFFSET (base
)))
561 expr
= fold_build2_loc (input_location
,
562 POINTER_PLUS_EXPR
, pointer_type
, expr
,
563 fold_convert (sizetype
, BINFO_OFFSET (base
)));
564 expr
= fold_convert (build_pointer_type (BINFO_TYPE (base
)), expr
);
565 expr
= build_fold_indirect_ref_loc (input_location
, expr
);
573 build_vfield_ref (tree datum
, tree type
)
575 tree vfield
, vcontext
;
577 if (datum
== error_mark_node
)
578 return error_mark_node
;
580 /* First, convert to the requested type. */
581 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum
), type
))
582 datum
= convert_to_base (datum
, type
, /*check_access=*/false,
583 /*nonnull=*/true, tf_warning_or_error
);
585 /* Second, the requested type may not be the owner of its own vptr.
586 If not, convert to the base class that owns it. We cannot use
587 convert_to_base here, because VCONTEXT may appear more than once
588 in the inheritance hierarchy of TYPE, and thus direct conversion
589 between the types may be ambiguous. Following the path back up
590 one step at a time via primary bases avoids the problem. */
591 vfield
= TYPE_VFIELD (type
);
592 vcontext
= DECL_CONTEXT (vfield
);
593 while (!same_type_ignoring_top_level_qualifiers_p (vcontext
, type
))
595 datum
= build_simple_base_path (datum
, CLASSTYPE_PRIMARY_BINFO (type
));
596 type
= TREE_TYPE (datum
);
599 return build3 (COMPONENT_REF
, TREE_TYPE (vfield
), datum
, vfield
, NULL_TREE
);
602 /* Given an object INSTANCE, return an expression which yields the
603 vtable element corresponding to INDEX. There are many special
604 cases for INSTANCE which we take care of here, mainly to avoid
605 creating extra tree nodes when we don't have to. */
608 build_vtbl_ref_1 (tree instance
, tree idx
)
611 tree vtbl
= NULL_TREE
;
613 /* Try to figure out what a reference refers to, and
614 access its virtual function table directly. */
617 tree fixed_type
= fixed_type_or_null (instance
, NULL
, &cdtorp
);
619 tree basetype
= non_reference (TREE_TYPE (instance
));
621 if (fixed_type
&& !cdtorp
)
623 tree binfo
= lookup_base (fixed_type
, basetype
,
624 ba_unique
| ba_quiet
, NULL
);
626 vtbl
= unshare_expr (BINFO_VTABLE (binfo
));
630 vtbl
= build_vfield_ref (instance
, basetype
);
632 aref
= build_array_ref (input_location
, vtbl
, idx
);
633 TREE_CONSTANT (aref
) |= TREE_CONSTANT (vtbl
) && TREE_CONSTANT (idx
);
639 build_vtbl_ref (tree instance
, tree idx
)
641 tree aref
= build_vtbl_ref_1 (instance
, idx
);
646 /* Given a stable object pointer INSTANCE_PTR, return an expression which
647 yields a function pointer corresponding to vtable element INDEX. */
650 build_vfn_ref (tree instance_ptr
, tree idx
)
654 aref
= build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr
, RO_NULL
,
655 tf_warning_or_error
),
658 /* When using function descriptors, the address of the
659 vtable entry is treated as a function pointer. */
660 if (TARGET_VTABLE_USES_DESCRIPTORS
)
661 aref
= build1 (NOP_EXPR
, TREE_TYPE (aref
),
662 cp_build_unary_op (ADDR_EXPR
, aref
, /*noconvert=*/1,
663 tf_warning_or_error
));
665 /* Remember this as a method reference, for later devirtualization. */
666 aref
= build3 (OBJ_TYPE_REF
, TREE_TYPE (aref
), aref
, instance_ptr
, idx
);
671 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
672 for the given TYPE. */
675 get_vtable_name (tree type
)
677 return mangle_vtbl_for_type (type
);
680 /* DECL is an entity associated with TYPE, like a virtual table or an
681 implicitly generated constructor. Determine whether or not DECL
682 should have external or internal linkage at the object file
683 level. This routine does not deal with COMDAT linkage and other
684 similar complexities; it simply sets TREE_PUBLIC if it possible for
685 entities in other translation units to contain copies of DECL, in
689 set_linkage_according_to_type (tree type
, tree decl
)
691 /* If TYPE involves a local class in a function with internal
692 linkage, then DECL should have internal linkage too. Other local
693 classes have no linkage -- but if their containing functions
694 have external linkage, it makes sense for DECL to have external
695 linkage too. That will allow template definitions to be merged,
697 if (no_linkage_check (type
, /*relaxed_p=*/true))
699 TREE_PUBLIC (decl
) = 0;
700 DECL_INTERFACE_KNOWN (decl
) = 1;
703 TREE_PUBLIC (decl
) = 1;
706 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
707 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
708 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
711 build_vtable (tree class_type
, tree name
, tree vtable_type
)
715 decl
= build_lang_decl (VAR_DECL
, name
, vtable_type
);
716 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
717 now to avoid confusion in mangle_decl. */
718 SET_DECL_ASSEMBLER_NAME (decl
, name
);
719 DECL_CONTEXT (decl
) = class_type
;
720 DECL_ARTIFICIAL (decl
) = 1;
721 TREE_STATIC (decl
) = 1;
722 TREE_READONLY (decl
) = 1;
723 DECL_VIRTUAL_P (decl
) = 1;
724 DECL_ALIGN (decl
) = TARGET_VTABLE_ENTRY_ALIGN
;
725 DECL_VTABLE_OR_VTT_P (decl
) = 1;
726 /* At one time the vtable info was grabbed 2 words at a time. This
727 fails on sparc unless you have 8-byte alignment. (tiemann) */
728 DECL_ALIGN (decl
) = MAX (TYPE_ALIGN (double_type_node
),
730 set_linkage_according_to_type (class_type
, decl
);
731 /* The vtable has not been defined -- yet. */
732 DECL_EXTERNAL (decl
) = 1;
733 DECL_NOT_REALLY_EXTERN (decl
) = 1;
735 /* Mark the VAR_DECL node representing the vtable itself as a
736 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
737 is rather important that such things be ignored because any
738 effort to actually generate DWARF for them will run into
739 trouble when/if we encounter code like:
742 struct S { virtual void member (); };
744 because the artificial declaration of the vtable itself (as
745 manufactured by the g++ front end) will say that the vtable is
746 a static member of `S' but only *after* the debug output for
747 the definition of `S' has already been output. This causes
748 grief because the DWARF entry for the definition of the vtable
749 will try to refer back to an earlier *declaration* of the
750 vtable as a static member of `S' and there won't be one. We
751 might be able to arrange to have the "vtable static member"
752 attached to the member list for `S' before the debug info for
753 `S' get written (which would solve the problem) but that would
754 require more intrusive changes to the g++ front end. */
755 DECL_IGNORED_P (decl
) = 1;
760 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
761 or even complete. If this does not exist, create it. If COMPLETE is
762 nonzero, then complete the definition of it -- that will render it
763 impossible to actually build the vtable, but is useful to get at those
764 which are known to exist in the runtime. */
767 get_vtable_decl (tree type
, int complete
)
771 if (CLASSTYPE_VTABLES (type
))
772 return CLASSTYPE_VTABLES (type
);
774 decl
= build_vtable (type
, get_vtable_name (type
), vtbl_type_node
);
775 CLASSTYPE_VTABLES (type
) = decl
;
779 DECL_EXTERNAL (decl
) = 1;
780 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
786 /* Build the primary virtual function table for TYPE. If BINFO is
787 non-NULL, build the vtable starting with the initial approximation
788 that it is the same as the one which is the head of the association
789 list. Returns a nonzero value if a new vtable is actually
793 build_primary_vtable (tree binfo
, tree type
)
798 decl
= get_vtable_decl (type
, /*complete=*/0);
802 if (BINFO_NEW_VTABLE_MARKED (binfo
))
803 /* We have already created a vtable for this base, so there's
804 no need to do it again. */
807 virtuals
= copy_list (BINFO_VIRTUALS (binfo
));
808 TREE_TYPE (decl
) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo
));
809 DECL_SIZE (decl
) = TYPE_SIZE (TREE_TYPE (decl
));
810 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
814 gcc_assert (TREE_TYPE (decl
) == vtbl_type_node
);
815 virtuals
= NULL_TREE
;
818 #ifdef GATHER_STATISTICS
820 n_vtable_elems
+= list_length (virtuals
);
823 /* Initialize the association list for this type, based
824 on our first approximation. */
825 BINFO_VTABLE (TYPE_BINFO (type
)) = decl
;
826 BINFO_VIRTUALS (TYPE_BINFO (type
)) = virtuals
;
827 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type
));
831 /* Give BINFO a new virtual function table which is initialized
832 with a skeleton-copy of its original initialization. The only
833 entry that changes is the `delta' entry, so we can really
834 share a lot of structure.
836 FOR_TYPE is the most derived type which caused this table to
839 Returns nonzero if we haven't met BINFO before.
841 The order in which vtables are built (by calling this function) for
842 an object must remain the same, otherwise a binary incompatibility
846 build_secondary_vtable (tree binfo
)
848 if (BINFO_NEW_VTABLE_MARKED (binfo
))
849 /* We already created a vtable for this base. There's no need to
853 /* Remember that we've created a vtable for this BINFO, so that we
854 don't try to do so again. */
855 SET_BINFO_NEW_VTABLE_MARKED (binfo
);
857 /* Make fresh virtual list, so we can smash it later. */
858 BINFO_VIRTUALS (binfo
) = copy_list (BINFO_VIRTUALS (binfo
));
860 /* Secondary vtables are laid out as part of the same structure as
861 the primary vtable. */
862 BINFO_VTABLE (binfo
) = NULL_TREE
;
866 /* Create a new vtable for BINFO which is the hierarchy dominated by
867 T. Return nonzero if we actually created a new vtable. */
870 make_new_vtable (tree t
, tree binfo
)
872 if (binfo
== TYPE_BINFO (t
))
873 /* In this case, it is *type*'s vtable we are modifying. We start
874 with the approximation that its vtable is that of the
875 immediate base class. */
876 return build_primary_vtable (binfo
, t
);
878 /* This is our very own copy of `basetype' to play with. Later,
879 we will fill in all the virtual functions that override the
880 virtual functions in these base classes which are not defined
881 by the current type. */
882 return build_secondary_vtable (binfo
);
885 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
886 (which is in the hierarchy dominated by T) list FNDECL as its
887 BV_FN. DELTA is the required constant adjustment from the `this'
888 pointer where the vtable entry appears to the `this' required when
889 the function is actually called. */
892 modify_vtable_entry (tree t
,
902 if (fndecl
!= BV_FN (v
)
903 || !tree_int_cst_equal (delta
, BV_DELTA (v
)))
905 /* We need a new vtable for BINFO. */
906 if (make_new_vtable (t
, binfo
))
908 /* If we really did make a new vtable, we also made a copy
909 of the BINFO_VIRTUALS list. Now, we have to find the
910 corresponding entry in that list. */
911 *virtuals
= BINFO_VIRTUALS (binfo
);
912 while (BV_FN (*virtuals
) != BV_FN (v
))
913 *virtuals
= TREE_CHAIN (*virtuals
);
917 BV_DELTA (v
) = delta
;
918 BV_VCALL_INDEX (v
) = NULL_TREE
;
924 /* Add method METHOD to class TYPE. If USING_DECL is non-null, it is
925 the USING_DECL naming METHOD. Returns true if the method could be
926 added to the method vec. */
929 add_method (tree type
, tree method
, tree using_decl
)
933 bool template_conv_p
= false;
935 VEC(tree
,gc
) *method_vec
;
937 bool insert_p
= false;
941 if (method
== error_mark_node
)
944 complete_p
= COMPLETE_TYPE_P (type
);
945 conv_p
= DECL_CONV_FN_P (method
);
947 template_conv_p
= (TREE_CODE (method
) == TEMPLATE_DECL
948 && DECL_TEMPLATE_CONV_FN_P (method
));
950 method_vec
= CLASSTYPE_METHOD_VEC (type
);
953 /* Make a new method vector. We start with 8 entries. We must
954 allocate at least two (for constructors and destructors), and
955 we're going to end up with an assignment operator at some
957 method_vec
= VEC_alloc (tree
, gc
, 8);
958 /* Create slots for constructors and destructors. */
959 VEC_quick_push (tree
, method_vec
, NULL_TREE
);
960 VEC_quick_push (tree
, method_vec
, NULL_TREE
);
961 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
964 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
965 grok_special_member_properties (method
);
967 /* Constructors and destructors go in special slots. */
968 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method
))
969 slot
= CLASSTYPE_CONSTRUCTOR_SLOT
;
970 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
972 slot
= CLASSTYPE_DESTRUCTOR_SLOT
;
974 if (TYPE_FOR_JAVA (type
))
976 if (!DECL_ARTIFICIAL (method
))
977 error ("Java class %qT cannot have a destructor", type
);
978 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
979 error ("Java class %qT cannot have an implicit non-trivial "
989 /* See if we already have an entry with this name. */
990 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
991 VEC_iterate (tree
, method_vec
, slot
, m
);
997 if (TREE_CODE (m
) == TEMPLATE_DECL
998 && DECL_TEMPLATE_CONV_FN_P (m
))
1002 if (conv_p
&& !DECL_CONV_FN_P (m
))
1004 if (DECL_NAME (m
) == DECL_NAME (method
))
1010 && !DECL_CONV_FN_P (m
)
1011 && DECL_NAME (m
) > DECL_NAME (method
))
1015 current_fns
= insert_p
? NULL_TREE
: VEC_index (tree
, method_vec
, slot
);
1017 /* Check to see if we've already got this method. */
1018 for (fns
= current_fns
; fns
; fns
= OVL_NEXT (fns
))
1020 tree fn
= OVL_CURRENT (fns
);
1026 if (TREE_CODE (fn
) != TREE_CODE (method
))
1029 /* [over.load] Member function declarations with the
1030 same name and the same parameter types cannot be
1031 overloaded if any of them is a static member
1032 function declaration.
1034 [namespace.udecl] When a using-declaration brings names
1035 from a base class into a derived class scope, member
1036 functions in the derived class override and/or hide member
1037 functions with the same name and parameter types in a base
1038 class (rather than conflicting). */
1039 fn_type
= TREE_TYPE (fn
);
1040 method_type
= TREE_TYPE (method
);
1041 parms1
= TYPE_ARG_TYPES (fn_type
);
1042 parms2
= TYPE_ARG_TYPES (method_type
);
1044 /* Compare the quals on the 'this' parm. Don't compare
1045 the whole types, as used functions are treated as
1046 coming from the using class in overload resolution. */
1047 if (! DECL_STATIC_FUNCTION_P (fn
)
1048 && ! DECL_STATIC_FUNCTION_P (method
)
1049 && TREE_TYPE (TREE_VALUE (parms1
)) != error_mark_node
1050 && TREE_TYPE (TREE_VALUE (parms2
)) != error_mark_node
1051 && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1
)))
1052 != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2
)))))
1055 /* For templates, the return type and template parameters
1056 must be identical. */
1057 if (TREE_CODE (fn
) == TEMPLATE_DECL
1058 && (!same_type_p (TREE_TYPE (fn_type
),
1059 TREE_TYPE (method_type
))
1060 || !comp_template_parms (DECL_TEMPLATE_PARMS (fn
),
1061 DECL_TEMPLATE_PARMS (method
))))
1064 if (! DECL_STATIC_FUNCTION_P (fn
))
1065 parms1
= TREE_CHAIN (parms1
);
1066 if (! DECL_STATIC_FUNCTION_P (method
))
1067 parms2
= TREE_CHAIN (parms2
);
1069 if (compparms (parms1
, parms2
)
1070 && (!DECL_CONV_FN_P (fn
)
1071 || same_type_p (TREE_TYPE (fn_type
),
1072 TREE_TYPE (method_type
))))
1076 if (DECL_CONTEXT (fn
) == type
)
1077 /* Defer to the local function. */
1079 if (DECL_CONTEXT (fn
) == DECL_CONTEXT (method
))
1080 error ("repeated using declaration %q+D", using_decl
);
1082 error ("using declaration %q+D conflicts with a previous using declaration",
1087 error ("%q+#D cannot be overloaded", method
);
1088 error ("with %q+#D", fn
);
1091 /* We don't call duplicate_decls here to merge the
1092 declarations because that will confuse things if the
1093 methods have inline definitions. In particular, we
1094 will crash while processing the definitions. */
1099 /* A class should never have more than one destructor. */
1100 if (current_fns
&& DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
1103 /* Add the new binding. */
1104 overload
= build_overload (method
, current_fns
);
1107 TYPE_HAS_CONVERSION (type
) = 1;
1108 else if (slot
>= CLASSTYPE_FIRST_CONVERSION_SLOT
&& !complete_p
)
1109 push_class_level_binding (DECL_NAME (method
), overload
);
1115 /* We only expect to add few methods in the COMPLETE_P case, so
1116 just make room for one more method in that case. */
1118 reallocated
= VEC_reserve_exact (tree
, gc
, method_vec
, 1);
1120 reallocated
= VEC_reserve (tree
, gc
, method_vec
, 1);
1122 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
1123 if (slot
== VEC_length (tree
, method_vec
))
1124 VEC_quick_push (tree
, method_vec
, overload
);
1126 VEC_quick_insert (tree
, method_vec
, slot
, overload
);
1129 /* Replace the current slot. */
1130 VEC_replace (tree
, method_vec
, slot
, overload
);
1134 /* Subroutines of finish_struct. */
1136 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1137 legit, otherwise return 0. */
1140 alter_access (tree t
, tree fdecl
, tree access
)
1144 if (!DECL_LANG_SPECIFIC (fdecl
))
1145 retrofit_lang_decl (fdecl
);
1147 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl
));
1149 elem
= purpose_member (t
, DECL_ACCESS (fdecl
));
1152 if (TREE_VALUE (elem
) != access
)
1154 if (TREE_CODE (TREE_TYPE (fdecl
)) == FUNCTION_DECL
)
1155 error ("conflicting access specifications for method"
1156 " %q+D, ignored", TREE_TYPE (fdecl
));
1158 error ("conflicting access specifications for field %qE, ignored",
1163 /* They're changing the access to the same thing they changed
1164 it to before. That's OK. */
1170 perform_or_defer_access_check (TYPE_BINFO (t
), fdecl
, fdecl
);
1171 DECL_ACCESS (fdecl
) = tree_cons (t
, access
, DECL_ACCESS (fdecl
));
1177 /* Process the USING_DECL, which is a member of T. */
1180 handle_using_decl (tree using_decl
, tree t
)
1182 tree decl
= USING_DECL_DECLS (using_decl
);
1183 tree name
= DECL_NAME (using_decl
);
1185 = TREE_PRIVATE (using_decl
) ? access_private_node
1186 : TREE_PROTECTED (using_decl
) ? access_protected_node
1187 : access_public_node
;
1188 tree flist
= NULL_TREE
;
1191 gcc_assert (!processing_template_decl
&& decl
);
1193 old_value
= lookup_member (t
, name
, /*protect=*/0, /*want_type=*/false);
1196 if (is_overloaded_fn (old_value
))
1197 old_value
= OVL_CURRENT (old_value
);
1199 if (DECL_P (old_value
) && DECL_CONTEXT (old_value
) == t
)
1202 old_value
= NULL_TREE
;
1205 cp_emit_debug_info_for_using (decl
, USING_DECL_SCOPE (using_decl
));
1207 if (is_overloaded_fn (decl
))
1212 else if (is_overloaded_fn (old_value
))
1215 /* It's OK to use functions from a base when there are functions with
1216 the same name already present in the current class. */;
1219 error ("%q+D invalid in %q#T", using_decl
, t
);
1220 error (" because of local method %q+#D with same name",
1221 OVL_CURRENT (old_value
));
1225 else if (!DECL_ARTIFICIAL (old_value
))
1227 error ("%q+D invalid in %q#T", using_decl
, t
);
1228 error (" because of local member %q+#D with same name", old_value
);
1232 /* Make type T see field decl FDECL with access ACCESS. */
1234 for (; flist
; flist
= OVL_NEXT (flist
))
1236 add_method (t
, OVL_CURRENT (flist
), using_decl
);
1237 alter_access (t
, OVL_CURRENT (flist
), access
);
1240 alter_access (t
, decl
, access
);
1243 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1244 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1245 properties of the bases. */
1248 check_bases (tree t
,
1249 int* cant_have_const_ctor_p
,
1250 int* no_const_asn_ref_p
)
1253 int seen_non_virtual_nearly_empty_base_p
;
1256 tree field
= NULL_TREE
;
1258 seen_non_virtual_nearly_empty_base_p
= 0;
1260 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1261 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
1262 if (TREE_CODE (field
) == FIELD_DECL
)
1265 for (binfo
= TYPE_BINFO (t
), i
= 0;
1266 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1268 tree basetype
= TREE_TYPE (base_binfo
);
1270 gcc_assert (COMPLETE_TYPE_P (basetype
));
1272 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1273 here because the case of virtual functions but non-virtual
1274 dtor is handled in finish_struct_1. */
1275 if (!TYPE_POLYMORPHIC_P (basetype
))
1276 warning (OPT_Weffc__
,
1277 "base class %q#T has a non-virtual destructor", basetype
);
1279 /* If the base class doesn't have copy constructors or
1280 assignment operators that take const references, then the
1281 derived class cannot have such a member automatically
1283 if (! TYPE_HAS_CONST_INIT_REF (basetype
))
1284 *cant_have_const_ctor_p
= 1;
1285 if (TYPE_HAS_ASSIGN_REF (basetype
)
1286 && !TYPE_HAS_CONST_ASSIGN_REF (basetype
))
1287 *no_const_asn_ref_p
= 1;
1289 if (BINFO_VIRTUAL_P (base_binfo
))
1290 /* A virtual base does not effect nearly emptiness. */
1292 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype
))
1294 if (seen_non_virtual_nearly_empty_base_p
)
1295 /* And if there is more than one nearly empty base, then the
1296 derived class is not nearly empty either. */
1297 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1299 /* Remember we've seen one. */
1300 seen_non_virtual_nearly_empty_base_p
= 1;
1302 else if (!is_empty_class (basetype
))
1303 /* If the base class is not empty or nearly empty, then this
1304 class cannot be nearly empty. */
1305 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1307 /* A lot of properties from the bases also apply to the derived
1309 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (basetype
);
1310 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1311 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
);
1312 TYPE_HAS_COMPLEX_ASSIGN_REF (t
)
1313 |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype
);
1314 TYPE_HAS_COMPLEX_INIT_REF (t
) |= TYPE_HAS_COMPLEX_INIT_REF (basetype
);
1315 TYPE_POLYMORPHIC_P (t
) |= TYPE_POLYMORPHIC_P (basetype
);
1316 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
)
1317 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype
);
1318 TYPE_HAS_COMPLEX_DFLT (t
) |= TYPE_HAS_COMPLEX_DFLT (basetype
);
1320 /* A standard-layout class is a class that:
1322 * has no non-standard-layout base classes, */
1323 CLASSTYPE_NON_STD_LAYOUT (t
) |= CLASSTYPE_NON_STD_LAYOUT (basetype
);
1324 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1327 /* ...has no base classes of the same type as the first non-static
1329 if (field
&& DECL_CONTEXT (field
) == t
1330 && (same_type_ignoring_top_level_qualifiers_p
1331 (TREE_TYPE (field
), basetype
)))
1332 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1334 /* ...either has no non-static data members in the most-derived
1335 class and at most one base class with non-static data
1336 members, or has no base classes with non-static data
1338 for (basefield
= TYPE_FIELDS (basetype
); basefield
;
1339 basefield
= TREE_CHAIN (basefield
))
1340 if (TREE_CODE (basefield
) == FIELD_DECL
)
1343 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1352 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1353 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1354 that have had a nearly-empty virtual primary base stolen by some
1355 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1359 determine_primary_bases (tree t
)
1362 tree primary
= NULL_TREE
;
1363 tree type_binfo
= TYPE_BINFO (t
);
1366 /* Determine the primary bases of our bases. */
1367 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1368 base_binfo
= TREE_CHAIN (base_binfo
))
1370 tree primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo
));
1372 /* See if we're the non-virtual primary of our inheritance
1374 if (!BINFO_VIRTUAL_P (base_binfo
))
1376 tree parent
= BINFO_INHERITANCE_CHAIN (base_binfo
);
1377 tree parent_primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent
));
1380 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
1381 BINFO_TYPE (parent_primary
)))
1382 /* We are the primary binfo. */
1383 BINFO_PRIMARY_P (base_binfo
) = 1;
1385 /* Determine if we have a virtual primary base, and mark it so.
1387 if (primary
&& BINFO_VIRTUAL_P (primary
))
1389 tree this_primary
= copied_binfo (primary
, base_binfo
);
1391 if (BINFO_PRIMARY_P (this_primary
))
1392 /* Someone already claimed this base. */
1393 BINFO_LOST_PRIMARY_P (base_binfo
) = 1;
1398 BINFO_PRIMARY_P (this_primary
) = 1;
1399 BINFO_INHERITANCE_CHAIN (this_primary
) = base_binfo
;
1401 /* A virtual binfo might have been copied from within
1402 another hierarchy. As we're about to use it as a
1403 primary base, make sure the offsets match. */
1404 delta
= size_diffop_loc (input_location
,
1406 BINFO_OFFSET (base_binfo
)),
1408 BINFO_OFFSET (this_primary
)));
1410 propagate_binfo_offsets (this_primary
, delta
);
1415 /* First look for a dynamic direct non-virtual base. */
1416 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, base_binfo
); i
++)
1418 tree basetype
= BINFO_TYPE (base_binfo
);
1420 if (TYPE_CONTAINS_VPTR_P (basetype
) && !BINFO_VIRTUAL_P (base_binfo
))
1422 primary
= base_binfo
;
1427 /* A "nearly-empty" virtual base class can be the primary base
1428 class, if no non-virtual polymorphic base can be found. Look for
1429 a nearly-empty virtual dynamic base that is not already a primary
1430 base of something in the hierarchy. If there is no such base,
1431 just pick the first nearly-empty virtual base. */
1433 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1434 base_binfo
= TREE_CHAIN (base_binfo
))
1435 if (BINFO_VIRTUAL_P (base_binfo
)
1436 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo
)))
1438 if (!BINFO_PRIMARY_P (base_binfo
))
1440 /* Found one that is not primary. */
1441 primary
= base_binfo
;
1445 /* Remember the first candidate. */
1446 primary
= base_binfo
;
1450 /* If we've got a primary base, use it. */
1453 tree basetype
= BINFO_TYPE (primary
);
1455 CLASSTYPE_PRIMARY_BINFO (t
) = primary
;
1456 if (BINFO_PRIMARY_P (primary
))
1457 /* We are stealing a primary base. */
1458 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary
)) = 1;
1459 BINFO_PRIMARY_P (primary
) = 1;
1460 if (BINFO_VIRTUAL_P (primary
))
1464 BINFO_INHERITANCE_CHAIN (primary
) = type_binfo
;
1465 /* A virtual binfo might have been copied from within
1466 another hierarchy. As we're about to use it as a primary
1467 base, make sure the offsets match. */
1468 delta
= size_diffop_loc (input_location
, ssize_int (0),
1469 convert (ssizetype
, BINFO_OFFSET (primary
)));
1471 propagate_binfo_offsets (primary
, delta
);
1474 primary
= TYPE_BINFO (basetype
);
1476 TYPE_VFIELD (t
) = TYPE_VFIELD (basetype
);
1477 BINFO_VTABLE (type_binfo
) = BINFO_VTABLE (primary
);
1478 BINFO_VIRTUALS (type_binfo
) = BINFO_VIRTUALS (primary
);
1482 /* Update the variant types of T. */
1485 fixup_type_variants (tree t
)
1492 for (variants
= TYPE_NEXT_VARIANT (t
);
1494 variants
= TYPE_NEXT_VARIANT (variants
))
1496 /* These fields are in the _TYPE part of the node, not in
1497 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1498 TYPE_HAS_USER_CONSTRUCTOR (variants
) = TYPE_HAS_USER_CONSTRUCTOR (t
);
1499 TYPE_NEEDS_CONSTRUCTING (variants
) = TYPE_NEEDS_CONSTRUCTING (t
);
1500 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants
)
1501 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
1503 TYPE_POLYMORPHIC_P (variants
) = TYPE_POLYMORPHIC_P (t
);
1505 TYPE_BINFO (variants
) = TYPE_BINFO (t
);
1507 /* Copy whatever these are holding today. */
1508 TYPE_VFIELD (variants
) = TYPE_VFIELD (t
);
1509 TYPE_METHODS (variants
) = TYPE_METHODS (t
);
1510 TYPE_FIELDS (variants
) = TYPE_FIELDS (t
);
1512 /* All variants of a class have the same attributes. */
1513 TYPE_ATTRIBUTES (variants
) = TYPE_ATTRIBUTES (t
);
1518 /* Set memoizing fields and bits of T (and its variants) for later
1522 finish_struct_bits (tree t
)
1524 /* Fix up variants (if any). */
1525 fixup_type_variants (t
);
1527 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) && TYPE_POLYMORPHIC_P (t
))
1528 /* For a class w/o baseclasses, 'finish_struct' has set
1529 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1530 Similarly for a class whose base classes do not have vtables.
1531 When neither of these is true, we might have removed abstract
1532 virtuals (by providing a definition), added some (by declaring
1533 new ones), or redeclared ones from a base class. We need to
1534 recalculate what's really an abstract virtual at this point (by
1535 looking in the vtables). */
1536 get_pure_virtuals (t
);
1538 /* If this type has a copy constructor or a destructor, force its
1539 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1540 nonzero. This will cause it to be passed by invisible reference
1541 and prevent it from being returned in a register. */
1542 if (! TYPE_HAS_TRIVIAL_INIT_REF (t
) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
1545 DECL_MODE (TYPE_MAIN_DECL (t
)) = BLKmode
;
1546 for (variants
= t
; variants
; variants
= TYPE_NEXT_VARIANT (variants
))
1548 SET_TYPE_MODE (variants
, BLKmode
);
1549 TREE_ADDRESSABLE (variants
) = 1;
1554 /* Issue warnings about T having private constructors, but no friends,
1557 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1558 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1559 non-private static member functions. */
1562 maybe_warn_about_overly_private_class (tree t
)
1564 int has_member_fn
= 0;
1565 int has_nonprivate_method
= 0;
1568 if (!warn_ctor_dtor_privacy
1569 /* If the class has friends, those entities might create and
1570 access instances, so we should not warn. */
1571 || (CLASSTYPE_FRIEND_CLASSES (t
)
1572 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
1573 /* We will have warned when the template was declared; there's
1574 no need to warn on every instantiation. */
1575 || CLASSTYPE_TEMPLATE_INSTANTIATION (t
))
1576 /* There's no reason to even consider warning about this
1580 /* We only issue one warning, if more than one applies, because
1581 otherwise, on code like:
1584 // Oops - forgot `public:'
1590 we warn several times about essentially the same problem. */
1592 /* Check to see if all (non-constructor, non-destructor) member
1593 functions are private. (Since there are no friends or
1594 non-private statics, we can't ever call any of the private member
1596 for (fn
= TYPE_METHODS (t
); fn
; fn
= TREE_CHAIN (fn
))
1597 /* We're not interested in compiler-generated methods; they don't
1598 provide any way to call private members. */
1599 if (!DECL_ARTIFICIAL (fn
))
1601 if (!TREE_PRIVATE (fn
))
1603 if (DECL_STATIC_FUNCTION_P (fn
))
1604 /* A non-private static member function is just like a
1605 friend; it can create and invoke private member
1606 functions, and be accessed without a class
1610 has_nonprivate_method
= 1;
1611 /* Keep searching for a static member function. */
1613 else if (!DECL_CONSTRUCTOR_P (fn
) && !DECL_DESTRUCTOR_P (fn
))
1617 if (!has_nonprivate_method
&& has_member_fn
)
1619 /* There are no non-private methods, and there's at least one
1620 private member function that isn't a constructor or
1621 destructor. (If all the private members are
1622 constructors/destructors we want to use the code below that
1623 issues error messages specifically referring to
1624 constructors/destructors.) */
1626 tree binfo
= TYPE_BINFO (t
);
1628 for (i
= 0; i
!= BINFO_N_BASE_BINFOS (binfo
); i
++)
1629 if (BINFO_BASE_ACCESS (binfo
, i
) != access_private_node
)
1631 has_nonprivate_method
= 1;
1634 if (!has_nonprivate_method
)
1636 warning (OPT_Wctor_dtor_privacy
,
1637 "all member functions in class %qT are private", t
);
1642 /* Even if some of the member functions are non-private, the class
1643 won't be useful for much if all the constructors or destructors
1644 are private: such an object can never be created or destroyed. */
1645 fn
= CLASSTYPE_DESTRUCTORS (t
);
1646 if (fn
&& TREE_PRIVATE (fn
))
1648 warning (OPT_Wctor_dtor_privacy
,
1649 "%q#T only defines a private destructor and has no friends",
1654 /* Warn about classes that have private constructors and no friends. */
1655 if (TYPE_HAS_USER_CONSTRUCTOR (t
)
1656 /* Implicitly generated constructors are always public. */
1657 && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t
)
1658 || !CLASSTYPE_LAZY_COPY_CTOR (t
)))
1660 int nonprivate_ctor
= 0;
1662 /* If a non-template class does not define a copy
1663 constructor, one is defined for it, enabling it to avoid
1664 this warning. For a template class, this does not
1665 happen, and so we would normally get a warning on:
1667 template <class T> class C { private: C(); };
1669 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
1670 complete non-template or fully instantiated classes have this
1672 if (!TYPE_HAS_INIT_REF (t
))
1673 nonprivate_ctor
= 1;
1675 for (fn
= CLASSTYPE_CONSTRUCTORS (t
); fn
; fn
= OVL_NEXT (fn
))
1677 tree ctor
= OVL_CURRENT (fn
);
1678 /* Ideally, we wouldn't count copy constructors (or, in
1679 fact, any constructor that takes an argument of the
1680 class type as a parameter) because such things cannot
1681 be used to construct an instance of the class unless
1682 you already have one. But, for now at least, we're
1684 if (! TREE_PRIVATE (ctor
))
1686 nonprivate_ctor
= 1;
1691 if (nonprivate_ctor
== 0)
1693 warning (OPT_Wctor_dtor_privacy
,
1694 "%q#T only defines private constructors and has no friends",
1702 gt_pointer_operator new_value
;
1706 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1709 method_name_cmp (const void* m1_p
, const void* m2_p
)
1711 const tree
*const m1
= (const tree
*) m1_p
;
1712 const tree
*const m2
= (const tree
*) m2_p
;
1714 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
1716 if (*m1
== NULL_TREE
)
1718 if (*m2
== NULL_TREE
)
1720 if (DECL_NAME (OVL_CURRENT (*m1
)) < DECL_NAME (OVL_CURRENT (*m2
)))
1725 /* This routine compares two fields like method_name_cmp but using the
1726 pointer operator in resort_field_decl_data. */
1729 resort_method_name_cmp (const void* m1_p
, const void* m2_p
)
1731 const tree
*const m1
= (const tree
*) m1_p
;
1732 const tree
*const m2
= (const tree
*) m2_p
;
1733 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
1735 if (*m1
== NULL_TREE
)
1737 if (*m2
== NULL_TREE
)
1740 tree d1
= DECL_NAME (OVL_CURRENT (*m1
));
1741 tree d2
= DECL_NAME (OVL_CURRENT (*m2
));
1742 resort_data
.new_value (&d1
, resort_data
.cookie
);
1743 resort_data
.new_value (&d2
, resort_data
.cookie
);
1750 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1753 resort_type_method_vec (void* obj
,
1754 void* orig_obj ATTRIBUTE_UNUSED
,
1755 gt_pointer_operator new_value
,
1758 VEC(tree
,gc
) *method_vec
= (VEC(tree
,gc
) *) obj
;
1759 int len
= VEC_length (tree
, method_vec
);
1763 /* The type conversion ops have to live at the front of the vec, so we
1765 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1766 VEC_iterate (tree
, method_vec
, slot
, fn
);
1768 if (!DECL_CONV_FN_P (OVL_CURRENT (fn
)))
1773 resort_data
.new_value
= new_value
;
1774 resort_data
.cookie
= cookie
;
1775 qsort (VEC_address (tree
, method_vec
) + slot
, len
- slot
, sizeof (tree
),
1776 resort_method_name_cmp
);
1780 /* Warn about duplicate methods in fn_fields.
1782 Sort methods that are not special (i.e., constructors, destructors,
1783 and type conversion operators) so that we can find them faster in
1787 finish_struct_methods (tree t
)
1790 VEC(tree
,gc
) *method_vec
;
1793 method_vec
= CLASSTYPE_METHOD_VEC (t
);
1797 len
= VEC_length (tree
, method_vec
);
1799 /* Clear DECL_IN_AGGR_P for all functions. */
1800 for (fn_fields
= TYPE_METHODS (t
); fn_fields
;
1801 fn_fields
= TREE_CHAIN (fn_fields
))
1802 DECL_IN_AGGR_P (fn_fields
) = 0;
1804 /* Issue warnings about private constructors and such. If there are
1805 no methods, then some public defaults are generated. */
1806 maybe_warn_about_overly_private_class (t
);
1808 /* The type conversion ops have to live at the front of the vec, so we
1810 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1811 VEC_iterate (tree
, method_vec
, slot
, fn_fields
);
1813 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields
)))
1816 qsort (VEC_address (tree
, method_vec
) + slot
,
1817 len
-slot
, sizeof (tree
), method_name_cmp
);
1820 /* Make BINFO's vtable have N entries, including RTTI entries,
1821 vbase and vcall offsets, etc. Set its type and call the back end
1825 layout_vtable_decl (tree binfo
, int n
)
1830 atype
= build_cplus_array_type (vtable_entry_type
,
1831 build_index_type (size_int (n
- 1)));
1832 layout_type (atype
);
1834 /* We may have to grow the vtable. */
1835 vtable
= get_vtbl_decl_for_binfo (binfo
);
1836 if (!same_type_p (TREE_TYPE (vtable
), atype
))
1838 TREE_TYPE (vtable
) = atype
;
1839 DECL_SIZE (vtable
) = DECL_SIZE_UNIT (vtable
) = NULL_TREE
;
1840 layout_decl (vtable
, 0);
1844 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1845 have the same signature. */
1848 same_signature_p (const_tree fndecl
, const_tree base_fndecl
)
1850 /* One destructor overrides another if they are the same kind of
1852 if (DECL_DESTRUCTOR_P (base_fndecl
) && DECL_DESTRUCTOR_P (fndecl
)
1853 && special_function_p (base_fndecl
) == special_function_p (fndecl
))
1855 /* But a non-destructor never overrides a destructor, nor vice
1856 versa, nor do different kinds of destructors override
1857 one-another. For example, a complete object destructor does not
1858 override a deleting destructor. */
1859 if (DECL_DESTRUCTOR_P (base_fndecl
) || DECL_DESTRUCTOR_P (fndecl
))
1862 if (DECL_NAME (fndecl
) == DECL_NAME (base_fndecl
)
1863 || (DECL_CONV_FN_P (fndecl
)
1864 && DECL_CONV_FN_P (base_fndecl
)
1865 && same_type_p (DECL_CONV_FN_TYPE (fndecl
),
1866 DECL_CONV_FN_TYPE (base_fndecl
))))
1868 tree types
, base_types
;
1869 types
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
1870 base_types
= TYPE_ARG_TYPES (TREE_TYPE (base_fndecl
));
1871 if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types
)))
1872 == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types
))))
1873 && compparms (TREE_CHAIN (base_types
), TREE_CHAIN (types
)))
1879 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1883 base_derived_from (tree derived
, tree base
)
1887 for (probe
= base
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
1889 if (probe
== derived
)
1891 else if (BINFO_VIRTUAL_P (probe
))
1892 /* If we meet a virtual base, we can't follow the inheritance
1893 any more. See if the complete type of DERIVED contains
1894 such a virtual base. */
1895 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (derived
))
1901 typedef struct find_final_overrider_data_s
{
1902 /* The function for which we are trying to find a final overrider. */
1904 /* The base class in which the function was declared. */
1905 tree declaring_base
;
1906 /* The candidate overriders. */
1908 /* Path to most derived. */
1909 VEC(tree
,heap
) *path
;
1910 } find_final_overrider_data
;
1912 /* Add the overrider along the current path to FFOD->CANDIDATES.
1913 Returns true if an overrider was found; false otherwise. */
1916 dfs_find_final_overrider_1 (tree binfo
,
1917 find_final_overrider_data
*ffod
,
1922 /* If BINFO is not the most derived type, try a more derived class.
1923 A definition there will overrider a definition here. */
1927 if (dfs_find_final_overrider_1
1928 (VEC_index (tree
, ffod
->path
, depth
), ffod
, depth
))
1932 method
= look_for_overrides_here (BINFO_TYPE (binfo
), ffod
->fn
);
1935 tree
*candidate
= &ffod
->candidates
;
1937 /* Remove any candidates overridden by this new function. */
1940 /* If *CANDIDATE overrides METHOD, then METHOD
1941 cannot override anything else on the list. */
1942 if (base_derived_from (TREE_VALUE (*candidate
), binfo
))
1944 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1945 if (base_derived_from (binfo
, TREE_VALUE (*candidate
)))
1946 *candidate
= TREE_CHAIN (*candidate
);
1948 candidate
= &TREE_CHAIN (*candidate
);
1951 /* Add the new function. */
1952 ffod
->candidates
= tree_cons (method
, binfo
, ffod
->candidates
);
1959 /* Called from find_final_overrider via dfs_walk. */
1962 dfs_find_final_overrider_pre (tree binfo
, void *data
)
1964 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
1966 if (binfo
== ffod
->declaring_base
)
1967 dfs_find_final_overrider_1 (binfo
, ffod
, VEC_length (tree
, ffod
->path
));
1968 VEC_safe_push (tree
, heap
, ffod
->path
, binfo
);
1974 dfs_find_final_overrider_post (tree binfo ATTRIBUTE_UNUSED
, void *data
)
1976 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
1977 VEC_pop (tree
, ffod
->path
);
1982 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1983 FN and whose TREE_VALUE is the binfo for the base where the
1984 overriding occurs. BINFO (in the hierarchy dominated by the binfo
1985 DERIVED) is the base object in which FN is declared. */
1988 find_final_overrider (tree derived
, tree binfo
, tree fn
)
1990 find_final_overrider_data ffod
;
1992 /* Getting this right is a little tricky. This is valid:
1994 struct S { virtual void f (); };
1995 struct T { virtual void f (); };
1996 struct U : public S, public T { };
1998 even though calling `f' in `U' is ambiguous. But,
2000 struct R { virtual void f(); };
2001 struct S : virtual public R { virtual void f (); };
2002 struct T : virtual public R { virtual void f (); };
2003 struct U : public S, public T { };
2005 is not -- there's no way to decide whether to put `S::f' or
2006 `T::f' in the vtable for `R'.
2008 The solution is to look at all paths to BINFO. If we find
2009 different overriders along any two, then there is a problem. */
2010 if (DECL_THUNK_P (fn
))
2011 fn
= THUNK_TARGET (fn
);
2013 /* Determine the depth of the hierarchy. */
2015 ffod
.declaring_base
= binfo
;
2016 ffod
.candidates
= NULL_TREE
;
2017 ffod
.path
= VEC_alloc (tree
, heap
, 30);
2019 dfs_walk_all (derived
, dfs_find_final_overrider_pre
,
2020 dfs_find_final_overrider_post
, &ffod
);
2022 VEC_free (tree
, heap
, ffod
.path
);
2024 /* If there was no winner, issue an error message. */
2025 if (!ffod
.candidates
|| TREE_CHAIN (ffod
.candidates
))
2026 return error_mark_node
;
2028 return ffod
.candidates
;
2031 /* Return the index of the vcall offset for FN when TYPE is used as a
2035 get_vcall_index (tree fn
, tree type
)
2037 VEC(tree_pair_s
,gc
) *indices
= CLASSTYPE_VCALL_INDICES (type
);
2041 for (ix
= 0; VEC_iterate (tree_pair_s
, indices
, ix
, p
); ix
++)
2042 if ((DECL_DESTRUCTOR_P (fn
) && DECL_DESTRUCTOR_P (p
->purpose
))
2043 || same_signature_p (fn
, p
->purpose
))
2046 /* There should always be an appropriate index. */
2050 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2051 dominated by T. FN has been overridden in BINFO; VIRTUALS points to the
2052 corresponding position in the BINFO_VIRTUALS list. */
2055 update_vtable_entry_for_fn (tree t
, tree binfo
, tree fn
, tree
* virtuals
,
2063 tree overrider_fn
, overrider_target
;
2064 tree target_fn
= DECL_THUNK_P (fn
) ? THUNK_TARGET (fn
) : fn
;
2065 tree over_return
, base_return
;
2068 /* Find the nearest primary base (possibly binfo itself) which defines
2069 this function; this is the class the caller will convert to when
2070 calling FN through BINFO. */
2071 for (b
= binfo
; ; b
= get_primary_binfo (b
))
2074 if (look_for_overrides_here (BINFO_TYPE (b
), target_fn
))
2077 /* The nearest definition is from a lost primary. */
2078 if (BINFO_LOST_PRIMARY_P (b
))
2083 /* Find the final overrider. */
2084 overrider
= find_final_overrider (TYPE_BINFO (t
), b
, target_fn
);
2085 if (overrider
== error_mark_node
)
2087 error ("no unique final overrider for %qD in %qT", target_fn
, t
);
2090 overrider_target
= overrider_fn
= TREE_PURPOSE (overrider
);
2092 /* Check for adjusting covariant return types. */
2093 over_return
= TREE_TYPE (TREE_TYPE (overrider_target
));
2094 base_return
= TREE_TYPE (TREE_TYPE (target_fn
));
2096 if (POINTER_TYPE_P (over_return
)
2097 && TREE_CODE (over_return
) == TREE_CODE (base_return
)
2098 && CLASS_TYPE_P (TREE_TYPE (over_return
))
2099 && CLASS_TYPE_P (TREE_TYPE (base_return
))
2100 /* If the overrider is invalid, don't even try. */
2101 && !DECL_INVALID_OVERRIDER_P (overrider_target
))
2103 /* If FN is a covariant thunk, we must figure out the adjustment
2104 to the final base FN was converting to. As OVERRIDER_TARGET might
2105 also be converting to the return type of FN, we have to
2106 combine the two conversions here. */
2107 tree fixed_offset
, virtual_offset
;
2109 over_return
= TREE_TYPE (over_return
);
2110 base_return
= TREE_TYPE (base_return
);
2112 if (DECL_THUNK_P (fn
))
2114 gcc_assert (DECL_RESULT_THUNK_P (fn
));
2115 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn
));
2116 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn
);
2119 fixed_offset
= virtual_offset
= NULL_TREE
;
2122 /* Find the equivalent binfo within the return type of the
2123 overriding function. We will want the vbase offset from
2125 virtual_offset
= binfo_for_vbase (BINFO_TYPE (virtual_offset
),
2127 else if (!same_type_ignoring_top_level_qualifiers_p
2128 (over_return
, base_return
))
2130 /* There was no existing virtual thunk (which takes
2131 precedence). So find the binfo of the base function's
2132 return type within the overriding function's return type.
2133 We cannot call lookup base here, because we're inside a
2134 dfs_walk, and will therefore clobber the BINFO_MARKED
2135 flags. Fortunately we know the covariancy is valid (it
2136 has already been checked), so we can just iterate along
2137 the binfos, which have been chained in inheritance graph
2138 order. Of course it is lame that we have to repeat the
2139 search here anyway -- we should really be caching pieces
2140 of the vtable and avoiding this repeated work. */
2141 tree thunk_binfo
, base_binfo
;
2143 /* Find the base binfo within the overriding function's
2144 return type. We will always find a thunk_binfo, except
2145 when the covariancy is invalid (which we will have
2146 already diagnosed). */
2147 for (base_binfo
= TYPE_BINFO (base_return
),
2148 thunk_binfo
= TYPE_BINFO (over_return
);
2150 thunk_binfo
= TREE_CHAIN (thunk_binfo
))
2151 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo
),
2152 BINFO_TYPE (base_binfo
)))
2155 /* See if virtual inheritance is involved. */
2156 for (virtual_offset
= thunk_binfo
;
2158 virtual_offset
= BINFO_INHERITANCE_CHAIN (virtual_offset
))
2159 if (BINFO_VIRTUAL_P (virtual_offset
))
2163 || (thunk_binfo
&& !BINFO_OFFSET_ZEROP (thunk_binfo
)))
2165 tree offset
= convert (ssizetype
, BINFO_OFFSET (thunk_binfo
));
2169 /* We convert via virtual base. Adjust the fixed
2170 offset to be from there. */
2172 size_diffop (offset
,
2174 BINFO_OFFSET (virtual_offset
)));
2177 /* There was an existing fixed offset, this must be
2178 from the base just converted to, and the base the
2179 FN was thunking to. */
2180 fixed_offset
= size_binop (PLUS_EXPR
, fixed_offset
, offset
);
2182 fixed_offset
= offset
;
2186 if (fixed_offset
|| virtual_offset
)
2187 /* Replace the overriding function with a covariant thunk. We
2188 will emit the overriding function in its own slot as
2190 overrider_fn
= make_thunk (overrider_target
, /*this_adjusting=*/0,
2191 fixed_offset
, virtual_offset
);
2194 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target
) ||
2195 !DECL_THUNK_P (fn
));
2197 /* Assume that we will produce a thunk that convert all the way to
2198 the final overrider, and not to an intermediate virtual base. */
2199 virtual_base
= NULL_TREE
;
2201 /* See if we can convert to an intermediate virtual base first, and then
2202 use the vcall offset located there to finish the conversion. */
2203 for (; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
2205 /* If we find the final overrider, then we can stop
2207 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b
),
2208 BINFO_TYPE (TREE_VALUE (overrider
))))
2211 /* If we find a virtual base, and we haven't yet found the
2212 overrider, then there is a virtual base between the
2213 declaring base (first_defn) and the final overrider. */
2214 if (BINFO_VIRTUAL_P (b
))
2221 if (overrider_fn
!= overrider_target
&& !virtual_base
)
2223 /* The ABI specifies that a covariant thunk includes a mangling
2224 for a this pointer adjustment. This-adjusting thunks that
2225 override a function from a virtual base have a vcall
2226 adjustment. When the virtual base in question is a primary
2227 virtual base, we know the adjustments are zero, (and in the
2228 non-covariant case, we would not use the thunk).
2229 Unfortunately we didn't notice this could happen, when
2230 designing the ABI and so never mandated that such a covariant
2231 thunk should be emitted. Because we must use the ABI mandated
2232 name, we must continue searching from the binfo where we
2233 found the most recent definition of the function, towards the
2234 primary binfo which first introduced the function into the
2235 vtable. If that enters a virtual base, we must use a vcall
2236 this-adjusting thunk. Bleah! */
2237 tree probe
= first_defn
;
2239 while ((probe
= get_primary_binfo (probe
))
2240 && (unsigned) list_length (BINFO_VIRTUALS (probe
)) > ix
)
2241 if (BINFO_VIRTUAL_P (probe
))
2242 virtual_base
= probe
;
2245 /* Even if we find a virtual base, the correct delta is
2246 between the overrider and the binfo we're building a vtable
2248 goto virtual_covariant
;
2251 /* Compute the constant adjustment to the `this' pointer. The
2252 `this' pointer, when this function is called, will point at BINFO
2253 (or one of its primary bases, which are at the same offset). */
2255 /* The `this' pointer needs to be adjusted from the declaration to
2256 the nearest virtual base. */
2257 delta
= size_diffop_loc (input_location
,
2258 convert (ssizetype
, BINFO_OFFSET (virtual_base
)),
2259 convert (ssizetype
, BINFO_OFFSET (first_defn
)));
2261 /* If the nearest definition is in a lost primary, we don't need an
2262 entry in our vtable. Except possibly in a constructor vtable,
2263 if we happen to get our primary back. In that case, the offset
2264 will be zero, as it will be a primary base. */
2265 delta
= size_zero_node
;
2267 /* The `this' pointer needs to be adjusted from pointing to
2268 BINFO to pointing at the base where the final overrider
2271 delta
= size_diffop_loc (input_location
,
2273 BINFO_OFFSET (TREE_VALUE (overrider
))),
2274 convert (ssizetype
, BINFO_OFFSET (binfo
)));
2276 modify_vtable_entry (t
, binfo
, overrider_fn
, delta
, virtuals
);
2279 BV_VCALL_INDEX (*virtuals
)
2280 = get_vcall_index (overrider_target
, BINFO_TYPE (virtual_base
));
2282 BV_VCALL_INDEX (*virtuals
) = NULL_TREE
;
2285 /* Called from modify_all_vtables via dfs_walk. */
2288 dfs_modify_vtables (tree binfo
, void* data
)
2290 tree t
= (tree
) data
;
2295 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
2296 /* A base without a vtable needs no modification, and its bases
2297 are uninteresting. */
2298 return dfs_skip_bases
;
2300 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
)
2301 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
2302 /* Don't do the primary vtable, if it's new. */
2305 if (BINFO_PRIMARY_P (binfo
) && !BINFO_VIRTUAL_P (binfo
))
2306 /* There's no need to modify the vtable for a non-virtual primary
2307 base; we're not going to use that vtable anyhow. We do still
2308 need to do this for virtual primary bases, as they could become
2309 non-primary in a construction vtable. */
2312 make_new_vtable (t
, binfo
);
2314 /* Now, go through each of the virtual functions in the virtual
2315 function table for BINFO. Find the final overrider, and update
2316 the BINFO_VIRTUALS list appropriately. */
2317 for (ix
= 0, virtuals
= BINFO_VIRTUALS (binfo
),
2318 old_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
2320 ix
++, virtuals
= TREE_CHAIN (virtuals
),
2321 old_virtuals
= TREE_CHAIN (old_virtuals
))
2322 update_vtable_entry_for_fn (t
,
2324 BV_FN (old_virtuals
),
2330 /* Update all of the primary and secondary vtables for T. Create new
2331 vtables as required, and initialize their RTTI information. Each
2332 of the functions in VIRTUALS is declared in T and may override a
2333 virtual function from a base class; find and modify the appropriate
2334 entries to point to the overriding functions. Returns a list, in
2335 declaration order, of the virtual functions that are declared in T,
2336 but do not appear in the primary base class vtable, and which
2337 should therefore be appended to the end of the vtable for T. */
2340 modify_all_vtables (tree t
, tree virtuals
)
2342 tree binfo
= TYPE_BINFO (t
);
2345 /* Update all of the vtables. */
2346 dfs_walk_once (binfo
, dfs_modify_vtables
, NULL
, t
);
2348 /* Add virtual functions not already in our primary vtable. These
2349 will be both those introduced by this class, and those overridden
2350 from secondary bases. It does not include virtuals merely
2351 inherited from secondary bases. */
2352 for (fnsp
= &virtuals
; *fnsp
; )
2354 tree fn
= TREE_VALUE (*fnsp
);
2356 if (!value_member (fn
, BINFO_VIRTUALS (binfo
))
2357 || DECL_VINDEX (fn
) == error_mark_node
)
2359 /* We don't need to adjust the `this' pointer when
2360 calling this function. */
2361 BV_DELTA (*fnsp
) = integer_zero_node
;
2362 BV_VCALL_INDEX (*fnsp
) = NULL_TREE
;
2364 /* This is a function not already in our vtable. Keep it. */
2365 fnsp
= &TREE_CHAIN (*fnsp
);
2368 /* We've already got an entry for this function. Skip it. */
2369 *fnsp
= TREE_CHAIN (*fnsp
);
2375 /* Get the base virtual function declarations in T that have the
2379 get_basefndecls (tree name
, tree t
)
2382 tree base_fndecls
= NULL_TREE
;
2383 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
2386 /* Find virtual functions in T with the indicated NAME. */
2387 i
= lookup_fnfields_1 (t
, name
);
2389 for (methods
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (t
), i
);
2391 methods
= OVL_NEXT (methods
))
2393 tree method
= OVL_CURRENT (methods
);
2395 if (TREE_CODE (method
) == FUNCTION_DECL
2396 && DECL_VINDEX (method
))
2397 base_fndecls
= tree_cons (NULL_TREE
, method
, base_fndecls
);
2401 return base_fndecls
;
2403 for (i
= 0; i
< n_baseclasses
; i
++)
2405 tree basetype
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t
), i
));
2406 base_fndecls
= chainon (get_basefndecls (name
, basetype
),
2410 return base_fndecls
;
2413 /* If this declaration supersedes the declaration of
2414 a method declared virtual in the base class, then
2415 mark this field as being virtual as well. */
2418 check_for_override (tree decl
, tree ctype
)
2420 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2421 /* In [temp.mem] we have:
2423 A specialization of a member function template does not
2424 override a virtual function from a base class. */
2426 if ((DECL_DESTRUCTOR_P (decl
)
2427 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
))
2428 || DECL_CONV_FN_P (decl
))
2429 && look_for_overrides (ctype
, decl
)
2430 && !DECL_STATIC_FUNCTION_P (decl
))
2431 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2432 the error_mark_node so that we know it is an overriding
2434 DECL_VINDEX (decl
) = decl
;
2436 if (DECL_VIRTUAL_P (decl
))
2438 if (!DECL_VINDEX (decl
))
2439 DECL_VINDEX (decl
) = error_mark_node
;
2440 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
2444 /* Warn about hidden virtual functions that are not overridden in t.
2445 We know that constructors and destructors don't apply. */
2448 warn_hidden (tree t
)
2450 VEC(tree
,gc
) *method_vec
= CLASSTYPE_METHOD_VEC (t
);
2454 /* We go through each separately named virtual function. */
2455 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2456 VEC_iterate (tree
, method_vec
, i
, fns
);
2467 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2468 have the same name. Figure out what name that is. */
2469 name
= DECL_NAME (OVL_CURRENT (fns
));
2470 /* There are no possibly hidden functions yet. */
2471 base_fndecls
= NULL_TREE
;
2472 /* Iterate through all of the base classes looking for possibly
2473 hidden functions. */
2474 for (binfo
= TYPE_BINFO (t
), j
= 0;
2475 BINFO_BASE_ITERATE (binfo
, j
, base_binfo
); j
++)
2477 tree basetype
= BINFO_TYPE (base_binfo
);
2478 base_fndecls
= chainon (get_basefndecls (name
, basetype
),
2482 /* If there are no functions to hide, continue. */
2486 /* Remove any overridden functions. */
2487 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
2489 fndecl
= OVL_CURRENT (fn
);
2490 if (DECL_VINDEX (fndecl
))
2492 tree
*prev
= &base_fndecls
;
2495 /* If the method from the base class has the same
2496 signature as the method from the derived class, it
2497 has been overridden. */
2498 if (same_signature_p (fndecl
, TREE_VALUE (*prev
)))
2499 *prev
= TREE_CHAIN (*prev
);
2501 prev
= &TREE_CHAIN (*prev
);
2505 /* Now give a warning for all base functions without overriders,
2506 as they are hidden. */
2507 while (base_fndecls
)
2509 /* Here we know it is a hider, and no overrider exists. */
2510 warning (OPT_Woverloaded_virtual
, "%q+D was hidden", TREE_VALUE (base_fndecls
));
2511 warning (OPT_Woverloaded_virtual
, " by %q+D", fns
);
2512 base_fndecls
= TREE_CHAIN (base_fndecls
);
2517 /* Check for things that are invalid. There are probably plenty of other
2518 things we should check for also. */
2521 finish_struct_anon (tree t
)
2525 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
2527 if (TREE_STATIC (field
))
2529 if (TREE_CODE (field
) != FIELD_DECL
)
2532 if (DECL_NAME (field
) == NULL_TREE
2533 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
2535 bool is_union
= TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
;
2536 tree elt
= TYPE_FIELDS (TREE_TYPE (field
));
2537 for (; elt
; elt
= TREE_CHAIN (elt
))
2539 /* We're generally only interested in entities the user
2540 declared, but we also find nested classes by noticing
2541 the TYPE_DECL that we create implicitly. You're
2542 allowed to put one anonymous union inside another,
2543 though, so we explicitly tolerate that. We use
2544 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2545 we also allow unnamed types used for defining fields. */
2546 if (DECL_ARTIFICIAL (elt
)
2547 && (!DECL_IMPLICIT_TYPEDEF_P (elt
)
2548 || TYPE_ANONYMOUS_P (TREE_TYPE (elt
))))
2551 if (TREE_CODE (elt
) != FIELD_DECL
)
2554 permerror (input_location
, "%q+#D invalid; an anonymous union can "
2555 "only have non-static data members", elt
);
2557 permerror (input_location
, "%q+#D invalid; an anonymous struct can "
2558 "only have non-static data members", elt
);
2562 if (TREE_PRIVATE (elt
))
2565 permerror (input_location
, "private member %q+#D in anonymous union", elt
);
2567 permerror (input_location
, "private member %q+#D in anonymous struct", elt
);
2569 else if (TREE_PROTECTED (elt
))
2572 permerror (input_location
, "protected member %q+#D in anonymous union", elt
);
2574 permerror (input_location
, "protected member %q+#D in anonymous struct", elt
);
2577 TREE_PRIVATE (elt
) = TREE_PRIVATE (field
);
2578 TREE_PROTECTED (elt
) = TREE_PROTECTED (field
);
2584 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2585 will be used later during class template instantiation.
2586 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2587 a non-static member data (FIELD_DECL), a member function
2588 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2589 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2590 When FRIEND_P is nonzero, T is either a friend class
2591 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2592 (FUNCTION_DECL, TEMPLATE_DECL). */
2595 maybe_add_class_template_decl_list (tree type
, tree t
, int friend_p
)
2597 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2598 if (CLASSTYPE_TEMPLATE_INFO (type
))
2599 CLASSTYPE_DECL_LIST (type
)
2600 = tree_cons (friend_p
? NULL_TREE
: type
,
2601 t
, CLASSTYPE_DECL_LIST (type
));
2604 /* Create default constructors, assignment operators, and so forth for
2605 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
2606 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
2607 the class cannot have a default constructor, copy constructor
2608 taking a const reference argument, or an assignment operator taking
2609 a const reference, respectively. */
2612 add_implicitly_declared_members (tree t
,
2613 int cant_have_const_cctor
,
2614 int cant_have_const_assignment
)
2617 if (!CLASSTYPE_DESTRUCTORS (t
))
2619 /* In general, we create destructors lazily. */
2620 CLASSTYPE_LAZY_DESTRUCTOR (t
) = 1;
2621 /* However, if the implicit destructor is non-trivial
2622 destructor, we sometimes have to create it at this point. */
2623 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
2627 if (TYPE_FOR_JAVA (t
))
2628 /* If this a Java class, any non-trivial destructor is
2629 invalid, even if compiler-generated. Therefore, if the
2630 destructor is non-trivial we create it now. */
2638 /* If the implicit destructor will be virtual, then we must
2639 generate it now because (unfortunately) we do not
2640 generate virtual tables lazily. */
2641 binfo
= TYPE_BINFO (t
);
2642 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2647 base_type
= BINFO_TYPE (base_binfo
);
2648 dtor
= CLASSTYPE_DESTRUCTORS (base_type
);
2649 if (dtor
&& DECL_VIRTUAL_P (dtor
))
2657 /* If we can't get away with being lazy, generate the destructor
2660 lazily_declare_fn (sfk_destructor
, t
);
2666 If there is no user-declared constructor for a class, a default
2667 constructor is implicitly declared. */
2668 if (! TYPE_HAS_USER_CONSTRUCTOR (t
))
2670 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 1;
2671 CLASSTYPE_LAZY_DEFAULT_CTOR (t
) = 1;
2676 If a class definition does not explicitly declare a copy
2677 constructor, one is declared implicitly. */
2678 if (! TYPE_HAS_INIT_REF (t
) && ! TYPE_FOR_JAVA (t
))
2680 TYPE_HAS_INIT_REF (t
) = 1;
2681 TYPE_HAS_CONST_INIT_REF (t
) = !cant_have_const_cctor
;
2682 CLASSTYPE_LAZY_COPY_CTOR (t
) = 1;
2685 /* Currently only lambdas get a lazy move ctor, but N2987 adds them for
2687 if (LAMBDA_TYPE_P (t
))
2688 CLASSTYPE_LAZY_MOVE_CTOR (t
) = 1;
2690 /* If there is no assignment operator, one will be created if and
2691 when it is needed. For now, just record whether or not the type
2692 of the parameter to the assignment operator will be a const or
2693 non-const reference. */
2694 if (!TYPE_HAS_ASSIGN_REF (t
) && !TYPE_FOR_JAVA (t
))
2696 TYPE_HAS_ASSIGN_REF (t
) = 1;
2697 TYPE_HAS_CONST_ASSIGN_REF (t
) = !cant_have_const_assignment
;
2698 CLASSTYPE_LAZY_ASSIGNMENT_OP (t
) = 1;
2702 /* Subroutine of finish_struct_1. Recursively count the number of fields
2703 in TYPE, including anonymous union members. */
2706 count_fields (tree fields
)
2710 for (x
= fields
; x
; x
= TREE_CHAIN (x
))
2712 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2713 n_fields
+= count_fields (TYPE_FIELDS (TREE_TYPE (x
)));
2720 /* Subroutine of finish_struct_1. Recursively add all the fields in the
2721 TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */
2724 add_fields_to_record_type (tree fields
, struct sorted_fields_type
*field_vec
, int idx
)
2727 for (x
= fields
; x
; x
= TREE_CHAIN (x
))
2729 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2730 idx
= add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x
)), field_vec
, idx
);
2732 field_vec
->elts
[idx
++] = x
;
2737 /* FIELD is a bit-field. We are finishing the processing for its
2738 enclosing type. Issue any appropriate messages and set appropriate
2739 flags. Returns false if an error has been diagnosed. */
2742 check_bitfield_decl (tree field
)
2744 tree type
= TREE_TYPE (field
);
2747 /* Extract the declared width of the bitfield, which has been
2748 temporarily stashed in DECL_INITIAL. */
2749 w
= DECL_INITIAL (field
);
2750 gcc_assert (w
!= NULL_TREE
);
2751 /* Remove the bit-field width indicator so that the rest of the
2752 compiler does not treat that value as an initializer. */
2753 DECL_INITIAL (field
) = NULL_TREE
;
2755 /* Detect invalid bit-field type. */
2756 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
2758 error ("bit-field %q+#D with non-integral type", field
);
2759 w
= error_mark_node
;
2763 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2766 /* detect invalid field size. */
2767 w
= integral_constant_value (w
);
2769 if (TREE_CODE (w
) != INTEGER_CST
)
2771 error ("bit-field %q+D width not an integer constant", field
);
2772 w
= error_mark_node
;
2774 else if (tree_int_cst_sgn (w
) < 0)
2776 error ("negative width in bit-field %q+D", field
);
2777 w
= error_mark_node
;
2779 else if (integer_zerop (w
) && DECL_NAME (field
) != 0)
2781 error ("zero width for bit-field %q+D", field
);
2782 w
= error_mark_node
;
2784 else if (compare_tree_int (w
, TYPE_PRECISION (type
)) > 0
2785 && TREE_CODE (type
) != ENUMERAL_TYPE
2786 && TREE_CODE (type
) != BOOLEAN_TYPE
)
2787 warning (0, "width of %q+D exceeds its type", field
);
2788 else if (TREE_CODE (type
) == ENUMERAL_TYPE
2789 && (0 > compare_tree_int (w
,
2790 tree_int_cst_min_precision
2791 (TYPE_MIN_VALUE (type
),
2792 TYPE_UNSIGNED (type
)))
2793 || 0 > compare_tree_int (w
,
2794 tree_int_cst_min_precision
2795 (TYPE_MAX_VALUE (type
),
2796 TYPE_UNSIGNED (type
)))))
2797 warning (0, "%q+D is too small to hold all values of %q#T", field
, type
);
2800 if (w
!= error_mark_node
)
2802 DECL_SIZE (field
) = convert (bitsizetype
, w
);
2803 DECL_BIT_FIELD (field
) = 1;
2808 /* Non-bit-fields are aligned for their type. */
2809 DECL_BIT_FIELD (field
) = 0;
2810 CLEAR_DECL_C_BIT_FIELD (field
);
2815 /* FIELD is a non bit-field. We are finishing the processing for its
2816 enclosing type T. Issue any appropriate messages and set appropriate
2820 check_field_decl (tree field
,
2822 int* cant_have_const_ctor
,
2823 int* no_const_asn_ref
,
2824 int* any_default_members
)
2826 tree type
= strip_array_types (TREE_TYPE (field
));
2828 /* An anonymous union cannot contain any fields which would change
2829 the settings of CANT_HAVE_CONST_CTOR and friends. */
2830 if (ANON_UNION_TYPE_P (type
))
2832 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2833 structs. So, we recurse through their fields here. */
2834 else if (ANON_AGGR_TYPE_P (type
))
2838 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
2839 if (TREE_CODE (fields
) == FIELD_DECL
&& !DECL_C_BIT_FIELD (field
))
2840 check_field_decl (fields
, t
, cant_have_const_ctor
,
2841 no_const_asn_ref
, any_default_members
);
2843 /* Check members with class type for constructors, destructors,
2845 else if (CLASS_TYPE_P (type
))
2847 /* Never let anything with uninheritable virtuals
2848 make it through without complaint. */
2849 abstract_virtuals_error (field
, type
);
2851 if (TREE_CODE (t
) == UNION_TYPE
)
2853 if (TYPE_NEEDS_CONSTRUCTING (type
))
2854 error ("member %q+#D with constructor not allowed in union",
2856 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2857 error ("member %q+#D with destructor not allowed in union", field
);
2858 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type
))
2859 error ("member %q+#D with copy assignment operator not allowed in union",
2864 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (type
);
2865 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
2866 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
);
2867 TYPE_HAS_COMPLEX_ASSIGN_REF (t
) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type
);
2868 TYPE_HAS_COMPLEX_INIT_REF (t
) |= TYPE_HAS_COMPLEX_INIT_REF (type
);
2869 TYPE_HAS_COMPLEX_DFLT (t
) |= TYPE_HAS_COMPLEX_DFLT (type
);
2872 if (!TYPE_HAS_CONST_INIT_REF (type
))
2873 *cant_have_const_ctor
= 1;
2875 if (!TYPE_HAS_CONST_ASSIGN_REF (type
))
2876 *no_const_asn_ref
= 1;
2878 if (DECL_INITIAL (field
) != NULL_TREE
)
2880 /* `build_class_init_list' does not recognize
2882 if (TREE_CODE (t
) == UNION_TYPE
&& any_default_members
!= 0)
2883 error ("multiple fields in union %qT initialized", t
);
2884 *any_default_members
= 1;
2888 /* Check the data members (both static and non-static), class-scoped
2889 typedefs, etc., appearing in the declaration of T. Issue
2890 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
2891 declaration order) of access declarations; each TREE_VALUE in this
2892 list is a USING_DECL.
2894 In addition, set the following flags:
2897 The class is empty, i.e., contains no non-static data members.
2899 CANT_HAVE_CONST_CTOR_P
2900 This class cannot have an implicitly generated copy constructor
2901 taking a const reference.
2903 CANT_HAVE_CONST_ASN_REF
2904 This class cannot have an implicitly generated assignment
2905 operator taking a const reference.
2907 All of these flags should be initialized before calling this
2910 Returns a pointer to the end of the TYPE_FIELDs chain; additional
2911 fields can be added by adding to this chain. */
2914 check_field_decls (tree t
, tree
*access_decls
,
2915 int *cant_have_const_ctor_p
,
2916 int *no_const_asn_ref_p
)
2921 int any_default_members
;
2923 int field_access
= -1;
2925 /* Assume there are no access declarations. */
2926 *access_decls
= NULL_TREE
;
2927 /* Assume this class has no pointer members. */
2928 has_pointers
= false;
2929 /* Assume none of the members of this class have default
2931 any_default_members
= 0;
2933 for (field
= &TYPE_FIELDS (t
); *field
; field
= next
)
2936 tree type
= TREE_TYPE (x
);
2937 int this_field_access
;
2939 next
= &TREE_CHAIN (x
);
2941 if (TREE_CODE (x
) == USING_DECL
)
2943 /* Prune the access declaration from the list of fields. */
2944 *field
= TREE_CHAIN (x
);
2946 /* Save the access declarations for our caller. */
2947 *access_decls
= tree_cons (NULL_TREE
, x
, *access_decls
);
2949 /* Since we've reset *FIELD there's no reason to skip to the
2955 if (TREE_CODE (x
) == TYPE_DECL
2956 || TREE_CODE (x
) == TEMPLATE_DECL
)
2959 /* If we've gotten this far, it's a data member, possibly static,
2960 or an enumerator. */
2961 DECL_CONTEXT (x
) = t
;
2963 /* When this goes into scope, it will be a non-local reference. */
2964 DECL_NONLOCAL (x
) = 1;
2966 if (TREE_CODE (t
) == UNION_TYPE
)
2970 If a union contains a static data member, or a member of
2971 reference type, the program is ill-formed. */
2972 if (TREE_CODE (x
) == VAR_DECL
)
2974 error ("%q+D may not be static because it is a member of a union", x
);
2977 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2979 error ("%q+D may not have reference type %qT because"
2980 " it is a member of a union",
2986 /* Perform error checking that did not get done in
2988 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2990 error ("field %q+D invalidly declared function type", x
);
2991 type
= build_pointer_type (type
);
2992 TREE_TYPE (x
) = type
;
2994 else if (TREE_CODE (type
) == METHOD_TYPE
)
2996 error ("field %q+D invalidly declared method type", x
);
2997 type
= build_pointer_type (type
);
2998 TREE_TYPE (x
) = type
;
3001 if (type
== error_mark_node
)
3004 if (TREE_CODE (x
) == CONST_DECL
|| TREE_CODE (x
) == VAR_DECL
)
3007 /* Now it can only be a FIELD_DECL. */
3009 if (TREE_PRIVATE (x
) || TREE_PROTECTED (x
))
3010 CLASSTYPE_NON_AGGREGATE (t
) = 1;
3012 /* A standard-layout class is a class that:
3014 has the same access control (Clause 11) for all non-static data members,
3016 this_field_access
= TREE_PROTECTED (x
) ? 1 : TREE_PRIVATE (x
) ? 2 : 0;
3017 if (field_access
== -1)
3018 field_access
= this_field_access
;
3019 else if (this_field_access
!= field_access
)
3020 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3022 /* If this is of reference type, check if it needs an init. */
3023 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3025 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3026 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3027 if (DECL_INITIAL (x
) == NULL_TREE
)
3028 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3030 /* ARM $12.6.2: [A member initializer list] (or, for an
3031 aggregate, initialization by a brace-enclosed list) is the
3032 only way to initialize nonstatic const and reference
3034 TYPE_HAS_COMPLEX_ASSIGN_REF (t
) = 1;
3037 type
= strip_array_types (type
);
3039 if (TYPE_PACKED (t
))
3041 if (!layout_pod_type_p (type
) && !TYPE_PACKED (type
))
3045 "ignoring packed attribute because of unpacked non-POD field %q+#D",
3049 else if (DECL_C_BIT_FIELD (x
)
3050 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
)
3051 DECL_PACKED (x
) = 1;
3054 if (DECL_C_BIT_FIELD (x
) && integer_zerop (DECL_INITIAL (x
)))
3055 /* We don't treat zero-width bitfields as making a class
3060 /* The class is non-empty. */
3061 CLASSTYPE_EMPTY_P (t
) = 0;
3062 /* The class is not even nearly empty. */
3063 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3064 /* If one of the data members contains an empty class,
3066 if (CLASS_TYPE_P (type
)
3067 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3068 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
3071 /* This is used by -Weffc++ (see below). Warn only for pointers
3072 to members which might hold dynamic memory. So do not warn
3073 for pointers to functions or pointers to members. */
3074 if (TYPE_PTR_P (type
)
3075 && !TYPE_PTRFN_P (type
)
3076 && !TYPE_PTR_TO_MEMBER_P (type
))
3077 has_pointers
= true;
3079 if (CLASS_TYPE_P (type
))
3081 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type
))
3082 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3083 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
))
3084 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3087 if (DECL_MUTABLE_P (x
) || TYPE_HAS_MUTABLE_P (type
))
3088 CLASSTYPE_HAS_MUTABLE (t
) = 1;
3090 if (! layout_pod_type_p (type
))
3091 /* DR 148 now allows pointers to members (which are POD themselves),
3092 to be allowed in POD structs. */
3093 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3095 if (!std_layout_type_p (type
))
3096 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3098 if (! zero_init_p (type
))
3099 CLASSTYPE_NON_ZERO_INIT_P (t
) = 1;
3101 /* If any field is const, the structure type is pseudo-const. */
3102 if (CP_TYPE_CONST_P (type
))
3104 C_TYPE_FIELDS_READONLY (t
) = 1;
3105 if (DECL_INITIAL (x
) == NULL_TREE
)
3106 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3108 /* ARM $12.6.2: [A member initializer list] (or, for an
3109 aggregate, initialization by a brace-enclosed list) is the
3110 only way to initialize nonstatic const and reference
3112 TYPE_HAS_COMPLEX_ASSIGN_REF (t
) = 1;
3114 /* A field that is pseudo-const makes the structure likewise. */
3115 else if (CLASS_TYPE_P (type
))
3117 C_TYPE_FIELDS_READONLY (t
) |= C_TYPE_FIELDS_READONLY (type
);
3118 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
,
3119 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
3120 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
));
3123 /* Core issue 80: A nonstatic data member is required to have a
3124 different name from the class iff the class has a
3125 user-declared constructor. */
3126 if (constructor_name_p (DECL_NAME (x
), t
)
3127 && TYPE_HAS_USER_CONSTRUCTOR (t
))
3128 permerror (input_location
, "field %q+#D with same name as class", x
);
3130 /* We set DECL_C_BIT_FIELD in grokbitfield.
3131 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3132 if (! DECL_C_BIT_FIELD (x
) || ! check_bitfield_decl (x
))
3133 check_field_decl (x
, t
,
3134 cant_have_const_ctor_p
,
3136 &any_default_members
);
3139 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3140 it should also define a copy constructor and an assignment operator to
3141 implement the correct copy semantic (deep vs shallow, etc.). As it is
3142 not feasible to check whether the constructors do allocate dynamic memory
3143 and store it within members, we approximate the warning like this:
3145 -- Warn only if there are members which are pointers
3146 -- Warn only if there is a non-trivial constructor (otherwise,
3147 there cannot be memory allocated).
3148 -- Warn only if there is a non-trivial destructor. We assume that the
3149 user at least implemented the cleanup correctly, and a destructor
3150 is needed to free dynamic memory.
3152 This seems enough for practical purposes. */
3155 && TYPE_HAS_USER_CONSTRUCTOR (t
)
3156 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3157 && !(TYPE_HAS_INIT_REF (t
) && TYPE_HAS_ASSIGN_REF (t
)))
3159 warning (OPT_Weffc__
, "%q#T has pointer data members", t
);
3161 if (! TYPE_HAS_INIT_REF (t
))
3163 warning (OPT_Weffc__
,
3164 " but does not override %<%T(const %T&)%>", t
, t
);
3165 if (!TYPE_HAS_ASSIGN_REF (t
))
3166 warning (OPT_Weffc__
, " or %<operator=(const %T&)%>", t
);
3168 else if (! TYPE_HAS_ASSIGN_REF (t
))
3169 warning (OPT_Weffc__
,
3170 " but does not override %<operator=(const %T&)%>", t
);
3173 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3175 TYPE_PACKED (t
) = 0;
3177 /* Check anonymous struct/anonymous union fields. */
3178 finish_struct_anon (t
);
3180 /* We've built up the list of access declarations in reverse order.
3182 *access_decls
= nreverse (*access_decls
);
3185 /* If TYPE is an empty class type, records its OFFSET in the table of
3189 record_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3193 if (!is_empty_class (type
))
3196 /* Record the location of this empty object in OFFSETS. */
3197 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3199 n
= splay_tree_insert (offsets
,
3200 (splay_tree_key
) offset
,
3201 (splay_tree_value
) NULL_TREE
);
3202 n
->value
= ((splay_tree_value
)
3203 tree_cons (NULL_TREE
,
3210 /* Returns nonzero if TYPE is an empty class type and there is
3211 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3214 check_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3219 if (!is_empty_class (type
))
3222 /* Record the location of this empty object in OFFSETS. */
3223 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3227 for (t
= (tree
) n
->value
; t
; t
= TREE_CHAIN (t
))
3228 if (same_type_p (TREE_VALUE (t
), type
))
3234 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3235 F for every subobject, passing it the type, offset, and table of
3236 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3239 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3240 than MAX_OFFSET will not be walked.
3242 If F returns a nonzero value, the traversal ceases, and that value
3243 is returned. Otherwise, returns zero. */
3246 walk_subobject_offsets (tree type
,
3247 subobject_offset_fn f
,
3254 tree type_binfo
= NULL_TREE
;
3256 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3258 if (max_offset
&& INT_CST_LT (max_offset
, offset
))
3261 if (type
== error_mark_node
)
3266 if (abi_version_at_least (2))
3268 type
= BINFO_TYPE (type
);
3271 if (CLASS_TYPE_P (type
))
3277 /* Avoid recursing into objects that are not interesting. */
3278 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3281 /* Record the location of TYPE. */
3282 r
= (*f
) (type
, offset
, offsets
);
3286 /* Iterate through the direct base classes of TYPE. */
3288 type_binfo
= TYPE_BINFO (type
);
3289 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, binfo
); i
++)
3293 if (abi_version_at_least (2)
3294 && BINFO_VIRTUAL_P (binfo
))
3298 && BINFO_VIRTUAL_P (binfo
)
3299 && !BINFO_PRIMARY_P (binfo
))
3302 if (!abi_version_at_least (2))
3303 binfo_offset
= size_binop (PLUS_EXPR
,
3305 BINFO_OFFSET (binfo
));
3309 /* We cannot rely on BINFO_OFFSET being set for the base
3310 class yet, but the offsets for direct non-virtual
3311 bases can be calculated by going back to the TYPE. */
3312 orig_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
3313 binfo_offset
= size_binop (PLUS_EXPR
,
3315 BINFO_OFFSET (orig_binfo
));
3318 r
= walk_subobject_offsets (binfo
,
3323 (abi_version_at_least (2)
3324 ? /*vbases_p=*/0 : vbases_p
));
3329 if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type
))
3332 VEC(tree
,gc
) *vbases
;
3334 /* Iterate through the virtual base classes of TYPE. In G++
3335 3.2, we included virtual bases in the direct base class
3336 loop above, which results in incorrect results; the
3337 correct offsets for virtual bases are only known when
3338 working with the most derived type. */
3340 for (vbases
= CLASSTYPE_VBASECLASSES (type
), ix
= 0;
3341 VEC_iterate (tree
, vbases
, ix
, binfo
); ix
++)
3343 r
= walk_subobject_offsets (binfo
,
3345 size_binop (PLUS_EXPR
,
3347 BINFO_OFFSET (binfo
)),
3356 /* We still have to walk the primary base, if it is
3357 virtual. (If it is non-virtual, then it was walked
3359 tree vbase
= get_primary_binfo (type_binfo
);
3361 if (vbase
&& BINFO_VIRTUAL_P (vbase
)
3362 && BINFO_PRIMARY_P (vbase
)
3363 && BINFO_INHERITANCE_CHAIN (vbase
) == type_binfo
)
3365 r
= (walk_subobject_offsets
3367 offsets
, max_offset
, /*vbases_p=*/0));
3374 /* Iterate through the fields of TYPE. */
3375 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
3376 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_ARTIFICIAL (field
))
3380 if (abi_version_at_least (2))
3381 field_offset
= byte_position (field
);
3383 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3384 field_offset
= DECL_FIELD_OFFSET (field
);
3386 r
= walk_subobject_offsets (TREE_TYPE (field
),
3388 size_binop (PLUS_EXPR
,
3398 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3400 tree element_type
= strip_array_types (type
);
3401 tree domain
= TYPE_DOMAIN (type
);
3404 /* Avoid recursing into objects that are not interesting. */
3405 if (!CLASS_TYPE_P (element_type
)
3406 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type
))
3409 /* Step through each of the elements in the array. */
3410 for (index
= size_zero_node
;
3411 /* G++ 3.2 had an off-by-one error here. */
3412 (abi_version_at_least (2)
3413 ? !INT_CST_LT (TYPE_MAX_VALUE (domain
), index
)
3414 : INT_CST_LT (index
, TYPE_MAX_VALUE (domain
)));
3415 index
= size_binop (PLUS_EXPR
, index
, size_one_node
))
3417 r
= walk_subobject_offsets (TREE_TYPE (type
),
3425 offset
= size_binop (PLUS_EXPR
, offset
,
3426 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3427 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3428 there's no point in iterating through the remaining
3429 elements of the array. */
3430 if (max_offset
&& INT_CST_LT (max_offset
, offset
))
3438 /* Record all of the empty subobjects of TYPE (either a type or a
3439 binfo). If IS_DATA_MEMBER is true, then a non-static data member
3440 is being placed at OFFSET; otherwise, it is a base class that is
3441 being placed at OFFSET. */
3444 record_subobject_offsets (tree type
,
3447 bool is_data_member
)
3450 /* If recording subobjects for a non-static data member or a
3451 non-empty base class , we do not need to record offsets beyond
3452 the size of the biggest empty class. Additional data members
3453 will go at the end of the class. Additional base classes will go
3454 either at offset zero (if empty, in which case they cannot
3455 overlap with offsets past the size of the biggest empty class) or
3456 at the end of the class.
3458 However, if we are placing an empty base class, then we must record
3459 all offsets, as either the empty class is at offset zero (where
3460 other empty classes might later be placed) or at the end of the
3461 class (where other objects might then be placed, so other empty
3462 subobjects might later overlap). */
3464 || !is_empty_class (BINFO_TYPE (type
)))
3465 max_offset
= sizeof_biggest_empty_class
;
3467 max_offset
= NULL_TREE
;
3468 walk_subobject_offsets (type
, record_subobject_offset
, offset
,
3469 offsets
, max_offset
, is_data_member
);
3472 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3473 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3474 virtual bases of TYPE are examined. */
3477 layout_conflict_p (tree type
,
3482 splay_tree_node max_node
;
3484 /* Get the node in OFFSETS that indicates the maximum offset where
3485 an empty subobject is located. */
3486 max_node
= splay_tree_max (offsets
);
3487 /* If there aren't any empty subobjects, then there's no point in
3488 performing this check. */
3492 return walk_subobject_offsets (type
, check_subobject_offset
, offset
,
3493 offsets
, (tree
) (max_node
->key
),
3497 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3498 non-static data member of the type indicated by RLI. BINFO is the
3499 binfo corresponding to the base subobject, OFFSETS maps offsets to
3500 types already located at those offsets. This function determines
3501 the position of the DECL. */
3504 layout_nonempty_base_or_field (record_layout_info rli
,
3509 tree offset
= NULL_TREE
;
3515 /* For the purposes of determining layout conflicts, we want to
3516 use the class type of BINFO; TREE_TYPE (DECL) will be the
3517 CLASSTYPE_AS_BASE version, which does not contain entries for
3518 zero-sized bases. */
3519 type
= TREE_TYPE (binfo
);
3524 type
= TREE_TYPE (decl
);
3528 /* Try to place the field. It may take more than one try if we have
3529 a hard time placing the field without putting two objects of the
3530 same type at the same address. */
3533 struct record_layout_info_s old_rli
= *rli
;
3535 /* Place this field. */
3536 place_field (rli
, decl
);
3537 offset
= byte_position (decl
);
3539 /* We have to check to see whether or not there is already
3540 something of the same type at the offset we're about to use.
3541 For example, consider:
3544 struct T : public S { int i; };
3545 struct U : public S, public T {};
3547 Here, we put S at offset zero in U. Then, we can't put T at
3548 offset zero -- its S component would be at the same address
3549 as the S we already allocated. So, we have to skip ahead.
3550 Since all data members, including those whose type is an
3551 empty class, have nonzero size, any overlap can happen only
3552 with a direct or indirect base-class -- it can't happen with
3554 /* In a union, overlap is permitted; all members are placed at
3556 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
3558 /* G++ 3.2 did not check for overlaps when placing a non-empty
3560 if (!abi_version_at_least (2) && binfo
&& BINFO_VIRTUAL_P (binfo
))
3562 if (layout_conflict_p (field_p
? type
: binfo
, offset
,
3565 /* Strip off the size allocated to this field. That puts us
3566 at the first place we could have put the field with
3567 proper alignment. */
3570 /* Bump up by the alignment required for the type. */
3572 = size_binop (PLUS_EXPR
, rli
->bitpos
,
3574 ? CLASSTYPE_ALIGN (type
)
3575 : TYPE_ALIGN (type
)));
3576 normalize_rli (rli
);
3579 /* There was no conflict. We're done laying out this field. */
3583 /* Now that we know where it will be placed, update its
3585 if (binfo
&& CLASS_TYPE_P (BINFO_TYPE (binfo
)))
3586 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3587 this point because their BINFO_OFFSET is copied from another
3588 hierarchy. Therefore, we may not need to add the entire
3590 propagate_binfo_offsets (binfo
,
3591 size_diffop_loc (input_location
,
3592 convert (ssizetype
, offset
),
3594 BINFO_OFFSET (binfo
))));
3597 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3600 empty_base_at_nonzero_offset_p (tree type
,
3602 splay_tree offsets ATTRIBUTE_UNUSED
)
3604 return is_empty_class (type
) && !integer_zerop (offset
);
3607 /* Layout the empty base BINFO. EOC indicates the byte currently just
3608 past the end of the class, and should be correctly aligned for a
3609 class of the type indicated by BINFO; OFFSETS gives the offsets of
3610 the empty bases allocated so far. T is the most derived
3611 type. Return nonzero iff we added it at the end. */
3614 layout_empty_base (record_layout_info rli
, tree binfo
,
3615 tree eoc
, splay_tree offsets
)
3618 tree basetype
= BINFO_TYPE (binfo
);
3621 /* This routine should only be used for empty classes. */
3622 gcc_assert (is_empty_class (basetype
));
3623 alignment
= ssize_int (CLASSTYPE_ALIGN_UNIT (basetype
));
3625 if (!integer_zerop (BINFO_OFFSET (binfo
)))
3627 if (abi_version_at_least (2))
3628 propagate_binfo_offsets
3629 (binfo
, size_diffop_loc (input_location
,
3630 size_zero_node
, BINFO_OFFSET (binfo
)));
3633 "offset of empty base %qT may not be ABI-compliant and may"
3634 "change in a future version of GCC",
3635 BINFO_TYPE (binfo
));
3638 /* This is an empty base class. We first try to put it at offset
3640 if (layout_conflict_p (binfo
,
3641 BINFO_OFFSET (binfo
),
3645 /* That didn't work. Now, we move forward from the next
3646 available spot in the class. */
3648 propagate_binfo_offsets (binfo
, convert (ssizetype
, eoc
));
3651 if (!layout_conflict_p (binfo
,
3652 BINFO_OFFSET (binfo
),
3655 /* We finally found a spot where there's no overlap. */
3658 /* There's overlap here, too. Bump along to the next spot. */
3659 propagate_binfo_offsets (binfo
, alignment
);
3663 if (CLASSTYPE_USER_ALIGN (basetype
))
3665 rli
->record_align
= MAX (rli
->record_align
, CLASSTYPE_ALIGN (basetype
));
3667 rli
->unpacked_align
= MAX (rli
->unpacked_align
, CLASSTYPE_ALIGN (basetype
));
3668 TYPE_USER_ALIGN (rli
->t
) = 1;
3674 /* Layout the base given by BINFO in the class indicated by RLI.
3675 *BASE_ALIGN is a running maximum of the alignments of
3676 any base class. OFFSETS gives the location of empty base
3677 subobjects. T is the most derived type. Return nonzero if the new
3678 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3679 *NEXT_FIELD, unless BINFO is for an empty base class.
3681 Returns the location at which the next field should be inserted. */
3684 build_base_field (record_layout_info rli
, tree binfo
,
3685 splay_tree offsets
, tree
*next_field
)
3688 tree basetype
= BINFO_TYPE (binfo
);
3690 if (!COMPLETE_TYPE_P (basetype
))
3691 /* This error is now reported in xref_tag, thus giving better
3692 location information. */
3695 /* Place the base class. */
3696 if (!is_empty_class (basetype
))
3700 /* The containing class is non-empty because it has a non-empty
3702 CLASSTYPE_EMPTY_P (t
) = 0;
3704 /* Create the FIELD_DECL. */
3705 decl
= build_decl (input_location
,
3706 FIELD_DECL
, NULL_TREE
, CLASSTYPE_AS_BASE (basetype
));
3707 DECL_ARTIFICIAL (decl
) = 1;
3708 DECL_IGNORED_P (decl
) = 1;
3709 DECL_FIELD_CONTEXT (decl
) = t
;
3710 if (CLASSTYPE_AS_BASE (basetype
))
3712 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
3713 DECL_SIZE_UNIT (decl
) = CLASSTYPE_SIZE_UNIT (basetype
);
3714 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
3715 DECL_USER_ALIGN (decl
) = CLASSTYPE_USER_ALIGN (basetype
);
3716 DECL_MODE (decl
) = TYPE_MODE (basetype
);
3717 DECL_FIELD_IS_BASE (decl
) = 1;
3719 /* Try to place the field. It may take more than one try if we
3720 have a hard time placing the field without putting two
3721 objects of the same type at the same address. */
3722 layout_nonempty_base_or_field (rli
, decl
, binfo
, offsets
);
3723 /* Add the new FIELD_DECL to the list of fields for T. */
3724 TREE_CHAIN (decl
) = *next_field
;
3726 next_field
= &TREE_CHAIN (decl
);
3734 /* On some platforms (ARM), even empty classes will not be
3736 eoc
= round_up_loc (input_location
,
3737 rli_size_unit_so_far (rli
),
3738 CLASSTYPE_ALIGN_UNIT (basetype
));
3739 atend
= layout_empty_base (rli
, binfo
, eoc
, offsets
);
3740 /* A nearly-empty class "has no proper base class that is empty,
3741 not morally virtual, and at an offset other than zero." */
3742 if (!BINFO_VIRTUAL_P (binfo
) && CLASSTYPE_NEARLY_EMPTY_P (t
))
3745 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3746 /* The check above (used in G++ 3.2) is insufficient because
3747 an empty class placed at offset zero might itself have an
3748 empty base at a nonzero offset. */
3749 else if (walk_subobject_offsets (basetype
,
3750 empty_base_at_nonzero_offset_p
,
3753 /*max_offset=*/NULL_TREE
,
3756 if (abi_version_at_least (2))
3757 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3760 "class %qT will be considered nearly empty in a "
3761 "future version of GCC", t
);
3765 /* We do not create a FIELD_DECL for empty base classes because
3766 it might overlap some other field. We want to be able to
3767 create CONSTRUCTORs for the class by iterating over the
3768 FIELD_DECLs, and the back end does not handle overlapping
3771 /* An empty virtual base causes a class to be non-empty
3772 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3773 here because that was already done when the virtual table
3774 pointer was created. */
3777 /* Record the offsets of BINFO and its base subobjects. */
3778 record_subobject_offsets (binfo
,
3779 BINFO_OFFSET (binfo
),
3781 /*is_data_member=*/false);
3786 /* Layout all of the non-virtual base classes. Record empty
3787 subobjects in OFFSETS. T is the most derived type. Return nonzero
3788 if the type cannot be nearly empty. The fields created
3789 corresponding to the base classes will be inserted at
3793 build_base_fields (record_layout_info rli
,
3794 splay_tree offsets
, tree
*next_field
)
3796 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3799 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
3802 /* The primary base class is always allocated first. */
3803 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
3804 next_field
= build_base_field (rli
, CLASSTYPE_PRIMARY_BINFO (t
),
3805 offsets
, next_field
);
3807 /* Now allocate the rest of the bases. */
3808 for (i
= 0; i
< n_baseclasses
; ++i
)
3812 base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (t
), i
);
3814 /* The primary base was already allocated above, so we don't
3815 need to allocate it again here. */
3816 if (base_binfo
== CLASSTYPE_PRIMARY_BINFO (t
))
3819 /* Virtual bases are added at the end (a primary virtual base
3820 will have already been added). */
3821 if (BINFO_VIRTUAL_P (base_binfo
))
3824 next_field
= build_base_field (rli
, base_binfo
,
3825 offsets
, next_field
);
3829 /* Go through the TYPE_METHODS of T issuing any appropriate
3830 diagnostics, figuring out which methods override which other
3831 methods, and so forth. */
3834 check_methods (tree t
)
3838 for (x
= TYPE_METHODS (t
); x
; x
= TREE_CHAIN (x
))
3840 check_for_override (x
, t
);
3841 if (DECL_PURE_VIRTUAL_P (x
) && ! DECL_VINDEX (x
))
3842 error ("initializer specified for non-virtual method %q+D", x
);
3843 /* The name of the field is the original field name
3844 Save this in auxiliary field for later overloading. */
3845 if (DECL_VINDEX (x
))
3847 TYPE_POLYMORPHIC_P (t
) = 1;
3848 if (DECL_PURE_VIRTUAL_P (x
))
3849 VEC_safe_push (tree
, gc
, CLASSTYPE_PURE_VIRTUALS (t
), x
);
3851 /* All user-provided destructors are non-trivial. */
3852 if (DECL_DESTRUCTOR_P (x
) && user_provided_p (x
))
3853 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = 1;
3857 /* FN is a constructor or destructor. Clone the declaration to create
3858 a specialized in-charge or not-in-charge version, as indicated by
3862 build_clone (tree fn
, tree name
)
3867 /* Copy the function. */
3868 clone
= copy_decl (fn
);
3869 /* Reset the function name. */
3870 DECL_NAME (clone
) = name
;
3871 SET_DECL_ASSEMBLER_NAME (clone
, NULL_TREE
);
3872 /* Remember where this function came from. */
3873 DECL_ABSTRACT_ORIGIN (clone
) = fn
;
3874 /* Make it easy to find the CLONE given the FN. */
3875 TREE_CHAIN (clone
) = TREE_CHAIN (fn
);
3876 TREE_CHAIN (fn
) = clone
;
3878 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
3879 if (TREE_CODE (clone
) == TEMPLATE_DECL
)
3881 tree result
= build_clone (DECL_TEMPLATE_RESULT (clone
), name
);
3882 DECL_TEMPLATE_RESULT (clone
) = result
;
3883 DECL_TEMPLATE_INFO (result
) = copy_node (DECL_TEMPLATE_INFO (result
));
3884 DECL_TI_TEMPLATE (result
) = clone
;
3885 TREE_TYPE (clone
) = TREE_TYPE (result
);
3889 DECL_CLONED_FUNCTION (clone
) = fn
;
3890 /* There's no pending inline data for this function. */
3891 DECL_PENDING_INLINE_INFO (clone
) = NULL
;
3892 DECL_PENDING_INLINE_P (clone
) = 0;
3894 /* The base-class destructor is not virtual. */
3895 if (name
== base_dtor_identifier
)
3897 DECL_VIRTUAL_P (clone
) = 0;
3898 if (TREE_CODE (clone
) != TEMPLATE_DECL
)
3899 DECL_VINDEX (clone
) = NULL_TREE
;
3902 /* If there was an in-charge parameter, drop it from the function
3904 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
3910 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
3911 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
3912 parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
3913 /* Skip the `this' parameter. */
3914 parmtypes
= TREE_CHAIN (parmtypes
);
3915 /* Skip the in-charge parameter. */
3916 parmtypes
= TREE_CHAIN (parmtypes
);
3917 /* And the VTT parm, in a complete [cd]tor. */
3918 if (DECL_HAS_VTT_PARM_P (fn
)
3919 && ! DECL_NEEDS_VTT_PARM_P (clone
))
3920 parmtypes
= TREE_CHAIN (parmtypes
);
3921 /* If this is subobject constructor or destructor, add the vtt
3924 = build_method_type_directly (basetype
,
3925 TREE_TYPE (TREE_TYPE (clone
)),
3928 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
),
3931 = cp_build_type_attribute_variant (TREE_TYPE (clone
),
3932 TYPE_ATTRIBUTES (TREE_TYPE (fn
)));
3935 /* Copy the function parameters. */
3936 DECL_ARGUMENTS (clone
) = copy_list (DECL_ARGUMENTS (clone
));
3937 /* Remove the in-charge parameter. */
3938 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
3940 TREE_CHAIN (DECL_ARGUMENTS (clone
))
3941 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone
)));
3942 DECL_HAS_IN_CHARGE_PARM_P (clone
) = 0;
3944 /* And the VTT parm, in a complete [cd]tor. */
3945 if (DECL_HAS_VTT_PARM_P (fn
))
3947 if (DECL_NEEDS_VTT_PARM_P (clone
))
3948 DECL_HAS_VTT_PARM_P (clone
) = 1;
3951 TREE_CHAIN (DECL_ARGUMENTS (clone
))
3952 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone
)));
3953 DECL_HAS_VTT_PARM_P (clone
) = 0;
3957 for (parms
= DECL_ARGUMENTS (clone
); parms
; parms
= TREE_CHAIN (parms
))
3959 DECL_CONTEXT (parms
) = clone
;
3960 cxx_dup_lang_specific_decl (parms
);
3963 /* Create the RTL for this function. */
3964 SET_DECL_RTL (clone
, NULL_RTX
);
3965 rest_of_decl_compilation (clone
, /*top_level=*/1, at_eof
);
3968 note_decl_for_pch (clone
);
3973 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
3974 not invoke this function directly.
3976 For a non-thunk function, returns the address of the slot for storing
3977 the function it is a clone of. Otherwise returns NULL_TREE.
3979 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
3980 cloned_function is unset. This is to support the separate
3981 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
3982 on a template makes sense, but not the former. */
3985 decl_cloned_function_p (const_tree decl
, bool just_testing
)
3989 decl
= STRIP_TEMPLATE (decl
);
3991 if (TREE_CODE (decl
) != FUNCTION_DECL
3992 || !DECL_LANG_SPECIFIC (decl
)
3993 || DECL_LANG_SPECIFIC (decl
)->u
.fn
.thunk_p
)
3995 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3997 lang_check_failed (__FILE__
, __LINE__
, __FUNCTION__
);
4003 ptr
= &DECL_LANG_SPECIFIC (decl
)->u
.fn
.u5
.cloned_function
;
4004 if (just_testing
&& *ptr
== NULL_TREE
)
4010 /* Produce declarations for all appropriate clones of FN. If
4011 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4012 CLASTYPE_METHOD_VEC as well. */
4015 clone_function_decl (tree fn
, int update_method_vec_p
)
4019 /* Avoid inappropriate cloning. */
4021 && DECL_CLONED_FUNCTION_P (TREE_CHAIN (fn
)))
4024 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
4026 /* For each constructor, we need two variants: an in-charge version
4027 and a not-in-charge version. */
4028 clone
= build_clone (fn
, complete_ctor_identifier
);
4029 if (update_method_vec_p
)
4030 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4031 clone
= build_clone (fn
, base_ctor_identifier
);
4032 if (update_method_vec_p
)
4033 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4037 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
));
4039 /* For each destructor, we need three variants: an in-charge
4040 version, a not-in-charge version, and an in-charge deleting
4041 version. We clone the deleting version first because that
4042 means it will go second on the TYPE_METHODS list -- and that
4043 corresponds to the correct layout order in the virtual
4046 For a non-virtual destructor, we do not build a deleting
4048 if (DECL_VIRTUAL_P (fn
))
4050 clone
= build_clone (fn
, deleting_dtor_identifier
);
4051 if (update_method_vec_p
)
4052 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4054 clone
= build_clone (fn
, complete_dtor_identifier
);
4055 if (update_method_vec_p
)
4056 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4057 clone
= build_clone (fn
, base_dtor_identifier
);
4058 if (update_method_vec_p
)
4059 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4062 /* Note that this is an abstract function that is never emitted. */
4063 DECL_ABSTRACT (fn
) = 1;
4066 /* DECL is an in charge constructor, which is being defined. This will
4067 have had an in class declaration, from whence clones were
4068 declared. An out-of-class definition can specify additional default
4069 arguments. As it is the clones that are involved in overload
4070 resolution, we must propagate the information from the DECL to its
4074 adjust_clone_args (tree decl
)
4078 for (clone
= TREE_CHAIN (decl
); clone
&& DECL_CLONED_FUNCTION_P (clone
);
4079 clone
= TREE_CHAIN (clone
))
4081 tree orig_clone_parms
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4082 tree orig_decl_parms
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
4083 tree decl_parms
, clone_parms
;
4085 clone_parms
= orig_clone_parms
;
4087 /* Skip the 'this' parameter. */
4088 orig_clone_parms
= TREE_CHAIN (orig_clone_parms
);
4089 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4091 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
4092 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4093 if (DECL_HAS_VTT_PARM_P (decl
))
4094 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4096 clone_parms
= orig_clone_parms
;
4097 if (DECL_HAS_VTT_PARM_P (clone
))
4098 clone_parms
= TREE_CHAIN (clone_parms
);
4100 for (decl_parms
= orig_decl_parms
; decl_parms
;
4101 decl_parms
= TREE_CHAIN (decl_parms
),
4102 clone_parms
= TREE_CHAIN (clone_parms
))
4104 gcc_assert (same_type_p (TREE_TYPE (decl_parms
),
4105 TREE_TYPE (clone_parms
)));
4107 if (TREE_PURPOSE (decl_parms
) && !TREE_PURPOSE (clone_parms
))
4109 /* A default parameter has been added. Adjust the
4110 clone's parameters. */
4111 tree exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4112 tree attrs
= TYPE_ATTRIBUTES (TREE_TYPE (clone
));
4113 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4116 clone_parms
= orig_decl_parms
;
4118 if (DECL_HAS_VTT_PARM_P (clone
))
4120 clone_parms
= tree_cons (TREE_PURPOSE (orig_clone_parms
),
4121 TREE_VALUE (orig_clone_parms
),
4123 TREE_TYPE (clone_parms
) = TREE_TYPE (orig_clone_parms
);
4125 type
= build_method_type_directly (basetype
,
4126 TREE_TYPE (TREE_TYPE (clone
)),
4129 type
= build_exception_variant (type
, exceptions
);
4131 type
= cp_build_type_attribute_variant (type
, attrs
);
4132 TREE_TYPE (clone
) = type
;
4134 clone_parms
= NULL_TREE
;
4138 gcc_assert (!clone_parms
);
4142 /* For each of the constructors and destructors in T, create an
4143 in-charge and not-in-charge variant. */
4146 clone_constructors_and_destructors (tree t
)
4150 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4152 if (!CLASSTYPE_METHOD_VEC (t
))
4155 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4156 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
4157 for (fns
= CLASSTYPE_DESTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4158 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
4161 /* Returns true iff class T has a user-defined constructor other than
4162 the default constructor. */
4165 type_has_user_nondefault_constructor (tree t
)
4169 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4172 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4174 tree fn
= OVL_CURRENT (fns
);
4175 if (!DECL_ARTIFICIAL (fn
)
4176 && (TREE_CODE (fn
) == TEMPLATE_DECL
4177 || (skip_artificial_parms_for (fn
, DECL_ARGUMENTS (fn
))
4185 /* Returns the defaulted constructor if T has one. Otherwise, returns
4189 in_class_defaulted_default_constructor (tree t
)
4193 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4196 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4198 tree fn
= OVL_CURRENT (fns
);
4200 if (DECL_DEFAULTED_IN_CLASS_P (fn
))
4202 args
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
4203 while (args
&& TREE_PURPOSE (args
))
4204 args
= TREE_CHAIN (args
);
4205 if (!args
|| args
== void_list_node
)
4213 /* Returns true iff FN is a user-provided function, i.e. user-declared
4214 and not defaulted at its first declaration; or explicit, private,
4215 protected, or non-const. */
4218 user_provided_p (tree fn
)
4220 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4223 return (!DECL_ARTIFICIAL (fn
)
4224 && !DECL_DEFAULTED_IN_CLASS_P (fn
));
4227 /* Returns true iff class T has a user-provided constructor. */
4230 type_has_user_provided_constructor (tree t
)
4234 if (!CLASS_TYPE_P (t
))
4237 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4240 /* This can happen in error cases; avoid crashing. */
4241 if (!CLASSTYPE_METHOD_VEC (t
))
4244 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4245 if (user_provided_p (OVL_CURRENT (fns
)))
4251 /* Returns true iff class T has a user-provided default constructor. */
4254 type_has_user_provided_default_constructor (tree t
)
4258 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4261 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4263 tree fn
= OVL_CURRENT (fns
);
4264 if (TREE_CODE (fn
) == FUNCTION_DECL
4265 && user_provided_p (fn
))
4267 args
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
4268 while (args
&& TREE_PURPOSE (args
))
4269 args
= TREE_CHAIN (args
);
4270 if (!args
|| args
== void_list_node
)
4278 /* Remove all zero-width bit-fields from T. */
4281 remove_zero_width_bit_fields (tree t
)
4285 fieldsp
= &TYPE_FIELDS (t
);
4288 if (TREE_CODE (*fieldsp
) == FIELD_DECL
4289 && DECL_C_BIT_FIELD (*fieldsp
)
4290 /* We should not be confused by the fact that grokbitfield
4291 temporarily sets the width of the bit field into
4292 DECL_INITIAL (*fieldsp).
4293 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
4295 && integer_zerop (DECL_SIZE (*fieldsp
)))
4296 *fieldsp
= TREE_CHAIN (*fieldsp
);
4298 fieldsp
= &TREE_CHAIN (*fieldsp
);
4302 /* Returns TRUE iff we need a cookie when dynamically allocating an
4303 array whose elements have the indicated class TYPE. */
4306 type_requires_array_cookie (tree type
)
4309 bool has_two_argument_delete_p
= false;
4311 gcc_assert (CLASS_TYPE_P (type
));
4313 /* If there's a non-trivial destructor, we need a cookie. In order
4314 to iterate through the array calling the destructor for each
4315 element, we'll have to know how many elements there are. */
4316 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4319 /* If the usual deallocation function is a two-argument whose second
4320 argument is of type `size_t', then we have to pass the size of
4321 the array to the deallocation function, so we will need to store
4323 fns
= lookup_fnfields (TYPE_BINFO (type
),
4324 ansi_opname (VEC_DELETE_EXPR
),
4326 /* If there are no `operator []' members, or the lookup is
4327 ambiguous, then we don't need a cookie. */
4328 if (!fns
|| fns
== error_mark_node
)
4330 /* Loop through all of the functions. */
4331 for (fns
= BASELINK_FUNCTIONS (fns
); fns
; fns
= OVL_NEXT (fns
))
4336 /* Select the current function. */
4337 fn
= OVL_CURRENT (fns
);
4338 /* See if this function is a one-argument delete function. If
4339 it is, then it will be the usual deallocation function. */
4340 second_parm
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn
)));
4341 if (second_parm
== void_list_node
)
4343 /* Do not consider this function if its second argument is an
4347 /* Otherwise, if we have a two-argument function and the second
4348 argument is `size_t', it will be the usual deallocation
4349 function -- unless there is one-argument function, too. */
4350 if (TREE_CHAIN (second_parm
) == void_list_node
4351 && same_type_p (TREE_VALUE (second_parm
), size_type_node
))
4352 has_two_argument_delete_p
= true;
4355 return has_two_argument_delete_p
;
4358 /* Check the validity of the bases and members declared in T. Add any
4359 implicitly-generated functions (like copy-constructors and
4360 assignment operators). Compute various flag bits (like
4361 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
4362 level: i.e., independently of the ABI in use. */
4365 check_bases_and_members (tree t
)
4367 /* Nonzero if the implicitly generated copy constructor should take
4368 a non-const reference argument. */
4369 int cant_have_const_ctor
;
4370 /* Nonzero if the implicitly generated assignment operator
4371 should take a non-const reference argument. */
4372 int no_const_asn_ref
;
4374 bool saved_complex_asn_ref
;
4375 bool saved_nontrivial_dtor
;
4378 /* By default, we use const reference arguments and generate default
4380 cant_have_const_ctor
= 0;
4381 no_const_asn_ref
= 0;
4383 /* Check all the base-classes. */
4384 check_bases (t
, &cant_have_const_ctor
,
4387 /* Check all the method declarations. */
4390 /* Save the initial values of these flags which only indicate whether
4391 or not the class has user-provided functions. As we analyze the
4392 bases and members we can set these flags for other reasons. */
4393 saved_complex_asn_ref
= TYPE_HAS_COMPLEX_ASSIGN_REF (t
);
4394 saved_nontrivial_dtor
= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
4396 /* Check all the data member declarations. We cannot call
4397 check_field_decls until we have called check_bases check_methods,
4398 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4399 being set appropriately. */
4400 check_field_decls (t
, &access_decls
,
4401 &cant_have_const_ctor
,
4404 /* A nearly-empty class has to be vptr-containing; a nearly empty
4405 class contains just a vptr. */
4406 if (!TYPE_CONTAINS_VPTR_P (t
))
4407 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4409 /* Do some bookkeeping that will guide the generation of implicitly
4410 declared member functions. */
4411 TYPE_HAS_COMPLEX_INIT_REF (t
) |= TYPE_CONTAINS_VPTR_P (t
);
4412 /* We need to call a constructor for this class if it has a
4413 user-provided constructor, or if the default constructor is going
4414 to initialize the vptr. (This is not an if-and-only-if;
4415 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
4416 themselves need constructing.) */
4417 TYPE_NEEDS_CONSTRUCTING (t
)
4418 |= (type_has_user_provided_constructor (t
) || TYPE_CONTAINS_VPTR_P (t
));
4421 An aggregate is an array or a class with no user-provided
4422 constructors ... and no virtual functions.
4424 Again, other conditions for being an aggregate are checked
4426 CLASSTYPE_NON_AGGREGATE (t
)
4427 |= (type_has_user_provided_constructor (t
) || TYPE_POLYMORPHIC_P (t
));
4428 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
4429 retain the old definition internally for ABI reasons. */
4430 CLASSTYPE_NON_LAYOUT_POD_P (t
)
4431 |= (CLASSTYPE_NON_AGGREGATE (t
)
4432 || saved_nontrivial_dtor
|| saved_complex_asn_ref
);
4433 CLASSTYPE_NON_STD_LAYOUT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
4434 TYPE_HAS_COMPLEX_ASSIGN_REF (t
) |= TYPE_CONTAINS_VPTR_P (t
);
4435 TYPE_HAS_COMPLEX_DFLT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
4437 /* If the class has no user-declared constructor, but does have
4438 non-static const or reference data members that can never be
4439 initialized, issue a warning. */
4440 if (warn_uninitialized
4441 /* Classes with user-declared constructors are presumed to
4442 initialize these members. */
4443 && !TYPE_HAS_USER_CONSTRUCTOR (t
)
4444 /* Aggregates can be initialized with brace-enclosed
4446 && CLASSTYPE_NON_AGGREGATE (t
))
4450 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
4454 if (TREE_CODE (field
) != FIELD_DECL
)
4457 type
= TREE_TYPE (field
);
4458 if (TREE_CODE (type
) == REFERENCE_TYPE
)
4459 warning (OPT_Wuninitialized
, "non-static reference %q+#D "
4460 "in class without a constructor", field
);
4461 else if (CP_TYPE_CONST_P (type
)
4462 && (!CLASS_TYPE_P (type
)
4463 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
4464 warning (OPT_Wuninitialized
, "non-static const member %q+#D "
4465 "in class without a constructor", field
);
4469 /* Synthesize any needed methods. */
4470 add_implicitly_declared_members (t
,
4471 cant_have_const_ctor
,
4474 /* Check defaulted declarations here so we have cant_have_const_ctor
4475 and don't need to worry about clones. */
4476 for (fn
= TYPE_METHODS (t
); fn
; fn
= TREE_CHAIN (fn
))
4477 if (DECL_DEFAULTED_IN_CLASS_P (fn
))
4479 int copy
= copy_fn_p (fn
);
4483 = (DECL_CONSTRUCTOR_P (fn
) ? !cant_have_const_ctor
4484 : !no_const_asn_ref
);
4485 bool fn_const_p
= (copy
== 2);
4487 if (fn_const_p
&& !imp_const_p
)
4488 /* If the function is defaulted outside the class, we just
4489 give the synthesis error. */
4490 error ("%q+D declared to take const reference, but implicit "
4491 "declaration would take non-const", fn
);
4492 else if (imp_const_p
&& !fn_const_p
)
4493 error ("%q+D declared to take non-const reference cannot be "
4494 "defaulted in the class body", fn
);
4496 defaulted_late_check (fn
);
4499 if (LAMBDA_TYPE_P (t
))
4501 /* "The closure type associated with a lambda-expression has a deleted
4502 default constructor and a deleted copy assignment operator." */
4503 TYPE_NEEDS_CONSTRUCTING (t
) = 1;
4504 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4505 CLASSTYPE_LAZY_DEFAULT_CTOR (t
) = 0;
4506 TYPE_HAS_ASSIGN_REF (t
) = 0;
4507 CLASSTYPE_LAZY_ASSIGNMENT_OP (t
) = 0;
4509 /* "This class type is not an aggregate." */
4510 CLASSTYPE_NON_AGGREGATE (t
) = 1;
4513 /* Create the in-charge and not-in-charge variants of constructors
4515 clone_constructors_and_destructors (t
);
4517 /* Process the using-declarations. */
4518 for (; access_decls
; access_decls
= TREE_CHAIN (access_decls
))
4519 handle_using_decl (TREE_VALUE (access_decls
), t
);
4521 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4522 finish_struct_methods (t
);
4524 /* Figure out whether or not we will need a cookie when dynamically
4525 allocating an array of this type. */
4526 TYPE_LANG_SPECIFIC (t
)->u
.c
.vec_new_uses_cookie
4527 = type_requires_array_cookie (t
);
4530 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4531 accordingly. If a new vfield was created (because T doesn't have a
4532 primary base class), then the newly created field is returned. It
4533 is not added to the TYPE_FIELDS list; it is the caller's
4534 responsibility to do that. Accumulate declared virtual functions
4538 create_vtable_ptr (tree t
, tree
* virtuals_p
)
4542 /* Collect the virtual functions declared in T. */
4543 for (fn
= TYPE_METHODS (t
); fn
; fn
= TREE_CHAIN (fn
))
4544 if (DECL_VINDEX (fn
) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
)
4545 && TREE_CODE (DECL_VINDEX (fn
)) != INTEGER_CST
)
4547 tree new_virtual
= make_node (TREE_LIST
);
4549 BV_FN (new_virtual
) = fn
;
4550 BV_DELTA (new_virtual
) = integer_zero_node
;
4551 BV_VCALL_INDEX (new_virtual
) = NULL_TREE
;
4553 TREE_CHAIN (new_virtual
) = *virtuals_p
;
4554 *virtuals_p
= new_virtual
;
4557 /* If we couldn't find an appropriate base class, create a new field
4558 here. Even if there weren't any new virtual functions, we might need a
4559 new virtual function table if we're supposed to include vptrs in
4560 all classes that need them. */
4561 if (!TYPE_VFIELD (t
) && (*virtuals_p
|| TYPE_CONTAINS_VPTR_P (t
)))
4563 /* We build this decl with vtbl_ptr_type_node, which is a
4564 `vtable_entry_type*'. It might seem more precise to use
4565 `vtable_entry_type (*)[N]' where N is the number of virtual
4566 functions. However, that would require the vtable pointer in
4567 base classes to have a different type than the vtable pointer
4568 in derived classes. We could make that happen, but that
4569 still wouldn't solve all the problems. In particular, the
4570 type-based alias analysis code would decide that assignments
4571 to the base class vtable pointer can't alias assignments to
4572 the derived class vtable pointer, since they have different
4573 types. Thus, in a derived class destructor, where the base
4574 class constructor was inlined, we could generate bad code for
4575 setting up the vtable pointer.
4577 Therefore, we use one type for all vtable pointers. We still
4578 use a type-correct type; it's just doesn't indicate the array
4579 bounds. That's better than using `void*' or some such; it's
4580 cleaner, and it let's the alias analysis code know that these
4581 stores cannot alias stores to void*! */
4584 field
= build_decl (input_location
,
4585 FIELD_DECL
, get_vfield_name (t
), vtbl_ptr_type_node
);
4586 DECL_VIRTUAL_P (field
) = 1;
4587 DECL_ARTIFICIAL (field
) = 1;
4588 DECL_FIELD_CONTEXT (field
) = t
;
4589 DECL_FCONTEXT (field
) = t
;
4590 if (TYPE_PACKED (t
))
4591 DECL_PACKED (field
) = 1;
4593 TYPE_VFIELD (t
) = field
;
4595 /* This class is non-empty. */
4596 CLASSTYPE_EMPTY_P (t
) = 0;
4604 /* Add OFFSET to all base types of BINFO which is a base in the
4605 hierarchy dominated by T.
4607 OFFSET, which is a type offset, is number of bytes. */
4610 propagate_binfo_offsets (tree binfo
, tree offset
)
4616 /* Update BINFO's offset. */
4617 BINFO_OFFSET (binfo
)
4618 = convert (sizetype
,
4619 size_binop (PLUS_EXPR
,
4620 convert (ssizetype
, BINFO_OFFSET (binfo
)),
4623 /* Find the primary base class. */
4624 primary_binfo
= get_primary_binfo (binfo
);
4626 if (primary_binfo
&& BINFO_INHERITANCE_CHAIN (primary_binfo
) == binfo
)
4627 propagate_binfo_offsets (primary_binfo
, offset
);
4629 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4631 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
4633 /* Don't do the primary base twice. */
4634 if (base_binfo
== primary_binfo
)
4637 if (BINFO_VIRTUAL_P (base_binfo
))
4640 propagate_binfo_offsets (base_binfo
, offset
);
4644 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
4645 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4646 empty subobjects of T. */
4649 layout_virtual_bases (record_layout_info rli
, splay_tree offsets
)
4653 bool first_vbase
= true;
4656 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) == 0)
4659 if (!abi_version_at_least(2))
4661 /* In G++ 3.2, we incorrectly rounded the size before laying out
4662 the virtual bases. */
4663 finish_record_layout (rli
, /*free_p=*/false);
4664 #ifdef STRUCTURE_SIZE_BOUNDARY
4665 /* Packed structures don't need to have minimum size. */
4666 if (! TYPE_PACKED (t
))
4667 TYPE_ALIGN (t
) = MAX (TYPE_ALIGN (t
), (unsigned) STRUCTURE_SIZE_BOUNDARY
);
4669 rli
->offset
= TYPE_SIZE_UNIT (t
);
4670 rli
->bitpos
= bitsize_zero_node
;
4671 rli
->record_align
= TYPE_ALIGN (t
);
4674 /* Find the last field. The artificial fields created for virtual
4675 bases will go after the last extant field to date. */
4676 next_field
= &TYPE_FIELDS (t
);
4678 next_field
= &TREE_CHAIN (*next_field
);
4680 /* Go through the virtual bases, allocating space for each virtual
4681 base that is not already a primary base class. These are
4682 allocated in inheritance graph order. */
4683 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
4685 if (!BINFO_VIRTUAL_P (vbase
))
4688 if (!BINFO_PRIMARY_P (vbase
))
4690 tree basetype
= TREE_TYPE (vbase
);
4692 /* This virtual base is not a primary base of any class in the
4693 hierarchy, so we have to add space for it. */
4694 next_field
= build_base_field (rli
, vbase
,
4695 offsets
, next_field
);
4697 /* If the first virtual base might have been placed at a
4698 lower address, had we started from CLASSTYPE_SIZE, rather
4699 than TYPE_SIZE, issue a warning. There can be both false
4700 positives and false negatives from this warning in rare
4701 cases; to deal with all the possibilities would probably
4702 require performing both layout algorithms and comparing
4703 the results which is not particularly tractable. */
4707 (size_binop (CEIL_DIV_EXPR
,
4708 round_up_loc (input_location
,
4710 CLASSTYPE_ALIGN (basetype
)),
4712 BINFO_OFFSET (vbase
))))
4714 "offset of virtual base %qT is not ABI-compliant and "
4715 "may change in a future version of GCC",
4718 first_vbase
= false;
4723 /* Returns the offset of the byte just past the end of the base class
4727 end_of_base (tree binfo
)
4731 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo
)))
4732 size
= TYPE_SIZE_UNIT (char_type_node
);
4733 else if (is_empty_class (BINFO_TYPE (binfo
)))
4734 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4735 allocate some space for it. It cannot have virtual bases, so
4736 TYPE_SIZE_UNIT is fine. */
4737 size
= TYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
4739 size
= CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
4741 return size_binop (PLUS_EXPR
, BINFO_OFFSET (binfo
), size
);
4744 /* Returns the offset of the byte just past the end of the base class
4745 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4746 only non-virtual bases are included. */
4749 end_of_class (tree t
, int include_virtuals_p
)
4751 tree result
= size_zero_node
;
4752 VEC(tree
,gc
) *vbases
;
4758 for (binfo
= TYPE_BINFO (t
), i
= 0;
4759 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
4761 if (!include_virtuals_p
4762 && BINFO_VIRTUAL_P (base_binfo
)
4763 && (!BINFO_PRIMARY_P (base_binfo
)
4764 || BINFO_INHERITANCE_CHAIN (base_binfo
) != TYPE_BINFO (t
)))
4767 offset
= end_of_base (base_binfo
);
4768 if (INT_CST_LT_UNSIGNED (result
, offset
))
4772 /* G++ 3.2 did not check indirect virtual bases. */
4773 if (abi_version_at_least (2) && include_virtuals_p
)
4774 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
4775 VEC_iterate (tree
, vbases
, i
, base_binfo
); i
++)
4777 offset
= end_of_base (base_binfo
);
4778 if (INT_CST_LT_UNSIGNED (result
, offset
))
4785 /* Warn about bases of T that are inaccessible because they are
4786 ambiguous. For example:
4789 struct T : public S {};
4790 struct U : public S, public T {};
4792 Here, `(S*) new U' is not allowed because there are two `S'
4796 warn_about_ambiguous_bases (tree t
)
4799 VEC(tree
,gc
) *vbases
;
4804 /* If there are no repeated bases, nothing can be ambiguous. */
4805 if (!CLASSTYPE_REPEATED_BASE_P (t
))
4808 /* Check direct bases. */
4809 for (binfo
= TYPE_BINFO (t
), i
= 0;
4810 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
4812 basetype
= BINFO_TYPE (base_binfo
);
4814 if (!lookup_base (t
, basetype
, ba_unique
| ba_quiet
, NULL
))
4815 warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
4819 /* Check for ambiguous virtual bases. */
4821 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
4822 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
4824 basetype
= BINFO_TYPE (binfo
);
4826 if (!lookup_base (t
, basetype
, ba_unique
| ba_quiet
, NULL
))
4827 warning (OPT_Wextra
, "virtual base %qT inaccessible in %qT due to ambiguity",
4832 /* Compare two INTEGER_CSTs K1 and K2. */
4835 splay_tree_compare_integer_csts (splay_tree_key k1
, splay_tree_key k2
)
4837 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4840 /* Increase the size indicated in RLI to account for empty classes
4841 that are "off the end" of the class. */
4844 include_empty_classes (record_layout_info rli
)
4849 /* It might be the case that we grew the class to allocate a
4850 zero-sized base class. That won't be reflected in RLI, yet,
4851 because we are willing to overlay multiple bases at the same
4852 offset. However, now we need to make sure that RLI is big enough
4853 to reflect the entire class. */
4854 eoc
= end_of_class (rli
->t
,
4855 CLASSTYPE_AS_BASE (rli
->t
) != NULL_TREE
);
4856 rli_size
= rli_size_unit_so_far (rli
);
4857 if (TREE_CODE (rli_size
) == INTEGER_CST
4858 && INT_CST_LT_UNSIGNED (rli_size
, eoc
))
4860 if (!abi_version_at_least (2))
4861 /* In version 1 of the ABI, the size of a class that ends with
4862 a bitfield was not rounded up to a whole multiple of a
4863 byte. Because rli_size_unit_so_far returns only the number
4864 of fully allocated bytes, any extra bits were not included
4866 rli
->bitpos
= round_down (rli
->bitpos
, BITS_PER_UNIT
);
4868 /* The size should have been rounded to a whole byte. */
4869 gcc_assert (tree_int_cst_equal
4870 (rli
->bitpos
, round_down (rli
->bitpos
, BITS_PER_UNIT
)));
4872 = size_binop (PLUS_EXPR
,
4874 size_binop (MULT_EXPR
,
4875 convert (bitsizetype
,
4876 size_binop (MINUS_EXPR
,
4878 bitsize_int (BITS_PER_UNIT
)));
4879 normalize_rli (rli
);
4883 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
4884 BINFO_OFFSETs for all of the base-classes. Position the vtable
4885 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
4888 layout_class_type (tree t
, tree
*virtuals_p
)
4890 tree non_static_data_members
;
4893 record_layout_info rli
;
4894 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4895 types that appear at that offset. */
4896 splay_tree empty_base_offsets
;
4897 /* True if the last field layed out was a bit-field. */
4898 bool last_field_was_bitfield
= false;
4899 /* The location at which the next field should be inserted. */
4901 /* T, as a base class. */
4904 /* Keep track of the first non-static data member. */
4905 non_static_data_members
= TYPE_FIELDS (t
);
4907 /* Start laying out the record. */
4908 rli
= start_record_layout (t
);
4910 /* Mark all the primary bases in the hierarchy. */
4911 determine_primary_bases (t
);
4913 /* Create a pointer to our virtual function table. */
4914 vptr
= create_vtable_ptr (t
, virtuals_p
);
4916 /* The vptr is always the first thing in the class. */
4919 TREE_CHAIN (vptr
) = TYPE_FIELDS (t
);
4920 TYPE_FIELDS (t
) = vptr
;
4921 next_field
= &TREE_CHAIN (vptr
);
4922 place_field (rli
, vptr
);
4925 next_field
= &TYPE_FIELDS (t
);
4927 /* Build FIELD_DECLs for all of the non-virtual base-types. */
4928 empty_base_offsets
= splay_tree_new (splay_tree_compare_integer_csts
,
4930 build_base_fields (rli
, empty_base_offsets
, next_field
);
4932 /* Layout the non-static data members. */
4933 for (field
= non_static_data_members
; field
; field
= TREE_CHAIN (field
))
4938 /* We still pass things that aren't non-static data members to
4939 the back end, in case it wants to do something with them. */
4940 if (TREE_CODE (field
) != FIELD_DECL
)
4942 place_field (rli
, field
);
4943 /* If the static data member has incomplete type, keep track
4944 of it so that it can be completed later. (The handling
4945 of pending statics in finish_record_layout is
4946 insufficient; consider:
4949 struct S2 { static S1 s1; };
4951 At this point, finish_record_layout will be called, but
4952 S1 is still incomplete.) */
4953 if (TREE_CODE (field
) == VAR_DECL
)
4955 maybe_register_incomplete_var (field
);
4956 /* The visibility of static data members is determined
4957 at their point of declaration, not their point of
4959 determine_visibility (field
);
4964 type
= TREE_TYPE (field
);
4965 if (type
== error_mark_node
)
4968 padding
= NULL_TREE
;
4970 /* If this field is a bit-field whose width is greater than its
4971 type, then there are some special rules for allocating
4973 if (DECL_C_BIT_FIELD (field
)
4974 && INT_CST_LT (TYPE_SIZE (type
), DECL_SIZE (field
)))
4978 bool was_unnamed_p
= false;
4979 /* We must allocate the bits as if suitably aligned for the
4980 longest integer type that fits in this many bits. type
4981 of the field. Then, we are supposed to use the left over
4982 bits as additional padding. */
4983 for (itk
= itk_char
; itk
!= itk_none
; ++itk
)
4984 if (INT_CST_LT (DECL_SIZE (field
),
4985 TYPE_SIZE (integer_types
[itk
])))
4988 /* ITK now indicates a type that is too large for the
4989 field. We have to back up by one to find the largest
4991 integer_type
= integer_types
[itk
- 1];
4993 /* Figure out how much additional padding is required. GCC
4994 3.2 always created a padding field, even if it had zero
4996 if (!abi_version_at_least (2)
4997 || INT_CST_LT (TYPE_SIZE (integer_type
), DECL_SIZE (field
)))
4999 if (abi_version_at_least (2) && TREE_CODE (t
) == UNION_TYPE
)
5000 /* In a union, the padding field must have the full width
5001 of the bit-field; all fields start at offset zero. */
5002 padding
= DECL_SIZE (field
);
5005 if (TREE_CODE (t
) == UNION_TYPE
)
5006 warning (OPT_Wabi
, "size assigned to %qT may not be "
5007 "ABI-compliant and may change in a future "
5010 padding
= size_binop (MINUS_EXPR
, DECL_SIZE (field
),
5011 TYPE_SIZE (integer_type
));
5014 #ifdef PCC_BITFIELD_TYPE_MATTERS
5015 /* An unnamed bitfield does not normally affect the
5016 alignment of the containing class on a target where
5017 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
5018 make any exceptions for unnamed bitfields when the
5019 bitfields are longer than their types. Therefore, we
5020 temporarily give the field a name. */
5021 if (PCC_BITFIELD_TYPE_MATTERS
&& !DECL_NAME (field
))
5023 was_unnamed_p
= true;
5024 DECL_NAME (field
) = make_anon_name ();
5027 DECL_SIZE (field
) = TYPE_SIZE (integer_type
);
5028 DECL_ALIGN (field
) = TYPE_ALIGN (integer_type
);
5029 DECL_USER_ALIGN (field
) = TYPE_USER_ALIGN (integer_type
);
5030 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
5031 empty_base_offsets
);
5033 DECL_NAME (field
) = NULL_TREE
;
5034 /* Now that layout has been performed, set the size of the
5035 field to the size of its declared type; the rest of the
5036 field is effectively invisible. */
5037 DECL_SIZE (field
) = TYPE_SIZE (type
);
5038 /* We must also reset the DECL_MODE of the field. */
5039 if (abi_version_at_least (2))
5040 DECL_MODE (field
) = TYPE_MODE (type
);
5042 && DECL_MODE (field
) != TYPE_MODE (type
))
5043 /* Versions of G++ before G++ 3.4 did not reset the
5046 "the offset of %qD may not be ABI-compliant and may "
5047 "change in a future version of GCC", field
);
5050 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
5051 empty_base_offsets
);
5053 /* Remember the location of any empty classes in FIELD. */
5054 if (abi_version_at_least (2))
5055 record_subobject_offsets (TREE_TYPE (field
),
5056 byte_position(field
),
5058 /*is_data_member=*/true);
5060 /* If a bit-field does not immediately follow another bit-field,
5061 and yet it starts in the middle of a byte, we have failed to
5062 comply with the ABI. */
5064 && DECL_C_BIT_FIELD (field
)
5065 /* The TREE_NO_WARNING flag gets set by Objective-C when
5066 laying out an Objective-C class. The ObjC ABI differs
5067 from the C++ ABI, and so we do not want a warning
5069 && !TREE_NO_WARNING (field
)
5070 && !last_field_was_bitfield
5071 && !integer_zerop (size_binop (TRUNC_MOD_EXPR
,
5072 DECL_FIELD_BIT_OFFSET (field
),
5073 bitsize_unit_node
)))
5074 warning (OPT_Wabi
, "offset of %q+D is not ABI-compliant and may "
5075 "change in a future version of GCC", field
);
5077 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
5078 offset of the field. */
5080 && !abi_version_at_least (2)
5081 && !tree_int_cst_equal (DECL_FIELD_OFFSET (field
),
5082 byte_position (field
))
5083 && contains_empty_class_p (TREE_TYPE (field
)))
5084 warning (OPT_Wabi
, "%q+D contains empty classes which may cause base "
5085 "classes to be placed at different locations in a "
5086 "future version of GCC", field
);
5088 /* The middle end uses the type of expressions to determine the
5089 possible range of expression values. In order to optimize
5090 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
5091 must be made aware of the width of "i", via its type.
5093 Because C++ does not have integer types of arbitrary width,
5094 we must (for the purposes of the front end) convert from the
5095 type assigned here to the declared type of the bitfield
5096 whenever a bitfield expression is used as an rvalue.
5097 Similarly, when assigning a value to a bitfield, the value
5098 must be converted to the type given the bitfield here. */
5099 if (DECL_C_BIT_FIELD (field
))
5101 unsigned HOST_WIDE_INT width
;
5102 tree ftype
= TREE_TYPE (field
);
5103 width
= tree_low_cst (DECL_SIZE (field
), /*unsignedp=*/1);
5104 if (width
!= TYPE_PRECISION (ftype
))
5107 = c_build_bitfield_integer_type (width
,
5108 TYPE_UNSIGNED (ftype
));
5110 = cp_build_qualified_type (TREE_TYPE (field
),
5111 TYPE_QUALS (ftype
));
5115 /* If we needed additional padding after this field, add it
5121 padding_field
= build_decl (input_location
,
5125 DECL_BIT_FIELD (padding_field
) = 1;
5126 DECL_SIZE (padding_field
) = padding
;
5127 DECL_CONTEXT (padding_field
) = t
;
5128 DECL_ARTIFICIAL (padding_field
) = 1;
5129 DECL_IGNORED_P (padding_field
) = 1;
5130 layout_nonempty_base_or_field (rli
, padding_field
,
5132 empty_base_offsets
);
5135 last_field_was_bitfield
= DECL_C_BIT_FIELD (field
);
5138 if (abi_version_at_least (2) && !integer_zerop (rli
->bitpos
))
5140 /* Make sure that we are on a byte boundary so that the size of
5141 the class without virtual bases will always be a round number
5143 rli
->bitpos
= round_up_loc (input_location
, rli
->bitpos
, BITS_PER_UNIT
);
5144 normalize_rli (rli
);
5147 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5149 if (!abi_version_at_least (2))
5150 include_empty_classes(rli
);
5152 /* Delete all zero-width bit-fields from the list of fields. Now
5153 that the type is laid out they are no longer important. */
5154 remove_zero_width_bit_fields (t
);
5156 /* Create the version of T used for virtual bases. We do not use
5157 make_class_type for this version; this is an artificial type. For
5158 a POD type, we just reuse T. */
5159 if (CLASSTYPE_NON_LAYOUT_POD_P (t
) || CLASSTYPE_EMPTY_P (t
))
5161 base_t
= make_node (TREE_CODE (t
));
5163 /* Set the size and alignment for the new type. In G++ 3.2, all
5164 empty classes were considered to have size zero when used as
5166 if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t
))
5168 TYPE_SIZE (base_t
) = bitsize_zero_node
;
5169 TYPE_SIZE_UNIT (base_t
) = size_zero_node
;
5170 if (warn_abi
&& !integer_zerop (rli_size_unit_so_far (rli
)))
5172 "layout of classes derived from empty class %qT "
5173 "may change in a future version of GCC",
5180 /* If the ABI version is not at least two, and the last
5181 field was a bit-field, RLI may not be on a byte
5182 boundary. In particular, rli_size_unit_so_far might
5183 indicate the last complete byte, while rli_size_so_far
5184 indicates the total number of bits used. Therefore,
5185 rli_size_so_far, rather than rli_size_unit_so_far, is
5186 used to compute TYPE_SIZE_UNIT. */
5187 eoc
= end_of_class (t
, /*include_virtuals_p=*/0);
5188 TYPE_SIZE_UNIT (base_t
)
5189 = size_binop (MAX_EXPR
,
5191 size_binop (CEIL_DIV_EXPR
,
5192 rli_size_so_far (rli
),
5193 bitsize_int (BITS_PER_UNIT
))),
5196 = size_binop (MAX_EXPR
,
5197 rli_size_so_far (rli
),
5198 size_binop (MULT_EXPR
,
5199 convert (bitsizetype
, eoc
),
5200 bitsize_int (BITS_PER_UNIT
)));
5202 TYPE_ALIGN (base_t
) = rli
->record_align
;
5203 TYPE_USER_ALIGN (base_t
) = TYPE_USER_ALIGN (t
);
5205 /* Copy the fields from T. */
5206 next_field
= &TYPE_FIELDS (base_t
);
5207 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
5208 if (TREE_CODE (field
) == FIELD_DECL
)
5210 *next_field
= build_decl (input_location
,
5214 DECL_CONTEXT (*next_field
) = base_t
;
5215 DECL_FIELD_OFFSET (*next_field
) = DECL_FIELD_OFFSET (field
);
5216 DECL_FIELD_BIT_OFFSET (*next_field
)
5217 = DECL_FIELD_BIT_OFFSET (field
);
5218 DECL_SIZE (*next_field
) = DECL_SIZE (field
);
5219 DECL_MODE (*next_field
) = DECL_MODE (field
);
5220 next_field
= &TREE_CHAIN (*next_field
);
5223 /* Record the base version of the type. */
5224 CLASSTYPE_AS_BASE (t
) = base_t
;
5225 TYPE_CONTEXT (base_t
) = t
;
5228 CLASSTYPE_AS_BASE (t
) = t
;
5230 /* Every empty class contains an empty class. */
5231 if (CLASSTYPE_EMPTY_P (t
))
5232 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
5234 /* Set the TYPE_DECL for this type to contain the right
5235 value for DECL_OFFSET, so that we can use it as part
5236 of a COMPONENT_REF for multiple inheritance. */
5237 layout_decl (TYPE_MAIN_DECL (t
), 0);
5239 /* Now fix up any virtual base class types that we left lying
5240 around. We must get these done before we try to lay out the
5241 virtual function table. As a side-effect, this will remove the
5242 base subobject fields. */
5243 layout_virtual_bases (rli
, empty_base_offsets
);
5245 /* Make sure that empty classes are reflected in RLI at this
5247 include_empty_classes(rli
);
5249 /* Make sure not to create any structures with zero size. */
5250 if (integer_zerop (rli_size_unit_so_far (rli
)) && CLASSTYPE_EMPTY_P (t
))
5252 build_decl (input_location
,
5253 FIELD_DECL
, NULL_TREE
, char_type_node
));
5255 /* If this is a non-POD, declaring it packed makes a difference to how it
5256 can be used as a field; don't let finalize_record_size undo it. */
5257 if (TYPE_PACKED (t
) && !layout_pod_type_p (t
))
5258 rli
->packed_maybe_necessary
= true;
5260 /* Let the back end lay out the type. */
5261 finish_record_layout (rli
, /*free_p=*/true);
5263 /* Warn about bases that can't be talked about due to ambiguity. */
5264 warn_about_ambiguous_bases (t
);
5266 /* Now that we're done with layout, give the base fields the real types. */
5267 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
5268 if (DECL_ARTIFICIAL (field
) && IS_FAKE_BASE_TYPE (TREE_TYPE (field
)))
5269 TREE_TYPE (field
) = TYPE_CONTEXT (TREE_TYPE (field
));
5272 splay_tree_delete (empty_base_offsets
);
5274 if (CLASSTYPE_EMPTY_P (t
)
5275 && tree_int_cst_lt (sizeof_biggest_empty_class
,
5276 TYPE_SIZE_UNIT (t
)))
5277 sizeof_biggest_empty_class
= TYPE_SIZE_UNIT (t
);
5280 /* Determine the "key method" for the class type indicated by TYPE,
5281 and set CLASSTYPE_KEY_METHOD accordingly. */
5284 determine_key_method (tree type
)
5288 if (TYPE_FOR_JAVA (type
)
5289 || processing_template_decl
5290 || CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
5291 || CLASSTYPE_INTERFACE_KNOWN (type
))
5294 /* The key method is the first non-pure virtual function that is not
5295 inline at the point of class definition. On some targets the
5296 key function may not be inline; those targets should not call
5297 this function until the end of the translation unit. */
5298 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
5299 method
= TREE_CHAIN (method
))
5300 if (DECL_VINDEX (method
) != NULL_TREE
5301 && ! DECL_DECLARED_INLINE_P (method
)
5302 && ! DECL_PURE_VIRTUAL_P (method
))
5304 CLASSTYPE_KEY_METHOD (type
) = method
;
5311 /* Perform processing required when the definition of T (a class type)
5315 finish_struct_1 (tree t
)
5318 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
5319 tree virtuals
= NULL_TREE
;
5322 if (COMPLETE_TYPE_P (t
))
5324 gcc_assert (MAYBE_CLASS_TYPE_P (t
));
5325 error ("redefinition of %q#T", t
);
5330 /* If this type was previously laid out as a forward reference,
5331 make sure we lay it out again. */
5332 TYPE_SIZE (t
) = NULL_TREE
;
5333 CLASSTYPE_PRIMARY_BINFO (t
) = NULL_TREE
;
5335 /* Make assumptions about the class; we'll reset the flags if
5337 CLASSTYPE_EMPTY_P (t
) = 1;
5338 CLASSTYPE_NEARLY_EMPTY_P (t
) = 1;
5339 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 0;
5341 /* Do end-of-class semantic processing: checking the validity of the
5342 bases and members and add implicitly generated methods. */
5343 check_bases_and_members (t
);
5345 /* Find the key method. */
5346 if (TYPE_CONTAINS_VPTR_P (t
))
5348 /* The Itanium C++ ABI permits the key method to be chosen when
5349 the class is defined -- even though the key method so
5350 selected may later turn out to be an inline function. On
5351 some systems (such as ARM Symbian OS) the key method cannot
5352 be determined until the end of the translation unit. On such
5353 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5354 will cause the class to be added to KEYED_CLASSES. Then, in
5355 finish_file we will determine the key method. */
5356 if (targetm
.cxx
.key_method_may_be_inline ())
5357 determine_key_method (t
);
5359 /* If a polymorphic class has no key method, we may emit the vtable
5360 in every translation unit where the class definition appears. */
5361 if (CLASSTYPE_KEY_METHOD (t
) == NULL_TREE
)
5362 keyed_classes
= tree_cons (NULL_TREE
, t
, keyed_classes
);
5365 /* Layout the class itself. */
5366 layout_class_type (t
, &virtuals
);
5367 if (CLASSTYPE_AS_BASE (t
) != t
)
5368 /* We use the base type for trivial assignments, and hence it
5370 compute_record_mode (CLASSTYPE_AS_BASE (t
));
5372 virtuals
= modify_all_vtables (t
, nreverse (virtuals
));
5374 /* If necessary, create the primary vtable for this class. */
5375 if (virtuals
|| TYPE_CONTAINS_VPTR_P (t
))
5377 /* We must enter these virtuals into the table. */
5378 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
5379 build_primary_vtable (NULL_TREE
, t
);
5380 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t
)))
5381 /* Here we know enough to change the type of our virtual
5382 function table, but we will wait until later this function. */
5383 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t
), t
);
5386 if (TYPE_CONTAINS_VPTR_P (t
))
5391 if (BINFO_VTABLE (TYPE_BINFO (t
)))
5392 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t
))));
5393 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
5394 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t
)) == NULL_TREE
);
5396 /* Add entries for virtual functions introduced by this class. */
5397 BINFO_VIRTUALS (TYPE_BINFO (t
))
5398 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t
)), virtuals
);
5400 /* Set DECL_VINDEX for all functions declared in this class. */
5401 for (vindex
= 0, fn
= BINFO_VIRTUALS (TYPE_BINFO (t
));
5403 fn
= TREE_CHAIN (fn
),
5404 vindex
+= (TARGET_VTABLE_USES_DESCRIPTORS
5405 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1))
5407 tree fndecl
= BV_FN (fn
);
5409 if (DECL_THUNK_P (fndecl
))
5410 /* A thunk. We should never be calling this entry directly
5411 from this vtable -- we'd use the entry for the non
5412 thunk base function. */
5413 DECL_VINDEX (fndecl
) = NULL_TREE
;
5414 else if (TREE_CODE (DECL_VINDEX (fndecl
)) != INTEGER_CST
)
5415 DECL_VINDEX (fndecl
) = build_int_cst (NULL_TREE
, vindex
);
5419 finish_struct_bits (t
);
5421 /* Complete the rtl for any static member objects of the type we're
5423 for (x
= TYPE_FIELDS (t
); x
; x
= TREE_CHAIN (x
))
5424 if (TREE_CODE (x
) == VAR_DECL
&& TREE_STATIC (x
)
5425 && TREE_TYPE (x
) != error_mark_node
5426 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x
)), t
))
5427 DECL_MODE (x
) = TYPE_MODE (t
);
5429 /* Done with FIELDS...now decide whether to sort these for
5430 faster lookups later.
5432 We use a small number because most searches fail (succeeding
5433 ultimately as the search bores through the inheritance
5434 hierarchy), and we want this failure to occur quickly. */
5436 n_fields
= count_fields (TYPE_FIELDS (t
));
5439 struct sorted_fields_type
*field_vec
= GGC_NEWVAR
5440 (struct sorted_fields_type
,
5441 sizeof (struct sorted_fields_type
) + n_fields
* sizeof (tree
));
5442 field_vec
->len
= n_fields
;
5443 add_fields_to_record_type (TYPE_FIELDS (t
), field_vec
, 0);
5444 qsort (field_vec
->elts
, n_fields
, sizeof (tree
),
5446 CLASSTYPE_SORTED_FIELDS (t
) = field_vec
;
5449 /* Complain if one of the field types requires lower visibility. */
5450 constrain_class_visibility (t
);
5452 /* Make the rtl for any new vtables we have created, and unmark
5453 the base types we marked. */
5456 /* Build the VTT for T. */
5459 /* This warning does not make sense for Java classes, since they
5460 cannot have destructors. */
5461 if (!TYPE_FOR_JAVA (t
) && warn_nonvdtor
&& TYPE_POLYMORPHIC_P (t
))
5465 dtor
= CLASSTYPE_DESTRUCTORS (t
);
5466 if (/* An implicitly declared destructor is always public. And,
5467 if it were virtual, we would have created it by now. */
5469 || (!DECL_VINDEX (dtor
)
5470 && (/* public non-virtual */
5471 (!TREE_PRIVATE (dtor
) && !TREE_PROTECTED (dtor
))
5472 || (/* non-public non-virtual with friends */
5473 (TREE_PRIVATE (dtor
) || TREE_PROTECTED (dtor
))
5474 && (CLASSTYPE_FRIEND_CLASSES (t
)
5475 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))))))
5476 warning (OPT_Wnon_virtual_dtor
,
5477 "%q#T has virtual functions and accessible"
5478 " non-virtual destructor", t
);
5483 if (warn_overloaded_virtual
)
5486 /* Class layout, assignment of virtual table slots, etc., is now
5487 complete. Give the back end a chance to tweak the visibility of
5488 the class or perform any other required target modifications. */
5489 targetm
.cxx
.adjust_class_at_definition (t
);
5491 maybe_suppress_debug_info (t
);
5493 dump_class_hierarchy (t
);
5495 /* Finish debugging output for this type. */
5496 rest_of_type_compilation (t
, ! LOCAL_CLASS_P (t
));
5499 /* When T was built up, the member declarations were added in reverse
5500 order. Rearrange them to declaration order. */
5503 unreverse_member_declarations (tree t
)
5509 /* The following lists are all in reverse order. Put them in
5510 declaration order now. */
5511 TYPE_METHODS (t
) = nreverse (TYPE_METHODS (t
));
5512 CLASSTYPE_DECL_LIST (t
) = nreverse (CLASSTYPE_DECL_LIST (t
));
5514 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5515 reverse order, so we can't just use nreverse. */
5517 for (x
= TYPE_FIELDS (t
);
5518 x
&& TREE_CODE (x
) != TYPE_DECL
;
5521 next
= TREE_CHAIN (x
);
5522 TREE_CHAIN (x
) = prev
;
5527 TREE_CHAIN (TYPE_FIELDS (t
)) = x
;
5529 TYPE_FIELDS (t
) = prev
;
5534 finish_struct (tree t
, tree attributes
)
5536 location_t saved_loc
= input_location
;
5538 /* Now that we've got all the field declarations, reverse everything
5540 unreverse_member_declarations (t
);
5542 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
5544 /* Nadger the current location so that diagnostics point to the start of
5545 the struct, not the end. */
5546 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (t
));
5548 if (processing_template_decl
)
5552 finish_struct_methods (t
);
5553 TYPE_SIZE (t
) = bitsize_zero_node
;
5554 TYPE_SIZE_UNIT (t
) = size_zero_node
;
5556 /* We need to emit an error message if this type was used as a parameter
5557 and it is an abstract type, even if it is a template. We construct
5558 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5559 account and we call complete_vars with this type, which will check
5560 the PARM_DECLS. Note that while the type is being defined,
5561 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5562 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
5563 CLASSTYPE_PURE_VIRTUALS (t
) = NULL
;
5564 for (x
= TYPE_METHODS (t
); x
; x
= TREE_CHAIN (x
))
5565 if (DECL_PURE_VIRTUAL_P (x
))
5566 VEC_safe_push (tree
, gc
, CLASSTYPE_PURE_VIRTUALS (t
), x
);
5569 /* Remember current #pragma pack value. */
5570 TYPE_PRECISION (t
) = maximum_field_alignment
;
5573 finish_struct_1 (t
);
5575 input_location
= saved_loc
;
5577 TYPE_BEING_DEFINED (t
) = 0;
5579 if (current_class_type
)
5582 error ("trying to finish struct, but kicked out due to previous parse errors");
5584 if (processing_template_decl
&& at_function_scope_p ())
5585 add_stmt (build_min (TAG_DEFN
, t
));
5590 /* Return the dynamic type of INSTANCE, if known.
5591 Used to determine whether the virtual function table is needed
5594 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5595 of our knowledge of its type. *NONNULL should be initialized
5596 before this function is called. */
5599 fixed_type_or_null (tree instance
, int *nonnull
, int *cdtorp
)
5601 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5603 switch (TREE_CODE (instance
))
5606 if (POINTER_TYPE_P (TREE_TYPE (instance
)))
5609 return RECUR (TREE_OPERAND (instance
, 0));
5612 /* This is a call to a constructor, hence it's never zero. */
5613 if (TREE_HAS_CONSTRUCTOR (instance
))
5617 return TREE_TYPE (instance
);
5622 /* This is a call to a constructor, hence it's never zero. */
5623 if (TREE_HAS_CONSTRUCTOR (instance
))
5627 return TREE_TYPE (instance
);
5629 return RECUR (TREE_OPERAND (instance
, 0));
5631 case POINTER_PLUS_EXPR
:
5634 if (TREE_CODE (TREE_OPERAND (instance
, 0)) == ADDR_EXPR
)
5635 return RECUR (TREE_OPERAND (instance
, 0));
5636 if (TREE_CODE (TREE_OPERAND (instance
, 1)) == INTEGER_CST
)
5637 /* Propagate nonnull. */
5638 return RECUR (TREE_OPERAND (instance
, 0));
5643 return RECUR (TREE_OPERAND (instance
, 0));
5646 instance
= TREE_OPERAND (instance
, 0);
5649 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5650 with a real object -- given &p->f, p can still be null. */
5651 tree t
= get_base_address (instance
);
5652 /* ??? Probably should check DECL_WEAK here. */
5653 if (t
&& DECL_P (t
))
5656 return RECUR (instance
);
5659 /* If this component is really a base class reference, then the field
5660 itself isn't definitive. */
5661 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance
, 1)))
5662 return RECUR (TREE_OPERAND (instance
, 0));
5663 return RECUR (TREE_OPERAND (instance
, 1));
5667 if (TREE_CODE (TREE_TYPE (instance
)) == ARRAY_TYPE
5668 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance
))))
5672 return TREE_TYPE (TREE_TYPE (instance
));
5674 /* fall through... */
5678 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance
)))
5682 return TREE_TYPE (instance
);
5684 else if (instance
== current_class_ptr
)
5689 /* if we're in a ctor or dtor, we know our type. */
5690 if (DECL_LANG_SPECIFIC (current_function_decl
)
5691 && (DECL_CONSTRUCTOR_P (current_function_decl
)
5692 || DECL_DESTRUCTOR_P (current_function_decl
)))
5696 return TREE_TYPE (TREE_TYPE (instance
));
5699 else if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
5701 /* We only need one hash table because it is always left empty. */
5704 ht
= htab_create (37,
5709 /* Reference variables should be references to objects. */
5713 /* Enter the INSTANCE in a table to prevent recursion; a
5714 variable's initializer may refer to the variable
5716 if (TREE_CODE (instance
) == VAR_DECL
5717 && DECL_INITIAL (instance
)
5718 && !htab_find (ht
, instance
))
5723 slot
= htab_find_slot (ht
, instance
, INSERT
);
5725 type
= RECUR (DECL_INITIAL (instance
));
5726 htab_remove_elt (ht
, instance
);
5739 /* Return nonzero if the dynamic type of INSTANCE is known, and
5740 equivalent to the static type. We also handle the case where
5741 INSTANCE is really a pointer. Return negative if this is a
5742 ctor/dtor. There the dynamic type is known, but this might not be
5743 the most derived base of the original object, and hence virtual
5744 bases may not be layed out according to this type.
5746 Used to determine whether the virtual function table is needed
5749 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5750 of our knowledge of its type. *NONNULL should be initialized
5751 before this function is called. */
5754 resolves_to_fixed_type_p (tree instance
, int* nonnull
)
5756 tree t
= TREE_TYPE (instance
);
5758 tree fixed
= fixed_type_or_null (instance
, nonnull
, &cdtorp
);
5759 if (fixed
== NULL_TREE
)
5761 if (POINTER_TYPE_P (t
))
5763 if (!same_type_ignoring_top_level_qualifiers_p (t
, fixed
))
5765 return cdtorp
? -1 : 1;
5770 init_class_processing (void)
5772 current_class_depth
= 0;
5773 current_class_stack_size
= 10;
5775 = XNEWVEC (struct class_stack_node
, current_class_stack_size
);
5776 local_classes
= VEC_alloc (tree
, gc
, 8);
5777 sizeof_biggest_empty_class
= size_zero_node
;
5779 ridpointers
[(int) RID_PUBLIC
] = access_public_node
;
5780 ridpointers
[(int) RID_PRIVATE
] = access_private_node
;
5781 ridpointers
[(int) RID_PROTECTED
] = access_protected_node
;
5784 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
5787 restore_class_cache (void)
5791 /* We are re-entering the same class we just left, so we don't
5792 have to search the whole inheritance matrix to find all the
5793 decls to bind again. Instead, we install the cached
5794 class_shadowed list and walk through it binding names. */
5795 push_binding_level (previous_class_level
);
5796 class_binding_level
= previous_class_level
;
5797 /* Restore IDENTIFIER_TYPE_VALUE. */
5798 for (type
= class_binding_level
->type_shadowed
;
5800 type
= TREE_CHAIN (type
))
5801 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type
), TREE_TYPE (type
));
5804 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5805 appropriate for TYPE.
5807 So that we may avoid calls to lookup_name, we cache the _TYPE
5808 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5810 For multiple inheritance, we perform a two-pass depth-first search
5811 of the type lattice. */
5814 pushclass (tree type
)
5816 class_stack_node_t csn
;
5818 type
= TYPE_MAIN_VARIANT (type
);
5820 /* Make sure there is enough room for the new entry on the stack. */
5821 if (current_class_depth
+ 1 >= current_class_stack_size
)
5823 current_class_stack_size
*= 2;
5825 = XRESIZEVEC (struct class_stack_node
, current_class_stack
,
5826 current_class_stack_size
);
5829 /* Insert a new entry on the class stack. */
5830 csn
= current_class_stack
+ current_class_depth
;
5831 csn
->name
= current_class_name
;
5832 csn
->type
= current_class_type
;
5833 csn
->access
= current_access_specifier
;
5834 csn
->names_used
= 0;
5836 current_class_depth
++;
5838 /* Now set up the new type. */
5839 current_class_name
= TYPE_NAME (type
);
5840 if (TREE_CODE (current_class_name
) == TYPE_DECL
)
5841 current_class_name
= DECL_NAME (current_class_name
);
5842 current_class_type
= type
;
5844 /* By default, things in classes are private, while things in
5845 structures or unions are public. */
5846 current_access_specifier
= (CLASSTYPE_DECLARED_CLASS (type
)
5847 ? access_private_node
5848 : access_public_node
);
5850 if (previous_class_level
5851 && type
!= previous_class_level
->this_entity
5852 && current_class_depth
== 1)
5854 /* Forcibly remove any old class remnants. */
5855 invalidate_class_lookup_cache ();
5858 if (!previous_class_level
5859 || type
!= previous_class_level
->this_entity
5860 || current_class_depth
> 1)
5863 restore_class_cache ();
5866 /* When we exit a toplevel class scope, we save its binding level so
5867 that we can restore it quickly. Here, we've entered some other
5868 class, so we must invalidate our cache. */
5871 invalidate_class_lookup_cache (void)
5873 previous_class_level
= NULL
;
5876 /* Get out of the current class scope. If we were in a class scope
5877 previously, that is the one popped to. */
5884 current_class_depth
--;
5885 current_class_name
= current_class_stack
[current_class_depth
].name
;
5886 current_class_type
= current_class_stack
[current_class_depth
].type
;
5887 current_access_specifier
= current_class_stack
[current_class_depth
].access
;
5888 if (current_class_stack
[current_class_depth
].names_used
)
5889 splay_tree_delete (current_class_stack
[current_class_depth
].names_used
);
5892 /* Mark the top of the class stack as hidden. */
5895 push_class_stack (void)
5897 if (current_class_depth
)
5898 ++current_class_stack
[current_class_depth
- 1].hidden
;
5901 /* Mark the top of the class stack as un-hidden. */
5904 pop_class_stack (void)
5906 if (current_class_depth
)
5907 --current_class_stack
[current_class_depth
- 1].hidden
;
5910 /* Returns 1 if the class type currently being defined is either T or
5911 a nested type of T. */
5914 currently_open_class (tree t
)
5918 if (!CLASS_TYPE_P (t
))
5921 t
= TYPE_MAIN_VARIANT (t
);
5923 /* We start looking from 1 because entry 0 is from global scope,
5925 for (i
= current_class_depth
; i
> 0; --i
)
5928 if (i
== current_class_depth
)
5929 c
= current_class_type
;
5932 if (current_class_stack
[i
].hidden
)
5934 c
= current_class_stack
[i
].type
;
5938 if (same_type_p (c
, t
))
5944 /* If either current_class_type or one of its enclosing classes are derived
5945 from T, return the appropriate type. Used to determine how we found
5946 something via unqualified lookup. */
5949 currently_open_derived_class (tree t
)
5953 /* The bases of a dependent type are unknown. */
5954 if (dependent_type_p (t
))
5957 if (!current_class_type
)
5960 if (DERIVED_FROM_P (t
, current_class_type
))
5961 return current_class_type
;
5963 for (i
= current_class_depth
- 1; i
> 0; --i
)
5965 if (current_class_stack
[i
].hidden
)
5967 if (DERIVED_FROM_P (t
, current_class_stack
[i
].type
))
5968 return current_class_stack
[i
].type
;
5974 /* When entering a class scope, all enclosing class scopes' names with
5975 static meaning (static variables, static functions, types and
5976 enumerators) have to be visible. This recursive function calls
5977 pushclass for all enclosing class contexts until global or a local
5978 scope is reached. TYPE is the enclosed class. */
5981 push_nested_class (tree type
)
5983 /* A namespace might be passed in error cases, like A::B:C. */
5984 if (type
== NULL_TREE
5985 || !CLASS_TYPE_P (type
))
5988 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type
)));
5993 /* Undoes a push_nested_class call. */
5996 pop_nested_class (void)
5998 tree context
= DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type
));
6001 if (context
&& CLASS_TYPE_P (context
))
6002 pop_nested_class ();
6005 /* Returns the number of extern "LANG" blocks we are nested within. */
6008 current_lang_depth (void)
6010 return VEC_length (tree
, current_lang_base
);
6013 /* Set global variables CURRENT_LANG_NAME to appropriate value
6014 so that behavior of name-mangling machinery is correct. */
6017 push_lang_context (tree name
)
6019 VEC_safe_push (tree
, gc
, current_lang_base
, current_lang_name
);
6021 if (name
== lang_name_cplusplus
)
6023 current_lang_name
= name
;
6025 else if (name
== lang_name_java
)
6027 current_lang_name
= name
;
6028 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6029 (See record_builtin_java_type in decl.c.) However, that causes
6030 incorrect debug entries if these types are actually used.
6031 So we re-enable debug output after extern "Java". */
6032 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node
)) = 0;
6033 DECL_IGNORED_P (TYPE_NAME (java_short_type_node
)) = 0;
6034 DECL_IGNORED_P (TYPE_NAME (java_int_type_node
)) = 0;
6035 DECL_IGNORED_P (TYPE_NAME (java_long_type_node
)) = 0;
6036 DECL_IGNORED_P (TYPE_NAME (java_float_type_node
)) = 0;
6037 DECL_IGNORED_P (TYPE_NAME (java_double_type_node
)) = 0;
6038 DECL_IGNORED_P (TYPE_NAME (java_char_type_node
)) = 0;
6039 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node
)) = 0;
6041 else if (name
== lang_name_c
)
6043 current_lang_name
= name
;
6046 error ("language string %<\"%E\"%> not recognized", name
);
6049 /* Get out of the current language scope. */
6052 pop_lang_context (void)
6054 current_lang_name
= VEC_pop (tree
, current_lang_base
);
6057 /* Type instantiation routines. */
6059 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6060 matches the TARGET_TYPE. If there is no satisfactory match, return
6061 error_mark_node, and issue an error & warning messages under
6062 control of FLAGS. Permit pointers to member function if FLAGS
6063 permits. If TEMPLATE_ONLY, the name of the overloaded function was
6064 a template-id, and EXPLICIT_TARGS are the explicitly provided
6067 If OVERLOAD is for one or more member functions, then ACCESS_PATH
6068 is the base path used to reference those member functions. If
6069 TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
6070 resolved to a member function, access checks will be performed and
6071 errors issued if appropriate. */
6074 resolve_address_of_overloaded_function (tree target_type
,
6076 tsubst_flags_t flags
,
6078 tree explicit_targs
,
6081 /* Here's what the standard says:
6085 If the name is a function template, template argument deduction
6086 is done, and if the argument deduction succeeds, the deduced
6087 arguments are used to generate a single template function, which
6088 is added to the set of overloaded functions considered.
6090 Non-member functions and static member functions match targets of
6091 type "pointer-to-function" or "reference-to-function." Nonstatic
6092 member functions match targets of type "pointer-to-member
6093 function;" the function type of the pointer to member is used to
6094 select the member function from the set of overloaded member
6095 functions. If a nonstatic member function is selected, the
6096 reference to the overloaded function name is required to have the
6097 form of a pointer to member as described in 5.3.1.
6099 If more than one function is selected, any template functions in
6100 the set are eliminated if the set also contains a non-template
6101 function, and any given template function is eliminated if the
6102 set contains a second template function that is more specialized
6103 than the first according to the partial ordering rules 14.5.5.2.
6104 After such eliminations, if any, there shall remain exactly one
6105 selected function. */
6108 /* We store the matches in a TREE_LIST rooted here. The functions
6109 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6110 interoperability with most_specialized_instantiation. */
6111 tree matches
= NULL_TREE
;
6113 tree target_fn_type
;
6115 /* By the time we get here, we should be seeing only real
6116 pointer-to-member types, not the internal POINTER_TYPE to
6117 METHOD_TYPE representation. */
6118 gcc_assert (TREE_CODE (target_type
) != POINTER_TYPE
6119 || TREE_CODE (TREE_TYPE (target_type
)) != METHOD_TYPE
);
6121 gcc_assert (is_overloaded_fn (overload
));
6123 /* Check that the TARGET_TYPE is reasonable. */
6124 if (TYPE_PTRFN_P (target_type
))
6126 else if (TYPE_PTRMEMFUNC_P (target_type
))
6127 /* This is OK, too. */
6129 else if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
6130 /* This is OK, too. This comes from a conversion to reference
6132 target_type
= build_reference_type (target_type
);
6135 if (flags
& tf_error
)
6136 error ("cannot resolve overloaded function %qD based on"
6137 " conversion to type %qT",
6138 DECL_NAME (OVL_FUNCTION (overload
)), target_type
);
6139 return error_mark_node
;
6142 /* Non-member functions and static member functions match targets of type
6143 "pointer-to-function" or "reference-to-function." Nonstatic member
6144 functions match targets of type "pointer-to-member-function;" the
6145 function type of the pointer to member is used to select the member
6146 function from the set of overloaded member functions.
6148 So figure out the FUNCTION_TYPE that we want to match against. */
6149 target_fn_type
= static_fn_type (target_type
);
6151 /* If we can find a non-template function that matches, we can just
6152 use it. There's no point in generating template instantiations
6153 if we're just going to throw them out anyhow. But, of course, we
6154 can only do this when we don't *need* a template function. */
6159 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
6161 tree fn
= OVL_CURRENT (fns
);
6163 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
6164 /* We're not looking for templates just yet. */
6167 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
6169 /* We're looking for a non-static member, and this isn't
6170 one, or vice versa. */
6173 /* Ignore functions which haven't been explicitly
6175 if (DECL_ANTICIPATED (fn
))
6178 /* See if there's a match. */
6179 if (same_type_p (target_fn_type
, static_fn_type (fn
)))
6180 matches
= tree_cons (fn
, NULL_TREE
, matches
);
6184 /* Now, if we've already got a match (or matches), there's no need
6185 to proceed to the template functions. But, if we don't have a
6186 match we need to look at them, too. */
6189 tree target_arg_types
;
6190 tree target_ret_type
;
6193 unsigned int nargs
, ia
;
6196 target_arg_types
= TYPE_ARG_TYPES (target_fn_type
);
6197 target_ret_type
= TREE_TYPE (target_fn_type
);
6199 nargs
= list_length (target_arg_types
);
6200 args
= XALLOCAVEC (tree
, nargs
);
6201 for (arg
= target_arg_types
, ia
= 0;
6202 arg
!= NULL_TREE
&& arg
!= void_list_node
;
6203 arg
= TREE_CHAIN (arg
), ++ia
)
6204 args
[ia
] = TREE_VALUE (arg
);
6207 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
6209 tree fn
= OVL_CURRENT (fns
);
6213 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
6214 /* We're only looking for templates. */
6217 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
6219 /* We're not looking for a non-static member, and this is
6220 one, or vice versa. */
6223 /* Try to do argument deduction. */
6224 targs
= make_tree_vec (DECL_NTPARMS (fn
));
6225 if (fn_type_unification (fn
, explicit_targs
, targs
, args
, nargs
,
6226 target_ret_type
, DEDUCE_EXACT
,
6228 /* Argument deduction failed. */
6231 /* Instantiate the template. */
6232 instantiation
= instantiate_template (fn
, targs
, flags
);
6233 if (instantiation
== error_mark_node
)
6234 /* Instantiation failed. */
6237 /* See if there's a match. */
6238 if (same_type_p (target_fn_type
, static_fn_type (instantiation
)))
6239 matches
= tree_cons (instantiation
, fn
, matches
);
6242 /* Now, remove all but the most specialized of the matches. */
6245 tree match
= most_specialized_instantiation (matches
);
6247 if (match
!= error_mark_node
)
6248 matches
= tree_cons (TREE_PURPOSE (match
),
6254 /* Now we should have exactly one function in MATCHES. */
6255 if (matches
== NULL_TREE
)
6257 /* There were *no* matches. */
6258 if (flags
& tf_error
)
6260 error ("no matches converting function %qD to type %q#T",
6261 DECL_NAME (OVL_CURRENT (overload
)),
6264 /* print_candidates expects a chain with the functions in
6265 TREE_VALUE slots, so we cons one up here (we're losing anyway,
6266 so why be clever?). */
6267 for (; overload
; overload
= OVL_NEXT (overload
))
6268 matches
= tree_cons (NULL_TREE
, OVL_CURRENT (overload
),
6271 print_candidates (matches
);
6273 return error_mark_node
;
6275 else if (TREE_CHAIN (matches
))
6277 /* There were too many matches. First check if they're all
6278 the same function. */
6281 fn
= TREE_PURPOSE (matches
);
6282 for (match
= TREE_CHAIN (matches
); match
; match
= TREE_CHAIN (match
))
6283 if (!decls_match (fn
, TREE_PURPOSE (match
)))
6288 if (flags
& tf_error
)
6290 error ("converting overloaded function %qD to type %q#T is ambiguous",
6291 DECL_NAME (OVL_FUNCTION (overload
)),
6294 /* Since print_candidates expects the functions in the
6295 TREE_VALUE slot, we flip them here. */
6296 for (match
= matches
; match
; match
= TREE_CHAIN (match
))
6297 TREE_VALUE (match
) = TREE_PURPOSE (match
);
6299 print_candidates (matches
);
6302 return error_mark_node
;
6306 /* Good, exactly one match. Now, convert it to the correct type. */
6307 fn
= TREE_PURPOSE (matches
);
6309 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
6310 && !(flags
& tf_ptrmem_ok
) && !flag_ms_extensions
)
6312 static int explained
;
6314 if (!(flags
& tf_error
))
6315 return error_mark_node
;
6317 permerror (input_location
, "assuming pointer to member %qD", fn
);
6320 inform (input_location
, "(a pointer to member can only be formed with %<&%E%>)", fn
);
6325 /* If we're doing overload resolution purely for the purpose of
6326 determining conversion sequences, we should not consider the
6327 function used. If this conversion sequence is selected, the
6328 function will be marked as used at this point. */
6329 if (!(flags
& tf_conv
))
6331 /* Make =delete work with SFINAE. */
6332 if (DECL_DELETED_FN (fn
) && !(flags
& tf_error
))
6333 return error_mark_node
;
6338 /* We could not check access to member functions when this
6339 expression was originally created since we did not know at that
6340 time to which function the expression referred. */
6341 if (!(flags
& tf_no_access_control
)
6342 && DECL_FUNCTION_MEMBER_P (fn
))
6344 gcc_assert (access_path
);
6345 perform_or_defer_access_check (access_path
, fn
, fn
);
6348 if (TYPE_PTRFN_P (target_type
) || TYPE_PTRMEMFUNC_P (target_type
))
6349 return cp_build_unary_op (ADDR_EXPR
, fn
, 0, flags
);
6352 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
6353 will mark the function as addressed, but here we must do it
6355 cxx_mark_addressable (fn
);
6361 /* This function will instantiate the type of the expression given in
6362 RHS to match the type of LHSTYPE. If errors exist, then return
6363 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
6364 we complain on errors. If we are not complaining, never modify rhs,
6365 as overload resolution wants to try many possible instantiations, in
6366 the hope that at least one will work.
6368 For non-recursive calls, LHSTYPE should be a function, pointer to
6369 function, or a pointer to member function. */
6372 instantiate_type (tree lhstype
, tree rhs
, tsubst_flags_t flags
)
6374 tsubst_flags_t flags_in
= flags
;
6375 tree access_path
= NULL_TREE
;
6377 flags
&= ~tf_ptrmem_ok
;
6379 if (TREE_CODE (lhstype
) == UNKNOWN_TYPE
)
6381 if (flags
& tf_error
)
6382 error ("not enough type information");
6383 return error_mark_node
;
6386 if (TREE_TYPE (rhs
) != NULL_TREE
&& ! (type_unknown_p (rhs
)))
6388 if (same_type_p (lhstype
, TREE_TYPE (rhs
)))
6390 if (flag_ms_extensions
6391 && TYPE_PTRMEMFUNC_P (lhstype
)
6392 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
6393 /* Microsoft allows `A::f' to be resolved to a
6394 pointer-to-member. */
6398 if (flags
& tf_error
)
6399 error ("argument of type %qT does not match %qT",
6400 TREE_TYPE (rhs
), lhstype
);
6401 return error_mark_node
;
6405 if (TREE_CODE (rhs
) == BASELINK
)
6407 access_path
= BASELINK_ACCESS_BINFO (rhs
);
6408 rhs
= BASELINK_FUNCTIONS (rhs
);
6411 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6412 deduce any type information. */
6413 if (TREE_CODE (rhs
) == NON_DEPENDENT_EXPR
)
6415 if (flags
& tf_error
)
6416 error ("not enough type information");
6417 return error_mark_node
;
6420 /* There only a few kinds of expressions that may have a type
6421 dependent on overload resolution. */
6422 gcc_assert (TREE_CODE (rhs
) == ADDR_EXPR
6423 || TREE_CODE (rhs
) == COMPONENT_REF
6424 || really_overloaded_fn (rhs
)
6425 || (flag_ms_extensions
&& TREE_CODE (rhs
) == FUNCTION_DECL
));
6427 /* This should really only be used when attempting to distinguish
6428 what sort of a pointer to function we have. For now, any
6429 arithmetic operation which is not supported on pointers
6430 is rejected as an error. */
6432 switch (TREE_CODE (rhs
))
6436 tree member
= TREE_OPERAND (rhs
, 1);
6438 member
= instantiate_type (lhstype
, member
, flags
);
6439 if (member
!= error_mark_node
6440 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs
, 0)))
6441 /* Do not lose object's side effects. */
6442 return build2 (COMPOUND_EXPR
, TREE_TYPE (member
),
6443 TREE_OPERAND (rhs
, 0), member
);
6448 rhs
= TREE_OPERAND (rhs
, 1);
6449 if (BASELINK_P (rhs
))
6450 return instantiate_type (lhstype
, rhs
, flags_in
);
6452 /* This can happen if we are forming a pointer-to-member for a
6454 gcc_assert (TREE_CODE (rhs
) == TEMPLATE_ID_EXPR
);
6458 case TEMPLATE_ID_EXPR
:
6460 tree fns
= TREE_OPERAND (rhs
, 0);
6461 tree args
= TREE_OPERAND (rhs
, 1);
6464 resolve_address_of_overloaded_function (lhstype
, fns
, flags_in
,
6465 /*template_only=*/true,
6472 resolve_address_of_overloaded_function (lhstype
, rhs
, flags_in
,
6473 /*template_only=*/false,
6474 /*explicit_targs=*/NULL_TREE
,
6479 if (PTRMEM_OK_P (rhs
))
6480 flags
|= tf_ptrmem_ok
;
6482 return instantiate_type (lhstype
, TREE_OPERAND (rhs
, 0), flags
);
6486 return error_mark_node
;
6491 return error_mark_node
;
6494 /* Return the name of the virtual function pointer field
6495 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6496 this may have to look back through base types to find the
6497 ultimate field name. (For single inheritance, these could
6498 all be the same name. Who knows for multiple inheritance). */
6501 get_vfield_name (tree type
)
6503 tree binfo
, base_binfo
;
6506 for (binfo
= TYPE_BINFO (type
);
6507 BINFO_N_BASE_BINFOS (binfo
);
6510 base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
6512 if (BINFO_VIRTUAL_P (base_binfo
)
6513 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo
)))
6517 type
= BINFO_TYPE (binfo
);
6518 buf
= (char *) alloca (sizeof (VFIELD_NAME_FORMAT
)
6519 + TYPE_NAME_LENGTH (type
) + 2);
6520 sprintf (buf
, VFIELD_NAME_FORMAT
,
6521 IDENTIFIER_POINTER (constructor_name (type
)));
6522 return get_identifier (buf
);
6526 print_class_statistics (void)
6528 #ifdef GATHER_STATISTICS
6529 fprintf (stderr
, "convert_harshness = %d\n", n_convert_harshness
);
6530 fprintf (stderr
, "compute_conversion_costs = %d\n", n_compute_conversion_costs
);
6533 fprintf (stderr
, "vtables = %d; vtable searches = %d\n",
6534 n_vtables
, n_vtable_searches
);
6535 fprintf (stderr
, "vtable entries = %d; vtable elems = %d\n",
6536 n_vtable_entries
, n_vtable_elems
);
6541 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6542 according to [class]:
6543 The class-name is also inserted
6544 into the scope of the class itself. For purposes of access checking,
6545 the inserted class name is treated as if it were a public member name. */
6548 build_self_reference (void)
6550 tree name
= constructor_name (current_class_type
);
6551 tree value
= build_lang_decl (TYPE_DECL
, name
, current_class_type
);
6554 DECL_NONLOCAL (value
) = 1;
6555 DECL_CONTEXT (value
) = current_class_type
;
6556 DECL_ARTIFICIAL (value
) = 1;
6557 SET_DECL_SELF_REFERENCE_P (value
);
6558 cp_set_underlying_type (value
);
6560 if (processing_template_decl
)
6561 value
= push_template_decl (value
);
6563 saved_cas
= current_access_specifier
;
6564 current_access_specifier
= access_public_node
;
6565 finish_member_declaration (value
);
6566 current_access_specifier
= saved_cas
;
6569 /* Returns 1 if TYPE contains only padding bytes. */
6572 is_empty_class (tree type
)
6574 if (type
== error_mark_node
)
6577 if (! CLASS_TYPE_P (type
))
6580 /* In G++ 3.2, whether or not a class was empty was determined by
6581 looking at its size. */
6582 if (abi_version_at_least (2))
6583 return CLASSTYPE_EMPTY_P (type
);
6585 return integer_zerop (CLASSTYPE_SIZE (type
));
6588 /* Returns true if TYPE contains an empty class. */
6591 contains_empty_class_p (tree type
)
6593 if (is_empty_class (type
))
6595 if (CLASS_TYPE_P (type
))
6602 for (binfo
= TYPE_BINFO (type
), i
= 0;
6603 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
6604 if (contains_empty_class_p (BINFO_TYPE (base_binfo
)))
6606 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
6607 if (TREE_CODE (field
) == FIELD_DECL
6608 && !DECL_ARTIFICIAL (field
)
6609 && is_empty_class (TREE_TYPE (field
)))
6612 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6613 return contains_empty_class_p (TREE_TYPE (type
));
6617 /* Returns true if TYPE contains no actual data, just various
6618 possible combinations of empty classes. */
6621 is_really_empty_class (tree type
)
6623 if (is_empty_class (type
))
6625 if (CLASS_TYPE_P (type
))
6632 for (binfo
= TYPE_BINFO (type
), i
= 0;
6633 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
6634 if (!is_really_empty_class (BINFO_TYPE (base_binfo
)))
6636 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
6637 if (TREE_CODE (field
) == FIELD_DECL
6638 && !DECL_ARTIFICIAL (field
)
6639 && !is_really_empty_class (TREE_TYPE (field
)))
6643 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6644 return is_really_empty_class (TREE_TYPE (type
));
6648 /* Note that NAME was looked up while the current class was being
6649 defined and that the result of that lookup was DECL. */
6652 maybe_note_name_used_in_class (tree name
, tree decl
)
6654 splay_tree names_used
;
6656 /* If we're not defining a class, there's nothing to do. */
6657 if (!(innermost_scope_kind() == sk_class
6658 && TYPE_BEING_DEFINED (current_class_type
)
6659 && !LAMBDA_TYPE_P (current_class_type
)))
6662 /* If there's already a binding for this NAME, then we don't have
6663 anything to worry about. */
6664 if (lookup_member (current_class_type
, name
,
6665 /*protect=*/0, /*want_type=*/false))
6668 if (!current_class_stack
[current_class_depth
- 1].names_used
)
6669 current_class_stack
[current_class_depth
- 1].names_used
6670 = splay_tree_new (splay_tree_compare_pointers
, 0, 0);
6671 names_used
= current_class_stack
[current_class_depth
- 1].names_used
;
6673 splay_tree_insert (names_used
,
6674 (splay_tree_key
) name
,
6675 (splay_tree_value
) decl
);
6678 /* Note that NAME was declared (as DECL) in the current class. Check
6679 to see that the declaration is valid. */
6682 note_name_declared_in_class (tree name
, tree decl
)
6684 splay_tree names_used
;
6687 /* Look to see if we ever used this name. */
6689 = current_class_stack
[current_class_depth
- 1].names_used
;
6693 n
= splay_tree_lookup (names_used
, (splay_tree_key
) name
);
6696 /* [basic.scope.class]
6698 A name N used in a class S shall refer to the same declaration
6699 in its context and when re-evaluated in the completed scope of
6701 permerror (input_location
, "declaration of %q#D", decl
);
6702 permerror (input_location
, "changes meaning of %qD from %q+#D",
6703 DECL_NAME (OVL_CURRENT (decl
)), (tree
) n
->value
);
6707 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6708 Secondary vtables are merged with primary vtables; this function
6709 will return the VAR_DECL for the primary vtable. */
6712 get_vtbl_decl_for_binfo (tree binfo
)
6716 decl
= BINFO_VTABLE (binfo
);
6717 if (decl
&& TREE_CODE (decl
) == POINTER_PLUS_EXPR
)
6719 gcc_assert (TREE_CODE (TREE_OPERAND (decl
, 0)) == ADDR_EXPR
);
6720 decl
= TREE_OPERAND (TREE_OPERAND (decl
, 0), 0);
6723 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
6728 /* Returns the binfo for the primary base of BINFO. If the resulting
6729 BINFO is a virtual base, and it is inherited elsewhere in the
6730 hierarchy, then the returned binfo might not be the primary base of
6731 BINFO in the complete object. Check BINFO_PRIMARY_P or
6732 BINFO_LOST_PRIMARY_P to be sure. */
6735 get_primary_binfo (tree binfo
)
6739 primary_base
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo
));
6743 return copied_binfo (primary_base
, binfo
);
6746 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
6749 maybe_indent_hierarchy (FILE * stream
, int indent
, int indented_p
)
6752 fprintf (stream
, "%*s", indent
, "");
6756 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6757 INDENT should be zero when called from the top level; it is
6758 incremented recursively. IGO indicates the next expected BINFO in
6759 inheritance graph ordering. */
6762 dump_class_hierarchy_r (FILE *stream
,
6772 indented
= maybe_indent_hierarchy (stream
, indent
, 0);
6773 fprintf (stream
, "%s (0x%lx) ",
6774 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
),
6775 (unsigned long) binfo
);
6778 fprintf (stream
, "alternative-path\n");
6781 igo
= TREE_CHAIN (binfo
);
6783 fprintf (stream
, HOST_WIDE_INT_PRINT_DEC
,
6784 tree_low_cst (BINFO_OFFSET (binfo
), 0));
6785 if (is_empty_class (BINFO_TYPE (binfo
)))
6786 fprintf (stream
, " empty");
6787 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo
)))
6788 fprintf (stream
, " nearly-empty");
6789 if (BINFO_VIRTUAL_P (binfo
))
6790 fprintf (stream
, " virtual");
6791 fprintf (stream
, "\n");
6794 if (BINFO_PRIMARY_P (binfo
))
6796 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6797 fprintf (stream
, " primary-for %s (0x%lx)",
6798 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo
)),
6799 TFF_PLAIN_IDENTIFIER
),
6800 (unsigned long)BINFO_INHERITANCE_CHAIN (binfo
));
6802 if (BINFO_LOST_PRIMARY_P (binfo
))
6804 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6805 fprintf (stream
, " lost-primary");
6808 fprintf (stream
, "\n");
6810 if (!(flags
& TDF_SLIM
))
6814 if (BINFO_SUBVTT_INDEX (binfo
))
6816 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6817 fprintf (stream
, " subvttidx=%s",
6818 expr_as_string (BINFO_SUBVTT_INDEX (binfo
),
6819 TFF_PLAIN_IDENTIFIER
));
6821 if (BINFO_VPTR_INDEX (binfo
))
6823 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6824 fprintf (stream
, " vptridx=%s",
6825 expr_as_string (BINFO_VPTR_INDEX (binfo
),
6826 TFF_PLAIN_IDENTIFIER
));
6828 if (BINFO_VPTR_FIELD (binfo
))
6830 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6831 fprintf (stream
, " vbaseoffset=%s",
6832 expr_as_string (BINFO_VPTR_FIELD (binfo
),
6833 TFF_PLAIN_IDENTIFIER
));
6835 if (BINFO_VTABLE (binfo
))
6837 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6838 fprintf (stream
, " vptr=%s",
6839 expr_as_string (BINFO_VTABLE (binfo
),
6840 TFF_PLAIN_IDENTIFIER
));
6844 fprintf (stream
, "\n");
6847 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
6848 igo
= dump_class_hierarchy_r (stream
, flags
, base_binfo
, igo
, indent
+ 2);
6853 /* Dump the BINFO hierarchy for T. */
6856 dump_class_hierarchy_1 (FILE *stream
, int flags
, tree t
)
6858 fprintf (stream
, "Class %s\n", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
6859 fprintf (stream
, " size=%lu align=%lu\n",
6860 (unsigned long)(tree_low_cst (TYPE_SIZE (t
), 0) / BITS_PER_UNIT
),
6861 (unsigned long)(TYPE_ALIGN (t
) / BITS_PER_UNIT
));
6862 fprintf (stream
, " base size=%lu base align=%lu\n",
6863 (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t
)), 0)
6865 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t
))
6867 dump_class_hierarchy_r (stream
, flags
, TYPE_BINFO (t
), TYPE_BINFO (t
), 0);
6868 fprintf (stream
, "\n");
6871 /* Debug interface to hierarchy dumping. */
6874 debug_class (tree t
)
6876 dump_class_hierarchy_1 (stderr
, TDF_SLIM
, t
);
6880 dump_class_hierarchy (tree t
)
6883 FILE *stream
= dump_begin (TDI_class
, &flags
);
6887 dump_class_hierarchy_1 (stream
, flags
, t
);
6888 dump_end (TDI_class
, stream
);
6893 dump_array (FILE * stream
, tree decl
)
6896 unsigned HOST_WIDE_INT ix
;
6898 tree size
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl
)));
6900 elt
= (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
))), 0)
6902 fprintf (stream
, "%s:", decl_as_string (decl
, TFF_PLAIN_IDENTIFIER
));
6903 fprintf (stream
, " %s entries",
6904 expr_as_string (size_binop (PLUS_EXPR
, size
, size_one_node
),
6905 TFF_PLAIN_IDENTIFIER
));
6906 fprintf (stream
, "\n");
6908 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
)),
6910 fprintf (stream
, "%-4ld %s\n", (long)(ix
* elt
),
6911 expr_as_string (value
, TFF_PLAIN_IDENTIFIER
));
6915 dump_vtable (tree t
, tree binfo
, tree vtable
)
6918 FILE *stream
= dump_begin (TDI_class
, &flags
);
6923 if (!(flags
& TDF_SLIM
))
6925 int ctor_vtbl_p
= TYPE_BINFO (t
) != binfo
;
6927 fprintf (stream
, "%s for %s",
6928 ctor_vtbl_p
? "Construction vtable" : "Vtable",
6929 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
));
6932 if (!BINFO_VIRTUAL_P (binfo
))
6933 fprintf (stream
, " (0x%lx instance)", (unsigned long)binfo
);
6934 fprintf (stream
, " in %s", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
6936 fprintf (stream
, "\n");
6937 dump_array (stream
, vtable
);
6938 fprintf (stream
, "\n");
6941 dump_end (TDI_class
, stream
);
6945 dump_vtt (tree t
, tree vtt
)
6948 FILE *stream
= dump_begin (TDI_class
, &flags
);
6953 if (!(flags
& TDF_SLIM
))
6955 fprintf (stream
, "VTT for %s\n",
6956 type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
6957 dump_array (stream
, vtt
);
6958 fprintf (stream
, "\n");
6961 dump_end (TDI_class
, stream
);
6964 /* Dump a function or thunk and its thunkees. */
6967 dump_thunk (FILE *stream
, int indent
, tree thunk
)
6969 static const char spaces
[] = " ";
6970 tree name
= DECL_NAME (thunk
);
6973 fprintf (stream
, "%.*s%p %s %s", indent
, spaces
,
6975 !DECL_THUNK_P (thunk
) ? "function"
6976 : DECL_THIS_THUNK_P (thunk
) ? "this-thunk" : "covariant-thunk",
6977 name
? IDENTIFIER_POINTER (name
) : "<unset>");
6978 if (DECL_THUNK_P (thunk
))
6980 HOST_WIDE_INT fixed_adjust
= THUNK_FIXED_OFFSET (thunk
);
6981 tree virtual_adjust
= THUNK_VIRTUAL_OFFSET (thunk
);
6983 fprintf (stream
, " fixed=" HOST_WIDE_INT_PRINT_DEC
, fixed_adjust
);
6984 if (!virtual_adjust
)
6986 else if (DECL_THIS_THUNK_P (thunk
))
6987 fprintf (stream
, " vcall=" HOST_WIDE_INT_PRINT_DEC
,
6988 tree_low_cst (virtual_adjust
, 0));
6990 fprintf (stream
, " vbase=" HOST_WIDE_INT_PRINT_DEC
"(%s)",
6991 tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust
), 0),
6992 type_as_string (BINFO_TYPE (virtual_adjust
), TFF_SCOPE
));
6993 if (THUNK_ALIAS (thunk
))
6994 fprintf (stream
, " alias to %p", (void *)THUNK_ALIAS (thunk
));
6996 fprintf (stream
, "\n");
6997 for (thunks
= DECL_THUNKS (thunk
); thunks
; thunks
= TREE_CHAIN (thunks
))
6998 dump_thunk (stream
, indent
+ 2, thunks
);
7001 /* Dump the thunks for FN. */
7004 debug_thunks (tree fn
)
7006 dump_thunk (stderr
, 0, fn
);
7009 /* Virtual function table initialization. */
7011 /* Create all the necessary vtables for T and its base classes. */
7014 finish_vtbls (tree t
)
7019 /* We lay out the primary and secondary vtables in one contiguous
7020 vtable. The primary vtable is first, followed by the non-virtual
7021 secondary vtables in inheritance graph order. */
7022 list
= build_tree_list (BINFO_VTABLE (TYPE_BINFO (t
)), NULL_TREE
);
7023 accumulate_vtbl_inits (TYPE_BINFO (t
), TYPE_BINFO (t
),
7024 TYPE_BINFO (t
), t
, list
);
7026 /* Then come the virtual bases, also in inheritance graph order. */
7027 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
7029 if (!BINFO_VIRTUAL_P (vbase
))
7031 accumulate_vtbl_inits (vbase
, vbase
, TYPE_BINFO (t
), t
, list
);
7034 if (BINFO_VTABLE (TYPE_BINFO (t
)))
7035 initialize_vtable (TYPE_BINFO (t
), TREE_VALUE (list
));
7038 /* Initialize the vtable for BINFO with the INITS. */
7041 initialize_vtable (tree binfo
, tree inits
)
7045 layout_vtable_decl (binfo
, list_length (inits
));
7046 decl
= get_vtbl_decl_for_binfo (binfo
);
7047 initialize_artificial_var (decl
, inits
);
7048 dump_vtable (BINFO_TYPE (binfo
), binfo
, decl
);
7051 /* Build the VTT (virtual table table) for T.
7052 A class requires a VTT if it has virtual bases.
7055 1 - primary virtual pointer for complete object T
7056 2 - secondary VTTs for each direct non-virtual base of T which requires a
7058 3 - secondary virtual pointers for each direct or indirect base of T which
7059 has virtual bases or is reachable via a virtual path from T.
7060 4 - secondary VTTs for each direct or indirect virtual base of T.
7062 Secondary VTTs look like complete object VTTs without part 4. */
7072 /* Build up the initializers for the VTT. */
7074 index
= size_zero_node
;
7075 build_vtt_inits (TYPE_BINFO (t
), t
, &inits
, &index
);
7077 /* If we didn't need a VTT, we're done. */
7081 /* Figure out the type of the VTT. */
7082 type
= build_index_type (size_int (list_length (inits
) - 1));
7083 type
= build_cplus_array_type (const_ptr_type_node
, type
);
7085 /* Now, build the VTT object itself. */
7086 vtt
= build_vtable (t
, mangle_vtt_for_type (t
), type
);
7087 initialize_artificial_var (vtt
, inits
);
7088 /* Add the VTT to the vtables list. */
7089 TREE_CHAIN (vtt
) = TREE_CHAIN (CLASSTYPE_VTABLES (t
));
7090 TREE_CHAIN (CLASSTYPE_VTABLES (t
)) = vtt
;
7095 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7096 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7097 and CHAIN the vtable pointer for this binfo after construction is
7098 complete. VALUE can also be another BINFO, in which case we recurse. */
7101 binfo_ctor_vtable (tree binfo
)
7107 vt
= BINFO_VTABLE (binfo
);
7108 if (TREE_CODE (vt
) == TREE_LIST
)
7109 vt
= TREE_VALUE (vt
);
7110 if (TREE_CODE (vt
) == TREE_BINFO
)
7119 /* Data for secondary VTT initialization. */
7120 typedef struct secondary_vptr_vtt_init_data_s
7122 /* Is this the primary VTT? */
7125 /* Current index into the VTT. */
7128 /* TREE_LIST of initializers built up. */
7131 /* The type being constructed by this secondary VTT. */
7132 tree type_being_constructed
;
7133 } secondary_vptr_vtt_init_data
;
7135 /* Recursively build the VTT-initializer for BINFO (which is in the
7136 hierarchy dominated by T). INITS points to the end of the initializer
7137 list to date. INDEX is the VTT index where the next element will be
7138 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7139 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
7140 for virtual bases of T. When it is not so, we build the constructor
7141 vtables for the BINFO-in-T variant. */
7144 build_vtt_inits (tree binfo
, tree t
, tree
*inits
, tree
*index
)
7149 tree secondary_vptrs
;
7150 secondary_vptr_vtt_init_data data
;
7151 int top_level_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
7153 /* We only need VTTs for subobjects with virtual bases. */
7154 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
7157 /* We need to use a construction vtable if this is not the primary
7161 build_ctor_vtbl_group (binfo
, t
);
7163 /* Record the offset in the VTT where this sub-VTT can be found. */
7164 BINFO_SUBVTT_INDEX (binfo
) = *index
;
7167 /* Add the address of the primary vtable for the complete object. */
7168 init
= binfo_ctor_vtable (binfo
);
7169 *inits
= build_tree_list (NULL_TREE
, init
);
7170 inits
= &TREE_CHAIN (*inits
);
7173 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
7174 BINFO_VPTR_INDEX (binfo
) = *index
;
7176 *index
= size_binop (PLUS_EXPR
, *index
, TYPE_SIZE_UNIT (ptr_type_node
));
7178 /* Recursively add the secondary VTTs for non-virtual bases. */
7179 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, b
); ++i
)
7180 if (!BINFO_VIRTUAL_P (b
))
7181 inits
= build_vtt_inits (b
, t
, inits
, index
);
7183 /* Add secondary virtual pointers for all subobjects of BINFO with
7184 either virtual bases or reachable along a virtual path, except
7185 subobjects that are non-virtual primary bases. */
7186 data
.top_level_p
= top_level_p
;
7187 data
.index
= *index
;
7189 data
.type_being_constructed
= BINFO_TYPE (binfo
);
7191 dfs_walk_once (binfo
, dfs_build_secondary_vptr_vtt_inits
, NULL
, &data
);
7193 *index
= data
.index
;
7195 /* The secondary vptrs come back in reverse order. After we reverse
7196 them, and add the INITS, the last init will be the first element
7198 secondary_vptrs
= data
.inits
;
7199 if (secondary_vptrs
)
7201 *inits
= nreverse (secondary_vptrs
);
7202 inits
= &TREE_CHAIN (secondary_vptrs
);
7203 gcc_assert (*inits
== NULL_TREE
);
7207 /* Add the secondary VTTs for virtual bases in inheritance graph
7209 for (b
= TYPE_BINFO (BINFO_TYPE (binfo
)); b
; b
= TREE_CHAIN (b
))
7211 if (!BINFO_VIRTUAL_P (b
))
7214 inits
= build_vtt_inits (b
, t
, inits
, index
);
7217 /* Remove the ctor vtables we created. */
7218 dfs_walk_all (binfo
, dfs_fixup_binfo_vtbls
, NULL
, binfo
);
7223 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
7224 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
7227 dfs_build_secondary_vptr_vtt_inits (tree binfo
, void *data_
)
7229 secondary_vptr_vtt_init_data
*data
= (secondary_vptr_vtt_init_data
*)data_
;
7231 /* We don't care about bases that don't have vtables. */
7232 if (!TYPE_VFIELD (BINFO_TYPE (binfo
)))
7233 return dfs_skip_bases
;
7235 /* We're only interested in proper subobjects of the type being
7237 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->type_being_constructed
))
7240 /* We're only interested in bases with virtual bases or reachable
7241 via a virtual path from the type being constructed. */
7242 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
7243 || binfo_via_virtual (binfo
, data
->type_being_constructed
)))
7244 return dfs_skip_bases
;
7246 /* We're not interested in non-virtual primary bases. */
7247 if (!BINFO_VIRTUAL_P (binfo
) && BINFO_PRIMARY_P (binfo
))
7250 /* Record the index where this secondary vptr can be found. */
7251 if (data
->top_level_p
)
7253 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
7254 BINFO_VPTR_INDEX (binfo
) = data
->index
;
7256 if (BINFO_VIRTUAL_P (binfo
))
7258 /* It's a primary virtual base, and this is not a
7259 construction vtable. Find the base this is primary of in
7260 the inheritance graph, and use that base's vtable
7262 while (BINFO_PRIMARY_P (binfo
))
7263 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
7267 /* Add the initializer for the secondary vptr itself. */
7268 data
->inits
= tree_cons (NULL_TREE
, binfo_ctor_vtable (binfo
), data
->inits
);
7270 /* Advance the vtt index. */
7271 data
->index
= size_binop (PLUS_EXPR
, data
->index
,
7272 TYPE_SIZE_UNIT (ptr_type_node
));
7277 /* Called from build_vtt_inits via dfs_walk. After building
7278 constructor vtables and generating the sub-vtt from them, we need
7279 to restore the BINFO_VTABLES that were scribbled on. DATA is the
7280 binfo of the base whose sub vtt was generated. */
7283 dfs_fixup_binfo_vtbls (tree binfo
, void* data
)
7285 tree vtable
= BINFO_VTABLE (binfo
);
7287 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
7288 /* If this class has no vtable, none of its bases do. */
7289 return dfs_skip_bases
;
7292 /* This might be a primary base, so have no vtable in this
7296 /* If we scribbled the construction vtable vptr into BINFO, clear it
7298 if (TREE_CODE (vtable
) == TREE_LIST
7299 && (TREE_PURPOSE (vtable
) == (tree
) data
))
7300 BINFO_VTABLE (binfo
) = TREE_CHAIN (vtable
);
7305 /* Build the construction vtable group for BINFO which is in the
7306 hierarchy dominated by T. */
7309 build_ctor_vtbl_group (tree binfo
, tree t
)
7318 /* See if we've already created this construction vtable group. */
7319 id
= mangle_ctor_vtbl_for_type (t
, binfo
);
7320 if (IDENTIFIER_GLOBAL_VALUE (id
))
7323 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
));
7324 /* Build a version of VTBL (with the wrong type) for use in
7325 constructing the addresses of secondary vtables in the
7326 construction vtable group. */
7327 vtbl
= build_vtable (t
, id
, ptr_type_node
);
7328 DECL_CONSTRUCTION_VTABLE_P (vtbl
) = 1;
7329 list
= build_tree_list (vtbl
, NULL_TREE
);
7330 accumulate_vtbl_inits (binfo
, TYPE_BINFO (TREE_TYPE (binfo
)),
7333 /* Add the vtables for each of our virtual bases using the vbase in T
7335 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
7337 vbase
= TREE_CHAIN (vbase
))
7341 if (!BINFO_VIRTUAL_P (vbase
))
7343 b
= copied_binfo (vbase
, binfo
);
7345 accumulate_vtbl_inits (b
, vbase
, binfo
, t
, list
);
7347 inits
= TREE_VALUE (list
);
7349 /* Figure out the type of the construction vtable. */
7350 type
= build_index_type (size_int (list_length (inits
) - 1));
7351 type
= build_cplus_array_type (vtable_entry_type
, type
);
7353 TREE_TYPE (vtbl
) = type
;
7354 DECL_SIZE (vtbl
) = DECL_SIZE_UNIT (vtbl
) = NULL_TREE
;
7355 layout_decl (vtbl
, 0);
7357 /* Initialize the construction vtable. */
7358 CLASSTYPE_VTABLES (t
) = chainon (CLASSTYPE_VTABLES (t
), vtbl
);
7359 initialize_artificial_var (vtbl
, inits
);
7360 dump_vtable (t
, binfo
, vtbl
);
7363 /* Add the vtbl initializers for BINFO (and its bases other than
7364 non-virtual primaries) to the list of INITS. BINFO is in the
7365 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7366 the constructor the vtbl inits should be accumulated for. (If this
7367 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7368 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7369 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7370 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7371 but are not necessarily the same in terms of layout. */
7374 accumulate_vtbl_inits (tree binfo
,
7382 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
7384 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (orig_binfo
)));
7386 /* If it doesn't have a vptr, we don't do anything. */
7387 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
7390 /* If we're building a construction vtable, we're not interested in
7391 subobjects that don't require construction vtables. */
7393 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
7394 && !binfo_via_virtual (orig_binfo
, BINFO_TYPE (rtti_binfo
)))
7397 /* Build the initializers for the BINFO-in-T vtable. */
7399 = chainon (TREE_VALUE (inits
),
7400 dfs_accumulate_vtbl_inits (binfo
, orig_binfo
,
7401 rtti_binfo
, t
, inits
));
7403 /* Walk the BINFO and its bases. We walk in preorder so that as we
7404 initialize each vtable we can figure out at what offset the
7405 secondary vtable lies from the primary vtable. We can't use
7406 dfs_walk here because we need to iterate through bases of BINFO
7407 and RTTI_BINFO simultaneously. */
7408 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
7410 /* Skip virtual bases. */
7411 if (BINFO_VIRTUAL_P (base_binfo
))
7413 accumulate_vtbl_inits (base_binfo
,
7414 BINFO_BASE_BINFO (orig_binfo
, i
),
7420 /* Called from accumulate_vtbl_inits. Returns the initializers for
7421 the BINFO vtable. */
7424 dfs_accumulate_vtbl_inits (tree binfo
,
7430 tree inits
= NULL_TREE
;
7431 tree vtbl
= NULL_TREE
;
7432 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
7435 && BINFO_VIRTUAL_P (orig_binfo
) && BINFO_PRIMARY_P (orig_binfo
))
7437 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7438 primary virtual base. If it is not the same primary in
7439 the hierarchy of T, we'll need to generate a ctor vtable
7440 for it, to place at its location in T. If it is the same
7441 primary, we still need a VTT entry for the vtable, but it
7442 should point to the ctor vtable for the base it is a
7443 primary for within the sub-hierarchy of RTTI_BINFO.
7445 There are three possible cases:
7447 1) We are in the same place.
7448 2) We are a primary base within a lost primary virtual base of
7450 3) We are primary to something not a base of RTTI_BINFO. */
7453 tree last
= NULL_TREE
;
7455 /* First, look through the bases we are primary to for RTTI_BINFO
7456 or a virtual base. */
7458 while (BINFO_PRIMARY_P (b
))
7460 b
= BINFO_INHERITANCE_CHAIN (b
);
7462 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
7465 /* If we run out of primary links, keep looking down our
7466 inheritance chain; we might be an indirect primary. */
7467 for (b
= last
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
7468 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
7472 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7473 base B and it is a base of RTTI_BINFO, this is case 2. In
7474 either case, we share our vtable with LAST, i.e. the
7475 derived-most base within B of which we are a primary. */
7477 || (b
&& binfo_for_vbase (BINFO_TYPE (b
), BINFO_TYPE (rtti_binfo
))))
7478 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7479 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7480 binfo_ctor_vtable after everything's been set up. */
7483 /* Otherwise, this is case 3 and we get our own. */
7485 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo
))
7493 /* Compute the initializer for this vtable. */
7494 inits
= build_vtbl_initializer (binfo
, orig_binfo
, t
, rtti_binfo
,
7497 /* Figure out the position to which the VPTR should point. */
7498 vtbl
= TREE_PURPOSE (l
);
7499 vtbl
= build1 (ADDR_EXPR
, vtbl_ptr_type_node
, vtbl
);
7500 index
= size_binop (PLUS_EXPR
,
7501 size_int (non_fn_entries
),
7502 size_int (list_length (TREE_VALUE (l
))));
7503 index
= size_binop (MULT_EXPR
,
7504 TYPE_SIZE_UNIT (vtable_entry_type
),
7506 vtbl
= build2 (POINTER_PLUS_EXPR
, TREE_TYPE (vtbl
), vtbl
, index
);
7510 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7511 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7512 straighten this out. */
7513 BINFO_VTABLE (binfo
) = tree_cons (rtti_binfo
, vtbl
, BINFO_VTABLE (binfo
));
7514 else if (BINFO_PRIMARY_P (binfo
) && BINFO_VIRTUAL_P (binfo
))
7517 /* For an ordinary vtable, set BINFO_VTABLE. */
7518 BINFO_VTABLE (binfo
) = vtbl
;
7523 static GTY(()) tree abort_fndecl_addr
;
7525 /* Construct the initializer for BINFO's virtual function table. BINFO
7526 is part of the hierarchy dominated by T. If we're building a
7527 construction vtable, the ORIG_BINFO is the binfo we should use to
7528 find the actual function pointers to put in the vtable - but they
7529 can be overridden on the path to most-derived in the graph that
7530 ORIG_BINFO belongs. Otherwise,
7531 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7532 BINFO that should be indicated by the RTTI information in the
7533 vtable; it will be a base class of T, rather than T itself, if we
7534 are building a construction vtable.
7536 The value returned is a TREE_LIST suitable for wrapping in a
7537 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7538 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7539 number of non-function entries in the vtable.
7541 It might seem that this function should never be called with a
7542 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7543 base is always subsumed by a derived class vtable. However, when
7544 we are building construction vtables, we do build vtables for
7545 primary bases; we need these while the primary base is being
7549 build_vtbl_initializer (tree binfo
,
7553 int* non_fn_entries_p
)
7560 VEC(tree
,gc
) *vbases
;
7562 /* Initialize VID. */
7563 memset (&vid
, 0, sizeof (vid
));
7566 vid
.rtti_binfo
= rtti_binfo
;
7567 vid
.last_init
= &vid
.inits
;
7568 vid
.primary_vtbl_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
7569 vid
.ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
7570 vid
.generate_vcall_entries
= true;
7571 /* The first vbase or vcall offset is at index -3 in the vtable. */
7572 vid
.index
= ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
7574 /* Add entries to the vtable for RTTI. */
7575 build_rtti_vtbl_entries (binfo
, &vid
);
7577 /* Create an array for keeping track of the functions we've
7578 processed. When we see multiple functions with the same
7579 signature, we share the vcall offsets. */
7580 vid
.fns
= VEC_alloc (tree
, gc
, 32);
7581 /* Add the vcall and vbase offset entries. */
7582 build_vcall_and_vbase_vtbl_entries (binfo
, &vid
);
7584 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7585 build_vbase_offset_vtbl_entries. */
7586 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
7587 VEC_iterate (tree
, vbases
, ix
, vbinfo
); ix
++)
7588 BINFO_VTABLE_PATH_MARKED (vbinfo
) = 0;
7590 /* If the target requires padding between data entries, add that now. */
7591 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE
> 1)
7595 for (prev
= &vid
.inits
; (cur
= *prev
); prev
= &TREE_CHAIN (cur
))
7600 for (i
= 1; i
< TARGET_VTABLE_DATA_ENTRY_DISTANCE
; ++i
)
7601 add
= tree_cons (NULL_TREE
,
7602 build1 (NOP_EXPR
, vtable_entry_type
,
7609 if (non_fn_entries_p
)
7610 *non_fn_entries_p
= list_length (vid
.inits
);
7612 /* Go through all the ordinary virtual functions, building up
7614 vfun_inits
= NULL_TREE
;
7615 for (v
= BINFO_VIRTUALS (orig_binfo
); v
; v
= TREE_CHAIN (v
))
7619 tree fn
, fn_original
;
7620 tree init
= NULL_TREE
;
7624 if (DECL_THUNK_P (fn
))
7626 if (!DECL_NAME (fn
))
7628 if (THUNK_ALIAS (fn
))
7630 fn
= THUNK_ALIAS (fn
);
7633 fn_original
= THUNK_TARGET (fn
);
7636 /* If the only definition of this function signature along our
7637 primary base chain is from a lost primary, this vtable slot will
7638 never be used, so just zero it out. This is important to avoid
7639 requiring extra thunks which cannot be generated with the function.
7641 We first check this in update_vtable_entry_for_fn, so we handle
7642 restored primary bases properly; we also need to do it here so we
7643 zero out unused slots in ctor vtables, rather than filling them
7644 with erroneous values (though harmless, apart from relocation
7646 for (b
= binfo
; ; b
= get_primary_binfo (b
))
7648 /* We found a defn before a lost primary; go ahead as normal. */
7649 if (look_for_overrides_here (BINFO_TYPE (b
), fn_original
))
7652 /* The nearest definition is from a lost primary; clear the
7654 if (BINFO_LOST_PRIMARY_P (b
))
7656 init
= size_zero_node
;
7663 /* Pull the offset for `this', and the function to call, out of
7665 delta
= BV_DELTA (v
);
7666 vcall_index
= BV_VCALL_INDEX (v
);
7668 gcc_assert (TREE_CODE (delta
) == INTEGER_CST
);
7669 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
7671 /* You can't call an abstract virtual function; it's abstract.
7672 So, we replace these functions with __pure_virtual. */
7673 if (DECL_PURE_VIRTUAL_P (fn_original
))
7676 if (abort_fndecl_addr
== NULL
)
7677 abort_fndecl_addr
= build1 (ADDR_EXPR
, vfunc_ptr_type_node
, fn
);
7678 init
= abort_fndecl_addr
;
7682 if (!integer_zerop (delta
) || vcall_index
)
7684 fn
= make_thunk (fn
, /*this_adjusting=*/1, delta
, vcall_index
);
7685 if (!DECL_NAME (fn
))
7688 /* Take the address of the function, considering it to be of an
7689 appropriate generic type. */
7690 init
= build1 (ADDR_EXPR
, vfunc_ptr_type_node
, fn
);
7694 /* And add it to the chain of initializers. */
7695 if (TARGET_VTABLE_USES_DESCRIPTORS
)
7698 if (init
== size_zero_node
)
7699 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
7700 vfun_inits
= tree_cons (NULL_TREE
, init
, vfun_inits
);
7702 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
7704 tree fdesc
= build2 (FDESC_EXPR
, vfunc_ptr_type_node
,
7705 TREE_OPERAND (init
, 0),
7706 build_int_cst (NULL_TREE
, i
));
7707 TREE_CONSTANT (fdesc
) = 1;
7709 vfun_inits
= tree_cons (NULL_TREE
, fdesc
, vfun_inits
);
7713 vfun_inits
= tree_cons (NULL_TREE
, init
, vfun_inits
);
7716 /* The initializers for virtual functions were built up in reverse
7717 order; straighten them out now. */
7718 vfun_inits
= nreverse (vfun_inits
);
7720 /* The negative offset initializers are also in reverse order. */
7721 vid
.inits
= nreverse (vid
.inits
);
7723 /* Chain the two together. */
7724 return chainon (vid
.inits
, vfun_inits
);
7727 /* Adds to vid->inits the initializers for the vbase and vcall
7728 offsets in BINFO, which is in the hierarchy dominated by T. */
7731 build_vcall_and_vbase_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
7735 /* If this is a derived class, we must first create entries
7736 corresponding to the primary base class. */
7737 b
= get_primary_binfo (binfo
);
7739 build_vcall_and_vbase_vtbl_entries (b
, vid
);
7741 /* Add the vbase entries for this base. */
7742 build_vbase_offset_vtbl_entries (binfo
, vid
);
7743 /* Add the vcall entries for this base. */
7744 build_vcall_offset_vtbl_entries (binfo
, vid
);
7747 /* Returns the initializers for the vbase offset entries in the vtable
7748 for BINFO (which is part of the class hierarchy dominated by T), in
7749 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7750 where the next vbase offset will go. */
7753 build_vbase_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
7757 tree non_primary_binfo
;
7759 /* If there are no virtual baseclasses, then there is nothing to
7761 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
7766 /* We might be a primary base class. Go up the inheritance hierarchy
7767 until we find the most derived class of which we are a primary base:
7768 it is the offset of that which we need to use. */
7769 non_primary_binfo
= binfo
;
7770 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
7774 /* If we have reached a virtual base, then it must be a primary
7775 base (possibly multi-level) of vid->binfo, or we wouldn't
7776 have called build_vcall_and_vbase_vtbl_entries for it. But it
7777 might be a lost primary, so just skip down to vid->binfo. */
7778 if (BINFO_VIRTUAL_P (non_primary_binfo
))
7780 non_primary_binfo
= vid
->binfo
;
7784 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
7785 if (get_primary_binfo (b
) != non_primary_binfo
)
7787 non_primary_binfo
= b
;
7790 /* Go through the virtual bases, adding the offsets. */
7791 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
7793 vbase
= TREE_CHAIN (vbase
))
7798 if (!BINFO_VIRTUAL_P (vbase
))
7801 /* Find the instance of this virtual base in the complete
7803 b
= copied_binfo (vbase
, binfo
);
7805 /* If we've already got an offset for this virtual base, we
7806 don't need another one. */
7807 if (BINFO_VTABLE_PATH_MARKED (b
))
7809 BINFO_VTABLE_PATH_MARKED (b
) = 1;
7811 /* Figure out where we can find this vbase offset. */
7812 delta
= size_binop (MULT_EXPR
,
7815 TYPE_SIZE_UNIT (vtable_entry_type
)));
7816 if (vid
->primary_vtbl_p
)
7817 BINFO_VPTR_FIELD (b
) = delta
;
7819 if (binfo
!= TYPE_BINFO (t
))
7820 /* The vbase offset had better be the same. */
7821 gcc_assert (tree_int_cst_equal (delta
, BINFO_VPTR_FIELD (vbase
)));
7823 /* The next vbase will come at a more negative offset. */
7824 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
7825 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
7827 /* The initializer is the delta from BINFO to this virtual base.
7828 The vbase offsets go in reverse inheritance-graph order, and
7829 we are walking in inheritance graph order so these end up in
7831 delta
= size_diffop_loc (input_location
,
7832 BINFO_OFFSET (b
), BINFO_OFFSET (non_primary_binfo
));
7835 = build_tree_list (NULL_TREE
,
7836 fold_build1_loc (input_location
, NOP_EXPR
,
7839 vid
->last_init
= &TREE_CHAIN (*vid
->last_init
);
7843 /* Adds the initializers for the vcall offset entries in the vtable
7844 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7848 build_vcall_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
7850 /* We only need these entries if this base is a virtual base. We
7851 compute the indices -- but do not add to the vtable -- when
7852 building the main vtable for a class. */
7853 if (binfo
== TYPE_BINFO (vid
->derived
)
7854 || (BINFO_VIRTUAL_P (binfo
)
7855 /* If BINFO is RTTI_BINFO, then (since BINFO does not
7856 correspond to VID->DERIVED), we are building a primary
7857 construction virtual table. Since this is a primary
7858 virtual table, we do not need the vcall offsets for
7860 && binfo
!= vid
->rtti_binfo
))
7862 /* We need a vcall offset for each of the virtual functions in this
7863 vtable. For example:
7865 class A { virtual void f (); };
7866 class B1 : virtual public A { virtual void f (); };
7867 class B2 : virtual public A { virtual void f (); };
7868 class C: public B1, public B2 { virtual void f (); };
7870 A C object has a primary base of B1, which has a primary base of A. A
7871 C also has a secondary base of B2, which no longer has a primary base
7872 of A. So the B2-in-C construction vtable needs a secondary vtable for
7873 A, which will adjust the A* to a B2* to call f. We have no way of
7874 knowing what (or even whether) this offset will be when we define B2,
7875 so we store this "vcall offset" in the A sub-vtable and look it up in
7876 a "virtual thunk" for B2::f.
7878 We need entries for all the functions in our primary vtable and
7879 in our non-virtual bases' secondary vtables. */
7881 /* If we are just computing the vcall indices -- but do not need
7882 the actual entries -- not that. */
7883 if (!BINFO_VIRTUAL_P (binfo
))
7884 vid
->generate_vcall_entries
= false;
7885 /* Now, walk through the non-virtual bases, adding vcall offsets. */
7886 add_vcall_offset_vtbl_entries_r (binfo
, vid
);
7890 /* Build vcall offsets, starting with those for BINFO. */
7893 add_vcall_offset_vtbl_entries_r (tree binfo
, vtbl_init_data
* vid
)
7899 /* Don't walk into virtual bases -- except, of course, for the
7900 virtual base for which we are building vcall offsets. Any
7901 primary virtual base will have already had its offsets generated
7902 through the recursion in build_vcall_and_vbase_vtbl_entries. */
7903 if (BINFO_VIRTUAL_P (binfo
) && vid
->vbase
!= binfo
)
7906 /* If BINFO has a primary base, process it first. */
7907 primary_binfo
= get_primary_binfo (binfo
);
7909 add_vcall_offset_vtbl_entries_r (primary_binfo
, vid
);
7911 /* Add BINFO itself to the list. */
7912 add_vcall_offset_vtbl_entries_1 (binfo
, vid
);
7914 /* Scan the non-primary bases of BINFO. */
7915 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
7916 if (base_binfo
!= primary_binfo
)
7917 add_vcall_offset_vtbl_entries_r (base_binfo
, vid
);
7920 /* Called from build_vcall_offset_vtbl_entries_r. */
7923 add_vcall_offset_vtbl_entries_1 (tree binfo
, vtbl_init_data
* vid
)
7925 /* Make entries for the rest of the virtuals. */
7926 if (abi_version_at_least (2))
7930 /* The ABI requires that the methods be processed in declaration
7931 order. G++ 3.2 used the order in the vtable. */
7932 for (orig_fn
= TYPE_METHODS (BINFO_TYPE (binfo
));
7934 orig_fn
= TREE_CHAIN (orig_fn
))
7935 if (DECL_VINDEX (orig_fn
))
7936 add_vcall_offset (orig_fn
, binfo
, vid
);
7940 tree derived_virtuals
;
7943 /* If BINFO is a primary base, the most derived class which has
7944 BINFO as a primary base; otherwise, just BINFO. */
7945 tree non_primary_binfo
;
7947 /* We might be a primary base class. Go up the inheritance hierarchy
7948 until we find the most derived class of which we are a primary base:
7949 it is the BINFO_VIRTUALS there that we need to consider. */
7950 non_primary_binfo
= binfo
;
7951 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
7955 /* If we have reached a virtual base, then it must be vid->vbase,
7956 because we ignore other virtual bases in
7957 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
7958 base (possibly multi-level) of vid->binfo, or we wouldn't
7959 have called build_vcall_and_vbase_vtbl_entries for it. But it
7960 might be a lost primary, so just skip down to vid->binfo. */
7961 if (BINFO_VIRTUAL_P (non_primary_binfo
))
7963 gcc_assert (non_primary_binfo
== vid
->vbase
);
7964 non_primary_binfo
= vid
->binfo
;
7968 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
7969 if (get_primary_binfo (b
) != non_primary_binfo
)
7971 non_primary_binfo
= b
;
7974 if (vid
->ctor_vtbl_p
)
7975 /* For a ctor vtable we need the equivalent binfo within the hierarchy
7976 where rtti_binfo is the most derived type. */
7978 = original_binfo (non_primary_binfo
, vid
->rtti_binfo
);
7980 for (base_virtuals
= BINFO_VIRTUALS (binfo
),
7981 derived_virtuals
= BINFO_VIRTUALS (non_primary_binfo
),
7982 orig_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
7984 base_virtuals
= TREE_CHAIN (base_virtuals
),
7985 derived_virtuals
= TREE_CHAIN (derived_virtuals
),
7986 orig_virtuals
= TREE_CHAIN (orig_virtuals
))
7990 /* Find the declaration that originally caused this function to
7991 be present in BINFO_TYPE (binfo). */
7992 orig_fn
= BV_FN (orig_virtuals
);
7994 /* When processing BINFO, we only want to generate vcall slots for
7995 function slots introduced in BINFO. So don't try to generate
7996 one if the function isn't even defined in BINFO. */
7997 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), DECL_CONTEXT (orig_fn
)))
8000 add_vcall_offset (orig_fn
, binfo
, vid
);
8005 /* Add a vcall offset entry for ORIG_FN to the vtable. */
8008 add_vcall_offset (tree orig_fn
, tree binfo
, vtbl_init_data
*vid
)
8014 /* If there is already an entry for a function with the same
8015 signature as FN, then we do not need a second vcall offset.
8016 Check the list of functions already present in the derived
8018 for (i
= 0; VEC_iterate (tree
, vid
->fns
, i
, derived_entry
); ++i
)
8020 if (same_signature_p (derived_entry
, orig_fn
)
8021 /* We only use one vcall offset for virtual destructors,
8022 even though there are two virtual table entries. */
8023 || (DECL_DESTRUCTOR_P (derived_entry
)
8024 && DECL_DESTRUCTOR_P (orig_fn
)))
8028 /* If we are building these vcall offsets as part of building
8029 the vtable for the most derived class, remember the vcall
8031 if (vid
->binfo
== TYPE_BINFO (vid
->derived
))
8033 tree_pair_p elt
= VEC_safe_push (tree_pair_s
, gc
,
8034 CLASSTYPE_VCALL_INDICES (vid
->derived
),
8036 elt
->purpose
= orig_fn
;
8037 elt
->value
= vid
->index
;
8040 /* The next vcall offset will be found at a more negative
8042 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
8043 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
8045 /* Keep track of this function. */
8046 VEC_safe_push (tree
, gc
, vid
->fns
, orig_fn
);
8048 if (vid
->generate_vcall_entries
)
8053 /* Find the overriding function. */
8054 fn
= find_final_overrider (vid
->rtti_binfo
, binfo
, orig_fn
);
8055 if (fn
== error_mark_node
)
8056 vcall_offset
= build1 (NOP_EXPR
, vtable_entry_type
,
8060 base
= TREE_VALUE (fn
);
8062 /* The vbase we're working on is a primary base of
8063 vid->binfo. But it might be a lost primary, so its
8064 BINFO_OFFSET might be wrong, so we just use the
8065 BINFO_OFFSET from vid->binfo. */
8066 vcall_offset
= size_diffop_loc (input_location
,
8067 BINFO_OFFSET (base
),
8068 BINFO_OFFSET (vid
->binfo
));
8069 vcall_offset
= fold_build1_loc (input_location
,
8070 NOP_EXPR
, vtable_entry_type
,
8073 /* Add the initializer to the vtable. */
8074 *vid
->last_init
= build_tree_list (NULL_TREE
, vcall_offset
);
8075 vid
->last_init
= &TREE_CHAIN (*vid
->last_init
);
8079 /* Return vtbl initializers for the RTTI entries corresponding to the
8080 BINFO's vtable. The RTTI entries should indicate the object given
8081 by VID->rtti_binfo. */
8084 build_rtti_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
8092 t
= BINFO_TYPE (vid
->rtti_binfo
);
8094 /* To find the complete object, we will first convert to our most
8095 primary base, and then add the offset in the vtbl to that value. */
8097 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b
))
8098 && !BINFO_LOST_PRIMARY_P (b
))
8102 primary_base
= get_primary_binfo (b
);
8103 gcc_assert (BINFO_PRIMARY_P (primary_base
)
8104 && BINFO_INHERITANCE_CHAIN (primary_base
) == b
);
8107 offset
= size_diffop_loc (input_location
,
8108 BINFO_OFFSET (vid
->rtti_binfo
), BINFO_OFFSET (b
));
8110 /* The second entry is the address of the typeinfo object. */
8112 decl
= build_address (get_tinfo_decl (t
));
8114 decl
= integer_zero_node
;
8116 /* Convert the declaration to a type that can be stored in the
8118 init
= build_nop (vfunc_ptr_type_node
, decl
);
8119 *vid
->last_init
= build_tree_list (NULL_TREE
, init
);
8120 vid
->last_init
= &TREE_CHAIN (*vid
->last_init
);
8122 /* Add the offset-to-top entry. It comes earlier in the vtable than
8123 the typeinfo entry. Convert the offset to look like a
8124 function pointer, so that we can put it in the vtable. */
8125 init
= build_nop (vfunc_ptr_type_node
, offset
);
8126 *vid
->last_init
= build_tree_list (NULL_TREE
, init
);
8127 vid
->last_init
= &TREE_CHAIN (*vid
->last_init
);
8130 /* Fold a OBJ_TYPE_REF expression to the address of a function.
8131 KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). */
8134 cp_fold_obj_type_ref (tree ref
, tree known_type
)
8136 HOST_WIDE_INT index
= tree_low_cst (OBJ_TYPE_REF_TOKEN (ref
), 1);
8137 HOST_WIDE_INT i
= 0;
8138 tree v
= BINFO_VIRTUALS (TYPE_BINFO (known_type
));
8143 i
+= (TARGET_VTABLE_USES_DESCRIPTORS
8144 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
8150 #ifdef ENABLE_CHECKING
8151 gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref
),
8152 DECL_VINDEX (fndecl
)));
8155 cgraph_node (fndecl
)->local
.vtable_method
= true;
8157 return build_address (fndecl
);
8160 #include "gt-cp-class.h"