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_addr_expr (expr, tf_warning_or_error);
287 expr = mark_rvalue_use (expr);
289 offset = BINFO_OFFSET (binfo);
290 fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
291 target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);
293 /* Do we need to look in the vtable for the real offset? */
294 virtual_access = (v_binfo && fixed_type_p <= 0);
296 /* Don't bother with the calculations inside sizeof; they'll ICE if the
297 source type is incomplete and the pointer value doesn't matter. */
298 if (cp_unevaluated_operand != 0)
300 expr = build_nop (build_pointer_type (target_type), expr);
302 expr = build_indirect_ref (EXPR_LOCATION (expr), expr, RO_NULL);
306 /* Do we need to check for a null pointer? */
307 if (want_pointer && !nonnull)
309 /* If we know the conversion will not actually change the value
310 of EXPR, then we can avoid testing the expression for NULL.
311 We have to avoid generating a COMPONENT_REF for a base class
312 field, because other parts of the compiler know that such
313 expressions are always non-NULL. */
314 if (!virtual_access && integer_zerop (offset))
317 /* TARGET_TYPE has been extracted from BINFO, and, is
318 therefore always cv-unqualified. Extract the
319 cv-qualifiers from EXPR so that the expression returned
320 matches the input. */
321 class_type = TREE_TYPE (TREE_TYPE (expr));
323 = cp_build_qualified_type (target_type,
324 cp_type_quals (class_type));
325 return build_nop (build_pointer_type (target_type), expr);
327 null_test = error_mark_node;
330 /* Protect against multiple evaluation if necessary. */
331 if (TREE_SIDE_EFFECTS (expr) && (null_test || virtual_access))
332 expr = save_expr (expr);
334 /* Now that we've saved expr, build the real null test. */
337 tree zero = cp_convert (TREE_TYPE (expr), integer_zero_node);
338 null_test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
342 /* If this is a simple base reference, express it as a COMPONENT_REF. */
343 if (code == PLUS_EXPR && !virtual_access
344 /* We don't build base fields for empty bases, and they aren't very
345 interesting to the optimizers anyway. */
348 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
349 expr = build_simple_base_path (expr, binfo);
351 expr = build_address (expr);
352 target_type = TREE_TYPE (expr);
358 /* Going via virtual base V_BINFO. We need the static offset
359 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
360 V_BINFO. That offset is an entry in D_BINFO's vtable. */
363 if (fixed_type_p < 0 && in_base_initializer)
365 /* In a base member initializer, we cannot rely on the
366 vtable being set up. We have to indirect via the
370 t = TREE_TYPE (TYPE_VFIELD (current_class_type));
371 t = build_pointer_type (t);
372 v_offset = convert (t, current_vtt_parm);
373 v_offset = cp_build_indirect_ref (v_offset, RO_NULL,
374 tf_warning_or_error);
377 v_offset = build_vfield_ref (cp_build_indirect_ref (expr, RO_NULL,
378 tf_warning_or_error),
379 TREE_TYPE (TREE_TYPE (expr)));
381 v_offset = build2 (POINTER_PLUS_EXPR, TREE_TYPE (v_offset),
382 v_offset, fold_convert (sizetype, BINFO_VPTR_FIELD (v_binfo)));
383 v_offset = build1 (NOP_EXPR,
384 build_pointer_type (ptrdiff_type_node),
386 v_offset = cp_build_indirect_ref (v_offset, RO_NULL, tf_warning_or_error);
387 TREE_CONSTANT (v_offset) = 1;
389 offset = convert_to_integer (ptrdiff_type_node,
390 size_diffop_loc (input_location, offset,
391 BINFO_OFFSET (v_binfo)));
393 if (!integer_zerop (offset))
394 v_offset = build2 (code, ptrdiff_type_node, v_offset, offset);
396 if (fixed_type_p < 0)
397 /* Negative fixed_type_p means this is a constructor or destructor;
398 virtual base layout is fixed in in-charge [cd]tors, but not in
400 offset = build3 (COND_EXPR, ptrdiff_type_node,
401 build2 (EQ_EXPR, boolean_type_node,
402 current_in_charge_parm, integer_zero_node),
404 convert_to_integer (ptrdiff_type_node,
405 BINFO_OFFSET (binfo)));
410 target_type = cp_build_qualified_type
411 (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr))));
412 ptr_target_type = build_pointer_type (target_type);
414 target_type = ptr_target_type;
416 expr = build1 (NOP_EXPR, ptr_target_type, expr);
418 if (!integer_zerop (offset))
420 offset = fold_convert (sizetype, offset);
421 if (code == MINUS_EXPR)
422 offset = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, offset);
423 expr = build2 (POINTER_PLUS_EXPR, ptr_target_type, expr, offset);
429 expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error);
433 expr = fold_build3_loc (input_location, COND_EXPR, target_type, null_test, expr,
434 fold_build1_loc (input_location, NOP_EXPR, target_type,
440 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
441 Perform a derived-to-base conversion by recursively building up a
442 sequence of COMPONENT_REFs to the appropriate base fields. */
445 build_simple_base_path (tree expr, tree binfo)
447 tree type = BINFO_TYPE (binfo);
448 tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo);
451 if (d_binfo == NULL_TREE)
455 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type);
457 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
458 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
459 an lvalue in the front end; only _DECLs and _REFs are lvalues
461 temp = unary_complex_lvalue (ADDR_EXPR, expr);
463 expr = cp_build_indirect_ref (temp, RO_NULL, tf_warning_or_error);
469 expr = build_simple_base_path (expr, d_binfo);
471 for (field = TYPE_FIELDS (BINFO_TYPE (d_binfo));
472 field; field = DECL_CHAIN (field))
473 /* Is this the base field created by build_base_field? */
474 if (TREE_CODE (field) == FIELD_DECL
475 && DECL_FIELD_IS_BASE (field)
476 && TREE_TYPE (field) == type)
478 /* We don't use build_class_member_access_expr here, as that
479 has unnecessary checks, and more importantly results in
480 recursive calls to dfs_walk_once. */
481 int type_quals = cp_type_quals (TREE_TYPE (expr));
483 expr = build3 (COMPONENT_REF,
484 cp_build_qualified_type (type, type_quals),
485 expr, field, NULL_TREE);
486 expr = fold_if_not_in_template (expr);
488 /* Mark the expression const or volatile, as appropriate.
489 Even though we've dealt with the type above, we still have
490 to mark the expression itself. */
491 if (type_quals & TYPE_QUAL_CONST)
492 TREE_READONLY (expr) = 1;
493 if (type_quals & TYPE_QUAL_VOLATILE)
494 TREE_THIS_VOLATILE (expr) = 1;
499 /* Didn't find the base field?!? */
503 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
504 type is a class type or a pointer to a class type. In the former
505 case, TYPE is also a class type; in the latter it is another
506 pointer type. If CHECK_ACCESS is true, an error message is emitted
507 if TYPE is inaccessible. If OBJECT has pointer type, the value is
508 assumed to be non-NULL. */
511 convert_to_base (tree object, tree type, bool check_access, bool nonnull,
512 tsubst_flags_t complain)
518 if (TYPE_PTR_P (TREE_TYPE (object)))
520 object_type = TREE_TYPE (TREE_TYPE (object));
521 type = TREE_TYPE (type);
524 object_type = TREE_TYPE (object);
526 access = check_access ? ba_check : ba_unique;
527 if (!(complain & tf_error))
529 binfo = lookup_base (object_type, type,
532 if (!binfo || binfo == error_mark_node)
533 return error_mark_node;
535 return build_base_path (PLUS_EXPR, object, binfo, nonnull);
538 /* EXPR is an expression with unqualified class type. BASE is a base
539 binfo of that class type. Returns EXPR, converted to the BASE
540 type. This function assumes that EXPR is the most derived class;
541 therefore virtual bases can be found at their static offsets. */
544 convert_to_base_statically (tree expr, tree base)
548 expr_type = TREE_TYPE (expr);
549 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base), expr_type))
553 pointer_type = build_pointer_type (expr_type);
555 /* We use fold_build2 and fold_convert below to simplify the trees
556 provided to the optimizers. It is not safe to call these functions
557 when processing a template because they do not handle C++-specific
559 gcc_assert (!processing_template_decl);
560 expr = cp_build_addr_expr (expr, tf_warning_or_error);
561 if (!integer_zerop (BINFO_OFFSET (base)))
562 expr = fold_build2_loc (input_location,
563 POINTER_PLUS_EXPR, pointer_type, expr,
564 fold_convert (sizetype, BINFO_OFFSET (base)));
565 expr = fold_convert (build_pointer_type (BINFO_TYPE (base)), expr);
566 expr = build_fold_indirect_ref_loc (input_location, expr);
574 build_vfield_ref (tree datum, tree type)
576 tree vfield, vcontext;
578 if (datum == error_mark_node)
579 return error_mark_node;
581 /* First, convert to the requested type. */
582 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))
583 datum = convert_to_base (datum, type, /*check_access=*/false,
584 /*nonnull=*/true, tf_warning_or_error);
586 /* Second, the requested type may not be the owner of its own vptr.
587 If not, convert to the base class that owns it. We cannot use
588 convert_to_base here, because VCONTEXT may appear more than once
589 in the inheritance hierarchy of TYPE, and thus direct conversion
590 between the types may be ambiguous. Following the path back up
591 one step at a time via primary bases avoids the problem. */
592 vfield = TYPE_VFIELD (type);
593 vcontext = DECL_CONTEXT (vfield);
594 while (!same_type_ignoring_top_level_qualifiers_p (vcontext, type))
596 datum = build_simple_base_path (datum, CLASSTYPE_PRIMARY_BINFO (type));
597 type = TREE_TYPE (datum);
600 return build3 (COMPONENT_REF, TREE_TYPE (vfield), datum, vfield, NULL_TREE);
603 /* Given an object INSTANCE, return an expression which yields the
604 vtable element corresponding to INDEX. There are many special
605 cases for INSTANCE which we take care of here, mainly to avoid
606 creating extra tree nodes when we don't have to. */
609 build_vtbl_ref_1 (tree instance, tree idx)
612 tree vtbl = NULL_TREE;
614 /* Try to figure out what a reference refers to, and
615 access its virtual function table directly. */
618 tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp);
620 tree basetype = non_reference (TREE_TYPE (instance));
622 if (fixed_type && !cdtorp)
624 tree binfo = lookup_base (fixed_type, basetype,
625 ba_unique | ba_quiet, NULL);
627 vtbl = unshare_expr (BINFO_VTABLE (binfo));
631 vtbl = build_vfield_ref (instance, basetype);
633 aref = build_array_ref (input_location, vtbl, idx);
634 TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx);
640 build_vtbl_ref (tree instance, tree idx)
642 tree aref = build_vtbl_ref_1 (instance, idx);
647 /* Given a stable object pointer INSTANCE_PTR, return an expression which
648 yields a function pointer corresponding to vtable element INDEX. */
651 build_vfn_ref (tree instance_ptr, tree idx)
655 aref = build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr, RO_NULL,
656 tf_warning_or_error),
659 /* When using function descriptors, the address of the
660 vtable entry is treated as a function pointer. */
661 if (TARGET_VTABLE_USES_DESCRIPTORS)
662 aref = build1 (NOP_EXPR, TREE_TYPE (aref),
663 cp_build_addr_expr (aref, 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 = DECL_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 /* If any base class is non-literal, so is the derived class. */
1273 if (!CLASSTYPE_LITERAL_P (basetype))
1274 CLASSTYPE_LITERAL_P (t) = false;
1276 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1277 here because the case of virtual functions but non-virtual
1278 dtor is handled in finish_struct_1. */
1279 if (!TYPE_POLYMORPHIC_P (basetype))
1280 warning (OPT_Weffc__,
1281 "base class %q#T has a non-virtual destructor", basetype);
1283 /* If the base class doesn't have copy constructors or
1284 assignment operators that take const references, then the
1285 derived class cannot have such a member automatically
1287 if (TYPE_HAS_COPY_CTOR (basetype)
1288 && ! TYPE_HAS_CONST_COPY_CTOR (basetype))
1289 *cant_have_const_ctor_p = 1;
1290 if (TYPE_HAS_COPY_ASSIGN (basetype)
1291 && !TYPE_HAS_CONST_COPY_ASSIGN (basetype))
1292 *no_const_asn_ref_p = 1;
1294 if (BINFO_VIRTUAL_P (base_binfo))
1295 /* A virtual base does not effect nearly emptiness. */
1297 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
1299 if (seen_non_virtual_nearly_empty_base_p)
1300 /* And if there is more than one nearly empty base, then the
1301 derived class is not nearly empty either. */
1302 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1304 /* Remember we've seen one. */
1305 seen_non_virtual_nearly_empty_base_p = 1;
1307 else if (!is_empty_class (basetype))
1308 /* If the base class is not empty or nearly empty, then this
1309 class cannot be nearly empty. */
1310 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
1312 /* A lot of properties from the bases also apply to the derived
1314 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1315 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
1316 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype);
1317 TYPE_HAS_COMPLEX_COPY_ASSIGN (t)
1318 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (basetype)
1319 || !TYPE_HAS_COPY_ASSIGN (basetype));
1320 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= (TYPE_HAS_COMPLEX_COPY_CTOR (basetype)
1321 || !TYPE_HAS_COPY_CTOR (basetype));
1322 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
1323 |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (basetype);
1324 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_HAS_COMPLEX_MOVE_CTOR (basetype);
1325 TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype);
1326 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)
1327 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype);
1328 TYPE_HAS_COMPLEX_DFLT (t) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype)
1329 || TYPE_HAS_COMPLEX_DFLT (basetype));
1331 /* A standard-layout class is a class that:
1333 * has no non-standard-layout base classes, */
1334 CLASSTYPE_NON_STD_LAYOUT (t) |= CLASSTYPE_NON_STD_LAYOUT (basetype);
1335 if (!CLASSTYPE_NON_STD_LAYOUT (t))
1338 /* ...has no base classes of the same type as the first non-static
1340 if (field && DECL_CONTEXT (field) == t
1341 && (same_type_ignoring_top_level_qualifiers_p
1342 (TREE_TYPE (field), basetype)))
1343 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
1345 /* ...either has no non-static data members in the most-derived
1346 class and at most one base class with non-static data
1347 members, or has no base classes with non-static data
1349 for (basefield = TYPE_FIELDS (basetype); basefield;
1350 basefield = DECL_CHAIN (basefield))
1351 if (TREE_CODE (basefield) == FIELD_DECL)
1354 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
1363 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1364 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1365 that have had a nearly-empty virtual primary base stolen by some
1366 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1370 determine_primary_bases (tree t)
1373 tree primary = NULL_TREE;
1374 tree type_binfo = TYPE_BINFO (t);
1377 /* Determine the primary bases of our bases. */
1378 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1379 base_binfo = TREE_CHAIN (base_binfo))
1381 tree primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo));
1383 /* See if we're the non-virtual primary of our inheritance
1385 if (!BINFO_VIRTUAL_P (base_binfo))
1387 tree parent = BINFO_INHERITANCE_CHAIN (base_binfo);
1388 tree parent_primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent));
1391 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo),
1392 BINFO_TYPE (parent_primary)))
1393 /* We are the primary binfo. */
1394 BINFO_PRIMARY_P (base_binfo) = 1;
1396 /* Determine if we have a virtual primary base, and mark it so.
1398 if (primary && BINFO_VIRTUAL_P (primary))
1400 tree this_primary = copied_binfo (primary, base_binfo);
1402 if (BINFO_PRIMARY_P (this_primary))
1403 /* Someone already claimed this base. */
1404 BINFO_LOST_PRIMARY_P (base_binfo) = 1;
1409 BINFO_PRIMARY_P (this_primary) = 1;
1410 BINFO_INHERITANCE_CHAIN (this_primary) = base_binfo;
1412 /* A virtual binfo might have been copied from within
1413 another hierarchy. As we're about to use it as a
1414 primary base, make sure the offsets match. */
1415 delta = size_diffop_loc (input_location,
1417 BINFO_OFFSET (base_binfo)),
1419 BINFO_OFFSET (this_primary)));
1421 propagate_binfo_offsets (this_primary, delta);
1426 /* First look for a dynamic direct non-virtual base. */
1427 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, base_binfo); i++)
1429 tree basetype = BINFO_TYPE (base_binfo);
1431 if (TYPE_CONTAINS_VPTR_P (basetype) && !BINFO_VIRTUAL_P (base_binfo))
1433 primary = base_binfo;
1438 /* A "nearly-empty" virtual base class can be the primary base
1439 class, if no non-virtual polymorphic base can be found. Look for
1440 a nearly-empty virtual dynamic base that is not already a primary
1441 base of something in the hierarchy. If there is no such base,
1442 just pick the first nearly-empty virtual base. */
1444 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo;
1445 base_binfo = TREE_CHAIN (base_binfo))
1446 if (BINFO_VIRTUAL_P (base_binfo)
1447 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo)))
1449 if (!BINFO_PRIMARY_P (base_binfo))
1451 /* Found one that is not primary. */
1452 primary = base_binfo;
1456 /* Remember the first candidate. */
1457 primary = base_binfo;
1461 /* If we've got a primary base, use it. */
1464 tree basetype = BINFO_TYPE (primary);
1466 CLASSTYPE_PRIMARY_BINFO (t) = primary;
1467 if (BINFO_PRIMARY_P (primary))
1468 /* We are stealing a primary base. */
1469 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary)) = 1;
1470 BINFO_PRIMARY_P (primary) = 1;
1471 if (BINFO_VIRTUAL_P (primary))
1475 BINFO_INHERITANCE_CHAIN (primary) = type_binfo;
1476 /* A virtual binfo might have been copied from within
1477 another hierarchy. As we're about to use it as a primary
1478 base, make sure the offsets match. */
1479 delta = size_diffop_loc (input_location, ssize_int (0),
1480 convert (ssizetype, BINFO_OFFSET (primary)));
1482 propagate_binfo_offsets (primary, delta);
1485 primary = TYPE_BINFO (basetype);
1487 TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1488 BINFO_VTABLE (type_binfo) = BINFO_VTABLE (primary);
1489 BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary);
1493 /* Update the variant types of T. */
1496 fixup_type_variants (tree t)
1503 for (variants = TYPE_NEXT_VARIANT (t);
1505 variants = TYPE_NEXT_VARIANT (variants))
1507 /* These fields are in the _TYPE part of the node, not in
1508 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1509 TYPE_HAS_USER_CONSTRUCTOR (variants) = TYPE_HAS_USER_CONSTRUCTOR (t);
1510 TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1511 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants)
1512 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
1514 TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t);
1516 TYPE_BINFO (variants) = TYPE_BINFO (t);
1518 /* Copy whatever these are holding today. */
1519 TYPE_VFIELD (variants) = TYPE_VFIELD (t);
1520 TYPE_METHODS (variants) = TYPE_METHODS (t);
1521 TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1525 /* Early variant fixups: we apply attributes at the beginning of the class
1526 definition, and we need to fix up any variants that have already been
1527 made via elaborated-type-specifier so that check_qualified_type works. */
1530 fixup_attribute_variants (tree t)
1537 for (variants = TYPE_NEXT_VARIANT (t);
1539 variants = TYPE_NEXT_VARIANT (variants))
1541 /* These are the two fields that check_qualified_type looks at and
1542 are affected by attributes. */
1543 TYPE_ATTRIBUTES (variants) = TYPE_ATTRIBUTES (t);
1544 TYPE_ALIGN (variants) = TYPE_ALIGN (t);
1548 /* Set memoizing fields and bits of T (and its variants) for later
1552 finish_struct_bits (tree t)
1554 /* Fix up variants (if any). */
1555 fixup_type_variants (t);
1557 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t))
1558 /* For a class w/o baseclasses, 'finish_struct' has set
1559 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1560 Similarly for a class whose base classes do not have vtables.
1561 When neither of these is true, we might have removed abstract
1562 virtuals (by providing a definition), added some (by declaring
1563 new ones), or redeclared ones from a base class. We need to
1564 recalculate what's really an abstract virtual at this point (by
1565 looking in the vtables). */
1566 get_pure_virtuals (t);
1568 /* If this type has a copy constructor or a destructor, force its
1569 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1570 nonzero. This will cause it to be passed by invisible reference
1571 and prevent it from being returned in a register. */
1572 if (type_has_nontrivial_copy_init (t)
1573 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
1576 DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
1577 for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1579 SET_TYPE_MODE (variants, BLKmode);
1580 TREE_ADDRESSABLE (variants) = 1;
1585 /* Issue warnings about T having private constructors, but no friends,
1588 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1589 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1590 non-private static member functions. */
1593 maybe_warn_about_overly_private_class (tree t)
1595 int has_member_fn = 0;
1596 int has_nonprivate_method = 0;
1599 if (!warn_ctor_dtor_privacy
1600 /* If the class has friends, those entities might create and
1601 access instances, so we should not warn. */
1602 || (CLASSTYPE_FRIEND_CLASSES (t)
1603 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))
1604 /* We will have warned when the template was declared; there's
1605 no need to warn on every instantiation. */
1606 || CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1607 /* There's no reason to even consider warning about this
1611 /* We only issue one warning, if more than one applies, because
1612 otherwise, on code like:
1615 // Oops - forgot `public:'
1621 we warn several times about essentially the same problem. */
1623 /* Check to see if all (non-constructor, non-destructor) member
1624 functions are private. (Since there are no friends or
1625 non-private statics, we can't ever call any of the private member
1627 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
1628 /* We're not interested in compiler-generated methods; they don't
1629 provide any way to call private members. */
1630 if (!DECL_ARTIFICIAL (fn))
1632 if (!TREE_PRIVATE (fn))
1634 if (DECL_STATIC_FUNCTION_P (fn))
1635 /* A non-private static member function is just like a
1636 friend; it can create and invoke private member
1637 functions, and be accessed without a class
1641 has_nonprivate_method = 1;
1642 /* Keep searching for a static member function. */
1644 else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn))
1648 if (!has_nonprivate_method && has_member_fn)
1650 /* There are no non-private methods, and there's at least one
1651 private member function that isn't a constructor or
1652 destructor. (If all the private members are
1653 constructors/destructors we want to use the code below that
1654 issues error messages specifically referring to
1655 constructors/destructors.) */
1657 tree binfo = TYPE_BINFO (t);
1659 for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++)
1660 if (BINFO_BASE_ACCESS (binfo, i) != access_private_node)
1662 has_nonprivate_method = 1;
1665 if (!has_nonprivate_method)
1667 warning (OPT_Wctor_dtor_privacy,
1668 "all member functions in class %qT are private", t);
1673 /* Even if some of the member functions are non-private, the class
1674 won't be useful for much if all the constructors or destructors
1675 are private: such an object can never be created or destroyed. */
1676 fn = CLASSTYPE_DESTRUCTORS (t);
1677 if (fn && TREE_PRIVATE (fn))
1679 warning (OPT_Wctor_dtor_privacy,
1680 "%q#T only defines a private destructor and has no friends",
1685 /* Warn about classes that have private constructors and no friends. */
1686 if (TYPE_HAS_USER_CONSTRUCTOR (t)
1687 /* Implicitly generated constructors are always public. */
1688 && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t)
1689 || !CLASSTYPE_LAZY_COPY_CTOR (t)))
1691 int nonprivate_ctor = 0;
1693 /* If a non-template class does not define a copy
1694 constructor, one is defined for it, enabling it to avoid
1695 this warning. For a template class, this does not
1696 happen, and so we would normally get a warning on:
1698 template <class T> class C { private: C(); };
1700 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All
1701 complete non-template or fully instantiated classes have this
1703 if (!TYPE_HAS_COPY_CTOR (t))
1704 nonprivate_ctor = 1;
1706 for (fn = CLASSTYPE_CONSTRUCTORS (t); fn; fn = OVL_NEXT (fn))
1708 tree ctor = OVL_CURRENT (fn);
1709 /* Ideally, we wouldn't count copy constructors (or, in
1710 fact, any constructor that takes an argument of the
1711 class type as a parameter) because such things cannot
1712 be used to construct an instance of the class unless
1713 you already have one. But, for now at least, we're
1715 if (! TREE_PRIVATE (ctor))
1717 nonprivate_ctor = 1;
1722 if (nonprivate_ctor == 0)
1724 warning (OPT_Wctor_dtor_privacy,
1725 "%q#T only defines private constructors and has no friends",
1733 gt_pointer_operator new_value;
1737 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1740 method_name_cmp (const void* m1_p, const void* m2_p)
1742 const tree *const m1 = (const tree *) m1_p;
1743 const tree *const m2 = (const tree *) m2_p;
1745 if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1747 if (*m1 == NULL_TREE)
1749 if (*m2 == NULL_TREE)
1751 if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2)))
1756 /* This routine compares two fields like method_name_cmp but using the
1757 pointer operator in resort_field_decl_data. */
1760 resort_method_name_cmp (const void* m1_p, const void* m2_p)
1762 const tree *const m1 = (const tree *) m1_p;
1763 const tree *const m2 = (const tree *) m2_p;
1764 if (*m1 == NULL_TREE && *m2 == NULL_TREE)
1766 if (*m1 == NULL_TREE)
1768 if (*m2 == NULL_TREE)
1771 tree d1 = DECL_NAME (OVL_CURRENT (*m1));
1772 tree d2 = DECL_NAME (OVL_CURRENT (*m2));
1773 resort_data.new_value (&d1, resort_data.cookie);
1774 resort_data.new_value (&d2, resort_data.cookie);
1781 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1784 resort_type_method_vec (void* obj,
1785 void* orig_obj ATTRIBUTE_UNUSED ,
1786 gt_pointer_operator new_value,
1789 VEC(tree,gc) *method_vec = (VEC(tree,gc) *) obj;
1790 int len = VEC_length (tree, method_vec);
1794 /* The type conversion ops have to live at the front of the vec, so we
1796 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1797 VEC_iterate (tree, method_vec, slot, fn);
1799 if (!DECL_CONV_FN_P (OVL_CURRENT (fn)))
1804 resort_data.new_value = new_value;
1805 resort_data.cookie = cookie;
1806 qsort (VEC_address (tree, method_vec) + slot, len - slot, sizeof (tree),
1807 resort_method_name_cmp);
1811 /* Warn about duplicate methods in fn_fields.
1813 Sort methods that are not special (i.e., constructors, destructors,
1814 and type conversion operators) so that we can find them faster in
1818 finish_struct_methods (tree t)
1821 VEC(tree,gc) *method_vec;
1824 method_vec = CLASSTYPE_METHOD_VEC (t);
1828 len = VEC_length (tree, method_vec);
1830 /* Clear DECL_IN_AGGR_P for all functions. */
1831 for (fn_fields = TYPE_METHODS (t); fn_fields;
1832 fn_fields = DECL_CHAIN (fn_fields))
1833 DECL_IN_AGGR_P (fn_fields) = 0;
1835 /* Issue warnings about private constructors and such. If there are
1836 no methods, then some public defaults are generated. */
1837 maybe_warn_about_overly_private_class (t);
1839 /* The type conversion ops have to live at the front of the vec, so we
1841 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT;
1842 VEC_iterate (tree, method_vec, slot, fn_fields);
1844 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields)))
1847 qsort (VEC_address (tree, method_vec) + slot,
1848 len-slot, sizeof (tree), method_name_cmp);
1851 /* Make BINFO's vtable have N entries, including RTTI entries,
1852 vbase and vcall offsets, etc. Set its type and call the back end
1856 layout_vtable_decl (tree binfo, int n)
1861 atype = build_array_of_n_type (vtable_entry_type, n);
1862 layout_type (atype);
1864 /* We may have to grow the vtable. */
1865 vtable = get_vtbl_decl_for_binfo (binfo);
1866 if (!same_type_p (TREE_TYPE (vtable), atype))
1868 TREE_TYPE (vtable) = atype;
1869 DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1870 layout_decl (vtable, 0);
1874 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1875 have the same signature. */
1878 same_signature_p (const_tree fndecl, const_tree base_fndecl)
1880 /* One destructor overrides another if they are the same kind of
1882 if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl)
1883 && special_function_p (base_fndecl) == special_function_p (fndecl))
1885 /* But a non-destructor never overrides a destructor, nor vice
1886 versa, nor do different kinds of destructors override
1887 one-another. For example, a complete object destructor does not
1888 override a deleting destructor. */
1889 if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl))
1892 if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl)
1893 || (DECL_CONV_FN_P (fndecl)
1894 && DECL_CONV_FN_P (base_fndecl)
1895 && same_type_p (DECL_CONV_FN_TYPE (fndecl),
1896 DECL_CONV_FN_TYPE (base_fndecl))))
1898 tree types, base_types;
1899 types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1900 base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
1901 if ((cp_type_quals (TREE_TYPE (TREE_VALUE (base_types)))
1902 == cp_type_quals (TREE_TYPE (TREE_VALUE (types))))
1903 && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types)))
1909 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1913 base_derived_from (tree derived, tree base)
1917 for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1919 if (probe == derived)
1921 else if (BINFO_VIRTUAL_P (probe))
1922 /* If we meet a virtual base, we can't follow the inheritance
1923 any more. See if the complete type of DERIVED contains
1924 such a virtual base. */
1925 return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (derived))
1931 typedef struct find_final_overrider_data_s {
1932 /* The function for which we are trying to find a final overrider. */
1934 /* The base class in which the function was declared. */
1935 tree declaring_base;
1936 /* The candidate overriders. */
1938 /* Path to most derived. */
1939 VEC(tree,heap) *path;
1940 } find_final_overrider_data;
1942 /* Add the overrider along the current path to FFOD->CANDIDATES.
1943 Returns true if an overrider was found; false otherwise. */
1946 dfs_find_final_overrider_1 (tree binfo,
1947 find_final_overrider_data *ffod,
1952 /* If BINFO is not the most derived type, try a more derived class.
1953 A definition there will overrider a definition here. */
1957 if (dfs_find_final_overrider_1
1958 (VEC_index (tree, ffod->path, depth), ffod, depth))
1962 method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1965 tree *candidate = &ffod->candidates;
1967 /* Remove any candidates overridden by this new function. */
1970 /* If *CANDIDATE overrides METHOD, then METHOD
1971 cannot override anything else on the list. */
1972 if (base_derived_from (TREE_VALUE (*candidate), binfo))
1974 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1975 if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1976 *candidate = TREE_CHAIN (*candidate);
1978 candidate = &TREE_CHAIN (*candidate);
1981 /* Add the new function. */
1982 ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1989 /* Called from find_final_overrider via dfs_walk. */
1992 dfs_find_final_overrider_pre (tree binfo, void *data)
1994 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1996 if (binfo == ffod->declaring_base)
1997 dfs_find_final_overrider_1 (binfo, ffod, VEC_length (tree, ffod->path));
1998 VEC_safe_push (tree, heap, ffod->path, binfo);
2004 dfs_find_final_overrider_post (tree binfo ATTRIBUTE_UNUSED, void *data)
2006 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
2007 VEC_pop (tree, ffod->path);
2012 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2013 FN and whose TREE_VALUE is the binfo for the base where the
2014 overriding occurs. BINFO (in the hierarchy dominated by the binfo
2015 DERIVED) is the base object in which FN is declared. */
2018 find_final_overrider (tree derived, tree binfo, tree fn)
2020 find_final_overrider_data ffod;
2022 /* Getting this right is a little tricky. This is valid:
2024 struct S { virtual void f (); };
2025 struct T { virtual void f (); };
2026 struct U : public S, public T { };
2028 even though calling `f' in `U' is ambiguous. But,
2030 struct R { virtual void f(); };
2031 struct S : virtual public R { virtual void f (); };
2032 struct T : virtual public R { virtual void f (); };
2033 struct U : public S, public T { };
2035 is not -- there's no way to decide whether to put `S::f' or
2036 `T::f' in the vtable for `R'.
2038 The solution is to look at all paths to BINFO. If we find
2039 different overriders along any two, then there is a problem. */
2040 if (DECL_THUNK_P (fn))
2041 fn = THUNK_TARGET (fn);
2043 /* Determine the depth of the hierarchy. */
2045 ffod.declaring_base = binfo;
2046 ffod.candidates = NULL_TREE;
2047 ffod.path = VEC_alloc (tree, heap, 30);
2049 dfs_walk_all (derived, dfs_find_final_overrider_pre,
2050 dfs_find_final_overrider_post, &ffod);
2052 VEC_free (tree, heap, ffod.path);
2054 /* If there was no winner, issue an error message. */
2055 if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
2056 return error_mark_node;
2058 return ffod.candidates;
2061 /* Return the index of the vcall offset for FN when TYPE is used as a
2065 get_vcall_index (tree fn, tree type)
2067 VEC(tree_pair_s,gc) *indices = CLASSTYPE_VCALL_INDICES (type);
2071 FOR_EACH_VEC_ELT (tree_pair_s, indices, ix, p)
2072 if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (p->purpose))
2073 || same_signature_p (fn, p->purpose))
2076 /* There should always be an appropriate index. */
2080 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2081 dominated by T. FN is the old function; VIRTUALS points to the
2082 corresponding position in the new BINFO_VIRTUALS list. IX is the index
2083 of that entry in the list. */
2086 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals,
2094 tree overrider_fn, overrider_target;
2095 tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2096 tree over_return, base_return;
2099 /* Find the nearest primary base (possibly binfo itself) which defines
2100 this function; this is the class the caller will convert to when
2101 calling FN through BINFO. */
2102 for (b = binfo; ; b = get_primary_binfo (b))
2105 if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2108 /* The nearest definition is from a lost primary. */
2109 if (BINFO_LOST_PRIMARY_P (b))
2114 /* Find the final overrider. */
2115 overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2116 if (overrider == error_mark_node)
2118 error ("no unique final overrider for %qD in %qT", target_fn, t);
2121 overrider_target = overrider_fn = TREE_PURPOSE (overrider);
2123 /* Check for adjusting covariant return types. */
2124 over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2125 base_return = TREE_TYPE (TREE_TYPE (target_fn));
2127 if (POINTER_TYPE_P (over_return)
2128 && TREE_CODE (over_return) == TREE_CODE (base_return)
2129 && CLASS_TYPE_P (TREE_TYPE (over_return))
2130 && CLASS_TYPE_P (TREE_TYPE (base_return))
2131 /* If the overrider is invalid, don't even try. */
2132 && !DECL_INVALID_OVERRIDER_P (overrider_target))
2134 /* If FN is a covariant thunk, we must figure out the adjustment
2135 to the final base FN was converting to. As OVERRIDER_TARGET might
2136 also be converting to the return type of FN, we have to
2137 combine the two conversions here. */
2138 tree fixed_offset, virtual_offset;
2140 over_return = TREE_TYPE (over_return);
2141 base_return = TREE_TYPE (base_return);
2143 if (DECL_THUNK_P (fn))
2145 gcc_assert (DECL_RESULT_THUNK_P (fn));
2146 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2147 virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2150 fixed_offset = virtual_offset = NULL_TREE;
2153 /* Find the equivalent binfo within the return type of the
2154 overriding function. We will want the vbase offset from
2156 virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset),
2158 else if (!same_type_ignoring_top_level_qualifiers_p
2159 (over_return, base_return))
2161 /* There was no existing virtual thunk (which takes
2162 precedence). So find the binfo of the base function's
2163 return type within the overriding function's return type.
2164 We cannot call lookup base here, because we're inside a
2165 dfs_walk, and will therefore clobber the BINFO_MARKED
2166 flags. Fortunately we know the covariancy is valid (it
2167 has already been checked), so we can just iterate along
2168 the binfos, which have been chained in inheritance graph
2169 order. Of course it is lame that we have to repeat the
2170 search here anyway -- we should really be caching pieces
2171 of the vtable and avoiding this repeated work. */
2172 tree thunk_binfo, base_binfo;
2174 /* Find the base binfo within the overriding function's
2175 return type. We will always find a thunk_binfo, except
2176 when the covariancy is invalid (which we will have
2177 already diagnosed). */
2178 for (base_binfo = TYPE_BINFO (base_return),
2179 thunk_binfo = TYPE_BINFO (over_return);
2181 thunk_binfo = TREE_CHAIN (thunk_binfo))
2182 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo),
2183 BINFO_TYPE (base_binfo)))
2186 /* See if virtual inheritance is involved. */
2187 for (virtual_offset = thunk_binfo;
2189 virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
2190 if (BINFO_VIRTUAL_P (virtual_offset))
2194 || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
2196 tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2200 /* We convert via virtual base. Adjust the fixed
2201 offset to be from there. */
2203 size_diffop (offset,
2205 BINFO_OFFSET (virtual_offset)));
2208 /* There was an existing fixed offset, this must be
2209 from the base just converted to, and the base the
2210 FN was thunking to. */
2211 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2213 fixed_offset = offset;
2217 if (fixed_offset || virtual_offset)
2218 /* Replace the overriding function with a covariant thunk. We
2219 will emit the overriding function in its own slot as
2221 overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0,
2222 fixed_offset, virtual_offset);
2225 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target) ||
2226 !DECL_THUNK_P (fn));
2228 /* If we need a covariant thunk, then we may need to adjust first_defn.
2229 The ABI specifies that the thunks emitted with a function are
2230 determined by which bases the function overrides, so we need to be
2231 sure that we're using a thunk for some overridden base; even if we
2232 know that the necessary this adjustment is zero, there may not be an
2233 appropriate zero-this-adjusment thunk for us to use since thunks for
2234 overriding virtual bases always use the vcall offset.
2236 Furthermore, just choosing any base that overrides this function isn't
2237 quite right, as this slot won't be used for calls through a type that
2238 puts a covariant thunk here. Calling the function through such a type
2239 will use a different slot, and that slot is the one that determines
2240 the thunk emitted for that base.
2242 So, keep looking until we find the base that we're really overriding
2243 in this slot: the nearest primary base that doesn't use a covariant
2244 thunk in this slot. */
2245 if (overrider_target != overrider_fn)
2247 if (BINFO_TYPE (b) == DECL_CONTEXT (overrider_target))
2248 /* We already know that the overrider needs a covariant thunk. */
2249 b = get_primary_binfo (b);
2250 for (; ; b = get_primary_binfo (b))
2252 tree main_binfo = TYPE_BINFO (BINFO_TYPE (b));
2253 tree bv = chain_index (ix, BINFO_VIRTUALS (main_binfo));
2254 if (BINFO_LOST_PRIMARY_P (b))
2256 if (!DECL_THUNK_P (TREE_VALUE (bv)))
2262 /* Assume that we will produce a thunk that convert all the way to
2263 the final overrider, and not to an intermediate virtual base. */
2264 virtual_base = NULL_TREE;
2266 /* See if we can convert to an intermediate virtual base first, and then
2267 use the vcall offset located there to finish the conversion. */
2268 for (; b; b = BINFO_INHERITANCE_CHAIN (b))
2270 /* If we find the final overrider, then we can stop
2272 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b),
2273 BINFO_TYPE (TREE_VALUE (overrider))))
2276 /* If we find a virtual base, and we haven't yet found the
2277 overrider, then there is a virtual base between the
2278 declaring base (first_defn) and the final overrider. */
2279 if (BINFO_VIRTUAL_P (b))
2286 /* Compute the constant adjustment to the `this' pointer. The
2287 `this' pointer, when this function is called, will point at BINFO
2288 (or one of its primary bases, which are at the same offset). */
2290 /* The `this' pointer needs to be adjusted from the declaration to
2291 the nearest virtual base. */
2292 delta = size_diffop_loc (input_location,
2293 convert (ssizetype, BINFO_OFFSET (virtual_base)),
2294 convert (ssizetype, BINFO_OFFSET (first_defn)));
2296 /* If the nearest definition is in a lost primary, we don't need an
2297 entry in our vtable. Except possibly in a constructor vtable,
2298 if we happen to get our primary back. In that case, the offset
2299 will be zero, as it will be a primary base. */
2300 delta = size_zero_node;
2302 /* The `this' pointer needs to be adjusted from pointing to
2303 BINFO to pointing at the base where the final overrider
2305 delta = size_diffop_loc (input_location,
2307 BINFO_OFFSET (TREE_VALUE (overrider))),
2308 convert (ssizetype, BINFO_OFFSET (binfo)));
2310 modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
2313 BV_VCALL_INDEX (*virtuals)
2314 = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base));
2316 BV_VCALL_INDEX (*virtuals) = NULL_TREE;
2319 BV_LOST_PRIMARY (*virtuals) = true;
2322 /* Called from modify_all_vtables via dfs_walk. */
2325 dfs_modify_vtables (tree binfo, void* data)
2327 tree t = (tree) data;
2332 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
2333 /* A base without a vtable needs no modification, and its bases
2334 are uninteresting. */
2335 return dfs_skip_bases;
2337 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t)
2338 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
2339 /* Don't do the primary vtable, if it's new. */
2342 if (BINFO_PRIMARY_P (binfo) && !BINFO_VIRTUAL_P (binfo))
2343 /* There's no need to modify the vtable for a non-virtual primary
2344 base; we're not going to use that vtable anyhow. We do still
2345 need to do this for virtual primary bases, as they could become
2346 non-primary in a construction vtable. */
2349 make_new_vtable (t, binfo);
2351 /* Now, go through each of the virtual functions in the virtual
2352 function table for BINFO. Find the final overrider, and update
2353 the BINFO_VIRTUALS list appropriately. */
2354 for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2355 old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2357 ix++, virtuals = TREE_CHAIN (virtuals),
2358 old_virtuals = TREE_CHAIN (old_virtuals))
2359 update_vtable_entry_for_fn (t,
2361 BV_FN (old_virtuals),
2367 /* Update all of the primary and secondary vtables for T. Create new
2368 vtables as required, and initialize their RTTI information. Each
2369 of the functions in VIRTUALS is declared in T and may override a
2370 virtual function from a base class; find and modify the appropriate
2371 entries to point to the overriding functions. Returns a list, in
2372 declaration order, of the virtual functions that are declared in T,
2373 but do not appear in the primary base class vtable, and which
2374 should therefore be appended to the end of the vtable for T. */
2377 modify_all_vtables (tree t, tree virtuals)
2379 tree binfo = TYPE_BINFO (t);
2382 /* Update all of the vtables. */
2383 dfs_walk_once (binfo, dfs_modify_vtables, NULL, t);
2385 /* Add virtual functions not already in our primary vtable. These
2386 will be both those introduced by this class, and those overridden
2387 from secondary bases. It does not include virtuals merely
2388 inherited from secondary bases. */
2389 for (fnsp = &virtuals; *fnsp; )
2391 tree fn = TREE_VALUE (*fnsp);
2393 if (!value_member (fn, BINFO_VIRTUALS (binfo))
2394 || DECL_VINDEX (fn) == error_mark_node)
2396 /* We don't need to adjust the `this' pointer when
2397 calling this function. */
2398 BV_DELTA (*fnsp) = integer_zero_node;
2399 BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2401 /* This is a function not already in our vtable. Keep it. */
2402 fnsp = &TREE_CHAIN (*fnsp);
2405 /* We've already got an entry for this function. Skip it. */
2406 *fnsp = TREE_CHAIN (*fnsp);
2412 /* Get the base virtual function declarations in T that have the
2416 get_basefndecls (tree name, tree t)
2419 tree base_fndecls = NULL_TREE;
2420 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
2423 /* Find virtual functions in T with the indicated NAME. */
2424 i = lookup_fnfields_1 (t, name);
2426 for (methods = VEC_index (tree, CLASSTYPE_METHOD_VEC (t), i);
2428 methods = OVL_NEXT (methods))
2430 tree method = OVL_CURRENT (methods);
2432 if (TREE_CODE (method) == FUNCTION_DECL
2433 && DECL_VINDEX (method))
2434 base_fndecls = tree_cons (NULL_TREE, method, base_fndecls);
2438 return base_fndecls;
2440 for (i = 0; i < n_baseclasses; i++)
2442 tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t), i));
2443 base_fndecls = chainon (get_basefndecls (name, basetype),
2447 return base_fndecls;
2450 /* If this declaration supersedes the declaration of
2451 a method declared virtual in the base class, then
2452 mark this field as being virtual as well. */
2455 check_for_override (tree decl, tree ctype)
2457 if (TREE_CODE (decl) == TEMPLATE_DECL)
2458 /* In [temp.mem] we have:
2460 A specialization of a member function template does not
2461 override a virtual function from a base class. */
2463 if ((DECL_DESTRUCTOR_P (decl)
2464 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl))
2465 || DECL_CONV_FN_P (decl))
2466 && look_for_overrides (ctype, decl)
2467 && !DECL_STATIC_FUNCTION_P (decl))
2468 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2469 the error_mark_node so that we know it is an overriding
2471 DECL_VINDEX (decl) = decl;
2473 if (DECL_VIRTUAL_P (decl))
2475 if (!DECL_VINDEX (decl))
2476 DECL_VINDEX (decl) = error_mark_node;
2477 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2481 /* Warn about hidden virtual functions that are not overridden in t.
2482 We know that constructors and destructors don't apply. */
2485 warn_hidden (tree t)
2487 VEC(tree,gc) *method_vec = CLASSTYPE_METHOD_VEC (t);
2491 /* We go through each separately named virtual function. */
2492 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT;
2493 VEC_iterate (tree, method_vec, i, fns);
2504 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2505 have the same name. Figure out what name that is. */
2506 name = DECL_NAME (OVL_CURRENT (fns));
2507 /* There are no possibly hidden functions yet. */
2508 base_fndecls = NULL_TREE;
2509 /* Iterate through all of the base classes looking for possibly
2510 hidden functions. */
2511 for (binfo = TYPE_BINFO (t), j = 0;
2512 BINFO_BASE_ITERATE (binfo, j, base_binfo); j++)
2514 tree basetype = BINFO_TYPE (base_binfo);
2515 base_fndecls = chainon (get_basefndecls (name, basetype),
2519 /* If there are no functions to hide, continue. */
2523 /* Remove any overridden functions. */
2524 for (fn = fns; fn; fn = OVL_NEXT (fn))
2526 fndecl = OVL_CURRENT (fn);
2527 if (DECL_VINDEX (fndecl))
2529 tree *prev = &base_fndecls;
2532 /* If the method from the base class has the same
2533 signature as the method from the derived class, it
2534 has been overridden. */
2535 if (same_signature_p (fndecl, TREE_VALUE (*prev)))
2536 *prev = TREE_CHAIN (*prev);
2538 prev = &TREE_CHAIN (*prev);
2542 /* Now give a warning for all base functions without overriders,
2543 as they are hidden. */
2544 while (base_fndecls)
2546 /* Here we know it is a hider, and no overrider exists. */
2547 warning (OPT_Woverloaded_virtual, "%q+D was hidden", TREE_VALUE (base_fndecls));
2548 warning (OPT_Woverloaded_virtual, " by %q+D", fns);
2549 base_fndecls = TREE_CHAIN (base_fndecls);
2554 /* Check for things that are invalid. There are probably plenty of other
2555 things we should check for also. */
2558 finish_struct_anon (tree t)
2562 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
2564 if (TREE_STATIC (field))
2566 if (TREE_CODE (field) != FIELD_DECL)
2569 if (DECL_NAME (field) == NULL_TREE
2570 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2572 bool is_union = TREE_CODE (TREE_TYPE (field)) == UNION_TYPE;
2573 tree elt = TYPE_FIELDS (TREE_TYPE (field));
2574 for (; elt; elt = DECL_CHAIN (elt))
2576 /* We're generally only interested in entities the user
2577 declared, but we also find nested classes by noticing
2578 the TYPE_DECL that we create implicitly. You're
2579 allowed to put one anonymous union inside another,
2580 though, so we explicitly tolerate that. We use
2581 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2582 we also allow unnamed types used for defining fields. */
2583 if (DECL_ARTIFICIAL (elt)
2584 && (!DECL_IMPLICIT_TYPEDEF_P (elt)
2585 || TYPE_ANONYMOUS_P (TREE_TYPE (elt))))
2588 if (TREE_CODE (elt) != FIELD_DECL)
2591 permerror (input_location, "%q+#D invalid; an anonymous union can "
2592 "only have non-static data members", elt);
2594 permerror (input_location, "%q+#D invalid; an anonymous struct can "
2595 "only have non-static data members", elt);
2599 if (TREE_PRIVATE (elt))
2602 permerror (input_location, "private member %q+#D in anonymous union", elt);
2604 permerror (input_location, "private member %q+#D in anonymous struct", elt);
2606 else if (TREE_PROTECTED (elt))
2609 permerror (input_location, "protected member %q+#D in anonymous union", elt);
2611 permerror (input_location, "protected member %q+#D in anonymous struct", elt);
2614 TREE_PRIVATE (elt) = TREE_PRIVATE (field);
2615 TREE_PROTECTED (elt) = TREE_PROTECTED (field);
2621 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2622 will be used later during class template instantiation.
2623 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2624 a non-static member data (FIELD_DECL), a member function
2625 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2626 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2627 When FRIEND_P is nonzero, T is either a friend class
2628 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2629 (FUNCTION_DECL, TEMPLATE_DECL). */
2632 maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
2634 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2635 if (CLASSTYPE_TEMPLATE_INFO (type))
2636 CLASSTYPE_DECL_LIST (type)
2637 = tree_cons (friend_p ? NULL_TREE : type,
2638 t, CLASSTYPE_DECL_LIST (type));
2641 /* Create default constructors, assignment operators, and so forth for
2642 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
2643 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
2644 the class cannot have a default constructor, copy constructor
2645 taking a const reference argument, or an assignment operator taking
2646 a const reference, respectively. */
2649 add_implicitly_declared_members (tree t,
2650 int cant_have_const_cctor,
2651 int cant_have_const_assignment)
2654 if (!CLASSTYPE_DESTRUCTORS (t))
2656 /* In general, we create destructors lazily. */
2657 CLASSTYPE_LAZY_DESTRUCTOR (t) = 1;
2659 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2660 && TYPE_FOR_JAVA (t))
2661 /* But if this is a Java class, any non-trivial destructor is
2662 invalid, even if compiler-generated. Therefore, if the
2663 destructor is non-trivial we create it now. */
2664 lazily_declare_fn (sfk_destructor, t);
2669 If there is no user-declared constructor for a class, a default
2670 constructor is implicitly declared. */
2671 if (! TYPE_HAS_USER_CONSTRUCTOR (t))
2673 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1;
2674 CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 1;
2675 if (cxx_dialect >= cxx0x)
2676 TYPE_HAS_CONSTEXPR_CTOR (t)
2677 = synthesized_default_constructor_is_constexpr (t);
2682 If a class definition does not explicitly declare a copy
2683 constructor, one is declared implicitly. */
2684 if (! TYPE_HAS_COPY_CTOR (t) && ! TYPE_FOR_JAVA (t)
2685 && !type_has_move_constructor (t))
2687 TYPE_HAS_COPY_CTOR (t) = 1;
2688 TYPE_HAS_CONST_COPY_CTOR (t) = !cant_have_const_cctor;
2689 CLASSTYPE_LAZY_COPY_CTOR (t) = 1;
2690 if (cxx_dialect >= cxx0x)
2691 CLASSTYPE_LAZY_MOVE_CTOR (t) = 1;
2694 /* If there is no assignment operator, one will be created if and
2695 when it is needed. For now, just record whether or not the type
2696 of the parameter to the assignment operator will be a const or
2697 non-const reference. */
2698 if (!TYPE_HAS_COPY_ASSIGN (t) && !TYPE_FOR_JAVA (t)
2699 && !type_has_move_assign (t))
2701 TYPE_HAS_COPY_ASSIGN (t) = 1;
2702 TYPE_HAS_CONST_COPY_ASSIGN (t) = !cant_have_const_assignment;
2703 CLASSTYPE_LAZY_COPY_ASSIGN (t) = 1;
2704 if (cxx_dialect >= cxx0x)
2705 CLASSTYPE_LAZY_MOVE_ASSIGN (t) = 1;
2708 /* We can't be lazy about declaring functions that might override
2709 a virtual function from a base class. */
2710 if (TYPE_POLYMORPHIC_P (t)
2711 && (CLASSTYPE_LAZY_COPY_ASSIGN (t)
2712 || CLASSTYPE_LAZY_MOVE_ASSIGN (t)
2713 || CLASSTYPE_LAZY_DESTRUCTOR (t)))
2715 tree binfo = TYPE_BINFO (t);
2718 tree opname = ansi_assopname (NOP_EXPR);
2719 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ++ix)
2722 for (bv = BINFO_VIRTUALS (base_binfo); bv; bv = TREE_CHAIN (bv))
2724 tree fn = BV_FN (bv);
2725 if (DECL_NAME (fn) == opname)
2727 if (CLASSTYPE_LAZY_COPY_ASSIGN (t))
2728 lazily_declare_fn (sfk_copy_assignment, t);
2729 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t))
2730 lazily_declare_fn (sfk_move_assignment, t);
2732 else if (DECL_DESTRUCTOR_P (fn)
2733 && CLASSTYPE_LAZY_DESTRUCTOR (t))
2734 lazily_declare_fn (sfk_destructor, t);
2740 /* Subroutine of finish_struct_1. Recursively count the number of fields
2741 in TYPE, including anonymous union members. */
2744 count_fields (tree fields)
2748 for (x = fields; x; x = DECL_CHAIN (x))
2750 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2751 n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x)));
2758 /* Subroutine of finish_struct_1. Recursively add all the fields in the
2759 TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */
2762 add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx)
2765 for (x = fields; x; x = DECL_CHAIN (x))
2767 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2768 idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx);
2770 field_vec->elts[idx++] = x;
2775 /* FIELD is a bit-field. We are finishing the processing for its
2776 enclosing type. Issue any appropriate messages and set appropriate
2777 flags. Returns false if an error has been diagnosed. */
2780 check_bitfield_decl (tree field)
2782 tree type = TREE_TYPE (field);
2785 /* Extract the declared width of the bitfield, which has been
2786 temporarily stashed in DECL_INITIAL. */
2787 w = DECL_INITIAL (field);
2788 gcc_assert (w != NULL_TREE);
2789 /* Remove the bit-field width indicator so that the rest of the
2790 compiler does not treat that value as an initializer. */
2791 DECL_INITIAL (field) = NULL_TREE;
2793 /* Detect invalid bit-field type. */
2794 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
2796 error ("bit-field %q+#D with non-integral type", field);
2797 w = error_mark_node;
2801 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2804 /* detect invalid field size. */
2805 w = cxx_constant_value (w);
2807 if (TREE_CODE (w) != INTEGER_CST)
2809 error ("bit-field %q+D width not an integer constant", field);
2810 w = error_mark_node;
2812 else if (tree_int_cst_sgn (w) < 0)
2814 error ("negative width in bit-field %q+D", field);
2815 w = error_mark_node;
2817 else if (integer_zerop (w) && DECL_NAME (field) != 0)
2819 error ("zero width for bit-field %q+D", field);
2820 w = error_mark_node;
2822 else if (compare_tree_int (w, TYPE_PRECISION (type)) > 0
2823 && TREE_CODE (type) != ENUMERAL_TYPE
2824 && TREE_CODE (type) != BOOLEAN_TYPE)
2825 warning (0, "width of %q+D exceeds its type", field);
2826 else if (TREE_CODE (type) == ENUMERAL_TYPE
2827 && (0 > (compare_tree_int
2828 (w, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type))))))
2829 warning (0, "%q+D is too small to hold all values of %q#T", field, type);
2832 if (w != error_mark_node)
2834 DECL_SIZE (field) = convert (bitsizetype, w);
2835 DECL_BIT_FIELD (field) = 1;
2840 /* Non-bit-fields are aligned for their type. */
2841 DECL_BIT_FIELD (field) = 0;
2842 CLEAR_DECL_C_BIT_FIELD (field);
2847 /* FIELD is a non bit-field. We are finishing the processing for its
2848 enclosing type T. Issue any appropriate messages and set appropriate
2852 check_field_decl (tree field,
2854 int* cant_have_const_ctor,
2855 int* no_const_asn_ref,
2856 int* any_default_members)
2858 tree type = strip_array_types (TREE_TYPE (field));
2860 /* In C++98 an anonymous union cannot contain any fields which would change
2861 the settings of CANT_HAVE_CONST_CTOR and friends. */
2862 if (ANON_UNION_TYPE_P (type) && cxx_dialect < cxx0x)
2864 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
2865 structs. So, we recurse through their fields here. */
2866 else if (ANON_AGGR_TYPE_P (type))
2870 for (fields = TYPE_FIELDS (type); fields; fields = DECL_CHAIN (fields))
2871 if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field))
2872 check_field_decl (fields, t, cant_have_const_ctor,
2873 no_const_asn_ref, any_default_members);
2875 /* Check members with class type for constructors, destructors,
2877 else if (CLASS_TYPE_P (type))
2879 /* Never let anything with uninheritable virtuals
2880 make it through without complaint. */
2881 abstract_virtuals_error (field, type);
2883 if (TREE_CODE (t) == UNION_TYPE && cxx_dialect < cxx0x)
2886 int oldcount = errorcount;
2887 if (TYPE_NEEDS_CONSTRUCTING (type))
2888 error ("member %q+#D with constructor not allowed in union",
2890 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2891 error ("member %q+#D with destructor not allowed in union", field);
2892 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
2893 error ("member %q+#D with copy assignment operator not allowed in union",
2895 if (!warned && errorcount > oldcount)
2897 inform (DECL_SOURCE_LOCATION (field), "unrestricted unions "
2898 "only available with -std=c++0x or -std=gnu++0x");
2904 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
2905 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
2906 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
2907 TYPE_HAS_COMPLEX_COPY_ASSIGN (t)
2908 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type)
2909 || !TYPE_HAS_COPY_ASSIGN (type));
2910 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= (TYPE_HAS_COMPLEX_COPY_CTOR (type)
2911 || !TYPE_HAS_COPY_CTOR (type));
2912 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type);
2913 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_HAS_COMPLEX_MOVE_CTOR (type);
2914 TYPE_HAS_COMPLEX_DFLT (t) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)
2915 || TYPE_HAS_COMPLEX_DFLT (type));
2918 if (TYPE_HAS_COPY_CTOR (type)
2919 && !TYPE_HAS_CONST_COPY_CTOR (type))
2920 *cant_have_const_ctor = 1;
2922 if (TYPE_HAS_COPY_ASSIGN (type)
2923 && !TYPE_HAS_CONST_COPY_ASSIGN (type))
2924 *no_const_asn_ref = 1;
2926 if (DECL_INITIAL (field) != NULL_TREE)
2928 /* `build_class_init_list' does not recognize
2930 if (TREE_CODE (t) == UNION_TYPE && any_default_members != 0)
2931 error ("multiple fields in union %qT initialized", t);
2932 *any_default_members = 1;
2936 /* Check the data members (both static and non-static), class-scoped
2937 typedefs, etc., appearing in the declaration of T. Issue
2938 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
2939 declaration order) of access declarations; each TREE_VALUE in this
2940 list is a USING_DECL.
2942 In addition, set the following flags:
2945 The class is empty, i.e., contains no non-static data members.
2947 CANT_HAVE_CONST_CTOR_P
2948 This class cannot have an implicitly generated copy constructor
2949 taking a const reference.
2951 CANT_HAVE_CONST_ASN_REF
2952 This class cannot have an implicitly generated assignment
2953 operator taking a const reference.
2955 All of these flags should be initialized before calling this
2958 Returns a pointer to the end of the TYPE_FIELDs chain; additional
2959 fields can be added by adding to this chain. */
2962 check_field_decls (tree t, tree *access_decls,
2963 int *cant_have_const_ctor_p,
2964 int *no_const_asn_ref_p)
2969 int any_default_members;
2971 int field_access = -1;
2973 /* Assume there are no access declarations. */
2974 *access_decls = NULL_TREE;
2975 /* Assume this class has no pointer members. */
2976 has_pointers = false;
2977 /* Assume none of the members of this class have default
2979 any_default_members = 0;
2981 for (field = &TYPE_FIELDS (t); *field; field = next)
2984 tree type = TREE_TYPE (x);
2985 int this_field_access;
2987 next = &DECL_CHAIN (x);
2989 if (TREE_CODE (x) == USING_DECL)
2991 /* Prune the access declaration from the list of fields. */
2992 *field = DECL_CHAIN (x);
2994 /* Save the access declarations for our caller. */
2995 *access_decls = tree_cons (NULL_TREE, x, *access_decls);
2997 /* Since we've reset *FIELD there's no reason to skip to the
3003 if (TREE_CODE (x) == TYPE_DECL
3004 || TREE_CODE (x) == TEMPLATE_DECL)
3007 /* If we've gotten this far, it's a data member, possibly static,
3008 or an enumerator. */
3009 DECL_CONTEXT (x) = t;
3011 /* When this goes into scope, it will be a non-local reference. */
3012 DECL_NONLOCAL (x) = 1;
3014 if (TREE_CODE (t) == UNION_TYPE)
3018 If a union contains a static data member, or a member of
3019 reference type, the program is ill-formed. */
3020 if (TREE_CODE (x) == VAR_DECL)
3022 error ("%q+D may not be static because it is a member of a union", x);
3025 if (TREE_CODE (type) == REFERENCE_TYPE)
3027 error ("%q+D may not have reference type %qT because"
3028 " it is a member of a union",
3034 /* Perform error checking that did not get done in
3036 if (TREE_CODE (type) == FUNCTION_TYPE)
3038 error ("field %q+D invalidly declared function type", x);
3039 type = build_pointer_type (type);
3040 TREE_TYPE (x) = type;
3042 else if (TREE_CODE (type) == METHOD_TYPE)
3044 error ("field %q+D invalidly declared method type", x);
3045 type = build_pointer_type (type);
3046 TREE_TYPE (x) = type;
3049 if (type == error_mark_node)
3052 if (TREE_CODE (x) == CONST_DECL || TREE_CODE (x) == VAR_DECL)
3055 /* Now it can only be a FIELD_DECL. */
3057 if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3058 CLASSTYPE_NON_AGGREGATE (t) = 1;
3060 /* If at least one non-static data member is non-literal, the whole
3061 class becomes non-literal. */
3062 if (!literal_type_p (type))
3063 CLASSTYPE_LITERAL_P (t) = false;
3065 /* A standard-layout class is a class that:
3067 has the same access control (Clause 11) for all non-static data members,
3069 this_field_access = TREE_PROTECTED (x) ? 1 : TREE_PRIVATE (x) ? 2 : 0;
3070 if (field_access == -1)
3071 field_access = this_field_access;
3072 else if (this_field_access != field_access)
3073 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3075 /* If this is of reference type, check if it needs an init. */
3076 if (TREE_CODE (type) == REFERENCE_TYPE)
3078 CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3079 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3080 if (DECL_INITIAL (x) == NULL_TREE)
3081 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3083 /* ARM $12.6.2: [A member initializer list] (or, for an
3084 aggregate, initialization by a brace-enclosed list) is the
3085 only way to initialize nonstatic const and reference
3087 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
3088 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) = 1;
3091 type = strip_array_types (type);
3093 if (TYPE_PACKED (t))
3095 if (!layout_pod_type_p (type) && !TYPE_PACKED (type))
3099 "ignoring packed attribute because of unpacked non-POD field %q+#D",
3103 else if (DECL_C_BIT_FIELD (x)
3104 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT)
3105 DECL_PACKED (x) = 1;
3108 if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x)))
3109 /* We don't treat zero-width bitfields as making a class
3114 /* The class is non-empty. */
3115 CLASSTYPE_EMPTY_P (t) = 0;
3116 /* The class is not even nearly empty. */
3117 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3118 /* If one of the data members contains an empty class,
3120 if (CLASS_TYPE_P (type)
3121 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3122 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
3125 /* This is used by -Weffc++ (see below). Warn only for pointers
3126 to members which might hold dynamic memory. So do not warn
3127 for pointers to functions or pointers to members. */
3128 if (TYPE_PTR_P (type)
3129 && !TYPE_PTRFN_P (type)
3130 && !TYPE_PTR_TO_MEMBER_P (type))
3131 has_pointers = true;
3133 if (CLASS_TYPE_P (type))
3135 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type))
3136 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1);
3137 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type))
3138 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3141 if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type))
3142 CLASSTYPE_HAS_MUTABLE (t) = 1;
3144 if (! layout_pod_type_p (type))
3145 /* DR 148 now allows pointers to members (which are POD themselves),
3146 to be allowed in POD structs. */
3147 CLASSTYPE_NON_LAYOUT_POD_P (t) = 1;
3149 if (!std_layout_type_p (type))
3150 CLASSTYPE_NON_STD_LAYOUT (t) = 1;
3152 if (! zero_init_p (type))
3153 CLASSTYPE_NON_ZERO_INIT_P (t) = 1;
3155 /* We set DECL_C_BIT_FIELD in grokbitfield.
3156 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3157 if (! DECL_C_BIT_FIELD (x) || ! check_bitfield_decl (x))
3158 check_field_decl (x, t,
3159 cant_have_const_ctor_p,
3161 &any_default_members);
3163 /* If any field is const, the structure type is pseudo-const. */
3164 if (CP_TYPE_CONST_P (type))
3166 C_TYPE_FIELDS_READONLY (t) = 1;
3167 if (DECL_INITIAL (x) == NULL_TREE)
3168 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1);
3170 /* ARM $12.6.2: [A member initializer list] (or, for an
3171 aggregate, initialization by a brace-enclosed list) is the
3172 only way to initialize nonstatic const and reference
3174 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
3175 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) = 1;
3177 /* A field that is pseudo-const makes the structure likewise. */
3178 else if (CLASS_TYPE_P (type))
3180 C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type);
3181 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t,
3182 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t)
3183 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type));
3186 /* Core issue 80: A nonstatic data member is required to have a
3187 different name from the class iff the class has a
3188 user-declared constructor. */
3189 if (constructor_name_p (DECL_NAME (x), t)
3190 && TYPE_HAS_USER_CONSTRUCTOR (t))
3191 permerror (input_location, "field %q+#D with same name as class", x);
3194 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3195 it should also define a copy constructor and an assignment operator to
3196 implement the correct copy semantic (deep vs shallow, etc.). As it is
3197 not feasible to check whether the constructors do allocate dynamic memory
3198 and store it within members, we approximate the warning like this:
3200 -- Warn only if there are members which are pointers
3201 -- Warn only if there is a non-trivial constructor (otherwise,
3202 there cannot be memory allocated).
3203 -- Warn only if there is a non-trivial destructor. We assume that the
3204 user at least implemented the cleanup correctly, and a destructor
3205 is needed to free dynamic memory.
3207 This seems enough for practical purposes. */
3210 && TYPE_HAS_USER_CONSTRUCTOR (t)
3211 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
3212 && !(TYPE_HAS_COPY_CTOR (t) && TYPE_HAS_COPY_ASSIGN (t)))
3214 warning (OPT_Weffc__, "%q#T has pointer data members", t);
3216 if (! TYPE_HAS_COPY_CTOR (t))
3218 warning (OPT_Weffc__,
3219 " but does not override %<%T(const %T&)%>", t, t);
3220 if (!TYPE_HAS_COPY_ASSIGN (t))
3221 warning (OPT_Weffc__, " or %<operator=(const %T&)%>", t);
3223 else if (! TYPE_HAS_COPY_ASSIGN (t))
3224 warning (OPT_Weffc__,
3225 " but does not override %<operator=(const %T&)%>", t);
3228 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3230 TYPE_PACKED (t) = 0;
3232 /* Check anonymous struct/anonymous union fields. */
3233 finish_struct_anon (t);
3235 /* We've built up the list of access declarations in reverse order.
3237 *access_decls = nreverse (*access_decls);
3240 /* If TYPE is an empty class type, records its OFFSET in the table of
3244 record_subobject_offset (tree type, tree offset, splay_tree offsets)
3248 if (!is_empty_class (type))
3251 /* Record the location of this empty object in OFFSETS. */
3252 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3254 n = splay_tree_insert (offsets,
3255 (splay_tree_key) offset,
3256 (splay_tree_value) NULL_TREE);
3257 n->value = ((splay_tree_value)
3258 tree_cons (NULL_TREE,
3265 /* Returns nonzero if TYPE is an empty class type and there is
3266 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3269 check_subobject_offset (tree type, tree offset, splay_tree offsets)
3274 if (!is_empty_class (type))
3277 /* Record the location of this empty object in OFFSETS. */
3278 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3282 for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3283 if (same_type_p (TREE_VALUE (t), type))
3289 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3290 F for every subobject, passing it the type, offset, and table of
3291 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3294 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3295 than MAX_OFFSET will not be walked.
3297 If F returns a nonzero value, the traversal ceases, and that value
3298 is returned. Otherwise, returns zero. */
3301 walk_subobject_offsets (tree type,
3302 subobject_offset_fn f,
3309 tree type_binfo = NULL_TREE;
3311 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3313 if (max_offset && INT_CST_LT (max_offset, offset))
3316 if (type == error_mark_node)
3321 if (abi_version_at_least (2))
3323 type = BINFO_TYPE (type);
3326 if (CLASS_TYPE_P (type))
3332 /* Avoid recursing into objects that are not interesting. */
3333 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3336 /* Record the location of TYPE. */
3337 r = (*f) (type, offset, offsets);
3341 /* Iterate through the direct base classes of TYPE. */
3343 type_binfo = TYPE_BINFO (type);
3344 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++)
3348 if (abi_version_at_least (2)
3349 && BINFO_VIRTUAL_P (binfo))
3353 && BINFO_VIRTUAL_P (binfo)
3354 && !BINFO_PRIMARY_P (binfo))
3357 if (!abi_version_at_least (2))
3358 binfo_offset = size_binop (PLUS_EXPR,
3360 BINFO_OFFSET (binfo));
3364 /* We cannot rely on BINFO_OFFSET being set for the base
3365 class yet, but the offsets for direct non-virtual
3366 bases can be calculated by going back to the TYPE. */
3367 orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
3368 binfo_offset = size_binop (PLUS_EXPR,
3370 BINFO_OFFSET (orig_binfo));
3373 r = walk_subobject_offsets (binfo,
3378 (abi_version_at_least (2)
3379 ? /*vbases_p=*/0 : vbases_p));
3384 if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type))
3387 VEC(tree,gc) *vbases;
3389 /* Iterate through the virtual base classes of TYPE. In G++
3390 3.2, we included virtual bases in the direct base class
3391 loop above, which results in incorrect results; the
3392 correct offsets for virtual bases are only known when
3393 working with the most derived type. */
3395 for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0;
3396 VEC_iterate (tree, vbases, ix, binfo); ix++)
3398 r = walk_subobject_offsets (binfo,
3400 size_binop (PLUS_EXPR,
3402 BINFO_OFFSET (binfo)),
3411 /* We still have to walk the primary base, if it is
3412 virtual. (If it is non-virtual, then it was walked
3414 tree vbase = get_primary_binfo (type_binfo);
3416 if (vbase && BINFO_VIRTUAL_P (vbase)
3417 && BINFO_PRIMARY_P (vbase)
3418 && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo)
3420 r = (walk_subobject_offsets
3422 offsets, max_offset, /*vbases_p=*/0));
3429 /* Iterate through the fields of TYPE. */
3430 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
3431 if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3435 if (abi_version_at_least (2))
3436 field_offset = byte_position (field);
3438 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3439 field_offset = DECL_FIELD_OFFSET (field);
3441 r = walk_subobject_offsets (TREE_TYPE (field),
3443 size_binop (PLUS_EXPR,
3453 else if (TREE_CODE (type) == ARRAY_TYPE)
3455 tree element_type = strip_array_types (type);
3456 tree domain = TYPE_DOMAIN (type);
3459 /* Avoid recursing into objects that are not interesting. */
3460 if (!CLASS_TYPE_P (element_type)
3461 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3464 /* Step through each of the elements in the array. */
3465 for (index = size_zero_node;
3466 /* G++ 3.2 had an off-by-one error here. */
3467 (abi_version_at_least (2)
3468 ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3469 : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3470 index = size_binop (PLUS_EXPR, index, size_one_node))
3472 r = walk_subobject_offsets (TREE_TYPE (type),
3480 offset = size_binop (PLUS_EXPR, offset,
3481 TYPE_SIZE_UNIT (TREE_TYPE (type)));
3482 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3483 there's no point in iterating through the remaining
3484 elements of the array. */
3485 if (max_offset && INT_CST_LT (max_offset, offset))
3493 /* Record all of the empty subobjects of TYPE (either a type or a
3494 binfo). If IS_DATA_MEMBER is true, then a non-static data member
3495 is being placed at OFFSET; otherwise, it is a base class that is
3496 being placed at OFFSET. */
3499 record_subobject_offsets (tree type,
3502 bool is_data_member)
3505 /* If recording subobjects for a non-static data member or a
3506 non-empty base class , we do not need to record offsets beyond
3507 the size of the biggest empty class. Additional data members
3508 will go at the end of the class. Additional base classes will go
3509 either at offset zero (if empty, in which case they cannot
3510 overlap with offsets past the size of the biggest empty class) or
3511 at the end of the class.
3513 However, if we are placing an empty base class, then we must record
3514 all offsets, as either the empty class is at offset zero (where
3515 other empty classes might later be placed) or at the end of the
3516 class (where other objects might then be placed, so other empty
3517 subobjects might later overlap). */
3519 || !is_empty_class (BINFO_TYPE (type)))
3520 max_offset = sizeof_biggest_empty_class;
3522 max_offset = NULL_TREE;
3523 walk_subobject_offsets (type, record_subobject_offset, offset,
3524 offsets, max_offset, is_data_member);
3527 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3528 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3529 virtual bases of TYPE are examined. */
3532 layout_conflict_p (tree type,
3537 splay_tree_node max_node;
3539 /* Get the node in OFFSETS that indicates the maximum offset where
3540 an empty subobject is located. */
3541 max_node = splay_tree_max (offsets);
3542 /* If there aren't any empty subobjects, then there's no point in
3543 performing this check. */
3547 return walk_subobject_offsets (type, check_subobject_offset, offset,
3548 offsets, (tree) (max_node->key),
3552 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3553 non-static data member of the type indicated by RLI. BINFO is the
3554 binfo corresponding to the base subobject, OFFSETS maps offsets to
3555 types already located at those offsets. This function determines
3556 the position of the DECL. */
3559 layout_nonempty_base_or_field (record_layout_info rli,
3564 tree offset = NULL_TREE;
3570 /* For the purposes of determining layout conflicts, we want to
3571 use the class type of BINFO; TREE_TYPE (DECL) will be the
3572 CLASSTYPE_AS_BASE version, which does not contain entries for
3573 zero-sized bases. */
3574 type = TREE_TYPE (binfo);
3579 type = TREE_TYPE (decl);
3583 /* Try to place the field. It may take more than one try if we have
3584 a hard time placing the field without putting two objects of the
3585 same type at the same address. */
3588 struct record_layout_info_s old_rli = *rli;
3590 /* Place this field. */
3591 place_field (rli, decl);
3592 offset = byte_position (decl);
3594 /* We have to check to see whether or not there is already
3595 something of the same type at the offset we're about to use.
3596 For example, consider:
3599 struct T : public S { int i; };
3600 struct U : public S, public T {};
3602 Here, we put S at offset zero in U. Then, we can't put T at
3603 offset zero -- its S component would be at the same address
3604 as the S we already allocated. So, we have to skip ahead.
3605 Since all data members, including those whose type is an
3606 empty class, have nonzero size, any overlap can happen only
3607 with a direct or indirect base-class -- it can't happen with
3609 /* In a union, overlap is permitted; all members are placed at
3611 if (TREE_CODE (rli->t) == UNION_TYPE)
3613 /* G++ 3.2 did not check for overlaps when placing a non-empty
3615 if (!abi_version_at_least (2) && binfo && BINFO_VIRTUAL_P (binfo))
3617 if (layout_conflict_p (field_p ? type : binfo, offset,
3620 /* Strip off the size allocated to this field. That puts us
3621 at the first place we could have put the field with
3622 proper alignment. */
3625 /* Bump up by the alignment required for the type. */
3627 = size_binop (PLUS_EXPR, rli->bitpos,
3629 ? CLASSTYPE_ALIGN (type)
3630 : TYPE_ALIGN (type)));
3631 normalize_rli (rli);
3634 /* There was no conflict. We're done laying out this field. */
3638 /* Now that we know where it will be placed, update its
3640 if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3641 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3642 this point because their BINFO_OFFSET is copied from another
3643 hierarchy. Therefore, we may not need to add the entire
3645 propagate_binfo_offsets (binfo,
3646 size_diffop_loc (input_location,
3647 convert (ssizetype, offset),
3649 BINFO_OFFSET (binfo))));
3652 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3655 empty_base_at_nonzero_offset_p (tree type,
3657 splay_tree offsets ATTRIBUTE_UNUSED)
3659 return is_empty_class (type) && !integer_zerop (offset);
3662 /* Layout the empty base BINFO. EOC indicates the byte currently just
3663 past the end of the class, and should be correctly aligned for a
3664 class of the type indicated by BINFO; OFFSETS gives the offsets of
3665 the empty bases allocated so far. T is the most derived
3666 type. Return nonzero iff we added it at the end. */
3669 layout_empty_base (record_layout_info rli, tree binfo,
3670 tree eoc, splay_tree offsets)
3673 tree basetype = BINFO_TYPE (binfo);
3676 /* This routine should only be used for empty classes. */
3677 gcc_assert (is_empty_class (basetype));
3678 alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3680 if (!integer_zerop (BINFO_OFFSET (binfo)))
3682 if (abi_version_at_least (2))
3683 propagate_binfo_offsets
3684 (binfo, size_diffop_loc (input_location,
3685 size_zero_node, BINFO_OFFSET (binfo)));
3688 "offset of empty base %qT may not be ABI-compliant and may"
3689 "change in a future version of GCC",
3690 BINFO_TYPE (binfo));
3693 /* This is an empty base class. We first try to put it at offset
3695 if (layout_conflict_p (binfo,
3696 BINFO_OFFSET (binfo),
3700 /* That didn't work. Now, we move forward from the next
3701 available spot in the class. */
3703 propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3706 if (!layout_conflict_p (binfo,
3707 BINFO_OFFSET (binfo),
3710 /* We finally found a spot where there's no overlap. */
3713 /* There's overlap here, too. Bump along to the next spot. */
3714 propagate_binfo_offsets (binfo, alignment);
3718 if (CLASSTYPE_USER_ALIGN (basetype))
3720 rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (basetype));
3722 rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (basetype));
3723 TYPE_USER_ALIGN (rli->t) = 1;
3729 /* Layout the base given by BINFO in the class indicated by RLI.
3730 *BASE_ALIGN is a running maximum of the alignments of
3731 any base class. OFFSETS gives the location of empty base
3732 subobjects. T is the most derived type. Return nonzero if the new
3733 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3734 *NEXT_FIELD, unless BINFO is for an empty base class.
3736 Returns the location at which the next field should be inserted. */
3739 build_base_field (record_layout_info rli, tree binfo,
3740 splay_tree offsets, tree *next_field)
3743 tree basetype = BINFO_TYPE (binfo);
3745 if (!COMPLETE_TYPE_P (basetype))
3746 /* This error is now reported in xref_tag, thus giving better
3747 location information. */
3750 /* Place the base class. */
3751 if (!is_empty_class (basetype))
3755 /* The containing class is non-empty because it has a non-empty
3757 CLASSTYPE_EMPTY_P (t) = 0;
3759 /* Create the FIELD_DECL. */
3760 decl = build_decl (input_location,
3761 FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3762 DECL_ARTIFICIAL (decl) = 1;
3763 DECL_IGNORED_P (decl) = 1;
3764 DECL_FIELD_CONTEXT (decl) = t;
3765 if (CLASSTYPE_AS_BASE (basetype))
3767 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3768 DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3769 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3770 DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3771 DECL_MODE (decl) = TYPE_MODE (basetype);
3772 DECL_FIELD_IS_BASE (decl) = 1;
3774 /* Try to place the field. It may take more than one try if we
3775 have a hard time placing the field without putting two
3776 objects of the same type at the same address. */
3777 layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3778 /* Add the new FIELD_DECL to the list of fields for T. */
3779 DECL_CHAIN (decl) = *next_field;
3781 next_field = &DECL_CHAIN (decl);
3789 /* On some platforms (ARM), even empty classes will not be
3791 eoc = round_up_loc (input_location,
3792 rli_size_unit_so_far (rli),
3793 CLASSTYPE_ALIGN_UNIT (basetype));
3794 atend = layout_empty_base (rli, binfo, eoc, offsets);
3795 /* A nearly-empty class "has no proper base class that is empty,
3796 not morally virtual, and at an offset other than zero." */
3797 if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3800 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3801 /* The check above (used in G++ 3.2) is insufficient because
3802 an empty class placed at offset zero might itself have an
3803 empty base at a nonzero offset. */
3804 else if (walk_subobject_offsets (basetype,
3805 empty_base_at_nonzero_offset_p,
3808 /*max_offset=*/NULL_TREE,
3811 if (abi_version_at_least (2))
3812 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3815 "class %qT will be considered nearly empty in a "
3816 "future version of GCC", t);
3820 /* We do not create a FIELD_DECL for empty base classes because
3821 it might overlap some other field. We want to be able to
3822 create CONSTRUCTORs for the class by iterating over the
3823 FIELD_DECLs, and the back end does not handle overlapping
3826 /* An empty virtual base causes a class to be non-empty
3827 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3828 here because that was already done when the virtual table
3829 pointer was created. */
3832 /* Record the offsets of BINFO and its base subobjects. */
3833 record_subobject_offsets (binfo,
3834 BINFO_OFFSET (binfo),
3836 /*is_data_member=*/false);
3841 /* Layout all of the non-virtual base classes. Record empty
3842 subobjects in OFFSETS. T is the most derived type. Return nonzero
3843 if the type cannot be nearly empty. The fields created
3844 corresponding to the base classes will be inserted at
3848 build_base_fields (record_layout_info rli,
3849 splay_tree offsets, tree *next_field)
3851 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3854 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t));
3857 /* The primary base class is always allocated first. */
3858 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3859 next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3860 offsets, next_field);
3862 /* Now allocate the rest of the bases. */
3863 for (i = 0; i < n_baseclasses; ++i)
3867 base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i);
3869 /* The primary base was already allocated above, so we don't
3870 need to allocate it again here. */
3871 if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3874 /* Virtual bases are added at the end (a primary virtual base
3875 will have already been added). */
3876 if (BINFO_VIRTUAL_P (base_binfo))
3879 next_field = build_base_field (rli, base_binfo,
3880 offsets, next_field);
3884 /* Go through the TYPE_METHODS of T issuing any appropriate
3885 diagnostics, figuring out which methods override which other
3886 methods, and so forth. */
3889 check_methods (tree t)
3893 for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x))
3895 check_for_override (x, t);
3896 if (DECL_PURE_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3897 error ("initializer specified for non-virtual method %q+D", x);
3898 /* The name of the field is the original field name
3899 Save this in auxiliary field for later overloading. */
3900 if (DECL_VINDEX (x))
3902 TYPE_POLYMORPHIC_P (t) = 1;
3903 if (DECL_PURE_VIRTUAL_P (x))
3904 VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
3906 /* All user-provided destructors are non-trivial.
3907 Constructors and assignment ops are handled in
3908 grok_special_member_properties. */
3909 if (DECL_DESTRUCTOR_P (x) && user_provided_p (x))
3910 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1;
3914 /* FN is a constructor or destructor. Clone the declaration to create
3915 a specialized in-charge or not-in-charge version, as indicated by
3919 build_clone (tree fn, tree name)
3924 /* Copy the function. */
3925 clone = copy_decl (fn);
3926 /* Reset the function name. */
3927 DECL_NAME (clone) = name;
3928 SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE);
3929 /* Remember where this function came from. */
3930 DECL_ABSTRACT_ORIGIN (clone) = fn;
3931 /* Make it easy to find the CLONE given the FN. */
3932 DECL_CHAIN (clone) = DECL_CHAIN (fn);
3933 DECL_CHAIN (fn) = clone;
3935 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
3936 if (TREE_CODE (clone) == TEMPLATE_DECL)
3938 tree result = build_clone (DECL_TEMPLATE_RESULT (clone), name);
3939 DECL_TEMPLATE_RESULT (clone) = result;
3940 DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result));
3941 DECL_TI_TEMPLATE (result) = clone;
3942 TREE_TYPE (clone) = TREE_TYPE (result);
3946 DECL_CLONED_FUNCTION (clone) = fn;
3947 /* There's no pending inline data for this function. */
3948 DECL_PENDING_INLINE_INFO (clone) = NULL;
3949 DECL_PENDING_INLINE_P (clone) = 0;
3951 /* The base-class destructor is not virtual. */
3952 if (name == base_dtor_identifier)
3954 DECL_VIRTUAL_P (clone) = 0;
3955 if (TREE_CODE (clone) != TEMPLATE_DECL)
3956 DECL_VINDEX (clone) = NULL_TREE;
3959 /* If there was an in-charge parameter, drop it from the function
3961 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3967 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
3968 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
3969 parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone));
3970 /* Skip the `this' parameter. */
3971 parmtypes = TREE_CHAIN (parmtypes);
3972 /* Skip the in-charge parameter. */
3973 parmtypes = TREE_CHAIN (parmtypes);
3974 /* And the VTT parm, in a complete [cd]tor. */
3975 if (DECL_HAS_VTT_PARM_P (fn)
3976 && ! DECL_NEEDS_VTT_PARM_P (clone))
3977 parmtypes = TREE_CHAIN (parmtypes);
3978 /* If this is subobject constructor or destructor, add the vtt
3981 = build_method_type_directly (basetype,
3982 TREE_TYPE (TREE_TYPE (clone)),
3985 TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone),
3988 = cp_build_type_attribute_variant (TREE_TYPE (clone),
3989 TYPE_ATTRIBUTES (TREE_TYPE (fn)));
3992 /* Copy the function parameters. */
3993 DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone));
3994 /* Remove the in-charge parameter. */
3995 if (DECL_HAS_IN_CHARGE_PARM_P (clone))
3997 DECL_CHAIN (DECL_ARGUMENTS (clone))
3998 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone)));
3999 DECL_HAS_IN_CHARGE_PARM_P (clone) = 0;
4001 /* And the VTT parm, in a complete [cd]tor. */
4002 if (DECL_HAS_VTT_PARM_P (fn))
4004 if (DECL_NEEDS_VTT_PARM_P (clone))
4005 DECL_HAS_VTT_PARM_P (clone) = 1;
4008 DECL_CHAIN (DECL_ARGUMENTS (clone))
4009 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone)));
4010 DECL_HAS_VTT_PARM_P (clone) = 0;
4014 for (parms = DECL_ARGUMENTS (clone); parms; parms = DECL_CHAIN (parms))
4016 DECL_CONTEXT (parms) = clone;
4017 cxx_dup_lang_specific_decl (parms);
4020 /* Create the RTL for this function. */
4021 SET_DECL_RTL (clone, NULL);
4022 rest_of_decl_compilation (clone, /*top_level=*/1, at_eof);
4025 note_decl_for_pch (clone);
4030 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
4031 not invoke this function directly.
4033 For a non-thunk function, returns the address of the slot for storing
4034 the function it is a clone of. Otherwise returns NULL_TREE.
4036 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
4037 cloned_function is unset. This is to support the separate
4038 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
4039 on a template makes sense, but not the former. */
4042 decl_cloned_function_p (const_tree decl, bool just_testing)
4046 decl = STRIP_TEMPLATE (decl);
4048 if (TREE_CODE (decl) != FUNCTION_DECL
4049 || !DECL_LANG_SPECIFIC (decl)
4050 || DECL_LANG_SPECIFIC (decl)->u.fn.thunk_p)
4052 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4054 lang_check_failed (__FILE__, __LINE__, __FUNCTION__);
4060 ptr = &DECL_LANG_SPECIFIC (decl)->u.fn.u5.cloned_function;
4061 if (just_testing && *ptr == NULL_TREE)
4067 /* Produce declarations for all appropriate clones of FN. If
4068 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4069 CLASTYPE_METHOD_VEC as well. */
4072 clone_function_decl (tree fn, int update_method_vec_p)
4076 /* Avoid inappropriate cloning. */
4078 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (fn)))
4081 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn))
4083 /* For each constructor, we need two variants: an in-charge version
4084 and a not-in-charge version. */
4085 clone = build_clone (fn, complete_ctor_identifier);
4086 if (update_method_vec_p)
4087 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4088 clone = build_clone (fn, base_ctor_identifier);
4089 if (update_method_vec_p)
4090 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4094 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn));
4096 /* For each destructor, we need three variants: an in-charge
4097 version, a not-in-charge version, and an in-charge deleting
4098 version. We clone the deleting version first because that
4099 means it will go second on the TYPE_METHODS list -- and that
4100 corresponds to the correct layout order in the virtual
4103 For a non-virtual destructor, we do not build a deleting
4105 if (DECL_VIRTUAL_P (fn))
4107 clone = build_clone (fn, deleting_dtor_identifier);
4108 if (update_method_vec_p)
4109 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4111 clone = build_clone (fn, complete_dtor_identifier);
4112 if (update_method_vec_p)
4113 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4114 clone = build_clone (fn, base_dtor_identifier);
4115 if (update_method_vec_p)
4116 add_method (DECL_CONTEXT (clone), clone, NULL_TREE);
4119 /* Note that this is an abstract function that is never emitted. */
4120 DECL_ABSTRACT (fn) = 1;
4123 /* DECL is an in charge constructor, which is being defined. This will
4124 have had an in class declaration, from whence clones were
4125 declared. An out-of-class definition can specify additional default
4126 arguments. As it is the clones that are involved in overload
4127 resolution, we must propagate the information from the DECL to its
4131 adjust_clone_args (tree decl)
4135 for (clone = DECL_CHAIN (decl); clone && DECL_CLONED_FUNCTION_P (clone);
4136 clone = DECL_CHAIN (clone))
4138 tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone));
4139 tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
4140 tree decl_parms, clone_parms;
4142 clone_parms = orig_clone_parms;
4144 /* Skip the 'this' parameter. */
4145 orig_clone_parms = TREE_CHAIN (orig_clone_parms);
4146 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4148 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
4149 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4150 if (DECL_HAS_VTT_PARM_P (decl))
4151 orig_decl_parms = TREE_CHAIN (orig_decl_parms);
4153 clone_parms = orig_clone_parms;
4154 if (DECL_HAS_VTT_PARM_P (clone))
4155 clone_parms = TREE_CHAIN (clone_parms);
4157 for (decl_parms = orig_decl_parms; decl_parms;
4158 decl_parms = TREE_CHAIN (decl_parms),
4159 clone_parms = TREE_CHAIN (clone_parms))
4161 gcc_assert (same_type_p (TREE_TYPE (decl_parms),
4162 TREE_TYPE (clone_parms)));
4164 if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
4166 /* A default parameter has been added. Adjust the
4167 clone's parameters. */
4168 tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
4169 tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (clone));
4170 tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
4173 clone_parms = orig_decl_parms;
4175 if (DECL_HAS_VTT_PARM_P (clone))
4177 clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms),
4178 TREE_VALUE (orig_clone_parms),
4180 TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms);
4182 type = build_method_type_directly (basetype,
4183 TREE_TYPE (TREE_TYPE (clone)),
4186 type = build_exception_variant (type, exceptions);
4188 type = cp_build_type_attribute_variant (type, attrs);
4189 TREE_TYPE (clone) = type;
4191 clone_parms = NULL_TREE;
4195 gcc_assert (!clone_parms);
4199 /* For each of the constructors and destructors in T, create an
4200 in-charge and not-in-charge variant. */
4203 clone_constructors_and_destructors (tree t)
4207 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4209 if (!CLASSTYPE_METHOD_VEC (t))
4212 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4213 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4214 for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4215 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1);
4218 /* Returns true iff class T has a user-defined constructor other than
4219 the default constructor. */
4222 type_has_user_nondefault_constructor (tree t)
4226 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4229 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4231 tree fn = OVL_CURRENT (fns);
4232 if (!DECL_ARTIFICIAL (fn)
4233 && (TREE_CODE (fn) == TEMPLATE_DECL
4234 || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn))
4242 /* Returns the defaulted constructor if T has one. Otherwise, returns
4246 in_class_defaulted_default_constructor (tree t)
4250 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4253 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4255 tree fn = OVL_CURRENT (fns);
4257 if (DECL_DEFAULTED_IN_CLASS_P (fn))
4259 args = FUNCTION_FIRST_USER_PARMTYPE (fn);
4260 while (args && TREE_PURPOSE (args))
4261 args = TREE_CHAIN (args);
4262 if (!args || args == void_list_node)
4270 /* Returns true iff FN is a user-provided function, i.e. user-declared
4271 and not defaulted at its first declaration; or explicit, private,
4272 protected, or non-const. */
4275 user_provided_p (tree fn)
4277 if (TREE_CODE (fn) == TEMPLATE_DECL)
4280 return (!DECL_ARTIFICIAL (fn)
4281 && !DECL_DEFAULTED_IN_CLASS_P (fn));
4284 /* Returns true iff class T has a user-provided constructor. */
4287 type_has_user_provided_constructor (tree t)
4291 if (!CLASS_TYPE_P (t))
4294 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4297 /* This can happen in error cases; avoid crashing. */
4298 if (!CLASSTYPE_METHOD_VEC (t))
4301 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4302 if (user_provided_p (OVL_CURRENT (fns)))
4308 /* Returns true iff class T has a user-provided default constructor. */
4311 type_has_user_provided_default_constructor (tree t)
4315 if (!TYPE_HAS_USER_CONSTRUCTOR (t))
4318 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4320 tree fn = OVL_CURRENT (fns);
4321 if (TREE_CODE (fn) == FUNCTION_DECL
4322 && user_provided_p (fn)
4323 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn)))
4330 /* Returns true iff for class T, a synthesized default constructor
4331 would be constexpr. */
4334 synthesized_default_constructor_is_constexpr (tree t)
4336 /* A defaulted default constructor is constexpr
4337 if there is nothing to initialize. */
4338 /* FIXME adjust for non-static data member initializers. */
4339 return is_really_empty_class (t);
4342 /* Returns true iff class T has a constexpr default constructor. */
4345 type_has_constexpr_default_constructor (tree t)
4349 if (!CLASS_TYPE_P (t))
4351 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t))
4352 return synthesized_default_constructor_is_constexpr (t);
4353 fns = get_default_ctor (t);
4354 return (fns && DECL_DECLARED_CONSTEXPR_P (fns));
4357 /* Returns true iff class TYPE has a virtual destructor. */
4360 type_has_virtual_destructor (tree type)
4364 if (!CLASS_TYPE_P (type))
4367 gcc_assert (COMPLETE_TYPE_P (type));
4368 dtor = CLASSTYPE_DESTRUCTORS (type);
4369 return (dtor && DECL_VIRTUAL_P (dtor));
4372 /* Returns true iff class T has a move constructor. */
4375 type_has_move_constructor (tree t)
4379 if (CLASSTYPE_LAZY_MOVE_CTOR (t))
4381 gcc_assert (COMPLETE_TYPE_P (t));
4382 lazily_declare_fn (sfk_move_constructor, t);
4385 if (!CLASSTYPE_METHOD_VEC (t))
4388 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns))
4389 if (move_fn_p (OVL_CURRENT (fns)))
4395 /* Returns true iff class T has a move assignment operator. */
4398 type_has_move_assign (tree t)
4402 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t))
4404 gcc_assert (COMPLETE_TYPE_P (t));
4405 lazily_declare_fn (sfk_move_assignment, t);
4408 for (fns = lookup_fnfields_slot (t, ansi_assopname (NOP_EXPR));
4409 fns; fns = OVL_NEXT (fns))
4410 if (move_fn_p (OVL_CURRENT (fns)))
4416 /* Remove all zero-width bit-fields from T. */
4419 remove_zero_width_bit_fields (tree t)
4423 fieldsp = &TYPE_FIELDS (t);
4426 if (TREE_CODE (*fieldsp) == FIELD_DECL
4427 && DECL_C_BIT_FIELD (*fieldsp)
4428 /* We should not be confused by the fact that grokbitfield
4429 temporarily sets the width of the bit field into
4430 DECL_INITIAL (*fieldsp).
4431 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
4433 && integer_zerop (DECL_SIZE (*fieldsp)))
4434 *fieldsp = DECL_CHAIN (*fieldsp);
4436 fieldsp = &DECL_CHAIN (*fieldsp);
4440 /* Returns TRUE iff we need a cookie when dynamically allocating an
4441 array whose elements have the indicated class TYPE. */
4444 type_requires_array_cookie (tree type)
4447 bool has_two_argument_delete_p = false;
4449 gcc_assert (CLASS_TYPE_P (type));
4451 /* If there's a non-trivial destructor, we need a cookie. In order
4452 to iterate through the array calling the destructor for each
4453 element, we'll have to know how many elements there are. */
4454 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4457 /* If the usual deallocation function is a two-argument whose second
4458 argument is of type `size_t', then we have to pass the size of
4459 the array to the deallocation function, so we will need to store
4461 fns = lookup_fnfields (TYPE_BINFO (type),
4462 ansi_opname (VEC_DELETE_EXPR),
4464 /* If there are no `operator []' members, or the lookup is
4465 ambiguous, then we don't need a cookie. */
4466 if (!fns || fns == error_mark_node)
4468 /* Loop through all of the functions. */
4469 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
4474 /* Select the current function. */
4475 fn = OVL_CURRENT (fns);
4476 /* See if this function is a one-argument delete function. If
4477 it is, then it will be the usual deallocation function. */
4478 second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
4479 if (second_parm == void_list_node)
4481 /* Do not consider this function if its second argument is an
4485 /* Otherwise, if we have a two-argument function and the second
4486 argument is `size_t', it will be the usual deallocation
4487 function -- unless there is one-argument function, too. */
4488 if (TREE_CHAIN (second_parm) == void_list_node
4489 && same_type_p (TREE_VALUE (second_parm), size_type_node))
4490 has_two_argument_delete_p = true;
4493 return has_two_argument_delete_p;
4496 /* Finish computing the `literal type' property of class type T.
4498 At this point, we have already processed base classes and
4499 non-static data members. We need to check whether the copy
4500 constructor is trivial, the destructor is trivial, and there
4501 is a trivial default constructor or at least one constexpr
4502 constructor other than the copy constructor. */
4505 finalize_literal_type_property (tree t)
4507 if (cxx_dialect < cxx0x
4508 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
4509 /* FIXME These constraints seem unnecessary; remove from standard.
4510 || !TYPE_HAS_TRIVIAL_COPY_CTOR (t)
4511 || TYPE_HAS_COMPLEX_MOVE_CTOR (t)*/ )
4512 CLASSTYPE_LITERAL_P (t) = false;
4513 else if (CLASSTYPE_LITERAL_P (t) && !TYPE_HAS_TRIVIAL_DFLT (t)
4514 && !TYPE_HAS_CONSTEXPR_CTOR (t))
4515 CLASSTYPE_LITERAL_P (t) = false;
4517 if (!CLASSTYPE_LITERAL_P (t) && !CLASSTYPE_TEMPLATE_INSTANTIATION (t))
4520 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4521 if (DECL_DECLARED_CONSTEXPR_P (fn)
4522 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
4523 && !DECL_CONSTRUCTOR_P (fn))
4525 error ("enclosing class of %q+D is not a literal type", fn);
4526 DECL_DECLARED_CONSTEXPR_P (fn) = false;
4531 /* Check the validity of the bases and members declared in T. Add any
4532 implicitly-generated functions (like copy-constructors and
4533 assignment operators). Compute various flag bits (like
4534 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
4535 level: i.e., independently of the ABI in use. */
4538 check_bases_and_members (tree t)
4540 /* Nonzero if the implicitly generated copy constructor should take
4541 a non-const reference argument. */
4542 int cant_have_const_ctor;
4543 /* Nonzero if the implicitly generated assignment operator
4544 should take a non-const reference argument. */
4545 int no_const_asn_ref;
4547 bool saved_complex_asn_ref;
4548 bool saved_nontrivial_dtor;
4551 /* By default, we use const reference arguments and generate default
4553 cant_have_const_ctor = 0;
4554 no_const_asn_ref = 0;
4556 /* Check all the base-classes. */
4557 check_bases (t, &cant_have_const_ctor,
4560 /* Check all the method declarations. */
4563 /* Save the initial values of these flags which only indicate whether
4564 or not the class has user-provided functions. As we analyze the
4565 bases and members we can set these flags for other reasons. */
4566 saved_complex_asn_ref = TYPE_HAS_COMPLEX_COPY_ASSIGN (t);
4567 saved_nontrivial_dtor = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t);
4569 /* Check all the data member declarations. We cannot call
4570 check_field_decls until we have called check_bases check_methods,
4571 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4572 being set appropriately. */
4573 check_field_decls (t, &access_decls,
4574 &cant_have_const_ctor,
4577 /* A nearly-empty class has to be vptr-containing; a nearly empty
4578 class contains just a vptr. */
4579 if (!TYPE_CONTAINS_VPTR_P (t))
4580 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
4582 /* Do some bookkeeping that will guide the generation of implicitly
4583 declared member functions. */
4584 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t);
4585 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t);
4586 /* We need to call a constructor for this class if it has a
4587 user-provided constructor, or if the default constructor is going
4588 to initialize the vptr. (This is not an if-and-only-if;
4589 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
4590 themselves need constructing.) */
4591 TYPE_NEEDS_CONSTRUCTING (t)
4592 |= (type_has_user_provided_constructor (t) || TYPE_CONTAINS_VPTR_P (t));
4595 An aggregate is an array or a class with no user-provided
4596 constructors ... and no virtual functions.
4598 Again, other conditions for being an aggregate are checked
4600 CLASSTYPE_NON_AGGREGATE (t)
4601 |= (type_has_user_provided_constructor (t) || TYPE_POLYMORPHIC_P (t));
4602 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
4603 retain the old definition internally for ABI reasons. */
4604 CLASSTYPE_NON_LAYOUT_POD_P (t)
4605 |= (CLASSTYPE_NON_AGGREGATE (t)
4606 || saved_nontrivial_dtor || saved_complex_asn_ref);
4607 CLASSTYPE_NON_STD_LAYOUT (t) |= TYPE_CONTAINS_VPTR_P (t);
4608 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t);
4609 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t);
4610 TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_CONTAINS_VPTR_P (t);
4612 /* If the class has no user-declared constructor, but does have
4613 non-static const or reference data members that can never be
4614 initialized, issue a warning. */
4615 if (warn_uninitialized
4616 /* Classes with user-declared constructors are presumed to
4617 initialize these members. */
4618 && !TYPE_HAS_USER_CONSTRUCTOR (t)
4619 /* Aggregates can be initialized with brace-enclosed
4621 && CLASSTYPE_NON_AGGREGATE (t))
4625 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4629 if (TREE_CODE (field) != FIELD_DECL)
4632 type = TREE_TYPE (field);
4633 if (TREE_CODE (type) == REFERENCE_TYPE)
4634 warning (OPT_Wuninitialized, "non-static reference %q+#D "
4635 "in class without a constructor", field);
4636 else if (CP_TYPE_CONST_P (type)
4637 && (!CLASS_TYPE_P (type)
4638 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4639 warning (OPT_Wuninitialized, "non-static const member %q+#D "
4640 "in class without a constructor", field);
4644 /* Synthesize any needed methods. */
4645 add_implicitly_declared_members (t,
4646 cant_have_const_ctor,
4649 /* Check defaulted declarations here so we have cant_have_const_ctor
4650 and don't need to worry about clones. */
4651 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4652 if (DECL_DEFAULTED_IN_CLASS_P (fn))
4654 int copy = copy_fn_p (fn);
4658 = (DECL_CONSTRUCTOR_P (fn) ? !cant_have_const_ctor
4659 : !no_const_asn_ref);
4660 bool fn_const_p = (copy == 2);
4662 if (fn_const_p && !imp_const_p)
4663 /* If the function is defaulted outside the class, we just
4664 give the synthesis error. */
4665 error ("%q+D declared to take const reference, but implicit "
4666 "declaration would take non-const", fn);
4667 else if (imp_const_p && !fn_const_p)
4668 error ("%q+D declared to take non-const reference cannot be "
4669 "defaulted in the class body", fn);
4671 defaulted_late_check (fn);
4674 if (LAMBDA_TYPE_P (t))
4676 /* "The closure type associated with a lambda-expression has a deleted
4677 default constructor and a deleted copy assignment operator." */
4678 TYPE_NEEDS_CONSTRUCTING (t) = 1;
4679 TYPE_HAS_COMPLEX_DFLT (t) = 1;
4680 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1;
4681 CLASSTYPE_LAZY_MOVE_ASSIGN (t) = 0;
4683 /* "This class type is not an aggregate." */
4684 CLASSTYPE_NON_AGGREGATE (t) = 1;
4687 /* Compute the 'literal type' property before we
4688 do anything with non-static member functions. */
4689 finalize_literal_type_property (t);
4691 /* Create the in-charge and not-in-charge variants of constructors
4693 clone_constructors_and_destructors (t);
4695 /* Process the using-declarations. */
4696 for (; access_decls; access_decls = TREE_CHAIN (access_decls))
4697 handle_using_decl (TREE_VALUE (access_decls), t);
4699 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4700 finish_struct_methods (t);
4702 /* Figure out whether or not we will need a cookie when dynamically
4703 allocating an array of this type. */
4704 TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie
4705 = type_requires_array_cookie (t);
4708 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4709 accordingly. If a new vfield was created (because T doesn't have a
4710 primary base class), then the newly created field is returned. It
4711 is not added to the TYPE_FIELDS list; it is the caller's
4712 responsibility to do that. Accumulate declared virtual functions
4716 create_vtable_ptr (tree t, tree* virtuals_p)
4720 /* Collect the virtual functions declared in T. */
4721 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
4722 if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4723 && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4725 tree new_virtual = make_node (TREE_LIST);
4727 BV_FN (new_virtual) = fn;
4728 BV_DELTA (new_virtual) = integer_zero_node;
4729 BV_VCALL_INDEX (new_virtual) = NULL_TREE;
4731 TREE_CHAIN (new_virtual) = *virtuals_p;
4732 *virtuals_p = new_virtual;
4735 /* If we couldn't find an appropriate base class, create a new field
4736 here. Even if there weren't any new virtual functions, we might need a
4737 new virtual function table if we're supposed to include vptrs in
4738 all classes that need them. */
4739 if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4741 /* We build this decl with vtbl_ptr_type_node, which is a
4742 `vtable_entry_type*'. It might seem more precise to use
4743 `vtable_entry_type (*)[N]' where N is the number of virtual
4744 functions. However, that would require the vtable pointer in
4745 base classes to have a different type than the vtable pointer
4746 in derived classes. We could make that happen, but that
4747 still wouldn't solve all the problems. In particular, the
4748 type-based alias analysis code would decide that assignments
4749 to the base class vtable pointer can't alias assignments to
4750 the derived class vtable pointer, since they have different
4751 types. Thus, in a derived class destructor, where the base
4752 class constructor was inlined, we could generate bad code for
4753 setting up the vtable pointer.
4755 Therefore, we use one type for all vtable pointers. We still
4756 use a type-correct type; it's just doesn't indicate the array
4757 bounds. That's better than using `void*' or some such; it's
4758 cleaner, and it let's the alias analysis code know that these
4759 stores cannot alias stores to void*! */
4762 field = build_decl (input_location,
4763 FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
4764 DECL_VIRTUAL_P (field) = 1;
4765 DECL_ARTIFICIAL (field) = 1;
4766 DECL_FIELD_CONTEXT (field) = t;
4767 DECL_FCONTEXT (field) = t;
4768 if (TYPE_PACKED (t))
4769 DECL_PACKED (field) = 1;
4771 TYPE_VFIELD (t) = field;
4773 /* This class is non-empty. */
4774 CLASSTYPE_EMPTY_P (t) = 0;
4782 /* Add OFFSET to all base types of BINFO which is a base in the
4783 hierarchy dominated by T.
4785 OFFSET, which is a type offset, is number of bytes. */
4788 propagate_binfo_offsets (tree binfo, tree offset)
4794 /* Update BINFO's offset. */
4795 BINFO_OFFSET (binfo)
4796 = convert (sizetype,
4797 size_binop (PLUS_EXPR,
4798 convert (ssizetype, BINFO_OFFSET (binfo)),
4801 /* Find the primary base class. */
4802 primary_binfo = get_primary_binfo (binfo);
4804 if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo)
4805 propagate_binfo_offsets (primary_binfo, offset);
4807 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4809 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4811 /* Don't do the primary base twice. */
4812 if (base_binfo == primary_binfo)
4815 if (BINFO_VIRTUAL_P (base_binfo))
4818 propagate_binfo_offsets (base_binfo, offset);
4822 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
4823 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4824 empty subobjects of T. */
4827 layout_virtual_bases (record_layout_info rli, splay_tree offsets)
4831 bool first_vbase = true;
4834 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0)
4837 if (!abi_version_at_least(2))
4839 /* In G++ 3.2, we incorrectly rounded the size before laying out
4840 the virtual bases. */
4841 finish_record_layout (rli, /*free_p=*/false);
4842 #ifdef STRUCTURE_SIZE_BOUNDARY
4843 /* Packed structures don't need to have minimum size. */
4844 if (! TYPE_PACKED (t))
4845 TYPE_ALIGN (t) = MAX (TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);
4847 rli->offset = TYPE_SIZE_UNIT (t);
4848 rli->bitpos = bitsize_zero_node;
4849 rli->record_align = TYPE_ALIGN (t);
4852 /* Find the last field. The artificial fields created for virtual
4853 bases will go after the last extant field to date. */
4854 next_field = &TYPE_FIELDS (t);
4856 next_field = &DECL_CHAIN (*next_field);
4858 /* Go through the virtual bases, allocating space for each virtual
4859 base that is not already a primary base class. These are
4860 allocated in inheritance graph order. */
4861 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
4863 if (!BINFO_VIRTUAL_P (vbase))
4866 if (!BINFO_PRIMARY_P (vbase))
4868 tree basetype = TREE_TYPE (vbase);
4870 /* This virtual base is not a primary base of any class in the
4871 hierarchy, so we have to add space for it. */
4872 next_field = build_base_field (rli, vbase,
4873 offsets, next_field);
4875 /* If the first virtual base might have been placed at a
4876 lower address, had we started from CLASSTYPE_SIZE, rather
4877 than TYPE_SIZE, issue a warning. There can be both false
4878 positives and false negatives from this warning in rare
4879 cases; to deal with all the possibilities would probably
4880 require performing both layout algorithms and comparing
4881 the results which is not particularly tractable. */
4885 (size_binop (CEIL_DIV_EXPR,
4886 round_up_loc (input_location,
4888 CLASSTYPE_ALIGN (basetype)),
4890 BINFO_OFFSET (vbase))))
4892 "offset of virtual base %qT is not ABI-compliant and "
4893 "may change in a future version of GCC",
4896 first_vbase = false;
4901 /* Returns the offset of the byte just past the end of the base class
4905 end_of_base (tree binfo)
4909 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo)))
4910 size = TYPE_SIZE_UNIT (char_type_node);
4911 else if (is_empty_class (BINFO_TYPE (binfo)))
4912 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4913 allocate some space for it. It cannot have virtual bases, so
4914 TYPE_SIZE_UNIT is fine. */
4915 size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4917 size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo));
4919 return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);
4922 /* Returns the offset of the byte just past the end of the base class
4923 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4924 only non-virtual bases are included. */
4927 end_of_class (tree t, int include_virtuals_p)
4929 tree result = size_zero_node;
4930 VEC(tree,gc) *vbases;
4936 for (binfo = TYPE_BINFO (t), i = 0;
4937 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4939 if (!include_virtuals_p
4940 && BINFO_VIRTUAL_P (base_binfo)
4941 && (!BINFO_PRIMARY_P (base_binfo)
4942 || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t)))
4945 offset = end_of_base (base_binfo);
4946 if (INT_CST_LT_UNSIGNED (result, offset))
4950 /* G++ 3.2 did not check indirect virtual bases. */
4951 if (abi_version_at_least (2) && include_virtuals_p)
4952 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
4953 VEC_iterate (tree, vbases, i, base_binfo); i++)
4955 offset = end_of_base (base_binfo);
4956 if (INT_CST_LT_UNSIGNED (result, offset))
4963 /* Warn about bases of T that are inaccessible because they are
4964 ambiguous. For example:
4967 struct T : public S {};
4968 struct U : public S, public T {};
4970 Here, `(S*) new U' is not allowed because there are two `S'
4974 warn_about_ambiguous_bases (tree t)
4977 VEC(tree,gc) *vbases;
4982 /* If there are no repeated bases, nothing can be ambiguous. */
4983 if (!CLASSTYPE_REPEATED_BASE_P (t))
4986 /* Check direct bases. */
4987 for (binfo = TYPE_BINFO (t), i = 0;
4988 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
4990 basetype = BINFO_TYPE (base_binfo);
4992 if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
4993 warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
4997 /* Check for ambiguous virtual bases. */
4999 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
5000 VEC_iterate (tree, vbases, i, binfo); i++)
5002 basetype = BINFO_TYPE (binfo);
5004 if (!lookup_base (t, basetype, ba_unique | ba_quiet, NULL))
5005 warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due to ambiguity",
5010 /* Compare two INTEGER_CSTs K1 and K2. */
5013 splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2)
5015 return tree_int_cst_compare ((tree) k1, (tree) k2);
5018 /* Increase the size indicated in RLI to account for empty classes
5019 that are "off the end" of the class. */
5022 include_empty_classes (record_layout_info rli)
5027 /* It might be the case that we grew the class to allocate a
5028 zero-sized base class. That won't be reflected in RLI, yet,
5029 because we are willing to overlay multiple bases at the same
5030 offset. However, now we need to make sure that RLI is big enough
5031 to reflect the entire class. */
5032 eoc = end_of_class (rli->t,
5033 CLASSTYPE_AS_BASE (rli->t) != NULL_TREE);
5034 rli_size = rli_size_unit_so_far (rli);
5035 if (TREE_CODE (rli_size) == INTEGER_CST
5036 && INT_CST_LT_UNSIGNED (rli_size, eoc))
5038 if (!abi_version_at_least (2))
5039 /* In version 1 of the ABI, the size of a class that ends with
5040 a bitfield was not rounded up to a whole multiple of a
5041 byte. Because rli_size_unit_so_far returns only the number
5042 of fully allocated bytes, any extra bits were not included
5044 rli->bitpos = round_down (rli->bitpos, BITS_PER_UNIT);
5046 /* The size should have been rounded to a whole byte. */
5047 gcc_assert (tree_int_cst_equal
5048 (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT)));
5050 = size_binop (PLUS_EXPR,
5052 size_binop (MULT_EXPR,
5053 convert (bitsizetype,
5054 size_binop (MINUS_EXPR,
5056 bitsize_int (BITS_PER_UNIT)));
5057 normalize_rli (rli);
5061 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5062 BINFO_OFFSETs for all of the base-classes. Position the vtable
5063 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
5066 layout_class_type (tree t, tree *virtuals_p)
5068 tree non_static_data_members;
5071 record_layout_info rli;
5072 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5073 types that appear at that offset. */
5074 splay_tree empty_base_offsets;
5075 /* True if the last field layed out was a bit-field. */
5076 bool last_field_was_bitfield = false;
5077 /* The location at which the next field should be inserted. */
5079 /* T, as a base class. */
5082 /* Keep track of the first non-static data member. */
5083 non_static_data_members = TYPE_FIELDS (t);
5085 /* Start laying out the record. */
5086 rli = start_record_layout (t);
5088 /* Mark all the primary bases in the hierarchy. */
5089 determine_primary_bases (t);
5091 /* Create a pointer to our virtual function table. */
5092 vptr = create_vtable_ptr (t, virtuals_p);
5094 /* The vptr is always the first thing in the class. */
5097 DECL_CHAIN (vptr) = TYPE_FIELDS (t);
5098 TYPE_FIELDS (t) = vptr;
5099 next_field = &DECL_CHAIN (vptr);
5100 place_field (rli, vptr);
5103 next_field = &TYPE_FIELDS (t);
5105 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5106 empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
5108 build_base_fields (rli, empty_base_offsets, next_field);
5110 /* Layout the non-static data members. */
5111 for (field = non_static_data_members; field; field = DECL_CHAIN (field))
5116 /* We still pass things that aren't non-static data members to
5117 the back end, in case it wants to do something with them. */
5118 if (TREE_CODE (field) != FIELD_DECL)
5120 place_field (rli, field);
5121 /* If the static data member has incomplete type, keep track
5122 of it so that it can be completed later. (The handling
5123 of pending statics in finish_record_layout is
5124 insufficient; consider:
5127 struct S2 { static S1 s1; };
5129 At this point, finish_record_layout will be called, but
5130 S1 is still incomplete.) */
5131 if (TREE_CODE (field) == VAR_DECL)
5133 maybe_register_incomplete_var (field);
5134 /* The visibility of static data members is determined
5135 at their point of declaration, not their point of
5137 determine_visibility (field);
5142 type = TREE_TYPE (field);
5143 if (type == error_mark_node)
5146 padding = NULL_TREE;
5148 /* If this field is a bit-field whose width is greater than its
5149 type, then there are some special rules for allocating
5151 if (DECL_C_BIT_FIELD (field)
5152 && INT_CST_LT (TYPE_SIZE (type), DECL_SIZE (field)))
5156 bool was_unnamed_p = false;
5157 /* We must allocate the bits as if suitably aligned for the
5158 longest integer type that fits in this many bits. type
5159 of the field. Then, we are supposed to use the left over
5160 bits as additional padding. */
5161 for (itk = itk_char; itk != itk_none; ++itk)
5162 if (integer_types[itk] != NULL_TREE
5163 && (INT_CST_LT (size_int (MAX_FIXED_MODE_SIZE),
5164 TYPE_SIZE (integer_types[itk]))
5165 || INT_CST_LT (DECL_SIZE (field),
5166 TYPE_SIZE (integer_types[itk]))))
5169 /* ITK now indicates a type that is too large for the
5170 field. We have to back up by one to find the largest
5175 integer_type = integer_types[itk];
5176 } while (itk > 0 && integer_type == NULL_TREE);
5178 /* Figure out how much additional padding is required. GCC
5179 3.2 always created a padding field, even if it had zero
5181 if (!abi_version_at_least (2)
5182 || INT_CST_LT (TYPE_SIZE (integer_type), DECL_SIZE (field)))
5184 if (abi_version_at_least (2) && TREE_CODE (t) == UNION_TYPE)
5185 /* In a union, the padding field must have the full width
5186 of the bit-field; all fields start at offset zero. */
5187 padding = DECL_SIZE (field);
5190 if (TREE_CODE (t) == UNION_TYPE)
5191 warning (OPT_Wabi, "size assigned to %qT may not be "
5192 "ABI-compliant and may change in a future "
5195 padding = size_binop (MINUS_EXPR, DECL_SIZE (field),
5196 TYPE_SIZE (integer_type));
5199 #ifdef PCC_BITFIELD_TYPE_MATTERS
5200 /* An unnamed bitfield does not normally affect the
5201 alignment of the containing class on a target where
5202 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
5203 make any exceptions for unnamed bitfields when the
5204 bitfields are longer than their types. Therefore, we
5205 temporarily give the field a name. */
5206 if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field))
5208 was_unnamed_p = true;
5209 DECL_NAME (field) = make_anon_name ();
5212 DECL_SIZE (field) = TYPE_SIZE (integer_type);
5213 DECL_ALIGN (field) = TYPE_ALIGN (integer_type);
5214 DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type);
5215 layout_nonempty_base_or_field (rli, field, NULL_TREE,
5216 empty_base_offsets);
5218 DECL_NAME (field) = NULL_TREE;
5219 /* Now that layout has been performed, set the size of the
5220 field to the size of its declared type; the rest of the
5221 field is effectively invisible. */
5222 DECL_SIZE (field) = TYPE_SIZE (type);
5223 /* We must also reset the DECL_MODE of the field. */
5224 if (abi_version_at_least (2))
5225 DECL_MODE (field) = TYPE_MODE (type);
5227 && DECL_MODE (field) != TYPE_MODE (type))
5228 /* Versions of G++ before G++ 3.4 did not reset the
5231 "the offset of %qD may not be ABI-compliant and may "
5232 "change in a future version of GCC", field);
5235 layout_nonempty_base_or_field (rli, field, NULL_TREE,
5236 empty_base_offsets);
5238 /* Remember the location of any empty classes in FIELD. */
5239 if (abi_version_at_least (2))
5240 record_subobject_offsets (TREE_TYPE (field),
5241 byte_position(field),
5243 /*is_data_member=*/true);
5245 /* If a bit-field does not immediately follow another bit-field,
5246 and yet it starts in the middle of a byte, we have failed to
5247 comply with the ABI. */
5249 && DECL_C_BIT_FIELD (field)
5250 /* The TREE_NO_WARNING flag gets set by Objective-C when
5251 laying out an Objective-C class. The ObjC ABI differs
5252 from the C++ ABI, and so we do not want a warning
5254 && !TREE_NO_WARNING (field)
5255 && !last_field_was_bitfield
5256 && !integer_zerop (size_binop (TRUNC_MOD_EXPR,
5257 DECL_FIELD_BIT_OFFSET (field),
5258 bitsize_unit_node)))
5259 warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may "
5260 "change in a future version of GCC", field);
5262 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
5263 offset of the field. */
5265 && !abi_version_at_least (2)
5266 && !tree_int_cst_equal (DECL_FIELD_OFFSET (field),
5267 byte_position (field))
5268 && contains_empty_class_p (TREE_TYPE (field)))
5269 warning (OPT_Wabi, "%q+D contains empty classes which may cause base "
5270 "classes to be placed at different locations in a "
5271 "future version of GCC", field);
5273 /* The middle end uses the type of expressions to determine the
5274 possible range of expression values. In order to optimize
5275 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
5276 must be made aware of the width of "i", via its type.
5278 Because C++ does not have integer types of arbitrary width,
5279 we must (for the purposes of the front end) convert from the
5280 type assigned here to the declared type of the bitfield
5281 whenever a bitfield expression is used as an rvalue.
5282 Similarly, when assigning a value to a bitfield, the value
5283 must be converted to the type given the bitfield here. */
5284 if (DECL_C_BIT_FIELD (field))
5286 unsigned HOST_WIDE_INT width;
5287 tree ftype = TREE_TYPE (field);
5288 width = tree_low_cst (DECL_SIZE (field), /*unsignedp=*/1);
5289 if (width != TYPE_PRECISION (ftype))
5292 = c_build_bitfield_integer_type (width,
5293 TYPE_UNSIGNED (ftype));
5295 = cp_build_qualified_type (TREE_TYPE (field),
5296 cp_type_quals (ftype));
5300 /* If we needed additional padding after this field, add it
5306 padding_field = build_decl (input_location,
5310 DECL_BIT_FIELD (padding_field) = 1;
5311 DECL_SIZE (padding_field) = padding;
5312 DECL_CONTEXT (padding_field) = t;
5313 DECL_ARTIFICIAL (padding_field) = 1;
5314 DECL_IGNORED_P (padding_field) = 1;
5315 layout_nonempty_base_or_field (rli, padding_field,
5317 empty_base_offsets);
5320 last_field_was_bitfield = DECL_C_BIT_FIELD (field);
5323 if (abi_version_at_least (2) && !integer_zerop (rli->bitpos))
5325 /* Make sure that we are on a byte boundary so that the size of
5326 the class without virtual bases will always be a round number
5328 rli->bitpos = round_up_loc (input_location, rli->bitpos, BITS_PER_UNIT);
5329 normalize_rli (rli);
5332 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5334 if (!abi_version_at_least (2))
5335 include_empty_classes(rli);
5337 /* Delete all zero-width bit-fields from the list of fields. Now
5338 that the type is laid out they are no longer important. */
5339 remove_zero_width_bit_fields (t);
5341 /* Create the version of T used for virtual bases. We do not use
5342 make_class_type for this version; this is an artificial type. For
5343 a POD type, we just reuse T. */
5344 if (CLASSTYPE_NON_LAYOUT_POD_P (t) || CLASSTYPE_EMPTY_P (t))
5346 base_t = make_node (TREE_CODE (t));
5348 /* Set the size and alignment for the new type. In G++ 3.2, all
5349 empty classes were considered to have size zero when used as
5351 if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t))
5353 TYPE_SIZE (base_t) = bitsize_zero_node;
5354 TYPE_SIZE_UNIT (base_t) = size_zero_node;
5355 if (warn_abi && !integer_zerop (rli_size_unit_so_far (rli)))
5357 "layout of classes derived from empty class %qT "
5358 "may change in a future version of GCC",
5365 /* If the ABI version is not at least two, and the last
5366 field was a bit-field, RLI may not be on a byte
5367 boundary. In particular, rli_size_unit_so_far might
5368 indicate the last complete byte, while rli_size_so_far
5369 indicates the total number of bits used. Therefore,
5370 rli_size_so_far, rather than rli_size_unit_so_far, is
5371 used to compute TYPE_SIZE_UNIT. */
5372 eoc = end_of_class (t, /*include_virtuals_p=*/0);
5373 TYPE_SIZE_UNIT (base_t)
5374 = size_binop (MAX_EXPR,
5376 size_binop (CEIL_DIV_EXPR,
5377 rli_size_so_far (rli),
5378 bitsize_int (BITS_PER_UNIT))),
5381 = size_binop (MAX_EXPR,
5382 rli_size_so_far (rli),
5383 size_binop (MULT_EXPR,
5384 convert (bitsizetype, eoc),
5385 bitsize_int (BITS_PER_UNIT)));
5387 TYPE_ALIGN (base_t) = rli->record_align;
5388 TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);
5390 /* Copy the fields from T. */
5391 next_field = &TYPE_FIELDS (base_t);
5392 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
5393 if (TREE_CODE (field) == FIELD_DECL)
5395 *next_field = build_decl (input_location,
5399 DECL_CONTEXT (*next_field) = base_t;
5400 DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field);
5401 DECL_FIELD_BIT_OFFSET (*next_field)
5402 = DECL_FIELD_BIT_OFFSET (field);
5403 DECL_SIZE (*next_field) = DECL_SIZE (field);
5404 DECL_MODE (*next_field) = DECL_MODE (field);
5405 next_field = &DECL_CHAIN (*next_field);
5408 /* Record the base version of the type. */
5409 CLASSTYPE_AS_BASE (t) = base_t;
5410 TYPE_CONTEXT (base_t) = t;
5413 CLASSTYPE_AS_BASE (t) = t;
5415 /* Every empty class contains an empty class. */
5416 if (CLASSTYPE_EMPTY_P (t))
5417 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;
5419 /* Set the TYPE_DECL for this type to contain the right
5420 value for DECL_OFFSET, so that we can use it as part
5421 of a COMPONENT_REF for multiple inheritance. */
5422 layout_decl (TYPE_MAIN_DECL (t), 0);
5424 /* Now fix up any virtual base class types that we left lying
5425 around. We must get these done before we try to lay out the
5426 virtual function table. As a side-effect, this will remove the
5427 base subobject fields. */
5428 layout_virtual_bases (rli, empty_base_offsets);
5430 /* Make sure that empty classes are reflected in RLI at this
5432 include_empty_classes(rli);
5434 /* Make sure not to create any structures with zero size. */
5435 if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t))
5437 build_decl (input_location,
5438 FIELD_DECL, NULL_TREE, char_type_node));
5440 /* If this is a non-POD, declaring it packed makes a difference to how it
5441 can be used as a field; don't let finalize_record_size undo it. */
5442 if (TYPE_PACKED (t) && !layout_pod_type_p (t))
5443 rli->packed_maybe_necessary = true;
5445 /* Let the back end lay out the type. */
5446 finish_record_layout (rli, /*free_p=*/true);
5448 /* Warn about bases that can't be talked about due to ambiguity. */
5449 warn_about_ambiguous_bases (t);
5451 /* Now that we're done with layout, give the base fields the real types. */
5452 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
5453 if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field)))
5454 TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field));
5457 splay_tree_delete (empty_base_offsets);
5459 if (CLASSTYPE_EMPTY_P (t)
5460 && tree_int_cst_lt (sizeof_biggest_empty_class,
5461 TYPE_SIZE_UNIT (t)))
5462 sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t);
5465 /* Determine the "key method" for the class type indicated by TYPE,
5466 and set CLASSTYPE_KEY_METHOD accordingly. */
5469 determine_key_method (tree type)
5473 if (TYPE_FOR_JAVA (type)
5474 || processing_template_decl
5475 || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
5476 || CLASSTYPE_INTERFACE_KNOWN (type))
5479 /* The key method is the first non-pure virtual function that is not
5480 inline at the point of class definition. On some targets the
5481 key function may not be inline; those targets should not call
5482 this function until the end of the translation unit. */
5483 for (method = TYPE_METHODS (type); method != NULL_TREE;
5484 method = DECL_CHAIN (method))
5485 if (DECL_VINDEX (method) != NULL_TREE
5486 && ! DECL_DECLARED_INLINE_P (method)
5487 && ! DECL_PURE_VIRTUAL_P (method))
5489 CLASSTYPE_KEY_METHOD (type) = method;
5496 /* Perform processing required when the definition of T (a class type)
5500 finish_struct_1 (tree t)
5503 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
5504 tree virtuals = NULL_TREE;
5507 if (COMPLETE_TYPE_P (t))
5509 gcc_assert (MAYBE_CLASS_TYPE_P (t));
5510 error ("redefinition of %q#T", t);
5515 /* If this type was previously laid out as a forward reference,
5516 make sure we lay it out again. */
5517 TYPE_SIZE (t) = NULL_TREE;
5518 CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
5520 /* Make assumptions about the class; we'll reset the flags if
5522 CLASSTYPE_EMPTY_P (t) = 1;
5523 CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
5524 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;
5525 CLASSTYPE_LITERAL_P (t) = true;
5527 /* Do end-of-class semantic processing: checking the validity of the
5528 bases and members and add implicitly generated methods. */
5529 check_bases_and_members (t);
5531 /* Find the key method. */
5532 if (TYPE_CONTAINS_VPTR_P (t))
5534 /* The Itanium C++ ABI permits the key method to be chosen when
5535 the class is defined -- even though the key method so
5536 selected may later turn out to be an inline function. On
5537 some systems (such as ARM Symbian OS) the key method cannot
5538 be determined until the end of the translation unit. On such
5539 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
5540 will cause the class to be added to KEYED_CLASSES. Then, in
5541 finish_file we will determine the key method. */
5542 if (targetm.cxx.key_method_may_be_inline ())
5543 determine_key_method (t);
5545 /* If a polymorphic class has no key method, we may emit the vtable
5546 in every translation unit where the class definition appears. */
5547 if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5548 keyed_classes = tree_cons (NULL_TREE, t, keyed_classes);
5551 /* Layout the class itself. */
5552 layout_class_type (t, &virtuals);
5553 if (CLASSTYPE_AS_BASE (t) != t)
5554 /* We use the base type for trivial assignments, and hence it
5556 compute_record_mode (CLASSTYPE_AS_BASE (t));
5558 virtuals = modify_all_vtables (t, nreverse (virtuals));
5560 /* If necessary, create the primary vtable for this class. */
5561 if (virtuals || TYPE_CONTAINS_VPTR_P (t))
5563 /* We must enter these virtuals into the table. */
5564 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5565 build_primary_vtable (NULL_TREE, t);
5566 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
5567 /* Here we know enough to change the type of our virtual
5568 function table, but we will wait until later this function. */
5569 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t);
5572 if (TYPE_CONTAINS_VPTR_P (t))
5577 if (BINFO_VTABLE (TYPE_BINFO (t)))
5578 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t))));
5579 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5580 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE);
5582 /* Add entries for virtual functions introduced by this class. */
5583 BINFO_VIRTUALS (TYPE_BINFO (t))
5584 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals);
5586 /* Set DECL_VINDEX for all functions declared in this class. */
5587 for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t));
5589 fn = TREE_CHAIN (fn),
5590 vindex += (TARGET_VTABLE_USES_DESCRIPTORS
5591 ? TARGET_VTABLE_USES_DESCRIPTORS : 1))
5593 tree fndecl = BV_FN (fn);
5595 if (DECL_THUNK_P (fndecl))
5596 /* A thunk. We should never be calling this entry directly
5597 from this vtable -- we'd use the entry for the non
5598 thunk base function. */
5599 DECL_VINDEX (fndecl) = NULL_TREE;
5600 else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
5601 DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
5605 finish_struct_bits (t);
5607 /* Complete the rtl for any static member objects of the type we're
5609 for (x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x))
5610 if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5611 && TREE_TYPE (x) != error_mark_node
5612 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5613 DECL_MODE (x) = TYPE_MODE (t);
5615 /* Done with FIELDS...now decide whether to sort these for
5616 faster lookups later.
5618 We use a small number because most searches fail (succeeding
5619 ultimately as the search bores through the inheritance
5620 hierarchy), and we want this failure to occur quickly. */
5622 n_fields = count_fields (TYPE_FIELDS (t));
5625 struct sorted_fields_type *field_vec = ggc_alloc_sorted_fields_type
5626 (sizeof (struct sorted_fields_type) + n_fields * sizeof (tree));
5627 field_vec->len = n_fields;
5628 add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5629 qsort (field_vec->elts, n_fields, sizeof (tree),
5631 CLASSTYPE_SORTED_FIELDS (t) = field_vec;
5634 /* Complain if one of the field types requires lower visibility. */
5635 constrain_class_visibility (t);
5637 /* Make the rtl for any new vtables we have created, and unmark
5638 the base types we marked. */
5641 /* Build the VTT for T. */
5644 /* This warning does not make sense for Java classes, since they
5645 cannot have destructors. */
5646 if (!TYPE_FOR_JAVA (t) && warn_nonvdtor && TYPE_POLYMORPHIC_P (t))
5650 dtor = CLASSTYPE_DESTRUCTORS (t);
5651 if (/* An implicitly declared destructor is always public. And,
5652 if it were virtual, we would have created it by now. */
5654 || (!DECL_VINDEX (dtor)
5655 && (/* public non-virtual */
5656 (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor))
5657 || (/* non-public non-virtual with friends */
5658 (TREE_PRIVATE (dtor) || TREE_PROTECTED (dtor))
5659 && (CLASSTYPE_FRIEND_CLASSES (t)
5660 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t)))))))
5661 warning (OPT_Wnon_virtual_dtor,
5662 "%q#T has virtual functions and accessible"
5663 " non-virtual destructor", t);
5668 if (warn_overloaded_virtual)
5671 /* Class layout, assignment of virtual table slots, etc., is now
5672 complete. Give the back end a chance to tweak the visibility of
5673 the class or perform any other required target modifications. */
5674 targetm.cxx.adjust_class_at_definition (t);
5676 maybe_suppress_debug_info (t);
5678 dump_class_hierarchy (t);
5680 /* Finish debugging output for this type. */
5681 rest_of_type_compilation (t, ! LOCAL_CLASS_P (t));
5684 /* When T was built up, the member declarations were added in reverse
5685 order. Rearrange them to declaration order. */
5688 unreverse_member_declarations (tree t)
5694 /* The following lists are all in reverse order. Put them in
5695 declaration order now. */
5696 TYPE_METHODS (t) = nreverse (TYPE_METHODS (t));
5697 CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t));
5699 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5700 reverse order, so we can't just use nreverse. */
5702 for (x = TYPE_FIELDS (t);
5703 x && TREE_CODE (x) != TYPE_DECL;
5706 next = DECL_CHAIN (x);
5707 DECL_CHAIN (x) = prev;
5712 DECL_CHAIN (TYPE_FIELDS (t)) = x;
5714 TYPE_FIELDS (t) = prev;
5719 finish_struct (tree t, tree attributes)
5721 location_t saved_loc = input_location;
5723 /* Now that we've got all the field declarations, reverse everything
5725 unreverse_member_declarations (t);
5727 cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
5729 /* Nadger the current location so that diagnostics point to the start of
5730 the struct, not the end. */
5731 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t));
5733 if (processing_template_decl)
5737 finish_struct_methods (t);
5738 TYPE_SIZE (t) = bitsize_zero_node;
5739 TYPE_SIZE_UNIT (t) = size_zero_node;
5741 /* We need to emit an error message if this type was used as a parameter
5742 and it is an abstract type, even if it is a template. We construct
5743 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5744 account and we call complete_vars with this type, which will check
5745 the PARM_DECLS. Note that while the type is being defined,
5746 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5747 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
5748 CLASSTYPE_PURE_VIRTUALS (t) = NULL;
5749 for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x))
5750 if (DECL_PURE_VIRTUAL_P (x))
5751 VEC_safe_push (tree, gc, CLASSTYPE_PURE_VIRTUALS (t), x);
5754 /* Remember current #pragma pack value. */
5755 TYPE_PRECISION (t) = maximum_field_alignment;
5758 finish_struct_1 (t);
5760 input_location = saved_loc;
5762 TYPE_BEING_DEFINED (t) = 0;
5764 if (current_class_type)
5767 error ("trying to finish struct, but kicked out due to previous parse errors");
5769 if (processing_template_decl && at_function_scope_p ())
5770 add_stmt (build_min (TAG_DEFN, t));
5775 /* Return the dynamic type of INSTANCE, if known.
5776 Used to determine whether the virtual function table is needed
5779 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5780 of our knowledge of its type. *NONNULL should be initialized
5781 before this function is called. */
5784 fixed_type_or_null (tree instance, int *nonnull, int *cdtorp)
5786 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
5788 switch (TREE_CODE (instance))
5791 if (POINTER_TYPE_P (TREE_TYPE (instance)))
5794 return RECUR (TREE_OPERAND (instance, 0));
5797 /* This is a call to a constructor, hence it's never zero. */
5798 if (TREE_HAS_CONSTRUCTOR (instance))
5802 return TREE_TYPE (instance);
5807 /* This is a call to a constructor, hence it's never zero. */
5808 if (TREE_HAS_CONSTRUCTOR (instance))
5812 return TREE_TYPE (instance);
5814 return RECUR (TREE_OPERAND (instance, 0));
5816 case POINTER_PLUS_EXPR:
5819 if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
5820 return RECUR (TREE_OPERAND (instance, 0));
5821 if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
5822 /* Propagate nonnull. */
5823 return RECUR (TREE_OPERAND (instance, 0));
5828 return RECUR (TREE_OPERAND (instance, 0));
5831 instance = TREE_OPERAND (instance, 0);
5834 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5835 with a real object -- given &p->f, p can still be null. */
5836 tree t = get_base_address (instance);
5837 /* ??? Probably should check DECL_WEAK here. */
5838 if (t && DECL_P (t))
5841 return RECUR (instance);
5844 /* If this component is really a base class reference, then the field
5845 itself isn't definitive. */
5846 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1)))
5847 return RECUR (TREE_OPERAND (instance, 0));
5848 return RECUR (TREE_OPERAND (instance, 1));
5852 if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
5853 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance))))
5857 return TREE_TYPE (TREE_TYPE (instance));
5859 /* fall through... */
5863 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance)))
5867 return TREE_TYPE (instance);
5869 else if (instance == current_class_ptr)
5874 /* if we're in a ctor or dtor, we know our type. */
5875 if (DECL_LANG_SPECIFIC (current_function_decl)
5876 && (DECL_CONSTRUCTOR_P (current_function_decl)
5877 || DECL_DESTRUCTOR_P (current_function_decl)))
5881 return TREE_TYPE (TREE_TYPE (instance));
5884 else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
5886 /* We only need one hash table because it is always left empty. */
5889 ht = htab_create (37,
5894 /* Reference variables should be references to objects. */
5898 /* Enter the INSTANCE in a table to prevent recursion; a
5899 variable's initializer may refer to the variable
5901 if (TREE_CODE (instance) == VAR_DECL
5902 && DECL_INITIAL (instance)
5903 && !htab_find (ht, instance))
5908 slot = htab_find_slot (ht, instance, INSERT);
5910 type = RECUR (DECL_INITIAL (instance));
5911 htab_remove_elt (ht, instance);
5924 /* Return nonzero if the dynamic type of INSTANCE is known, and
5925 equivalent to the static type. We also handle the case where
5926 INSTANCE is really a pointer. Return negative if this is a
5927 ctor/dtor. There the dynamic type is known, but this might not be
5928 the most derived base of the original object, and hence virtual
5929 bases may not be layed out according to this type.
5931 Used to determine whether the virtual function table is needed
5934 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5935 of our knowledge of its type. *NONNULL should be initialized
5936 before this function is called. */
5939 resolves_to_fixed_type_p (tree instance, int* nonnull)
5941 tree t = TREE_TYPE (instance);
5943 tree fixed = fixed_type_or_null (instance, nonnull, &cdtorp);
5944 if (fixed == NULL_TREE)
5946 if (POINTER_TYPE_P (t))
5948 if (!same_type_ignoring_top_level_qualifiers_p (t, fixed))
5950 return cdtorp ? -1 : 1;
5955 init_class_processing (void)
5957 current_class_depth = 0;
5958 current_class_stack_size = 10;
5960 = XNEWVEC (struct class_stack_node, current_class_stack_size);
5961 local_classes = VEC_alloc (tree, gc, 8);
5962 sizeof_biggest_empty_class = size_zero_node;
5964 ridpointers[(int) RID_PUBLIC] = access_public_node;
5965 ridpointers[(int) RID_PRIVATE] = access_private_node;
5966 ridpointers[(int) RID_PROTECTED] = access_protected_node;
5969 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
5972 restore_class_cache (void)
5976 /* We are re-entering the same class we just left, so we don't
5977 have to search the whole inheritance matrix to find all the
5978 decls to bind again. Instead, we install the cached
5979 class_shadowed list and walk through it binding names. */
5980 push_binding_level (previous_class_level);
5981 class_binding_level = previous_class_level;
5982 /* Restore IDENTIFIER_TYPE_VALUE. */
5983 for (type = class_binding_level->type_shadowed;
5985 type = TREE_CHAIN (type))
5986 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type));
5989 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5990 appropriate for TYPE.
5992 So that we may avoid calls to lookup_name, we cache the _TYPE
5993 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5995 For multiple inheritance, we perform a two-pass depth-first search
5996 of the type lattice. */
5999 pushclass (tree type)
6001 class_stack_node_t csn;
6003 type = TYPE_MAIN_VARIANT (type);
6005 /* Make sure there is enough room for the new entry on the stack. */
6006 if (current_class_depth + 1 >= current_class_stack_size)
6008 current_class_stack_size *= 2;
6010 = XRESIZEVEC (struct class_stack_node, current_class_stack,
6011 current_class_stack_size);
6014 /* Insert a new entry on the class stack. */
6015 csn = current_class_stack + current_class_depth;
6016 csn->name = current_class_name;
6017 csn->type = current_class_type;
6018 csn->access = current_access_specifier;
6019 csn->names_used = 0;
6021 current_class_depth++;
6023 /* Now set up the new type. */
6024 current_class_name = TYPE_NAME (type);
6025 if (TREE_CODE (current_class_name) == TYPE_DECL)
6026 current_class_name = DECL_NAME (current_class_name);
6027 current_class_type = type;
6029 /* By default, things in classes are private, while things in
6030 structures or unions are public. */
6031 current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type)
6032 ? access_private_node
6033 : access_public_node);
6035 if (previous_class_level
6036 && type != previous_class_level->this_entity
6037 && current_class_depth == 1)
6039 /* Forcibly remove any old class remnants. */
6040 invalidate_class_lookup_cache ();
6043 if (!previous_class_level
6044 || type != previous_class_level->this_entity
6045 || current_class_depth > 1)
6048 restore_class_cache ();
6051 /* When we exit a toplevel class scope, we save its binding level so
6052 that we can restore it quickly. Here, we've entered some other
6053 class, so we must invalidate our cache. */
6056 invalidate_class_lookup_cache (void)
6058 previous_class_level = NULL;
6061 /* Get out of the current class scope. If we were in a class scope
6062 previously, that is the one popped to. */
6069 current_class_depth--;
6070 current_class_name = current_class_stack[current_class_depth].name;
6071 current_class_type = current_class_stack[current_class_depth].type;
6072 current_access_specifier = current_class_stack[current_class_depth].access;
6073 if (current_class_stack[current_class_depth].names_used)
6074 splay_tree_delete (current_class_stack[current_class_depth].names_used);
6077 /* Mark the top of the class stack as hidden. */
6080 push_class_stack (void)
6082 if (current_class_depth)
6083 ++current_class_stack[current_class_depth - 1].hidden;
6086 /* Mark the top of the class stack as un-hidden. */
6089 pop_class_stack (void)
6091 if (current_class_depth)
6092 --current_class_stack[current_class_depth - 1].hidden;
6095 /* Returns 1 if the class type currently being defined is either T or
6096 a nested type of T. */
6099 currently_open_class (tree t)
6103 if (!CLASS_TYPE_P (t))
6106 t = TYPE_MAIN_VARIANT (t);
6108 /* We start looking from 1 because entry 0 is from global scope,
6110 for (i = current_class_depth; i > 0; --i)
6113 if (i == current_class_depth)
6114 c = current_class_type;
6117 if (current_class_stack[i].hidden)
6119 c = current_class_stack[i].type;
6123 if (same_type_p (c, t))
6129 /* If either current_class_type or one of its enclosing classes are derived
6130 from T, return the appropriate type. Used to determine how we found
6131 something via unqualified lookup. */
6134 currently_open_derived_class (tree t)
6138 /* The bases of a dependent type are unknown. */
6139 if (dependent_type_p (t))
6142 if (!current_class_type)
6145 if (DERIVED_FROM_P (t, current_class_type))
6146 return current_class_type;
6148 for (i = current_class_depth - 1; i > 0; --i)
6150 if (current_class_stack[i].hidden)
6152 if (DERIVED_FROM_P (t, current_class_stack[i].type))
6153 return current_class_stack[i].type;
6159 /* Returns the innermost class type which is not a lambda closure type. */
6162 current_nonlambda_class_type (void)
6166 /* We start looking from 1 because entry 0 is from global scope,
6168 for (i = current_class_depth; i > 0; --i)
6171 if (i == current_class_depth)
6172 c = current_class_type;
6175 if (current_class_stack[i].hidden)
6177 c = current_class_stack[i].type;
6181 if (!LAMBDA_TYPE_P (c))
6187 /* When entering a class scope, all enclosing class scopes' names with
6188 static meaning (static variables, static functions, types and
6189 enumerators) have to be visible. This recursive function calls
6190 pushclass for all enclosing class contexts until global or a local
6191 scope is reached. TYPE is the enclosed class. */
6194 push_nested_class (tree type)
6196 /* A namespace might be passed in error cases, like A::B:C. */
6197 if (type == NULL_TREE
6198 || !CLASS_TYPE_P (type))
6201 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type)));
6206 /* Undoes a push_nested_class call. */
6209 pop_nested_class (void)
6211 tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type));
6214 if (context && CLASS_TYPE_P (context))
6215 pop_nested_class ();
6218 /* Returns the number of extern "LANG" blocks we are nested within. */
6221 current_lang_depth (void)
6223 return VEC_length (tree, current_lang_base);
6226 /* Set global variables CURRENT_LANG_NAME to appropriate value
6227 so that behavior of name-mangling machinery is correct. */
6230 push_lang_context (tree name)
6232 VEC_safe_push (tree, gc, current_lang_base, current_lang_name);
6234 if (name == lang_name_cplusplus)
6236 current_lang_name = name;
6238 else if (name == lang_name_java)
6240 current_lang_name = name;
6241 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6242 (See record_builtin_java_type in decl.c.) However, that causes
6243 incorrect debug entries if these types are actually used.
6244 So we re-enable debug output after extern "Java". */
6245 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
6246 DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
6247 DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
6248 DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0;
6249 DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0;
6250 DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0;
6251 DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0;
6252 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0;
6254 else if (name == lang_name_c)
6256 current_lang_name = name;
6259 error ("language string %<\"%E\"%> not recognized", name);
6262 /* Get out of the current language scope. */
6265 pop_lang_context (void)
6267 current_lang_name = VEC_pop (tree, current_lang_base);
6270 /* Type instantiation routines. */
6272 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6273 matches the TARGET_TYPE. If there is no satisfactory match, return
6274 error_mark_node, and issue an error & warning messages under
6275 control of FLAGS. Permit pointers to member function if FLAGS
6276 permits. If TEMPLATE_ONLY, the name of the overloaded function was
6277 a template-id, and EXPLICIT_TARGS are the explicitly provided
6280 If OVERLOAD is for one or more member functions, then ACCESS_PATH
6281 is the base path used to reference those member functions. If
6282 TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
6283 resolved to a member function, access checks will be performed and
6284 errors issued if appropriate. */
6287 resolve_address_of_overloaded_function (tree target_type,
6289 tsubst_flags_t flags,
6291 tree explicit_targs,
6294 /* Here's what the standard says:
6298 If the name is a function template, template argument deduction
6299 is done, and if the argument deduction succeeds, the deduced
6300 arguments are used to generate a single template function, which
6301 is added to the set of overloaded functions considered.
6303 Non-member functions and static member functions match targets of
6304 type "pointer-to-function" or "reference-to-function." Nonstatic
6305 member functions match targets of type "pointer-to-member
6306 function;" the function type of the pointer to member is used to
6307 select the member function from the set of overloaded member
6308 functions. If a nonstatic member function is selected, the
6309 reference to the overloaded function name is required to have the
6310 form of a pointer to member as described in 5.3.1.
6312 If more than one function is selected, any template functions in
6313 the set are eliminated if the set also contains a non-template
6314 function, and any given template function is eliminated if the
6315 set contains a second template function that is more specialized
6316 than the first according to the partial ordering rules 14.5.5.2.
6317 After such eliminations, if any, there shall remain exactly one
6318 selected function. */
6321 /* We store the matches in a TREE_LIST rooted here. The functions
6322 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6323 interoperability with most_specialized_instantiation. */
6324 tree matches = NULL_TREE;
6326 tree target_fn_type;
6328 /* By the time we get here, we should be seeing only real
6329 pointer-to-member types, not the internal POINTER_TYPE to
6330 METHOD_TYPE representation. */
6331 gcc_assert (TREE_CODE (target_type) != POINTER_TYPE
6332 || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE);
6334 gcc_assert (is_overloaded_fn (overload));
6336 /* Check that the TARGET_TYPE is reasonable. */
6337 if (TYPE_PTRFN_P (target_type))
6339 else if (TYPE_PTRMEMFUNC_P (target_type))
6340 /* This is OK, too. */
6342 else if (TREE_CODE (target_type) == FUNCTION_TYPE)
6343 /* This is OK, too. This comes from a conversion to reference
6345 target_type = build_reference_type (target_type);
6348 if (flags & tf_error)
6349 error ("cannot resolve overloaded function %qD based on"
6350 " conversion to type %qT",
6351 DECL_NAME (OVL_FUNCTION (overload)), target_type);
6352 return error_mark_node;
6355 /* Non-member functions and static member functions match targets of type
6356 "pointer-to-function" or "reference-to-function." Nonstatic member
6357 functions match targets of type "pointer-to-member-function;" the
6358 function type of the pointer to member is used to select the member
6359 function from the set of overloaded member functions.
6361 So figure out the FUNCTION_TYPE that we want to match against. */
6362 target_fn_type = static_fn_type (target_type);
6364 /* If we can find a non-template function that matches, we can just
6365 use it. There's no point in generating template instantiations
6366 if we're just going to throw them out anyhow. But, of course, we
6367 can only do this when we don't *need* a template function. */
6372 for (fns = overload; fns; fns = OVL_NEXT (fns))
6374 tree fn = OVL_CURRENT (fns);
6376 if (TREE_CODE (fn) == TEMPLATE_DECL)
6377 /* We're not looking for templates just yet. */
6380 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6382 /* We're looking for a non-static member, and this isn't
6383 one, or vice versa. */
6386 /* Ignore functions which haven't been explicitly
6388 if (DECL_ANTICIPATED (fn))
6391 /* See if there's a match. */
6392 if (same_type_p (target_fn_type, static_fn_type (fn)))
6393 matches = tree_cons (fn, NULL_TREE, matches);
6397 /* Now, if we've already got a match (or matches), there's no need
6398 to proceed to the template functions. But, if we don't have a
6399 match we need to look at them, too. */
6402 tree target_arg_types;
6403 tree target_ret_type;
6406 unsigned int nargs, ia;
6409 target_arg_types = TYPE_ARG_TYPES (target_fn_type);
6410 target_ret_type = TREE_TYPE (target_fn_type);
6412 nargs = list_length (target_arg_types);
6413 args = XALLOCAVEC (tree, nargs);
6414 for (arg = target_arg_types, ia = 0;
6415 arg != NULL_TREE && arg != void_list_node;
6416 arg = TREE_CHAIN (arg), ++ia)
6417 args[ia] = TREE_VALUE (arg);
6420 for (fns = overload; fns; fns = OVL_NEXT (fns))
6422 tree fn = OVL_CURRENT (fns);
6426 if (TREE_CODE (fn) != TEMPLATE_DECL)
6427 /* We're only looking for templates. */
6430 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
6432 /* We're not looking for a non-static member, and this is
6433 one, or vice versa. */
6436 /* Try to do argument deduction. */
6437 targs = make_tree_vec (DECL_NTPARMS (fn));
6438 if (fn_type_unification (fn, explicit_targs, targs, args, nargs,
6439 target_ret_type, DEDUCE_EXACT,
6441 /* Argument deduction failed. */
6444 /* Instantiate the template. */
6445 instantiation = instantiate_template (fn, targs, flags);
6446 if (instantiation == error_mark_node)
6447 /* Instantiation failed. */
6450 /* See if there's a match. */
6451 if (same_type_p (target_fn_type, static_fn_type (instantiation)))
6452 matches = tree_cons (instantiation, fn, matches);
6455 /* Now, remove all but the most specialized of the matches. */
6458 tree match = most_specialized_instantiation (matches);
6460 if (match != error_mark_node)
6461 matches = tree_cons (TREE_PURPOSE (match),
6467 /* Now we should have exactly one function in MATCHES. */
6468 if (matches == NULL_TREE)
6470 /* There were *no* matches. */
6471 if (flags & tf_error)
6473 error ("no matches converting function %qD to type %q#T",
6474 DECL_NAME (OVL_CURRENT (overload)),
6477 /* print_candidates expects a chain with the functions in
6478 TREE_VALUE slots, so we cons one up here (we're losing anyway,
6479 so why be clever?). */
6480 for (; overload; overload = OVL_NEXT (overload))
6481 matches = tree_cons (NULL_TREE, OVL_CURRENT (overload),
6484 print_candidates (matches);
6486 return error_mark_node;
6488 else if (TREE_CHAIN (matches))
6490 /* There were too many matches. First check if they're all
6491 the same function. */
6494 fn = TREE_PURPOSE (matches);
6495 for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match))
6496 if (!decls_match (fn, TREE_PURPOSE (match)))
6501 if (flags & tf_error)
6503 error ("converting overloaded function %qD to type %q#T is ambiguous",
6504 DECL_NAME (OVL_FUNCTION (overload)),
6507 /* Since print_candidates expects the functions in the
6508 TREE_VALUE slot, we flip them here. */
6509 for (match = matches; match; match = TREE_CHAIN (match))
6510 TREE_VALUE (match) = TREE_PURPOSE (match);
6512 print_candidates (matches);
6515 return error_mark_node;
6519 /* Good, exactly one match. Now, convert it to the correct type. */
6520 fn = TREE_PURPOSE (matches);
6522 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
6523 && !(flags & tf_ptrmem_ok) && !flag_ms_extensions)
6525 static int explained;
6527 if (!(flags & tf_error))
6528 return error_mark_node;
6530 permerror (input_location, "assuming pointer to member %qD", fn);
6533 inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn);
6538 /* If we're doing overload resolution purely for the purpose of
6539 determining conversion sequences, we should not consider the
6540 function used. If this conversion sequence is selected, the
6541 function will be marked as used at this point. */
6542 if (!(flags & tf_conv))
6544 /* Make =delete work with SFINAE. */
6545 if (DECL_DELETED_FN (fn) && !(flags & tf_error))
6546 return error_mark_node;
6551 /* We could not check access to member functions when this
6552 expression was originally created since we did not know at that
6553 time to which function the expression referred. */
6554 if (!(flags & tf_no_access_control)
6555 && DECL_FUNCTION_MEMBER_P (fn))
6557 gcc_assert (access_path);
6558 perform_or_defer_access_check (access_path, fn, fn);
6561 if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type))
6562 return cp_build_addr_expr (fn, flags);
6565 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
6566 will mark the function as addressed, but here we must do it
6568 cxx_mark_addressable (fn);
6574 /* This function will instantiate the type of the expression given in
6575 RHS to match the type of LHSTYPE. If errors exist, then return
6576 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
6577 we complain on errors. If we are not complaining, never modify rhs,
6578 as overload resolution wants to try many possible instantiations, in
6579 the hope that at least one will work.
6581 For non-recursive calls, LHSTYPE should be a function, pointer to
6582 function, or a pointer to member function. */
6585 instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
6587 tsubst_flags_t flags_in = flags;
6588 tree access_path = NULL_TREE;
6590 flags &= ~tf_ptrmem_ok;
6592 if (lhstype == unknown_type_node)
6594 if (flags & tf_error)
6595 error ("not enough type information");
6596 return error_mark_node;
6599 if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
6601 if (same_type_p (lhstype, TREE_TYPE (rhs)))
6603 if (flag_ms_extensions
6604 && TYPE_PTRMEMFUNC_P (lhstype)
6605 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs)))
6606 /* Microsoft allows `A::f' to be resolved to a
6607 pointer-to-member. */
6611 if (flags & tf_error)
6612 error ("argument of type %qT does not match %qT",
6613 TREE_TYPE (rhs), lhstype);
6614 return error_mark_node;
6618 if (TREE_CODE (rhs) == BASELINK)
6620 access_path = BASELINK_ACCESS_BINFO (rhs);
6621 rhs = BASELINK_FUNCTIONS (rhs);
6624 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
6625 deduce any type information. */
6626 if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR)
6628 if (flags & tf_error)
6629 error ("not enough type information");
6630 return error_mark_node;
6633 /* There only a few kinds of expressions that may have a type
6634 dependent on overload resolution. */
6635 gcc_assert (TREE_CODE (rhs) == ADDR_EXPR
6636 || TREE_CODE (rhs) == COMPONENT_REF
6637 || really_overloaded_fn (rhs)
6638 || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL));
6640 /* This should really only be used when attempting to distinguish
6641 what sort of a pointer to function we have. For now, any
6642 arithmetic operation which is not supported on pointers
6643 is rejected as an error. */
6645 switch (TREE_CODE (rhs))
6649 tree member = TREE_OPERAND (rhs, 1);
6651 member = instantiate_type (lhstype, member, flags);
6652 if (member != error_mark_node
6653 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
6654 /* Do not lose object's side effects. */
6655 return build2 (COMPOUND_EXPR, TREE_TYPE (member),
6656 TREE_OPERAND (rhs, 0), member);
6661 rhs = TREE_OPERAND (rhs, 1);
6662 if (BASELINK_P (rhs))
6663 return instantiate_type (lhstype, rhs, flags_in);
6665 /* This can happen if we are forming a pointer-to-member for a
6667 gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR);
6671 case TEMPLATE_ID_EXPR:
6673 tree fns = TREE_OPERAND (rhs, 0);
6674 tree args = TREE_OPERAND (rhs, 1);
6677 resolve_address_of_overloaded_function (lhstype, fns, flags_in,
6678 /*template_only=*/true,
6685 resolve_address_of_overloaded_function (lhstype, rhs, flags_in,
6686 /*template_only=*/false,
6687 /*explicit_targs=*/NULL_TREE,
6692 if (PTRMEM_OK_P (rhs))
6693 flags |= tf_ptrmem_ok;
6695 return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags);
6699 return error_mark_node;
6704 return error_mark_node;
6707 /* Return the name of the virtual function pointer field
6708 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6709 this may have to look back through base types to find the
6710 ultimate field name. (For single inheritance, these could
6711 all be the same name. Who knows for multiple inheritance). */
6714 get_vfield_name (tree type)
6716 tree binfo, base_binfo;
6719 for (binfo = TYPE_BINFO (type);
6720 BINFO_N_BASE_BINFOS (binfo);
6723 base_binfo = BINFO_BASE_BINFO (binfo, 0);
6725 if (BINFO_VIRTUAL_P (base_binfo)
6726 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo)))
6730 type = BINFO_TYPE (binfo);
6731 buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT)
6732 + TYPE_NAME_LENGTH (type) + 2);
6733 sprintf (buf, VFIELD_NAME_FORMAT,
6734 IDENTIFIER_POINTER (constructor_name (type)));
6735 return get_identifier (buf);
6739 print_class_statistics (void)
6741 #ifdef GATHER_STATISTICS
6742 fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
6743 fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
6746 fprintf (stderr, "vtables = %d; vtable searches = %d\n",
6747 n_vtables, n_vtable_searches);
6748 fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
6749 n_vtable_entries, n_vtable_elems);
6754 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6755 according to [class]:
6756 The class-name is also inserted
6757 into the scope of the class itself. For purposes of access checking,
6758 the inserted class name is treated as if it were a public member name. */
6761 build_self_reference (void)
6763 tree name = constructor_name (current_class_type);
6764 tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6767 DECL_NONLOCAL (value) = 1;
6768 DECL_CONTEXT (value) = current_class_type;
6769 DECL_ARTIFICIAL (value) = 1;
6770 SET_DECL_SELF_REFERENCE_P (value);
6771 set_underlying_type (value);
6773 if (processing_template_decl)
6774 value = push_template_decl (value);
6776 saved_cas = current_access_specifier;
6777 current_access_specifier = access_public_node;
6778 finish_member_declaration (value);
6779 current_access_specifier = saved_cas;
6782 /* Returns 1 if TYPE contains only padding bytes. */
6785 is_empty_class (tree type)
6787 if (type == error_mark_node)
6790 if (! CLASS_TYPE_P (type))
6793 /* In G++ 3.2, whether or not a class was empty was determined by
6794 looking at its size. */
6795 if (abi_version_at_least (2))
6796 return CLASSTYPE_EMPTY_P (type);
6798 return integer_zerop (CLASSTYPE_SIZE (type));
6801 /* Returns true if TYPE contains an empty class. */
6804 contains_empty_class_p (tree type)
6806 if (is_empty_class (type))
6808 if (CLASS_TYPE_P (type))
6815 for (binfo = TYPE_BINFO (type), i = 0;
6816 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6817 if (contains_empty_class_p (BINFO_TYPE (base_binfo)))
6819 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6820 if (TREE_CODE (field) == FIELD_DECL
6821 && !DECL_ARTIFICIAL (field)
6822 && is_empty_class (TREE_TYPE (field)))
6825 else if (TREE_CODE (type) == ARRAY_TYPE)
6826 return contains_empty_class_p (TREE_TYPE (type));
6830 /* Returns true if TYPE contains no actual data, just various
6831 possible combinations of empty classes and possibly a vptr. */
6834 is_really_empty_class (tree type)
6836 if (CLASS_TYPE_P (type))
6843 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
6844 out, but we'd like to be able to check this before then. */
6845 if (COMPLETE_TYPE_P (type) && is_empty_class (type))
6848 for (binfo = TYPE_BINFO (type), i = 0;
6849 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
6850 if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
6852 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6853 if (TREE_CODE (field) == FIELD_DECL
6854 && !DECL_ARTIFICIAL (field)
6855 && !is_really_empty_class (TREE_TYPE (field)))
6859 else if (TREE_CODE (type) == ARRAY_TYPE)
6860 return is_really_empty_class (TREE_TYPE (type));
6864 /* Note that NAME was looked up while the current class was being
6865 defined and that the result of that lookup was DECL. */
6868 maybe_note_name_used_in_class (tree name, tree decl)
6870 splay_tree names_used;
6872 /* If we're not defining a class, there's nothing to do. */
6873 if (!(innermost_scope_kind() == sk_class
6874 && TYPE_BEING_DEFINED (current_class_type)
6875 && !LAMBDA_TYPE_P (current_class_type)))
6878 /* If there's already a binding for this NAME, then we don't have
6879 anything to worry about. */
6880 if (lookup_member (current_class_type, name,
6881 /*protect=*/0, /*want_type=*/false))
6884 if (!current_class_stack[current_class_depth - 1].names_used)
6885 current_class_stack[current_class_depth - 1].names_used
6886 = splay_tree_new (splay_tree_compare_pointers, 0, 0);
6887 names_used = current_class_stack[current_class_depth - 1].names_used;
6889 splay_tree_insert (names_used,
6890 (splay_tree_key) name,
6891 (splay_tree_value) decl);
6894 /* Note that NAME was declared (as DECL) in the current class. Check
6895 to see that the declaration is valid. */
6898 note_name_declared_in_class (tree name, tree decl)
6900 splay_tree names_used;
6903 /* Look to see if we ever used this name. */
6905 = current_class_stack[current_class_depth - 1].names_used;
6908 /* The C language allows members to be declared with a type of the same
6909 name, and the C++ standard says this diagnostic is not required. So
6910 allow it in extern "C" blocks unless predantic is specified.
6911 Allow it in all cases if -ms-extensions is specified. */
6912 if ((!pedantic && current_lang_name == lang_name_c)
6913 || flag_ms_extensions)
6915 n = splay_tree_lookup (names_used, (splay_tree_key) name);
6918 /* [basic.scope.class]
6920 A name N used in a class S shall refer to the same declaration
6921 in its context and when re-evaluated in the completed scope of
6923 permerror (input_location, "declaration of %q#D", decl);
6924 permerror (input_location, "changes meaning of %qD from %q+#D",
6925 DECL_NAME (OVL_CURRENT (decl)), (tree) n->value);
6929 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6930 Secondary vtables are merged with primary vtables; this function
6931 will return the VAR_DECL for the primary vtable. */
6934 get_vtbl_decl_for_binfo (tree binfo)
6938 decl = BINFO_VTABLE (binfo);
6939 if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR)
6941 gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR);
6942 decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6945 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6950 /* Returns the binfo for the primary base of BINFO. If the resulting
6951 BINFO is a virtual base, and it is inherited elsewhere in the
6952 hierarchy, then the returned binfo might not be the primary base of
6953 BINFO in the complete object. Check BINFO_PRIMARY_P or
6954 BINFO_LOST_PRIMARY_P to be sure. */
6957 get_primary_binfo (tree binfo)
6961 primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6965 return copied_binfo (primary_base, binfo);
6968 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
6971 maybe_indent_hierarchy (FILE * stream, int indent, int indented_p)
6974 fprintf (stream, "%*s", indent, "");
6978 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6979 INDENT should be zero when called from the top level; it is
6980 incremented recursively. IGO indicates the next expected BINFO in
6981 inheritance graph ordering. */
6984 dump_class_hierarchy_r (FILE *stream,
6994 indented = maybe_indent_hierarchy (stream, indent, 0);
6995 fprintf (stream, "%s (0x%lx) ",
6996 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER),
6997 (unsigned long) binfo);
7000 fprintf (stream, "alternative-path\n");
7003 igo = TREE_CHAIN (binfo);
7005 fprintf (stream, HOST_WIDE_INT_PRINT_DEC,
7006 tree_low_cst (BINFO_OFFSET (binfo), 0));
7007 if (is_empty_class (BINFO_TYPE (binfo)))
7008 fprintf (stream, " empty");
7009 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo)))
7010 fprintf (stream, " nearly-empty");
7011 if (BINFO_VIRTUAL_P (binfo))
7012 fprintf (stream, " virtual");
7013 fprintf (stream, "\n");
7016 if (BINFO_PRIMARY_P (binfo))
7018 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7019 fprintf (stream, " primary-for %s (0x%lx)",
7020 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)),
7021 TFF_PLAIN_IDENTIFIER),
7022 (unsigned long)BINFO_INHERITANCE_CHAIN (binfo));
7024 if (BINFO_LOST_PRIMARY_P (binfo))
7026 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7027 fprintf (stream, " lost-primary");
7030 fprintf (stream, "\n");
7032 if (!(flags & TDF_SLIM))
7036 if (BINFO_SUBVTT_INDEX (binfo))
7038 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7039 fprintf (stream, " subvttidx=%s",
7040 expr_as_string (BINFO_SUBVTT_INDEX (binfo),
7041 TFF_PLAIN_IDENTIFIER));
7043 if (BINFO_VPTR_INDEX (binfo))
7045 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7046 fprintf (stream, " vptridx=%s",
7047 expr_as_string (BINFO_VPTR_INDEX (binfo),
7048 TFF_PLAIN_IDENTIFIER));
7050 if (BINFO_VPTR_FIELD (binfo))
7052 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7053 fprintf (stream, " vbaseoffset=%s",
7054 expr_as_string (BINFO_VPTR_FIELD (binfo),
7055 TFF_PLAIN_IDENTIFIER));
7057 if (BINFO_VTABLE (binfo))
7059 indented = maybe_indent_hierarchy (stream, indent + 3, indented);
7060 fprintf (stream, " vptr=%s",
7061 expr_as_string (BINFO_VTABLE (binfo),
7062 TFF_PLAIN_IDENTIFIER));
7066 fprintf (stream, "\n");
7069 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
7070 igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2);
7075 /* Dump the BINFO hierarchy for T. */
7078 dump_class_hierarchy_1 (FILE *stream, int flags, tree t)
7080 fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER));
7081 fprintf (stream, " size=%lu align=%lu\n",
7082 (unsigned long)(tree_low_cst (TYPE_SIZE (t), 0) / BITS_PER_UNIT),
7083 (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT));
7084 fprintf (stream, " base size=%lu base align=%lu\n",
7085 (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t)), 0)
7087 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t))
7089 dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0);
7090 fprintf (stream, "\n");
7093 /* Debug interface to hierarchy dumping. */
7096 debug_class (tree t)
7098 dump_class_hierarchy_1 (stderr, TDF_SLIM, t);
7102 dump_class_hierarchy (tree t)
7105 FILE *stream = dump_begin (TDI_class, &flags);
7109 dump_class_hierarchy_1 (stream, flags, t);
7110 dump_end (TDI_class, stream);
7115 dump_array (FILE * stream, tree decl)
7118 unsigned HOST_WIDE_INT ix;
7120 tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl)));
7122 elt = (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))), 0)
7124 fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER));
7125 fprintf (stream, " %s entries",
7126 expr_as_string (size_binop (PLUS_EXPR, size, size_one_node),
7127 TFF_PLAIN_IDENTIFIER));
7128 fprintf (stream, "\n");
7130 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
7132 fprintf (stream, "%-4ld %s\n", (long)(ix * elt),
7133 expr_as_string (value, TFF_PLAIN_IDENTIFIER));
7137 dump_vtable (tree t, tree binfo, tree vtable)
7140 FILE *stream = dump_begin (TDI_class, &flags);
7145 if (!(flags & TDF_SLIM))
7147 int ctor_vtbl_p = TYPE_BINFO (t) != binfo;
7149 fprintf (stream, "%s for %s",
7150 ctor_vtbl_p ? "Construction vtable" : "Vtable",
7151 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER));
7154 if (!BINFO_VIRTUAL_P (binfo))
7155 fprintf (stream, " (0x%lx instance)", (unsigned long)binfo);
7156 fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER));
7158 fprintf (stream, "\n");
7159 dump_array (stream, vtable);
7160 fprintf (stream, "\n");
7163 dump_end (TDI_class, stream);
7167 dump_vtt (tree t, tree vtt)
7170 FILE *stream = dump_begin (TDI_class, &flags);
7175 if (!(flags & TDF_SLIM))
7177 fprintf (stream, "VTT for %s\n",
7178 type_as_string (t, TFF_PLAIN_IDENTIFIER));
7179 dump_array (stream, vtt);
7180 fprintf (stream, "\n");
7183 dump_end (TDI_class, stream);
7186 /* Dump a function or thunk and its thunkees. */
7189 dump_thunk (FILE *stream, int indent, tree thunk)
7191 static const char spaces[] = " ";
7192 tree name = DECL_NAME (thunk);
7195 fprintf (stream, "%.*s%p %s %s", indent, spaces,
7197 !DECL_THUNK_P (thunk) ? "function"
7198 : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk",
7199 name ? IDENTIFIER_POINTER (name) : "<unset>");
7200 if (DECL_THUNK_P (thunk))
7202 HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk);
7203 tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk);
7205 fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust);
7206 if (!virtual_adjust)
7208 else if (DECL_THIS_THUNK_P (thunk))
7209 fprintf (stream, " vcall=" HOST_WIDE_INT_PRINT_DEC,
7210 tree_low_cst (virtual_adjust, 0));
7212 fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)",
7213 tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust), 0),
7214 type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE));
7215 if (THUNK_ALIAS (thunk))
7216 fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk));
7218 fprintf (stream, "\n");
7219 for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks))
7220 dump_thunk (stream, indent + 2, thunks);
7223 /* Dump the thunks for FN. */
7226 debug_thunks (tree fn)
7228 dump_thunk (stderr, 0, fn);
7231 /* Virtual function table initialization. */
7233 /* Create all the necessary vtables for T and its base classes. */
7236 finish_vtbls (tree t)
7239 VEC(constructor_elt,gc) *v = NULL;
7240 tree vtable = BINFO_VTABLE (TYPE_BINFO (t));
7242 /* We lay out the primary and secondary vtables in one contiguous
7243 vtable. The primary vtable is first, followed by the non-virtual
7244 secondary vtables in inheritance graph order. */
7245 accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t), TYPE_BINFO (t),
7248 /* Then come the virtual bases, also in inheritance graph order. */
7249 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
7251 if (!BINFO_VIRTUAL_P (vbase))
7253 accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), vtable, t, &v);
7256 if (BINFO_VTABLE (TYPE_BINFO (t)))
7257 initialize_vtable (TYPE_BINFO (t), v);
7260 /* Initialize the vtable for BINFO with the INITS. */
7263 initialize_vtable (tree binfo, VEC(constructor_elt,gc) *inits)
7267 layout_vtable_decl (binfo, VEC_length (constructor_elt, inits));
7268 decl = get_vtbl_decl_for_binfo (binfo);
7269 initialize_artificial_var (decl, inits);
7270 dump_vtable (BINFO_TYPE (binfo), binfo, decl);
7273 /* Build the VTT (virtual table table) for T.
7274 A class requires a VTT if it has virtual bases.
7277 1 - primary virtual pointer for complete object T
7278 2 - secondary VTTs for each direct non-virtual base of T which requires a
7280 3 - secondary virtual pointers for each direct or indirect base of T which
7281 has virtual bases or is reachable via a virtual path from T.
7282 4 - secondary VTTs for each direct or indirect virtual base of T.
7284 Secondary VTTs look like complete object VTTs without part 4. */
7292 VEC(constructor_elt,gc) *inits;
7294 /* Build up the initializers for the VTT. */
7296 index = size_zero_node;
7297 build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);
7299 /* If we didn't need a VTT, we're done. */
7303 /* Figure out the type of the VTT. */
7304 type = build_array_of_n_type (const_ptr_type_node,
7305 VEC_length (constructor_elt, inits));
7307 /* Now, build the VTT object itself. */
7308 vtt = build_vtable (t, mangle_vtt_for_type (t), type);
7309 initialize_artificial_var (vtt, inits);
7310 /* Add the VTT to the vtables list. */
7311 DECL_CHAIN (vtt) = DECL_CHAIN (CLASSTYPE_VTABLES (t));
7312 DECL_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;
7317 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7318 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7319 and CHAIN the vtable pointer for this binfo after construction is
7320 complete. VALUE can also be another BINFO, in which case we recurse. */
7323 binfo_ctor_vtable (tree binfo)
7329 vt = BINFO_VTABLE (binfo);
7330 if (TREE_CODE (vt) == TREE_LIST)
7331 vt = TREE_VALUE (vt);
7332 if (TREE_CODE (vt) == TREE_BINFO)
7341 /* Data for secondary VTT initialization. */
7342 typedef struct secondary_vptr_vtt_init_data_s
7344 /* Is this the primary VTT? */
7347 /* Current index into the VTT. */
7350 /* Vector of initializers built up. */
7351 VEC(constructor_elt,gc) *inits;
7353 /* The type being constructed by this secondary VTT. */
7354 tree type_being_constructed;
7355 } secondary_vptr_vtt_init_data;
7357 /* Recursively build the VTT-initializer for BINFO (which is in the
7358 hierarchy dominated by T). INITS points to the end of the initializer
7359 list to date. INDEX is the VTT index where the next element will be
7360 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7361 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
7362 for virtual bases of T. When it is not so, we build the constructor
7363 vtables for the BINFO-in-T variant. */
7366 build_vtt_inits (tree binfo, tree t, VEC(constructor_elt,gc) **inits, tree *index)
7371 secondary_vptr_vtt_init_data data;
7372 int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7374 /* We only need VTTs for subobjects with virtual bases. */
7375 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7378 /* We need to use a construction vtable if this is not the primary
7382 build_ctor_vtbl_group (binfo, t);
7384 /* Record the offset in the VTT where this sub-VTT can be found. */
7385 BINFO_SUBVTT_INDEX (binfo) = *index;
7388 /* Add the address of the primary vtable for the complete object. */
7389 init = binfo_ctor_vtable (binfo);
7390 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
7393 gcc_assert (!BINFO_VPTR_INDEX (binfo));
7394 BINFO_VPTR_INDEX (binfo) = *index;
7396 *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));
7398 /* Recursively add the secondary VTTs for non-virtual bases. */
7399 for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i)
7400 if (!BINFO_VIRTUAL_P (b))
7401 build_vtt_inits (b, t, inits, index);
7403 /* Add secondary virtual pointers for all subobjects of BINFO with
7404 either virtual bases or reachable along a virtual path, except
7405 subobjects that are non-virtual primary bases. */
7406 data.top_level_p = top_level_p;
7407 data.index = *index;
7408 data.inits = *inits;
7409 data.type_being_constructed = BINFO_TYPE (binfo);
7411 dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data);
7413 *index = data.index;
7415 /* data.inits might have grown as we added secondary virtual pointers.
7416 Make sure our caller knows about the new vector. */
7417 *inits = data.inits;
7420 /* Add the secondary VTTs for virtual bases in inheritance graph
7422 for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))
7424 if (!BINFO_VIRTUAL_P (b))
7427 build_vtt_inits (b, t, inits, index);
7430 /* Remove the ctor vtables we created. */
7431 dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo);
7434 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
7435 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
7438 dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_)
7440 secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_;
7442 /* We don't care about bases that don't have vtables. */
7443 if (!TYPE_VFIELD (BINFO_TYPE (binfo)))
7444 return dfs_skip_bases;
7446 /* We're only interested in proper subobjects of the type being
7448 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed))
7451 /* We're only interested in bases with virtual bases or reachable
7452 via a virtual path from the type being constructed. */
7453 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7454 || binfo_via_virtual (binfo, data->type_being_constructed)))
7455 return dfs_skip_bases;
7457 /* We're not interested in non-virtual primary bases. */
7458 if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo))
7461 /* Record the index where this secondary vptr can be found. */
7462 if (data->top_level_p)
7464 gcc_assert (!BINFO_VPTR_INDEX (binfo));
7465 BINFO_VPTR_INDEX (binfo) = data->index;
7467 if (BINFO_VIRTUAL_P (binfo))
7469 /* It's a primary virtual base, and this is not a
7470 construction vtable. Find the base this is primary of in
7471 the inheritance graph, and use that base's vtable
7473 while (BINFO_PRIMARY_P (binfo))
7474 binfo = BINFO_INHERITANCE_CHAIN (binfo);
7478 /* Add the initializer for the secondary vptr itself. */
7479 CONSTRUCTOR_APPEND_ELT (data->inits, NULL_TREE, binfo_ctor_vtable (binfo));
7481 /* Advance the vtt index. */
7482 data->index = size_binop (PLUS_EXPR, data->index,
7483 TYPE_SIZE_UNIT (ptr_type_node));
7488 /* Called from build_vtt_inits via dfs_walk. After building
7489 constructor vtables and generating the sub-vtt from them, we need
7490 to restore the BINFO_VTABLES that were scribbled on. DATA is the
7491 binfo of the base whose sub vtt was generated. */
7494 dfs_fixup_binfo_vtbls (tree binfo, void* data)
7496 tree vtable = BINFO_VTABLE (binfo);
7498 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7499 /* If this class has no vtable, none of its bases do. */
7500 return dfs_skip_bases;
7503 /* This might be a primary base, so have no vtable in this
7507 /* If we scribbled the construction vtable vptr into BINFO, clear it
7509 if (TREE_CODE (vtable) == TREE_LIST
7510 && (TREE_PURPOSE (vtable) == (tree) data))
7511 BINFO_VTABLE (binfo) = TREE_CHAIN (vtable);
7516 /* Build the construction vtable group for BINFO which is in the
7517 hierarchy dominated by T. */
7520 build_ctor_vtbl_group (tree binfo, tree t)
7526 VEC(constructor_elt,gc) *v;
7528 /* See if we've already created this construction vtable group. */
7529 id = mangle_ctor_vtbl_for_type (t, binfo);
7530 if (IDENTIFIER_GLOBAL_VALUE (id))
7533 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t));
7534 /* Build a version of VTBL (with the wrong type) for use in
7535 constructing the addresses of secondary vtables in the
7536 construction vtable group. */
7537 vtbl = build_vtable (t, id, ptr_type_node);
7538 DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1;
7541 accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),
7542 binfo, vtbl, t, &v);
7544 /* Add the vtables for each of our virtual bases using the vbase in T
7546 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7548 vbase = TREE_CHAIN (vbase))
7552 if (!BINFO_VIRTUAL_P (vbase))
7554 b = copied_binfo (vbase, binfo);
7556 accumulate_vtbl_inits (b, vbase, binfo, vtbl, t, &v);
7559 /* Figure out the type of the construction vtable. */
7560 type = build_array_of_n_type (vtable_entry_type,
7561 VEC_length (constructor_elt, v));
7563 TREE_TYPE (vtbl) = type;
7564 DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE;
7565 layout_decl (vtbl, 0);
7567 /* Initialize the construction vtable. */
7568 CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);
7569 initialize_artificial_var (vtbl, v);
7570 dump_vtable (t, binfo, vtbl);
7573 /* Add the vtbl initializers for BINFO (and its bases other than
7574 non-virtual primaries) to the list of INITS. BINFO is in the
7575 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7576 the constructor the vtbl inits should be accumulated for. (If this
7577 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7578 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7579 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7580 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7581 but are not necessarily the same in terms of layout. */
7584 accumulate_vtbl_inits (tree binfo,
7589 VEC(constructor_elt,gc) **inits)
7593 int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7595 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo)));
7597 /* If it doesn't have a vptr, we don't do anything. */
7598 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7601 /* If we're building a construction vtable, we're not interested in
7602 subobjects that don't require construction vtables. */
7604 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))
7605 && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7608 /* Build the initializers for the BINFO-in-T vtable. */
7609 dfs_accumulate_vtbl_inits (binfo, orig_binfo, rtti_binfo, vtbl, t, inits);
7611 /* Walk the BINFO and its bases. We walk in preorder so that as we
7612 initialize each vtable we can figure out at what offset the
7613 secondary vtable lies from the primary vtable. We can't use
7614 dfs_walk here because we need to iterate through bases of BINFO
7615 and RTTI_BINFO simultaneously. */
7616 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
7618 /* Skip virtual bases. */
7619 if (BINFO_VIRTUAL_P (base_binfo))
7621 accumulate_vtbl_inits (base_binfo,
7622 BINFO_BASE_BINFO (orig_binfo, i),
7623 rtti_binfo, vtbl, t,
7628 /* Called from accumulate_vtbl_inits. Adds the initializers for the
7629 BINFO vtable to L. */
7632 dfs_accumulate_vtbl_inits (tree binfo,
7637 VEC(constructor_elt,gc) **l)
7639 tree vtbl = NULL_TREE;
7640 int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7644 && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7646 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7647 primary virtual base. If it is not the same primary in
7648 the hierarchy of T, we'll need to generate a ctor vtable
7649 for it, to place at its location in T. If it is the same
7650 primary, we still need a VTT entry for the vtable, but it
7651 should point to the ctor vtable for the base it is a
7652 primary for within the sub-hierarchy of RTTI_BINFO.
7654 There are three possible cases:
7656 1) We are in the same place.
7657 2) We are a primary base within a lost primary virtual base of
7659 3) We are primary to something not a base of RTTI_BINFO. */
7662 tree last = NULL_TREE;
7664 /* First, look through the bases we are primary to for RTTI_BINFO
7665 or a virtual base. */
7667 while (BINFO_PRIMARY_P (b))
7669 b = BINFO_INHERITANCE_CHAIN (b);
7671 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7674 /* If we run out of primary links, keep looking down our
7675 inheritance chain; we might be an indirect primary. */
7676 for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))
7677 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo)
7681 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7682 base B and it is a base of RTTI_BINFO, this is case 2. In
7683 either case, we share our vtable with LAST, i.e. the
7684 derived-most base within B of which we are a primary. */
7686 || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo))))
7687 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7688 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7689 binfo_ctor_vtable after everything's been set up. */
7692 /* Otherwise, this is case 3 and we get our own. */
7694 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7697 n_inits = VEC_length (constructor_elt, *l);
7704 /* Add the initializer for this vtable. */
7705 build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7706 &non_fn_entries, l);
7708 /* Figure out the position to which the VPTR should point. */
7709 vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, orig_vtbl);
7710 index = size_binop (PLUS_EXPR,
7711 size_int (non_fn_entries),
7712 size_int (n_inits));
7713 index = size_binop (MULT_EXPR,
7714 TYPE_SIZE_UNIT (vtable_entry_type),
7716 vtbl = build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);
7720 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7721 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7722 straighten this out. */
7723 BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
7724 else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
7725 /* Throw away any unneeded intializers. */
7726 VEC_truncate (constructor_elt, *l, n_inits);
7728 /* For an ordinary vtable, set BINFO_VTABLE. */
7729 BINFO_VTABLE (binfo) = vtbl;
7732 static GTY(()) tree abort_fndecl_addr;
7734 /* Construct the initializer for BINFO's virtual function table. BINFO
7735 is part of the hierarchy dominated by T. If we're building a
7736 construction vtable, the ORIG_BINFO is the binfo we should use to
7737 find the actual function pointers to put in the vtable - but they
7738 can be overridden on the path to most-derived in the graph that
7739 ORIG_BINFO belongs. Otherwise,
7740 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7741 BINFO that should be indicated by the RTTI information in the
7742 vtable; it will be a base class of T, rather than T itself, if we
7743 are building a construction vtable.
7745 The value returned is a TREE_LIST suitable for wrapping in a
7746 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7747 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7748 number of non-function entries in the vtable.
7750 It might seem that this function should never be called with a
7751 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7752 base is always subsumed by a derived class vtable. However, when
7753 we are building construction vtables, we do build vtables for
7754 primary bases; we need these while the primary base is being
7758 build_vtbl_initializer (tree binfo,
7762 int* non_fn_entries_p,
7763 VEC(constructor_elt,gc) **inits)
7769 VEC(tree,gc) *vbases;
7772 /* Initialize VID. */
7773 memset (&vid, 0, sizeof (vid));
7776 vid.rtti_binfo = rtti_binfo;
7777 vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t);
7778 vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t);
7779 vid.generate_vcall_entries = true;
7780 /* The first vbase or vcall offset is at index -3 in the vtable. */
7781 vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7783 /* Add entries to the vtable for RTTI. */
7784 build_rtti_vtbl_entries (binfo, &vid);
7786 /* Create an array for keeping track of the functions we've
7787 processed. When we see multiple functions with the same
7788 signature, we share the vcall offsets. */
7789 vid.fns = VEC_alloc (tree, gc, 32);
7790 /* Add the vcall and vbase offset entries. */
7791 build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7793 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7794 build_vbase_offset_vtbl_entries. */
7795 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0;
7796 VEC_iterate (tree, vbases, ix, vbinfo); ix++)
7797 BINFO_VTABLE_PATH_MARKED (vbinfo) = 0;
7799 /* If the target requires padding between data entries, add that now. */
7800 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7802 int n_entries = VEC_length (constructor_elt, vid.inits);
7804 VEC_safe_grow (constructor_elt, gc, vid.inits,
7805 TARGET_VTABLE_DATA_ENTRY_DISTANCE * n_entries);
7807 /* Move data entries into their new positions and add padding
7808 after the new positions. Iterate backwards so we don't
7809 overwrite entries that we would need to process later. */
7810 for (ix = n_entries - 1;
7811 VEC_iterate (constructor_elt, vid.inits, ix, e);
7815 int new_position = (TARGET_VTABLE_DATA_ENTRY_DISTANCE * ix
7816 + (TARGET_VTABLE_DATA_ENTRY_DISTANCE - 1));
7818 VEC_replace (constructor_elt, vid.inits, new_position, e);
7820 for (j = 1; j < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++j)
7822 constructor_elt *f = VEC_index (constructor_elt, vid.inits,
7824 f->index = NULL_TREE;
7825 f->value = build1 (NOP_EXPR, vtable_entry_type,
7831 if (non_fn_entries_p)
7832 *non_fn_entries_p = VEC_length (constructor_elt, vid.inits);
7834 /* The initializers for virtual functions were built up in reverse
7835 order. Straighten them out and add them to the running list in one
7837 jx = VEC_length (constructor_elt, *inits);
7838 VEC_safe_grow (constructor_elt, gc, *inits,
7839 (jx + VEC_length (constructor_elt, vid.inits)));
7841 for (ix = VEC_length (constructor_elt, vid.inits) - 1;
7842 VEC_iterate (constructor_elt, vid.inits, ix, e);
7844 VEC_replace (constructor_elt, *inits, jx, e);
7846 /* Go through all the ordinary virtual functions, building up
7848 for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7852 tree fn, fn_original;
7853 tree init = NULL_TREE;
7857 if (DECL_THUNK_P (fn))
7859 if (!DECL_NAME (fn))
7861 if (THUNK_ALIAS (fn))
7863 fn = THUNK_ALIAS (fn);
7866 fn_original = THUNK_TARGET (fn);
7869 /* If the only definition of this function signature along our
7870 primary base chain is from a lost primary, this vtable slot will
7871 never be used, so just zero it out. This is important to avoid
7872 requiring extra thunks which cannot be generated with the function.
7874 We first check this in update_vtable_entry_for_fn, so we handle
7875 restored primary bases properly; we also need to do it here so we
7876 zero out unused slots in ctor vtables, rather than filling them
7877 with erroneous values (though harmless, apart from relocation
7879 if (BV_LOST_PRIMARY (v))
7880 init = size_zero_node;
7884 /* Pull the offset for `this', and the function to call, out of
7886 delta = BV_DELTA (v);
7887 vcall_index = BV_VCALL_INDEX (v);
7889 gcc_assert (TREE_CODE (delta) == INTEGER_CST);
7890 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
7892 /* You can't call an abstract virtual function; it's abstract.
7893 So, we replace these functions with __pure_virtual. */
7894 if (DECL_PURE_VIRTUAL_P (fn_original))
7897 if (!TARGET_VTABLE_USES_DESCRIPTORS)
7899 if (abort_fndecl_addr == NULL)
7901 = fold_convert (vfunc_ptr_type_node,
7902 build_fold_addr_expr (fn));
7903 init = abort_fndecl_addr;
7908 if (!integer_zerop (delta) || vcall_index)
7910 fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index);
7911 if (!DECL_NAME (fn))
7914 /* Take the address of the function, considering it to be of an
7915 appropriate generic type. */
7916 if (!TARGET_VTABLE_USES_DESCRIPTORS)
7917 init = fold_convert (vfunc_ptr_type_node,
7918 build_fold_addr_expr (fn));
7922 /* And add it to the chain of initializers. */
7923 if (TARGET_VTABLE_USES_DESCRIPTORS)
7926 if (init == size_zero_node)
7927 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7928 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
7930 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i)
7932 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
7933 fn, build_int_cst (NULL_TREE, i));
7934 TREE_CONSTANT (fdesc) = 1;
7936 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, fdesc);
7940 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init);
7944 /* Adds to vid->inits the initializers for the vbase and vcall
7945 offsets in BINFO, which is in the hierarchy dominated by T. */
7948 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid)
7952 /* If this is a derived class, we must first create entries
7953 corresponding to the primary base class. */
7954 b = get_primary_binfo (binfo);
7956 build_vcall_and_vbase_vtbl_entries (b, vid);
7958 /* Add the vbase entries for this base. */
7959 build_vbase_offset_vtbl_entries (binfo, vid);
7960 /* Add the vcall entries for this base. */
7961 build_vcall_offset_vtbl_entries (binfo, vid);
7964 /* Returns the initializers for the vbase offset entries in the vtable
7965 for BINFO (which is part of the class hierarchy dominated by T), in
7966 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7967 where the next vbase offset will go. */
7970 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
7974 tree non_primary_binfo;
7976 /* If there are no virtual baseclasses, then there is nothing to
7978 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)))
7983 /* We might be a primary base class. Go up the inheritance hierarchy
7984 until we find the most derived class of which we are a primary base:
7985 it is the offset of that which we need to use. */
7986 non_primary_binfo = binfo;
7987 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7991 /* If we have reached a virtual base, then it must be a primary
7992 base (possibly multi-level) of vid->binfo, or we wouldn't
7993 have called build_vcall_and_vbase_vtbl_entries for it. But it
7994 might be a lost primary, so just skip down to vid->binfo. */
7995 if (BINFO_VIRTUAL_P (non_primary_binfo))
7997 non_primary_binfo = vid->binfo;
8001 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
8002 if (get_primary_binfo (b) != non_primary_binfo)
8004 non_primary_binfo = b;
8007 /* Go through the virtual bases, adding the offsets. */
8008 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
8010 vbase = TREE_CHAIN (vbase))
8015 if (!BINFO_VIRTUAL_P (vbase))
8018 /* Find the instance of this virtual base in the complete
8020 b = copied_binfo (vbase, binfo);
8022 /* If we've already got an offset for this virtual base, we
8023 don't need another one. */
8024 if (BINFO_VTABLE_PATH_MARKED (b))
8026 BINFO_VTABLE_PATH_MARKED (b) = 1;
8028 /* Figure out where we can find this vbase offset. */
8029 delta = size_binop (MULT_EXPR,
8032 TYPE_SIZE_UNIT (vtable_entry_type)));
8033 if (vid->primary_vtbl_p)
8034 BINFO_VPTR_FIELD (b) = delta;
8036 if (binfo != TYPE_BINFO (t))
8037 /* The vbase offset had better be the same. */
8038 gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase)));
8040 /* The next vbase will come at a more negative offset. */
8041 vid->index = size_binop (MINUS_EXPR, vid->index,
8042 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
8044 /* The initializer is the delta from BINFO to this virtual base.
8045 The vbase offsets go in reverse inheritance-graph order, and
8046 we are walking in inheritance graph order so these end up in
8048 delta = size_diffop_loc (input_location,
8049 BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
8051 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE,
8052 fold_build1_loc (input_location, NOP_EXPR,
8053 vtable_entry_type, delta));
8057 /* Adds the initializers for the vcall offset entries in the vtable
8058 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
8062 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid)
8064 /* We only need these entries if this base is a virtual base. We
8065 compute the indices -- but do not add to the vtable -- when
8066 building the main vtable for a class. */
8067 if (binfo == TYPE_BINFO (vid->derived)
8068 || (BINFO_VIRTUAL_P (binfo)
8069 /* If BINFO is RTTI_BINFO, then (since BINFO does not
8070 correspond to VID->DERIVED), we are building a primary
8071 construction virtual table. Since this is a primary
8072 virtual table, we do not need the vcall offsets for
8074 && binfo != vid->rtti_binfo))
8076 /* We need a vcall offset for each of the virtual functions in this
8077 vtable. For example:
8079 class A { virtual void f (); };
8080 class B1 : virtual public A { virtual void f (); };
8081 class B2 : virtual public A { virtual void f (); };
8082 class C: public B1, public B2 { virtual void f (); };
8084 A C object has a primary base of B1, which has a primary base of A. A
8085 C also has a secondary base of B2, which no longer has a primary base
8086 of A. So the B2-in-C construction vtable needs a secondary vtable for
8087 A, which will adjust the A* to a B2* to call f. We have no way of
8088 knowing what (or even whether) this offset will be when we define B2,
8089 so we store this "vcall offset" in the A sub-vtable and look it up in
8090 a "virtual thunk" for B2::f.
8092 We need entries for all the functions in our primary vtable and
8093 in our non-virtual bases' secondary vtables. */
8095 /* If we are just computing the vcall indices -- but do not need
8096 the actual entries -- not that. */
8097 if (!BINFO_VIRTUAL_P (binfo))
8098 vid->generate_vcall_entries = false;
8099 /* Now, walk through the non-virtual bases, adding vcall offsets. */
8100 add_vcall_offset_vtbl_entries_r (binfo, vid);
8104 /* Build vcall offsets, starting with those for BINFO. */
8107 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid)
8113 /* Don't walk into virtual bases -- except, of course, for the
8114 virtual base for which we are building vcall offsets. Any
8115 primary virtual base will have already had its offsets generated
8116 through the recursion in build_vcall_and_vbase_vtbl_entries. */
8117 if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo)
8120 /* If BINFO has a primary base, process it first. */
8121 primary_binfo = get_primary_binfo (binfo);
8123 add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
8125 /* Add BINFO itself to the list. */
8126 add_vcall_offset_vtbl_entries_1 (binfo, vid);
8128 /* Scan the non-primary bases of BINFO. */
8129 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
8130 if (base_binfo != primary_binfo)
8131 add_vcall_offset_vtbl_entries_r (base_binfo, vid);
8134 /* Called from build_vcall_offset_vtbl_entries_r. */
8137 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid)
8139 /* Make entries for the rest of the virtuals. */
8140 if (abi_version_at_least (2))
8144 /* The ABI requires that the methods be processed in declaration
8145 order. G++ 3.2 used the order in the vtable. */
8146 for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
8148 orig_fn = DECL_CHAIN (orig_fn))
8149 if (DECL_VINDEX (orig_fn))
8150 add_vcall_offset (orig_fn, binfo, vid);
8154 tree derived_virtuals;
8157 /* If BINFO is a primary base, the most derived class which has
8158 BINFO as a primary base; otherwise, just BINFO. */
8159 tree non_primary_binfo;
8161 /* We might be a primary base class. Go up the inheritance hierarchy
8162 until we find the most derived class of which we are a primary base:
8163 it is the BINFO_VIRTUALS there that we need to consider. */
8164 non_primary_binfo = binfo;
8165 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
8169 /* If we have reached a virtual base, then it must be vid->vbase,
8170 because we ignore other virtual bases in
8171 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
8172 base (possibly multi-level) of vid->binfo, or we wouldn't
8173 have called build_vcall_and_vbase_vtbl_entries for it. But it
8174 might be a lost primary, so just skip down to vid->binfo. */
8175 if (BINFO_VIRTUAL_P (non_primary_binfo))
8177 gcc_assert (non_primary_binfo == vid->vbase);
8178 non_primary_binfo = vid->binfo;
8182 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
8183 if (get_primary_binfo (b) != non_primary_binfo)
8185 non_primary_binfo = b;
8188 if (vid->ctor_vtbl_p)
8189 /* For a ctor vtable we need the equivalent binfo within the hierarchy
8190 where rtti_binfo is the most derived type. */
8192 = original_binfo (non_primary_binfo, vid->rtti_binfo);
8194 for (base_virtuals = BINFO_VIRTUALS (binfo),
8195 derived_virtuals = BINFO_VIRTUALS (non_primary_binfo),
8196 orig_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
8198 base_virtuals = TREE_CHAIN (base_virtuals),
8199 derived_virtuals = TREE_CHAIN (derived_virtuals),
8200 orig_virtuals = TREE_CHAIN (orig_virtuals))
8204 /* Find the declaration that originally caused this function to
8205 be present in BINFO_TYPE (binfo). */
8206 orig_fn = BV_FN (orig_virtuals);
8208 /* When processing BINFO, we only want to generate vcall slots for
8209 function slots introduced in BINFO. So don't try to generate
8210 one if the function isn't even defined in BINFO. */
8211 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), DECL_CONTEXT (orig_fn)))
8214 add_vcall_offset (orig_fn, binfo, vid);
8219 /* Add a vcall offset entry for ORIG_FN to the vtable. */
8222 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
8228 /* If there is already an entry for a function with the same
8229 signature as FN, then we do not need a second vcall offset.
8230 Check the list of functions already present in the derived
8232 FOR_EACH_VEC_ELT (tree, vid->fns, i, derived_entry)
8234 if (same_signature_p (derived_entry, orig_fn)
8235 /* We only use one vcall offset for virtual destructors,
8236 even though there are two virtual table entries. */
8237 || (DECL_DESTRUCTOR_P (derived_entry)
8238 && DECL_DESTRUCTOR_P (orig_fn)))
8242 /* If we are building these vcall offsets as part of building
8243 the vtable for the most derived class, remember the vcall
8245 if (vid->binfo == TYPE_BINFO (vid->derived))
8247 tree_pair_p elt = VEC_safe_push (tree_pair_s, gc,
8248 CLASSTYPE_VCALL_INDICES (vid->derived),
8250 elt->purpose = orig_fn;
8251 elt->value = vid->index;
8254 /* The next vcall offset will be found at a more negative
8256 vid->index = size_binop (MINUS_EXPR, vid->index,
8257 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
8259 /* Keep track of this function. */
8260 VEC_safe_push (tree, gc, vid->fns, orig_fn);
8262 if (vid->generate_vcall_entries)
8267 /* Find the overriding function. */
8268 fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
8269 if (fn == error_mark_node)
8270 vcall_offset = build1 (NOP_EXPR, vtable_entry_type,
8274 base = TREE_VALUE (fn);
8276 /* The vbase we're working on is a primary base of
8277 vid->binfo. But it might be a lost primary, so its
8278 BINFO_OFFSET might be wrong, so we just use the
8279 BINFO_OFFSET from vid->binfo. */
8280 vcall_offset = size_diffop_loc (input_location,
8281 BINFO_OFFSET (base),
8282 BINFO_OFFSET (vid->binfo));
8283 vcall_offset = fold_build1_loc (input_location,
8284 NOP_EXPR, vtable_entry_type,
8287 /* Add the initializer to the vtable. */
8288 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, vcall_offset);
8292 /* Return vtbl initializers for the RTTI entries corresponding to the
8293 BINFO's vtable. The RTTI entries should indicate the object given
8294 by VID->rtti_binfo. */
8297 build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid)
8305 t = BINFO_TYPE (vid->rtti_binfo);
8307 /* To find the complete object, we will first convert to our most
8308 primary base, and then add the offset in the vtbl to that value. */
8310 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
8311 && !BINFO_LOST_PRIMARY_P (b))
8315 primary_base = get_primary_binfo (b);
8316 gcc_assert (BINFO_PRIMARY_P (primary_base)
8317 && BINFO_INHERITANCE_CHAIN (primary_base) == b);
8320 offset = size_diffop_loc (input_location,
8321 BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
8323 /* The second entry is the address of the typeinfo object. */
8325 decl = build_address (get_tinfo_decl (t));
8327 decl = integer_zero_node;
8329 /* Convert the declaration to a type that can be stored in the
8331 init = build_nop (vfunc_ptr_type_node, decl);
8332 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
8334 /* Add the offset-to-top entry. It comes earlier in the vtable than
8335 the typeinfo entry. Convert the offset to look like a
8336 function pointer, so that we can put it in the vtable. */
8337 init = build_nop (vfunc_ptr_type_node, offset);
8338 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init);
8341 /* Fold a OBJ_TYPE_REF expression to the address of a function.
8342 KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). */
8345 cp_fold_obj_type_ref (tree ref, tree known_type)
8347 HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
8348 HOST_WIDE_INT i = 0;
8349 tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
8354 i += (TARGET_VTABLE_USES_DESCRIPTORS
8355 ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
8361 #ifdef ENABLE_CHECKING
8362 gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
8363 DECL_VINDEX (fndecl)));
8366 cgraph_node (fndecl)->local.vtable_method = true;
8368 return build_address (fndecl);
8371 #include "gt-cp-class.h"