1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* High-level class interface. */
28 #include "coretypes.h"
38 #include "tree-dump.h"
39 #include "splay-tree.h"
41 /* The number of nested classes being processed. If we are not in the
42 scope of any class, this is zero. */
44 int current_class_depth;
46 /* In order to deal with nested classes, we keep a stack of classes.
47 The topmost entry is the innermost class, and is the entry at index
48 CURRENT_CLASS_DEPTH */
50 typedef struct class_stack_node {
51 /* The name of the class. */
54 /* The _TYPE node for the class. */
57 /* The access specifier pending for new declarations in the scope of
61 /* If were defining TYPE, the names used in this class. */
62 splay_tree names_used;
64 /* Nonzero if this class is no longer open, because of a call to
67 }* class_stack_node_t;
69 typedef struct vtbl_init_data_s
71 /* The base for which we're building initializers. */
73 /* The type of the most-derived type. */
75 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
76 unless ctor_vtbl_p is true. */
78 /* The negative-index vtable initializers built up so far. These
79 are in order from least negative index to most negative index. */
80 VEC(constructor_elt,gc) *inits;
81 /* The binfo for the virtual base for which we're building
82 vcall offset initializers. */
84 /* The functions in vbase for which we have already provided vcall
87 /* The vtable index of the next vcall or vbase offset. */
89 /* Nonzero if we are building the initializer for the primary
92 /* Nonzero if we are building the initializer for a construction
95 /* True when adding vcall offset entries to the vtable. False when
96 merely computing the indices. */
97 bool generate_vcall_entries;
100 /* The type of a function passed to walk_subobject_offsets. */
101 typedef int (*subobject_offset_fn) (tree, tree, splay_tree);
103 /* The stack itself. This is a dynamically resized array. The
104 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
105 static int current_class_stack_size;
106 static class_stack_node_t current_class_stack;
108 /* The size of the largest empty class seen in this translation unit. */
109 static GTY (()) tree sizeof_biggest_empty_class;
111 /* An array of all local classes present in this translation unit, in
112 declaration order. */
113 VEC(tree,gc) *local_classes;
115 static tree get_vfield_name (tree);
116 static void finish_struct_anon (tree);
117 static tree get_vtable_name (tree);
118 static tree get_basefndecls (tree, tree);
119 static int build_primary_vtable (tree, tree);
120 static int build_secondary_vtable (tree);
121 static void finish_vtbls (tree);
122 static void modify_vtable_entry (tree, tree, tree, tree, tree *);
123 static void finish_struct_bits (tree);
124 static int alter_access (tree, tree, tree);
125 static void handle_using_decl (tree, tree);
126 static tree dfs_modify_vtables (tree, void *);
127 static tree modify_all_vtables (tree, tree);
128 static void determine_primary_bases (tree);
129 static void finish_struct_methods (tree);
130 static void maybe_warn_about_overly_private_class (tree);
131 static int method_name_cmp (const void *, const void *);
132 static int resort_method_name_cmp (const void *, const void *);
133 static void add_implicitly_declared_members (tree, int, int);
134 static tree fixed_type_or_null (tree, int *, int *);
135 static tree build_simple_base_path (tree expr, tree binfo);
136 static tree build_vtbl_ref_1 (tree, tree);
137 static void build_vtbl_initializer (tree, tree, tree, tree, int *,
138 VEC(constructor_elt,gc) **);
139 static int count_fields (tree);
140 static int add_fields_to_record_type (tree, struct sorted_fields_type*, int);
141 static bool check_bitfield_decl (tree);
142 static void check_field_decl (tree, tree, int *, int *, int *);
143 static void check_field_decls (tree, tree *, int *, int *);
144 static tree *build_base_field (record_layout_info, tree, splay_tree, tree *);
145 static void build_base_fields (record_layout_info, splay_tree, tree *);
146 static void check_methods (tree);
147 static void remove_zero_width_bit_fields (tree);
148 static void check_bases (tree, int *, int *);
149 static void check_bases_and_members (tree);
150 static tree create_vtable_ptr (tree, tree *);
151 static void include_empty_classes (record_layout_info);
152 static void layout_class_type (tree, tree *);
153 static void propagate_binfo_offsets (tree, tree);
154 static void layout_virtual_bases (record_layout_info, splay_tree);
155 static void build_vbase_offset_vtbl_entries (tree, vtbl_init_data *);
156 static void add_vcall_offset_vtbl_entries_r (tree, vtbl_init_data *);
157 static void add_vcall_offset_vtbl_entries_1 (tree, vtbl_init_data *);
158 static void build_vcall_offset_vtbl_entries (tree, vtbl_init_data *);
159 static void add_vcall_offset (tree, tree, vtbl_init_data *);
160 static void layout_vtable_decl (tree, int);
161 static tree dfs_find_final_overrider_pre (tree, void *);
162 static tree dfs_find_final_overrider_post (tree, void *);
163 static tree find_final_overrider (tree, tree, tree);
164 static int make_new_vtable (tree, tree);
165 static tree get_primary_binfo (tree);
166 static int maybe_indent_hierarchy (FILE *, int, int);
167 static tree dump_class_hierarchy_r (FILE *, int, tree, tree, int);
168 static void dump_class_hierarchy (tree);
169 static void dump_class_hierarchy_1 (FILE *, int, tree);
170 static void dump_array (FILE *, tree);
171 static void dump_vtable (tree, tree, tree);
172 static void dump_vtt (tree, tree);
173 static void dump_thunk (FILE *, int, tree);
174 static tree build_vtable (tree, tree, tree);
175 static void initialize_vtable (tree, VEC(constructor_elt,gc) *);
176 static void layout_nonempty_base_or_field (record_layout_info,
177 tree, tree, splay_tree);
178 static tree end_of_class (tree, int);
179 static bool layout_empty_base (record_layout_info, tree, tree, splay_tree);
180 static void accumulate_vtbl_inits (tree, tree, tree, tree, tree,
181 VEC(constructor_elt,gc) **);
182 static void dfs_accumulate_vtbl_inits (tree, tree, tree, tree, tree,
183 VEC(constructor_elt,gc) **);
184 static void build_rtti_vtbl_entries (tree, vtbl_init_data *);
185 static void build_vcall_and_vbase_vtbl_entries (tree, vtbl_init_data *);
186 static void clone_constructors_and_destructors (tree);
187 static tree build_clone (tree, tree);
188 static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned);
189 static void build_ctor_vtbl_group (tree, tree);
190 static void build_vtt (tree);
191 static tree binfo_ctor_vtable (tree);
192 static void build_vtt_inits (tree, tree, VEC(constructor_elt,gc) **, tree *);
193 static tree dfs_build_secondary_vptr_vtt_inits (tree, void *);
194 static tree dfs_fixup_binfo_vtbls (tree, void *);
195 static int record_subobject_offset (tree, tree, splay_tree);
196 static int check_subobject_offset (tree, tree, splay_tree);
197 static int walk_subobject_offsets (tree, subobject_offset_fn,
198 tree, splay_tree, tree, int);
199 static void record_subobject_offsets (tree, tree, splay_tree, bool);
200 static int layout_conflict_p (tree, tree, splay_tree, int);
201 static int splay_tree_compare_integer_csts (splay_tree_key k1,
203 static void warn_about_ambiguous_bases (tree);
204 static bool type_requires_array_cookie (tree);
205 static bool contains_empty_class_p (tree);
206 static bool base_derived_from (tree, tree);
207 static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree);
208 static tree end_of_base (tree);
209 static tree get_vcall_index (tree, tree);
211 /* Variables shared between class.c and call.c. */
213 #ifdef GATHER_STATISTICS
215 int n_vtable_entries = 0;
216 int n_vtable_searches = 0;
217 int n_vtable_elems = 0;
218 int n_convert_harshness = 0;
219 int n_compute_conversion_costs = 0;
220 int n_inner_fields_searched = 0;
223 /* Convert to or from a base subobject. EXPR is an expression of type
224 `A' or `A*', an expression of type `B' or `B*' is returned. To
225 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
226 the B base instance within A. To convert base A to derived B, CODE
227 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
228 In this latter case, A must not be a morally virtual base of B.
229 NONNULL is true if EXPR is known to be non-NULL (this is only
230 needed when EXPR is of pointer type). CV qualifiers are preserved
234 build_base_path (enum tree_code code,
239 tree v_binfo = NULL_TREE;
240 tree d_binfo = NULL_TREE;
244 tree null_test = NULL;
245 tree ptr_target_type;
247 int want_pointer = TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE;
248 bool has_empty = false;
251 if (expr == error_mark_node || binfo == error_mark_node || !binfo)
252 return error_mark_node;
254 for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
257 if (is_empty_class (BINFO_TYPE (probe)))
259 if (!v_binfo && BINFO_VIRTUAL_P (probe))
263 probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
265 probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe));
267 gcc_assert ((code == MINUS_EXPR
268 && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), probe))
269 || (code == PLUS_EXPR
270 && SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo), probe)));
272 if (binfo == d_binfo)
276 if (code == MINUS_EXPR && v_binfo)
278 error ("cannot convert from base %qT to derived type %qT via virtual base %qT",
279 BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo));
280 return error_mark_node;
284 /* This must happen before the call to save_expr. */
285 expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
287 offset = BINFO_OFFSET (binfo);
288 fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
289 target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);
291 /* Do we need to look in the vtable for the real offset? */
292 virtual_access = (v_binfo && fixed_type_p <= 0);
294 /* Don't bother with the calculations inside sizeof; they'll ICE if the
295 source type is incomplete and the pointer value doesn't matter. */
296 if (cp_unevaluated_operand != 0)
298 expr = build_nop (build_pointer_type (target_type), expr);
300 expr = build_indirect_ref (EXPR_LOCATION (expr), expr, RO_NULL);
304 /* Do we need to check for a null pointer? */
305 if (want_pointer && !nonnull)
307 /* If we know the conversion will not actually change the value
308 of EXPR, then we can avoid testing the expression for NULL.
309 We have to avoid generating a COMPONENT_REF for a base class
310 field, because other parts of the compiler know that such
311 expressions are always non-NULL. */
312 if (!virtual_access && integer_zerop (offset))
315 /* TARGET_TYPE has been extracted from BINFO, and, is
316 therefore always cv-unqualified. Extract the
317 cv-qualifiers from EXPR so that the expression returned
318 matches the input. */
319 class_type = TREE_TYPE (TREE_TYPE (expr));
321 = cp_build_qualified_type (target_type,
322 cp_type_quals (class_type));
323 return build_nop (build_pointer_type (target_type), expr);
325 null_test = error_mark_node;
328 /* Protect against multiple evaluation if necessary. */
329 if (TREE_SIDE_EFFECTS (expr) && (null_test || virtual_access))
330 expr = save_expr (expr);
332 /* Now that we've saved expr, build the real null test. */
335 tree zero = cp_convert (TREE_TYPE (expr), integer_zero_node);
336 null_test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
340 /* If this is a simple base reference, express it as a COMPONENT_REF. */
341 if (code == PLUS_EXPR && !virtual_access
342 /* We don't build base fields for empty bases, and they aren't very
343 interesting to the optimizers anyway. */
346 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
347 expr = build_simple_base_path (expr, binfo);
349 expr = build_address (expr);
350 target_type = TREE_TYPE (expr);
356 /* Going via virtual base V_BINFO. We need the static offset
357 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
358 V_BINFO. That offset is an entry in D_BINFO's vtable. */
361 if (fixed_type_p < 0 && in_base_initializer)
363 /* In a base member initializer, we cannot rely on the
364 vtable being set up. We have to indirect via the
368 t = TREE_TYPE (TYPE_VFIELD (current_class_type));
369 t = build_pointer_type (t);
370 v_offset = convert (t, current_vtt_parm);
371 v_offset = cp_build_indirect_ref (v_offset, RO_NULL,
372 tf_warning_or_error);
375 v_offset = build_vfield_ref (cp_build_indirect_ref (expr, RO_NULL,
376 tf_warning_or_error),
377 TREE_TYPE (TREE_TYPE (expr)));
379 v_offset = build2 (POINTER_PLUS_EXPR, TREE_TYPE (v_offset),
380 v_offset, fold_convert (sizetype, BINFO_VPTR_FIELD (v_binfo)));
381 v_offset = build1 (NOP_EXPR,
382 build_pointer_type (ptrdiff_type_node),
384 v_offset = cp_build_indirect_ref (v_offset, RO_NULL, tf_warning_or_error);
385 TREE_CONSTANT (v_offset) = 1;
387 offset = convert_to_integer (ptrdiff_type_node,
388 size_diffop_loc (input_location, offset,
389 BINFO_OFFSET (v_binfo)));
391 if (!integer_zerop (offset))
392 v_offset = build2 (code, ptrdiff_type_node, v_offset, offset);
394 if (fixed_type_p < 0)
395 /* Negative fixed_type_p means this is a constructor or destructor;
396 virtual base layout is fixed in in-charge [cd]tors, but not in
398 offset = build3 (COND_EXPR, ptrdiff_type_node,
399 build2 (EQ_EXPR, boolean_type_node,
400 current_in_charge_parm, integer_zero_node),
402 convert_to_integer (ptrdiff_type_node,
403 BINFO_OFFSET (binfo)));
408 target_type = cp_build_qualified_type
409 (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr))));
410 ptr_target_type = build_pointer_type (target_type);
412 target_type = ptr_target_type;
414 expr = build1 (NOP_EXPR, ptr_target_type, expr);
416 if (!integer_zerop (offset))
418 offset = fold_convert (sizetype, offset);
419 if (code == MINUS_EXPR)
420 offset = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, offset);
421 expr = build2 (POINTER_PLUS_EXPR, ptr_target_type, expr, offset);
427 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
431 expr = fold_build3_loc (input_location, COND_EXPR, target_type, null_test, expr,
432 fold_build1_loc (input_location, NOP_EXPR, target_type,
438 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
439 Perform a derived-to-base conversion by recursively building up a
440 sequence of COMPONENT_REFs to the appropriate base fields. */
443 build_simple_base_path (tree expr, tree binfo)
445 tree type = BINFO_TYPE (binfo);
446 tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo);
449 if (d_binfo == NULL_TREE)
453 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type);
455 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
456 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
457 an lvalue in the front end; only _DECLs and _REFs are lvalues
459 temp = unary_complex_lvalue (ADDR_EXPR, expr);
461 expr = cp_build_indirect_ref (temp, RO_NULL, tf_warning_or_error);
467 expr = build_simple_base_path (expr, d_binfo);
469 for (field = TYPE_FIELDS (BINFO_TYPE (d_binfo));
470 field; field = TREE_CHAIN (field))
471 /* Is this the base field created by build_base_field? */
472 if (TREE_CODE (field) == FIELD_DECL
473 && DECL_FIELD_IS_BASE (field)
474 && TREE_TYPE (field) == type)
476 /* We don't use build_class_member_access_expr here, as that
477 has unnecessary checks, and more importantly results in
478 recursive calls to dfs_walk_once. */
479 int type_quals = cp_type_quals (TREE_TYPE (expr));
481 expr = build3 (COMPONENT_REF,
482 cp_build_qualified_type (type, type_quals),
483 expr, field, NULL_TREE);
484 expr = fold_if_not_in_template (expr);
486 /* Mark the expression const or volatile, as appropriate.
487 Even though we've dealt with the type above, we still have
488 to mark the expression itself. */
489 if (type_quals & TYPE_QUAL_CONST)
490 TREE_READONLY (expr) = 1;
491 if (type_quals & TYPE_QUAL_VOLATILE)
492 TREE_THIS_VOLATILE (expr) = 1;
497 /* Didn't find the base field?!? */
501 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
502 type is a class type or a pointer to a class type. In the former
503 case, TYPE is also a class type; in the latter it is another
504 pointer type. If CHECK_ACCESS is true, an error message is emitted
505 if TYPE is inaccessible. If OBJECT has pointer type, the value is
506 assumed to be non-NULL. */
509 convert_to_base (tree object, tree type, bool check_access, bool nonnull,
510 tsubst_flags_t complain)
516 if (TYPE_PTR_P (TREE_TYPE (object)))
518 object_type = TREE_TYPE (TREE_TYPE (object));
519 type = TREE_TYPE (type);
522 object_type = TREE_TYPE (object);
524 access = check_access ? ba_check : ba_unique;
525 if (!(complain & tf_error))
527 binfo = lookup_base (object_type, type,
530 if (!binfo || binfo == error_mark_node)
531 return error_mark_node;
533 return build_base_path (PLUS_EXPR, object, binfo, nonnull);
536 /* EXPR is an expression with unqualified class type. BASE is a base
537 binfo of that class type. Returns EXPR, converted to the BASE
538 type. This function assumes that EXPR is the most derived class;
539 therefore virtual bases can be found at their static offsets. */
542 convert_to_base_statically (tree expr, tree base)
546 expr_type = TREE_TYPE (expr);
547 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base), expr_type))
551 pointer_type = build_pointer_type (expr_type);
553 /* We use fold_build2 and fold_convert below to simplify the trees
554 provided to the optimizers. It is not safe to call these functions
555 when processing a template because they do not handle C++-specific
557 gcc_assert (!processing_template_decl);
558 expr = cp_build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1,
559 tf_warning_or_error);
560 if (!integer_zerop (BINFO_OFFSET (base)))
561 expr = fold_build2_loc (input_location,
562 POINTER_PLUS_EXPR, pointer_type, expr,
563 fold_convert (sizetype, BINFO_OFFSET (base)));
564 expr = fold_convert (build_pointer_type (BINFO_TYPE (base)), expr);
565 expr = build_fold_indirect_ref_loc (input_location, expr);
573 build_vfield_ref (tree datum, tree type)
575 tree vfield, vcontext;
577 if (datum == error_mark_node)
578 return error_mark_node;
580 /* First, convert to the requested type. */
581 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
582 datum = convert_to_base (datum, type, /*check_access=*/false,
583 /*nonnull=*/true, tf_warning_or_error);
585 /* Second, the requested type may not be the owner of its own vptr.
586 If not, convert to the base class that owns it. We cannot use
587 convert_to_base here, because VCONTEXT may appear more than once
588 in the inheritance hierarchy of TYPE, and thus direct conversion
589 between the types may be ambiguous. Following the path back up
590 one step at a time via primary bases avoids the problem. */
591 vfield = TYPE_VFIELD (type);
592 vcontext = DECL_CONTEXT (vfield);
593 while (!same_type_ignoring_top_level_qualifiers_p (vcontext, type))
595 datum = build_simple_base_path (datum, CLASSTYPE_PRIMARY_BINFO (type));
596 type = TREE_TYPE (datum);
599 return build3 (COMPONENT_REF, TREE_TYPE (vfield), datum, vfield, NULL_TREE);
602 /* Given an object INSTANCE, return an expression which yields the
603 vtable element corresponding to INDEX. There are many special
604 cases for INSTANCE which we take care of here, mainly to avoid
605 creating extra tree nodes when we don't have to. */
608 build_vtbl_ref_1 (tree instance, tree idx)
611 tree vtbl = NULL_TREE;
613 /* Try to figure out what a reference refers to, and
614 access its virtual function table directly. */
617 tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp);
619 tree basetype = non_reference (TREE_TYPE (instance));
621 if (fixed_type && !cdtorp)
623 tree binfo = lookup_base (fixed_type, basetype,
624 ba_unique | ba_quiet, NULL);
626 vtbl = unshare_expr (BINFO_VTABLE (binfo));
630 vtbl = build_vfield_ref (instance, basetype);
632 aref = build_array_ref (input_location, vtbl, idx);
633 TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx);
639 build_vtbl_ref (tree instance, tree idx)
641 tree aref = build_vtbl_ref_1 (instance, idx);
646 /* Given a stable object pointer INSTANCE_PTR, return an expression which
647 yields a function pointer corresponding to vtable element INDEX. */
650 build_vfn_ref (tree instance_ptr, tree idx)
654 aref = build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr, RO_NULL,
655 tf_warning_or_error),
658 /* When using function descriptors, the address of the
659 vtable entry is treated as a function pointer. */
660 if (TARGET_VTABLE_USES_DESCRIPTORS)
661 aref = build1 (NOP_EXPR, TREE_TYPE (aref),
662 cp_build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1,
663 tf_warning_or_error));
665 /* Remember this as a method reference, for later devirtualization. */
666 aref = build3 (OBJ_TYPE_REF, TREE_TYPE (aref), aref, instance_ptr, idx);
671 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
672 for the given TYPE. */
675 get_vtable_name (tree type)
677 return mangle_vtbl_for_type (type);
680 /* DECL is an entity associated with TYPE, like a virtual table or an
681 implicitly generated constructor. Determine whether or not DECL
682 should have external or internal linkage at the object file
683 level. This routine does not deal with COMDAT linkage and other
684 similar complexities; it simply sets TREE_PUBLIC if it possible for
685 entities in other translation units to contain copies of DECL, in
689 set_linkage_according_to_type (tree type, tree decl)
691 /* If TYPE involves a local class in a function with internal
692 linkage, then DECL should have internal linkage too. Other local
693 classes have no linkage -- but if their containing functions
694 have external linkage, it makes sense for DECL to have external
695 linkage too. That will allow template definitions to be merged,
697 if (no_linkage_check (type, /*relaxed_p=*/true))
699 TREE_PUBLIC (decl) = 0;
700 DECL_INTERFACE_KNOWN (decl) = 1;
703 TREE_PUBLIC (decl) = 1;
706 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
707 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
708 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
711 build_vtable (tree class_type, tree name, tree vtable_type)
715 decl = build_lang_decl (VAR_DECL, name, vtable_type);
716 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
717 now to avoid confusion in mangle_decl. */
718 SET_DECL_ASSEMBLER_NAME (decl, name);
719 DECL_CONTEXT (decl) = class_type;
720 DECL_ARTIFICIAL (decl) = 1;
721 TREE_STATIC (decl) = 1;
722 TREE_READONLY (decl) = 1;
723 DECL_VIRTUAL_P (decl) = 1;
724 DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
725 DECL_VTABLE_OR_VTT_P (decl) = 1;
726 /* At one time the vtable info was grabbed 2 words at a time. This
727 fails on sparc unless you have 8-byte alignment. (tiemann) */
728 DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
730 set_linkage_according_to_type (class_type, decl);
731 /* The vtable has not been defined -- yet. */
732 DECL_EXTERNAL (decl) = 1;
733 DECL_NOT_REALLY_EXTERN (decl) = 1;
735 /* Mark the VAR_DECL node representing the vtable itself as a
736 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
737 is rather important that such things be ignored because any
738 effort to actually generate DWARF for them will run into
739 trouble when/if we encounter code like:
742 struct S { virtual void member (); };
744 because the artificial declaration of the vtable itself (as
745 manufactured by the g++ front end) will say that the vtable is
746 a static member of `S' but only *after* the debug output for
747 the definition of `S' has already been output. This causes
748 grief because the DWARF entry for the definition of the vtable
749 will try to refer back to an earlier *declaration* of the
750 vtable as a static member of `S' and there won't be one. We
751 might be able to arrange to have the "vtable static member"
752 attached to the member list for `S' before the debug info for
753 `S' get written (which would solve the problem) but that would
754 require more intrusive changes to the g++ front end. */
755 DECL_IGNORED_P (decl) = 1;
760 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
761 or even complete. If this does not exist, create it. If COMPLETE is
762 nonzero, then complete the definition of it -- that will render it
763 impossible to actually build the vtable, but is useful to get at those
764 which are known to exist in the runtime. */
767 get_vtable_decl (tree type, int complete)
771 if (CLASSTYPE_VTABLES (type))
772 return CLASSTYPE_VTABLES (type);
774 decl = build_vtable (type, get_vtable_name (type), vtbl_type_node);
775 CLASSTYPE_VTABLES (type) = decl;
779 DECL_EXTERNAL (decl) = 1;
780 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
786 /* Build the primary virtual function table for TYPE. If BINFO is
787 non-NULL, build the vtable starting with the initial approximation
788 that it is the same as the one which is the head of the association
789 list. Returns a nonzero value if a new vtable is actually
793 build_primary_vtable (tree binfo, tree type)
798 decl = get_vtable_decl (type, /*complete=*/0);
802 if (BINFO_NEW_VTABLE_MARKED (binfo))
803 /* We have already created a vtable for this base, so there's
804 no need to do it again. */
807 virtuals = copy_list (BINFO_VIRTUALS (binfo));
808 TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo));
809 DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
810 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
814 gcc_assert (TREE_TYPE (decl) == vtbl_type_node);
815 virtuals = NULL_TREE;
818 #ifdef GATHER_STATISTICS
820 n_vtable_elems += list_length (virtuals);
823 /* Initialize the association list for this type, based
824 on our first approximation. */
825 BINFO_VTABLE (TYPE_BINFO (type)) = decl;
826 BINFO_VIRTUALS (TYPE_BINFO (type)) = virtuals;
827 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
831 /* Give BINFO a new virtual function table which is initialized
832 with a skeleton-copy of its original initialization. The only
833 entry that changes is the `delta' entry, so we can really
834 share a lot of structure.
836 FOR_TYPE is the most derived type which caused this table to
839 Returns nonzero if we haven't met BINFO before.
841 The order in which vtables are built (by calling this function) for
842 an object must remain the same, otherwise a binary incompatibility
846 build_secondary_vtable (tree binfo)
848 if (BINFO_NEW_VTABLE_MARKED (binfo))
849 /* We already created a vtable for this base. There's no need to
853 /* Remember that we've created a vtable for this BINFO, so that we
854 don't try to do so again. */
855 SET_BINFO_NEW_VTABLE_MARKED (binfo);
857 /* Make fresh virtual list, so we can smash it later. */
858 BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
860 /* Secondary vtables are laid out as part of the same structure as
861 the primary vtable. */
862 BINFO_VTABLE (binfo) = NULL_TREE;
866 /* Create a new vtable for BINFO which is the hierarchy dominated by
867 T. Return nonzero if we actually created a new vtable. */
870 make_new_vtable (tree t, tree binfo)
872 if (binfo == TYPE_BINFO (t))
873 /* In this case, it is *type*'s vtable we are modifying. We start
874 with the approximation that its vtable is that of the
875 immediate base class. */
876 return build_primary_vtable (binfo, t);
878 /* This is our very own copy of `basetype' to play with. Later,
879 we will fill in all the virtual functions that override the
880 virtual functions in these base classes which are not defined
881 by the current type. */
882 return build_secondary_vtable (binfo);
885 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
886 (which is in the hierarchy dominated by T) list FNDECL as its
887 BV_FN. DELTA is the required constant adjustment from the `this'
888 pointer where the vtable entry appears to the `this' required when
889 the function is actually called. */
892 modify_vtable_entry (tree t,
902 if (fndecl != BV_FN (v)
903 || !tree_int_cst_equal (delta, BV_DELTA (v)))
905 /* We need a new vtable for BINFO. */
906 if (make_new_vtable (t, binfo))
908 /* If we really did make a new vtable, we also made a copy
909 of the BINFO_VIRTUALS list. Now, we have to find the
910 corresponding entry in that list. */
911 *virtuals = BINFO_VIRTUALS (binfo);
912 while (BV_FN (*virtuals) != BV_FN (v))
913 *virtuals = TREE_CHAIN (*virtuals);
917 BV_DELTA (v) = delta;
918 BV_VCALL_INDEX (v) = NULL_TREE;
924 /* Add method METHOD to class TYPE. If USING_DECL is non-null, it is
925 the USING_DECL naming METHOD. Returns true if the method could be
926 added to the method vec. */
929 add_method (tree type, tree method, tree using_decl)
933 bool template_conv_p = false;
935 VEC(tree,gc) *method_vec;
937 bool insert_p = false;
941 if (method == error_mark_node)
944 complete_p = COMPLETE_TYPE_P (type);
945 conv_p = DECL_CONV_FN_P (method);
947 template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL
948 && DECL_TEMPLATE_CONV_FN_P (method));
950 method_vec = CLASSTYPE_METHOD_VEC (type);
953 /* Make a new method vector. We start with 8 entries. We must
954 allocate at least two (for constructors and destructors), and
955 we're going to end up with an assignment operator at some
957 method_vec = VEC_alloc (tree, gc, 8);
958 /* Create slots for constructors and destructors. */
959 VEC_quick_push (tree, method_vec, NULL_TREE);
960 VEC_quick_push (tree, method_vec, NULL_TREE);
961 CLASSTYPE_METHOD_VEC (type) = method_vec;
964 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
965 grok_special_member_properties (method);
967 /* Constructors and destructors go in special slots. */
968 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method))
969 slot = CLASSTYPE_CONSTRUCTOR_SLOT;
970 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
972 slot = CLASSTYPE_DESTRUCTOR_SLOT;
974 if (TYPE_FOR_JAVA (type))
976 if (!DECL_ARTIFICIAL (method))
977 error ("Java class %qT cannot have a destructor", type);
978 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
979 error ("Java class %qT cannot have an implicit non-trivial "
989 /* See if we already have an entry with this name. */
990 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
991 VEC_iterate (tree, method_vec, slot, m);
997 if (TREE_CODE (m) == TEMPLATE_DECL
998 && DECL_TEMPLATE_CONV_FN_P (m))
1002 if (conv_p && !DECL_CONV_FN_P (m))
1004 if (DECL_NAME (m) == DECL_NAME (method))
1010 && !DECL_CONV_FN_P (m)
1011 && DECL_NAME (m) > DECL_NAME (method))
1015 current_fns = insert_p ? NULL_TREE : VEC_index (tree, method_vec, slot);
1017 /* Check to see if we've already got this method. */
1018 for (fns = current_fns; fns; fns = OVL_NEXT (fns))
1020 tree fn = OVL_CURRENT (fns);
1026 if (TREE_CODE (fn) != TREE_CODE (method))
1029 /* [over.load] Member function declarations with the
1030 same name and the same parameter types cannot be
1031 overloaded if any of them is a static member
1032 function declaration.
1034 [namespace.udecl] When a using-declaration brings names
1035 from a base class into a derived class scope, member
1036 functions in the derived class override and/or hide member
1037 functions with the same name and parameter types in a base
1038 class (rather than conflicting). */
1039 fn_type = TREE_TYPE (fn);
1040 method_type = TREE_TYPE (method);
1041 parms1 = TYPE_ARG_TYPES (fn_type);
1042 parms2 = TYPE_ARG_TYPES (method_type);
1044 /* Compare the quals on the 'this' parm. Don't compare
1045 the whole types, as used functions are treated as
1046 coming from the using class in overload resolution. */
1047 if (! DECL_STATIC_FUNCTION_P (fn)
1048 && ! DECL_STATIC_FUNCTION_P (method)
1049 && TREE_TYPE (TREE_VALUE (parms1)) != error_mark_node
1050 && TREE_TYPE (TREE_VALUE (parms2)) != error_mark_node
1051 && (cp_type_quals (TREE_TYPE (TREE_VALUE (parms1)))
1052 != cp_type_quals (TREE_TYPE (TREE_VALUE (parms2)))))
1055 /* For templates, the return type and template parameters
1056 must be identical. */
1057 if (TREE_CODE (fn) == TEMPLATE_DECL
1058 && (!same_type_p (TREE_TYPE (fn_type),
1059 TREE_TYPE (method_type))
1060 || !comp_template_parms (DECL_TEMPLATE_PARMS (fn),
1061 DECL_TEMPLATE_PARMS (method))))
1064 if (! DECL_STATIC_FUNCTION_P (fn))
1065 parms1 = TREE_CHAIN (parms1);
1066 if (! DECL_STATIC_FUNCTION_P (method))
1067 parms2 = TREE_CHAIN (parms2);
1069 if (compparms (parms1, parms2)
1070 && (!DECL_CONV_FN_P (fn)
1071 || same_type_p (TREE_TYPE (fn_type),
1072 TREE_TYPE (method_type))))
1076 if (DECL_CONTEXT (fn) == type)
1077 /* Defer to the local function. */
1079 if (DECL_CONTEXT (fn) == DECL_CONTEXT (method))
1080 error ("repeated using declaration %q+D", using_decl);
1082 error ("using declaration %q+D conflicts with a previous using declaration",
1087 error ("%q+#D cannot be overloaded", method);
1088 error ("with %q+#D", fn);
1091 /* We don't call duplicate_decls here to merge the
1092 declarations because that will confuse things if the
1093 methods have inline definitions. In particular, we
1094 will crash while processing the definitions. */
1099 /* A class should never have more than one destructor. */
1100 if (current_fns && DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method))
1103 /* Add the new binding. */
1104 overload = build_overload (method, current_fns);
1107 TYPE_HAS_CONVERSION (type) = 1;
1108 else if (slot >= CLASSTYPE_FIRST_CONVERSION_SLOT && !complete_p)
1109 push_class_level_binding (DECL_NAME (method), overload);
1115 /* We only expect to add few methods in the COMPLETE_P case, so
1116 just make room for one more method in that case. */
1118 reallocated = VEC_reserve_exact (tree, gc, method_vec, 1);
1120 reallocated = VEC_reserve (tree, gc, method_vec, 1);
1122 CLASSTYPE_METHOD_VEC (type) = method_vec;
1123 if (slot == VEC_length (tree, method_vec))
1124 VEC_quick_push (tree, method_vec, overload);
1126 VEC_quick_insert (tree, method_vec, slot, overload);
1129 /* Replace the current slot. */
1130 VEC_replace (tree, method_vec, slot, overload);
1134 /* Subroutines of finish_struct. */
1136 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1137 legit, otherwise return 0. */
1140 alter_access (tree t, tree fdecl, tree access)
1144 if (!DECL_LANG_SPECIFIC (fdecl))
1145 retrofit_lang_decl (fdecl);
1147 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl));
1149 elem = purpose_member (t, DECL_ACCESS (fdecl));
1152 if (TREE_VALUE (elem) != access)
1154 if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1155 error ("conflicting access specifications for method"
1156 " %q+D, ignored", TREE_TYPE (fdecl));
1158 error ("conflicting access specifications for field %qE, ignored",
1163 /* They're changing the access to the same thing they changed
1164 it to before. That's OK. */
1170 perform_or_defer_access_check (TYPE_BINFO (t), fdecl, fdecl);
1171 DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1177 /* Process the USING_DECL, which is a member of T. */
1180 handle_using_decl (tree using_decl, tree t)
1182 tree decl = USING_DECL_DECLS (using_decl);
1183 tree name = DECL_NAME (using_decl);
1185 = TREE_PRIVATE (using_decl) ? access_private_node
1186 : TREE_PROTECTED (using_decl) ? access_protected_node
1187 : access_public_node;
1188 tree flist = NULL_TREE;
1191 gcc_assert (!processing_template_decl && decl);
1193 old_value = lookup_member (t, name, /*protect=*/0, /*want_type=*/false);
1196 if (is_overloaded_fn (old_value))
1197 old_value = OVL_CURRENT (old_value);
1199 if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t)
1202 old_value = NULL_TREE;
1205 cp_emit_debug_info_for_using (decl, USING_DECL_SCOPE (using_decl));
1207 if (is_overloaded_fn (decl))
1212 else if (is_overloaded_fn (old_value))
1215 /* It's OK to use functions from a base when there are functions with
1216 the same name already present in the current class. */;
1219 error ("%q+D invalid in %q#T", using_decl, t);
1220 error (" because of local method %q+#D with same name",
1221 OVL_CURRENT (old_value));
1225 else if (!DECL_ARTIFICIAL (old_value))
1227 error ("%q+D invalid in %q#T", using_decl, t);
1228 error (" because of local member %q+#D with same name", old_value);
1232 /* Make type T see field decl FDECL with access ACCESS. */
1234 for (; flist; flist = OVL_NEXT (flist))
1236 add_method (t, OVL_CURRENT (flist), using_decl);
1237 alter_access (t, OVL_CURRENT (flist), access);
1240 alter_access (t, decl, access);
1243 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1244 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1245 properties of the bases. */
1248 check_bases (tree t,
1249 int* cant_have_const_ctor_p,
1250 int* no_const_asn_ref_p)
1253 int seen_non_virtual_nearly_empty_base_p;
1256 tree field = NULL_TREE;
1258 seen_non_virtual_nearly_empty_base_p = 0;
1260 if (!CLASSTYPE_NON_STD_LAYOUT (t))
1261 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
1262 if (TREE_CODE (field) == FIELD_DECL)
1265 for (binfo = TYPE_BINFO (t), i = 0;
1266 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
1268 tree basetype = TREE_TYPE (base_binfo);
1270 gcc_assert (COMPLETE_TYPE_P (basetype));
1272 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1273 here because the case of virtual functions but non-virtual
1274 dtor is handled in finish_struct_1. */
1275 if (!TYPE_POLYMORPHIC_P (basetype))
1276 warning (OPT_Weffc__,
1277 "base class %q#T has a non-virtual destructor", basetype);
1279 /* If the base class doesn't have copy constructors or
1280 assignment operators that take const references, then the
1281 derived class cannot have such a member automatically
1283 if (! TYPE_HAS_CONST_INIT_REF (basetype))
1284 *cant_have_const_ctor_p = 1;
1285 if (TYPE_HAS_ASSIGN_REF (basetype)
1286 && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1287 *no_const_asn_ref_p = 1;
1289 if (BINFO_VIRTUAL_P (base_binfo))
1290 /* A virtual base does not effect nearly emptiness. */
1292 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1294 if (seen_non_virtual_nearly_empty_base_p)
1295 /* And if there is more than one nearly empty base, then the
1296 derived class is not nearly empty either. */
1297 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1299 /* Remember we've seen one. */
1300 seen_non_virtual_nearly_empty_base_p = 1;
1302 else if (!is_empty_class (basetype))
1303 /* If the base class is not empty or nearly empty, then this
1304 class cannot be nearly empty. */
1305 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1307 /* A lot of properties from the bases also apply to the derived
1309 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1310 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1311 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype);
1312 TYPE_HAS_COMPLEX_ASSIGN_REF (t)
1313 |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1314 TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1315 TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1316 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)
1317 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype);
1318 TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_HAS_COMPLEX_DFLT (basetype);
1320 /* A standard-layout class is a class that:
1322 * has no non-standard-layout base classes, */
1323 CLASSTYPE_NON_STD_LAYOUT (t) |= CLASSTYPE_NON_STD_LAYOUT (basetype);
1324 if (!CLASSTYPE_NON_STD_LAYOUT (t))
1327 /* ...has no base classes of the same type as the first non-static
1329 if (field && DECL_CONTEXT (field) == t
1330 && (same_type_ignoring_top_level_qualifiers_p
1331 (TREE_TYPE (field), basetype)))
1332 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
1334 /* ...either has no non-static data members in the most-derived
1335 class and at most one base class with non-static data
1336 members, or has no base classes with non-static data
1338 for (basefield = TYPE_FIELDS (basetype); basefield;
1339 basefield = TREE_CHAIN (basefield))
1340 if (TREE_CODE (basefield) == FIELD_DECL)
1343 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
1352 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1353 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1354 that have had a nearly-empty virtual primary base stolen by some
1355 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1359 determine_primary_bases (tree t)
1362 tree primary = NULL_TREE;
1363 tree type_binfo = TYPE_BINFO (t);
1366 /* Determine the primary bases of our bases. */
1367 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1368 base_binfo = TREE_CHAIN (base_binfo))
1370 tree primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo));
1372 /* See if we're the non-virtual primary of our inheritance
1374 if (!BINFO_VIRTUAL_P (base_binfo))
1376 tree parent = BINFO_INHERITANCE_CHAIN (base_binfo);
1377 tree parent_primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent));
1380 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
1381 BINFO_TYPE (parent_primary)))
1382 /* We are the primary binfo. */
1383 BINFO_PRIMARY_P (base_binfo) = 1;
1385 /* Determine if we have a virtual primary base, and mark it so.
1387 if (primary && BINFO_VIRTUAL_P (primary))
1389 tree this_primary = copied_binfo (primary, base_binfo);
1391 if (BINFO_PRIMARY_P (this_primary))
1392 /* Someone already claimed this base. */
1393 BINFO_LOST_PRIMARY_P (base_binfo) = 1;
1398 BINFO_PRIMARY_P (this_primary) = 1;
1399 BINFO_INHERITANCE_CHAIN (this_primary) = base_binfo;
1401 /* A virtual binfo might have been copied from within
1402 another hierarchy. As we're about to use it as a
1403 primary base, make sure the offsets match. */
1404 delta = size_diffop_loc (input_location,
1406 BINFO_OFFSET (base_binfo)),
1408 BINFO_OFFSET (this_primary)));
1410 propagate_binfo_offsets (this_primary, delta);
1415 /* First look for a dynamic direct non-virtual base. */
1416 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, base_binfo); i++)
1418 tree basetype = BINFO_TYPE (base_binfo);
1420 if (TYPE_CONTAINS_VPTR_P (basetype) && !BINFO_VIRTUAL_P (base_binfo))
1422 primary = base_binfo;
1427 /* A "nearly-empty" virtual base class can be the primary base
1428 class, if no non-virtual polymorphic base can be found. Look for
1429 a nearly-empty virtual dynamic base that is not already a primary
1430 base of something in the hierarchy. If there is no such base,
1431 just pick the first nearly-empty virtual base. */
1433 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1434 base_binfo = TREE_CHAIN (base_binfo))
1435 if (BINFO_VIRTUAL_P (base_binfo)
1436 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo)))
1438 if (!BINFO_PRIMARY_P (base_binfo))
1440 /* Found one that is not primary. */
1441 primary = base_binfo;
1445 /* Remember the first candidate. */
1446 primary = base_binfo;
1450 /* If we've got a primary base, use it. */
1453 tree basetype = BINFO_TYPE (primary);
1455 CLASSTYPE_PRIMARY_BINFO (t) = primary;
1456 if (BINFO_PRIMARY_P (primary))
1457 /* We are stealing a primary base. */
1458 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary)) = 1;
1459 BINFO_PRIMARY_P (primary) = 1;
1460 if (BINFO_VIRTUAL_P (primary))
1464 BINFO_INHERITANCE_CHAIN (primary) = type_binfo;
1465 /* A virtual binfo might have been copied from within
1466 another hierarchy. As we're about to use it as a primary
1467 base, make sure the offsets match. */
1468 delta = size_diffop_loc (input_location, ssize_int (0),
1469 convert (ssizetype, BINFO_OFFSET (primary)));
1471 propagate_binfo_offsets (primary, delta);
1474 primary = TYPE_BINFO (basetype);
1476 TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1477 BINFO_VTABLE (type_binfo) = BINFO_VTABLE (primary);
1478 BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary);
1482 /* Update the variant types of T. */
1485 fixup_type_variants (tree t)
1492 for (variants = TYPE_NEXT_VARIANT (t);
1494 variants = TYPE_NEXT_VARIANT (variants))
1496 /* These fields are in the _TYPE part of the node, not in
1497 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1498 TYPE_HAS_USER_CONSTRUCTOR (variants) = TYPE_HAS_USER_CONSTRUCTOR (t);
1499 TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1500 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants)
1501 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
1503 TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
1505 TYPE_BINFO (variants) = TYPE_BINFO (t);
1507 /* Copy whatever these are holding today. */
1508 TYPE_VFIELD (variants) = TYPE_VFIELD (t);
1509 TYPE_METHODS (variants) = TYPE_METHODS (t);
1510 TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1512 /* All variants of a class have the same attributes. */
1513 TYPE_ATTRIBUTES (variants) = TYPE_ATTRIBUTES (t);
1518 /* Set memoizing fields and bits of T (and its variants) for later
1522 finish_struct_bits (tree t)
1524 /* Fix up variants (if any). */
1525 fixup_type_variants (t);
1527 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t))
1528 /* For a class w/o baseclasses, 'finish_struct' has set
1529 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1530 Similarly for a class whose base classes do not have vtables.
1531 When neither of these is true, we might have removed abstract
1532 virtuals (by providing a definition), added some (by declaring
1533 new ones), or redeclared ones from a base class. We need to
1534 recalculate what's really an abstract virtual at this point (by
1535 looking in the vtables). */
1536 get_pure_virtuals (t);
1538 /* If this type has a copy constructor or a destructor, force its
1539 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1540 nonzero. This will cause it to be passed by invisible reference
1541 and prevent it from being returned in a register. */
1542 if (! TYPE_HAS_TRIVIAL_INIT_REF (t) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
1545 DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1546 for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1548 SET_TYPE_MODE (variants, BLKmode);
1549 TREE_ADDRESSABLE (variants) = 1;
1554 /* Issue warnings about T having private constructors, but no friends,
1557 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1558 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1559 non-private static member functions. */
1562 maybe_warn_about_overly_private_class (tree t)
1564 int has_member_fn = 0;
1565 int has_nonprivate_method = 0;
1568 if (!warn_ctor_dtor_privacy
1569 /* If the class has friends, those entities might create and
1570 access instances, so we should not warn. */
1571 || (CLASSTYPE_FRIEND_CLASSES (t)
1572 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
1573 /* We will have warned when the template was declared; there's
1574 no need to warn on every instantiation. */
1575 || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1576 /* There's no reason to even consider warning about this
1580 /* We only issue one warning, if more than one applies, because
1581 otherwise, on code like:
1584 // Oops - forgot `public:'
1590 we warn several times about essentially the same problem. */
1592 /* Check to see if all (non-constructor, non-destructor) member
1593 functions are private. (Since there are no friends or
1594 non-private statics, we can't ever call any of the private member
1596 for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
1597 /* We're not interested in compiler-generated methods; they don't
1598 provide any way to call private members. */
1599 if (!DECL_ARTIFICIAL (fn))
1601 if (!TREE_PRIVATE (fn))
1603 if (DECL_STATIC_FUNCTION_P (fn))
1604 /* A non-private static member function is just like a
1605 friend; it can create and invoke private member
1606 functions, and be accessed without a class
1610 has_nonprivate_method = 1;
1611 /* Keep searching for a static member function. */
1613 else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
1617 if (!has_nonprivate_method && has_member_fn)
1619 /* There are no non-private methods, and there's at least one
1620 private member function that isn't a constructor or
1621 destructor. (If all the private members are
1622 constructors/destructors we want to use the code below that
1623 issues error messages specifically referring to
1624 constructors/destructors.) */
1626 tree binfo = TYPE_BINFO (t);
1628 for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++)
1629 if (BINFO_BASE_ACCESS (binfo, i) != access_private_node)
1631 has_nonprivate_method = 1;
1634 if (!has_nonprivate_method)
1636 warning (OPT_Wctor_dtor_privacy,
1637 "all member functions in class %qT are private", t);
1642 /* Even if some of the member functions are non-private, the class
1643 won't be useful for much if all the constructors or destructors
1644 are private: such an object can never be created or destroyed. */
1645 fn = CLASSTYPE_DESTRUCTORS (t);
1646 if (fn && TREE_PRIVATE (fn))
1648 warning (OPT_Wctor_dtor_privacy,
1649 "%q#T only defines a private destructor and has no friends",
1654 /* Warn about classes that have private constructors and no friends. */
1655 if (TYPE_HAS_USER_CONSTRUCTOR (t)
1656 /* Implicitly generated constructors are always public. */
1657 && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t)
1658 || !CLASSTYPE_LAZY_COPY_CTOR (t)))
1660 int nonprivate_ctor = 0;
1662 /* If a non-template class does not define a copy
1663 constructor, one is defined for it, enabling it to avoid
1664 this warning. For a template class, this does not
1665 happen, and so we would normally get a warning on:
1667 template <class T> class C { private: C(); };
1669 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
1670 complete non-template or fully instantiated classes have this
1672 if (!TYPE_HAS_INIT_REF (t))
1673 nonprivate_ctor = 1;
1675 for (fn = CLASSTYPE_CONSTRUCTORS (t); fn; fn = OVL_NEXT (fn))
1677 tree ctor = OVL_CURRENT (fn);
1678 /* Ideally, we wouldn't count copy constructors (or, in
1679 fact, any constructor that takes an argument of the
1680 class type as a parameter) because such things cannot
1681 be used to construct an instance of the class unless
1682 you already have one. But, for now at least, we're
1684 if (! TREE_PRIVATE (ctor))
1686 nonprivate_ctor = 1;
1691 if (nonprivate_ctor == 0)
1693 warning (OPT_Wctor_dtor_privacy,
1694 "%q#T only defines private constructors and has no friends",
1702 gt_pointer_operator new_value;
1706 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1709 method_name_cmp (const void* m1_p, const void* m2_p)
1711 const tree *const m1 = (const tree *) m1_p;
1712 const tree *const m2 = (const tree *) m2_p;
1714 if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1716 if (*m1 == NULL_TREE)
1718 if (*m2 == NULL_TREE)
1720 if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
1725 /* This routine compares two fields like method_name_cmp but using the
1726 pointer operator in resort_field_decl_data. */
1729 resort_method_name_cmp (const void* m1_p, const void* m2_p)
1731 const tree *const m1 = (const tree *) m1_p;
1732 const tree *const m2 = (const tree *) m2_p;
1733 if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1735 if (*m1 == NULL_TREE)
1737 if (*m2 == NULL_TREE)
1740 tree d1 = DECL_NAME (OVL_CURRENT (*m1));
1741 tree d2 = DECL_NAME (OVL_CURRENT (*m2));
1742 resort_data.new_value (&d1, resort_data.cookie);
1743 resort_data.new_value (&d2, resort_data.cookie);
1750 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1753 resort_type_method_vec (void* obj,
1754 void* orig_obj ATTRIBUTE_UNUSED ,
1755 gt_pointer_operator new_value,
1758 VEC(tree,gc) *method_vec = (VEC(tree,gc) *) obj;
1759 int len = VEC_length (tree, method_vec);
1763 /* The type conversion ops have to live at the front of the vec, so we
1765 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1766 VEC_iterate (tree, method_vec, slot, fn);
1768 if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1773 resort_data.new_value = new_value;
1774 resort_data.cookie = cookie;
1775 qsort (VEC_address (tree, method_vec) + slot, len - slot, sizeof (tree),
1776 resort_method_name_cmp);
1780 /* Warn about duplicate methods in fn_fields.
1782 Sort methods that are not special (i.e., constructors, destructors,
1783 and type conversion operators) so that we can find them faster in
1787 finish_struct_methods (tree t)
1790 VEC(tree,gc) *method_vec;
1793 method_vec = CLASSTYPE_METHOD_VEC (t);
1797 len = VEC_length (tree, method_vec);
1799 /* Clear DECL_IN_AGGR_P for all functions. */
1800 for (fn_fields = TYPE_METHODS (t); fn_fields;
1801 fn_fields = TREE_CHAIN (fn_fields))
1802 DECL_IN_AGGR_P (fn_fields) = 0;
1804 /* Issue warnings about private constructors and such. If there are
1805 no methods, then some public defaults are generated. */
1806 maybe_warn_about_overly_private_class (t);
1808 /* The type conversion ops have to live at the front of the vec, so we
1810 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1811 VEC_iterate (tree, method_vec, slot, fn_fields);
1813 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields)))
1816 qsort (VEC_address (tree, method_vec) + slot,
1817 len-slot, sizeof (tree), method_name_cmp);
1820 /* Make BINFO's vtable have N entries, including RTTI entries,
1821 vbase and vcall offsets, etc. Set its type and call the back end
1825 layout_vtable_decl (tree binfo, int n)
1830 atype = build_cplus_array_type (vtable_entry_type,
1831 build_index_type (size_int (n - 1)));
1832 layout_type (atype);
1834 /* We may have to grow the vtable. */
1835 vtable = get_vtbl_decl_for_binfo (binfo);
1836 if (!same_type_p (TREE_TYPE (vtable), atype))
1838 TREE_TYPE (vtable) = atype;
1839 DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1840 layout_decl (vtable, 0);
1844 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1845 have the same signature. */
1848 same_signature_p (const_tree fndecl, const_tree base_fndecl)
1850 /* One destructor overrides another if they are the same kind of
1852 if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl)
1853 && special_function_p (base_fndecl) == special_function_p (fndecl))
1855 /* But a non-destructor never overrides a destructor, nor vice
1856 versa, nor do different kinds of destructors override
1857 one-another. For example, a complete object destructor does not
1858 override a deleting destructor. */
1859 if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl))
1862 if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl)
1863 || (DECL_CONV_FN_P (fndecl)
1864 && DECL_CONV_FN_P (base_fndecl)
1865 && same_type_p (DECL_CONV_FN_TYPE (fndecl),
1866 DECL_CONV_FN_TYPE (base_fndecl))))
1868 tree types, base_types;
1869 types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1870 base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
1871 if ((cp_type_quals (TREE_TYPE (TREE_VALUE (base_types)))
1872 == cp_type_quals (TREE_TYPE (TREE_VALUE (types))))
1873 && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
1879 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1883 base_derived_from (tree derived, tree base)
1887 for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1889 if (probe == derived)
1891 else if (BINFO_VIRTUAL_P (probe))
1892 /* If we meet a virtual base, we can't follow the inheritance
1893 any more. See if the complete type of DERIVED contains
1894 such a virtual base. */
1895 return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (derived))
1901 typedef struct find_final_overrider_data_s {
1902 /* The function for which we are trying to find a final overrider. */
1904 /* The base class in which the function was declared. */
1905 tree declaring_base;
1906 /* The candidate overriders. */
1908 /* Path to most derived. */
1909 VEC(tree,heap) *path;
1910 } find_final_overrider_data;
1912 /* Add the overrider along the current path to FFOD->CANDIDATES.
1913 Returns true if an overrider was found; false otherwise. */
1916 dfs_find_final_overrider_1 (tree binfo,
1917 find_final_overrider_data *ffod,
1922 /* If BINFO is not the most derived type, try a more derived class.
1923 A definition there will overrider a definition here. */
1927 if (dfs_find_final_overrider_1
1928 (VEC_index (tree, ffod->path, depth), ffod, depth))
1932 method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1935 tree *candidate = &ffod->candidates;
1937 /* Remove any candidates overridden by this new function. */
1940 /* If *CANDIDATE overrides METHOD, then METHOD
1941 cannot override anything else on the list. */
1942 if (base_derived_from (TREE_VALUE (*candidate), binfo))
1944 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1945 if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1946 *candidate = TREE_CHAIN (*candidate);
1948 candidate = &TREE_CHAIN (*candidate);
1951 /* Add the new function. */
1952 ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1959 /* Called from find_final_overrider via dfs_walk. */
1962 dfs_find_final_overrider_pre (tree binfo, void *data)
1964 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1966 if (binfo == ffod->declaring_base)
1967 dfs_find_final_overrider_1 (binfo, ffod, VEC_length (tree, ffod->path));
1968 VEC_safe_push (tree, heap, ffod->path, binfo);
1974 dfs_find_final_overrider_post (tree binfo ATTRIBUTE_UNUSED, void *data)
1976 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1977 VEC_pop (tree, ffod->path);
1982 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1983 FN and whose TREE_VALUE is the binfo for the base where the
1984 overriding occurs. BINFO (in the hierarchy dominated by the binfo
1985 DERIVED) is the base object in which FN is declared. */
1988 find_final_overrider (tree derived, tree binfo, tree fn)
1990 find_final_overrider_data ffod;
1992 /* Getting this right is a little tricky. This is valid:
1994 struct S { virtual void f (); };
1995 struct T { virtual void f (); };
1996 struct U : public S, public T { };
1998 even though calling `f' in `U' is ambiguous. But,
2000 struct R { virtual void f(); };
2001 struct S : virtual public R { virtual void f (); };
2002 struct T : virtual public R { virtual void f (); };
2003 struct U : public S, public T { };
2005 is not -- there's no way to decide whether to put `S::f' or
2006 `T::f' in the vtable for `R'.
2008 The solution is to look at all paths to BINFO. If we find
2009 different overriders along any two, then there is a problem. */
2010 if (DECL_THUNK_P (fn))
2011 fn = THUNK_TARGET (fn);
2013 /* Determine the depth of the hierarchy. */
2015 ffod.declaring_base = binfo;
2016 ffod.candidates = NULL_TREE;
2017 ffod.path = VEC_alloc (tree, heap, 30);
2019 dfs_walk_all (derived, dfs_find_final_overrider_pre,
2020 dfs_find_final_overrider_post, &ffod);
2022 VEC_free (tree, heap, ffod.path);
2024 /* If there was no winner, issue an error message. */
2025 if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
2026 return error_mark_node;
2028 return ffod.candidates;
2031 /* Return the index of the vcall offset for FN when TYPE is used as a
2035 get_vcall_index (tree fn, tree type)
2037 VEC(tree_pair_s,gc) *indices = CLASSTYPE_VCALL_INDICES (type);
2041 for (ix = 0; VEC_iterate (tree_pair_s, indices, ix, p); ix++)
2042 if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (p->purpose))
2043 || same_signature_p (fn, p->purpose))
2046 /* There should always be an appropriate index. */
2050 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2051 dominated by T. FN has been overridden in BINFO; VIRTUALS points to the
2052 corresponding position in the BINFO_VIRTUALS list. */
2055 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
2063 tree overrider_fn, overrider_target;
2064 tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2065 tree over_return, base_return;
2068 /* Find the nearest primary base (possibly binfo itself) which defines
2069 this function; this is the class the caller will convert to when
2070 calling FN through BINFO. */
2071 for (b = binfo; ; b = get_primary_binfo (b))
2074 if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2077 /* The nearest definition is from a lost primary. */
2078 if (BINFO_LOST_PRIMARY_P (b))
2083 /* Find the final overrider. */
2084 overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2085 if (overrider == error_mark_node)
2087 error ("no unique final overrider for %qD in %qT", target_fn, t);
2090 overrider_target = overrider_fn = TREE_PURPOSE (overrider);
2092 /* Check for adjusting covariant return types. */
2093 over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2094 base_return = TREE_TYPE (TREE_TYPE (target_fn));
2096 if (POINTER_TYPE_P (over_return)
2097 && TREE_CODE (over_return) == TREE_CODE (base_return)
2098 && CLASS_TYPE_P (TREE_TYPE (over_return))
2099 && CLASS_TYPE_P (TREE_TYPE (base_return))
2100 /* If the overrider is invalid, don't even try. */
2101 && !DECL_INVALID_OVERRIDER_P (overrider_target))
2103 /* If FN is a covariant thunk, we must figure out the adjustment
2104 to the final base FN was converting to. As OVERRIDER_TARGET might
2105 also be converting to the return type of FN, we have to
2106 combine the two conversions here. */
2107 tree fixed_offset, virtual_offset;
2109 over_return = TREE_TYPE (over_return);
2110 base_return = TREE_TYPE (base_return);
2112 if (DECL_THUNK_P (fn))
2114 gcc_assert (DECL_RESULT_THUNK_P (fn));
2115 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2116 virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2119 fixed_offset = virtual_offset = NULL_TREE;
2122 /* Find the equivalent binfo within the return type of the
2123 overriding function. We will want the vbase offset from
2125 virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset),
2127 else if (!same_type_ignoring_top_level_qualifiers_p
2128 (over_return, base_return))
2130 /* There was no existing virtual thunk (which takes
2131 precedence). So find the binfo of the base function's
2132 return type within the overriding function's return type.
2133 We cannot call lookup base here, because we're inside a
2134 dfs_walk, and will therefore clobber the BINFO_MARKED
2135 flags. Fortunately we know the covariancy is valid (it
2136 has already been checked), so we can just iterate along
2137 the binfos, which have been chained in inheritance graph
2138 order. Of course it is lame that we have to repeat the
2139 search here anyway -- we should really be caching pieces
2140 of the vtable and avoiding this repeated work. */
2141 tree thunk_binfo, base_binfo;
2143 /* Find the base binfo within the overriding function's
2144 return type. We will always find a thunk_binfo, except
2145 when the covariancy is invalid (which we will have
2146 already diagnosed). */
2147 for (base_binfo = TYPE_BINFO (base_return),
2148 thunk_binfo = TYPE_BINFO (over_return);
2150 thunk_binfo = TREE_CHAIN (thunk_binfo))
2151 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo),
2152 BINFO_TYPE (base_binfo)))
2155 /* See if virtual inheritance is involved. */
2156 for (virtual_offset = thunk_binfo;
2158 virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
2159 if (BINFO_VIRTUAL_P (virtual_offset))
2163 || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
2165 tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2169 /* We convert via virtual base. Adjust the fixed
2170 offset to be from there. */
2172 size_diffop (offset,
2174 BINFO_OFFSET (virtual_offset)));
2177 /* There was an existing fixed offset, this must be
2178 from the base just converted to, and the base the
2179 FN was thunking to. */
2180 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2182 fixed_offset = offset;
2186 if (fixed_offset || virtual_offset)
2187 /* Replace the overriding function with a covariant thunk. We
2188 will emit the overriding function in its own slot as
2190 overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0,
2191 fixed_offset, virtual_offset);
2194 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target) ||
2195 !DECL_THUNK_P (fn));
2197 /* Assume that we will produce a thunk that convert all the way to
2198 the final overrider, and not to an intermediate virtual base. */
2199 virtual_base = NULL_TREE;
2201 /* See if we can convert to an intermediate virtual base first, and then
2202 use the vcall offset located there to finish the conversion. */
2203 for (; b; b = BINFO_INHERITANCE_CHAIN (b))
2205 /* If we find the final overrider, then we can stop
2207 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b),
2208 BINFO_TYPE (TREE_VALUE (overrider))))
2211 /* If we find a virtual base, and we haven't yet found the
2212 overrider, then there is a virtual base between the
2213 declaring base (first_defn) and the final overrider. */
2214 if (BINFO_VIRTUAL_P (b))
2221 if (overrider_fn != overrider_target && !virtual_base)
2223 /* The ABI specifies that a covariant thunk includes a mangling
2224 for a this pointer adjustment. This-adjusting thunks that
2225 override a function from a virtual base have a vcall
2226 adjustment. When the virtual base in question is a primary
2227 virtual base, we know the adjustments are zero, (and in the
2228 non-covariant case, we would not use the thunk).
2229 Unfortunately we didn't notice this could happen, when
2230 designing the ABI and so never mandated that such a covariant
2231 thunk should be emitted. Because we must use the ABI mandated
2232 name, we must continue searching from the binfo where we
2233 found the most recent definition of the function, towards the
2234 primary binfo which first introduced the function into the
2235 vtable. If that enters a virtual base, we must use a vcall
2236 this-adjusting thunk. Bleah! */
2237 tree probe = first_defn;
2239 while ((probe = get_primary_binfo (probe))
2240 && (unsigned) list_length (BINFO_VIRTUALS (probe)) > ix)
2241 if (BINFO_VIRTUAL_P (probe))
2242 virtual_base = probe;
2245 /* Even if we find a virtual base, the correct delta is
2246 between the overrider and the binfo we're building a vtable
2248 goto virtual_covariant;
2251 /* Compute the constant adjustment to the `this' pointer. The
2252 `this' pointer, when this function is called, will point at BINFO
2253 (or one of its primary bases, which are at the same offset). */
2255 /* The `this' pointer needs to be adjusted from the declaration to
2256 the nearest virtual base. */
2257 delta = size_diffop_loc (input_location,
2258 convert (ssizetype, BINFO_OFFSET (virtual_base)),
2259 convert (ssizetype, BINFO_OFFSET (first_defn)));
2261 /* If the nearest definition is in a lost primary, we don't need an
2262 entry in our vtable. Except possibly in a constructor vtable,
2263 if we happen to get our primary back. In that case, the offset
2264 will be zero, as it will be a primary base. */
2265 delta = size_zero_node;
2267 /* The `this' pointer needs to be adjusted from pointing to
2268 BINFO to pointing at the base where the final overrider
2271 delta = size_diffop_loc (input_location,
2273 BINFO_OFFSET (TREE_VALUE (overrider))),
2274 convert (ssizetype, BINFO_OFFSET (binfo)));
2276 modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
2279 BV_VCALL_INDEX (*virtuals)
2280 = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base));
2282 BV_VCALL_INDEX (*virtuals) = NULL_TREE;
2285 /* Called from modify_all_vtables via dfs_walk. */
2288 dfs_modify_vtables (tree binfo, void* data)
2290 tree t = (tree) data;
2295 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
2296 /* A base without a vtable needs no modification, and its bases
2297 are uninteresting. */
2298 return dfs_skip_bases;
2300 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t)
2301 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
2302 /* Don't do the primary vtable, if it's new. */
2305 if (BINFO_PRIMARY_P (binfo) && !BINFO_VIRTUAL_P (binfo))
2306 /* There's no need to modify the vtable for a non-virtual primary
2307 base; we're not going to use that vtable anyhow. We do still
2308 need to do this for virtual primary bases, as they could become
2309 non-primary in a construction vtable. */
2312 make_new_vtable (t, binfo);
2314 /* Now, go through each of the virtual functions in the virtual
2315 function table for BINFO. Find the final overrider, and update
2316 the BINFO_VIRTUALS list appropriately. */
2317 for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2318 old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2320 ix++, virtuals = TREE_CHAIN (virtuals),
2321 old_virtuals = TREE_CHAIN (old_virtuals))
2322 update_vtable_entry_for_fn (t,
2324 BV_FN (old_virtuals),
2330 /* Update all of the primary and secondary vtables for T. Create new
2331 vtables as required, and initialize their RTTI information. Each
2332 of the functions in VIRTUALS is declared in T and may override a
2333 virtual function from a base class; find and modify the appropriate
2334 entries to point to the overriding functions. Returns a list, in
2335 declaration order, of the virtual functions that are declared in T,
2336 but do not appear in the primary base class vtable, and which
2337 should therefore be appended to the end of the vtable for T. */
2340 modify_all_vtables (tree t, tree virtuals)
2342 tree binfo = TYPE_BINFO (t);
2345 /* Update all of the vtables. */
2346 dfs_walk_once (binfo, dfs_modify_vtables, NULL, t);
2348 /* Add virtual functions not already in our primary vtable. These
2349 will be both those introduced by this class, and those overridden
2350 from secondary bases. It does not include virtuals merely
2351 inherited from secondary bases. */
2352 for (fnsp = &virtuals; *fnsp; )
2354 tree fn = TREE_VALUE (*fnsp);
2356 if (!value_member (fn, BINFO_VIRTUALS (binfo))
2357 || DECL_VINDEX (fn) == error_mark_node)
2359 /* We don't need to adjust the `this' pointer when
2360 calling this function. */
2361 BV_DELTA (*fnsp) = integer_zero_node;
2362 BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2364 /* This is a function not already in our vtable. Keep it. */
2365 fnsp = &TREE_CHAIN (*fnsp);
2368 /* We've already got an entry for this function. Skip it. */
2369 *fnsp = TREE_CHAIN (*fnsp);
2375 /* Get the base virtual function declarations in T that have the
2379 get_basefndecls (tree name, tree t)
2382 tree base_fndecls = NULL_TREE;
2383 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
2386 /* Find virtual functions in T with the indicated NAME. */
2387 i = lookup_fnfields_1 (t, name);
2389 for (methods = VEC_index (tree, CLASSTYPE_METHOD_VEC (t), i);
2391 methods = OVL_NEXT (methods))
2393 tree method = OVL_CURRENT (methods);
2395 if (TREE_CODE (method) == FUNCTION_DECL
2396 && DECL_VINDEX (method))
2397 base_fndecls = tree_cons (NULL_TREE, method, base_fndecls);
2401 return base_fndecls;
2403 for (i = 0; i < n_baseclasses; i++)
2405 tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t), i));
2406 base_fndecls = chainon (get_basefndecls (name, basetype),
2410 return base_fndecls;
2413 /* If this declaration supersedes the declaration of
2414 a method declared virtual in the base class, then
2415 mark this field as being virtual as well. */
2418 check_for_override (tree decl, tree ctype)
2420 if (TREE_CODE (decl) == TEMPLATE_DECL)
2421 /* In [temp.mem] we have:
2423 A specialization of a member function template does not
2424 override a virtual function from a base class. */
2426 if ((DECL_DESTRUCTOR_P (decl)
2427 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl))
2428 || DECL_CONV_FN_P (decl))
2429 && look_for_overrides (ctype, decl)
2430 && !DECL_STATIC_FUNCTION_P (decl))
2431 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2432 the error_mark_node so that we know it is an overriding
2434 DECL_VINDEX (decl) = decl;
2436 if (DECL_VIRTUAL_P (decl))
2438 if (!DECL_VINDEX (decl))
2439 DECL_VINDEX (decl) = error_mark_node;
2440 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2444 /* Warn about hidden virtual functions that are not overridden in t.
2445 We know that constructors and destructors don't apply. */
2448 warn_hidden (tree t)
2450 VEC(tree,gc) *method_vec = CLASSTYPE_METHOD_VEC (t);
2454 /* We go through each separately named virtual function. */
2455 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2456 VEC_iterate (tree, method_vec, i, fns);
2467 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2468 have the same name. Figure out what name that is. */
2469 name = DECL_NAME (OVL_CURRENT (fns));
2470 /* There are no possibly hidden functions yet. */
2471 base_fndecls = NULL_TREE;
2472 /* Iterate through all of the base classes looking for possibly
2473 hidden functions. */
2474 for (binfo = TYPE_BINFO (t), j = 0;
2475 BINFO_BASE_ITERATE (binfo, j, base_binfo); j++)
2477 tree basetype = BINFO_TYPE (base_binfo);
2478 base_fndecls = chainon (get_basefndecls (name, basetype),
2482 /* If there are no functions to hide, continue. */
2486 /* Remove any overridden functions. */
2487 for (fn = fns; fn; fn = OVL_NEXT (fn))
2489 fndecl = OVL_CURRENT (fn);
2490 if (DECL_VINDEX (fndecl))
2492 tree *prev = &base_fndecls;
2495 /* If the method from the base class has the same
2496 signature as the method from the derived class, it
2497 has been overridden. */
2498 if (same_signature_p (fndecl, TREE_VALUE (*prev)))
2499 *prev = TREE_CHAIN (*prev);
2501 prev = &TREE_CHAIN (*prev);
2505 /* Now give a warning for all base functions without overriders,
2506 as they are hidden. */
2507 while (base_fndecls)
2509 /* Here we know it is a hider, and no overrider exists. */
2510 warning (OPT_Woverloaded_virtual, "%q+D was hidden", TREE_VALUE (base_fndecls));
2511 warning (OPT_Woverloaded_virtual, " by %q+D", fns);
2512 base_fndecls = TREE_CHAIN (base_fndecls);
2517 /* Check for things that are invalid. There are probably plenty of other
2518 things we should check for also. */
2521 finish_struct_anon (tree t)
2525 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2527 if (TREE_STATIC (field))
2529 if (TREE_CODE (field) != FIELD_DECL)
2532 if (DECL_NAME (field) == NULL_TREE
2533 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2535 bool is_union = TREE_CODE (TREE_TYPE (field)) == UNION_TYPE;
2536 tree elt = TYPE_FIELDS (TREE_TYPE (field));
2537 for (; elt; elt = TREE_CHAIN (elt))
2539 /* We're generally only interested in entities the user
2540 declared, but we also find nested classes by noticing
2541 the TYPE_DECL that we create implicitly. You're
2542 allowed to put one anonymous union inside another,
2543 though, so we explicitly tolerate that. We use
2544 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2545 we also allow unnamed types used for defining fields. */
2546 if (DECL_ARTIFICIAL (elt)
2547 && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2548 || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2551 if (TREE_CODE (elt) != FIELD_DECL)
2554 permerror (input_location, "%q+#D invalid; an anonymous union can "
2555 "only have non-static data members", elt);
2557 permerror (input_location, "%q+#D invalid; an anonymous struct can "
2558 "only have non-static data members", elt);
2562 if (TREE_PRIVATE (elt))
2565 permerror (input_location, "private member %q+#D in anonymous union", elt);
2567 permerror (input_location, "private member %q+#D in anonymous struct", elt);
2569 else if (TREE_PROTECTED (elt))
2572 permerror (input_location, "protected member %q+#D in anonymous union", elt);
2574 permerror (input_location, "protected member %q+#D in anonymous struct", elt);
2577 TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2578 TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2584 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2585 will be used later during class template instantiation.
2586 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2587 a non-static member data (FIELD_DECL), a member function
2588 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2589 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2590 When FRIEND_P is nonzero, T is either a friend class
2591 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2592 (FUNCTION_DECL, TEMPLATE_DECL). */
2595 maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
2597 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2598 if (CLASSTYPE_TEMPLATE_INFO (type))
2599 CLASSTYPE_DECL_LIST (type)
2600 = tree_cons (friend_p ? NULL_TREE : type,
2601 t, CLASSTYPE_DECL_LIST (type));
2604 /* Create default constructors, assignment operators, and so forth for
2605 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
2606 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
2607 the class cannot have a default constructor, copy constructor
2608 taking a const reference argument, or an assignment operator taking
2609 a const reference, respectively. */
2612 add_implicitly_declared_members (tree t,
2613 int cant_have_const_cctor,
2614 int cant_have_const_assignment)
2617 if (!CLASSTYPE_DESTRUCTORS (t))
2619 /* In general, we create destructors lazily. */
2620 CLASSTYPE_LAZY_DESTRUCTOR (t) = 1;
2621 /* However, if the implicit destructor is non-trivial
2622 destructor, we sometimes have to create it at this point. */
2623 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
2627 if (TYPE_FOR_JAVA (t))
2628 /* If this a Java class, any non-trivial destructor is
2629 invalid, even if compiler-generated. Therefore, if the
2630 destructor is non-trivial we create it now. */
2638 /* If the implicit destructor will be virtual, then we must
2639 generate it now because (unfortunately) we do not
2640 generate virtual tables lazily. */
2641 binfo = TYPE_BINFO (t);
2642 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
2647 base_type = BINFO_TYPE (base_binfo);
2648 dtor = CLASSTYPE_DESTRUCTORS (base_type);
2649 if (dtor && DECL_VIRTUAL_P (dtor))
2657 /* If we can't get away with being lazy, generate the destructor
2660 lazily_declare_fn (sfk_destructor, t);
2666 If there is no user-declared constructor for a class, a default
2667 constructor is implicitly declared. */
2668 if (! TYPE_HAS_USER_CONSTRUCTOR (t))
2670 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1;
2671 CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 1;
2676 If a class definition does not explicitly declare a copy
2677 constructor, one is declared implicitly. */
2678 if (! TYPE_HAS_INIT_REF (t) && ! TYPE_FOR_JAVA (t))
2680 TYPE_HAS_INIT_REF (t) = 1;
2681 TYPE_HAS_CONST_INIT_REF (t) = !cant_have_const_cctor;
2682 CLASSTYPE_LAZY_COPY_CTOR (t) = 1;
2685 /* Currently only lambdas get a lazy move ctor, but N2987 adds them for
2687 if (LAMBDA_TYPE_P (t))
2688 CLASSTYPE_LAZY_MOVE_CTOR (t) = 1;
2690 /* If there is no assignment operator, one will be created if and
2691 when it is needed. For now, just record whether or not the type
2692 of the parameter to the assignment operator will be a const or
2693 non-const reference. */
2694 if (!TYPE_HAS_ASSIGN_REF (t) && !TYPE_FOR_JAVA (t))
2696 TYPE_HAS_ASSIGN_REF (t) = 1;
2697 TYPE_HAS_CONST_ASSIGN_REF (t) = !cant_have_const_assignment;
2698 CLASSTYPE_LAZY_ASSIGNMENT_OP (t) = 1;
2702 /* Subroutine of finish_struct_1. Recursively count the number of fields
2703 in TYPE, including anonymous union members. */
2706 count_fields (tree fields)
2710 for (x = fields; x; x = TREE_CHAIN (x))
2712 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2713 n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2720 /* Subroutine of finish_struct_1. Recursively add all the fields in the
2721 TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */
2724 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2727 for (x = fields; x; x = TREE_CHAIN (x))
2729 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2730 idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2732 field_vec->elts[idx++] = x;
2737 /* FIELD is a bit-field. We are finishing the processing for its
2738 enclosing type. Issue any appropriate messages and set appropriate
2739 flags. Returns false if an error has been diagnosed. */
2742 check_bitfield_decl (tree field)
2744 tree type = TREE_TYPE (field);
2747 /* Extract the declared width of the bitfield, which has been
2748 temporarily stashed in DECL_INITIAL. */
2749 w = DECL_INITIAL (field);
2750 gcc_assert (w != NULL_TREE);
2751 /* Remove the bit-field width indicator so that the rest of the
2752 compiler does not treat that value as an initializer. */
2753 DECL_INITIAL (field) = NULL_TREE;
2755 /* Detect invalid bit-field type. */
2756 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
2758 error ("bit-field %q+#D with non-integral type", field);
2759 w = error_mark_node;
2763 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2766 /* detect invalid field size. */
2767 w = integral_constant_value (w);
2769 if (TREE_CODE (w) != INTEGER_CST)
2771 error ("bit-field %q+D width not an integer constant", field);
2772 w = error_mark_node;
2774 else if (tree_int_cst_sgn (w) < 0)
2776 error ("negative width in bit-field %q+D", field);
2777 w = error_mark_node;
2779 else if (integer_zerop (w) && DECL_NAME (field) != 0)
2781 error ("zero width for bit-field %q+D", field);
2782 w = error_mark_node;
2784 else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2785 && TREE_CODE (type) != ENUMERAL_TYPE
2786 && TREE_CODE (type) != BOOLEAN_TYPE)
2787 warning (0, "width of %q+D exceeds its type", field);
2788 else if (TREE_CODE (type) == ENUMERAL_TYPE
2789 && (0 > (compare_tree_int
2790 (w, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type))))))
2791 warning (0, "%q+D is too small to hold all values of %q#T", field, type);
2794 if (w != error_mark_node)
2796 DECL_SIZE (field) = convert (bitsizetype, w);
2797 DECL_BIT_FIELD (field) = 1;
2802 /* Non-bit-fields are aligned for their type. */
2803 DECL_BIT_FIELD (field) = 0;
2804 CLEAR_DECL_C_BIT_FIELD (field);
2809 /* FIELD is a non bit-field. We are finishing the processing for its
2810 enclosing type T. Issue any appropriate messages and set appropriate
2814 check_field_decl (tree field,
2816 int* cant_have_const_ctor,
2817 int* no_const_asn_ref,
2818 int* any_default_members)
2820 tree type = strip_array_types (TREE_TYPE (field));
2822 /* An anonymous union cannot contain any fields which would change
2823 the settings of CANT_HAVE_CONST_CTOR and friends. */
2824 if (ANON_UNION_TYPE_P (type))
2826 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2827 structs. So, we recurse through their fields here. */
2828 else if (ANON_AGGR_TYPE_P (type))
2832 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2833 if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2834 check_field_decl (fields, t, cant_have_const_ctor,
2835 no_const_asn_ref, any_default_members);
2837 /* Check members with class type for constructors, destructors,
2839 else if (CLASS_TYPE_P (type))
2841 /* Never let anything with uninheritable virtuals
2842 make it through without complaint. */
2843 abstract_virtuals_error (field, type);
2845 if (TREE_CODE (t) == UNION_TYPE)
2847 if (TYPE_NEEDS_CONSTRUCTING (type))
2848 error ("member %q+#D with constructor not allowed in union",
2850 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2851 error ("member %q+#D with destructor not allowed in union", field);
2852 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2853 error ("member %q+#D with copy assignment operator not allowed in union",
2858 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2859 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2860 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2861 TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
2862 TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
2863 TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_HAS_COMPLEX_DFLT (type);
2866 if (!TYPE_HAS_CONST_INIT_REF (type))
2867 *cant_have_const_ctor = 1;
2869 if (!TYPE_HAS_CONST_ASSIGN_REF (type))
2870 *no_const_asn_ref = 1;
2872 if (DECL_INITIAL (field) != NULL_TREE)
2874 /* `build_class_init_list' does not recognize
2876 if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2877 error ("multiple fields in union %qT initialized", t);
2878 *any_default_members = 1;
2882 /* Check the data members (both static and non-static), class-scoped
2883 typedefs, etc., appearing in the declaration of T. Issue
2884 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
2885 declaration order) of access declarations; each TREE_VALUE in this
2886 list is a USING_DECL.
2888 In addition, set the following flags:
2891 The class is empty, i.e., contains no non-static data members.
2893 CANT_HAVE_CONST_CTOR_P
2894 This class cannot have an implicitly generated copy constructor
2895 taking a const reference.
2897 CANT_HAVE_CONST_ASN_REF
2898 This class cannot have an implicitly generated assignment
2899 operator taking a const reference.
2901 All of these flags should be initialized before calling this
2904 Returns a pointer to the end of the TYPE_FIELDs chain; additional
2905 fields can be added by adding to this chain. */
2908 check_field_decls (tree t, tree *access_decls,
2909 int *cant_have_const_ctor_p,
2910 int *no_const_asn_ref_p)
2915 int any_default_members;
2917 int field_access = -1;
2919 /* Assume there are no access declarations. */
2920 *access_decls = NULL_TREE;
2921 /* Assume this class has no pointer members. */
2922 has_pointers = false;
2923 /* Assume none of the members of this class have default
2925 any_default_members = 0;
2927 for (field = &TYPE_FIELDS (t); *field; field = next)
2930 tree type = TREE_TYPE (x);
2931 int this_field_access;
2933 next = &TREE_CHAIN (x);
2935 if (TREE_CODE (x) == USING_DECL)
2937 /* Prune the access declaration from the list of fields. */
2938 *field = TREE_CHAIN (x);
2940 /* Save the access declarations for our caller. */
2941 *access_decls = tree_cons (NULL_TREE, x, *access_decls);
2943 /* Since we've reset *FIELD there's no reason to skip to the
2949 if (TREE_CODE (x) == TYPE_DECL
2950 || TREE_CODE (x) == TEMPLATE_DECL)
2953 /* If we've gotten this far, it's a data member, possibly static,
2954 or an enumerator. */
2955 DECL_CONTEXT (x) = t;
2957 /* When this goes into scope, it will be a non-local reference. */
2958 DECL_NONLOCAL (x) = 1;
2960 if (TREE_CODE (t) == UNION_TYPE)
2964 If a union contains a static data member, or a member of
2965 reference type, the program is ill-formed. */
2966 if (TREE_CODE (x) == VAR_DECL)
2968 error ("%q+D may not be static because it is a member of a union", x);
2971 if (TREE_CODE (type) == REFERENCE_TYPE)
2973 error ("%q+D may not have reference type %qT because"
2974 " it is a member of a union",
2980 /* Perform error checking that did not get done in
2982 if (TREE_CODE (type) == FUNCTION_TYPE)
2984 error ("field %q+D invalidly declared function type", x);
2985 type = build_pointer_type (type);
2986 TREE_TYPE (x) = type;
2988 else if (TREE_CODE (type) == METHOD_TYPE)
2990 error ("field %q+D invalidly declared method type", x);
2991 type = build_pointer_type (type);
2992 TREE_TYPE (x) = type;
2995 if (type == error_mark_node)
2998 if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
3001 /* Now it can only be a FIELD_DECL. */
3003 if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3004 CLASSTYPE_NON_AGGREGATE (t) = 1;
3006 /* A standard-layout class is a class that:
3008 has the same access control (Clause 11) for all non-static data members,
3010 this_field_access = TREE_PROTECTED (x) ? 1 : TREE_PRIVATE (x) ? 2 : 0;
3011 if (field_access == -1)
3012 field_access = this_field_access;
3013 else if (this_field_access != field_access)
3014 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3016 /* If this is of reference type, check if it needs an init. */
3017 if (TREE_CODE (type) == REFERENCE_TYPE)
3019 CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3020 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3021 if (DECL_INITIAL (x) == NULL_TREE)
3022 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3024 /* ARM $12.6.2: [A member initializer list] (or, for an
3025 aggregate, initialization by a brace-enclosed list) is the
3026 only way to initialize nonstatic const and reference
3028 TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3031 type = strip_array_types (type);
3033 if (TYPE_PACKED (t))
3035 if (!layout_pod_type_p (type) && !TYPE_PACKED (type))
3039 "ignoring packed attribute because of unpacked non-POD field %q+#D",
3043 else if (DECL_C_BIT_FIELD (x)
3044 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
3045 DECL_PACKED (x) = 1;
3048 if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
3049 /* We don't treat zero-width bitfields as making a class
3054 /* The class is non-empty. */
3055 CLASSTYPE_EMPTY_P (t) = 0;
3056 /* The class is not even nearly empty. */
3057 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3058 /* If one of the data members contains an empty class,
3060 if (CLASS_TYPE_P (type)
3061 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3062 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
3065 /* This is used by -Weffc++ (see below). Warn only for pointers
3066 to members which might hold dynamic memory. So do not warn
3067 for pointers to functions or pointers to members. */
3068 if (TYPE_PTR_P (type)
3069 && !TYPE_PTRFN_P (type)
3070 && !TYPE_PTR_TO_MEMBER_P (type))
3071 has_pointers = true;
3073 if (CLASS_TYPE_P (type))
3075 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3076 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3077 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3078 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3081 if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3082 CLASSTYPE_HAS_MUTABLE (t) = 1;
3084 if (! layout_pod_type_p (type))
3085 /* DR 148 now allows pointers to members (which are POD themselves),
3086 to be allowed in POD structs. */
3087 CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3089 if (!std_layout_type_p (type))
3090 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3092 if (! zero_init_p (type))
3093 CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3095 /* We set DECL_C_BIT_FIELD in grokbitfield.
3096 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3097 if (! DECL_C_BIT_FIELD (x) || ! check_bitfield_decl (x))
3098 check_field_decl (x, t,
3099 cant_have_const_ctor_p,
3101 &any_default_members);
3103 /* If any field is const, the structure type is pseudo-const. */
3104 if (CP_TYPE_CONST_P (type))
3106 C_TYPE_FIELDS_READONLY (t) = 1;
3107 if (DECL_INITIAL (x) == NULL_TREE)
3108 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3110 /* ARM $12.6.2: [A member initializer list] (or, for an
3111 aggregate, initialization by a brace-enclosed list) is the
3112 only way to initialize nonstatic const and reference
3114 TYPE_HAS_COMPLEX_ASSIGN_REF (t) = 1;
3116 /* A field that is pseudo-const makes the structure likewise. */
3117 else if (CLASS_TYPE_P (type))
3119 C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3120 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3121 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3122 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3125 /* Core issue 80: A nonstatic data member is required to have a
3126 different name from the class iff the class has a
3127 user-declared constructor. */
3128 if (constructor_name_p (DECL_NAME (x), t)
3129 && TYPE_HAS_USER_CONSTRUCTOR (t))
3130 permerror (input_location, "field %q+#D with same name as class", x);
3133 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3134 it should also define a copy constructor and an assignment operator to
3135 implement the correct copy semantic (deep vs shallow, etc.). As it is
3136 not feasible to check whether the constructors do allocate dynamic memory
3137 and store it within members, we approximate the warning like this:
3139 -- Warn only if there are members which are pointers
3140 -- Warn only if there is a non-trivial constructor (otherwise,
3141 there cannot be memory allocated).
3142 -- Warn only if there is a non-trivial destructor. We assume that the
3143 user at least implemented the cleanup correctly, and a destructor
3144 is needed to free dynamic memory.
3146 This seems enough for practical purposes. */
3149 && TYPE_HAS_USER_CONSTRUCTOR (t)
3150 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
3151 && !(TYPE_HAS_INIT_REF (t) && TYPE_HAS_ASSIGN_REF (t)))
3153 warning (OPT_Weffc__, "%q#T has pointer data members", t);
3155 if (! TYPE_HAS_INIT_REF (t))
3157 warning (OPT_Weffc__,
3158 " but does not override %<%T(const %T&)%>", t, t);
3159 if (!TYPE_HAS_ASSIGN_REF (t))
3160 warning (OPT_Weffc__, " or %<operator=(const %T&)%>", t);
3162 else if (! TYPE_HAS_ASSIGN_REF (t))
3163 warning (OPT_Weffc__,
3164 " but does not override %<operator=(const %T&)%>", t);
3167 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3169 TYPE_PACKED (t) = 0;
3171 /* Check anonymous struct/anonymous union fields. */
3172 finish_struct_anon (t);
3174 /* We've built up the list of access declarations in reverse order.
3176 *access_decls = nreverse (*access_decls);
3179 /* If TYPE is an empty class type, records its OFFSET in the table of
3183 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3187 if (!is_empty_class (type))
3190 /* Record the location of this empty object in OFFSETS. */
3191 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3193 n = splay_tree_insert (offsets,
3194 (splay_tree_key) offset,
3195 (splay_tree_value) NULL_TREE);
3196 n->value = ((splay_tree_value)
3197 tree_cons (NULL_TREE,
3204 /* Returns nonzero if TYPE is an empty class type and there is
3205 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3208 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3213 if (!is_empty_class (type))
3216 /* Record the location of this empty object in OFFSETS. */
3217 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3221 for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3222 if (same_type_p (TREE_VALUE (t), type))
3228 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3229 F for every subobject, passing it the type, offset, and table of
3230 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3233 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3234 than MAX_OFFSET will not be walked.
3236 If F returns a nonzero value, the traversal ceases, and that value
3237 is returned. Otherwise, returns zero. */
3240 walk_subobject_offsets (tree type,
3241 subobject_offset_fn f,
3248 tree type_binfo = NULL_TREE;
3250 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3252 if (max_offset && INT_CST_LT (max_offset, offset))
3255 if (type == error_mark_node)
3260 if (abi_version_at_least (2))
3262 type = BINFO_TYPE (type);
3265 if (CLASS_TYPE_P (type))
3271 /* Avoid recursing into objects that are not interesting. */
3272 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3275 /* Record the location of TYPE. */
3276 r = (*f) (type, offset, offsets);
3280 /* Iterate through the direct base classes of TYPE. */
3282 type_binfo = TYPE_BINFO (type);
3283 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++)
3287 if (abi_version_at_least (2)
3288 && BINFO_VIRTUAL_P (binfo))
3292 && BINFO_VIRTUAL_P (binfo)
3293 && !BINFO_PRIMARY_P (binfo))
3296 if (!abi_version_at_least (2))
3297 binfo_offset = size_binop (PLUS_EXPR,
3299 BINFO_OFFSET (binfo));
3303 /* We cannot rely on BINFO_OFFSET being set for the base
3304 class yet, but the offsets for direct non-virtual
3305 bases can be calculated by going back to the TYPE. */
3306 orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
3307 binfo_offset = size_binop (PLUS_EXPR,
3309 BINFO_OFFSET (orig_binfo));
3312 r = walk_subobject_offsets (binfo,
3317 (abi_version_at_least (2)
3318 ? /*vbases_p=*/0 : vbases_p));
3323 if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type))
3326 VEC(tree,gc) *vbases;
3328 /* Iterate through the virtual base classes of TYPE. In G++
3329 3.2, we included virtual bases in the direct base class
3330 loop above, which results in incorrect results; the
3331 correct offsets for virtual bases are only known when
3332 working with the most derived type. */
3334 for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0;
3335 VEC_iterate (tree, vbases, ix, binfo); ix++)
3337 r = walk_subobject_offsets (binfo,
3339 size_binop (PLUS_EXPR,
3341 BINFO_OFFSET (binfo)),
3350 /* We still have to walk the primary base, if it is
3351 virtual. (If it is non-virtual, then it was walked
3353 tree vbase = get_primary_binfo (type_binfo);
3355 if (vbase && BINFO_VIRTUAL_P (vbase)
3356 && BINFO_PRIMARY_P (vbase)
3357 && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo)
3359 r = (walk_subobject_offsets
3361 offsets, max_offset, /*vbases_p=*/0));
3368 /* Iterate through the fields of TYPE. */
3369 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3370 if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3374 if (abi_version_at_least (2))
3375 field_offset = byte_position (field);
3377 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3378 field_offset = DECL_FIELD_OFFSET (field);
3380 r = walk_subobject_offsets (TREE_TYPE (field),
3382 size_binop (PLUS_EXPR,
3392 else if (TREE_CODE (type) == ARRAY_TYPE)
3394 tree element_type = strip_array_types (type);
3395 tree domain = TYPE_DOMAIN (type);
3398 /* Avoid recursing into objects that are not interesting. */
3399 if (!CLASS_TYPE_P (element_type)
3400 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3403 /* Step through each of the elements in the array. */
3404 for (index = size_zero_node;
3405 /* G++ 3.2 had an off-by-one error here. */
3406 (abi_version_at_least (2)
3407 ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3408 : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3409 index = size_binop (PLUS_EXPR, index, size_one_node))
3411 r = walk_subobject_offsets (TREE_TYPE (type),
3419 offset = size_binop (PLUS_EXPR, offset,
3420 TYPE_SIZE_UNIT (TREE_TYPE (type)));
3421 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3422 there's no point in iterating through the remaining
3423 elements of the array. */
3424 if (max_offset && INT_CST_LT (max_offset, offset))
3432 /* Record all of the empty subobjects of TYPE (either a type or a
3433 binfo). If IS_DATA_MEMBER is true, then a non-static data member
3434 is being placed at OFFSET; otherwise, it is a base class that is
3435 being placed at OFFSET. */
3438 record_subobject_offsets (tree type,
3441 bool is_data_member)
3444 /* If recording subobjects for a non-static data member or a
3445 non-empty base class , we do not need to record offsets beyond
3446 the size of the biggest empty class. Additional data members
3447 will go at the end of the class. Additional base classes will go
3448 either at offset zero (if empty, in which case they cannot
3449 overlap with offsets past the size of the biggest empty class) or
3450 at the end of the class.
3452 However, if we are placing an empty base class, then we must record
3453 all offsets, as either the empty class is at offset zero (where
3454 other empty classes might later be placed) or at the end of the
3455 class (where other objects might then be placed, so other empty
3456 subobjects might later overlap). */
3458 || !is_empty_class (BINFO_TYPE (type)))
3459 max_offset = sizeof_biggest_empty_class;
3461 max_offset = NULL_TREE;
3462 walk_subobject_offsets (type, record_subobject_offset, offset,
3463 offsets, max_offset, is_data_member);
3466 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3467 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3468 virtual bases of TYPE are examined. */
3471 layout_conflict_p (tree type,
3476 splay_tree_node max_node;
3478 /* Get the node in OFFSETS that indicates the maximum offset where
3479 an empty subobject is located. */
3480 max_node = splay_tree_max (offsets);
3481 /* If there aren't any empty subobjects, then there's no point in
3482 performing this check. */
3486 return walk_subobject_offsets (type, check_subobject_offset, offset,
3487 offsets, (tree) (max_node->key),
3491 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3492 non-static data member of the type indicated by RLI. BINFO is the
3493 binfo corresponding to the base subobject, OFFSETS maps offsets to
3494 types already located at those offsets. This function determines
3495 the position of the DECL. */
3498 layout_nonempty_base_or_field (record_layout_info rli,
3503 tree offset = NULL_TREE;
3509 /* For the purposes of determining layout conflicts, we want to
3510 use the class type of BINFO; TREE_TYPE (DECL) will be the
3511 CLASSTYPE_AS_BASE version, which does not contain entries for
3512 zero-sized bases. */
3513 type = TREE_TYPE (binfo);
3518 type = TREE_TYPE (decl);
3522 /* Try to place the field. It may take more than one try if we have
3523 a hard time placing the field without putting two objects of the
3524 same type at the same address. */
3527 struct record_layout_info_s old_rli = *rli;
3529 /* Place this field. */
3530 place_field (rli, decl);
3531 offset = byte_position (decl);
3533 /* We have to check to see whether or not there is already
3534 something of the same type at the offset we're about to use.
3535 For example, consider:
3538 struct T : public S { int i; };
3539 struct U : public S, public T {};
3541 Here, we put S at offset zero in U. Then, we can't put T at
3542 offset zero -- its S component would be at the same address
3543 as the S we already allocated. So, we have to skip ahead.
3544 Since all data members, including those whose type is an
3545 empty class, have nonzero size, any overlap can happen only
3546 with a direct or indirect base-class -- it can't happen with
3548 /* In a union, overlap is permitted; all members are placed at
3550 if (TREE_CODE (rli->t) == UNION_TYPE)
3552 /* G++ 3.2 did not check for overlaps when placing a non-empty
3554 if (!abi_version_at_least (2) && binfo && BINFO_VIRTUAL_P (binfo))
3556 if (layout_conflict_p (field_p ? type : binfo, offset,
3559 /* Strip off the size allocated to this field. That puts us
3560 at the first place we could have put the field with
3561 proper alignment. */
3564 /* Bump up by the alignment required for the type. */
3566 = size_binop (PLUS_EXPR, rli->bitpos,
3568 ? CLASSTYPE_ALIGN (type)
3569 : TYPE_ALIGN (type)));
3570 normalize_rli (rli);
3573 /* There was no conflict. We're done laying out this field. */
3577 /* Now that we know where it will be placed, update its
3579 if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3580 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3581 this point because their BINFO_OFFSET is copied from another
3582 hierarchy. Therefore, we may not need to add the entire
3584 propagate_binfo_offsets (binfo,
3585 size_diffop_loc (input_location,
3586 convert (ssizetype, offset),
3588 BINFO_OFFSET (binfo))));
3591 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3594 empty_base_at_nonzero_offset_p (tree type,
3596 splay_tree offsets ATTRIBUTE_UNUSED)
3598 return is_empty_class (type) && !integer_zerop (offset);
3601 /* Layout the empty base BINFO. EOC indicates the byte currently just
3602 past the end of the class, and should be correctly aligned for a
3603 class of the type indicated by BINFO; OFFSETS gives the offsets of
3604 the empty bases allocated so far. T is the most derived
3605 type. Return nonzero iff we added it at the end. */
3608 layout_empty_base (record_layout_info rli, tree binfo,
3609 tree eoc, splay_tree offsets)
3612 tree basetype = BINFO_TYPE (binfo);
3615 /* This routine should only be used for empty classes. */
3616 gcc_assert (is_empty_class (basetype));
3617 alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3619 if (!integer_zerop (BINFO_OFFSET (binfo)))
3621 if (abi_version_at_least (2))
3622 propagate_binfo_offsets
3623 (binfo, size_diffop_loc (input_location,
3624 size_zero_node, BINFO_OFFSET (binfo)));
3627 "offset of empty base %qT may not be ABI-compliant and may"
3628 "change in a future version of GCC",
3629 BINFO_TYPE (binfo));
3632 /* This is an empty base class. We first try to put it at offset
3634 if (layout_conflict_p (binfo,
3635 BINFO_OFFSET (binfo),
3639 /* That didn't work. Now, we move forward from the next
3640 available spot in the class. */
3642 propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3645 if (!layout_conflict_p (binfo,
3646 BINFO_OFFSET (binfo),
3649 /* We finally found a spot where there's no overlap. */
3652 /* There's overlap here, too. Bump along to the next spot. */
3653 propagate_binfo_offsets (binfo, alignment);
3657 if (CLASSTYPE_USER_ALIGN (basetype))
3659 rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (basetype));
3661 rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (basetype));
3662 TYPE_USER_ALIGN (rli->t) = 1;
3668 /* Layout the base given by BINFO in the class indicated by RLI.
3669 *BASE_ALIGN is a running maximum of the alignments of
3670 any base class. OFFSETS gives the location of empty base
3671 subobjects. T is the most derived type. Return nonzero if the new
3672 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3673 *NEXT_FIELD, unless BINFO is for an empty base class.
3675 Returns the location at which the next field should be inserted. */
3678 build_base_field (record_layout_info rli, tree binfo,
3679 splay_tree offsets, tree *next_field)
3682 tree basetype = BINFO_TYPE (binfo);
3684 if (!COMPLETE_TYPE_P (basetype))
3685 /* This error is now reported in xref_tag, thus giving better
3686 location information. */
3689 /* Place the base class. */
3690 if (!is_empty_class (basetype))
3694 /* The containing class is non-empty because it has a non-empty
3696 CLASSTYPE_EMPTY_P (t) = 0;
3698 /* Create the FIELD_DECL. */
3699 decl = build_decl (input_location,
3700 FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3701 DECL_ARTIFICIAL (decl) = 1;
3702 DECL_IGNORED_P (decl) = 1;
3703 DECL_FIELD_CONTEXT (decl) = t;
3704 if (CLASSTYPE_AS_BASE (basetype))
3706 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3707 DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3708 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3709 DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3710 DECL_MODE (decl) = TYPE_MODE (basetype);
3711 DECL_FIELD_IS_BASE (decl) = 1;
3713 /* Try to place the field. It may take more than one try if we
3714 have a hard time placing the field without putting two
3715 objects of the same type at the same address. */
3716 layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3717 /* Add the new FIELD_DECL to the list of fields for T. */
3718 TREE_CHAIN (decl) = *next_field;
3720 next_field = &TREE_CHAIN (decl);
3728 /* On some platforms (ARM), even empty classes will not be
3730 eoc = round_up_loc (input_location,
3731 rli_size_unit_so_far (rli),
3732 CLASSTYPE_ALIGN_UNIT (basetype));
3733 atend = layout_empty_base (rli, binfo, eoc, offsets);
3734 /* A nearly-empty class "has no proper base class that is empty,
3735 not morally virtual, and at an offset other than zero." */
3736 if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3739 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3740 /* The check above (used in G++ 3.2) is insufficient because
3741 an empty class placed at offset zero might itself have an
3742 empty base at a nonzero offset. */
3743 else if (walk_subobject_offsets (basetype,
3744 empty_base_at_nonzero_offset_p,
3747 /*max_offset=*/NULL_TREE,
3750 if (abi_version_at_least (2))
3751 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3754 "class %qT will be considered nearly empty in a "
3755 "future version of GCC", t);
3759 /* We do not create a FIELD_DECL for empty base classes because
3760 it might overlap some other field. We want to be able to
3761 create CONSTRUCTORs for the class by iterating over the
3762 FIELD_DECLs, and the back end does not handle overlapping
3765 /* An empty virtual base causes a class to be non-empty
3766 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3767 here because that was already done when the virtual table
3768 pointer was created. */
3771 /* Record the offsets of BINFO and its base subobjects. */
3772 record_subobject_offsets (binfo,
3773 BINFO_OFFSET (binfo),
3775 /*is_data_member=*/false);
3780 /* Layout all of the non-virtual base classes. Record empty
3781 subobjects in OFFSETS. T is the most derived type. Return nonzero
3782 if the type cannot be nearly empty. The fields created
3783 corresponding to the base classes will be inserted at
3787 build_base_fields (record_layout_info rli,
3788 splay_tree offsets, tree *next_field)
3790 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3793 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
3796 /* The primary base class is always allocated first. */
3797 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3798 next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3799 offsets, next_field);
3801 /* Now allocate the rest of the bases. */
3802 for (i = 0; i < n_baseclasses; ++i)
3806 base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
3808 /* The primary base was already allocated above, so we don't
3809 need to allocate it again here. */
3810 if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3813 /* Virtual bases are added at the end (a primary virtual base
3814 will have already been added). */
3815 if (BINFO_VIRTUAL_P (base_binfo))
3818 next_field = build_base_field (rli, base_binfo,
3819 offsets, next_field);
3823 /* Go through the TYPE_METHODS of T issuing any appropriate
3824 diagnostics, figuring out which methods override which other
3825 methods, and so forth. */
3828 check_methods (tree t)
3832 for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3834 check_for_override (x, t);
3835 if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3836 error ("initializer specified for non-virtual method %q+D", x);
3837 /* The name of the field is the original field name
3838 Save this in auxiliary field for later overloading. */
3839 if (DECL_VINDEX (x))
3841 TYPE_POLYMORPHIC_P (t) = 1;
3842 if (DECL_PURE_VIRTUAL_P (x))
3843 VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
3845 /* All user-provided destructors are non-trivial. */
3846 if (DECL_DESTRUCTOR_P (x) && user_provided_p (x))
3847 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1;
3851 /* FN is a constructor or destructor. Clone the declaration to create
3852 a specialized in-charge or not-in-charge version, as indicated by
3856 build_clone (tree fn, tree name)
3861 /* Copy the function. */
3862 clone = copy_decl (fn);
3863 /* Reset the function name. */
3864 DECL_NAME (clone) = name;
3865 SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3866 /* Remember where this function came from. */
3867 DECL_ABSTRACT_ORIGIN (clone) = fn;
3868 /* Make it easy to find the CLONE given the FN. */
3869 TREE_CHAIN (clone) = TREE_CHAIN (fn);
3870 TREE_CHAIN (fn) = clone;
3872 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
3873 if (TREE_CODE (clone) == TEMPLATE_DECL)
3875 tree result = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3876 DECL_TEMPLATE_RESULT (clone) = result;
3877 DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3878 DECL_TI_TEMPLATE (result) = clone;
3879 TREE_TYPE (clone) = TREE_TYPE (result);
3883 DECL_CLONED_FUNCTION (clone) = fn;
3884 /* There's no pending inline data for this function. */
3885 DECL_PENDING_INLINE_INFO (clone) = NULL;
3886 DECL_PENDING_INLINE_P (clone) = 0;
3888 /* The base-class destructor is not virtual. */
3889 if (name == base_dtor_identifier)
3891 DECL_VIRTUAL_P (clone) = 0;
3892 if (TREE_CODE (clone) != TEMPLATE_DECL)
3893 DECL_VINDEX (clone) = NULL_TREE;
3896 /* If there was an in-charge parameter, drop it from the function
3898 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3904 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3905 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3906 parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3907 /* Skip the `this' parameter. */
3908 parmtypes = TREE_CHAIN (parmtypes);
3909 /* Skip the in-charge parameter. */
3910 parmtypes = TREE_CHAIN (parmtypes);
3911 /* And the VTT parm, in a complete [cd]tor. */
3912 if (DECL_HAS_VTT_PARM_P (fn)
3913 && ! DECL_NEEDS_VTT_PARM_P (clone))
3914 parmtypes = TREE_CHAIN (parmtypes);
3915 /* If this is subobject constructor or destructor, add the vtt
3918 = build_method_type_directly (basetype,
3919 TREE_TYPE (TREE_TYPE (clone)),
3922 TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
3925 = cp_build_type_attribute_variant (TREE_TYPE (clone),
3926 TYPE_ATTRIBUTES (TREE_TYPE (fn)));
3929 /* Copy the function parameters. */
3930 DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
3931 /* Remove the in-charge parameter. */
3932 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3934 TREE_CHAIN (DECL_ARGUMENTS (clone))
3935 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3936 DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
3938 /* And the VTT parm, in a complete [cd]tor. */
3939 if (DECL_HAS_VTT_PARM_P (fn))
3941 if (DECL_NEEDS_VTT_PARM_P (clone))
3942 DECL_HAS_VTT_PARM_P (clone) = 1;
3945 TREE_CHAIN (DECL_ARGUMENTS (clone))
3946 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone)));
3947 DECL_HAS_VTT_PARM_P (clone) = 0;
3951 for (parms = DECL_ARGUMENTS (clone); parms; parms = TREE_CHAIN (parms))
3953 DECL_CONTEXT (parms) = clone;
3954 cxx_dup_lang_specific_decl (parms);
3957 /* Create the RTL for this function. */
3958 SET_DECL_RTL (clone, NULL);
3959 rest_of_decl_compilation (clone, /*top_level=*/1, at_eof);
3962 note_decl_for_pch (clone);
3967 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
3968 not invoke this function directly.
3970 For a non-thunk function, returns the address of the slot for storing
3971 the function it is a clone of. Otherwise returns NULL_TREE.
3973 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
3974 cloned_function is unset. This is to support the separate
3975 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
3976 on a template makes sense, but not the former. */
3979 decl_cloned_function_p (const_tree decl, bool just_testing)
3983 decl = STRIP_TEMPLATE (decl);
3985 if (TREE_CODE (decl) != FUNCTION_DECL
3986 || !DECL_LANG_SPECIFIC (decl)
3987 || DECL_LANG_SPECIFIC (decl)->u.fn.thunk_p)
3989 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3991 lang_check_failed (__FILE__, __LINE__, __FUNCTION__);
3997 ptr = &DECL_LANG_SPECIFIC (decl)->u.fn.u5.cloned_function;
3998 if (just_testing && *ptr == NULL_TREE)
4004 /* Produce declarations for all appropriate clones of FN. If
4005 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4006 CLASTYPE_METHOD_VEC as well. */
4009 clone_function_decl (tree fn, int update_method_vec_p)
4013 /* Avoid inappropriate cloning. */
4015 && DECL_CLONED_FUNCTION_P (TREE_CHAIN (fn)))
4018 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
4020 /* For each constructor, we need two variants: an in-charge version
4021 and a not-in-charge version. */
4022 clone = build_clone (fn, complete_ctor_identifier);
4023 if (update_method_vec_p)
4024 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4025 clone = build_clone (fn, base_ctor_identifier);
4026 if (update_method_vec_p)
4027 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4031 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
4033 /* For each destructor, we need three variants: an in-charge
4034 version, a not-in-charge version, and an in-charge deleting
4035 version. We clone the deleting version first because that
4036 means it will go second on the TYPE_METHODS list -- and that
4037 corresponds to the correct layout order in the virtual
4040 For a non-virtual destructor, we do not build a deleting
4042 if (DECL_VIRTUAL_P (fn))
4044 clone = build_clone (fn, deleting_dtor_identifier);
4045 if (update_method_vec_p)
4046 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4048 clone = build_clone (fn, complete_dtor_identifier);
4049 if (update_method_vec_p)
4050 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4051 clone = build_clone (fn, base_dtor_identifier);
4052 if (update_method_vec_p)
4053 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4056 /* Note that this is an abstract function that is never emitted. */
4057 DECL_ABSTRACT (fn) = 1;
4060 /* DECL is an in charge constructor, which is being defined. This will
4061 have had an in class declaration, from whence clones were
4062 declared. An out-of-class definition can specify additional default
4063 arguments. As it is the clones that are involved in overload
4064 resolution, we must propagate the information from the DECL to its
4068 adjust_clone_args (tree decl)
4072 for (clone = TREE_CHAIN (decl); clone && DECL_CLONED_FUNCTION_P (clone);
4073 clone = TREE_CHAIN (clone))
4075 tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
4076 tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
4077 tree decl_parms, clone_parms;
4079 clone_parms = orig_clone_parms;
4081 /* Skip the 'this' parameter. */
4082 orig_clone_parms = TREE_CHAIN (orig_clone_parms);
4083 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4085 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
4086 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4087 if (DECL_HAS_VTT_PARM_P (decl))
4088 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4090 clone_parms = orig_clone_parms;
4091 if (DECL_HAS_VTT_PARM_P (clone))
4092 clone_parms = TREE_CHAIN (clone_parms);
4094 for (decl_parms = orig_decl_parms; decl_parms;
4095 decl_parms = TREE_CHAIN (decl_parms),
4096 clone_parms = TREE_CHAIN (clone_parms))
4098 gcc_assert (same_type_p (TREE_TYPE (decl_parms),
4099 TREE_TYPE (clone_parms)));
4101 if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
4103 /* A default parameter has been added. Adjust the
4104 clone's parameters. */
4105 tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4106 tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (clone));
4107 tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4110 clone_parms = orig_decl_parms;
4112 if (DECL_HAS_VTT_PARM_P (clone))
4114 clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
4115 TREE_VALUE (orig_clone_parms),
4117 TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
4119 type = build_method_type_directly (basetype,
4120 TREE_TYPE (TREE_TYPE (clone)),
4123 type = build_exception_variant (type, exceptions);
4125 type = cp_build_type_attribute_variant (type, attrs);
4126 TREE_TYPE (clone) = type;
4128 clone_parms = NULL_TREE;
4132 gcc_assert (!clone_parms);
4136 /* For each of the constructors and destructors in T, create an
4137 in-charge and not-in-charge variant. */
4140 clone_constructors_and_destructors (tree t)
4144 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4146 if (!CLASSTYPE_METHOD_VEC (t))
4149 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4150 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4151 for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4152 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4155 /* Returns true iff class T has a user-defined constructor other than
4156 the default constructor. */
4159 type_has_user_nondefault_constructor (tree t)
4163 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4166 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4168 tree fn = OVL_CURRENT (fns);
4169 if (!DECL_ARTIFICIAL (fn)
4170 && (TREE_CODE (fn) == TEMPLATE_DECL
4171 || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
4179 /* Returns the defaulted constructor if T has one. Otherwise, returns
4183 in_class_defaulted_default_constructor (tree t)
4187 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4190 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4192 tree fn = OVL_CURRENT (fns);
4194 if (DECL_DEFAULTED_IN_CLASS_P (fn))
4196 args = FUNCTION_FIRST_USER_PARMTYPE (fn);
4197 while (args && TREE_PURPOSE (args))
4198 args = TREE_CHAIN (args);
4199 if (!args || args == void_list_node)
4207 /* Returns true iff FN is a user-provided function, i.e. user-declared
4208 and not defaulted at its first declaration; or explicit, private,
4209 protected, or non-const. */
4212 user_provided_p (tree fn)
4214 if (TREE_CODE (fn) == TEMPLATE_DECL)
4217 return (!DECL_ARTIFICIAL (fn)
4218 && !DECL_DEFAULTED_IN_CLASS_P (fn));
4221 /* Returns true iff class T has a user-provided constructor. */
4224 type_has_user_provided_constructor (tree t)
4228 if (!CLASS_TYPE_P (t))
4231 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4234 /* This can happen in error cases; avoid crashing. */
4235 if (!CLASSTYPE_METHOD_VEC (t))
4238 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4239 if (user_provided_p (OVL_CURRENT (fns)))
4245 /* Returns true iff class T has a user-provided default constructor. */
4248 type_has_user_provided_default_constructor (tree t)
4252 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4255 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4257 tree fn = OVL_CURRENT (fns);
4258 if (TREE_CODE (fn) == FUNCTION_DECL
4259 && user_provided_p (fn))
4261 args = FUNCTION_FIRST_USER_PARMTYPE (fn);
4262 while (args && TREE_PURPOSE (args))
4263 args = TREE_CHAIN (args);
4264 if (!args || args == void_list_node)
4272 /* Remove all zero-width bit-fields from T. */
4275 remove_zero_width_bit_fields (tree t)
4279 fieldsp = &TYPE_FIELDS (t);
4282 if (TREE_CODE (*fieldsp) == FIELD_DECL
4283 && DECL_C_BIT_FIELD (*fieldsp)
4284 /* We should not be confused by the fact that grokbitfield
4285 temporarily sets the width of the bit field into
4286 DECL_INITIAL (*fieldsp).
4287 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
4289 && integer_zerop (DECL_SIZE (*fieldsp)))
4290 *fieldsp = TREE_CHAIN (*fieldsp);
4292 fieldsp = &TREE_CHAIN (*fieldsp);
4296 /* Returns TRUE iff we need a cookie when dynamically allocating an
4297 array whose elements have the indicated class TYPE. */
4300 type_requires_array_cookie (tree type)
4303 bool has_two_argument_delete_p = false;
4305 gcc_assert (CLASS_TYPE_P (type));
4307 /* If there's a non-trivial destructor, we need a cookie. In order
4308 to iterate through the array calling the destructor for each
4309 element, we'll have to know how many elements there are. */
4310 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4313 /* If the usual deallocation function is a two-argument whose second
4314 argument is of type `size_t', then we have to pass the size of
4315 the array to the deallocation function, so we will need to store
4317 fns = lookup_fnfields (TYPE_BINFO (type),
4318 ansi_opname (VEC_DELETE_EXPR),
4320 /* If there are no `operator []' members, or the lookup is
4321 ambiguous, then we don't need a cookie. */
4322 if (!fns || fns == error_mark_node)
4324 /* Loop through all of the functions. */
4325 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4330 /* Select the current function. */
4331 fn = OVL_CURRENT (fns);
4332 /* See if this function is a one-argument delete function. If
4333 it is, then it will be the usual deallocation function. */
4334 second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4335 if (second_parm == void_list_node)
4337 /* Do not consider this function if its second argument is an
4341 /* Otherwise, if we have a two-argument function and the second
4342 argument is `size_t', it will be the usual deallocation
4343 function -- unless there is one-argument function, too. */
4344 if (TREE_CHAIN (second_parm) == void_list_node
4345 && same_type_p (TREE_VALUE (second_parm), size_type_node))
4346 has_two_argument_delete_p = true;
4349 return has_two_argument_delete_p;
4352 /* Check the validity of the bases and members declared in T. Add any
4353 implicitly-generated functions (like copy-constructors and
4354 assignment operators). Compute various flag bits (like
4355 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
4356 level: i.e., independently of the ABI in use. */
4359 check_bases_and_members (tree t)
4361 /* Nonzero if the implicitly generated copy constructor should take
4362 a non-const reference argument. */
4363 int cant_have_const_ctor;
4364 /* Nonzero if the implicitly generated assignment operator
4365 should take a non-const reference argument. */
4366 int no_const_asn_ref;
4368 bool saved_complex_asn_ref;
4369 bool saved_nontrivial_dtor;
4372 /* By default, we use const reference arguments and generate default
4374 cant_have_const_ctor = 0;
4375 no_const_asn_ref = 0;
4377 /* Check all the base-classes. */
4378 check_bases (t, &cant_have_const_ctor,
4381 /* Check all the method declarations. */
4384 /* Save the initial values of these flags which only indicate whether
4385 or not the class has user-provided functions. As we analyze the
4386 bases and members we can set these flags for other reasons. */
4387 saved_complex_asn_ref = TYPE_HAS_COMPLEX_ASSIGN_REF (t);
4388 saved_nontrivial_dtor = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
4390 /* Check all the data member declarations. We cannot call
4391 check_field_decls until we have called check_bases check_methods,
4392 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4393 being set appropriately. */
4394 check_field_decls (t, &access_decls,
4395 &cant_have_const_ctor,
4398 /* A nearly-empty class has to be vptr-containing; a nearly empty
4399 class contains just a vptr. */
4400 if (!TYPE_CONTAINS_VPTR_P (t))
4401 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4403 /* Do some bookkeeping that will guide the generation of implicitly
4404 declared member functions. */
4405 TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_CONTAINS_VPTR_P (t);
4406 /* We need to call a constructor for this class if it has a
4407 user-provided constructor, or if the default constructor is going
4408 to initialize the vptr. (This is not an if-and-only-if;
4409 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
4410 themselves need constructing.) */
4411 TYPE_NEEDS_CONSTRUCTING (t)
4412 |= (type_has_user_provided_constructor (t) || TYPE_CONTAINS_VPTR_P (t));
4415 An aggregate is an array or a class with no user-provided
4416 constructors ... and no virtual functions.
4418 Again, other conditions for being an aggregate are checked
4420 CLASSTYPE_NON_AGGREGATE (t)
4421 |= (type_has_user_provided_constructor (t) || TYPE_POLYMORPHIC_P (t));
4422 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
4423 retain the old definition internally for ABI reasons. */
4424 CLASSTYPE_NON_LAYOUT_POD_P (t)
4425 |= (CLASSTYPE_NON_AGGREGATE (t)
4426 || saved_nontrivial_dtor || saved_complex_asn_ref);
4427 CLASSTYPE_NON_STD_LAYOUT (t) |= TYPE_CONTAINS_VPTR_P (t);
4428 TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_CONTAINS_VPTR_P (t);
4429 TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_CONTAINS_VPTR_P (t);
4431 /* If the class has no user-declared constructor, but does have
4432 non-static const or reference data members that can never be
4433 initialized, issue a warning. */
4434 if (warn_uninitialized
4435 /* Classes with user-declared constructors are presumed to
4436 initialize these members. */
4437 && !TYPE_HAS_USER_CONSTRUCTOR (t)
4438 /* Aggregates can be initialized with brace-enclosed
4440 && CLASSTYPE_NON_AGGREGATE (t))
4444 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
4448 if (TREE_CODE (field) != FIELD_DECL)
4451 type = TREE_TYPE (field);
4452 if (TREE_CODE (type) == REFERENCE_TYPE)
4453 warning (OPT_Wuninitialized, "non-static reference %q+#D "
4454 "in class without a constructor", field);
4455 else if (CP_TYPE_CONST_P (type)
4456 && (!CLASS_TYPE_P (type)
4457 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4458 warning (OPT_Wuninitialized, "non-static const member %q+#D "
4459 "in class without a constructor", field);
4463 /* Synthesize any needed methods. */
4464 add_implicitly_declared_members (t,
4465 cant_have_const_ctor,
4468 /* Check defaulted declarations here so we have cant_have_const_ctor
4469 and don't need to worry about clones. */
4470 for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4471 if (DECL_DEFAULTED_IN_CLASS_P (fn))
4473 int copy = copy_fn_p (fn);
4477 = (DECL_CONSTRUCTOR_P (fn) ? !cant_have_const_ctor
4478 : !no_const_asn_ref);
4479 bool fn_const_p = (copy == 2);
4481 if (fn_const_p && !imp_const_p)
4482 /* If the function is defaulted outside the class, we just
4483 give the synthesis error. */
4484 error ("%q+D declared to take const reference, but implicit "
4485 "declaration would take non-const", fn);
4486 else if (imp_const_p && !fn_const_p)
4487 error ("%q+D declared to take non-const reference cannot be "
4488 "defaulted in the class body", fn);
4490 defaulted_late_check (fn);
4493 if (LAMBDA_TYPE_P (t))
4495 /* "The closure type associated with a lambda-expression has a deleted
4496 default constructor and a deleted copy assignment operator." */
4497 TYPE_NEEDS_CONSTRUCTING (t) = 1;
4498 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
4499 CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 0;
4500 TYPE_HAS_ASSIGN_REF (t) = 0;
4501 CLASSTYPE_LAZY_ASSIGNMENT_OP (t) = 0;
4503 /* "This class type is not an aggregate." */
4504 CLASSTYPE_NON_AGGREGATE (t) = 1;
4507 /* Create the in-charge and not-in-charge variants of constructors
4509 clone_constructors_and_destructors (t);
4511 /* Process the using-declarations. */
4512 for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4513 handle_using_decl (TREE_VALUE (access_decls), t);
4515 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4516 finish_struct_methods (t);
4518 /* Figure out whether or not we will need a cookie when dynamically
4519 allocating an array of this type. */
4520 TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4521 = type_requires_array_cookie (t);
4524 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4525 accordingly. If a new vfield was created (because T doesn't have a
4526 primary base class), then the newly created field is returned. It
4527 is not added to the TYPE_FIELDS list; it is the caller's
4528 responsibility to do that. Accumulate declared virtual functions
4532 create_vtable_ptr (tree t, tree* virtuals_p)
4536 /* Collect the virtual functions declared in T. */
4537 for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4538 if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4539 && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4541 tree new_virtual = make_node (TREE_LIST);
4543 BV_FN (new_virtual) = fn;
4544 BV_DELTA (new_virtual) = integer_zero_node;
4545 BV_VCALL_INDEX (new_virtual) = NULL_TREE;
4547 TREE_CHAIN (new_virtual) = *virtuals_p;
4548 *virtuals_p = new_virtual;
4551 /* If we couldn't find an appropriate base class, create a new field
4552 here. Even if there weren't any new virtual functions, we might need a
4553 new virtual function table if we're supposed to include vptrs in
4554 all classes that need them. */
4555 if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4557 /* We build this decl with vtbl_ptr_type_node, which is a
4558 `vtable_entry_type*'. It might seem more precise to use
4559 `vtable_entry_type (*)[N]' where N is the number of virtual
4560 functions. However, that would require the vtable pointer in
4561 base classes to have a different type than the vtable pointer
4562 in derived classes. We could make that happen, but that
4563 still wouldn't solve all the problems. In particular, the
4564 type-based alias analysis code would decide that assignments
4565 to the base class vtable pointer can't alias assignments to
4566 the derived class vtable pointer, since they have different
4567 types. Thus, in a derived class destructor, where the base
4568 class constructor was inlined, we could generate bad code for
4569 setting up the vtable pointer.
4571 Therefore, we use one type for all vtable pointers. We still
4572 use a type-correct type; it's just doesn't indicate the array
4573 bounds. That's better than using `void*' or some such; it's
4574 cleaner, and it let's the alias analysis code know that these
4575 stores cannot alias stores to void*! */
4578 field = build_decl (input_location,
4579 FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4580 DECL_VIRTUAL_P (field) = 1;
4581 DECL_ARTIFICIAL (field) = 1;
4582 DECL_FIELD_CONTEXT (field) = t;
4583 DECL_FCONTEXT (field) = t;
4584 if (TYPE_PACKED (t))
4585 DECL_PACKED (field) = 1;
4587 TYPE_VFIELD (t) = field;
4589 /* This class is non-empty. */
4590 CLASSTYPE_EMPTY_P (t) = 0;
4598 /* Add OFFSET to all base types of BINFO which is a base in the
4599 hierarchy dominated by T.
4601 OFFSET, which is a type offset, is number of bytes. */
4604 propagate_binfo_offsets (tree binfo, tree offset)
4610 /* Update BINFO's offset. */
4611 BINFO_OFFSET (binfo)
4612 = convert (sizetype,
4613 size_binop (PLUS_EXPR,
4614 convert (ssizetype, BINFO_OFFSET (binfo)),
4617 /* Find the primary base class. */
4618 primary_binfo = get_primary_binfo (binfo);
4620 if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
4621 propagate_binfo_offsets (primary_binfo, offset);
4623 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4625 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4627 /* Don't do the primary base twice. */
4628 if (base_binfo == primary_binfo)
4631 if (BINFO_VIRTUAL_P (base_binfo))
4634 propagate_binfo_offsets (base_binfo, offset);
4638 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
4639 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4640 empty subobjects of T. */
4643 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4647 bool first_vbase = true;
4650 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
4653 if (!abi_version_at_least(2))
4655 /* In G++ 3.2, we incorrectly rounded the size before laying out
4656 the virtual bases. */
4657 finish_record_layout (rli, /*free_p=*/false);
4658 #ifdef STRUCTURE_SIZE_BOUNDARY
4659 /* Packed structures don't need to have minimum size. */
4660 if (! TYPE_PACKED (t))
4661 TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4663 rli->offset = TYPE_SIZE_UNIT (t);
4664 rli->bitpos = bitsize_zero_node;
4665 rli->record_align = TYPE_ALIGN (t);
4668 /* Find the last field. The artificial fields created for virtual
4669 bases will go after the last extant field to date. */
4670 next_field = &TYPE_FIELDS (t);
4672 next_field = &TREE_CHAIN (*next_field);
4674 /* Go through the virtual bases, allocating space for each virtual
4675 base that is not already a primary base class. These are
4676 allocated in inheritance graph order. */
4677 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4679 if (!BINFO_VIRTUAL_P (vbase))
4682 if (!BINFO_PRIMARY_P (vbase))
4684 tree basetype = TREE_TYPE (vbase);
4686 /* This virtual base is not a primary base of any class in the
4687 hierarchy, so we have to add space for it. */
4688 next_field = build_base_field (rli, vbase,
4689 offsets, next_field);
4691 /* If the first virtual base might have been placed at a
4692 lower address, had we started from CLASSTYPE_SIZE, rather
4693 than TYPE_SIZE, issue a warning. There can be both false
4694 positives and false negatives from this warning in rare
4695 cases; to deal with all the possibilities would probably
4696 require performing both layout algorithms and comparing
4697 the results which is not particularly tractable. */
4701 (size_binop (CEIL_DIV_EXPR,
4702 round_up_loc (input_location,
4704 CLASSTYPE_ALIGN (basetype)),
4706 BINFO_OFFSET (vbase))))
4708 "offset of virtual base %qT is not ABI-compliant and "
4709 "may change in a future version of GCC",
4712 first_vbase = false;
4717 /* Returns the offset of the byte just past the end of the base class
4721 end_of_base (tree binfo)
4725 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo)))
4726 size = TYPE_SIZE_UNIT (char_type_node);
4727 else if (is_empty_class (BINFO_TYPE (binfo)))
4728 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4729 allocate some space for it. It cannot have virtual bases, so
4730 TYPE_SIZE_UNIT is fine. */
4731 size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4733 size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4735 return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
4738 /* Returns the offset of the byte just past the end of the base class
4739 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4740 only non-virtual bases are included. */
4743 end_of_class (tree t, int include_virtuals_p)
4745 tree result = size_zero_node;
4746 VEC(tree,gc) *vbases;
4752 for (binfo = TYPE_BINFO (t), i = 0;
4753 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4755 if (!include_virtuals_p
4756 && BINFO_VIRTUAL_P (base_binfo)
4757 && (!BINFO_PRIMARY_P (base_binfo)
4758 || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
4761 offset = end_of_base (base_binfo);
4762 if (INT_CST_LT_UNSIGNED (result, offset))
4766 /* G++ 3.2 did not check indirect virtual bases. */
4767 if (abi_version_at_least (2) && include_virtuals_p)
4768 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4769 VEC_iterate (tree, vbases, i, base_binfo); i++)
4771 offset = end_of_base (base_binfo);
4772 if (INT_CST_LT_UNSIGNED (result, offset))
4779 /* Warn about bases of T that are inaccessible because they are
4780 ambiguous. For example:
4783 struct T : public S {};
4784 struct U : public S, public T {};
4786 Here, `(S*) new U' is not allowed because there are two `S'
4790 warn_about_ambiguous_bases (tree t)
4793 VEC(tree,gc) *vbases;
4798 /* If there are no repeated bases, nothing can be ambiguous. */
4799 if (!CLASSTYPE_REPEATED_BASE_P (t))
4802 /* Check direct bases. */
4803 for (binfo = TYPE_BINFO (t), i = 0;
4804 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4806 basetype = BINFO_TYPE (base_binfo);
4808 if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4809 warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
4813 /* Check for ambiguous virtual bases. */
4815 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4816 VEC_iterate (tree, vbases, i, binfo); i++)
4818 basetype = BINFO_TYPE (binfo);
4820 if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4821 warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity",
4826 /* Compare two INTEGER_CSTs K1 and K2. */
4829 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
4831 return tree_int_cst_compare ((tree) k1, (tree) k2);
4834 /* Increase the size indicated in RLI to account for empty classes
4835 that are "off the end" of the class. */
4838 include_empty_classes (record_layout_info rli)
4843 /* It might be the case that we grew the class to allocate a
4844 zero-sized base class. That won't be reflected in RLI, yet,
4845 because we are willing to overlay multiple bases at the same
4846 offset. However, now we need to make sure that RLI is big enough
4847 to reflect the entire class. */
4848 eoc = end_of_class (rli->t,
4849 CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
4850 rli_size = rli_size_unit_so_far (rli);
4851 if (TREE_CODE (rli_size) == INTEGER_CST
4852 && INT_CST_LT_UNSIGNED (rli_size, eoc))
4854 if (!abi_version_at_least (2))
4855 /* In version 1 of the ABI, the size of a class that ends with
4856 a bitfield was not rounded up to a whole multiple of a
4857 byte. Because rli_size_unit_so_far returns only the number
4858 of fully allocated bytes, any extra bits were not included
4860 rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
4862 /* The size should have been rounded to a whole byte. */
4863 gcc_assert (tree_int_cst_equal
4864 (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
4866 = size_binop (PLUS_EXPR,
4868 size_binop (MULT_EXPR,
4869 convert (bitsizetype,
4870 size_binop (MINUS_EXPR,
4872 bitsize_int (BITS_PER_UNIT)));
4873 normalize_rli (rli);
4877 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
4878 BINFO_OFFSETs for all of the base-classes. Position the vtable
4879 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
4882 layout_class_type (tree t, tree *virtuals_p)
4884 tree non_static_data_members;
4887 record_layout_info rli;
4888 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4889 types that appear at that offset. */
4890 splay_tree empty_base_offsets;
4891 /* True if the last field layed out was a bit-field. */
4892 bool last_field_was_bitfield = false;
4893 /* The location at which the next field should be inserted. */
4895 /* T, as a base class. */
4898 /* Keep track of the first non-static data member. */
4899 non_static_data_members = TYPE_FIELDS (t);
4901 /* Start laying out the record. */
4902 rli = start_record_layout (t);
4904 /* Mark all the primary bases in the hierarchy. */
4905 determine_primary_bases (t);
4907 /* Create a pointer to our virtual function table. */
4908 vptr = create_vtable_ptr (t, virtuals_p);
4910 /* The vptr is always the first thing in the class. */
4913 TREE_CHAIN (vptr) = TYPE_FIELDS (t);
4914 TYPE_FIELDS (t) = vptr;
4915 next_field = &TREE_CHAIN (vptr);
4916 place_field (rli, vptr);
4919 next_field = &TYPE_FIELDS (t);
4921 /* Build FIELD_DECLs for all of the non-virtual base-types. */
4922 empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
4924 build_base_fields (rli, empty_base_offsets, next_field);
4926 /* Layout the non-static data members. */
4927 for (field = non_static_data_members; field; field = TREE_CHAIN (field))
4932 /* We still pass things that aren't non-static data members to
4933 the back end, in case it wants to do something with them. */
4934 if (TREE_CODE (field) != FIELD_DECL)
4936 place_field (rli, field);
4937 /* If the static data member has incomplete type, keep track
4938 of it so that it can be completed later. (The handling
4939 of pending statics in finish_record_layout is
4940 insufficient; consider:
4943 struct S2 { static S1 s1; };
4945 At this point, finish_record_layout will be called, but
4946 S1 is still incomplete.) */
4947 if (TREE_CODE (field) == VAR_DECL)
4949 maybe_register_incomplete_var (field);
4950 /* The visibility of static data members is determined
4951 at their point of declaration, not their point of
4953 determine_visibility (field);
4958 type = TREE_TYPE (field);
4959 if (type == error_mark_node)
4962 padding = NULL_TREE;
4964 /* If this field is a bit-field whose width is greater than its
4965 type, then there are some special rules for allocating
4967 if (DECL_C_BIT_FIELD (field)
4968 && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
4972 bool was_unnamed_p = false;
4973 /* We must allocate the bits as if suitably aligned for the
4974 longest integer type that fits in this many bits. type
4975 of the field. Then, we are supposed to use the left over
4976 bits as additional padding. */
4977 for (itk = itk_char; itk != itk_none; ++itk)
4978 if (integer_types[itk] != NULL_TREE
4979 && (INT_CST_LT (size_int (MAX_FIXED_MODE_SIZE),
4980 TYPE_SIZE (integer_types[itk]))
4981 || INT_CST_LT (DECL_SIZE (field),
4982 TYPE_SIZE (integer_types[itk]))))
4985 /* ITK now indicates a type that is too large for the
4986 field. We have to back up by one to find the largest
4991 integer_type = integer_types[itk];
4992 } while (itk > 0 && integer_type == NULL_TREE);
4994 /* Figure out how much additional padding is required. GCC
4995 3.2 always created a padding field, even if it had zero
4997 if (!abi_version_at_least (2)
4998 || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
5000 if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
5001 /* In a union, the padding field must have the full width
5002 of the bit-field; all fields start at offset zero. */
5003 padding = DECL_SIZE (field);
5006 if (TREE_CODE (t) == UNION_TYPE)
5007 warning (OPT_Wabi, "size assigned to %qT may not be "
5008 "ABI-compliant and may change in a future "
5011 padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
5012 TYPE_SIZE (integer_type));
5015 #ifdef PCC_BITFIELD_TYPE_MATTERS
5016 /* An unnamed bitfield does not normally affect the
5017 alignment of the containing class on a target where
5018 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
5019 make any exceptions for unnamed bitfields when the
5020 bitfields are longer than their types. Therefore, we
5021 temporarily give the field a name. */
5022 if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
5024 was_unnamed_p = true;
5025 DECL_NAME (field) = make_anon_name ();
5028 DECL_SIZE (field) = TYPE_SIZE (integer_type);
5029 DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
5030 DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
5031 layout_nonempty_base_or_field (rli, field, NULL_TREE,
5032 empty_base_offsets);
5034 DECL_NAME (field) = NULL_TREE;
5035 /* Now that layout has been performed, set the size of the
5036 field to the size of its declared type; the rest of the
5037 field is effectively invisible. */
5038 DECL_SIZE (field) = TYPE_SIZE (type);
5039 /* We must also reset the DECL_MODE of the field. */
5040 if (abi_version_at_least (2))
5041 DECL_MODE (field) = TYPE_MODE (type);
5043 && DECL_MODE (field) != TYPE_MODE (type))
5044 /* Versions of G++ before G++ 3.4 did not reset the
5047 "the offset of %qD may not be ABI-compliant and may "
5048 "change in a future version of GCC", field);
5051 layout_nonempty_base_or_field (rli, field, NULL_TREE,
5052 empty_base_offsets);
5054 /* Remember the location of any empty classes in FIELD. */
5055 if (abi_version_at_least (2))
5056 record_subobject_offsets (TREE_TYPE (field),
5057 byte_position(field),
5059 /*is_data_member=*/true);
5061 /* If a bit-field does not immediately follow another bit-field,
5062 and yet it starts in the middle of a byte, we have failed to
5063 comply with the ABI. */
5065 && DECL_C_BIT_FIELD (field)
5066 /* The TREE_NO_WARNING flag gets set by Objective-C when
5067 laying out an Objective-C class. The ObjC ABI differs
5068 from the C++ ABI, and so we do not want a warning
5070 && !TREE_NO_WARNING (field)
5071 && !last_field_was_bitfield
5072 && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
5073 DECL_FIELD_BIT_OFFSET (field),
5074 bitsize_unit_node)))
5075 warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may "
5076 "change in a future version of GCC", field);
5078 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
5079 offset of the field. */
5081 && !abi_version_at_least (2)
5082 && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
5083 byte_position (field))
5084 && contains_empty_class_p (TREE_TYPE (field)))
5085 warning (OPT_Wabi, "%q+D contains empty classes which may cause base "
5086 "classes to be placed at different locations in a "
5087 "future version of GCC", field);
5089 /* The middle end uses the type of expressions to determine the
5090 possible range of expression values. In order to optimize
5091 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
5092 must be made aware of the width of "i", via its type.
5094 Because C++ does not have integer types of arbitrary width,
5095 we must (for the purposes of the front end) convert from the
5096 type assigned here to the declared type of the bitfield
5097 whenever a bitfield expression is used as an rvalue.
5098 Similarly, when assigning a value to a bitfield, the value
5099 must be converted to the type given the bitfield here. */
5100 if (DECL_C_BIT_FIELD (field))
5102 unsigned HOST_WIDE_INT width;
5103 tree ftype = TREE_TYPE (field);
5104 width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1);
5105 if (width != TYPE_PRECISION (ftype))
5108 = c_build_bitfield_integer_type (width,
5109 TYPE_UNSIGNED (ftype));
5111 = cp_build_qualified_type (TREE_TYPE (field),
5112 cp_type_quals (ftype));
5116 /* If we needed additional padding after this field, add it
5122 padding_field = build_decl (input_location,
5126 DECL_BIT_FIELD (padding_field) = 1;
5127 DECL_SIZE (padding_field) = padding;
5128 DECL_CONTEXT (padding_field) = t;
5129 DECL_ARTIFICIAL (padding_field) = 1;
5130 DECL_IGNORED_P (padding_field) = 1;
5131 layout_nonempty_base_or_field (rli, padding_field,
5133 empty_base_offsets);
5136 last_field_was_bitfield = DECL_C_BIT_FIELD (field);
5139 if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
5141 /* Make sure that we are on a byte boundary so that the size of
5142 the class without virtual bases will always be a round number
5144 rli->bitpos = round_up_loc (input_location, rli->bitpos, BITS_PER_UNIT);
5145 normalize_rli (rli);
5148 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5150 if (!abi_version_at_least (2))
5151 include_empty_classes(rli);
5153 /* Delete all zero-width bit-fields from the list of fields. Now
5154 that the type is laid out they are no longer important. */
5155 remove_zero_width_bit_fields (t);
5157 /* Create the version of T used for virtual bases. We do not use
5158 make_class_type for this version; this is an artificial type. For
5159 a POD type, we just reuse T. */
5160 if (CLASSTYPE_NON_LAYOUT_POD_P (t) || CLASSTYPE_EMPTY_P (t))
5162 base_t = make_node (TREE_CODE (t));
5164 /* Set the size and alignment for the new type. In G++ 3.2, all
5165 empty classes were considered to have size zero when used as
5167 if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
5169 TYPE_SIZE (base_t) = bitsize_zero_node;
5170 TYPE_SIZE_UNIT (base_t) = size_zero_node;
5171 if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
5173 "layout of classes derived from empty class %qT "
5174 "may change in a future version of GCC",
5181 /* If the ABI version is not at least two, and the last
5182 field was a bit-field, RLI may not be on a byte
5183 boundary. In particular, rli_size_unit_so_far might
5184 indicate the last complete byte, while rli_size_so_far
5185 indicates the total number of bits used. Therefore,
5186 rli_size_so_far, rather than rli_size_unit_so_far, is
5187 used to compute TYPE_SIZE_UNIT. */
5188 eoc = end_of_class (t, /*include_virtuals_p=*/0);
5189 TYPE_SIZE_UNIT (base_t)
5190 = size_binop (MAX_EXPR,
5192 size_binop (CEIL_DIV_EXPR,
5193 rli_size_so_far (rli),
5194 bitsize_int (BITS_PER_UNIT))),
5197 = size_binop (MAX_EXPR,
5198 rli_size_so_far (rli),
5199 size_binop (MULT_EXPR,
5200 convert (bitsizetype, eoc),
5201 bitsize_int (BITS_PER_UNIT)));
5203 TYPE_ALIGN (base_t) = rli->record_align;
5204 TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
5206 /* Copy the fields from T. */
5207 next_field = &TYPE_FIELDS (base_t);
5208 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5209 if (TREE_CODE (field) == FIELD_DECL)
5211 *next_field = build_decl (input_location,
5215 DECL_CONTEXT (*next_field) = base_t;
5216 DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
5217 DECL_FIELD_BIT_OFFSET (*next_field)
5218 = DECL_FIELD_BIT_OFFSET (field);
5219 DECL_SIZE (*next_field) = DECL_SIZE (field);
5220 DECL_MODE (*next_field) = DECL_MODE (field);
5221 next_field = &TREE_CHAIN (*next_field);
5224 /* Record the base version of the type. */
5225 CLASSTYPE_AS_BASE (t) = base_t;
5226 TYPE_CONTEXT (base_t) = t;
5229 CLASSTYPE_AS_BASE (t) = t;
5231 /* Every empty class contains an empty class. */
5232 if (CLASSTYPE_EMPTY_P (t))
5233 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
5235 /* Set the TYPE_DECL for this type to contain the right
5236 value for DECL_OFFSET, so that we can use it as part
5237 of a COMPONENT_REF for multiple inheritance. */
5238 layout_decl (TYPE_MAIN_DECL (t), 0);
5240 /* Now fix up any virtual base class types that we left lying
5241 around. We must get these done before we try to lay out the
5242 virtual function table. As a side-effect, this will remove the
5243 base subobject fields. */
5244 layout_virtual_bases (rli, empty_base_offsets);
5246 /* Make sure that empty classes are reflected in RLI at this
5248 include_empty_classes(rli);
5250 /* Make sure not to create any structures with zero size. */
5251 if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
5253 build_decl (input_location,
5254 FIELD_DECL, NULL_TREE, char_type_node));
5256 /* If this is a non-POD, declaring it packed makes a difference to how it
5257 can be used as a field; don't let finalize_record_size undo it. */
5258 if (TYPE_PACKED (t) && !layout_pod_type_p (t))
5259 rli->packed_maybe_necessary = true;
5261 /* Let the back end lay out the type. */
5262 finish_record_layout (rli, /*free_p=*/true);
5264 /* Warn about bases that can't be talked about due to ambiguity. */
5265 warn_about_ambiguous_bases (t);
5267 /* Now that we're done with layout, give the base fields the real types. */
5268 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
5269 if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
5270 TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
5273 splay_tree_delete (empty_base_offsets);
5275 if (CLASSTYPE_EMPTY_P (t)
5276 && tree_int_cst_lt (sizeof_biggest_empty_class,
5277 TYPE_SIZE_UNIT (t)))
5278 sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
5281 /* Determine the "key method" for the class type indicated by TYPE,
5282 and set CLASSTYPE_KEY_METHOD accordingly. */
5285 determine_key_method (tree type)
5289 if (TYPE_FOR_JAVA (type)
5290 || processing_template_decl
5291 || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
5292 || CLASSTYPE_INTERFACE_KNOWN (type))
5295 /* The key method is the first non-pure virtual function that is not
5296 inline at the point of class definition. On some targets the
5297 key function may not be inline; those targets should not call
5298 this function until the end of the translation unit. */
5299 for (method = TYPE_METHODS (type); method != NULL_TREE;
5300 method = TREE_CHAIN (method))
5301 if (DECL_VINDEX (method) != NULL_TREE
5302 && ! DECL_DECLARED_INLINE_P (method)
5303 && ! DECL_PURE_VIRTUAL_P (method))
5305 CLASSTYPE_KEY_METHOD (type) = method;
5312 /* Perform processing required when the definition of T (a class type)
5316 finish_struct_1 (tree t)
5319 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
5320 tree virtuals = NULL_TREE;
5323 if (COMPLETE_TYPE_P (t))
5325 gcc_assert (MAYBE_CLASS_TYPE_P (t));
5326 error ("redefinition of %q#T", t);
5331 /* If this type was previously laid out as a forward reference,
5332 make sure we lay it out again. */
5333 TYPE_SIZE (t) = NULL_TREE;
5334 CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5336 /* Make assumptions about the class; we'll reset the flags if
5338 CLASSTYPE_EMPTY_P (t) = 1;
5339 CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5340 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5342 /* Do end-of-class semantic processing: checking the validity of the
5343 bases and members and add implicitly generated methods. */
5344 check_bases_and_members (t);
5346 /* Find the key method. */
5347 if (TYPE_CONTAINS_VPTR_P (t))
5349 /* The Itanium C++ ABI permits the key method to be chosen when
5350 the class is defined -- even though the key method so
5351 selected may later turn out to be an inline function. On
5352 some systems (such as ARM Symbian OS) the key method cannot
5353 be determined until the end of the translation unit. On such
5354 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5355 will cause the class to be added to KEYED_CLASSES. Then, in
5356 finish_file we will determine the key method. */
5357 if (targetm.cxx.key_method_may_be_inline ())
5358 determine_key_method (t);
5360 /* If a polymorphic class has no key method, we may emit the vtable
5361 in every translation unit where the class definition appears. */
5362 if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5363 keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5366 /* Layout the class itself. */
5367 layout_class_type (t, &virtuals);
5368 if (CLASSTYPE_AS_BASE (t) != t)
5369 /* We use the base type for trivial assignments, and hence it
5371 compute_record_mode (CLASSTYPE_AS_BASE (t));
5373 virtuals = modify_all_vtables (t, nreverse (virtuals));
5375 /* If necessary, create the primary vtable for this class. */
5376 if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5378 /* We must enter these virtuals into the table. */
5379 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5380 build_primary_vtable (NULL_TREE, t);
5381 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5382 /* Here we know enough to change the type of our virtual
5383 function table, but we will wait until later this function. */
5384 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5387 if (TYPE_CONTAINS_VPTR_P (t))
5392 if (BINFO_VTABLE (TYPE_BINFO (t)))
5393 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5394 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5395 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5397 /* Add entries for virtual functions introduced by this class. */
5398 BINFO_VIRTUALS (TYPE_BINFO (t))
5399 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5401 /* Set DECL_VINDEX for all functions declared in this class. */
5402 for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5404 fn = TREE_CHAIN (fn),
5405 vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5406 ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5408 tree fndecl = BV_FN (fn);
5410 if (DECL_THUNK_P (fndecl))
5411 /* A thunk. We should never be calling this entry directly
5412 from this vtable -- we'd use the entry for the non
5413 thunk base function. */
5414 DECL_VINDEX (fndecl) = NULL_TREE;
5415 else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5416 DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5420 finish_struct_bits (t);
5422 /* Complete the rtl for any static member objects of the type we're
5424 for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5425 if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5426 && TREE_TYPE (x) != error_mark_node
5427 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5428 DECL_MODE (x) = TYPE_MODE (t);
5430 /* Done with FIELDS...now decide whether to sort these for
5431 faster lookups later.
5433 We use a small number because most searches fail (succeeding
5434 ultimately as the search bores through the inheritance
5435 hierarchy), and we want this failure to occur quickly. */
5437 n_fields = count_fields (TYPE_FIELDS (t));
5440 struct sorted_fields_type *field_vec = GGC_NEWVAR
5441 (struct sorted_fields_type,
5442 sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5443 field_vec->len = n_fields;
5444 add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5445 qsort (field_vec->elts, n_fields, sizeof (tree),
5447 CLASSTYPE_SORTED_FIELDS (t) = field_vec;
5450 /* Complain if one of the field types requires lower visibility. */
5451 constrain_class_visibility (t);
5453 /* Make the rtl for any new vtables we have created, and unmark
5454 the base types we marked. */
5457 /* Build the VTT for T. */
5460 /* This warning does not make sense for Java classes, since they
5461 cannot have destructors. */
5462 if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t))
5466 dtor = CLASSTYPE_DESTRUCTORS (t);
5467 if (/* An implicitly declared destructor is always public. And,
5468 if it were virtual, we would have created it by now. */
5470 || (!DECL_VINDEX (dtor)
5471 && (/* public non-virtual */
5472 (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor))
5473 || (/* non-public non-virtual with friends */
5474 (TREE_PRIVATE (dtor) || TREE_PROTECTED (dtor))
5475 && (CLASSTYPE_FRIEND_CLASSES (t)
5476 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))))))
5477 warning (OPT_Wnon_virtual_dtor,
5478 "%q#T has virtual functions and accessible"
5479 " non-virtual destructor", t);
5484 if (warn_overloaded_virtual)
5487 /* Class layout, assignment of virtual table slots, etc., is now
5488 complete. Give the back end a chance to tweak the visibility of
5489 the class or perform any other required target modifications. */
5490 targetm.cxx.adjust_class_at_definition (t);
5492 maybe_suppress_debug_info (t);
5494 dump_class_hierarchy (t);
5496 /* Finish debugging output for this type. */
5497 rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5500 /* When T was built up, the member declarations were added in reverse
5501 order. Rearrange them to declaration order. */
5504 unreverse_member_declarations (tree t)
5510 /* The following lists are all in reverse order. Put them in
5511 declaration order now. */
5512 TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5513 CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5515 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5516 reverse order, so we can't just use nreverse. */
5518 for (x = TYPE_FIELDS (t);
5519 x && TREE_CODE (x) != TYPE_DECL;
5522 next = TREE_CHAIN (x);
5523 TREE_CHAIN (x) = prev;
5528 TREE_CHAIN (TYPE_FIELDS (t)) = x;
5530 TYPE_FIELDS (t) = prev;
5535 finish_struct (tree t, tree attributes)
5537 location_t saved_loc = input_location;
5539 /* Now that we've got all the field declarations, reverse everything
5541 unreverse_member_declarations (t);
5543 cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5545 /* Nadger the current location so that diagnostics point to the start of
5546 the struct, not the end. */
5547 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5549 if (processing_template_decl)
5553 finish_struct_methods (t);
5554 TYPE_SIZE (t) = bitsize_zero_node;
5555 TYPE_SIZE_UNIT (t) = size_zero_node;
5557 /* We need to emit an error message if this type was used as a parameter
5558 and it is an abstract type, even if it is a template. We construct
5559 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5560 account and we call complete_vars with this type, which will check
5561 the PARM_DECLS. Note that while the type is being defined,
5562 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5563 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
5564 CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5565 for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
5566 if (DECL_PURE_VIRTUAL_P (x))
5567 VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
5570 /* Remember current #pragma pack value. */
5571 TYPE_PRECISION (t) = maximum_field_alignment;
5574 finish_struct_1 (t);
5576 input_location = saved_loc;
5578 TYPE_BEING_DEFINED (t) = 0;
5580 if (current_class_type)
5583 error ("trying to finish struct, but kicked out due to previous parse errors");
5585 if (processing_template_decl && at_function_scope_p ())
5586 add_stmt (build_min (TAG_DEFN, t));
5591 /* Return the dynamic type of INSTANCE, if known.
5592 Used to determine whether the virtual function table is needed
5595 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5596 of our knowledge of its type. *NONNULL should be initialized
5597 before this function is called. */
5600 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
5602 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5604 switch (TREE_CODE (instance))
5607 if (POINTER_TYPE_P (TREE_TYPE (instance)))
5610 return RECUR (TREE_OPERAND (instance, 0));
5613 /* This is a call to a constructor, hence it's never zero. */
5614 if (TREE_HAS_CONSTRUCTOR (instance))
5618 return TREE_TYPE (instance);
5623 /* This is a call to a constructor, hence it's never zero. */
5624 if (TREE_HAS_CONSTRUCTOR (instance))
5628 return TREE_TYPE (instance);
5630 return RECUR (TREE_OPERAND (instance, 0));
5632 case POINTER_PLUS_EXPR:
5635 if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5636 return RECUR (TREE_OPERAND (instance, 0));
5637 if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5638 /* Propagate nonnull. */
5639 return RECUR (TREE_OPERAND (instance, 0));
5644 return RECUR (TREE_OPERAND (instance, 0));
5647 instance = TREE_OPERAND (instance, 0);
5650 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5651 with a real object -- given &p->f, p can still be null. */
5652 tree t = get_base_address (instance);
5653 /* ??? Probably should check DECL_WEAK here. */
5654 if (t && DECL_P (t))
5657 return RECUR (instance);
5660 /* If this component is really a base class reference, then the field
5661 itself isn't definitive. */
5662 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5663 return RECUR (TREE_OPERAND (instance, 0));
5664 return RECUR (TREE_OPERAND (instance, 1));
5668 if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5669 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance))))
5673 return TREE_TYPE (TREE_TYPE (instance));
5675 /* fall through... */
5679 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance)))
5683 return TREE_TYPE (instance);
5685 else if (instance == current_class_ptr)
5690 /* if we're in a ctor or dtor, we know our type. */
5691 if (DECL_LANG_SPECIFIC (current_function_decl)
5692 && (DECL_CONSTRUCTOR_P (current_function_decl)
5693 || DECL_DESTRUCTOR_P (current_function_decl)))
5697 return TREE_TYPE (TREE_TYPE (instance));
5700 else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5702 /* We only need one hash table because it is always left empty. */
5705 ht = htab_create (37,
5710 /* Reference variables should be references to objects. */
5714 /* Enter the INSTANCE in a table to prevent recursion; a
5715 variable's initializer may refer to the variable
5717 if (TREE_CODE (instance) == VAR_DECL
5718 && DECL_INITIAL (instance)
5719 && !htab_find (ht, instance))
5724 slot = htab_find_slot (ht, instance, INSERT);
5726 type = RECUR (DECL_INITIAL (instance));
5727 htab_remove_elt (ht, instance);
5740 /* Return nonzero if the dynamic type of INSTANCE is known, and
5741 equivalent to the static type. We also handle the case where
5742 INSTANCE is really a pointer. Return negative if this is a
5743 ctor/dtor. There the dynamic type is known, but this might not be
5744 the most derived base of the original object, and hence virtual
5745 bases may not be layed out according to this type.
5747 Used to determine whether the virtual function table is needed
5750 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5751 of our knowledge of its type. *NONNULL should be initialized
5752 before this function is called. */
5755 resolves_to_fixed_type_p (tree instance, int* nonnull)
5757 tree t = TREE_TYPE (instance);
5759 tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5760 if (fixed == NULL_TREE)
5762 if (POINTER_TYPE_P (t))
5764 if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5766 return cdtorp ? -1 : 1;
5771 init_class_processing (void)
5773 current_class_depth = 0;
5774 current_class_stack_size = 10;
5776 = XNEWVEC (struct class_stack_node, current_class_stack_size);
5777 local_classes = VEC_alloc (tree, gc, 8);
5778 sizeof_biggest_empty_class = size_zero_node;
5780 ridpointers[(int) RID_PUBLIC] = access_public_node;
5781 ridpointers[(int) RID_PRIVATE] = access_private_node;
5782 ridpointers[(int) RID_PROTECTED] = access_protected_node;
5785 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
5788 restore_class_cache (void)
5792 /* We are re-entering the same class we just left, so we don't
5793 have to search the whole inheritance matrix to find all the
5794 decls to bind again. Instead, we install the cached
5795 class_shadowed list and walk through it binding names. */
5796 push_binding_level (previous_class_level);
5797 class_binding_level = previous_class_level;
5798 /* Restore IDENTIFIER_TYPE_VALUE. */
5799 for (type = class_binding_level->type_shadowed;
5801 type = TREE_CHAIN (type))
5802 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5805 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5806 appropriate for TYPE.
5808 So that we may avoid calls to lookup_name, we cache the _TYPE
5809 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5811 For multiple inheritance, we perform a two-pass depth-first search
5812 of the type lattice. */
5815 pushclass (tree type)
5817 class_stack_node_t csn;
5819 type = TYPE_MAIN_VARIANT (type);
5821 /* Make sure there is enough room for the new entry on the stack. */
5822 if (current_class_depth + 1 >= current_class_stack_size)
5824 current_class_stack_size *= 2;
5826 = XRESIZEVEC (struct class_stack_node, current_class_stack,
5827 current_class_stack_size);
5830 /* Insert a new entry on the class stack. */
5831 csn = current_class_stack + current_class_depth;
5832 csn->name = current_class_name;
5833 csn->type = current_class_type;
5834 csn->access = current_access_specifier;
5835 csn->names_used = 0;
5837 current_class_depth++;
5839 /* Now set up the new type. */
5840 current_class_name = TYPE_NAME (type);
5841 if (TREE_CODE (current_class_name) == TYPE_DECL)
5842 current_class_name = DECL_NAME (current_class_name);
5843 current_class_type = type;
5845 /* By default, things in classes are private, while things in
5846 structures or unions are public. */
5847 current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
5848 ? access_private_node
5849 : access_public_node);
5851 if (previous_class_level
5852 && type != previous_class_level->this_entity
5853 && current_class_depth == 1)
5855 /* Forcibly remove any old class remnants. */
5856 invalidate_class_lookup_cache ();
5859 if (!previous_class_level
5860 || type != previous_class_level->this_entity
5861 || current_class_depth > 1)
5864 restore_class_cache ();
5867 /* When we exit a toplevel class scope, we save its binding level so
5868 that we can restore it quickly. Here, we've entered some other
5869 class, so we must invalidate our cache. */
5872 invalidate_class_lookup_cache (void)
5874 previous_class_level = NULL;
5877 /* Get out of the current class scope. If we were in a class scope
5878 previously, that is the one popped to. */
5885 current_class_depth--;
5886 current_class_name = current_class_stack[current_class_depth].name;
5887 current_class_type = current_class_stack[current_class_depth].type;
5888 current_access_specifier = current_class_stack[current_class_depth].access;
5889 if (current_class_stack[current_class_depth].names_used)
5890 splay_tree_delete (current_class_stack[current_class_depth].names_used);
5893 /* Mark the top of the class stack as hidden. */
5896 push_class_stack (void)
5898 if (current_class_depth)
5899 ++current_class_stack[current_class_depth - 1].hidden;
5902 /* Mark the top of the class stack as un-hidden. */
5905 pop_class_stack (void)
5907 if (current_class_depth)
5908 --current_class_stack[current_class_depth - 1].hidden;
5911 /* Returns 1 if the class type currently being defined is either T or
5912 a nested type of T. */
5915 currently_open_class (tree t)
5919 if (!CLASS_TYPE_P (t))
5922 t = TYPE_MAIN_VARIANT (t);
5924 /* We start looking from 1 because entry 0 is from global scope,
5926 for (i = current_class_depth; i > 0; --i)
5929 if (i == current_class_depth)
5930 c = current_class_type;
5933 if (current_class_stack[i].hidden)
5935 c = current_class_stack[i].type;
5939 if (same_type_p (c, t))
5945 /* If either current_class_type or one of its enclosing classes are derived
5946 from T, return the appropriate type. Used to determine how we found
5947 something via unqualified lookup. */
5950 currently_open_derived_class (tree t)
5954 /* The bases of a dependent type are unknown. */
5955 if (dependent_type_p (t))
5958 if (!current_class_type)
5961 if (DERIVED_FROM_P (t, current_class_type))
5962 return current_class_type;
5964 for (i = current_class_depth - 1; i > 0; --i)
5966 if (current_class_stack[i].hidden)
5968 if (DERIVED_FROM_P (t, current_class_stack[i].type))
5969 return current_class_stack[i].type;
5975 /* Returns the innermost class type which is not a lambda closure type. */
5978 current_nonlambda_class_type (void)
5982 /* We start looking from 1 because entry 0 is from global scope,
5984 for (i = current_class_depth; i > 0; --i)
5987 if (i == current_class_depth)
5988 c = current_class_type;
5991 if (current_class_stack[i].hidden)
5993 c = current_class_stack[i].type;
5997 if (!LAMBDA_TYPE_P (c))
6003 /* When entering a class scope, all enclosing class scopes' names with
6004 static meaning (static variables, static functions, types and
6005 enumerators) have to be visible. This recursive function calls
6006 pushclass for all enclosing class contexts until global or a local
6007 scope is reached. TYPE is the enclosed class. */
6010 push_nested_class (tree type)
6012 /* A namespace might be passed in error cases, like A::B:C. */
6013 if (type == NULL_TREE
6014 || !CLASS_TYPE_P (type))
6017 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
6022 /* Undoes a push_nested_class call. */
6025 pop_nested_class (void)
6027 tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
6030 if (context && CLASS_TYPE_P (context))
6031 pop_nested_class ();
6034 /* Returns the number of extern "LANG" blocks we are nested within. */
6037 current_lang_depth (void)
6039 return VEC_length (tree, current_lang_base);
6042 /* Set global variables CURRENT_LANG_NAME to appropriate value
6043 so that behavior of name-mangling machinery is correct. */
6046 push_lang_context (tree name)
6048 VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
6050 if (name == lang_name_cplusplus)
6052 current_lang_name = name;
6054 else if (name == lang_name_java)
6056 current_lang_name = name;
6057 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6058 (See record_builtin_java_type in decl.c.) However, that causes
6059 incorrect debug entries if these types are actually used.
6060 So we re-enable debug output after extern "Java". */
6061 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
6062 DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
6063 DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
6064 DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
6065 DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
6066 DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
6067 DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
6068 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
6070 else if (name == lang_name_c)
6072 current_lang_name = name;
6075 error ("language string %<\"%E\"%> not recognized", name);
6078 /* Get out of the current language scope. */
6081 pop_lang_context (void)
6083 current_lang_name = VEC_pop (tree, current_lang_base);
6086 /* Type instantiation routines. */
6088 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6089 matches the TARGET_TYPE. If there is no satisfactory match, return
6090 error_mark_node, and issue an error & warning messages under
6091 control of FLAGS. Permit pointers to member function if FLAGS
6092 permits. If TEMPLATE_ONLY, the name of the overloaded function was
6093 a template-id, and EXPLICIT_TARGS are the explicitly provided
6096 If OVERLOAD is for one or more member functions, then ACCESS_PATH
6097 is the base path used to reference those member functions. If
6098 TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
6099 resolved to a member function, access checks will be performed and
6100 errors issued if appropriate. */
6103 resolve_address_of_overloaded_function (tree target_type,
6105 tsubst_flags_t flags,
6107 tree explicit_targs,
6110 /* Here's what the standard says:
6114 If the name is a function template, template argument deduction
6115 is done, and if the argument deduction succeeds, the deduced
6116 arguments are used to generate a single template function, which
6117 is added to the set of overloaded functions considered.
6119 Non-member functions and static member functions match targets of
6120 type "pointer-to-function" or "reference-to-function." Nonstatic
6121 member functions match targets of type "pointer-to-member
6122 function;" the function type of the pointer to member is used to
6123 select the member function from the set of overloaded member
6124 functions. If a nonstatic member function is selected, the
6125 reference to the overloaded function name is required to have the
6126 form of a pointer to member as described in 5.3.1.
6128 If more than one function is selected, any template functions in
6129 the set are eliminated if the set also contains a non-template
6130 function, and any given template function is eliminated if the
6131 set contains a second template function that is more specialized
6132 than the first according to the partial ordering rules 14.5.5.2.
6133 After such eliminations, if any, there shall remain exactly one
6134 selected function. */
6137 /* We store the matches in a TREE_LIST rooted here. The functions
6138 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6139 interoperability with most_specialized_instantiation. */
6140 tree matches = NULL_TREE;
6142 tree target_fn_type;
6144 /* By the time we get here, we should be seeing only real
6145 pointer-to-member types, not the internal POINTER_TYPE to
6146 METHOD_TYPE representation. */
6147 gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
6148 || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
6150 gcc_assert (is_overloaded_fn (overload));
6152 /* Check that the TARGET_TYPE is reasonable. */
6153 if (TYPE_PTRFN_P (target_type))
6155 else if (TYPE_PTRMEMFUNC_P (target_type))
6156 /* This is OK, too. */
6158 else if (TREE_CODE (target_type) == FUNCTION_TYPE)
6159 /* This is OK, too. This comes from a conversion to reference
6161 target_type = build_reference_type (target_type);
6164 if (flags & tf_error)
6165 error ("cannot resolve overloaded function %qD based on"
6166 " conversion to type %qT",
6167 DECL_NAME (OVL_FUNCTION (overload)), target_type);
6168 return error_mark_node;
6171 /* Non-member functions and static member functions match targets of type
6172 "pointer-to-function" or "reference-to-function." Nonstatic member
6173 functions match targets of type "pointer-to-member-function;" the
6174 function type of the pointer to member is used to select the member
6175 function from the set of overloaded member functions.
6177 So figure out the FUNCTION_TYPE that we want to match against. */
6178 target_fn_type = static_fn_type (target_type);
6180 /* If we can find a non-template function that matches, we can just
6181 use it. There's no point in generating template instantiations
6182 if we're just going to throw them out anyhow. But, of course, we
6183 can only do this when we don't *need* a template function. */
6188 for (fns = overload; fns; fns = OVL_NEXT (fns))
6190 tree fn = OVL_CURRENT (fns);
6192 if (TREE_CODE (fn) == TEMPLATE_DECL)
6193 /* We're not looking for templates just yet. */
6196 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6198 /* We're looking for a non-static member, and this isn't
6199 one, or vice versa. */
6202 /* Ignore functions which haven't been explicitly
6204 if (DECL_ANTICIPATED (fn))
6207 /* See if there's a match. */
6208 if (same_type_p (target_fn_type, static_fn_type (fn)))
6209 matches = tree_cons (fn, NULL_TREE, matches);
6213 /* Now, if we've already got a match (or matches), there's no need
6214 to proceed to the template functions. But, if we don't have a
6215 match we need to look at them, too. */
6218 tree target_arg_types;
6219 tree target_ret_type;
6222 unsigned int nargs, ia;
6225 target_arg_types = TYPE_ARG_TYPES (target_fn_type);
6226 target_ret_type = TREE_TYPE (target_fn_type);
6228 nargs = list_length (target_arg_types);
6229 args = XALLOCAVEC (tree, nargs);
6230 for (arg = target_arg_types, ia = 0;
6231 arg != NULL_TREE && arg != void_list_node;
6232 arg = TREE_CHAIN (arg), ++ia)
6233 args[ia] = TREE_VALUE (arg);
6236 for (fns = overload; fns; fns = OVL_NEXT (fns))
6238 tree fn = OVL_CURRENT (fns);
6242 if (TREE_CODE (fn) != TEMPLATE_DECL)
6243 /* We're only looking for templates. */
6246 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6248 /* We're not looking for a non-static member, and this is
6249 one, or vice versa. */
6252 /* Try to do argument deduction. */
6253 targs = make_tree_vec (DECL_NTPARMS (fn));
6254 if (fn_type_unification (fn, explicit_targs, targs, args, nargs,
6255 target_ret_type, DEDUCE_EXACT,
6257 /* Argument deduction failed. */
6260 /* Instantiate the template. */
6261 instantiation = instantiate_template (fn, targs, flags);
6262 if (instantiation == error_mark_node)
6263 /* Instantiation failed. */
6266 /* See if there's a match. */
6267 if (same_type_p (target_fn_type, static_fn_type (instantiation)))
6268 matches = tree_cons (instantiation, fn, matches);
6271 /* Now, remove all but the most specialized of the matches. */
6274 tree match = most_specialized_instantiation (matches);
6276 if (match != error_mark_node)
6277 matches = tree_cons (TREE_PURPOSE (match),
6283 /* Now we should have exactly one function in MATCHES. */
6284 if (matches == NULL_TREE)
6286 /* There were *no* matches. */
6287 if (flags & tf_error)
6289 error ("no matches converting function %qD to type %q#T",
6290 DECL_NAME (OVL_CURRENT (overload)),
6293 /* print_candidates expects a chain with the functions in
6294 TREE_VALUE slots, so we cons one up here (we're losing anyway,
6295 so why be clever?). */
6296 for (; overload; overload = OVL_NEXT (overload))
6297 matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
6300 print_candidates (matches);
6302 return error_mark_node;
6304 else if (TREE_CHAIN (matches))
6306 /* There were too many matches. First check if they're all
6307 the same function. */
6310 fn = TREE_PURPOSE (matches);
6311 for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
6312 if (!decls_match (fn, TREE_PURPOSE (match)))
6317 if (flags & tf_error)
6319 error ("converting overloaded function %qD to type %q#T is ambiguous",
6320 DECL_NAME (OVL_FUNCTION (overload)),
6323 /* Since print_candidates expects the functions in the
6324 TREE_VALUE slot, we flip them here. */
6325 for (match = matches; match; match = TREE_CHAIN (match))
6326 TREE_VALUE (match) = TREE_PURPOSE (match);
6328 print_candidates (matches);
6331 return error_mark_node;
6335 /* Good, exactly one match. Now, convert it to the correct type. */
6336 fn = TREE_PURPOSE (matches);
6338 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6339 && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6341 static int explained;
6343 if (!(flags & tf_error))
6344 return error_mark_node;
6346 permerror (input_location, "assuming pointer to member %qD", fn);
6349 inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
6354 /* If we're doing overload resolution purely for the purpose of
6355 determining conversion sequences, we should not consider the
6356 function used. If this conversion sequence is selected, the
6357 function will be marked as used at this point. */
6358 if (!(flags & tf_conv))
6360 /* Make =delete work with SFINAE. */
6361 if (DECL_DELETED_FN (fn) && !(flags & tf_error))
6362 return error_mark_node;
6367 /* We could not check access to member functions when this
6368 expression was originally created since we did not know at that
6369 time to which function the expression referred. */
6370 if (!(flags & tf_no_access_control)
6371 && DECL_FUNCTION_MEMBER_P (fn))
6373 gcc_assert (access_path);
6374 perform_or_defer_access_check (access_path, fn, fn);
6377 if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6378 return cp_build_unary_op (ADDR_EXPR, fn, 0, flags);
6381 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
6382 will mark the function as addressed, but here we must do it
6384 cxx_mark_addressable (fn);
6390 /* This function will instantiate the type of the expression given in
6391 RHS to match the type of LHSTYPE. If errors exist, then return
6392 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
6393 we complain on errors. If we are not complaining, never modify rhs,
6394 as overload resolution wants to try many possible instantiations, in
6395 the hope that at least one will work.
6397 For non-recursive calls, LHSTYPE should be a function, pointer to
6398 function, or a pointer to member function. */
6401 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6403 tsubst_flags_t flags_in = flags;
6404 tree access_path = NULL_TREE;
6406 flags &= ~tf_ptrmem_ok;
6408 if (lhstype == unknown_type_node)
6410 if (flags & tf_error)
6411 error ("not enough type information");
6412 return error_mark_node;
6415 if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6417 if (same_type_p (lhstype, TREE_TYPE (rhs)))
6419 if (flag_ms_extensions
6420 && TYPE_PTRMEMFUNC_P (lhstype)
6421 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6422 /* Microsoft allows `A::f' to be resolved to a
6423 pointer-to-member. */
6427 if (flags & tf_error)
6428 error ("argument of type %qT does not match %qT",
6429 TREE_TYPE (rhs), lhstype);
6430 return error_mark_node;
6434 if (TREE_CODE (rhs) == BASELINK)
6436 access_path = BASELINK_ACCESS_BINFO (rhs);
6437 rhs = BASELINK_FUNCTIONS (rhs);
6440 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6441 deduce any type information. */
6442 if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6444 if (flags & tf_error)
6445 error ("not enough type information");
6446 return error_mark_node;
6449 /* There only a few kinds of expressions that may have a type
6450 dependent on overload resolution. */
6451 gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6452 || TREE_CODE (rhs) == COMPONENT_REF
6453 || really_overloaded_fn (rhs)
6454 || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL));
6456 /* This should really only be used when attempting to distinguish
6457 what sort of a pointer to function we have. For now, any
6458 arithmetic operation which is not supported on pointers
6459 is rejected as an error. */
6461 switch (TREE_CODE (rhs))
6465 tree member = TREE_OPERAND (rhs, 1);
6467 member = instantiate_type (lhstype, member, flags);
6468 if (member != error_mark_node
6469 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6470 /* Do not lose object's side effects. */
6471 return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6472 TREE_OPERAND (rhs, 0), member);
6477 rhs = TREE_OPERAND (rhs, 1);
6478 if (BASELINK_P (rhs))
6479 return instantiate_type (lhstype, rhs, flags_in);
6481 /* This can happen if we are forming a pointer-to-member for a
6483 gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6487 case TEMPLATE_ID_EXPR:
6489 tree fns = TREE_OPERAND (rhs, 0);
6490 tree args = TREE_OPERAND (rhs, 1);
6493 resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6494 /*template_only=*/true,
6501 resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6502 /*template_only=*/false,
6503 /*explicit_targs=*/NULL_TREE,
6508 if (PTRMEM_OK_P (rhs))
6509 flags |= tf_ptrmem_ok;
6511 return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6515 return error_mark_node;
6520 return error_mark_node;
6523 /* Return the name of the virtual function pointer field
6524 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6525 this may have to look back through base types to find the
6526 ultimate field name. (For single inheritance, these could
6527 all be the same name. Who knows for multiple inheritance). */
6530 get_vfield_name (tree type)
6532 tree binfo, base_binfo;
6535 for (binfo = TYPE_BINFO (type);
6536 BINFO_N_BASE_BINFOS (binfo);
6539 base_binfo = BINFO_BASE_BINFO (binfo, 0);
6541 if (BINFO_VIRTUAL_P (base_binfo)
6542 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6546 type = BINFO_TYPE (binfo);
6547 buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6548 + TYPE_NAME_LENGTH (type) + 2);
6549 sprintf (buf, VFIELD_NAME_FORMAT,
6550 IDENTIFIER_POINTER (constructor_name (type)));
6551 return get_identifier (buf);
6555 print_class_statistics (void)
6557 #ifdef GATHER_STATISTICS
6558 fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6559 fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6562 fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6563 n_vtables, n_vtable_searches);
6564 fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6565 n_vtable_entries, n_vtable_elems);
6570 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6571 according to [class]:
6572 The class-name is also inserted
6573 into the scope of the class itself. For purposes of access checking,
6574 the inserted class name is treated as if it were a public member name. */
6577 build_self_reference (void)
6579 tree name = constructor_name (current_class_type);
6580 tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6583 DECL_NONLOCAL (value) = 1;
6584 DECL_CONTEXT (value) = current_class_type;
6585 DECL_ARTIFICIAL (value) = 1;
6586 SET_DECL_SELF_REFERENCE_P (value);
6587 cp_set_underlying_type (value);
6589 if (processing_template_decl)
6590 value = push_template_decl (value);
6592 saved_cas = current_access_specifier;
6593 current_access_specifier = access_public_node;
6594 finish_member_declaration (value);
6595 current_access_specifier = saved_cas;
6598 /* Returns 1 if TYPE contains only padding bytes. */
6601 is_empty_class (tree type)
6603 if (type == error_mark_node)
6606 if (! CLASS_TYPE_P (type))
6609 /* In G++ 3.2, whether or not a class was empty was determined by
6610 looking at its size. */
6611 if (abi_version_at_least (2))
6612 return CLASSTYPE_EMPTY_P (type);
6614 return integer_zerop (CLASSTYPE_SIZE (type));
6617 /* Returns true if TYPE contains an empty class. */
6620 contains_empty_class_p (tree type)
6622 if (is_empty_class (type))
6624 if (CLASS_TYPE_P (type))
6631 for (binfo = TYPE_BINFO (type), i = 0;
6632 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6633 if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6635 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6636 if (TREE_CODE (field) == FIELD_DECL
6637 && !DECL_ARTIFICIAL (field)
6638 && is_empty_class (TREE_TYPE (field)))
6641 else if (TREE_CODE (type) == ARRAY_TYPE)
6642 return contains_empty_class_p (TREE_TYPE (type));
6646 /* Returns true if TYPE contains no actual data, just various
6647 possible combinations of empty classes. */
6650 is_really_empty_class (tree type)
6652 if (is_empty_class (type))
6654 if (CLASS_TYPE_P (type))
6661 for (binfo = TYPE_BINFO (type), i = 0;
6662 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6663 if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
6665 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6666 if (TREE_CODE (field) == FIELD_DECL
6667 && !DECL_ARTIFICIAL (field)
6668 && !is_really_empty_class (TREE_TYPE (field)))
6672 else if (TREE_CODE (type) == ARRAY_TYPE)
6673 return is_really_empty_class (TREE_TYPE (type));
6677 /* Note that NAME was looked up while the current class was being
6678 defined and that the result of that lookup was DECL. */
6681 maybe_note_name_used_in_class (tree name, tree decl)
6683 splay_tree names_used;
6685 /* If we're not defining a class, there's nothing to do. */
6686 if (!(innermost_scope_kind() == sk_class
6687 && TYPE_BEING_DEFINED (current_class_type)
6688 && !LAMBDA_TYPE_P (current_class_type)))
6691 /* If there's already a binding for this NAME, then we don't have
6692 anything to worry about. */
6693 if (lookup_member (current_class_type, name,
6694 /*protect=*/0, /*want_type=*/false))
6697 if (!current_class_stack[current_class_depth - 1].names_used)
6698 current_class_stack[current_class_depth - 1].names_used
6699 = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6700 names_used = current_class_stack[current_class_depth - 1].names_used;
6702 splay_tree_insert (names_used,
6703 (splay_tree_key) name,
6704 (splay_tree_value) decl);
6707 /* Note that NAME was declared (as DECL) in the current class. Check
6708 to see that the declaration is valid. */
6711 note_name_declared_in_class (tree name, tree decl)
6713 splay_tree names_used;
6716 /* Look to see if we ever used this name. */
6718 = current_class_stack[current_class_depth - 1].names_used;
6722 n = splay_tree_lookup (names_used, (splay_tree_key) name);
6725 /* [basic.scope.class]
6727 A name N used in a class S shall refer to the same declaration
6728 in its context and when re-evaluated in the completed scope of
6730 permerror (input_location, "declaration of %q#D", decl);
6731 permerror (input_location, "changes meaning of %qD from %q+#D",
6732 DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
6736 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6737 Secondary vtables are merged with primary vtables; this function
6738 will return the VAR_DECL for the primary vtable. */
6741 get_vtbl_decl_for_binfo (tree binfo)
6745 decl = BINFO_VTABLE (binfo);
6746 if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
6748 gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6749 decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6752 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6757 /* Returns the binfo for the primary base of BINFO. If the resulting
6758 BINFO is a virtual base, and it is inherited elsewhere in the
6759 hierarchy, then the returned binfo might not be the primary base of
6760 BINFO in the complete object. Check BINFO_PRIMARY_P or
6761 BINFO_LOST_PRIMARY_P to be sure. */
6764 get_primary_binfo (tree binfo)
6768 primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6772 return copied_binfo (primary_base, binfo);
6775 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
6778 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6781 fprintf (stream, "%*s", indent, "");
6785 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6786 INDENT should be zero when called from the top level; it is
6787 incremented recursively. IGO indicates the next expected BINFO in
6788 inheritance graph ordering. */
6791 dump_class_hierarchy_r (FILE *stream,
6801 indented = maybe_indent_hierarchy (stream, indent, 0);
6802 fprintf (stream, "%s (0x%lx) ",
6803 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6804 (unsigned long) binfo);
6807 fprintf (stream, "alternative-path\n");
6810 igo = TREE_CHAIN (binfo);
6812 fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
6813 tree_low_cst (BINFO_OFFSET (binfo), 0));
6814 if (is_empty_class (BINFO_TYPE (binfo)))
6815 fprintf (stream, " empty");
6816 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
6817 fprintf (stream, " nearly-empty");
6818 if (BINFO_VIRTUAL_P (binfo))
6819 fprintf (stream, " virtual");
6820 fprintf (stream, "\n");
6823 if (BINFO_PRIMARY_P (binfo))
6825 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6826 fprintf (stream, " primary-for %s (0x%lx)",
6827 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
6828 TFF_PLAIN_IDENTIFIER),
6829 (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
6831 if (BINFO_LOST_PRIMARY_P (binfo))
6833 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6834 fprintf (stream, " lost-primary");
6837 fprintf (stream, "\n");
6839 if (!(flags & TDF_SLIM))
6843 if (BINFO_SUBVTT_INDEX (binfo))
6845 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6846 fprintf (stream, " subvttidx=%s",
6847 expr_as_string (BINFO_SUBVTT_INDEX (binfo),
6848 TFF_PLAIN_IDENTIFIER));
6850 if (BINFO_VPTR_INDEX (binfo))
6852 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6853 fprintf (stream, " vptridx=%s",
6854 expr_as_string (BINFO_VPTR_INDEX (binfo),
6855 TFF_PLAIN_IDENTIFIER));
6857 if (BINFO_VPTR_FIELD (binfo))
6859 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6860 fprintf (stream, " vbaseoffset=%s",
6861 expr_as_string (BINFO_VPTR_FIELD (binfo),
6862 TFF_PLAIN_IDENTIFIER));
6864 if (BINFO_VTABLE (binfo))
6866 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
6867 fprintf (stream, " vptr=%s",
6868 expr_as_string (BINFO_VTABLE (binfo),
6869 TFF_PLAIN_IDENTIFIER));
6873 fprintf (stream, "\n");
6876 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
6877 igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
6882 /* Dump the BINFO hierarchy for T. */
6885 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
6887 fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6888 fprintf (stream, " size=%lu align=%lu\n",
6889 (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
6890 (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
6891 fprintf (stream, " base size=%lu base align=%lu\n",
6892 (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
6894 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
6896 dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
6897 fprintf (stream, "\n");
6900 /* Debug interface to hierarchy dumping. */
6903 debug_class (tree t)
6905 dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
6909 dump_class_hierarchy (tree t)
6912 FILE *stream = dump_begin (TDI_class, &flags);
6916 dump_class_hierarchy_1 (stream, flags, t);
6917 dump_end (TDI_class, stream);
6922 dump_array (FILE * stream, tree decl)
6925 unsigned HOST_WIDE_INT ix;
6927 tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
6929 elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
6931 fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
6932 fprintf (stream, " %s entries",
6933 expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
6934 TFF_PLAIN_IDENTIFIER));
6935 fprintf (stream, "\n");
6937 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
6939 fprintf (stream, "%-4ld %s\n", (long)(ix * elt),
6940 expr_as_string (value, TFF_PLAIN_IDENTIFIER));
6944 dump_vtable (tree t, tree binfo, tree vtable)
6947 FILE *stream = dump_begin (TDI_class, &flags);
6952 if (!(flags & TDF_SLIM))
6954 int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
6956 fprintf (stream, "%s for %s",
6957 ctor_vtbl_p ? "Construction vtable" : "Vtable",
6958 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
6961 if (!BINFO_VIRTUAL_P (binfo))
6962 fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
6963 fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
6965 fprintf (stream, "\n");
6966 dump_array (stream, vtable);
6967 fprintf (stream, "\n");
6970 dump_end (TDI_class, stream);
6974 dump_vtt (tree t, tree vtt)
6977 FILE *stream = dump_begin (TDI_class, &flags);
6982 if (!(flags & TDF_SLIM))
6984 fprintf (stream, "VTT for %s\n",
6985 type_as_string (t, TFF_PLAIN_IDENTIFIER));
6986 dump_array (stream, vtt);
6987 fprintf (stream, "\n");
6990 dump_end (TDI_class, stream);
6993 /* Dump a function or thunk and its thunkees. */
6996 dump_thunk (FILE *stream, int indent, tree thunk)
6998 static const char spaces[] = " ";
6999 tree name = DECL_NAME (thunk);
7002 fprintf (stream, "%.*s%p %s %s", indent, spaces,
7004 !DECL_THUNK_P (thunk) ? "function"
7005 : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
7006 name ? IDENTIFIER_POINTER (name) : "<unset>");
7007 if (DECL_THUNK_P (thunk))
7009 HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
7010 tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
7012 fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
7013 if (!virtual_adjust)
7015 else if (DECL_THIS_THUNK_P (thunk))
7016 fprintf (stream, " vcall=" HOST_WIDE_INT_PRINT_DEC,
7017 tree_low_cst (virtual_adjust, 0));
7019 fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
7020 tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
7021 type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
7022 if (THUNK_ALIAS (thunk))
7023 fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
7025 fprintf (stream, "\n");
7026 for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
7027 dump_thunk (stream, indent + 2, thunks);
7030 /* Dump the thunks for FN. */
7033 debug_thunks (tree fn)
7035 dump_thunk (stderr, 0, fn);
7038 /* Virtual function table initialization. */
7040 /* Create all the necessary vtables for T and its base classes. */
7043 finish_vtbls (tree t)
7046 VEC(constructor_elt,gc) *v = NULL;
7047 tree vtable = BINFO_VTABLE (TYPE_BINFO (t));
7049 /* We lay out the primary and secondary vtables in one contiguous
7050 vtable. The primary vtable is first, followed by the non-virtual
7051 secondary vtables in inheritance graph order. */
7052 accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t), TYPE_BINFO (t),
7055 /* Then come the virtual bases, also in inheritance graph order. */
7056 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
7058 if (!BINFO_VIRTUAL_P (vbase))
7060 accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), vtable, t, &v);
7063 if (BINFO_VTABLE (TYPE_BINFO (t)))
7064 initialize_vtable (TYPE_BINFO (t), v);
7067 /* Initialize the vtable for BINFO with the INITS. */
7070 initialize_vtable (tree binfo, VEC(constructor_elt,gc) *inits)
7074 layout_vtable_decl (binfo, VEC_length (constructor_elt, inits));
7075 decl = get_vtbl_decl_for_binfo (binfo);
7076 initialize_artificial_var (decl, inits);
7077 dump_vtable (BINFO_TYPE (binfo), binfo, decl);
7080 /* Build the VTT (virtual table table) for T.
7081 A class requires a VTT if it has virtual bases.
7084 1 - primary virtual pointer for complete object T
7085 2 - secondary VTTs for each direct non-virtual base of T which requires a
7087 3 - secondary virtual pointers for each direct or indirect base of T which
7088 has virtual bases or is reachable via a virtual path from T.
7089 4 - secondary VTTs for each direct or indirect virtual base of T.
7091 Secondary VTTs look like complete object VTTs without part 4. */
7099 VEC(constructor_elt,gc) *inits;
7101 /* Build up the initializers for the VTT. */
7103 index = size_zero_node;
7104 build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
7106 /* If we didn't need a VTT, we're done. */
7110 /* Figure out the type of the VTT. */
7111 type = build_index_type (size_int (VEC_length (constructor_elt, inits) - 1));
7112 type = build_cplus_array_type (const_ptr_type_node, type);
7114 /* Now, build the VTT object itself. */
7115 vtt = build_vtable (t, mangle_vtt_for_type (t), type);
7116 initialize_artificial_var (vtt, inits);
7117 /* Add the VTT to the vtables list. */
7118 TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));
7119 TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
7124 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7125 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7126 and CHAIN the vtable pointer for this binfo after construction is
7127 complete. VALUE can also be another BINFO, in which case we recurse. */
7130 binfo_ctor_vtable (tree binfo)
7136 vt = BINFO_VTABLE (binfo);
7137 if (TREE_CODE (vt) == TREE_LIST)
7138 vt = TREE_VALUE (vt);
7139 if (TREE_CODE (vt) == TREE_BINFO)
7148 /* Data for secondary VTT initialization. */
7149 typedef struct secondary_vptr_vtt_init_data_s
7151 /* Is this the primary VTT? */
7154 /* Current index into the VTT. */
7157 /* Vector of initializers built up. */
7158 VEC(constructor_elt,gc) *inits;
7160 /* The type being constructed by this secondary VTT. */
7161 tree type_being_constructed;
7162 } secondary_vptr_vtt_init_data;
7164 /* Recursively build the VTT-initializer for BINFO (which is in the
7165 hierarchy dominated by T). INITS points to the end of the initializer
7166 list to date. INDEX is the VTT index where the next element will be
7167 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7168 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
7169 for virtual bases of T. When it is not so, we build the constructor
7170 vtables for the BINFO-in-T variant. */
7173 build_vtt_inits (tree binfo, tree t, VEC(constructor_elt,gc) **inits, tree *index)
7178 secondary_vptr_vtt_init_data data;
7179 int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7181 /* We only need VTTs for subobjects with virtual bases. */
7182 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7185 /* We need to use a construction vtable if this is not the primary
7189 build_ctor_vtbl_group (binfo, t);
7191 /* Record the offset in the VTT where this sub-VTT can be found. */
7192 BINFO_SUBVTT_INDEX (binfo) = *index;
7195 /* Add the address of the primary vtable for the complete object. */
7196 init = binfo_ctor_vtable (binfo);
7197 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
7200 gcc_assert (!BINFO_VPTR_INDEX (binfo));
7201 BINFO_VPTR_INDEX (binfo) = *index;
7203 *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
7205 /* Recursively add the secondary VTTs for non-virtual bases. */
7206 for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
7207 if (!BINFO_VIRTUAL_P (b))
7208 build_vtt_inits (b, t, inits, index);
7210 /* Add secondary virtual pointers for all subobjects of BINFO with
7211 either virtual bases or reachable along a virtual path, except
7212 subobjects that are non-virtual primary bases. */
7213 data.top_level_p = top_level_p;
7214 data.index = *index;
7215 data.inits = *inits;
7216 data.type_being_constructed = BINFO_TYPE (binfo);
7218 dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
7220 *index = data.index;
7222 /* data.inits might have grown as we added secondary virtual pointers.
7223 Make sure our caller knows about the new vector. */
7224 *inits = data.inits;
7227 /* Add the secondary VTTs for virtual bases in inheritance graph
7229 for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
7231 if (!BINFO_VIRTUAL_P (b))
7234 build_vtt_inits (b, t, inits, index);
7237 /* Remove the ctor vtables we created. */
7238 dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
7241 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
7242 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
7245 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
7247 secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
7249 /* We don't care about bases that don't have vtables. */
7250 if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7251 return dfs_skip_bases;
7253 /* We're only interested in proper subobjects of the type being
7255 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
7258 /* We're only interested in bases with virtual bases or reachable
7259 via a virtual path from the type being constructed. */
7260 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7261 || binfo_via_virtual (binfo, data->type_being_constructed)))
7262 return dfs_skip_bases;
7264 /* We're not interested in non-virtual primary bases. */
7265 if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
7268 /* Record the index where this secondary vptr can be found. */
7269 if (data->top_level_p)
7271 gcc_assert (!BINFO_VPTR_INDEX (binfo));
7272 BINFO_VPTR_INDEX (binfo) = data->index;
7274 if (BINFO_VIRTUAL_P (binfo))
7276 /* It's a primary virtual base, and this is not a
7277 construction vtable. Find the base this is primary of in
7278 the inheritance graph, and use that base's vtable
7280 while (BINFO_PRIMARY_P (binfo))
7281 binfo = BINFO_INHERITANCE_CHAIN (binfo);
7285 /* Add the initializer for the secondary vptr itself. */
7286 CONSTRUCTOR_APPEND_ELT (data->inits, NULL_TREE, binfo_ctor_vtable (binfo));
7288 /* Advance the vtt index. */
7289 data->index = size_binop (PLUS_EXPR, data->index,
7290 TYPE_SIZE_UNIT (ptr_type_node));
7295 /* Called from build_vtt_inits via dfs_walk. After building
7296 constructor vtables and generating the sub-vtt from them, we need
7297 to restore the BINFO_VTABLES that were scribbled on. DATA is the
7298 binfo of the base whose sub vtt was generated. */
7301 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7303 tree vtable = BINFO_VTABLE (binfo);
7305 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7306 /* If this class has no vtable, none of its bases do. */
7307 return dfs_skip_bases;
7310 /* This might be a primary base, so have no vtable in this
7314 /* If we scribbled the construction vtable vptr into BINFO, clear it
7316 if (TREE_CODE (vtable) == TREE_LIST
7317 && (TREE_PURPOSE (vtable) == (tree) data))
7318 BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
7323 /* Build the construction vtable group for BINFO which is in the
7324 hierarchy dominated by T. */
7327 build_ctor_vtbl_group (tree binfo, tree t)
7333 VEC(constructor_elt,gc) *v;
7335 /* See if we've already created this construction vtable group. */
7336 id = mangle_ctor_vtbl_for_type (t, binfo);
7337 if (IDENTIFIER_GLOBAL_VALUE (id))
7340 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
7341 /* Build a version of VTBL (with the wrong type) for use in
7342 constructing the addresses of secondary vtables in the
7343 construction vtable group. */
7344 vtbl = build_vtable (t, id, ptr_type_node);
7345 DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
7348 accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7349 binfo, vtbl, t, &v);
7351 /* Add the vtables for each of our virtual bases using the vbase in T
7353 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7355 vbase = TREE_CHAIN (vbase))
7359 if (!BINFO_VIRTUAL_P (vbase))
7361 b = copied_binfo (vbase, binfo);
7363 accumulate_vtbl_inits (b, vbase, binfo, vtbl, t, &v);
7366 /* Figure out the type of the construction vtable. */
7367 type = build_index_type (size_int (VEC_length (constructor_elt, v) - 1));
7368 type = build_cplus_array_type (vtable_entry_type, type);
7370 TREE_TYPE (vtbl) = type;
7371 DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
7372 layout_decl (vtbl, 0);
7374 /* Initialize the construction vtable. */
7375 CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7376 initialize_artificial_var (vtbl, v);
7377 dump_vtable (t, binfo, vtbl);
7380 /* Add the vtbl initializers for BINFO (and its bases other than
7381 non-virtual primaries) to the list of INITS. BINFO is in the
7382 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7383 the constructor the vtbl inits should be accumulated for. (If this
7384 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7385 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7386 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7387 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7388 but are not necessarily the same in terms of layout. */
7391 accumulate_vtbl_inits (tree binfo,
7396 VEC(constructor_elt,gc) **inits)
7400 int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7402 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7404 /* If it doesn't have a vptr, we don't do anything. */
7405 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7408 /* If we're building a construction vtable, we're not interested in
7409 subobjects that don't require construction vtables. */
7411 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7412 && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7415 /* Build the initializers for the BINFO-in-T vtable. */
7416 dfs_accumulate_vtbl_inits (binfo, orig_binfo, rtti_binfo, vtbl, t, inits);
7418 /* Walk the BINFO and its bases. We walk in preorder so that as we
7419 initialize each vtable we can figure out at what offset the
7420 secondary vtable lies from the primary vtable. We can't use
7421 dfs_walk here because we need to iterate through bases of BINFO
7422 and RTTI_BINFO simultaneously. */
7423 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7425 /* Skip virtual bases. */
7426 if (BINFO_VIRTUAL_P (base_binfo))
7428 accumulate_vtbl_inits (base_binfo,
7429 BINFO_BASE_BINFO (orig_binfo, i),
7430 rtti_binfo, vtbl, t,
7435 /* Called from accumulate_vtbl_inits. Adds the initializers for the
7436 BINFO vtable to L. */
7439 dfs_accumulate_vtbl_inits (tree binfo,
7444 VEC(constructor_elt,gc) **l)
7446 tree vtbl = NULL_TREE;
7447 int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7451 && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7453 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7454 primary virtual base. If it is not the same primary in
7455 the hierarchy of T, we'll need to generate a ctor vtable
7456 for it, to place at its location in T. If it is the same
7457 primary, we still need a VTT entry for the vtable, but it
7458 should point to the ctor vtable for the base it is a
7459 primary for within the sub-hierarchy of RTTI_BINFO.
7461 There are three possible cases:
7463 1) We are in the same place.
7464 2) We are a primary base within a lost primary virtual base of
7466 3) We are primary to something not a base of RTTI_BINFO. */
7469 tree last = NULL_TREE;
7471 /* First, look through the bases we are primary to for RTTI_BINFO
7472 or a virtual base. */
7474 while (BINFO_PRIMARY_P (b))
7476 b = BINFO_INHERITANCE_CHAIN (b);
7478 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7481 /* If we run out of primary links, keep looking down our
7482 inheritance chain; we might be an indirect primary. */
7483 for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7484 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7488 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7489 base B and it is a base of RTTI_BINFO, this is case 2. In
7490 either case, we share our vtable with LAST, i.e. the
7491 derived-most base within B of which we are a primary. */
7493 || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7494 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7495 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7496 binfo_ctor_vtable after everything's been set up. */
7499 /* Otherwise, this is case 3 and we get our own. */
7501 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7504 n_inits = VEC_length (constructor_elt, *l);
7511 /* Add the initializer for this vtable. */
7512 build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7513 &non_fn_entries, l);
7515 /* Figure out the position to which the VPTR should point. */
7516 vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, orig_vtbl);
7517 index = size_binop (PLUS_EXPR,
7518 size_int (non_fn_entries),
7519 size_int (n_inits));
7520 index = size_binop (MULT_EXPR,
7521 TYPE_SIZE_UNIT (vtable_entry_type),
7523 vtbl = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7527 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7528 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7529 straighten this out. */
7530 BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7531 else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7532 /* Throw away any unneeded intializers. */
7533 VEC_truncate (constructor_elt, *l, n_inits);
7535 /* For an ordinary vtable, set BINFO_VTABLE. */
7536 BINFO_VTABLE (binfo) = vtbl;
7539 static GTY(()) tree abort_fndecl_addr;
7541 /* Construct the initializer for BINFO's virtual function table. BINFO
7542 is part of the hierarchy dominated by T. If we're building a
7543 construction vtable, the ORIG_BINFO is the binfo we should use to
7544 find the actual function pointers to put in the vtable - but they
7545 can be overridden on the path to most-derived in the graph that
7546 ORIG_BINFO belongs. Otherwise,
7547 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7548 BINFO that should be indicated by the RTTI information in the
7549 vtable; it will be a base class of T, rather than T itself, if we
7550 are building a construction vtable.
7552 The value returned is a TREE_LIST suitable for wrapping in a
7553 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7554 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7555 number of non-function entries in the vtable.
7557 It might seem that this function should never be called with a
7558 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7559 base is always subsumed by a derived class vtable. However, when
7560 we are building construction vtables, we do build vtables for
7561 primary bases; we need these while the primary base is being
7565 build_vtbl_initializer (tree binfo,
7569 int* non_fn_entries_p,
7570 VEC(constructor_elt,gc) **inits)
7576 VEC(tree,gc) *vbases;
7579 /* Initialize VID. */
7580 memset (&vid, 0, sizeof (vid));
7583 vid.rtti_binfo = rtti_binfo;
7584 vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7585 vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7586 vid.generate_vcall_entries = true;
7587 /* The first vbase or vcall offset is at index -3 in the vtable. */
7588 vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7590 /* Add entries to the vtable for RTTI. */
7591 build_rtti_vtbl_entries (binfo, &vid);
7593 /* Create an array for keeping track of the functions we've
7594 processed. When we see multiple functions with the same
7595 signature, we share the vcall offsets. */
7596 vid.fns = VEC_alloc (tree, gc, 32);
7597 /* Add the vcall and vbase offset entries. */
7598 build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7600 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7601 build_vbase_offset_vtbl_entries. */
7602 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7603 VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7604 BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7606 /* If the target requires padding between data entries, add that now. */
7607 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7609 int n_entries = VEC_length (constructor_elt, vid.inits);
7611 VEC_safe_grow (constructor_elt, gc, vid.inits,
7612 TARGET_VTABLE_DATA_ENTRY_DISTANCE * n_entries);
7614 /* Move data entries into their new positions and add padding
7615 after the new positions. Iterate backwards so we don't
7616 overwrite entries that we would need to process later. */
7617 for (ix = n_entries - 1;
7618 VEC_iterate (constructor_elt, vid.inits, ix, e);
7622 int new_position = TARGET_VTABLE_DATA_ENTRY_DISTANCE * ix;
7624 VEC_replace (constructor_elt, vid.inits, new_position, e);
7626 for (j = 1; j < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++j)
7628 constructor_elt *f = VEC_index (constructor_elt, *inits,
7630 f->index = NULL_TREE;
7631 f->value = build1 (NOP_EXPR, vtable_entry_type,
7637 if (non_fn_entries_p)
7638 *non_fn_entries_p = VEC_length (constructor_elt, vid.inits);
7640 /* The initializers for virtual functions were built up in reverse
7641 order. Straighten them out and add them to the running list in one
7643 jx = VEC_length (constructor_elt, *inits);
7644 VEC_safe_grow (constructor_elt, gc, *inits,
7645 (jx + VEC_length (constructor_elt, vid.inits)));
7647 for (ix = VEC_length (constructor_elt, vid.inits) - 1;
7648 VEC_iterate (constructor_elt, vid.inits, ix, e);
7650 VEC_replace (constructor_elt, *inits, jx, e);
7652 /* Go through all the ordinary virtual functions, building up
7654 for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7658 tree fn, fn_original;
7659 tree init = NULL_TREE;
7663 if (DECL_THUNK_P (fn))
7665 if (!DECL_NAME (fn))
7667 if (THUNK_ALIAS (fn))
7669 fn = THUNK_ALIAS (fn);
7672 fn_original = THUNK_TARGET (fn);
7675 /* If the only definition of this function signature along our
7676 primary base chain is from a lost primary, this vtable slot will
7677 never be used, so just zero it out. This is important to avoid
7678 requiring extra thunks which cannot be generated with the function.
7680 We first check this in update_vtable_entry_for_fn, so we handle
7681 restored primary bases properly; we also need to do it here so we
7682 zero out unused slots in ctor vtables, rather than filling them
7683 with erroneous values (though harmless, apart from relocation
7685 for (b = binfo; ; b = get_primary_binfo (b))
7687 /* We found a defn before a lost primary; go ahead as normal. */
7688 if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7691 /* The nearest definition is from a lost primary; clear the
7693 if (BINFO_LOST_PRIMARY_P (b))
7695 init = size_zero_node;
7702 /* Pull the offset for `this', and the function to call, out of
7704 delta = BV_DELTA (v);
7705 vcall_index = BV_VCALL_INDEX (v);
7707 gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7708 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7710 /* You can't call an abstract virtual function; it's abstract.
7711 So, we replace these functions with __pure_virtual. */
7712 if (DECL_PURE_VIRTUAL_P (fn_original))
7715 if (abort_fndecl_addr == NULL)
7716 abort_fndecl_addr = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7717 init = abort_fndecl_addr;
7721 if (!integer_zerop (delta) || vcall_index)
7723 fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7724 if (!DECL_NAME (fn))
7727 /* Take the address of the function, considering it to be of an
7728 appropriate generic type. */
7729 init = build1 (ADDR_EXPR, vfunc_ptr_type_node, fn);
7733 /* And add it to the chain of initializers. */
7734 if (TARGET_VTABLE_USES_DESCRIPTORS)
7737 if (init == size_zero_node)
7738 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7739 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
7741 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7743 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7744 TREE_OPERAND (init, 0),
7745 build_int_cst (NULL_TREE, i));
7746 TREE_CONSTANT (fdesc) = 1;
7748 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, fdesc);
7752 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
7756 /* Adds to vid->inits the initializers for the vbase and vcall
7757 offsets in BINFO, which is in the hierarchy dominated by T. */
7760 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7764 /* If this is a derived class, we must first create entries
7765 corresponding to the primary base class. */
7766 b = get_primary_binfo (binfo);
7768 build_vcall_and_vbase_vtbl_entries (b, vid);
7770 /* Add the vbase entries for this base. */
7771 build_vbase_offset_vtbl_entries (binfo, vid);
7772 /* Add the vcall entries for this base. */
7773 build_vcall_offset_vtbl_entries (binfo, vid);
7776 /* Returns the initializers for the vbase offset entries in the vtable
7777 for BINFO (which is part of the class hierarchy dominated by T), in
7778 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7779 where the next vbase offset will go. */
7782 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7786 tree non_primary_binfo;
7788 /* If there are no virtual baseclasses, then there is nothing to
7790 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7795 /* We might be a primary base class. Go up the inheritance hierarchy
7796 until we find the most derived class of which we are a primary base:
7797 it is the offset of that which we need to use. */
7798 non_primary_binfo = binfo;
7799 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7803 /* If we have reached a virtual base, then it must be a primary
7804 base (possibly multi-level) of vid->binfo, or we wouldn't
7805 have called build_vcall_and_vbase_vtbl_entries for it. But it
7806 might be a lost primary, so just skip down to vid->binfo. */
7807 if (BINFO_VIRTUAL_P (non_primary_binfo))
7809 non_primary_binfo = vid->binfo;
7813 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7814 if (get_primary_binfo (b) != non_primary_binfo)
7816 non_primary_binfo = b;
7819 /* Go through the virtual bases, adding the offsets. */
7820 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7822 vbase = TREE_CHAIN (vbase))
7827 if (!BINFO_VIRTUAL_P (vbase))
7830 /* Find the instance of this virtual base in the complete
7832 b = copied_binfo (vbase, binfo);
7834 /* If we've already got an offset for this virtual base, we
7835 don't need another one. */
7836 if (BINFO_VTABLE_PATH_MARKED (b))
7838 BINFO_VTABLE_PATH_MARKED (b) = 1;
7840 /* Figure out where we can find this vbase offset. */
7841 delta = size_binop (MULT_EXPR,
7844 TYPE_SIZE_UNIT (vtable_entry_type)));
7845 if (vid->primary_vtbl_p)
7846 BINFO_VPTR_FIELD (b) = delta;
7848 if (binfo != TYPE_BINFO (t))
7849 /* The vbase offset had better be the same. */
7850 gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
7852 /* The next vbase will come at a more negative offset. */
7853 vid->index = size_binop (MINUS_EXPR, vid->index,
7854 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7856 /* The initializer is the delta from BINFO to this virtual base.
7857 The vbase offsets go in reverse inheritance-graph order, and
7858 we are walking in inheritance graph order so these end up in
7860 delta = size_diffop_loc (input_location,
7861 BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7863 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE,
7864 fold_build1_loc (input_location, NOP_EXPR,
7865 vtable_entry_type, delta));
7869 /* Adds the initializers for the vcall offset entries in the vtable
7870 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7874 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7876 /* We only need these entries if this base is a virtual base. We
7877 compute the indices -- but do not add to the vtable -- when
7878 building the main vtable for a class. */
7879 if (binfo == TYPE_BINFO (vid->derived)
7880 || (BINFO_VIRTUAL_P (binfo)
7881 /* If BINFO is RTTI_BINFO, then (since BINFO does not
7882 correspond to VID->DERIVED), we are building a primary
7883 construction virtual table. Since this is a primary
7884 virtual table, we do not need the vcall offsets for
7886 && binfo != vid->rtti_binfo))
7888 /* We need a vcall offset for each of the virtual functions in this
7889 vtable. For example:
7891 class A { virtual void f (); };
7892 class B1 : virtual public A { virtual void f (); };
7893 class B2 : virtual public A { virtual void f (); };
7894 class C: public B1, public B2 { virtual void f (); };
7896 A C object has a primary base of B1, which has a primary base of A. A
7897 C also has a secondary base of B2, which no longer has a primary base
7898 of A. So the B2-in-C construction vtable needs a secondary vtable for
7899 A, which will adjust the A* to a B2* to call f. We have no way of
7900 knowing what (or even whether) this offset will be when we define B2,
7901 so we store this "vcall offset" in the A sub-vtable and look it up in
7902 a "virtual thunk" for B2::f.
7904 We need entries for all the functions in our primary vtable and
7905 in our non-virtual bases' secondary vtables. */
7907 /* If we are just computing the vcall indices -- but do not need
7908 the actual entries -- not that. */
7909 if (!BINFO_VIRTUAL_P (binfo))
7910 vid->generate_vcall_entries = false;
7911 /* Now, walk through the non-virtual bases, adding vcall offsets. */
7912 add_vcall_offset_vtbl_entries_r (binfo, vid);
7916 /* Build vcall offsets, starting with those for BINFO. */
7919 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
7925 /* Don't walk into virtual bases -- except, of course, for the
7926 virtual base for which we are building vcall offsets. Any
7927 primary virtual base will have already had its offsets generated
7928 through the recursion in build_vcall_and_vbase_vtbl_entries. */
7929 if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
7932 /* If BINFO has a primary base, process it first. */
7933 primary_binfo = get_primary_binfo (binfo);
7935 add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7937 /* Add BINFO itself to the list. */
7938 add_vcall_offset_vtbl_entries_1 (binfo, vid);
7940 /* Scan the non-primary bases of BINFO. */
7941 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7942 if (base_binfo != primary_binfo)
7943 add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7946 /* Called from build_vcall_offset_vtbl_entries_r. */
7949 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
7951 /* Make entries for the rest of the virtuals. */
7952 if (abi_version_at_least (2))
7956 /* The ABI requires that the methods be processed in declaration
7957 order. G++ 3.2 used the order in the vtable. */
7958 for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7960 orig_fn = TREE_CHAIN (orig_fn))
7961 if (DECL_VINDEX (orig_fn))
7962 add_vcall_offset (orig_fn, binfo, vid);
7966 tree derived_virtuals;
7969 /* If BINFO is a primary base, the most derived class which has
7970 BINFO as a primary base; otherwise, just BINFO. */
7971 tree non_primary_binfo;
7973 /* We might be a primary base class. Go up the inheritance hierarchy
7974 until we find the most derived class of which we are a primary base:
7975 it is the BINFO_VIRTUALS there that we need to consider. */
7976 non_primary_binfo = binfo;
7977 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7981 /* If we have reached a virtual base, then it must be vid->vbase,
7982 because we ignore other virtual bases in
7983 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
7984 base (possibly multi-level) of vid->binfo, or we wouldn't
7985 have called build_vcall_and_vbase_vtbl_entries for it. But it
7986 might be a lost primary, so just skip down to vid->binfo. */
7987 if (BINFO_VIRTUAL_P (non_primary_binfo))
7989 gcc_assert (non_primary_binfo == vid->vbase);
7990 non_primary_binfo = vid->binfo;
7994 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7995 if (get_primary_binfo (b) != non_primary_binfo)
7997 non_primary_binfo = b;
8000 if (vid->ctor_vtbl_p)
8001 /* For a ctor vtable we need the equivalent binfo within the hierarchy
8002 where rtti_binfo is the most derived type. */
8004 = original_binfo (non_primary_binfo, vid->rtti_binfo);
8006 for (base_virtuals = BINFO_VIRTUALS (binfo),
8007 derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
8008 orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
8010 base_virtuals = TREE_CHAIN (base_virtuals),
8011 derived_virtuals = TREE_CHAIN (derived_virtuals),
8012 orig_virtuals = TREE_CHAIN (orig_virtuals))
8016 /* Find the declaration that originally caused this function to
8017 be present in BINFO_TYPE (binfo). */
8018 orig_fn = BV_FN (orig_virtuals);
8020 /* When processing BINFO, we only want to generate vcall slots for
8021 function slots introduced in BINFO. So don't try to generate
8022 one if the function isn't even defined in BINFO. */
8023 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
8026 add_vcall_offset (orig_fn, binfo, vid);
8031 /* Add a vcall offset entry for ORIG_FN to the vtable. */
8034 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
8040 /* If there is already an entry for a function with the same
8041 signature as FN, then we do not need a second vcall offset.
8042 Check the list of functions already present in the derived
8044 for (i = 0; VEC_iterate (tree, vid->fns, i, derived_entry); ++i)
8046 if (same_signature_p (derived_entry, orig_fn)
8047 /* We only use one vcall offset for virtual destructors,
8048 even though there are two virtual table entries. */
8049 || (DECL_DESTRUCTOR_P (derived_entry)
8050 && DECL_DESTRUCTOR_P (orig_fn)))
8054 /* If we are building these vcall offsets as part of building
8055 the vtable for the most derived class, remember the vcall
8057 if (vid->binfo == TYPE_BINFO (vid->derived))
8059 tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
8060 CLASSTYPE_VCALL_INDICES (vid->derived),
8062 elt->purpose = orig_fn;
8063 elt->value = vid->index;
8066 /* The next vcall offset will be found at a more negative
8068 vid->index = size_binop (MINUS_EXPR, vid->index,
8069 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
8071 /* Keep track of this function. */
8072 VEC_safe_push (tree, gc, vid->fns, orig_fn);
8074 if (vid->generate_vcall_entries)
8079 /* Find the overriding function. */
8080 fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
8081 if (fn == error_mark_node)
8082 vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
8086 base = TREE_VALUE (fn);
8088 /* The vbase we're working on is a primary base of
8089 vid->binfo. But it might be a lost primary, so its
8090 BINFO_OFFSET might be wrong, so we just use the
8091 BINFO_OFFSET from vid->binfo. */
8092 vcall_offset = size_diffop_loc (input_location,
8093 BINFO_OFFSET (base),
8094 BINFO_OFFSET (vid->binfo));
8095 vcall_offset = fold_build1_loc (input_location,
8096 NOP_EXPR, vtable_entry_type,
8099 /* Add the initializer to the vtable. */
8100 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, vcall_offset);
8104 /* Return vtbl initializers for the RTTI entries corresponding to the
8105 BINFO's vtable. The RTTI entries should indicate the object given
8106 by VID->rtti_binfo. */
8109 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
8117 t = BINFO_TYPE (vid->rtti_binfo);
8119 /* To find the complete object, we will first convert to our most
8120 primary base, and then add the offset in the vtbl to that value. */
8122 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
8123 && !BINFO_LOST_PRIMARY_P (b))
8127 primary_base = get_primary_binfo (b);
8128 gcc_assert (BINFO_PRIMARY_P (primary_base)
8129 && BINFO_INHERITANCE_CHAIN (primary_base) == b);
8132 offset = size_diffop_loc (input_location,
8133 BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
8135 /* The second entry is the address of the typeinfo object. */
8137 decl = build_address (get_tinfo_decl (t));
8139 decl = integer_zero_node;
8141 /* Convert the declaration to a type that can be stored in the
8143 init = build_nop (vfunc_ptr_type_node, decl);
8144 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
8146 /* Add the offset-to-top entry. It comes earlier in the vtable than
8147 the typeinfo entry. Convert the offset to look like a
8148 function pointer, so that we can put it in the vtable. */
8149 init = build_nop (vfunc_ptr_type_node, offset);
8150 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
8153 /* Fold a OBJ_TYPE_REF expression to the address of a function.
8154 KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). */
8157 cp_fold_obj_type_ref (tree ref, tree known_type)
8159 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
8160 HOST_WIDE_INT i = 0;
8161 tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
8166 i += (TARGET_VTABLE_USES_DESCRIPTORS
8167 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
8173 #ifdef ENABLE_CHECKING
8174 gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
8175 DECL_VINDEX (fndecl)));
8178 cgraph_node (fndecl)->local.vtable_method = true;
8180 return build_address (fndecl);
8183 #include "gt-cp-class.h"