1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987-2013 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* High-level class interface. */
26 #include "coretypes.h"
29 #include "stringpool.h"
30 #include "stor-layout.h"
32 #include "pointer-set.h"
33 #include "hash-table.h"
41 #include "splay-tree.h"
45 /* The number of nested classes being processed. If we are not in the
46 scope of any class, this is zero. */
48 int current_class_depth
;
50 /* In order to deal with nested classes, we keep a stack of classes.
51 The topmost entry is the innermost class, and is the entry at index
52 CURRENT_CLASS_DEPTH */
54 typedef struct class_stack_node
{
55 /* The name of the class. */
58 /* The _TYPE node for the class. */
61 /* The access specifier pending for new declarations in the scope of
65 /* If were defining TYPE, the names used in this class. */
66 splay_tree names_used
;
68 /* Nonzero if this class is no longer open, because of a call to
71 }* class_stack_node_t
;
73 typedef struct vtbl_init_data_s
75 /* The base for which we're building initializers. */
77 /* The type of the most-derived type. */
79 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
80 unless ctor_vtbl_p is true. */
82 /* The negative-index vtable initializers built up so far. These
83 are in order from least negative index to most negative index. */
84 vec
<constructor_elt
, va_gc
> *inits
;
85 /* The binfo for the virtual base for which we're building
86 vcall offset initializers. */
88 /* The functions in vbase for which we have already provided vcall
90 vec
<tree
, va_gc
> *fns
;
91 /* The vtable index of the next vcall or vbase offset. */
93 /* Nonzero if we are building the initializer for the primary
96 /* Nonzero if we are building the initializer for a construction
99 /* True when adding vcall offset entries to the vtable. False when
100 merely computing the indices. */
101 bool generate_vcall_entries
;
104 /* The type of a function passed to walk_subobject_offsets. */
105 typedef int (*subobject_offset_fn
) (tree
, tree
, splay_tree
);
107 /* The stack itself. This is a dynamically resized array. The
108 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
109 static int current_class_stack_size
;
110 static class_stack_node_t current_class_stack
;
112 /* The size of the largest empty class seen in this translation unit. */
113 static GTY (()) tree sizeof_biggest_empty_class
;
115 /* An array of all local classes present in this translation unit, in
116 declaration order. */
117 vec
<tree
, va_gc
> *local_classes
;
119 static tree
get_vfield_name (tree
);
120 static void finish_struct_anon (tree
);
121 static tree
get_vtable_name (tree
);
122 static tree
get_basefndecls (tree
, tree
);
123 static int build_primary_vtable (tree
, tree
);
124 static int build_secondary_vtable (tree
);
125 static void finish_vtbls (tree
);
126 static void modify_vtable_entry (tree
, tree
, tree
, tree
, tree
*);
127 static void finish_struct_bits (tree
);
128 static int alter_access (tree
, tree
, tree
);
129 static void handle_using_decl (tree
, tree
);
130 static tree
dfs_modify_vtables (tree
, void *);
131 static tree
modify_all_vtables (tree
, tree
);
132 static void determine_primary_bases (tree
);
133 static void finish_struct_methods (tree
);
134 static void maybe_warn_about_overly_private_class (tree
);
135 static int method_name_cmp (const void *, const void *);
136 static int resort_method_name_cmp (const void *, const void *);
137 static void add_implicitly_declared_members (tree
, tree
*, int, int);
138 static tree
fixed_type_or_null (tree
, int *, int *);
139 static tree
build_simple_base_path (tree expr
, tree binfo
);
140 static tree
build_vtbl_ref_1 (tree
, tree
);
141 static void build_vtbl_initializer (tree
, tree
, tree
, tree
, int *,
142 vec
<constructor_elt
, va_gc
> **);
143 static int count_fields (tree
);
144 static int add_fields_to_record_type (tree
, struct sorted_fields_type
*, int);
145 static void insert_into_classtype_sorted_fields (tree
, tree
, int);
146 static bool check_bitfield_decl (tree
);
147 static void check_field_decl (tree
, tree
, int *, int *, int *);
148 static void check_field_decls (tree
, tree
*, int *, int *);
149 static tree
*build_base_field (record_layout_info
, tree
, splay_tree
, tree
*);
150 static void build_base_fields (record_layout_info
, splay_tree
, tree
*);
151 static void check_methods (tree
);
152 static void remove_zero_width_bit_fields (tree
);
153 static void check_bases (tree
, int *, int *);
154 static void check_bases_and_members (tree
);
155 static tree
create_vtable_ptr (tree
, tree
*);
156 static void include_empty_classes (record_layout_info
);
157 static void layout_class_type (tree
, tree
*);
158 static void propagate_binfo_offsets (tree
, tree
);
159 static void layout_virtual_bases (record_layout_info
, splay_tree
);
160 static void build_vbase_offset_vtbl_entries (tree
, vtbl_init_data
*);
161 static void add_vcall_offset_vtbl_entries_r (tree
, vtbl_init_data
*);
162 static void add_vcall_offset_vtbl_entries_1 (tree
, vtbl_init_data
*);
163 static void build_vcall_offset_vtbl_entries (tree
, vtbl_init_data
*);
164 static void add_vcall_offset (tree
, tree
, vtbl_init_data
*);
165 static void layout_vtable_decl (tree
, int);
166 static tree
dfs_find_final_overrider_pre (tree
, void *);
167 static tree
dfs_find_final_overrider_post (tree
, void *);
168 static tree
find_final_overrider (tree
, tree
, tree
);
169 static int make_new_vtable (tree
, tree
);
170 static tree
get_primary_binfo (tree
);
171 static int maybe_indent_hierarchy (FILE *, int, int);
172 static tree
dump_class_hierarchy_r (FILE *, int, tree
, tree
, int);
173 static void dump_class_hierarchy (tree
);
174 static void dump_class_hierarchy_1 (FILE *, int, tree
);
175 static void dump_array (FILE *, tree
);
176 static void dump_vtable (tree
, tree
, tree
);
177 static void dump_vtt (tree
, tree
);
178 static void dump_thunk (FILE *, int, tree
);
179 static tree
build_vtable (tree
, tree
, tree
);
180 static void initialize_vtable (tree
, vec
<constructor_elt
, va_gc
> *);
181 static void layout_nonempty_base_or_field (record_layout_info
,
182 tree
, tree
, splay_tree
);
183 static tree
end_of_class (tree
, int);
184 static bool layout_empty_base (record_layout_info
, tree
, tree
, splay_tree
);
185 static void accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
,
186 vec
<constructor_elt
, va_gc
> **);
187 static void dfs_accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
,
188 vec
<constructor_elt
, va_gc
> **);
189 static void build_rtti_vtbl_entries (tree
, vtbl_init_data
*);
190 static void build_vcall_and_vbase_vtbl_entries (tree
, vtbl_init_data
*);
191 static void clone_constructors_and_destructors (tree
);
192 static tree
build_clone (tree
, tree
);
193 static void update_vtable_entry_for_fn (tree
, tree
, tree
, tree
*, unsigned);
194 static void build_ctor_vtbl_group (tree
, tree
);
195 static void build_vtt (tree
);
196 static tree
binfo_ctor_vtable (tree
);
197 static void build_vtt_inits (tree
, tree
, vec
<constructor_elt
, va_gc
> **,
199 static tree
dfs_build_secondary_vptr_vtt_inits (tree
, void *);
200 static tree
dfs_fixup_binfo_vtbls (tree
, void *);
201 static int record_subobject_offset (tree
, tree
, splay_tree
);
202 static int check_subobject_offset (tree
, tree
, splay_tree
);
203 static int walk_subobject_offsets (tree
, subobject_offset_fn
,
204 tree
, splay_tree
, tree
, int);
205 static void record_subobject_offsets (tree
, tree
, splay_tree
, bool);
206 static int layout_conflict_p (tree
, tree
, splay_tree
, int);
207 static int splay_tree_compare_integer_csts (splay_tree_key k1
,
209 static void warn_about_ambiguous_bases (tree
);
210 static bool type_requires_array_cookie (tree
);
211 static bool contains_empty_class_p (tree
);
212 static bool base_derived_from (tree
, tree
);
213 static int empty_base_at_nonzero_offset_p (tree
, tree
, splay_tree
);
214 static tree
end_of_base (tree
);
215 static tree
get_vcall_index (tree
, tree
);
217 /* Variables shared between class.c and call.c. */
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;
227 /* Convert to or from a base subobject. EXPR is an expression of type
228 `A' or `A*', an expression of type `B' or `B*' is returned. To
229 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
230 the B base instance within A. To convert base A to derived B, CODE
231 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
232 In this latter case, A must not be a morally virtual base of B.
233 NONNULL is true if EXPR is known to be non-NULL (this is only
234 needed when EXPR is of pointer type). CV qualifiers are preserved
238 build_base_path (enum tree_code code
,
242 tsubst_flags_t complain
)
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
= TYPE_PTR_P (TREE_TYPE (expr
));
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 if (code
== PLUS_EXPR
273 && !SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo
), probe
))
275 /* This can happen when adjust_result_of_qualified_name_lookup can't
276 find a unique base binfo in a call to a member function. We
277 couldn't give the diagnostic then since we might have been calling
278 a static member function, so we do it now. */
279 if (complain
& tf_error
)
281 tree base
= lookup_base (probe
, BINFO_TYPE (d_binfo
),
282 ba_unique
, NULL
, complain
);
283 gcc_assert (base
== error_mark_node
);
285 return error_mark_node
;
288 gcc_assert ((code
== MINUS_EXPR
289 && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), probe
))
290 || code
== PLUS_EXPR
);
292 if (binfo
== d_binfo
)
296 if (code
== MINUS_EXPR
&& v_binfo
)
298 if (complain
& tf_error
)
300 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (v_binfo
)))
303 error ("cannot convert from pointer to base class %qT to "
304 "pointer to derived class %qT because the base is "
305 "virtual", BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
));
307 error ("cannot convert from base class %qT to derived "
308 "class %qT because the base is virtual",
309 BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
));
314 error ("cannot convert from pointer to base class %qT to "
315 "pointer to derived class %qT via virtual base %qT",
316 BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
),
317 BINFO_TYPE (v_binfo
));
319 error ("cannot convert from base class %qT to derived "
320 "class %qT via virtual base %qT", BINFO_TYPE (binfo
),
321 BINFO_TYPE (d_binfo
), BINFO_TYPE (v_binfo
));
324 return error_mark_node
;
328 /* This must happen before the call to save_expr. */
329 expr
= cp_build_addr_expr (expr
, complain
);
331 expr
= mark_rvalue_use (expr
);
333 offset
= BINFO_OFFSET (binfo
);
334 fixed_type_p
= resolves_to_fixed_type_p (expr
, &nonnull
);
335 target_type
= code
== PLUS_EXPR
? BINFO_TYPE (binfo
) : BINFO_TYPE (d_binfo
);
336 /* TARGET_TYPE has been extracted from BINFO, and, is therefore always
337 cv-unqualified. Extract the cv-qualifiers from EXPR so that the
338 expression returned matches the input. */
339 target_type
= cp_build_qualified_type
340 (target_type
, cp_type_quals (TREE_TYPE (TREE_TYPE (expr
))));
341 ptr_target_type
= build_pointer_type (target_type
);
343 /* Do we need to look in the vtable for the real offset? */
344 virtual_access
= (v_binfo
&& fixed_type_p
<= 0);
346 /* Don't bother with the calculations inside sizeof; they'll ICE if the
347 source type is incomplete and the pointer value doesn't matter. In a
348 template (even in fold_non_dependent_expr), we don't have vtables set
349 up properly yet, and the value doesn't matter there either; we're just
350 interested in the result of overload resolution. */
351 if (cp_unevaluated_operand
!= 0
352 || in_template_function ())
354 expr
= build_nop (ptr_target_type
, expr
);
356 expr
= build_indirect_ref (EXPR_LOCATION (expr
), expr
, RO_NULL
);
360 /* If we're in an NSDMI, we don't have the full constructor context yet
361 that we need for converting to a virtual base, so just build a stub
362 CONVERT_EXPR and expand it later in bot_replace. */
363 if (virtual_access
&& fixed_type_p
< 0
364 && current_scope () != current_function_decl
)
366 expr
= build1 (CONVERT_EXPR
, ptr_target_type
, expr
);
367 CONVERT_EXPR_VBASE_PATH (expr
) = true;
369 expr
= build_indirect_ref (EXPR_LOCATION (expr
), expr
, RO_NULL
);
373 /* Do we need to check for a null pointer? */
374 if (want_pointer
&& !nonnull
)
376 /* If we know the conversion will not actually change the value
377 of EXPR, then we can avoid testing the expression for NULL.
378 We have to avoid generating a COMPONENT_REF for a base class
379 field, because other parts of the compiler know that such
380 expressions are always non-NULL. */
381 if (!virtual_access
&& integer_zerop (offset
))
382 return build_nop (ptr_target_type
, expr
);
383 null_test
= error_mark_node
;
386 /* Protect against multiple evaluation if necessary. */
387 if (TREE_SIDE_EFFECTS (expr
) && (null_test
|| virtual_access
))
388 expr
= save_expr (expr
);
390 /* Now that we've saved expr, build the real null test. */
393 tree zero
= cp_convert (TREE_TYPE (expr
), nullptr_node
, complain
);
394 null_test
= fold_build2_loc (input_location
, NE_EXPR
, boolean_type_node
,
398 /* If this is a simple base reference, express it as a COMPONENT_REF. */
399 if (code
== PLUS_EXPR
&& !virtual_access
400 /* We don't build base fields for empty bases, and they aren't very
401 interesting to the optimizers anyway. */
404 expr
= cp_build_indirect_ref (expr
, RO_NULL
, complain
);
405 expr
= build_simple_base_path (expr
, binfo
);
407 expr
= build_address (expr
);
408 target_type
= TREE_TYPE (expr
);
414 /* Going via virtual base V_BINFO. We need the static offset
415 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
416 V_BINFO. That offset is an entry in D_BINFO's vtable. */
419 if (fixed_type_p
< 0 && in_base_initializer
)
421 /* In a base member initializer, we cannot rely on the
422 vtable being set up. We have to indirect via the
426 t
= TREE_TYPE (TYPE_VFIELD (current_class_type
));
427 t
= build_pointer_type (t
);
428 v_offset
= convert (t
, current_vtt_parm
);
429 v_offset
= cp_build_indirect_ref (v_offset
, RO_NULL
, complain
);
432 v_offset
= build_vfield_ref (cp_build_indirect_ref (expr
, RO_NULL
,
434 TREE_TYPE (TREE_TYPE (expr
)));
436 v_offset
= fold_build_pointer_plus (v_offset
, BINFO_VPTR_FIELD (v_binfo
));
437 v_offset
= build1 (NOP_EXPR
,
438 build_pointer_type (ptrdiff_type_node
),
440 v_offset
= cp_build_indirect_ref (v_offset
, RO_NULL
, complain
);
441 TREE_CONSTANT (v_offset
) = 1;
443 offset
= convert_to_integer (ptrdiff_type_node
,
444 size_diffop_loc (input_location
, offset
,
445 BINFO_OFFSET (v_binfo
)));
447 if (!integer_zerop (offset
))
448 v_offset
= build2 (code
, ptrdiff_type_node
, v_offset
, offset
);
450 if (fixed_type_p
< 0)
451 /* Negative fixed_type_p means this is a constructor or destructor;
452 virtual base layout is fixed in in-charge [cd]tors, but not in
454 offset
= build3 (COND_EXPR
, ptrdiff_type_node
,
455 build2 (EQ_EXPR
, boolean_type_node
,
456 current_in_charge_parm
, integer_zero_node
),
458 convert_to_integer (ptrdiff_type_node
,
459 BINFO_OFFSET (binfo
)));
465 target_type
= ptr_target_type
;
467 expr
= build1 (NOP_EXPR
, ptr_target_type
, expr
);
469 if (!integer_zerop (offset
))
471 offset
= fold_convert (sizetype
, offset
);
472 if (code
== MINUS_EXPR
)
473 offset
= fold_build1_loc (input_location
, NEGATE_EXPR
, sizetype
, offset
);
474 expr
= fold_build_pointer_plus (expr
, offset
);
480 expr
= cp_build_indirect_ref (expr
, RO_NULL
, complain
);
484 expr
= fold_build3_loc (input_location
, COND_EXPR
, target_type
, null_test
, expr
,
485 build_zero_cst (target_type
));
490 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
491 Perform a derived-to-base conversion by recursively building up a
492 sequence of COMPONENT_REFs to the appropriate base fields. */
495 build_simple_base_path (tree expr
, tree binfo
)
497 tree type
= BINFO_TYPE (binfo
);
498 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
501 if (d_binfo
== NULL_TREE
)
505 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)) == type
);
507 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
508 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
509 an lvalue in the front end; only _DECLs and _REFs are lvalues
511 temp
= unary_complex_lvalue (ADDR_EXPR
, expr
);
513 expr
= cp_build_indirect_ref (temp
, RO_NULL
, tf_warning_or_error
);
519 expr
= build_simple_base_path (expr
, d_binfo
);
521 for (field
= TYPE_FIELDS (BINFO_TYPE (d_binfo
));
522 field
; field
= DECL_CHAIN (field
))
523 /* Is this the base field created by build_base_field? */
524 if (TREE_CODE (field
) == FIELD_DECL
525 && DECL_FIELD_IS_BASE (field
)
526 && TREE_TYPE (field
) == type
527 /* If we're looking for a field in the most-derived class,
528 also check the field offset; we can have two base fields
529 of the same type if one is an indirect virtual base and one
530 is a direct non-virtual base. */
531 && (BINFO_INHERITANCE_CHAIN (d_binfo
)
532 || tree_int_cst_equal (byte_position (field
),
533 BINFO_OFFSET (binfo
))))
535 /* We don't use build_class_member_access_expr here, as that
536 has unnecessary checks, and more importantly results in
537 recursive calls to dfs_walk_once. */
538 int type_quals
= cp_type_quals (TREE_TYPE (expr
));
540 expr
= build3 (COMPONENT_REF
,
541 cp_build_qualified_type (type
, type_quals
),
542 expr
, field
, NULL_TREE
);
543 expr
= fold_if_not_in_template (expr
);
545 /* Mark the expression const or volatile, as appropriate.
546 Even though we've dealt with the type above, we still have
547 to mark the expression itself. */
548 if (type_quals
& TYPE_QUAL_CONST
)
549 TREE_READONLY (expr
) = 1;
550 if (type_quals
& TYPE_QUAL_VOLATILE
)
551 TREE_THIS_VOLATILE (expr
) = 1;
556 /* Didn't find the base field?!? */
560 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
561 type is a class type or a pointer to a class type. In the former
562 case, TYPE is also a class type; in the latter it is another
563 pointer type. If CHECK_ACCESS is true, an error message is emitted
564 if TYPE is inaccessible. If OBJECT has pointer type, the value is
565 assumed to be non-NULL. */
568 convert_to_base (tree object
, tree type
, bool check_access
, bool nonnull
,
569 tsubst_flags_t complain
)
574 if (TYPE_PTR_P (TREE_TYPE (object
)))
576 object_type
= TREE_TYPE (TREE_TYPE (object
));
577 type
= TREE_TYPE (type
);
580 object_type
= TREE_TYPE (object
);
582 binfo
= lookup_base (object_type
, type
, check_access
? ba_check
: ba_unique
,
584 if (!binfo
|| binfo
== error_mark_node
)
585 return error_mark_node
;
587 return build_base_path (PLUS_EXPR
, object
, binfo
, nonnull
, complain
);
590 /* EXPR is an expression with unqualified class type. BASE is a base
591 binfo of that class type. Returns EXPR, converted to the BASE
592 type. This function assumes that EXPR is the most derived class;
593 therefore virtual bases can be found at their static offsets. */
596 convert_to_base_statically (tree expr
, tree base
)
600 expr_type
= TREE_TYPE (expr
);
601 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base
), expr_type
))
603 /* If this is a non-empty base, use a COMPONENT_REF. */
604 if (!is_empty_class (BINFO_TYPE (base
)))
605 return build_simple_base_path (expr
, base
);
607 /* We use fold_build2 and fold_convert below to simplify the trees
608 provided to the optimizers. It is not safe to call these functions
609 when processing a template because they do not handle C++-specific
611 gcc_assert (!processing_template_decl
);
612 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
613 if (!integer_zerop (BINFO_OFFSET (base
)))
614 expr
= fold_build_pointer_plus_loc (input_location
,
615 expr
, BINFO_OFFSET (base
));
616 expr
= fold_convert (build_pointer_type (BINFO_TYPE (base
)), expr
);
617 expr
= build_fold_indirect_ref_loc (input_location
, expr
);
625 build_vfield_ref (tree datum
, tree type
)
627 tree vfield
, vcontext
;
629 if (datum
== error_mark_node
)
630 return error_mark_node
;
632 /* First, convert to the requested type. */
633 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum
), type
))
634 datum
= convert_to_base (datum
, type
, /*check_access=*/false,
635 /*nonnull=*/true, tf_warning_or_error
);
637 /* Second, the requested type may not be the owner of its own vptr.
638 If not, convert to the base class that owns it. We cannot use
639 convert_to_base here, because VCONTEXT may appear more than once
640 in the inheritance hierarchy of TYPE, and thus direct conversion
641 between the types may be ambiguous. Following the path back up
642 one step at a time via primary bases avoids the problem. */
643 vfield
= TYPE_VFIELD (type
);
644 vcontext
= DECL_CONTEXT (vfield
);
645 while (!same_type_ignoring_top_level_qualifiers_p (vcontext
, type
))
647 datum
= build_simple_base_path (datum
, CLASSTYPE_PRIMARY_BINFO (type
));
648 type
= TREE_TYPE (datum
);
651 return build3 (COMPONENT_REF
, TREE_TYPE (vfield
), datum
, vfield
, NULL_TREE
);
654 /* Given an object INSTANCE, return an expression which yields the
655 vtable element corresponding to INDEX. There are many special
656 cases for INSTANCE which we take care of here, mainly to avoid
657 creating extra tree nodes when we don't have to. */
660 build_vtbl_ref_1 (tree instance
, tree idx
)
663 tree vtbl
= NULL_TREE
;
665 /* Try to figure out what a reference refers to, and
666 access its virtual function table directly. */
669 tree fixed_type
= fixed_type_or_null (instance
, NULL
, &cdtorp
);
671 tree basetype
= non_reference (TREE_TYPE (instance
));
673 if (fixed_type
&& !cdtorp
)
675 tree binfo
= lookup_base (fixed_type
, basetype
,
676 ba_unique
, NULL
, tf_none
);
677 if (binfo
&& binfo
!= error_mark_node
)
678 vtbl
= unshare_expr (BINFO_VTABLE (binfo
));
682 vtbl
= build_vfield_ref (instance
, basetype
);
684 aref
= build_array_ref (input_location
, vtbl
, idx
);
685 TREE_CONSTANT (aref
) |= TREE_CONSTANT (vtbl
) && TREE_CONSTANT (idx
);
691 build_vtbl_ref (tree instance
, tree idx
)
693 tree aref
= build_vtbl_ref_1 (instance
, idx
);
698 /* Given a stable object pointer INSTANCE_PTR, return an expression which
699 yields a function pointer corresponding to vtable element INDEX. */
702 build_vfn_ref (tree instance_ptr
, tree idx
)
706 aref
= build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr
, RO_NULL
,
707 tf_warning_or_error
),
710 /* When using function descriptors, the address of the
711 vtable entry is treated as a function pointer. */
712 if (TARGET_VTABLE_USES_DESCRIPTORS
)
713 aref
= build1 (NOP_EXPR
, TREE_TYPE (aref
),
714 cp_build_addr_expr (aref
, tf_warning_or_error
));
716 /* Remember this as a method reference, for later devirtualization. */
717 aref
= build3 (OBJ_TYPE_REF
, TREE_TYPE (aref
), aref
, instance_ptr
, idx
);
722 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
723 for the given TYPE. */
726 get_vtable_name (tree type
)
728 return mangle_vtbl_for_type (type
);
731 /* DECL is an entity associated with TYPE, like a virtual table or an
732 implicitly generated constructor. Determine whether or not DECL
733 should have external or internal linkage at the object file
734 level. This routine does not deal with COMDAT linkage and other
735 similar complexities; it simply sets TREE_PUBLIC if it possible for
736 entities in other translation units to contain copies of DECL, in
740 set_linkage_according_to_type (tree
/*type*/, tree decl
)
742 TREE_PUBLIC (decl
) = 1;
743 determine_visibility (decl
);
746 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
747 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
748 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
751 build_vtable (tree class_type
, tree name
, tree vtable_type
)
755 decl
= build_lang_decl (VAR_DECL
, name
, vtable_type
);
756 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
757 now to avoid confusion in mangle_decl. */
758 SET_DECL_ASSEMBLER_NAME (decl
, name
);
759 DECL_CONTEXT (decl
) = class_type
;
760 DECL_ARTIFICIAL (decl
) = 1;
761 TREE_STATIC (decl
) = 1;
762 TREE_READONLY (decl
) = 1;
763 DECL_VIRTUAL_P (decl
) = 1;
764 DECL_ALIGN (decl
) = TARGET_VTABLE_ENTRY_ALIGN
;
765 DECL_VTABLE_OR_VTT_P (decl
) = 1;
766 /* At one time the vtable info was grabbed 2 words at a time. This
767 fails on sparc unless you have 8-byte alignment. (tiemann) */
768 DECL_ALIGN (decl
) = MAX (TYPE_ALIGN (double_type_node
),
770 set_linkage_according_to_type (class_type
, decl
);
771 /* The vtable has not been defined -- yet. */
772 DECL_EXTERNAL (decl
) = 1;
773 DECL_NOT_REALLY_EXTERN (decl
) = 1;
775 /* Mark the VAR_DECL node representing the vtable itself as a
776 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
777 is rather important that such things be ignored because any
778 effort to actually generate DWARF for them will run into
779 trouble when/if we encounter code like:
782 struct S { virtual void member (); };
784 because the artificial declaration of the vtable itself (as
785 manufactured by the g++ front end) will say that the vtable is
786 a static member of `S' but only *after* the debug output for
787 the definition of `S' has already been output. This causes
788 grief because the DWARF entry for the definition of the vtable
789 will try to refer back to an earlier *declaration* of the
790 vtable as a static member of `S' and there won't be one. We
791 might be able to arrange to have the "vtable static member"
792 attached to the member list for `S' before the debug info for
793 `S' get written (which would solve the problem) but that would
794 require more intrusive changes to the g++ front end. */
795 DECL_IGNORED_P (decl
) = 1;
800 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
801 or even complete. If this does not exist, create it. If COMPLETE is
802 nonzero, then complete the definition of it -- that will render it
803 impossible to actually build the vtable, but is useful to get at those
804 which are known to exist in the runtime. */
807 get_vtable_decl (tree type
, int complete
)
811 if (CLASSTYPE_VTABLES (type
))
812 return CLASSTYPE_VTABLES (type
);
814 decl
= build_vtable (type
, get_vtable_name (type
), vtbl_type_node
);
815 CLASSTYPE_VTABLES (type
) = decl
;
819 DECL_EXTERNAL (decl
) = 1;
820 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
826 /* Build the primary virtual function table for TYPE. If BINFO is
827 non-NULL, build the vtable starting with the initial approximation
828 that it is the same as the one which is the head of the association
829 list. Returns a nonzero value if a new vtable is actually
833 build_primary_vtable (tree binfo
, tree type
)
838 decl
= get_vtable_decl (type
, /*complete=*/0);
842 if (BINFO_NEW_VTABLE_MARKED (binfo
))
843 /* We have already created a vtable for this base, so there's
844 no need to do it again. */
847 virtuals
= copy_list (BINFO_VIRTUALS (binfo
));
848 TREE_TYPE (decl
) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo
));
849 DECL_SIZE (decl
) = TYPE_SIZE (TREE_TYPE (decl
));
850 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
854 gcc_assert (TREE_TYPE (decl
) == vtbl_type_node
);
855 virtuals
= NULL_TREE
;
858 if (GATHER_STATISTICS
)
861 n_vtable_elems
+= list_length (virtuals
);
864 /* Initialize the association list for this type, based
865 on our first approximation. */
866 BINFO_VTABLE (TYPE_BINFO (type
)) = decl
;
867 BINFO_VIRTUALS (TYPE_BINFO (type
)) = virtuals
;
868 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type
));
872 /* Give BINFO a new virtual function table which is initialized
873 with a skeleton-copy of its original initialization. The only
874 entry that changes is the `delta' entry, so we can really
875 share a lot of structure.
877 FOR_TYPE is the most derived type which caused this table to
880 Returns nonzero if we haven't met BINFO before.
882 The order in which vtables are built (by calling this function) for
883 an object must remain the same, otherwise a binary incompatibility
887 build_secondary_vtable (tree binfo
)
889 if (BINFO_NEW_VTABLE_MARKED (binfo
))
890 /* We already created a vtable for this base. There's no need to
894 /* Remember that we've created a vtable for this BINFO, so that we
895 don't try to do so again. */
896 SET_BINFO_NEW_VTABLE_MARKED (binfo
);
898 /* Make fresh virtual list, so we can smash it later. */
899 BINFO_VIRTUALS (binfo
) = copy_list (BINFO_VIRTUALS (binfo
));
901 /* Secondary vtables are laid out as part of the same structure as
902 the primary vtable. */
903 BINFO_VTABLE (binfo
) = NULL_TREE
;
907 /* Create a new vtable for BINFO which is the hierarchy dominated by
908 T. Return nonzero if we actually created a new vtable. */
911 make_new_vtable (tree t
, tree binfo
)
913 if (binfo
== TYPE_BINFO (t
))
914 /* In this case, it is *type*'s vtable we are modifying. We start
915 with the approximation that its vtable is that of the
916 immediate base class. */
917 return build_primary_vtable (binfo
, t
);
919 /* This is our very own copy of `basetype' to play with. Later,
920 we will fill in all the virtual functions that override the
921 virtual functions in these base classes which are not defined
922 by the current type. */
923 return build_secondary_vtable (binfo
);
926 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
927 (which is in the hierarchy dominated by T) list FNDECL as its
928 BV_FN. DELTA is the required constant adjustment from the `this'
929 pointer where the vtable entry appears to the `this' required when
930 the function is actually called. */
933 modify_vtable_entry (tree t
,
943 if (fndecl
!= BV_FN (v
)
944 || !tree_int_cst_equal (delta
, BV_DELTA (v
)))
946 /* We need a new vtable for BINFO. */
947 if (make_new_vtable (t
, binfo
))
949 /* If we really did make a new vtable, we also made a copy
950 of the BINFO_VIRTUALS list. Now, we have to find the
951 corresponding entry in that list. */
952 *virtuals
= BINFO_VIRTUALS (binfo
);
953 while (BV_FN (*virtuals
) != BV_FN (v
))
954 *virtuals
= TREE_CHAIN (*virtuals
);
958 BV_DELTA (v
) = delta
;
959 BV_VCALL_INDEX (v
) = NULL_TREE
;
965 /* Add method METHOD to class TYPE. If USING_DECL is non-null, it is
966 the USING_DECL naming METHOD. Returns true if the method could be
967 added to the method vec. */
970 add_method (tree type
, tree method
, tree using_decl
)
974 bool template_conv_p
= false;
976 vec
<tree
, va_gc
> *method_vec
;
978 bool insert_p
= false;
982 if (method
== error_mark_node
)
985 complete_p
= COMPLETE_TYPE_P (type
);
986 conv_p
= DECL_CONV_FN_P (method
);
988 template_conv_p
= (TREE_CODE (method
) == TEMPLATE_DECL
989 && DECL_TEMPLATE_CONV_FN_P (method
));
991 method_vec
= CLASSTYPE_METHOD_VEC (type
);
994 /* Make a new method vector. We start with 8 entries. We must
995 allocate at least two (for constructors and destructors), and
996 we're going to end up with an assignment operator at some
998 vec_alloc (method_vec
, 8);
999 /* Create slots for constructors and destructors. */
1000 method_vec
->quick_push (NULL_TREE
);
1001 method_vec
->quick_push (NULL_TREE
);
1002 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
1005 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
1006 grok_special_member_properties (method
);
1008 /* Constructors and destructors go in special slots. */
1009 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method
))
1010 slot
= CLASSTYPE_CONSTRUCTOR_SLOT
;
1011 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
1013 slot
= CLASSTYPE_DESTRUCTOR_SLOT
;
1015 if (TYPE_FOR_JAVA (type
))
1017 if (!DECL_ARTIFICIAL (method
))
1018 error ("Java class %qT cannot have a destructor", type
);
1019 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
1020 error ("Java class %qT cannot have an implicit non-trivial "
1030 /* See if we already have an entry with this name. */
1031 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1032 vec_safe_iterate (method_vec
, slot
, &m
);
1035 m
= OVL_CURRENT (m
);
1036 if (template_conv_p
)
1038 if (TREE_CODE (m
) == TEMPLATE_DECL
1039 && DECL_TEMPLATE_CONV_FN_P (m
))
1043 if (conv_p
&& !DECL_CONV_FN_P (m
))
1045 if (DECL_NAME (m
) == DECL_NAME (method
))
1051 && !DECL_CONV_FN_P (m
)
1052 && DECL_NAME (m
) > DECL_NAME (method
))
1056 current_fns
= insert_p
? NULL_TREE
: (*method_vec
)[slot
];
1058 /* Check to see if we've already got this method. */
1059 for (fns
= current_fns
; fns
; fns
= OVL_NEXT (fns
))
1061 tree fn
= OVL_CURRENT (fns
);
1067 if (TREE_CODE (fn
) != TREE_CODE (method
))
1070 /* [over.load] Member function declarations with the
1071 same name and the same parameter types cannot be
1072 overloaded if any of them is a static member
1073 function declaration.
1075 [over.load] Member function declarations with the same name and
1076 the same parameter-type-list as well as member function template
1077 declarations with the same name, the same parameter-type-list, and
1078 the same template parameter lists cannot be overloaded if any of
1079 them, but not all, have a ref-qualifier.
1081 [namespace.udecl] When a using-declaration brings names
1082 from a base class into a derived class scope, member
1083 functions in the derived class override and/or hide member
1084 functions with the same name and parameter types in a base
1085 class (rather than conflicting). */
1086 fn_type
= TREE_TYPE (fn
);
1087 method_type
= TREE_TYPE (method
);
1088 parms1
= TYPE_ARG_TYPES (fn_type
);
1089 parms2
= TYPE_ARG_TYPES (method_type
);
1091 /* Compare the quals on the 'this' parm. Don't compare
1092 the whole types, as used functions are treated as
1093 coming from the using class in overload resolution. */
1094 if (! DECL_STATIC_FUNCTION_P (fn
)
1095 && ! DECL_STATIC_FUNCTION_P (method
)
1096 /* Either both or neither need to be ref-qualified for
1097 differing quals to allow overloading. */
1098 && (FUNCTION_REF_QUALIFIED (fn_type
)
1099 == FUNCTION_REF_QUALIFIED (method_type
))
1100 && (type_memfn_quals (fn_type
) != type_memfn_quals (method_type
)
1101 || type_memfn_rqual (fn_type
) != type_memfn_rqual (method_type
)))
1104 /* For templates, the return type and template parameters
1105 must be identical. */
1106 if (TREE_CODE (fn
) == TEMPLATE_DECL
1107 && (!same_type_p (TREE_TYPE (fn_type
),
1108 TREE_TYPE (method_type
))
1109 || !comp_template_parms (DECL_TEMPLATE_PARMS (fn
),
1110 DECL_TEMPLATE_PARMS (method
))))
1113 if (! DECL_STATIC_FUNCTION_P (fn
))
1114 parms1
= TREE_CHAIN (parms1
);
1115 if (! DECL_STATIC_FUNCTION_P (method
))
1116 parms2
= TREE_CHAIN (parms2
);
1118 if (compparms (parms1
, parms2
)
1119 && (!DECL_CONV_FN_P (fn
)
1120 || same_type_p (TREE_TYPE (fn_type
),
1121 TREE_TYPE (method_type
))))
1123 /* For function versions, their parms and types match
1124 but they are not duplicates. Record function versions
1125 as and when they are found. extern "C" functions are
1126 not treated as versions. */
1127 if (TREE_CODE (fn
) == FUNCTION_DECL
1128 && TREE_CODE (method
) == FUNCTION_DECL
1129 && !DECL_EXTERN_C_P (fn
)
1130 && !DECL_EXTERN_C_P (method
)
1131 && targetm
.target_option
.function_versions (fn
, method
))
1133 /* Mark functions as versions if necessary. Modify the mangled
1134 decl name if necessary. */
1135 if (!DECL_FUNCTION_VERSIONED (fn
))
1137 DECL_FUNCTION_VERSIONED (fn
) = 1;
1138 if (DECL_ASSEMBLER_NAME_SET_P (fn
))
1141 if (!DECL_FUNCTION_VERSIONED (method
))
1143 DECL_FUNCTION_VERSIONED (method
) = 1;
1144 if (DECL_ASSEMBLER_NAME_SET_P (method
))
1145 mangle_decl (method
);
1147 record_function_versions (fn
, method
);
1150 if (DECL_INHERITED_CTOR_BASE (method
))
1152 if (DECL_INHERITED_CTOR_BASE (fn
))
1154 error_at (DECL_SOURCE_LOCATION (method
),
1155 "%q#D inherited from %qT", method
,
1156 DECL_INHERITED_CTOR_BASE (method
));
1157 error_at (DECL_SOURCE_LOCATION (fn
),
1158 "conflicts with version inherited from %qT",
1159 DECL_INHERITED_CTOR_BASE (fn
));
1161 /* Otherwise defer to the other function. */
1166 if (DECL_CONTEXT (fn
) == type
)
1167 /* Defer to the local function. */
1172 error ("%q+#D cannot be overloaded", method
);
1173 error ("with %q+#D", fn
);
1176 /* We don't call duplicate_decls here to merge the
1177 declarations because that will confuse things if the
1178 methods have inline definitions. In particular, we
1179 will crash while processing the definitions. */
1184 /* A class should never have more than one destructor. */
1185 if (current_fns
&& DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
1188 /* Add the new binding. */
1191 overload
= ovl_cons (method
, current_fns
);
1192 OVL_USED (overload
) = true;
1195 overload
= build_overload (method
, current_fns
);
1198 TYPE_HAS_CONVERSION (type
) = 1;
1199 else if (slot
>= CLASSTYPE_FIRST_CONVERSION_SLOT
&& !complete_p
)
1200 push_class_level_binding (DECL_NAME (method
), overload
);
1206 /* We only expect to add few methods in the COMPLETE_P case, so
1207 just make room for one more method in that case. */
1209 reallocated
= vec_safe_reserve_exact (method_vec
, 1);
1211 reallocated
= vec_safe_reserve (method_vec
, 1);
1213 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
1214 if (slot
== method_vec
->length ())
1215 method_vec
->quick_push (overload
);
1217 method_vec
->quick_insert (slot
, overload
);
1220 /* Replace the current slot. */
1221 (*method_vec
)[slot
] = overload
;
1225 /* Subroutines of finish_struct. */
1227 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1228 legit, otherwise return 0. */
1231 alter_access (tree t
, tree fdecl
, tree access
)
1235 if (!DECL_LANG_SPECIFIC (fdecl
))
1236 retrofit_lang_decl (fdecl
);
1238 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl
));
1240 elem
= purpose_member (t
, DECL_ACCESS (fdecl
));
1243 if (TREE_VALUE (elem
) != access
)
1245 if (TREE_CODE (TREE_TYPE (fdecl
)) == FUNCTION_DECL
)
1246 error ("conflicting access specifications for method"
1247 " %q+D, ignored", TREE_TYPE (fdecl
));
1249 error ("conflicting access specifications for field %qE, ignored",
1254 /* They're changing the access to the same thing they changed
1255 it to before. That's OK. */
1261 perform_or_defer_access_check (TYPE_BINFO (t
), fdecl
, fdecl
,
1262 tf_warning_or_error
);
1263 DECL_ACCESS (fdecl
) = tree_cons (t
, access
, DECL_ACCESS (fdecl
));
1269 /* Process the USING_DECL, which is a member of T. */
1272 handle_using_decl (tree using_decl
, tree t
)
1274 tree decl
= USING_DECL_DECLS (using_decl
);
1275 tree name
= DECL_NAME (using_decl
);
1277 = TREE_PRIVATE (using_decl
) ? access_private_node
1278 : TREE_PROTECTED (using_decl
) ? access_protected_node
1279 : access_public_node
;
1280 tree flist
= NULL_TREE
;
1283 gcc_assert (!processing_template_decl
&& decl
);
1285 old_value
= lookup_member (t
, name
, /*protect=*/0, /*want_type=*/false,
1286 tf_warning_or_error
);
1289 if (is_overloaded_fn (old_value
))
1290 old_value
= OVL_CURRENT (old_value
);
1292 if (DECL_P (old_value
) && DECL_CONTEXT (old_value
) == t
)
1295 old_value
= NULL_TREE
;
1298 cp_emit_debug_info_for_using (decl
, USING_DECL_SCOPE (using_decl
));
1300 if (is_overloaded_fn (decl
))
1305 else if (is_overloaded_fn (old_value
))
1308 /* It's OK to use functions from a base when there are functions with
1309 the same name already present in the current class. */;
1312 error ("%q+D invalid in %q#T", using_decl
, t
);
1313 error (" because of local method %q+#D with same name",
1314 OVL_CURRENT (old_value
));
1318 else if (!DECL_ARTIFICIAL (old_value
))
1320 error ("%q+D invalid in %q#T", using_decl
, t
);
1321 error (" because of local member %q+#D with same name", old_value
);
1325 /* Make type T see field decl FDECL with access ACCESS. */
1327 for (; flist
; flist
= OVL_NEXT (flist
))
1329 add_method (t
, OVL_CURRENT (flist
), using_decl
);
1330 alter_access (t
, OVL_CURRENT (flist
), access
);
1333 alter_access (t
, decl
, access
);
1336 /* walk_tree callback for check_abi_tags: if the type at *TP involves any
1337 types with abi tags, add the corresponding identifiers to the VEC in
1338 *DATA and set IDENTIFIER_MARKED. */
1347 find_abi_tags_r (tree
*tp
, int */
*walk_subtrees*/
, void *data
)
1349 if (!OVERLOAD_TYPE_P (*tp
))
1352 if (tree attributes
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (*tp
)))
1354 struct abi_tag_data
*p
= static_cast<struct abi_tag_data
*>(data
);
1355 for (tree list
= TREE_VALUE (attributes
); list
;
1356 list
= TREE_CHAIN (list
))
1358 tree tag
= TREE_VALUE (list
);
1359 tree id
= get_identifier (TREE_STRING_POINTER (tag
));
1360 if (!IDENTIFIER_MARKED (id
))
1362 if (TYPE_P (p
->subob
))
1364 warning (OPT_Wabi_tag
, "%qT does not have the %E abi tag "
1365 "that base %qT has", p
->t
, tag
, p
->subob
);
1366 inform (location_of (p
->subob
), "%qT declared here",
1371 warning (OPT_Wabi_tag
, "%qT does not have the %E abi tag "
1372 "that %qT (used in the type of %qD) has",
1373 p
->t
, tag
, *tp
, p
->subob
);
1374 inform (location_of (p
->subob
), "%qD declared here",
1376 inform (location_of (*tp
), "%qT declared here", *tp
);
1384 /* Set IDENTIFIER_MARKED on all the ABI tags on T and its (transitively
1385 complete) template arguments. */
1388 mark_type_abi_tags (tree t
, bool val
)
1390 tree attributes
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (t
));
1393 for (tree list
= TREE_VALUE (attributes
); list
;
1394 list
= TREE_CHAIN (list
))
1396 tree tag
= TREE_VALUE (list
);
1397 tree id
= get_identifier (TREE_STRING_POINTER (tag
));
1398 IDENTIFIER_MARKED (id
) = val
;
1402 /* Also mark ABI tags from template arguments. */
1403 if (CLASSTYPE_TEMPLATE_INFO (t
))
1405 tree args
= CLASSTYPE_TI_ARGS (t
);
1406 for (int i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
1408 tree level
= TMPL_ARGS_LEVEL (args
, i
+1);
1409 for (int j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
1411 tree arg
= TREE_VEC_ELT (level
, j
);
1412 if (CLASS_TYPE_P (arg
))
1413 mark_type_abi_tags (arg
, val
);
1419 /* Check that class T has all the abi tags that subobject SUBOB has, or
1423 check_abi_tags (tree t
, tree subob
)
1425 mark_type_abi_tags (t
, true);
1427 tree subtype
= TYPE_P (subob
) ? subob
: TREE_TYPE (subob
);
1428 struct abi_tag_data data
= { t
, subob
};
1430 cp_walk_tree_without_duplicates (&subtype
, find_abi_tags_r
, &data
);
1432 mark_type_abi_tags (t
, false);
1435 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1436 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1437 properties of the bases. */
1440 check_bases (tree t
,
1441 int* cant_have_const_ctor_p
,
1442 int* no_const_asn_ref_p
)
1445 bool seen_non_virtual_nearly_empty_base_p
= 0;
1446 int seen_tm_mask
= 0;
1449 tree field
= NULL_TREE
;
1451 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1452 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
1453 if (TREE_CODE (field
) == FIELD_DECL
)
1456 for (binfo
= TYPE_BINFO (t
), i
= 0;
1457 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1459 tree basetype
= TREE_TYPE (base_binfo
);
1461 gcc_assert (COMPLETE_TYPE_P (basetype
));
1463 if (CLASSTYPE_FINAL (basetype
))
1464 error ("cannot derive from %<final%> base %qT in derived type %qT",
1467 /* If any base class is non-literal, so is the derived class. */
1468 if (!CLASSTYPE_LITERAL_P (basetype
))
1469 CLASSTYPE_LITERAL_P (t
) = false;
1471 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1472 here because the case of virtual functions but non-virtual
1473 dtor is handled in finish_struct_1. */
1474 if (!TYPE_POLYMORPHIC_P (basetype
))
1475 warning (OPT_Weffc__
,
1476 "base class %q#T has a non-virtual destructor", basetype
);
1478 /* If the base class doesn't have copy constructors or
1479 assignment operators that take const references, then the
1480 derived class cannot have such a member automatically
1482 if (TYPE_HAS_COPY_CTOR (basetype
)
1483 && ! TYPE_HAS_CONST_COPY_CTOR (basetype
))
1484 *cant_have_const_ctor_p
= 1;
1485 if (TYPE_HAS_COPY_ASSIGN (basetype
)
1486 && !TYPE_HAS_CONST_COPY_ASSIGN (basetype
))
1487 *no_const_asn_ref_p
= 1;
1489 if (BINFO_VIRTUAL_P (base_binfo
))
1490 /* A virtual base does not effect nearly emptiness. */
1492 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype
))
1494 if (seen_non_virtual_nearly_empty_base_p
)
1495 /* And if there is more than one nearly empty base, then the
1496 derived class is not nearly empty either. */
1497 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1499 /* Remember we've seen one. */
1500 seen_non_virtual_nearly_empty_base_p
= 1;
1502 else if (!is_empty_class (basetype
))
1503 /* If the base class is not empty or nearly empty, then this
1504 class cannot be nearly empty. */
1505 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1507 /* A lot of properties from the bases also apply to the derived
1509 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (basetype
);
1510 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1511 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
);
1512 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
)
1513 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (basetype
)
1514 || !TYPE_HAS_COPY_ASSIGN (basetype
));
1515 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= (TYPE_HAS_COMPLEX_COPY_CTOR (basetype
)
1516 || !TYPE_HAS_COPY_CTOR (basetype
));
1517 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
1518 |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (basetype
);
1519 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_HAS_COMPLEX_MOVE_CTOR (basetype
);
1520 TYPE_POLYMORPHIC_P (t
) |= TYPE_POLYMORPHIC_P (basetype
);
1521 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
)
1522 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype
);
1523 TYPE_HAS_COMPLEX_DFLT (t
) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
1524 || TYPE_HAS_COMPLEX_DFLT (basetype
));
1525 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT
1526 (t
, CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
1527 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (basetype
));
1528 SET_CLASSTYPE_REF_FIELDS_NEED_INIT
1529 (t
, CLASSTYPE_REF_FIELDS_NEED_INIT (t
)
1530 | CLASSTYPE_REF_FIELDS_NEED_INIT (basetype
));
1532 /* A standard-layout class is a class that:
1534 * has no non-standard-layout base classes, */
1535 CLASSTYPE_NON_STD_LAYOUT (t
) |= CLASSTYPE_NON_STD_LAYOUT (basetype
);
1536 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1539 /* ...has no base classes of the same type as the first non-static
1541 if (field
&& DECL_CONTEXT (field
) == t
1542 && (same_type_ignoring_top_level_qualifiers_p
1543 (TREE_TYPE (field
), basetype
)))
1544 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1546 /* ...either has no non-static data members in the most-derived
1547 class and at most one base class with non-static data
1548 members, or has no base classes with non-static data
1550 for (basefield
= TYPE_FIELDS (basetype
); basefield
;
1551 basefield
= DECL_CHAIN (basefield
))
1552 if (TREE_CODE (basefield
) == FIELD_DECL
)
1555 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1562 /* Don't bother collecting tm attributes if transactional memory
1563 support is not enabled. */
1566 tree tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (basetype
));
1568 seen_tm_mask
|= tm_attr_to_mask (tm_attr
);
1571 check_abi_tags (t
, basetype
);
1574 /* If one of the base classes had TM attributes, and the current class
1575 doesn't define its own, then the current class inherits one. */
1576 if (seen_tm_mask
&& !find_tm_attribute (TYPE_ATTRIBUTES (t
)))
1578 tree tm_attr
= tm_mask_to_attr (seen_tm_mask
& -seen_tm_mask
);
1579 TYPE_ATTRIBUTES (t
) = tree_cons (tm_attr
, NULL
, TYPE_ATTRIBUTES (t
));
1583 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1584 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1585 that have had a nearly-empty virtual primary base stolen by some
1586 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1590 determine_primary_bases (tree t
)
1593 tree primary
= NULL_TREE
;
1594 tree type_binfo
= TYPE_BINFO (t
);
1597 /* Determine the primary bases of our bases. */
1598 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1599 base_binfo
= TREE_CHAIN (base_binfo
))
1601 tree primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo
));
1603 /* See if we're the non-virtual primary of our inheritance
1605 if (!BINFO_VIRTUAL_P (base_binfo
))
1607 tree parent
= BINFO_INHERITANCE_CHAIN (base_binfo
);
1608 tree parent_primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent
));
1611 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
1612 BINFO_TYPE (parent_primary
)))
1613 /* We are the primary binfo. */
1614 BINFO_PRIMARY_P (base_binfo
) = 1;
1616 /* Determine if we have a virtual primary base, and mark it so.
1618 if (primary
&& BINFO_VIRTUAL_P (primary
))
1620 tree this_primary
= copied_binfo (primary
, base_binfo
);
1622 if (BINFO_PRIMARY_P (this_primary
))
1623 /* Someone already claimed this base. */
1624 BINFO_LOST_PRIMARY_P (base_binfo
) = 1;
1629 BINFO_PRIMARY_P (this_primary
) = 1;
1630 BINFO_INHERITANCE_CHAIN (this_primary
) = base_binfo
;
1632 /* A virtual binfo might have been copied from within
1633 another hierarchy. As we're about to use it as a
1634 primary base, make sure the offsets match. */
1635 delta
= size_diffop_loc (input_location
,
1637 BINFO_OFFSET (base_binfo
)),
1639 BINFO_OFFSET (this_primary
)));
1641 propagate_binfo_offsets (this_primary
, delta
);
1646 /* First look for a dynamic direct non-virtual base. */
1647 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, base_binfo
); i
++)
1649 tree basetype
= BINFO_TYPE (base_binfo
);
1651 if (TYPE_CONTAINS_VPTR_P (basetype
) && !BINFO_VIRTUAL_P (base_binfo
))
1653 primary
= base_binfo
;
1658 /* A "nearly-empty" virtual base class can be the primary base
1659 class, if no non-virtual polymorphic base can be found. Look for
1660 a nearly-empty virtual dynamic base that is not already a primary
1661 base of something in the hierarchy. If there is no such base,
1662 just pick the first nearly-empty virtual base. */
1664 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1665 base_binfo
= TREE_CHAIN (base_binfo
))
1666 if (BINFO_VIRTUAL_P (base_binfo
)
1667 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo
)))
1669 if (!BINFO_PRIMARY_P (base_binfo
))
1671 /* Found one that is not primary. */
1672 primary
= base_binfo
;
1676 /* Remember the first candidate. */
1677 primary
= base_binfo
;
1681 /* If we've got a primary base, use it. */
1684 tree basetype
= BINFO_TYPE (primary
);
1686 CLASSTYPE_PRIMARY_BINFO (t
) = primary
;
1687 if (BINFO_PRIMARY_P (primary
))
1688 /* We are stealing a primary base. */
1689 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary
)) = 1;
1690 BINFO_PRIMARY_P (primary
) = 1;
1691 if (BINFO_VIRTUAL_P (primary
))
1695 BINFO_INHERITANCE_CHAIN (primary
) = type_binfo
;
1696 /* A virtual binfo might have been copied from within
1697 another hierarchy. As we're about to use it as a primary
1698 base, make sure the offsets match. */
1699 delta
= size_diffop_loc (input_location
, ssize_int (0),
1700 convert (ssizetype
, BINFO_OFFSET (primary
)));
1702 propagate_binfo_offsets (primary
, delta
);
1705 primary
= TYPE_BINFO (basetype
);
1707 TYPE_VFIELD (t
) = TYPE_VFIELD (basetype
);
1708 BINFO_VTABLE (type_binfo
) = BINFO_VTABLE (primary
);
1709 BINFO_VIRTUALS (type_binfo
) = BINFO_VIRTUALS (primary
);
1713 /* Update the variant types of T. */
1716 fixup_type_variants (tree t
)
1723 for (variants
= TYPE_NEXT_VARIANT (t
);
1725 variants
= TYPE_NEXT_VARIANT (variants
))
1727 /* These fields are in the _TYPE part of the node, not in
1728 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1729 TYPE_HAS_USER_CONSTRUCTOR (variants
) = TYPE_HAS_USER_CONSTRUCTOR (t
);
1730 TYPE_NEEDS_CONSTRUCTING (variants
) = TYPE_NEEDS_CONSTRUCTING (t
);
1731 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants
)
1732 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
1734 TYPE_POLYMORPHIC_P (variants
) = TYPE_POLYMORPHIC_P (t
);
1736 TYPE_BINFO (variants
) = TYPE_BINFO (t
);
1738 /* Copy whatever these are holding today. */
1739 TYPE_VFIELD (variants
) = TYPE_VFIELD (t
);
1740 TYPE_METHODS (variants
) = TYPE_METHODS (t
);
1741 TYPE_FIELDS (variants
) = TYPE_FIELDS (t
);
1745 /* Early variant fixups: we apply attributes at the beginning of the class
1746 definition, and we need to fix up any variants that have already been
1747 made via elaborated-type-specifier so that check_qualified_type works. */
1750 fixup_attribute_variants (tree t
)
1757 for (variants
= TYPE_NEXT_VARIANT (t
);
1759 variants
= TYPE_NEXT_VARIANT (variants
))
1761 /* These are the two fields that check_qualified_type looks at and
1762 are affected by attributes. */
1763 TYPE_ATTRIBUTES (variants
) = TYPE_ATTRIBUTES (t
);
1764 TYPE_ALIGN (variants
) = TYPE_ALIGN (t
);
1768 /* Set memoizing fields and bits of T (and its variants) for later
1772 finish_struct_bits (tree t
)
1774 /* Fix up variants (if any). */
1775 fixup_type_variants (t
);
1777 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) && TYPE_POLYMORPHIC_P (t
))
1778 /* For a class w/o baseclasses, 'finish_struct' has set
1779 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1780 Similarly for a class whose base classes do not have vtables.
1781 When neither of these is true, we might have removed abstract
1782 virtuals (by providing a definition), added some (by declaring
1783 new ones), or redeclared ones from a base class. We need to
1784 recalculate what's really an abstract virtual at this point (by
1785 looking in the vtables). */
1786 get_pure_virtuals (t
);
1788 /* If this type has a copy constructor or a destructor, force its
1789 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1790 nonzero. This will cause it to be passed by invisible reference
1791 and prevent it from being returned in a register. */
1792 if (type_has_nontrivial_copy_init (t
)
1793 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
1796 DECL_MODE (TYPE_MAIN_DECL (t
)) = BLKmode
;
1797 for (variants
= t
; variants
; variants
= TYPE_NEXT_VARIANT (variants
))
1799 SET_TYPE_MODE (variants
, BLKmode
);
1800 TREE_ADDRESSABLE (variants
) = 1;
1805 /* Issue warnings about T having private constructors, but no friends,
1808 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1809 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1810 non-private static member functions. */
1813 maybe_warn_about_overly_private_class (tree t
)
1815 int has_member_fn
= 0;
1816 int has_nonprivate_method
= 0;
1819 if (!warn_ctor_dtor_privacy
1820 /* If the class has friends, those entities might create and
1821 access instances, so we should not warn. */
1822 || (CLASSTYPE_FRIEND_CLASSES (t
)
1823 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
1824 /* We will have warned when the template was declared; there's
1825 no need to warn on every instantiation. */
1826 || CLASSTYPE_TEMPLATE_INSTANTIATION (t
))
1827 /* There's no reason to even consider warning about this
1831 /* We only issue one warning, if more than one applies, because
1832 otherwise, on code like:
1835 // Oops - forgot `public:'
1841 we warn several times about essentially the same problem. */
1843 /* Check to see if all (non-constructor, non-destructor) member
1844 functions are private. (Since there are no friends or
1845 non-private statics, we can't ever call any of the private member
1847 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
1848 /* We're not interested in compiler-generated methods; they don't
1849 provide any way to call private members. */
1850 if (!DECL_ARTIFICIAL (fn
))
1852 if (!TREE_PRIVATE (fn
))
1854 if (DECL_STATIC_FUNCTION_P (fn
))
1855 /* A non-private static member function is just like a
1856 friend; it can create and invoke private member
1857 functions, and be accessed without a class
1861 has_nonprivate_method
= 1;
1862 /* Keep searching for a static member function. */
1864 else if (!DECL_CONSTRUCTOR_P (fn
) && !DECL_DESTRUCTOR_P (fn
))
1868 if (!has_nonprivate_method
&& has_member_fn
)
1870 /* There are no non-private methods, and there's at least one
1871 private member function that isn't a constructor or
1872 destructor. (If all the private members are
1873 constructors/destructors we want to use the code below that
1874 issues error messages specifically referring to
1875 constructors/destructors.) */
1877 tree binfo
= TYPE_BINFO (t
);
1879 for (i
= 0; i
!= BINFO_N_BASE_BINFOS (binfo
); i
++)
1880 if (BINFO_BASE_ACCESS (binfo
, i
) != access_private_node
)
1882 has_nonprivate_method
= 1;
1885 if (!has_nonprivate_method
)
1887 warning (OPT_Wctor_dtor_privacy
,
1888 "all member functions in class %qT are private", t
);
1893 /* Even if some of the member functions are non-private, the class
1894 won't be useful for much if all the constructors or destructors
1895 are private: such an object can never be created or destroyed. */
1896 fn
= CLASSTYPE_DESTRUCTORS (t
);
1897 if (fn
&& TREE_PRIVATE (fn
))
1899 warning (OPT_Wctor_dtor_privacy
,
1900 "%q#T only defines a private destructor and has no friends",
1905 /* Warn about classes that have private constructors and no friends. */
1906 if (TYPE_HAS_USER_CONSTRUCTOR (t
)
1907 /* Implicitly generated constructors are always public. */
1908 && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t
)
1909 || !CLASSTYPE_LAZY_COPY_CTOR (t
)))
1911 int nonprivate_ctor
= 0;
1913 /* If a non-template class does not define a copy
1914 constructor, one is defined for it, enabling it to avoid
1915 this warning. For a template class, this does not
1916 happen, and so we would normally get a warning on:
1918 template <class T> class C { private: C(); };
1920 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All
1921 complete non-template or fully instantiated classes have this
1923 if (!TYPE_HAS_COPY_CTOR (t
))
1924 nonprivate_ctor
= 1;
1926 for (fn
= CLASSTYPE_CONSTRUCTORS (t
); fn
; fn
= OVL_NEXT (fn
))
1928 tree ctor
= OVL_CURRENT (fn
);
1929 /* Ideally, we wouldn't count copy constructors (or, in
1930 fact, any constructor that takes an argument of the
1931 class type as a parameter) because such things cannot
1932 be used to construct an instance of the class unless
1933 you already have one. But, for now at least, we're
1935 if (! TREE_PRIVATE (ctor
))
1937 nonprivate_ctor
= 1;
1942 if (nonprivate_ctor
== 0)
1944 warning (OPT_Wctor_dtor_privacy
,
1945 "%q#T only defines private constructors and has no friends",
1953 gt_pointer_operator new_value
;
1957 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1960 method_name_cmp (const void* m1_p
, const void* m2_p
)
1962 const tree
*const m1
= (const tree
*) m1_p
;
1963 const tree
*const m2
= (const tree
*) m2_p
;
1965 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
1967 if (*m1
== NULL_TREE
)
1969 if (*m2
== NULL_TREE
)
1971 if (DECL_NAME (OVL_CURRENT (*m1
)) < DECL_NAME (OVL_CURRENT (*m2
)))
1976 /* This routine compares two fields like method_name_cmp but using the
1977 pointer operator in resort_field_decl_data. */
1980 resort_method_name_cmp (const void* m1_p
, const void* m2_p
)
1982 const tree
*const m1
= (const tree
*) m1_p
;
1983 const tree
*const m2
= (const tree
*) m2_p
;
1984 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
1986 if (*m1
== NULL_TREE
)
1988 if (*m2
== NULL_TREE
)
1991 tree d1
= DECL_NAME (OVL_CURRENT (*m1
));
1992 tree d2
= DECL_NAME (OVL_CURRENT (*m2
));
1993 resort_data
.new_value (&d1
, resort_data
.cookie
);
1994 resort_data
.new_value (&d2
, resort_data
.cookie
);
2001 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
2004 resort_type_method_vec (void* obj
,
2006 gt_pointer_operator new_value
,
2009 vec
<tree
, va_gc
> *method_vec
= (vec
<tree
, va_gc
> *) obj
;
2010 int len
= vec_safe_length (method_vec
);
2014 /* The type conversion ops have to live at the front of the vec, so we
2016 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2017 vec_safe_iterate (method_vec
, slot
, &fn
);
2019 if (!DECL_CONV_FN_P (OVL_CURRENT (fn
)))
2024 resort_data
.new_value
= new_value
;
2025 resort_data
.cookie
= cookie
;
2026 qsort (method_vec
->address () + slot
, len
- slot
, sizeof (tree
),
2027 resort_method_name_cmp
);
2031 /* Warn about duplicate methods in fn_fields.
2033 Sort methods that are not special (i.e., constructors, destructors,
2034 and type conversion operators) so that we can find them faster in
2038 finish_struct_methods (tree t
)
2041 vec
<tree
, va_gc
> *method_vec
;
2044 method_vec
= CLASSTYPE_METHOD_VEC (t
);
2048 len
= method_vec
->length ();
2050 /* Clear DECL_IN_AGGR_P for all functions. */
2051 for (fn_fields
= TYPE_METHODS (t
); fn_fields
;
2052 fn_fields
= DECL_CHAIN (fn_fields
))
2053 DECL_IN_AGGR_P (fn_fields
) = 0;
2055 /* Issue warnings about private constructors and such. If there are
2056 no methods, then some public defaults are generated. */
2057 maybe_warn_about_overly_private_class (t
);
2059 /* The type conversion ops have to live at the front of the vec, so we
2061 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2062 method_vec
->iterate (slot
, &fn_fields
);
2064 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields
)))
2067 qsort (method_vec
->address () + slot
,
2068 len
-slot
, sizeof (tree
), method_name_cmp
);
2071 /* Make BINFO's vtable have N entries, including RTTI entries,
2072 vbase and vcall offsets, etc. Set its type and call the back end
2076 layout_vtable_decl (tree binfo
, int n
)
2081 atype
= build_array_of_n_type (vtable_entry_type
, n
);
2082 layout_type (atype
);
2084 /* We may have to grow the vtable. */
2085 vtable
= get_vtbl_decl_for_binfo (binfo
);
2086 if (!same_type_p (TREE_TYPE (vtable
), atype
))
2088 TREE_TYPE (vtable
) = atype
;
2089 DECL_SIZE (vtable
) = DECL_SIZE_UNIT (vtable
) = NULL_TREE
;
2090 layout_decl (vtable
, 0);
2094 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
2095 have the same signature. */
2098 same_signature_p (const_tree fndecl
, const_tree base_fndecl
)
2100 /* One destructor overrides another if they are the same kind of
2102 if (DECL_DESTRUCTOR_P (base_fndecl
) && DECL_DESTRUCTOR_P (fndecl
)
2103 && special_function_p (base_fndecl
) == special_function_p (fndecl
))
2105 /* But a non-destructor never overrides a destructor, nor vice
2106 versa, nor do different kinds of destructors override
2107 one-another. For example, a complete object destructor does not
2108 override a deleting destructor. */
2109 if (DECL_DESTRUCTOR_P (base_fndecl
) || DECL_DESTRUCTOR_P (fndecl
))
2112 if (DECL_NAME (fndecl
) == DECL_NAME (base_fndecl
)
2113 || (DECL_CONV_FN_P (fndecl
)
2114 && DECL_CONV_FN_P (base_fndecl
)
2115 && same_type_p (DECL_CONV_FN_TYPE (fndecl
),
2116 DECL_CONV_FN_TYPE (base_fndecl
))))
2118 tree fntype
= TREE_TYPE (fndecl
);
2119 tree base_fntype
= TREE_TYPE (base_fndecl
);
2120 if (type_memfn_quals (fntype
) == type_memfn_quals (base_fntype
)
2121 && type_memfn_rqual (fntype
) == type_memfn_rqual (base_fntype
)
2122 && compparms (FUNCTION_FIRST_USER_PARMTYPE (fndecl
),
2123 FUNCTION_FIRST_USER_PARMTYPE (base_fndecl
)))
2129 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
2133 base_derived_from (tree derived
, tree base
)
2137 for (probe
= base
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
2139 if (probe
== derived
)
2141 else if (BINFO_VIRTUAL_P (probe
))
2142 /* If we meet a virtual base, we can't follow the inheritance
2143 any more. See if the complete type of DERIVED contains
2144 such a virtual base. */
2145 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (derived
))
2151 typedef struct find_final_overrider_data_s
{
2152 /* The function for which we are trying to find a final overrider. */
2154 /* The base class in which the function was declared. */
2155 tree declaring_base
;
2156 /* The candidate overriders. */
2158 /* Path to most derived. */
2160 } find_final_overrider_data
;
2162 /* Add the overrider along the current path to FFOD->CANDIDATES.
2163 Returns true if an overrider was found; false otherwise. */
2166 dfs_find_final_overrider_1 (tree binfo
,
2167 find_final_overrider_data
*ffod
,
2172 /* If BINFO is not the most derived type, try a more derived class.
2173 A definition there will overrider a definition here. */
2177 if (dfs_find_final_overrider_1
2178 (ffod
->path
[depth
], ffod
, depth
))
2182 method
= look_for_overrides_here (BINFO_TYPE (binfo
), ffod
->fn
);
2185 tree
*candidate
= &ffod
->candidates
;
2187 /* Remove any candidates overridden by this new function. */
2190 /* If *CANDIDATE overrides METHOD, then METHOD
2191 cannot override anything else on the list. */
2192 if (base_derived_from (TREE_VALUE (*candidate
), binfo
))
2194 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
2195 if (base_derived_from (binfo
, TREE_VALUE (*candidate
)))
2196 *candidate
= TREE_CHAIN (*candidate
);
2198 candidate
= &TREE_CHAIN (*candidate
);
2201 /* Add the new function. */
2202 ffod
->candidates
= tree_cons (method
, binfo
, ffod
->candidates
);
2209 /* Called from find_final_overrider via dfs_walk. */
2212 dfs_find_final_overrider_pre (tree binfo
, void *data
)
2214 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
2216 if (binfo
== ffod
->declaring_base
)
2217 dfs_find_final_overrider_1 (binfo
, ffod
, ffod
->path
.length ());
2218 ffod
->path
.safe_push (binfo
);
2224 dfs_find_final_overrider_post (tree
/*binfo*/, void *data
)
2226 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
2232 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2233 FN and whose TREE_VALUE is the binfo for the base where the
2234 overriding occurs. BINFO (in the hierarchy dominated by the binfo
2235 DERIVED) is the base object in which FN is declared. */
2238 find_final_overrider (tree derived
, tree binfo
, tree fn
)
2240 find_final_overrider_data ffod
;
2242 /* Getting this right is a little tricky. This is valid:
2244 struct S { virtual void f (); };
2245 struct T { virtual void f (); };
2246 struct U : public S, public T { };
2248 even though calling `f' in `U' is ambiguous. But,
2250 struct R { virtual void f(); };
2251 struct S : virtual public R { virtual void f (); };
2252 struct T : virtual public R { virtual void f (); };
2253 struct U : public S, public T { };
2255 is not -- there's no way to decide whether to put `S::f' or
2256 `T::f' in the vtable for `R'.
2258 The solution is to look at all paths to BINFO. If we find
2259 different overriders along any two, then there is a problem. */
2260 if (DECL_THUNK_P (fn
))
2261 fn
= THUNK_TARGET (fn
);
2263 /* Determine the depth of the hierarchy. */
2265 ffod
.declaring_base
= binfo
;
2266 ffod
.candidates
= NULL_TREE
;
2267 ffod
.path
.create (30);
2269 dfs_walk_all (derived
, dfs_find_final_overrider_pre
,
2270 dfs_find_final_overrider_post
, &ffod
);
2272 ffod
.path
.release ();
2274 /* If there was no winner, issue an error message. */
2275 if (!ffod
.candidates
|| TREE_CHAIN (ffod
.candidates
))
2276 return error_mark_node
;
2278 return ffod
.candidates
;
2281 /* Return the index of the vcall offset for FN when TYPE is used as a
2285 get_vcall_index (tree fn
, tree type
)
2287 vec
<tree_pair_s
, va_gc
> *indices
= CLASSTYPE_VCALL_INDICES (type
);
2291 FOR_EACH_VEC_SAFE_ELT (indices
, ix
, p
)
2292 if ((DECL_DESTRUCTOR_P (fn
) && DECL_DESTRUCTOR_P (p
->purpose
))
2293 || same_signature_p (fn
, p
->purpose
))
2296 /* There should always be an appropriate index. */
2300 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2301 dominated by T. FN is the old function; VIRTUALS points to the
2302 corresponding position in the new BINFO_VIRTUALS list. IX is the index
2303 of that entry in the list. */
2306 update_vtable_entry_for_fn (tree t
, tree binfo
, tree fn
, tree
* virtuals
,
2314 tree overrider_fn
, overrider_target
;
2315 tree target_fn
= DECL_THUNK_P (fn
) ? THUNK_TARGET (fn
) : fn
;
2316 tree over_return
, base_return
;
2319 /* Find the nearest primary base (possibly binfo itself) which defines
2320 this function; this is the class the caller will convert to when
2321 calling FN through BINFO. */
2322 for (b
= binfo
; ; b
= get_primary_binfo (b
))
2325 if (look_for_overrides_here (BINFO_TYPE (b
), target_fn
))
2328 /* The nearest definition is from a lost primary. */
2329 if (BINFO_LOST_PRIMARY_P (b
))
2334 /* Find the final overrider. */
2335 overrider
= find_final_overrider (TYPE_BINFO (t
), b
, target_fn
);
2336 if (overrider
== error_mark_node
)
2338 error ("no unique final overrider for %qD in %qT", target_fn
, t
);
2341 overrider_target
= overrider_fn
= TREE_PURPOSE (overrider
);
2343 /* Check for adjusting covariant return types. */
2344 over_return
= TREE_TYPE (TREE_TYPE (overrider_target
));
2345 base_return
= TREE_TYPE (TREE_TYPE (target_fn
));
2347 if (POINTER_TYPE_P (over_return
)
2348 && TREE_CODE (over_return
) == TREE_CODE (base_return
)
2349 && CLASS_TYPE_P (TREE_TYPE (over_return
))
2350 && CLASS_TYPE_P (TREE_TYPE (base_return
))
2351 /* If the overrider is invalid, don't even try. */
2352 && !DECL_INVALID_OVERRIDER_P (overrider_target
))
2354 /* If FN is a covariant thunk, we must figure out the adjustment
2355 to the final base FN was converting to. As OVERRIDER_TARGET might
2356 also be converting to the return type of FN, we have to
2357 combine the two conversions here. */
2358 tree fixed_offset
, virtual_offset
;
2360 over_return
= TREE_TYPE (over_return
);
2361 base_return
= TREE_TYPE (base_return
);
2363 if (DECL_THUNK_P (fn
))
2365 gcc_assert (DECL_RESULT_THUNK_P (fn
));
2366 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn
));
2367 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn
);
2370 fixed_offset
= virtual_offset
= NULL_TREE
;
2373 /* Find the equivalent binfo within the return type of the
2374 overriding function. We will want the vbase offset from
2376 virtual_offset
= binfo_for_vbase (BINFO_TYPE (virtual_offset
),
2378 else if (!same_type_ignoring_top_level_qualifiers_p
2379 (over_return
, base_return
))
2381 /* There was no existing virtual thunk (which takes
2382 precedence). So find the binfo of the base function's
2383 return type within the overriding function's return type.
2384 We cannot call lookup base here, because we're inside a
2385 dfs_walk, and will therefore clobber the BINFO_MARKED
2386 flags. Fortunately we know the covariancy is valid (it
2387 has already been checked), so we can just iterate along
2388 the binfos, which have been chained in inheritance graph
2389 order. Of course it is lame that we have to repeat the
2390 search here anyway -- we should really be caching pieces
2391 of the vtable and avoiding this repeated work. */
2392 tree thunk_binfo
, base_binfo
;
2394 /* Find the base binfo within the overriding function's
2395 return type. We will always find a thunk_binfo, except
2396 when the covariancy is invalid (which we will have
2397 already diagnosed). */
2398 for (base_binfo
= TYPE_BINFO (base_return
),
2399 thunk_binfo
= TYPE_BINFO (over_return
);
2401 thunk_binfo
= TREE_CHAIN (thunk_binfo
))
2402 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo
),
2403 BINFO_TYPE (base_binfo
)))
2406 /* See if virtual inheritance is involved. */
2407 for (virtual_offset
= thunk_binfo
;
2409 virtual_offset
= BINFO_INHERITANCE_CHAIN (virtual_offset
))
2410 if (BINFO_VIRTUAL_P (virtual_offset
))
2414 || (thunk_binfo
&& !BINFO_OFFSET_ZEROP (thunk_binfo
)))
2416 tree offset
= convert (ssizetype
, BINFO_OFFSET (thunk_binfo
));
2420 /* We convert via virtual base. Adjust the fixed
2421 offset to be from there. */
2423 size_diffop (offset
,
2425 BINFO_OFFSET (virtual_offset
)));
2428 /* There was an existing fixed offset, this must be
2429 from the base just converted to, and the base the
2430 FN was thunking to. */
2431 fixed_offset
= size_binop (PLUS_EXPR
, fixed_offset
, offset
);
2433 fixed_offset
= offset
;
2437 if (fixed_offset
|| virtual_offset
)
2438 /* Replace the overriding function with a covariant thunk. We
2439 will emit the overriding function in its own slot as
2441 overrider_fn
= make_thunk (overrider_target
, /*this_adjusting=*/0,
2442 fixed_offset
, virtual_offset
);
2445 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target
) ||
2446 !DECL_THUNK_P (fn
));
2448 /* If we need a covariant thunk, then we may need to adjust first_defn.
2449 The ABI specifies that the thunks emitted with a function are
2450 determined by which bases the function overrides, so we need to be
2451 sure that we're using a thunk for some overridden base; even if we
2452 know that the necessary this adjustment is zero, there may not be an
2453 appropriate zero-this-adjusment thunk for us to use since thunks for
2454 overriding virtual bases always use the vcall offset.
2456 Furthermore, just choosing any base that overrides this function isn't
2457 quite right, as this slot won't be used for calls through a type that
2458 puts a covariant thunk here. Calling the function through such a type
2459 will use a different slot, and that slot is the one that determines
2460 the thunk emitted for that base.
2462 So, keep looking until we find the base that we're really overriding
2463 in this slot: the nearest primary base that doesn't use a covariant
2464 thunk in this slot. */
2465 if (overrider_target
!= overrider_fn
)
2467 if (BINFO_TYPE (b
) == DECL_CONTEXT (overrider_target
))
2468 /* We already know that the overrider needs a covariant thunk. */
2469 b
= get_primary_binfo (b
);
2470 for (; ; b
= get_primary_binfo (b
))
2472 tree main_binfo
= TYPE_BINFO (BINFO_TYPE (b
));
2473 tree bv
= chain_index (ix
, BINFO_VIRTUALS (main_binfo
));
2474 if (!DECL_THUNK_P (TREE_VALUE (bv
)))
2476 if (BINFO_LOST_PRIMARY_P (b
))
2482 /* Assume that we will produce a thunk that convert all the way to
2483 the final overrider, and not to an intermediate virtual base. */
2484 virtual_base
= NULL_TREE
;
2486 /* See if we can convert to an intermediate virtual base first, and then
2487 use the vcall offset located there to finish the conversion. */
2488 for (; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
2490 /* If we find the final overrider, then we can stop
2492 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b
),
2493 BINFO_TYPE (TREE_VALUE (overrider
))))
2496 /* If we find a virtual base, and we haven't yet found the
2497 overrider, then there is a virtual base between the
2498 declaring base (first_defn) and the final overrider. */
2499 if (BINFO_VIRTUAL_P (b
))
2506 /* Compute the constant adjustment to the `this' pointer. The
2507 `this' pointer, when this function is called, will point at BINFO
2508 (or one of its primary bases, which are at the same offset). */
2510 /* The `this' pointer needs to be adjusted from the declaration to
2511 the nearest virtual base. */
2512 delta
= size_diffop_loc (input_location
,
2513 convert (ssizetype
, BINFO_OFFSET (virtual_base
)),
2514 convert (ssizetype
, BINFO_OFFSET (first_defn
)));
2516 /* If the nearest definition is in a lost primary, we don't need an
2517 entry in our vtable. Except possibly in a constructor vtable,
2518 if we happen to get our primary back. In that case, the offset
2519 will be zero, as it will be a primary base. */
2520 delta
= size_zero_node
;
2522 /* The `this' pointer needs to be adjusted from pointing to
2523 BINFO to pointing at the base where the final overrider
2525 delta
= size_diffop_loc (input_location
,
2527 BINFO_OFFSET (TREE_VALUE (overrider
))),
2528 convert (ssizetype
, BINFO_OFFSET (binfo
)));
2530 modify_vtable_entry (t
, binfo
, overrider_fn
, delta
, virtuals
);
2533 BV_VCALL_INDEX (*virtuals
)
2534 = get_vcall_index (overrider_target
, BINFO_TYPE (virtual_base
));
2536 BV_VCALL_INDEX (*virtuals
) = NULL_TREE
;
2538 BV_LOST_PRIMARY (*virtuals
) = lost
;
2541 /* Called from modify_all_vtables via dfs_walk. */
2544 dfs_modify_vtables (tree binfo
, void* data
)
2546 tree t
= (tree
) data
;
2551 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
2552 /* A base without a vtable needs no modification, and its bases
2553 are uninteresting. */
2554 return dfs_skip_bases
;
2556 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
)
2557 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
2558 /* Don't do the primary vtable, if it's new. */
2561 if (BINFO_PRIMARY_P (binfo
) && !BINFO_VIRTUAL_P (binfo
))
2562 /* There's no need to modify the vtable for a non-virtual primary
2563 base; we're not going to use that vtable anyhow. We do still
2564 need to do this for virtual primary bases, as they could become
2565 non-primary in a construction vtable. */
2568 make_new_vtable (t
, binfo
);
2570 /* Now, go through each of the virtual functions in the virtual
2571 function table for BINFO. Find the final overrider, and update
2572 the BINFO_VIRTUALS list appropriately. */
2573 for (ix
= 0, virtuals
= BINFO_VIRTUALS (binfo
),
2574 old_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
2576 ix
++, virtuals
= TREE_CHAIN (virtuals
),
2577 old_virtuals
= TREE_CHAIN (old_virtuals
))
2578 update_vtable_entry_for_fn (t
,
2580 BV_FN (old_virtuals
),
2586 /* Update all of the primary and secondary vtables for T. Create new
2587 vtables as required, and initialize their RTTI information. Each
2588 of the functions in VIRTUALS is declared in T and may override a
2589 virtual function from a base class; find and modify the appropriate
2590 entries to point to the overriding functions. Returns a list, in
2591 declaration order, of the virtual functions that are declared in T,
2592 but do not appear in the primary base class vtable, and which
2593 should therefore be appended to the end of the vtable for T. */
2596 modify_all_vtables (tree t
, tree virtuals
)
2598 tree binfo
= TYPE_BINFO (t
);
2601 /* Mangle the vtable name before entering dfs_walk (c++/51884). */
2602 if (TYPE_CONTAINS_VPTR_P (t
))
2603 get_vtable_decl (t
, false);
2605 /* Update all of the vtables. */
2606 dfs_walk_once (binfo
, dfs_modify_vtables
, NULL
, t
);
2608 /* Add virtual functions not already in our primary vtable. These
2609 will be both those introduced by this class, and those overridden
2610 from secondary bases. It does not include virtuals merely
2611 inherited from secondary bases. */
2612 for (fnsp
= &virtuals
; *fnsp
; )
2614 tree fn
= TREE_VALUE (*fnsp
);
2616 if (!value_member (fn
, BINFO_VIRTUALS (binfo
))
2617 || DECL_VINDEX (fn
) == error_mark_node
)
2619 /* We don't need to adjust the `this' pointer when
2620 calling this function. */
2621 BV_DELTA (*fnsp
) = integer_zero_node
;
2622 BV_VCALL_INDEX (*fnsp
) = NULL_TREE
;
2624 /* This is a function not already in our vtable. Keep it. */
2625 fnsp
= &TREE_CHAIN (*fnsp
);
2628 /* We've already got an entry for this function. Skip it. */
2629 *fnsp
= TREE_CHAIN (*fnsp
);
2635 /* Get the base virtual function declarations in T that have the
2639 get_basefndecls (tree name
, tree t
)
2642 tree base_fndecls
= NULL_TREE
;
2643 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
2646 /* Find virtual functions in T with the indicated NAME. */
2647 i
= lookup_fnfields_1 (t
, name
);
2649 for (methods
= (*CLASSTYPE_METHOD_VEC (t
))[i
];
2651 methods
= OVL_NEXT (methods
))
2653 tree method
= OVL_CURRENT (methods
);
2655 if (TREE_CODE (method
) == FUNCTION_DECL
2656 && DECL_VINDEX (method
))
2657 base_fndecls
= tree_cons (NULL_TREE
, method
, base_fndecls
);
2661 return base_fndecls
;
2663 for (i
= 0; i
< n_baseclasses
; i
++)
2665 tree basetype
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t
), i
));
2666 base_fndecls
= chainon (get_basefndecls (name
, basetype
),
2670 return base_fndecls
;
2673 /* If this declaration supersedes the declaration of
2674 a method declared virtual in the base class, then
2675 mark this field as being virtual as well. */
2678 check_for_override (tree decl
, tree ctype
)
2680 bool overrides_found
= false;
2681 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2682 /* In [temp.mem] we have:
2684 A specialization of a member function template does not
2685 override a virtual function from a base class. */
2687 if ((DECL_DESTRUCTOR_P (decl
)
2688 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
))
2689 || DECL_CONV_FN_P (decl
))
2690 && look_for_overrides (ctype
, decl
)
2691 && !DECL_STATIC_FUNCTION_P (decl
))
2692 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2693 the error_mark_node so that we know it is an overriding
2696 DECL_VINDEX (decl
) = decl
;
2697 overrides_found
= true;
2700 if (DECL_VIRTUAL_P (decl
))
2702 if (!DECL_VINDEX (decl
))
2703 DECL_VINDEX (decl
) = error_mark_node
;
2704 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
2705 if (DECL_DESTRUCTOR_P (decl
))
2706 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype
) = true;
2708 else if (DECL_FINAL_P (decl
))
2709 error ("%q+#D marked final, but is not virtual", decl
);
2710 if (DECL_OVERRIDE_P (decl
) && !overrides_found
)
2711 error ("%q+#D marked override, but does not override", decl
);
2714 /* Warn about hidden virtual functions that are not overridden in t.
2715 We know that constructors and destructors don't apply. */
2718 warn_hidden (tree t
)
2720 vec
<tree
, va_gc
> *method_vec
= CLASSTYPE_METHOD_VEC (t
);
2724 /* We go through each separately named virtual function. */
2725 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2726 vec_safe_iterate (method_vec
, i
, &fns
);
2737 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2738 have the same name. Figure out what name that is. */
2739 name
= DECL_NAME (OVL_CURRENT (fns
));
2740 /* There are no possibly hidden functions yet. */
2741 base_fndecls
= NULL_TREE
;
2742 /* Iterate through all of the base classes looking for possibly
2743 hidden functions. */
2744 for (binfo
= TYPE_BINFO (t
), j
= 0;
2745 BINFO_BASE_ITERATE (binfo
, j
, base_binfo
); j
++)
2747 tree basetype
= BINFO_TYPE (base_binfo
);
2748 base_fndecls
= chainon (get_basefndecls (name
, basetype
),
2752 /* If there are no functions to hide, continue. */
2756 /* Remove any overridden functions. */
2757 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
2759 fndecl
= OVL_CURRENT (fn
);
2760 if (DECL_VINDEX (fndecl
))
2762 tree
*prev
= &base_fndecls
;
2765 /* If the method from the base class has the same
2766 signature as the method from the derived class, it
2767 has been overridden. */
2768 if (same_signature_p (fndecl
, TREE_VALUE (*prev
)))
2769 *prev
= TREE_CHAIN (*prev
);
2771 prev
= &TREE_CHAIN (*prev
);
2775 /* Now give a warning for all base functions without overriders,
2776 as they are hidden. */
2777 while (base_fndecls
)
2779 /* Here we know it is a hider, and no overrider exists. */
2780 warning (OPT_Woverloaded_virtual
, "%q+D was hidden", TREE_VALUE (base_fndecls
));
2781 warning (OPT_Woverloaded_virtual
, " by %q+D", fns
);
2782 base_fndecls
= TREE_CHAIN (base_fndecls
);
2787 /* Recursive helper for finish_struct_anon. */
2790 finish_struct_anon_r (tree field
, bool complain
)
2792 bool is_union
= TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
;
2793 tree elt
= TYPE_FIELDS (TREE_TYPE (field
));
2794 for (; elt
; elt
= DECL_CHAIN (elt
))
2796 /* We're generally only interested in entities the user
2797 declared, but we also find nested classes by noticing
2798 the TYPE_DECL that we create implicitly. You're
2799 allowed to put one anonymous union inside another,
2800 though, so we explicitly tolerate that. We use
2801 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2802 we also allow unnamed types used for defining fields. */
2803 if (DECL_ARTIFICIAL (elt
)
2804 && (!DECL_IMPLICIT_TYPEDEF_P (elt
)
2805 || TYPE_ANONYMOUS_P (TREE_TYPE (elt
))))
2808 if (TREE_CODE (elt
) != FIELD_DECL
)
2813 permerror (input_location
,
2814 "%q+#D invalid; an anonymous union can "
2815 "only have non-static data members", elt
);
2817 permerror (input_location
,
2818 "%q+#D invalid; an anonymous struct can "
2819 "only have non-static data members", elt
);
2826 if (TREE_PRIVATE (elt
))
2829 permerror (input_location
,
2830 "private member %q+#D in anonymous union", elt
);
2832 permerror (input_location
,
2833 "private member %q+#D in anonymous struct", elt
);
2835 else if (TREE_PROTECTED (elt
))
2838 permerror (input_location
,
2839 "protected member %q+#D in anonymous union", elt
);
2841 permerror (input_location
,
2842 "protected member %q+#D in anonymous struct", elt
);
2846 TREE_PRIVATE (elt
) = TREE_PRIVATE (field
);
2847 TREE_PROTECTED (elt
) = TREE_PROTECTED (field
);
2849 /* Recurse into the anonymous aggregates to handle correctly
2850 access control (c++/24926):
2861 if (DECL_NAME (elt
) == NULL_TREE
2862 && ANON_AGGR_TYPE_P (TREE_TYPE (elt
)))
2863 finish_struct_anon_r (elt
, /*complain=*/false);
2867 /* Check for things that are invalid. There are probably plenty of other
2868 things we should check for also. */
2871 finish_struct_anon (tree t
)
2873 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
2875 if (TREE_STATIC (field
))
2877 if (TREE_CODE (field
) != FIELD_DECL
)
2880 if (DECL_NAME (field
) == NULL_TREE
2881 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
2882 finish_struct_anon_r (field
, /*complain=*/true);
2886 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2887 will be used later during class template instantiation.
2888 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2889 a non-static member data (FIELD_DECL), a member function
2890 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2891 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2892 When FRIEND_P is nonzero, T is either a friend class
2893 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2894 (FUNCTION_DECL, TEMPLATE_DECL). */
2897 maybe_add_class_template_decl_list (tree type
, tree t
, int friend_p
)
2899 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2900 if (CLASSTYPE_TEMPLATE_INFO (type
))
2901 CLASSTYPE_DECL_LIST (type
)
2902 = tree_cons (friend_p
? NULL_TREE
: type
,
2903 t
, CLASSTYPE_DECL_LIST (type
));
2906 /* This function is called from declare_virt_assop_and_dtor via
2909 DATA is a type that direcly or indirectly inherits the base
2910 represented by BINFO. If BINFO contains a virtual assignment [copy
2911 assignment or move assigment] operator or a virtual constructor,
2912 declare that function in DATA if it hasn't been already declared. */
2915 dfs_declare_virt_assop_and_dtor (tree binfo
, void *data
)
2917 tree bv
, fn
, t
= (tree
)data
;
2918 tree opname
= ansi_assopname (NOP_EXPR
);
2920 gcc_assert (t
&& CLASS_TYPE_P (t
));
2921 gcc_assert (binfo
&& TREE_CODE (binfo
) == TREE_BINFO
);
2923 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
2924 /* A base without a vtable needs no modification, and its bases
2925 are uninteresting. */
2926 return dfs_skip_bases
;
2928 if (BINFO_PRIMARY_P (binfo
))
2929 /* If this is a primary base, then we have already looked at the
2930 virtual functions of its vtable. */
2933 for (bv
= BINFO_VIRTUALS (binfo
); bv
; bv
= TREE_CHAIN (bv
))
2937 if (DECL_NAME (fn
) == opname
)
2939 if (CLASSTYPE_LAZY_COPY_ASSIGN (t
))
2940 lazily_declare_fn (sfk_copy_assignment
, t
);
2941 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
2942 lazily_declare_fn (sfk_move_assignment
, t
);
2944 else if (DECL_DESTRUCTOR_P (fn
)
2945 && CLASSTYPE_LAZY_DESTRUCTOR (t
))
2946 lazily_declare_fn (sfk_destructor
, t
);
2952 /* If the class type T has a direct or indirect base that contains a
2953 virtual assignment operator or a virtual destructor, declare that
2954 function in T if it hasn't been already declared. */
2957 declare_virt_assop_and_dtor (tree t
)
2959 if (!(TYPE_POLYMORPHIC_P (t
)
2960 && (CLASSTYPE_LAZY_COPY_ASSIGN (t
)
2961 || CLASSTYPE_LAZY_MOVE_ASSIGN (t
)
2962 || CLASSTYPE_LAZY_DESTRUCTOR (t
))))
2965 dfs_walk_all (TYPE_BINFO (t
),
2966 dfs_declare_virt_assop_and_dtor
,
2970 /* Declare the inheriting constructor for class T inherited from base
2971 constructor CTOR with the parameter array PARMS of size NPARMS. */
2974 one_inheriting_sig (tree t
, tree ctor
, tree
*parms
, int nparms
)
2976 /* We don't declare an inheriting ctor that would be a default,
2977 copy or move ctor for derived or base. */
2981 && TREE_CODE (parms
[0]) == REFERENCE_TYPE
)
2983 tree parm
= TYPE_MAIN_VARIANT (TREE_TYPE (parms
[0]));
2984 if (parm
== t
|| parm
== DECL_CONTEXT (ctor
))
2988 tree parmlist
= void_list_node
;
2989 for (int i
= nparms
- 1; i
>= 0; i
--)
2990 parmlist
= tree_cons (NULL_TREE
, parms
[i
], parmlist
);
2991 tree fn
= implicitly_declare_fn (sfk_inheriting_constructor
,
2992 t
, false, ctor
, parmlist
);
2993 if (add_method (t
, fn
, NULL_TREE
))
2995 DECL_CHAIN (fn
) = TYPE_METHODS (t
);
2996 TYPE_METHODS (t
) = fn
;
3000 /* Declare all the inheriting constructors for class T inherited from base
3001 constructor CTOR. */
3004 one_inherited_ctor (tree ctor
, tree t
)
3006 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (ctor
);
3008 tree
*new_parms
= XALLOCAVEC (tree
, list_length (parms
));
3010 for (; parms
&& parms
!= void_list_node
; parms
= TREE_CHAIN (parms
))
3012 if (TREE_PURPOSE (parms
))
3013 one_inheriting_sig (t
, ctor
, new_parms
, i
);
3014 new_parms
[i
++] = TREE_VALUE (parms
);
3016 one_inheriting_sig (t
, ctor
, new_parms
, i
);
3017 if (parms
== NULL_TREE
)
3019 warning (OPT_Winherited_variadic_ctor
,
3020 "the ellipsis in %qD is not inherited", ctor
);
3021 inform (DECL_SOURCE_LOCATION (ctor
), "%qD declared here", ctor
);
3025 /* Create default constructors, assignment operators, and so forth for
3026 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
3027 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
3028 the class cannot have a default constructor, copy constructor
3029 taking a const reference argument, or an assignment operator taking
3030 a const reference, respectively. */
3033 add_implicitly_declared_members (tree t
, tree
* access_decls
,
3034 int cant_have_const_cctor
,
3035 int cant_have_const_assignment
)
3037 bool move_ok
= false;
3039 if (cxx_dialect
>= cxx11
&& !CLASSTYPE_DESTRUCTORS (t
)
3040 && !TYPE_HAS_COPY_CTOR (t
) && !TYPE_HAS_COPY_ASSIGN (t
)
3041 && !type_has_move_constructor (t
) && !type_has_move_assign (t
))
3045 if (!CLASSTYPE_DESTRUCTORS (t
))
3047 /* In general, we create destructors lazily. */
3048 CLASSTYPE_LAZY_DESTRUCTOR (t
) = 1;
3050 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3051 && TYPE_FOR_JAVA (t
))
3052 /* But if this is a Java class, any non-trivial destructor is
3053 invalid, even if compiler-generated. Therefore, if the
3054 destructor is non-trivial we create it now. */
3055 lazily_declare_fn (sfk_destructor
, t
);
3060 If there is no user-declared constructor for a class, a default
3061 constructor is implicitly declared. */
3062 if (! TYPE_HAS_USER_CONSTRUCTOR (t
))
3064 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 1;
3065 CLASSTYPE_LAZY_DEFAULT_CTOR (t
) = 1;
3066 if (cxx_dialect
>= cxx11
)
3067 TYPE_HAS_CONSTEXPR_CTOR (t
)
3068 /* This might force the declaration. */
3069 = type_has_constexpr_default_constructor (t
);
3074 If a class definition does not explicitly declare a copy
3075 constructor, one is declared implicitly. */
3076 if (! TYPE_HAS_COPY_CTOR (t
) && ! TYPE_FOR_JAVA (t
))
3078 TYPE_HAS_COPY_CTOR (t
) = 1;
3079 TYPE_HAS_CONST_COPY_CTOR (t
) = !cant_have_const_cctor
;
3080 CLASSTYPE_LAZY_COPY_CTOR (t
) = 1;
3082 CLASSTYPE_LAZY_MOVE_CTOR (t
) = 1;
3085 /* If there is no assignment operator, one will be created if and
3086 when it is needed. For now, just record whether or not the type
3087 of the parameter to the assignment operator will be a const or
3088 non-const reference. */
3089 if (!TYPE_HAS_COPY_ASSIGN (t
) && !TYPE_FOR_JAVA (t
))
3091 TYPE_HAS_COPY_ASSIGN (t
) = 1;
3092 TYPE_HAS_CONST_COPY_ASSIGN (t
) = !cant_have_const_assignment
;
3093 CLASSTYPE_LAZY_COPY_ASSIGN (t
) = 1;
3095 CLASSTYPE_LAZY_MOVE_ASSIGN (t
) = 1;
3098 /* We can't be lazy about declaring functions that might override
3099 a virtual function from a base class. */
3100 declare_virt_assop_and_dtor (t
);
3102 while (*access_decls
)
3104 tree using_decl
= TREE_VALUE (*access_decls
);
3105 tree decl
= USING_DECL_DECLS (using_decl
);
3106 if (DECL_NAME (using_decl
) == ctor_identifier
)
3108 /* declare, then remove the decl */
3109 tree ctor_list
= decl
;
3110 location_t loc
= input_location
;
3111 input_location
= DECL_SOURCE_LOCATION (using_decl
);
3113 for (; ctor_list
; ctor_list
= OVL_NEXT (ctor_list
))
3114 one_inherited_ctor (OVL_CURRENT (ctor_list
), t
);
3115 *access_decls
= TREE_CHAIN (*access_decls
);
3116 input_location
= loc
;
3119 access_decls
= &TREE_CHAIN (*access_decls
);
3123 /* Subroutine of insert_into_classtype_sorted_fields. Recursively
3124 count the number of fields in TYPE, including anonymous union
3128 count_fields (tree fields
)
3132 for (x
= fields
; x
; x
= DECL_CHAIN (x
))
3134 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3135 n_fields
+= count_fields (TYPE_FIELDS (TREE_TYPE (x
)));
3142 /* Subroutine of insert_into_classtype_sorted_fields. Recursively add
3143 all the fields in the TREE_LIST FIELDS to the SORTED_FIELDS_TYPE
3144 elts, starting at offset IDX. */
3147 add_fields_to_record_type (tree fields
, struct sorted_fields_type
*field_vec
, int idx
)
3150 for (x
= fields
; x
; x
= DECL_CHAIN (x
))
3152 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3153 idx
= add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x
)), field_vec
, idx
);
3155 field_vec
->elts
[idx
++] = x
;
3160 /* Add all of the enum values of ENUMTYPE, to the FIELD_VEC elts,
3161 starting at offset IDX. */
3164 add_enum_fields_to_record_type (tree enumtype
,
3165 struct sorted_fields_type
*field_vec
,
3169 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
3170 field_vec
->elts
[idx
++] = TREE_VALUE (values
);
3174 /* FIELD is a bit-field. We are finishing the processing for its
3175 enclosing type. Issue any appropriate messages and set appropriate
3176 flags. Returns false if an error has been diagnosed. */
3179 check_bitfield_decl (tree field
)
3181 tree type
= TREE_TYPE (field
);
3184 /* Extract the declared width of the bitfield, which has been
3185 temporarily stashed in DECL_INITIAL. */
3186 w
= DECL_INITIAL (field
);
3187 gcc_assert (w
!= NULL_TREE
);
3188 /* Remove the bit-field width indicator so that the rest of the
3189 compiler does not treat that value as an initializer. */
3190 DECL_INITIAL (field
) = NULL_TREE
;
3192 /* Detect invalid bit-field type. */
3193 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3195 error ("bit-field %q+#D with non-integral type", field
);
3196 w
= error_mark_node
;
3200 location_t loc
= input_location
;
3201 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
3204 /* detect invalid field size. */
3205 input_location
= DECL_SOURCE_LOCATION (field
);
3206 w
= cxx_constant_value (w
);
3207 input_location
= loc
;
3209 if (TREE_CODE (w
) != INTEGER_CST
)
3211 error ("bit-field %q+D width not an integer constant", field
);
3212 w
= error_mark_node
;
3214 else if (tree_int_cst_sgn (w
) < 0)
3216 error ("negative width in bit-field %q+D", field
);
3217 w
= error_mark_node
;
3219 else if (integer_zerop (w
) && DECL_NAME (field
) != 0)
3221 error ("zero width for bit-field %q+D", field
);
3222 w
= error_mark_node
;
3224 else if ((TREE_CODE (type
) != ENUMERAL_TYPE
3225 && TREE_CODE (type
) != BOOLEAN_TYPE
3226 && compare_tree_int (w
, TYPE_PRECISION (type
)) > 0)
3227 || ((TREE_CODE (type
) == ENUMERAL_TYPE
3228 || TREE_CODE (type
) == BOOLEAN_TYPE
)
3229 && tree_int_cst_lt (TYPE_SIZE (type
), w
)))
3230 warning (0, "width of %q+D exceeds its type", field
);
3231 else if (TREE_CODE (type
) == ENUMERAL_TYPE
3232 && (0 > (compare_tree_int
3233 (w
, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type
))))))
3234 warning (0, "%q+D is too small to hold all values of %q#T", field
, type
);
3237 if (w
!= error_mark_node
)
3239 DECL_SIZE (field
) = convert (bitsizetype
, w
);
3240 DECL_BIT_FIELD (field
) = 1;
3245 /* Non-bit-fields are aligned for their type. */
3246 DECL_BIT_FIELD (field
) = 0;
3247 CLEAR_DECL_C_BIT_FIELD (field
);
3252 /* FIELD is a non bit-field. We are finishing the processing for its
3253 enclosing type T. Issue any appropriate messages and set appropriate
3257 check_field_decl (tree field
,
3259 int* cant_have_const_ctor
,
3260 int* no_const_asn_ref
,
3261 int* any_default_members
)
3263 tree type
= strip_array_types (TREE_TYPE (field
));
3265 /* In C++98 an anonymous union cannot contain any fields which would change
3266 the settings of CANT_HAVE_CONST_CTOR and friends. */
3267 if (ANON_UNION_TYPE_P (type
) && cxx_dialect
< cxx11
)
3269 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
3270 structs. So, we recurse through their fields here. */
3271 else if (ANON_AGGR_TYPE_P (type
))
3275 for (fields
= TYPE_FIELDS (type
); fields
; fields
= DECL_CHAIN (fields
))
3276 if (TREE_CODE (fields
) == FIELD_DECL
&& !DECL_C_BIT_FIELD (field
))
3277 check_field_decl (fields
, t
, cant_have_const_ctor
,
3278 no_const_asn_ref
, any_default_members
);
3280 /* Check members with class type for constructors, destructors,
3282 else if (CLASS_TYPE_P (type
))
3284 /* Never let anything with uninheritable virtuals
3285 make it through without complaint. */
3286 abstract_virtuals_error (field
, type
);
3288 if (TREE_CODE (t
) == UNION_TYPE
&& cxx_dialect
< cxx11
)
3291 int oldcount
= errorcount
;
3292 if (TYPE_NEEDS_CONSTRUCTING (type
))
3293 error ("member %q+#D with constructor not allowed in union",
3295 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3296 error ("member %q+#D with destructor not allowed in union", field
);
3297 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
3298 error ("member %q+#D with copy assignment operator not allowed in union",
3300 if (!warned
&& errorcount
> oldcount
)
3302 inform (DECL_SOURCE_LOCATION (field
), "unrestricted unions "
3303 "only available with -std=c++11 or -std=gnu++11");
3309 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (type
);
3310 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3311 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
);
3312 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
)
3313 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
)
3314 || !TYPE_HAS_COPY_ASSIGN (type
));
3315 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= (TYPE_HAS_COMPLEX_COPY_CTOR (type
)
3316 || !TYPE_HAS_COPY_CTOR (type
));
3317 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type
);
3318 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_HAS_COMPLEX_MOVE_CTOR (type
);
3319 TYPE_HAS_COMPLEX_DFLT (t
) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)
3320 || TYPE_HAS_COMPLEX_DFLT (type
));
3323 if (TYPE_HAS_COPY_CTOR (type
)
3324 && !TYPE_HAS_CONST_COPY_CTOR (type
))
3325 *cant_have_const_ctor
= 1;
3327 if (TYPE_HAS_COPY_ASSIGN (type
)
3328 && !TYPE_HAS_CONST_COPY_ASSIGN (type
))
3329 *no_const_asn_ref
= 1;
3332 check_abi_tags (t
, field
);
3334 if (DECL_INITIAL (field
) != NULL_TREE
)
3336 /* `build_class_init_list' does not recognize
3338 if (TREE_CODE (t
) == UNION_TYPE
&& *any_default_members
!= 0)
3339 error ("multiple fields in union %qT initialized", t
);
3340 *any_default_members
= 1;
3344 /* Check the data members (both static and non-static), class-scoped
3345 typedefs, etc., appearing in the declaration of T. Issue
3346 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3347 declaration order) of access declarations; each TREE_VALUE in this
3348 list is a USING_DECL.
3350 In addition, set the following flags:
3353 The class is empty, i.e., contains no non-static data members.
3355 CANT_HAVE_CONST_CTOR_P
3356 This class cannot have an implicitly generated copy constructor
3357 taking a const reference.
3359 CANT_HAVE_CONST_ASN_REF
3360 This class cannot have an implicitly generated assignment
3361 operator taking a const reference.
3363 All of these flags should be initialized before calling this
3366 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3367 fields can be added by adding to this chain. */
3370 check_field_decls (tree t
, tree
*access_decls
,
3371 int *cant_have_const_ctor_p
,
3372 int *no_const_asn_ref_p
)
3377 int any_default_members
;
3379 int field_access
= -1;
3381 /* Assume there are no access declarations. */
3382 *access_decls
= NULL_TREE
;
3383 /* Assume this class has no pointer members. */
3384 has_pointers
= false;
3385 /* Assume none of the members of this class have default
3387 any_default_members
= 0;
3389 for (field
= &TYPE_FIELDS (t
); *field
; field
= next
)
3392 tree type
= TREE_TYPE (x
);
3393 int this_field_access
;
3395 next
= &DECL_CHAIN (x
);
3397 if (TREE_CODE (x
) == USING_DECL
)
3399 /* Save the access declarations for our caller. */
3400 *access_decls
= tree_cons (NULL_TREE
, x
, *access_decls
);
3404 if (TREE_CODE (x
) == TYPE_DECL
3405 || TREE_CODE (x
) == TEMPLATE_DECL
)
3408 /* If we've gotten this far, it's a data member, possibly static,
3409 or an enumerator. */
3410 if (TREE_CODE (x
) != CONST_DECL
)
3411 DECL_CONTEXT (x
) = t
;
3413 /* When this goes into scope, it will be a non-local reference. */
3414 DECL_NONLOCAL (x
) = 1;
3416 if (TREE_CODE (t
) == UNION_TYPE
)
3420 If a union contains a static data member, or a member of
3421 reference type, the program is ill-formed. */
3424 error ("%q+D may not be static because it is a member of a union", x
);
3427 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3429 error ("%q+D may not have reference type %qT because"
3430 " it is a member of a union",
3436 /* Perform error checking that did not get done in
3438 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3440 error ("field %q+D invalidly declared function type", x
);
3441 type
= build_pointer_type (type
);
3442 TREE_TYPE (x
) = type
;
3444 else if (TREE_CODE (type
) == METHOD_TYPE
)
3446 error ("field %q+D invalidly declared method type", x
);
3447 type
= build_pointer_type (type
);
3448 TREE_TYPE (x
) = type
;
3451 if (type
== error_mark_node
)
3454 if (TREE_CODE (x
) == CONST_DECL
|| VAR_P (x
))
3457 /* Now it can only be a FIELD_DECL. */
3459 if (TREE_PRIVATE (x
) || TREE_PROTECTED (x
))
3460 CLASSTYPE_NON_AGGREGATE (t
) = 1;
3462 /* If at least one non-static data member is non-literal, the whole
3463 class becomes non-literal. Note: if the type is incomplete we
3464 will complain later on. */
3465 if (COMPLETE_TYPE_P (type
) && !literal_type_p (type
))
3466 CLASSTYPE_LITERAL_P (t
) = false;
3468 /* A standard-layout class is a class that:
3470 has the same access control (Clause 11) for all non-static data members,
3472 this_field_access
= TREE_PROTECTED (x
) ? 1 : TREE_PRIVATE (x
) ? 2 : 0;
3473 if (field_access
== -1)
3474 field_access
= this_field_access
;
3475 else if (this_field_access
!= field_access
)
3476 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3478 /* If this is of reference type, check if it needs an init. */
3479 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3481 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3482 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3483 if (DECL_INITIAL (x
) == NULL_TREE
)
3484 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3486 /* ARM $12.6.2: [A member initializer list] (or, for an
3487 aggregate, initialization by a brace-enclosed list) is the
3488 only way to initialize nonstatic const and reference
3490 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
3491 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) = 1;
3494 type
= strip_array_types (type
);
3496 if (TYPE_PACKED (t
))
3498 if (!layout_pod_type_p (type
) && !TYPE_PACKED (type
))
3502 "ignoring packed attribute because of unpacked non-POD field %q+#D",
3506 else if (DECL_C_BIT_FIELD (x
)
3507 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
)
3508 DECL_PACKED (x
) = 1;
3511 if (DECL_C_BIT_FIELD (x
) && integer_zerop (DECL_INITIAL (x
)))
3512 /* We don't treat zero-width bitfields as making a class
3517 /* The class is non-empty. */
3518 CLASSTYPE_EMPTY_P (t
) = 0;
3519 /* The class is not even nearly empty. */
3520 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3521 /* If one of the data members contains an empty class,
3523 if (CLASS_TYPE_P (type
)
3524 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3525 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
3528 /* This is used by -Weffc++ (see below). Warn only for pointers
3529 to members which might hold dynamic memory. So do not warn
3530 for pointers to functions or pointers to members. */
3531 if (TYPE_PTR_P (type
)
3532 && !TYPE_PTRFN_P (type
))
3533 has_pointers
= true;
3535 if (CLASS_TYPE_P (type
))
3537 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type
))
3538 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3539 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
))
3540 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3543 if (DECL_MUTABLE_P (x
) || TYPE_HAS_MUTABLE_P (type
))
3544 CLASSTYPE_HAS_MUTABLE (t
) = 1;
3546 if (DECL_MUTABLE_P (x
))
3548 if (CP_TYPE_CONST_P (type
))
3550 error ("member %q+D cannot be declared both %<const%> "
3551 "and %<mutable%>", x
);
3554 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3556 error ("member %q+D cannot be declared as a %<mutable%> "
3562 if (! layout_pod_type_p (type
))
3563 /* DR 148 now allows pointers to members (which are POD themselves),
3564 to be allowed in POD structs. */
3565 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3567 if (!std_layout_type_p (type
))
3568 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3570 if (! zero_init_p (type
))
3571 CLASSTYPE_NON_ZERO_INIT_P (t
) = 1;
3573 /* We set DECL_C_BIT_FIELD in grokbitfield.
3574 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3575 if (! DECL_C_BIT_FIELD (x
) || ! check_bitfield_decl (x
))
3576 check_field_decl (x
, t
,
3577 cant_have_const_ctor_p
,
3579 &any_default_members
);
3581 /* Now that we've removed bit-field widths from DECL_INITIAL,
3582 anything left in DECL_INITIAL is an NSDMI that makes the class
3584 if (DECL_INITIAL (x
))
3585 CLASSTYPE_NON_AGGREGATE (t
) = true;
3587 /* If any field is const, the structure type is pseudo-const. */
3588 if (CP_TYPE_CONST_P (type
))
3590 C_TYPE_FIELDS_READONLY (t
) = 1;
3591 if (DECL_INITIAL (x
) == NULL_TREE
)
3592 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3594 /* ARM $12.6.2: [A member initializer list] (or, for an
3595 aggregate, initialization by a brace-enclosed list) is the
3596 only way to initialize nonstatic const and reference
3598 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
3599 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) = 1;
3601 /* A field that is pseudo-const makes the structure likewise. */
3602 else if (CLASS_TYPE_P (type
))
3604 C_TYPE_FIELDS_READONLY (t
) |= C_TYPE_FIELDS_READONLY (type
);
3605 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
,
3606 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
3607 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
));
3610 /* Core issue 80: A nonstatic data member is required to have a
3611 different name from the class iff the class has a
3612 user-declared constructor. */
3613 if (constructor_name_p (DECL_NAME (x
), t
)
3614 && TYPE_HAS_USER_CONSTRUCTOR (t
))
3615 permerror (input_location
, "field %q+#D with same name as class", x
);
3618 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3619 it should also define a copy constructor and an assignment operator to
3620 implement the correct copy semantic (deep vs shallow, etc.). As it is
3621 not feasible to check whether the constructors do allocate dynamic memory
3622 and store it within members, we approximate the warning like this:
3624 -- Warn only if there are members which are pointers
3625 -- Warn only if there is a non-trivial constructor (otherwise,
3626 there cannot be memory allocated).
3627 -- Warn only if there is a non-trivial destructor. We assume that the
3628 user at least implemented the cleanup correctly, and a destructor
3629 is needed to free dynamic memory.
3631 This seems enough for practical purposes. */
3634 && TYPE_HAS_USER_CONSTRUCTOR (t
)
3635 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3636 && !(TYPE_HAS_COPY_CTOR (t
) && TYPE_HAS_COPY_ASSIGN (t
)))
3638 warning (OPT_Weffc__
, "%q#T has pointer data members", t
);
3640 if (! TYPE_HAS_COPY_CTOR (t
))
3642 warning (OPT_Weffc__
,
3643 " but does not override %<%T(const %T&)%>", t
, t
);
3644 if (!TYPE_HAS_COPY_ASSIGN (t
))
3645 warning (OPT_Weffc__
, " or %<operator=(const %T&)%>", t
);
3647 else if (! TYPE_HAS_COPY_ASSIGN (t
))
3648 warning (OPT_Weffc__
,
3649 " but does not override %<operator=(const %T&)%>", t
);
3652 /* Non-static data member initializers make the default constructor
3654 if (any_default_members
)
3656 TYPE_NEEDS_CONSTRUCTING (t
) = true;
3657 TYPE_HAS_COMPLEX_DFLT (t
) = true;
3660 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3662 TYPE_PACKED (t
) = 0;
3664 /* Check anonymous struct/anonymous union fields. */
3665 finish_struct_anon (t
);
3667 /* We've built up the list of access declarations in reverse order.
3669 *access_decls
= nreverse (*access_decls
);
3672 /* If TYPE is an empty class type, records its OFFSET in the table of
3676 record_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3680 if (!is_empty_class (type
))
3683 /* Record the location of this empty object in OFFSETS. */
3684 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3686 n
= splay_tree_insert (offsets
,
3687 (splay_tree_key
) offset
,
3688 (splay_tree_value
) NULL_TREE
);
3689 n
->value
= ((splay_tree_value
)
3690 tree_cons (NULL_TREE
,
3697 /* Returns nonzero if TYPE is an empty class type and there is
3698 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3701 check_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3706 if (!is_empty_class (type
))
3709 /* Record the location of this empty object in OFFSETS. */
3710 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3714 for (t
= (tree
) n
->value
; t
; t
= TREE_CHAIN (t
))
3715 if (same_type_p (TREE_VALUE (t
), type
))
3721 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3722 F for every subobject, passing it the type, offset, and table of
3723 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3726 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3727 than MAX_OFFSET will not be walked.
3729 If F returns a nonzero value, the traversal ceases, and that value
3730 is returned. Otherwise, returns zero. */
3733 walk_subobject_offsets (tree type
,
3734 subobject_offset_fn f
,
3741 tree type_binfo
= NULL_TREE
;
3743 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3745 if (max_offset
&& INT_CST_LT (max_offset
, offset
))
3748 if (type
== error_mark_node
)
3753 if (abi_version_at_least (2))
3755 type
= BINFO_TYPE (type
);
3758 if (CLASS_TYPE_P (type
))
3764 /* Avoid recursing into objects that are not interesting. */
3765 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3768 /* Record the location of TYPE. */
3769 r
= (*f
) (type
, offset
, offsets
);
3773 /* Iterate through the direct base classes of TYPE. */
3775 type_binfo
= TYPE_BINFO (type
);
3776 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, binfo
); i
++)
3780 if (abi_version_at_least (2)
3781 && BINFO_VIRTUAL_P (binfo
))
3785 && BINFO_VIRTUAL_P (binfo
)
3786 && !BINFO_PRIMARY_P (binfo
))
3789 if (!abi_version_at_least (2))
3790 binfo_offset
= size_binop (PLUS_EXPR
,
3792 BINFO_OFFSET (binfo
));
3796 /* We cannot rely on BINFO_OFFSET being set for the base
3797 class yet, but the offsets for direct non-virtual
3798 bases can be calculated by going back to the TYPE. */
3799 orig_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
3800 binfo_offset
= size_binop (PLUS_EXPR
,
3802 BINFO_OFFSET (orig_binfo
));
3805 r
= walk_subobject_offsets (binfo
,
3810 (abi_version_at_least (2)
3811 ? /*vbases_p=*/0 : vbases_p
));
3816 if (abi_version_at_least (2) && CLASSTYPE_VBASECLASSES (type
))
3819 vec
<tree
, va_gc
> *vbases
;
3821 /* Iterate through the virtual base classes of TYPE. In G++
3822 3.2, we included virtual bases in the direct base class
3823 loop above, which results in incorrect results; the
3824 correct offsets for virtual bases are only known when
3825 working with the most derived type. */
3827 for (vbases
= CLASSTYPE_VBASECLASSES (type
), ix
= 0;
3828 vec_safe_iterate (vbases
, ix
, &binfo
); ix
++)
3830 r
= walk_subobject_offsets (binfo
,
3832 size_binop (PLUS_EXPR
,
3834 BINFO_OFFSET (binfo
)),
3843 /* We still have to walk the primary base, if it is
3844 virtual. (If it is non-virtual, then it was walked
3846 tree vbase
= get_primary_binfo (type_binfo
);
3848 if (vbase
&& BINFO_VIRTUAL_P (vbase
)
3849 && BINFO_PRIMARY_P (vbase
)
3850 && BINFO_INHERITANCE_CHAIN (vbase
) == type_binfo
)
3852 r
= (walk_subobject_offsets
3854 offsets
, max_offset
, /*vbases_p=*/0));
3861 /* Iterate through the fields of TYPE. */
3862 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3863 if (TREE_CODE (field
) == FIELD_DECL
3864 && TREE_TYPE (field
) != error_mark_node
3865 && !DECL_ARTIFICIAL (field
))
3869 if (abi_version_at_least (2))
3870 field_offset
= byte_position (field
);
3872 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3873 field_offset
= DECL_FIELD_OFFSET (field
);
3875 r
= walk_subobject_offsets (TREE_TYPE (field
),
3877 size_binop (PLUS_EXPR
,
3887 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3889 tree element_type
= strip_array_types (type
);
3890 tree domain
= TYPE_DOMAIN (type
);
3893 /* Avoid recursing into objects that are not interesting. */
3894 if (!CLASS_TYPE_P (element_type
)
3895 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type
))
3898 /* Step through each of the elements in the array. */
3899 for (index
= size_zero_node
;
3900 /* G++ 3.2 had an off-by-one error here. */
3901 (abi_version_at_least (2)
3902 ? !INT_CST_LT (TYPE_MAX_VALUE (domain
), index
)
3903 : INT_CST_LT (index
, TYPE_MAX_VALUE (domain
)));
3904 index
= size_binop (PLUS_EXPR
, index
, size_one_node
))
3906 r
= walk_subobject_offsets (TREE_TYPE (type
),
3914 offset
= size_binop (PLUS_EXPR
, offset
,
3915 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3916 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3917 there's no point in iterating through the remaining
3918 elements of the array. */
3919 if (max_offset
&& INT_CST_LT (max_offset
, offset
))
3927 /* Record all of the empty subobjects of TYPE (either a type or a
3928 binfo). If IS_DATA_MEMBER is true, then a non-static data member
3929 is being placed at OFFSET; otherwise, it is a base class that is
3930 being placed at OFFSET. */
3933 record_subobject_offsets (tree type
,
3936 bool is_data_member
)
3939 /* If recording subobjects for a non-static data member or a
3940 non-empty base class , we do not need to record offsets beyond
3941 the size of the biggest empty class. Additional data members
3942 will go at the end of the class. Additional base classes will go
3943 either at offset zero (if empty, in which case they cannot
3944 overlap with offsets past the size of the biggest empty class) or
3945 at the end of the class.
3947 However, if we are placing an empty base class, then we must record
3948 all offsets, as either the empty class is at offset zero (where
3949 other empty classes might later be placed) or at the end of the
3950 class (where other objects might then be placed, so other empty
3951 subobjects might later overlap). */
3953 || !is_empty_class (BINFO_TYPE (type
)))
3954 max_offset
= sizeof_biggest_empty_class
;
3956 max_offset
= NULL_TREE
;
3957 walk_subobject_offsets (type
, record_subobject_offset
, offset
,
3958 offsets
, max_offset
, is_data_member
);
3961 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3962 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3963 virtual bases of TYPE are examined. */
3966 layout_conflict_p (tree type
,
3971 splay_tree_node max_node
;
3973 /* Get the node in OFFSETS that indicates the maximum offset where
3974 an empty subobject is located. */
3975 max_node
= splay_tree_max (offsets
);
3976 /* If there aren't any empty subobjects, then there's no point in
3977 performing this check. */
3981 return walk_subobject_offsets (type
, check_subobject_offset
, offset
,
3982 offsets
, (tree
) (max_node
->key
),
3986 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3987 non-static data member of the type indicated by RLI. BINFO is the
3988 binfo corresponding to the base subobject, OFFSETS maps offsets to
3989 types already located at those offsets. This function determines
3990 the position of the DECL. */
3993 layout_nonempty_base_or_field (record_layout_info rli
,
3998 tree offset
= NULL_TREE
;
4004 /* For the purposes of determining layout conflicts, we want to
4005 use the class type of BINFO; TREE_TYPE (DECL) will be the
4006 CLASSTYPE_AS_BASE version, which does not contain entries for
4007 zero-sized bases. */
4008 type
= TREE_TYPE (binfo
);
4013 type
= TREE_TYPE (decl
);
4017 /* Try to place the field. It may take more than one try if we have
4018 a hard time placing the field without putting two objects of the
4019 same type at the same address. */
4022 struct record_layout_info_s old_rli
= *rli
;
4024 /* Place this field. */
4025 place_field (rli
, decl
);
4026 offset
= byte_position (decl
);
4028 /* We have to check to see whether or not there is already
4029 something of the same type at the offset we're about to use.
4030 For example, consider:
4033 struct T : public S { int i; };
4034 struct U : public S, public T {};
4036 Here, we put S at offset zero in U. Then, we can't put T at
4037 offset zero -- its S component would be at the same address
4038 as the S we already allocated. So, we have to skip ahead.
4039 Since all data members, including those whose type is an
4040 empty class, have nonzero size, any overlap can happen only
4041 with a direct or indirect base-class -- it can't happen with
4043 /* In a union, overlap is permitted; all members are placed at
4045 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
4047 /* G++ 3.2 did not check for overlaps when placing a non-empty
4049 if (!abi_version_at_least (2) && binfo
&& BINFO_VIRTUAL_P (binfo
))
4051 if (layout_conflict_p (field_p
? type
: binfo
, offset
,
4054 /* Strip off the size allocated to this field. That puts us
4055 at the first place we could have put the field with
4056 proper alignment. */
4059 /* Bump up by the alignment required for the type. */
4061 = size_binop (PLUS_EXPR
, rli
->bitpos
,
4063 ? CLASSTYPE_ALIGN (type
)
4064 : TYPE_ALIGN (type
)));
4065 normalize_rli (rli
);
4068 /* There was no conflict. We're done laying out this field. */
4072 /* Now that we know where it will be placed, update its
4074 if (binfo
&& CLASS_TYPE_P (BINFO_TYPE (binfo
)))
4075 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
4076 this point because their BINFO_OFFSET is copied from another
4077 hierarchy. Therefore, we may not need to add the entire
4079 propagate_binfo_offsets (binfo
,
4080 size_diffop_loc (input_location
,
4081 convert (ssizetype
, offset
),
4083 BINFO_OFFSET (binfo
))));
4086 /* Returns true if TYPE is empty and OFFSET is nonzero. */
4089 empty_base_at_nonzero_offset_p (tree type
,
4091 splay_tree
/*offsets*/)
4093 return is_empty_class (type
) && !integer_zerop (offset
);
4096 /* Layout the empty base BINFO. EOC indicates the byte currently just
4097 past the end of the class, and should be correctly aligned for a
4098 class of the type indicated by BINFO; OFFSETS gives the offsets of
4099 the empty bases allocated so far. T is the most derived
4100 type. Return nonzero iff we added it at the end. */
4103 layout_empty_base (record_layout_info rli
, tree binfo
,
4104 tree eoc
, splay_tree offsets
)
4107 tree basetype
= BINFO_TYPE (binfo
);
4110 /* This routine should only be used for empty classes. */
4111 gcc_assert (is_empty_class (basetype
));
4112 alignment
= ssize_int (CLASSTYPE_ALIGN_UNIT (basetype
));
4114 if (!integer_zerop (BINFO_OFFSET (binfo
)))
4116 if (abi_version_at_least (2))
4117 propagate_binfo_offsets
4118 (binfo
, size_diffop_loc (input_location
,
4119 size_zero_node
, BINFO_OFFSET (binfo
)));
4122 "offset of empty base %qT may not be ABI-compliant and may"
4123 "change in a future version of GCC",
4124 BINFO_TYPE (binfo
));
4127 /* This is an empty base class. We first try to put it at offset
4129 if (layout_conflict_p (binfo
,
4130 BINFO_OFFSET (binfo
),
4134 /* That didn't work. Now, we move forward from the next
4135 available spot in the class. */
4137 propagate_binfo_offsets (binfo
, convert (ssizetype
, eoc
));
4140 if (!layout_conflict_p (binfo
,
4141 BINFO_OFFSET (binfo
),
4144 /* We finally found a spot where there's no overlap. */
4147 /* There's overlap here, too. Bump along to the next spot. */
4148 propagate_binfo_offsets (binfo
, alignment
);
4152 if (CLASSTYPE_USER_ALIGN (basetype
))
4154 rli
->record_align
= MAX (rli
->record_align
, CLASSTYPE_ALIGN (basetype
));
4156 rli
->unpacked_align
= MAX (rli
->unpacked_align
, CLASSTYPE_ALIGN (basetype
));
4157 TYPE_USER_ALIGN (rli
->t
) = 1;
4163 /* Layout the base given by BINFO in the class indicated by RLI.
4164 *BASE_ALIGN is a running maximum of the alignments of
4165 any base class. OFFSETS gives the location of empty base
4166 subobjects. T is the most derived type. Return nonzero if the new
4167 object cannot be nearly-empty. A new FIELD_DECL is inserted at
4168 *NEXT_FIELD, unless BINFO is for an empty base class.
4170 Returns the location at which the next field should be inserted. */
4173 build_base_field (record_layout_info rli
, tree binfo
,
4174 splay_tree offsets
, tree
*next_field
)
4177 tree basetype
= BINFO_TYPE (binfo
);
4179 if (!COMPLETE_TYPE_P (basetype
))
4180 /* This error is now reported in xref_tag, thus giving better
4181 location information. */
4184 /* Place the base class. */
4185 if (!is_empty_class (basetype
))
4189 /* The containing class is non-empty because it has a non-empty
4191 CLASSTYPE_EMPTY_P (t
) = 0;
4193 /* Create the FIELD_DECL. */
4194 decl
= build_decl (input_location
,
4195 FIELD_DECL
, NULL_TREE
, CLASSTYPE_AS_BASE (basetype
));
4196 DECL_ARTIFICIAL (decl
) = 1;
4197 DECL_IGNORED_P (decl
) = 1;
4198 DECL_FIELD_CONTEXT (decl
) = t
;
4199 if (CLASSTYPE_AS_BASE (basetype
))
4201 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
4202 DECL_SIZE_UNIT (decl
) = CLASSTYPE_SIZE_UNIT (basetype
);
4203 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
4204 DECL_USER_ALIGN (decl
) = CLASSTYPE_USER_ALIGN (basetype
);
4205 DECL_MODE (decl
) = TYPE_MODE (basetype
);
4206 DECL_FIELD_IS_BASE (decl
) = 1;
4208 /* Try to place the field. It may take more than one try if we
4209 have a hard time placing the field without putting two
4210 objects of the same type at the same address. */
4211 layout_nonempty_base_or_field (rli
, decl
, binfo
, offsets
);
4212 /* Add the new FIELD_DECL to the list of fields for T. */
4213 DECL_CHAIN (decl
) = *next_field
;
4215 next_field
= &DECL_CHAIN (decl
);
4223 /* On some platforms (ARM), even empty classes will not be
4225 eoc
= round_up_loc (input_location
,
4226 rli_size_unit_so_far (rli
),
4227 CLASSTYPE_ALIGN_UNIT (basetype
));
4228 atend
= layout_empty_base (rli
, binfo
, eoc
, offsets
);
4229 /* A nearly-empty class "has no proper base class that is empty,
4230 not morally virtual, and at an offset other than zero." */
4231 if (!BINFO_VIRTUAL_P (binfo
) && CLASSTYPE_NEARLY_EMPTY_P (t
))
4234 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4235 /* The check above (used in G++ 3.2) is insufficient because
4236 an empty class placed at offset zero might itself have an
4237 empty base at a nonzero offset. */
4238 else if (walk_subobject_offsets (basetype
,
4239 empty_base_at_nonzero_offset_p
,
4242 /*max_offset=*/NULL_TREE
,
4245 if (abi_version_at_least (2))
4246 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4249 "class %qT will be considered nearly empty in a "
4250 "future version of GCC", t
);
4254 /* We do not create a FIELD_DECL for empty base classes because
4255 it might overlap some other field. We want to be able to
4256 create CONSTRUCTORs for the class by iterating over the
4257 FIELD_DECLs, and the back end does not handle overlapping
4260 /* An empty virtual base causes a class to be non-empty
4261 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
4262 here because that was already done when the virtual table
4263 pointer was created. */
4266 /* Record the offsets of BINFO and its base subobjects. */
4267 record_subobject_offsets (binfo
,
4268 BINFO_OFFSET (binfo
),
4270 /*is_data_member=*/false);
4275 /* Layout all of the non-virtual base classes. Record empty
4276 subobjects in OFFSETS. T is the most derived type. Return nonzero
4277 if the type cannot be nearly empty. The fields created
4278 corresponding to the base classes will be inserted at
4282 build_base_fields (record_layout_info rli
,
4283 splay_tree offsets
, tree
*next_field
)
4285 /* Chain to hold all the new FIELD_DECLs which stand in for base class
4288 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
4291 /* The primary base class is always allocated first. */
4292 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
4293 next_field
= build_base_field (rli
, CLASSTYPE_PRIMARY_BINFO (t
),
4294 offsets
, next_field
);
4296 /* Now allocate the rest of the bases. */
4297 for (i
= 0; i
< n_baseclasses
; ++i
)
4301 base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (t
), i
);
4303 /* The primary base was already allocated above, so we don't
4304 need to allocate it again here. */
4305 if (base_binfo
== CLASSTYPE_PRIMARY_BINFO (t
))
4308 /* Virtual bases are added at the end (a primary virtual base
4309 will have already been added). */
4310 if (BINFO_VIRTUAL_P (base_binfo
))
4313 next_field
= build_base_field (rli
, base_binfo
,
4314 offsets
, next_field
);
4318 /* Go through the TYPE_METHODS of T issuing any appropriate
4319 diagnostics, figuring out which methods override which other
4320 methods, and so forth. */
4323 check_methods (tree t
)
4327 for (x
= TYPE_METHODS (t
); x
; x
= DECL_CHAIN (x
))
4329 check_for_override (x
, t
);
4330 if (DECL_PURE_VIRTUAL_P (x
) && ! DECL_VINDEX (x
))
4331 error ("initializer specified for non-virtual method %q+D", x
);
4332 /* The name of the field is the original field name
4333 Save this in auxiliary field for later overloading. */
4334 if (DECL_VINDEX (x
))
4336 TYPE_POLYMORPHIC_P (t
) = 1;
4337 if (DECL_PURE_VIRTUAL_P (x
))
4338 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t
), x
);
4340 /* All user-provided destructors are non-trivial.
4341 Constructors and assignment ops are handled in
4342 grok_special_member_properties. */
4343 if (DECL_DESTRUCTOR_P (x
) && user_provided_p (x
))
4344 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = 1;
4348 /* FN is a constructor or destructor. Clone the declaration to create
4349 a specialized in-charge or not-in-charge version, as indicated by
4353 build_clone (tree fn
, tree name
)
4358 /* Copy the function. */
4359 clone
= copy_decl (fn
);
4360 /* Reset the function name. */
4361 DECL_NAME (clone
) = name
;
4362 SET_DECL_ASSEMBLER_NAME (clone
, NULL_TREE
);
4363 /* Remember where this function came from. */
4364 DECL_ABSTRACT_ORIGIN (clone
) = fn
;
4365 /* Make it easy to find the CLONE given the FN. */
4366 DECL_CHAIN (clone
) = DECL_CHAIN (fn
);
4367 DECL_CHAIN (fn
) = clone
;
4369 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
4370 if (TREE_CODE (clone
) == TEMPLATE_DECL
)
4372 tree result
= build_clone (DECL_TEMPLATE_RESULT (clone
), name
);
4373 DECL_TEMPLATE_RESULT (clone
) = result
;
4374 DECL_TEMPLATE_INFO (result
) = copy_node (DECL_TEMPLATE_INFO (result
));
4375 DECL_TI_TEMPLATE (result
) = clone
;
4376 TREE_TYPE (clone
) = TREE_TYPE (result
);
4380 DECL_CLONED_FUNCTION (clone
) = fn
;
4381 /* There's no pending inline data for this function. */
4382 DECL_PENDING_INLINE_INFO (clone
) = NULL
;
4383 DECL_PENDING_INLINE_P (clone
) = 0;
4385 /* The base-class destructor is not virtual. */
4386 if (name
== base_dtor_identifier
)
4388 DECL_VIRTUAL_P (clone
) = 0;
4389 if (TREE_CODE (clone
) != TEMPLATE_DECL
)
4390 DECL_VINDEX (clone
) = NULL_TREE
;
4393 /* If there was an in-charge parameter, drop it from the function
4395 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
4401 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4402 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4403 parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4404 /* Skip the `this' parameter. */
4405 parmtypes
= TREE_CHAIN (parmtypes
);
4406 /* Skip the in-charge parameter. */
4407 parmtypes
= TREE_CHAIN (parmtypes
);
4408 /* And the VTT parm, in a complete [cd]tor. */
4409 if (DECL_HAS_VTT_PARM_P (fn
)
4410 && ! DECL_NEEDS_VTT_PARM_P (clone
))
4411 parmtypes
= TREE_CHAIN (parmtypes
);
4412 /* If this is subobject constructor or destructor, add the vtt
4415 = build_method_type_directly (basetype
,
4416 TREE_TYPE (TREE_TYPE (clone
)),
4419 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
),
4422 = cp_build_type_attribute_variant (TREE_TYPE (clone
),
4423 TYPE_ATTRIBUTES (TREE_TYPE (fn
)));
4426 /* Copy the function parameters. */
4427 DECL_ARGUMENTS (clone
) = copy_list (DECL_ARGUMENTS (clone
));
4428 /* Remove the in-charge parameter. */
4429 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
4431 DECL_CHAIN (DECL_ARGUMENTS (clone
))
4432 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
)));
4433 DECL_HAS_IN_CHARGE_PARM_P (clone
) = 0;
4435 /* And the VTT parm, in a complete [cd]tor. */
4436 if (DECL_HAS_VTT_PARM_P (fn
))
4438 if (DECL_NEEDS_VTT_PARM_P (clone
))
4439 DECL_HAS_VTT_PARM_P (clone
) = 1;
4442 DECL_CHAIN (DECL_ARGUMENTS (clone
))
4443 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
)));
4444 DECL_HAS_VTT_PARM_P (clone
) = 0;
4448 for (parms
= DECL_ARGUMENTS (clone
); parms
; parms
= DECL_CHAIN (parms
))
4450 DECL_CONTEXT (parms
) = clone
;
4451 cxx_dup_lang_specific_decl (parms
);
4454 /* Create the RTL for this function. */
4455 SET_DECL_RTL (clone
, NULL
);
4456 rest_of_decl_compilation (clone
, /*top_level=*/1, at_eof
);
4459 note_decl_for_pch (clone
);
4464 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
4465 not invoke this function directly.
4467 For a non-thunk function, returns the address of the slot for storing
4468 the function it is a clone of. Otherwise returns NULL_TREE.
4470 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
4471 cloned_function is unset. This is to support the separate
4472 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
4473 on a template makes sense, but not the former. */
4476 decl_cloned_function_p (const_tree decl
, bool just_testing
)
4480 decl
= STRIP_TEMPLATE (decl
);
4482 if (TREE_CODE (decl
) != FUNCTION_DECL
4483 || !DECL_LANG_SPECIFIC (decl
)
4484 || DECL_LANG_SPECIFIC (decl
)->u
.fn
.thunk_p
)
4486 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4488 lang_check_failed (__FILE__
, __LINE__
, __FUNCTION__
);
4494 ptr
= &DECL_LANG_SPECIFIC (decl
)->u
.fn
.u5
.cloned_function
;
4495 if (just_testing
&& *ptr
== NULL_TREE
)
4501 /* Produce declarations for all appropriate clones of FN. If
4502 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4503 CLASTYPE_METHOD_VEC as well. */
4506 clone_function_decl (tree fn
, int update_method_vec_p
)
4510 /* Avoid inappropriate cloning. */
4512 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (fn
)))
4515 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
4517 /* For each constructor, we need two variants: an in-charge version
4518 and a not-in-charge version. */
4519 clone
= build_clone (fn
, complete_ctor_identifier
);
4520 if (update_method_vec_p
)
4521 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4522 clone
= build_clone (fn
, base_ctor_identifier
);
4523 if (update_method_vec_p
)
4524 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4528 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
));
4530 /* For each destructor, we need three variants: an in-charge
4531 version, a not-in-charge version, and an in-charge deleting
4532 version. We clone the deleting version first because that
4533 means it will go second on the TYPE_METHODS list -- and that
4534 corresponds to the correct layout order in the virtual
4537 For a non-virtual destructor, we do not build a deleting
4539 if (DECL_VIRTUAL_P (fn
))
4541 clone
= build_clone (fn
, deleting_dtor_identifier
);
4542 if (update_method_vec_p
)
4543 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4545 clone
= build_clone (fn
, complete_dtor_identifier
);
4546 if (update_method_vec_p
)
4547 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4548 clone
= build_clone (fn
, base_dtor_identifier
);
4549 if (update_method_vec_p
)
4550 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4553 /* Note that this is an abstract function that is never emitted. */
4554 DECL_ABSTRACT (fn
) = 1;
4557 /* DECL is an in charge constructor, which is being defined. This will
4558 have had an in class declaration, from whence clones were
4559 declared. An out-of-class definition can specify additional default
4560 arguments. As it is the clones that are involved in overload
4561 resolution, we must propagate the information from the DECL to its
4565 adjust_clone_args (tree decl
)
4569 for (clone
= DECL_CHAIN (decl
); clone
&& DECL_CLONED_FUNCTION_P (clone
);
4570 clone
= DECL_CHAIN (clone
))
4572 tree orig_clone_parms
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4573 tree orig_decl_parms
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
4574 tree decl_parms
, clone_parms
;
4576 clone_parms
= orig_clone_parms
;
4578 /* Skip the 'this' parameter. */
4579 orig_clone_parms
= TREE_CHAIN (orig_clone_parms
);
4580 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4582 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
4583 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4584 if (DECL_HAS_VTT_PARM_P (decl
))
4585 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4587 clone_parms
= orig_clone_parms
;
4588 if (DECL_HAS_VTT_PARM_P (clone
))
4589 clone_parms
= TREE_CHAIN (clone_parms
);
4591 for (decl_parms
= orig_decl_parms
; decl_parms
;
4592 decl_parms
= TREE_CHAIN (decl_parms
),
4593 clone_parms
= TREE_CHAIN (clone_parms
))
4595 gcc_assert (same_type_p (TREE_TYPE (decl_parms
),
4596 TREE_TYPE (clone_parms
)));
4598 if (TREE_PURPOSE (decl_parms
) && !TREE_PURPOSE (clone_parms
))
4600 /* A default parameter has been added. Adjust the
4601 clone's parameters. */
4602 tree exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4603 tree attrs
= TYPE_ATTRIBUTES (TREE_TYPE (clone
));
4604 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4607 clone_parms
= orig_decl_parms
;
4609 if (DECL_HAS_VTT_PARM_P (clone
))
4611 clone_parms
= tree_cons (TREE_PURPOSE (orig_clone_parms
),
4612 TREE_VALUE (orig_clone_parms
),
4614 TREE_TYPE (clone_parms
) = TREE_TYPE (orig_clone_parms
);
4616 type
= build_method_type_directly (basetype
,
4617 TREE_TYPE (TREE_TYPE (clone
)),
4620 type
= build_exception_variant (type
, exceptions
);
4622 type
= cp_build_type_attribute_variant (type
, attrs
);
4623 TREE_TYPE (clone
) = type
;
4625 clone_parms
= NULL_TREE
;
4629 gcc_assert (!clone_parms
);
4633 /* For each of the constructors and destructors in T, create an
4634 in-charge and not-in-charge variant. */
4637 clone_constructors_and_destructors (tree t
)
4641 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4643 if (!CLASSTYPE_METHOD_VEC (t
))
4646 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4647 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
4648 for (fns
= CLASSTYPE_DESTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4649 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
4652 /* Deduce noexcept for a destructor DTOR. */
4655 deduce_noexcept_on_destructor (tree dtor
)
4657 if (!TYPE_RAISES_EXCEPTIONS (TREE_TYPE (dtor
)))
4659 tree ctx
= DECL_CONTEXT (dtor
);
4660 tree implicit_fn
= implicitly_declare_fn (sfk_destructor
, ctx
,
4663 tree eh_spec
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn
));
4664 TREE_TYPE (dtor
) = build_exception_variant (TREE_TYPE (dtor
), eh_spec
);
4668 /* For each destructor in T, deduce noexcept:
4670 12.4/3: A declaration of a destructor that does not have an
4671 exception-specification is implicitly considered to have the
4672 same exception-specification as an implicit declaration (15.4). */
4675 deduce_noexcept_on_destructors (tree t
)
4677 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4679 if (!CLASSTYPE_METHOD_VEC (t
))
4682 for (tree fns
= CLASSTYPE_DESTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4683 deduce_noexcept_on_destructor (OVL_CURRENT (fns
));
4686 /* Subroutine of set_one_vmethod_tm_attributes. Search base classes
4687 of TYPE for virtual functions which FNDECL overrides. Return a
4688 mask of the tm attributes found therein. */
4691 look_for_tm_attr_overrides (tree type
, tree fndecl
)
4693 tree binfo
= TYPE_BINFO (type
);
4697 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ++ix
)
4699 tree o
, basetype
= BINFO_TYPE (base_binfo
);
4701 if (!TYPE_POLYMORPHIC_P (basetype
))
4704 o
= look_for_overrides_here (basetype
, fndecl
);
4706 found
|= tm_attr_to_mask (find_tm_attribute
4707 (TYPE_ATTRIBUTES (TREE_TYPE (o
))));
4709 found
|= look_for_tm_attr_overrides (basetype
, fndecl
);
4715 /* Subroutine of set_method_tm_attributes. Handle the checks and
4716 inheritance for one virtual method FNDECL. */
4719 set_one_vmethod_tm_attributes (tree type
, tree fndecl
)
4724 found
= look_for_tm_attr_overrides (type
, fndecl
);
4726 /* If FNDECL doesn't actually override anything (i.e. T is the
4727 class that first declares FNDECL virtual), then we're done. */
4731 tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl
)));
4732 have
= tm_attr_to_mask (tm_attr
);
4734 /* Intel STM Language Extension 3.0, Section 4.2 table 4:
4735 tm_pure must match exactly, otherwise no weakening of
4736 tm_safe > tm_callable > nothing. */
4737 /* ??? The tm_pure attribute didn't make the transition to the
4738 multivendor language spec. */
4739 if (have
== TM_ATTR_PURE
)
4741 if (found
!= TM_ATTR_PURE
)
4747 /* If the overridden function is tm_pure, then FNDECL must be. */
4748 else if (found
== TM_ATTR_PURE
&& tm_attr
)
4750 /* Look for base class combinations that cannot be satisfied. */
4751 else if (found
!= TM_ATTR_PURE
&& (found
& TM_ATTR_PURE
))
4753 found
&= ~TM_ATTR_PURE
;
4755 error_at (DECL_SOURCE_LOCATION (fndecl
),
4756 "method overrides both %<transaction_pure%> and %qE methods",
4757 tm_mask_to_attr (found
));
4759 /* If FNDECL did not declare an attribute, then inherit the most
4761 else if (tm_attr
== NULL
)
4763 apply_tm_attr (fndecl
, tm_mask_to_attr (found
& -found
));
4765 /* Otherwise validate that we're not weaker than a function
4766 that is being overridden. */
4770 if (found
<= TM_ATTR_CALLABLE
&& have
> found
)
4776 error_at (DECL_SOURCE_LOCATION (fndecl
),
4777 "method declared %qE overriding %qE method",
4778 tm_attr
, tm_mask_to_attr (found
));
4781 /* For each of the methods in T, propagate a class-level tm attribute. */
4784 set_method_tm_attributes (tree t
)
4786 tree class_tm_attr
, fndecl
;
4788 /* Don't bother collecting tm attributes if transactional memory
4789 support is not enabled. */
4793 /* Process virtual methods first, as they inherit directly from the
4794 base virtual function and also require validation of new attributes. */
4795 if (TYPE_CONTAINS_VPTR_P (t
))
4798 for (vchain
= BINFO_VIRTUALS (TYPE_BINFO (t
)); vchain
;
4799 vchain
= TREE_CHAIN (vchain
))
4801 fndecl
= BV_FN (vchain
);
4802 if (DECL_THUNK_P (fndecl
))
4803 fndecl
= THUNK_TARGET (fndecl
);
4804 set_one_vmethod_tm_attributes (t
, fndecl
);
4808 /* If the class doesn't have an attribute, nothing more to do. */
4809 class_tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (t
));
4810 if (class_tm_attr
== NULL
)
4813 /* Any method that does not yet have a tm attribute inherits
4814 the one from the class. */
4815 for (fndecl
= TYPE_METHODS (t
); fndecl
; fndecl
= TREE_CHAIN (fndecl
))
4817 if (!find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
4818 apply_tm_attr (fndecl
, class_tm_attr
);
4822 /* Returns true iff class T has a user-defined constructor other than
4823 the default constructor. */
4826 type_has_user_nondefault_constructor (tree t
)
4830 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4833 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4835 tree fn
= OVL_CURRENT (fns
);
4836 if (!DECL_ARTIFICIAL (fn
)
4837 && (TREE_CODE (fn
) == TEMPLATE_DECL
4838 || (skip_artificial_parms_for (fn
, DECL_ARGUMENTS (fn
))
4846 /* Returns the defaulted constructor if T has one. Otherwise, returns
4850 in_class_defaulted_default_constructor (tree t
)
4854 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4857 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4859 tree fn
= OVL_CURRENT (fns
);
4861 if (DECL_DEFAULTED_IN_CLASS_P (fn
))
4863 args
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
4864 while (args
&& TREE_PURPOSE (args
))
4865 args
= TREE_CHAIN (args
);
4866 if (!args
|| args
== void_list_node
)
4874 /* Returns true iff FN is a user-provided function, i.e. user-declared
4875 and not defaulted at its first declaration; or explicit, private,
4876 protected, or non-const. */
4879 user_provided_p (tree fn
)
4881 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4884 return (!DECL_ARTIFICIAL (fn
)
4885 && !(DECL_INITIALIZED_IN_CLASS_P (fn
)
4886 && (DECL_DEFAULTED_FN (fn
) || DECL_DELETED_FN (fn
))));
4889 /* Returns true iff class T has a user-provided constructor. */
4892 type_has_user_provided_constructor (tree t
)
4896 if (!CLASS_TYPE_P (t
))
4899 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4902 /* This can happen in error cases; avoid crashing. */
4903 if (!CLASSTYPE_METHOD_VEC (t
))
4906 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4907 if (user_provided_p (OVL_CURRENT (fns
)))
4913 /* Returns true iff class T has a user-provided default constructor. */
4916 type_has_user_provided_default_constructor (tree t
)
4920 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4923 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4925 tree fn
= OVL_CURRENT (fns
);
4926 if (TREE_CODE (fn
) == FUNCTION_DECL
4927 && user_provided_p (fn
)
4928 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)))
4935 /* TYPE is being used as a virtual base, and has a non-trivial move
4936 assignment. Return true if this is due to there being a user-provided
4937 move assignment in TYPE or one of its subobjects; if there isn't, then
4938 multiple move assignment can't cause any harm. */
4941 vbase_has_user_provided_move_assign (tree type
)
4943 /* Does the type itself have a user-provided move assignment operator? */
4945 = lookup_fnfields_slot_nolazy (type
, ansi_assopname (NOP_EXPR
));
4946 fns
; fns
= OVL_NEXT (fns
))
4948 tree fn
= OVL_CURRENT (fns
);
4949 if (move_fn_p (fn
) && user_provided_p (fn
))
4953 /* Do any of its bases? */
4954 tree binfo
= TYPE_BINFO (type
);
4956 for (int i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
4957 if (vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo
)))
4960 /* Or non-static data members? */
4961 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
4963 if (TREE_CODE (field
) == FIELD_DECL
4964 && CLASS_TYPE_P (TREE_TYPE (field
))
4965 && vbase_has_user_provided_move_assign (TREE_TYPE (field
)))
4973 /* If default-initialization leaves part of TYPE uninitialized, returns
4974 a DECL for the field or TYPE itself (DR 253). */
4977 default_init_uninitialized_part (tree type
)
4982 type
= strip_array_types (type
);
4983 if (!CLASS_TYPE_P (type
))
4985 if (type_has_user_provided_default_constructor (type
))
4987 for (binfo
= TYPE_BINFO (type
), i
= 0;
4988 BINFO_BASE_ITERATE (binfo
, i
, t
); ++i
)
4990 r
= default_init_uninitialized_part (BINFO_TYPE (t
));
4994 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
4995 if (TREE_CODE (t
) == FIELD_DECL
4996 && !DECL_ARTIFICIAL (t
)
4997 && !DECL_INITIAL (t
))
4999 r
= default_init_uninitialized_part (TREE_TYPE (t
));
5001 return DECL_P (r
) ? r
: t
;
5007 /* Returns true iff for class T, a trivial synthesized default constructor
5008 would be constexpr. */
5011 trivial_default_constructor_is_constexpr (tree t
)
5013 /* A defaulted trivial default constructor is constexpr
5014 if there is nothing to initialize. */
5015 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (t
));
5016 return is_really_empty_class (t
);
5019 /* Returns true iff class T has a constexpr default constructor. */
5022 type_has_constexpr_default_constructor (tree t
)
5026 if (!CLASS_TYPE_P (t
))
5028 /* The caller should have stripped an enclosing array. */
5029 gcc_assert (TREE_CODE (t
) != ARRAY_TYPE
);
5032 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t
))
5034 if (!TYPE_HAS_COMPLEX_DFLT (t
))
5035 return trivial_default_constructor_is_constexpr (t
);
5036 /* Non-trivial, we need to check subobject constructors. */
5037 lazily_declare_fn (sfk_constructor
, t
);
5039 fns
= locate_ctor (t
);
5040 return (fns
&& DECL_DECLARED_CONSTEXPR_P (fns
));
5043 /* Returns true iff class TYPE has a virtual destructor. */
5046 type_has_virtual_destructor (tree type
)
5050 if (!CLASS_TYPE_P (type
))
5053 gcc_assert (COMPLETE_TYPE_P (type
));
5054 dtor
= CLASSTYPE_DESTRUCTORS (type
);
5055 return (dtor
&& DECL_VIRTUAL_P (dtor
));
5058 /* Returns true iff class T has a move constructor. */
5061 type_has_move_constructor (tree t
)
5065 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
5067 gcc_assert (COMPLETE_TYPE_P (t
));
5068 lazily_declare_fn (sfk_move_constructor
, t
);
5071 if (!CLASSTYPE_METHOD_VEC (t
))
5074 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5075 if (move_fn_p (OVL_CURRENT (fns
)))
5081 /* Returns true iff class T has a move assignment operator. */
5084 type_has_move_assign (tree t
)
5088 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
5090 gcc_assert (COMPLETE_TYPE_P (t
));
5091 lazily_declare_fn (sfk_move_assignment
, t
);
5094 for (fns
= lookup_fnfields_slot_nolazy (t
, ansi_assopname (NOP_EXPR
));
5095 fns
; fns
= OVL_NEXT (fns
))
5096 if (move_fn_p (OVL_CURRENT (fns
)))
5102 /* Returns true iff class T has a move constructor that was explicitly
5103 declared in the class body. Note that this is different from
5104 "user-provided", which doesn't include functions that are defaulted in
5108 type_has_user_declared_move_constructor (tree t
)
5112 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
5115 if (!CLASSTYPE_METHOD_VEC (t
))
5118 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5120 tree fn
= OVL_CURRENT (fns
);
5121 if (move_fn_p (fn
) && !DECL_ARTIFICIAL (fn
))
5128 /* Returns true iff class T has a move assignment operator that was
5129 explicitly declared in the class body. */
5132 type_has_user_declared_move_assign (tree t
)
5136 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
5139 for (fns
= lookup_fnfields_slot_nolazy (t
, ansi_assopname (NOP_EXPR
));
5140 fns
; fns
= OVL_NEXT (fns
))
5142 tree fn
= OVL_CURRENT (fns
);
5143 if (move_fn_p (fn
) && !DECL_ARTIFICIAL (fn
))
5150 /* Nonzero if we need to build up a constructor call when initializing an
5151 object of this class, either because it has a user-declared constructor
5152 or because it doesn't have a default constructor (so we need to give an
5153 error if no initializer is provided). Use TYPE_NEEDS_CONSTRUCTING when
5154 what you care about is whether or not an object can be produced by a
5155 constructor (e.g. so we don't set TREE_READONLY on const variables of
5156 such type); use this function when what you care about is whether or not
5157 to try to call a constructor to create an object. The latter case is
5158 the former plus some cases of constructors that cannot be called. */
5161 type_build_ctor_call (tree t
)
5164 if (TYPE_NEEDS_CONSTRUCTING (t
))
5166 inner
= strip_array_types (t
);
5167 if (!CLASS_TYPE_P (inner
) || ANON_AGGR_TYPE_P (inner
))
5169 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (inner
))
5171 if (cxx_dialect
< cxx11
)
5173 /* A user-declared constructor might be private, and a constructor might
5174 be trivial but deleted. */
5175 for (tree fns
= lookup_fnfields_slot (inner
, complete_ctor_identifier
);
5176 fns
; fns
= OVL_NEXT (fns
))
5178 tree fn
= OVL_CURRENT (fns
);
5179 if (!DECL_ARTIFICIAL (fn
)
5180 || DECL_DELETED_FN (fn
))
5186 /* Like type_build_ctor_call, but for destructors. */
5189 type_build_dtor_call (tree t
)
5192 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5194 inner
= strip_array_types (t
);
5195 if (!CLASS_TYPE_P (inner
) || ANON_AGGR_TYPE_P (inner
)
5196 || !COMPLETE_TYPE_P (inner
))
5198 if (cxx_dialect
< cxx11
)
5200 /* A user-declared destructor might be private, and a destructor might
5201 be trivial but deleted. */
5202 for (tree fns
= lookup_fnfields_slot (inner
, complete_dtor_identifier
);
5203 fns
; fns
= OVL_NEXT (fns
))
5205 tree fn
= OVL_CURRENT (fns
);
5206 if (!DECL_ARTIFICIAL (fn
)
5207 || DECL_DELETED_FN (fn
))
5213 /* Remove all zero-width bit-fields from T. */
5216 remove_zero_width_bit_fields (tree t
)
5220 fieldsp
= &TYPE_FIELDS (t
);
5223 if (TREE_CODE (*fieldsp
) == FIELD_DECL
5224 && DECL_C_BIT_FIELD (*fieldsp
)
5225 /* We should not be confused by the fact that grokbitfield
5226 temporarily sets the width of the bit field into
5227 DECL_INITIAL (*fieldsp).
5228 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
5230 && integer_zerop (DECL_SIZE (*fieldsp
)))
5231 *fieldsp
= DECL_CHAIN (*fieldsp
);
5233 fieldsp
= &DECL_CHAIN (*fieldsp
);
5237 /* Returns TRUE iff we need a cookie when dynamically allocating an
5238 array whose elements have the indicated class TYPE. */
5241 type_requires_array_cookie (tree type
)
5244 bool has_two_argument_delete_p
= false;
5246 gcc_assert (CLASS_TYPE_P (type
));
5248 /* If there's a non-trivial destructor, we need a cookie. In order
5249 to iterate through the array calling the destructor for each
5250 element, we'll have to know how many elements there are. */
5251 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
5254 /* If the usual deallocation function is a two-argument whose second
5255 argument is of type `size_t', then we have to pass the size of
5256 the array to the deallocation function, so we will need to store
5258 fns
= lookup_fnfields (TYPE_BINFO (type
),
5259 ansi_opname (VEC_DELETE_EXPR
),
5261 /* If there are no `operator []' members, or the lookup is
5262 ambiguous, then we don't need a cookie. */
5263 if (!fns
|| fns
== error_mark_node
)
5265 /* Loop through all of the functions. */
5266 for (fns
= BASELINK_FUNCTIONS (fns
); fns
; fns
= OVL_NEXT (fns
))
5271 /* Select the current function. */
5272 fn
= OVL_CURRENT (fns
);
5273 /* See if this function is a one-argument delete function. If
5274 it is, then it will be the usual deallocation function. */
5275 second_parm
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn
)));
5276 if (second_parm
== void_list_node
)
5278 /* Do not consider this function if its second argument is an
5282 /* Otherwise, if we have a two-argument function and the second
5283 argument is `size_t', it will be the usual deallocation
5284 function -- unless there is one-argument function, too. */
5285 if (TREE_CHAIN (second_parm
) == void_list_node
5286 && same_type_p (TREE_VALUE (second_parm
), size_type_node
))
5287 has_two_argument_delete_p
= true;
5290 return has_two_argument_delete_p
;
5293 /* Finish computing the `literal type' property of class type T.
5295 At this point, we have already processed base classes and
5296 non-static data members. We need to check whether the copy
5297 constructor is trivial, the destructor is trivial, and there
5298 is a trivial default constructor or at least one constexpr
5299 constructor other than the copy constructor. */
5302 finalize_literal_type_property (tree t
)
5306 if (cxx_dialect
< cxx11
5307 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5308 CLASSTYPE_LITERAL_P (t
) = false;
5309 else if (CLASSTYPE_LITERAL_P (t
) && !TYPE_HAS_TRIVIAL_DFLT (t
)
5310 && CLASSTYPE_NON_AGGREGATE (t
)
5311 && !TYPE_HAS_CONSTEXPR_CTOR (t
))
5312 CLASSTYPE_LITERAL_P (t
) = false;
5314 if (!CLASSTYPE_LITERAL_P (t
))
5315 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5316 if (DECL_DECLARED_CONSTEXPR_P (fn
)
5317 && TREE_CODE (fn
) != TEMPLATE_DECL
5318 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
5319 && !DECL_CONSTRUCTOR_P (fn
))
5321 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
5322 if (!DECL_GENERATED_P (fn
))
5324 error ("enclosing class of constexpr non-static member "
5325 "function %q+#D is not a literal type", fn
);
5326 explain_non_literal_class (t
);
5331 /* T is a non-literal type used in a context which requires a constant
5332 expression. Explain why it isn't literal. */
5335 explain_non_literal_class (tree t
)
5337 static struct pointer_set_t
*diagnosed
;
5339 if (!CLASS_TYPE_P (t
))
5341 t
= TYPE_MAIN_VARIANT (t
);
5343 if (diagnosed
== NULL
)
5344 diagnosed
= pointer_set_create ();
5345 if (pointer_set_insert (diagnosed
, t
) != 0)
5346 /* Already explained. */
5349 inform (0, "%q+T is not literal because:", t
);
5350 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5351 inform (0, " %q+T has a non-trivial destructor", t
);
5352 else if (CLASSTYPE_NON_AGGREGATE (t
)
5353 && !TYPE_HAS_TRIVIAL_DFLT (t
)
5354 && !TYPE_HAS_CONSTEXPR_CTOR (t
))
5356 inform (0, " %q+T is not an aggregate, does not have a trivial "
5357 "default constructor, and has no constexpr constructor that "
5358 "is not a copy or move constructor", t
);
5359 if (TYPE_HAS_DEFAULT_CONSTRUCTOR (t
)
5360 && !type_has_user_provided_default_constructor (t
))
5362 /* Note that we can't simply call locate_ctor because when the
5363 constructor is deleted it just returns NULL_TREE. */
5365 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5367 tree fn
= OVL_CURRENT (fns
);
5368 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
5370 parms
= skip_artificial_parms_for (fn
, parms
);
5372 if (sufficient_parms_p (parms
))
5374 if (DECL_DELETED_FN (fn
))
5375 maybe_explain_implicit_delete (fn
);
5377 explain_invalid_constexpr_fn (fn
);
5385 tree binfo
, base_binfo
, field
; int i
;
5386 for (binfo
= TYPE_BINFO (t
), i
= 0;
5387 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5389 tree basetype
= TREE_TYPE (base_binfo
);
5390 if (!CLASSTYPE_LITERAL_P (basetype
))
5392 inform (0, " base class %qT of %q+T is non-literal",
5394 explain_non_literal_class (basetype
);
5398 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
5401 if (TREE_CODE (field
) != FIELD_DECL
)
5403 ftype
= TREE_TYPE (field
);
5404 if (!literal_type_p (ftype
))
5406 inform (0, " non-static data member %q+D has "
5407 "non-literal type", field
);
5408 if (CLASS_TYPE_P (ftype
))
5409 explain_non_literal_class (ftype
);
5415 /* Check the validity of the bases and members declared in T. Add any
5416 implicitly-generated functions (like copy-constructors and
5417 assignment operators). Compute various flag bits (like
5418 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
5419 level: i.e., independently of the ABI in use. */
5422 check_bases_and_members (tree t
)
5424 /* Nonzero if the implicitly generated copy constructor should take
5425 a non-const reference argument. */
5426 int cant_have_const_ctor
;
5427 /* Nonzero if the implicitly generated assignment operator
5428 should take a non-const reference argument. */
5429 int no_const_asn_ref
;
5431 bool saved_complex_asn_ref
;
5432 bool saved_nontrivial_dtor
;
5435 /* By default, we use const reference arguments and generate default
5437 cant_have_const_ctor
= 0;
5438 no_const_asn_ref
= 0;
5440 /* Check all the base-classes. */
5441 check_bases (t
, &cant_have_const_ctor
,
5444 /* Deduce noexcept on destructors. This needs to happen after we've set
5445 triviality flags appropriately for our bases. */
5446 if (cxx_dialect
>= cxx11
)
5447 deduce_noexcept_on_destructors (t
);
5449 /* Check all the method declarations. */
5452 /* Save the initial values of these flags which only indicate whether
5453 or not the class has user-provided functions. As we analyze the
5454 bases and members we can set these flags for other reasons. */
5455 saved_complex_asn_ref
= TYPE_HAS_COMPLEX_COPY_ASSIGN (t
);
5456 saved_nontrivial_dtor
= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
5458 /* Check all the data member declarations. We cannot call
5459 check_field_decls until we have called check_bases check_methods,
5460 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5461 being set appropriately. */
5462 check_field_decls (t
, &access_decls
,
5463 &cant_have_const_ctor
,
5466 /* A nearly-empty class has to be vptr-containing; a nearly empty
5467 class contains just a vptr. */
5468 if (!TYPE_CONTAINS_VPTR_P (t
))
5469 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
5471 /* Do some bookkeeping that will guide the generation of implicitly
5472 declared member functions. */
5473 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5474 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5475 /* We need to call a constructor for this class if it has a
5476 user-provided constructor, or if the default constructor is going
5477 to initialize the vptr. (This is not an if-and-only-if;
5478 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
5479 themselves need constructing.) */
5480 TYPE_NEEDS_CONSTRUCTING (t
)
5481 |= (type_has_user_provided_constructor (t
) || TYPE_CONTAINS_VPTR_P (t
));
5484 An aggregate is an array or a class with no user-provided
5485 constructors ... and no virtual functions.
5487 Again, other conditions for being an aggregate are checked
5489 CLASSTYPE_NON_AGGREGATE (t
)
5490 |= (type_has_user_provided_constructor (t
) || TYPE_POLYMORPHIC_P (t
));
5491 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
5492 retain the old definition internally for ABI reasons. */
5493 CLASSTYPE_NON_LAYOUT_POD_P (t
)
5494 |= (CLASSTYPE_NON_AGGREGATE (t
)
5495 || saved_nontrivial_dtor
|| saved_complex_asn_ref
);
5496 CLASSTYPE_NON_STD_LAYOUT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5497 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5498 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5499 TYPE_HAS_COMPLEX_DFLT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5501 /* If the class has no user-declared constructor, but does have
5502 non-static const or reference data members that can never be
5503 initialized, issue a warning. */
5504 if (warn_uninitialized
5505 /* Classes with user-declared constructors are presumed to
5506 initialize these members. */
5507 && !TYPE_HAS_USER_CONSTRUCTOR (t
)
5508 /* Aggregates can be initialized with brace-enclosed
5510 && CLASSTYPE_NON_AGGREGATE (t
))
5514 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
5518 if (TREE_CODE (field
) != FIELD_DECL
5519 || DECL_INITIAL (field
) != NULL_TREE
)
5522 type
= TREE_TYPE (field
);
5523 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5524 warning (OPT_Wuninitialized
, "non-static reference %q+#D "
5525 "in class without a constructor", field
);
5526 else if (CP_TYPE_CONST_P (type
)
5527 && (!CLASS_TYPE_P (type
)
5528 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
5529 warning (OPT_Wuninitialized
, "non-static const member %q+#D "
5530 "in class without a constructor", field
);
5534 /* Synthesize any needed methods. */
5535 add_implicitly_declared_members (t
, &access_decls
,
5536 cant_have_const_ctor
,
5539 /* Check defaulted declarations here so we have cant_have_const_ctor
5540 and don't need to worry about clones. */
5541 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5542 if (!DECL_ARTIFICIAL (fn
) && DECL_DEFAULTED_IN_CLASS_P (fn
))
5544 int copy
= copy_fn_p (fn
);
5548 = (DECL_CONSTRUCTOR_P (fn
) ? !cant_have_const_ctor
5549 : !no_const_asn_ref
);
5550 bool fn_const_p
= (copy
== 2);
5552 if (fn_const_p
&& !imp_const_p
)
5553 /* If the function is defaulted outside the class, we just
5554 give the synthesis error. */
5555 error ("%q+D declared to take const reference, but implicit "
5556 "declaration would take non-const", fn
);
5558 defaulted_late_check (fn
);
5561 if (LAMBDA_TYPE_P (t
))
5563 /* "The closure type associated with a lambda-expression has a deleted
5564 default constructor and a deleted copy assignment operator." */
5565 TYPE_NEEDS_CONSTRUCTING (t
) = 1;
5566 TYPE_HAS_COMPLEX_DFLT (t
) = 1;
5567 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
5568 CLASSTYPE_LAZY_MOVE_ASSIGN (t
) = 0;
5570 /* "This class type is not an aggregate." */
5571 CLASSTYPE_NON_AGGREGATE (t
) = 1;
5574 /* Compute the 'literal type' property before we
5575 do anything with non-static member functions. */
5576 finalize_literal_type_property (t
);
5578 /* Create the in-charge and not-in-charge variants of constructors
5580 clone_constructors_and_destructors (t
);
5582 /* Process the using-declarations. */
5583 for (; access_decls
; access_decls
= TREE_CHAIN (access_decls
))
5584 handle_using_decl (TREE_VALUE (access_decls
), t
);
5586 /* Build and sort the CLASSTYPE_METHOD_VEC. */
5587 finish_struct_methods (t
);
5589 /* Figure out whether or not we will need a cookie when dynamically
5590 allocating an array of this type. */
5591 TYPE_LANG_SPECIFIC (t
)->u
.c
.vec_new_uses_cookie
5592 = type_requires_array_cookie (t
);
5595 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
5596 accordingly. If a new vfield was created (because T doesn't have a
5597 primary base class), then the newly created field is returned. It
5598 is not added to the TYPE_FIELDS list; it is the caller's
5599 responsibility to do that. Accumulate declared virtual functions
5603 create_vtable_ptr (tree t
, tree
* virtuals_p
)
5607 /* Collect the virtual functions declared in T. */
5608 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5609 if (DECL_VINDEX (fn
) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
)
5610 && TREE_CODE (DECL_VINDEX (fn
)) != INTEGER_CST
)
5612 tree new_virtual
= make_node (TREE_LIST
);
5614 BV_FN (new_virtual
) = fn
;
5615 BV_DELTA (new_virtual
) = integer_zero_node
;
5616 BV_VCALL_INDEX (new_virtual
) = NULL_TREE
;
5618 TREE_CHAIN (new_virtual
) = *virtuals_p
;
5619 *virtuals_p
= new_virtual
;
5622 /* If we couldn't find an appropriate base class, create a new field
5623 here. Even if there weren't any new virtual functions, we might need a
5624 new virtual function table if we're supposed to include vptrs in
5625 all classes that need them. */
5626 if (!TYPE_VFIELD (t
) && (*virtuals_p
|| TYPE_CONTAINS_VPTR_P (t
)))
5628 /* We build this decl with vtbl_ptr_type_node, which is a
5629 `vtable_entry_type*'. It might seem more precise to use
5630 `vtable_entry_type (*)[N]' where N is the number of virtual
5631 functions. However, that would require the vtable pointer in
5632 base classes to have a different type than the vtable pointer
5633 in derived classes. We could make that happen, but that
5634 still wouldn't solve all the problems. In particular, the
5635 type-based alias analysis code would decide that assignments
5636 to the base class vtable pointer can't alias assignments to
5637 the derived class vtable pointer, since they have different
5638 types. Thus, in a derived class destructor, where the base
5639 class constructor was inlined, we could generate bad code for
5640 setting up the vtable pointer.
5642 Therefore, we use one type for all vtable pointers. We still
5643 use a type-correct type; it's just doesn't indicate the array
5644 bounds. That's better than using `void*' or some such; it's
5645 cleaner, and it let's the alias analysis code know that these
5646 stores cannot alias stores to void*! */
5649 field
= build_decl (input_location
,
5650 FIELD_DECL
, get_vfield_name (t
), vtbl_ptr_type_node
);
5651 DECL_VIRTUAL_P (field
) = 1;
5652 DECL_ARTIFICIAL (field
) = 1;
5653 DECL_FIELD_CONTEXT (field
) = t
;
5654 DECL_FCONTEXT (field
) = t
;
5655 if (TYPE_PACKED (t
))
5656 DECL_PACKED (field
) = 1;
5658 TYPE_VFIELD (t
) = field
;
5660 /* This class is non-empty. */
5661 CLASSTYPE_EMPTY_P (t
) = 0;
5669 /* Add OFFSET to all base types of BINFO which is a base in the
5670 hierarchy dominated by T.
5672 OFFSET, which is a type offset, is number of bytes. */
5675 propagate_binfo_offsets (tree binfo
, tree offset
)
5681 /* Update BINFO's offset. */
5682 BINFO_OFFSET (binfo
)
5683 = convert (sizetype
,
5684 size_binop (PLUS_EXPR
,
5685 convert (ssizetype
, BINFO_OFFSET (binfo
)),
5688 /* Find the primary base class. */
5689 primary_binfo
= get_primary_binfo (binfo
);
5691 if (primary_binfo
&& BINFO_INHERITANCE_CHAIN (primary_binfo
) == binfo
)
5692 propagate_binfo_offsets (primary_binfo
, offset
);
5694 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
5696 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5698 /* Don't do the primary base twice. */
5699 if (base_binfo
== primary_binfo
)
5702 if (BINFO_VIRTUAL_P (base_binfo
))
5705 propagate_binfo_offsets (base_binfo
, offset
);
5709 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
5710 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
5711 empty subobjects of T. */
5714 layout_virtual_bases (record_layout_info rli
, splay_tree offsets
)
5718 bool first_vbase
= true;
5721 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) == 0)
5724 if (!abi_version_at_least(2))
5726 /* In G++ 3.2, we incorrectly rounded the size before laying out
5727 the virtual bases. */
5728 finish_record_layout (rli
, /*free_p=*/false);
5729 #ifdef STRUCTURE_SIZE_BOUNDARY
5730 /* Packed structures don't need to have minimum size. */
5731 if (! TYPE_PACKED (t
))
5732 TYPE_ALIGN (t
) = MAX (TYPE_ALIGN (t
), (unsigned) STRUCTURE_SIZE_BOUNDARY
);
5734 rli
->offset
= TYPE_SIZE_UNIT (t
);
5735 rli
->bitpos
= bitsize_zero_node
;
5736 rli
->record_align
= TYPE_ALIGN (t
);
5739 /* Find the last field. The artificial fields created for virtual
5740 bases will go after the last extant field to date. */
5741 next_field
= &TYPE_FIELDS (t
);
5743 next_field
= &DECL_CHAIN (*next_field
);
5745 /* Go through the virtual bases, allocating space for each virtual
5746 base that is not already a primary base class. These are
5747 allocated in inheritance graph order. */
5748 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
5750 if (!BINFO_VIRTUAL_P (vbase
))
5753 if (!BINFO_PRIMARY_P (vbase
))
5755 tree basetype
= TREE_TYPE (vbase
);
5757 /* This virtual base is not a primary base of any class in the
5758 hierarchy, so we have to add space for it. */
5759 next_field
= build_base_field (rli
, vbase
,
5760 offsets
, next_field
);
5762 /* If the first virtual base might have been placed at a
5763 lower address, had we started from CLASSTYPE_SIZE, rather
5764 than TYPE_SIZE, issue a warning. There can be both false
5765 positives and false negatives from this warning in rare
5766 cases; to deal with all the possibilities would probably
5767 require performing both layout algorithms and comparing
5768 the results which is not particularly tractable. */
5772 (size_binop (CEIL_DIV_EXPR
,
5773 round_up_loc (input_location
,
5775 CLASSTYPE_ALIGN (basetype
)),
5777 BINFO_OFFSET (vbase
))))
5779 "offset of virtual base %qT is not ABI-compliant and "
5780 "may change in a future version of GCC",
5783 first_vbase
= false;
5788 /* Returns the offset of the byte just past the end of the base class
5792 end_of_base (tree binfo
)
5796 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo
)))
5797 size
= TYPE_SIZE_UNIT (char_type_node
);
5798 else if (is_empty_class (BINFO_TYPE (binfo
)))
5799 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5800 allocate some space for it. It cannot have virtual bases, so
5801 TYPE_SIZE_UNIT is fine. */
5802 size
= TYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
5804 size
= CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
5806 return size_binop (PLUS_EXPR
, BINFO_OFFSET (binfo
), size
);
5809 /* Returns the offset of the byte just past the end of the base class
5810 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
5811 only non-virtual bases are included. */
5814 end_of_class (tree t
, int include_virtuals_p
)
5816 tree result
= size_zero_node
;
5817 vec
<tree
, va_gc
> *vbases
;
5823 for (binfo
= TYPE_BINFO (t
), i
= 0;
5824 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5826 if (!include_virtuals_p
5827 && BINFO_VIRTUAL_P (base_binfo
)
5828 && (!BINFO_PRIMARY_P (base_binfo
)
5829 || BINFO_INHERITANCE_CHAIN (base_binfo
) != TYPE_BINFO (t
)))
5832 offset
= end_of_base (base_binfo
);
5833 if (INT_CST_LT (result
, offset
))
5837 /* G++ 3.2 did not check indirect virtual bases. */
5838 if (abi_version_at_least (2) && include_virtuals_p
)
5839 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
5840 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
5842 offset
= end_of_base (base_binfo
);
5843 if (INT_CST_LT (result
, offset
))
5850 /* Warn about bases of T that are inaccessible because they are
5851 ambiguous. For example:
5854 struct T : public S {};
5855 struct U : public S, public T {};
5857 Here, `(S*) new U' is not allowed because there are two `S'
5861 warn_about_ambiguous_bases (tree t
)
5864 vec
<tree
, va_gc
> *vbases
;
5869 /* If there are no repeated bases, nothing can be ambiguous. */
5870 if (!CLASSTYPE_REPEATED_BASE_P (t
))
5873 /* Check direct bases. */
5874 for (binfo
= TYPE_BINFO (t
), i
= 0;
5875 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5877 basetype
= BINFO_TYPE (base_binfo
);
5879 if (!uniquely_derived_from_p (basetype
, t
))
5880 warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
5884 /* Check for ambiguous virtual bases. */
5886 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
5887 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
5889 basetype
= BINFO_TYPE (binfo
);
5891 if (!uniquely_derived_from_p (basetype
, t
))
5892 warning (OPT_Wextra
, "virtual base %qT inaccessible in %qT due "
5893 "to ambiguity", basetype
, t
);
5897 /* Compare two INTEGER_CSTs K1 and K2. */
5900 splay_tree_compare_integer_csts (splay_tree_key k1
, splay_tree_key k2
)
5902 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5905 /* Increase the size indicated in RLI to account for empty classes
5906 that are "off the end" of the class. */
5909 include_empty_classes (record_layout_info rli
)
5914 /* It might be the case that we grew the class to allocate a
5915 zero-sized base class. That won't be reflected in RLI, yet,
5916 because we are willing to overlay multiple bases at the same
5917 offset. However, now we need to make sure that RLI is big enough
5918 to reflect the entire class. */
5919 eoc
= end_of_class (rli
->t
,
5920 CLASSTYPE_AS_BASE (rli
->t
) != NULL_TREE
);
5921 rli_size
= rli_size_unit_so_far (rli
);
5922 if (TREE_CODE (rli_size
) == INTEGER_CST
5923 && INT_CST_LT (rli_size
, eoc
))
5925 if (!abi_version_at_least (2))
5926 /* In version 1 of the ABI, the size of a class that ends with
5927 a bitfield was not rounded up to a whole multiple of a
5928 byte. Because rli_size_unit_so_far returns only the number
5929 of fully allocated bytes, any extra bits were not included
5931 rli
->bitpos
= round_down (rli
->bitpos
, BITS_PER_UNIT
);
5933 /* The size should have been rounded to a whole byte. */
5934 gcc_assert (tree_int_cst_equal
5935 (rli
->bitpos
, round_down (rli
->bitpos
, BITS_PER_UNIT
)));
5937 = size_binop (PLUS_EXPR
,
5939 size_binop (MULT_EXPR
,
5940 convert (bitsizetype
,
5941 size_binop (MINUS_EXPR
,
5943 bitsize_int (BITS_PER_UNIT
)));
5944 normalize_rli (rli
);
5948 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5949 BINFO_OFFSETs for all of the base-classes. Position the vtable
5950 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
5953 layout_class_type (tree t
, tree
*virtuals_p
)
5955 tree non_static_data_members
;
5958 record_layout_info rli
;
5959 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5960 types that appear at that offset. */
5961 splay_tree empty_base_offsets
;
5962 /* True if the last field laid out was a bit-field. */
5963 bool last_field_was_bitfield
= false;
5964 /* The location at which the next field should be inserted. */
5966 /* T, as a base class. */
5969 /* Keep track of the first non-static data member. */
5970 non_static_data_members
= TYPE_FIELDS (t
);
5972 /* Start laying out the record. */
5973 rli
= start_record_layout (t
);
5975 /* Mark all the primary bases in the hierarchy. */
5976 determine_primary_bases (t
);
5978 /* Create a pointer to our virtual function table. */
5979 vptr
= create_vtable_ptr (t
, virtuals_p
);
5981 /* The vptr is always the first thing in the class. */
5984 DECL_CHAIN (vptr
) = TYPE_FIELDS (t
);
5985 TYPE_FIELDS (t
) = vptr
;
5986 next_field
= &DECL_CHAIN (vptr
);
5987 place_field (rli
, vptr
);
5990 next_field
= &TYPE_FIELDS (t
);
5992 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5993 empty_base_offsets
= splay_tree_new (splay_tree_compare_integer_csts
,
5995 build_base_fields (rli
, empty_base_offsets
, next_field
);
5997 /* Layout the non-static data members. */
5998 for (field
= non_static_data_members
; field
; field
= DECL_CHAIN (field
))
6003 /* We still pass things that aren't non-static data members to
6004 the back end, in case it wants to do something with them. */
6005 if (TREE_CODE (field
) != FIELD_DECL
)
6007 place_field (rli
, field
);
6008 /* If the static data member has incomplete type, keep track
6009 of it so that it can be completed later. (The handling
6010 of pending statics in finish_record_layout is
6011 insufficient; consider:
6014 struct S2 { static S1 s1; };
6016 At this point, finish_record_layout will be called, but
6017 S1 is still incomplete.) */
6020 maybe_register_incomplete_var (field
);
6021 /* The visibility of static data members is determined
6022 at their point of declaration, not their point of
6024 determine_visibility (field
);
6029 type
= TREE_TYPE (field
);
6030 if (type
== error_mark_node
)
6033 padding
= NULL_TREE
;
6035 /* If this field is a bit-field whose width is greater than its
6036 type, then there are some special rules for allocating
6038 if (DECL_C_BIT_FIELD (field
)
6039 && INT_CST_LT (TYPE_SIZE (type
), DECL_SIZE (field
)))
6043 bool was_unnamed_p
= false;
6044 /* We must allocate the bits as if suitably aligned for the
6045 longest integer type that fits in this many bits. type
6046 of the field. Then, we are supposed to use the left over
6047 bits as additional padding. */
6048 for (itk
= itk_char
; itk
!= itk_none
; ++itk
)
6049 if (integer_types
[itk
] != NULL_TREE
6050 && (INT_CST_LT (size_int (MAX_FIXED_MODE_SIZE
),
6051 TYPE_SIZE (integer_types
[itk
]))
6052 || INT_CST_LT (DECL_SIZE (field
),
6053 TYPE_SIZE (integer_types
[itk
]))))
6056 /* ITK now indicates a type that is too large for the
6057 field. We have to back up by one to find the largest
6062 integer_type
= integer_types
[itk
];
6063 } while (itk
> 0 && integer_type
== NULL_TREE
);
6065 /* Figure out how much additional padding is required. GCC
6066 3.2 always created a padding field, even if it had zero
6068 if (!abi_version_at_least (2)
6069 || INT_CST_LT (TYPE_SIZE (integer_type
), DECL_SIZE (field
)))
6071 if (abi_version_at_least (2) && TREE_CODE (t
) == UNION_TYPE
)
6072 /* In a union, the padding field must have the full width
6073 of the bit-field; all fields start at offset zero. */
6074 padding
= DECL_SIZE (field
);
6077 if (TREE_CODE (t
) == UNION_TYPE
)
6078 warning (OPT_Wabi
, "size assigned to %qT may not be "
6079 "ABI-compliant and may change in a future "
6082 padding
= size_binop (MINUS_EXPR
, DECL_SIZE (field
),
6083 TYPE_SIZE (integer_type
));
6086 #ifdef PCC_BITFIELD_TYPE_MATTERS
6087 /* An unnamed bitfield does not normally affect the
6088 alignment of the containing class on a target where
6089 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
6090 make any exceptions for unnamed bitfields when the
6091 bitfields are longer than their types. Therefore, we
6092 temporarily give the field a name. */
6093 if (PCC_BITFIELD_TYPE_MATTERS
&& !DECL_NAME (field
))
6095 was_unnamed_p
= true;
6096 DECL_NAME (field
) = make_anon_name ();
6099 DECL_SIZE (field
) = TYPE_SIZE (integer_type
);
6100 DECL_ALIGN (field
) = TYPE_ALIGN (integer_type
);
6101 DECL_USER_ALIGN (field
) = TYPE_USER_ALIGN (integer_type
);
6102 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
6103 empty_base_offsets
);
6105 DECL_NAME (field
) = NULL_TREE
;
6106 /* Now that layout has been performed, set the size of the
6107 field to the size of its declared type; the rest of the
6108 field is effectively invisible. */
6109 DECL_SIZE (field
) = TYPE_SIZE (type
);
6110 /* We must also reset the DECL_MODE of the field. */
6111 if (abi_version_at_least (2))
6112 DECL_MODE (field
) = TYPE_MODE (type
);
6114 && DECL_MODE (field
) != TYPE_MODE (type
))
6115 /* Versions of G++ before G++ 3.4 did not reset the
6118 "the offset of %qD may not be ABI-compliant and may "
6119 "change in a future version of GCC", field
);
6122 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
6123 empty_base_offsets
);
6125 /* Remember the location of any empty classes in FIELD. */
6126 if (abi_version_at_least (2))
6127 record_subobject_offsets (TREE_TYPE (field
),
6128 byte_position(field
),
6130 /*is_data_member=*/true);
6132 /* If a bit-field does not immediately follow another bit-field,
6133 and yet it starts in the middle of a byte, we have failed to
6134 comply with the ABI. */
6136 && DECL_C_BIT_FIELD (field
)
6137 /* The TREE_NO_WARNING flag gets set by Objective-C when
6138 laying out an Objective-C class. The ObjC ABI differs
6139 from the C++ ABI, and so we do not want a warning
6141 && !TREE_NO_WARNING (field
)
6142 && !last_field_was_bitfield
6143 && !integer_zerop (size_binop (TRUNC_MOD_EXPR
,
6144 DECL_FIELD_BIT_OFFSET (field
),
6145 bitsize_unit_node
)))
6146 warning (OPT_Wabi
, "offset of %q+D is not ABI-compliant and may "
6147 "change in a future version of GCC", field
);
6149 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
6150 offset of the field. */
6152 && !abi_version_at_least (2)
6153 && !tree_int_cst_equal (DECL_FIELD_OFFSET (field
),
6154 byte_position (field
))
6155 && contains_empty_class_p (TREE_TYPE (field
)))
6156 warning (OPT_Wabi
, "%q+D contains empty classes which may cause base "
6157 "classes to be placed at different locations in a "
6158 "future version of GCC", field
);
6160 /* The middle end uses the type of expressions to determine the
6161 possible range of expression values. In order to optimize
6162 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
6163 must be made aware of the width of "i", via its type.
6165 Because C++ does not have integer types of arbitrary width,
6166 we must (for the purposes of the front end) convert from the
6167 type assigned here to the declared type of the bitfield
6168 whenever a bitfield expression is used as an rvalue.
6169 Similarly, when assigning a value to a bitfield, the value
6170 must be converted to the type given the bitfield here. */
6171 if (DECL_C_BIT_FIELD (field
))
6173 unsigned HOST_WIDE_INT width
;
6174 tree ftype
= TREE_TYPE (field
);
6175 width
= tree_to_uhwi (DECL_SIZE (field
));
6176 if (width
!= TYPE_PRECISION (ftype
))
6179 = c_build_bitfield_integer_type (width
,
6180 TYPE_UNSIGNED (ftype
));
6182 = cp_build_qualified_type (TREE_TYPE (field
),
6183 cp_type_quals (ftype
));
6187 /* If we needed additional padding after this field, add it
6193 padding_field
= build_decl (input_location
,
6197 DECL_BIT_FIELD (padding_field
) = 1;
6198 DECL_SIZE (padding_field
) = padding
;
6199 DECL_CONTEXT (padding_field
) = t
;
6200 DECL_ARTIFICIAL (padding_field
) = 1;
6201 DECL_IGNORED_P (padding_field
) = 1;
6202 layout_nonempty_base_or_field (rli
, padding_field
,
6204 empty_base_offsets
);
6207 last_field_was_bitfield
= DECL_C_BIT_FIELD (field
);
6210 if (abi_version_at_least (2) && !integer_zerop (rli
->bitpos
))
6212 /* Make sure that we are on a byte boundary so that the size of
6213 the class without virtual bases will always be a round number
6215 rli
->bitpos
= round_up_loc (input_location
, rli
->bitpos
, BITS_PER_UNIT
);
6216 normalize_rli (rli
);
6219 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
6221 if (!abi_version_at_least (2))
6222 include_empty_classes(rli
);
6224 /* Delete all zero-width bit-fields from the list of fields. Now
6225 that the type is laid out they are no longer important. */
6226 remove_zero_width_bit_fields (t
);
6228 /* Create the version of T used for virtual bases. We do not use
6229 make_class_type for this version; this is an artificial type. For
6230 a POD type, we just reuse T. */
6231 if (CLASSTYPE_NON_LAYOUT_POD_P (t
) || CLASSTYPE_EMPTY_P (t
))
6233 base_t
= make_node (TREE_CODE (t
));
6235 /* Set the size and alignment for the new type. In G++ 3.2, all
6236 empty classes were considered to have size zero when used as
6238 if (!abi_version_at_least (2) && CLASSTYPE_EMPTY_P (t
))
6240 TYPE_SIZE (base_t
) = bitsize_zero_node
;
6241 TYPE_SIZE_UNIT (base_t
) = size_zero_node
;
6242 if (warn_abi
&& !integer_zerop (rli_size_unit_so_far (rli
)))
6244 "layout of classes derived from empty class %qT "
6245 "may change in a future version of GCC",
6252 /* If the ABI version is not at least two, and the last
6253 field was a bit-field, RLI may not be on a byte
6254 boundary. In particular, rli_size_unit_so_far might
6255 indicate the last complete byte, while rli_size_so_far
6256 indicates the total number of bits used. Therefore,
6257 rli_size_so_far, rather than rli_size_unit_so_far, is
6258 used to compute TYPE_SIZE_UNIT. */
6259 eoc
= end_of_class (t
, /*include_virtuals_p=*/0);
6260 TYPE_SIZE_UNIT (base_t
)
6261 = size_binop (MAX_EXPR
,
6263 size_binop (CEIL_DIV_EXPR
,
6264 rli_size_so_far (rli
),
6265 bitsize_int (BITS_PER_UNIT
))),
6268 = size_binop (MAX_EXPR
,
6269 rli_size_so_far (rli
),
6270 size_binop (MULT_EXPR
,
6271 convert (bitsizetype
, eoc
),
6272 bitsize_int (BITS_PER_UNIT
)));
6274 TYPE_ALIGN (base_t
) = rli
->record_align
;
6275 TYPE_USER_ALIGN (base_t
) = TYPE_USER_ALIGN (t
);
6277 /* Copy the fields from T. */
6278 next_field
= &TYPE_FIELDS (base_t
);
6279 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
6280 if (TREE_CODE (field
) == FIELD_DECL
)
6282 *next_field
= build_decl (input_location
,
6286 DECL_CONTEXT (*next_field
) = base_t
;
6287 DECL_FIELD_OFFSET (*next_field
) = DECL_FIELD_OFFSET (field
);
6288 DECL_FIELD_BIT_OFFSET (*next_field
)
6289 = DECL_FIELD_BIT_OFFSET (field
);
6290 DECL_SIZE (*next_field
) = DECL_SIZE (field
);
6291 DECL_MODE (*next_field
) = DECL_MODE (field
);
6292 next_field
= &DECL_CHAIN (*next_field
);
6295 /* Record the base version of the type. */
6296 CLASSTYPE_AS_BASE (t
) = base_t
;
6297 TYPE_CONTEXT (base_t
) = t
;
6300 CLASSTYPE_AS_BASE (t
) = t
;
6302 /* Every empty class contains an empty class. */
6303 if (CLASSTYPE_EMPTY_P (t
))
6304 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
6306 /* Set the TYPE_DECL for this type to contain the right
6307 value for DECL_OFFSET, so that we can use it as part
6308 of a COMPONENT_REF for multiple inheritance. */
6309 layout_decl (TYPE_MAIN_DECL (t
), 0);
6311 /* Now fix up any virtual base class types that we left lying
6312 around. We must get these done before we try to lay out the
6313 virtual function table. As a side-effect, this will remove the
6314 base subobject fields. */
6315 layout_virtual_bases (rli
, empty_base_offsets
);
6317 /* Make sure that empty classes are reflected in RLI at this
6319 include_empty_classes(rli
);
6321 /* Make sure not to create any structures with zero size. */
6322 if (integer_zerop (rli_size_unit_so_far (rli
)) && CLASSTYPE_EMPTY_P (t
))
6324 build_decl (input_location
,
6325 FIELD_DECL
, NULL_TREE
, char_type_node
));
6327 /* If this is a non-POD, declaring it packed makes a difference to how it
6328 can be used as a field; don't let finalize_record_size undo it. */
6329 if (TYPE_PACKED (t
) && !layout_pod_type_p (t
))
6330 rli
->packed_maybe_necessary
= true;
6332 /* Let the back end lay out the type. */
6333 finish_record_layout (rli
, /*free_p=*/true);
6335 if (TYPE_SIZE_UNIT (t
)
6336 && TREE_CODE (TYPE_SIZE_UNIT (t
)) == INTEGER_CST
6337 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t
))
6338 && !valid_constant_size_p (TYPE_SIZE_UNIT (t
)))
6339 error ("type %qT is too large", t
);
6341 /* Warn about bases that can't be talked about due to ambiguity. */
6342 warn_about_ambiguous_bases (t
);
6344 /* Now that we're done with layout, give the base fields the real types. */
6345 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
6346 if (DECL_ARTIFICIAL (field
) && IS_FAKE_BASE_TYPE (TREE_TYPE (field
)))
6347 TREE_TYPE (field
) = TYPE_CONTEXT (TREE_TYPE (field
));
6350 splay_tree_delete (empty_base_offsets
);
6352 if (CLASSTYPE_EMPTY_P (t
)
6353 && tree_int_cst_lt (sizeof_biggest_empty_class
,
6354 TYPE_SIZE_UNIT (t
)))
6355 sizeof_biggest_empty_class
= TYPE_SIZE_UNIT (t
);
6358 /* Determine the "key method" for the class type indicated by TYPE,
6359 and set CLASSTYPE_KEY_METHOD accordingly. */
6362 determine_key_method (tree type
)
6366 if (TYPE_FOR_JAVA (type
)
6367 || processing_template_decl
6368 || CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
6369 || CLASSTYPE_INTERFACE_KNOWN (type
))
6372 /* The key method is the first non-pure virtual function that is not
6373 inline at the point of class definition. On some targets the
6374 key function may not be inline; those targets should not call
6375 this function until the end of the translation unit. */
6376 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
6377 method
= DECL_CHAIN (method
))
6378 if (DECL_VINDEX (method
) != NULL_TREE
6379 && ! DECL_DECLARED_INLINE_P (method
)
6380 && ! DECL_PURE_VIRTUAL_P (method
))
6382 CLASSTYPE_KEY_METHOD (type
) = method
;
6390 /* Allocate and return an instance of struct sorted_fields_type with
6393 static struct sorted_fields_type
*
6394 sorted_fields_type_new (int n
)
6396 struct sorted_fields_type
*sft
;
6397 sft
= ggc_alloc_sorted_fields_type (sizeof (struct sorted_fields_type
)
6398 + n
* sizeof (tree
));
6405 /* Perform processing required when the definition of T (a class type)
6409 finish_struct_1 (tree t
)
6412 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
6413 tree virtuals
= NULL_TREE
;
6415 if (COMPLETE_TYPE_P (t
))
6417 gcc_assert (MAYBE_CLASS_TYPE_P (t
));
6418 error ("redefinition of %q#T", t
);
6423 /* If this type was previously laid out as a forward reference,
6424 make sure we lay it out again. */
6425 TYPE_SIZE (t
) = NULL_TREE
;
6426 CLASSTYPE_PRIMARY_BINFO (t
) = NULL_TREE
;
6428 /* Make assumptions about the class; we'll reset the flags if
6430 CLASSTYPE_EMPTY_P (t
) = 1;
6431 CLASSTYPE_NEARLY_EMPTY_P (t
) = 1;
6432 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 0;
6433 CLASSTYPE_LITERAL_P (t
) = true;
6435 /* Do end-of-class semantic processing: checking the validity of the
6436 bases and members and add implicitly generated methods. */
6437 check_bases_and_members (t
);
6439 /* Find the key method. */
6440 if (TYPE_CONTAINS_VPTR_P (t
))
6442 /* The Itanium C++ ABI permits the key method to be chosen when
6443 the class is defined -- even though the key method so
6444 selected may later turn out to be an inline function. On
6445 some systems (such as ARM Symbian OS) the key method cannot
6446 be determined until the end of the translation unit. On such
6447 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
6448 will cause the class to be added to KEYED_CLASSES. Then, in
6449 finish_file we will determine the key method. */
6450 if (targetm
.cxx
.key_method_may_be_inline ())
6451 determine_key_method (t
);
6453 /* If a polymorphic class has no key method, we may emit the vtable
6454 in every translation unit where the class definition appears. */
6455 if (CLASSTYPE_KEY_METHOD (t
) == NULL_TREE
)
6456 keyed_classes
= tree_cons (NULL_TREE
, t
, keyed_classes
);
6459 /* Layout the class itself. */
6460 layout_class_type (t
, &virtuals
);
6461 if (CLASSTYPE_AS_BASE (t
) != t
)
6462 /* We use the base type for trivial assignments, and hence it
6464 compute_record_mode (CLASSTYPE_AS_BASE (t
));
6466 virtuals
= modify_all_vtables (t
, nreverse (virtuals
));
6468 /* If necessary, create the primary vtable for this class. */
6469 if (virtuals
|| TYPE_CONTAINS_VPTR_P (t
))
6471 /* We must enter these virtuals into the table. */
6472 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6473 build_primary_vtable (NULL_TREE
, t
);
6474 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t
)))
6475 /* Here we know enough to change the type of our virtual
6476 function table, but we will wait until later this function. */
6477 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t
), t
);
6479 /* If we're warning about ABI tags, check the types of the new
6480 virtual functions. */
6482 for (tree v
= virtuals
; v
; v
= TREE_CHAIN (v
))
6483 check_abi_tags (t
, TREE_VALUE (v
));
6486 if (TYPE_CONTAINS_VPTR_P (t
))
6491 if (BINFO_VTABLE (TYPE_BINFO (t
)))
6492 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t
))));
6493 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6494 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t
)) == NULL_TREE
);
6496 /* Add entries for virtual functions introduced by this class. */
6497 BINFO_VIRTUALS (TYPE_BINFO (t
))
6498 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t
)), virtuals
);
6500 /* Set DECL_VINDEX for all functions declared in this class. */
6501 for (vindex
= 0, fn
= BINFO_VIRTUALS (TYPE_BINFO (t
));
6503 fn
= TREE_CHAIN (fn
),
6504 vindex
+= (TARGET_VTABLE_USES_DESCRIPTORS
6505 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1))
6507 tree fndecl
= BV_FN (fn
);
6509 if (DECL_THUNK_P (fndecl
))
6510 /* A thunk. We should never be calling this entry directly
6511 from this vtable -- we'd use the entry for the non
6512 thunk base function. */
6513 DECL_VINDEX (fndecl
) = NULL_TREE
;
6514 else if (TREE_CODE (DECL_VINDEX (fndecl
)) != INTEGER_CST
)
6515 DECL_VINDEX (fndecl
) = build_int_cst (NULL_TREE
, vindex
);
6519 finish_struct_bits (t
);
6520 set_method_tm_attributes (t
);
6522 /* Complete the rtl for any static member objects of the type we're
6524 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
6525 if (VAR_P (x
) && TREE_STATIC (x
)
6526 && TREE_TYPE (x
) != error_mark_node
6527 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x
)), t
))
6528 DECL_MODE (x
) = TYPE_MODE (t
);
6530 /* Done with FIELDS...now decide whether to sort these for
6531 faster lookups later.
6533 We use a small number because most searches fail (succeeding
6534 ultimately as the search bores through the inheritance
6535 hierarchy), and we want this failure to occur quickly. */
6537 insert_into_classtype_sorted_fields (TYPE_FIELDS (t
), t
, 8);
6539 /* Complain if one of the field types requires lower visibility. */
6540 constrain_class_visibility (t
);
6542 /* Make the rtl for any new vtables we have created, and unmark
6543 the base types we marked. */
6546 /* Build the VTT for T. */
6549 /* This warning does not make sense for Java classes, since they
6550 cannot have destructors. */
6551 if (!TYPE_FOR_JAVA (t
) && warn_nonvdtor
&& TYPE_POLYMORPHIC_P (t
))
6555 dtor
= CLASSTYPE_DESTRUCTORS (t
);
6556 if (/* An implicitly declared destructor is always public. And,
6557 if it were virtual, we would have created it by now. */
6559 || (!DECL_VINDEX (dtor
)
6560 && (/* public non-virtual */
6561 (!TREE_PRIVATE (dtor
) && !TREE_PROTECTED (dtor
))
6562 || (/* non-public non-virtual with friends */
6563 (TREE_PRIVATE (dtor
) || TREE_PROTECTED (dtor
))
6564 && (CLASSTYPE_FRIEND_CLASSES (t
)
6565 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))))))
6566 warning (OPT_Wnon_virtual_dtor
,
6567 "%q#T has virtual functions and accessible"
6568 " non-virtual destructor", t
);
6573 if (warn_overloaded_virtual
)
6576 /* Class layout, assignment of virtual table slots, etc., is now
6577 complete. Give the back end a chance to tweak the visibility of
6578 the class or perform any other required target modifications. */
6579 targetm
.cxx
.adjust_class_at_definition (t
);
6581 maybe_suppress_debug_info (t
);
6583 if (flag_vtable_verify
)
6584 vtv_save_class_info (t
);
6586 dump_class_hierarchy (t
);
6588 /* Finish debugging output for this type. */
6589 rest_of_type_compilation (t
, ! LOCAL_CLASS_P (t
));
6591 if (TYPE_TRANSPARENT_AGGR (t
))
6593 tree field
= first_field (t
);
6594 if (field
== NULL_TREE
|| error_operand_p (field
))
6596 error ("type transparent %q#T does not have any fields", t
);
6597 TYPE_TRANSPARENT_AGGR (t
) = 0;
6599 else if (DECL_ARTIFICIAL (field
))
6601 if (DECL_FIELD_IS_BASE (field
))
6602 error ("type transparent class %qT has base classes", t
);
6605 gcc_checking_assert (DECL_VIRTUAL_P (field
));
6606 error ("type transparent class %qT has virtual functions", t
);
6608 TYPE_TRANSPARENT_AGGR (t
) = 0;
6610 else if (TYPE_MODE (t
) != DECL_MODE (field
))
6612 error ("type transparent %q#T cannot be made transparent because "
6613 "the type of the first field has a different ABI from the "
6614 "class overall", t
);
6615 TYPE_TRANSPARENT_AGGR (t
) = 0;
6620 /* Insert FIELDS into T for the sorted case if the FIELDS count is
6621 equal to THRESHOLD or greater than THRESHOLD. */
6624 insert_into_classtype_sorted_fields (tree fields
, tree t
, int threshold
)
6626 int n_fields
= count_fields (fields
);
6627 if (n_fields
>= threshold
)
6629 struct sorted_fields_type
*field_vec
= sorted_fields_type_new (n_fields
);
6630 add_fields_to_record_type (fields
, field_vec
, 0);
6631 qsort (field_vec
->elts
, n_fields
, sizeof (tree
), field_decl_cmp
);
6632 CLASSTYPE_SORTED_FIELDS (t
) = field_vec
;
6636 /* Insert lately defined enum ENUMTYPE into T for the sorted case. */
6639 insert_late_enum_def_into_classtype_sorted_fields (tree enumtype
, tree t
)
6641 struct sorted_fields_type
*sorted_fields
= CLASSTYPE_SORTED_FIELDS (t
);
6646 = list_length (TYPE_VALUES (enumtype
)) + sorted_fields
->len
;
6647 struct sorted_fields_type
*field_vec
= sorted_fields_type_new (n_fields
);
6649 for (i
= 0; i
< sorted_fields
->len
; ++i
)
6650 field_vec
->elts
[i
] = sorted_fields
->elts
[i
];
6652 add_enum_fields_to_record_type (enumtype
, field_vec
,
6653 sorted_fields
->len
);
6654 qsort (field_vec
->elts
, n_fields
, sizeof (tree
), field_decl_cmp
);
6655 CLASSTYPE_SORTED_FIELDS (t
) = field_vec
;
6659 /* When T was built up, the member declarations were added in reverse
6660 order. Rearrange them to declaration order. */
6663 unreverse_member_declarations (tree t
)
6669 /* The following lists are all in reverse order. Put them in
6670 declaration order now. */
6671 TYPE_METHODS (t
) = nreverse (TYPE_METHODS (t
));
6672 CLASSTYPE_DECL_LIST (t
) = nreverse (CLASSTYPE_DECL_LIST (t
));
6674 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
6675 reverse order, so we can't just use nreverse. */
6677 for (x
= TYPE_FIELDS (t
);
6678 x
&& TREE_CODE (x
) != TYPE_DECL
;
6681 next
= DECL_CHAIN (x
);
6682 DECL_CHAIN (x
) = prev
;
6687 DECL_CHAIN (TYPE_FIELDS (t
)) = x
;
6689 TYPE_FIELDS (t
) = prev
;
6694 finish_struct (tree t
, tree attributes
)
6696 location_t saved_loc
= input_location
;
6698 /* Now that we've got all the field declarations, reverse everything
6700 unreverse_member_declarations (t
);
6702 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
6704 /* Nadger the current location so that diagnostics point to the start of
6705 the struct, not the end. */
6706 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (t
));
6708 if (processing_template_decl
)
6712 finish_struct_methods (t
);
6713 TYPE_SIZE (t
) = bitsize_zero_node
;
6714 TYPE_SIZE_UNIT (t
) = size_zero_node
;
6716 /* We need to emit an error message if this type was used as a parameter
6717 and it is an abstract type, even if it is a template. We construct
6718 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
6719 account and we call complete_vars with this type, which will check
6720 the PARM_DECLS. Note that while the type is being defined,
6721 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
6722 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
6723 CLASSTYPE_PURE_VIRTUALS (t
) = NULL
;
6724 for (x
= TYPE_METHODS (t
); x
; x
= DECL_CHAIN (x
))
6725 if (DECL_PURE_VIRTUAL_P (x
))
6726 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t
), x
);
6728 /* We need to add the target functions to the CLASSTYPE_METHOD_VEC if
6729 an enclosing scope is a template class, so that this function be
6730 found by lookup_fnfields_1 when the using declaration is not
6731 instantiated yet. */
6732 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
6733 if (TREE_CODE (x
) == USING_DECL
)
6735 tree fn
= strip_using_decl (x
);
6736 if (is_overloaded_fn (fn
))
6737 for (; fn
; fn
= OVL_NEXT (fn
))
6738 add_method (t
, OVL_CURRENT (fn
), x
);
6741 /* Remember current #pragma pack value. */
6742 TYPE_PRECISION (t
) = maximum_field_alignment
;
6744 /* Fix up any variants we've already built. */
6745 for (x
= TYPE_NEXT_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
6747 TYPE_SIZE (x
) = TYPE_SIZE (t
);
6748 TYPE_SIZE_UNIT (x
) = TYPE_SIZE_UNIT (t
);
6749 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
6750 TYPE_METHODS (x
) = TYPE_METHODS (t
);
6754 finish_struct_1 (t
);
6756 input_location
= saved_loc
;
6758 TYPE_BEING_DEFINED (t
) = 0;
6760 if (current_class_type
)
6763 error ("trying to finish struct, but kicked out due to previous parse errors");
6765 if (processing_template_decl
&& at_function_scope_p ()
6766 /* Lambdas are defined by the LAMBDA_EXPR. */
6767 && !LAMBDA_TYPE_P (t
))
6768 add_stmt (build_min (TAG_DEFN
, t
));
6773 /* Hash table to avoid endless recursion when handling references. */
6774 static hash_table
<pointer_hash
<tree_node
> > fixed_type_or_null_ref_ht
;
6776 /* Return the dynamic type of INSTANCE, if known.
6777 Used to determine whether the virtual function table is needed
6780 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6781 of our knowledge of its type. *NONNULL should be initialized
6782 before this function is called. */
6785 fixed_type_or_null (tree instance
, int *nonnull
, int *cdtorp
)
6787 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
6789 switch (TREE_CODE (instance
))
6792 if (POINTER_TYPE_P (TREE_TYPE (instance
)))
6795 return RECUR (TREE_OPERAND (instance
, 0));
6798 /* This is a call to a constructor, hence it's never zero. */
6799 if (TREE_HAS_CONSTRUCTOR (instance
))
6803 return TREE_TYPE (instance
);
6808 /* This is a call to a constructor, hence it's never zero. */
6809 if (TREE_HAS_CONSTRUCTOR (instance
))
6813 return TREE_TYPE (instance
);
6815 return RECUR (TREE_OPERAND (instance
, 0));
6817 case POINTER_PLUS_EXPR
:
6820 if (TREE_CODE (TREE_OPERAND (instance
, 0)) == ADDR_EXPR
)
6821 return RECUR (TREE_OPERAND (instance
, 0));
6822 if (TREE_CODE (TREE_OPERAND (instance
, 1)) == INTEGER_CST
)
6823 /* Propagate nonnull. */
6824 return RECUR (TREE_OPERAND (instance
, 0));
6829 return RECUR (TREE_OPERAND (instance
, 0));
6832 instance
= TREE_OPERAND (instance
, 0);
6835 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
6836 with a real object -- given &p->f, p can still be null. */
6837 tree t
= get_base_address (instance
);
6838 /* ??? Probably should check DECL_WEAK here. */
6839 if (t
&& DECL_P (t
))
6842 return RECUR (instance
);
6845 /* If this component is really a base class reference, then the field
6846 itself isn't definitive. */
6847 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance
, 1)))
6848 return RECUR (TREE_OPERAND (instance
, 0));
6849 return RECUR (TREE_OPERAND (instance
, 1));
6853 if (TREE_CODE (TREE_TYPE (instance
)) == ARRAY_TYPE
6854 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance
))))
6858 return TREE_TYPE (TREE_TYPE (instance
));
6860 /* fall through... */
6864 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance
)))
6868 return TREE_TYPE (instance
);
6870 else if (instance
== current_class_ptr
)
6875 /* if we're in a ctor or dtor, we know our type. If
6876 current_class_ptr is set but we aren't in a function, we're in
6877 an NSDMI (and therefore a constructor). */
6878 if (current_scope () != current_function_decl
6879 || (DECL_LANG_SPECIFIC (current_function_decl
)
6880 && (DECL_CONSTRUCTOR_P (current_function_decl
)
6881 || DECL_DESTRUCTOR_P (current_function_decl
))))
6885 return TREE_TYPE (TREE_TYPE (instance
));
6888 else if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
6890 /* We only need one hash table because it is always left empty. */
6891 if (!fixed_type_or_null_ref_ht
.is_created ())
6892 fixed_type_or_null_ref_ht
.create (37);
6894 /* Reference variables should be references to objects. */
6898 /* Enter the INSTANCE in a table to prevent recursion; a
6899 variable's initializer may refer to the variable
6901 if (VAR_P (instance
)
6902 && DECL_INITIAL (instance
)
6903 && !type_dependent_expression_p_push (DECL_INITIAL (instance
))
6904 && !fixed_type_or_null_ref_ht
.find (instance
))
6909 slot
= fixed_type_or_null_ref_ht
.find_slot (instance
, INSERT
);
6911 type
= RECUR (DECL_INITIAL (instance
));
6912 fixed_type_or_null_ref_ht
.remove_elt (instance
);
6925 /* Return nonzero if the dynamic type of INSTANCE is known, and
6926 equivalent to the static type. We also handle the case where
6927 INSTANCE is really a pointer. Return negative if this is a
6928 ctor/dtor. There the dynamic type is known, but this might not be
6929 the most derived base of the original object, and hence virtual
6930 bases may not be laid out according to this type.
6932 Used to determine whether the virtual function table is needed
6935 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6936 of our knowledge of its type. *NONNULL should be initialized
6937 before this function is called. */
6940 resolves_to_fixed_type_p (tree instance
, int* nonnull
)
6942 tree t
= TREE_TYPE (instance
);
6946 /* processing_template_decl can be false in a template if we're in
6947 fold_non_dependent_expr, but we still want to suppress this check. */
6948 if (in_template_function ())
6950 /* In a template we only care about the type of the result. */
6956 fixed
= fixed_type_or_null (instance
, nonnull
, &cdtorp
);
6957 if (fixed
== NULL_TREE
)
6959 if (POINTER_TYPE_P (t
))
6961 if (!same_type_ignoring_top_level_qualifiers_p (t
, fixed
))
6963 return cdtorp
? -1 : 1;
6968 init_class_processing (void)
6970 current_class_depth
= 0;
6971 current_class_stack_size
= 10;
6973 = XNEWVEC (struct class_stack_node
, current_class_stack_size
);
6974 vec_alloc (local_classes
, 8);
6975 sizeof_biggest_empty_class
= size_zero_node
;
6977 ridpointers
[(int) RID_PUBLIC
] = access_public_node
;
6978 ridpointers
[(int) RID_PRIVATE
] = access_private_node
;
6979 ridpointers
[(int) RID_PROTECTED
] = access_protected_node
;
6982 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
6985 restore_class_cache (void)
6989 /* We are re-entering the same class we just left, so we don't
6990 have to search the whole inheritance matrix to find all the
6991 decls to bind again. Instead, we install the cached
6992 class_shadowed list and walk through it binding names. */
6993 push_binding_level (previous_class_level
);
6994 class_binding_level
= previous_class_level
;
6995 /* Restore IDENTIFIER_TYPE_VALUE. */
6996 for (type
= class_binding_level
->type_shadowed
;
6998 type
= TREE_CHAIN (type
))
6999 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type
), TREE_TYPE (type
));
7002 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
7003 appropriate for TYPE.
7005 So that we may avoid calls to lookup_name, we cache the _TYPE
7006 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
7008 For multiple inheritance, we perform a two-pass depth-first search
7009 of the type lattice. */
7012 pushclass (tree type
)
7014 class_stack_node_t csn
;
7016 type
= TYPE_MAIN_VARIANT (type
);
7018 /* Make sure there is enough room for the new entry on the stack. */
7019 if (current_class_depth
+ 1 >= current_class_stack_size
)
7021 current_class_stack_size
*= 2;
7023 = XRESIZEVEC (struct class_stack_node
, current_class_stack
,
7024 current_class_stack_size
);
7027 /* Insert a new entry on the class stack. */
7028 csn
= current_class_stack
+ current_class_depth
;
7029 csn
->name
= current_class_name
;
7030 csn
->type
= current_class_type
;
7031 csn
->access
= current_access_specifier
;
7032 csn
->names_used
= 0;
7034 current_class_depth
++;
7036 /* Now set up the new type. */
7037 current_class_name
= TYPE_NAME (type
);
7038 if (TREE_CODE (current_class_name
) == TYPE_DECL
)
7039 current_class_name
= DECL_NAME (current_class_name
);
7040 current_class_type
= type
;
7042 /* By default, things in classes are private, while things in
7043 structures or unions are public. */
7044 current_access_specifier
= (CLASSTYPE_DECLARED_CLASS (type
)
7045 ? access_private_node
7046 : access_public_node
);
7048 if (previous_class_level
7049 && type
!= previous_class_level
->this_entity
7050 && current_class_depth
== 1)
7052 /* Forcibly remove any old class remnants. */
7053 invalidate_class_lookup_cache ();
7056 if (!previous_class_level
7057 || type
!= previous_class_level
->this_entity
7058 || current_class_depth
> 1)
7061 restore_class_cache ();
7064 /* When we exit a toplevel class scope, we save its binding level so
7065 that we can restore it quickly. Here, we've entered some other
7066 class, so we must invalidate our cache. */
7069 invalidate_class_lookup_cache (void)
7071 previous_class_level
= NULL
;
7074 /* Get out of the current class scope. If we were in a class scope
7075 previously, that is the one popped to. */
7082 current_class_depth
--;
7083 current_class_name
= current_class_stack
[current_class_depth
].name
;
7084 current_class_type
= current_class_stack
[current_class_depth
].type
;
7085 current_access_specifier
= current_class_stack
[current_class_depth
].access
;
7086 if (current_class_stack
[current_class_depth
].names_used
)
7087 splay_tree_delete (current_class_stack
[current_class_depth
].names_used
);
7090 /* Mark the top of the class stack as hidden. */
7093 push_class_stack (void)
7095 if (current_class_depth
)
7096 ++current_class_stack
[current_class_depth
- 1].hidden
;
7099 /* Mark the top of the class stack as un-hidden. */
7102 pop_class_stack (void)
7104 if (current_class_depth
)
7105 --current_class_stack
[current_class_depth
- 1].hidden
;
7108 /* Returns 1 if the class type currently being defined is either T or
7109 a nested type of T. */
7112 currently_open_class (tree t
)
7116 if (!CLASS_TYPE_P (t
))
7119 t
= TYPE_MAIN_VARIANT (t
);
7121 /* We start looking from 1 because entry 0 is from global scope,
7123 for (i
= current_class_depth
; i
> 0; --i
)
7126 if (i
== current_class_depth
)
7127 c
= current_class_type
;
7130 if (current_class_stack
[i
].hidden
)
7132 c
= current_class_stack
[i
].type
;
7136 if (same_type_p (c
, t
))
7142 /* If either current_class_type or one of its enclosing classes are derived
7143 from T, return the appropriate type. Used to determine how we found
7144 something via unqualified lookup. */
7147 currently_open_derived_class (tree t
)
7151 /* The bases of a dependent type are unknown. */
7152 if (dependent_type_p (t
))
7155 if (!current_class_type
)
7158 if (DERIVED_FROM_P (t
, current_class_type
))
7159 return current_class_type
;
7161 for (i
= current_class_depth
- 1; i
> 0; --i
)
7163 if (current_class_stack
[i
].hidden
)
7165 if (DERIVED_FROM_P (t
, current_class_stack
[i
].type
))
7166 return current_class_stack
[i
].type
;
7172 /* Returns the innermost class type which is not a lambda closure type. */
7175 current_nonlambda_class_type (void)
7179 /* We start looking from 1 because entry 0 is from global scope,
7181 for (i
= current_class_depth
; i
> 0; --i
)
7184 if (i
== current_class_depth
)
7185 c
= current_class_type
;
7188 if (current_class_stack
[i
].hidden
)
7190 c
= current_class_stack
[i
].type
;
7194 if (!LAMBDA_TYPE_P (c
))
7200 /* When entering a class scope, all enclosing class scopes' names with
7201 static meaning (static variables, static functions, types and
7202 enumerators) have to be visible. This recursive function calls
7203 pushclass for all enclosing class contexts until global or a local
7204 scope is reached. TYPE is the enclosed class. */
7207 push_nested_class (tree type
)
7209 /* A namespace might be passed in error cases, like A::B:C. */
7210 if (type
== NULL_TREE
7211 || !CLASS_TYPE_P (type
))
7214 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type
)));
7219 /* Undoes a push_nested_class call. */
7222 pop_nested_class (void)
7224 tree context
= DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type
));
7227 if (context
&& CLASS_TYPE_P (context
))
7228 pop_nested_class ();
7231 /* Returns the number of extern "LANG" blocks we are nested within. */
7234 current_lang_depth (void)
7236 return vec_safe_length (current_lang_base
);
7239 /* Set global variables CURRENT_LANG_NAME to appropriate value
7240 so that behavior of name-mangling machinery is correct. */
7243 push_lang_context (tree name
)
7245 vec_safe_push (current_lang_base
, current_lang_name
);
7247 if (name
== lang_name_cplusplus
)
7249 current_lang_name
= name
;
7251 else if (name
== lang_name_java
)
7253 current_lang_name
= name
;
7254 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
7255 (See record_builtin_java_type in decl.c.) However, that causes
7256 incorrect debug entries if these types are actually used.
7257 So we re-enable debug output after extern "Java". */
7258 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node
)) = 0;
7259 DECL_IGNORED_P (TYPE_NAME (java_short_type_node
)) = 0;
7260 DECL_IGNORED_P (TYPE_NAME (java_int_type_node
)) = 0;
7261 DECL_IGNORED_P (TYPE_NAME (java_long_type_node
)) = 0;
7262 DECL_IGNORED_P (TYPE_NAME (java_float_type_node
)) = 0;
7263 DECL_IGNORED_P (TYPE_NAME (java_double_type_node
)) = 0;
7264 DECL_IGNORED_P (TYPE_NAME (java_char_type_node
)) = 0;
7265 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node
)) = 0;
7267 else if (name
== lang_name_c
)
7269 current_lang_name
= name
;
7272 error ("language string %<\"%E\"%> not recognized", name
);
7275 /* Get out of the current language scope. */
7278 pop_lang_context (void)
7280 current_lang_name
= current_lang_base
->pop ();
7283 /* Type instantiation routines. */
7285 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
7286 matches the TARGET_TYPE. If there is no satisfactory match, return
7287 error_mark_node, and issue an error & warning messages under
7288 control of FLAGS. Permit pointers to member function if FLAGS
7289 permits. If TEMPLATE_ONLY, the name of the overloaded function was
7290 a template-id, and EXPLICIT_TARGS are the explicitly provided
7293 If OVERLOAD is for one or more member functions, then ACCESS_PATH
7294 is the base path used to reference those member functions. If
7295 the address is resolved to a member function, access checks will be
7296 performed and errors issued if appropriate. */
7299 resolve_address_of_overloaded_function (tree target_type
,
7301 tsubst_flags_t flags
,
7303 tree explicit_targs
,
7306 /* Here's what the standard says:
7310 If the name is a function template, template argument deduction
7311 is done, and if the argument deduction succeeds, the deduced
7312 arguments are used to generate a single template function, which
7313 is added to the set of overloaded functions considered.
7315 Non-member functions and static member functions match targets of
7316 type "pointer-to-function" or "reference-to-function." Nonstatic
7317 member functions match targets of type "pointer-to-member
7318 function;" the function type of the pointer to member is used to
7319 select the member function from the set of overloaded member
7320 functions. If a nonstatic member function is selected, the
7321 reference to the overloaded function name is required to have the
7322 form of a pointer to member as described in 5.3.1.
7324 If more than one function is selected, any template functions in
7325 the set are eliminated if the set also contains a non-template
7326 function, and any given template function is eliminated if the
7327 set contains a second template function that is more specialized
7328 than the first according to the partial ordering rules 14.5.5.2.
7329 After such eliminations, if any, there shall remain exactly one
7330 selected function. */
7333 /* We store the matches in a TREE_LIST rooted here. The functions
7334 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
7335 interoperability with most_specialized_instantiation. */
7336 tree matches
= NULL_TREE
;
7338 tree target_fn_type
;
7340 /* By the time we get here, we should be seeing only real
7341 pointer-to-member types, not the internal POINTER_TYPE to
7342 METHOD_TYPE representation. */
7343 gcc_assert (!TYPE_PTR_P (target_type
)
7344 || TREE_CODE (TREE_TYPE (target_type
)) != METHOD_TYPE
);
7346 gcc_assert (is_overloaded_fn (overload
));
7348 /* Check that the TARGET_TYPE is reasonable. */
7349 if (TYPE_PTRFN_P (target_type
)
7350 || TYPE_REFFN_P (target_type
))
7352 else if (TYPE_PTRMEMFUNC_P (target_type
))
7353 /* This is OK, too. */
7355 else if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
7356 /* This is OK, too. This comes from a conversion to reference
7358 target_type
= build_reference_type (target_type
);
7361 if (flags
& tf_error
)
7362 error ("cannot resolve overloaded function %qD based on"
7363 " conversion to type %qT",
7364 DECL_NAME (OVL_FUNCTION (overload
)), target_type
);
7365 return error_mark_node
;
7368 /* Non-member functions and static member functions match targets of type
7369 "pointer-to-function" or "reference-to-function." Nonstatic member
7370 functions match targets of type "pointer-to-member-function;" the
7371 function type of the pointer to member is used to select the member
7372 function from the set of overloaded member functions.
7374 So figure out the FUNCTION_TYPE that we want to match against. */
7375 target_fn_type
= static_fn_type (target_type
);
7377 /* If we can find a non-template function that matches, we can just
7378 use it. There's no point in generating template instantiations
7379 if we're just going to throw them out anyhow. But, of course, we
7380 can only do this when we don't *need* a template function. */
7385 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
7387 tree fn
= OVL_CURRENT (fns
);
7389 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
7390 /* We're not looking for templates just yet. */
7393 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7395 /* We're looking for a non-static member, and this isn't
7396 one, or vice versa. */
7399 /* Ignore functions which haven't been explicitly
7401 if (DECL_ANTICIPATED (fn
))
7404 /* See if there's a match. */
7405 if (same_type_p (target_fn_type
, static_fn_type (fn
)))
7406 matches
= tree_cons (fn
, NULL_TREE
, matches
);
7410 /* Now, if we've already got a match (or matches), there's no need
7411 to proceed to the template functions. But, if we don't have a
7412 match we need to look at them, too. */
7415 tree target_arg_types
;
7416 tree target_ret_type
;
7419 unsigned int nargs
, ia
;
7422 target_arg_types
= TYPE_ARG_TYPES (target_fn_type
);
7423 target_ret_type
= TREE_TYPE (target_fn_type
);
7425 nargs
= list_length (target_arg_types
);
7426 args
= XALLOCAVEC (tree
, nargs
);
7427 for (arg
= target_arg_types
, ia
= 0;
7428 arg
!= NULL_TREE
&& arg
!= void_list_node
;
7429 arg
= TREE_CHAIN (arg
), ++ia
)
7430 args
[ia
] = TREE_VALUE (arg
);
7433 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
7435 tree fn
= OVL_CURRENT (fns
);
7439 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7440 /* We're only looking for templates. */
7443 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7445 /* We're not looking for a non-static member, and this is
7446 one, or vice versa. */
7449 tree ret
= target_ret_type
;
7451 /* If the template has a deduced return type, don't expose it to
7452 template argument deduction. */
7453 if (undeduced_auto_decl (fn
))
7456 /* Try to do argument deduction. */
7457 targs
= make_tree_vec (DECL_NTPARMS (fn
));
7458 instantiation
= fn_type_unification (fn
, explicit_targs
, targs
, args
,
7460 DEDUCE_EXACT
, LOOKUP_NORMAL
,
7462 if (instantiation
== error_mark_node
)
7463 /* Instantiation failed. */
7466 /* And now force instantiation to do return type deduction. */
7467 if (undeduced_auto_decl (instantiation
))
7470 instantiate_decl (instantiation
, /*defer*/false, /*class*/false);
7473 require_deduced_type (instantiation
);
7476 /* See if there's a match. */
7477 if (same_type_p (target_fn_type
, static_fn_type (instantiation
)))
7478 matches
= tree_cons (instantiation
, fn
, matches
);
7483 /* Now, remove all but the most specialized of the matches. */
7486 tree match
= most_specialized_instantiation (matches
);
7488 if (match
!= error_mark_node
)
7489 matches
= tree_cons (TREE_PURPOSE (match
),
7495 /* Now we should have exactly one function in MATCHES. */
7496 if (matches
== NULL_TREE
)
7498 /* There were *no* matches. */
7499 if (flags
& tf_error
)
7501 error ("no matches converting function %qD to type %q#T",
7502 DECL_NAME (OVL_CURRENT (overload
)),
7505 print_candidates (overload
);
7507 return error_mark_node
;
7509 else if (TREE_CHAIN (matches
))
7511 /* There were too many matches. First check if they're all
7512 the same function. */
7513 tree match
= NULL_TREE
;
7515 fn
= TREE_PURPOSE (matches
);
7517 /* For multi-versioned functions, more than one match is just fine and
7518 decls_match will return false as they are different. */
7519 for (match
= TREE_CHAIN (matches
); match
; match
= TREE_CHAIN (match
))
7520 if (!decls_match (fn
, TREE_PURPOSE (match
))
7521 && !targetm
.target_option
.function_versions
7522 (fn
, TREE_PURPOSE (match
)))
7527 if (flags
& tf_error
)
7529 error ("converting overloaded function %qD to type %q#T is ambiguous",
7530 DECL_NAME (OVL_FUNCTION (overload
)),
7533 /* Since print_candidates expects the functions in the
7534 TREE_VALUE slot, we flip them here. */
7535 for (match
= matches
; match
; match
= TREE_CHAIN (match
))
7536 TREE_VALUE (match
) = TREE_PURPOSE (match
);
7538 print_candidates (matches
);
7541 return error_mark_node
;
7545 /* Good, exactly one match. Now, convert it to the correct type. */
7546 fn
= TREE_PURPOSE (matches
);
7548 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
7549 && !(flags
& tf_ptrmem_ok
) && !flag_ms_extensions
)
7551 static int explained
;
7553 if (!(flags
& tf_error
))
7554 return error_mark_node
;
7556 permerror (input_location
, "assuming pointer to member %qD", fn
);
7559 inform (input_location
, "(a pointer to member can only be formed with %<&%E%>)", fn
);
7564 /* If a pointer to a function that is multi-versioned is requested, the
7565 pointer to the dispatcher function is returned instead. This works
7566 well because indirectly calling the function will dispatch the right
7567 function version at run-time. */
7568 if (DECL_FUNCTION_VERSIONED (fn
))
7570 fn
= get_function_version_dispatcher (fn
);
7572 return error_mark_node
;
7573 /* Mark all the versions corresponding to the dispatcher as used. */
7574 if (!(flags
& tf_conv
))
7575 mark_versions_used (fn
);
7578 /* If we're doing overload resolution purely for the purpose of
7579 determining conversion sequences, we should not consider the
7580 function used. If this conversion sequence is selected, the
7581 function will be marked as used at this point. */
7582 if (!(flags
& tf_conv
))
7584 /* Make =delete work with SFINAE. */
7585 if (DECL_DELETED_FN (fn
) && !(flags
& tf_error
))
7586 return error_mark_node
;
7591 /* We could not check access to member functions when this
7592 expression was originally created since we did not know at that
7593 time to which function the expression referred. */
7594 if (DECL_FUNCTION_MEMBER_P (fn
))
7596 gcc_assert (access_path
);
7597 perform_or_defer_access_check (access_path
, fn
, fn
, flags
);
7600 if (TYPE_PTRFN_P (target_type
) || TYPE_PTRMEMFUNC_P (target_type
))
7601 return cp_build_addr_expr (fn
, flags
);
7604 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
7605 will mark the function as addressed, but here we must do it
7607 cxx_mark_addressable (fn
);
7613 /* This function will instantiate the type of the expression given in
7614 RHS to match the type of LHSTYPE. If errors exist, then return
7615 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
7616 we complain on errors. If we are not complaining, never modify rhs,
7617 as overload resolution wants to try many possible instantiations, in
7618 the hope that at least one will work.
7620 For non-recursive calls, LHSTYPE should be a function, pointer to
7621 function, or a pointer to member function. */
7624 instantiate_type (tree lhstype
, tree rhs
, tsubst_flags_t flags
)
7626 tsubst_flags_t flags_in
= flags
;
7627 tree access_path
= NULL_TREE
;
7629 flags
&= ~tf_ptrmem_ok
;
7631 if (lhstype
== unknown_type_node
)
7633 if (flags
& tf_error
)
7634 error ("not enough type information");
7635 return error_mark_node
;
7638 if (TREE_TYPE (rhs
) != NULL_TREE
&& ! (type_unknown_p (rhs
)))
7640 tree fntype
= non_reference (lhstype
);
7641 if (same_type_p (fntype
, TREE_TYPE (rhs
)))
7643 if (flag_ms_extensions
7644 && TYPE_PTRMEMFUNC_P (fntype
)
7645 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
7646 /* Microsoft allows `A::f' to be resolved to a
7647 pointer-to-member. */
7651 if (flags
& tf_error
)
7652 error ("cannot convert %qE from type %qT to type %qT",
7653 rhs
, TREE_TYPE (rhs
), fntype
);
7654 return error_mark_node
;
7658 if (BASELINK_P (rhs
))
7660 access_path
= BASELINK_ACCESS_BINFO (rhs
);
7661 rhs
= BASELINK_FUNCTIONS (rhs
);
7664 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
7665 deduce any type information. */
7666 if (TREE_CODE (rhs
) == NON_DEPENDENT_EXPR
)
7668 if (flags
& tf_error
)
7669 error ("not enough type information");
7670 return error_mark_node
;
7673 /* There only a few kinds of expressions that may have a type
7674 dependent on overload resolution. */
7675 gcc_assert (TREE_CODE (rhs
) == ADDR_EXPR
7676 || TREE_CODE (rhs
) == COMPONENT_REF
7677 || is_overloaded_fn (rhs
)
7678 || (flag_ms_extensions
&& TREE_CODE (rhs
) == FUNCTION_DECL
));
7680 /* This should really only be used when attempting to distinguish
7681 what sort of a pointer to function we have. For now, any
7682 arithmetic operation which is not supported on pointers
7683 is rejected as an error. */
7685 switch (TREE_CODE (rhs
))
7689 tree member
= TREE_OPERAND (rhs
, 1);
7691 member
= instantiate_type (lhstype
, member
, flags
);
7692 if (member
!= error_mark_node
7693 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs
, 0)))
7694 /* Do not lose object's side effects. */
7695 return build2 (COMPOUND_EXPR
, TREE_TYPE (member
),
7696 TREE_OPERAND (rhs
, 0), member
);
7701 rhs
= TREE_OPERAND (rhs
, 1);
7702 if (BASELINK_P (rhs
))
7703 return instantiate_type (lhstype
, rhs
, flags_in
);
7705 /* This can happen if we are forming a pointer-to-member for a
7707 gcc_assert (TREE_CODE (rhs
) == TEMPLATE_ID_EXPR
);
7711 case TEMPLATE_ID_EXPR
:
7713 tree fns
= TREE_OPERAND (rhs
, 0);
7714 tree args
= TREE_OPERAND (rhs
, 1);
7717 resolve_address_of_overloaded_function (lhstype
, fns
, flags_in
,
7718 /*template_only=*/true,
7725 resolve_address_of_overloaded_function (lhstype
, rhs
, flags_in
,
7726 /*template_only=*/false,
7727 /*explicit_targs=*/NULL_TREE
,
7732 if (PTRMEM_OK_P (rhs
))
7733 flags
|= tf_ptrmem_ok
;
7735 return instantiate_type (lhstype
, TREE_OPERAND (rhs
, 0), flags
);
7739 return error_mark_node
;
7744 return error_mark_node
;
7747 /* Return the name of the virtual function pointer field
7748 (as an IDENTIFIER_NODE) for the given TYPE. Note that
7749 this may have to look back through base types to find the
7750 ultimate field name. (For single inheritance, these could
7751 all be the same name. Who knows for multiple inheritance). */
7754 get_vfield_name (tree type
)
7756 tree binfo
, base_binfo
;
7759 for (binfo
= TYPE_BINFO (type
);
7760 BINFO_N_BASE_BINFOS (binfo
);
7763 base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
7765 if (BINFO_VIRTUAL_P (base_binfo
)
7766 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo
)))
7770 type
= BINFO_TYPE (binfo
);
7771 buf
= (char *) alloca (sizeof (VFIELD_NAME_FORMAT
)
7772 + TYPE_NAME_LENGTH (type
) + 2);
7773 sprintf (buf
, VFIELD_NAME_FORMAT
,
7774 IDENTIFIER_POINTER (constructor_name (type
)));
7775 return get_identifier (buf
);
7779 print_class_statistics (void)
7781 if (! GATHER_STATISTICS
)
7784 fprintf (stderr
, "convert_harshness = %d\n", n_convert_harshness
);
7785 fprintf (stderr
, "compute_conversion_costs = %d\n", n_compute_conversion_costs
);
7788 fprintf (stderr
, "vtables = %d; vtable searches = %d\n",
7789 n_vtables
, n_vtable_searches
);
7790 fprintf (stderr
, "vtable entries = %d; vtable elems = %d\n",
7791 n_vtable_entries
, n_vtable_elems
);
7795 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
7796 according to [class]:
7797 The class-name is also inserted
7798 into the scope of the class itself. For purposes of access checking,
7799 the inserted class name is treated as if it were a public member name. */
7802 build_self_reference (void)
7804 tree name
= constructor_name (current_class_type
);
7805 tree value
= build_lang_decl (TYPE_DECL
, name
, current_class_type
);
7808 DECL_NONLOCAL (value
) = 1;
7809 DECL_CONTEXT (value
) = current_class_type
;
7810 DECL_ARTIFICIAL (value
) = 1;
7811 SET_DECL_SELF_REFERENCE_P (value
);
7812 set_underlying_type (value
);
7814 if (processing_template_decl
)
7815 value
= push_template_decl (value
);
7817 saved_cas
= current_access_specifier
;
7818 current_access_specifier
= access_public_node
;
7819 finish_member_declaration (value
);
7820 current_access_specifier
= saved_cas
;
7823 /* Returns 1 if TYPE contains only padding bytes. */
7826 is_empty_class (tree type
)
7828 if (type
== error_mark_node
)
7831 if (! CLASS_TYPE_P (type
))
7834 /* In G++ 3.2, whether or not a class was empty was determined by
7835 looking at its size. */
7836 if (abi_version_at_least (2))
7837 return CLASSTYPE_EMPTY_P (type
);
7839 return integer_zerop (CLASSTYPE_SIZE (type
));
7842 /* Returns true if TYPE contains an empty class. */
7845 contains_empty_class_p (tree type
)
7847 if (is_empty_class (type
))
7849 if (CLASS_TYPE_P (type
))
7856 for (binfo
= TYPE_BINFO (type
), i
= 0;
7857 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
7858 if (contains_empty_class_p (BINFO_TYPE (base_binfo
)))
7860 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
7861 if (TREE_CODE (field
) == FIELD_DECL
7862 && !DECL_ARTIFICIAL (field
)
7863 && is_empty_class (TREE_TYPE (field
)))
7866 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7867 return contains_empty_class_p (TREE_TYPE (type
));
7871 /* Returns true if TYPE contains no actual data, just various
7872 possible combinations of empty classes and possibly a vptr. */
7875 is_really_empty_class (tree type
)
7877 if (CLASS_TYPE_P (type
))
7884 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
7885 out, but we'd like to be able to check this before then. */
7886 if (COMPLETE_TYPE_P (type
) && is_empty_class (type
))
7889 for (binfo
= TYPE_BINFO (type
), i
= 0;
7890 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
7891 if (!is_really_empty_class (BINFO_TYPE (base_binfo
)))
7893 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7894 if (TREE_CODE (field
) == FIELD_DECL
7895 && !DECL_ARTIFICIAL (field
)
7896 && !is_really_empty_class (TREE_TYPE (field
)))
7900 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7901 return is_really_empty_class (TREE_TYPE (type
));
7905 /* Note that NAME was looked up while the current class was being
7906 defined and that the result of that lookup was DECL. */
7909 maybe_note_name_used_in_class (tree name
, tree decl
)
7911 splay_tree names_used
;
7913 /* If we're not defining a class, there's nothing to do. */
7914 if (!(innermost_scope_kind() == sk_class
7915 && TYPE_BEING_DEFINED (current_class_type
)
7916 && !LAMBDA_TYPE_P (current_class_type
)))
7919 /* If there's already a binding for this NAME, then we don't have
7920 anything to worry about. */
7921 if (lookup_member (current_class_type
, name
,
7922 /*protect=*/0, /*want_type=*/false, tf_warning_or_error
))
7925 if (!current_class_stack
[current_class_depth
- 1].names_used
)
7926 current_class_stack
[current_class_depth
- 1].names_used
7927 = splay_tree_new (splay_tree_compare_pointers
, 0, 0);
7928 names_used
= current_class_stack
[current_class_depth
- 1].names_used
;
7930 splay_tree_insert (names_used
,
7931 (splay_tree_key
) name
,
7932 (splay_tree_value
) decl
);
7935 /* Note that NAME was declared (as DECL) in the current class. Check
7936 to see that the declaration is valid. */
7939 note_name_declared_in_class (tree name
, tree decl
)
7941 splay_tree names_used
;
7944 /* Look to see if we ever used this name. */
7946 = current_class_stack
[current_class_depth
- 1].names_used
;
7949 /* The C language allows members to be declared with a type of the same
7950 name, and the C++ standard says this diagnostic is not required. So
7951 allow it in extern "C" blocks unless predantic is specified.
7952 Allow it in all cases if -ms-extensions is specified. */
7953 if ((!pedantic
&& current_lang_name
== lang_name_c
)
7954 || flag_ms_extensions
)
7956 n
= splay_tree_lookup (names_used
, (splay_tree_key
) name
);
7959 /* [basic.scope.class]
7961 A name N used in a class S shall refer to the same declaration
7962 in its context and when re-evaluated in the completed scope of
7964 permerror (input_location
, "declaration of %q#D", decl
);
7965 permerror (input_location
, "changes meaning of %qD from %q+#D",
7966 DECL_NAME (OVL_CURRENT (decl
)), (tree
) n
->value
);
7970 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
7971 Secondary vtables are merged with primary vtables; this function
7972 will return the VAR_DECL for the primary vtable. */
7975 get_vtbl_decl_for_binfo (tree binfo
)
7979 decl
= BINFO_VTABLE (binfo
);
7980 if (decl
&& TREE_CODE (decl
) == POINTER_PLUS_EXPR
)
7982 gcc_assert (TREE_CODE (TREE_OPERAND (decl
, 0)) == ADDR_EXPR
);
7983 decl
= TREE_OPERAND (TREE_OPERAND (decl
, 0), 0);
7986 gcc_assert (VAR_P (decl
));
7991 /* Returns the binfo for the primary base of BINFO. If the resulting
7992 BINFO is a virtual base, and it is inherited elsewhere in the
7993 hierarchy, then the returned binfo might not be the primary base of
7994 BINFO in the complete object. Check BINFO_PRIMARY_P or
7995 BINFO_LOST_PRIMARY_P to be sure. */
7998 get_primary_binfo (tree binfo
)
8002 primary_base
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo
));
8006 return copied_binfo (primary_base
, binfo
);
8009 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
8012 maybe_indent_hierarchy (FILE * stream
, int indent
, int indented_p
)
8015 fprintf (stream
, "%*s", indent
, "");
8019 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
8020 INDENT should be zero when called from the top level; it is
8021 incremented recursively. IGO indicates the next expected BINFO in
8022 inheritance graph ordering. */
8025 dump_class_hierarchy_r (FILE *stream
,
8035 indented
= maybe_indent_hierarchy (stream
, indent
, 0);
8036 fprintf (stream
, "%s (0x" HOST_WIDE_INT_PRINT_HEX
") ",
8037 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
),
8038 (HOST_WIDE_INT
) (uintptr_t) binfo
);
8041 fprintf (stream
, "alternative-path\n");
8044 igo
= TREE_CHAIN (binfo
);
8046 fprintf (stream
, HOST_WIDE_INT_PRINT_DEC
,
8047 tree_to_shwi (BINFO_OFFSET (binfo
)));
8048 if (is_empty_class (BINFO_TYPE (binfo
)))
8049 fprintf (stream
, " empty");
8050 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo
)))
8051 fprintf (stream
, " nearly-empty");
8052 if (BINFO_VIRTUAL_P (binfo
))
8053 fprintf (stream
, " virtual");
8054 fprintf (stream
, "\n");
8057 if (BINFO_PRIMARY_P (binfo
))
8059 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8060 fprintf (stream
, " primary-for %s (0x" HOST_WIDE_INT_PRINT_HEX
")",
8061 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo
)),
8062 TFF_PLAIN_IDENTIFIER
),
8063 (HOST_WIDE_INT
) (uintptr_t) BINFO_INHERITANCE_CHAIN (binfo
));
8065 if (BINFO_LOST_PRIMARY_P (binfo
))
8067 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8068 fprintf (stream
, " lost-primary");
8071 fprintf (stream
, "\n");
8073 if (!(flags
& TDF_SLIM
))
8077 if (BINFO_SUBVTT_INDEX (binfo
))
8079 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8080 fprintf (stream
, " subvttidx=%s",
8081 expr_as_string (BINFO_SUBVTT_INDEX (binfo
),
8082 TFF_PLAIN_IDENTIFIER
));
8084 if (BINFO_VPTR_INDEX (binfo
))
8086 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8087 fprintf (stream
, " vptridx=%s",
8088 expr_as_string (BINFO_VPTR_INDEX (binfo
),
8089 TFF_PLAIN_IDENTIFIER
));
8091 if (BINFO_VPTR_FIELD (binfo
))
8093 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8094 fprintf (stream
, " vbaseoffset=%s",
8095 expr_as_string (BINFO_VPTR_FIELD (binfo
),
8096 TFF_PLAIN_IDENTIFIER
));
8098 if (BINFO_VTABLE (binfo
))
8100 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8101 fprintf (stream
, " vptr=%s",
8102 expr_as_string (BINFO_VTABLE (binfo
),
8103 TFF_PLAIN_IDENTIFIER
));
8107 fprintf (stream
, "\n");
8110 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
8111 igo
= dump_class_hierarchy_r (stream
, flags
, base_binfo
, igo
, indent
+ 2);
8116 /* Dump the BINFO hierarchy for T. */
8119 dump_class_hierarchy_1 (FILE *stream
, int flags
, tree t
)
8121 fprintf (stream
, "Class %s\n", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8122 fprintf (stream
, " size=%lu align=%lu\n",
8123 (unsigned long)(tree_to_shwi (TYPE_SIZE (t
)) / BITS_PER_UNIT
),
8124 (unsigned long)(TYPE_ALIGN (t
) / BITS_PER_UNIT
));
8125 fprintf (stream
, " base size=%lu base align=%lu\n",
8126 (unsigned long)(tree_to_shwi (TYPE_SIZE (CLASSTYPE_AS_BASE (t
)))
8128 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t
))
8130 dump_class_hierarchy_r (stream
, flags
, TYPE_BINFO (t
), TYPE_BINFO (t
), 0);
8131 fprintf (stream
, "\n");
8134 /* Debug interface to hierarchy dumping. */
8137 debug_class (tree t
)
8139 dump_class_hierarchy_1 (stderr
, TDF_SLIM
, t
);
8143 dump_class_hierarchy (tree t
)
8146 FILE *stream
= dump_begin (TDI_class
, &flags
);
8150 dump_class_hierarchy_1 (stream
, flags
, t
);
8151 dump_end (TDI_class
, stream
);
8156 dump_array (FILE * stream
, tree decl
)
8159 unsigned HOST_WIDE_INT ix
;
8161 tree size
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl
)));
8163 elt
= (tree_to_shwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
))))
8165 fprintf (stream
, "%s:", decl_as_string (decl
, TFF_PLAIN_IDENTIFIER
));
8166 fprintf (stream
, " %s entries",
8167 expr_as_string (size_binop (PLUS_EXPR
, size
, size_one_node
),
8168 TFF_PLAIN_IDENTIFIER
));
8169 fprintf (stream
, "\n");
8171 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
)),
8173 fprintf (stream
, "%-4ld %s\n", (long)(ix
* elt
),
8174 expr_as_string (value
, TFF_PLAIN_IDENTIFIER
));
8178 dump_vtable (tree t
, tree binfo
, tree vtable
)
8181 FILE *stream
= dump_begin (TDI_class
, &flags
);
8186 if (!(flags
& TDF_SLIM
))
8188 int ctor_vtbl_p
= TYPE_BINFO (t
) != binfo
;
8190 fprintf (stream
, "%s for %s",
8191 ctor_vtbl_p
? "Construction vtable" : "Vtable",
8192 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
));
8195 if (!BINFO_VIRTUAL_P (binfo
))
8196 fprintf (stream
, " (0x" HOST_WIDE_INT_PRINT_HEX
" instance)",
8197 (HOST_WIDE_INT
) (uintptr_t) binfo
);
8198 fprintf (stream
, " in %s", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8200 fprintf (stream
, "\n");
8201 dump_array (stream
, vtable
);
8202 fprintf (stream
, "\n");
8205 dump_end (TDI_class
, stream
);
8209 dump_vtt (tree t
, tree vtt
)
8212 FILE *stream
= dump_begin (TDI_class
, &flags
);
8217 if (!(flags
& TDF_SLIM
))
8219 fprintf (stream
, "VTT for %s\n",
8220 type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8221 dump_array (stream
, vtt
);
8222 fprintf (stream
, "\n");
8225 dump_end (TDI_class
, stream
);
8228 /* Dump a function or thunk and its thunkees. */
8231 dump_thunk (FILE *stream
, int indent
, tree thunk
)
8233 static const char spaces
[] = " ";
8234 tree name
= DECL_NAME (thunk
);
8237 fprintf (stream
, "%.*s%p %s %s", indent
, spaces
,
8239 !DECL_THUNK_P (thunk
) ? "function"
8240 : DECL_THIS_THUNK_P (thunk
) ? "this-thunk" : "covariant-thunk",
8241 name
? IDENTIFIER_POINTER (name
) : "<unset>");
8242 if (DECL_THUNK_P (thunk
))
8244 HOST_WIDE_INT fixed_adjust
= THUNK_FIXED_OFFSET (thunk
);
8245 tree virtual_adjust
= THUNK_VIRTUAL_OFFSET (thunk
);
8247 fprintf (stream
, " fixed=" HOST_WIDE_INT_PRINT_DEC
, fixed_adjust
);
8248 if (!virtual_adjust
)
8250 else if (DECL_THIS_THUNK_P (thunk
))
8251 fprintf (stream
, " vcall=" HOST_WIDE_INT_PRINT_DEC
,
8252 tree_to_shwi (virtual_adjust
));
8254 fprintf (stream
, " vbase=" HOST_WIDE_INT_PRINT_DEC
"(%s)",
8255 tree_to_shwi (BINFO_VPTR_FIELD (virtual_adjust
)),
8256 type_as_string (BINFO_TYPE (virtual_adjust
), TFF_SCOPE
));
8257 if (THUNK_ALIAS (thunk
))
8258 fprintf (stream
, " alias to %p", (void *)THUNK_ALIAS (thunk
));
8260 fprintf (stream
, "\n");
8261 for (thunks
= DECL_THUNKS (thunk
); thunks
; thunks
= TREE_CHAIN (thunks
))
8262 dump_thunk (stream
, indent
+ 2, thunks
);
8265 /* Dump the thunks for FN. */
8268 debug_thunks (tree fn
)
8270 dump_thunk (stderr
, 0, fn
);
8273 /* Virtual function table initialization. */
8275 /* Create all the necessary vtables for T and its base classes. */
8278 finish_vtbls (tree t
)
8281 vec
<constructor_elt
, va_gc
> *v
= NULL
;
8282 tree vtable
= BINFO_VTABLE (TYPE_BINFO (t
));
8284 /* We lay out the primary and secondary vtables in one contiguous
8285 vtable. The primary vtable is first, followed by the non-virtual
8286 secondary vtables in inheritance graph order. */
8287 accumulate_vtbl_inits (TYPE_BINFO (t
), TYPE_BINFO (t
), TYPE_BINFO (t
),
8290 /* Then come the virtual bases, also in inheritance graph order. */
8291 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
8293 if (!BINFO_VIRTUAL_P (vbase
))
8295 accumulate_vtbl_inits (vbase
, vbase
, TYPE_BINFO (t
), vtable
, t
, &v
);
8298 if (BINFO_VTABLE (TYPE_BINFO (t
)))
8299 initialize_vtable (TYPE_BINFO (t
), v
);
8302 /* Initialize the vtable for BINFO with the INITS. */
8305 initialize_vtable (tree binfo
, vec
<constructor_elt
, va_gc
> *inits
)
8309 layout_vtable_decl (binfo
, vec_safe_length (inits
));
8310 decl
= get_vtbl_decl_for_binfo (binfo
);
8311 initialize_artificial_var (decl
, inits
);
8312 dump_vtable (BINFO_TYPE (binfo
), binfo
, decl
);
8315 /* Build the VTT (virtual table table) for T.
8316 A class requires a VTT if it has virtual bases.
8319 1 - primary virtual pointer for complete object T
8320 2 - secondary VTTs for each direct non-virtual base of T which requires a
8322 3 - secondary virtual pointers for each direct or indirect base of T which
8323 has virtual bases or is reachable via a virtual path from T.
8324 4 - secondary VTTs for each direct or indirect virtual base of T.
8326 Secondary VTTs look like complete object VTTs without part 4. */
8334 vec
<constructor_elt
, va_gc
> *inits
;
8336 /* Build up the initializers for the VTT. */
8338 index
= size_zero_node
;
8339 build_vtt_inits (TYPE_BINFO (t
), t
, &inits
, &index
);
8341 /* If we didn't need a VTT, we're done. */
8345 /* Figure out the type of the VTT. */
8346 type
= build_array_of_n_type (const_ptr_type_node
,
8349 /* Now, build the VTT object itself. */
8350 vtt
= build_vtable (t
, mangle_vtt_for_type (t
), type
);
8351 initialize_artificial_var (vtt
, inits
);
8352 /* Add the VTT to the vtables list. */
8353 DECL_CHAIN (vtt
) = DECL_CHAIN (CLASSTYPE_VTABLES (t
));
8354 DECL_CHAIN (CLASSTYPE_VTABLES (t
)) = vtt
;
8359 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
8360 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
8361 and CHAIN the vtable pointer for this binfo after construction is
8362 complete. VALUE can also be another BINFO, in which case we recurse. */
8365 binfo_ctor_vtable (tree binfo
)
8371 vt
= BINFO_VTABLE (binfo
);
8372 if (TREE_CODE (vt
) == TREE_LIST
)
8373 vt
= TREE_VALUE (vt
);
8374 if (TREE_CODE (vt
) == TREE_BINFO
)
8383 /* Data for secondary VTT initialization. */
8384 typedef struct secondary_vptr_vtt_init_data_s
8386 /* Is this the primary VTT? */
8389 /* Current index into the VTT. */
8392 /* Vector of initializers built up. */
8393 vec
<constructor_elt
, va_gc
> *inits
;
8395 /* The type being constructed by this secondary VTT. */
8396 tree type_being_constructed
;
8397 } secondary_vptr_vtt_init_data
;
8399 /* Recursively build the VTT-initializer for BINFO (which is in the
8400 hierarchy dominated by T). INITS points to the end of the initializer
8401 list to date. INDEX is the VTT index where the next element will be
8402 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
8403 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
8404 for virtual bases of T. When it is not so, we build the constructor
8405 vtables for the BINFO-in-T variant. */
8408 build_vtt_inits (tree binfo
, tree t
, vec
<constructor_elt
, va_gc
> **inits
,
8414 secondary_vptr_vtt_init_data data
;
8415 int top_level_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
8417 /* We only need VTTs for subobjects with virtual bases. */
8418 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
8421 /* We need to use a construction vtable if this is not the primary
8425 build_ctor_vtbl_group (binfo
, t
);
8427 /* Record the offset in the VTT where this sub-VTT can be found. */
8428 BINFO_SUBVTT_INDEX (binfo
) = *index
;
8431 /* Add the address of the primary vtable for the complete object. */
8432 init
= binfo_ctor_vtable (binfo
);
8433 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8436 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
8437 BINFO_VPTR_INDEX (binfo
) = *index
;
8439 *index
= size_binop (PLUS_EXPR
, *index
, TYPE_SIZE_UNIT (ptr_type_node
));
8441 /* Recursively add the secondary VTTs for non-virtual bases. */
8442 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, b
); ++i
)
8443 if (!BINFO_VIRTUAL_P (b
))
8444 build_vtt_inits (b
, t
, inits
, index
);
8446 /* Add secondary virtual pointers for all subobjects of BINFO with
8447 either virtual bases or reachable along a virtual path, except
8448 subobjects that are non-virtual primary bases. */
8449 data
.top_level_p
= top_level_p
;
8450 data
.index
= *index
;
8451 data
.inits
= *inits
;
8452 data
.type_being_constructed
= BINFO_TYPE (binfo
);
8454 dfs_walk_once (binfo
, dfs_build_secondary_vptr_vtt_inits
, NULL
, &data
);
8456 *index
= data
.index
;
8458 /* data.inits might have grown as we added secondary virtual pointers.
8459 Make sure our caller knows about the new vector. */
8460 *inits
= data
.inits
;
8463 /* Add the secondary VTTs for virtual bases in inheritance graph
8465 for (b
= TYPE_BINFO (BINFO_TYPE (binfo
)); b
; b
= TREE_CHAIN (b
))
8467 if (!BINFO_VIRTUAL_P (b
))
8470 build_vtt_inits (b
, t
, inits
, index
);
8473 /* Remove the ctor vtables we created. */
8474 dfs_walk_all (binfo
, dfs_fixup_binfo_vtbls
, NULL
, binfo
);
8477 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
8478 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
8481 dfs_build_secondary_vptr_vtt_inits (tree binfo
, void *data_
)
8483 secondary_vptr_vtt_init_data
*data
= (secondary_vptr_vtt_init_data
*)data_
;
8485 /* We don't care about bases that don't have vtables. */
8486 if (!TYPE_VFIELD (BINFO_TYPE (binfo
)))
8487 return dfs_skip_bases
;
8489 /* We're only interested in proper subobjects of the type being
8491 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->type_being_constructed
))
8494 /* We're only interested in bases with virtual bases or reachable
8495 via a virtual path from the type being constructed. */
8496 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
8497 || binfo_via_virtual (binfo
, data
->type_being_constructed
)))
8498 return dfs_skip_bases
;
8500 /* We're not interested in non-virtual primary bases. */
8501 if (!BINFO_VIRTUAL_P (binfo
) && BINFO_PRIMARY_P (binfo
))
8504 /* Record the index where this secondary vptr can be found. */
8505 if (data
->top_level_p
)
8507 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
8508 BINFO_VPTR_INDEX (binfo
) = data
->index
;
8510 if (BINFO_VIRTUAL_P (binfo
))
8512 /* It's a primary virtual base, and this is not a
8513 construction vtable. Find the base this is primary of in
8514 the inheritance graph, and use that base's vtable
8516 while (BINFO_PRIMARY_P (binfo
))
8517 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
8521 /* Add the initializer for the secondary vptr itself. */
8522 CONSTRUCTOR_APPEND_ELT (data
->inits
, NULL_TREE
, binfo_ctor_vtable (binfo
));
8524 /* Advance the vtt index. */
8525 data
->index
= size_binop (PLUS_EXPR
, data
->index
,
8526 TYPE_SIZE_UNIT (ptr_type_node
));
8531 /* Called from build_vtt_inits via dfs_walk. After building
8532 constructor vtables and generating the sub-vtt from them, we need
8533 to restore the BINFO_VTABLES that were scribbled on. DATA is the
8534 binfo of the base whose sub vtt was generated. */
8537 dfs_fixup_binfo_vtbls (tree binfo
, void* data
)
8539 tree vtable
= BINFO_VTABLE (binfo
);
8541 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
8542 /* If this class has no vtable, none of its bases do. */
8543 return dfs_skip_bases
;
8546 /* This might be a primary base, so have no vtable in this
8550 /* If we scribbled the construction vtable vptr into BINFO, clear it
8552 if (TREE_CODE (vtable
) == TREE_LIST
8553 && (TREE_PURPOSE (vtable
) == (tree
) data
))
8554 BINFO_VTABLE (binfo
) = TREE_CHAIN (vtable
);
8559 /* Build the construction vtable group for BINFO which is in the
8560 hierarchy dominated by T. */
8563 build_ctor_vtbl_group (tree binfo
, tree t
)
8569 vec
<constructor_elt
, va_gc
> *v
;
8571 /* See if we've already created this construction vtable group. */
8572 id
= mangle_ctor_vtbl_for_type (t
, binfo
);
8573 if (IDENTIFIER_GLOBAL_VALUE (id
))
8576 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
));
8577 /* Build a version of VTBL (with the wrong type) for use in
8578 constructing the addresses of secondary vtables in the
8579 construction vtable group. */
8580 vtbl
= build_vtable (t
, id
, ptr_type_node
);
8581 DECL_CONSTRUCTION_VTABLE_P (vtbl
) = 1;
8582 /* Don't export construction vtables from shared libraries. Even on
8583 targets that don't support hidden visibility, this tells
8584 can_refer_decl_in_current_unit_p not to assume that it's safe to
8585 access from a different compilation unit (bz 54314). */
8586 DECL_VISIBILITY (vtbl
) = VISIBILITY_HIDDEN
;
8587 DECL_VISIBILITY_SPECIFIED (vtbl
) = true;
8590 accumulate_vtbl_inits (binfo
, TYPE_BINFO (TREE_TYPE (binfo
)),
8591 binfo
, vtbl
, t
, &v
);
8593 /* Add the vtables for each of our virtual bases using the vbase in T
8595 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
8597 vbase
= TREE_CHAIN (vbase
))
8601 if (!BINFO_VIRTUAL_P (vbase
))
8603 b
= copied_binfo (vbase
, binfo
);
8605 accumulate_vtbl_inits (b
, vbase
, binfo
, vtbl
, t
, &v
);
8608 /* Figure out the type of the construction vtable. */
8609 type
= build_array_of_n_type (vtable_entry_type
, v
->length ());
8611 TREE_TYPE (vtbl
) = type
;
8612 DECL_SIZE (vtbl
) = DECL_SIZE_UNIT (vtbl
) = NULL_TREE
;
8613 layout_decl (vtbl
, 0);
8615 /* Initialize the construction vtable. */
8616 CLASSTYPE_VTABLES (t
) = chainon (CLASSTYPE_VTABLES (t
), vtbl
);
8617 initialize_artificial_var (vtbl
, v
);
8618 dump_vtable (t
, binfo
, vtbl
);
8621 /* Add the vtbl initializers for BINFO (and its bases other than
8622 non-virtual primaries) to the list of INITS. BINFO is in the
8623 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
8624 the constructor the vtbl inits should be accumulated for. (If this
8625 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
8626 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
8627 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
8628 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
8629 but are not necessarily the same in terms of layout. */
8632 accumulate_vtbl_inits (tree binfo
,
8637 vec
<constructor_elt
, va_gc
> **inits
)
8641 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8643 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (orig_binfo
)));
8645 /* If it doesn't have a vptr, we don't do anything. */
8646 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
8649 /* If we're building a construction vtable, we're not interested in
8650 subobjects that don't require construction vtables. */
8652 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
8653 && !binfo_via_virtual (orig_binfo
, BINFO_TYPE (rtti_binfo
)))
8656 /* Build the initializers for the BINFO-in-T vtable. */
8657 dfs_accumulate_vtbl_inits (binfo
, orig_binfo
, rtti_binfo
, vtbl
, t
, inits
);
8659 /* Walk the BINFO and its bases. We walk in preorder so that as we
8660 initialize each vtable we can figure out at what offset the
8661 secondary vtable lies from the primary vtable. We can't use
8662 dfs_walk here because we need to iterate through bases of BINFO
8663 and RTTI_BINFO simultaneously. */
8664 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
8666 /* Skip virtual bases. */
8667 if (BINFO_VIRTUAL_P (base_binfo
))
8669 accumulate_vtbl_inits (base_binfo
,
8670 BINFO_BASE_BINFO (orig_binfo
, i
),
8671 rtti_binfo
, vtbl
, t
,
8676 /* Called from accumulate_vtbl_inits. Adds the initializers for the
8677 BINFO vtable to L. */
8680 dfs_accumulate_vtbl_inits (tree binfo
,
8685 vec
<constructor_elt
, va_gc
> **l
)
8687 tree vtbl
= NULL_TREE
;
8688 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8692 && BINFO_VIRTUAL_P (orig_binfo
) && BINFO_PRIMARY_P (orig_binfo
))
8694 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
8695 primary virtual base. If it is not the same primary in
8696 the hierarchy of T, we'll need to generate a ctor vtable
8697 for it, to place at its location in T. If it is the same
8698 primary, we still need a VTT entry for the vtable, but it
8699 should point to the ctor vtable for the base it is a
8700 primary for within the sub-hierarchy of RTTI_BINFO.
8702 There are three possible cases:
8704 1) We are in the same place.
8705 2) We are a primary base within a lost primary virtual base of
8707 3) We are primary to something not a base of RTTI_BINFO. */
8710 tree last
= NULL_TREE
;
8712 /* First, look through the bases we are primary to for RTTI_BINFO
8713 or a virtual base. */
8715 while (BINFO_PRIMARY_P (b
))
8717 b
= BINFO_INHERITANCE_CHAIN (b
);
8719 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
8722 /* If we run out of primary links, keep looking down our
8723 inheritance chain; we might be an indirect primary. */
8724 for (b
= last
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
8725 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
8729 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
8730 base B and it is a base of RTTI_BINFO, this is case 2. In
8731 either case, we share our vtable with LAST, i.e. the
8732 derived-most base within B of which we are a primary. */
8734 || (b
&& binfo_for_vbase (BINFO_TYPE (b
), BINFO_TYPE (rtti_binfo
))))
8735 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
8736 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
8737 binfo_ctor_vtable after everything's been set up. */
8740 /* Otherwise, this is case 3 and we get our own. */
8742 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo
))
8745 n_inits
= vec_safe_length (*l
);
8752 /* Add the initializer for this vtable. */
8753 build_vtbl_initializer (binfo
, orig_binfo
, t
, rtti_binfo
,
8754 &non_fn_entries
, l
);
8756 /* Figure out the position to which the VPTR should point. */
8757 vtbl
= build1 (ADDR_EXPR
, vtbl_ptr_type_node
, orig_vtbl
);
8758 index
= size_binop (MULT_EXPR
,
8759 TYPE_SIZE_UNIT (vtable_entry_type
),
8760 size_int (non_fn_entries
+ n_inits
));
8761 vtbl
= fold_build_pointer_plus (vtbl
, index
);
8765 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
8766 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
8767 straighten this out. */
8768 BINFO_VTABLE (binfo
) = tree_cons (rtti_binfo
, vtbl
, BINFO_VTABLE (binfo
));
8769 else if (BINFO_PRIMARY_P (binfo
) && BINFO_VIRTUAL_P (binfo
))
8770 /* Throw away any unneeded intializers. */
8771 (*l
)->truncate (n_inits
);
8773 /* For an ordinary vtable, set BINFO_VTABLE. */
8774 BINFO_VTABLE (binfo
) = vtbl
;
8777 static GTY(()) tree abort_fndecl_addr
;
8779 /* Construct the initializer for BINFO's virtual function table. BINFO
8780 is part of the hierarchy dominated by T. If we're building a
8781 construction vtable, the ORIG_BINFO is the binfo we should use to
8782 find the actual function pointers to put in the vtable - but they
8783 can be overridden on the path to most-derived in the graph that
8784 ORIG_BINFO belongs. Otherwise,
8785 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
8786 BINFO that should be indicated by the RTTI information in the
8787 vtable; it will be a base class of T, rather than T itself, if we
8788 are building a construction vtable.
8790 The value returned is a TREE_LIST suitable for wrapping in a
8791 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
8792 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
8793 number of non-function entries in the vtable.
8795 It might seem that this function should never be called with a
8796 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
8797 base is always subsumed by a derived class vtable. However, when
8798 we are building construction vtables, we do build vtables for
8799 primary bases; we need these while the primary base is being
8803 build_vtbl_initializer (tree binfo
,
8807 int* non_fn_entries_p
,
8808 vec
<constructor_elt
, va_gc
> **inits
)
8814 vec
<tree
, va_gc
> *vbases
;
8817 /* Initialize VID. */
8818 memset (&vid
, 0, sizeof (vid
));
8821 vid
.rtti_binfo
= rtti_binfo
;
8822 vid
.primary_vtbl_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
8823 vid
.ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8824 vid
.generate_vcall_entries
= true;
8825 /* The first vbase or vcall offset is at index -3 in the vtable. */
8826 vid
.index
= ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
8828 /* Add entries to the vtable for RTTI. */
8829 build_rtti_vtbl_entries (binfo
, &vid
);
8831 /* Create an array for keeping track of the functions we've
8832 processed. When we see multiple functions with the same
8833 signature, we share the vcall offsets. */
8834 vec_alloc (vid
.fns
, 32);
8835 /* Add the vcall and vbase offset entries. */
8836 build_vcall_and_vbase_vtbl_entries (binfo
, &vid
);
8838 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
8839 build_vbase_offset_vtbl_entries. */
8840 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
8841 vec_safe_iterate (vbases
, ix
, &vbinfo
); ix
++)
8842 BINFO_VTABLE_PATH_MARKED (vbinfo
) = 0;
8844 /* If the target requires padding between data entries, add that now. */
8845 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE
> 1)
8847 int n_entries
= vec_safe_length (vid
.inits
);
8849 vec_safe_grow (vid
.inits
, TARGET_VTABLE_DATA_ENTRY_DISTANCE
* n_entries
);
8851 /* Move data entries into their new positions and add padding
8852 after the new positions. Iterate backwards so we don't
8853 overwrite entries that we would need to process later. */
8854 for (ix
= n_entries
- 1;
8855 vid
.inits
->iterate (ix
, &e
);
8859 int new_position
= (TARGET_VTABLE_DATA_ENTRY_DISTANCE
* ix
8860 + (TARGET_VTABLE_DATA_ENTRY_DISTANCE
- 1));
8862 (*vid
.inits
)[new_position
] = *e
;
8864 for (j
= 1; j
< TARGET_VTABLE_DATA_ENTRY_DISTANCE
; ++j
)
8866 constructor_elt
*f
= &(*vid
.inits
)[new_position
- j
];
8867 f
->index
= NULL_TREE
;
8868 f
->value
= build1 (NOP_EXPR
, vtable_entry_type
,
8874 if (non_fn_entries_p
)
8875 *non_fn_entries_p
= vec_safe_length (vid
.inits
);
8877 /* The initializers for virtual functions were built up in reverse
8878 order. Straighten them out and add them to the running list in one
8880 jx
= vec_safe_length (*inits
);
8881 vec_safe_grow (*inits
, jx
+ vid
.inits
->length ());
8883 for (ix
= vid
.inits
->length () - 1;
8884 vid
.inits
->iterate (ix
, &e
);
8888 /* Go through all the ordinary virtual functions, building up
8890 for (v
= BINFO_VIRTUALS (orig_binfo
); v
; v
= TREE_CHAIN (v
))
8894 tree fn
, fn_original
;
8895 tree init
= NULL_TREE
;
8899 if (DECL_THUNK_P (fn
))
8901 if (!DECL_NAME (fn
))
8903 if (THUNK_ALIAS (fn
))
8905 fn
= THUNK_ALIAS (fn
);
8908 fn_original
= THUNK_TARGET (fn
);
8911 /* If the only definition of this function signature along our
8912 primary base chain is from a lost primary, this vtable slot will
8913 never be used, so just zero it out. This is important to avoid
8914 requiring extra thunks which cannot be generated with the function.
8916 We first check this in update_vtable_entry_for_fn, so we handle
8917 restored primary bases properly; we also need to do it here so we
8918 zero out unused slots in ctor vtables, rather than filling them
8919 with erroneous values (though harmless, apart from relocation
8921 if (BV_LOST_PRIMARY (v
))
8922 init
= size_zero_node
;
8926 /* Pull the offset for `this', and the function to call, out of
8928 delta
= BV_DELTA (v
);
8929 vcall_index
= BV_VCALL_INDEX (v
);
8931 gcc_assert (TREE_CODE (delta
) == INTEGER_CST
);
8932 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
8934 /* You can't call an abstract virtual function; it's abstract.
8935 So, we replace these functions with __pure_virtual. */
8936 if (DECL_PURE_VIRTUAL_P (fn_original
))
8939 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8941 if (abort_fndecl_addr
== NULL
)
8943 = fold_convert (vfunc_ptr_type_node
,
8944 build_fold_addr_expr (fn
));
8945 init
= abort_fndecl_addr
;
8948 /* Likewise for deleted virtuals. */
8949 else if (DECL_DELETED_FN (fn_original
))
8951 fn
= get_identifier ("__cxa_deleted_virtual");
8952 if (!get_global_value_if_present (fn
, &fn
))
8953 fn
= push_library_fn (fn
, (build_function_type_list
8954 (void_type_node
, NULL_TREE
)),
8955 NULL_TREE
, ECF_NORETURN
);
8956 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8957 init
= fold_convert (vfunc_ptr_type_node
,
8958 build_fold_addr_expr (fn
));
8962 if (!integer_zerop (delta
) || vcall_index
)
8964 fn
= make_thunk (fn
, /*this_adjusting=*/1, delta
, vcall_index
);
8965 if (!DECL_NAME (fn
))
8968 /* Take the address of the function, considering it to be of an
8969 appropriate generic type. */
8970 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8971 init
= fold_convert (vfunc_ptr_type_node
,
8972 build_fold_addr_expr (fn
));
8976 /* And add it to the chain of initializers. */
8977 if (TARGET_VTABLE_USES_DESCRIPTORS
)
8980 if (init
== size_zero_node
)
8981 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
8982 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8984 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
8986 tree fdesc
= build2 (FDESC_EXPR
, vfunc_ptr_type_node
,
8987 fn
, build_int_cst (NULL_TREE
, i
));
8988 TREE_CONSTANT (fdesc
) = 1;
8990 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, fdesc
);
8994 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8998 /* Adds to vid->inits the initializers for the vbase and vcall
8999 offsets in BINFO, which is in the hierarchy dominated by T. */
9002 build_vcall_and_vbase_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9006 /* If this is a derived class, we must first create entries
9007 corresponding to the primary base class. */
9008 b
= get_primary_binfo (binfo
);
9010 build_vcall_and_vbase_vtbl_entries (b
, vid
);
9012 /* Add the vbase entries for this base. */
9013 build_vbase_offset_vtbl_entries (binfo
, vid
);
9014 /* Add the vcall entries for this base. */
9015 build_vcall_offset_vtbl_entries (binfo
, vid
);
9018 /* Returns the initializers for the vbase offset entries in the vtable
9019 for BINFO (which is part of the class hierarchy dominated by T), in
9020 reverse order. VBASE_OFFSET_INDEX gives the vtable index
9021 where the next vbase offset will go. */
9024 build_vbase_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9028 tree non_primary_binfo
;
9030 /* If there are no virtual baseclasses, then there is nothing to
9032 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
9037 /* We might be a primary base class. Go up the inheritance hierarchy
9038 until we find the most derived class of which we are a primary base:
9039 it is the offset of that which we need to use. */
9040 non_primary_binfo
= binfo
;
9041 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
9045 /* If we have reached a virtual base, then it must be a primary
9046 base (possibly multi-level) of vid->binfo, or we wouldn't
9047 have called build_vcall_and_vbase_vtbl_entries for it. But it
9048 might be a lost primary, so just skip down to vid->binfo. */
9049 if (BINFO_VIRTUAL_P (non_primary_binfo
))
9051 non_primary_binfo
= vid
->binfo
;
9055 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
9056 if (get_primary_binfo (b
) != non_primary_binfo
)
9058 non_primary_binfo
= b
;
9061 /* Go through the virtual bases, adding the offsets. */
9062 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
9064 vbase
= TREE_CHAIN (vbase
))
9069 if (!BINFO_VIRTUAL_P (vbase
))
9072 /* Find the instance of this virtual base in the complete
9074 b
= copied_binfo (vbase
, binfo
);
9076 /* If we've already got an offset for this virtual base, we
9077 don't need another one. */
9078 if (BINFO_VTABLE_PATH_MARKED (b
))
9080 BINFO_VTABLE_PATH_MARKED (b
) = 1;
9082 /* Figure out where we can find this vbase offset. */
9083 delta
= size_binop (MULT_EXPR
,
9086 TYPE_SIZE_UNIT (vtable_entry_type
)));
9087 if (vid
->primary_vtbl_p
)
9088 BINFO_VPTR_FIELD (b
) = delta
;
9090 if (binfo
!= TYPE_BINFO (t
))
9091 /* The vbase offset had better be the same. */
9092 gcc_assert (tree_int_cst_equal (delta
, BINFO_VPTR_FIELD (vbase
)));
9094 /* The next vbase will come at a more negative offset. */
9095 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
9096 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
9098 /* The initializer is the delta from BINFO to this virtual base.
9099 The vbase offsets go in reverse inheritance-graph order, and
9100 we are walking in inheritance graph order so these end up in
9102 delta
= size_diffop_loc (input_location
,
9103 BINFO_OFFSET (b
), BINFO_OFFSET (non_primary_binfo
));
9105 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
,
9106 fold_build1_loc (input_location
, NOP_EXPR
,
9107 vtable_entry_type
, delta
));
9111 /* Adds the initializers for the vcall offset entries in the vtable
9112 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
9116 build_vcall_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9118 /* We only need these entries if this base is a virtual base. We
9119 compute the indices -- but do not add to the vtable -- when
9120 building the main vtable for a class. */
9121 if (binfo
== TYPE_BINFO (vid
->derived
)
9122 || (BINFO_VIRTUAL_P (binfo
)
9123 /* If BINFO is RTTI_BINFO, then (since BINFO does not
9124 correspond to VID->DERIVED), we are building a primary
9125 construction virtual table. Since this is a primary
9126 virtual table, we do not need the vcall offsets for
9128 && binfo
!= vid
->rtti_binfo
))
9130 /* We need a vcall offset for each of the virtual functions in this
9131 vtable. For example:
9133 class A { virtual void f (); };
9134 class B1 : virtual public A { virtual void f (); };
9135 class B2 : virtual public A { virtual void f (); };
9136 class C: public B1, public B2 { virtual void f (); };
9138 A C object has a primary base of B1, which has a primary base of A. A
9139 C also has a secondary base of B2, which no longer has a primary base
9140 of A. So the B2-in-C construction vtable needs a secondary vtable for
9141 A, which will adjust the A* to a B2* to call f. We have no way of
9142 knowing what (or even whether) this offset will be when we define B2,
9143 so we store this "vcall offset" in the A sub-vtable and look it up in
9144 a "virtual thunk" for B2::f.
9146 We need entries for all the functions in our primary vtable and
9147 in our non-virtual bases' secondary vtables. */
9149 /* If we are just computing the vcall indices -- but do not need
9150 the actual entries -- not that. */
9151 if (!BINFO_VIRTUAL_P (binfo
))
9152 vid
->generate_vcall_entries
= false;
9153 /* Now, walk through the non-virtual bases, adding vcall offsets. */
9154 add_vcall_offset_vtbl_entries_r (binfo
, vid
);
9158 /* Build vcall offsets, starting with those for BINFO. */
9161 add_vcall_offset_vtbl_entries_r (tree binfo
, vtbl_init_data
* vid
)
9167 /* Don't walk into virtual bases -- except, of course, for the
9168 virtual base for which we are building vcall offsets. Any
9169 primary virtual base will have already had its offsets generated
9170 through the recursion in build_vcall_and_vbase_vtbl_entries. */
9171 if (BINFO_VIRTUAL_P (binfo
) && vid
->vbase
!= binfo
)
9174 /* If BINFO has a primary base, process it first. */
9175 primary_binfo
= get_primary_binfo (binfo
);
9177 add_vcall_offset_vtbl_entries_r (primary_binfo
, vid
);
9179 /* Add BINFO itself to the list. */
9180 add_vcall_offset_vtbl_entries_1 (binfo
, vid
);
9182 /* Scan the non-primary bases of BINFO. */
9183 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
9184 if (base_binfo
!= primary_binfo
)
9185 add_vcall_offset_vtbl_entries_r (base_binfo
, vid
);
9188 /* Called from build_vcall_offset_vtbl_entries_r. */
9191 add_vcall_offset_vtbl_entries_1 (tree binfo
, vtbl_init_data
* vid
)
9193 /* Make entries for the rest of the virtuals. */
9194 if (abi_version_at_least (2))
9198 /* The ABI requires that the methods be processed in declaration
9199 order. G++ 3.2 used the order in the vtable. */
9200 for (orig_fn
= TYPE_METHODS (BINFO_TYPE (binfo
));
9202 orig_fn
= DECL_CHAIN (orig_fn
))
9203 if (DECL_VINDEX (orig_fn
))
9204 add_vcall_offset (orig_fn
, binfo
, vid
);
9208 tree derived_virtuals
;
9211 /* If BINFO is a primary base, the most derived class which has
9212 BINFO as a primary base; otherwise, just BINFO. */
9213 tree non_primary_binfo
;
9215 /* We might be a primary base class. Go up the inheritance hierarchy
9216 until we find the most derived class of which we are a primary base:
9217 it is the BINFO_VIRTUALS there that we need to consider. */
9218 non_primary_binfo
= binfo
;
9219 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
9223 /* If we have reached a virtual base, then it must be vid->vbase,
9224 because we ignore other virtual bases in
9225 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
9226 base (possibly multi-level) of vid->binfo, or we wouldn't
9227 have called build_vcall_and_vbase_vtbl_entries for it. But it
9228 might be a lost primary, so just skip down to vid->binfo. */
9229 if (BINFO_VIRTUAL_P (non_primary_binfo
))
9231 gcc_assert (non_primary_binfo
== vid
->vbase
);
9232 non_primary_binfo
= vid
->binfo
;
9236 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
9237 if (get_primary_binfo (b
) != non_primary_binfo
)
9239 non_primary_binfo
= b
;
9242 if (vid
->ctor_vtbl_p
)
9243 /* For a ctor vtable we need the equivalent binfo within the hierarchy
9244 where rtti_binfo is the most derived type. */
9246 = original_binfo (non_primary_binfo
, vid
->rtti_binfo
);
9248 for (base_virtuals
= BINFO_VIRTUALS (binfo
),
9249 derived_virtuals
= BINFO_VIRTUALS (non_primary_binfo
),
9250 orig_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
9252 base_virtuals
= TREE_CHAIN (base_virtuals
),
9253 derived_virtuals
= TREE_CHAIN (derived_virtuals
),
9254 orig_virtuals
= TREE_CHAIN (orig_virtuals
))
9258 /* Find the declaration that originally caused this function to
9259 be present in BINFO_TYPE (binfo). */
9260 orig_fn
= BV_FN (orig_virtuals
);
9262 /* When processing BINFO, we only want to generate vcall slots for
9263 function slots introduced in BINFO. So don't try to generate
9264 one if the function isn't even defined in BINFO. */
9265 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), DECL_CONTEXT (orig_fn
)))
9268 add_vcall_offset (orig_fn
, binfo
, vid
);
9273 /* Add a vcall offset entry for ORIG_FN to the vtable. */
9276 add_vcall_offset (tree orig_fn
, tree binfo
, vtbl_init_data
*vid
)
9282 /* If there is already an entry for a function with the same
9283 signature as FN, then we do not need a second vcall offset.
9284 Check the list of functions already present in the derived
9286 FOR_EACH_VEC_SAFE_ELT (vid
->fns
, i
, derived_entry
)
9288 if (same_signature_p (derived_entry
, orig_fn
)
9289 /* We only use one vcall offset for virtual destructors,
9290 even though there are two virtual table entries. */
9291 || (DECL_DESTRUCTOR_P (derived_entry
)
9292 && DECL_DESTRUCTOR_P (orig_fn
)))
9296 /* If we are building these vcall offsets as part of building
9297 the vtable for the most derived class, remember the vcall
9299 if (vid
->binfo
== TYPE_BINFO (vid
->derived
))
9301 tree_pair_s elt
= {orig_fn
, vid
->index
};
9302 vec_safe_push (CLASSTYPE_VCALL_INDICES (vid
->derived
), elt
);
9305 /* The next vcall offset will be found at a more negative
9307 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
9308 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
9310 /* Keep track of this function. */
9311 vec_safe_push (vid
->fns
, orig_fn
);
9313 if (vid
->generate_vcall_entries
)
9318 /* Find the overriding function. */
9319 fn
= find_final_overrider (vid
->rtti_binfo
, binfo
, orig_fn
);
9320 if (fn
== error_mark_node
)
9321 vcall_offset
= build_zero_cst (vtable_entry_type
);
9324 base
= TREE_VALUE (fn
);
9326 /* The vbase we're working on is a primary base of
9327 vid->binfo. But it might be a lost primary, so its
9328 BINFO_OFFSET might be wrong, so we just use the
9329 BINFO_OFFSET from vid->binfo. */
9330 vcall_offset
= size_diffop_loc (input_location
,
9331 BINFO_OFFSET (base
),
9332 BINFO_OFFSET (vid
->binfo
));
9333 vcall_offset
= fold_build1_loc (input_location
,
9334 NOP_EXPR
, vtable_entry_type
,
9337 /* Add the initializer to the vtable. */
9338 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, vcall_offset
);
9342 /* Return vtbl initializers for the RTTI entries corresponding to the
9343 BINFO's vtable. The RTTI entries should indicate the object given
9344 by VID->rtti_binfo. */
9347 build_rtti_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9355 t
= BINFO_TYPE (vid
->rtti_binfo
);
9357 /* To find the complete object, we will first convert to our most
9358 primary base, and then add the offset in the vtbl to that value. */
9360 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b
))
9361 && !BINFO_LOST_PRIMARY_P (b
))
9365 primary_base
= get_primary_binfo (b
);
9366 gcc_assert (BINFO_PRIMARY_P (primary_base
)
9367 && BINFO_INHERITANCE_CHAIN (primary_base
) == b
);
9370 offset
= size_diffop_loc (input_location
,
9371 BINFO_OFFSET (vid
->rtti_binfo
), BINFO_OFFSET (b
));
9373 /* The second entry is the address of the typeinfo object. */
9375 decl
= build_address (get_tinfo_decl (t
));
9377 decl
= integer_zero_node
;
9379 /* Convert the declaration to a type that can be stored in the
9381 init
= build_nop (vfunc_ptr_type_node
, decl
);
9382 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, init
);
9384 /* Add the offset-to-top entry. It comes earlier in the vtable than
9385 the typeinfo entry. Convert the offset to look like a
9386 function pointer, so that we can put it in the vtable. */
9387 init
= build_nop (vfunc_ptr_type_node
, offset
);
9388 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, init
);
9391 /* TRUE iff TYPE is uniquely derived from PARENT. Ignores
9395 uniquely_derived_from_p (tree parent
, tree type
)
9397 tree base
= lookup_base (type
, parent
, ba_unique
, NULL
, tf_none
);
9398 return base
&& base
!= error_mark_node
;
9401 /* TRUE iff TYPE is publicly & uniquely derived from PARENT. */
9404 publicly_uniquely_derived_p (tree parent
, tree type
)
9406 tree base
= lookup_base (type
, parent
, ba_ignore_scope
| ba_check
,
9408 return base
&& base
!= error_mark_node
;
9411 /* CTX1 and CTX2 are declaration contexts. Return the innermost common
9412 class between them, if any. */
9415 common_enclosing_class (tree ctx1
, tree ctx2
)
9417 if (!TYPE_P (ctx1
) || !TYPE_P (ctx2
))
9419 gcc_assert (ctx1
== TYPE_MAIN_VARIANT (ctx1
)
9420 && ctx2
== TYPE_MAIN_VARIANT (ctx2
));
9423 for (tree t
= ctx1
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9424 TYPE_MARKED_P (t
) = true;
9425 tree found
= NULL_TREE
;
9426 for (tree t
= ctx2
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9427 if (TYPE_MARKED_P (t
))
9432 for (tree t
= ctx1
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9433 TYPE_MARKED_P (t
) = false;
9437 #include "gt-cp-class.h"