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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* High-level class interface. */
28 #include "coretypes.h"
39 /* The number of nested classes being processed. If we are not in the
40 scope of any class, this is zero. */
42 int current_class_depth
;
44 /* In order to deal with nested classes, we keep a stack of classes.
45 The topmost entry is the innermost class, and is the entry at index
46 CURRENT_CLASS_DEPTH */
48 typedef struct class_stack_node
{
49 /* The name of the class. */
52 /* The _TYPE node for the class. */
55 /* The access specifier pending for new declarations in the scope of
59 /* If were defining TYPE, the names used in this class. */
60 splay_tree names_used
;
61 }* class_stack_node_t
;
63 typedef struct vtbl_init_data_s
65 /* The base for which we're building initializers. */
67 /* The type of the most-derived type. */
69 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
70 unless ctor_vtbl_p is true. */
72 /* The negative-index vtable initializers built up so far. These
73 are in order from least negative index to most negative index. */
75 /* The last (i.e., most negative) entry in INITS. */
77 /* The binfo for the virtual base for which we're building
78 vcall offset initializers. */
80 /* The functions in vbase for which we have already provided vcall
83 /* The vtable index of the next vcall or vbase offset. */
85 /* Nonzero if we are building the initializer for the primary
88 /* Nonzero if we are building the initializer for a construction
91 /* True when adding vcall offset entries to the vtable. False when
92 merely computing the indices. */
93 bool generate_vcall_entries
;
96 /* The type of a function passed to walk_subobject_offsets. */
97 typedef int (*subobject_offset_fn
) (tree
, tree
, splay_tree
);
99 /* The stack itself. This is a dynamically resized array. The
100 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
101 static int current_class_stack_size
;
102 static class_stack_node_t current_class_stack
;
104 /* An array of all local classes present in this translation unit, in
105 declaration order. */
106 varray_type local_classes
;
108 static tree
get_vfield_name (tree
);
109 static void finish_struct_anon (tree
);
110 static tree
get_vtable_name (tree
);
111 static tree
get_basefndecls (tree
, tree
);
112 static int build_primary_vtable (tree
, tree
);
113 static int build_secondary_vtable (tree
);
114 static void finish_vtbls (tree
);
115 static void modify_vtable_entry (tree
, tree
, tree
, tree
, tree
*);
116 static void finish_struct_bits (tree
);
117 static int alter_access (tree
, tree
, tree
);
118 static void handle_using_decl (tree
, tree
);
119 static void check_for_override (tree
, tree
);
120 static tree
dfs_modify_vtables (tree
, void *);
121 static tree
modify_all_vtables (tree
, tree
);
122 static void determine_primary_bases (tree
);
123 static void finish_struct_methods (tree
);
124 static void maybe_warn_about_overly_private_class (tree
);
125 static int method_name_cmp (const void *, const void *);
126 static int resort_method_name_cmp (const void *, const void *);
127 static void add_implicitly_declared_members (tree
, int, int, int);
128 static tree
fixed_type_or_null (tree
, int *, int *);
129 static tree
resolve_address_of_overloaded_function (tree
, tree
, tsubst_flags_t
,
131 static tree
build_simple_base_path (tree expr
, tree binfo
);
132 static tree
build_vtbl_ref_1 (tree
, tree
);
133 static tree
build_vtbl_initializer (tree
, tree
, tree
, tree
, int *);
134 static int count_fields (tree
);
135 static int add_fields_to_record_type (tree
, struct sorted_fields_type
*, int);
136 static void check_bitfield_decl (tree
);
137 static void check_field_decl (tree
, tree
, int *, int *, int *, int *);
138 static void check_field_decls (tree
, tree
*, int *, int *, int *);
139 static tree
*build_base_field (record_layout_info
, tree
, splay_tree
, tree
*);
140 static void build_base_fields (record_layout_info
, splay_tree
, tree
*);
141 static void check_methods (tree
);
142 static void remove_zero_width_bit_fields (tree
);
143 static void check_bases (tree
, int *, int *, int *);
144 static void check_bases_and_members (tree
);
145 static tree
create_vtable_ptr (tree
, tree
*);
146 static void include_empty_classes (record_layout_info
);
147 static void layout_class_type (tree
, tree
*);
148 static void fixup_pending_inline (tree
);
149 static void fixup_inline_methods (tree
);
150 static void propagate_binfo_offsets (tree
, tree
);
151 static void layout_virtual_bases (record_layout_info
, splay_tree
);
152 static void build_vbase_offset_vtbl_entries (tree
, vtbl_init_data
*);
153 static void add_vcall_offset_vtbl_entries_r (tree
, vtbl_init_data
*);
154 static void add_vcall_offset_vtbl_entries_1 (tree
, vtbl_init_data
*);
155 static void build_vcall_offset_vtbl_entries (tree
, vtbl_init_data
*);
156 static void add_vcall_offset (tree
, tree
, vtbl_init_data
*);
157 static void layout_vtable_decl (tree
, int);
158 static tree
dfs_find_final_overrider (tree
, void *);
159 static tree
dfs_find_final_overrider_post (tree
, void *);
160 static tree
dfs_find_final_overrider_q (tree
, int, void *);
161 static tree
find_final_overrider (tree
, tree
, tree
);
162 static int make_new_vtable (tree
, tree
);
163 static int maybe_indent_hierarchy (FILE *, int, int);
164 static tree
dump_class_hierarchy_r (FILE *, int, tree
, tree
, int);
165 static void dump_class_hierarchy (tree
);
166 static void dump_class_hierarchy_1 (FILE *, int, tree
);
167 static void dump_array (FILE *, tree
);
168 static void dump_vtable (tree
, tree
, tree
);
169 static void dump_vtt (tree
, tree
);
170 static void dump_thunk (FILE *, int, tree
);
171 static tree
build_vtable (tree
, tree
, tree
);
172 static void initialize_vtable (tree
, tree
);
173 static void layout_nonempty_base_or_field (record_layout_info
,
174 tree
, tree
, splay_tree
);
175 static tree
end_of_class (tree
, int);
176 static bool layout_empty_base (tree
, tree
, splay_tree
);
177 static void accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
);
178 static tree
dfs_accumulate_vtbl_inits (tree
, tree
, tree
, tree
,
180 static void build_rtti_vtbl_entries (tree
, vtbl_init_data
*);
181 static void build_vcall_and_vbase_vtbl_entries (tree
,
183 static void clone_constructors_and_destructors (tree
);
184 static tree
build_clone (tree
, tree
);
185 static void update_vtable_entry_for_fn (tree
, tree
, tree
, tree
*, unsigned);
186 static tree
copy_virtuals (tree
);
187 static void build_ctor_vtbl_group (tree
, tree
);
188 static void build_vtt (tree
);
189 static tree
binfo_ctor_vtable (tree
);
190 static tree
*build_vtt_inits (tree
, tree
, tree
*, tree
*);
191 static tree
dfs_build_secondary_vptr_vtt_inits (tree
, void *);
192 static tree
dfs_ctor_vtable_bases_queue_p (tree
, int, void *data
);
193 static tree
dfs_fixup_binfo_vtbls (tree
, void *);
194 static int record_subobject_offset (tree
, tree
, splay_tree
);
195 static int check_subobject_offset (tree
, tree
, splay_tree
);
196 static int walk_subobject_offsets (tree
, subobject_offset_fn
,
197 tree
, splay_tree
, tree
, int);
198 static void record_subobject_offsets (tree
, tree
, splay_tree
, int);
199 static int layout_conflict_p (tree
, tree
, splay_tree
, int);
200 static int splay_tree_compare_integer_csts (splay_tree_key k1
,
202 static void warn_about_ambiguous_bases (tree
);
203 static bool type_requires_array_cookie (tree
);
204 static bool contains_empty_class_p (tree
);
205 static bool base_derived_from (tree
, tree
);
206 static int empty_base_at_nonzero_offset_p (tree
, tree
, splay_tree
);
207 static tree
end_of_base (tree
);
208 static tree
get_vcall_index (tree
, tree
);
210 /* Macros for dfs walking during vtt construction. See
211 dfs_ctor_vtable_bases_queue_p, dfs_build_secondary_vptr_vtt_inits
212 and dfs_fixup_binfo_vtbls. */
213 #define VTT_TOP_LEVEL_P(NODE) (TREE_LIST_CHECK (NODE)->common.unsigned_flag)
214 #define VTT_MARKED_BINFO_P(NODE) TREE_USED (NODE)
216 /* Variables shared between class.c and call.c. */
218 #ifdef GATHER_STATISTICS
220 int n_vtable_entries
= 0;
221 int n_vtable_searches
= 0;
222 int n_vtable_elems
= 0;
223 int n_convert_harshness
= 0;
224 int n_compute_conversion_costs
= 0;
225 int n_inner_fields_searched
= 0;
228 /* Convert to or from a base subobject. EXPR is an expression of type
229 `A' or `A*', an expression of type `B' or `B*' is returned. To
230 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
231 the B base instance within A. To convert base A to derived B, CODE
232 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
233 In this latter case, A must not be a morally virtual base of B.
234 NONNULL is true if EXPR is known to be non-NULL (this is only
235 needed when EXPR is of pointer type). CV qualifiers are preserved
239 build_base_path (enum tree_code code
,
244 tree v_binfo
= NULL_TREE
;
245 tree d_binfo
= NULL_TREE
;
249 tree null_test
= NULL
;
250 tree ptr_target_type
;
252 int want_pointer
= TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
;
253 bool has_empty
= false;
256 if (expr
== error_mark_node
|| binfo
== error_mark_node
|| !binfo
)
257 return error_mark_node
;
259 for (probe
= binfo
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
262 if (is_empty_class (BINFO_TYPE (probe
)))
264 if (!v_binfo
&& BINFO_VIRTUAL_P (probe
))
268 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
270 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (probe
));
272 gcc_assert (code
== MINUS_EXPR
273 ? same_type_p (BINFO_TYPE (binfo
), probe
)
275 ? same_type_p (BINFO_TYPE (d_binfo
), probe
)
278 if (binfo
== d_binfo
)
282 if (code
== MINUS_EXPR
&& v_binfo
)
284 error ("cannot convert from base `%T' to derived type `%T' via virtual base `%T'",
285 BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
), BINFO_TYPE (v_binfo
));
286 return error_mark_node
;
290 /* This must happen before the call to save_expr. */
291 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
293 offset
= BINFO_OFFSET (binfo
);
294 fixed_type_p
= resolves_to_fixed_type_p (expr
, &nonnull
);
296 /* Do we need to look in the vtable for the real offset? */
297 virtual_access
= (v_binfo
&& fixed_type_p
<= 0);
299 /* Do we need to check for a null pointer? */
300 if (want_pointer
&& !nonnull
&& (virtual_access
|| !integer_zerop (offset
)))
301 null_test
= error_mark_node
;
303 /* Protect against multiple evaluation if necessary. */
304 if (TREE_SIDE_EFFECTS (expr
) && (null_test
|| virtual_access
))
305 expr
= save_expr (expr
);
307 /* Now that we've saved expr, build the real null test. */
309 null_test
= fold (build2 (NE_EXPR
, boolean_type_node
,
310 expr
, integer_zero_node
));
312 /* If this is a simple base reference, express it as a COMPONENT_REF. */
313 if (code
== PLUS_EXPR
&& !virtual_access
314 /* We don't build base fields for empty bases, and they aren't very
315 interesting to the optimizers anyway. */
318 expr
= build_indirect_ref (expr
, NULL
);
319 expr
= build_simple_base_path (expr
, binfo
);
321 expr
= build_address (expr
);
322 target_type
= TREE_TYPE (expr
);
328 /* Going via virtual base V_BINFO. We need the static offset
329 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
330 V_BINFO. That offset is an entry in D_BINFO's vtable. */
333 if (fixed_type_p
< 0 && in_base_initializer
)
335 /* In a base member initializer, we cannot rely on
336 the vtable being set up. We have to use the vtt_parm. */
337 tree derived
= BINFO_INHERITANCE_CHAIN (v_binfo
);
340 t
= TREE_TYPE (TYPE_VFIELD (BINFO_TYPE (derived
)));
341 t
= build_pointer_type (t
);
342 v_offset
= convert (t
, current_vtt_parm
);
343 v_offset
= build2 (PLUS_EXPR
, t
, v_offset
,
344 BINFO_VPTR_INDEX (derived
));
345 v_offset
= build_indirect_ref (v_offset
, NULL
);
348 v_offset
= build_vfield_ref (build_indirect_ref (expr
, NULL
),
349 TREE_TYPE (TREE_TYPE (expr
)));
351 v_offset
= build2 (PLUS_EXPR
, TREE_TYPE (v_offset
),
352 v_offset
, BINFO_VPTR_FIELD (v_binfo
));
353 v_offset
= build1 (NOP_EXPR
,
354 build_pointer_type (ptrdiff_type_node
),
356 v_offset
= build_indirect_ref (v_offset
, NULL
);
357 TREE_CONSTANT (v_offset
) = 1;
358 TREE_INVARIANT (v_offset
) = 1;
360 offset
= convert_to_integer (ptrdiff_type_node
,
362 BINFO_OFFSET (v_binfo
)));
364 if (!integer_zerop (offset
))
365 v_offset
= build2 (code
, ptrdiff_type_node
, v_offset
, offset
);
367 if (fixed_type_p
< 0)
368 /* Negative fixed_type_p means this is a constructor or destructor;
369 virtual base layout is fixed in in-charge [cd]tors, but not in
371 offset
= build3 (COND_EXPR
, ptrdiff_type_node
,
372 build2 (EQ_EXPR
, boolean_type_node
,
373 current_in_charge_parm
, integer_zero_node
),
375 BINFO_OFFSET (binfo
));
380 target_type
= code
== PLUS_EXPR
? BINFO_TYPE (binfo
) : BINFO_TYPE (d_binfo
);
382 target_type
= cp_build_qualified_type
383 (target_type
, cp_type_quals (TREE_TYPE (TREE_TYPE (expr
))));
384 ptr_target_type
= build_pointer_type (target_type
);
386 target_type
= ptr_target_type
;
388 expr
= build1 (NOP_EXPR
, ptr_target_type
, expr
);
390 if (!integer_zerop (offset
))
391 expr
= build2 (code
, ptr_target_type
, expr
, offset
);
396 expr
= build_indirect_ref (expr
, NULL
);
400 expr
= fold (build3 (COND_EXPR
, target_type
, null_test
, expr
,
401 fold (build1 (NOP_EXPR
, target_type
,
402 integer_zero_node
))));
407 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
408 Perform a derived-to-base conversion by recursively building up a
409 sequence of COMPONENT_REFs to the appropriate base fields. */
412 build_simple_base_path (tree expr
, tree binfo
)
414 tree type
= BINFO_TYPE (binfo
);
415 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
418 if (d_binfo
== NULL_TREE
)
420 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)) == type
);
425 expr
= build_simple_base_path (expr
, d_binfo
);
427 for (field
= TYPE_FIELDS (BINFO_TYPE (d_binfo
));
428 field
; field
= TREE_CHAIN (field
))
429 /* Is this the base field created by build_base_field? */
430 if (TREE_CODE (field
) == FIELD_DECL
431 && DECL_FIELD_IS_BASE (field
)
432 && TREE_TYPE (field
) == type
)
433 return build_class_member_access_expr (expr
, field
,
436 /* Didn't find the base field?!? */
440 /* Convert OBJECT to the base TYPE. If CHECK_ACCESS is true, an error
441 message is emitted if TYPE is inaccessible. OBJECT is assumed to
445 convert_to_base (tree object
, tree type
, bool check_access
)
449 binfo
= lookup_base (TREE_TYPE (object
), type
,
450 check_access
? ba_check
: ba_ignore
,
452 if (!binfo
|| binfo
== error_mark_node
)
453 return error_mark_node
;
455 return build_base_path (PLUS_EXPR
, object
, binfo
, /*nonnull=*/1);
458 /* EXPR is an expression with class type. BASE is a base class (a
459 BINFO) of that class type. Returns EXPR, converted to the BASE
460 type. This function assumes that EXPR is the most derived class;
461 therefore virtual bases can be found at their static offsets. */
464 convert_to_base_statically (tree expr
, tree base
)
468 expr_type
= TREE_TYPE (expr
);
469 if (!same_type_p (expr_type
, BINFO_TYPE (base
)))
473 pointer_type
= build_pointer_type (expr_type
);
474 expr
= build_unary_op (ADDR_EXPR
, expr
, /*noconvert=*/1);
475 if (!integer_zerop (BINFO_OFFSET (base
)))
476 expr
= build2 (PLUS_EXPR
, pointer_type
, expr
,
477 build_nop (pointer_type
, BINFO_OFFSET (base
)));
478 expr
= build_nop (build_pointer_type (BINFO_TYPE (base
)), expr
);
479 expr
= build1 (INDIRECT_REF
, BINFO_TYPE (base
), expr
);
486 /* Given an object INSTANCE, return an expression which yields the
487 vtable element corresponding to INDEX. There are many special
488 cases for INSTANCE which we take care of here, mainly to avoid
489 creating extra tree nodes when we don't have to. */
492 build_vtbl_ref_1 (tree instance
, tree idx
)
495 tree vtbl
= NULL_TREE
;
497 /* Try to figure out what a reference refers to, and
498 access its virtual function table directly. */
501 tree fixed_type
= fixed_type_or_null (instance
, NULL
, &cdtorp
);
503 tree basetype
= non_reference (TREE_TYPE (instance
));
505 if (fixed_type
&& !cdtorp
)
507 tree binfo
= lookup_base (fixed_type
, basetype
,
508 ba_ignore
|ba_quiet
, NULL
);
510 vtbl
= unshare_expr (BINFO_VTABLE (binfo
));
514 vtbl
= build_vfield_ref (instance
, basetype
);
516 assemble_external (vtbl
);
518 aref
= build_array_ref (vtbl
, idx
);
519 TREE_CONSTANT (aref
) |= TREE_CONSTANT (vtbl
) && TREE_CONSTANT (idx
);
520 TREE_INVARIANT (aref
) = TREE_CONSTANT (aref
);
526 build_vtbl_ref (tree instance
, tree idx
)
528 tree aref
= build_vtbl_ref_1 (instance
, idx
);
533 /* Given a stable object pointer INSTANCE_PTR, return an expression which
534 yields a function pointer corresponding to vtable element INDEX. */
537 build_vfn_ref (tree instance_ptr
, tree idx
)
541 aref
= build_vtbl_ref_1 (build_indirect_ref (instance_ptr
, 0), idx
);
543 /* When using function descriptors, the address of the
544 vtable entry is treated as a function pointer. */
545 if (TARGET_VTABLE_USES_DESCRIPTORS
)
546 aref
= build1 (NOP_EXPR
, TREE_TYPE (aref
),
547 build_unary_op (ADDR_EXPR
, aref
, /*noconvert=*/1));
549 /* Remember this as a method reference, for later devirtualization. */
550 aref
= build3 (OBJ_TYPE_REF
, TREE_TYPE (aref
), aref
, instance_ptr
, idx
);
555 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
556 for the given TYPE. */
559 get_vtable_name (tree type
)
561 return mangle_vtbl_for_type (type
);
564 /* Return an IDENTIFIER_NODE for the name of the virtual table table
568 get_vtt_name (tree type
)
570 return mangle_vtt_for_type (type
);
573 /* DECL is an entity associated with TYPE, like a virtual table or an
574 implicitly generated constructor. Determine whether or not DECL
575 should have external or internal linkage at the object file
576 level. This routine does not deal with COMDAT linkage and other
577 similar complexities; it simply sets TREE_PUBLIC if it possible for
578 entities in other translation units to contain copies of DECL, in
582 set_linkage_according_to_type (tree type
, tree decl
)
584 /* If TYPE involves a local class in a function with internal
585 linkage, then DECL should have internal linkage too. Other local
586 classes have no linkage -- but if their containing functions
587 have external linkage, it makes sense for DECL to have external
588 linkage too. That will allow template definitions to be merged,
590 if (no_linkage_check (type
, /*relaxed_p=*/true))
592 TREE_PUBLIC (decl
) = 0;
593 DECL_INTERFACE_KNOWN (decl
) = 1;
596 TREE_PUBLIC (decl
) = 1;
599 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
600 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
601 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
604 build_vtable (tree class_type
, tree name
, tree vtable_type
)
608 decl
= build_lang_decl (VAR_DECL
, name
, vtable_type
);
609 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
610 now to avoid confusion in mangle_decl. */
611 SET_DECL_ASSEMBLER_NAME (decl
, name
);
612 DECL_CONTEXT (decl
) = class_type
;
613 DECL_ARTIFICIAL (decl
) = 1;
614 TREE_STATIC (decl
) = 1;
615 TREE_READONLY (decl
) = 1;
616 DECL_VIRTUAL_P (decl
) = 1;
617 DECL_ALIGN (decl
) = TARGET_VTABLE_ENTRY_ALIGN
;
618 DECL_VTABLE_OR_VTT_P (decl
) = 1;
619 /* At one time the vtable info was grabbed 2 words at a time. This
620 fails on sparc unless you have 8-byte alignment. (tiemann) */
621 DECL_ALIGN (decl
) = MAX (TYPE_ALIGN (double_type_node
),
623 set_linkage_according_to_type (class_type
, decl
);
624 /* The vtable has not been defined -- yet. */
625 DECL_EXTERNAL (decl
) = 1;
626 DECL_NOT_REALLY_EXTERN (decl
) = 1;
628 if (write_symbols
== DWARF2_DEBUG
)
629 /* Mark the VAR_DECL node representing the vtable itself as a
630 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
631 is rather important that such things be ignored because any
632 effort to actually generate DWARF for them will run into
633 trouble when/if we encounter code like:
636 struct S { virtual void member (); };
638 because the artificial declaration of the vtable itself (as
639 manufactured by the g++ front end) will say that the vtable is
640 a static member of `S' but only *after* the debug output for
641 the definition of `S' has already been output. This causes
642 grief because the DWARF entry for the definition of the vtable
643 will try to refer back to an earlier *declaration* of the
644 vtable as a static member of `S' and there won't be one. We
645 might be able to arrange to have the "vtable static member"
646 attached to the member list for `S' before the debug info for
647 `S' get written (which would solve the problem) but that would
648 require more intrusive changes to the g++ front end. */
649 DECL_IGNORED_P (decl
) = 1;
654 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
655 or even complete. If this does not exist, create it. If COMPLETE is
656 nonzero, then complete the definition of it -- that will render it
657 impossible to actually build the vtable, but is useful to get at those
658 which are known to exist in the runtime. */
661 get_vtable_decl (tree type
, int complete
)
665 if (CLASSTYPE_VTABLES (type
))
666 return CLASSTYPE_VTABLES (type
);
668 decl
= build_vtable (type
, get_vtable_name (type
), vtbl_type_node
);
669 CLASSTYPE_VTABLES (type
) = decl
;
673 DECL_EXTERNAL (decl
) = 1;
674 cp_finish_decl (decl
, NULL_TREE
, NULL_TREE
, 0);
680 /* Returns a copy of the BINFO_VIRTUALS list in BINFO. The
681 BV_VCALL_INDEX for each entry is cleared. */
684 copy_virtuals (tree binfo
)
689 copies
= copy_list (BINFO_VIRTUALS (binfo
));
690 for (t
= copies
; t
; t
= TREE_CHAIN (t
))
691 BV_VCALL_INDEX (t
) = NULL_TREE
;
696 /* Build the primary virtual function table for TYPE. If BINFO is
697 non-NULL, build the vtable starting with the initial approximation
698 that it is the same as the one which is the head of the association
699 list. Returns a nonzero value if a new vtable is actually
703 build_primary_vtable (tree binfo
, tree type
)
708 decl
= get_vtable_decl (type
, /*complete=*/0);
712 if (BINFO_NEW_VTABLE_MARKED (binfo
))
713 /* We have already created a vtable for this base, so there's
714 no need to do it again. */
717 virtuals
= copy_virtuals (binfo
);
718 TREE_TYPE (decl
) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo
));
719 DECL_SIZE (decl
) = TYPE_SIZE (TREE_TYPE (decl
));
720 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
724 gcc_assert (TREE_TYPE (decl
) == vtbl_type_node
);
725 virtuals
= NULL_TREE
;
728 #ifdef GATHER_STATISTICS
730 n_vtable_elems
+= list_length (virtuals
);
733 /* Initialize the association list for this type, based
734 on our first approximation. */
735 BINFO_VTABLE (TYPE_BINFO (type
)) = decl
;
736 BINFO_VIRTUALS (TYPE_BINFO (type
)) = virtuals
;
737 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type
));
741 /* Give BINFO a new virtual function table which is initialized
742 with a skeleton-copy of its original initialization. The only
743 entry that changes is the `delta' entry, so we can really
744 share a lot of structure.
746 FOR_TYPE is the most derived type which caused this table to
749 Returns nonzero if we haven't met BINFO before.
751 The order in which vtables are built (by calling this function) for
752 an object must remain the same, otherwise a binary incompatibility
756 build_secondary_vtable (tree binfo
)
758 if (BINFO_NEW_VTABLE_MARKED (binfo
))
759 /* We already created a vtable for this base. There's no need to
763 /* Remember that we've created a vtable for this BINFO, so that we
764 don't try to do so again. */
765 SET_BINFO_NEW_VTABLE_MARKED (binfo
);
767 /* Make fresh virtual list, so we can smash it later. */
768 BINFO_VIRTUALS (binfo
) = copy_virtuals (binfo
);
770 /* Secondary vtables are laid out as part of the same structure as
771 the primary vtable. */
772 BINFO_VTABLE (binfo
) = NULL_TREE
;
776 /* Create a new vtable for BINFO which is the hierarchy dominated by
777 T. Return nonzero if we actually created a new vtable. */
780 make_new_vtable (tree t
, tree binfo
)
782 if (binfo
== TYPE_BINFO (t
))
783 /* In this case, it is *type*'s vtable we are modifying. We start
784 with the approximation that its vtable is that of the
785 immediate base class. */
786 /* ??? This actually passes TYPE_BINFO (t), not the primary base binfo,
787 since we've updated DECL_CONTEXT (TYPE_VFIELD (t)) by now. */
788 return build_primary_vtable (TYPE_BINFO (DECL_CONTEXT (TYPE_VFIELD (t
))),
791 /* This is our very own copy of `basetype' to play with. Later,
792 we will fill in all the virtual functions that override the
793 virtual functions in these base classes which are not defined
794 by the current type. */
795 return build_secondary_vtable (binfo
);
798 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
799 (which is in the hierarchy dominated by T) list FNDECL as its
800 BV_FN. DELTA is the required constant adjustment from the `this'
801 pointer where the vtable entry appears to the `this' required when
802 the function is actually called. */
805 modify_vtable_entry (tree t
,
815 if (fndecl
!= BV_FN (v
)
816 || !tree_int_cst_equal (delta
, BV_DELTA (v
)))
818 /* We need a new vtable for BINFO. */
819 if (make_new_vtable (t
, binfo
))
821 /* If we really did make a new vtable, we also made a copy
822 of the BINFO_VIRTUALS list. Now, we have to find the
823 corresponding entry in that list. */
824 *virtuals
= BINFO_VIRTUALS (binfo
);
825 while (BV_FN (*virtuals
) != BV_FN (v
))
826 *virtuals
= TREE_CHAIN (*virtuals
);
830 BV_DELTA (v
) = delta
;
831 BV_VCALL_INDEX (v
) = NULL_TREE
;
837 /* Add method METHOD to class TYPE. */
840 add_method (tree type
, tree method
)
846 VEC(tree
) *method_vec
;
848 bool insert_p
= false;
851 if (method
== error_mark_node
)
854 complete_p
= COMPLETE_TYPE_P (type
);
855 using = (DECL_CONTEXT (method
) != type
);
856 template_conv_p
= (TREE_CODE (method
) == TEMPLATE_DECL
857 && DECL_TEMPLATE_CONV_FN_P (method
));
859 method_vec
= CLASSTYPE_METHOD_VEC (type
);
862 /* Make a new method vector. We start with 8 entries. We must
863 allocate at least two (for constructors and destructors), and
864 we're going to end up with an assignment operator at some
866 method_vec
= VEC_alloc (tree
, 8);
867 /* Create slots for constructors and destructors. */
868 VEC_quick_push (tree
, method_vec
, NULL_TREE
);
869 VEC_quick_push (tree
, method_vec
, NULL_TREE
);
870 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
873 /* Constructors and destructors go in special slots. */
874 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method
))
875 slot
= CLASSTYPE_CONSTRUCTOR_SLOT
;
876 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
878 slot
= CLASSTYPE_DESTRUCTOR_SLOT
;
879 TYPE_HAS_DESTRUCTOR (type
) = 1;
881 if (TYPE_FOR_JAVA (type
))
882 error (DECL_ARTIFICIAL (method
)
883 ? "Java class '%T' cannot have an implicit non-trivial destructor"
884 : "Java class '%T' cannot have a destructor",
885 DECL_CONTEXT (method
));
889 bool conv_p
= DECL_CONV_FN_P (method
);
893 /* See if we already have an entry with this name. */
894 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
895 VEC_iterate (tree
, method_vec
, slot
, m
);
901 if (TREE_CODE (m
) == TEMPLATE_DECL
902 && DECL_TEMPLATE_CONV_FN_P (m
))
906 if (conv_p
&& !DECL_CONV_FN_P (m
))
908 if (DECL_NAME (m
) == DECL_NAME (method
))
914 && !DECL_CONV_FN_P (m
)
915 && DECL_NAME (m
) > DECL_NAME (method
))
919 current_fns
= insert_p
? NULL_TREE
: VEC_index (tree
, method_vec
, slot
);
921 if (processing_template_decl
)
922 /* TYPE is a template class. Don't issue any errors now; wait
923 until instantiation time to complain. */
929 /* Check to see if we've already got this method. */
930 for (fns
= current_fns
; fns
; fns
= OVL_NEXT (fns
))
932 tree fn
= OVL_CURRENT (fns
);
937 if (TREE_CODE (fn
) != TREE_CODE (method
))
940 /* [over.load] Member function declarations with the
941 same name and the same parameter types cannot be
942 overloaded if any of them is a static member
943 function declaration.
945 [namespace.udecl] When a using-declaration brings names
946 from a base class into a derived class scope, member
947 functions in the derived class override and/or hide member
948 functions with the same name and parameter types in a base
949 class (rather than conflicting). */
950 parms1
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
951 parms2
= TYPE_ARG_TYPES (TREE_TYPE (method
));
953 /* Compare the quals on the 'this' parm. Don't compare
954 the whole types, as used functions are treated as
955 coming from the using class in overload resolution. */
956 if (! DECL_STATIC_FUNCTION_P (fn
)
957 && ! DECL_STATIC_FUNCTION_P (method
)
958 && (TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms1
)))
959 != TYPE_QUALS (TREE_TYPE (TREE_VALUE (parms2
)))))
962 /* For templates, the template parms must be identical. */
963 if (TREE_CODE (fn
) == TEMPLATE_DECL
964 && !comp_template_parms (DECL_TEMPLATE_PARMS (fn
),
965 DECL_TEMPLATE_PARMS (method
)))
968 if (! DECL_STATIC_FUNCTION_P (fn
))
969 parms1
= TREE_CHAIN (parms1
);
970 if (! DECL_STATIC_FUNCTION_P (method
))
971 parms2
= TREE_CHAIN (parms2
);
973 if (same
&& compparms (parms1
, parms2
)
974 && (!DECL_CONV_FN_P (fn
)
975 || same_type_p (TREE_TYPE (TREE_TYPE (fn
)),
976 TREE_TYPE (TREE_TYPE (method
)))))
978 if (using && DECL_CONTEXT (fn
) == type
)
979 /* Defer to the local function. */
983 cp_error_at ("`%#D' and `%#D' cannot be overloaded",
986 /* We don't call duplicate_decls here to merge
987 the declarations because that will confuse
988 things if the methods have inline
989 definitions. In particular, we will crash
990 while processing the definitions. */
997 /* Add the new binding. */
998 overload
= build_overload (method
, current_fns
);
1000 if (slot
>= CLASSTYPE_FIRST_CONVERSION_SLOT
&& !complete_p
)
1001 push_class_level_binding (DECL_NAME (method
), overload
);
1005 /* We only expect to add few methods in the COMPLETE_P case, so
1006 just make room for one more method in that case. */
1007 if (VEC_reserve (tree
, method_vec
, complete_p
? 1 : -1))
1008 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
1009 if (slot
== VEC_length (tree
, method_vec
))
1010 VEC_quick_push (tree
, method_vec
, overload
);
1012 VEC_quick_insert (tree
, method_vec
, slot
, overload
);
1015 /* Replace the current slot. */
1016 VEC_replace (tree
, method_vec
, slot
, overload
);
1019 /* Subroutines of finish_struct. */
1021 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1022 legit, otherwise return 0. */
1025 alter_access (tree t
, tree fdecl
, tree access
)
1029 if (!DECL_LANG_SPECIFIC (fdecl
))
1030 retrofit_lang_decl (fdecl
);
1032 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl
));
1034 elem
= purpose_member (t
, DECL_ACCESS (fdecl
));
1037 if (TREE_VALUE (elem
) != access
)
1039 if (TREE_CODE (TREE_TYPE (fdecl
)) == FUNCTION_DECL
)
1040 cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl
));
1042 error ("conflicting access specifications for field `%E', ignored",
1047 /* They're changing the access to the same thing they changed
1048 it to before. That's OK. */
1054 perform_or_defer_access_check (TYPE_BINFO (t
), fdecl
);
1055 DECL_ACCESS (fdecl
) = tree_cons (t
, access
, DECL_ACCESS (fdecl
));
1061 /* Process the USING_DECL, which is a member of T. */
1064 handle_using_decl (tree using_decl
, tree t
)
1066 tree ctype
= DECL_INITIAL (using_decl
);
1067 tree name
= DECL_NAME (using_decl
);
1069 = TREE_PRIVATE (using_decl
) ? access_private_node
1070 : TREE_PROTECTED (using_decl
) ? access_protected_node
1071 : access_public_node
;
1073 tree flist
= NULL_TREE
;
1076 if (ctype
== error_mark_node
)
1079 binfo
= lookup_base (t
, ctype
, ba_any
, NULL
);
1082 location_t saved_loc
= input_location
;
1084 input_location
= DECL_SOURCE_LOCATION (using_decl
);
1085 error_not_base_type (ctype
, t
);
1086 input_location
= saved_loc
;
1090 if (constructor_name_p (name
, ctype
))
1092 cp_error_at ("`%D' names constructor", using_decl
);
1095 if (constructor_name_p (name
, t
))
1097 cp_error_at ("`%D' invalid in `%T'", using_decl
, t
);
1101 fdecl
= lookup_member (binfo
, name
, 0, false);
1105 cp_error_at ("no members matching `%D' in `%#T'", using_decl
, ctype
);
1109 if (BASELINK_P (fdecl
))
1110 /* Ignore base type this came from. */
1111 fdecl
= BASELINK_FUNCTIONS (fdecl
);
1113 old_value
= lookup_member (t
, name
, /*protect=*/0, /*want_type=*/false);
1116 if (is_overloaded_fn (old_value
))
1117 old_value
= OVL_CURRENT (old_value
);
1119 if (DECL_P (old_value
) && DECL_CONTEXT (old_value
) == t
)
1122 old_value
= NULL_TREE
;
1125 if (is_overloaded_fn (fdecl
))
1130 else if (is_overloaded_fn (old_value
))
1133 /* It's OK to use functions from a base when there are functions with
1134 the same name already present in the current class. */;
1137 cp_error_at ("`%D' invalid in `%#T'", using_decl
, t
);
1138 cp_error_at (" because of local method `%#D' with same name",
1139 OVL_CURRENT (old_value
));
1143 else if (!DECL_ARTIFICIAL (old_value
))
1145 cp_error_at ("`%D' invalid in `%#T'", using_decl
, t
);
1146 cp_error_at (" because of local member `%#D' with same name", old_value
);
1150 /* Make type T see field decl FDECL with access ACCESS. */
1152 for (; flist
; flist
= OVL_NEXT (flist
))
1154 add_method (t
, OVL_CURRENT (flist
));
1155 alter_access (t
, OVL_CURRENT (flist
), access
);
1158 alter_access (t
, fdecl
, access
);
1161 /* Run through the base classes of T, updating
1162 CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1163 NO_CONST_ASN_REF_P. Also set flag bits in T based on properties of
1167 check_bases (tree t
,
1168 int* cant_have_default_ctor_p
,
1169 int* cant_have_const_ctor_p
,
1170 int* no_const_asn_ref_p
)
1173 int seen_non_virtual_nearly_empty_base_p
;
1177 seen_non_virtual_nearly_empty_base_p
= 0;
1179 for (binfo
= TYPE_BINFO (t
), i
= 0;
1180 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1182 tree basetype
= TREE_TYPE (base_binfo
);
1184 gcc_assert (COMPLETE_TYPE_P (basetype
));
1186 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1187 here because the case of virtual functions but non-virtual
1188 dtor is handled in finish_struct_1. */
1189 if (warn_ecpp
&& ! TYPE_POLYMORPHIC_P (basetype
)
1190 && TYPE_HAS_DESTRUCTOR (basetype
))
1191 warning ("base class `%#T' has a non-virtual destructor",
1194 /* If the base class doesn't have copy constructors or
1195 assignment operators that take const references, then the
1196 derived class cannot have such a member automatically
1198 if (! TYPE_HAS_CONST_INIT_REF (basetype
))
1199 *cant_have_const_ctor_p
= 1;
1200 if (TYPE_HAS_ASSIGN_REF (basetype
)
1201 && !TYPE_HAS_CONST_ASSIGN_REF (basetype
))
1202 *no_const_asn_ref_p
= 1;
1203 /* Similarly, if the base class doesn't have a default
1204 constructor, then the derived class won't have an
1205 automatically generated default constructor. */
1206 if (TYPE_HAS_CONSTRUCTOR (basetype
)
1207 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
))
1209 *cant_have_default_ctor_p
= 1;
1210 if (! TYPE_HAS_CONSTRUCTOR (t
))
1211 pedwarn ("base `%T' with only non-default constructor in class without a constructor",
1215 if (BINFO_VIRTUAL_P (base_binfo
))
1216 /* A virtual base does not effect nearly emptiness. */
1218 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype
))
1220 if (seen_non_virtual_nearly_empty_base_p
)
1221 /* And if there is more than one nearly empty base, then the
1222 derived class is not nearly empty either. */
1223 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1225 /* Remember we've seen one. */
1226 seen_non_virtual_nearly_empty_base_p
= 1;
1228 else if (!is_empty_class (basetype
))
1229 /* If the base class is not empty or nearly empty, then this
1230 class cannot be nearly empty. */
1231 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1233 /* A lot of properties from the bases also apply to the derived
1235 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (basetype
);
1236 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1237 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
);
1238 TYPE_HAS_COMPLEX_ASSIGN_REF (t
)
1239 |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype
);
1240 TYPE_HAS_COMPLEX_INIT_REF (t
) |= TYPE_HAS_COMPLEX_INIT_REF (basetype
);
1241 TYPE_POLYMORPHIC_P (t
) |= TYPE_POLYMORPHIC_P (basetype
);
1242 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
)
1243 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype
);
1247 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1248 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1249 that have had a nearly-empty virtual primary base stolen by some
1250 other base in the heirarchy. Determines CLASSTYPE_PRIMARY_BASE for
1254 determine_primary_bases (tree t
)
1257 tree primary
= NULL_TREE
;
1258 tree type_binfo
= TYPE_BINFO (t
);
1261 /* Determine the primary bases of our bases. */
1262 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1263 base_binfo
= TREE_CHAIN (base_binfo
))
1265 tree primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo
));
1267 /* See if we're the non-virtual primary of our inheritance
1269 if (!BINFO_VIRTUAL_P (base_binfo
))
1271 tree parent
= BINFO_INHERITANCE_CHAIN (base_binfo
);
1272 tree parent_primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent
));
1275 && BINFO_TYPE (base_binfo
) == BINFO_TYPE (parent_primary
))
1276 /* We are the primary binfo. */
1277 BINFO_PRIMARY_P (base_binfo
) = 1;
1279 /* Determine if we have a virtual primary base, and mark it so.
1281 if (primary
&& BINFO_VIRTUAL_P (primary
))
1283 tree this_primary
= copied_binfo (primary
, base_binfo
);
1285 if (BINFO_PRIMARY_P (this_primary
))
1286 /* Someone already claimed this base. */
1287 BINFO_LOST_PRIMARY_P (base_binfo
) = 1;
1292 BINFO_PRIMARY_P (this_primary
) = 1;
1293 BINFO_INHERITANCE_CHAIN (this_primary
) = base_binfo
;
1295 /* A virtual binfo might have been copied from within
1296 another hierarchy. As we're about to use it as a
1297 primary base, make sure the offsets match. */
1298 delta
= size_diffop (convert (ssizetype
,
1299 BINFO_OFFSET (base_binfo
)),
1301 BINFO_OFFSET (this_primary
)));
1303 propagate_binfo_offsets (this_primary
, delta
);
1308 /* First look for a dynamic direct non-virtual base. */
1309 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, base_binfo
); i
++)
1311 tree basetype
= BINFO_TYPE (base_binfo
);
1313 if (TYPE_CONTAINS_VPTR_P (basetype
) && !BINFO_VIRTUAL_P (base_binfo
))
1315 primary
= base_binfo
;
1320 /* A "nearly-empty" virtual base class can be the primary base
1321 class, if no non-virtual polymorphic base can be found. Look for
1322 a nearly-empty virtual dynamic base that is not already a primary
1323 base of something in the heirarchy. If there is no such base,
1324 just pick the first nearly-empty virtual base. */
1326 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1327 base_binfo
= TREE_CHAIN (base_binfo
))
1328 if (BINFO_VIRTUAL_P (base_binfo
)
1329 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo
)))
1331 if (!BINFO_PRIMARY_P (base_binfo
))
1333 /* Found one that is not primary. */
1334 primary
= base_binfo
;
1338 /* Remember the first candidate. */
1339 primary
= base_binfo
;
1343 /* If we've got a primary base, use it. */
1346 tree basetype
= BINFO_TYPE (primary
);
1348 CLASSTYPE_PRIMARY_BINFO (t
) = primary
;
1349 if (BINFO_PRIMARY_P (primary
))
1350 /* We are stealing a primary base. */
1351 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary
)) = 1;
1352 BINFO_PRIMARY_P (primary
) = 1;
1353 if (BINFO_VIRTUAL_P (primary
))
1357 BINFO_INHERITANCE_CHAIN (primary
) = type_binfo
;
1358 /* A virtual binfo might have been copied from within
1359 another hierarchy. As we're about to use it as a primary
1360 base, make sure the offsets match. */
1361 delta
= size_diffop (ssize_int (0),
1362 convert (ssizetype
, BINFO_OFFSET (primary
)));
1364 propagate_binfo_offsets (primary
, delta
);
1367 primary
= TYPE_BINFO (basetype
);
1369 TYPE_VFIELD (t
) = TYPE_VFIELD (basetype
);
1370 BINFO_VTABLE (type_binfo
) = BINFO_VTABLE (primary
);
1371 BINFO_VIRTUALS (type_binfo
) = BINFO_VIRTUALS (primary
);
1375 /* Set memoizing fields and bits of T (and its variants) for later
1379 finish_struct_bits (tree t
)
1383 /* Fix up variants (if any). */
1384 for (variants
= TYPE_NEXT_VARIANT (t
);
1386 variants
= TYPE_NEXT_VARIANT (variants
))
1388 /* These fields are in the _TYPE part of the node, not in
1389 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1390 TYPE_HAS_CONSTRUCTOR (variants
) = TYPE_HAS_CONSTRUCTOR (t
);
1391 TYPE_HAS_DESTRUCTOR (variants
) = TYPE_HAS_DESTRUCTOR (t
);
1392 TYPE_NEEDS_CONSTRUCTING (variants
) = TYPE_NEEDS_CONSTRUCTING (t
);
1393 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants
)
1394 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
1396 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (variants
)
1397 = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t
);
1398 TYPE_POLYMORPHIC_P (variants
) = TYPE_POLYMORPHIC_P (t
);
1399 TYPE_USES_VIRTUAL_BASECLASSES (variants
)
1400 = TYPE_USES_VIRTUAL_BASECLASSES (t
);
1402 TYPE_BINFO (variants
) = TYPE_BINFO (t
);
1404 /* Copy whatever these are holding today. */
1405 TYPE_VFIELD (variants
) = TYPE_VFIELD (t
);
1406 TYPE_METHODS (variants
) = TYPE_METHODS (t
);
1407 TYPE_FIELDS (variants
) = TYPE_FIELDS (t
);
1408 TYPE_SIZE (variants
) = TYPE_SIZE (t
);
1409 TYPE_SIZE_UNIT (variants
) = TYPE_SIZE_UNIT (t
);
1412 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) && TYPE_POLYMORPHIC_P (t
))
1413 /* For a class w/o baseclasses, `finish_struct' has set
1414 CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by definition).
1415 Similarly for a class whose base classes do not have vtables.
1416 When neither of these is true, we might have removed abstract
1417 virtuals (by providing a definition), added some (by declaring
1418 new ones), or redeclared ones from a base class. We need to
1419 recalculate what's really an abstract virtual at this point (by
1420 looking in the vtables). */
1421 get_pure_virtuals (t
);
1423 /* If this type has a copy constructor or a destructor, force its
1424 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1425 nonzero. This will cause it to be passed by invisible reference
1426 and prevent it from being returned in a register. */
1427 if (! TYPE_HAS_TRIVIAL_INIT_REF (t
) || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
1430 DECL_MODE (TYPE_MAIN_DECL (t
)) = BLKmode
;
1431 for (variants
= t
; variants
; variants
= TYPE_NEXT_VARIANT (variants
))
1433 TYPE_MODE (variants
) = BLKmode
;
1434 TREE_ADDRESSABLE (variants
) = 1;
1439 /* Issue warnings about T having private constructors, but no friends,
1442 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1443 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1444 non-private static member functions. */
1447 maybe_warn_about_overly_private_class (tree t
)
1449 int has_member_fn
= 0;
1450 int has_nonprivate_method
= 0;
1453 if (!warn_ctor_dtor_privacy
1454 /* If the class has friends, those entities might create and
1455 access instances, so we should not warn. */
1456 || (CLASSTYPE_FRIEND_CLASSES (t
)
1457 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
1458 /* We will have warned when the template was declared; there's
1459 no need to warn on every instantiation. */
1460 || CLASSTYPE_TEMPLATE_INSTANTIATION (t
))
1461 /* There's no reason to even consider warning about this
1465 /* We only issue one warning, if more than one applies, because
1466 otherwise, on code like:
1469 // Oops - forgot `public:'
1475 we warn several times about essentially the same problem. */
1477 /* Check to see if all (non-constructor, non-destructor) member
1478 functions are private. (Since there are no friends or
1479 non-private statics, we can't ever call any of the private member
1481 for (fn
= TYPE_METHODS (t
); fn
; fn
= TREE_CHAIN (fn
))
1482 /* We're not interested in compiler-generated methods; they don't
1483 provide any way to call private members. */
1484 if (!DECL_ARTIFICIAL (fn
))
1486 if (!TREE_PRIVATE (fn
))
1488 if (DECL_STATIC_FUNCTION_P (fn
))
1489 /* A non-private static member function is just like a
1490 friend; it can create and invoke private member
1491 functions, and be accessed without a class
1495 has_nonprivate_method
= 1;
1496 /* Keep searching for a static member function. */
1498 else if (!DECL_CONSTRUCTOR_P (fn
) && !DECL_DESTRUCTOR_P (fn
))
1502 if (!has_nonprivate_method
&& has_member_fn
)
1504 /* There are no non-private methods, and there's at least one
1505 private member function that isn't a constructor or
1506 destructor. (If all the private members are
1507 constructors/destructors we want to use the code below that
1508 issues error messages specifically referring to
1509 constructors/destructors.) */
1511 tree binfo
= TYPE_BINFO (t
);
1513 for (i
= 0; i
!= BINFO_N_BASE_BINFOS (binfo
); i
++)
1514 if (BINFO_BASE_ACCESS (binfo
, i
) != access_private_node
)
1516 has_nonprivate_method
= 1;
1519 if (!has_nonprivate_method
)
1521 warning ("all member functions in class `%T' are private", t
);
1526 /* Even if some of the member functions are non-private, the class
1527 won't be useful for much if all the constructors or destructors
1528 are private: such an object can never be created or destroyed. */
1529 if (TYPE_HAS_DESTRUCTOR (t
)
1530 && TREE_PRIVATE (CLASSTYPE_DESTRUCTORS (t
)))
1532 warning ("`%#T' only defines a private destructor and has no friends",
1537 if (TYPE_HAS_CONSTRUCTOR (t
))
1539 int nonprivate_ctor
= 0;
1541 /* If a non-template class does not define a copy
1542 constructor, one is defined for it, enabling it to avoid
1543 this warning. For a template class, this does not
1544 happen, and so we would normally get a warning on:
1546 template <class T> class C { private: C(); };
1548 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
1549 complete non-template or fully instantiated classes have this
1551 if (!TYPE_HAS_INIT_REF (t
))
1552 nonprivate_ctor
= 1;
1554 for (fn
= CLASSTYPE_CONSTRUCTORS (t
); fn
; fn
= OVL_NEXT (fn
))
1556 tree ctor
= OVL_CURRENT (fn
);
1557 /* Ideally, we wouldn't count copy constructors (or, in
1558 fact, any constructor that takes an argument of the
1559 class type as a parameter) because such things cannot
1560 be used to construct an instance of the class unless
1561 you already have one. But, for now at least, we're
1563 if (! TREE_PRIVATE (ctor
))
1565 nonprivate_ctor
= 1;
1570 if (nonprivate_ctor
== 0)
1572 warning ("`%#T' only defines private constructors and has no friends",
1580 gt_pointer_operator new_value
;
1584 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1587 method_name_cmp (const void* m1_p
, const void* m2_p
)
1589 const tree
*const m1
= m1_p
;
1590 const tree
*const m2
= m2_p
;
1592 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
1594 if (*m1
== NULL_TREE
)
1596 if (*m2
== NULL_TREE
)
1598 if (DECL_NAME (OVL_CURRENT (*m1
)) < DECL_NAME (OVL_CURRENT (*m2
)))
1603 /* This routine compares two fields like method_name_cmp but using the
1604 pointer operator in resort_field_decl_data. */
1607 resort_method_name_cmp (const void* m1_p
, const void* m2_p
)
1609 const tree
*const m1
= m1_p
;
1610 const tree
*const m2
= m2_p
;
1611 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
1613 if (*m1
== NULL_TREE
)
1615 if (*m2
== NULL_TREE
)
1618 tree d1
= DECL_NAME (OVL_CURRENT (*m1
));
1619 tree d2
= DECL_NAME (OVL_CURRENT (*m2
));
1620 resort_data
.new_value (&d1
, resort_data
.cookie
);
1621 resort_data
.new_value (&d2
, resort_data
.cookie
);
1628 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1631 resort_type_method_vec (void* obj
,
1632 void* orig_obj ATTRIBUTE_UNUSED
,
1633 gt_pointer_operator new_value
,
1636 VEC(tree
) *method_vec
= (VEC(tree
) *) obj
;
1637 int len
= VEC_length (tree
, method_vec
);
1641 /* The type conversion ops have to live at the front of the vec, so we
1643 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1644 VEC_iterate (tree
, method_vec
, slot
, fn
);
1646 if (!DECL_CONV_FN_P (OVL_CURRENT (fn
)))
1651 resort_data
.new_value
= new_value
;
1652 resort_data
.cookie
= cookie
;
1653 qsort (VEC_address (tree
, method_vec
) + slot
, len
- slot
, sizeof (tree
),
1654 resort_method_name_cmp
);
1658 /* Warn about duplicate methods in fn_fields. Also compact method
1659 lists so that lookup can be made faster.
1661 Data Structure: List of method lists. The outer list is a
1662 TREE_LIST, whose TREE_PURPOSE field is the field name and the
1663 TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs. TREE_CHAIN
1664 links the entire list of methods for TYPE_METHODS. Friends are
1665 chained in the same way as member functions (? TREE_CHAIN or
1666 DECL_CHAIN), but they live in the TREE_TYPE field of the outer
1667 list. That allows them to be quickly deleted, and requires no
1670 Sort methods that are not special (i.e., constructors, destructors,
1671 and type conversion operators) so that we can find them faster in
1675 finish_struct_methods (tree t
)
1678 VEC(tree
) *method_vec
;
1681 method_vec
= CLASSTYPE_METHOD_VEC (t
);
1685 len
= VEC_length (tree
, method_vec
);
1687 /* First fill in entry 0 with the constructors, entry 1 with destructors,
1688 and the next few with type conversion operators (if any). */
1689 for (fn_fields
= TYPE_METHODS (t
); fn_fields
;
1690 fn_fields
= TREE_CHAIN (fn_fields
))
1691 /* Clear out this flag. */
1692 DECL_IN_AGGR_P (fn_fields
) = 0;
1694 if (TYPE_HAS_DESTRUCTOR (t
) && !CLASSTYPE_DESTRUCTORS (t
))
1695 /* We thought there was a destructor, but there wasn't. Some
1696 parse errors cause this anomalous situation. */
1697 TYPE_HAS_DESTRUCTOR (t
) = 0;
1699 /* Issue warnings about private constructors and such. If there are
1700 no methods, then some public defaults are generated. */
1701 maybe_warn_about_overly_private_class (t
);
1703 /* The type conversion ops have to live at the front of the vec, so we
1705 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1706 VEC_iterate (tree
, method_vec
, slot
, fn_fields
);
1708 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields
)))
1711 qsort (VEC_address (tree
, method_vec
) + slot
,
1712 len
-slot
, sizeof (tree
), method_name_cmp
);
1715 /* Make BINFO's vtable have N entries, including RTTI entries,
1716 vbase and vcall offsets, etc. Set its type and call the backend
1720 layout_vtable_decl (tree binfo
, int n
)
1725 atype
= build_cplus_array_type (vtable_entry_type
,
1726 build_index_type (size_int (n
- 1)));
1727 layout_type (atype
);
1729 /* We may have to grow the vtable. */
1730 vtable
= get_vtbl_decl_for_binfo (binfo
);
1731 if (!same_type_p (TREE_TYPE (vtable
), atype
))
1733 TREE_TYPE (vtable
) = atype
;
1734 DECL_SIZE (vtable
) = DECL_SIZE_UNIT (vtable
) = NULL_TREE
;
1735 layout_decl (vtable
, 0);
1739 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1740 have the same signature. */
1743 same_signature_p (tree fndecl
, tree base_fndecl
)
1745 /* One destructor overrides another if they are the same kind of
1747 if (DECL_DESTRUCTOR_P (base_fndecl
) && DECL_DESTRUCTOR_P (fndecl
)
1748 && special_function_p (base_fndecl
) == special_function_p (fndecl
))
1750 /* But a non-destructor never overrides a destructor, nor vice
1751 versa, nor do different kinds of destructors override
1752 one-another. For example, a complete object destructor does not
1753 override a deleting destructor. */
1754 if (DECL_DESTRUCTOR_P (base_fndecl
) || DECL_DESTRUCTOR_P (fndecl
))
1757 if (DECL_NAME (fndecl
) == DECL_NAME (base_fndecl
)
1758 || (DECL_CONV_FN_P (fndecl
)
1759 && DECL_CONV_FN_P (base_fndecl
)
1760 && same_type_p (DECL_CONV_FN_TYPE (fndecl
),
1761 DECL_CONV_FN_TYPE (base_fndecl
))))
1763 tree types
, base_types
;
1764 types
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
1765 base_types
= TYPE_ARG_TYPES (TREE_TYPE (base_fndecl
));
1766 if ((TYPE_QUALS (TREE_TYPE (TREE_VALUE (base_types
)))
1767 == TYPE_QUALS (TREE_TYPE (TREE_VALUE (types
))))
1768 && compparms (TREE_CHAIN (base_types
), TREE_CHAIN (types
)))
1774 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1778 base_derived_from (tree derived
, tree base
)
1782 for (probe
= base
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
1784 if (probe
== derived
)
1786 else if (BINFO_VIRTUAL_P (probe
))
1787 /* If we meet a virtual base, we can't follow the inheritance
1788 any more. See if the complete type of DERIVED contains
1789 such a virtual base. */
1790 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (derived
))
1796 typedef struct count_depth_data
{
1797 /* The depth of the current subobject, with "1" as the depth of the
1798 most derived object in the hierarchy. */
1800 /* The maximum depth found so far. */
1804 /* Called from find_final_overrider via dfs_walk. */
1807 dfs_depth_post (tree binfo ATTRIBUTE_UNUSED
, void *data
)
1809 count_depth_data
*cd
= (count_depth_data
*) data
;
1810 if (cd
->depth
> cd
->max_depth
)
1811 cd
->max_depth
= cd
->depth
;
1816 /* Called from find_final_overrider via dfs_walk. */
1819 dfs_depth_q (tree derived
, int i
, void *data
)
1821 count_depth_data
*cd
= (count_depth_data
*) data
;
1823 return BINFO_BASE_BINFO (derived
, i
);
1826 typedef struct find_final_overrider_data_s
{
1827 /* The function for which we are trying to find a final overrider. */
1829 /* The base class in which the function was declared. */
1830 tree declaring_base
;
1831 /* The most derived class in the hierarchy. */
1832 tree most_derived_type
;
1833 /* The candidate overriders. */
1835 /* Each entry in this array is the next-most-derived class for a
1836 virtual base class along the current path. */
1838 /* A pointer one past the top of the VPATH_LIST. */
1840 } find_final_overrider_data
;
1842 /* Add the overrider along the current path to FFOD->CANDIDATES.
1843 Returns true if an overrider was found; false otherwise. */
1846 dfs_find_final_overrider_1 (tree binfo
,
1848 find_final_overrider_data
*ffod
)
1852 /* If BINFO is not the most derived type, try a more derived class.
1853 A definition there will overrider a definition here. */
1854 if (!same_type_p (BINFO_TYPE (binfo
), ffod
->most_derived_type
))
1858 if (BINFO_VIRTUAL_P (binfo
))
1861 derived
= BINFO_INHERITANCE_CHAIN (binfo
);
1862 if (dfs_find_final_overrider_1 (derived
, vpath
, ffod
))
1866 method
= look_for_overrides_here (BINFO_TYPE (binfo
), ffod
->fn
);
1869 tree
*candidate
= &ffod
->candidates
;
1871 /* Remove any candidates overridden by this new function. */
1874 /* If *CANDIDATE overrides METHOD, then METHOD
1875 cannot override anything else on the list. */
1876 if (base_derived_from (TREE_VALUE (*candidate
), binfo
))
1878 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1879 if (base_derived_from (binfo
, TREE_VALUE (*candidate
)))
1880 *candidate
= TREE_CHAIN (*candidate
);
1882 candidate
= &TREE_CHAIN (*candidate
);
1885 /* Add the new function. */
1886 ffod
->candidates
= tree_cons (method
, binfo
, ffod
->candidates
);
1893 /* Called from find_final_overrider via dfs_walk. */
1896 dfs_find_final_overrider (tree binfo
, void* data
)
1898 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
1900 if (binfo
== ffod
->declaring_base
)
1901 dfs_find_final_overrider_1 (binfo
, ffod
->vpath
, ffod
);
1907 dfs_find_final_overrider_q (tree derived
, int ix
, void *data
)
1909 tree binfo
= BINFO_BASE_BINFO (derived
, ix
);
1910 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
1912 if (BINFO_VIRTUAL_P (binfo
))
1913 *ffod
->vpath
++ = derived
;
1919 dfs_find_final_overrider_post (tree binfo
, void *data
)
1921 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
1923 if (BINFO_VIRTUAL_P (binfo
))
1929 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1930 FN and whose TREE_VALUE is the binfo for the base where the
1931 overriding occurs. BINFO (in the hierarchy dominated by the binfo
1932 DERIVED) is the base object in which FN is declared. */
1935 find_final_overrider (tree derived
, tree binfo
, tree fn
)
1937 find_final_overrider_data ffod
;
1938 count_depth_data cd
;
1940 /* Getting this right is a little tricky. This is valid:
1942 struct S { virtual void f (); };
1943 struct T { virtual void f (); };
1944 struct U : public S, public T { };
1946 even though calling `f' in `U' is ambiguous. But,
1948 struct R { virtual void f(); };
1949 struct S : virtual public R { virtual void f (); };
1950 struct T : virtual public R { virtual void f (); };
1951 struct U : public S, public T { };
1953 is not -- there's no way to decide whether to put `S::f' or
1954 `T::f' in the vtable for `R'.
1956 The solution is to look at all paths to BINFO. If we find
1957 different overriders along any two, then there is a problem. */
1958 if (DECL_THUNK_P (fn
))
1959 fn
= THUNK_TARGET (fn
);
1961 /* Determine the depth of the hierarchy. */
1964 dfs_walk (derived
, dfs_depth_post
, dfs_depth_q
, &cd
);
1967 ffod
.declaring_base
= binfo
;
1968 ffod
.most_derived_type
= BINFO_TYPE (derived
);
1969 ffod
.candidates
= NULL_TREE
;
1970 ffod
.vpath_list
= (tree
*) xcalloc (cd
.max_depth
, sizeof (tree
));
1971 ffod
.vpath
= ffod
.vpath_list
;
1973 dfs_walk_real (derived
,
1974 dfs_find_final_overrider
,
1975 dfs_find_final_overrider_post
,
1976 dfs_find_final_overrider_q
,
1979 free (ffod
.vpath_list
);
1981 /* If there was no winner, issue an error message. */
1982 if (!ffod
.candidates
|| TREE_CHAIN (ffod
.candidates
))
1984 error ("no unique final overrider for `%D' in `%T'", fn
,
1985 BINFO_TYPE (derived
));
1986 return error_mark_node
;
1989 return ffod
.candidates
;
1992 /* Return the index of the vcall offset for FN when TYPE is used as a
1996 get_vcall_index (tree fn
, tree type
)
1998 VEC (tree_pair_s
) *indices
= CLASSTYPE_VCALL_INDICES (type
);
2002 for (ix
= 0; VEC_iterate (tree_pair_s
, indices
, ix
, p
); ix
++)
2003 if ((DECL_DESTRUCTOR_P (fn
) && DECL_DESTRUCTOR_P (p
->purpose
))
2004 || same_signature_p (fn
, p
->purpose
))
2007 /* There should always be an appropriate index. */
2011 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2012 dominated by T. FN has been overridden in BINFO; VIRTUALS points to the
2013 corresponding position in the BINFO_VIRTUALS list. */
2016 update_vtable_entry_for_fn (tree t
, tree binfo
, tree fn
, tree
* virtuals
,
2024 tree overrider_fn
, overrider_target
;
2025 tree target_fn
= DECL_THUNK_P (fn
) ? THUNK_TARGET (fn
) : fn
;
2026 tree over_return
, base_return
;
2029 /* Find the nearest primary base (possibly binfo itself) which defines
2030 this function; this is the class the caller will convert to when
2031 calling FN through BINFO. */
2032 for (b
= binfo
; ; b
= get_primary_binfo (b
))
2035 if (look_for_overrides_here (BINFO_TYPE (b
), target_fn
))
2038 /* The nearest definition is from a lost primary. */
2039 if (BINFO_LOST_PRIMARY_P (b
))
2044 /* Find the final overrider. */
2045 overrider
= find_final_overrider (TYPE_BINFO (t
), b
, target_fn
);
2046 if (overrider
== error_mark_node
)
2048 overrider_target
= overrider_fn
= TREE_PURPOSE (overrider
);
2050 /* Check for adjusting covariant return types. */
2051 over_return
= TREE_TYPE (TREE_TYPE (overrider_target
));
2052 base_return
= TREE_TYPE (TREE_TYPE (target_fn
));
2054 if (POINTER_TYPE_P (over_return
)
2055 && TREE_CODE (over_return
) == TREE_CODE (base_return
)
2056 && CLASS_TYPE_P (TREE_TYPE (over_return
))
2057 && CLASS_TYPE_P (TREE_TYPE (base_return
)))
2059 /* If FN is a covariant thunk, we must figure out the adjustment
2060 to the final base FN was converting to. As OVERRIDER_TARGET might
2061 also be converting to the return type of FN, we have to
2062 combine the two conversions here. */
2063 tree fixed_offset
, virtual_offset
;
2065 if (DECL_THUNK_P (fn
))
2067 gcc_assert (DECL_RESULT_THUNK_P (fn
));
2068 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn
));
2069 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn
);
2072 fixed_offset
= virtual_offset
= NULL_TREE
;
2075 /* Find the equivalent binfo within the return type of the
2076 overriding function. We will want the vbase offset from
2078 virtual_offset
= binfo_for_vbase (BINFO_TYPE (virtual_offset
),
2079 TREE_TYPE (over_return
));
2080 else if (!same_type_p (TREE_TYPE (over_return
),
2081 TREE_TYPE (base_return
)))
2083 /* There was no existing virtual thunk (which takes
2088 thunk_binfo
= lookup_base (TREE_TYPE (over_return
),
2089 TREE_TYPE (base_return
),
2090 ba_check
| ba_quiet
, &kind
);
2092 if (thunk_binfo
&& (kind
== bk_via_virtual
2093 || !BINFO_OFFSET_ZEROP (thunk_binfo
)))
2095 tree offset
= convert (ssizetype
, BINFO_OFFSET (thunk_binfo
));
2097 if (kind
== bk_via_virtual
)
2099 /* We convert via virtual base. Find the virtual
2100 base and adjust the fixed offset to be from there. */
2101 while (!BINFO_VIRTUAL_P (thunk_binfo
))
2102 thunk_binfo
= BINFO_INHERITANCE_CHAIN (thunk_binfo
);
2104 virtual_offset
= thunk_binfo
;
2105 offset
= size_diffop
2107 (ssizetype
, BINFO_OFFSET (virtual_offset
)));
2110 /* There was an existing fixed offset, this must be
2111 from the base just converted to, and the base the
2112 FN was thunking to. */
2113 fixed_offset
= size_binop (PLUS_EXPR
, fixed_offset
, offset
);
2115 fixed_offset
= offset
;
2119 if (fixed_offset
|| virtual_offset
)
2120 /* Replace the overriding function with a covariant thunk. We
2121 will emit the overriding function in its own slot as
2123 overrider_fn
= make_thunk (overrider_target
, /*this_adjusting=*/0,
2124 fixed_offset
, virtual_offset
);
2127 gcc_assert (!DECL_THUNK_P (fn
));
2129 /* Assume that we will produce a thunk that convert all the way to
2130 the final overrider, and not to an intermediate virtual base. */
2131 virtual_base
= NULL_TREE
;
2133 /* See if we can convert to an intermediate virtual base first, and then
2134 use the vcall offset located there to finish the conversion. */
2135 for (; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
2137 /* If we find the final overrider, then we can stop
2139 if (same_type_p (BINFO_TYPE (b
),
2140 BINFO_TYPE (TREE_VALUE (overrider
))))
2143 /* If we find a virtual base, and we haven't yet found the
2144 overrider, then there is a virtual base between the
2145 declaring base (first_defn) and the final overrider. */
2146 if (BINFO_VIRTUAL_P (b
))
2153 if (overrider_fn
!= overrider_target
&& !virtual_base
)
2155 /* The ABI specifies that a covariant thunk includes a mangling
2156 for a this pointer adjustment. This-adjusting thunks that
2157 override a function from a virtual base have a vcall
2158 adjustment. When the virtual base in question is a primary
2159 virtual base, we know the adjustments are zero, (and in the
2160 non-covariant case, we would not use the thunk).
2161 Unfortunately we didn't notice this could happen, when
2162 designing the ABI and so never mandated that such a covariant
2163 thunk should be emitted. Because we must use the ABI mandated
2164 name, we must continue searching from the binfo where we
2165 found the most recent definition of the function, towards the
2166 primary binfo which first introduced the function into the
2167 vtable. If that enters a virtual base, we must use a vcall
2168 this-adjusting thunk. Bleah! */
2169 tree probe
= first_defn
;
2171 while ((probe
= get_primary_binfo (probe
))
2172 && (unsigned) list_length (BINFO_VIRTUALS (probe
)) > ix
)
2173 if (BINFO_VIRTUAL_P (probe
))
2174 virtual_base
= probe
;
2177 /* Even if we find a virtual base, the correct delta is
2178 between the overrider and the binfo we're building a vtable
2180 goto virtual_covariant
;
2183 /* Compute the constant adjustment to the `this' pointer. The
2184 `this' pointer, when this function is called, will point at BINFO
2185 (or one of its primary bases, which are at the same offset). */
2187 /* The `this' pointer needs to be adjusted from the declaration to
2188 the nearest virtual base. */
2189 delta
= size_diffop (convert (ssizetype
, BINFO_OFFSET (virtual_base
)),
2190 convert (ssizetype
, BINFO_OFFSET (first_defn
)));
2192 /* If the nearest definition is in a lost primary, we don't need an
2193 entry in our vtable. Except possibly in a constructor vtable,
2194 if we happen to get our primary back. In that case, the offset
2195 will be zero, as it will be a primary base. */
2196 delta
= size_zero_node
;
2198 /* The `this' pointer needs to be adjusted from pointing to
2199 BINFO to pointing at the base where the final overrider
2202 delta
= size_diffop (convert (ssizetype
,
2203 BINFO_OFFSET (TREE_VALUE (overrider
))),
2204 convert (ssizetype
, BINFO_OFFSET (binfo
)));
2206 modify_vtable_entry (t
, binfo
, overrider_fn
, delta
, virtuals
);
2209 BV_VCALL_INDEX (*virtuals
)
2210 = get_vcall_index (overrider_target
, BINFO_TYPE (virtual_base
));
2213 /* Called from modify_all_vtables via dfs_walk. */
2216 dfs_modify_vtables (tree binfo
, void* data
)
2218 tree t
= (tree
) data
;
2220 if (/* There's no need to modify the vtable for a non-virtual
2221 primary base; we're not going to use that vtable anyhow.
2222 We do still need to do this for virtual primary bases, as they
2223 could become non-primary in a construction vtable. */
2224 (!BINFO_PRIMARY_P (binfo
) || BINFO_VIRTUAL_P (binfo
))
2225 /* Similarly, a base without a vtable needs no modification. */
2226 && TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
))
2227 /* Don't do the primary vtable, if it's new. */
2228 && (BINFO_TYPE (binfo
) != t
|| CLASSTYPE_HAS_PRIMARY_BASE_P (t
)))
2234 make_new_vtable (t
, binfo
);
2236 /* Now, go through each of the virtual functions in the virtual
2237 function table for BINFO. Find the final overrider, and
2238 update the BINFO_VIRTUALS list appropriately. */
2239 for (ix
= 0, virtuals
= BINFO_VIRTUALS (binfo
),
2240 old_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
2242 ix
++, virtuals
= TREE_CHAIN (virtuals
),
2243 old_virtuals
= TREE_CHAIN (old_virtuals
))
2244 update_vtable_entry_for_fn (t
,
2246 BV_FN (old_virtuals
),
2250 BINFO_MARKED (binfo
) = 1;
2255 /* Update all of the primary and secondary vtables for T. Create new
2256 vtables as required, and initialize their RTTI information. Each
2257 of the functions in VIRTUALS is declared in T and may override a
2258 virtual function from a base class; find and modify the appropriate
2259 entries to point to the overriding functions. Returns a list, in
2260 declaration order, of the virtual functions that are declared in T,
2261 but do not appear in the primary base class vtable, and which
2262 should therefore be appended to the end of the vtable for T. */
2265 modify_all_vtables (tree t
, tree virtuals
)
2267 tree binfo
= TYPE_BINFO (t
);
2270 /* Update all of the vtables. */
2271 dfs_walk (binfo
, dfs_modify_vtables
, unmarkedp
, t
);
2272 dfs_walk (binfo
, dfs_unmark
, markedp
, t
);
2274 /* Add virtual functions not already in our primary vtable. These
2275 will be both those introduced by this class, and those overridden
2276 from secondary bases. It does not include virtuals merely
2277 inherited from secondary bases. */
2278 for (fnsp
= &virtuals
; *fnsp
; )
2280 tree fn
= TREE_VALUE (*fnsp
);
2282 if (!value_member (fn
, BINFO_VIRTUALS (binfo
))
2283 || DECL_VINDEX (fn
) == error_mark_node
)
2285 /* We don't need to adjust the `this' pointer when
2286 calling this function. */
2287 BV_DELTA (*fnsp
) = integer_zero_node
;
2288 BV_VCALL_INDEX (*fnsp
) = NULL_TREE
;
2290 /* This is a function not already in our vtable. Keep it. */
2291 fnsp
= &TREE_CHAIN (*fnsp
);
2294 /* We've already got an entry for this function. Skip it. */
2295 *fnsp
= TREE_CHAIN (*fnsp
);
2301 /* Get the base virtual function declarations in T that have the
2305 get_basefndecls (tree name
, tree t
)
2308 tree base_fndecls
= NULL_TREE
;
2309 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
2312 /* Find virtual functions in T with the indicated NAME. */
2313 i
= lookup_fnfields_1 (t
, name
);
2315 for (methods
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (t
), i
);
2317 methods
= OVL_NEXT (methods
))
2319 tree method
= OVL_CURRENT (methods
);
2321 if (TREE_CODE (method
) == FUNCTION_DECL
2322 && DECL_VINDEX (method
))
2323 base_fndecls
= tree_cons (NULL_TREE
, method
, base_fndecls
);
2327 return base_fndecls
;
2329 for (i
= 0; i
< n_baseclasses
; i
++)
2331 tree basetype
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t
), i
));
2332 base_fndecls
= chainon (get_basefndecls (name
, basetype
),
2336 return base_fndecls
;
2339 /* If this declaration supersedes the declaration of
2340 a method declared virtual in the base class, then
2341 mark this field as being virtual as well. */
2344 check_for_override (tree decl
, tree ctype
)
2346 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2347 /* In [temp.mem] we have:
2349 A specialization of a member function template does not
2350 override a virtual function from a base class. */
2352 if ((DECL_DESTRUCTOR_P (decl
)
2353 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
))
2354 || DECL_CONV_FN_P (decl
))
2355 && look_for_overrides (ctype
, decl
)
2356 && !DECL_STATIC_FUNCTION_P (decl
))
2357 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2358 the error_mark_node so that we know it is an overriding
2360 DECL_VINDEX (decl
) = decl
;
2362 if (DECL_VIRTUAL_P (decl
))
2364 if (!DECL_VINDEX (decl
))
2365 DECL_VINDEX (decl
) = error_mark_node
;
2366 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
2370 /* Warn about hidden virtual functions that are not overridden in t.
2371 We know that constructors and destructors don't apply. */
2374 warn_hidden (tree t
)
2376 VEC(tree
) *method_vec
= CLASSTYPE_METHOD_VEC (t
);
2380 /* We go through each separately named virtual function. */
2381 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2382 VEC_iterate (tree
, method_vec
, i
, fns
);
2393 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2394 have the same name. Figure out what name that is. */
2395 name
= DECL_NAME (OVL_CURRENT (fns
));
2396 /* There are no possibly hidden functions yet. */
2397 base_fndecls
= NULL_TREE
;
2398 /* Iterate through all of the base classes looking for possibly
2399 hidden functions. */
2400 for (binfo
= TYPE_BINFO (t
), j
= 0;
2401 BINFO_BASE_ITERATE (binfo
, j
, base_binfo
); j
++)
2403 tree basetype
= BINFO_TYPE (base_binfo
);
2404 base_fndecls
= chainon (get_basefndecls (name
, basetype
),
2408 /* If there are no functions to hide, continue. */
2412 /* Remove any overridden functions. */
2413 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
2415 fndecl
= OVL_CURRENT (fn
);
2416 if (DECL_VINDEX (fndecl
))
2418 tree
*prev
= &base_fndecls
;
2421 /* If the method from the base class has the same
2422 signature as the method from the derived class, it
2423 has been overridden. */
2424 if (same_signature_p (fndecl
, TREE_VALUE (*prev
)))
2425 *prev
= TREE_CHAIN (*prev
);
2427 prev
= &TREE_CHAIN (*prev
);
2431 /* Now give a warning for all base functions without overriders,
2432 as they are hidden. */
2433 while (base_fndecls
)
2435 /* Here we know it is a hider, and no overrider exists. */
2436 cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls
));
2437 cp_warning_at (" by `%D'", fns
);
2438 base_fndecls
= TREE_CHAIN (base_fndecls
);
2443 /* Check for things that are invalid. There are probably plenty of other
2444 things we should check for also. */
2447 finish_struct_anon (tree t
)
2451 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
2453 if (TREE_STATIC (field
))
2455 if (TREE_CODE (field
) != FIELD_DECL
)
2458 if (DECL_NAME (field
) == NULL_TREE
2459 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
2461 tree elt
= TYPE_FIELDS (TREE_TYPE (field
));
2462 for (; elt
; elt
= TREE_CHAIN (elt
))
2464 /* We're generally only interested in entities the user
2465 declared, but we also find nested classes by noticing
2466 the TYPE_DECL that we create implicitly. You're
2467 allowed to put one anonymous union inside another,
2468 though, so we explicitly tolerate that. We use
2469 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2470 we also allow unnamed types used for defining fields. */
2471 if (DECL_ARTIFICIAL (elt
)
2472 && (!DECL_IMPLICIT_TYPEDEF_P (elt
)
2473 || TYPE_ANONYMOUS_P (TREE_TYPE (elt
))))
2476 if (TREE_CODE (elt
) != FIELD_DECL
)
2478 cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members",
2483 if (TREE_PRIVATE (elt
))
2484 cp_pedwarn_at ("private member `%#D' in anonymous union",
2486 else if (TREE_PROTECTED (elt
))
2487 cp_pedwarn_at ("protected member `%#D' in anonymous union",
2490 TREE_PRIVATE (elt
) = TREE_PRIVATE (field
);
2491 TREE_PROTECTED (elt
) = TREE_PROTECTED (field
);
2497 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2498 will be used later during class template instantiation.
2499 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2500 a non-static member data (FIELD_DECL), a member function
2501 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2502 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2503 When FRIEND_P is nonzero, T is either a friend class
2504 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2505 (FUNCTION_DECL, TEMPLATE_DECL). */
2508 maybe_add_class_template_decl_list (tree type
, tree t
, int friend_p
)
2510 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2511 if (CLASSTYPE_TEMPLATE_INFO (type
))
2512 CLASSTYPE_DECL_LIST (type
)
2513 = tree_cons (friend_p
? NULL_TREE
: type
,
2514 t
, CLASSTYPE_DECL_LIST (type
));
2517 /* Create default constructors, assignment operators, and so forth for
2518 the type indicated by T, if they are needed.
2519 CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
2520 CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
2521 class cannot have a default constructor, copy constructor taking a
2522 const reference argument, or an assignment operator taking a const
2523 reference, respectively. If a virtual destructor is created, its
2524 DECL is returned; otherwise the return value is NULL_TREE. */
2527 add_implicitly_declared_members (tree t
,
2528 int cant_have_default_ctor
,
2529 int cant_have_const_cctor
,
2530 int cant_have_const_assignment
)
2533 tree implicit_fns
= NULL_TREE
;
2534 tree virtual_dtor
= NULL_TREE
;
2538 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) && !TYPE_HAS_DESTRUCTOR (t
))
2540 default_fn
= implicitly_declare_fn (sfk_destructor
, t
, /*const_p=*/0);
2541 check_for_override (default_fn
, t
);
2543 /* If we couldn't make it work, then pretend we didn't need it. */
2544 if (default_fn
== void_type_node
)
2545 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = 0;
2548 TREE_CHAIN (default_fn
) = implicit_fns
;
2549 implicit_fns
= default_fn
;
2551 if (DECL_VINDEX (default_fn
))
2552 virtual_dtor
= default_fn
;
2556 /* Any non-implicit destructor is non-trivial. */
2557 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) |= TYPE_HAS_DESTRUCTOR (t
);
2559 /* Default constructor. */
2560 if (! TYPE_HAS_CONSTRUCTOR (t
) && ! cant_have_default_ctor
)
2562 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 1;
2563 CLASSTYPE_LAZY_DEFAULT_CTOR (t
) = 1;
2566 /* Copy constructor. */
2567 if (! TYPE_HAS_INIT_REF (t
) && ! TYPE_FOR_JAVA (t
))
2569 TYPE_HAS_INIT_REF (t
) = 1;
2570 TYPE_HAS_CONST_INIT_REF (t
) = !cant_have_const_cctor
;
2571 CLASSTYPE_LAZY_COPY_CTOR (t
) = 1;
2572 TYPE_HAS_CONSTRUCTOR (t
) = 1;
2575 /* If there is no assignment operator, one will be created if and
2576 when it is needed. For now, just record whether or not the type
2577 of the parameter to the assignment operator will be a const or
2578 non-const reference. */
2579 if (!TYPE_HAS_ASSIGN_REF (t
) && !TYPE_FOR_JAVA (t
))
2581 TYPE_HAS_ASSIGN_REF (t
) = 1;
2582 TYPE_HAS_CONST_ASSIGN_REF (t
) = !cant_have_const_assignment
;
2583 CLASSTYPE_LAZY_ASSIGNMENT_OP (t
) = 1;
2586 /* Now, hook all of the new functions on to TYPE_METHODS,
2587 and add them to the CLASSTYPE_METHOD_VEC. */
2588 for (f
= &implicit_fns
; *f
; f
= &TREE_CHAIN (*f
))
2591 maybe_add_class_template_decl_list (current_class_type
, *f
, /*friend_p=*/0);
2593 if (abi_version_at_least (2))
2594 /* G++ 3.2 put the implicit destructor at the *beginning* of the
2595 list, which cause the destructor to be emitted in an incorrect
2596 location in the vtable. */
2597 TYPE_METHODS (t
) = chainon (TYPE_METHODS (t
), implicit_fns
);
2600 if (warn_abi
&& virtual_dtor
)
2601 warning ("vtable layout for class `%T' may not be ABI-compliant "
2602 "and may change in a future version of GCC due to implicit "
2603 "virtual destructor",
2605 *f
= TYPE_METHODS (t
);
2606 TYPE_METHODS (t
) = implicit_fns
;
2610 /* Subroutine of finish_struct_1. Recursively count the number of fields
2611 in TYPE, including anonymous union members. */
2614 count_fields (tree fields
)
2618 for (x
= fields
; x
; x
= TREE_CHAIN (x
))
2620 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2621 n_fields
+= count_fields (TYPE_FIELDS (TREE_TYPE (x
)));
2628 /* Subroutine of finish_struct_1. Recursively add all the fields in the
2629 TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */
2632 add_fields_to_record_type (tree fields
, struct sorted_fields_type
*field_vec
, int idx
)
2635 for (x
= fields
; x
; x
= TREE_CHAIN (x
))
2637 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
2638 idx
= add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x
)), field_vec
, idx
);
2640 field_vec
->elts
[idx
++] = x
;
2645 /* FIELD is a bit-field. We are finishing the processing for its
2646 enclosing type. Issue any appropriate messages and set appropriate
2650 check_bitfield_decl (tree field
)
2652 tree type
= TREE_TYPE (field
);
2655 /* Detect invalid bit-field type. */
2656 if (DECL_INITIAL (field
)
2657 && ! INTEGRAL_TYPE_P (TREE_TYPE (field
)))
2659 cp_error_at ("bit-field `%#D' with non-integral type", field
);
2660 w
= error_mark_node
;
2663 /* Detect and ignore out of range field width. */
2664 if (DECL_INITIAL (field
))
2666 w
= DECL_INITIAL (field
);
2668 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2671 /* detect invalid field size. */
2672 if (TREE_CODE (w
) == CONST_DECL
)
2673 w
= DECL_INITIAL (w
);
2675 w
= decl_constant_value (w
);
2677 if (TREE_CODE (w
) != INTEGER_CST
)
2679 cp_error_at ("bit-field `%D' width not an integer constant",
2681 w
= error_mark_node
;
2683 else if (tree_int_cst_sgn (w
) < 0)
2685 cp_error_at ("negative width in bit-field `%D'", field
);
2686 w
= error_mark_node
;
2688 else if (integer_zerop (w
) && DECL_NAME (field
) != 0)
2690 cp_error_at ("zero width for bit-field `%D'", field
);
2691 w
= error_mark_node
;
2693 else if (compare_tree_int (w
, TYPE_PRECISION (type
)) > 0
2694 && TREE_CODE (type
) != ENUMERAL_TYPE
2695 && TREE_CODE (type
) != BOOLEAN_TYPE
)
2696 cp_warning_at ("width of `%D' exceeds its type", field
);
2697 else if (TREE_CODE (type
) == ENUMERAL_TYPE
2698 && (0 > compare_tree_int (w
,
2699 min_precision (TYPE_MIN_VALUE (type
),
2700 TYPE_UNSIGNED (type
)))
2701 || 0 > compare_tree_int (w
,
2703 (TYPE_MAX_VALUE (type
),
2704 TYPE_UNSIGNED (type
)))))
2705 cp_warning_at ("`%D' is too small to hold all values of `%#T'",
2709 /* Remove the bit-field width indicator so that the rest of the
2710 compiler does not treat that value as an initializer. */
2711 DECL_INITIAL (field
) = NULL_TREE
;
2713 if (w
!= error_mark_node
)
2715 DECL_SIZE (field
) = convert (bitsizetype
, w
);
2716 DECL_BIT_FIELD (field
) = 1;
2720 /* Non-bit-fields are aligned for their type. */
2721 DECL_BIT_FIELD (field
) = 0;
2722 CLEAR_DECL_C_BIT_FIELD (field
);
2726 /* FIELD is a non bit-field. We are finishing the processing for its
2727 enclosing type T. Issue any appropriate messages and set appropriate
2731 check_field_decl (tree field
,
2733 int* cant_have_const_ctor
,
2734 int* cant_have_default_ctor
,
2735 int* no_const_asn_ref
,
2736 int* any_default_members
)
2738 tree type
= strip_array_types (TREE_TYPE (field
));
2740 /* An anonymous union cannot contain any fields which would change
2741 the settings of CANT_HAVE_CONST_CTOR and friends. */
2742 if (ANON_UNION_TYPE_P (type
))
2744 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2745 structs. So, we recurse through their fields here. */
2746 else if (ANON_AGGR_TYPE_P (type
))
2750 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
2751 if (TREE_CODE (fields
) == FIELD_DECL
&& !DECL_C_BIT_FIELD (field
))
2752 check_field_decl (fields
, t
, cant_have_const_ctor
,
2753 cant_have_default_ctor
, no_const_asn_ref
,
2754 any_default_members
);
2756 /* Check members with class type for constructors, destructors,
2758 else if (CLASS_TYPE_P (type
))
2760 /* Never let anything with uninheritable virtuals
2761 make it through without complaint. */
2762 abstract_virtuals_error (field
, type
);
2764 if (TREE_CODE (t
) == UNION_TYPE
)
2766 if (TYPE_NEEDS_CONSTRUCTING (type
))
2767 cp_error_at ("member `%#D' with constructor not allowed in union",
2769 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2770 cp_error_at ("member `%#D' with destructor not allowed in union",
2772 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type
))
2773 cp_error_at ("member `%#D' with copy assignment operator not allowed in union",
2778 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (type
);
2779 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
2780 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
);
2781 TYPE_HAS_COMPLEX_ASSIGN_REF (t
) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type
);
2782 TYPE_HAS_COMPLEX_INIT_REF (t
) |= TYPE_HAS_COMPLEX_INIT_REF (type
);
2785 if (!TYPE_HAS_CONST_INIT_REF (type
))
2786 *cant_have_const_ctor
= 1;
2788 if (!TYPE_HAS_CONST_ASSIGN_REF (type
))
2789 *no_const_asn_ref
= 1;
2791 if (TYPE_HAS_CONSTRUCTOR (type
)
2792 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
2793 *cant_have_default_ctor
= 1;
2795 if (DECL_INITIAL (field
) != NULL_TREE
)
2797 /* `build_class_init_list' does not recognize
2799 if (TREE_CODE (t
) == UNION_TYPE
&& any_default_members
!= 0)
2800 error ("multiple fields in union `%T' initialized", t
);
2801 *any_default_members
= 1;
2805 /* Check the data members (both static and non-static), class-scoped
2806 typedefs, etc., appearing in the declaration of T. Issue
2807 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
2808 declaration order) of access declarations; each TREE_VALUE in this
2809 list is a USING_DECL.
2811 In addition, set the following flags:
2814 The class is empty, i.e., contains no non-static data members.
2816 CANT_HAVE_DEFAULT_CTOR_P
2817 This class cannot have an implicitly generated default
2820 CANT_HAVE_CONST_CTOR_P
2821 This class cannot have an implicitly generated copy constructor
2822 taking a const reference.
2824 CANT_HAVE_CONST_ASN_REF
2825 This class cannot have an implicitly generated assignment
2826 operator taking a const reference.
2828 All of these flags should be initialized before calling this
2831 Returns a pointer to the end of the TYPE_FIELDs chain; additional
2832 fields can be added by adding to this chain. */
2835 check_field_decls (tree t
, tree
*access_decls
,
2836 int *cant_have_default_ctor_p
,
2837 int *cant_have_const_ctor_p
,
2838 int *no_const_asn_ref_p
)
2843 int any_default_members
;
2845 /* Assume there are no access declarations. */
2846 *access_decls
= NULL_TREE
;
2847 /* Assume this class has no pointer members. */
2848 has_pointers
= false;
2849 /* Assume none of the members of this class have default
2851 any_default_members
= 0;
2853 for (field
= &TYPE_FIELDS (t
); *field
; field
= next
)
2856 tree type
= TREE_TYPE (x
);
2858 next
= &TREE_CHAIN (x
);
2860 if (TREE_CODE (x
) == FIELD_DECL
)
2862 if (TYPE_PACKED (t
))
2864 if (!pod_type_p (TREE_TYPE (x
)) && !TYPE_PACKED (TREE_TYPE (x
)))
2866 ("ignoring packed attribute on unpacked non-POD field `%#D'",
2869 DECL_PACKED (x
) = 1;
2872 if (DECL_C_BIT_FIELD (x
) && integer_zerop (DECL_INITIAL (x
)))
2873 /* We don't treat zero-width bitfields as making a class
2880 /* The class is non-empty. */
2881 CLASSTYPE_EMPTY_P (t
) = 0;
2882 /* The class is not even nearly empty. */
2883 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
2884 /* If one of the data members contains an empty class,
2886 element_type
= strip_array_types (type
);
2887 if (CLASS_TYPE_P (element_type
)
2888 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type
))
2889 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
2893 if (TREE_CODE (x
) == USING_DECL
)
2895 /* Prune the access declaration from the list of fields. */
2896 *field
= TREE_CHAIN (x
);
2898 /* Save the access declarations for our caller. */
2899 *access_decls
= tree_cons (NULL_TREE
, x
, *access_decls
);
2901 /* Since we've reset *FIELD there's no reason to skip to the
2907 if (TREE_CODE (x
) == TYPE_DECL
2908 || TREE_CODE (x
) == TEMPLATE_DECL
)
2911 /* If we've gotten this far, it's a data member, possibly static,
2912 or an enumerator. */
2913 DECL_CONTEXT (x
) = t
;
2915 /* When this goes into scope, it will be a non-local reference. */
2916 DECL_NONLOCAL (x
) = 1;
2918 if (TREE_CODE (t
) == UNION_TYPE
)
2922 If a union contains a static data member, or a member of
2923 reference type, the program is ill-formed. */
2924 if (TREE_CODE (x
) == VAR_DECL
)
2926 cp_error_at ("`%D' may not be static because it is a member of a union", x
);
2929 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2931 cp_error_at ("`%D' may not have reference type `%T' because it is a member of a union",
2937 /* ``A local class cannot have static data members.'' ARM 9.4 */
2938 if (current_function_decl
&& TREE_STATIC (x
))
2939 cp_error_at ("field `%D' in local class cannot be static", x
);
2941 /* Perform error checking that did not get done in
2943 if (TREE_CODE (type
) == FUNCTION_TYPE
)
2945 cp_error_at ("field `%D' invalidly declared function type",
2947 type
= build_pointer_type (type
);
2948 TREE_TYPE (x
) = type
;
2950 else if (TREE_CODE (type
) == METHOD_TYPE
)
2952 cp_error_at ("field `%D' invalidly declared method type", x
);
2953 type
= build_pointer_type (type
);
2954 TREE_TYPE (x
) = type
;
2957 if (type
== error_mark_node
)
2960 if (TREE_CODE (x
) == CONST_DECL
|| TREE_CODE (x
) == VAR_DECL
)
2963 /* Now it can only be a FIELD_DECL. */
2965 if (TREE_PRIVATE (x
) || TREE_PROTECTED (x
))
2966 CLASSTYPE_NON_AGGREGATE (t
) = 1;
2968 /* If this is of reference type, check if it needs an init.
2969 Also do a little ANSI jig if necessary. */
2970 if (TREE_CODE (type
) == REFERENCE_TYPE
)
2972 CLASSTYPE_NON_POD_P (t
) = 1;
2973 if (DECL_INITIAL (x
) == NULL_TREE
)
2974 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
2976 /* ARM $12.6.2: [A member initializer list] (or, for an
2977 aggregate, initialization by a brace-enclosed list) is the
2978 only way to initialize nonstatic const and reference
2980 *cant_have_default_ctor_p
= 1;
2981 TYPE_HAS_COMPLEX_ASSIGN_REF (t
) = 1;
2983 if (! TYPE_HAS_CONSTRUCTOR (t
) && CLASSTYPE_NON_AGGREGATE (t
)
2985 cp_warning_at ("non-static reference `%#D' in class without a constructor", x
);
2988 type
= strip_array_types (type
);
2990 /* This is used by -Weffc++ (see below). Warn only for pointers
2991 to members which might hold dynamic memory. So do not warn
2992 for pointers to functions or pointers to members. */
2993 if (TYPE_PTR_P (type
)
2994 && !TYPE_PTRFN_P (type
)
2995 && !TYPE_PTR_TO_MEMBER_P (type
))
2996 has_pointers
= true;
2998 if (CLASS_TYPE_P (type
))
3000 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type
))
3001 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3002 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
))
3003 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3006 if (DECL_MUTABLE_P (x
) || TYPE_HAS_MUTABLE_P (type
))
3007 CLASSTYPE_HAS_MUTABLE (t
) = 1;
3009 if (! pod_type_p (type
))
3010 /* DR 148 now allows pointers to members (which are POD themselves),
3011 to be allowed in POD structs. */
3012 CLASSTYPE_NON_POD_P (t
) = 1;
3014 if (! zero_init_p (type
))
3015 CLASSTYPE_NON_ZERO_INIT_P (t
) = 1;
3017 /* If any field is const, the structure type is pseudo-const. */
3018 if (CP_TYPE_CONST_P (type
))
3020 C_TYPE_FIELDS_READONLY (t
) = 1;
3021 if (DECL_INITIAL (x
) == NULL_TREE
)
3022 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3024 /* ARM $12.6.2: [A member initializer list] (or, for an
3025 aggregate, initialization by a brace-enclosed list) is the
3026 only way to initialize nonstatic const and reference
3028 *cant_have_default_ctor_p
= 1;
3029 TYPE_HAS_COMPLEX_ASSIGN_REF (t
) = 1;
3031 if (! TYPE_HAS_CONSTRUCTOR (t
) && CLASSTYPE_NON_AGGREGATE (t
)
3033 cp_warning_at ("non-static const member `%#D' in class without a constructor", x
);
3035 /* A field that is pseudo-const makes the structure likewise. */
3036 else if (CLASS_TYPE_P (type
))
3038 C_TYPE_FIELDS_READONLY (t
) |= C_TYPE_FIELDS_READONLY (type
);
3039 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
,
3040 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
3041 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
));
3044 /* Core issue 80: A nonstatic data member is required to have a
3045 different name from the class iff the class has a
3046 user-defined constructor. */
3047 if (constructor_name_p (DECL_NAME (x
), t
) && TYPE_HAS_CONSTRUCTOR (t
))
3048 cp_pedwarn_at ("field `%#D' with same name as class", x
);
3050 /* We set DECL_C_BIT_FIELD in grokbitfield.
3051 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3052 if (DECL_C_BIT_FIELD (x
))
3053 check_bitfield_decl (x
);
3055 check_field_decl (x
, t
,
3056 cant_have_const_ctor_p
,
3057 cant_have_default_ctor_p
,
3059 &any_default_members
);
3062 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3063 it should also define a copy constructor and an assignment operator to
3064 implement the correct copy semantic (deep vs shallow, etc.). As it is
3065 not feasible to check whether the constructors do allocate dynamic memory
3066 and store it within members, we approximate the warning like this:
3068 -- Warn only if there are members which are pointers
3069 -- Warn only if there is a non-trivial constructor (otherwise,
3070 there cannot be memory allocated).
3071 -- Warn only if there is a non-trivial destructor. We assume that the
3072 user at least implemented the cleanup correctly, and a destructor
3073 is needed to free dynamic memory.
3075 This seems enough for pratical purposes. */
3078 && TYPE_HAS_CONSTRUCTOR (t
)
3079 && TYPE_HAS_DESTRUCTOR (t
)
3080 && !(TYPE_HAS_INIT_REF (t
) && TYPE_HAS_ASSIGN_REF (t
)))
3082 warning ("`%#T' has pointer data members", t
);
3084 if (! TYPE_HAS_INIT_REF (t
))
3086 warning (" but does not override `%T(const %T&)'", t
, t
);
3087 if (! TYPE_HAS_ASSIGN_REF (t
))
3088 warning (" or `operator=(const %T&)'", t
);
3090 else if (! TYPE_HAS_ASSIGN_REF (t
))
3091 warning (" but does not override `operator=(const %T&)'", t
);
3095 /* Check anonymous struct/anonymous union fields. */
3096 finish_struct_anon (t
);
3098 /* We've built up the list of access declarations in reverse order.
3100 *access_decls
= nreverse (*access_decls
);
3103 /* If TYPE is an empty class type, records its OFFSET in the table of
3107 record_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3111 if (!is_empty_class (type
))
3114 /* Record the location of this empty object in OFFSETS. */
3115 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3117 n
= splay_tree_insert (offsets
,
3118 (splay_tree_key
) offset
,
3119 (splay_tree_value
) NULL_TREE
);
3120 n
->value
= ((splay_tree_value
)
3121 tree_cons (NULL_TREE
,
3128 /* Returns nonzero if TYPE is an empty class type and there is
3129 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3132 check_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3137 if (!is_empty_class (type
))
3140 /* Record the location of this empty object in OFFSETS. */
3141 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3145 for (t
= (tree
) n
->value
; t
; t
= TREE_CHAIN (t
))
3146 if (same_type_p (TREE_VALUE (t
), type
))
3152 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3153 F for every subobject, passing it the type, offset, and table of
3154 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3157 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3158 than MAX_OFFSET will not be walked.
3160 If F returns a nonzero value, the traversal ceases, and that value
3161 is returned. Otherwise, returns zero. */
3164 walk_subobject_offsets (tree type
,
3165 subobject_offset_fn f
,
3172 tree type_binfo
= NULL_TREE
;
3174 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3176 if (max_offset
&& INT_CST_LT (max_offset
, offset
))
3181 if (abi_version_at_least (2))
3183 type
= BINFO_TYPE (type
);
3186 if (CLASS_TYPE_P (type
))
3192 /* Avoid recursing into objects that are not interesting. */
3193 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3196 /* Record the location of TYPE. */
3197 r
= (*f
) (type
, offset
, offsets
);
3201 /* Iterate through the direct base classes of TYPE. */
3203 type_binfo
= TYPE_BINFO (type
);
3204 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, binfo
); i
++)
3208 if (abi_version_at_least (2)
3209 && BINFO_VIRTUAL_P (binfo
))
3213 && BINFO_VIRTUAL_P (binfo
)
3214 && !BINFO_PRIMARY_P (binfo
))
3217 if (!abi_version_at_least (2))
3218 binfo_offset
= size_binop (PLUS_EXPR
,
3220 BINFO_OFFSET (binfo
));
3224 /* We cannot rely on BINFO_OFFSET being set for the base
3225 class yet, but the offsets for direct non-virtual
3226 bases can be calculated by going back to the TYPE. */
3227 orig_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
3228 binfo_offset
= size_binop (PLUS_EXPR
,
3230 BINFO_OFFSET (orig_binfo
));
3233 r
= walk_subobject_offsets (binfo
,
3238 (abi_version_at_least (2)
3239 ? /*vbases_p=*/0 : vbases_p
));
3244 if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type
))
3249 /* Iterate through the virtual base classes of TYPE. In G++
3250 3.2, we included virtual bases in the direct base class
3251 loop above, which results in incorrect results; the
3252 correct offsets for virtual bases are only known when
3253 working with the most derived type. */
3255 for (vbases
= CLASSTYPE_VBASECLASSES (type
), ix
= 0;
3256 VEC_iterate (tree
, vbases
, ix
, binfo
); ix
++)
3258 r
= walk_subobject_offsets (binfo
,
3260 size_binop (PLUS_EXPR
,
3262 BINFO_OFFSET (binfo
)),
3271 /* We still have to walk the primary base, if it is
3272 virtual. (If it is non-virtual, then it was walked
3274 tree vbase
= get_primary_binfo (type_binfo
);
3276 if (vbase
&& BINFO_VIRTUAL_P (vbase
)
3277 && BINFO_PRIMARY_P (vbase
)
3278 && BINFO_INHERITANCE_CHAIN (vbase
) == type_binfo
)
3280 r
= (walk_subobject_offsets
3282 offsets
, max_offset
, /*vbases_p=*/0));
3289 /* Iterate through the fields of TYPE. */
3290 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
3291 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_ARTIFICIAL (field
))
3295 if (abi_version_at_least (2))
3296 field_offset
= byte_position (field
);
3298 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3299 field_offset
= DECL_FIELD_OFFSET (field
);
3301 r
= walk_subobject_offsets (TREE_TYPE (field
),
3303 size_binop (PLUS_EXPR
,
3313 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3315 tree element_type
= strip_array_types (type
);
3316 tree domain
= TYPE_DOMAIN (type
);
3319 /* Avoid recursing into objects that are not interesting. */
3320 if (!CLASS_TYPE_P (element_type
)
3321 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type
))
3324 /* Step through each of the elements in the array. */
3325 for (index
= size_zero_node
;
3326 /* G++ 3.2 had an off-by-one error here. */
3327 (abi_version_at_least (2)
3328 ? !INT_CST_LT (TYPE_MAX_VALUE (domain
), index
)
3329 : INT_CST_LT (index
, TYPE_MAX_VALUE (domain
)));
3330 index
= size_binop (PLUS_EXPR
, index
, size_one_node
))
3332 r
= walk_subobject_offsets (TREE_TYPE (type
),
3340 offset
= size_binop (PLUS_EXPR
, offset
,
3341 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3342 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3343 there's no point in iterating through the remaining
3344 elements of the array. */
3345 if (max_offset
&& INT_CST_LT (max_offset
, offset
))
3353 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3354 OFFSETS. If VBASES_P is nonzero, virtual bases of TYPE are
3358 record_subobject_offsets (tree type
,
3363 walk_subobject_offsets (type
, record_subobject_offset
, offset
,
3364 offsets
, /*max_offset=*/NULL_TREE
, vbases_p
);
3367 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3368 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3369 virtual bases of TYPE are examined. */
3372 layout_conflict_p (tree type
,
3377 splay_tree_node max_node
;
3379 /* Get the node in OFFSETS that indicates the maximum offset where
3380 an empty subobject is located. */
3381 max_node
= splay_tree_max (offsets
);
3382 /* If there aren't any empty subobjects, then there's no point in
3383 performing this check. */
3387 return walk_subobject_offsets (type
, check_subobject_offset
, offset
,
3388 offsets
, (tree
) (max_node
->key
),
3392 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3393 non-static data member of the type indicated by RLI. BINFO is the
3394 binfo corresponding to the base subobject, OFFSETS maps offsets to
3395 types already located at those offsets. This function determines
3396 the position of the DECL. */
3399 layout_nonempty_base_or_field (record_layout_info rli
,
3404 tree offset
= NULL_TREE
;
3410 /* For the purposes of determining layout conflicts, we want to
3411 use the class type of BINFO; TREE_TYPE (DECL) will be the
3412 CLASSTYPE_AS_BASE version, which does not contain entries for
3413 zero-sized bases. */
3414 type
= TREE_TYPE (binfo
);
3419 type
= TREE_TYPE (decl
);
3423 /* Try to place the field. It may take more than one try if we have
3424 a hard time placing the field without putting two objects of the
3425 same type at the same address. */
3428 struct record_layout_info_s old_rli
= *rli
;
3430 /* Place this field. */
3431 place_field (rli
, decl
);
3432 offset
= byte_position (decl
);
3434 /* We have to check to see whether or not there is already
3435 something of the same type at the offset we're about to use.
3436 For example, consider:
3439 struct T : public S { int i; };
3440 struct U : public S, public T {};
3442 Here, we put S at offset zero in U. Then, we can't put T at
3443 offset zero -- its S component would be at the same address
3444 as the S we already allocated. So, we have to skip ahead.
3445 Since all data members, including those whose type is an
3446 empty class, have nonzero size, any overlap can happen only
3447 with a direct or indirect base-class -- it can't happen with
3449 /* In a union, overlap is permitted; all members are placed at
3451 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
3453 /* G++ 3.2 did not check for overlaps when placing a non-empty
3455 if (!abi_version_at_least (2) && binfo
&& BINFO_VIRTUAL_P (binfo
))
3457 if (layout_conflict_p (field_p
? type
: binfo
, offset
,
3460 /* Strip off the size allocated to this field. That puts us
3461 at the first place we could have put the field with
3462 proper alignment. */
3465 /* Bump up by the alignment required for the type. */
3467 = size_binop (PLUS_EXPR
, rli
->bitpos
,
3469 ? CLASSTYPE_ALIGN (type
)
3470 : TYPE_ALIGN (type
)));
3471 normalize_rli (rli
);
3474 /* There was no conflict. We're done laying out this field. */
3478 /* Now that we know where it will be placed, update its
3480 if (binfo
&& CLASS_TYPE_P (BINFO_TYPE (binfo
)))
3481 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3482 this point because their BINFO_OFFSET is copied from another
3483 hierarchy. Therefore, we may not need to add the entire
3485 propagate_binfo_offsets (binfo
,
3486 size_diffop (convert (ssizetype
, offset
),
3488 BINFO_OFFSET (binfo
))));
3491 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3494 empty_base_at_nonzero_offset_p (tree type
,
3496 splay_tree offsets ATTRIBUTE_UNUSED
)
3498 return is_empty_class (type
) && !integer_zerop (offset
);
3501 /* Layout the empty base BINFO. EOC indicates the byte currently just
3502 past the end of the class, and should be correctly aligned for a
3503 class of the type indicated by BINFO; OFFSETS gives the offsets of
3504 the empty bases allocated so far. T is the most derived
3505 type. Return nonzero iff we added it at the end. */
3508 layout_empty_base (tree binfo
, tree eoc
, splay_tree offsets
)
3511 tree basetype
= BINFO_TYPE (binfo
);
3514 /* This routine should only be used for empty classes. */
3515 gcc_assert (is_empty_class (basetype
));
3516 alignment
= ssize_int (CLASSTYPE_ALIGN_UNIT (basetype
));
3518 if (!integer_zerop (BINFO_OFFSET (binfo
)))
3520 if (abi_version_at_least (2))
3521 propagate_binfo_offsets
3522 (binfo
, size_diffop (size_zero_node
, BINFO_OFFSET (binfo
)));
3524 warning ("offset of empty base `%T' may not be ABI-compliant and may"
3525 "change in a future version of GCC",
3526 BINFO_TYPE (binfo
));
3529 /* This is an empty base class. We first try to put it at offset
3531 if (layout_conflict_p (binfo
,
3532 BINFO_OFFSET (binfo
),
3536 /* That didn't work. Now, we move forward from the next
3537 available spot in the class. */
3539 propagate_binfo_offsets (binfo
, convert (ssizetype
, eoc
));
3542 if (!layout_conflict_p (binfo
,
3543 BINFO_OFFSET (binfo
),
3546 /* We finally found a spot where there's no overlap. */
3549 /* There's overlap here, too. Bump along to the next spot. */
3550 propagate_binfo_offsets (binfo
, alignment
);
3556 /* Layout the the base given by BINFO in the class indicated by RLI.
3557 *BASE_ALIGN is a running maximum of the alignments of
3558 any base class. OFFSETS gives the location of empty base
3559 subobjects. T is the most derived type. Return nonzero if the new
3560 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3561 *NEXT_FIELD, unless BINFO is for an empty base class.
3563 Returns the location at which the next field should be inserted. */
3566 build_base_field (record_layout_info rli
, tree binfo
,
3567 splay_tree offsets
, tree
*next_field
)
3570 tree basetype
= BINFO_TYPE (binfo
);
3572 if (!COMPLETE_TYPE_P (basetype
))
3573 /* This error is now reported in xref_tag, thus giving better
3574 location information. */
3577 /* Place the base class. */
3578 if (!is_empty_class (basetype
))
3582 /* The containing class is non-empty because it has a non-empty
3584 CLASSTYPE_EMPTY_P (t
) = 0;
3586 /* Create the FIELD_DECL. */
3587 decl
= build_decl (FIELD_DECL
, NULL_TREE
, CLASSTYPE_AS_BASE (basetype
));
3588 DECL_ARTIFICIAL (decl
) = 1;
3589 DECL_FIELD_CONTEXT (decl
) = t
;
3590 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
3591 DECL_SIZE_UNIT (decl
) = CLASSTYPE_SIZE_UNIT (basetype
);
3592 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
3593 DECL_USER_ALIGN (decl
) = CLASSTYPE_USER_ALIGN (basetype
);
3594 DECL_IGNORED_P (decl
) = 1;
3595 DECL_FIELD_IS_BASE (decl
) = 1;
3597 /* Try to place the field. It may take more than one try if we
3598 have a hard time placing the field without putting two
3599 objects of the same type at the same address. */
3600 layout_nonempty_base_or_field (rli
, decl
, binfo
, offsets
);
3601 /* Add the new FIELD_DECL to the list of fields for T. */
3602 TREE_CHAIN (decl
) = *next_field
;
3604 next_field
= &TREE_CHAIN (decl
);
3611 /* On some platforms (ARM), even empty classes will not be
3613 eoc
= round_up (rli_size_unit_so_far (rli
),
3614 CLASSTYPE_ALIGN_UNIT (basetype
));
3615 atend
= layout_empty_base (binfo
, eoc
, offsets
);
3616 /* A nearly-empty class "has no proper base class that is empty,
3617 not morally virtual, and at an offset other than zero." */
3618 if (!BINFO_VIRTUAL_P (binfo
) && CLASSTYPE_NEARLY_EMPTY_P (t
))
3621 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3622 /* The check above (used in G++ 3.2) is insufficient because
3623 an empty class placed at offset zero might itself have an
3624 empty base at a nonzero offset. */
3625 else if (walk_subobject_offsets (basetype
,
3626 empty_base_at_nonzero_offset_p
,
3629 /*max_offset=*/NULL_TREE
,
3632 if (abi_version_at_least (2))
3633 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3635 warning ("class `%T' will be considered nearly empty in a "
3636 "future version of GCC", t
);
3640 /* We do not create a FIELD_DECL for empty base classes because
3641 it might overlap some other field. We want to be able to
3642 create CONSTRUCTORs for the class by iterating over the
3643 FIELD_DECLs, and the back end does not handle overlapping
3646 /* An empty virtual base causes a class to be non-empty
3647 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3648 here because that was already done when the virtual table
3649 pointer was created. */
3652 /* Record the offsets of BINFO and its base subobjects. */
3653 record_subobject_offsets (binfo
,
3654 BINFO_OFFSET (binfo
),
3661 /* Layout all of the non-virtual base classes. Record empty
3662 subobjects in OFFSETS. T is the most derived type. Return nonzero
3663 if the type cannot be nearly empty. The fields created
3664 corresponding to the base classes will be inserted at
3668 build_base_fields (record_layout_info rli
,
3669 splay_tree offsets
, tree
*next_field
)
3671 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3674 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
3677 /* The primary base class is always allocated first. */
3678 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
3679 next_field
= build_base_field (rli
, CLASSTYPE_PRIMARY_BINFO (t
),
3680 offsets
, next_field
);
3682 /* Now allocate the rest of the bases. */
3683 for (i
= 0; i
< n_baseclasses
; ++i
)
3687 base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (t
), i
);
3689 /* The primary base was already allocated above, so we don't
3690 need to allocate it again here. */
3691 if (base_binfo
== CLASSTYPE_PRIMARY_BINFO (t
))
3694 /* Virtual bases are added at the end (a primary virtual base
3695 will have already been added). */
3696 if (BINFO_VIRTUAL_P (base_binfo
))
3699 next_field
= build_base_field (rli
, base_binfo
,
3700 offsets
, next_field
);
3704 /* Go through the TYPE_METHODS of T issuing any appropriate
3705 diagnostics, figuring out which methods override which other
3706 methods, and so forth. */
3709 check_methods (tree t
)
3713 for (x
= TYPE_METHODS (t
); x
; x
= TREE_CHAIN (x
))
3715 check_for_override (x
, t
);
3716 if (DECL_PURE_VIRTUAL_P (x
) && ! DECL_VINDEX (x
))
3717 cp_error_at ("initializer specified for non-virtual method `%D'", x
);
3718 /* The name of the field is the original field name
3719 Save this in auxiliary field for later overloading. */
3720 if (DECL_VINDEX (x
))
3722 TYPE_POLYMORPHIC_P (t
) = 1;
3723 if (DECL_PURE_VIRTUAL_P (x
))
3724 CLASSTYPE_PURE_VIRTUALS (t
)
3725 = tree_cons (NULL_TREE
, x
, CLASSTYPE_PURE_VIRTUALS (t
));
3730 /* FN is a constructor or destructor. Clone the declaration to create
3731 a specialized in-charge or not-in-charge version, as indicated by
3735 build_clone (tree fn
, tree name
)
3740 /* Copy the function. */
3741 clone
= copy_decl (fn
);
3742 /* Remember where this function came from. */
3743 DECL_CLONED_FUNCTION (clone
) = fn
;
3744 DECL_ABSTRACT_ORIGIN (clone
) = fn
;
3745 /* Reset the function name. */
3746 DECL_NAME (clone
) = name
;
3747 SET_DECL_ASSEMBLER_NAME (clone
, NULL_TREE
);
3748 /* There's no pending inline data for this function. */
3749 DECL_PENDING_INLINE_INFO (clone
) = NULL
;
3750 DECL_PENDING_INLINE_P (clone
) = 0;
3751 /* And it hasn't yet been deferred. */
3752 DECL_DEFERRED_FN (clone
) = 0;
3754 /* The base-class destructor is not virtual. */
3755 if (name
== base_dtor_identifier
)
3757 DECL_VIRTUAL_P (clone
) = 0;
3758 if (TREE_CODE (clone
) != TEMPLATE_DECL
)
3759 DECL_VINDEX (clone
) = NULL_TREE
;
3762 /* If there was an in-charge parameter, drop it from the function
3764 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
3770 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
3771 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
3772 parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
3773 /* Skip the `this' parameter. */
3774 parmtypes
= TREE_CHAIN (parmtypes
);
3775 /* Skip the in-charge parameter. */
3776 parmtypes
= TREE_CHAIN (parmtypes
);
3777 /* And the VTT parm, in a complete [cd]tor. */
3778 if (DECL_HAS_VTT_PARM_P (fn
)
3779 && ! DECL_NEEDS_VTT_PARM_P (clone
))
3780 parmtypes
= TREE_CHAIN (parmtypes
);
3781 /* If this is subobject constructor or destructor, add the vtt
3784 = build_method_type_directly (basetype
,
3785 TREE_TYPE (TREE_TYPE (clone
)),
3788 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
),
3791 = cp_build_type_attribute_variant (TREE_TYPE (clone
),
3792 TYPE_ATTRIBUTES (TREE_TYPE (fn
)));
3795 /* Copy the function parameters. But, DECL_ARGUMENTS on a TEMPLATE_DECL
3796 aren't function parameters; those are the template parameters. */
3797 if (TREE_CODE (clone
) != TEMPLATE_DECL
)
3799 DECL_ARGUMENTS (clone
) = copy_list (DECL_ARGUMENTS (clone
));
3800 /* Remove the in-charge parameter. */
3801 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
3803 TREE_CHAIN (DECL_ARGUMENTS (clone
))
3804 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone
)));
3805 DECL_HAS_IN_CHARGE_PARM_P (clone
) = 0;
3807 /* And the VTT parm, in a complete [cd]tor. */
3808 if (DECL_HAS_VTT_PARM_P (fn
))
3810 if (DECL_NEEDS_VTT_PARM_P (clone
))
3811 DECL_HAS_VTT_PARM_P (clone
) = 1;
3814 TREE_CHAIN (DECL_ARGUMENTS (clone
))
3815 = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (clone
)));
3816 DECL_HAS_VTT_PARM_P (clone
) = 0;
3820 for (parms
= DECL_ARGUMENTS (clone
); parms
; parms
= TREE_CHAIN (parms
))
3822 DECL_CONTEXT (parms
) = clone
;
3823 cxx_dup_lang_specific_decl (parms
);
3827 /* Create the RTL for this function. */
3828 SET_DECL_RTL (clone
, NULL_RTX
);
3829 rest_of_decl_compilation (clone
, /*top_level=*/1, at_eof
);
3831 /* Make it easy to find the CLONE given the FN. */
3832 TREE_CHAIN (clone
) = TREE_CHAIN (fn
);
3833 TREE_CHAIN (fn
) = clone
;
3835 /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */
3836 if (TREE_CODE (clone
) == TEMPLATE_DECL
)
3840 DECL_TEMPLATE_RESULT (clone
)
3841 = build_clone (DECL_TEMPLATE_RESULT (clone
), name
);
3842 result
= DECL_TEMPLATE_RESULT (clone
);
3843 DECL_TEMPLATE_INFO (result
) = copy_node (DECL_TEMPLATE_INFO (result
));
3844 DECL_TI_TEMPLATE (result
) = clone
;
3850 /* Produce declarations for all appropriate clones of FN. If
3851 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
3852 CLASTYPE_METHOD_VEC as well. */
3855 clone_function_decl (tree fn
, int update_method_vec_p
)
3859 /* Avoid inappropriate cloning. */
3861 && DECL_CLONED_FUNCTION (TREE_CHAIN (fn
)))
3864 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
3866 /* For each constructor, we need two variants: an in-charge version
3867 and a not-in-charge version. */
3868 clone
= build_clone (fn
, complete_ctor_identifier
);
3869 if (update_method_vec_p
)
3870 add_method (DECL_CONTEXT (clone
), clone
);
3871 clone
= build_clone (fn
, base_ctor_identifier
);
3872 if (update_method_vec_p
)
3873 add_method (DECL_CONTEXT (clone
), clone
);
3877 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
));
3879 /* For each destructor, we need three variants: an in-charge
3880 version, a not-in-charge version, and an in-charge deleting
3881 version. We clone the deleting version first because that
3882 means it will go second on the TYPE_METHODS list -- and that
3883 corresponds to the correct layout order in the virtual
3886 For a non-virtual destructor, we do not build a deleting
3888 if (DECL_VIRTUAL_P (fn
))
3890 clone
= build_clone (fn
, deleting_dtor_identifier
);
3891 if (update_method_vec_p
)
3892 add_method (DECL_CONTEXT (clone
), clone
);
3894 clone
= build_clone (fn
, complete_dtor_identifier
);
3895 if (update_method_vec_p
)
3896 add_method (DECL_CONTEXT (clone
), clone
);
3897 clone
= build_clone (fn
, base_dtor_identifier
);
3898 if (update_method_vec_p
)
3899 add_method (DECL_CONTEXT (clone
), clone
);
3902 /* Note that this is an abstract function that is never emitted. */
3903 DECL_ABSTRACT (fn
) = 1;
3906 /* DECL is an in charge constructor, which is being defined. This will
3907 have had an in class declaration, from whence clones were
3908 declared. An out-of-class definition can specify additional default
3909 arguments. As it is the clones that are involved in overload
3910 resolution, we must propagate the information from the DECL to its
3914 adjust_clone_args (tree decl
)
3918 for (clone
= TREE_CHAIN (decl
); clone
&& DECL_CLONED_FUNCTION (clone
);
3919 clone
= TREE_CHAIN (clone
))
3921 tree orig_clone_parms
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
3922 tree orig_decl_parms
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
3923 tree decl_parms
, clone_parms
;
3925 clone_parms
= orig_clone_parms
;
3927 /* Skip the 'this' parameter. */
3928 orig_clone_parms
= TREE_CHAIN (orig_clone_parms
);
3929 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
3931 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
3932 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
3933 if (DECL_HAS_VTT_PARM_P (decl
))
3934 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
3936 clone_parms
= orig_clone_parms
;
3937 if (DECL_HAS_VTT_PARM_P (clone
))
3938 clone_parms
= TREE_CHAIN (clone_parms
);
3940 for (decl_parms
= orig_decl_parms
; decl_parms
;
3941 decl_parms
= TREE_CHAIN (decl_parms
),
3942 clone_parms
= TREE_CHAIN (clone_parms
))
3944 gcc_assert (same_type_p (TREE_TYPE (decl_parms
),
3945 TREE_TYPE (clone_parms
)));
3947 if (TREE_PURPOSE (decl_parms
) && !TREE_PURPOSE (clone_parms
))
3949 /* A default parameter has been added. Adjust the
3950 clone's parameters. */
3951 tree exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
3952 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
3955 clone_parms
= orig_decl_parms
;
3957 if (DECL_HAS_VTT_PARM_P (clone
))
3959 clone_parms
= tree_cons (TREE_PURPOSE (orig_clone_parms
),
3960 TREE_VALUE (orig_clone_parms
),
3962 TREE_TYPE (clone_parms
) = TREE_TYPE (orig_clone_parms
);
3964 type
= build_method_type_directly (basetype
,
3965 TREE_TYPE (TREE_TYPE (clone
)),
3968 type
= build_exception_variant (type
, exceptions
);
3969 TREE_TYPE (clone
) = type
;
3971 clone_parms
= NULL_TREE
;
3975 gcc_assert (!clone_parms
);
3979 /* For each of the constructors and destructors in T, create an
3980 in-charge and not-in-charge variant. */
3983 clone_constructors_and_destructors (tree t
)
3987 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
3989 if (!CLASSTYPE_METHOD_VEC (t
))
3992 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
3993 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
3994 for (fns
= CLASSTYPE_DESTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
3995 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
3998 /* Remove all zero-width bit-fields from T. */
4001 remove_zero_width_bit_fields (tree t
)
4005 fieldsp
= &TYPE_FIELDS (t
);
4008 if (TREE_CODE (*fieldsp
) == FIELD_DECL
4009 && DECL_C_BIT_FIELD (*fieldsp
)
4010 && DECL_INITIAL (*fieldsp
))
4011 *fieldsp
= TREE_CHAIN (*fieldsp
);
4013 fieldsp
= &TREE_CHAIN (*fieldsp
);
4017 /* Returns TRUE iff we need a cookie when dynamically allocating an
4018 array whose elements have the indicated class TYPE. */
4021 type_requires_array_cookie (tree type
)
4024 bool has_two_argument_delete_p
= false;
4026 gcc_assert (CLASS_TYPE_P (type
));
4028 /* If there's a non-trivial destructor, we need a cookie. In order
4029 to iterate through the array calling the destructor for each
4030 element, we'll have to know how many elements there are. */
4031 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4034 /* If the usual deallocation function is a two-argument whose second
4035 argument is of type `size_t', then we have to pass the size of
4036 the array to the deallocation function, so we will need to store
4038 fns
= lookup_fnfields (TYPE_BINFO (type
),
4039 ansi_opname (VEC_DELETE_EXPR
),
4041 /* If there are no `operator []' members, or the lookup is
4042 ambiguous, then we don't need a cookie. */
4043 if (!fns
|| fns
== error_mark_node
)
4045 /* Loop through all of the functions. */
4046 for (fns
= BASELINK_FUNCTIONS (fns
); fns
; fns
= OVL_NEXT (fns
))
4051 /* Select the current function. */
4052 fn
= OVL_CURRENT (fns
);
4053 /* See if this function is a one-argument delete function. If
4054 it is, then it will be the usual deallocation function. */
4055 second_parm
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn
)));
4056 if (second_parm
== void_list_node
)
4058 /* Otherwise, if we have a two-argument function and the second
4059 argument is `size_t', it will be the usual deallocation
4060 function -- unless there is one-argument function, too. */
4061 if (TREE_CHAIN (second_parm
) == void_list_node
4062 && same_type_p (TREE_VALUE (second_parm
), sizetype
))
4063 has_two_argument_delete_p
= true;
4066 return has_two_argument_delete_p
;
4069 /* Check the validity of the bases and members declared in T. Add any
4070 implicitly-generated functions (like copy-constructors and
4071 assignment operators). Compute various flag bits (like
4072 CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++
4073 level: i.e., independently of the ABI in use. */
4076 check_bases_and_members (tree t
)
4078 /* Nonzero if we are not allowed to generate a default constructor
4080 int cant_have_default_ctor
;
4081 /* Nonzero if the implicitly generated copy constructor should take
4082 a non-const reference argument. */
4083 int cant_have_const_ctor
;
4084 /* Nonzero if the the implicitly generated assignment operator
4085 should take a non-const reference argument. */
4086 int no_const_asn_ref
;
4089 /* By default, we use const reference arguments and generate default
4091 cant_have_default_ctor
= 0;
4092 cant_have_const_ctor
= 0;
4093 no_const_asn_ref
= 0;
4095 /* Check all the base-classes. */
4096 check_bases (t
, &cant_have_default_ctor
, &cant_have_const_ctor
,
4099 /* Check all the data member declarations. */
4100 check_field_decls (t
, &access_decls
,
4101 &cant_have_default_ctor
,
4102 &cant_have_const_ctor
,
4105 /* Check all the method declarations. */
4108 /* A nearly-empty class has to be vptr-containing; a nearly empty
4109 class contains just a vptr. */
4110 if (!TYPE_CONTAINS_VPTR_P (t
))
4111 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4113 /* Do some bookkeeping that will guide the generation of implicitly
4114 declared member functions. */
4115 TYPE_HAS_COMPLEX_INIT_REF (t
)
4116 |= (TYPE_HAS_INIT_REF (t
)
4117 || TYPE_USES_VIRTUAL_BASECLASSES (t
)
4118 || TYPE_POLYMORPHIC_P (t
));
4119 TYPE_NEEDS_CONSTRUCTING (t
)
4120 |= (TYPE_HAS_CONSTRUCTOR (t
)
4121 || TYPE_USES_VIRTUAL_BASECLASSES (t
)
4122 || TYPE_POLYMORPHIC_P (t
));
4123 CLASSTYPE_NON_AGGREGATE (t
) |= (TYPE_HAS_CONSTRUCTOR (t
)
4124 || TYPE_POLYMORPHIC_P (t
));
4125 CLASSTYPE_NON_POD_P (t
)
4126 |= (CLASSTYPE_NON_AGGREGATE (t
) || TYPE_HAS_DESTRUCTOR (t
)
4127 || TYPE_HAS_ASSIGN_REF (t
));
4128 TYPE_HAS_COMPLEX_ASSIGN_REF (t
)
4129 |= TYPE_HAS_ASSIGN_REF (t
) || TYPE_CONTAINS_VPTR_P (t
);
4131 /* Synthesize any needed methods. */
4132 add_implicitly_declared_members (t
, cant_have_default_ctor
,
4133 cant_have_const_ctor
,
4136 /* Create the in-charge and not-in-charge variants of constructors
4138 clone_constructors_and_destructors (t
);
4140 /* Process the using-declarations. */
4141 for (; access_decls
; access_decls
= TREE_CHAIN (access_decls
))
4142 handle_using_decl (TREE_VALUE (access_decls
), t
);
4144 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4145 finish_struct_methods (t
);
4147 /* Figure out whether or not we will need a cookie when dynamically
4148 allocating an array of this type. */
4149 TYPE_LANG_SPECIFIC (t
)->u
.c
.vec_new_uses_cookie
4150 = type_requires_array_cookie (t
);
4153 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4154 accordingly. If a new vfield was created (because T doesn't have a
4155 primary base class), then the newly created field is returned. It
4156 is not added to the TYPE_FIELDS list; it is the caller's
4157 responsibility to do that. Accumulate declared virtual functions
4161 create_vtable_ptr (tree t
, tree
* virtuals_p
)
4165 /* Collect the virtual functions declared in T. */
4166 for (fn
= TYPE_METHODS (t
); fn
; fn
= TREE_CHAIN (fn
))
4167 if (DECL_VINDEX (fn
) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
)
4168 && TREE_CODE (DECL_VINDEX (fn
)) != INTEGER_CST
)
4170 tree new_virtual
= make_node (TREE_LIST
);
4172 BV_FN (new_virtual
) = fn
;
4173 BV_DELTA (new_virtual
) = integer_zero_node
;
4175 TREE_CHAIN (new_virtual
) = *virtuals_p
;
4176 *virtuals_p
= new_virtual
;
4179 /* If we couldn't find an appropriate base class, create a new field
4180 here. Even if there weren't any new virtual functions, we might need a
4181 new virtual function table if we're supposed to include vptrs in
4182 all classes that need them. */
4183 if (!TYPE_VFIELD (t
) && (*virtuals_p
|| TYPE_CONTAINS_VPTR_P (t
)))
4185 /* We build this decl with vtbl_ptr_type_node, which is a
4186 `vtable_entry_type*'. It might seem more precise to use
4187 `vtable_entry_type (*)[N]' where N is the number of virtual
4188 functions. However, that would require the vtable pointer in
4189 base classes to have a different type than the vtable pointer
4190 in derived classes. We could make that happen, but that
4191 still wouldn't solve all the problems. In particular, the
4192 type-based alias analysis code would decide that assignments
4193 to the base class vtable pointer can't alias assignments to
4194 the derived class vtable pointer, since they have different
4195 types. Thus, in a derived class destructor, where the base
4196 class constructor was inlined, we could generate bad code for
4197 setting up the vtable pointer.
4199 Therefore, we use one type for all vtable pointers. We still
4200 use a type-correct type; it's just doesn't indicate the array
4201 bounds. That's better than using `void*' or some such; it's
4202 cleaner, and it let's the alias analysis code know that these
4203 stores cannot alias stores to void*! */
4206 field
= build_decl (FIELD_DECL
, get_vfield_name (t
), vtbl_ptr_type_node
);
4207 SET_DECL_ASSEMBLER_NAME (field
, get_identifier (VFIELD_BASE
));
4208 DECL_VIRTUAL_P (field
) = 1;
4209 DECL_ARTIFICIAL (field
) = 1;
4210 DECL_FIELD_CONTEXT (field
) = t
;
4211 DECL_FCONTEXT (field
) = t
;
4213 TYPE_VFIELD (t
) = field
;
4215 /* This class is non-empty. */
4216 CLASSTYPE_EMPTY_P (t
) = 0;
4218 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)))
4219 /* If there were any baseclasses, they can't possibly be at
4220 offset zero any more, because that's where the vtable
4221 pointer is. So, converting to a base class is going to
4223 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t
) = 1;
4231 /* Fixup the inline function given by INFO now that the class is
4235 fixup_pending_inline (tree fn
)
4237 if (DECL_PENDING_INLINE_INFO (fn
))
4239 tree args
= DECL_ARGUMENTS (fn
);
4242 DECL_CONTEXT (args
) = fn
;
4243 args
= TREE_CHAIN (args
);
4248 /* Fixup the inline methods and friends in TYPE now that TYPE is
4252 fixup_inline_methods (tree type
)
4254 tree method
= TYPE_METHODS (type
);
4256 if (method
&& TREE_CODE (method
) == TREE_VEC
)
4258 if (TREE_VEC_ELT (method
, 1))
4259 method
= TREE_VEC_ELT (method
, 1);
4260 else if (TREE_VEC_ELT (method
, 0))
4261 method
= TREE_VEC_ELT (method
, 0);
4263 method
= TREE_VEC_ELT (method
, 2);
4266 /* Do inline member functions. */
4267 for (; method
; method
= TREE_CHAIN (method
))
4268 fixup_pending_inline (method
);
4271 for (method
= CLASSTYPE_INLINE_FRIENDS (type
);
4273 method
= TREE_CHAIN (method
))
4274 fixup_pending_inline (TREE_VALUE (method
));
4275 CLASSTYPE_INLINE_FRIENDS (type
) = NULL_TREE
;
4278 /* Add OFFSET to all base types of BINFO which is a base in the
4279 hierarchy dominated by T.
4281 OFFSET, which is a type offset, is number of bytes. */
4284 propagate_binfo_offsets (tree binfo
, tree offset
)
4290 /* Update BINFO's offset. */
4291 BINFO_OFFSET (binfo
)
4292 = convert (sizetype
,
4293 size_binop (PLUS_EXPR
,
4294 convert (ssizetype
, BINFO_OFFSET (binfo
)),
4297 /* Find the primary base class. */
4298 primary_binfo
= get_primary_binfo (binfo
);
4300 if (primary_binfo
&& BINFO_INHERITANCE_CHAIN (primary_binfo
) == binfo
)
4301 propagate_binfo_offsets (primary_binfo
, offset
);
4303 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4305 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
4307 /* Don't do the primary base twice. */
4308 if (base_binfo
== primary_binfo
)
4311 if (BINFO_VIRTUAL_P (base_binfo
))
4314 propagate_binfo_offsets (base_binfo
, offset
);
4318 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
4319 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4320 empty subobjects of T. */
4323 layout_virtual_bases (record_layout_info rli
, splay_tree offsets
)
4327 bool first_vbase
= true;
4330 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) == 0)
4333 if (!abi_version_at_least(2))
4335 /* In G++ 3.2, we incorrectly rounded the size before laying out
4336 the virtual bases. */
4337 finish_record_layout (rli
, /*free_p=*/false);
4338 #ifdef STRUCTURE_SIZE_BOUNDARY
4339 /* Packed structures don't need to have minimum size. */
4340 if (! TYPE_PACKED (t
))
4341 TYPE_ALIGN (t
) = MAX (TYPE_ALIGN (t
), (unsigned) STRUCTURE_SIZE_BOUNDARY
);
4343 rli
->offset
= TYPE_SIZE_UNIT (t
);
4344 rli
->bitpos
= bitsize_zero_node
;
4345 rli
->record_align
= TYPE_ALIGN (t
);
4348 /* Find the last field. The artificial fields created for virtual
4349 bases will go after the last extant field to date. */
4350 next_field
= &TYPE_FIELDS (t
);
4352 next_field
= &TREE_CHAIN (*next_field
);
4354 /* Go through the virtual bases, allocating space for each virtual
4355 base that is not already a primary base class. These are
4356 allocated in inheritance graph order. */
4357 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
4359 if (!BINFO_VIRTUAL_P (vbase
))
4362 if (!BINFO_PRIMARY_P (vbase
))
4364 tree basetype
= TREE_TYPE (vbase
);
4366 /* This virtual base is not a primary base of any class in the
4367 hierarchy, so we have to add space for it. */
4368 next_field
= build_base_field (rli
, vbase
,
4369 offsets
, next_field
);
4371 /* If the first virtual base might have been placed at a
4372 lower address, had we started from CLASSTYPE_SIZE, rather
4373 than TYPE_SIZE, issue a warning. There can be both false
4374 positives and false negatives from this warning in rare
4375 cases; to deal with all the possibilities would probably
4376 require performing both layout algorithms and comparing
4377 the results which is not particularly tractable. */
4381 (size_binop (CEIL_DIV_EXPR
,
4382 round_up (CLASSTYPE_SIZE (t
),
4383 CLASSTYPE_ALIGN (basetype
)),
4385 BINFO_OFFSET (vbase
))))
4386 warning ("offset of virtual base `%T' is not ABI-compliant and may change in a future version of GCC",
4389 first_vbase
= false;
4394 /* Returns the offset of the byte just past the end of the base class
4398 end_of_base (tree binfo
)
4402 if (is_empty_class (BINFO_TYPE (binfo
)))
4403 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4404 allocate some space for it. It cannot have virtual bases, so
4405 TYPE_SIZE_UNIT is fine. */
4406 size
= TYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
4408 size
= CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
4410 return size_binop (PLUS_EXPR
, BINFO_OFFSET (binfo
), size
);
4413 /* Returns the offset of the byte just past the end of the base class
4414 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4415 only non-virtual bases are included. */
4418 end_of_class (tree t
, int include_virtuals_p
)
4420 tree result
= size_zero_node
;
4427 for (binfo
= TYPE_BINFO (t
), i
= 0;
4428 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
4430 if (!include_virtuals_p
4431 && BINFO_VIRTUAL_P (base_binfo
)
4432 && (!BINFO_PRIMARY_P (base_binfo
)
4433 || BINFO_INHERITANCE_CHAIN (base_binfo
) != TYPE_BINFO (t
)))
4436 offset
= end_of_base (base_binfo
);
4437 if (INT_CST_LT_UNSIGNED (result
, offset
))
4441 /* G++ 3.2 did not check indirect virtual bases. */
4442 if (abi_version_at_least (2) && include_virtuals_p
)
4443 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
4444 VEC_iterate (tree
, vbases
, i
, base_binfo
); i
++)
4446 offset
= end_of_base (base_binfo
);
4447 if (INT_CST_LT_UNSIGNED (result
, offset
))
4454 /* Warn about bases of T that are inaccessible because they are
4455 ambiguous. For example:
4458 struct T : public S {};
4459 struct U : public S, public T {};
4461 Here, `(S*) new U' is not allowed because there are two `S'
4465 warn_about_ambiguous_bases (tree t
)
4473 /* Check direct bases. */
4474 for (binfo
= TYPE_BINFO (t
), i
= 0;
4475 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
4477 basetype
= BINFO_TYPE (base_binfo
);
4479 if (!lookup_base (t
, basetype
, ba_ignore
| ba_quiet
, NULL
))
4480 warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
4484 /* Check for ambiguous virtual bases. */
4486 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
4487 VEC_iterate (tree
, vbases
, i
, binfo
); i
++)
4489 basetype
= BINFO_TYPE (binfo
);
4491 if (!lookup_base (t
, basetype
, ba_ignore
| ba_quiet
, NULL
))
4492 warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
4497 /* Compare two INTEGER_CSTs K1 and K2. */
4500 splay_tree_compare_integer_csts (splay_tree_key k1
, splay_tree_key k2
)
4502 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4505 /* Increase the size indicated in RLI to account for empty classes
4506 that are "off the end" of the class. */
4509 include_empty_classes (record_layout_info rli
)
4514 /* It might be the case that we grew the class to allocate a
4515 zero-sized base class. That won't be reflected in RLI, yet,
4516 because we are willing to overlay multiple bases at the same
4517 offset. However, now we need to make sure that RLI is big enough
4518 to reflect the entire class. */
4519 eoc
= end_of_class (rli
->t
,
4520 CLASSTYPE_AS_BASE (rli
->t
) != NULL_TREE
);
4521 rli_size
= rli_size_unit_so_far (rli
);
4522 if (TREE_CODE (rli_size
) == INTEGER_CST
4523 && INT_CST_LT_UNSIGNED (rli_size
, eoc
))
4525 if (!abi_version_at_least (2))
4526 /* In version 1 of the ABI, the size of a class that ends with
4527 a bitfield was not rounded up to a whole multiple of a
4528 byte. Because rli_size_unit_so_far returns only the number
4529 of fully allocated bytes, any extra bits were not included
4531 rli
->bitpos
= round_down (rli
->bitpos
, BITS_PER_UNIT
);
4533 /* The size should have been rounded to a whole byte. */
4534 gcc_assert (tree_int_cst_equal
4535 (rli
->bitpos
, round_down (rli
->bitpos
, BITS_PER_UNIT
)));
4537 = size_binop (PLUS_EXPR
,
4539 size_binop (MULT_EXPR
,
4540 convert (bitsizetype
,
4541 size_binop (MINUS_EXPR
,
4543 bitsize_int (BITS_PER_UNIT
)));
4544 normalize_rli (rli
);
4548 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
4549 BINFO_OFFSETs for all of the base-classes. Position the vtable
4550 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
4553 layout_class_type (tree t
, tree
*virtuals_p
)
4555 tree non_static_data_members
;
4558 record_layout_info rli
;
4559 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4560 types that appear at that offset. */
4561 splay_tree empty_base_offsets
;
4562 /* True if the last field layed out was a bit-field. */
4563 bool last_field_was_bitfield
= false;
4564 /* The location at which the next field should be inserted. */
4566 /* T, as a base class. */
4569 /* Keep track of the first non-static data member. */
4570 non_static_data_members
= TYPE_FIELDS (t
);
4572 /* Start laying out the record. */
4573 rli
= start_record_layout (t
);
4575 /* Mark all the primary bases in the hierarchy. */
4576 determine_primary_bases (t
);
4578 /* Create a pointer to our virtual function table. */
4579 vptr
= create_vtable_ptr (t
, virtuals_p
);
4581 /* The vptr is always the first thing in the class. */
4584 TREE_CHAIN (vptr
) = TYPE_FIELDS (t
);
4585 TYPE_FIELDS (t
) = vptr
;
4586 next_field
= &TREE_CHAIN (vptr
);
4587 place_field (rli
, vptr
);
4590 next_field
= &TYPE_FIELDS (t
);
4592 /* Build FIELD_DECLs for all of the non-virtual base-types. */
4593 empty_base_offsets
= splay_tree_new (splay_tree_compare_integer_csts
,
4595 build_base_fields (rli
, empty_base_offsets
, next_field
);
4597 /* Layout the non-static data members. */
4598 for (field
= non_static_data_members
; field
; field
= TREE_CHAIN (field
))
4603 /* We still pass things that aren't non-static data members to
4604 the back-end, in case it wants to do something with them. */
4605 if (TREE_CODE (field
) != FIELD_DECL
)
4607 place_field (rli
, field
);
4608 /* If the static data member has incomplete type, keep track
4609 of it so that it can be completed later. (The handling
4610 of pending statics in finish_record_layout is
4611 insufficient; consider:
4614 struct S2 { static S1 s1; };
4616 At this point, finish_record_layout will be called, but
4617 S1 is still incomplete.) */
4618 if (TREE_CODE (field
) == VAR_DECL
)
4619 maybe_register_incomplete_var (field
);
4623 type
= TREE_TYPE (field
);
4625 padding
= NULL_TREE
;
4627 /* If this field is a bit-field whose width is greater than its
4628 type, then there are some special rules for allocating
4630 if (DECL_C_BIT_FIELD (field
)
4631 && INT_CST_LT (TYPE_SIZE (type
), DECL_SIZE (field
)))
4633 integer_type_kind itk
;
4635 bool was_unnamed_p
= false;
4636 /* We must allocate the bits as if suitably aligned for the
4637 longest integer type that fits in this many bits. type
4638 of the field. Then, we are supposed to use the left over
4639 bits as additional padding. */
4640 for (itk
= itk_char
; itk
!= itk_none
; ++itk
)
4641 if (INT_CST_LT (DECL_SIZE (field
),
4642 TYPE_SIZE (integer_types
[itk
])))
4645 /* ITK now indicates a type that is too large for the
4646 field. We have to back up by one to find the largest
4648 integer_type
= integer_types
[itk
- 1];
4650 /* Figure out how much additional padding is required. GCC
4651 3.2 always created a padding field, even if it had zero
4653 if (!abi_version_at_least (2)
4654 || INT_CST_LT (TYPE_SIZE (integer_type
), DECL_SIZE (field
)))
4656 if (abi_version_at_least (2) && TREE_CODE (t
) == UNION_TYPE
)
4657 /* In a union, the padding field must have the full width
4658 of the bit-field; all fields start at offset zero. */
4659 padding
= DECL_SIZE (field
);
4662 if (warn_abi
&& TREE_CODE (t
) == UNION_TYPE
)
4663 warning ("size assigned to `%T' may not be "
4664 "ABI-compliant and may change in a future "
4667 padding
= size_binop (MINUS_EXPR
, DECL_SIZE (field
),
4668 TYPE_SIZE (integer_type
));
4671 #ifdef PCC_BITFIELD_TYPE_MATTERS
4672 /* An unnamed bitfield does not normally affect the
4673 alignment of the containing class on a target where
4674 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
4675 make any exceptions for unnamed bitfields when the
4676 bitfields are longer than their types. Therefore, we
4677 temporarily give the field a name. */
4678 if (PCC_BITFIELD_TYPE_MATTERS
&& !DECL_NAME (field
))
4680 was_unnamed_p
= true;
4681 DECL_NAME (field
) = make_anon_name ();
4684 DECL_SIZE (field
) = TYPE_SIZE (integer_type
);
4685 DECL_ALIGN (field
) = TYPE_ALIGN (integer_type
);
4686 DECL_USER_ALIGN (field
) = TYPE_USER_ALIGN (integer_type
);
4687 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
4688 empty_base_offsets
);
4690 DECL_NAME (field
) = NULL_TREE
;
4691 /* Now that layout has been performed, set the size of the
4692 field to the size of its declared type; the rest of the
4693 field is effectively invisible. */
4694 DECL_SIZE (field
) = TYPE_SIZE (type
);
4695 /* We must also reset the DECL_MODE of the field. */
4696 if (abi_version_at_least (2))
4697 DECL_MODE (field
) = TYPE_MODE (type
);
4699 && DECL_MODE (field
) != TYPE_MODE (type
))
4700 /* Versions of G++ before G++ 3.4 did not reset the
4702 warning ("the offset of `%D' may not be ABI-compliant and may "
4703 "change in a future version of GCC", field
);
4706 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
4707 empty_base_offsets
);
4709 /* Remember the location of any empty classes in FIELD. */
4710 if (abi_version_at_least (2))
4711 record_subobject_offsets (TREE_TYPE (field
),
4712 byte_position(field
),
4716 /* If a bit-field does not immediately follow another bit-field,
4717 and yet it starts in the middle of a byte, we have failed to
4718 comply with the ABI. */
4720 && DECL_C_BIT_FIELD (field
)
4721 && !last_field_was_bitfield
4722 && !integer_zerop (size_binop (TRUNC_MOD_EXPR
,
4723 DECL_FIELD_BIT_OFFSET (field
),
4724 bitsize_unit_node
)))
4725 cp_warning_at ("offset of `%D' is not ABI-compliant and may change in a future version of GCC",
4728 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4729 offset of the field. */
4731 && !tree_int_cst_equal (DECL_FIELD_OFFSET (field
),
4732 byte_position (field
))
4733 && contains_empty_class_p (TREE_TYPE (field
)))
4734 cp_warning_at ("`%D' contains empty classes which may cause base "
4735 "classes to be placed at different locations in a "
4736 "future version of GCC",
4739 /* If we needed additional padding after this field, add it
4745 padding_field
= build_decl (FIELD_DECL
,
4748 DECL_BIT_FIELD (padding_field
) = 1;
4749 DECL_SIZE (padding_field
) = padding
;
4750 DECL_CONTEXT (padding_field
) = t
;
4751 DECL_ARTIFICIAL (padding_field
) = 1;
4752 layout_nonempty_base_or_field (rli
, padding_field
,
4754 empty_base_offsets
);
4757 last_field_was_bitfield
= DECL_C_BIT_FIELD (field
);
4760 if (abi_version_at_least (2) && !integer_zerop (rli
->bitpos
))
4762 /* Make sure that we are on a byte boundary so that the size of
4763 the class without virtual bases will always be a round number
4765 rli
->bitpos
= round_up (rli
->bitpos
, BITS_PER_UNIT
);
4766 normalize_rli (rli
);
4769 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4771 if (!abi_version_at_least (2))
4772 include_empty_classes(rli
);
4774 /* Delete all zero-width bit-fields from the list of fields. Now
4775 that the type is laid out they are no longer important. */
4776 remove_zero_width_bit_fields (t
);
4778 /* Create the version of T used for virtual bases. We do not use
4779 make_aggr_type for this version; this is an artificial type. For
4780 a POD type, we just reuse T. */
4781 if (CLASSTYPE_NON_POD_P (t
) || CLASSTYPE_EMPTY_P (t
))
4783 base_t
= make_node (TREE_CODE (t
));
4785 /* Set the size and alignment for the new type. In G++ 3.2, all
4786 empty classes were considered to have size zero when used as
4788 if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t
))
4790 TYPE_SIZE (base_t
) = bitsize_zero_node
;
4791 TYPE_SIZE_UNIT (base_t
) = size_zero_node
;
4792 if (warn_abi
&& !integer_zerop (rli_size_unit_so_far (rli
)))
4793 warning ("layout of classes derived from empty class `%T' "
4794 "may change in a future version of GCC",
4801 /* If the ABI version is not at least two, and the last
4802 field was a bit-field, RLI may not be on a byte
4803 boundary. In particular, rli_size_unit_so_far might
4804 indicate the last complete byte, while rli_size_so_far
4805 indicates the total number of bits used. Therefore,
4806 rli_size_so_far, rather than rli_size_unit_so_far, is
4807 used to compute TYPE_SIZE_UNIT. */
4808 eoc
= end_of_class (t
, /*include_virtuals_p=*/0);
4809 TYPE_SIZE_UNIT (base_t
)
4810 = size_binop (MAX_EXPR
,
4812 size_binop (CEIL_DIV_EXPR
,
4813 rli_size_so_far (rli
),
4814 bitsize_int (BITS_PER_UNIT
))),
4817 = size_binop (MAX_EXPR
,
4818 rli_size_so_far (rli
),
4819 size_binop (MULT_EXPR
,
4820 convert (bitsizetype
, eoc
),
4821 bitsize_int (BITS_PER_UNIT
)));
4823 TYPE_ALIGN (base_t
) = rli
->record_align
;
4824 TYPE_USER_ALIGN (base_t
) = TYPE_USER_ALIGN (t
);
4826 /* Copy the fields from T. */
4827 next_field
= &TYPE_FIELDS (base_t
);
4828 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
4829 if (TREE_CODE (field
) == FIELD_DECL
)
4831 *next_field
= build_decl (FIELD_DECL
,
4834 DECL_CONTEXT (*next_field
) = base_t
;
4835 DECL_FIELD_OFFSET (*next_field
) = DECL_FIELD_OFFSET (field
);
4836 DECL_FIELD_BIT_OFFSET (*next_field
)
4837 = DECL_FIELD_BIT_OFFSET (field
);
4838 DECL_SIZE (*next_field
) = DECL_SIZE (field
);
4839 DECL_MODE (*next_field
) = DECL_MODE (field
);
4840 next_field
= &TREE_CHAIN (*next_field
);
4843 /* Record the base version of the type. */
4844 CLASSTYPE_AS_BASE (t
) = base_t
;
4845 TYPE_CONTEXT (base_t
) = t
;
4848 CLASSTYPE_AS_BASE (t
) = t
;
4850 /* Every empty class contains an empty class. */
4851 if (CLASSTYPE_EMPTY_P (t
))
4852 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
4854 /* Set the TYPE_DECL for this type to contain the right
4855 value for DECL_OFFSET, so that we can use it as part
4856 of a COMPONENT_REF for multiple inheritance. */
4857 layout_decl (TYPE_MAIN_DECL (t
), 0);
4859 /* Now fix up any virtual base class types that we left lying
4860 around. We must get these done before we try to lay out the
4861 virtual function table. As a side-effect, this will remove the
4862 base subobject fields. */
4863 layout_virtual_bases (rli
, empty_base_offsets
);
4865 /* Make sure that empty classes are reflected in RLI at this
4867 include_empty_classes(rli
);
4869 /* Make sure not to create any structures with zero size. */
4870 if (integer_zerop (rli_size_unit_so_far (rli
)) && CLASSTYPE_EMPTY_P (t
))
4872 build_decl (FIELD_DECL
, NULL_TREE
, char_type_node
));
4874 /* Let the back-end lay out the type. */
4875 finish_record_layout (rli
, /*free_p=*/true);
4877 /* Warn about bases that can't be talked about due to ambiguity. */
4878 warn_about_ambiguous_bases (t
);
4880 /* Now that we're done with layout, give the base fields the real types. */
4881 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
4882 if (DECL_ARTIFICIAL (field
) && IS_FAKE_BASE_TYPE (TREE_TYPE (field
)))
4883 TREE_TYPE (field
) = TYPE_CONTEXT (TREE_TYPE (field
));
4886 splay_tree_delete (empty_base_offsets
);
4889 /* Determine the "key method" for the class type indicated by TYPE,
4890 and set CLASSTYPE_KEY_METHOD accordingly. */
4893 determine_key_method (tree type
)
4897 if (TYPE_FOR_JAVA (type
)
4898 || processing_template_decl
4899 || CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
4900 || CLASSTYPE_INTERFACE_KNOWN (type
))
4903 /* The key method is the first non-pure virtual function that is not
4904 inline at the point of class definition. On some targets the
4905 key function may not be inline; those targets should not call
4906 this function until the end of the translation unit. */
4907 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
4908 method
= TREE_CHAIN (method
))
4909 if (DECL_VINDEX (method
) != NULL_TREE
4910 && ! DECL_DECLARED_INLINE_P (method
)
4911 && ! DECL_PURE_VIRTUAL_P (method
))
4913 CLASSTYPE_KEY_METHOD (type
) = method
;
4920 /* Perform processing required when the definition of T (a class type)
4924 finish_struct_1 (tree t
)
4927 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
4928 tree virtuals
= NULL_TREE
;
4932 if (COMPLETE_TYPE_P (t
))
4934 gcc_assert (IS_AGGR_TYPE (t
));
4935 error ("redefinition of `%#T'", t
);
4940 /* If this type was previously laid out as a forward reference,
4941 make sure we lay it out again. */
4942 TYPE_SIZE (t
) = NULL_TREE
;
4943 CLASSTYPE_PRIMARY_BINFO (t
) = NULL_TREE
;
4945 fixup_inline_methods (t
);
4947 /* Make assumptions about the class; we'll reset the flags if
4949 CLASSTYPE_EMPTY_P (t
) = 1;
4950 CLASSTYPE_NEARLY_EMPTY_P (t
) = 1;
4951 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 0;
4953 /* Do end-of-class semantic processing: checking the validity of the
4954 bases and members and add implicitly generated methods. */
4955 check_bases_and_members (t
);
4957 /* Find the key method. */
4958 if (TYPE_CONTAINS_VPTR_P (t
))
4960 /* The Itanium C++ ABI permits the key method to be chosen when
4961 the class is defined -- even though the key method so
4962 selected may later turn out to be an inline function. On
4963 some systems (such as ARM Symbian OS) the key method cannot
4964 be determined until the end of the translation unit. On such
4965 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
4966 will cause the class to be added to KEYED_CLASSES. Then, in
4967 finish_file we will determine the key method. */
4968 if (targetm
.cxx
.key_method_may_be_inline ())
4969 determine_key_method (t
);
4971 /* If a polymorphic class has no key method, we may emit the vtable
4972 in every translation unit where the class definition appears. */
4973 if (CLASSTYPE_KEY_METHOD (t
) == NULL_TREE
)
4974 keyed_classes
= tree_cons (NULL_TREE
, t
, keyed_classes
);
4977 /* Layout the class itself. */
4978 layout_class_type (t
, &virtuals
);
4979 if (CLASSTYPE_AS_BASE (t
) != t
)
4980 /* We use the base type for trivial assignments, and hence it
4982 compute_record_mode (CLASSTYPE_AS_BASE (t
));
4984 /* Make sure that we get our own copy of the vfield FIELD_DECL. */
4985 vfield
= TYPE_VFIELD (t
);
4986 if (vfield
&& CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
4988 tree primary
= CLASSTYPE_PRIMARY_BINFO (t
);
4990 gcc_assert (same_type_p (DECL_FIELD_CONTEXT (vfield
),
4991 BINFO_TYPE (primary
)));
4992 /* The vtable better be at the start. */
4993 gcc_assert (integer_zerop (DECL_FIELD_OFFSET (vfield
)));
4994 gcc_assert (integer_zerop (BINFO_OFFSET (primary
)));
4996 vfield
= copy_decl (vfield
);
4997 DECL_FIELD_CONTEXT (vfield
) = t
;
4998 TYPE_VFIELD (t
) = vfield
;
5001 gcc_assert (!vfield
|| DECL_FIELD_CONTEXT (vfield
) == t
);
5003 virtuals
= modify_all_vtables (t
, nreverse (virtuals
));
5005 /* If necessary, create the primary vtable for this class. */
5006 if (virtuals
|| TYPE_CONTAINS_VPTR_P (t
))
5008 /* We must enter these virtuals into the table. */
5009 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
5010 build_primary_vtable (NULL_TREE
, t
);
5011 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t
)))
5012 /* Here we know enough to change the type of our virtual
5013 function table, but we will wait until later this function. */
5014 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t
), t
);
5017 if (TYPE_CONTAINS_VPTR_P (t
))
5022 if (BINFO_VTABLE (TYPE_BINFO (t
)))
5023 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t
))));
5024 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
5025 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t
)) == NULL_TREE
);
5027 /* Add entries for virtual functions introduced by this class. */
5028 BINFO_VIRTUALS (TYPE_BINFO (t
))
5029 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t
)), virtuals
);
5031 /* Set DECL_VINDEX for all functions declared in this class. */
5032 for (vindex
= 0, fn
= BINFO_VIRTUALS (TYPE_BINFO (t
));
5034 fn
= TREE_CHAIN (fn
),
5035 vindex
+= (TARGET_VTABLE_USES_DESCRIPTORS
5036 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1))
5038 tree fndecl
= BV_FN (fn
);
5040 if (DECL_THUNK_P (fndecl
))
5041 /* A thunk. We should never be calling this entry directly
5042 from this vtable -- we'd use the entry for the non
5043 thunk base function. */
5044 DECL_VINDEX (fndecl
) = NULL_TREE
;
5045 else if (TREE_CODE (DECL_VINDEX (fndecl
)) != INTEGER_CST
)
5046 DECL_VINDEX (fndecl
) = build_int_cst (NULL_TREE
, vindex
);
5050 finish_struct_bits (t
);
5052 /* Complete the rtl for any static member objects of the type we're
5054 for (x
= TYPE_FIELDS (t
); x
; x
= TREE_CHAIN (x
))
5055 if (TREE_CODE (x
) == VAR_DECL
&& TREE_STATIC (x
)
5056 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x
)), t
))
5057 DECL_MODE (x
) = TYPE_MODE (t
);
5059 /* Done with FIELDS...now decide whether to sort these for
5060 faster lookups later.
5062 We use a small number because most searches fail (succeeding
5063 ultimately as the search bores through the inheritance
5064 hierarchy), and we want this failure to occur quickly. */
5066 n_fields
= count_fields (TYPE_FIELDS (t
));
5069 struct sorted_fields_type
*field_vec
= GGC_NEWVAR
5070 (struct sorted_fields_type
,
5071 sizeof (struct sorted_fields_type
) + n_fields
* sizeof (tree
));
5072 field_vec
->len
= n_fields
;
5073 add_fields_to_record_type (TYPE_FIELDS (t
), field_vec
, 0);
5074 qsort (field_vec
->elts
, n_fields
, sizeof (tree
),
5076 if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t
)))
5077 retrofit_lang_decl (TYPE_MAIN_DECL (t
));
5078 DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t
)) = field_vec
;
5081 /* Make the rtl for any new vtables we have created, and unmark
5082 the base types we marked. */
5085 /* Build the VTT for T. */
5088 if (warn_nonvdtor
&& TYPE_POLYMORPHIC_P (t
) && TYPE_HAS_DESTRUCTOR (t
)
5089 && !DECL_VINDEX (CLASSTYPE_DESTRUCTORS (t
)))
5092 tree dtor
= CLASSTYPE_DESTRUCTORS (t
);
5094 /* Warn only if the dtor is non-private or the class has friends */
5095 if (!TREE_PRIVATE (dtor
) ||
5096 (CLASSTYPE_FRIEND_CLASSES (t
) ||
5097 DECL_FRIENDLIST (TYPE_MAIN_DECL (t
))))
5098 warning ("%#T' has virtual functions but non-virtual destructor", t
);
5103 if (warn_overloaded_virtual
)
5106 maybe_suppress_debug_info (t
);
5108 dump_class_hierarchy (t
);
5110 /* Finish debugging output for this type. */
5111 rest_of_type_compilation (t
, ! LOCAL_CLASS_P (t
));
5114 /* When T was built up, the member declarations were added in reverse
5115 order. Rearrange them to declaration order. */
5118 unreverse_member_declarations (tree t
)
5124 /* The following lists are all in reverse order. Put them in
5125 declaration order now. */
5126 TYPE_METHODS (t
) = nreverse (TYPE_METHODS (t
));
5127 CLASSTYPE_DECL_LIST (t
) = nreverse (CLASSTYPE_DECL_LIST (t
));
5129 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5130 reverse order, so we can't just use nreverse. */
5132 for (x
= TYPE_FIELDS (t
);
5133 x
&& TREE_CODE (x
) != TYPE_DECL
;
5136 next
= TREE_CHAIN (x
);
5137 TREE_CHAIN (x
) = prev
;
5142 TREE_CHAIN (TYPE_FIELDS (t
)) = x
;
5144 TYPE_FIELDS (t
) = prev
;
5149 finish_struct (tree t
, tree attributes
)
5151 location_t saved_loc
= input_location
;
5153 /* Now that we've got all the field declarations, reverse everything
5155 unreverse_member_declarations (t
);
5157 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
5159 /* Nadger the current location so that diagnostics point to the start of
5160 the struct, not the end. */
5161 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (t
));
5163 if (processing_template_decl
)
5167 finish_struct_methods (t
);
5168 TYPE_SIZE (t
) = bitsize_zero_node
;
5170 /* We need to emit an error message if this type was used as a parameter
5171 and it is an abstract type, even if it is a template. We construct
5172 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5173 account and we call complete_vars with this type, which will check
5174 the PARM_DECLS. Note that while the type is being defined,
5175 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5176 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
5177 CLASSTYPE_PURE_VIRTUALS (t
) = NULL_TREE
;
5178 for (x
= TYPE_METHODS (t
); x
; x
= TREE_CHAIN (x
))
5179 if (DECL_PURE_VIRTUAL_P (x
))
5180 CLASSTYPE_PURE_VIRTUALS (t
)
5181 = tree_cons (NULL_TREE
, x
, CLASSTYPE_PURE_VIRTUALS (t
));
5185 finish_struct_1 (t
);
5187 input_location
= saved_loc
;
5189 TYPE_BEING_DEFINED (t
) = 0;
5191 if (current_class_type
)
5194 error ("trying to finish struct, but kicked out due to previous parse errors");
5196 if (processing_template_decl
&& at_function_scope_p ())
5197 add_stmt (build_min (TAG_DEFN
, t
));
5202 /* Return the dynamic type of INSTANCE, if known.
5203 Used to determine whether the virtual function table is needed
5206 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5207 of our knowledge of its type. *NONNULL should be initialized
5208 before this function is called. */
5211 fixed_type_or_null (tree instance
, int* nonnull
, int* cdtorp
)
5213 switch (TREE_CODE (instance
))
5216 if (POINTER_TYPE_P (TREE_TYPE (instance
)))
5219 return fixed_type_or_null (TREE_OPERAND (instance
, 0),
5223 /* This is a call to a constructor, hence it's never zero. */
5224 if (TREE_HAS_CONSTRUCTOR (instance
))
5228 return TREE_TYPE (instance
);
5233 /* This is a call to a constructor, hence it's never zero. */
5234 if (TREE_HAS_CONSTRUCTOR (instance
))
5238 return TREE_TYPE (instance
);
5240 return fixed_type_or_null (TREE_OPERAND (instance
, 0), nonnull
, cdtorp
);
5244 if (TREE_CODE (TREE_OPERAND (instance
, 0)) == ADDR_EXPR
)
5245 return fixed_type_or_null (TREE_OPERAND (instance
, 0), nonnull
, cdtorp
);
5246 if (TREE_CODE (TREE_OPERAND (instance
, 1)) == INTEGER_CST
)
5247 /* Propagate nonnull. */
5248 return fixed_type_or_null (TREE_OPERAND (instance
, 0), nonnull
, cdtorp
);
5253 return fixed_type_or_null (TREE_OPERAND (instance
, 0), nonnull
, cdtorp
);
5256 instance
= TREE_OPERAND (instance
, 0);
5259 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5260 with a real object -- given &p->f, p can still be null. */
5261 tree t
= get_base_address (instance
);
5262 /* ??? Probably should check DECL_WEAK here. */
5263 if (t
&& DECL_P (t
))
5266 return fixed_type_or_null (instance
, nonnull
, cdtorp
);
5269 /* If this component is really a base class reference, then the field
5270 itself isn't definitive. */
5271 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance
, 1)))
5272 return fixed_type_or_null (TREE_OPERAND (instance
, 0), nonnull
, cdtorp
);
5273 return fixed_type_or_null (TREE_OPERAND (instance
, 1), nonnull
, cdtorp
);
5277 if (TREE_CODE (TREE_TYPE (instance
)) == ARRAY_TYPE
5278 && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance
))))
5282 return TREE_TYPE (TREE_TYPE (instance
));
5284 /* fall through... */
5288 if (IS_AGGR_TYPE (TREE_TYPE (instance
)))
5292 return TREE_TYPE (instance
);
5294 else if (instance
== current_class_ptr
)
5299 /* if we're in a ctor or dtor, we know our type. */
5300 if (DECL_LANG_SPECIFIC (current_function_decl
)
5301 && (DECL_CONSTRUCTOR_P (current_function_decl
)
5302 || DECL_DESTRUCTOR_P (current_function_decl
)))
5306 return TREE_TYPE (TREE_TYPE (instance
));
5309 else if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
5311 /* Reference variables should be references to objects. */
5315 /* DECL_VAR_MARKED_P is used to prevent recursion; a
5316 variable's initializer may refer to the variable
5318 if (TREE_CODE (instance
) == VAR_DECL
5319 && DECL_INITIAL (instance
)
5320 && !DECL_VAR_MARKED_P (instance
))
5323 DECL_VAR_MARKED_P (instance
) = 1;
5324 type
= fixed_type_or_null (DECL_INITIAL (instance
),
5326 DECL_VAR_MARKED_P (instance
) = 0;
5337 /* Return nonzero if the dynamic type of INSTANCE is known, and
5338 equivalent to the static type. We also handle the case where
5339 INSTANCE is really a pointer. Return negative if this is a
5340 ctor/dtor. There the dynamic type is known, but this might not be
5341 the most derived base of the original object, and hence virtual
5342 bases may not be layed out according to this type.
5344 Used to determine whether the virtual function table is needed
5347 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5348 of our knowledge of its type. *NONNULL should be initialized
5349 before this function is called. */
5352 resolves_to_fixed_type_p (tree instance
, int* nonnull
)
5354 tree t
= TREE_TYPE (instance
);
5357 tree fixed
= fixed_type_or_null (instance
, nonnull
, &cdtorp
);
5358 if (fixed
== NULL_TREE
)
5360 if (POINTER_TYPE_P (t
))
5362 if (!same_type_ignoring_top_level_qualifiers_p (t
, fixed
))
5364 return cdtorp
? -1 : 1;
5369 init_class_processing (void)
5371 current_class_depth
= 0;
5372 current_class_stack_size
= 10;
5374 = xmalloc (current_class_stack_size
* sizeof (struct class_stack_node
));
5375 VARRAY_TREE_INIT (local_classes
, 8, "local_classes");
5377 ridpointers
[(int) RID_PUBLIC
] = access_public_node
;
5378 ridpointers
[(int) RID_PRIVATE
] = access_private_node
;
5379 ridpointers
[(int) RID_PROTECTED
] = access_protected_node
;
5382 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
5385 restore_class_cache (void)
5389 /* We are re-entering the same class we just left, so we don't
5390 have to search the whole inheritance matrix to find all the
5391 decls to bind again. Instead, we install the cached
5392 class_shadowed list and walk through it binding names. */
5393 push_binding_level (previous_class_level
);
5394 class_binding_level
= previous_class_level
;
5395 /* Restore IDENTIFIER_TYPE_VALUE. */
5396 for (type
= class_binding_level
->type_shadowed
;
5398 type
= TREE_CHAIN (type
))
5399 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type
), TREE_TYPE (type
));
5402 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5403 appropriate for TYPE.
5405 So that we may avoid calls to lookup_name, we cache the _TYPE
5406 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5408 For multiple inheritance, we perform a two-pass depth-first search
5409 of the type lattice. */
5412 pushclass (tree type
)
5414 type
= TYPE_MAIN_VARIANT (type
);
5416 /* Make sure there is enough room for the new entry on the stack. */
5417 if (current_class_depth
+ 1 >= current_class_stack_size
)
5419 current_class_stack_size
*= 2;
5421 = xrealloc (current_class_stack
,
5422 current_class_stack_size
5423 * sizeof (struct class_stack_node
));
5426 /* Insert a new entry on the class stack. */
5427 current_class_stack
[current_class_depth
].name
= current_class_name
;
5428 current_class_stack
[current_class_depth
].type
= current_class_type
;
5429 current_class_stack
[current_class_depth
].access
= current_access_specifier
;
5430 current_class_stack
[current_class_depth
].names_used
= 0;
5431 current_class_depth
++;
5433 /* Now set up the new type. */
5434 current_class_name
= TYPE_NAME (type
);
5435 if (TREE_CODE (current_class_name
) == TYPE_DECL
)
5436 current_class_name
= DECL_NAME (current_class_name
);
5437 current_class_type
= type
;
5439 /* By default, things in classes are private, while things in
5440 structures or unions are public. */
5441 current_access_specifier
= (CLASSTYPE_DECLARED_CLASS (type
)
5442 ? access_private_node
5443 : access_public_node
);
5445 if (previous_class_level
5446 && type
!= previous_class_level
->this_entity
5447 && current_class_depth
== 1)
5449 /* Forcibly remove any old class remnants. */
5450 invalidate_class_lookup_cache ();
5453 if (!previous_class_level
5454 || type
!= previous_class_level
->this_entity
5455 || current_class_depth
> 1)
5458 restore_class_cache ();
5460 cxx_remember_type_decls (CLASSTYPE_NESTED_UTDS (type
));
5463 /* When we exit a toplevel class scope, we save its binding level so
5464 that we can restore it quickly. Here, we've entered some other
5465 class, so we must invalidate our cache. */
5468 invalidate_class_lookup_cache (void)
5470 previous_class_level
= NULL
;
5473 /* Get out of the current class scope. If we were in a class scope
5474 previously, that is the one popped to. */
5481 current_class_depth
--;
5482 current_class_name
= current_class_stack
[current_class_depth
].name
;
5483 current_class_type
= current_class_stack
[current_class_depth
].type
;
5484 current_access_specifier
= current_class_stack
[current_class_depth
].access
;
5485 if (current_class_stack
[current_class_depth
].names_used
)
5486 splay_tree_delete (current_class_stack
[current_class_depth
].names_used
);
5489 /* Returns 1 if current_class_type is either T or a nested type of T.
5490 We start looking from 1 because entry 0 is from global scope, and has
5494 currently_open_class (tree t
)
5497 if (current_class_type
&& same_type_p (t
, current_class_type
))
5499 for (i
= 1; i
< current_class_depth
; ++i
)
5500 if (current_class_stack
[i
].type
5501 && same_type_p (current_class_stack
[i
].type
, t
))
5506 /* If either current_class_type or one of its enclosing classes are derived
5507 from T, return the appropriate type. Used to determine how we found
5508 something via unqualified lookup. */
5511 currently_open_derived_class (tree t
)
5515 /* The bases of a dependent type are unknown. */
5516 if (dependent_type_p (t
))
5519 if (!current_class_type
)
5522 if (DERIVED_FROM_P (t
, current_class_type
))
5523 return current_class_type
;
5525 for (i
= current_class_depth
- 1; i
> 0; --i
)
5526 if (DERIVED_FROM_P (t
, current_class_stack
[i
].type
))
5527 return current_class_stack
[i
].type
;
5532 /* When entering a class scope, all enclosing class scopes' names with
5533 static meaning (static variables, static functions, types and
5534 enumerators) have to be visible. This recursive function calls
5535 pushclass for all enclosing class contexts until global or a local
5536 scope is reached. TYPE is the enclosed class. */
5539 push_nested_class (tree type
)
5543 /* A namespace might be passed in error cases, like A::B:C. */
5544 if (type
== NULL_TREE
5545 || type
== error_mark_node
5546 || TREE_CODE (type
) == NAMESPACE_DECL
5547 || ! IS_AGGR_TYPE (type
)
5548 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5549 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
5552 context
= DECL_CONTEXT (TYPE_MAIN_DECL (type
));
5554 if (context
&& CLASS_TYPE_P (context
))
5555 push_nested_class (context
);
5559 /* Undoes a push_nested_class call. */
5562 pop_nested_class (void)
5564 tree context
= DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type
));
5567 if (context
&& CLASS_TYPE_P (context
))
5568 pop_nested_class ();
5571 /* Returns the number of extern "LANG" blocks we are nested within. */
5574 current_lang_depth (void)
5576 return VARRAY_ACTIVE_SIZE (current_lang_base
);
5579 /* Set global variables CURRENT_LANG_NAME to appropriate value
5580 so that behavior of name-mangling machinery is correct. */
5583 push_lang_context (tree name
)
5585 VARRAY_PUSH_TREE (current_lang_base
, current_lang_name
);
5587 if (name
== lang_name_cplusplus
)
5589 current_lang_name
= name
;
5591 else if (name
== lang_name_java
)
5593 current_lang_name
= name
;
5594 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5595 (See record_builtin_java_type in decl.c.) However, that causes
5596 incorrect debug entries if these types are actually used.
5597 So we re-enable debug output after extern "Java". */
5598 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node
)) = 0;
5599 DECL_IGNORED_P (TYPE_NAME (java_short_type_node
)) = 0;
5600 DECL_IGNORED_P (TYPE_NAME (java_int_type_node
)) = 0;
5601 DECL_IGNORED_P (TYPE_NAME (java_long_type_node
)) = 0;
5602 DECL_IGNORED_P (TYPE_NAME (java_float_type_node
)) = 0;
5603 DECL_IGNORED_P (TYPE_NAME (java_double_type_node
)) = 0;
5604 DECL_IGNORED_P (TYPE_NAME (java_char_type_node
)) = 0;
5605 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node
)) = 0;
5607 else if (name
== lang_name_c
)
5609 current_lang_name
= name
;
5612 error ("language string `\"%E\"' not recognized", name
);
5615 /* Get out of the current language scope. */
5618 pop_lang_context (void)
5620 current_lang_name
= VARRAY_TOP_TREE (current_lang_base
);
5621 VARRAY_POP (current_lang_base
);
5624 /* Type instantiation routines. */
5626 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5627 matches the TARGET_TYPE. If there is no satisfactory match, return
5628 error_mark_node, and issue a error & warning messages under control
5629 of FLAGS. Permit pointers to member function if FLAGS permits. If
5630 TEMPLATE_ONLY, the name of the overloaded function was a
5631 template-id, and EXPLICIT_TARGS are the explicitly provided
5632 template arguments. */
5635 resolve_address_of_overloaded_function (tree target_type
,
5637 tsubst_flags_t flags
,
5639 tree explicit_targs
)
5641 /* Here's what the standard says:
5645 If the name is a function template, template argument deduction
5646 is done, and if the argument deduction succeeds, the deduced
5647 arguments are used to generate a single template function, which
5648 is added to the set of overloaded functions considered.
5650 Non-member functions and static member functions match targets of
5651 type "pointer-to-function" or "reference-to-function." Nonstatic
5652 member functions match targets of type "pointer-to-member
5653 function;" the function type of the pointer to member is used to
5654 select the member function from the set of overloaded member
5655 functions. If a nonstatic member function is selected, the
5656 reference to the overloaded function name is required to have the
5657 form of a pointer to member as described in 5.3.1.
5659 If more than one function is selected, any template functions in
5660 the set are eliminated if the set also contains a non-template
5661 function, and any given template function is eliminated if the
5662 set contains a second template function that is more specialized
5663 than the first according to the partial ordering rules 14.5.5.2.
5664 After such eliminations, if any, there shall remain exactly one
5665 selected function. */
5668 int is_reference
= 0;
5669 /* We store the matches in a TREE_LIST rooted here. The functions
5670 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5671 interoperability with most_specialized_instantiation. */
5672 tree matches
= NULL_TREE
;
5675 /* By the time we get here, we should be seeing only real
5676 pointer-to-member types, not the internal POINTER_TYPE to
5677 METHOD_TYPE representation. */
5678 gcc_assert (TREE_CODE (target_type
) != POINTER_TYPE
5679 || TREE_CODE (TREE_TYPE (target_type
)) != METHOD_TYPE
);
5681 gcc_assert (is_overloaded_fn (overload
));
5683 /* Check that the TARGET_TYPE is reasonable. */
5684 if (TYPE_PTRFN_P (target_type
))
5686 else if (TYPE_PTRMEMFUNC_P (target_type
))
5687 /* This is OK, too. */
5689 else if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
5691 /* This is OK, too. This comes from a conversion to reference
5693 target_type
= build_reference_type (target_type
);
5698 if (flags
& tf_error
)
5700 cannot resolve overloaded function `%D' based on conversion to type `%T'",
5701 DECL_NAME (OVL_FUNCTION (overload
)), target_type
);
5702 return error_mark_node
;
5705 /* If we can find a non-template function that matches, we can just
5706 use it. There's no point in generating template instantiations
5707 if we're just going to throw them out anyhow. But, of course, we
5708 can only do this when we don't *need* a template function. */
5713 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
5715 tree fn
= OVL_CURRENT (fns
);
5718 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
5719 /* We're not looking for templates just yet. */
5722 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
5724 /* We're looking for a non-static member, and this isn't
5725 one, or vice versa. */
5728 /* Ignore anticipated decls of undeclared builtins. */
5729 if (DECL_ANTICIPATED (fn
))
5732 /* See if there's a match. */
5733 fntype
= TREE_TYPE (fn
);
5735 fntype
= build_ptrmemfunc_type (build_pointer_type (fntype
));
5736 else if (!is_reference
)
5737 fntype
= build_pointer_type (fntype
);
5739 if (can_convert_arg (target_type
, fntype
, fn
))
5740 matches
= tree_cons (fn
, NULL_TREE
, matches
);
5744 /* Now, if we've already got a match (or matches), there's no need
5745 to proceed to the template functions. But, if we don't have a
5746 match we need to look at them, too. */
5749 tree target_fn_type
;
5750 tree target_arg_types
;
5751 tree target_ret_type
;
5756 = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (target_type
));
5758 target_fn_type
= TREE_TYPE (target_type
);
5759 target_arg_types
= TYPE_ARG_TYPES (target_fn_type
);
5760 target_ret_type
= TREE_TYPE (target_fn_type
);
5762 /* Never do unification on the 'this' parameter. */
5763 if (TREE_CODE (target_fn_type
) == METHOD_TYPE
)
5764 target_arg_types
= TREE_CHAIN (target_arg_types
);
5766 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
5768 tree fn
= OVL_CURRENT (fns
);
5770 tree instantiation_type
;
5773 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
5774 /* We're only looking for templates. */
5777 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
5779 /* We're not looking for a non-static member, and this is
5780 one, or vice versa. */
5783 /* Try to do argument deduction. */
5784 targs
= make_tree_vec (DECL_NTPARMS (fn
));
5785 if (fn_type_unification (fn
, explicit_targs
, targs
,
5786 target_arg_types
, target_ret_type
,
5787 DEDUCE_EXACT
, -1) != 0)
5788 /* Argument deduction failed. */
5791 /* Instantiate the template. */
5792 instantiation
= instantiate_template (fn
, targs
, flags
);
5793 if (instantiation
== error_mark_node
)
5794 /* Instantiation failed. */
5797 /* See if there's a match. */
5798 instantiation_type
= TREE_TYPE (instantiation
);
5800 instantiation_type
=
5801 build_ptrmemfunc_type (build_pointer_type (instantiation_type
));
5802 else if (!is_reference
)
5803 instantiation_type
= build_pointer_type (instantiation_type
);
5804 if (can_convert_arg (target_type
, instantiation_type
, instantiation
))
5805 matches
= tree_cons (instantiation
, fn
, matches
);
5808 /* Now, remove all but the most specialized of the matches. */
5811 tree match
= most_specialized_instantiation (matches
);
5813 if (match
!= error_mark_node
)
5814 matches
= tree_cons (match
, NULL_TREE
, NULL_TREE
);
5818 /* Now we should have exactly one function in MATCHES. */
5819 if (matches
== NULL_TREE
)
5821 /* There were *no* matches. */
5822 if (flags
& tf_error
)
5824 error ("no matches converting function `%D' to type `%#T'",
5825 DECL_NAME (OVL_FUNCTION (overload
)),
5828 /* print_candidates expects a chain with the functions in
5829 TREE_VALUE slots, so we cons one up here (we're losing anyway,
5830 so why be clever?). */
5831 for (; overload
; overload
= OVL_NEXT (overload
))
5832 matches
= tree_cons (NULL_TREE
, OVL_CURRENT (overload
),
5835 print_candidates (matches
);
5837 return error_mark_node
;
5839 else if (TREE_CHAIN (matches
))
5841 /* There were too many matches. */
5843 if (flags
& tf_error
)
5847 error ("converting overloaded function `%D' to type `%#T' is ambiguous",
5848 DECL_NAME (OVL_FUNCTION (overload
)),
5851 /* Since print_candidates expects the functions in the
5852 TREE_VALUE slot, we flip them here. */
5853 for (match
= matches
; match
; match
= TREE_CHAIN (match
))
5854 TREE_VALUE (match
) = TREE_PURPOSE (match
);
5856 print_candidates (matches
);
5859 return error_mark_node
;
5862 /* Good, exactly one match. Now, convert it to the correct type. */
5863 fn
= TREE_PURPOSE (matches
);
5865 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
5866 && !(flags
& tf_ptrmem_ok
) && !flag_ms_extensions
)
5868 static int explained
;
5870 if (!(flags
& tf_error
))
5871 return error_mark_node
;
5873 pedwarn ("assuming pointer to member `%D'", fn
);
5876 pedwarn ("(a pointer to member can only be formed with `&%E')", fn
);
5881 /* If we're doing overload resolution purely for the purpose of
5882 determining conversion sequences, we should not consider the
5883 function used. If this conversion sequence is selected, the
5884 function will be marked as used at this point. */
5885 if (!(flags
& tf_conv
))
5888 if (TYPE_PTRFN_P (target_type
) || TYPE_PTRMEMFUNC_P (target_type
))
5889 return build_unary_op (ADDR_EXPR
, fn
, 0);
5892 /* The target must be a REFERENCE_TYPE. Above, build_unary_op
5893 will mark the function as addressed, but here we must do it
5895 cxx_mark_addressable (fn
);
5901 /* This function will instantiate the type of the expression given in
5902 RHS to match the type of LHSTYPE. If errors exist, then return
5903 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
5904 we complain on errors. If we are not complaining, never modify rhs,
5905 as overload resolution wants to try many possible instantiations, in
5906 the hope that at least one will work.
5908 For non-recursive calls, LHSTYPE should be a function, pointer to
5909 function, or a pointer to member function. */
5912 instantiate_type (tree lhstype
, tree rhs
, tsubst_flags_t flags
)
5914 tsubst_flags_t flags_in
= flags
;
5916 flags
&= ~tf_ptrmem_ok
;
5918 if (TREE_CODE (lhstype
) == UNKNOWN_TYPE
)
5920 if (flags
& tf_error
)
5921 error ("not enough type information");
5922 return error_mark_node
;
5925 if (TREE_TYPE (rhs
) != NULL_TREE
&& ! (type_unknown_p (rhs
)))
5927 if (same_type_p (lhstype
, TREE_TYPE (rhs
)))
5929 if (flag_ms_extensions
5930 && TYPE_PTRMEMFUNC_P (lhstype
)
5931 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
5932 /* Microsoft allows `A::f' to be resolved to a
5933 pointer-to-member. */
5937 if (flags
& tf_error
)
5938 error ("argument of type `%T' does not match `%T'",
5939 TREE_TYPE (rhs
), lhstype
);
5940 return error_mark_node
;
5944 if (TREE_CODE (rhs
) == BASELINK
)
5945 rhs
= BASELINK_FUNCTIONS (rhs
);
5947 /* We don't overwrite rhs if it is an overloaded function.
5948 Copying it would destroy the tree link. */
5949 if (TREE_CODE (rhs
) != OVERLOAD
)
5950 rhs
= copy_node (rhs
);
5952 /* This should really only be used when attempting to distinguish
5953 what sort of a pointer to function we have. For now, any
5954 arithmetic operation which is not supported on pointers
5955 is rejected as an error. */
5957 switch (TREE_CODE (rhs
))
5970 new_rhs
= instantiate_type (build_pointer_type (lhstype
),
5971 TREE_OPERAND (rhs
, 0), flags
);
5972 if (new_rhs
== error_mark_node
)
5973 return error_mark_node
;
5975 TREE_TYPE (rhs
) = lhstype
;
5976 TREE_OPERAND (rhs
, 0) = new_rhs
;
5981 rhs
= copy_node (TREE_OPERAND (rhs
, 0));
5982 TREE_TYPE (rhs
) = unknown_type_node
;
5983 return instantiate_type (lhstype
, rhs
, flags
);
5987 tree addr
= instantiate_type (lhstype
, TREE_OPERAND (rhs
, 1), flags
);
5989 if (addr
!= error_mark_node
5990 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs
, 0)))
5991 /* Do not lose object's side effects. */
5992 addr
= build2 (COMPOUND_EXPR
, TREE_TYPE (addr
),
5993 TREE_OPERAND (rhs
, 0), addr
);
5998 rhs
= TREE_OPERAND (rhs
, 1);
5999 if (BASELINK_P (rhs
))
6000 return instantiate_type (lhstype
, BASELINK_FUNCTIONS (rhs
), flags_in
);
6002 /* This can happen if we are forming a pointer-to-member for a
6004 gcc_assert (TREE_CODE (rhs
) == TEMPLATE_ID_EXPR
);
6008 case TEMPLATE_ID_EXPR
:
6010 tree fns
= TREE_OPERAND (rhs
, 0);
6011 tree args
= TREE_OPERAND (rhs
, 1);
6014 resolve_address_of_overloaded_function (lhstype
, fns
, flags_in
,
6015 /*template_only=*/true,
6022 resolve_address_of_overloaded_function (lhstype
, rhs
, flags_in
,
6023 /*template_only=*/false,
6024 /*explicit_targs=*/NULL_TREE
);
6027 /* Now we should have a baselink. */
6028 gcc_assert (BASELINK_P (rhs
));
6030 return instantiate_type (lhstype
, BASELINK_FUNCTIONS (rhs
), flags
);
6033 /* This is too hard for now. */
6039 TREE_OPERAND (rhs
, 0)
6040 = instantiate_type (lhstype
, TREE_OPERAND (rhs
, 0), flags
);
6041 if (TREE_OPERAND (rhs
, 0) == error_mark_node
)
6042 return error_mark_node
;
6043 TREE_OPERAND (rhs
, 1)
6044 = instantiate_type (lhstype
, TREE_OPERAND (rhs
, 1), flags
);
6045 if (TREE_OPERAND (rhs
, 1) == error_mark_node
)
6046 return error_mark_node
;
6048 TREE_TYPE (rhs
) = lhstype
;
6052 case TRUNC_DIV_EXPR
:
6053 case FLOOR_DIV_EXPR
:
6055 case ROUND_DIV_EXPR
:
6057 case TRUNC_MOD_EXPR
:
6058 case FLOOR_MOD_EXPR
:
6060 case ROUND_MOD_EXPR
:
6061 case FIX_ROUND_EXPR
:
6062 case FIX_FLOOR_EXPR
:
6064 case FIX_TRUNC_EXPR
:
6079 case PREINCREMENT_EXPR
:
6080 case PREDECREMENT_EXPR
:
6081 case POSTINCREMENT_EXPR
:
6082 case POSTDECREMENT_EXPR
:
6083 if (flags
& tf_error
)
6084 error ("invalid operation on uninstantiated type");
6085 return error_mark_node
;
6087 case TRUTH_AND_EXPR
:
6089 case TRUTH_XOR_EXPR
:
6096 case TRUTH_ANDIF_EXPR
:
6097 case TRUTH_ORIF_EXPR
:
6098 case TRUTH_NOT_EXPR
:
6099 if (flags
& tf_error
)
6100 error ("not enough type information");
6101 return error_mark_node
;
6104 if (type_unknown_p (TREE_OPERAND (rhs
, 0)))
6106 if (flags
& tf_error
)
6107 error ("not enough type information");
6108 return error_mark_node
;
6110 TREE_OPERAND (rhs
, 1)
6111 = instantiate_type (lhstype
, TREE_OPERAND (rhs
, 1), flags
);
6112 if (TREE_OPERAND (rhs
, 1) == error_mark_node
)
6113 return error_mark_node
;
6114 TREE_OPERAND (rhs
, 2)
6115 = instantiate_type (lhstype
, TREE_OPERAND (rhs
, 2), flags
);
6116 if (TREE_OPERAND (rhs
, 2) == error_mark_node
)
6117 return error_mark_node
;
6119 TREE_TYPE (rhs
) = lhstype
;
6123 TREE_OPERAND (rhs
, 1)
6124 = instantiate_type (lhstype
, TREE_OPERAND (rhs
, 1), flags
);
6125 if (TREE_OPERAND (rhs
, 1) == error_mark_node
)
6126 return error_mark_node
;
6128 TREE_TYPE (rhs
) = lhstype
;
6133 if (PTRMEM_OK_P (rhs
))
6134 flags
|= tf_ptrmem_ok
;
6136 return instantiate_type (lhstype
, TREE_OPERAND (rhs
, 0), flags
);
6140 return error_mark_node
;
6145 return error_mark_node
;
6148 /* Return the name of the virtual function pointer field
6149 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6150 this may have to look back through base types to find the
6151 ultimate field name. (For single inheritance, these could
6152 all be the same name. Who knows for multiple inheritance). */
6155 get_vfield_name (tree type
)
6157 tree binfo
, base_binfo
;
6160 for (binfo
= TYPE_BINFO (type
);
6161 BINFO_N_BASE_BINFOS (binfo
);
6164 base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
6166 if (BINFO_VIRTUAL_P (base_binfo
)
6167 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo
)))
6171 type
= BINFO_TYPE (binfo
);
6172 buf
= alloca (sizeof (VFIELD_NAME_FORMAT
) + TYPE_NAME_LENGTH (type
) + 2);
6173 sprintf (buf
, VFIELD_NAME_FORMAT
,
6174 IDENTIFIER_POINTER (constructor_name (type
)));
6175 return get_identifier (buf
);
6179 print_class_statistics (void)
6181 #ifdef GATHER_STATISTICS
6182 fprintf (stderr
, "convert_harshness = %d\n", n_convert_harshness
);
6183 fprintf (stderr
, "compute_conversion_costs = %d\n", n_compute_conversion_costs
);
6186 fprintf (stderr
, "vtables = %d; vtable searches = %d\n",
6187 n_vtables
, n_vtable_searches
);
6188 fprintf (stderr
, "vtable entries = %d; vtable elems = %d\n",
6189 n_vtable_entries
, n_vtable_elems
);
6194 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6195 according to [class]:
6196 The class-name is also inserted
6197 into the scope of the class itself. For purposes of access checking,
6198 the inserted class name is treated as if it were a public member name. */
6201 build_self_reference (void)
6203 tree name
= constructor_name (current_class_type
);
6204 tree value
= build_lang_decl (TYPE_DECL
, name
, current_class_type
);
6207 DECL_NONLOCAL (value
) = 1;
6208 DECL_CONTEXT (value
) = current_class_type
;
6209 DECL_ARTIFICIAL (value
) = 1;
6210 SET_DECL_SELF_REFERENCE_P (value
);
6212 if (processing_template_decl
)
6213 value
= push_template_decl (value
);
6215 saved_cas
= current_access_specifier
;
6216 current_access_specifier
= access_public_node
;
6217 finish_member_declaration (value
);
6218 current_access_specifier
= saved_cas
;
6221 /* Returns 1 if TYPE contains only padding bytes. */
6224 is_empty_class (tree type
)
6226 if (type
== error_mark_node
)
6229 if (! IS_AGGR_TYPE (type
))
6232 /* In G++ 3.2, whether or not a class was empty was determined by
6233 looking at its size. */
6234 if (abi_version_at_least (2))
6235 return CLASSTYPE_EMPTY_P (type
);
6237 return integer_zerop (CLASSTYPE_SIZE (type
));
6240 /* Returns true if TYPE contains an empty class. */
6243 contains_empty_class_p (tree type
)
6245 if (is_empty_class (type
))
6247 if (CLASS_TYPE_P (type
))
6254 for (binfo
= TYPE_BINFO (type
), i
= 0;
6255 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
6256 if (contains_empty_class_p (BINFO_TYPE (base_binfo
)))
6258 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
6259 if (TREE_CODE (field
) == FIELD_DECL
6260 && !DECL_ARTIFICIAL (field
)
6261 && is_empty_class (TREE_TYPE (field
)))
6264 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6265 return contains_empty_class_p (TREE_TYPE (type
));
6269 /* Find the enclosing class of the given NODE. NODE can be a *_DECL or
6270 a *_TYPE node. NODE can also be a local class. */
6273 get_enclosing_class (tree type
)
6277 while (node
&& TREE_CODE (node
) != NAMESPACE_DECL
)
6279 switch (TREE_CODE_CLASS (TREE_CODE (node
)))
6282 node
= DECL_CONTEXT (node
);
6288 node
= TYPE_CONTEXT (node
);
6298 /* Note that NAME was looked up while the current class was being
6299 defined and that the result of that lookup was DECL. */
6302 maybe_note_name_used_in_class (tree name
, tree decl
)
6304 splay_tree names_used
;
6306 /* If we're not defining a class, there's nothing to do. */
6307 if (!(innermost_scope_kind() == sk_class
6308 && TYPE_BEING_DEFINED (current_class_type
)))
6311 /* If there's already a binding for this NAME, then we don't have
6312 anything to worry about. */
6313 if (lookup_member (current_class_type
, name
,
6314 /*protect=*/0, /*want_type=*/false))
6317 if (!current_class_stack
[current_class_depth
- 1].names_used
)
6318 current_class_stack
[current_class_depth
- 1].names_used
6319 = splay_tree_new (splay_tree_compare_pointers
, 0, 0);
6320 names_used
= current_class_stack
[current_class_depth
- 1].names_used
;
6322 splay_tree_insert (names_used
,
6323 (splay_tree_key
) name
,
6324 (splay_tree_value
) decl
);
6327 /* Note that NAME was declared (as DECL) in the current class. Check
6328 to see that the declaration is valid. */
6331 note_name_declared_in_class (tree name
, tree decl
)
6333 splay_tree names_used
;
6336 /* Look to see if we ever used this name. */
6338 = current_class_stack
[current_class_depth
- 1].names_used
;
6342 n
= splay_tree_lookup (names_used
, (splay_tree_key
) name
);
6345 /* [basic.scope.class]
6347 A name N used in a class S shall refer to the same declaration
6348 in its context and when re-evaluated in the completed scope of
6350 error ("declaration of `%#D'", decl
);
6351 cp_error_at ("changes meaning of `%D' from `%+#D'",
6352 DECL_NAME (OVL_CURRENT (decl
)),
6357 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6358 Secondary vtables are merged with primary vtables; this function
6359 will return the VAR_DECL for the primary vtable. */
6362 get_vtbl_decl_for_binfo (tree binfo
)
6366 decl
= BINFO_VTABLE (binfo
);
6367 if (decl
&& TREE_CODE (decl
) == PLUS_EXPR
)
6369 gcc_assert (TREE_CODE (TREE_OPERAND (decl
, 0)) == ADDR_EXPR
);
6370 decl
= TREE_OPERAND (TREE_OPERAND (decl
, 0), 0);
6373 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
6378 /* Returns the binfo for the primary base of BINFO. If the resulting
6379 BINFO is a virtual base, and it is inherited elsewhere in the
6380 hierarchy, then the returned binfo might not be the primary base of
6381 BINFO in the complete object. Check BINFO_PRIMARY_P or
6382 BINFO_LOST_PRIMARY_P to be sure. */
6385 get_primary_binfo (tree binfo
)
6390 primary_base
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo
));
6394 result
= copied_binfo (primary_base
, binfo
);
6398 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
6401 maybe_indent_hierarchy (FILE * stream
, int indent
, int indented_p
)
6404 fprintf (stream
, "%*s", indent
, "");
6408 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6409 INDENT should be zero when called from the top level; it is
6410 incremented recursively. IGO indicates the next expected BINFO in
6411 inheritance graph ordering. */
6414 dump_class_hierarchy_r (FILE *stream
,
6424 indented
= maybe_indent_hierarchy (stream
, indent
, 0);
6425 fprintf (stream
, "%s (0x%lx) ",
6426 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
),
6427 (unsigned long) binfo
);
6430 fprintf (stream
, "alternative-path\n");
6433 igo
= TREE_CHAIN (binfo
);
6435 fprintf (stream
, HOST_WIDE_INT_PRINT_DEC
,
6436 tree_low_cst (BINFO_OFFSET (binfo
), 0));
6437 if (is_empty_class (BINFO_TYPE (binfo
)))
6438 fprintf (stream
, " empty");
6439 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo
)))
6440 fprintf (stream
, " nearly-empty");
6441 if (BINFO_VIRTUAL_P (binfo
))
6442 fprintf (stream
, " virtual");
6443 fprintf (stream
, "\n");
6446 if (BINFO_PRIMARY_P (binfo
))
6448 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6449 fprintf (stream
, " primary-for %s (0x%lx)",
6450 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo
)),
6451 TFF_PLAIN_IDENTIFIER
),
6452 (unsigned long)BINFO_INHERITANCE_CHAIN (binfo
));
6454 if (BINFO_LOST_PRIMARY_P (binfo
))
6456 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6457 fprintf (stream
, " lost-primary");
6460 fprintf (stream
, "\n");
6462 if (!(flags
& TDF_SLIM
))
6466 if (BINFO_SUBVTT_INDEX (binfo
))
6468 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6469 fprintf (stream
, " subvttidx=%s",
6470 expr_as_string (BINFO_SUBVTT_INDEX (binfo
),
6471 TFF_PLAIN_IDENTIFIER
));
6473 if (BINFO_VPTR_INDEX (binfo
))
6475 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6476 fprintf (stream
, " vptridx=%s",
6477 expr_as_string (BINFO_VPTR_INDEX (binfo
),
6478 TFF_PLAIN_IDENTIFIER
));
6480 if (BINFO_VPTR_FIELD (binfo
))
6482 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6483 fprintf (stream
, " vbaseoffset=%s",
6484 expr_as_string (BINFO_VPTR_FIELD (binfo
),
6485 TFF_PLAIN_IDENTIFIER
));
6487 if (BINFO_VTABLE (binfo
))
6489 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
6490 fprintf (stream
, " vptr=%s",
6491 expr_as_string (BINFO_VTABLE (binfo
),
6492 TFF_PLAIN_IDENTIFIER
));
6496 fprintf (stream
, "\n");
6499 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
6500 igo
= dump_class_hierarchy_r (stream
, flags
, base_binfo
, igo
, indent
+ 2);
6505 /* Dump the BINFO hierarchy for T. */
6508 dump_class_hierarchy_1 (FILE *stream
, int flags
, tree t
)
6510 fprintf (stream
, "Class %s\n", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
6511 fprintf (stream
, " size=%lu align=%lu\n",
6512 (unsigned long)(tree_low_cst (TYPE_SIZE (t
), 0) / BITS_PER_UNIT
),
6513 (unsigned long)(TYPE_ALIGN (t
) / BITS_PER_UNIT
));
6514 fprintf (stream
, " base size=%lu base align=%lu\n",
6515 (unsigned long)(tree_low_cst (TYPE_SIZE (CLASSTYPE_AS_BASE (t
)), 0)
6517 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t
))
6519 dump_class_hierarchy_r (stream
, flags
, TYPE_BINFO (t
), TYPE_BINFO (t
), 0);
6520 fprintf (stream
, "\n");
6523 /* Debug interface to hierarchy dumping. */
6526 debug_class (tree t
)
6528 dump_class_hierarchy_1 (stderr
, TDF_SLIM
, t
);
6532 dump_class_hierarchy (tree t
)
6535 FILE *stream
= dump_begin (TDI_class
, &flags
);
6539 dump_class_hierarchy_1 (stream
, flags
, t
);
6540 dump_end (TDI_class
, stream
);
6545 dump_array (FILE * stream
, tree decl
)
6550 tree size
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl
)));
6552 elt
= (tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
))), 0)
6554 fprintf (stream
, "%s:", decl_as_string (decl
, TFF_PLAIN_IDENTIFIER
));
6555 fprintf (stream
, " %s entries",
6556 expr_as_string (size_binop (PLUS_EXPR
, size
, size_one_node
),
6557 TFF_PLAIN_IDENTIFIER
));
6558 fprintf (stream
, "\n");
6560 for (ix
= 0, inits
= CONSTRUCTOR_ELTS (DECL_INITIAL (decl
));
6561 inits
; ix
++, inits
= TREE_CHAIN (inits
))
6562 fprintf (stream
, "%-4ld %s\n", (long)(ix
* elt
),
6563 expr_as_string (TREE_VALUE (inits
), TFF_PLAIN_IDENTIFIER
));
6567 dump_vtable (tree t
, tree binfo
, tree vtable
)
6570 FILE *stream
= dump_begin (TDI_class
, &flags
);
6575 if (!(flags
& TDF_SLIM
))
6577 int ctor_vtbl_p
= TYPE_BINFO (t
) != binfo
;
6579 fprintf (stream
, "%s for %s",
6580 ctor_vtbl_p
? "Construction vtable" : "Vtable",
6581 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
));
6584 if (!BINFO_VIRTUAL_P (binfo
))
6585 fprintf (stream
, " (0x%lx instance)", (unsigned long)binfo
);
6586 fprintf (stream
, " in %s", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
6588 fprintf (stream
, "\n");
6589 dump_array (stream
, vtable
);
6590 fprintf (stream
, "\n");
6593 dump_end (TDI_class
, stream
);
6597 dump_vtt (tree t
, tree vtt
)
6600 FILE *stream
= dump_begin (TDI_class
, &flags
);
6605 if (!(flags
& TDF_SLIM
))
6607 fprintf (stream
, "VTT for %s\n",
6608 type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
6609 dump_array (stream
, vtt
);
6610 fprintf (stream
, "\n");
6613 dump_end (TDI_class
, stream
);
6616 /* Dump a function or thunk and its thunkees. */
6619 dump_thunk (FILE *stream
, int indent
, tree thunk
)
6621 static const char spaces
[] = " ";
6622 tree name
= DECL_NAME (thunk
);
6625 fprintf (stream
, "%.*s%p %s %s", indent
, spaces
,
6627 !DECL_THUNK_P (thunk
) ? "function"
6628 : DECL_THIS_THUNK_P (thunk
) ? "this-thunk" : "covariant-thunk",
6629 name
? IDENTIFIER_POINTER (name
) : "<unset>");
6630 if (DECL_THUNK_P (thunk
))
6632 HOST_WIDE_INT fixed_adjust
= THUNK_FIXED_OFFSET (thunk
);
6633 tree virtual_adjust
= THUNK_VIRTUAL_OFFSET (thunk
);
6635 fprintf (stream
, " fixed=" HOST_WIDE_INT_PRINT_DEC
, fixed_adjust
);
6636 if (!virtual_adjust
)
6638 else if (DECL_THIS_THUNK_P (thunk
))
6639 fprintf (stream
, " vcall=" HOST_WIDE_INT_PRINT_DEC
,
6640 tree_low_cst (virtual_adjust
, 0));
6642 fprintf (stream
, " vbase=" HOST_WIDE_INT_PRINT_DEC
"(%s)",
6643 tree_low_cst (BINFO_VPTR_FIELD (virtual_adjust
), 0),
6644 type_as_string (BINFO_TYPE (virtual_adjust
), TFF_SCOPE
));
6645 if (THUNK_ALIAS (thunk
))
6646 fprintf (stream
, " alias to %p", (void *)THUNK_ALIAS (thunk
));
6648 fprintf (stream
, "\n");
6649 for (thunks
= DECL_THUNKS (thunk
); thunks
; thunks
= TREE_CHAIN (thunks
))
6650 dump_thunk (stream
, indent
+ 2, thunks
);
6653 /* Dump the thunks for FN. */
6656 debug_thunks (tree fn
)
6658 dump_thunk (stderr
, 0, fn
);
6661 /* Virtual function table initialization. */
6663 /* Create all the necessary vtables for T and its base classes. */
6666 finish_vtbls (tree t
)
6671 /* We lay out the primary and secondary vtables in one contiguous
6672 vtable. The primary vtable is first, followed by the non-virtual
6673 secondary vtables in inheritance graph order. */
6674 list
= build_tree_list (BINFO_VTABLE (TYPE_BINFO (t
)), NULL_TREE
);
6675 accumulate_vtbl_inits (TYPE_BINFO (t
), TYPE_BINFO (t
),
6676 TYPE_BINFO (t
), t
, list
);
6678 /* Then come the virtual bases, also in inheritance graph order. */
6679 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
6681 if (!BINFO_VIRTUAL_P (vbase
))
6683 accumulate_vtbl_inits (vbase
, vbase
, TYPE_BINFO (t
), t
, list
);
6686 if (BINFO_VTABLE (TYPE_BINFO (t
)))
6687 initialize_vtable (TYPE_BINFO (t
), TREE_VALUE (list
));
6690 /* Initialize the vtable for BINFO with the INITS. */
6693 initialize_vtable (tree binfo
, tree inits
)
6697 layout_vtable_decl (binfo
, list_length (inits
));
6698 decl
= get_vtbl_decl_for_binfo (binfo
);
6699 initialize_artificial_var (decl
, inits
);
6700 dump_vtable (BINFO_TYPE (binfo
), binfo
, decl
);
6703 /* Build the VTT (virtual table table) for T.
6704 A class requires a VTT if it has virtual bases.
6707 1 - primary virtual pointer for complete object T
6708 2 - secondary VTTs for each direct non-virtual base of T which requires a
6710 3 - secondary virtual pointers for each direct or indirect base of T which
6711 has virtual bases or is reachable via a virtual path from T.
6712 4 - secondary VTTs for each direct or indirect virtual base of T.
6714 Secondary VTTs look like complete object VTTs without part 4. */
6724 /* Build up the initializers for the VTT. */
6726 index
= size_zero_node
;
6727 build_vtt_inits (TYPE_BINFO (t
), t
, &inits
, &index
);
6729 /* If we didn't need a VTT, we're done. */
6733 /* Figure out the type of the VTT. */
6734 type
= build_index_type (size_int (list_length (inits
) - 1));
6735 type
= build_cplus_array_type (const_ptr_type_node
, type
);
6737 /* Now, build the VTT object itself. */
6738 vtt
= build_vtable (t
, get_vtt_name (t
), type
);
6739 initialize_artificial_var (vtt
, inits
);
6740 /* Add the VTT to the vtables list. */
6741 TREE_CHAIN (vtt
) = TREE_CHAIN (CLASSTYPE_VTABLES (t
));
6742 TREE_CHAIN (CLASSTYPE_VTABLES (t
)) = vtt
;
6747 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6748 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6749 and CHAIN the vtable pointer for this binfo after construction is
6750 complete. VALUE can also be another BINFO, in which case we recurse. */
6753 binfo_ctor_vtable (tree binfo
)
6759 vt
= BINFO_VTABLE (binfo
);
6760 if (TREE_CODE (vt
) == TREE_LIST
)
6761 vt
= TREE_VALUE (vt
);
6762 if (TREE_CODE (vt
) == TREE_BINFO
)
6771 /* Recursively build the VTT-initializer for BINFO (which is in the
6772 hierarchy dominated by T). INITS points to the end of the initializer
6773 list to date. INDEX is the VTT index where the next element will be
6774 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6775 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
6776 for virtual bases of T. When it is not so, we build the constructor
6777 vtables for the BINFO-in-T variant. */
6780 build_vtt_inits (tree binfo
, tree t
, tree
* inits
, tree
* index
)
6785 tree secondary_vptrs
;
6786 int top_level_p
= same_type_p (TREE_TYPE (binfo
), t
);
6788 /* We only need VTTs for subobjects with virtual bases. */
6789 if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo
)))
6792 /* We need to use a construction vtable if this is not the primary
6796 build_ctor_vtbl_group (binfo
, t
);
6798 /* Record the offset in the VTT where this sub-VTT can be found. */
6799 BINFO_SUBVTT_INDEX (binfo
) = *index
;
6802 /* Add the address of the primary vtable for the complete object. */
6803 init
= binfo_ctor_vtable (binfo
);
6804 *inits
= build_tree_list (NULL_TREE
, init
);
6805 inits
= &TREE_CHAIN (*inits
);
6808 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
6809 BINFO_VPTR_INDEX (binfo
) = *index
;
6811 *index
= size_binop (PLUS_EXPR
, *index
, TYPE_SIZE_UNIT (ptr_type_node
));
6813 /* Recursively add the secondary VTTs for non-virtual bases. */
6814 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, b
); ++i
)
6815 if (!BINFO_VIRTUAL_P (b
))
6816 inits
= build_vtt_inits (BINFO_BASE_BINFO (binfo
, i
), t
, inits
, index
);
6818 /* Add secondary virtual pointers for all subobjects of BINFO with
6819 either virtual bases or reachable along a virtual path, except
6820 subobjects that are non-virtual primary bases. */
6821 secondary_vptrs
= tree_cons (t
, NULL_TREE
, BINFO_TYPE (binfo
));
6822 TREE_TYPE (secondary_vptrs
) = *index
;
6823 VTT_TOP_LEVEL_P (secondary_vptrs
) = top_level_p
;
6824 VTT_MARKED_BINFO_P (secondary_vptrs
) = 0;
6826 dfs_walk_real (binfo
,
6827 dfs_build_secondary_vptr_vtt_inits
,
6829 dfs_ctor_vtable_bases_queue_p
,
6831 VTT_MARKED_BINFO_P (secondary_vptrs
) = 1;
6832 dfs_walk (binfo
, dfs_unmark
, dfs_ctor_vtable_bases_queue_p
,
6835 *index
= TREE_TYPE (secondary_vptrs
);
6837 /* The secondary vptrs come back in reverse order. After we reverse
6838 them, and add the INITS, the last init will be the first element
6840 secondary_vptrs
= TREE_VALUE (secondary_vptrs
);
6841 if (secondary_vptrs
)
6843 *inits
= nreverse (secondary_vptrs
);
6844 inits
= &TREE_CHAIN (secondary_vptrs
);
6845 gcc_assert (*inits
== NULL_TREE
);
6848 /* Add the secondary VTTs for virtual bases. */
6850 for (b
= TYPE_BINFO (BINFO_TYPE (binfo
)); b
; b
= TREE_CHAIN (b
))
6852 if (!BINFO_VIRTUAL_P (b
))
6855 inits
= build_vtt_inits (b
, t
, inits
, index
);
6860 tree data
= tree_cons (t
, binfo
, NULL_TREE
);
6861 VTT_TOP_LEVEL_P (data
) = 0;
6862 VTT_MARKED_BINFO_P (data
) = 0;
6864 dfs_walk (binfo
, dfs_fixup_binfo_vtbls
,
6865 dfs_ctor_vtable_bases_queue_p
,
6872 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
6873 in most derived. DATA is a TREE_LIST who's TREE_CHAIN is the type of the
6874 base being constructed whilst this secondary vptr is live. The
6875 TREE_TOP_LEVEL flag indicates that this is the primary VTT. */
6878 dfs_build_secondary_vptr_vtt_inits (tree binfo
, void *data
)
6888 top_level_p
= VTT_TOP_LEVEL_P (l
);
6890 BINFO_MARKED (binfo
) = 1;
6892 /* We don't care about bases that don't have vtables. */
6893 if (!TYPE_VFIELD (BINFO_TYPE (binfo
)))
6896 /* We're only interested in proper subobjects of T. */
6897 if (same_type_p (BINFO_TYPE (binfo
), t
))
6900 /* We're not interested in non-virtual primary bases. */
6901 if (!BINFO_VIRTUAL_P (binfo
) && BINFO_PRIMARY_P (binfo
))
6904 /* If BINFO has virtual bases or is reachable via a virtual path
6905 from T, it'll have a secondary vptr. */
6906 if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo
))
6907 && !binfo_via_virtual (binfo
, t
))
6910 /* Record the index where this secondary vptr can be found. */
6911 index
= TREE_TYPE (l
);
6914 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
6915 BINFO_VPTR_INDEX (binfo
) = index
;
6917 TREE_TYPE (l
) = size_binop (PLUS_EXPR
, index
,
6918 TYPE_SIZE_UNIT (ptr_type_node
));
6920 /* Add the initializer for the secondary vptr itself. */
6921 if (top_level_p
&& BINFO_VIRTUAL_P (binfo
))
6923 /* It's a primary virtual base, and this is not the construction
6924 vtable. Find the base this is primary of in the inheritance graph,
6925 and use that base's vtable now. */
6926 while (BINFO_PRIMARY_P (binfo
))
6927 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
6929 init
= binfo_ctor_vtable (binfo
);
6930 TREE_VALUE (l
) = tree_cons (NULL_TREE
, init
, TREE_VALUE (l
));
6935 /* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST,
6936 VTT_MARKED_BINFO_P indicates whether marked or unmarked bases
6937 should be walked. TREE_PURPOSE is the TREE_TYPE that dominates the
6941 dfs_ctor_vtable_bases_queue_p (tree derived
, int ix
,
6944 tree binfo
= BINFO_BASE_BINFO (derived
, ix
);
6946 if (!BINFO_MARKED (binfo
) == VTT_MARKED_BINFO_P ((tree
) data
))
6951 /* Called from build_vtt_inits via dfs_walk. After building constructor
6952 vtables and generating the sub-vtt from them, we need to restore the
6953 BINFO_VTABLES that were scribbled on. DATA is a TREE_LIST whose
6954 TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated. */
6957 dfs_fixup_binfo_vtbls (tree binfo
, void* data
)
6959 BINFO_MARKED (binfo
) = 0;
6961 /* We don't care about bases that don't have vtables. */
6962 if (!TYPE_VFIELD (BINFO_TYPE (binfo
)))
6965 /* If we scribbled the construction vtable vptr into BINFO, clear it
6967 if (BINFO_VTABLE (binfo
)
6968 && TREE_CODE (BINFO_VTABLE (binfo
)) == TREE_LIST
6969 && (TREE_PURPOSE (BINFO_VTABLE (binfo
))
6970 == TREE_VALUE ((tree
) data
)))
6971 BINFO_VTABLE (binfo
) = TREE_CHAIN (BINFO_VTABLE (binfo
));
6976 /* Build the construction vtable group for BINFO which is in the
6977 hierarchy dominated by T. */
6980 build_ctor_vtbl_group (tree binfo
, tree t
)
6989 /* See if we've already created this construction vtable group. */
6990 id
= mangle_ctor_vtbl_for_type (t
, binfo
);
6991 if (IDENTIFIER_GLOBAL_VALUE (id
))
6994 gcc_assert (!same_type_p (BINFO_TYPE (binfo
), t
));
6995 /* Build a version of VTBL (with the wrong type) for use in
6996 constructing the addresses of secondary vtables in the
6997 construction vtable group. */
6998 vtbl
= build_vtable (t
, id
, ptr_type_node
);
6999 list
= build_tree_list (vtbl
, NULL_TREE
);
7000 accumulate_vtbl_inits (binfo
, TYPE_BINFO (TREE_TYPE (binfo
)),
7003 /* Add the vtables for each of our virtual bases using the vbase in T
7005 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
7007 vbase
= TREE_CHAIN (vbase
))
7011 if (!BINFO_VIRTUAL_P (vbase
))
7013 b
= copied_binfo (vbase
, binfo
);
7015 accumulate_vtbl_inits (b
, vbase
, binfo
, t
, list
);
7017 inits
= TREE_VALUE (list
);
7019 /* Figure out the type of the construction vtable. */
7020 type
= build_index_type (size_int (list_length (inits
) - 1));
7021 type
= build_cplus_array_type (vtable_entry_type
, type
);
7022 TREE_TYPE (vtbl
) = type
;
7024 /* Initialize the construction vtable. */
7025 CLASSTYPE_VTABLES (t
) = chainon (CLASSTYPE_VTABLES (t
), vtbl
);
7026 initialize_artificial_var (vtbl
, inits
);
7027 dump_vtable (t
, binfo
, vtbl
);
7030 /* Add the vtbl initializers for BINFO (and its bases other than
7031 non-virtual primaries) to the list of INITS. BINFO is in the
7032 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7033 the constructor the vtbl inits should be accumulated for. (If this
7034 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7035 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7036 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7037 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7038 but are not necessarily the same in terms of layout. */
7041 accumulate_vtbl_inits (tree binfo
,
7049 int ctor_vtbl_p
= !same_type_p (BINFO_TYPE (rtti_binfo
), t
);
7051 gcc_assert (same_type_p (BINFO_TYPE (binfo
), BINFO_TYPE (orig_binfo
)));
7053 /* If it doesn't have a vptr, we don't do anything. */
7054 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
7057 /* If we're building a construction vtable, we're not interested in
7058 subobjects that don't require construction vtables. */
7060 && !TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo
))
7061 && !binfo_via_virtual (orig_binfo
, BINFO_TYPE (rtti_binfo
)))
7064 /* Build the initializers for the BINFO-in-T vtable. */
7066 = chainon (TREE_VALUE (inits
),
7067 dfs_accumulate_vtbl_inits (binfo
, orig_binfo
,
7068 rtti_binfo
, t
, inits
));
7070 /* Walk the BINFO and its bases. We walk in preorder so that as we
7071 initialize each vtable we can figure out at what offset the
7072 secondary vtable lies from the primary vtable. We can't use
7073 dfs_walk here because we need to iterate through bases of BINFO
7074 and RTTI_BINFO simultaneously. */
7075 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
7077 /* Skip virtual bases. */
7078 if (BINFO_VIRTUAL_P (base_binfo
))
7080 accumulate_vtbl_inits (base_binfo
,
7081 BINFO_BASE_BINFO (orig_binfo
, i
),
7087 /* Called from accumulate_vtbl_inits. Returns the initializers for
7088 the BINFO vtable. */
7091 dfs_accumulate_vtbl_inits (tree binfo
,
7097 tree inits
= NULL_TREE
;
7098 tree vtbl
= NULL_TREE
;
7099 int ctor_vtbl_p
= !same_type_p (BINFO_TYPE (rtti_binfo
), t
);
7102 && BINFO_VIRTUAL_P (orig_binfo
) && BINFO_PRIMARY_P (orig_binfo
))
7104 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7105 primary virtual base. If it is not the same primary in
7106 the hierarchy of T, we'll need to generate a ctor vtable
7107 for it, to place at its location in T. If it is the same
7108 primary, we still need a VTT entry for the vtable, but it
7109 should point to the ctor vtable for the base it is a
7110 primary for within the sub-hierarchy of RTTI_BINFO.
7112 There are three possible cases:
7114 1) We are in the same place.
7115 2) We are a primary base within a lost primary virtual base of
7117 3) We are primary to something not a base of RTTI_BINFO. */
7120 tree last
= NULL_TREE
;
7122 /* First, look through the bases we are primary to for RTTI_BINFO
7123 or a virtual base. */
7125 while (BINFO_PRIMARY_P (b
))
7127 b
= BINFO_INHERITANCE_CHAIN (b
);
7129 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
7132 /* If we run out of primary links, keep looking down our
7133 inheritance chain; we might be an indirect primary. */
7134 for (b
= last
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
7135 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
7139 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7140 base B and it is a base of RTTI_BINFO, this is case 2. In
7141 either case, we share our vtable with LAST, i.e. the
7142 derived-most base within B of which we are a primary. */
7144 || (b
&& binfo_for_vbase (BINFO_TYPE (b
), BINFO_TYPE (rtti_binfo
))))
7145 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7146 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7147 binfo_ctor_vtable after everything's been set up. */
7150 /* Otherwise, this is case 3 and we get our own. */
7152 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo
))
7160 /* Compute the initializer for this vtable. */
7161 inits
= build_vtbl_initializer (binfo
, orig_binfo
, t
, rtti_binfo
,
7164 /* Figure out the position to which the VPTR should point. */
7165 vtbl
= TREE_PURPOSE (l
);
7166 vtbl
= build1 (ADDR_EXPR
, vtbl_ptr_type_node
, vtbl
);
7167 index
= size_binop (PLUS_EXPR
,
7168 size_int (non_fn_entries
),
7169 size_int (list_length (TREE_VALUE (l
))));
7170 index
= size_binop (MULT_EXPR
,
7171 TYPE_SIZE_UNIT (vtable_entry_type
),
7173 vtbl
= build2 (PLUS_EXPR
, TREE_TYPE (vtbl
), vtbl
, index
);
7177 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7178 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7179 straighten this out. */
7180 BINFO_VTABLE (binfo
) = tree_cons (rtti_binfo
, vtbl
, BINFO_VTABLE (binfo
));
7181 else if (BINFO_PRIMARY_P (binfo
) && BINFO_VIRTUAL_P (binfo
))
7184 /* For an ordinary vtable, set BINFO_VTABLE. */
7185 BINFO_VTABLE (binfo
) = vtbl
;
7190 /* Construct the initializer for BINFO's virtual function table. BINFO
7191 is part of the hierarchy dominated by T. If we're building a
7192 construction vtable, the ORIG_BINFO is the binfo we should use to
7193 find the actual function pointers to put in the vtable - but they
7194 can be overridden on the path to most-derived in the graph that
7195 ORIG_BINFO belongs. Otherwise,
7196 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7197 BINFO that should be indicated by the RTTI information in the
7198 vtable; it will be a base class of T, rather than T itself, if we
7199 are building a construction vtable.
7201 The value returned is a TREE_LIST suitable for wrapping in a
7202 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7203 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7204 number of non-function entries in the vtable.
7206 It might seem that this function should never be called with a
7207 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7208 base is always subsumed by a derived class vtable. However, when
7209 we are building construction vtables, we do build vtables for
7210 primary bases; we need these while the primary base is being
7214 build_vtbl_initializer (tree binfo
,
7218 int* non_fn_entries_p
)
7227 /* Initialize VID. */
7228 memset (&vid
, 0, sizeof (vid
));
7231 vid
.rtti_binfo
= rtti_binfo
;
7232 vid
.last_init
= &vid
.inits
;
7233 vid
.primary_vtbl_p
= (binfo
== TYPE_BINFO (t
));
7234 vid
.ctor_vtbl_p
= !same_type_p (BINFO_TYPE (rtti_binfo
), t
);
7235 vid
.generate_vcall_entries
= true;
7236 /* The first vbase or vcall offset is at index -3 in the vtable. */
7237 vid
.index
= ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
7239 /* Add entries to the vtable for RTTI. */
7240 build_rtti_vtbl_entries (binfo
, &vid
);
7242 /* Create an array for keeping track of the functions we've
7243 processed. When we see multiple functions with the same
7244 signature, we share the vcall offsets. */
7245 VARRAY_TREE_INIT (vid
.fns
, 32, "fns");
7246 /* Add the vcall and vbase offset entries. */
7247 build_vcall_and_vbase_vtbl_entries (binfo
, &vid
);
7249 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7250 build_vbase_offset_vtbl_entries. */
7251 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
7252 VEC_iterate (tree
, vbases
, ix
, vbinfo
); ix
++)
7253 BINFO_VTABLE_PATH_MARKED (vbinfo
) = 0;
7255 /* If the target requires padding between data entries, add that now. */
7256 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE
> 1)
7260 for (prev
= &vid
.inits
; (cur
= *prev
); prev
= &TREE_CHAIN (cur
))
7265 for (i
= 1; i
< TARGET_VTABLE_DATA_ENTRY_DISTANCE
; ++i
)
7266 add
= tree_cons (NULL_TREE
,
7267 build1 (NOP_EXPR
, vtable_entry_type
,
7274 if (non_fn_entries_p
)
7275 *non_fn_entries_p
= list_length (vid
.inits
);
7277 /* Go through all the ordinary virtual functions, building up
7279 vfun_inits
= NULL_TREE
;
7280 for (v
= BINFO_VIRTUALS (orig_binfo
); v
; v
= TREE_CHAIN (v
))
7284 tree fn
, fn_original
;
7285 tree init
= NULL_TREE
;
7289 if (DECL_THUNK_P (fn
))
7291 if (!DECL_NAME (fn
))
7293 if (THUNK_ALIAS (fn
))
7295 fn
= THUNK_ALIAS (fn
);
7298 fn_original
= THUNK_TARGET (fn
);
7301 /* If the only definition of this function signature along our
7302 primary base chain is from a lost primary, this vtable slot will
7303 never be used, so just zero it out. This is important to avoid
7304 requiring extra thunks which cannot be generated with the function.
7306 We first check this in update_vtable_entry_for_fn, so we handle
7307 restored primary bases properly; we also need to do it here so we
7308 zero out unused slots in ctor vtables, rather than filling themff
7309 with erroneous values (though harmless, apart from relocation
7311 for (b
= binfo
; ; b
= get_primary_binfo (b
))
7313 /* We found a defn before a lost primary; go ahead as normal. */
7314 if (look_for_overrides_here (BINFO_TYPE (b
), fn_original
))
7317 /* The nearest definition is from a lost primary; clear the
7319 if (BINFO_LOST_PRIMARY_P (b
))
7321 init
= size_zero_node
;
7328 /* Pull the offset for `this', and the function to call, out of
7330 delta
= BV_DELTA (v
);
7331 vcall_index
= BV_VCALL_INDEX (v
);
7333 gcc_assert (TREE_CODE (delta
) == INTEGER_CST
);
7334 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
7336 /* You can't call an abstract virtual function; it's abstract.
7337 So, we replace these functions with __pure_virtual. */
7338 if (DECL_PURE_VIRTUAL_P (fn_original
))
7340 else if (!integer_zerop (delta
) || vcall_index
)
7342 fn
= make_thunk (fn
, /*this_adjusting=*/1, delta
, vcall_index
);
7343 if (!DECL_NAME (fn
))
7346 /* Take the address of the function, considering it to be of an
7347 appropriate generic type. */
7348 init
= build1 (ADDR_EXPR
, vfunc_ptr_type_node
, fn
);
7351 /* And add it to the chain of initializers. */
7352 if (TARGET_VTABLE_USES_DESCRIPTORS
)
7355 if (init
== size_zero_node
)
7356 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
7357 vfun_inits
= tree_cons (NULL_TREE
, init
, vfun_inits
);
7359 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
7361 tree fdesc
= build2 (FDESC_EXPR
, vfunc_ptr_type_node
,
7362 TREE_OPERAND (init
, 0),
7363 build_int_cst (NULL_TREE
, i
));
7364 TREE_CONSTANT (fdesc
) = 1;
7365 TREE_INVARIANT (fdesc
) = 1;
7367 vfun_inits
= tree_cons (NULL_TREE
, fdesc
, vfun_inits
);
7371 vfun_inits
= tree_cons (NULL_TREE
, init
, vfun_inits
);
7374 /* The initializers for virtual functions were built up in reverse
7375 order; straighten them out now. */
7376 vfun_inits
= nreverse (vfun_inits
);
7378 /* The negative offset initializers are also in reverse order. */
7379 vid
.inits
= nreverse (vid
.inits
);
7381 /* Chain the two together. */
7382 return chainon (vid
.inits
, vfun_inits
);
7385 /* Adds to vid->inits the initializers for the vbase and vcall
7386 offsets in BINFO, which is in the hierarchy dominated by T. */
7389 build_vcall_and_vbase_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
7393 /* If this is a derived class, we must first create entries
7394 corresponding to the primary base class. */
7395 b
= get_primary_binfo (binfo
);
7397 build_vcall_and_vbase_vtbl_entries (b
, vid
);
7399 /* Add the vbase entries for this base. */
7400 build_vbase_offset_vtbl_entries (binfo
, vid
);
7401 /* Add the vcall entries for this base. */
7402 build_vcall_offset_vtbl_entries (binfo
, vid
);
7405 /* Returns the initializers for the vbase offset entries in the vtable
7406 for BINFO (which is part of the class hierarchy dominated by T), in
7407 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7408 where the next vbase offset will go. */
7411 build_vbase_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
7415 tree non_primary_binfo
;
7417 /* If there are no virtual baseclasses, then there is nothing to
7419 if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo
)))
7424 /* We might be a primary base class. Go up the inheritance hierarchy
7425 until we find the most derived class of which we are a primary base:
7426 it is the offset of that which we need to use. */
7427 non_primary_binfo
= binfo
;
7428 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
7432 /* If we have reached a virtual base, then it must be a primary
7433 base (possibly multi-level) of vid->binfo, or we wouldn't
7434 have called build_vcall_and_vbase_vtbl_entries for it. But it
7435 might be a lost primary, so just skip down to vid->binfo. */
7436 if (BINFO_VIRTUAL_P (non_primary_binfo
))
7438 non_primary_binfo
= vid
->binfo
;
7442 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
7443 if (get_primary_binfo (b
) != non_primary_binfo
)
7445 non_primary_binfo
= b
;
7448 /* Go through the virtual bases, adding the offsets. */
7449 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
7451 vbase
= TREE_CHAIN (vbase
))
7456 if (!BINFO_VIRTUAL_P (vbase
))
7459 /* Find the instance of this virtual base in the complete
7461 b
= copied_binfo (vbase
, binfo
);
7463 /* If we've already got an offset for this virtual base, we
7464 don't need another one. */
7465 if (BINFO_VTABLE_PATH_MARKED (b
))
7467 BINFO_VTABLE_PATH_MARKED (b
) = 1;
7469 /* Figure out where we can find this vbase offset. */
7470 delta
= size_binop (MULT_EXPR
,
7473 TYPE_SIZE_UNIT (vtable_entry_type
)));
7474 if (vid
->primary_vtbl_p
)
7475 BINFO_VPTR_FIELD (b
) = delta
;
7477 if (binfo
!= TYPE_BINFO (t
))
7478 /* The vbase offset had better be the same. */
7479 gcc_assert (tree_int_cst_equal (delta
, BINFO_VPTR_FIELD (vbase
)));
7481 /* The next vbase will come at a more negative offset. */
7482 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
7483 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
7485 /* The initializer is the delta from BINFO to this virtual base.
7486 The vbase offsets go in reverse inheritance-graph order, and
7487 we are walking in inheritance graph order so these end up in
7489 delta
= size_diffop (BINFO_OFFSET (b
), BINFO_OFFSET (non_primary_binfo
));
7492 = build_tree_list (NULL_TREE
,
7493 fold (build1 (NOP_EXPR
,
7496 vid
->last_init
= &TREE_CHAIN (*vid
->last_init
);
7500 /* Adds the initializers for the vcall offset entries in the vtable
7501 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7505 build_vcall_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
7507 /* We only need these entries if this base is a virtual base. We
7508 compute the indices -- but do not add to the vtable -- when
7509 building the main vtable for a class. */
7510 if (BINFO_VIRTUAL_P (binfo
) || binfo
== TYPE_BINFO (vid
->derived
))
7512 /* We need a vcall offset for each of the virtual functions in this
7513 vtable. For example:
7515 class A { virtual void f (); };
7516 class B1 : virtual public A { virtual void f (); };
7517 class B2 : virtual public A { virtual void f (); };
7518 class C: public B1, public B2 { virtual void f (); };
7520 A C object has a primary base of B1, which has a primary base of A. A
7521 C also has a secondary base of B2, which no longer has a primary base
7522 of A. So the B2-in-C construction vtable needs a secondary vtable for
7523 A, which will adjust the A* to a B2* to call f. We have no way of
7524 knowing what (or even whether) this offset will be when we define B2,
7525 so we store this "vcall offset" in the A sub-vtable and look it up in
7526 a "virtual thunk" for B2::f.
7528 We need entries for all the functions in our primary vtable and
7529 in our non-virtual bases' secondary vtables. */
7531 /* If we are just computing the vcall indices -- but do not need
7532 the actual entries -- not that. */
7533 if (!BINFO_VIRTUAL_P (binfo
))
7534 vid
->generate_vcall_entries
= false;
7535 /* Now, walk through the non-virtual bases, adding vcall offsets. */
7536 add_vcall_offset_vtbl_entries_r (binfo
, vid
);
7540 /* Build vcall offsets, starting with those for BINFO. */
7543 add_vcall_offset_vtbl_entries_r (tree binfo
, vtbl_init_data
* vid
)
7549 /* Don't walk into virtual bases -- except, of course, for the
7550 virtual base for which we are building vcall offsets. Any
7551 primary virtual base will have already had its offsets generated
7552 through the recursion in build_vcall_and_vbase_vtbl_entries. */
7553 if (BINFO_VIRTUAL_P (binfo
) && vid
->vbase
!= binfo
)
7556 /* If BINFO has a primary base, process it first. */
7557 primary_binfo
= get_primary_binfo (binfo
);
7559 add_vcall_offset_vtbl_entries_r (primary_binfo
, vid
);
7561 /* Add BINFO itself to the list. */
7562 add_vcall_offset_vtbl_entries_1 (binfo
, vid
);
7564 /* Scan the non-primary bases of BINFO. */
7565 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
7566 if (base_binfo
!= primary_binfo
)
7567 add_vcall_offset_vtbl_entries_r (base_binfo
, vid
);
7570 /* Called from build_vcall_offset_vtbl_entries_r. */
7573 add_vcall_offset_vtbl_entries_1 (tree binfo
, vtbl_init_data
* vid
)
7575 /* Make entries for the rest of the virtuals. */
7576 if (abi_version_at_least (2))
7580 /* The ABI requires that the methods be processed in declaration
7581 order. G++ 3.2 used the order in the vtable. */
7582 for (orig_fn
= TYPE_METHODS (BINFO_TYPE (binfo
));
7584 orig_fn
= TREE_CHAIN (orig_fn
))
7585 if (DECL_VINDEX (orig_fn
))
7586 add_vcall_offset (orig_fn
, binfo
, vid
);
7590 tree derived_virtuals
;
7593 /* If BINFO is a primary base, the most derived class which has
7594 BINFO as a primary base; otherwise, just BINFO. */
7595 tree non_primary_binfo
;
7597 /* We might be a primary base class. Go up the inheritance hierarchy
7598 until we find the most derived class of which we are a primary base:
7599 it is the BINFO_VIRTUALS there that we need to consider. */
7600 non_primary_binfo
= binfo
;
7601 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
7605 /* If we have reached a virtual base, then it must be vid->vbase,
7606 because we ignore other virtual bases in
7607 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
7608 base (possibly multi-level) of vid->binfo, or we wouldn't
7609 have called build_vcall_and_vbase_vtbl_entries for it. But it
7610 might be a lost primary, so just skip down to vid->binfo. */
7611 if (BINFO_VIRTUAL_P (non_primary_binfo
))
7613 gcc_assert (non_primary_binfo
== vid
->vbase
);
7614 non_primary_binfo
= vid
->binfo
;
7618 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
7619 if (get_primary_binfo (b
) != non_primary_binfo
)
7621 non_primary_binfo
= b
;
7624 if (vid
->ctor_vtbl_p
)
7625 /* For a ctor vtable we need the equivalent binfo within the hierarchy
7626 where rtti_binfo is the most derived type. */
7628 = original_binfo (non_primary_binfo
, vid
->rtti_binfo
);
7630 for (base_virtuals
= BINFO_VIRTUALS (binfo
),
7631 derived_virtuals
= BINFO_VIRTUALS (non_primary_binfo
),
7632 orig_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
7634 base_virtuals
= TREE_CHAIN (base_virtuals
),
7635 derived_virtuals
= TREE_CHAIN (derived_virtuals
),
7636 orig_virtuals
= TREE_CHAIN (orig_virtuals
))
7640 /* Find the declaration that originally caused this function to
7641 be present in BINFO_TYPE (binfo). */
7642 orig_fn
= BV_FN (orig_virtuals
);
7644 /* When processing BINFO, we only want to generate vcall slots for
7645 function slots introduced in BINFO. So don't try to generate
7646 one if the function isn't even defined in BINFO. */
7647 if (!same_type_p (DECL_CONTEXT (orig_fn
), BINFO_TYPE (binfo
)))
7650 add_vcall_offset (orig_fn
, binfo
, vid
);
7655 /* Add a vcall offset entry for ORIG_FN to the vtable. */
7658 add_vcall_offset (tree orig_fn
, tree binfo
, vtbl_init_data
*vid
)
7663 /* If there is already an entry for a function with the same
7664 signature as FN, then we do not need a second vcall offset.
7665 Check the list of functions already present in the derived
7667 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (vid
->fns
); ++i
)
7671 derived_entry
= VARRAY_TREE (vid
->fns
, i
);
7672 if (same_signature_p (derived_entry
, orig_fn
)
7673 /* We only use one vcall offset for virtual destructors,
7674 even though there are two virtual table entries. */
7675 || (DECL_DESTRUCTOR_P (derived_entry
)
7676 && DECL_DESTRUCTOR_P (orig_fn
)))
7680 /* If we are building these vcall offsets as part of building
7681 the vtable for the most derived class, remember the vcall
7683 if (vid
->binfo
== TYPE_BINFO (vid
->derived
))
7685 tree_pair_p elt
= VEC_safe_push (tree_pair_s
,
7686 CLASSTYPE_VCALL_INDICES (vid
->derived
),
7688 elt
->purpose
= orig_fn
;
7689 elt
->value
= vid
->index
;
7692 /* The next vcall offset will be found at a more negative
7694 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
7695 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
7697 /* Keep track of this function. */
7698 VARRAY_PUSH_TREE (vid
->fns
, orig_fn
);
7700 if (vid
->generate_vcall_entries
)
7705 /* Find the overriding function. */
7706 fn
= find_final_overrider (vid
->rtti_binfo
, binfo
, orig_fn
);
7707 if (fn
== error_mark_node
)
7708 vcall_offset
= build1 (NOP_EXPR
, vtable_entry_type
,
7712 base
= TREE_VALUE (fn
);
7714 /* The vbase we're working on is a primary base of
7715 vid->binfo. But it might be a lost primary, so its
7716 BINFO_OFFSET might be wrong, so we just use the
7717 BINFO_OFFSET from vid->binfo. */
7718 vcall_offset
= size_diffop (BINFO_OFFSET (base
),
7719 BINFO_OFFSET (vid
->binfo
));
7720 vcall_offset
= fold (build1 (NOP_EXPR
, vtable_entry_type
,
7723 /* Add the initializer to the vtable. */
7724 *vid
->last_init
= build_tree_list (NULL_TREE
, vcall_offset
);
7725 vid
->last_init
= &TREE_CHAIN (*vid
->last_init
);
7729 /* Return vtbl initializers for the RTTI entries corresponding to the
7730 BINFO's vtable. The RTTI entries should indicate the object given
7731 by VID->rtti_binfo. */
7734 build_rtti_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
7743 basetype
= BINFO_TYPE (binfo
);
7744 t
= BINFO_TYPE (vid
->rtti_binfo
);
7746 /* To find the complete object, we will first convert to our most
7747 primary base, and then add the offset in the vtbl to that value. */
7749 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b
))
7750 && !BINFO_LOST_PRIMARY_P (b
))
7754 primary_base
= get_primary_binfo (b
);
7755 gcc_assert (BINFO_PRIMARY_P (primary_base
)
7756 && BINFO_INHERITANCE_CHAIN (primary_base
) == b
);
7759 offset
= size_diffop (BINFO_OFFSET (vid
->rtti_binfo
), BINFO_OFFSET (b
));
7761 /* The second entry is the address of the typeinfo object. */
7763 decl
= build_address (get_tinfo_decl (t
));
7765 decl
= integer_zero_node
;
7767 /* Convert the declaration to a type that can be stored in the
7769 init
= build_nop (vfunc_ptr_type_node
, decl
);
7770 *vid
->last_init
= build_tree_list (NULL_TREE
, init
);
7771 vid
->last_init
= &TREE_CHAIN (*vid
->last_init
);
7773 /* Add the offset-to-top entry. It comes earlier in the vtable that
7774 the the typeinfo entry. Convert the offset to look like a
7775 function pointer, so that we can put it in the vtable. */
7776 init
= build_nop (vfunc_ptr_type_node
, offset
);
7777 *vid
->last_init
= build_tree_list (NULL_TREE
, init
);
7778 vid
->last_init
= &TREE_CHAIN (*vid
->last_init
);
7781 /* Fold a OBJ_TYPE_REF expression to the address of a function.
7782 KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). */
7785 cp_fold_obj_type_ref (tree ref
, tree known_type
)
7787 HOST_WIDE_INT index
= tree_low_cst (OBJ_TYPE_REF_TOKEN (ref
), 1);
7788 HOST_WIDE_INT i
= 0;
7789 tree v
= BINFO_VIRTUALS (TYPE_BINFO (known_type
));
7794 i
+= (TARGET_VTABLE_USES_DESCRIPTORS
7795 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1);
7801 #ifdef ENABLE_CHECKING
7802 gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref
),
7803 DECL_VINDEX (fndecl
)));
7806 return build_address (fndecl
);