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, 2011
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"
38 #include "tree-dump.h"
39 #include "splay-tree.h"
40 #include "pointer-set.h"
42 /* The number of nested classes being processed. If we are not in the
43 scope of any class, this is zero. */
45 int current_class_depth;
47 /* In order to deal with nested classes, we keep a stack of classes.
48 The topmost entry is the innermost class, and is the entry at index
49 CURRENT_CLASS_DEPTH */
51 typedef struct class_stack_node {
52 /* The name of the class. */
55 /* The _TYPE node for the class. */
58 /* The access specifier pending for new declarations in the scope of
62 /* If were defining TYPE, the names used in this class. */
63 splay_tree names_used;
65 /* Nonzero if this class is no longer open, because of a call to
68 }* class_stack_node_t;
70 typedef struct vtbl_init_data_s
72 /* The base for which we're building initializers. */
74 /* The type of the most-derived type. */
76 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
77 unless ctor_vtbl_p is true. */
79 /* The negative-index vtable initializers built up so far. These
80 are in order from least negative index to most negative index. */
81 VEC(constructor_elt,gc) *inits;
82 /* The binfo for the virtual base for which we're building
83 vcall offset initializers. */
85 /* The functions in vbase for which we have already provided vcall
88 /* The vtable index of the next vcall or vbase offset. */
90 /* Nonzero if we are building the initializer for the primary
93 /* Nonzero if we are building the initializer for a construction
96 /* True when adding vcall offset entries to the vtable. False when
97 merely computing the indices. */
98 bool generate_vcall_entries;
101 /* The type of a function passed to walk_subobject_offsets. */
102 typedef int (*subobject_offset_fn) (tree, tree, splay_tree);
104 /* The stack itself. This is a dynamically resized array. The
105 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
106 static int current_class_stack_size;
107 static class_stack_node_t current_class_stack;
109 /* The size of the largest empty class seen in this translation unit. */
110 static GTY (()) tree sizeof_biggest_empty_class;
112 /* An array of all local classes present in this translation unit, in
113 declaration order. */
114 VEC(tree,gc) *local_classes;
116 static tree get_vfield_name (tree);
117 static void finish_struct_anon (tree);
118 static tree get_vtable_name (tree);
119 static tree get_basefndecls (tree, tree);
120 static int build_primary_vtable (tree, tree);
121 static int build_secondary_vtable (tree);
122 static void finish_vtbls (tree);
123 static void modify_vtable_entry (tree, tree, tree, tree, tree *);
124 static void finish_struct_bits (tree);
125 static int alter_access (tree, tree, tree);
126 static void handle_using_decl (tree, tree);
127 static tree dfs_modify_vtables (tree, void *);
128 static tree modify_all_vtables (tree, tree);
129 static void determine_primary_bases (tree);
130 static void finish_struct_methods (tree);
131 static void maybe_warn_about_overly_private_class (tree);
132 static int method_name_cmp (const void *, const void *);
133 static int resort_method_name_cmp (const void *, const void *);
134 static void add_implicitly_declared_members (tree, int, int);
135 static tree fixed_type_or_null (tree, int *, int *);
136 static tree build_simple_base_path (tree expr, tree binfo);
137 static tree build_vtbl_ref_1 (tree, tree);
138 static void build_vtbl_initializer (tree, tree, tree, tree, int *,
139 VEC(constructor_elt,gc) **);
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, VEC(constructor_elt,gc) *);
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 VEC(constructor_elt,gc) **);
183 static void dfs_accumulate_vtbl_inits (tree, tree, tree, tree, tree,
184 VEC(constructor_elt,gc) **);
185 static void build_rtti_vtbl_entries (tree, vtbl_init_data *);
186 static void build_vcall_and_vbase_vtbl_entries (tree, vtbl_init_data *);
187 static void clone_constructors_and_destructors (tree);
188 static tree build_clone (tree, tree);
189 static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned);
190 static void build_ctor_vtbl_group (tree, tree);
191 static void build_vtt (tree);
192 static tree binfo_ctor_vtable (tree);
193 static void build_vtt_inits (tree, tree, VEC(constructor_elt,gc) **, tree *);
194 static tree dfs_build_secondary_vptr_vtt_inits (tree, void *);
195 static tree dfs_fixup_binfo_vtbls (tree, void *);
196 static int record_subobject_offset (tree, tree, splay_tree);
197 static int check_subobject_offset (tree, tree, splay_tree);
198 static int walk_subobject_offsets (tree, subobject_offset_fn,
199 tree, splay_tree, tree, int);
200 static void record_subobject_offsets (tree, tree, splay_tree, bool);
201 static int layout_conflict_p (tree, tree, splay_tree, int);
202 static int splay_tree_compare_integer_csts (splay_tree_key k1,
204 static void warn_about_ambiguous_bases (tree);
205 static bool type_requires_array_cookie (tree);
206 static bool contains_empty_class_p (tree);
207 static bool base_derived_from (tree, tree);
208 static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree);
209 static tree end_of_base (tree);
210 static tree get_vcall_index (tree, tree);
212 /* Variables shared between class.c and call.c. */
214 #ifdef GATHER_STATISTICS
216 int n_vtable_entries = 0;
217 int n_vtable_searches = 0;
218 int n_vtable_elems = 0;
219 int n_convert_harshness = 0;
220 int n_compute_conversion_costs = 0;
221 int n_inner_fields_searched = 0;
224 /* Convert to or from a base subobject. EXPR is an expression of type
225 `A' or `A*', an expression of type `B' or `B*' is returned. To
226 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
227 the B base instance within A. To convert base A to derived B, CODE
228 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
229 In this latter case, A must not be a morally virtual base of B.
230 NONNULL is true if EXPR is known to be non-NULL (this is only
231 needed when EXPR is of pointer type). CV qualifiers are preserved
235 build_base_path (enum tree_code code,
240 tree v_binfo = NULL_TREE;
241 tree d_binfo = NULL_TREE;
245 tree null_test = NULL;
246 tree ptr_target_type;
248 int want_pointer = TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE;
249 bool has_empty = false;
252 if (expr == error_mark_node || binfo == error_mark_node || !binfo)
253 return error_mark_node;
255 for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
258 if (is_empty_class (BINFO_TYPE (probe)))
260 if (!v_binfo && BINFO_VIRTUAL_P (probe))
264 probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
266 probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe));
268 gcc_assert ((code == MINUS_EXPR
269 && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), probe))
270 || (code == PLUS_EXPR
271 && SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo), probe)));
273 if (binfo == d_binfo)
277 if (code == MINUS_EXPR && v_binfo)
279 error ("cannot convert from base %qT to derived type %qT via virtual base %qT",
280 BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo));
281 return error_mark_node;
285 /* This must happen before the call to save_expr. */
286 expr = cp_build_addr_expr (expr, tf_warning_or_error);
288 expr = mark_rvalue_use (expr);
290 offset = BINFO_OFFSET (binfo);
291 fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
292 target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);
293 /* TARGET_TYPE has been extracted from BINFO, and, is therefore always
294 cv-unqualified. Extract the cv-qualifiers from EXPR so that the
295 expression returned matches the input. */
296 target_type = cp_build_qualified_type
297 (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr))));
298 ptr_target_type = build_pointer_type (target_type);
300 /* Do we need to look in the vtable for the real offset? */
301 virtual_access = (v_binfo && fixed_type_p <= 0);
303 /* Don't bother with the calculations inside sizeof; they'll ICE if the
304 source type is incomplete and the pointer value doesn't matter. */
305 if (cp_unevaluated_operand != 0)
307 expr = build_nop (ptr_target_type, expr);
309 expr = build_indirect_ref (EXPR_LOCATION (expr), expr, RO_NULL);
313 /* Do we need to check for a null pointer? */
314 if (want_pointer && !nonnull)
316 /* If we know the conversion will not actually change the value
317 of EXPR, then we can avoid testing the expression for NULL.
318 We have to avoid generating a COMPONENT_REF for a base class
319 field, because other parts of the compiler know that such
320 expressions are always non-NULL. */
321 if (!virtual_access && integer_zerop (offset))
322 return build_nop (ptr_target_type, expr);
323 null_test = error_mark_node;
326 /* Protect against multiple evaluation if necessary. */
327 if (TREE_SIDE_EFFECTS (expr) && (null_test || virtual_access))
328 expr = save_expr (expr);
330 /* Now that we've saved expr, build the real null test. */
333 tree zero = cp_convert (TREE_TYPE (expr), integer_zero_node);
334 null_test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
338 /* If this is a simple base reference, express it as a COMPONENT_REF. */
339 if (code == PLUS_EXPR && !virtual_access
340 /* We don't build base fields for empty bases, and they aren't very
341 interesting to the optimizers anyway. */
344 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
345 expr = build_simple_base_path (expr, binfo);
347 expr = build_address (expr);
348 target_type = TREE_TYPE (expr);
354 /* Going via virtual base V_BINFO. We need the static offset
355 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
356 V_BINFO. That offset is an entry in D_BINFO's vtable. */
359 if (fixed_type_p < 0 && in_base_initializer)
361 /* In a base member initializer, we cannot rely on the
362 vtable being set up. We have to indirect via the
366 t = TREE_TYPE (TYPE_VFIELD (current_class_type));
367 t = build_pointer_type (t);
368 v_offset = convert (t, current_vtt_parm);
369 v_offset = cp_build_indirect_ref (v_offset, RO_NULL,
370 tf_warning_or_error);
373 v_offset = build_vfield_ref (cp_build_indirect_ref (expr, RO_NULL,
374 tf_warning_or_error),
375 TREE_TYPE (TREE_TYPE (expr)));
377 v_offset = fold_build_pointer_plus (v_offset, BINFO_VPTR_FIELD (v_binfo));
378 v_offset = build1 (NOP_EXPR,
379 build_pointer_type (ptrdiff_type_node),
381 v_offset = cp_build_indirect_ref (v_offset, RO_NULL, tf_warning_or_error);
382 TREE_CONSTANT (v_offset) = 1;
384 offset = convert_to_integer (ptrdiff_type_node,
385 size_diffop_loc (input_location, offset,
386 BINFO_OFFSET (v_binfo)));
388 if (!integer_zerop (offset))
389 v_offset = build2 (code, ptrdiff_type_node, v_offset, offset);
391 if (fixed_type_p < 0)
392 /* Negative fixed_type_p means this is a constructor or destructor;
393 virtual base layout is fixed in in-charge [cd]tors, but not in
395 offset = build3 (COND_EXPR, ptrdiff_type_node,
396 build2 (EQ_EXPR, boolean_type_node,
397 current_in_charge_parm, integer_zero_node),
399 convert_to_integer (ptrdiff_type_node,
400 BINFO_OFFSET (binfo)));
406 target_type = ptr_target_type;
408 expr = build1 (NOP_EXPR, ptr_target_type, expr);
410 if (!integer_zerop (offset))
412 offset = fold_convert (sizetype, offset);
413 if (code == MINUS_EXPR)
414 offset = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, offset);
415 expr = fold_build_pointer_plus (expr, offset);
421 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
425 expr = fold_build3_loc (input_location, COND_EXPR, target_type, null_test, expr,
426 build_zero_cst (target_type));
431 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
432 Perform a derived-to-base conversion by recursively building up a
433 sequence of COMPONENT_REFs to the appropriate base fields. */
436 build_simple_base_path (tree expr, tree binfo)
438 tree type = BINFO_TYPE (binfo);
439 tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo);
442 if (d_binfo == NULL_TREE)
446 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type);
448 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
449 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
450 an lvalue in the front end; only _DECLs and _REFs are lvalues
452 temp = unary_complex_lvalue (ADDR_EXPR, expr);
454 expr = cp_build_indirect_ref (temp, RO_NULL, tf_warning_or_error);
460 expr = build_simple_base_path (expr, d_binfo);
462 for (field = TYPE_FIELDS (BINFO_TYPE (d_binfo));
463 field; field = DECL_CHAIN (field))
464 /* Is this the base field created by build_base_field? */
465 if (TREE_CODE (field) == FIELD_DECL
466 && DECL_FIELD_IS_BASE (field)
467 && TREE_TYPE (field) == type)
469 /* We don't use build_class_member_access_expr here, as that
470 has unnecessary checks, and more importantly results in
471 recursive calls to dfs_walk_once. */
472 int type_quals = cp_type_quals (TREE_TYPE (expr));
474 expr = build3 (COMPONENT_REF,
475 cp_build_qualified_type (type, type_quals),
476 expr, field, NULL_TREE);
477 expr = fold_if_not_in_template (expr);
479 /* Mark the expression const or volatile, as appropriate.
480 Even though we've dealt with the type above, we still have
481 to mark the expression itself. */
482 if (type_quals & TYPE_QUAL_CONST)
483 TREE_READONLY (expr) = 1;
484 if (type_quals & TYPE_QUAL_VOLATILE)
485 TREE_THIS_VOLATILE (expr) = 1;
490 /* Didn't find the base field?!? */
494 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
495 type is a class type or a pointer to a class type. In the former
496 case, TYPE is also a class type; in the latter it is another
497 pointer type. If CHECK_ACCESS is true, an error message is emitted
498 if TYPE is inaccessible. If OBJECT has pointer type, the value is
499 assumed to be non-NULL. */
502 convert_to_base (tree object, tree type, bool check_access, bool nonnull,
503 tsubst_flags_t complain)
509 if (TYPE_PTR_P (TREE_TYPE (object)))
511 object_type = TREE_TYPE (TREE_TYPE (object));
512 type = TREE_TYPE (type);
515 object_type = TREE_TYPE (object);
517 access = check_access ? ba_check : ba_unique;
518 if (!(complain & tf_error))
520 binfo = lookup_base (object_type, type,
523 if (!binfo || binfo == error_mark_node)
524 return error_mark_node;
526 return build_base_path (PLUS_EXPR, object, binfo, nonnull);
529 /* EXPR is an expression with unqualified class type. BASE is a base
530 binfo of that class type. Returns EXPR, converted to the BASE
531 type. This function assumes that EXPR is the most derived class;
532 therefore virtual bases can be found at their static offsets. */
535 convert_to_base_statically (tree expr, tree base)
539 expr_type = TREE_TYPE (expr);
540 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base), expr_type))
542 /* We use fold_build2 and fold_convert below to simplify the trees
543 provided to the optimizers. It is not safe to call these functions
544 when processing a template because they do not handle C++-specific
546 gcc_assert (!processing_template_decl);
547 expr = cp_build_addr_expr (expr, tf_warning_or_error);
548 if (!integer_zerop (BINFO_OFFSET (base)))
549 expr = fold_build_pointer_plus_loc (input_location,
550 expr, BINFO_OFFSET (base));
551 expr = fold_convert (build_pointer_type (BINFO_TYPE (base)), expr);
552 expr = build_fold_indirect_ref_loc (input_location, expr);
560 build_vfield_ref (tree datum, tree type)
562 tree vfield, vcontext;
564 if (datum == error_mark_node)
565 return error_mark_node;
567 /* First, convert to the requested type. */
568 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
569 datum = convert_to_base (datum, type, /*check_access=*/false,
570 /*nonnull=*/true, tf_warning_or_error);
572 /* Second, the requested type may not be the owner of its own vptr.
573 If not, convert to the base class that owns it. We cannot use
574 convert_to_base here, because VCONTEXT may appear more than once
575 in the inheritance hierarchy of TYPE, and thus direct conversion
576 between the types may be ambiguous. Following the path back up
577 one step at a time via primary bases avoids the problem. */
578 vfield = TYPE_VFIELD (type);
579 vcontext = DECL_CONTEXT (vfield);
580 while (!same_type_ignoring_top_level_qualifiers_p (vcontext, type))
582 datum = build_simple_base_path (datum, CLASSTYPE_PRIMARY_BINFO (type));
583 type = TREE_TYPE (datum);
586 return build3 (COMPONENT_REF, TREE_TYPE (vfield), datum, vfield, NULL_TREE);
589 /* Given an object INSTANCE, return an expression which yields the
590 vtable element corresponding to INDEX. There are many special
591 cases for INSTANCE which we take care of here, mainly to avoid
592 creating extra tree nodes when we don't have to. */
595 build_vtbl_ref_1 (tree instance, tree idx)
598 tree vtbl = NULL_TREE;
600 /* Try to figure out what a reference refers to, and
601 access its virtual function table directly. */
604 tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp);
606 tree basetype = non_reference (TREE_TYPE (instance));
608 if (fixed_type && !cdtorp)
610 tree binfo = lookup_base (fixed_type, basetype,
611 ba_unique | ba_quiet, NULL);
613 vtbl = unshare_expr (BINFO_VTABLE (binfo));
617 vtbl = build_vfield_ref (instance, basetype);
619 aref = build_array_ref (input_location, vtbl, idx);
620 TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx);
626 build_vtbl_ref (tree instance, tree idx)
628 tree aref = build_vtbl_ref_1 (instance, idx);
633 /* Given a stable object pointer INSTANCE_PTR, return an expression which
634 yields a function pointer corresponding to vtable element INDEX. */
637 build_vfn_ref (tree instance_ptr, tree idx)
641 aref = build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr, RO_NULL,
642 tf_warning_or_error),
645 /* When using function descriptors, the address of the
646 vtable entry is treated as a function pointer. */
647 if (TARGET_VTABLE_USES_DESCRIPTORS)
648 aref = build1 (NOP_EXPR, TREE_TYPE (aref),
649 cp_build_addr_expr (aref, tf_warning_or_error));
651 /* Remember this as a method reference, for later devirtualization. */
652 aref = build3 (OBJ_TYPE_REF, TREE_TYPE (aref), aref, instance_ptr, idx);
657 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
658 for the given TYPE. */
661 get_vtable_name (tree type)
663 return mangle_vtbl_for_type (type);
666 /* DECL is an entity associated with TYPE, like a virtual table or an
667 implicitly generated constructor. Determine whether or not DECL
668 should have external or internal linkage at the object file
669 level. This routine does not deal with COMDAT linkage and other
670 similar complexities; it simply sets TREE_PUBLIC if it possible for
671 entities in other translation units to contain copies of DECL, in
675 set_linkage_according_to_type (tree type ATTRIBUTE_UNUSED, tree decl)
677 TREE_PUBLIC (decl) = 1;
678 determine_visibility (decl);
681 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
682 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
683 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
686 build_vtable (tree class_type, tree name, tree vtable_type)
690 decl = build_lang_decl (VAR_DECL, name, vtable_type);
691 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
692 now to avoid confusion in mangle_decl. */
693 SET_DECL_ASSEMBLER_NAME (decl, name);
694 DECL_CONTEXT (decl) = class_type;
695 DECL_ARTIFICIAL (decl) = 1;
696 TREE_STATIC (decl) = 1;
697 TREE_READONLY (decl) = 1;
698 DECL_VIRTUAL_P (decl) = 1;
699 DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
700 DECL_VTABLE_OR_VTT_P (decl) = 1;
701 /* At one time the vtable info was grabbed 2 words at a time. This
702 fails on sparc unless you have 8-byte alignment. (tiemann) */
703 DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
705 set_linkage_according_to_type (class_type, decl);
706 /* The vtable has not been defined -- yet. */
707 DECL_EXTERNAL (decl) = 1;
708 DECL_NOT_REALLY_EXTERN (decl) = 1;
710 /* Mark the VAR_DECL node representing the vtable itself as a
711 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
712 is rather important that such things be ignored because any
713 effort to actually generate DWARF for them will run into
714 trouble when/if we encounter code like:
717 struct S { virtual void member (); };
719 because the artificial declaration of the vtable itself (as
720 manufactured by the g++ front end) will say that the vtable is
721 a static member of `S' but only *after* the debug output for
722 the definition of `S' has already been output. This causes
723 grief because the DWARF entry for the definition of the vtable
724 will try to refer back to an earlier *declaration* of the
725 vtable as a static member of `S' and there won't be one. We
726 might be able to arrange to have the "vtable static member"
727 attached to the member list for `S' before the debug info for
728 `S' get written (which would solve the problem) but that would
729 require more intrusive changes to the g++ front end. */
730 DECL_IGNORED_P (decl) = 1;
735 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
736 or even complete. If this does not exist, create it. If COMPLETE is
737 nonzero, then complete the definition of it -- that will render it
738 impossible to actually build the vtable, but is useful to get at those
739 which are known to exist in the runtime. */
742 get_vtable_decl (tree type, int complete)
746 if (CLASSTYPE_VTABLES (type))
747 return CLASSTYPE_VTABLES (type);
749 decl = build_vtable (type, get_vtable_name (type), vtbl_type_node);
750 CLASSTYPE_VTABLES (type) = decl;
754 DECL_EXTERNAL (decl) = 1;
755 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
761 /* Build the primary virtual function table for TYPE. If BINFO is
762 non-NULL, build the vtable starting with the initial approximation
763 that it is the same as the one which is the head of the association
764 list. Returns a nonzero value if a new vtable is actually
768 build_primary_vtable (tree binfo, tree type)
773 decl = get_vtable_decl (type, /*complete=*/0);
777 if (BINFO_NEW_VTABLE_MARKED (binfo))
778 /* We have already created a vtable for this base, so there's
779 no need to do it again. */
782 virtuals = copy_list (BINFO_VIRTUALS (binfo));
783 TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo));
784 DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
785 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
789 gcc_assert (TREE_TYPE (decl) == vtbl_type_node);
790 virtuals = NULL_TREE;
793 #ifdef GATHER_STATISTICS
795 n_vtable_elems += list_length (virtuals);
798 /* Initialize the association list for this type, based
799 on our first approximation. */
800 BINFO_VTABLE (TYPE_BINFO (type)) = decl;
801 BINFO_VIRTUALS (TYPE_BINFO (type)) = virtuals;
802 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
806 /* Give BINFO a new virtual function table which is initialized
807 with a skeleton-copy of its original initialization. The only
808 entry that changes is the `delta' entry, so we can really
809 share a lot of structure.
811 FOR_TYPE is the most derived type which caused this table to
814 Returns nonzero if we haven't met BINFO before.
816 The order in which vtables are built (by calling this function) for
817 an object must remain the same, otherwise a binary incompatibility
821 build_secondary_vtable (tree binfo)
823 if (BINFO_NEW_VTABLE_MARKED (binfo))
824 /* We already created a vtable for this base. There's no need to
828 /* Remember that we've created a vtable for this BINFO, so that we
829 don't try to do so again. */
830 SET_BINFO_NEW_VTABLE_MARKED (binfo);
832 /* Make fresh virtual list, so we can smash it later. */
833 BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
835 /* Secondary vtables are laid out as part of the same structure as
836 the primary vtable. */
837 BINFO_VTABLE (binfo) = NULL_TREE;
841 /* Create a new vtable for BINFO which is the hierarchy dominated by
842 T. Return nonzero if we actually created a new vtable. */
845 make_new_vtable (tree t, tree binfo)
847 if (binfo == TYPE_BINFO (t))
848 /* In this case, it is *type*'s vtable we are modifying. We start
849 with the approximation that its vtable is that of the
850 immediate base class. */
851 return build_primary_vtable (binfo, t);
853 /* This is our very own copy of `basetype' to play with. Later,
854 we will fill in all the virtual functions that override the
855 virtual functions in these base classes which are not defined
856 by the current type. */
857 return build_secondary_vtable (binfo);
860 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
861 (which is in the hierarchy dominated by T) list FNDECL as its
862 BV_FN. DELTA is the required constant adjustment from the `this'
863 pointer where the vtable entry appears to the `this' required when
864 the function is actually called. */
867 modify_vtable_entry (tree t,
877 if (fndecl != BV_FN (v)
878 || !tree_int_cst_equal (delta, BV_DELTA (v)))
880 /* We need a new vtable for BINFO. */
881 if (make_new_vtable (t, binfo))
883 /* If we really did make a new vtable, we also made a copy
884 of the BINFO_VIRTUALS list. Now, we have to find the
885 corresponding entry in that list. */
886 *virtuals = BINFO_VIRTUALS (binfo);
887 while (BV_FN (*virtuals) != BV_FN (v))
888 *virtuals = TREE_CHAIN (*virtuals);
892 BV_DELTA (v) = delta;
893 BV_VCALL_INDEX (v) = NULL_TREE;
899 /* Add method METHOD to class TYPE. If USING_DECL is non-null, it is
900 the USING_DECL naming METHOD. Returns true if the method could be
901 added to the method vec. */
904 add_method (tree type, tree method, tree using_decl)
908 bool template_conv_p = false;
910 VEC(tree,gc) *method_vec;
912 bool insert_p = false;
916 if (method == error_mark_node)
919 complete_p = COMPLETE_TYPE_P (type);
920 conv_p = DECL_CONV_FN_P (method);
922 template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL
923 && DECL_TEMPLATE_CONV_FN_P (method));
925 method_vec = CLASSTYPE_METHOD_VEC (type);
928 /* Make a new method vector. We start with 8 entries. We must
929 allocate at least two (for constructors and destructors), and
930 we're going to end up with an assignment operator at some
932 method_vec = VEC_alloc (tree, gc, 8);
933 /* Create slots for constructors and destructors. */
934 VEC_quick_push (tree, method_vec, NULL_TREE);
935 VEC_quick_push (tree, method_vec, NULL_TREE);
936 CLASSTYPE_METHOD_VEC (type) = method_vec;
939 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
940 grok_special_member_properties (method);
942 /* Constructors and destructors go in special slots. */
943 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method))
944 slot = CLASSTYPE_CONSTRUCTOR_SLOT;
945 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
947 slot = CLASSTYPE_DESTRUCTOR_SLOT;
949 if (TYPE_FOR_JAVA (type))
951 if (!DECL_ARTIFICIAL (method))
952 error ("Java class %qT cannot have a destructor", type);
953 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
954 error ("Java class %qT cannot have an implicit non-trivial "
964 /* See if we already have an entry with this name. */
965 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
966 VEC_iterate (tree, method_vec, slot, m);
972 if (TREE_CODE (m) == TEMPLATE_DECL
973 && DECL_TEMPLATE_CONV_FN_P (m))
977 if (conv_p && !DECL_CONV_FN_P (m))
979 if (DECL_NAME (m) == DECL_NAME (method))
985 && !DECL_CONV_FN_P (m)
986 && DECL_NAME (m) > DECL_NAME (method))
990 current_fns = insert_p ? NULL_TREE : VEC_index (tree, method_vec, slot);
992 /* Check to see if we've already got this method. */
993 for (fns = current_fns; fns; fns = OVL_NEXT (fns))
995 tree fn = OVL_CURRENT (fns);
1001 if (TREE_CODE (fn) != TREE_CODE (method))
1004 /* [over.load] Member function declarations with the
1005 same name and the same parameter types cannot be
1006 overloaded if any of them is a static member
1007 function declaration.
1009 [namespace.udecl] When a using-declaration brings names
1010 from a base class into a derived class scope, member
1011 functions in the derived class override and/or hide member
1012 functions with the same name and parameter types in a base
1013 class (rather than conflicting). */
1014 fn_type = TREE_TYPE (fn);
1015 method_type = TREE_TYPE (method);
1016 parms1 = TYPE_ARG_TYPES (fn_type);
1017 parms2 = TYPE_ARG_TYPES (method_type);
1019 /* Compare the quals on the 'this' parm. Don't compare
1020 the whole types, as used functions are treated as
1021 coming from the using class in overload resolution. */
1022 if (! DECL_STATIC_FUNCTION_P (fn)
1023 && ! DECL_STATIC_FUNCTION_P (method)
1024 && TREE_TYPE (TREE_VALUE (parms1)) != error_mark_node
1025 && TREE_TYPE (TREE_VALUE (parms2)) != error_mark_node
1026 && (cp_type_quals (TREE_TYPE (TREE_VALUE (parms1)))
1027 != cp_type_quals (TREE_TYPE (TREE_VALUE (parms2)))))
1030 /* For templates, the return type and template parameters
1031 must be identical. */
1032 if (TREE_CODE (fn) == TEMPLATE_DECL
1033 && (!same_type_p (TREE_TYPE (fn_type),
1034 TREE_TYPE (method_type))
1035 || !comp_template_parms (DECL_TEMPLATE_PARMS (fn),
1036 DECL_TEMPLATE_PARMS (method))))
1039 if (! DECL_STATIC_FUNCTION_P (fn))
1040 parms1 = TREE_CHAIN (parms1);
1041 if (! DECL_STATIC_FUNCTION_P (method))
1042 parms2 = TREE_CHAIN (parms2);
1044 if (compparms (parms1, parms2)
1045 && (!DECL_CONV_FN_P (fn)
1046 || same_type_p (TREE_TYPE (fn_type),
1047 TREE_TYPE (method_type))))
1051 if (DECL_CONTEXT (fn) == type)
1052 /* Defer to the local function. */
1054 if (DECL_CONTEXT (fn) == DECL_CONTEXT (method))
1055 error ("repeated using declaration %q+D", using_decl);
1057 error ("using declaration %q+D conflicts with a previous using declaration",
1062 error ("%q+#D cannot be overloaded", method);
1063 error ("with %q+#D", fn);
1066 /* We don't call duplicate_decls here to merge the
1067 declarations because that will confuse things if the
1068 methods have inline definitions. In particular, we
1069 will crash while processing the definitions. */
1074 /* A class should never have more than one destructor. */
1075 if (current_fns && DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
1078 /* Add the new binding. */
1079 overload = build_overload (method, current_fns);
1082 TYPE_HAS_CONVERSION (type) = 1;
1083 else if (slot >= CLASSTYPE_FIRST_CONVERSION_SLOT && !complete_p)
1084 push_class_level_binding (DECL_NAME (method), overload);
1090 /* We only expect to add few methods in the COMPLETE_P case, so
1091 just make room for one more method in that case. */
1093 reallocated = VEC_reserve_exact (tree, gc, method_vec, 1);
1095 reallocated = VEC_reserve (tree, gc, method_vec, 1);
1097 CLASSTYPE_METHOD_VEC (type) = method_vec;
1098 if (slot == VEC_length (tree, method_vec))
1099 VEC_quick_push (tree, method_vec, overload);
1101 VEC_quick_insert (tree, method_vec, slot, overload);
1104 /* Replace the current slot. */
1105 VEC_replace (tree, method_vec, slot, overload);
1109 /* Subroutines of finish_struct. */
1111 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1112 legit, otherwise return 0. */
1115 alter_access (tree t, tree fdecl, tree access)
1119 if (!DECL_LANG_SPECIFIC (fdecl))
1120 retrofit_lang_decl (fdecl);
1122 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl));
1124 elem = purpose_member (t, DECL_ACCESS (fdecl));
1127 if (TREE_VALUE (elem) != access)
1129 if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1130 error ("conflicting access specifications for method"
1131 " %q+D, ignored", TREE_TYPE (fdecl));
1133 error ("conflicting access specifications for field %qE, ignored",
1138 /* They're changing the access to the same thing they changed
1139 it to before. That's OK. */
1145 perform_or_defer_access_check (TYPE_BINFO (t), fdecl, fdecl);
1146 DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1152 /* Process the USING_DECL, which is a member of T. */
1155 handle_using_decl (tree using_decl, tree t)
1157 tree decl = USING_DECL_DECLS (using_decl);
1158 tree name = DECL_NAME (using_decl);
1160 = TREE_PRIVATE (using_decl) ? access_private_node
1161 : TREE_PROTECTED (using_decl) ? access_protected_node
1162 : access_public_node;
1163 tree flist = NULL_TREE;
1166 gcc_assert (!processing_template_decl && decl);
1168 old_value = lookup_member (t, name, /*protect=*/0, /*want_type=*/false);
1171 if (is_overloaded_fn (old_value))
1172 old_value = OVL_CURRENT (old_value);
1174 if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t)
1177 old_value = NULL_TREE;
1180 cp_emit_debug_info_for_using (decl, USING_DECL_SCOPE (using_decl));
1182 if (is_overloaded_fn (decl))
1187 else if (is_overloaded_fn (old_value))
1190 /* It's OK to use functions from a base when there are functions with
1191 the same name already present in the current class. */;
1194 error ("%q+D invalid in %q#T", using_decl, t);
1195 error (" because of local method %q+#D with same name",
1196 OVL_CURRENT (old_value));
1200 else if (!DECL_ARTIFICIAL (old_value))
1202 error ("%q+D invalid in %q#T", using_decl, t);
1203 error (" because of local member %q+#D with same name", old_value);
1207 /* Make type T see field decl FDECL with access ACCESS. */
1209 for (; flist; flist = OVL_NEXT (flist))
1211 add_method (t, OVL_CURRENT (flist), using_decl);
1212 alter_access (t, OVL_CURRENT (flist), access);
1215 alter_access (t, decl, access);
1218 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1219 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1220 properties of the bases. */
1223 check_bases (tree t,
1224 int* cant_have_const_ctor_p,
1225 int* no_const_asn_ref_p)
1228 int seen_non_virtual_nearly_empty_base_p;
1231 tree field = NULL_TREE;
1233 seen_non_virtual_nearly_empty_base_p = 0;
1235 if (!CLASSTYPE_NON_STD_LAYOUT (t))
1236 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
1237 if (TREE_CODE (field) == FIELD_DECL)
1240 for (binfo = TYPE_BINFO (t), i = 0;
1241 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1243 tree basetype = TREE_TYPE (base_binfo);
1245 gcc_assert (COMPLETE_TYPE_P (basetype));
1247 if (CLASSTYPE_FINAL (basetype))
1248 error ("cannot derive from %<final%> base %qT in derived type %qT",
1251 /* If any base class is non-literal, so is the derived class. */
1252 if (!CLASSTYPE_LITERAL_P (basetype))
1253 CLASSTYPE_LITERAL_P (t) = false;
1255 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1256 here because the case of virtual functions but non-virtual
1257 dtor is handled in finish_struct_1. */
1258 if (!TYPE_POLYMORPHIC_P (basetype))
1259 warning (OPT_Weffc__,
1260 "base class %q#T has a non-virtual destructor", basetype);
1262 /* If the base class doesn't have copy constructors or
1263 assignment operators that take const references, then the
1264 derived class cannot have such a member automatically
1266 if (TYPE_HAS_COPY_CTOR (basetype)
1267 && ! TYPE_HAS_CONST_COPY_CTOR (basetype))
1268 *cant_have_const_ctor_p = 1;
1269 if (TYPE_HAS_COPY_ASSIGN (basetype)
1270 && !TYPE_HAS_CONST_COPY_ASSIGN (basetype))
1271 *no_const_asn_ref_p = 1;
1273 if (BINFO_VIRTUAL_P (base_binfo))
1274 /* A virtual base does not effect nearly emptiness. */
1276 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1278 if (seen_non_virtual_nearly_empty_base_p)
1279 /* And if there is more than one nearly empty base, then the
1280 derived class is not nearly empty either. */
1281 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1283 /* Remember we've seen one. */
1284 seen_non_virtual_nearly_empty_base_p = 1;
1286 else if (!is_empty_class (basetype))
1287 /* If the base class is not empty or nearly empty, then this
1288 class cannot be nearly empty. */
1289 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1291 /* A lot of properties from the bases also apply to the derived
1293 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1294 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1295 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype);
1296 TYPE_HAS_COMPLEX_COPY_ASSIGN (t)
1297 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (basetype)
1298 || !TYPE_HAS_COPY_ASSIGN (basetype));
1299 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= (TYPE_HAS_COMPLEX_COPY_CTOR (basetype)
1300 || !TYPE_HAS_COPY_CTOR (basetype));
1301 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
1302 |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (basetype);
1303 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_HAS_COMPLEX_MOVE_CTOR (basetype);
1304 TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1305 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)
1306 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype);
1307 TYPE_HAS_COMPLEX_DFLT (t) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype)
1308 || TYPE_HAS_COMPLEX_DFLT (basetype));
1310 /* A standard-layout class is a class that:
1312 * has no non-standard-layout base classes, */
1313 CLASSTYPE_NON_STD_LAYOUT (t) |= CLASSTYPE_NON_STD_LAYOUT (basetype);
1314 if (!CLASSTYPE_NON_STD_LAYOUT (t))
1317 /* ...has no base classes of the same type as the first non-static
1319 if (field && DECL_CONTEXT (field) == t
1320 && (same_type_ignoring_top_level_qualifiers_p
1321 (TREE_TYPE (field), basetype)))
1322 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
1324 /* ...either has no non-static data members in the most-derived
1325 class and at most one base class with non-static data
1326 members, or has no base classes with non-static data
1328 for (basefield = TYPE_FIELDS (basetype); basefield;
1329 basefield = DECL_CHAIN (basefield))
1330 if (TREE_CODE (basefield) == FIELD_DECL)
1333 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
1342 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1343 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1344 that have had a nearly-empty virtual primary base stolen by some
1345 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1349 determine_primary_bases (tree t)
1352 tree primary = NULL_TREE;
1353 tree type_binfo = TYPE_BINFO (t);
1356 /* Determine the primary bases of our bases. */
1357 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1358 base_binfo = TREE_CHAIN (base_binfo))
1360 tree primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo));
1362 /* See if we're the non-virtual primary of our inheritance
1364 if (!BINFO_VIRTUAL_P (base_binfo))
1366 tree parent = BINFO_INHERITANCE_CHAIN (base_binfo);
1367 tree parent_primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent));
1370 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
1371 BINFO_TYPE (parent_primary)))
1372 /* We are the primary binfo. */
1373 BINFO_PRIMARY_P (base_binfo) = 1;
1375 /* Determine if we have a virtual primary base, and mark it so.
1377 if (primary && BINFO_VIRTUAL_P (primary))
1379 tree this_primary = copied_binfo (primary, base_binfo);
1381 if (BINFO_PRIMARY_P (this_primary))
1382 /* Someone already claimed this base. */
1383 BINFO_LOST_PRIMARY_P (base_binfo) = 1;
1388 BINFO_PRIMARY_P (this_primary) = 1;
1389 BINFO_INHERITANCE_CHAIN (this_primary) = base_binfo;
1391 /* A virtual binfo might have been copied from within
1392 another hierarchy. As we're about to use it as a
1393 primary base, make sure the offsets match. */
1394 delta = size_diffop_loc (input_location,
1396 BINFO_OFFSET (base_binfo)),
1398 BINFO_OFFSET (this_primary)));
1400 propagate_binfo_offsets (this_primary, delta);
1405 /* First look for a dynamic direct non-virtual base. */
1406 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, base_binfo); i++)
1408 tree basetype = BINFO_TYPE (base_binfo);
1410 if (TYPE_CONTAINS_VPTR_P (basetype) && !BINFO_VIRTUAL_P (base_binfo))
1412 primary = base_binfo;
1417 /* A "nearly-empty" virtual base class can be the primary base
1418 class, if no non-virtual polymorphic base can be found. Look for
1419 a nearly-empty virtual dynamic base that is not already a primary
1420 base of something in the hierarchy. If there is no such base,
1421 just pick the first nearly-empty virtual base. */
1423 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1424 base_binfo = TREE_CHAIN (base_binfo))
1425 if (BINFO_VIRTUAL_P (base_binfo)
1426 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo)))
1428 if (!BINFO_PRIMARY_P (base_binfo))
1430 /* Found one that is not primary. */
1431 primary = base_binfo;
1435 /* Remember the first candidate. */
1436 primary = base_binfo;
1440 /* If we've got a primary base, use it. */
1443 tree basetype = BINFO_TYPE (primary);
1445 CLASSTYPE_PRIMARY_BINFO (t) = primary;
1446 if (BINFO_PRIMARY_P (primary))
1447 /* We are stealing a primary base. */
1448 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary)) = 1;
1449 BINFO_PRIMARY_P (primary) = 1;
1450 if (BINFO_VIRTUAL_P (primary))
1454 BINFO_INHERITANCE_CHAIN (primary) = type_binfo;
1455 /* A virtual binfo might have been copied from within
1456 another hierarchy. As we're about to use it as a primary
1457 base, make sure the offsets match. */
1458 delta = size_diffop_loc (input_location, ssize_int (0),
1459 convert (ssizetype, BINFO_OFFSET (primary)));
1461 propagate_binfo_offsets (primary, delta);
1464 primary = TYPE_BINFO (basetype);
1466 TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1467 BINFO_VTABLE (type_binfo) = BINFO_VTABLE (primary);
1468 BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary);
1472 /* Update the variant types of T. */
1475 fixup_type_variants (tree t)
1482 for (variants = TYPE_NEXT_VARIANT (t);
1484 variants = TYPE_NEXT_VARIANT (variants))
1486 /* These fields are in the _TYPE part of the node, not in
1487 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1488 TYPE_HAS_USER_CONSTRUCTOR (variants) = TYPE_HAS_USER_CONSTRUCTOR (t);
1489 TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1490 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants)
1491 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
1493 TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
1495 TYPE_BINFO (variants) = TYPE_BINFO (t);
1497 /* Copy whatever these are holding today. */
1498 TYPE_VFIELD (variants) = TYPE_VFIELD (t);
1499 TYPE_METHODS (variants) = TYPE_METHODS (t);
1500 TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1504 /* Early variant fixups: we apply attributes at the beginning of the class
1505 definition, and we need to fix up any variants that have already been
1506 made via elaborated-type-specifier so that check_qualified_type works. */
1509 fixup_attribute_variants (tree t)
1516 for (variants = TYPE_NEXT_VARIANT (t);
1518 variants = TYPE_NEXT_VARIANT (variants))
1520 /* These are the two fields that check_qualified_type looks at and
1521 are affected by attributes. */
1522 TYPE_ATTRIBUTES (variants) = TYPE_ATTRIBUTES (t);
1523 TYPE_ALIGN (variants) = TYPE_ALIGN (t);
1527 /* Set memoizing fields and bits of T (and its variants) for later
1531 finish_struct_bits (tree t)
1533 /* Fix up variants (if any). */
1534 fixup_type_variants (t);
1536 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t))
1537 /* For a class w/o baseclasses, 'finish_struct' has set
1538 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1539 Similarly for a class whose base classes do not have vtables.
1540 When neither of these is true, we might have removed abstract
1541 virtuals (by providing a definition), added some (by declaring
1542 new ones), or redeclared ones from a base class. We need to
1543 recalculate what's really an abstract virtual at this point (by
1544 looking in the vtables). */
1545 get_pure_virtuals (t);
1547 /* If this type has a copy constructor or a destructor, force its
1548 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1549 nonzero. This will cause it to be passed by invisible reference
1550 and prevent it from being returned in a register. */
1551 if (type_has_nontrivial_copy_init (t)
1552 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
1555 DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1556 for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1558 SET_TYPE_MODE (variants, BLKmode);
1559 TREE_ADDRESSABLE (variants) = 1;
1564 /* Issue warnings about T having private constructors, but no friends,
1567 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1568 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1569 non-private static member functions. */
1572 maybe_warn_about_overly_private_class (tree t)
1574 int has_member_fn = 0;
1575 int has_nonprivate_method = 0;
1578 if (!warn_ctor_dtor_privacy
1579 /* If the class has friends, those entities might create and
1580 access instances, so we should not warn. */
1581 || (CLASSTYPE_FRIEND_CLASSES (t)
1582 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
1583 /* We will have warned when the template was declared; there's
1584 no need to warn on every instantiation. */
1585 || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1586 /* There's no reason to even consider warning about this
1590 /* We only issue one warning, if more than one applies, because
1591 otherwise, on code like:
1594 // Oops - forgot `public:'
1600 we warn several times about essentially the same problem. */
1602 /* Check to see if all (non-constructor, non-destructor) member
1603 functions are private. (Since there are no friends or
1604 non-private statics, we can't ever call any of the private member
1606 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
1607 /* We're not interested in compiler-generated methods; they don't
1608 provide any way to call private members. */
1609 if (!DECL_ARTIFICIAL (fn))
1611 if (!TREE_PRIVATE (fn))
1613 if (DECL_STATIC_FUNCTION_P (fn))
1614 /* A non-private static member function is just like a
1615 friend; it can create and invoke private member
1616 functions, and be accessed without a class
1620 has_nonprivate_method = 1;
1621 /* Keep searching for a static member function. */
1623 else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
1627 if (!has_nonprivate_method && has_member_fn)
1629 /* There are no non-private methods, and there's at least one
1630 private member function that isn't a constructor or
1631 destructor. (If all the private members are
1632 constructors/destructors we want to use the code below that
1633 issues error messages specifically referring to
1634 constructors/destructors.) */
1636 tree binfo = TYPE_BINFO (t);
1638 for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++)
1639 if (BINFO_BASE_ACCESS (binfo, i) != access_private_node)
1641 has_nonprivate_method = 1;
1644 if (!has_nonprivate_method)
1646 warning (OPT_Wctor_dtor_privacy,
1647 "all member functions in class %qT are private", t);
1652 /* Even if some of the member functions are non-private, the class
1653 won't be useful for much if all the constructors or destructors
1654 are private: such an object can never be created or destroyed. */
1655 fn = CLASSTYPE_DESTRUCTORS (t);
1656 if (fn && TREE_PRIVATE (fn))
1658 warning (OPT_Wctor_dtor_privacy,
1659 "%q#T only defines a private destructor and has no friends",
1664 /* Warn about classes that have private constructors and no friends. */
1665 if (TYPE_HAS_USER_CONSTRUCTOR (t)
1666 /* Implicitly generated constructors are always public. */
1667 && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t)
1668 || !CLASSTYPE_LAZY_COPY_CTOR (t)))
1670 int nonprivate_ctor = 0;
1672 /* If a non-template class does not define a copy
1673 constructor, one is defined for it, enabling it to avoid
1674 this warning. For a template class, this does not
1675 happen, and so we would normally get a warning on:
1677 template <class T> class C { private: C(); };
1679 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All
1680 complete non-template or fully instantiated classes have this
1682 if (!TYPE_HAS_COPY_CTOR (t))
1683 nonprivate_ctor = 1;
1685 for (fn = CLASSTYPE_CONSTRUCTORS (t); fn; fn = OVL_NEXT (fn))
1687 tree ctor = OVL_CURRENT (fn);
1688 /* Ideally, we wouldn't count copy constructors (or, in
1689 fact, any constructor that takes an argument of the
1690 class type as a parameter) because such things cannot
1691 be used to construct an instance of the class unless
1692 you already have one. But, for now at least, we're
1694 if (! TREE_PRIVATE (ctor))
1696 nonprivate_ctor = 1;
1701 if (nonprivate_ctor == 0)
1703 warning (OPT_Wctor_dtor_privacy,
1704 "%q#T only defines private constructors and has no friends",
1712 gt_pointer_operator new_value;
1716 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1719 method_name_cmp (const void* m1_p, const void* m2_p)
1721 const tree *const m1 = (const tree *) m1_p;
1722 const tree *const m2 = (const tree *) m2_p;
1724 if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1726 if (*m1 == NULL_TREE)
1728 if (*m2 == NULL_TREE)
1730 if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
1735 /* This routine compares two fields like method_name_cmp but using the
1736 pointer operator in resort_field_decl_data. */
1739 resort_method_name_cmp (const void* m1_p, const void* m2_p)
1741 const tree *const m1 = (const tree *) m1_p;
1742 const tree *const m2 = (const tree *) m2_p;
1743 if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1745 if (*m1 == NULL_TREE)
1747 if (*m2 == NULL_TREE)
1750 tree d1 = DECL_NAME (OVL_CURRENT (*m1));
1751 tree d2 = DECL_NAME (OVL_CURRENT (*m2));
1752 resort_data.new_value (&d1, resort_data.cookie);
1753 resort_data.new_value (&d2, resort_data.cookie);
1760 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1763 resort_type_method_vec (void* obj,
1764 void* orig_obj ATTRIBUTE_UNUSED ,
1765 gt_pointer_operator new_value,
1768 VEC(tree,gc) *method_vec = (VEC(tree,gc) *) obj;
1769 int len = VEC_length (tree, method_vec);
1773 /* The type conversion ops have to live at the front of the vec, so we
1775 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1776 VEC_iterate (tree, method_vec, slot, fn);
1778 if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1783 resort_data.new_value = new_value;
1784 resort_data.cookie = cookie;
1785 qsort (VEC_address (tree, method_vec) + slot, len - slot, sizeof (tree),
1786 resort_method_name_cmp);
1790 /* Warn about duplicate methods in fn_fields.
1792 Sort methods that are not special (i.e., constructors, destructors,
1793 and type conversion operators) so that we can find them faster in
1797 finish_struct_methods (tree t)
1800 VEC(tree,gc) *method_vec;
1803 method_vec = CLASSTYPE_METHOD_VEC (t);
1807 len = VEC_length (tree, method_vec);
1809 /* Clear DECL_IN_AGGR_P for all functions. */
1810 for (fn_fields = TYPE_METHODS (t); fn_fields;
1811 fn_fields = DECL_CHAIN (fn_fields))
1812 DECL_IN_AGGR_P (fn_fields) = 0;
1814 /* Issue warnings about private constructors and such. If there are
1815 no methods, then some public defaults are generated. */
1816 maybe_warn_about_overly_private_class (t);
1818 /* The type conversion ops have to live at the front of the vec, so we
1820 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1821 VEC_iterate (tree, method_vec, slot, fn_fields);
1823 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields)))
1826 qsort (VEC_address (tree, method_vec) + slot,
1827 len-slot, sizeof (tree), method_name_cmp);
1830 /* Make BINFO's vtable have N entries, including RTTI entries,
1831 vbase and vcall offsets, etc. Set its type and call the back end
1835 layout_vtable_decl (tree binfo, int n)
1840 atype = build_array_of_n_type (vtable_entry_type, n);
1841 layout_type (atype);
1843 /* We may have to grow the vtable. */
1844 vtable = get_vtbl_decl_for_binfo (binfo);
1845 if (!same_type_p (TREE_TYPE (vtable), atype))
1847 TREE_TYPE (vtable) = atype;
1848 DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1849 layout_decl (vtable, 0);
1853 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1854 have the same signature. */
1857 same_signature_p (const_tree fndecl, const_tree base_fndecl)
1859 /* One destructor overrides another if they are the same kind of
1861 if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl)
1862 && special_function_p (base_fndecl) == special_function_p (fndecl))
1864 /* But a non-destructor never overrides a destructor, nor vice
1865 versa, nor do different kinds of destructors override
1866 one-another. For example, a complete object destructor does not
1867 override a deleting destructor. */
1868 if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl))
1871 if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl)
1872 || (DECL_CONV_FN_P (fndecl)
1873 && DECL_CONV_FN_P (base_fndecl)
1874 && same_type_p (DECL_CONV_FN_TYPE (fndecl),
1875 DECL_CONV_FN_TYPE (base_fndecl))))
1877 tree types, base_types;
1878 types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1879 base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
1880 if ((cp_type_quals (TREE_TYPE (TREE_VALUE (base_types)))
1881 == cp_type_quals (TREE_TYPE (TREE_VALUE (types))))
1882 && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
1888 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1892 base_derived_from (tree derived, tree base)
1896 for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1898 if (probe == derived)
1900 else if (BINFO_VIRTUAL_P (probe))
1901 /* If we meet a virtual base, we can't follow the inheritance
1902 any more. See if the complete type of DERIVED contains
1903 such a virtual base. */
1904 return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (derived))
1910 typedef struct find_final_overrider_data_s {
1911 /* The function for which we are trying to find a final overrider. */
1913 /* The base class in which the function was declared. */
1914 tree declaring_base;
1915 /* The candidate overriders. */
1917 /* Path to most derived. */
1918 VEC(tree,heap) *path;
1919 } find_final_overrider_data;
1921 /* Add the overrider along the current path to FFOD->CANDIDATES.
1922 Returns true if an overrider was found; false otherwise. */
1925 dfs_find_final_overrider_1 (tree binfo,
1926 find_final_overrider_data *ffod,
1931 /* If BINFO is not the most derived type, try a more derived class.
1932 A definition there will overrider a definition here. */
1936 if (dfs_find_final_overrider_1
1937 (VEC_index (tree, ffod->path, depth), ffod, depth))
1941 method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1944 tree *candidate = &ffod->candidates;
1946 /* Remove any candidates overridden by this new function. */
1949 /* If *CANDIDATE overrides METHOD, then METHOD
1950 cannot override anything else on the list. */
1951 if (base_derived_from (TREE_VALUE (*candidate), binfo))
1953 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1954 if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1955 *candidate = TREE_CHAIN (*candidate);
1957 candidate = &TREE_CHAIN (*candidate);
1960 /* Add the new function. */
1961 ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1968 /* Called from find_final_overrider via dfs_walk. */
1971 dfs_find_final_overrider_pre (tree binfo, void *data)
1973 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1975 if (binfo == ffod->declaring_base)
1976 dfs_find_final_overrider_1 (binfo, ffod, VEC_length (tree, ffod->path));
1977 VEC_safe_push (tree, heap, ffod->path, binfo);
1983 dfs_find_final_overrider_post (tree binfo ATTRIBUTE_UNUSED, void *data)
1985 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1986 VEC_pop (tree, ffod->path);
1991 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1992 FN and whose TREE_VALUE is the binfo for the base where the
1993 overriding occurs. BINFO (in the hierarchy dominated by the binfo
1994 DERIVED) is the base object in which FN is declared. */
1997 find_final_overrider (tree derived, tree binfo, tree fn)
1999 find_final_overrider_data ffod;
2001 /* Getting this right is a little tricky. This is valid:
2003 struct S { virtual void f (); };
2004 struct T { virtual void f (); };
2005 struct U : public S, public T { };
2007 even though calling `f' in `U' is ambiguous. But,
2009 struct R { virtual void f(); };
2010 struct S : virtual public R { virtual void f (); };
2011 struct T : virtual public R { virtual void f (); };
2012 struct U : public S, public T { };
2014 is not -- there's no way to decide whether to put `S::f' or
2015 `T::f' in the vtable for `R'.
2017 The solution is to look at all paths to BINFO. If we find
2018 different overriders along any two, then there is a problem. */
2019 if (DECL_THUNK_P (fn))
2020 fn = THUNK_TARGET (fn);
2022 /* Determine the depth of the hierarchy. */
2024 ffod.declaring_base = binfo;
2025 ffod.candidates = NULL_TREE;
2026 ffod.path = VEC_alloc (tree, heap, 30);
2028 dfs_walk_all (derived, dfs_find_final_overrider_pre,
2029 dfs_find_final_overrider_post, &ffod);
2031 VEC_free (tree, heap, ffod.path);
2033 /* If there was no winner, issue an error message. */
2034 if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
2035 return error_mark_node;
2037 return ffod.candidates;
2040 /* Return the index of the vcall offset for FN when TYPE is used as a
2044 get_vcall_index (tree fn, tree type)
2046 VEC(tree_pair_s,gc) *indices = CLASSTYPE_VCALL_INDICES (type);
2050 FOR_EACH_VEC_ELT (tree_pair_s, indices, ix, p)
2051 if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (p->purpose))
2052 || same_signature_p (fn, p->purpose))
2055 /* There should always be an appropriate index. */
2059 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2060 dominated by T. FN is the old function; VIRTUALS points to the
2061 corresponding position in the new BINFO_VIRTUALS list. IX is the index
2062 of that entry in the list. */
2065 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
2073 tree overrider_fn, overrider_target;
2074 tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2075 tree over_return, base_return;
2078 /* Find the nearest primary base (possibly binfo itself) which defines
2079 this function; this is the class the caller will convert to when
2080 calling FN through BINFO. */
2081 for (b = binfo; ; b = get_primary_binfo (b))
2084 if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2087 /* The nearest definition is from a lost primary. */
2088 if (BINFO_LOST_PRIMARY_P (b))
2093 /* Find the final overrider. */
2094 overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2095 if (overrider == error_mark_node)
2097 error ("no unique final overrider for %qD in %qT", target_fn, t);
2100 overrider_target = overrider_fn = TREE_PURPOSE (overrider);
2102 /* Check for adjusting covariant return types. */
2103 over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2104 base_return = TREE_TYPE (TREE_TYPE (target_fn));
2106 if (POINTER_TYPE_P (over_return)
2107 && TREE_CODE (over_return) == TREE_CODE (base_return)
2108 && CLASS_TYPE_P (TREE_TYPE (over_return))
2109 && CLASS_TYPE_P (TREE_TYPE (base_return))
2110 /* If the overrider is invalid, don't even try. */
2111 && !DECL_INVALID_OVERRIDER_P (overrider_target))
2113 /* If FN is a covariant thunk, we must figure out the adjustment
2114 to the final base FN was converting to. As OVERRIDER_TARGET might
2115 also be converting to the return type of FN, we have to
2116 combine the two conversions here. */
2117 tree fixed_offset, virtual_offset;
2119 over_return = TREE_TYPE (over_return);
2120 base_return = TREE_TYPE (base_return);
2122 if (DECL_THUNK_P (fn))
2124 gcc_assert (DECL_RESULT_THUNK_P (fn));
2125 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2126 virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2129 fixed_offset = virtual_offset = NULL_TREE;
2132 /* Find the equivalent binfo within the return type of the
2133 overriding function. We will want the vbase offset from
2135 virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset),
2137 else if (!same_type_ignoring_top_level_qualifiers_p
2138 (over_return, base_return))
2140 /* There was no existing virtual thunk (which takes
2141 precedence). So find the binfo of the base function's
2142 return type within the overriding function's return type.
2143 We cannot call lookup base here, because we're inside a
2144 dfs_walk, and will therefore clobber the BINFO_MARKED
2145 flags. Fortunately we know the covariancy is valid (it
2146 has already been checked), so we can just iterate along
2147 the binfos, which have been chained in inheritance graph
2148 order. Of course it is lame that we have to repeat the
2149 search here anyway -- we should really be caching pieces
2150 of the vtable and avoiding this repeated work. */
2151 tree thunk_binfo, base_binfo;
2153 /* Find the base binfo within the overriding function's
2154 return type. We will always find a thunk_binfo, except
2155 when the covariancy is invalid (which we will have
2156 already diagnosed). */
2157 for (base_binfo = TYPE_BINFO (base_return),
2158 thunk_binfo = TYPE_BINFO (over_return);
2160 thunk_binfo = TREE_CHAIN (thunk_binfo))
2161 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo),
2162 BINFO_TYPE (base_binfo)))
2165 /* See if virtual inheritance is involved. */
2166 for (virtual_offset = thunk_binfo;
2168 virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
2169 if (BINFO_VIRTUAL_P (virtual_offset))
2173 || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
2175 tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2179 /* We convert via virtual base. Adjust the fixed
2180 offset to be from there. */
2182 size_diffop (offset,
2184 BINFO_OFFSET (virtual_offset)));
2187 /* There was an existing fixed offset, this must be
2188 from the base just converted to, and the base the
2189 FN was thunking to. */
2190 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2192 fixed_offset = offset;
2196 if (fixed_offset || virtual_offset)
2197 /* Replace the overriding function with a covariant thunk. We
2198 will emit the overriding function in its own slot as
2200 overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0,
2201 fixed_offset, virtual_offset);
2204 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target) ||
2205 !DECL_THUNK_P (fn));
2207 /* If we need a covariant thunk, then we may need to adjust first_defn.
2208 The ABI specifies that the thunks emitted with a function are
2209 determined by which bases the function overrides, so we need to be
2210 sure that we're using a thunk for some overridden base; even if we
2211 know that the necessary this adjustment is zero, there may not be an
2212 appropriate zero-this-adjusment thunk for us to use since thunks for
2213 overriding virtual bases always use the vcall offset.
2215 Furthermore, just choosing any base that overrides this function isn't
2216 quite right, as this slot won't be used for calls through a type that
2217 puts a covariant thunk here. Calling the function through such a type
2218 will use a different slot, and that slot is the one that determines
2219 the thunk emitted for that base.
2221 So, keep looking until we find the base that we're really overriding
2222 in this slot: the nearest primary base that doesn't use a covariant
2223 thunk in this slot. */
2224 if (overrider_target != overrider_fn)
2226 if (BINFO_TYPE (b) == DECL_CONTEXT (overrider_target))
2227 /* We already know that the overrider needs a covariant thunk. */
2228 b = get_primary_binfo (b);
2229 for (; ; b = get_primary_binfo (b))
2231 tree main_binfo = TYPE_BINFO (BINFO_TYPE (b));
2232 tree bv = chain_index (ix, BINFO_VIRTUALS (main_binfo));
2233 if (!DECL_THUNK_P (TREE_VALUE (bv)))
2235 if (BINFO_LOST_PRIMARY_P (b))
2241 /* Assume that we will produce a thunk that convert all the way to
2242 the final overrider, and not to an intermediate virtual base. */
2243 virtual_base = NULL_TREE;
2245 /* See if we can convert to an intermediate virtual base first, and then
2246 use the vcall offset located there to finish the conversion. */
2247 for (; b; b = BINFO_INHERITANCE_CHAIN (b))
2249 /* If we find the final overrider, then we can stop
2251 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b),
2252 BINFO_TYPE (TREE_VALUE (overrider))))
2255 /* If we find a virtual base, and we haven't yet found the
2256 overrider, then there is a virtual base between the
2257 declaring base (first_defn) and the final overrider. */
2258 if (BINFO_VIRTUAL_P (b))
2265 /* Compute the constant adjustment to the `this' pointer. The
2266 `this' pointer, when this function is called, will point at BINFO
2267 (or one of its primary bases, which are at the same offset). */
2269 /* The `this' pointer needs to be adjusted from the declaration to
2270 the nearest virtual base. */
2271 delta = size_diffop_loc (input_location,
2272 convert (ssizetype, BINFO_OFFSET (virtual_base)),
2273 convert (ssizetype, BINFO_OFFSET (first_defn)));
2275 /* If the nearest definition is in a lost primary, we don't need an
2276 entry in our vtable. Except possibly in a constructor vtable,
2277 if we happen to get our primary back. In that case, the offset
2278 will be zero, as it will be a primary base. */
2279 delta = size_zero_node;
2281 /* The `this' pointer needs to be adjusted from pointing to
2282 BINFO to pointing at the base where the final overrider
2284 delta = size_diffop_loc (input_location,
2286 BINFO_OFFSET (TREE_VALUE (overrider))),
2287 convert (ssizetype, BINFO_OFFSET (binfo)));
2289 modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
2292 BV_VCALL_INDEX (*virtuals)
2293 = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base));
2295 BV_VCALL_INDEX (*virtuals) = NULL_TREE;
2297 BV_LOST_PRIMARY (*virtuals) = lost;
2300 /* Called from modify_all_vtables via dfs_walk. */
2303 dfs_modify_vtables (tree binfo, void* data)
2305 tree t = (tree) data;
2310 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
2311 /* A base without a vtable needs no modification, and its bases
2312 are uninteresting. */
2313 return dfs_skip_bases;
2315 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t)
2316 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
2317 /* Don't do the primary vtable, if it's new. */
2320 if (BINFO_PRIMARY_P (binfo) && !BINFO_VIRTUAL_P (binfo))
2321 /* There's no need to modify the vtable for a non-virtual primary
2322 base; we're not going to use that vtable anyhow. We do still
2323 need to do this for virtual primary bases, as they could become
2324 non-primary in a construction vtable. */
2327 make_new_vtable (t, binfo);
2329 /* Now, go through each of the virtual functions in the virtual
2330 function table for BINFO. Find the final overrider, and update
2331 the BINFO_VIRTUALS list appropriately. */
2332 for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2333 old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2335 ix++, virtuals = TREE_CHAIN (virtuals),
2336 old_virtuals = TREE_CHAIN (old_virtuals))
2337 update_vtable_entry_for_fn (t,
2339 BV_FN (old_virtuals),
2345 /* Update all of the primary and secondary vtables for T. Create new
2346 vtables as required, and initialize their RTTI information. Each
2347 of the functions in VIRTUALS is declared in T and may override a
2348 virtual function from a base class; find and modify the appropriate
2349 entries to point to the overriding functions. Returns a list, in
2350 declaration order, of the virtual functions that are declared in T,
2351 but do not appear in the primary base class vtable, and which
2352 should therefore be appended to the end of the vtable for T. */
2355 modify_all_vtables (tree t, tree virtuals)
2357 tree binfo = TYPE_BINFO (t);
2360 /* Update all of the vtables. */
2361 dfs_walk_once (binfo, dfs_modify_vtables, NULL, t);
2363 /* Add virtual functions not already in our primary vtable. These
2364 will be both those introduced by this class, and those overridden
2365 from secondary bases. It does not include virtuals merely
2366 inherited from secondary bases. */
2367 for (fnsp = &virtuals; *fnsp; )
2369 tree fn = TREE_VALUE (*fnsp);
2371 if (!value_member (fn, BINFO_VIRTUALS (binfo))
2372 || DECL_VINDEX (fn) == error_mark_node)
2374 /* We don't need to adjust the `this' pointer when
2375 calling this function. */
2376 BV_DELTA (*fnsp) = integer_zero_node;
2377 BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2379 /* This is a function not already in our vtable. Keep it. */
2380 fnsp = &TREE_CHAIN (*fnsp);
2383 /* We've already got an entry for this function. Skip it. */
2384 *fnsp = TREE_CHAIN (*fnsp);
2390 /* Get the base virtual function declarations in T that have the
2394 get_basefndecls (tree name, tree t)
2397 tree base_fndecls = NULL_TREE;
2398 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
2401 /* Find virtual functions in T with the indicated NAME. */
2402 i = lookup_fnfields_1 (t, name);
2404 for (methods = VEC_index (tree, CLASSTYPE_METHOD_VEC (t), i);
2406 methods = OVL_NEXT (methods))
2408 tree method = OVL_CURRENT (methods);
2410 if (TREE_CODE (method) == FUNCTION_DECL
2411 && DECL_VINDEX (method))
2412 base_fndecls = tree_cons (NULL_TREE, method, base_fndecls);
2416 return base_fndecls;
2418 for (i = 0; i < n_baseclasses; i++)
2420 tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t), i));
2421 base_fndecls = chainon (get_basefndecls (name, basetype),
2425 return base_fndecls;
2428 /* If this declaration supersedes the declaration of
2429 a method declared virtual in the base class, then
2430 mark this field as being virtual as well. */
2433 check_for_override (tree decl, tree ctype)
2435 bool overrides_found = false;
2436 if (TREE_CODE (decl) == TEMPLATE_DECL)
2437 /* In [temp.mem] we have:
2439 A specialization of a member function template does not
2440 override a virtual function from a base class. */
2442 if ((DECL_DESTRUCTOR_P (decl)
2443 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl))
2444 || DECL_CONV_FN_P (decl))
2445 && look_for_overrides (ctype, decl)
2446 && !DECL_STATIC_FUNCTION_P (decl))
2447 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2448 the error_mark_node so that we know it is an overriding
2451 DECL_VINDEX (decl) = decl;
2452 overrides_found = true;
2455 if (DECL_VIRTUAL_P (decl))
2457 if (!DECL_VINDEX (decl))
2458 DECL_VINDEX (decl) = error_mark_node;
2459 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2460 if (DECL_DESTRUCTOR_P (decl))
2461 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true;
2463 else if (DECL_FINAL_P (decl))
2464 error ("%q+#D marked final, but is not virtual", decl);
2465 if (DECL_OVERRIDE_P (decl) && !overrides_found)
2466 error ("%q+#D marked override, but does not override", decl);
2469 /* Warn about hidden virtual functions that are not overridden in t.
2470 We know that constructors and destructors don't apply. */
2473 warn_hidden (tree t)
2475 VEC(tree,gc) *method_vec = CLASSTYPE_METHOD_VEC (t);
2479 /* We go through each separately named virtual function. */
2480 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2481 VEC_iterate (tree, method_vec, i, fns);
2492 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2493 have the same name. Figure out what name that is. */
2494 name = DECL_NAME (OVL_CURRENT (fns));
2495 /* There are no possibly hidden functions yet. */
2496 base_fndecls = NULL_TREE;
2497 /* Iterate through all of the base classes looking for possibly
2498 hidden functions. */
2499 for (binfo = TYPE_BINFO (t), j = 0;
2500 BINFO_BASE_ITERATE (binfo, j, base_binfo); j++)
2502 tree basetype = BINFO_TYPE (base_binfo);
2503 base_fndecls = chainon (get_basefndecls (name, basetype),
2507 /* If there are no functions to hide, continue. */
2511 /* Remove any overridden functions. */
2512 for (fn = fns; fn; fn = OVL_NEXT (fn))
2514 fndecl = OVL_CURRENT (fn);
2515 if (DECL_VINDEX (fndecl))
2517 tree *prev = &base_fndecls;
2520 /* If the method from the base class has the same
2521 signature as the method from the derived class, it
2522 has been overridden. */
2523 if (same_signature_p (fndecl, TREE_VALUE (*prev)))
2524 *prev = TREE_CHAIN (*prev);
2526 prev = &TREE_CHAIN (*prev);
2530 /* Now give a warning for all base functions without overriders,
2531 as they are hidden. */
2532 while (base_fndecls)
2534 /* Here we know it is a hider, and no overrider exists. */
2535 warning (OPT_Woverloaded_virtual, "%q+D was hidden", TREE_VALUE (base_fndecls));
2536 warning (OPT_Woverloaded_virtual, " by %q+D", fns);
2537 base_fndecls = TREE_CHAIN (base_fndecls);
2542 /* Check for things that are invalid. There are probably plenty of other
2543 things we should check for also. */
2546 finish_struct_anon (tree t)
2550 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
2552 if (TREE_STATIC (field))
2554 if (TREE_CODE (field) != FIELD_DECL)
2557 if (DECL_NAME (field) == NULL_TREE
2558 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2560 bool is_union = TREE_CODE (TREE_TYPE (field)) == UNION_TYPE;
2561 tree elt = TYPE_FIELDS (TREE_TYPE (field));
2562 for (; elt; elt = DECL_CHAIN (elt))
2564 /* We're generally only interested in entities the user
2565 declared, but we also find nested classes by noticing
2566 the TYPE_DECL that we create implicitly. You're
2567 allowed to put one anonymous union inside another,
2568 though, so we explicitly tolerate that. We use
2569 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2570 we also allow unnamed types used for defining fields. */
2571 if (DECL_ARTIFICIAL (elt)
2572 && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2573 || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2576 if (TREE_CODE (elt) != FIELD_DECL)
2579 permerror (input_location, "%q+#D invalid; an anonymous union can "
2580 "only have non-static data members", elt);
2582 permerror (input_location, "%q+#D invalid; an anonymous struct can "
2583 "only have non-static data members", elt);
2587 if (TREE_PRIVATE (elt))
2590 permerror (input_location, "private member %q+#D in anonymous union", elt);
2592 permerror (input_location, "private member %q+#D in anonymous struct", elt);
2594 else if (TREE_PROTECTED (elt))
2597 permerror (input_location, "protected member %q+#D in anonymous union", elt);
2599 permerror (input_location, "protected member %q+#D in anonymous struct", elt);
2602 TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2603 TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2609 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2610 will be used later during class template instantiation.
2611 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2612 a non-static member data (FIELD_DECL), a member function
2613 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2614 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2615 When FRIEND_P is nonzero, T is either a friend class
2616 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2617 (FUNCTION_DECL, TEMPLATE_DECL). */
2620 maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
2622 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2623 if (CLASSTYPE_TEMPLATE_INFO (type))
2624 CLASSTYPE_DECL_LIST (type)
2625 = tree_cons (friend_p ? NULL_TREE : type,
2626 t, CLASSTYPE_DECL_LIST (type));
2629 /* This function is called from declare_virt_assop_and_dtor via
2632 DATA is a type that direcly or indirectly inherits the base
2633 represented by BINFO. If BINFO contains a virtual assignment [copy
2634 assignment or move assigment] operator or a virtual constructor,
2635 declare that function in DATA if it hasn't been already declared. */
2638 dfs_declare_virt_assop_and_dtor (tree binfo, void *data)
2640 tree bv, fn, t = (tree)data;
2641 tree opname = ansi_assopname (NOP_EXPR);
2643 gcc_assert (t && CLASS_TYPE_P (t));
2644 gcc_assert (binfo && TREE_CODE (binfo) == TREE_BINFO);
2646 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
2647 /* A base without a vtable needs no modification, and its bases
2648 are uninteresting. */
2649 return dfs_skip_bases;
2651 if (BINFO_PRIMARY_P (binfo))
2652 /* If this is a primary base, then we have already looked at the
2653 virtual functions of its vtable. */
2656 for (bv = BINFO_VIRTUALS (binfo); bv; bv = TREE_CHAIN (bv))
2660 if (DECL_NAME (fn) == opname)
2662 if (CLASSTYPE_LAZY_COPY_ASSIGN (t))
2663 lazily_declare_fn (sfk_copy_assignment, t);
2664 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t))
2665 lazily_declare_fn (sfk_move_assignment, t);
2667 else if (DECL_DESTRUCTOR_P (fn)
2668 && CLASSTYPE_LAZY_DESTRUCTOR (t))
2669 lazily_declare_fn (sfk_destructor, t);
2675 /* If the class type T has a direct or indirect base that contains a
2676 virtual assignment operator or a virtual destructor, declare that
2677 function in T if it hasn't been already declared. */
2680 declare_virt_assop_and_dtor (tree t)
2682 if (!(TYPE_POLYMORPHIC_P (t)
2683 && (CLASSTYPE_LAZY_COPY_ASSIGN (t)
2684 || CLASSTYPE_LAZY_MOVE_ASSIGN (t)
2685 || CLASSTYPE_LAZY_DESTRUCTOR (t))))
2688 dfs_walk_all (TYPE_BINFO (t),
2689 dfs_declare_virt_assop_and_dtor,
2693 /* Create default constructors, assignment operators, and so forth for
2694 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
2695 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
2696 the class cannot have a default constructor, copy constructor
2697 taking a const reference argument, or an assignment operator taking
2698 a const reference, respectively. */
2701 add_implicitly_declared_members (tree t,
2702 int cant_have_const_cctor,
2703 int cant_have_const_assignment)
2706 if (!CLASSTYPE_DESTRUCTORS (t))
2708 /* In general, we create destructors lazily. */
2709 CLASSTYPE_LAZY_DESTRUCTOR (t) = 1;
2711 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2712 && TYPE_FOR_JAVA (t))
2713 /* But if this is a Java class, any non-trivial destructor is
2714 invalid, even if compiler-generated. Therefore, if the
2715 destructor is non-trivial we create it now. */
2716 lazily_declare_fn (sfk_destructor, t);
2721 If there is no user-declared constructor for a class, a default
2722 constructor is implicitly declared. */
2723 if (! TYPE_HAS_USER_CONSTRUCTOR (t))
2725 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1;
2726 CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 1;
2727 if (cxx_dialect >= cxx0x)
2728 TYPE_HAS_CONSTEXPR_CTOR (t)
2729 /* This might force the declaration. */
2730 = type_has_constexpr_default_constructor (t);
2735 If a class definition does not explicitly declare a copy
2736 constructor, one is declared implicitly. */
2737 if (! TYPE_HAS_COPY_CTOR (t) && ! TYPE_FOR_JAVA (t)
2738 && !type_has_move_constructor (t))
2740 TYPE_HAS_COPY_CTOR (t) = 1;
2741 TYPE_HAS_CONST_COPY_CTOR (t) = !cant_have_const_cctor;
2742 CLASSTYPE_LAZY_COPY_CTOR (t) = 1;
2743 if (cxx_dialect >= cxx0x)
2744 CLASSTYPE_LAZY_MOVE_CTOR (t) = 1;
2747 /* If there is no assignment operator, one will be created if and
2748 when it is needed. For now, just record whether or not the type
2749 of the parameter to the assignment operator will be a const or
2750 non-const reference. */
2751 if (!TYPE_HAS_COPY_ASSIGN (t) && !TYPE_FOR_JAVA (t)
2752 && !type_has_move_assign (t))
2754 TYPE_HAS_COPY_ASSIGN (t) = 1;
2755 TYPE_HAS_CONST_COPY_ASSIGN (t) = !cant_have_const_assignment;
2756 CLASSTYPE_LAZY_COPY_ASSIGN (t) = 1;
2757 if (cxx_dialect >= cxx0x)
2758 CLASSTYPE_LAZY_MOVE_ASSIGN (t) = 1;
2761 /* We can't be lazy about declaring functions that might override
2762 a virtual function from a base class. */
2763 declare_virt_assop_and_dtor (t);
2766 /* Subroutine of finish_struct_1. Recursively count the number of fields
2767 in TYPE, including anonymous union members. */
2770 count_fields (tree fields)
2774 for (x = fields; x; x = DECL_CHAIN (x))
2776 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2777 n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2784 /* Subroutine of finish_struct_1. Recursively add all the fields in the
2785 TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */
2788 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2791 for (x = fields; x; x = DECL_CHAIN (x))
2793 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2794 idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2796 field_vec->elts[idx++] = x;
2801 /* FIELD is a bit-field. We are finishing the processing for its
2802 enclosing type. Issue any appropriate messages and set appropriate
2803 flags. Returns false if an error has been diagnosed. */
2806 check_bitfield_decl (tree field)
2808 tree type = TREE_TYPE (field);
2811 /* Extract the declared width of the bitfield, which has been
2812 temporarily stashed in DECL_INITIAL. */
2813 w = DECL_INITIAL (field);
2814 gcc_assert (w != NULL_TREE);
2815 /* Remove the bit-field width indicator so that the rest of the
2816 compiler does not treat that value as an initializer. */
2817 DECL_INITIAL (field) = NULL_TREE;
2819 /* Detect invalid bit-field type. */
2820 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
2822 error ("bit-field %q+#D with non-integral type", field);
2823 w = error_mark_node;
2827 location_t loc = input_location;
2828 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2831 /* detect invalid field size. */
2832 input_location = DECL_SOURCE_LOCATION (field);
2833 w = cxx_constant_value (w);
2834 input_location = loc;
2836 if (TREE_CODE (w) != INTEGER_CST)
2838 error ("bit-field %q+D width not an integer constant", field);
2839 w = error_mark_node;
2841 else if (tree_int_cst_sgn (w) < 0)
2843 error ("negative width in bit-field %q+D", field);
2844 w = error_mark_node;
2846 else if (integer_zerop (w) && DECL_NAME (field) != 0)
2848 error ("zero width for bit-field %q+D", field);
2849 w = error_mark_node;
2851 else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2852 && TREE_CODE (type) != ENUMERAL_TYPE
2853 && TREE_CODE (type) != BOOLEAN_TYPE)
2854 warning (0, "width of %q+D exceeds its type", field);
2855 else if (TREE_CODE (type) == ENUMERAL_TYPE
2856 && (0 > (compare_tree_int
2857 (w, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type))))))
2858 warning (0, "%q+D is too small to hold all values of %q#T", field, type);
2861 if (w != error_mark_node)
2863 DECL_SIZE (field) = convert (bitsizetype, w);
2864 DECL_BIT_FIELD (field) = 1;
2869 /* Non-bit-fields are aligned for their type. */
2870 DECL_BIT_FIELD (field) = 0;
2871 CLEAR_DECL_C_BIT_FIELD (field);
2876 /* FIELD is a non bit-field. We are finishing the processing for its
2877 enclosing type T. Issue any appropriate messages and set appropriate
2881 check_field_decl (tree field,
2883 int* cant_have_const_ctor,
2884 int* no_const_asn_ref,
2885 int* any_default_members)
2887 tree type = strip_array_types (TREE_TYPE (field));
2889 /* In C++98 an anonymous union cannot contain any fields which would change
2890 the settings of CANT_HAVE_CONST_CTOR and friends. */
2891 if (ANON_UNION_TYPE_P (type) && cxx_dialect < cxx0x)
2893 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
2894 structs. So, we recurse through their fields here. */
2895 else if (ANON_AGGR_TYPE_P (type))
2899 for (fields = TYPE_FIELDS (type); fields; fields = DECL_CHAIN (fields))
2900 if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2901 check_field_decl (fields, t, cant_have_const_ctor,
2902 no_const_asn_ref, any_default_members);
2904 /* Check members with class type for constructors, destructors,
2906 else if (CLASS_TYPE_P (type))
2908 /* Never let anything with uninheritable virtuals
2909 make it through without complaint. */
2910 abstract_virtuals_error (field, type);
2912 if (TREE_CODE (t) == UNION_TYPE && cxx_dialect < cxx0x)
2915 int oldcount = errorcount;
2916 if (TYPE_NEEDS_CONSTRUCTING (type))
2917 error ("member %q+#D with constructor not allowed in union",
2919 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2920 error ("member %q+#D with destructor not allowed in union", field);
2921 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
2922 error ("member %q+#D with copy assignment operator not allowed in union",
2924 if (!warned && errorcount > oldcount)
2926 inform (DECL_SOURCE_LOCATION (field), "unrestricted unions "
2927 "only available with -std=c++0x or -std=gnu++0x");
2933 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2934 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2935 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2936 TYPE_HAS_COMPLEX_COPY_ASSIGN (t)
2937 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type)
2938 || !TYPE_HAS_COPY_ASSIGN (type));
2939 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= (TYPE_HAS_COMPLEX_COPY_CTOR (type)
2940 || !TYPE_HAS_COPY_CTOR (type));
2941 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type);
2942 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_HAS_COMPLEX_MOVE_CTOR (type);
2943 TYPE_HAS_COMPLEX_DFLT (t) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)
2944 || TYPE_HAS_COMPLEX_DFLT (type));
2947 if (TYPE_HAS_COPY_CTOR (type)
2948 && !TYPE_HAS_CONST_COPY_CTOR (type))
2949 *cant_have_const_ctor = 1;
2951 if (TYPE_HAS_COPY_ASSIGN (type)
2952 && !TYPE_HAS_CONST_COPY_ASSIGN (type))
2953 *no_const_asn_ref = 1;
2955 if (DECL_INITIAL (field) != NULL_TREE)
2957 /* `build_class_init_list' does not recognize
2959 if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2960 error ("multiple fields in union %qT initialized", t);
2961 *any_default_members = 1;
2965 /* Check the data members (both static and non-static), class-scoped
2966 typedefs, etc., appearing in the declaration of T. Issue
2967 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
2968 declaration order) of access declarations; each TREE_VALUE in this
2969 list is a USING_DECL.
2971 In addition, set the following flags:
2974 The class is empty, i.e., contains no non-static data members.
2976 CANT_HAVE_CONST_CTOR_P
2977 This class cannot have an implicitly generated copy constructor
2978 taking a const reference.
2980 CANT_HAVE_CONST_ASN_REF
2981 This class cannot have an implicitly generated assignment
2982 operator taking a const reference.
2984 All of these flags should be initialized before calling this
2987 Returns a pointer to the end of the TYPE_FIELDs chain; additional
2988 fields can be added by adding to this chain. */
2991 check_field_decls (tree t, tree *access_decls,
2992 int *cant_have_const_ctor_p,
2993 int *no_const_asn_ref_p)
2998 int any_default_members;
3000 int field_access = -1;
3002 /* Assume there are no access declarations. */
3003 *access_decls = NULL_TREE;
3004 /* Assume this class has no pointer members. */
3005 has_pointers = false;
3006 /* Assume none of the members of this class have default
3008 any_default_members = 0;
3010 for (field = &TYPE_FIELDS (t); *field; field = next)
3013 tree type = TREE_TYPE (x);
3014 int this_field_access;
3016 next = &DECL_CHAIN (x);
3018 if (TREE_CODE (x) == USING_DECL)
3020 /* Prune the access declaration from the list of fields. */
3021 *field = DECL_CHAIN (x);
3023 /* Save the access declarations for our caller. */
3024 *access_decls = tree_cons (NULL_TREE, x, *access_decls);
3026 /* Since we've reset *FIELD there's no reason to skip to the
3032 if (TREE_CODE (x) == TYPE_DECL
3033 || TREE_CODE (x) == TEMPLATE_DECL)
3036 /* If we've gotten this far, it's a data member, possibly static,
3037 or an enumerator. */
3038 DECL_CONTEXT (x) = t;
3040 /* When this goes into scope, it will be a non-local reference. */
3041 DECL_NONLOCAL (x) = 1;
3043 if (TREE_CODE (t) == UNION_TYPE)
3047 If a union contains a static data member, or a member of
3048 reference type, the program is ill-formed. */
3049 if (TREE_CODE (x) == VAR_DECL)
3051 error ("%q+D may not be static because it is a member of a union", x);
3054 if (TREE_CODE (type) == REFERENCE_TYPE)
3056 error ("%q+D may not have reference type %qT because"
3057 " it is a member of a union",
3063 /* Perform error checking that did not get done in
3065 if (TREE_CODE (type) == FUNCTION_TYPE)
3067 error ("field %q+D invalidly declared function type", x);
3068 type = build_pointer_type (type);
3069 TREE_TYPE (x) = type;
3071 else if (TREE_CODE (type) == METHOD_TYPE)
3073 error ("field %q+D invalidly declared method type", x);
3074 type = build_pointer_type (type);
3075 TREE_TYPE (x) = type;
3078 if (type == error_mark_node)
3081 if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
3084 /* Now it can only be a FIELD_DECL. */
3086 if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3087 CLASSTYPE_NON_AGGREGATE (t) = 1;
3089 /* If at least one non-static data member is non-literal, the whole
3090 class becomes non-literal. */
3091 if (!literal_type_p (type))
3092 CLASSTYPE_LITERAL_P (t) = false;
3094 /* A standard-layout class is a class that:
3096 has the same access control (Clause 11) for all non-static data members,
3098 this_field_access = TREE_PROTECTED (x) ? 1 : TREE_PRIVATE (x) ? 2 : 0;
3099 if (field_access == -1)
3100 field_access = this_field_access;
3101 else if (this_field_access != field_access)
3102 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3104 /* If this is of reference type, check if it needs an init. */
3105 if (TREE_CODE (type) == REFERENCE_TYPE)
3107 CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3108 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3109 if (DECL_INITIAL (x) == NULL_TREE)
3110 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3112 /* ARM $12.6.2: [A member initializer list] (or, for an
3113 aggregate, initialization by a brace-enclosed list) is the
3114 only way to initialize nonstatic const and reference
3116 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
3117 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) = 1;
3120 type = strip_array_types (type);
3122 if (TYPE_PACKED (t))
3124 if (!layout_pod_type_p (type) && !TYPE_PACKED (type))
3128 "ignoring packed attribute because of unpacked non-POD field %q+#D",
3132 else if (DECL_C_BIT_FIELD (x)
3133 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
3134 DECL_PACKED (x) = 1;
3137 if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
3138 /* We don't treat zero-width bitfields as making a class
3143 /* The class is non-empty. */
3144 CLASSTYPE_EMPTY_P (t) = 0;
3145 /* The class is not even nearly empty. */
3146 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3147 /* If one of the data members contains an empty class,
3149 if (CLASS_TYPE_P (type)
3150 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3151 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
3154 /* This is used by -Weffc++ (see below). Warn only for pointers
3155 to members which might hold dynamic memory. So do not warn
3156 for pointers to functions or pointers to members. */
3157 if (TYPE_PTR_P (type)
3158 && !TYPE_PTRFN_P (type)
3159 && !TYPE_PTR_TO_MEMBER_P (type))
3160 has_pointers = true;
3162 if (CLASS_TYPE_P (type))
3164 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3165 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3166 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3167 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3170 if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3171 CLASSTYPE_HAS_MUTABLE (t) = 1;
3173 if (! layout_pod_type_p (type))
3174 /* DR 148 now allows pointers to members (which are POD themselves),
3175 to be allowed in POD structs. */
3176 CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3178 if (!std_layout_type_p (type))
3179 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3181 if (! zero_init_p (type))
3182 CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3184 /* We set DECL_C_BIT_FIELD in grokbitfield.
3185 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3186 if (! DECL_C_BIT_FIELD (x) || ! check_bitfield_decl (x))
3187 check_field_decl (x, t,
3188 cant_have_const_ctor_p,
3190 &any_default_members);
3192 /* If any field is const, the structure type is pseudo-const. */
3193 if (CP_TYPE_CONST_P (type))
3195 C_TYPE_FIELDS_READONLY (t) = 1;
3196 if (DECL_INITIAL (x) == NULL_TREE)
3197 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3199 /* ARM $12.6.2: [A member initializer list] (or, for an
3200 aggregate, initialization by a brace-enclosed list) is the
3201 only way to initialize nonstatic const and reference
3203 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
3204 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) = 1;
3206 /* A field that is pseudo-const makes the structure likewise. */
3207 else if (CLASS_TYPE_P (type))
3209 C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3210 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3211 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3212 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3215 /* Core issue 80: A nonstatic data member is required to have a
3216 different name from the class iff the class has a
3217 user-declared constructor. */
3218 if (constructor_name_p (DECL_NAME (x), t)
3219 && TYPE_HAS_USER_CONSTRUCTOR (t))
3220 permerror (input_location, "field %q+#D with same name as class", x);
3223 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3224 it should also define a copy constructor and an assignment operator to
3225 implement the correct copy semantic (deep vs shallow, etc.). As it is
3226 not feasible to check whether the constructors do allocate dynamic memory
3227 and store it within members, we approximate the warning like this:
3229 -- Warn only if there are members which are pointers
3230 -- Warn only if there is a non-trivial constructor (otherwise,
3231 there cannot be memory allocated).
3232 -- Warn only if there is a non-trivial destructor. We assume that the
3233 user at least implemented the cleanup correctly, and a destructor
3234 is needed to free dynamic memory.
3236 This seems enough for practical purposes. */
3239 && TYPE_HAS_USER_CONSTRUCTOR (t)
3240 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
3241 && !(TYPE_HAS_COPY_CTOR (t) && TYPE_HAS_COPY_ASSIGN (t)))
3243 warning (OPT_Weffc__, "%q#T has pointer data members", t);
3245 if (! TYPE_HAS_COPY_CTOR (t))
3247 warning (OPT_Weffc__,
3248 " but does not override %<%T(const %T&)%>", t, t);
3249 if (!TYPE_HAS_COPY_ASSIGN (t))
3250 warning (OPT_Weffc__, " or %<operator=(const %T&)%>", t);
3252 else if (! TYPE_HAS_COPY_ASSIGN (t))
3253 warning (OPT_Weffc__,
3254 " but does not override %<operator=(const %T&)%>", t);
3257 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3259 TYPE_PACKED (t) = 0;
3261 /* Check anonymous struct/anonymous union fields. */
3262 finish_struct_anon (t);
3264 /* We've built up the list of access declarations in reverse order.
3266 *access_decls = nreverse (*access_decls);
3269 /* If TYPE is an empty class type, records its OFFSET in the table of
3273 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3277 if (!is_empty_class (type))
3280 /* Record the location of this empty object in OFFSETS. */
3281 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3283 n = splay_tree_insert (offsets,
3284 (splay_tree_key) offset,
3285 (splay_tree_value) NULL_TREE);
3286 n->value = ((splay_tree_value)
3287 tree_cons (NULL_TREE,
3294 /* Returns nonzero if TYPE is an empty class type and there is
3295 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3298 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3303 if (!is_empty_class (type))
3306 /* Record the location of this empty object in OFFSETS. */
3307 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3311 for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3312 if (same_type_p (TREE_VALUE (t), type))
3318 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3319 F for every subobject, passing it the type, offset, and table of
3320 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3323 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3324 than MAX_OFFSET will not be walked.
3326 If F returns a nonzero value, the traversal ceases, and that value
3327 is returned. Otherwise, returns zero. */
3330 walk_subobject_offsets (tree type,
3331 subobject_offset_fn f,
3338 tree type_binfo = NULL_TREE;
3340 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3342 if (max_offset && INT_CST_LT (max_offset, offset))
3345 if (type == error_mark_node)
3350 if (abi_version_at_least (2))
3352 type = BINFO_TYPE (type);
3355 if (CLASS_TYPE_P (type))
3361 /* Avoid recursing into objects that are not interesting. */
3362 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3365 /* Record the location of TYPE. */
3366 r = (*f) (type, offset, offsets);
3370 /* Iterate through the direct base classes of TYPE. */
3372 type_binfo = TYPE_BINFO (type);
3373 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++)
3377 if (abi_version_at_least (2)
3378 && BINFO_VIRTUAL_P (binfo))
3382 && BINFO_VIRTUAL_P (binfo)
3383 && !BINFO_PRIMARY_P (binfo))
3386 if (!abi_version_at_least (2))
3387 binfo_offset = size_binop (PLUS_EXPR,
3389 BINFO_OFFSET (binfo));
3393 /* We cannot rely on BINFO_OFFSET being set for the base
3394 class yet, but the offsets for direct non-virtual
3395 bases can be calculated by going back to the TYPE. */
3396 orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
3397 binfo_offset = size_binop (PLUS_EXPR,
3399 BINFO_OFFSET (orig_binfo));
3402 r = walk_subobject_offsets (binfo,
3407 (abi_version_at_least (2)
3408 ? /*vbases_p=*/0 : vbases_p));
3413 if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type))
3416 VEC(tree,gc) *vbases;
3418 /* Iterate through the virtual base classes of TYPE. In G++
3419 3.2, we included virtual bases in the direct base class
3420 loop above, which results in incorrect results; the
3421 correct offsets for virtual bases are only known when
3422 working with the most derived type. */
3424 for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0;
3425 VEC_iterate (tree, vbases, ix, binfo); ix++)
3427 r = walk_subobject_offsets (binfo,
3429 size_binop (PLUS_EXPR,
3431 BINFO_OFFSET (binfo)),
3440 /* We still have to walk the primary base, if it is
3441 virtual. (If it is non-virtual, then it was walked
3443 tree vbase = get_primary_binfo (type_binfo);
3445 if (vbase && BINFO_VIRTUAL_P (vbase)
3446 && BINFO_PRIMARY_P (vbase)
3447 && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo)
3449 r = (walk_subobject_offsets
3451 offsets, max_offset, /*vbases_p=*/0));
3458 /* Iterate through the fields of TYPE. */
3459 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3460 if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3464 if (abi_version_at_least (2))
3465 field_offset = byte_position (field);
3467 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3468 field_offset = DECL_FIELD_OFFSET (field);
3470 r = walk_subobject_offsets (TREE_TYPE (field),
3472 size_binop (PLUS_EXPR,
3482 else if (TREE_CODE (type) == ARRAY_TYPE)
3484 tree element_type = strip_array_types (type);
3485 tree domain = TYPE_DOMAIN (type);
3488 /* Avoid recursing into objects that are not interesting. */
3489 if (!CLASS_TYPE_P (element_type)
3490 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3493 /* Step through each of the elements in the array. */
3494 for (index = size_zero_node;
3495 /* G++ 3.2 had an off-by-one error here. */
3496 (abi_version_at_least (2)
3497 ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3498 : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3499 index = size_binop (PLUS_EXPR, index, size_one_node))
3501 r = walk_subobject_offsets (TREE_TYPE (type),
3509 offset = size_binop (PLUS_EXPR, offset,
3510 TYPE_SIZE_UNIT (TREE_TYPE (type)));
3511 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3512 there's no point in iterating through the remaining
3513 elements of the array. */
3514 if (max_offset && INT_CST_LT (max_offset, offset))
3522 /* Record all of the empty subobjects of TYPE (either a type or a
3523 binfo). If IS_DATA_MEMBER is true, then a non-static data member
3524 is being placed at OFFSET; otherwise, it is a base class that is
3525 being placed at OFFSET. */
3528 record_subobject_offsets (tree type,
3531 bool is_data_member)
3534 /* If recording subobjects for a non-static data member or a
3535 non-empty base class , we do not need to record offsets beyond
3536 the size of the biggest empty class. Additional data members
3537 will go at the end of the class. Additional base classes will go
3538 either at offset zero (if empty, in which case they cannot
3539 overlap with offsets past the size of the biggest empty class) or
3540 at the end of the class.
3542 However, if we are placing an empty base class, then we must record
3543 all offsets, as either the empty class is at offset zero (where
3544 other empty classes might later be placed) or at the end of the
3545 class (where other objects might then be placed, so other empty
3546 subobjects might later overlap). */
3548 || !is_empty_class (BINFO_TYPE (type)))
3549 max_offset = sizeof_biggest_empty_class;
3551 max_offset = NULL_TREE;
3552 walk_subobject_offsets (type, record_subobject_offset, offset,
3553 offsets, max_offset, is_data_member);
3556 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3557 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3558 virtual bases of TYPE are examined. */
3561 layout_conflict_p (tree type,
3566 splay_tree_node max_node;
3568 /* Get the node in OFFSETS that indicates the maximum offset where
3569 an empty subobject is located. */
3570 max_node = splay_tree_max (offsets);
3571 /* If there aren't any empty subobjects, then there's no point in
3572 performing this check. */
3576 return walk_subobject_offsets (type, check_subobject_offset, offset,
3577 offsets, (tree) (max_node->key),
3581 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3582 non-static data member of the type indicated by RLI. BINFO is the
3583 binfo corresponding to the base subobject, OFFSETS maps offsets to
3584 types already located at those offsets. This function determines
3585 the position of the DECL. */
3588 layout_nonempty_base_or_field (record_layout_info rli,
3593 tree offset = NULL_TREE;
3599 /* For the purposes of determining layout conflicts, we want to
3600 use the class type of BINFO; TREE_TYPE (DECL) will be the
3601 CLASSTYPE_AS_BASE version, which does not contain entries for
3602 zero-sized bases. */
3603 type = TREE_TYPE (binfo);
3608 type = TREE_TYPE (decl);
3612 /* Try to place the field. It may take more than one try if we have
3613 a hard time placing the field without putting two objects of the
3614 same type at the same address. */
3617 struct record_layout_info_s old_rli = *rli;
3619 /* Place this field. */
3620 place_field (rli, decl);
3621 offset = byte_position (decl);
3623 /* We have to check to see whether or not there is already
3624 something of the same type at the offset we're about to use.
3625 For example, consider:
3628 struct T : public S { int i; };
3629 struct U : public S, public T {};
3631 Here, we put S at offset zero in U. Then, we can't put T at
3632 offset zero -- its S component would be at the same address
3633 as the S we already allocated. So, we have to skip ahead.
3634 Since all data members, including those whose type is an
3635 empty class, have nonzero size, any overlap can happen only
3636 with a direct or indirect base-class -- it can't happen with
3638 /* In a union, overlap is permitted; all members are placed at
3640 if (TREE_CODE (rli->t) == UNION_TYPE)
3642 /* G++ 3.2 did not check for overlaps when placing a non-empty
3644 if (!abi_version_at_least (2) && binfo && BINFO_VIRTUAL_P (binfo))
3646 if (layout_conflict_p (field_p ? type : binfo, offset,
3649 /* Strip off the size allocated to this field. That puts us
3650 at the first place we could have put the field with
3651 proper alignment. */
3654 /* Bump up by the alignment required for the type. */
3656 = size_binop (PLUS_EXPR, rli->bitpos,
3658 ? CLASSTYPE_ALIGN (type)
3659 : TYPE_ALIGN (type)));
3660 normalize_rli (rli);
3663 /* There was no conflict. We're done laying out this field. */
3667 /* Now that we know where it will be placed, update its
3669 if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3670 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3671 this point because their BINFO_OFFSET is copied from another
3672 hierarchy. Therefore, we may not need to add the entire
3674 propagate_binfo_offsets (binfo,
3675 size_diffop_loc (input_location,
3676 convert (ssizetype, offset),
3678 BINFO_OFFSET (binfo))));
3681 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3684 empty_base_at_nonzero_offset_p (tree type,
3686 splay_tree offsets ATTRIBUTE_UNUSED)
3688 return is_empty_class (type) && !integer_zerop (offset);
3691 /* Layout the empty base BINFO. EOC indicates the byte currently just
3692 past the end of the class, and should be correctly aligned for a
3693 class of the type indicated by BINFO; OFFSETS gives the offsets of
3694 the empty bases allocated so far. T is the most derived
3695 type. Return nonzero iff we added it at the end. */
3698 layout_empty_base (record_layout_info rli, tree binfo,
3699 tree eoc, splay_tree offsets)
3702 tree basetype = BINFO_TYPE (binfo);
3705 /* This routine should only be used for empty classes. */
3706 gcc_assert (is_empty_class (basetype));
3707 alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3709 if (!integer_zerop (BINFO_OFFSET (binfo)))
3711 if (abi_version_at_least (2))
3712 propagate_binfo_offsets
3713 (binfo, size_diffop_loc (input_location,
3714 size_zero_node, BINFO_OFFSET (binfo)));
3717 "offset of empty base %qT may not be ABI-compliant and may"
3718 "change in a future version of GCC",
3719 BINFO_TYPE (binfo));
3722 /* This is an empty base class. We first try to put it at offset
3724 if (layout_conflict_p (binfo,
3725 BINFO_OFFSET (binfo),
3729 /* That didn't work. Now, we move forward from the next
3730 available spot in the class. */
3732 propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3735 if (!layout_conflict_p (binfo,
3736 BINFO_OFFSET (binfo),
3739 /* We finally found a spot where there's no overlap. */
3742 /* There's overlap here, too. Bump along to the next spot. */
3743 propagate_binfo_offsets (binfo, alignment);
3747 if (CLASSTYPE_USER_ALIGN (basetype))
3749 rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (basetype));
3751 rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (basetype));
3752 TYPE_USER_ALIGN (rli->t) = 1;
3758 /* Layout the base given by BINFO in the class indicated by RLI.
3759 *BASE_ALIGN is a running maximum of the alignments of
3760 any base class. OFFSETS gives the location of empty base
3761 subobjects. T is the most derived type. Return nonzero if the new
3762 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3763 *NEXT_FIELD, unless BINFO is for an empty base class.
3765 Returns the location at which the next field should be inserted. */
3768 build_base_field (record_layout_info rli, tree binfo,
3769 splay_tree offsets, tree *next_field)
3772 tree basetype = BINFO_TYPE (binfo);
3774 if (!COMPLETE_TYPE_P (basetype))
3775 /* This error is now reported in xref_tag, thus giving better
3776 location information. */
3779 /* Place the base class. */
3780 if (!is_empty_class (basetype))
3784 /* The containing class is non-empty because it has a non-empty
3786 CLASSTYPE_EMPTY_P (t) = 0;
3788 /* Create the FIELD_DECL. */
3789 decl = build_decl (input_location,
3790 FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3791 DECL_ARTIFICIAL (decl) = 1;
3792 DECL_IGNORED_P (decl) = 1;
3793 DECL_FIELD_CONTEXT (decl) = t;
3794 if (CLASSTYPE_AS_BASE (basetype))
3796 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3797 DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3798 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3799 DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3800 DECL_MODE (decl) = TYPE_MODE (basetype);
3801 DECL_FIELD_IS_BASE (decl) = 1;
3803 /* Try to place the field. It may take more than one try if we
3804 have a hard time placing the field without putting two
3805 objects of the same type at the same address. */
3806 layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3807 /* Add the new FIELD_DECL to the list of fields for T. */
3808 DECL_CHAIN (decl) = *next_field;
3810 next_field = &DECL_CHAIN (decl);
3818 /* On some platforms (ARM), even empty classes will not be
3820 eoc = round_up_loc (input_location,
3821 rli_size_unit_so_far (rli),
3822 CLASSTYPE_ALIGN_UNIT (basetype));
3823 atend = layout_empty_base (rli, binfo, eoc, offsets);
3824 /* A nearly-empty class "has no proper base class that is empty,
3825 not morally virtual, and at an offset other than zero." */
3826 if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3829 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3830 /* The check above (used in G++ 3.2) is insufficient because
3831 an empty class placed at offset zero might itself have an
3832 empty base at a nonzero offset. */
3833 else if (walk_subobject_offsets (basetype,
3834 empty_base_at_nonzero_offset_p,
3837 /*max_offset=*/NULL_TREE,
3840 if (abi_version_at_least (2))
3841 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3844 "class %qT will be considered nearly empty in a "
3845 "future version of GCC", t);
3849 /* We do not create a FIELD_DECL for empty base classes because
3850 it might overlap some other field. We want to be able to
3851 create CONSTRUCTORs for the class by iterating over the
3852 FIELD_DECLs, and the back end does not handle overlapping
3855 /* An empty virtual base causes a class to be non-empty
3856 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3857 here because that was already done when the virtual table
3858 pointer was created. */
3861 /* Record the offsets of BINFO and its base subobjects. */
3862 record_subobject_offsets (binfo,
3863 BINFO_OFFSET (binfo),
3865 /*is_data_member=*/false);
3870 /* Layout all of the non-virtual base classes. Record empty
3871 subobjects in OFFSETS. T is the most derived type. Return nonzero
3872 if the type cannot be nearly empty. The fields created
3873 corresponding to the base classes will be inserted at
3877 build_base_fields (record_layout_info rli,
3878 splay_tree offsets, tree *next_field)
3880 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3883 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
3886 /* The primary base class is always allocated first. */
3887 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3888 next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3889 offsets, next_field);
3891 /* Now allocate the rest of the bases. */
3892 for (i = 0; i < n_baseclasses; ++i)
3896 base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
3898 /* The primary base was already allocated above, so we don't
3899 need to allocate it again here. */
3900 if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3903 /* Virtual bases are added at the end (a primary virtual base
3904 will have already been added). */
3905 if (BINFO_VIRTUAL_P (base_binfo))
3908 next_field = build_base_field (rli, base_binfo,
3909 offsets, next_field);
3913 /* Go through the TYPE_METHODS of T issuing any appropriate
3914 diagnostics, figuring out which methods override which other
3915 methods, and so forth. */
3918 check_methods (tree t)
3922 for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x))
3924 check_for_override (x, t);
3925 if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3926 error ("initializer specified for non-virtual method %q+D", x);
3927 /* The name of the field is the original field name
3928 Save this in auxiliary field for later overloading. */
3929 if (DECL_VINDEX (x))
3931 TYPE_POLYMORPHIC_P (t) = 1;
3932 if (DECL_PURE_VIRTUAL_P (x))
3933 VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
3935 /* All user-provided destructors are non-trivial.
3936 Constructors and assignment ops are handled in
3937 grok_special_member_properties. */
3938 if (DECL_DESTRUCTOR_P (x) && user_provided_p (x))
3939 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1;
3943 /* FN is a constructor or destructor. Clone the declaration to create
3944 a specialized in-charge or not-in-charge version, as indicated by
3948 build_clone (tree fn, tree name)
3953 /* Copy the function. */
3954 clone = copy_decl (fn);
3955 /* Reset the function name. */
3956 DECL_NAME (clone) = name;
3957 SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3958 /* Remember where this function came from. */
3959 DECL_ABSTRACT_ORIGIN (clone) = fn;
3960 /* Make it easy to find the CLONE given the FN. */
3961 DECL_CHAIN (clone) = DECL_CHAIN (fn);
3962 DECL_CHAIN (fn) = clone;
3964 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
3965 if (TREE_CODE (clone) == TEMPLATE_DECL)
3967 tree result = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3968 DECL_TEMPLATE_RESULT (clone) = result;
3969 DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3970 DECL_TI_TEMPLATE (result) = clone;
3971 TREE_TYPE (clone) = TREE_TYPE (result);
3975 DECL_CLONED_FUNCTION (clone) = fn;
3976 /* There's no pending inline data for this function. */
3977 DECL_PENDING_INLINE_INFO (clone) = NULL;
3978 DECL_PENDING_INLINE_P (clone) = 0;
3980 /* The base-class destructor is not virtual. */
3981 if (name == base_dtor_identifier)
3983 DECL_VIRTUAL_P (clone) = 0;
3984 if (TREE_CODE (clone) != TEMPLATE_DECL)
3985 DECL_VINDEX (clone) = NULL_TREE;
3988 /* If there was an in-charge parameter, drop it from the function
3990 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3996 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3997 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3998 parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3999 /* Skip the `this' parameter. */
4000 parmtypes = TREE_CHAIN (parmtypes);
4001 /* Skip the in-charge parameter. */
4002 parmtypes = TREE_CHAIN (parmtypes);
4003 /* And the VTT parm, in a complete [cd]tor. */
4004 if (DECL_HAS_VTT_PARM_P (fn)
4005 && ! DECL_NEEDS_VTT_PARM_P (clone))
4006 parmtypes = TREE_CHAIN (parmtypes);
4007 /* If this is subobject constructor or destructor, add the vtt
4010 = build_method_type_directly (basetype,
4011 TREE_TYPE (TREE_TYPE (clone)),
4014 TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
4017 = cp_build_type_attribute_variant (TREE_TYPE (clone),
4018 TYPE_ATTRIBUTES (TREE_TYPE (fn)));
4021 /* Copy the function parameters. */
4022 DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
4023 /* Remove the in-charge parameter. */
4024 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
4026 DECL_CHAIN (DECL_ARGUMENTS (clone))
4027 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone)));
4028 DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
4030 /* And the VTT parm, in a complete [cd]tor. */
4031 if (DECL_HAS_VTT_PARM_P (fn))
4033 if (DECL_NEEDS_VTT_PARM_P (clone))
4034 DECL_HAS_VTT_PARM_P (clone) = 1;
4037 DECL_CHAIN (DECL_ARGUMENTS (clone))
4038 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone)));
4039 DECL_HAS_VTT_PARM_P (clone) = 0;
4043 for (parms = DECL_ARGUMENTS (clone); parms; parms = DECL_CHAIN (parms))
4045 DECL_CONTEXT (parms) = clone;
4046 cxx_dup_lang_specific_decl (parms);
4049 /* Create the RTL for this function. */
4050 SET_DECL_RTL (clone, NULL);
4051 rest_of_decl_compilation (clone, /*top_level=*/1, at_eof);
4054 note_decl_for_pch (clone);
4059 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
4060 not invoke this function directly.
4062 For a non-thunk function, returns the address of the slot for storing
4063 the function it is a clone of. Otherwise returns NULL_TREE.
4065 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
4066 cloned_function is unset. This is to support the separate
4067 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
4068 on a template makes sense, but not the former. */
4071 decl_cloned_function_p (const_tree decl, bool just_testing)
4075 decl = STRIP_TEMPLATE (decl);
4077 if (TREE_CODE (decl) != FUNCTION_DECL
4078 || !DECL_LANG_SPECIFIC (decl)
4079 || DECL_LANG_SPECIFIC (decl)->u.fn.thunk_p)
4081 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4083 lang_check_failed (__FILE__, __LINE__, __FUNCTION__);
4089 ptr = &DECL_LANG_SPECIFIC (decl)->u.fn.u5.cloned_function;
4090 if (just_testing && *ptr == NULL_TREE)
4096 /* Produce declarations for all appropriate clones of FN. If
4097 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4098 CLASTYPE_METHOD_VEC as well. */
4101 clone_function_decl (tree fn, int update_method_vec_p)
4105 /* Avoid inappropriate cloning. */
4107 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (fn)))
4110 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
4112 /* For each constructor, we need two variants: an in-charge version
4113 and a not-in-charge version. */
4114 clone = build_clone (fn, complete_ctor_identifier);
4115 if (update_method_vec_p)
4116 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4117 clone = build_clone (fn, base_ctor_identifier);
4118 if (update_method_vec_p)
4119 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4123 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
4125 /* For each destructor, we need three variants: an in-charge
4126 version, a not-in-charge version, and an in-charge deleting
4127 version. We clone the deleting version first because that
4128 means it will go second on the TYPE_METHODS list -- and that
4129 corresponds to the correct layout order in the virtual
4132 For a non-virtual destructor, we do not build a deleting
4134 if (DECL_VIRTUAL_P (fn))
4136 clone = build_clone (fn, deleting_dtor_identifier);
4137 if (update_method_vec_p)
4138 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4140 clone = build_clone (fn, complete_dtor_identifier);
4141 if (update_method_vec_p)
4142 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4143 clone = build_clone (fn, base_dtor_identifier);
4144 if (update_method_vec_p)
4145 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4148 /* Note that this is an abstract function that is never emitted. */
4149 DECL_ABSTRACT (fn) = 1;
4152 /* DECL is an in charge constructor, which is being defined. This will
4153 have had an in class declaration, from whence clones were
4154 declared. An out-of-class definition can specify additional default
4155 arguments. As it is the clones that are involved in overload
4156 resolution, we must propagate the information from the DECL to its
4160 adjust_clone_args (tree decl)
4164 for (clone = DECL_CHAIN (decl); clone && DECL_CLONED_FUNCTION_P (clone);
4165 clone = DECL_CHAIN (clone))
4167 tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
4168 tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
4169 tree decl_parms, clone_parms;
4171 clone_parms = orig_clone_parms;
4173 /* Skip the 'this' parameter. */
4174 orig_clone_parms = TREE_CHAIN (orig_clone_parms);
4175 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4177 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
4178 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4179 if (DECL_HAS_VTT_PARM_P (decl))
4180 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4182 clone_parms = orig_clone_parms;
4183 if (DECL_HAS_VTT_PARM_P (clone))
4184 clone_parms = TREE_CHAIN (clone_parms);
4186 for (decl_parms = orig_decl_parms; decl_parms;
4187 decl_parms = TREE_CHAIN (decl_parms),
4188 clone_parms = TREE_CHAIN (clone_parms))
4190 gcc_assert (same_type_p (TREE_TYPE (decl_parms),
4191 TREE_TYPE (clone_parms)));
4193 if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
4195 /* A default parameter has been added. Adjust the
4196 clone's parameters. */
4197 tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4198 tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (clone));
4199 tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4202 clone_parms = orig_decl_parms;
4204 if (DECL_HAS_VTT_PARM_P (clone))
4206 clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
4207 TREE_VALUE (orig_clone_parms),
4209 TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
4211 type = build_method_type_directly (basetype,
4212 TREE_TYPE (TREE_TYPE (clone)),
4215 type = build_exception_variant (type, exceptions);
4217 type = cp_build_type_attribute_variant (type, attrs);
4218 TREE_TYPE (clone) = type;
4220 clone_parms = NULL_TREE;
4224 gcc_assert (!clone_parms);
4228 /* For each of the constructors and destructors in T, create an
4229 in-charge and not-in-charge variant. */
4232 clone_constructors_and_destructors (tree t)
4236 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4238 if (!CLASSTYPE_METHOD_VEC (t))
4241 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4242 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4243 for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4244 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4247 /* Returns true iff class T has a user-defined constructor other than
4248 the default constructor. */
4251 type_has_user_nondefault_constructor (tree t)
4255 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4258 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4260 tree fn = OVL_CURRENT (fns);
4261 if (!DECL_ARTIFICIAL (fn)
4262 && (TREE_CODE (fn) == TEMPLATE_DECL
4263 || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
4271 /* Returns the defaulted constructor if T has one. Otherwise, returns
4275 in_class_defaulted_default_constructor (tree t)
4279 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4282 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4284 tree fn = OVL_CURRENT (fns);
4286 if (DECL_DEFAULTED_IN_CLASS_P (fn))
4288 args = FUNCTION_FIRST_USER_PARMTYPE (fn);
4289 while (args && TREE_PURPOSE (args))
4290 args = TREE_CHAIN (args);
4291 if (!args || args == void_list_node)
4299 /* Returns true iff FN is a user-provided function, i.e. user-declared
4300 and not defaulted at its first declaration; or explicit, private,
4301 protected, or non-const. */
4304 user_provided_p (tree fn)
4306 if (TREE_CODE (fn) == TEMPLATE_DECL)
4309 return (!DECL_ARTIFICIAL (fn)
4310 && !DECL_DEFAULTED_IN_CLASS_P (fn));
4313 /* Returns true iff class T has a user-provided constructor. */
4316 type_has_user_provided_constructor (tree t)
4320 if (!CLASS_TYPE_P (t))
4323 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4326 /* This can happen in error cases; avoid crashing. */
4327 if (!CLASSTYPE_METHOD_VEC (t))
4330 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4331 if (user_provided_p (OVL_CURRENT (fns)))
4337 /* Returns true iff class T has a user-provided default constructor. */
4340 type_has_user_provided_default_constructor (tree t)
4344 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4347 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4349 tree fn = OVL_CURRENT (fns);
4350 if (TREE_CODE (fn) == FUNCTION_DECL
4351 && user_provided_p (fn)
4352 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn)))
4359 /* Returns true iff for class T, a trivial synthesized default constructor
4360 would be constexpr. */
4363 trivial_default_constructor_is_constexpr (tree t)
4365 /* A defaulted trivial default constructor is constexpr
4366 if there is nothing to initialize. */
4367 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (t));
4368 return is_really_empty_class (t);
4371 /* Returns true iff class T has a constexpr default constructor. */
4374 type_has_constexpr_default_constructor (tree t)
4378 if (!CLASS_TYPE_P (t))
4380 /* The caller should have stripped an enclosing array. */
4381 gcc_assert (TREE_CODE (t) != ARRAY_TYPE);
4384 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t))
4386 if (!TYPE_HAS_COMPLEX_DFLT (t))
4387 return trivial_default_constructor_is_constexpr (t);
4388 /* Non-trivial, we need to check subobject constructors. */
4389 lazily_declare_fn (sfk_constructor, t);
4391 fns = locate_ctor (t);
4392 return (fns && DECL_DECLARED_CONSTEXPR_P (fns));
4395 /* Returns true iff class TYPE has a virtual destructor. */
4398 type_has_virtual_destructor (tree type)
4402 if (!CLASS_TYPE_P (type))
4405 gcc_assert (COMPLETE_TYPE_P (type));
4406 dtor = CLASSTYPE_DESTRUCTORS (type);
4407 return (dtor && DECL_VIRTUAL_P (dtor));
4410 /* Returns true iff class T has a move constructor. */
4413 type_has_move_constructor (tree t)
4417 if (CLASSTYPE_LAZY_MOVE_CTOR (t))
4419 gcc_assert (COMPLETE_TYPE_P (t));
4420 lazily_declare_fn (sfk_move_constructor, t);
4423 if (!CLASSTYPE_METHOD_VEC (t))
4426 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4427 if (move_fn_p (OVL_CURRENT (fns)))
4433 /* Returns true iff class T has a move assignment operator. */
4436 type_has_move_assign (tree t)
4440 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t))
4442 gcc_assert (COMPLETE_TYPE_P (t));
4443 lazily_declare_fn (sfk_move_assignment, t);
4446 for (fns = lookup_fnfields_slot (t, ansi_assopname (NOP_EXPR));
4447 fns; fns = OVL_NEXT (fns))
4448 if (move_fn_p (OVL_CURRENT (fns)))
4454 /* Nonzero if we need to build up a constructor call when initializing an
4455 object of this class, either because it has a user-provided constructor
4456 or because it doesn't have a default constructor (so we need to give an
4457 error if no initializer is provided). Use TYPE_NEEDS_CONSTRUCTING when
4458 what you care about is whether or not an object can be produced by a
4459 constructor (e.g. so we don't set TREE_READONLY on const variables of
4460 such type); use this function when what you care about is whether or not
4461 to try to call a constructor to create an object. The latter case is
4462 the former plus some cases of constructors that cannot be called. */
4465 type_build_ctor_call (tree t)
4468 if (TYPE_NEEDS_CONSTRUCTING (t))
4470 inner = strip_array_types (t);
4471 return (CLASS_TYPE_P (inner) && !TYPE_HAS_DEFAULT_CONSTRUCTOR (inner)
4472 && !ANON_AGGR_TYPE_P (inner));
4475 /* Remove all zero-width bit-fields from T. */
4478 remove_zero_width_bit_fields (tree t)
4482 fieldsp = &TYPE_FIELDS (t);
4485 if (TREE_CODE (*fieldsp) == FIELD_DECL
4486 && DECL_C_BIT_FIELD (*fieldsp)
4487 /* We should not be confused by the fact that grokbitfield
4488 temporarily sets the width of the bit field into
4489 DECL_INITIAL (*fieldsp).
4490 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
4492 && integer_zerop (DECL_SIZE (*fieldsp)))
4493 *fieldsp = DECL_CHAIN (*fieldsp);
4495 fieldsp = &DECL_CHAIN (*fieldsp);
4499 /* Returns TRUE iff we need a cookie when dynamically allocating an
4500 array whose elements have the indicated class TYPE. */
4503 type_requires_array_cookie (tree type)
4506 bool has_two_argument_delete_p = false;
4508 gcc_assert (CLASS_TYPE_P (type));
4510 /* If there's a non-trivial destructor, we need a cookie. In order
4511 to iterate through the array calling the destructor for each
4512 element, we'll have to know how many elements there are. */
4513 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4516 /* If the usual deallocation function is a two-argument whose second
4517 argument is of type `size_t', then we have to pass the size of
4518 the array to the deallocation function, so we will need to store
4520 fns = lookup_fnfields (TYPE_BINFO (type),
4521 ansi_opname (VEC_DELETE_EXPR),
4523 /* If there are no `operator []' members, or the lookup is
4524 ambiguous, then we don't need a cookie. */
4525 if (!fns || fns == error_mark_node)
4527 /* Loop through all of the functions. */
4528 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4533 /* Select the current function. */
4534 fn = OVL_CURRENT (fns);
4535 /* See if this function is a one-argument delete function. If
4536 it is, then it will be the usual deallocation function. */
4537 second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4538 if (second_parm == void_list_node)
4540 /* Do not consider this function if its second argument is an
4544 /* Otherwise, if we have a two-argument function and the second
4545 argument is `size_t', it will be the usual deallocation
4546 function -- unless there is one-argument function, too. */
4547 if (TREE_CHAIN (second_parm) == void_list_node
4548 && same_type_p (TREE_VALUE (second_parm), size_type_node))
4549 has_two_argument_delete_p = true;
4552 return has_two_argument_delete_p;
4555 /* Finish computing the `literal type' property of class type T.
4557 At this point, we have already processed base classes and
4558 non-static data members. We need to check whether the copy
4559 constructor is trivial, the destructor is trivial, and there
4560 is a trivial default constructor or at least one constexpr
4561 constructor other than the copy constructor. */
4564 finalize_literal_type_property (tree t)
4568 if (cxx_dialect < cxx0x
4569 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
4570 CLASSTYPE_LITERAL_P (t) = false;
4571 else if (CLASSTYPE_LITERAL_P (t) && !TYPE_HAS_TRIVIAL_DFLT (t)
4572 && CLASSTYPE_NON_AGGREGATE (t)
4573 && !TYPE_HAS_CONSTEXPR_CTOR (t))
4574 CLASSTYPE_LITERAL_P (t) = false;
4576 if (!CLASSTYPE_LITERAL_P (t))
4577 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4578 if (DECL_DECLARED_CONSTEXPR_P (fn)
4579 && TREE_CODE (fn) != TEMPLATE_DECL
4580 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
4581 && !DECL_CONSTRUCTOR_P (fn))
4583 DECL_DECLARED_CONSTEXPR_P (fn) = false;
4584 if (!DECL_GENERATED_P (fn))
4586 error ("enclosing class of constexpr non-static member "
4587 "function %q+#D is not a literal type", fn);
4588 explain_non_literal_class (t);
4593 /* T is a non-literal type used in a context which requires a constant
4594 expression. Explain why it isn't literal. */
4597 explain_non_literal_class (tree t)
4599 static struct pointer_set_t *diagnosed;
4601 if (!CLASS_TYPE_P (t))
4603 t = TYPE_MAIN_VARIANT (t);
4605 if (diagnosed == NULL)
4606 diagnosed = pointer_set_create ();
4607 if (pointer_set_insert (diagnosed, t) != 0)
4608 /* Already explained. */
4611 inform (0, "%q+T is not literal because:", t);
4612 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
4613 inform (0, " %q+T has a non-trivial destructor", t);
4614 else if (CLASSTYPE_NON_AGGREGATE (t)
4615 && !TYPE_HAS_TRIVIAL_DFLT (t)
4616 && !TYPE_HAS_CONSTEXPR_CTOR (t))
4618 inform (0, " %q+T is not an aggregate, does not have a trivial "
4619 "default constructor, and has no constexpr constructor that "
4620 "is not a copy or move constructor", t);
4621 if (TYPE_HAS_DEFAULT_CONSTRUCTOR (t)
4622 && !type_has_user_provided_default_constructor (t))
4623 explain_invalid_constexpr_fn (locate_ctor (t));
4627 tree binfo, base_binfo, field; int i;
4628 for (binfo = TYPE_BINFO (t), i = 0;
4629 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4631 tree basetype = TREE_TYPE (base_binfo);
4632 if (!CLASSTYPE_LITERAL_P (basetype))
4634 inform (0, " base class %qT of %q+T is non-literal",
4636 explain_non_literal_class (basetype);
4640 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4643 if (TREE_CODE (field) != FIELD_DECL)
4645 ftype = TREE_TYPE (field);
4646 if (!literal_type_p (ftype))
4648 inform (0, " non-static data member %q+D has "
4649 "non-literal type", field);
4650 if (CLASS_TYPE_P (ftype))
4651 explain_non_literal_class (ftype);
4657 /* Check the validity of the bases and members declared in T. Add any
4658 implicitly-generated functions (like copy-constructors and
4659 assignment operators). Compute various flag bits (like
4660 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
4661 level: i.e., independently of the ABI in use. */
4664 check_bases_and_members (tree t)
4666 /* Nonzero if the implicitly generated copy constructor should take
4667 a non-const reference argument. */
4668 int cant_have_const_ctor;
4669 /* Nonzero if the implicitly generated assignment operator
4670 should take a non-const reference argument. */
4671 int no_const_asn_ref;
4673 bool saved_complex_asn_ref;
4674 bool saved_nontrivial_dtor;
4677 /* By default, we use const reference arguments and generate default
4679 cant_have_const_ctor = 0;
4680 no_const_asn_ref = 0;
4682 /* Check all the base-classes. */
4683 check_bases (t, &cant_have_const_ctor,
4686 /* Check all the method declarations. */
4689 /* Save the initial values of these flags which only indicate whether
4690 or not the class has user-provided functions. As we analyze the
4691 bases and members we can set these flags for other reasons. */
4692 saved_complex_asn_ref = TYPE_HAS_COMPLEX_COPY_ASSIGN (t);
4693 saved_nontrivial_dtor = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
4695 /* Check all the data member declarations. We cannot call
4696 check_field_decls until we have called check_bases check_methods,
4697 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4698 being set appropriately. */
4699 check_field_decls (t, &access_decls,
4700 &cant_have_const_ctor,
4703 /* A nearly-empty class has to be vptr-containing; a nearly empty
4704 class contains just a vptr. */
4705 if (!TYPE_CONTAINS_VPTR_P (t))
4706 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4708 /* Do some bookkeeping that will guide the generation of implicitly
4709 declared member functions. */
4710 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t);
4711 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t);
4712 /* We need to call a constructor for this class if it has a
4713 user-provided constructor, or if the default constructor is going
4714 to initialize the vptr. (This is not an if-and-only-if;
4715 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
4716 themselves need constructing.) */
4717 TYPE_NEEDS_CONSTRUCTING (t)
4718 |= (type_has_user_provided_constructor (t) || TYPE_CONTAINS_VPTR_P (t));
4721 An aggregate is an array or a class with no user-provided
4722 constructors ... and no virtual functions.
4724 Again, other conditions for being an aggregate are checked
4726 CLASSTYPE_NON_AGGREGATE (t)
4727 |= (type_has_user_provided_constructor (t) || TYPE_POLYMORPHIC_P (t));
4728 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
4729 retain the old definition internally for ABI reasons. */
4730 CLASSTYPE_NON_LAYOUT_POD_P (t)
4731 |= (CLASSTYPE_NON_AGGREGATE (t)
4732 || saved_nontrivial_dtor || saved_complex_asn_ref);
4733 CLASSTYPE_NON_STD_LAYOUT (t) |= TYPE_CONTAINS_VPTR_P (t);
4734 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t);
4735 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t);
4736 TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_CONTAINS_VPTR_P (t);
4738 /* If the class has no user-declared constructor, but does have
4739 non-static const or reference data members that can never be
4740 initialized, issue a warning. */
4741 if (warn_uninitialized
4742 /* Classes with user-declared constructors are presumed to
4743 initialize these members. */
4744 && !TYPE_HAS_USER_CONSTRUCTOR (t)
4745 /* Aggregates can be initialized with brace-enclosed
4747 && CLASSTYPE_NON_AGGREGATE (t))
4751 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4755 if (TREE_CODE (field) != FIELD_DECL)
4758 type = TREE_TYPE (field);
4759 if (TREE_CODE (type) == REFERENCE_TYPE)
4760 warning (OPT_Wuninitialized, "non-static reference %q+#D "
4761 "in class without a constructor", field);
4762 else if (CP_TYPE_CONST_P (type)
4763 && (!CLASS_TYPE_P (type)
4764 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4765 warning (OPT_Wuninitialized, "non-static const member %q+#D "
4766 "in class without a constructor", field);
4770 /* Synthesize any needed methods. */
4771 add_implicitly_declared_members (t,
4772 cant_have_const_ctor,
4775 /* Check defaulted declarations here so we have cant_have_const_ctor
4776 and don't need to worry about clones. */
4777 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4778 if (DECL_DEFAULTED_IN_CLASS_P (fn))
4780 int copy = copy_fn_p (fn);
4784 = (DECL_CONSTRUCTOR_P (fn) ? !cant_have_const_ctor
4785 : !no_const_asn_ref);
4786 bool fn_const_p = (copy == 2);
4788 if (fn_const_p && !imp_const_p)
4789 /* If the function is defaulted outside the class, we just
4790 give the synthesis error. */
4791 error ("%q+D declared to take const reference, but implicit "
4792 "declaration would take non-const", fn);
4793 else if (imp_const_p && !fn_const_p)
4794 error ("%q+D declared to take non-const reference cannot be "
4795 "defaulted in the class body", fn);
4797 defaulted_late_check (fn);
4800 if (LAMBDA_TYPE_P (t))
4802 /* "The closure type associated with a lambda-expression has a deleted
4803 default constructor and a deleted copy assignment operator." */
4804 TYPE_NEEDS_CONSTRUCTING (t) = 1;
4805 TYPE_HAS_COMPLEX_DFLT (t) = 1;
4806 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
4807 CLASSTYPE_LAZY_MOVE_ASSIGN (t) = 0;
4809 /* "This class type is not an aggregate." */
4810 CLASSTYPE_NON_AGGREGATE (t) = 1;
4813 /* Compute the 'literal type' property before we
4814 do anything with non-static member functions. */
4815 finalize_literal_type_property (t);
4817 /* Create the in-charge and not-in-charge variants of constructors
4819 clone_constructors_and_destructors (t);
4821 /* Process the using-declarations. */
4822 for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4823 handle_using_decl (TREE_VALUE (access_decls), t);
4825 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4826 finish_struct_methods (t);
4828 /* Figure out whether or not we will need a cookie when dynamically
4829 allocating an array of this type. */
4830 TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4831 = type_requires_array_cookie (t);
4834 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4835 accordingly. If a new vfield was created (because T doesn't have a
4836 primary base class), then the newly created field is returned. It
4837 is not added to the TYPE_FIELDS list; it is the caller's
4838 responsibility to do that. Accumulate declared virtual functions
4842 create_vtable_ptr (tree t, tree* virtuals_p)
4846 /* Collect the virtual functions declared in T. */
4847 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4848 if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4849 && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4851 tree new_virtual = make_node (TREE_LIST);
4853 BV_FN (new_virtual) = fn;
4854 BV_DELTA (new_virtual) = integer_zero_node;
4855 BV_VCALL_INDEX (new_virtual) = NULL_TREE;
4857 TREE_CHAIN (new_virtual) = *virtuals_p;
4858 *virtuals_p = new_virtual;
4861 /* If we couldn't find an appropriate base class, create a new field
4862 here. Even if there weren't any new virtual functions, we might need a
4863 new virtual function table if we're supposed to include vptrs in
4864 all classes that need them. */
4865 if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4867 /* We build this decl with vtbl_ptr_type_node, which is a
4868 `vtable_entry_type*'. It might seem more precise to use
4869 `vtable_entry_type (*)[N]' where N is the number of virtual
4870 functions. However, that would require the vtable pointer in
4871 base classes to have a different type than the vtable pointer
4872 in derived classes. We could make that happen, but that
4873 still wouldn't solve all the problems. In particular, the
4874 type-based alias analysis code would decide that assignments
4875 to the base class vtable pointer can't alias assignments to
4876 the derived class vtable pointer, since they have different
4877 types. Thus, in a derived class destructor, where the base
4878 class constructor was inlined, we could generate bad code for
4879 setting up the vtable pointer.
4881 Therefore, we use one type for all vtable pointers. We still
4882 use a type-correct type; it's just doesn't indicate the array
4883 bounds. That's better than using `void*' or some such; it's
4884 cleaner, and it let's the alias analysis code know that these
4885 stores cannot alias stores to void*! */
4888 field = build_decl (input_location,
4889 FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4890 DECL_VIRTUAL_P (field) = 1;
4891 DECL_ARTIFICIAL (field) = 1;
4892 DECL_FIELD_CONTEXT (field) = t;
4893 DECL_FCONTEXT (field) = t;
4894 if (TYPE_PACKED (t))
4895 DECL_PACKED (field) = 1;
4897 TYPE_VFIELD (t) = field;
4899 /* This class is non-empty. */
4900 CLASSTYPE_EMPTY_P (t) = 0;
4908 /* Add OFFSET to all base types of BINFO which is a base in the
4909 hierarchy dominated by T.
4911 OFFSET, which is a type offset, is number of bytes. */
4914 propagate_binfo_offsets (tree binfo, tree offset)
4920 /* Update BINFO's offset. */
4921 BINFO_OFFSET (binfo)
4922 = convert (sizetype,
4923 size_binop (PLUS_EXPR,
4924 convert (ssizetype, BINFO_OFFSET (binfo)),
4927 /* Find the primary base class. */
4928 primary_binfo = get_primary_binfo (binfo);
4930 if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
4931 propagate_binfo_offsets (primary_binfo, offset);
4933 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4935 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4937 /* Don't do the primary base twice. */
4938 if (base_binfo == primary_binfo)
4941 if (BINFO_VIRTUAL_P (base_binfo))
4944 propagate_binfo_offsets (base_binfo, offset);
4948 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
4949 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4950 empty subobjects of T. */
4953 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4957 bool first_vbase = true;
4960 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
4963 if (!abi_version_at_least(2))
4965 /* In G++ 3.2, we incorrectly rounded the size before laying out
4966 the virtual bases. */
4967 finish_record_layout (rli, /*free_p=*/false);
4968 #ifdef STRUCTURE_SIZE_BOUNDARY
4969 /* Packed structures don't need to have minimum size. */
4970 if (! TYPE_PACKED (t))
4971 TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4973 rli->offset = TYPE_SIZE_UNIT (t);
4974 rli->bitpos = bitsize_zero_node;
4975 rli->record_align = TYPE_ALIGN (t);
4978 /* Find the last field. The artificial fields created for virtual
4979 bases will go after the last extant field to date. */
4980 next_field = &TYPE_FIELDS (t);
4982 next_field = &DECL_CHAIN (*next_field);
4984 /* Go through the virtual bases, allocating space for each virtual
4985 base that is not already a primary base class. These are
4986 allocated in inheritance graph order. */
4987 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4989 if (!BINFO_VIRTUAL_P (vbase))
4992 if (!BINFO_PRIMARY_P (vbase))
4994 tree basetype = TREE_TYPE (vbase);
4996 /* This virtual base is not a primary base of any class in the
4997 hierarchy, so we have to add space for it. */
4998 next_field = build_base_field (rli, vbase,
4999 offsets, next_field);
5001 /* If the first virtual base might have been placed at a
5002 lower address, had we started from CLASSTYPE_SIZE, rather
5003 than TYPE_SIZE, issue a warning. There can be both false
5004 positives and false negatives from this warning in rare
5005 cases; to deal with all the possibilities would probably
5006 require performing both layout algorithms and comparing
5007 the results which is not particularly tractable. */
5011 (size_binop (CEIL_DIV_EXPR,
5012 round_up_loc (input_location,
5014 CLASSTYPE_ALIGN (basetype)),
5016 BINFO_OFFSET (vbase))))
5018 "offset of virtual base %qT is not ABI-compliant and "
5019 "may change in a future version of GCC",
5022 first_vbase = false;
5027 /* Returns the offset of the byte just past the end of the base class
5031 end_of_base (tree binfo)
5035 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo)))
5036 size = TYPE_SIZE_UNIT (char_type_node);
5037 else if (is_empty_class (BINFO_TYPE (binfo)))
5038 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5039 allocate some space for it. It cannot have virtual bases, so
5040 TYPE_SIZE_UNIT is fine. */
5041 size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
5043 size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
5045 return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
5048 /* Returns the offset of the byte just past the end of the base class
5049 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
5050 only non-virtual bases are included. */
5053 end_of_class (tree t, int include_virtuals_p)
5055 tree result = size_zero_node;
5056 VEC(tree,gc) *vbases;
5062 for (binfo = TYPE_BINFO (t), i = 0;
5063 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
5065 if (!include_virtuals_p
5066 && BINFO_VIRTUAL_P (base_binfo)
5067 && (!BINFO_PRIMARY_P (base_binfo)
5068 || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
5071 offset = end_of_base (base_binfo);
5072 if (INT_CST_LT_UNSIGNED (result, offset))
5076 /* G++ 3.2 did not check indirect virtual bases. */
5077 if (abi_version_at_least (2) && include_virtuals_p)
5078 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
5079 VEC_iterate (tree, vbases, i, base_binfo); i++)
5081 offset = end_of_base (base_binfo);
5082 if (INT_CST_LT_UNSIGNED (result, offset))
5089 /* Warn about bases of T that are inaccessible because they are
5090 ambiguous. For example:
5093 struct T : public S {};
5094 struct U : public S, public T {};
5096 Here, `(S*) new U' is not allowed because there are two `S'
5100 warn_about_ambiguous_bases (tree t)
5103 VEC(tree,gc) *vbases;
5108 /* If there are no repeated bases, nothing can be ambiguous. */
5109 if (!CLASSTYPE_REPEATED_BASE_P (t))
5112 /* Check direct bases. */
5113 for (binfo = TYPE_BINFO (t), i = 0;
5114 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
5116 basetype = BINFO_TYPE (base_binfo);
5118 if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
5119 warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
5123 /* Check for ambiguous virtual bases. */
5125 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
5126 VEC_iterate (tree, vbases, i, binfo); i++)
5128 basetype = BINFO_TYPE (binfo);
5130 if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
5131 warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity",
5136 /* Compare two INTEGER_CSTs K1 and K2. */
5139 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
5141 return tree_int_cst_compare ((tree) k1, (tree) k2);
5144 /* Increase the size indicated in RLI to account for empty classes
5145 that are "off the end" of the class. */
5148 include_empty_classes (record_layout_info rli)
5153 /* It might be the case that we grew the class to allocate a
5154 zero-sized base class. That won't be reflected in RLI, yet,
5155 because we are willing to overlay multiple bases at the same
5156 offset. However, now we need to make sure that RLI is big enough
5157 to reflect the entire class. */
5158 eoc = end_of_class (rli->t,
5159 CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
5160 rli_size = rli_size_unit_so_far (rli);
5161 if (TREE_CODE (rli_size) == INTEGER_CST
5162 && INT_CST_LT_UNSIGNED (rli_size, eoc))
5164 if (!abi_version_at_least (2))
5165 /* In version 1 of the ABI, the size of a class that ends with
5166 a bitfield was not rounded up to a whole multiple of a
5167 byte. Because rli_size_unit_so_far returns only the number
5168 of fully allocated bytes, any extra bits were not included
5170 rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
5172 /* The size should have been rounded to a whole byte. */
5173 gcc_assert (tree_int_cst_equal
5174 (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
5176 = size_binop (PLUS_EXPR,
5178 size_binop (MULT_EXPR,
5179 convert (bitsizetype,
5180 size_binop (MINUS_EXPR,
5182 bitsize_int (BITS_PER_UNIT)));
5183 normalize_rli (rli);
5187 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5188 BINFO_OFFSETs for all of the base-classes. Position the vtable
5189 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
5192 layout_class_type (tree t, tree *virtuals_p)
5194 tree non_static_data_members;
5197 record_layout_info rli;
5198 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5199 types that appear at that offset. */
5200 splay_tree empty_base_offsets;
5201 /* True if the last field layed out was a bit-field. */
5202 bool last_field_was_bitfield = false;
5203 /* The location at which the next field should be inserted. */
5205 /* T, as a base class. */
5208 /* Keep track of the first non-static data member. */
5209 non_static_data_members = TYPE_FIELDS (t);
5211 /* Start laying out the record. */
5212 rli = start_record_layout (t);
5214 /* Mark all the primary bases in the hierarchy. */
5215 determine_primary_bases (t);
5217 /* Create a pointer to our virtual function table. */
5218 vptr = create_vtable_ptr (t, virtuals_p);
5220 /* The vptr is always the first thing in the class. */
5223 DECL_CHAIN (vptr) = TYPE_FIELDS (t);
5224 TYPE_FIELDS (t) = vptr;
5225 next_field = &DECL_CHAIN (vptr);
5226 place_field (rli, vptr);
5229 next_field = &TYPE_FIELDS (t);
5231 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5232 empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
5234 build_base_fields (rli, empty_base_offsets, next_field);
5236 /* Layout the non-static data members. */
5237 for (field = non_static_data_members; field; field = DECL_CHAIN (field))
5242 /* We still pass things that aren't non-static data members to
5243 the back end, in case it wants to do something with them. */
5244 if (TREE_CODE (field) != FIELD_DECL)
5246 place_field (rli, field);
5247 /* If the static data member has incomplete type, keep track
5248 of it so that it can be completed later. (The handling
5249 of pending statics in finish_record_layout is
5250 insufficient; consider:
5253 struct S2 { static S1 s1; };
5255 At this point, finish_record_layout will be called, but
5256 S1 is still incomplete.) */
5257 if (TREE_CODE (field) == VAR_DECL)
5259 maybe_register_incomplete_var (field);
5260 /* The visibility of static data members is determined
5261 at their point of declaration, not their point of
5263 determine_visibility (field);
5268 type = TREE_TYPE (field);
5269 if (type == error_mark_node)
5272 padding = NULL_TREE;
5274 /* If this field is a bit-field whose width is greater than its
5275 type, then there are some special rules for allocating
5277 if (DECL_C_BIT_FIELD (field)
5278 && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
5282 bool was_unnamed_p = false;
5283 /* We must allocate the bits as if suitably aligned for the
5284 longest integer type that fits in this many bits. type
5285 of the field. Then, we are supposed to use the left over
5286 bits as additional padding. */
5287 for (itk = itk_char; itk != itk_none; ++itk)
5288 if (integer_types[itk] != NULL_TREE
5289 && (INT_CST_LT (size_int (MAX_FIXED_MODE_SIZE),
5290 TYPE_SIZE (integer_types[itk]))
5291 || INT_CST_LT (DECL_SIZE (field),
5292 TYPE_SIZE (integer_types[itk]))))
5295 /* ITK now indicates a type that is too large for the
5296 field. We have to back up by one to find the largest
5301 integer_type = integer_types[itk];
5302 } while (itk > 0 && integer_type == NULL_TREE);
5304 /* Figure out how much additional padding is required. GCC
5305 3.2 always created a padding field, even if it had zero
5307 if (!abi_version_at_least (2)
5308 || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
5310 if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
5311 /* In a union, the padding field must have the full width
5312 of the bit-field; all fields start at offset zero. */
5313 padding = DECL_SIZE (field);
5316 if (TREE_CODE (t) == UNION_TYPE)
5317 warning (OPT_Wabi, "size assigned to %qT may not be "
5318 "ABI-compliant and may change in a future "
5321 padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
5322 TYPE_SIZE (integer_type));
5325 #ifdef PCC_BITFIELD_TYPE_MATTERS
5326 /* An unnamed bitfield does not normally affect the
5327 alignment of the containing class on a target where
5328 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
5329 make any exceptions for unnamed bitfields when the
5330 bitfields are longer than their types. Therefore, we
5331 temporarily give the field a name. */
5332 if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
5334 was_unnamed_p = true;
5335 DECL_NAME (field) = make_anon_name ();
5338 DECL_SIZE (field) = TYPE_SIZE (integer_type);
5339 DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
5340 DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
5341 layout_nonempty_base_or_field (rli, field, NULL_TREE,
5342 empty_base_offsets);
5344 DECL_NAME (field) = NULL_TREE;
5345 /* Now that layout has been performed, set the size of the
5346 field to the size of its declared type; the rest of the
5347 field is effectively invisible. */
5348 DECL_SIZE (field) = TYPE_SIZE (type);
5349 /* We must also reset the DECL_MODE of the field. */
5350 if (abi_version_at_least (2))
5351 DECL_MODE (field) = TYPE_MODE (type);
5353 && DECL_MODE (field) != TYPE_MODE (type))
5354 /* Versions of G++ before G++ 3.4 did not reset the
5357 "the offset of %qD may not be ABI-compliant and may "
5358 "change in a future version of GCC", field);
5361 layout_nonempty_base_or_field (rli, field, NULL_TREE,
5362 empty_base_offsets);
5364 /* Remember the location of any empty classes in FIELD. */
5365 if (abi_version_at_least (2))
5366 record_subobject_offsets (TREE_TYPE (field),
5367 byte_position(field),
5369 /*is_data_member=*/true);
5371 /* If a bit-field does not immediately follow another bit-field,
5372 and yet it starts in the middle of a byte, we have failed to
5373 comply with the ABI. */
5375 && DECL_C_BIT_FIELD (field)
5376 /* The TREE_NO_WARNING flag gets set by Objective-C when
5377 laying out an Objective-C class. The ObjC ABI differs
5378 from the C++ ABI, and so we do not want a warning
5380 && !TREE_NO_WARNING (field)
5381 && !last_field_was_bitfield
5382 && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
5383 DECL_FIELD_BIT_OFFSET (field),
5384 bitsize_unit_node)))
5385 warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may "
5386 "change in a future version of GCC", field);
5388 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
5389 offset of the field. */
5391 && !abi_version_at_least (2)
5392 && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
5393 byte_position (field))
5394 && contains_empty_class_p (TREE_TYPE (field)))
5395 warning (OPT_Wabi, "%q+D contains empty classes which may cause base "
5396 "classes to be placed at different locations in a "
5397 "future version of GCC", field);
5399 /* The middle end uses the type of expressions to determine the
5400 possible range of expression values. In order to optimize
5401 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
5402 must be made aware of the width of "i", via its type.
5404 Because C++ does not have integer types of arbitrary width,
5405 we must (for the purposes of the front end) convert from the
5406 type assigned here to the declared type of the bitfield
5407 whenever a bitfield expression is used as an rvalue.
5408 Similarly, when assigning a value to a bitfield, the value
5409 must be converted to the type given the bitfield here. */
5410 if (DECL_C_BIT_FIELD (field))
5412 unsigned HOST_WIDE_INT width;
5413 tree ftype = TREE_TYPE (field);
5414 width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1);
5415 if (width != TYPE_PRECISION (ftype))
5418 = c_build_bitfield_integer_type (width,
5419 TYPE_UNSIGNED (ftype));
5421 = cp_build_qualified_type (TREE_TYPE (field),
5422 cp_type_quals (ftype));
5426 /* If we needed additional padding after this field, add it
5432 padding_field = build_decl (input_location,
5436 DECL_BIT_FIELD (padding_field) = 1;
5437 DECL_SIZE (padding_field) = padding;
5438 DECL_CONTEXT (padding_field) = t;
5439 DECL_ARTIFICIAL (padding_field) = 1;
5440 DECL_IGNORED_P (padding_field) = 1;
5441 layout_nonempty_base_or_field (rli, padding_field,
5443 empty_base_offsets);
5446 last_field_was_bitfield = DECL_C_BIT_FIELD (field);
5449 if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
5451 /* Make sure that we are on a byte boundary so that the size of
5452 the class without virtual bases will always be a round number
5454 rli->bitpos = round_up_loc (input_location, rli->bitpos, BITS_PER_UNIT);
5455 normalize_rli (rli);
5458 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5460 if (!abi_version_at_least (2))
5461 include_empty_classes(rli);
5463 /* Delete all zero-width bit-fields from the list of fields. Now
5464 that the type is laid out they are no longer important. */
5465 remove_zero_width_bit_fields (t);
5467 /* Create the version of T used for virtual bases. We do not use
5468 make_class_type for this version; this is an artificial type. For
5469 a POD type, we just reuse T. */
5470 if (CLASSTYPE_NON_LAYOUT_POD_P (t) || CLASSTYPE_EMPTY_P (t))
5472 base_t = make_node (TREE_CODE (t));
5474 /* Set the size and alignment for the new type. In G++ 3.2, all
5475 empty classes were considered to have size zero when used as
5477 if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
5479 TYPE_SIZE (base_t) = bitsize_zero_node;
5480 TYPE_SIZE_UNIT (base_t) = size_zero_node;
5481 if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
5483 "layout of classes derived from empty class %qT "
5484 "may change in a future version of GCC",
5491 /* If the ABI version is not at least two, and the last
5492 field was a bit-field, RLI may not be on a byte
5493 boundary. In particular, rli_size_unit_so_far might
5494 indicate the last complete byte, while rli_size_so_far
5495 indicates the total number of bits used. Therefore,
5496 rli_size_so_far, rather than rli_size_unit_so_far, is
5497 used to compute TYPE_SIZE_UNIT. */
5498 eoc = end_of_class (t, /*include_virtuals_p=*/0);
5499 TYPE_SIZE_UNIT (base_t)
5500 = size_binop (MAX_EXPR,
5502 size_binop (CEIL_DIV_EXPR,
5503 rli_size_so_far (rli),
5504 bitsize_int (BITS_PER_UNIT))),
5507 = size_binop (MAX_EXPR,
5508 rli_size_so_far (rli),
5509 size_binop (MULT_EXPR,
5510 convert (bitsizetype, eoc),
5511 bitsize_int (BITS_PER_UNIT)));
5513 TYPE_ALIGN (base_t) = rli->record_align;
5514 TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
5516 /* Copy the fields from T. */
5517 next_field = &TYPE_FIELDS (base_t);
5518 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
5519 if (TREE_CODE (field) == FIELD_DECL)
5521 *next_field = build_decl (input_location,
5525 DECL_CONTEXT (*next_field) = base_t;
5526 DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
5527 DECL_FIELD_BIT_OFFSET (*next_field)
5528 = DECL_FIELD_BIT_OFFSET (field);
5529 DECL_SIZE (*next_field) = DECL_SIZE (field);
5530 DECL_MODE (*next_field) = DECL_MODE (field);
5531 next_field = &DECL_CHAIN (*next_field);
5534 /* Record the base version of the type. */
5535 CLASSTYPE_AS_BASE (t) = base_t;
5536 TYPE_CONTEXT (base_t) = t;
5539 CLASSTYPE_AS_BASE (t) = t;
5541 /* Every empty class contains an empty class. */
5542 if (CLASSTYPE_EMPTY_P (t))
5543 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
5545 /* Set the TYPE_DECL for this type to contain the right
5546 value for DECL_OFFSET, so that we can use it as part
5547 of a COMPONENT_REF for multiple inheritance. */
5548 layout_decl (TYPE_MAIN_DECL (t), 0);
5550 /* Now fix up any virtual base class types that we left lying
5551 around. We must get these done before we try to lay out the
5552 virtual function table. As a side-effect, this will remove the
5553 base subobject fields. */
5554 layout_virtual_bases (rli, empty_base_offsets);
5556 /* Make sure that empty classes are reflected in RLI at this
5558 include_empty_classes(rli);
5560 /* Make sure not to create any structures with zero size. */
5561 if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
5563 build_decl (input_location,
5564 FIELD_DECL, NULL_TREE, char_type_node));
5566 /* If this is a non-POD, declaring it packed makes a difference to how it
5567 can be used as a field; don't let finalize_record_size undo it. */
5568 if (TYPE_PACKED (t) && !layout_pod_type_p (t))
5569 rli->packed_maybe_necessary = true;
5571 /* Let the back end lay out the type. */
5572 finish_record_layout (rli, /*free_p=*/true);
5574 /* Warn about bases that can't be talked about due to ambiguity. */
5575 warn_about_ambiguous_bases (t);
5577 /* Now that we're done with layout, give the base fields the real types. */
5578 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
5579 if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
5580 TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
5583 splay_tree_delete (empty_base_offsets);
5585 if (CLASSTYPE_EMPTY_P (t)
5586 && tree_int_cst_lt (sizeof_biggest_empty_class,
5587 TYPE_SIZE_UNIT (t)))
5588 sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
5591 /* Determine the "key method" for the class type indicated by TYPE,
5592 and set CLASSTYPE_KEY_METHOD accordingly. */
5595 determine_key_method (tree type)
5599 if (TYPE_FOR_JAVA (type)
5600 || processing_template_decl
5601 || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
5602 || CLASSTYPE_INTERFACE_KNOWN (type))
5605 /* The key method is the first non-pure virtual function that is not
5606 inline at the point of class definition. On some targets the
5607 key function may not be inline; those targets should not call
5608 this function until the end of the translation unit. */
5609 for (method = TYPE_METHODS (type); method != NULL_TREE;
5610 method = DECL_CHAIN (method))
5611 if (DECL_VINDEX (method) != NULL_TREE
5612 && ! DECL_DECLARED_INLINE_P (method)
5613 && ! DECL_PURE_VIRTUAL_P (method))
5615 CLASSTYPE_KEY_METHOD (type) = method;
5622 /* Perform processing required when the definition of T (a class type)
5626 finish_struct_1 (tree t)
5629 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
5630 tree virtuals = NULL_TREE;
5633 if (COMPLETE_TYPE_P (t))
5635 gcc_assert (MAYBE_CLASS_TYPE_P (t));
5636 error ("redefinition of %q#T", t);
5641 /* If this type was previously laid out as a forward reference,
5642 make sure we lay it out again. */
5643 TYPE_SIZE (t) = NULL_TREE;
5644 CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5646 /* Make assumptions about the class; we'll reset the flags if
5648 CLASSTYPE_EMPTY_P (t) = 1;
5649 CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5650 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5651 CLASSTYPE_LITERAL_P (t) = true;
5653 /* Do end-of-class semantic processing: checking the validity of the
5654 bases and members and add implicitly generated methods. */
5655 check_bases_and_members (t);
5657 /* Find the key method. */
5658 if (TYPE_CONTAINS_VPTR_P (t))
5660 /* The Itanium C++ ABI permits the key method to be chosen when
5661 the class is defined -- even though the key method so
5662 selected may later turn out to be an inline function. On
5663 some systems (such as ARM Symbian OS) the key method cannot
5664 be determined until the end of the translation unit. On such
5665 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5666 will cause the class to be added to KEYED_CLASSES. Then, in
5667 finish_file we will determine the key method. */
5668 if (targetm.cxx.key_method_may_be_inline ())
5669 determine_key_method (t);
5671 /* If a polymorphic class has no key method, we may emit the vtable
5672 in every translation unit where the class definition appears. */
5673 if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5674 keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5677 /* Layout the class itself. */
5678 layout_class_type (t, &virtuals);
5679 if (CLASSTYPE_AS_BASE (t) != t)
5680 /* We use the base type for trivial assignments, and hence it
5682 compute_record_mode (CLASSTYPE_AS_BASE (t));
5684 virtuals = modify_all_vtables (t, nreverse (virtuals));
5686 /* If necessary, create the primary vtable for this class. */
5687 if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5689 /* We must enter these virtuals into the table. */
5690 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5691 build_primary_vtable (NULL_TREE, t);
5692 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5693 /* Here we know enough to change the type of our virtual
5694 function table, but we will wait until later this function. */
5695 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5698 if (TYPE_CONTAINS_VPTR_P (t))
5703 if (BINFO_VTABLE (TYPE_BINFO (t)))
5704 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5705 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5706 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5708 /* Add entries for virtual functions introduced by this class. */
5709 BINFO_VIRTUALS (TYPE_BINFO (t))
5710 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5712 /* Set DECL_VINDEX for all functions declared in this class. */
5713 for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5715 fn = TREE_CHAIN (fn),
5716 vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5717 ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5719 tree fndecl = BV_FN (fn);
5721 if (DECL_THUNK_P (fndecl))
5722 /* A thunk. We should never be calling this entry directly
5723 from this vtable -- we'd use the entry for the non
5724 thunk base function. */
5725 DECL_VINDEX (fndecl) = NULL_TREE;
5726 else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5727 DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5731 finish_struct_bits (t);
5733 /* Complete the rtl for any static member objects of the type we're
5735 for (x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x))
5736 if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5737 && TREE_TYPE (x) != error_mark_node
5738 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5739 DECL_MODE (x) = TYPE_MODE (t);
5741 /* Done with FIELDS...now decide whether to sort these for
5742 faster lookups later.
5744 We use a small number because most searches fail (succeeding
5745 ultimately as the search bores through the inheritance
5746 hierarchy), and we want this failure to occur quickly. */
5748 n_fields = count_fields (TYPE_FIELDS (t));
5751 struct sorted_fields_type *field_vec = ggc_alloc_sorted_fields_type
5752 (sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5753 field_vec->len = n_fields;
5754 add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5755 qsort (field_vec->elts, n_fields, sizeof (tree),
5757 CLASSTYPE_SORTED_FIELDS (t) = field_vec;
5760 /* Complain if one of the field types requires lower visibility. */
5761 constrain_class_visibility (t);
5763 /* Make the rtl for any new vtables we have created, and unmark
5764 the base types we marked. */
5767 /* Build the VTT for T. */
5770 /* This warning does not make sense for Java classes, since they
5771 cannot have destructors. */
5772 if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t))
5776 dtor = CLASSTYPE_DESTRUCTORS (t);
5777 if (/* An implicitly declared destructor is always public. And,
5778 if it were virtual, we would have created it by now. */
5780 || (!DECL_VINDEX (dtor)
5781 && (/* public non-virtual */
5782 (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor))
5783 || (/* non-public non-virtual with friends */
5784 (TREE_PRIVATE (dtor) || TREE_PROTECTED (dtor))
5785 && (CLASSTYPE_FRIEND_CLASSES (t)
5786 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))))))
5787 warning (OPT_Wnon_virtual_dtor,
5788 "%q#T has virtual functions and accessible"
5789 " non-virtual destructor", t);
5794 if (warn_overloaded_virtual)
5797 /* Class layout, assignment of virtual table slots, etc., is now
5798 complete. Give the back end a chance to tweak the visibility of
5799 the class or perform any other required target modifications. */
5800 targetm.cxx.adjust_class_at_definition (t);
5802 maybe_suppress_debug_info (t);
5804 dump_class_hierarchy (t);
5806 /* Finish debugging output for this type. */
5807 rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5809 if (TYPE_TRANSPARENT_AGGR (t))
5811 tree field = first_field (t);
5812 if (field == NULL_TREE || error_operand_p (field))
5814 error ("type transparent class %qT does not have any fields", t);
5815 TYPE_TRANSPARENT_AGGR (t) = 0;
5817 else if (DECL_ARTIFICIAL (field))
5819 if (DECL_FIELD_IS_BASE (field))
5820 error ("type transparent class %qT has base classes", t);
5823 gcc_checking_assert (DECL_VIRTUAL_P (field));
5824 error ("type transparent class %qT has virtual functions", t);
5826 TYPE_TRANSPARENT_AGGR (t) = 0;
5831 /* When T was built up, the member declarations were added in reverse
5832 order. Rearrange them to declaration order. */
5835 unreverse_member_declarations (tree t)
5841 /* The following lists are all in reverse order. Put them in
5842 declaration order now. */
5843 TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5844 CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5846 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5847 reverse order, so we can't just use nreverse. */
5849 for (x = TYPE_FIELDS (t);
5850 x && TREE_CODE (x) != TYPE_DECL;
5853 next = DECL_CHAIN (x);
5854 DECL_CHAIN (x) = prev;
5859 DECL_CHAIN (TYPE_FIELDS (t)) = x;
5861 TYPE_FIELDS (t) = prev;
5866 finish_struct (tree t, tree attributes)
5868 location_t saved_loc = input_location;
5870 /* Now that we've got all the field declarations, reverse everything
5872 unreverse_member_declarations (t);
5874 cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5876 /* Nadger the current location so that diagnostics point to the start of
5877 the struct, not the end. */
5878 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5880 if (processing_template_decl)
5884 finish_struct_methods (t);
5885 TYPE_SIZE (t) = bitsize_zero_node;
5886 TYPE_SIZE_UNIT (t) = size_zero_node;
5888 /* We need to emit an error message if this type was used as a parameter
5889 and it is an abstract type, even if it is a template. We construct
5890 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5891 account and we call complete_vars with this type, which will check
5892 the PARM_DECLS. Note that while the type is being defined,
5893 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5894 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
5895 CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5896 for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x))
5897 if (DECL_PURE_VIRTUAL_P (x))
5898 VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
5901 /* Remember current #pragma pack value. */
5902 TYPE_PRECISION (t) = maximum_field_alignment;
5905 finish_struct_1 (t);
5907 input_location = saved_loc;
5909 TYPE_BEING_DEFINED (t) = 0;
5911 if (current_class_type)
5914 error ("trying to finish struct, but kicked out due to previous parse errors");
5916 if (processing_template_decl && at_function_scope_p ())
5917 add_stmt (build_min (TAG_DEFN, t));
5922 /* Return the dynamic type of INSTANCE, if known.
5923 Used to determine whether the virtual function table is needed
5926 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5927 of our knowledge of its type. *NONNULL should be initialized
5928 before this function is called. */
5931 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
5933 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5935 switch (TREE_CODE (instance))
5938 if (POINTER_TYPE_P (TREE_TYPE (instance)))
5941 return RECUR (TREE_OPERAND (instance, 0));
5944 /* This is a call to a constructor, hence it's never zero. */
5945 if (TREE_HAS_CONSTRUCTOR (instance))
5949 return TREE_TYPE (instance);
5954 /* This is a call to a constructor, hence it's never zero. */
5955 if (TREE_HAS_CONSTRUCTOR (instance))
5959 return TREE_TYPE (instance);
5961 return RECUR (TREE_OPERAND (instance, 0));
5963 case POINTER_PLUS_EXPR:
5966 if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5967 return RECUR (TREE_OPERAND (instance, 0));
5968 if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5969 /* Propagate nonnull. */
5970 return RECUR (TREE_OPERAND (instance, 0));
5975 return RECUR (TREE_OPERAND (instance, 0));
5978 instance = TREE_OPERAND (instance, 0);
5981 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5982 with a real object -- given &p->f, p can still be null. */
5983 tree t = get_base_address (instance);
5984 /* ??? Probably should check DECL_WEAK here. */
5985 if (t && DECL_P (t))
5988 return RECUR (instance);
5991 /* If this component is really a base class reference, then the field
5992 itself isn't definitive. */
5993 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5994 return RECUR (TREE_OPERAND (instance, 0));
5995 return RECUR (TREE_OPERAND (instance, 1));
5999 if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
6000 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance))))
6004 return TREE_TYPE (TREE_TYPE (instance));
6006 /* fall through... */
6010 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance)))
6014 return TREE_TYPE (instance);
6016 else if (instance == current_class_ptr)
6021 /* if we're in a ctor or dtor, we know our type. */
6022 if (DECL_LANG_SPECIFIC (current_function_decl)
6023 && (DECL_CONSTRUCTOR_P (current_function_decl)
6024 || DECL_DESTRUCTOR_P (current_function_decl)))
6028 return TREE_TYPE (TREE_TYPE (instance));
6031 else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
6033 /* We only need one hash table because it is always left empty. */
6036 ht = htab_create (37,
6041 /* Reference variables should be references to objects. */
6045 /* Enter the INSTANCE in a table to prevent recursion; a
6046 variable's initializer may refer to the variable
6048 if (TREE_CODE (instance) == VAR_DECL
6049 && DECL_INITIAL (instance)
6050 && !type_dependent_expression_p_push (DECL_INITIAL (instance))
6051 && !htab_find (ht, instance))
6056 slot = htab_find_slot (ht, instance, INSERT);
6058 type = RECUR (DECL_INITIAL (instance));
6059 htab_remove_elt (ht, instance);
6072 /* Return nonzero if the dynamic type of INSTANCE is known, and
6073 equivalent to the static type. We also handle the case where
6074 INSTANCE is really a pointer. Return negative if this is a
6075 ctor/dtor. There the dynamic type is known, but this might not be
6076 the most derived base of the original object, and hence virtual
6077 bases may not be layed out according to this type.
6079 Used to determine whether the virtual function table is needed
6082 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6083 of our knowledge of its type. *NONNULL should be initialized
6084 before this function is called. */
6087 resolves_to_fixed_type_p (tree instance, int* nonnull)
6089 tree t = TREE_TYPE (instance);
6093 if (processing_template_decl)
6095 /* In a template we only care about the type of the result. */
6101 fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
6102 if (fixed == NULL_TREE)
6104 if (POINTER_TYPE_P (t))
6106 if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
6108 return cdtorp ? -1 : 1;
6113 init_class_processing (void)
6115 current_class_depth = 0;
6116 current_class_stack_size = 10;
6118 = XNEWVEC (struct class_stack_node, current_class_stack_size);
6119 local_classes = VEC_alloc (tree, gc, 8);
6120 sizeof_biggest_empty_class = size_zero_node;
6122 ridpointers[(int) RID_PUBLIC] = access_public_node;
6123 ridpointers[(int) RID_PRIVATE] = access_private_node;
6124 ridpointers[(int) RID_PROTECTED] = access_protected_node;
6127 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
6130 restore_class_cache (void)
6134 /* We are re-entering the same class we just left, so we don't
6135 have to search the whole inheritance matrix to find all the
6136 decls to bind again. Instead, we install the cached
6137 class_shadowed list and walk through it binding names. */
6138 push_binding_level (previous_class_level);
6139 class_binding_level = previous_class_level;
6140 /* Restore IDENTIFIER_TYPE_VALUE. */
6141 for (type = class_binding_level->type_shadowed;
6143 type = TREE_CHAIN (type))
6144 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
6147 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
6148 appropriate for TYPE.
6150 So that we may avoid calls to lookup_name, we cache the _TYPE
6151 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
6153 For multiple inheritance, we perform a two-pass depth-first search
6154 of the type lattice. */
6157 pushclass (tree type)
6159 class_stack_node_t csn;
6161 type = TYPE_MAIN_VARIANT (type);
6163 /* Make sure there is enough room for the new entry on the stack. */
6164 if (current_class_depth + 1 >= current_class_stack_size)
6166 current_class_stack_size *= 2;
6168 = XRESIZEVEC (struct class_stack_node, current_class_stack,
6169 current_class_stack_size);
6172 /* Insert a new entry on the class stack. */
6173 csn = current_class_stack + current_class_depth;
6174 csn->name = current_class_name;
6175 csn->type = current_class_type;
6176 csn->access = current_access_specifier;
6177 csn->names_used = 0;
6179 current_class_depth++;
6181 /* Now set up the new type. */
6182 current_class_name = TYPE_NAME (type);
6183 if (TREE_CODE (current_class_name) == TYPE_DECL)
6184 current_class_name = DECL_NAME (current_class_name);
6185 current_class_type = type;
6187 /* By default, things in classes are private, while things in
6188 structures or unions are public. */
6189 current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
6190 ? access_private_node
6191 : access_public_node);
6193 if (previous_class_level
6194 && type != previous_class_level->this_entity
6195 && current_class_depth == 1)
6197 /* Forcibly remove any old class remnants. */
6198 invalidate_class_lookup_cache ();
6201 if (!previous_class_level
6202 || type != previous_class_level->this_entity
6203 || current_class_depth > 1)
6206 restore_class_cache ();
6209 /* When we exit a toplevel class scope, we save its binding level so
6210 that we can restore it quickly. Here, we've entered some other
6211 class, so we must invalidate our cache. */
6214 invalidate_class_lookup_cache (void)
6216 previous_class_level = NULL;
6219 /* Get out of the current class scope. If we were in a class scope
6220 previously, that is the one popped to. */
6227 current_class_depth--;
6228 current_class_name = current_class_stack[current_class_depth].name;
6229 current_class_type = current_class_stack[current_class_depth].type;
6230 current_access_specifier = current_class_stack[current_class_depth].access;
6231 if (current_class_stack[current_class_depth].names_used)
6232 splay_tree_delete (current_class_stack[current_class_depth].names_used);
6235 /* Mark the top of the class stack as hidden. */
6238 push_class_stack (void)
6240 if (current_class_depth)
6241 ++current_class_stack[current_class_depth - 1].hidden;
6244 /* Mark the top of the class stack as un-hidden. */
6247 pop_class_stack (void)
6249 if (current_class_depth)
6250 --current_class_stack[current_class_depth - 1].hidden;
6253 /* Returns 1 if the class type currently being defined is either T or
6254 a nested type of T. */
6257 currently_open_class (tree t)
6261 if (!CLASS_TYPE_P (t))
6264 t = TYPE_MAIN_VARIANT (t);
6266 /* We start looking from 1 because entry 0 is from global scope,
6268 for (i = current_class_depth; i > 0; --i)
6271 if (i == current_class_depth)
6272 c = current_class_type;
6275 if (current_class_stack[i].hidden)
6277 c = current_class_stack[i].type;
6281 if (same_type_p (c, t))
6287 /* If either current_class_type or one of its enclosing classes are derived
6288 from T, return the appropriate type. Used to determine how we found
6289 something via unqualified lookup. */
6292 currently_open_derived_class (tree t)
6296 /* The bases of a dependent type are unknown. */
6297 if (dependent_type_p (t))
6300 if (!current_class_type)
6303 if (DERIVED_FROM_P (t, current_class_type))
6304 return current_class_type;
6306 for (i = current_class_depth - 1; i > 0; --i)
6308 if (current_class_stack[i].hidden)
6310 if (DERIVED_FROM_P (t, current_class_stack[i].type))
6311 return current_class_stack[i].type;
6317 /* Returns the innermost class type which is not a lambda closure type. */
6320 current_nonlambda_class_type (void)
6324 /* We start looking from 1 because entry 0 is from global scope,
6326 for (i = current_class_depth; i > 0; --i)
6329 if (i == current_class_depth)
6330 c = current_class_type;
6333 if (current_class_stack[i].hidden)
6335 c = current_class_stack[i].type;
6339 if (!LAMBDA_TYPE_P (c))
6345 /* When entering a class scope, all enclosing class scopes' names with
6346 static meaning (static variables, static functions, types and
6347 enumerators) have to be visible. This recursive function calls
6348 pushclass for all enclosing class contexts until global or a local
6349 scope is reached. TYPE is the enclosed class. */
6352 push_nested_class (tree type)
6354 /* A namespace might be passed in error cases, like A::B:C. */
6355 if (type == NULL_TREE
6356 || !CLASS_TYPE_P (type))
6359 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
6364 /* Undoes a push_nested_class call. */
6367 pop_nested_class (void)
6369 tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
6372 if (context && CLASS_TYPE_P (context))
6373 pop_nested_class ();
6376 /* Returns the number of extern "LANG" blocks we are nested within. */
6379 current_lang_depth (void)
6381 return VEC_length (tree, current_lang_base);
6384 /* Set global variables CURRENT_LANG_NAME to appropriate value
6385 so that behavior of name-mangling machinery is correct. */
6388 push_lang_context (tree name)
6390 VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
6392 if (name == lang_name_cplusplus)
6394 current_lang_name = name;
6396 else if (name == lang_name_java)
6398 current_lang_name = name;
6399 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6400 (See record_builtin_java_type in decl.c.) However, that causes
6401 incorrect debug entries if these types are actually used.
6402 So we re-enable debug output after extern "Java". */
6403 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
6404 DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
6405 DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
6406 DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
6407 DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
6408 DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
6409 DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
6410 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
6412 else if (name == lang_name_c)
6414 current_lang_name = name;
6417 error ("language string %<\"%E\"%> not recognized", name);
6420 /* Get out of the current language scope. */
6423 pop_lang_context (void)
6425 current_lang_name = VEC_pop (tree, current_lang_base);
6428 /* Type instantiation routines. */
6430 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6431 matches the TARGET_TYPE. If there is no satisfactory match, return
6432 error_mark_node, and issue an error & warning messages under
6433 control of FLAGS. Permit pointers to member function if FLAGS
6434 permits. If TEMPLATE_ONLY, the name of the overloaded function was
6435 a template-id, and EXPLICIT_TARGS are the explicitly provided
6438 If OVERLOAD is for one or more member functions, then ACCESS_PATH
6439 is the base path used to reference those member functions. If
6440 TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
6441 resolved to a member function, access checks will be performed and
6442 errors issued if appropriate. */
6445 resolve_address_of_overloaded_function (tree target_type,
6447 tsubst_flags_t flags,
6449 tree explicit_targs,
6452 /* Here's what the standard says:
6456 If the name is a function template, template argument deduction
6457 is done, and if the argument deduction succeeds, the deduced
6458 arguments are used to generate a single template function, which
6459 is added to the set of overloaded functions considered.
6461 Non-member functions and static member functions match targets of
6462 type "pointer-to-function" or "reference-to-function." Nonstatic
6463 member functions match targets of type "pointer-to-member
6464 function;" the function type of the pointer to member is used to
6465 select the member function from the set of overloaded member
6466 functions. If a nonstatic member function is selected, the
6467 reference to the overloaded function name is required to have the
6468 form of a pointer to member as described in 5.3.1.
6470 If more than one function is selected, any template functions in
6471 the set are eliminated if the set also contains a non-template
6472 function, and any given template function is eliminated if the
6473 set contains a second template function that is more specialized
6474 than the first according to the partial ordering rules 14.5.5.2.
6475 After such eliminations, if any, there shall remain exactly one
6476 selected function. */
6479 /* We store the matches in a TREE_LIST rooted here. The functions
6480 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6481 interoperability with most_specialized_instantiation. */
6482 tree matches = NULL_TREE;
6484 tree target_fn_type;
6486 /* By the time we get here, we should be seeing only real
6487 pointer-to-member types, not the internal POINTER_TYPE to
6488 METHOD_TYPE representation. */
6489 gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
6490 || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
6492 gcc_assert (is_overloaded_fn (overload));
6494 /* Check that the TARGET_TYPE is reasonable. */
6495 if (TYPE_PTRFN_P (target_type))
6497 else if (TYPE_PTRMEMFUNC_P (target_type))
6498 /* This is OK, too. */
6500 else if (TREE_CODE (target_type) == FUNCTION_TYPE)
6501 /* This is OK, too. This comes from a conversion to reference
6503 target_type = build_reference_type (target_type);
6506 if (flags & tf_error)
6507 error ("cannot resolve overloaded function %qD based on"
6508 " conversion to type %qT",
6509 DECL_NAME (OVL_FUNCTION (overload)), target_type);
6510 return error_mark_node;
6513 /* Non-member functions and static member functions match targets of type
6514 "pointer-to-function" or "reference-to-function." Nonstatic member
6515 functions match targets of type "pointer-to-member-function;" the
6516 function type of the pointer to member is used to select the member
6517 function from the set of overloaded member functions.
6519 So figure out the FUNCTION_TYPE that we want to match against. */
6520 target_fn_type = static_fn_type (target_type);
6522 /* If we can find a non-template function that matches, we can just
6523 use it. There's no point in generating template instantiations
6524 if we're just going to throw them out anyhow. But, of course, we
6525 can only do this when we don't *need* a template function. */
6530 for (fns = overload; fns; fns = OVL_NEXT (fns))
6532 tree fn = OVL_CURRENT (fns);
6534 if (TREE_CODE (fn) == TEMPLATE_DECL)
6535 /* We're not looking for templates just yet. */
6538 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6540 /* We're looking for a non-static member, and this isn't
6541 one, or vice versa. */
6544 /* Ignore functions which haven't been explicitly
6546 if (DECL_ANTICIPATED (fn))
6549 /* See if there's a match. */
6550 if (same_type_p (target_fn_type, static_fn_type (fn)))
6551 matches = tree_cons (fn, NULL_TREE, matches);
6555 /* Now, if we've already got a match (or matches), there's no need
6556 to proceed to the template functions. But, if we don't have a
6557 match we need to look at them, too. */
6560 tree target_arg_types;
6561 tree target_ret_type;
6564 unsigned int nargs, ia;
6567 target_arg_types = TYPE_ARG_TYPES (target_fn_type);
6568 target_ret_type = TREE_TYPE (target_fn_type);
6570 nargs = list_length (target_arg_types);
6571 args = XALLOCAVEC (tree, nargs);
6572 for (arg = target_arg_types, ia = 0;
6573 arg != NULL_TREE && arg != void_list_node;
6574 arg = TREE_CHAIN (arg), ++ia)
6575 args[ia] = TREE_VALUE (arg);
6578 for (fns = overload; fns; fns = OVL_NEXT (fns))
6580 tree fn = OVL_CURRENT (fns);
6584 if (TREE_CODE (fn) != TEMPLATE_DECL)
6585 /* We're only looking for templates. */
6588 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6590 /* We're not looking for a non-static member, and this is
6591 one, or vice versa. */
6594 /* Try to do argument deduction. */
6595 targs = make_tree_vec (DECL_NTPARMS (fn));
6596 if (fn_type_unification (fn, explicit_targs, targs, args, nargs,
6597 target_ret_type, DEDUCE_EXACT,
6598 LOOKUP_NORMAL, false))
6599 /* Argument deduction failed. */
6602 /* Instantiate the template. */
6603 instantiation = instantiate_template (fn, targs, flags);
6604 if (instantiation == error_mark_node)
6605 /* Instantiation failed. */
6608 /* See if there's a match. */
6609 if (same_type_p (target_fn_type, static_fn_type (instantiation)))
6610 matches = tree_cons (instantiation, fn, matches);
6613 /* Now, remove all but the most specialized of the matches. */
6616 tree match = most_specialized_instantiation (matches);
6618 if (match != error_mark_node)
6619 matches = tree_cons (TREE_PURPOSE (match),
6625 /* Now we should have exactly one function in MATCHES. */
6626 if (matches == NULL_TREE)
6628 /* There were *no* matches. */
6629 if (flags & tf_error)
6631 error ("no matches converting function %qD to type %q#T",
6632 DECL_NAME (OVL_CURRENT (overload)),
6635 print_candidates (overload);
6637 return error_mark_node;
6639 else if (TREE_CHAIN (matches))
6641 /* There were too many matches. First check if they're all
6642 the same function. */
6645 fn = TREE_PURPOSE (matches);
6646 for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
6647 if (!decls_match (fn, TREE_PURPOSE (match)))
6652 if (flags & tf_error)
6654 error ("converting overloaded function %qD to type %q#T is ambiguous",
6655 DECL_NAME (OVL_FUNCTION (overload)),
6658 /* Since print_candidates expects the functions in the
6659 TREE_VALUE slot, we flip them here. */
6660 for (match = matches; match; match = TREE_CHAIN (match))
6661 TREE_VALUE (match) = TREE_PURPOSE (match);
6663 print_candidates (matches);
6666 return error_mark_node;
6670 /* Good, exactly one match. Now, convert it to the correct type. */
6671 fn = TREE_PURPOSE (matches);
6673 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6674 && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6676 static int explained;
6678 if (!(flags & tf_error))
6679 return error_mark_node;
6681 permerror (input_location, "assuming pointer to member %qD", fn);
6684 inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
6689 /* If we're doing overload resolution purely for the purpose of
6690 determining conversion sequences, we should not consider the
6691 function used. If this conversion sequence is selected, the
6692 function will be marked as used at this point. */
6693 if (!(flags & tf_conv))
6695 /* Make =delete work with SFINAE. */
6696 if (DECL_DELETED_FN (fn) && !(flags & tf_error))
6697 return error_mark_node;
6702 /* We could not check access to member functions when this
6703 expression was originally created since we did not know at that
6704 time to which function the expression referred. */
6705 if (!(flags & tf_no_access_control)
6706 && DECL_FUNCTION_MEMBER_P (fn))
6708 gcc_assert (access_path);
6709 perform_or_defer_access_check (access_path, fn, fn);
6712 if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6713 return cp_build_addr_expr (fn, flags);
6716 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
6717 will mark the function as addressed, but here we must do it
6719 cxx_mark_addressable (fn);
6725 /* This function will instantiate the type of the expression given in
6726 RHS to match the type of LHSTYPE. If errors exist, then return
6727 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
6728 we complain on errors. If we are not complaining, never modify rhs,
6729 as overload resolution wants to try many possible instantiations, in
6730 the hope that at least one will work.
6732 For non-recursive calls, LHSTYPE should be a function, pointer to
6733 function, or a pointer to member function. */
6736 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6738 tsubst_flags_t flags_in = flags;
6739 tree access_path = NULL_TREE;
6741 flags &= ~tf_ptrmem_ok;
6743 if (lhstype == unknown_type_node)
6745 if (flags & tf_error)
6746 error ("not enough type information");
6747 return error_mark_node;
6750 if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6752 if (same_type_p (lhstype, TREE_TYPE (rhs)))
6754 if (flag_ms_extensions
6755 && TYPE_PTRMEMFUNC_P (lhstype)
6756 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6757 /* Microsoft allows `A::f' to be resolved to a
6758 pointer-to-member. */
6762 if (flags & tf_error)
6763 error ("argument of type %qT does not match %qT",
6764 TREE_TYPE (rhs), lhstype);
6765 return error_mark_node;
6769 if (TREE_CODE (rhs) == BASELINK)
6771 access_path = BASELINK_ACCESS_BINFO (rhs);
6772 rhs = BASELINK_FUNCTIONS (rhs);
6775 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6776 deduce any type information. */
6777 if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6779 if (flags & tf_error)
6780 error ("not enough type information");
6781 return error_mark_node;
6784 /* There only a few kinds of expressions that may have a type
6785 dependent on overload resolution. */
6786 gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6787 || TREE_CODE (rhs) == COMPONENT_REF
6788 || really_overloaded_fn (rhs)
6789 || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL));
6791 /* This should really only be used when attempting to distinguish
6792 what sort of a pointer to function we have. For now, any
6793 arithmetic operation which is not supported on pointers
6794 is rejected as an error. */
6796 switch (TREE_CODE (rhs))
6800 tree member = TREE_OPERAND (rhs, 1);
6802 member = instantiate_type (lhstype, member, flags);
6803 if (member != error_mark_node
6804 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6805 /* Do not lose object's side effects. */
6806 return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6807 TREE_OPERAND (rhs, 0), member);
6812 rhs = TREE_OPERAND (rhs, 1);
6813 if (BASELINK_P (rhs))
6814 return instantiate_type (lhstype, rhs, flags_in);
6816 /* This can happen if we are forming a pointer-to-member for a
6818 gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6822 case TEMPLATE_ID_EXPR:
6824 tree fns = TREE_OPERAND (rhs, 0);
6825 tree args = TREE_OPERAND (rhs, 1);
6828 resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6829 /*template_only=*/true,
6836 resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6837 /*template_only=*/false,
6838 /*explicit_targs=*/NULL_TREE,
6843 if (PTRMEM_OK_P (rhs))
6844 flags |= tf_ptrmem_ok;
6846 return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6850 return error_mark_node;
6855 return error_mark_node;
6858 /* Return the name of the virtual function pointer field
6859 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6860 this may have to look back through base types to find the
6861 ultimate field name. (For single inheritance, these could
6862 all be the same name. Who knows for multiple inheritance). */
6865 get_vfield_name (tree type)
6867 tree binfo, base_binfo;
6870 for (binfo = TYPE_BINFO (type);
6871 BINFO_N_BASE_BINFOS (binfo);
6874 base_binfo = BINFO_BASE_BINFO (binfo, 0);
6876 if (BINFO_VIRTUAL_P (base_binfo)
6877 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6881 type = BINFO_TYPE (binfo);
6882 buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6883 + TYPE_NAME_LENGTH (type) + 2);
6884 sprintf (buf, VFIELD_NAME_FORMAT,
6885 IDENTIFIER_POINTER (constructor_name (type)));
6886 return get_identifier (buf);
6890 print_class_statistics (void)
6892 #ifdef GATHER_STATISTICS
6893 fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6894 fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6897 fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6898 n_vtables, n_vtable_searches);
6899 fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6900 n_vtable_entries, n_vtable_elems);
6905 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6906 according to [class]:
6907 The class-name is also inserted
6908 into the scope of the class itself. For purposes of access checking,
6909 the inserted class name is treated as if it were a public member name. */
6912 build_self_reference (void)
6914 tree name = constructor_name (current_class_type);
6915 tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6918 DECL_NONLOCAL (value) = 1;
6919 DECL_CONTEXT (value) = current_class_type;
6920 DECL_ARTIFICIAL (value) = 1;
6921 SET_DECL_SELF_REFERENCE_P (value);
6922 set_underlying_type (value);
6924 if (processing_template_decl)
6925 value = push_template_decl (value);
6927 saved_cas = current_access_specifier;
6928 current_access_specifier = access_public_node;
6929 finish_member_declaration (value);
6930 current_access_specifier = saved_cas;
6933 /* Returns 1 if TYPE contains only padding bytes. */
6936 is_empty_class (tree type)
6938 if (type == error_mark_node)
6941 if (! CLASS_TYPE_P (type))
6944 /* In G++ 3.2, whether or not a class was empty was determined by
6945 looking at its size. */
6946 if (abi_version_at_least (2))
6947 return CLASSTYPE_EMPTY_P (type);
6949 return integer_zerop (CLASSTYPE_SIZE (type));
6952 /* Returns true if TYPE contains an empty class. */
6955 contains_empty_class_p (tree type)
6957 if (is_empty_class (type))
6959 if (CLASS_TYPE_P (type))
6966 for (binfo = TYPE_BINFO (type), i = 0;
6967 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6968 if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6970 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6971 if (TREE_CODE (field) == FIELD_DECL
6972 && !DECL_ARTIFICIAL (field)
6973 && is_empty_class (TREE_TYPE (field)))
6976 else if (TREE_CODE (type) == ARRAY_TYPE)
6977 return contains_empty_class_p (TREE_TYPE (type));
6981 /* Returns true if TYPE contains no actual data, just various
6982 possible combinations of empty classes and possibly a vptr. */
6985 is_really_empty_class (tree type)
6987 if (CLASS_TYPE_P (type))
6994 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
6995 out, but we'd like to be able to check this before then. */
6996 if (COMPLETE_TYPE_P (type) && is_empty_class (type))
6999 for (binfo = TYPE_BINFO (type), i = 0;
7000 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7001 if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
7003 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
7004 if (TREE_CODE (field) == FIELD_DECL
7005 && !DECL_ARTIFICIAL (field)
7006 && !is_really_empty_class (TREE_TYPE (field)))
7010 else if (TREE_CODE (type) == ARRAY_TYPE)
7011 return is_really_empty_class (TREE_TYPE (type));
7015 /* Note that NAME was looked up while the current class was being
7016 defined and that the result of that lookup was DECL. */
7019 maybe_note_name_used_in_class (tree name, tree decl)
7021 splay_tree names_used;
7023 /* If we're not defining a class, there's nothing to do. */
7024 if (!(innermost_scope_kind() == sk_class
7025 && TYPE_BEING_DEFINED (current_class_type)
7026 && !LAMBDA_TYPE_P (current_class_type)))
7029 /* If there's already a binding for this NAME, then we don't have
7030 anything to worry about. */
7031 if (lookup_member (current_class_type, name,
7032 /*protect=*/0, /*want_type=*/false))
7035 if (!current_class_stack[current_class_depth - 1].names_used)
7036 current_class_stack[current_class_depth - 1].names_used
7037 = splay_tree_new (splay_tree_compare_pointers, 0, 0);
7038 names_used = current_class_stack[current_class_depth - 1].names_used;
7040 splay_tree_insert (names_used,
7041 (splay_tree_key) name,
7042 (splay_tree_value) decl);
7045 /* Note that NAME was declared (as DECL) in the current class. Check
7046 to see that the declaration is valid. */
7049 note_name_declared_in_class (tree name, tree decl)
7051 splay_tree names_used;
7054 /* Look to see if we ever used this name. */
7056 = current_class_stack[current_class_depth - 1].names_used;
7059 /* The C language allows members to be declared with a type of the same
7060 name, and the C++ standard says this diagnostic is not required. So
7061 allow it in extern "C" blocks unless predantic is specified.
7062 Allow it in all cases if -ms-extensions is specified. */
7063 if ((!pedantic && current_lang_name == lang_name_c)
7064 || flag_ms_extensions)
7066 n = splay_tree_lookup (names_used, (splay_tree_key) name);
7069 /* [basic.scope.class]
7071 A name N used in a class S shall refer to the same declaration
7072 in its context and when re-evaluated in the completed scope of
7074 permerror (input_location, "declaration of %q#D", decl);
7075 permerror (input_location, "changes meaning of %qD from %q+#D",
7076 DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
7080 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
7081 Secondary vtables are merged with primary vtables; this function
7082 will return the VAR_DECL for the primary vtable. */
7085 get_vtbl_decl_for_binfo (tree binfo)
7089 decl = BINFO_VTABLE (binfo);
7090 if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
7092 gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
7093 decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
7096 gcc_assert (TREE_CODE (decl) == VAR_DECL);
7101 /* Returns the binfo for the primary base of BINFO. If the resulting
7102 BINFO is a virtual base, and it is inherited elsewhere in the
7103 hierarchy, then the returned binfo might not be the primary base of
7104 BINFO in the complete object. Check BINFO_PRIMARY_P or
7105 BINFO_LOST_PRIMARY_P to be sure. */
7108 get_primary_binfo (tree binfo)
7112 primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
7116 return copied_binfo (primary_base, binfo);
7119 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
7122 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
7125 fprintf (stream, "%*s", indent, "");
7129 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
7130 INDENT should be zero when called from the top level; it is
7131 incremented recursively. IGO indicates the next expected BINFO in
7132 inheritance graph ordering. */
7135 dump_class_hierarchy_r (FILE *stream,
7145 indented = maybe_indent_hierarchy (stream, indent, 0);
7146 fprintf (stream, "%s (0x%lx) ",
7147 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
7148 (unsigned long) binfo);
7151 fprintf (stream, "alternative-path\n");
7154 igo = TREE_CHAIN (binfo);
7156 fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
7157 tree_low_cst (BINFO_OFFSET (binfo), 0));
7158 if (is_empty_class (BINFO_TYPE (binfo)))
7159 fprintf (stream, " empty");
7160 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
7161 fprintf (stream, " nearly-empty");
7162 if (BINFO_VIRTUAL_P (binfo))
7163 fprintf (stream, " virtual");
7164 fprintf (stream, "\n");
7167 if (BINFO_PRIMARY_P (binfo))
7169 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7170 fprintf (stream, " primary-for %s (0x%lx)",
7171 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
7172 TFF_PLAIN_IDENTIFIER),
7173 (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
7175 if (BINFO_LOST_PRIMARY_P (binfo))
7177 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7178 fprintf (stream, " lost-primary");
7181 fprintf (stream, "\n");
7183 if (!(flags & TDF_SLIM))
7187 if (BINFO_SUBVTT_INDEX (binfo))
7189 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7190 fprintf (stream, " subvttidx=%s",
7191 expr_as_string (BINFO_SUBVTT_INDEX (binfo),
7192 TFF_PLAIN_IDENTIFIER));
7194 if (BINFO_VPTR_INDEX (binfo))
7196 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7197 fprintf (stream, " vptridx=%s",
7198 expr_as_string (BINFO_VPTR_INDEX (binfo),
7199 TFF_PLAIN_IDENTIFIER));
7201 if (BINFO_VPTR_FIELD (binfo))
7203 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7204 fprintf (stream, " vbaseoffset=%s",
7205 expr_as_string (BINFO_VPTR_FIELD (binfo),
7206 TFF_PLAIN_IDENTIFIER));
7208 if (BINFO_VTABLE (binfo))
7210 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7211 fprintf (stream, " vptr=%s",
7212 expr_as_string (BINFO_VTABLE (binfo),
7213 TFF_PLAIN_IDENTIFIER));
7217 fprintf (stream, "\n");
7220 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
7221 igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
7226 /* Dump the BINFO hierarchy for T. */
7229 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
7231 fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
7232 fprintf (stream, " size=%lu align=%lu\n",
7233 (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
7234 (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
7235 fprintf (stream, " base size=%lu base align=%lu\n",
7236 (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
7238 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
7240 dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
7241 fprintf (stream, "\n");
7244 /* Debug interface to hierarchy dumping. */
7247 debug_class (tree t)
7249 dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
7253 dump_class_hierarchy (tree t)
7256 FILE *stream = dump_begin (TDI_class, &flags);
7260 dump_class_hierarchy_1 (stream, flags, t);
7261 dump_end (TDI_class, stream);
7266 dump_array (FILE * stream, tree decl)
7269 unsigned HOST_WIDE_INT ix;
7271 tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
7273 elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
7275 fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
7276 fprintf (stream, " %s entries",
7277 expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
7278 TFF_PLAIN_IDENTIFIER));
7279 fprintf (stream, "\n");
7281 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
7283 fprintf (stream, "%-4ld %s\n", (long)(ix * elt),
7284 expr_as_string (value, TFF_PLAIN_IDENTIFIER));
7288 dump_vtable (tree t, tree binfo, tree vtable)
7291 FILE *stream = dump_begin (TDI_class, &flags);
7296 if (!(flags & TDF_SLIM))
7298 int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
7300 fprintf (stream, "%s for %s",
7301 ctor_vtbl_p ? "Construction vtable" : "Vtable",
7302 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
7305 if (!BINFO_VIRTUAL_P (binfo))
7306 fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
7307 fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
7309 fprintf (stream, "\n");
7310 dump_array (stream, vtable);
7311 fprintf (stream, "\n");
7314 dump_end (TDI_class, stream);
7318 dump_vtt (tree t, tree vtt)
7321 FILE *stream = dump_begin (TDI_class, &flags);
7326 if (!(flags & TDF_SLIM))
7328 fprintf (stream, "VTT for %s\n",
7329 type_as_string (t, TFF_PLAIN_IDENTIFIER));
7330 dump_array (stream, vtt);
7331 fprintf (stream, "\n");
7334 dump_end (TDI_class, stream);
7337 /* Dump a function or thunk and its thunkees. */
7340 dump_thunk (FILE *stream, int indent, tree thunk)
7342 static const char spaces[] = " ";
7343 tree name = DECL_NAME (thunk);
7346 fprintf (stream, "%.*s%p %s %s", indent, spaces,
7348 !DECL_THUNK_P (thunk) ? "function"
7349 : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
7350 name ? IDENTIFIER_POINTER (name) : "<unset>");
7351 if (DECL_THUNK_P (thunk))
7353 HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
7354 tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
7356 fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
7357 if (!virtual_adjust)
7359 else if (DECL_THIS_THUNK_P (thunk))
7360 fprintf (stream, " vcall=" HOST_WIDE_INT_PRINT_DEC,
7361 tree_low_cst (virtual_adjust, 0));
7363 fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
7364 tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
7365 type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
7366 if (THUNK_ALIAS (thunk))
7367 fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
7369 fprintf (stream, "\n");
7370 for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
7371 dump_thunk (stream, indent + 2, thunks);
7374 /* Dump the thunks for FN. */
7377 debug_thunks (tree fn)
7379 dump_thunk (stderr, 0, fn);
7382 /* Virtual function table initialization. */
7384 /* Create all the necessary vtables for T and its base classes. */
7387 finish_vtbls (tree t)
7390 VEC(constructor_elt,gc) *v = NULL;
7391 tree vtable = BINFO_VTABLE (TYPE_BINFO (t));
7393 /* We lay out the primary and secondary vtables in one contiguous
7394 vtable. The primary vtable is first, followed by the non-virtual
7395 secondary vtables in inheritance graph order. */
7396 accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t), TYPE_BINFO (t),
7399 /* Then come the virtual bases, also in inheritance graph order. */
7400 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
7402 if (!BINFO_VIRTUAL_P (vbase))
7404 accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), vtable, t, &v);
7407 if (BINFO_VTABLE (TYPE_BINFO (t)))
7408 initialize_vtable (TYPE_BINFO (t), v);
7411 /* Initialize the vtable for BINFO with the INITS. */
7414 initialize_vtable (tree binfo, VEC(constructor_elt,gc) *inits)
7418 layout_vtable_decl (binfo, VEC_length (constructor_elt, inits));
7419 decl = get_vtbl_decl_for_binfo (binfo);
7420 initialize_artificial_var (decl, inits);
7421 dump_vtable (BINFO_TYPE (binfo), binfo, decl);
7424 /* Build the VTT (virtual table table) for T.
7425 A class requires a VTT if it has virtual bases.
7428 1 - primary virtual pointer for complete object T
7429 2 - secondary VTTs for each direct non-virtual base of T which requires a
7431 3 - secondary virtual pointers for each direct or indirect base of T which
7432 has virtual bases or is reachable via a virtual path from T.
7433 4 - secondary VTTs for each direct or indirect virtual base of T.
7435 Secondary VTTs look like complete object VTTs without part 4. */
7443 VEC(constructor_elt,gc) *inits;
7445 /* Build up the initializers for the VTT. */
7447 index = size_zero_node;
7448 build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
7450 /* If we didn't need a VTT, we're done. */
7454 /* Figure out the type of the VTT. */
7455 type = build_array_of_n_type (const_ptr_type_node,
7456 VEC_length (constructor_elt, inits));
7458 /* Now, build the VTT object itself. */
7459 vtt = build_vtable (t, mangle_vtt_for_type (t), type);
7460 initialize_artificial_var (vtt, inits);
7461 /* Add the VTT to the vtables list. */
7462 DECL_CHAIN (vtt) = DECL_CHAIN (CLASSTYPE_VTABLES (t));
7463 DECL_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
7468 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7469 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7470 and CHAIN the vtable pointer for this binfo after construction is
7471 complete. VALUE can also be another BINFO, in which case we recurse. */
7474 binfo_ctor_vtable (tree binfo)
7480 vt = BINFO_VTABLE (binfo);
7481 if (TREE_CODE (vt) == TREE_LIST)
7482 vt = TREE_VALUE (vt);
7483 if (TREE_CODE (vt) == TREE_BINFO)
7492 /* Data for secondary VTT initialization. */
7493 typedef struct secondary_vptr_vtt_init_data_s
7495 /* Is this the primary VTT? */
7498 /* Current index into the VTT. */
7501 /* Vector of initializers built up. */
7502 VEC(constructor_elt,gc) *inits;
7504 /* The type being constructed by this secondary VTT. */
7505 tree type_being_constructed;
7506 } secondary_vptr_vtt_init_data;
7508 /* Recursively build the VTT-initializer for BINFO (which is in the
7509 hierarchy dominated by T). INITS points to the end of the initializer
7510 list to date. INDEX is the VTT index where the next element will be
7511 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7512 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
7513 for virtual bases of T. When it is not so, we build the constructor
7514 vtables for the BINFO-in-T variant. */
7517 build_vtt_inits (tree binfo, tree t, VEC(constructor_elt,gc) **inits, tree *index)
7522 secondary_vptr_vtt_init_data data;
7523 int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7525 /* We only need VTTs for subobjects with virtual bases. */
7526 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7529 /* We need to use a construction vtable if this is not the primary
7533 build_ctor_vtbl_group (binfo, t);
7535 /* Record the offset in the VTT where this sub-VTT can be found. */
7536 BINFO_SUBVTT_INDEX (binfo) = *index;
7539 /* Add the address of the primary vtable for the complete object. */
7540 init = binfo_ctor_vtable (binfo);
7541 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
7544 gcc_assert (!BINFO_VPTR_INDEX (binfo));
7545 BINFO_VPTR_INDEX (binfo) = *index;
7547 *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
7549 /* Recursively add the secondary VTTs for non-virtual bases. */
7550 for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
7551 if (!BINFO_VIRTUAL_P (b))
7552 build_vtt_inits (b, t, inits, index);
7554 /* Add secondary virtual pointers for all subobjects of BINFO with
7555 either virtual bases or reachable along a virtual path, except
7556 subobjects that are non-virtual primary bases. */
7557 data.top_level_p = top_level_p;
7558 data.index = *index;
7559 data.inits = *inits;
7560 data.type_being_constructed = BINFO_TYPE (binfo);
7562 dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
7564 *index = data.index;
7566 /* data.inits might have grown as we added secondary virtual pointers.
7567 Make sure our caller knows about the new vector. */
7568 *inits = data.inits;
7571 /* Add the secondary VTTs for virtual bases in inheritance graph
7573 for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
7575 if (!BINFO_VIRTUAL_P (b))
7578 build_vtt_inits (b, t, inits, index);
7581 /* Remove the ctor vtables we created. */
7582 dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
7585 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
7586 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
7589 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
7591 secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
7593 /* We don't care about bases that don't have vtables. */
7594 if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7595 return dfs_skip_bases;
7597 /* We're only interested in proper subobjects of the type being
7599 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
7602 /* We're only interested in bases with virtual bases or reachable
7603 via a virtual path from the type being constructed. */
7604 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7605 || binfo_via_virtual (binfo, data->type_being_constructed)))
7606 return dfs_skip_bases;
7608 /* We're not interested in non-virtual primary bases. */
7609 if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
7612 /* Record the index where this secondary vptr can be found. */
7613 if (data->top_level_p)
7615 gcc_assert (!BINFO_VPTR_INDEX (binfo));
7616 BINFO_VPTR_INDEX (binfo) = data->index;
7618 if (BINFO_VIRTUAL_P (binfo))
7620 /* It's a primary virtual base, and this is not a
7621 construction vtable. Find the base this is primary of in
7622 the inheritance graph, and use that base's vtable
7624 while (BINFO_PRIMARY_P (binfo))
7625 binfo = BINFO_INHERITANCE_CHAIN (binfo);
7629 /* Add the initializer for the secondary vptr itself. */
7630 CONSTRUCTOR_APPEND_ELT (data->inits, NULL_TREE, binfo_ctor_vtable (binfo));
7632 /* Advance the vtt index. */
7633 data->index = size_binop (PLUS_EXPR, data->index,
7634 TYPE_SIZE_UNIT (ptr_type_node));
7639 /* Called from build_vtt_inits via dfs_walk. After building
7640 constructor vtables and generating the sub-vtt from them, we need
7641 to restore the BINFO_VTABLES that were scribbled on. DATA is the
7642 binfo of the base whose sub vtt was generated. */
7645 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7647 tree vtable = BINFO_VTABLE (binfo);
7649 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7650 /* If this class has no vtable, none of its bases do. */
7651 return dfs_skip_bases;
7654 /* This might be a primary base, so have no vtable in this
7658 /* If we scribbled the construction vtable vptr into BINFO, clear it
7660 if (TREE_CODE (vtable) == TREE_LIST
7661 && (TREE_PURPOSE (vtable) == (tree) data))
7662 BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
7667 /* Build the construction vtable group for BINFO which is in the
7668 hierarchy dominated by T. */
7671 build_ctor_vtbl_group (tree binfo, tree t)
7677 VEC(constructor_elt,gc) *v;
7679 /* See if we've already created this construction vtable group. */
7680 id = mangle_ctor_vtbl_for_type (t, binfo);
7681 if (IDENTIFIER_GLOBAL_VALUE (id))
7684 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
7685 /* Build a version of VTBL (with the wrong type) for use in
7686 constructing the addresses of secondary vtables in the
7687 construction vtable group. */
7688 vtbl = build_vtable (t, id, ptr_type_node);
7689 DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
7692 accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7693 binfo, vtbl, t, &v);
7695 /* Add the vtables for each of our virtual bases using the vbase in T
7697 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7699 vbase = TREE_CHAIN (vbase))
7703 if (!BINFO_VIRTUAL_P (vbase))
7705 b = copied_binfo (vbase, binfo);
7707 accumulate_vtbl_inits (b, vbase, binfo, vtbl, t, &v);
7710 /* Figure out the type of the construction vtable. */
7711 type = build_array_of_n_type (vtable_entry_type,
7712 VEC_length (constructor_elt, v));
7714 TREE_TYPE (vtbl) = type;
7715 DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
7716 layout_decl (vtbl, 0);
7718 /* Initialize the construction vtable. */
7719 CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7720 initialize_artificial_var (vtbl, v);
7721 dump_vtable (t, binfo, vtbl);
7724 /* Add the vtbl initializers for BINFO (and its bases other than
7725 non-virtual primaries) to the list of INITS. BINFO is in the
7726 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7727 the constructor the vtbl inits should be accumulated for. (If this
7728 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7729 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7730 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7731 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7732 but are not necessarily the same in terms of layout. */
7735 accumulate_vtbl_inits (tree binfo,
7740 VEC(constructor_elt,gc) **inits)
7744 int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7746 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7748 /* If it doesn't have a vptr, we don't do anything. */
7749 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7752 /* If we're building a construction vtable, we're not interested in
7753 subobjects that don't require construction vtables. */
7755 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7756 && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7759 /* Build the initializers for the BINFO-in-T vtable. */
7760 dfs_accumulate_vtbl_inits (binfo, orig_binfo, rtti_binfo, vtbl, t, inits);
7762 /* Walk the BINFO and its bases. We walk in preorder so that as we
7763 initialize each vtable we can figure out at what offset the
7764 secondary vtable lies from the primary vtable. We can't use
7765 dfs_walk here because we need to iterate through bases of BINFO
7766 and RTTI_BINFO simultaneously. */
7767 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7769 /* Skip virtual bases. */
7770 if (BINFO_VIRTUAL_P (base_binfo))
7772 accumulate_vtbl_inits (base_binfo,
7773 BINFO_BASE_BINFO (orig_binfo, i),
7774 rtti_binfo, vtbl, t,
7779 /* Called from accumulate_vtbl_inits. Adds the initializers for the
7780 BINFO vtable to L. */
7783 dfs_accumulate_vtbl_inits (tree binfo,
7788 VEC(constructor_elt,gc) **l)
7790 tree vtbl = NULL_TREE;
7791 int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7795 && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7797 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7798 primary virtual base. If it is not the same primary in
7799 the hierarchy of T, we'll need to generate a ctor vtable
7800 for it, to place at its location in T. If it is the same
7801 primary, we still need a VTT entry for the vtable, but it
7802 should point to the ctor vtable for the base it is a
7803 primary for within the sub-hierarchy of RTTI_BINFO.
7805 There are three possible cases:
7807 1) We are in the same place.
7808 2) We are a primary base within a lost primary virtual base of
7810 3) We are primary to something not a base of RTTI_BINFO. */
7813 tree last = NULL_TREE;
7815 /* First, look through the bases we are primary to for RTTI_BINFO
7816 or a virtual base. */
7818 while (BINFO_PRIMARY_P (b))
7820 b = BINFO_INHERITANCE_CHAIN (b);
7822 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7825 /* If we run out of primary links, keep looking down our
7826 inheritance chain; we might be an indirect primary. */
7827 for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7828 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7832 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7833 base B and it is a base of RTTI_BINFO, this is case 2. In
7834 either case, we share our vtable with LAST, i.e. the
7835 derived-most base within B of which we are a primary. */
7837 || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7838 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7839 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7840 binfo_ctor_vtable after everything's been set up. */
7843 /* Otherwise, this is case 3 and we get our own. */
7845 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7848 n_inits = VEC_length (constructor_elt, *l);
7855 /* Add the initializer for this vtable. */
7856 build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7857 &non_fn_entries, l);
7859 /* Figure out the position to which the VPTR should point. */
7860 vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, orig_vtbl);
7861 index = size_binop (MULT_EXPR,
7862 TYPE_SIZE_UNIT (vtable_entry_type),
7863 size_int (non_fn_entries + n_inits));
7864 vtbl = fold_build_pointer_plus (vtbl, index);
7868 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7869 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7870 straighten this out. */
7871 BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7872 else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7873 /* Throw away any unneeded intializers. */
7874 VEC_truncate (constructor_elt, *l, n_inits);
7876 /* For an ordinary vtable, set BINFO_VTABLE. */
7877 BINFO_VTABLE (binfo) = vtbl;
7880 static GTY(()) tree abort_fndecl_addr;
7882 /* Construct the initializer for BINFO's virtual function table. BINFO
7883 is part of the hierarchy dominated by T. If we're building a
7884 construction vtable, the ORIG_BINFO is the binfo we should use to
7885 find the actual function pointers to put in the vtable - but they
7886 can be overridden on the path to most-derived in the graph that
7887 ORIG_BINFO belongs. Otherwise,
7888 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7889 BINFO that should be indicated by the RTTI information in the
7890 vtable; it will be a base class of T, rather than T itself, if we
7891 are building a construction vtable.
7893 The value returned is a TREE_LIST suitable for wrapping in a
7894 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7895 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7896 number of non-function entries in the vtable.
7898 It might seem that this function should never be called with a
7899 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7900 base is always subsumed by a derived class vtable. However, when
7901 we are building construction vtables, we do build vtables for
7902 primary bases; we need these while the primary base is being
7906 build_vtbl_initializer (tree binfo,
7910 int* non_fn_entries_p,
7911 VEC(constructor_elt,gc) **inits)
7917 VEC(tree,gc) *vbases;
7920 /* Initialize VID. */
7921 memset (&vid, 0, sizeof (vid));
7924 vid.rtti_binfo = rtti_binfo;
7925 vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7926 vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7927 vid.generate_vcall_entries = true;
7928 /* The first vbase or vcall offset is at index -3 in the vtable. */
7929 vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7931 /* Add entries to the vtable for RTTI. */
7932 build_rtti_vtbl_entries (binfo, &vid);
7934 /* Create an array for keeping track of the functions we've
7935 processed. When we see multiple functions with the same
7936 signature, we share the vcall offsets. */
7937 vid.fns = VEC_alloc (tree, gc, 32);
7938 /* Add the vcall and vbase offset entries. */
7939 build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7941 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7942 build_vbase_offset_vtbl_entries. */
7943 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7944 VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7945 BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7947 /* If the target requires padding between data entries, add that now. */
7948 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7950 int n_entries = VEC_length (constructor_elt, vid.inits);
7952 VEC_safe_grow (constructor_elt, gc, vid.inits,
7953 TARGET_VTABLE_DATA_ENTRY_DISTANCE * n_entries);
7955 /* Move data entries into their new positions and add padding
7956 after the new positions. Iterate backwards so we don't
7957 overwrite entries that we would need to process later. */
7958 for (ix = n_entries - 1;
7959 VEC_iterate (constructor_elt, vid.inits, ix, e);
7963 int new_position = (TARGET_VTABLE_DATA_ENTRY_DISTANCE * ix
7964 + (TARGET_VTABLE_DATA_ENTRY_DISTANCE - 1));
7966 VEC_replace (constructor_elt, vid.inits, new_position, e);
7968 for (j = 1; j < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++j)
7970 constructor_elt *f = VEC_index (constructor_elt, vid.inits,
7972 f->index = NULL_TREE;
7973 f->value = build1 (NOP_EXPR, vtable_entry_type,
7979 if (non_fn_entries_p)
7980 *non_fn_entries_p = VEC_length (constructor_elt, vid.inits);
7982 /* The initializers for virtual functions were built up in reverse
7983 order. Straighten them out and add them to the running list in one
7985 jx = VEC_length (constructor_elt, *inits);
7986 VEC_safe_grow (constructor_elt, gc, *inits,
7987 (jx + VEC_length (constructor_elt, vid.inits)));
7989 for (ix = VEC_length (constructor_elt, vid.inits) - 1;
7990 VEC_iterate (constructor_elt, vid.inits, ix, e);
7992 VEC_replace (constructor_elt, *inits, jx, e);
7994 /* Go through all the ordinary virtual functions, building up
7996 for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
8000 tree fn, fn_original;
8001 tree init = NULL_TREE;
8005 if (DECL_THUNK_P (fn))
8007 if (!DECL_NAME (fn))
8009 if (THUNK_ALIAS (fn))
8011 fn = THUNK_ALIAS (fn);
8014 fn_original = THUNK_TARGET (fn);
8017 /* If the only definition of this function signature along our
8018 primary base chain is from a lost primary, this vtable slot will
8019 never be used, so just zero it out. This is important to avoid
8020 requiring extra thunks which cannot be generated with the function.
8022 We first check this in update_vtable_entry_for_fn, so we handle
8023 restored primary bases properly; we also need to do it here so we
8024 zero out unused slots in ctor vtables, rather than filling them
8025 with erroneous values (though harmless, apart from relocation
8027 if (BV_LOST_PRIMARY (v))
8028 init = size_zero_node;
8032 /* Pull the offset for `this', and the function to call, out of
8034 delta = BV_DELTA (v);
8035 vcall_index = BV_VCALL_INDEX (v);
8037 gcc_assert (TREE_CODE (delta) == INTEGER_CST);
8038 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
8040 /* You can't call an abstract virtual function; it's abstract.
8041 So, we replace these functions with __pure_virtual. */
8042 if (DECL_PURE_VIRTUAL_P (fn_original))
8045 if (!TARGET_VTABLE_USES_DESCRIPTORS)
8047 if (abort_fndecl_addr == NULL)
8049 = fold_convert (vfunc_ptr_type_node,
8050 build_fold_addr_expr (fn));
8051 init = abort_fndecl_addr;
8056 if (!integer_zerop (delta) || vcall_index)
8058 fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
8059 if (!DECL_NAME (fn))
8062 /* Take the address of the function, considering it to be of an
8063 appropriate generic type. */
8064 if (!TARGET_VTABLE_USES_DESCRIPTORS)
8065 init = fold_convert (vfunc_ptr_type_node,
8066 build_fold_addr_expr (fn));
8070 /* And add it to the chain of initializers. */
8071 if (TARGET_VTABLE_USES_DESCRIPTORS)
8074 if (init == size_zero_node)
8075 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
8076 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
8078 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
8080 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
8081 fn, build_int_cst (NULL_TREE, i));
8082 TREE_CONSTANT (fdesc) = 1;
8084 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, fdesc);
8088 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
8092 /* Adds to vid->inits the initializers for the vbase and vcall
8093 offsets in BINFO, which is in the hierarchy dominated by T. */
8096 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
8100 /* If this is a derived class, we must first create entries
8101 corresponding to the primary base class. */
8102 b = get_primary_binfo (binfo);
8104 build_vcall_and_vbase_vtbl_entries (b, vid);
8106 /* Add the vbase entries for this base. */
8107 build_vbase_offset_vtbl_entries (binfo, vid);
8108 /* Add the vcall entries for this base. */
8109 build_vcall_offset_vtbl_entries (binfo, vid);
8112 /* Returns the initializers for the vbase offset entries in the vtable
8113 for BINFO (which is part of the class hierarchy dominated by T), in
8114 reverse order. VBASE_OFFSET_INDEX gives the vtable index
8115 where the next vbase offset will go. */
8118 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
8122 tree non_primary_binfo;
8124 /* If there are no virtual baseclasses, then there is nothing to
8126 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
8131 /* We might be a primary base class. Go up the inheritance hierarchy
8132 until we find the most derived class of which we are a primary base:
8133 it is the offset of that which we need to use. */
8134 non_primary_binfo = binfo;
8135 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
8139 /* If we have reached a virtual base, then it must be a primary
8140 base (possibly multi-level) of vid->binfo, or we wouldn't
8141 have called build_vcall_and_vbase_vtbl_entries for it. But it
8142 might be a lost primary, so just skip down to vid->binfo. */
8143 if (BINFO_VIRTUAL_P (non_primary_binfo))
8145 non_primary_binfo = vid->binfo;
8149 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
8150 if (get_primary_binfo (b) != non_primary_binfo)
8152 non_primary_binfo = b;
8155 /* Go through the virtual bases, adding the offsets. */
8156 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
8158 vbase = TREE_CHAIN (vbase))
8163 if (!BINFO_VIRTUAL_P (vbase))
8166 /* Find the instance of this virtual base in the complete
8168 b = copied_binfo (vbase, binfo);
8170 /* If we've already got an offset for this virtual base, we
8171 don't need another one. */
8172 if (BINFO_VTABLE_PATH_MARKED (b))
8174 BINFO_VTABLE_PATH_MARKED (b) = 1;
8176 /* Figure out where we can find this vbase offset. */
8177 delta = size_binop (MULT_EXPR,
8180 TYPE_SIZE_UNIT (vtable_entry_type)));
8181 if (vid->primary_vtbl_p)
8182 BINFO_VPTR_FIELD (b) = delta;
8184 if (binfo != TYPE_BINFO (t))
8185 /* The vbase offset had better be the same. */
8186 gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
8188 /* The next vbase will come at a more negative offset. */
8189 vid->index = size_binop (MINUS_EXPR, vid->index,
8190 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
8192 /* The initializer is the delta from BINFO to this virtual base.
8193 The vbase offsets go in reverse inheritance-graph order, and
8194 we are walking in inheritance graph order so these end up in
8196 delta = size_diffop_loc (input_location,
8197 BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
8199 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE,
8200 fold_build1_loc (input_location, NOP_EXPR,
8201 vtable_entry_type, delta));
8205 /* Adds the initializers for the vcall offset entries in the vtable
8206 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
8210 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
8212 /* We only need these entries if this base is a virtual base. We
8213 compute the indices -- but do not add to the vtable -- when
8214 building the main vtable for a class. */
8215 if (binfo == TYPE_BINFO (vid->derived)
8216 || (BINFO_VIRTUAL_P (binfo)
8217 /* If BINFO is RTTI_BINFO, then (since BINFO does not
8218 correspond to VID->DERIVED), we are building a primary
8219 construction virtual table. Since this is a primary
8220 virtual table, we do not need the vcall offsets for
8222 && binfo != vid->rtti_binfo))
8224 /* We need a vcall offset for each of the virtual functions in this
8225 vtable. For example:
8227 class A { virtual void f (); };
8228 class B1 : virtual public A { virtual void f (); };
8229 class B2 : virtual public A { virtual void f (); };
8230 class C: public B1, public B2 { virtual void f (); };
8232 A C object has a primary base of B1, which has a primary base of A. A
8233 C also has a secondary base of B2, which no longer has a primary base
8234 of A. So the B2-in-C construction vtable needs a secondary vtable for
8235 A, which will adjust the A* to a B2* to call f. We have no way of
8236 knowing what (or even whether) this offset will be when we define B2,
8237 so we store this "vcall offset" in the A sub-vtable and look it up in
8238 a "virtual thunk" for B2::f.
8240 We need entries for all the functions in our primary vtable and
8241 in our non-virtual bases' secondary vtables. */
8243 /* If we are just computing the vcall indices -- but do not need
8244 the actual entries -- not that. */
8245 if (!BINFO_VIRTUAL_P (binfo))
8246 vid->generate_vcall_entries = false;
8247 /* Now, walk through the non-virtual bases, adding vcall offsets. */
8248 add_vcall_offset_vtbl_entries_r (binfo, vid);
8252 /* Build vcall offsets, starting with those for BINFO. */
8255 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
8261 /* Don't walk into virtual bases -- except, of course, for the
8262 virtual base for which we are building vcall offsets. Any
8263 primary virtual base will have already had its offsets generated
8264 through the recursion in build_vcall_and_vbase_vtbl_entries. */
8265 if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
8268 /* If BINFO has a primary base, process it first. */
8269 primary_binfo = get_primary_binfo (binfo);
8271 add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
8273 /* Add BINFO itself to the list. */
8274 add_vcall_offset_vtbl_entries_1 (binfo, vid);
8276 /* Scan the non-primary bases of BINFO. */
8277 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
8278 if (base_binfo != primary_binfo)
8279 add_vcall_offset_vtbl_entries_r (base_binfo, vid);
8282 /* Called from build_vcall_offset_vtbl_entries_r. */
8285 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
8287 /* Make entries for the rest of the virtuals. */
8288 if (abi_version_at_least (2))
8292 /* The ABI requires that the methods be processed in declaration
8293 order. G++ 3.2 used the order in the vtable. */
8294 for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
8296 orig_fn = DECL_CHAIN (orig_fn))
8297 if (DECL_VINDEX (orig_fn))
8298 add_vcall_offset (orig_fn, binfo, vid);
8302 tree derived_virtuals;
8305 /* If BINFO is a primary base, the most derived class which has
8306 BINFO as a primary base; otherwise, just BINFO. */
8307 tree non_primary_binfo;
8309 /* We might be a primary base class. Go up the inheritance hierarchy
8310 until we find the most derived class of which we are a primary base:
8311 it is the BINFO_VIRTUALS there that we need to consider. */
8312 non_primary_binfo = binfo;
8313 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
8317 /* If we have reached a virtual base, then it must be vid->vbase,
8318 because we ignore other virtual bases in
8319 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
8320 base (possibly multi-level) of vid->binfo, or we wouldn't
8321 have called build_vcall_and_vbase_vtbl_entries for it. But it
8322 might be a lost primary, so just skip down to vid->binfo. */
8323 if (BINFO_VIRTUAL_P (non_primary_binfo))
8325 gcc_assert (non_primary_binfo == vid->vbase);
8326 non_primary_binfo = vid->binfo;
8330 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
8331 if (get_primary_binfo (b) != non_primary_binfo)
8333 non_primary_binfo = b;
8336 if (vid->ctor_vtbl_p)
8337 /* For a ctor vtable we need the equivalent binfo within the hierarchy
8338 where rtti_binfo is the most derived type. */
8340 = original_binfo (non_primary_binfo, vid->rtti_binfo);
8342 for (base_virtuals = BINFO_VIRTUALS (binfo),
8343 derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
8344 orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
8346 base_virtuals = TREE_CHAIN (base_virtuals),
8347 derived_virtuals = TREE_CHAIN (derived_virtuals),
8348 orig_virtuals = TREE_CHAIN (orig_virtuals))
8352 /* Find the declaration that originally caused this function to
8353 be present in BINFO_TYPE (binfo). */
8354 orig_fn = BV_FN (orig_virtuals);
8356 /* When processing BINFO, we only want to generate vcall slots for
8357 function slots introduced in BINFO. So don't try to generate
8358 one if the function isn't even defined in BINFO. */
8359 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
8362 add_vcall_offset (orig_fn, binfo, vid);
8367 /* Add a vcall offset entry for ORIG_FN to the vtable. */
8370 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
8376 /* If there is already an entry for a function with the same
8377 signature as FN, then we do not need a second vcall offset.
8378 Check the list of functions already present in the derived
8380 FOR_EACH_VEC_ELT (tree, vid->fns, i, derived_entry)
8382 if (same_signature_p (derived_entry, orig_fn)
8383 /* We only use one vcall offset for virtual destructors,
8384 even though there are two virtual table entries. */
8385 || (DECL_DESTRUCTOR_P (derived_entry)
8386 && DECL_DESTRUCTOR_P (orig_fn)))
8390 /* If we are building these vcall offsets as part of building
8391 the vtable for the most derived class, remember the vcall
8393 if (vid->binfo == TYPE_BINFO (vid->derived))
8395 tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
8396 CLASSTYPE_VCALL_INDICES (vid->derived),
8398 elt->purpose = orig_fn;
8399 elt->value = vid->index;
8402 /* The next vcall offset will be found at a more negative
8404 vid->index = size_binop (MINUS_EXPR, vid->index,
8405 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
8407 /* Keep track of this function. */
8408 VEC_safe_push (tree, gc, vid->fns, orig_fn);
8410 if (vid->generate_vcall_entries)
8415 /* Find the overriding function. */
8416 fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
8417 if (fn == error_mark_node)
8418 vcall_offset = build_zero_cst (vtable_entry_type);
8421 base = TREE_VALUE (fn);
8423 /* The vbase we're working on is a primary base of
8424 vid->binfo. But it might be a lost primary, so its
8425 BINFO_OFFSET might be wrong, so we just use the
8426 BINFO_OFFSET from vid->binfo. */
8427 vcall_offset = size_diffop_loc (input_location,
8428 BINFO_OFFSET (base),
8429 BINFO_OFFSET (vid->binfo));
8430 vcall_offset = fold_build1_loc (input_location,
8431 NOP_EXPR, vtable_entry_type,
8434 /* Add the initializer to the vtable. */
8435 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, vcall_offset);
8439 /* Return vtbl initializers for the RTTI entries corresponding to the
8440 BINFO's vtable. The RTTI entries should indicate the object given
8441 by VID->rtti_binfo. */
8444 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
8452 t = BINFO_TYPE (vid->rtti_binfo);
8454 /* To find the complete object, we will first convert to our most
8455 primary base, and then add the offset in the vtbl to that value. */
8457 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
8458 && !BINFO_LOST_PRIMARY_P (b))
8462 primary_base = get_primary_binfo (b);
8463 gcc_assert (BINFO_PRIMARY_P (primary_base)
8464 && BINFO_INHERITANCE_CHAIN (primary_base) == b);
8467 offset = size_diffop_loc (input_location,
8468 BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
8470 /* The second entry is the address of the typeinfo object. */
8472 decl = build_address (get_tinfo_decl (t));
8474 decl = integer_zero_node;
8476 /* Convert the declaration to a type that can be stored in the
8478 init = build_nop (vfunc_ptr_type_node, decl);
8479 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
8481 /* Add the offset-to-top entry. It comes earlier in the vtable than
8482 the typeinfo entry. Convert the offset to look like a
8483 function pointer, so that we can put it in the vtable. */
8484 init = build_nop (vfunc_ptr_type_node, offset);
8485 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
8488 #include "gt-cp-class.h"