1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987-2015 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 "hash-table.h"
40 #include "plugin-api.h"
45 #include "hard-reg-set.h"
51 #include "splay-tree.h"
55 /* The number of nested classes being processed. If we are not in the
56 scope of any class, this is zero. */
58 int current_class_depth
;
60 /* In order to deal with nested classes, we keep a stack of classes.
61 The topmost entry is the innermost class, and is the entry at index
62 CURRENT_CLASS_DEPTH */
64 typedef struct class_stack_node
{
65 /* The name of the class. */
68 /* The _TYPE node for the class. */
71 /* The access specifier pending for new declarations in the scope of
75 /* If were defining TYPE, the names used in this class. */
76 splay_tree names_used
;
78 /* Nonzero if this class is no longer open, because of a call to
81 }* class_stack_node_t
;
83 typedef struct vtbl_init_data_s
85 /* The base for which we're building initializers. */
87 /* The type of the most-derived type. */
89 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
90 unless ctor_vtbl_p is true. */
92 /* The negative-index vtable initializers built up so far. These
93 are in order from least negative index to most negative index. */
94 vec
<constructor_elt
, va_gc
> *inits
;
95 /* The binfo for the virtual base for which we're building
96 vcall offset initializers. */
98 /* The functions in vbase for which we have already provided vcall
100 vec
<tree
, va_gc
> *fns
;
101 /* The vtable index of the next vcall or vbase offset. */
103 /* Nonzero if we are building the initializer for the primary
106 /* Nonzero if we are building the initializer for a construction
109 /* True when adding vcall offset entries to the vtable. False when
110 merely computing the indices. */
111 bool generate_vcall_entries
;
114 /* The type of a function passed to walk_subobject_offsets. */
115 typedef int (*subobject_offset_fn
) (tree
, tree
, splay_tree
);
117 /* The stack itself. This is a dynamically resized array. The
118 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
119 static int current_class_stack_size
;
120 static class_stack_node_t current_class_stack
;
122 /* The size of the largest empty class seen in this translation unit. */
123 static GTY (()) tree sizeof_biggest_empty_class
;
125 /* An array of all local classes present in this translation unit, in
126 declaration order. */
127 vec
<tree
, va_gc
> *local_classes
;
129 static tree
get_vfield_name (tree
);
130 static void finish_struct_anon (tree
);
131 static tree
get_vtable_name (tree
);
132 static void get_basefndecls (tree
, tree
, vec
<tree
> *);
133 static int build_primary_vtable (tree
, tree
);
134 static int build_secondary_vtable (tree
);
135 static void finish_vtbls (tree
);
136 static void modify_vtable_entry (tree
, tree
, tree
, tree
, tree
*);
137 static void finish_struct_bits (tree
);
138 static int alter_access (tree
, tree
, tree
);
139 static void handle_using_decl (tree
, tree
);
140 static tree
dfs_modify_vtables (tree
, void *);
141 static tree
modify_all_vtables (tree
, tree
);
142 static void determine_primary_bases (tree
);
143 static void finish_struct_methods (tree
);
144 static void maybe_warn_about_overly_private_class (tree
);
145 static int method_name_cmp (const void *, const void *);
146 static int resort_method_name_cmp (const void *, const void *);
147 static void add_implicitly_declared_members (tree
, tree
*, int, int);
148 static tree
fixed_type_or_null (tree
, int *, int *);
149 static tree
build_simple_base_path (tree expr
, tree binfo
);
150 static tree
build_vtbl_ref_1 (tree
, tree
);
151 static void build_vtbl_initializer (tree
, tree
, tree
, tree
, int *,
152 vec
<constructor_elt
, va_gc
> **);
153 static int count_fields (tree
);
154 static int add_fields_to_record_type (tree
, struct sorted_fields_type
*, int);
155 static void insert_into_classtype_sorted_fields (tree
, tree
, int);
156 static bool check_bitfield_decl (tree
);
157 static void check_field_decl (tree
, tree
, int *, int *, int *);
158 static void check_field_decls (tree
, tree
*, int *, int *);
159 static tree
*build_base_field (record_layout_info
, tree
, splay_tree
, tree
*);
160 static void build_base_fields (record_layout_info
, splay_tree
, tree
*);
161 static void check_methods (tree
);
162 static void remove_zero_width_bit_fields (tree
);
163 static bool accessible_nvdtor_p (tree
);
164 static void check_bases (tree
, int *, int *);
165 static void check_bases_and_members (tree
);
166 static tree
create_vtable_ptr (tree
, tree
*);
167 static void include_empty_classes (record_layout_info
);
168 static void layout_class_type (tree
, tree
*);
169 static void propagate_binfo_offsets (tree
, tree
);
170 static void layout_virtual_bases (record_layout_info
, splay_tree
);
171 static void build_vbase_offset_vtbl_entries (tree
, vtbl_init_data
*);
172 static void add_vcall_offset_vtbl_entries_r (tree
, vtbl_init_data
*);
173 static void add_vcall_offset_vtbl_entries_1 (tree
, vtbl_init_data
*);
174 static void build_vcall_offset_vtbl_entries (tree
, vtbl_init_data
*);
175 static void add_vcall_offset (tree
, tree
, vtbl_init_data
*);
176 static void layout_vtable_decl (tree
, int);
177 static tree
dfs_find_final_overrider_pre (tree
, void *);
178 static tree
dfs_find_final_overrider_post (tree
, void *);
179 static tree
find_final_overrider (tree
, tree
, tree
);
180 static int make_new_vtable (tree
, tree
);
181 static tree
get_primary_binfo (tree
);
182 static int maybe_indent_hierarchy (FILE *, int, int);
183 static tree
dump_class_hierarchy_r (FILE *, int, tree
, tree
, int);
184 static void dump_class_hierarchy (tree
);
185 static void dump_class_hierarchy_1 (FILE *, int, tree
);
186 static void dump_array (FILE *, tree
);
187 static void dump_vtable (tree
, tree
, tree
);
188 static void dump_vtt (tree
, tree
);
189 static void dump_thunk (FILE *, int, tree
);
190 static tree
build_vtable (tree
, tree
, tree
);
191 static void initialize_vtable (tree
, vec
<constructor_elt
, va_gc
> *);
192 static void layout_nonempty_base_or_field (record_layout_info
,
193 tree
, tree
, splay_tree
);
194 static tree
end_of_class (tree
, int);
195 static bool layout_empty_base (record_layout_info
, tree
, tree
, splay_tree
);
196 static void accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
,
197 vec
<constructor_elt
, va_gc
> **);
198 static void dfs_accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
,
199 vec
<constructor_elt
, va_gc
> **);
200 static void build_rtti_vtbl_entries (tree
, vtbl_init_data
*);
201 static void build_vcall_and_vbase_vtbl_entries (tree
, vtbl_init_data
*);
202 static void clone_constructors_and_destructors (tree
);
203 static tree
build_clone (tree
, tree
);
204 static void update_vtable_entry_for_fn (tree
, tree
, tree
, tree
*, unsigned);
205 static void build_ctor_vtbl_group (tree
, tree
);
206 static void build_vtt (tree
);
207 static tree
binfo_ctor_vtable (tree
);
208 static void build_vtt_inits (tree
, tree
, vec
<constructor_elt
, va_gc
> **,
210 static tree
dfs_build_secondary_vptr_vtt_inits (tree
, void *);
211 static tree
dfs_fixup_binfo_vtbls (tree
, void *);
212 static int record_subobject_offset (tree
, tree
, splay_tree
);
213 static int check_subobject_offset (tree
, tree
, splay_tree
);
214 static int walk_subobject_offsets (tree
, subobject_offset_fn
,
215 tree
, splay_tree
, tree
, int);
216 static void record_subobject_offsets (tree
, tree
, splay_tree
, bool);
217 static int layout_conflict_p (tree
, tree
, splay_tree
, int);
218 static int splay_tree_compare_integer_csts (splay_tree_key k1
,
220 static void warn_about_ambiguous_bases (tree
);
221 static bool type_requires_array_cookie (tree
);
222 static bool base_derived_from (tree
, tree
);
223 static int empty_base_at_nonzero_offset_p (tree
, tree
, splay_tree
);
224 static tree
end_of_base (tree
);
225 static tree
get_vcall_index (tree
, tree
);
227 /* Variables shared between class.c and call.c. */
230 int n_vtable_entries
= 0;
231 int n_vtable_searches
= 0;
232 int n_vtable_elems
= 0;
233 int n_convert_harshness
= 0;
234 int n_compute_conversion_costs
= 0;
235 int n_inner_fields_searched
= 0;
237 /* Convert to or from a base subobject. EXPR is an expression of type
238 `A' or `A*', an expression of type `B' or `B*' is returned. To
239 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
240 the B base instance within A. To convert base A to derived B, CODE
241 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
242 In this latter case, A must not be a morally virtual base of B.
243 NONNULL is true if EXPR is known to be non-NULL (this is only
244 needed when EXPR is of pointer type). CV qualifiers are preserved
248 build_base_path (enum tree_code code
,
252 tsubst_flags_t complain
)
254 tree v_binfo
= NULL_TREE
;
255 tree d_binfo
= NULL_TREE
;
259 tree null_test
= NULL
;
260 tree ptr_target_type
;
262 int want_pointer
= TYPE_PTR_P (TREE_TYPE (expr
));
263 bool has_empty
= false;
267 if (expr
== error_mark_node
|| binfo
== error_mark_node
|| !binfo
)
268 return error_mark_node
;
270 for (probe
= binfo
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
273 if (is_empty_class (BINFO_TYPE (probe
)))
275 if (!v_binfo
&& BINFO_VIRTUAL_P (probe
))
279 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
281 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (probe
));
283 if (code
== PLUS_EXPR
284 && !SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo
), probe
))
286 /* This can happen when adjust_result_of_qualified_name_lookup can't
287 find a unique base binfo in a call to a member function. We
288 couldn't give the diagnostic then since we might have been calling
289 a static member function, so we do it now. */
290 if (complain
& tf_error
)
292 tree base
= lookup_base (probe
, BINFO_TYPE (d_binfo
),
293 ba_unique
, NULL
, complain
);
294 gcc_assert (base
== error_mark_node
);
296 return error_mark_node
;
299 gcc_assert ((code
== MINUS_EXPR
300 && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), probe
))
301 || code
== PLUS_EXPR
);
303 if (binfo
== d_binfo
)
307 if (code
== MINUS_EXPR
&& v_binfo
)
309 if (complain
& tf_error
)
311 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (v_binfo
)))
314 error ("cannot convert from pointer to base class %qT to "
315 "pointer to derived class %qT because the base is "
316 "virtual", BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
));
318 error ("cannot convert from base class %qT to derived "
319 "class %qT because the base is virtual",
320 BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
));
325 error ("cannot convert from pointer to base class %qT to "
326 "pointer to derived class %qT via virtual base %qT",
327 BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
),
328 BINFO_TYPE (v_binfo
));
330 error ("cannot convert from base class %qT to derived "
331 "class %qT via virtual base %qT", BINFO_TYPE (binfo
),
332 BINFO_TYPE (d_binfo
), BINFO_TYPE (v_binfo
));
335 return error_mark_node
;
340 rvalue
= !real_lvalue_p (expr
);
341 /* This must happen before the call to save_expr. */
342 expr
= cp_build_addr_expr (expr
, complain
);
345 expr
= mark_rvalue_use (expr
);
347 offset
= BINFO_OFFSET (binfo
);
348 fixed_type_p
= resolves_to_fixed_type_p (expr
, &nonnull
);
349 target_type
= code
== PLUS_EXPR
? BINFO_TYPE (binfo
) : BINFO_TYPE (d_binfo
);
350 /* TARGET_TYPE has been extracted from BINFO, and, is therefore always
351 cv-unqualified. Extract the cv-qualifiers from EXPR so that the
352 expression returned matches the input. */
353 target_type
= cp_build_qualified_type
354 (target_type
, cp_type_quals (TREE_TYPE (TREE_TYPE (expr
))));
355 ptr_target_type
= build_pointer_type (target_type
);
357 /* Do we need to look in the vtable for the real offset? */
358 virtual_access
= (v_binfo
&& fixed_type_p
<= 0);
360 /* Don't bother with the calculations inside sizeof; they'll ICE if the
361 source type is incomplete and the pointer value doesn't matter. In a
362 template (even in instantiate_non_dependent_expr), we don't have vtables
363 set up properly yet, and the value doesn't matter there either; we're
364 just interested in the result of overload resolution. */
365 if (cp_unevaluated_operand
!= 0
366 || in_template_function ())
368 expr
= build_nop (ptr_target_type
, expr
);
372 /* If we're in an NSDMI, we don't have the full constructor context yet
373 that we need for converting to a virtual base, so just build a stub
374 CONVERT_EXPR and expand it later in bot_replace. */
375 if (virtual_access
&& fixed_type_p
< 0
376 && current_scope () != current_function_decl
)
378 expr
= build1 (CONVERT_EXPR
, ptr_target_type
, expr
);
379 CONVERT_EXPR_VBASE_PATH (expr
) = true;
383 /* Do we need to check for a null pointer? */
384 if (want_pointer
&& !nonnull
)
386 /* If we know the conversion will not actually change the value
387 of EXPR, then we can avoid testing the expression for NULL.
388 We have to avoid generating a COMPONENT_REF for a base class
389 field, because other parts of the compiler know that such
390 expressions are always non-NULL. */
391 if (!virtual_access
&& integer_zerop (offset
))
392 return build_nop (ptr_target_type
, expr
);
393 null_test
= error_mark_node
;
396 /* Protect against multiple evaluation if necessary. */
397 if (TREE_SIDE_EFFECTS (expr
) && (null_test
|| virtual_access
))
398 expr
= save_expr (expr
);
400 /* Now that we've saved expr, build the real null test. */
403 tree zero
= cp_convert (TREE_TYPE (expr
), nullptr_node
, complain
);
404 null_test
= fold_build2_loc (input_location
, NE_EXPR
, boolean_type_node
,
408 /* If this is a simple base reference, express it as a COMPONENT_REF. */
409 if (code
== PLUS_EXPR
&& !virtual_access
410 /* We don't build base fields for empty bases, and they aren't very
411 interesting to the optimizers anyway. */
414 expr
= cp_build_indirect_ref (expr
, RO_NULL
, complain
);
415 expr
= build_simple_base_path (expr
, binfo
);
419 expr
= build_address (expr
);
420 target_type
= TREE_TYPE (expr
);
426 /* Going via virtual base V_BINFO. We need the static offset
427 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
428 V_BINFO. That offset is an entry in D_BINFO's vtable. */
431 if (fixed_type_p
< 0 && in_base_initializer
)
433 /* In a base member initializer, we cannot rely on the
434 vtable being set up. We have to indirect via the
438 t
= TREE_TYPE (TYPE_VFIELD (current_class_type
));
439 t
= build_pointer_type (t
);
440 v_offset
= convert (t
, current_vtt_parm
);
441 v_offset
= cp_build_indirect_ref (v_offset
, RO_NULL
, complain
);
444 v_offset
= build_vfield_ref (cp_build_indirect_ref (expr
, RO_NULL
,
446 TREE_TYPE (TREE_TYPE (expr
)));
448 if (v_offset
== error_mark_node
)
449 return error_mark_node
;
451 v_offset
= fold_build_pointer_plus (v_offset
, BINFO_VPTR_FIELD (v_binfo
));
452 v_offset
= build1 (NOP_EXPR
,
453 build_pointer_type (ptrdiff_type_node
),
455 v_offset
= cp_build_indirect_ref (v_offset
, RO_NULL
, complain
);
456 TREE_CONSTANT (v_offset
) = 1;
458 offset
= convert_to_integer (ptrdiff_type_node
,
459 size_diffop_loc (input_location
, offset
,
460 BINFO_OFFSET (v_binfo
)));
462 if (!integer_zerop (offset
))
463 v_offset
= build2 (code
, ptrdiff_type_node
, v_offset
, offset
);
465 if (fixed_type_p
< 0)
466 /* Negative fixed_type_p means this is a constructor or destructor;
467 virtual base layout is fixed in in-charge [cd]tors, but not in
469 offset
= build3 (COND_EXPR
, ptrdiff_type_node
,
470 build2 (EQ_EXPR
, boolean_type_node
,
471 current_in_charge_parm
, integer_zero_node
),
473 convert_to_integer (ptrdiff_type_node
,
474 BINFO_OFFSET (binfo
)));
480 target_type
= ptr_target_type
;
482 expr
= build1 (NOP_EXPR
, ptr_target_type
, expr
);
484 if (!integer_zerop (offset
))
486 offset
= fold_convert (sizetype
, offset
);
487 if (code
== MINUS_EXPR
)
488 offset
= fold_build1_loc (input_location
, NEGATE_EXPR
, sizetype
, offset
);
489 expr
= fold_build_pointer_plus (expr
, offset
);
497 expr
= cp_build_indirect_ref (expr
, RO_NULL
, complain
);
504 expr
= fold_build3_loc (input_location
, COND_EXPR
, target_type
, null_test
, expr
,
505 build_zero_cst (target_type
));
510 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
511 Perform a derived-to-base conversion by recursively building up a
512 sequence of COMPONENT_REFs to the appropriate base fields. */
515 build_simple_base_path (tree expr
, tree binfo
)
517 tree type
= BINFO_TYPE (binfo
);
518 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
521 if (d_binfo
== NULL_TREE
)
525 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)) == type
);
527 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
528 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
529 an lvalue in the front end; only _DECLs and _REFs are lvalues
531 temp
= unary_complex_lvalue (ADDR_EXPR
, expr
);
533 expr
= cp_build_indirect_ref (temp
, RO_NULL
, tf_warning_or_error
);
539 expr
= build_simple_base_path (expr
, d_binfo
);
541 for (field
= TYPE_FIELDS (BINFO_TYPE (d_binfo
));
542 field
; field
= DECL_CHAIN (field
))
543 /* Is this the base field created by build_base_field? */
544 if (TREE_CODE (field
) == FIELD_DECL
545 && DECL_FIELD_IS_BASE (field
)
546 && TREE_TYPE (field
) == type
547 /* If we're looking for a field in the most-derived class,
548 also check the field offset; we can have two base fields
549 of the same type if one is an indirect virtual base and one
550 is a direct non-virtual base. */
551 && (BINFO_INHERITANCE_CHAIN (d_binfo
)
552 || tree_int_cst_equal (byte_position (field
),
553 BINFO_OFFSET (binfo
))))
555 /* We don't use build_class_member_access_expr here, as that
556 has unnecessary checks, and more importantly results in
557 recursive calls to dfs_walk_once. */
558 int type_quals
= cp_type_quals (TREE_TYPE (expr
));
560 expr
= build3 (COMPONENT_REF
,
561 cp_build_qualified_type (type
, type_quals
),
562 expr
, field
, NULL_TREE
);
563 expr
= fold_if_not_in_template (expr
);
565 /* Mark the expression const or volatile, as appropriate.
566 Even though we've dealt with the type above, we still have
567 to mark the expression itself. */
568 if (type_quals
& TYPE_QUAL_CONST
)
569 TREE_READONLY (expr
) = 1;
570 if (type_quals
& TYPE_QUAL_VOLATILE
)
571 TREE_THIS_VOLATILE (expr
) = 1;
576 /* Didn't find the base field?!? */
580 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
581 type is a class type or a pointer to a class type. In the former
582 case, TYPE is also a class type; in the latter it is another
583 pointer type. If CHECK_ACCESS is true, an error message is emitted
584 if TYPE is inaccessible. If OBJECT has pointer type, the value is
585 assumed to be non-NULL. */
588 convert_to_base (tree object
, tree type
, bool check_access
, bool nonnull
,
589 tsubst_flags_t complain
)
594 if (TYPE_PTR_P (TREE_TYPE (object
)))
596 object_type
= TREE_TYPE (TREE_TYPE (object
));
597 type
= TREE_TYPE (type
);
600 object_type
= TREE_TYPE (object
);
602 binfo
= lookup_base (object_type
, type
, check_access
? ba_check
: ba_unique
,
604 if (!binfo
|| binfo
== error_mark_node
)
605 return error_mark_node
;
607 return build_base_path (PLUS_EXPR
, object
, binfo
, nonnull
, complain
);
610 /* EXPR is an expression with unqualified class type. BASE is a base
611 binfo of that class type. Returns EXPR, converted to the BASE
612 type. This function assumes that EXPR is the most derived class;
613 therefore virtual bases can be found at their static offsets. */
616 convert_to_base_statically (tree expr
, tree base
)
620 expr_type
= TREE_TYPE (expr
);
621 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base
), expr_type
))
623 /* If this is a non-empty base, use a COMPONENT_REF. */
624 if (!is_empty_class (BINFO_TYPE (base
)))
625 return build_simple_base_path (expr
, base
);
627 /* We use fold_build2 and fold_convert below to simplify the trees
628 provided to the optimizers. It is not safe to call these functions
629 when processing a template because they do not handle C++-specific
631 gcc_assert (!processing_template_decl
);
632 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
633 if (!integer_zerop (BINFO_OFFSET (base
)))
634 expr
= fold_build_pointer_plus_loc (input_location
,
635 expr
, BINFO_OFFSET (base
));
636 expr
= fold_convert (build_pointer_type (BINFO_TYPE (base
)), expr
);
637 expr
= build_fold_indirect_ref_loc (input_location
, expr
);
645 build_vfield_ref (tree datum
, tree type
)
647 tree vfield
, vcontext
;
649 if (datum
== error_mark_node
650 /* Can happen in case of duplicate base types (c++/59082). */
651 || !TYPE_VFIELD (type
))
652 return error_mark_node
;
654 /* First, convert to the requested type. */
655 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum
), type
))
656 datum
= convert_to_base (datum
, type
, /*check_access=*/false,
657 /*nonnull=*/true, tf_warning_or_error
);
659 /* Second, the requested type may not be the owner of its own vptr.
660 If not, convert to the base class that owns it. We cannot use
661 convert_to_base here, because VCONTEXT may appear more than once
662 in the inheritance hierarchy of TYPE, and thus direct conversion
663 between the types may be ambiguous. Following the path back up
664 one step at a time via primary bases avoids the problem. */
665 vfield
= TYPE_VFIELD (type
);
666 vcontext
= DECL_CONTEXT (vfield
);
667 while (!same_type_ignoring_top_level_qualifiers_p (vcontext
, type
))
669 datum
= build_simple_base_path (datum
, CLASSTYPE_PRIMARY_BINFO (type
));
670 type
= TREE_TYPE (datum
);
673 return build3 (COMPONENT_REF
, TREE_TYPE (vfield
), datum
, vfield
, NULL_TREE
);
676 /* Given an object INSTANCE, return an expression which yields the
677 vtable element corresponding to INDEX. There are many special
678 cases for INSTANCE which we take care of here, mainly to avoid
679 creating extra tree nodes when we don't have to. */
682 build_vtbl_ref_1 (tree instance
, tree idx
)
685 tree vtbl
= NULL_TREE
;
687 /* Try to figure out what a reference refers to, and
688 access its virtual function table directly. */
691 tree fixed_type
= fixed_type_or_null (instance
, NULL
, &cdtorp
);
693 tree basetype
= non_reference (TREE_TYPE (instance
));
695 if (fixed_type
&& !cdtorp
)
697 tree binfo
= lookup_base (fixed_type
, basetype
,
698 ba_unique
, NULL
, tf_none
);
699 if (binfo
&& binfo
!= error_mark_node
)
700 vtbl
= unshare_expr (BINFO_VTABLE (binfo
));
704 vtbl
= build_vfield_ref (instance
, basetype
);
706 aref
= build_array_ref (input_location
, vtbl
, idx
);
707 TREE_CONSTANT (aref
) |= TREE_CONSTANT (vtbl
) && TREE_CONSTANT (idx
);
713 build_vtbl_ref (tree instance
, tree idx
)
715 tree aref
= build_vtbl_ref_1 (instance
, idx
);
720 /* Given a stable object pointer INSTANCE_PTR, return an expression which
721 yields a function pointer corresponding to vtable element INDEX. */
724 build_vfn_ref (tree instance_ptr
, tree idx
)
728 aref
= build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr
, RO_NULL
,
729 tf_warning_or_error
),
732 /* When using function descriptors, the address of the
733 vtable entry is treated as a function pointer. */
734 if (TARGET_VTABLE_USES_DESCRIPTORS
)
735 aref
= build1 (NOP_EXPR
, TREE_TYPE (aref
),
736 cp_build_addr_expr (aref
, tf_warning_or_error
));
738 /* Remember this as a method reference, for later devirtualization. */
739 aref
= build3 (OBJ_TYPE_REF
, TREE_TYPE (aref
), aref
, instance_ptr
, idx
);
744 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
745 for the given TYPE. */
748 get_vtable_name (tree type
)
750 return mangle_vtbl_for_type (type
);
753 /* DECL is an entity associated with TYPE, like a virtual table or an
754 implicitly generated constructor. Determine whether or not DECL
755 should have external or internal linkage at the object file
756 level. This routine does not deal with COMDAT linkage and other
757 similar complexities; it simply sets TREE_PUBLIC if it possible for
758 entities in other translation units to contain copies of DECL, in
762 set_linkage_according_to_type (tree
/*type*/, tree decl
)
764 TREE_PUBLIC (decl
) = 1;
765 determine_visibility (decl
);
768 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
769 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
770 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
773 build_vtable (tree class_type
, tree name
, tree vtable_type
)
777 decl
= build_lang_decl (VAR_DECL
, name
, vtable_type
);
778 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
779 now to avoid confusion in mangle_decl. */
780 SET_DECL_ASSEMBLER_NAME (decl
, name
);
781 DECL_CONTEXT (decl
) = class_type
;
782 DECL_ARTIFICIAL (decl
) = 1;
783 TREE_STATIC (decl
) = 1;
784 TREE_READONLY (decl
) = 1;
785 DECL_VIRTUAL_P (decl
) = 1;
786 DECL_ALIGN (decl
) = TARGET_VTABLE_ENTRY_ALIGN
;
787 DECL_USER_ALIGN (decl
) = true;
788 DECL_VTABLE_OR_VTT_P (decl
) = 1;
789 set_linkage_according_to_type (class_type
, decl
);
790 /* The vtable has not been defined -- yet. */
791 DECL_EXTERNAL (decl
) = 1;
792 DECL_NOT_REALLY_EXTERN (decl
) = 1;
794 /* Mark the VAR_DECL node representing the vtable itself as a
795 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
796 is rather important that such things be ignored because any
797 effort to actually generate DWARF for them will run into
798 trouble when/if we encounter code like:
801 struct S { virtual void member (); };
803 because the artificial declaration of the vtable itself (as
804 manufactured by the g++ front end) will say that the vtable is
805 a static member of `S' but only *after* the debug output for
806 the definition of `S' has already been output. This causes
807 grief because the DWARF entry for the definition of the vtable
808 will try to refer back to an earlier *declaration* of the
809 vtable as a static member of `S' and there won't be one. We
810 might be able to arrange to have the "vtable static member"
811 attached to the member list for `S' before the debug info for
812 `S' get written (which would solve the problem) but that would
813 require more intrusive changes to the g++ front end. */
814 DECL_IGNORED_P (decl
) = 1;
819 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
820 or even complete. If this does not exist, create it. If COMPLETE is
821 nonzero, then complete the definition of it -- that will render it
822 impossible to actually build the vtable, but is useful to get at those
823 which are known to exist in the runtime. */
826 get_vtable_decl (tree type
, int complete
)
830 if (CLASSTYPE_VTABLES (type
))
831 return CLASSTYPE_VTABLES (type
);
833 decl
= build_vtable (type
, get_vtable_name (type
), vtbl_type_node
);
834 CLASSTYPE_VTABLES (type
) = decl
;
838 DECL_EXTERNAL (decl
) = 1;
839 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
845 /* Build the primary virtual function table for TYPE. If BINFO is
846 non-NULL, build the vtable starting with the initial approximation
847 that it is the same as the one which is the head of the association
848 list. Returns a nonzero value if a new vtable is actually
852 build_primary_vtable (tree binfo
, tree type
)
857 decl
= get_vtable_decl (type
, /*complete=*/0);
861 if (BINFO_NEW_VTABLE_MARKED (binfo
))
862 /* We have already created a vtable for this base, so there's
863 no need to do it again. */
866 virtuals
= copy_list (BINFO_VIRTUALS (binfo
));
867 TREE_TYPE (decl
) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo
));
868 DECL_SIZE (decl
) = TYPE_SIZE (TREE_TYPE (decl
));
869 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
873 gcc_assert (TREE_TYPE (decl
) == vtbl_type_node
);
874 virtuals
= NULL_TREE
;
877 if (GATHER_STATISTICS
)
880 n_vtable_elems
+= list_length (virtuals
);
883 /* Initialize the association list for this type, based
884 on our first approximation. */
885 BINFO_VTABLE (TYPE_BINFO (type
)) = decl
;
886 BINFO_VIRTUALS (TYPE_BINFO (type
)) = virtuals
;
887 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type
));
891 /* Give BINFO a new virtual function table which is initialized
892 with a skeleton-copy of its original initialization. The only
893 entry that changes is the `delta' entry, so we can really
894 share a lot of structure.
896 FOR_TYPE is the most derived type which caused this table to
899 Returns nonzero if we haven't met BINFO before.
901 The order in which vtables are built (by calling this function) for
902 an object must remain the same, otherwise a binary incompatibility
906 build_secondary_vtable (tree binfo
)
908 if (BINFO_NEW_VTABLE_MARKED (binfo
))
909 /* We already created a vtable for this base. There's no need to
913 /* Remember that we've created a vtable for this BINFO, so that we
914 don't try to do so again. */
915 SET_BINFO_NEW_VTABLE_MARKED (binfo
);
917 /* Make fresh virtual list, so we can smash it later. */
918 BINFO_VIRTUALS (binfo
) = copy_list (BINFO_VIRTUALS (binfo
));
920 /* Secondary vtables are laid out as part of the same structure as
921 the primary vtable. */
922 BINFO_VTABLE (binfo
) = NULL_TREE
;
926 /* Create a new vtable for BINFO which is the hierarchy dominated by
927 T. Return nonzero if we actually created a new vtable. */
930 make_new_vtable (tree t
, tree binfo
)
932 if (binfo
== TYPE_BINFO (t
))
933 /* In this case, it is *type*'s vtable we are modifying. We start
934 with the approximation that its vtable is that of the
935 immediate base class. */
936 return build_primary_vtable (binfo
, t
);
938 /* This is our very own copy of `basetype' to play with. Later,
939 we will fill in all the virtual functions that override the
940 virtual functions in these base classes which are not defined
941 by the current type. */
942 return build_secondary_vtable (binfo
);
945 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
946 (which is in the hierarchy dominated by T) list FNDECL as its
947 BV_FN. DELTA is the required constant adjustment from the `this'
948 pointer where the vtable entry appears to the `this' required when
949 the function is actually called. */
952 modify_vtable_entry (tree t
,
962 if (fndecl
!= BV_FN (v
)
963 || !tree_int_cst_equal (delta
, BV_DELTA (v
)))
965 /* We need a new vtable for BINFO. */
966 if (make_new_vtable (t
, binfo
))
968 /* If we really did make a new vtable, we also made a copy
969 of the BINFO_VIRTUALS list. Now, we have to find the
970 corresponding entry in that list. */
971 *virtuals
= BINFO_VIRTUALS (binfo
);
972 while (BV_FN (*virtuals
) != BV_FN (v
))
973 *virtuals
= TREE_CHAIN (*virtuals
);
977 BV_DELTA (v
) = delta
;
978 BV_VCALL_INDEX (v
) = NULL_TREE
;
984 /* Add method METHOD to class TYPE. If USING_DECL is non-null, it is
985 the USING_DECL naming METHOD. Returns true if the method could be
986 added to the method vec. */
989 add_method (tree type
, tree method
, tree using_decl
)
993 bool template_conv_p
= false;
995 vec
<tree
, va_gc
> *method_vec
;
997 bool insert_p
= false;
1001 if (method
== error_mark_node
)
1004 complete_p
= COMPLETE_TYPE_P (type
);
1005 conv_p
= DECL_CONV_FN_P (method
);
1007 template_conv_p
= (TREE_CODE (method
) == TEMPLATE_DECL
1008 && DECL_TEMPLATE_CONV_FN_P (method
));
1010 method_vec
= CLASSTYPE_METHOD_VEC (type
);
1013 /* Make a new method vector. We start with 8 entries. We must
1014 allocate at least two (for constructors and destructors), and
1015 we're going to end up with an assignment operator at some
1017 vec_alloc (method_vec
, 8);
1018 /* Create slots for constructors and destructors. */
1019 method_vec
->quick_push (NULL_TREE
);
1020 method_vec
->quick_push (NULL_TREE
);
1021 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
1024 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
1025 grok_special_member_properties (method
);
1027 /* Constructors and destructors go in special slots. */
1028 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method
))
1029 slot
= CLASSTYPE_CONSTRUCTOR_SLOT
;
1030 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
1032 slot
= CLASSTYPE_DESTRUCTOR_SLOT
;
1034 if (TYPE_FOR_JAVA (type
))
1036 if (!DECL_ARTIFICIAL (method
))
1037 error ("Java class %qT cannot have a destructor", type
);
1038 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
1039 error ("Java class %qT cannot have an implicit non-trivial "
1049 /* See if we already have an entry with this name. */
1050 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1051 vec_safe_iterate (method_vec
, slot
, &m
);
1054 m
= OVL_CURRENT (m
);
1055 if (template_conv_p
)
1057 if (TREE_CODE (m
) == TEMPLATE_DECL
1058 && DECL_TEMPLATE_CONV_FN_P (m
))
1062 if (conv_p
&& !DECL_CONV_FN_P (m
))
1064 if (DECL_NAME (m
) == DECL_NAME (method
))
1070 && !DECL_CONV_FN_P (m
)
1071 && DECL_NAME (m
) > DECL_NAME (method
))
1075 current_fns
= insert_p
? NULL_TREE
: (*method_vec
)[slot
];
1077 /* Check to see if we've already got this method. */
1078 for (fns
= current_fns
; fns
; fns
= OVL_NEXT (fns
))
1080 tree fn
= OVL_CURRENT (fns
);
1086 if (TREE_CODE (fn
) != TREE_CODE (method
))
1089 /* [over.load] Member function declarations with the
1090 same name and the same parameter types cannot be
1091 overloaded if any of them is a static member
1092 function declaration.
1094 [over.load] Member function declarations with the same name and
1095 the same parameter-type-list as well as member function template
1096 declarations with the same name, the same parameter-type-list, and
1097 the same template parameter lists cannot be overloaded if any of
1098 them, but not all, have a ref-qualifier.
1100 [namespace.udecl] When a using-declaration brings names
1101 from a base class into a derived class scope, member
1102 functions in the derived class override and/or hide member
1103 functions with the same name and parameter types in a base
1104 class (rather than conflicting). */
1105 fn_type
= TREE_TYPE (fn
);
1106 method_type
= TREE_TYPE (method
);
1107 parms1
= TYPE_ARG_TYPES (fn_type
);
1108 parms2
= TYPE_ARG_TYPES (method_type
);
1110 /* Compare the quals on the 'this' parm. Don't compare
1111 the whole types, as used functions are treated as
1112 coming from the using class in overload resolution. */
1113 if (! DECL_STATIC_FUNCTION_P (fn
)
1114 && ! DECL_STATIC_FUNCTION_P (method
)
1115 /* Either both or neither need to be ref-qualified for
1116 differing quals to allow overloading. */
1117 && (FUNCTION_REF_QUALIFIED (fn_type
)
1118 == FUNCTION_REF_QUALIFIED (method_type
))
1119 && (type_memfn_quals (fn_type
) != type_memfn_quals (method_type
)
1120 || type_memfn_rqual (fn_type
) != type_memfn_rqual (method_type
)))
1123 /* For templates, the return type and template parameters
1124 must be identical. */
1125 if (TREE_CODE (fn
) == TEMPLATE_DECL
1126 && (!same_type_p (TREE_TYPE (fn_type
),
1127 TREE_TYPE (method_type
))
1128 || !comp_template_parms (DECL_TEMPLATE_PARMS (fn
),
1129 DECL_TEMPLATE_PARMS (method
))))
1132 if (! DECL_STATIC_FUNCTION_P (fn
))
1133 parms1
= TREE_CHAIN (parms1
);
1134 if (! DECL_STATIC_FUNCTION_P (method
))
1135 parms2
= TREE_CHAIN (parms2
);
1137 if (compparms (parms1
, parms2
)
1138 && (!DECL_CONV_FN_P (fn
)
1139 || same_type_p (TREE_TYPE (fn_type
),
1140 TREE_TYPE (method_type
))))
1142 /* For function versions, their parms and types match
1143 but they are not duplicates. Record function versions
1144 as and when they are found. extern "C" functions are
1145 not treated as versions. */
1146 if (TREE_CODE (fn
) == FUNCTION_DECL
1147 && TREE_CODE (method
) == FUNCTION_DECL
1148 && !DECL_EXTERN_C_P (fn
)
1149 && !DECL_EXTERN_C_P (method
)
1150 && targetm
.target_option
.function_versions (fn
, method
))
1152 /* Mark functions as versions if necessary. Modify the mangled
1153 decl name if necessary. */
1154 if (!DECL_FUNCTION_VERSIONED (fn
))
1156 DECL_FUNCTION_VERSIONED (fn
) = 1;
1157 if (DECL_ASSEMBLER_NAME_SET_P (fn
))
1160 if (!DECL_FUNCTION_VERSIONED (method
))
1162 DECL_FUNCTION_VERSIONED (method
) = 1;
1163 if (DECL_ASSEMBLER_NAME_SET_P (method
))
1164 mangle_decl (method
);
1166 cgraph_node::record_function_versions (fn
, method
);
1169 if (DECL_INHERITED_CTOR_BASE (method
))
1171 if (DECL_INHERITED_CTOR_BASE (fn
))
1173 error_at (DECL_SOURCE_LOCATION (method
),
1174 "%q#D inherited from %qT", method
,
1175 DECL_INHERITED_CTOR_BASE (method
));
1176 error_at (DECL_SOURCE_LOCATION (fn
),
1177 "conflicts with version inherited from %qT",
1178 DECL_INHERITED_CTOR_BASE (fn
));
1180 /* Otherwise defer to the other function. */
1185 if (DECL_CONTEXT (fn
) == type
)
1186 /* Defer to the local function. */
1191 error ("%q+#D cannot be overloaded", method
);
1192 error ("with %q+#D", fn
);
1195 /* We don't call duplicate_decls here to merge the
1196 declarations because that will confuse things if the
1197 methods have inline definitions. In particular, we
1198 will crash while processing the definitions. */
1203 /* A class should never have more than one destructor. */
1204 if (current_fns
&& DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
1207 /* Add the new binding. */
1210 overload
= ovl_cons (method
, current_fns
);
1211 OVL_USED (overload
) = true;
1214 overload
= build_overload (method
, current_fns
);
1217 TYPE_HAS_CONVERSION (type
) = 1;
1218 else if (slot
>= CLASSTYPE_FIRST_CONVERSION_SLOT
&& !complete_p
)
1219 push_class_level_binding (DECL_NAME (method
), overload
);
1225 /* We only expect to add few methods in the COMPLETE_P case, so
1226 just make room for one more method in that case. */
1228 reallocated
= vec_safe_reserve_exact (method_vec
, 1);
1230 reallocated
= vec_safe_reserve (method_vec
, 1);
1232 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
1233 if (slot
== method_vec
->length ())
1234 method_vec
->quick_push (overload
);
1236 method_vec
->quick_insert (slot
, overload
);
1239 /* Replace the current slot. */
1240 (*method_vec
)[slot
] = overload
;
1244 /* Subroutines of finish_struct. */
1246 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1247 legit, otherwise return 0. */
1250 alter_access (tree t
, tree fdecl
, tree access
)
1254 if (!DECL_LANG_SPECIFIC (fdecl
))
1255 retrofit_lang_decl (fdecl
);
1257 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl
));
1259 elem
= purpose_member (t
, DECL_ACCESS (fdecl
));
1262 if (TREE_VALUE (elem
) != access
)
1264 if (TREE_CODE (TREE_TYPE (fdecl
)) == FUNCTION_DECL
)
1265 error ("conflicting access specifications for method"
1266 " %q+D, ignored", TREE_TYPE (fdecl
));
1268 error ("conflicting access specifications for field %qE, ignored",
1273 /* They're changing the access to the same thing they changed
1274 it to before. That's OK. */
1280 perform_or_defer_access_check (TYPE_BINFO (t
), fdecl
, fdecl
,
1281 tf_warning_or_error
);
1282 DECL_ACCESS (fdecl
) = tree_cons (t
, access
, DECL_ACCESS (fdecl
));
1288 /* Process the USING_DECL, which is a member of T. */
1291 handle_using_decl (tree using_decl
, tree t
)
1293 tree decl
= USING_DECL_DECLS (using_decl
);
1294 tree name
= DECL_NAME (using_decl
);
1296 = TREE_PRIVATE (using_decl
) ? access_private_node
1297 : TREE_PROTECTED (using_decl
) ? access_protected_node
1298 : access_public_node
;
1299 tree flist
= NULL_TREE
;
1302 gcc_assert (!processing_template_decl
&& decl
);
1304 old_value
= lookup_member (t
, name
, /*protect=*/0, /*want_type=*/false,
1305 tf_warning_or_error
);
1308 if (is_overloaded_fn (old_value
))
1309 old_value
= OVL_CURRENT (old_value
);
1311 if (DECL_P (old_value
) && DECL_CONTEXT (old_value
) == t
)
1314 old_value
= NULL_TREE
;
1317 cp_emit_debug_info_for_using (decl
, t
);
1319 if (is_overloaded_fn (decl
))
1324 else if (is_overloaded_fn (old_value
))
1327 /* It's OK to use functions from a base when there are functions with
1328 the same name already present in the current class. */;
1331 error ("%q+D invalid in %q#T", using_decl
, t
);
1332 error (" because of local method %q+#D with same name",
1333 OVL_CURRENT (old_value
));
1337 else if (!DECL_ARTIFICIAL (old_value
))
1339 error ("%q+D invalid in %q#T", using_decl
, t
);
1340 error (" because of local member %q+#D with same name", old_value
);
1344 /* Make type T see field decl FDECL with access ACCESS. */
1346 for (; flist
; flist
= OVL_NEXT (flist
))
1348 add_method (t
, OVL_CURRENT (flist
), using_decl
);
1349 alter_access (t
, OVL_CURRENT (flist
), access
);
1352 alter_access (t
, decl
, access
);
1355 /* Data structure for find_abi_tags_r, below. */
1359 tree t
; // The type that we're checking for missing tags.
1360 tree subob
; // The subobject of T that we're getting tags from.
1361 tree tags
; // error_mark_node for diagnostics, or a list of missing tags.
1364 /* Subroutine of find_abi_tags_r. Handle a single TAG found on the class TP
1365 in the context of P. TAG can be either an identifier (the DECL_NAME of
1366 a tag NAMESPACE_DECL) or a STRING_CST (a tag attribute). */
1369 check_tag (tree tag
, tree
*tp
, abi_tag_data
*p
)
1373 if (TREE_CODE (tag
) == STRING_CST
)
1374 id
= get_identifier (TREE_STRING_POINTER (tag
));
1381 if (!IDENTIFIER_MARKED (id
))
1384 tag
= build_string (IDENTIFIER_LENGTH (id
) + 1,
1385 IDENTIFIER_POINTER (id
));
1386 if (p
->tags
!= error_mark_node
)
1388 /* We're collecting tags from template arguments. */
1389 p
->tags
= tree_cons (NULL_TREE
, tag
, p
->tags
);
1390 ABI_TAG_IMPLICIT (p
->tags
) = true;
1392 /* Don't inherit this tag multiple times. */
1393 IDENTIFIER_MARKED (id
) = true;
1396 /* Otherwise we're diagnosing missing tags. */
1397 else if (TYPE_P (p
->subob
))
1399 if (warning (OPT_Wabi_tag
, "%qT does not have the %E abi tag "
1400 "that base %qT has", p
->t
, tag
, p
->subob
))
1401 inform (location_of (p
->subob
), "%qT declared here",
1406 if (warning (OPT_Wabi_tag
, "%qT does not have the %E abi tag "
1407 "that %qT (used in the type of %qD) has",
1408 p
->t
, tag
, *tp
, p
->subob
))
1410 inform (location_of (p
->subob
), "%qD declared here",
1412 inform (location_of (*tp
), "%qT declared here", *tp
);
1418 /* walk_tree callback for check_abi_tags: if the type at *TP involves any
1419 types with abi tags, add the corresponding identifiers to the VEC in
1420 *DATA and set IDENTIFIER_MARKED. */
1423 find_abi_tags_r (tree
*tp
, int *walk_subtrees
, void *data
)
1425 if (!OVERLOAD_TYPE_P (*tp
))
1428 /* walk_tree shouldn't be walking into any subtrees of a RECORD_TYPE
1429 anyway, but let's make sure of it. */
1430 *walk_subtrees
= false;
1432 abi_tag_data
*p
= static_cast<struct abi_tag_data
*>(data
);
1434 for (tree ns
= decl_namespace_context (*tp
);
1435 ns
!= global_namespace
;
1436 ns
= CP_DECL_CONTEXT (ns
))
1437 if (NAMESPACE_ABI_TAG (ns
))
1438 check_tag (DECL_NAME (ns
), tp
, p
);
1440 if (tree attributes
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (*tp
)))
1442 for (tree list
= TREE_VALUE (attributes
); list
;
1443 list
= TREE_CHAIN (list
))
1445 tree tag
= TREE_VALUE (list
);
1446 check_tag (tag
, tp
, p
);
1452 /* Set IDENTIFIER_MARKED on all the ABI tags on T and its (transitively
1453 complete) template arguments. */
1456 mark_type_abi_tags (tree t
, bool val
)
1458 for (tree ns
= decl_namespace_context (t
);
1459 ns
!= global_namespace
;
1460 ns
= CP_DECL_CONTEXT (ns
))
1461 if (NAMESPACE_ABI_TAG (ns
))
1462 IDENTIFIER_MARKED (DECL_NAME (ns
)) = val
;
1464 tree attributes
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (t
));
1467 for (tree list
= TREE_VALUE (attributes
); list
;
1468 list
= TREE_CHAIN (list
))
1470 tree tag
= TREE_VALUE (list
);
1471 tree id
= get_identifier (TREE_STRING_POINTER (tag
));
1472 IDENTIFIER_MARKED (id
) = val
;
1477 /* Check that class T has all the abi tags that subobject SUBOB has, or
1481 check_abi_tags (tree t
, tree subob
)
1483 mark_type_abi_tags (t
, true);
1485 tree subtype
= TYPE_P (subob
) ? subob
: TREE_TYPE (subob
);
1486 struct abi_tag_data data
= { t
, subob
, error_mark_node
};
1488 cp_walk_tree_without_duplicates (&subtype
, find_abi_tags_r
, &data
);
1490 mark_type_abi_tags (t
, false);
1494 inherit_targ_abi_tags (tree t
)
1496 if (!CLASS_TYPE_P (t
)
1497 || CLASSTYPE_TEMPLATE_INFO (t
) == NULL_TREE
)
1500 mark_type_abi_tags (t
, true);
1502 tree args
= CLASSTYPE_TI_ARGS (t
);
1503 struct abi_tag_data data
= { t
, NULL_TREE
, NULL_TREE
};
1504 for (int i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
1506 tree level
= TMPL_ARGS_LEVEL (args
, i
+1);
1507 for (int j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
1509 tree arg
= TREE_VEC_ELT (level
, j
);
1511 cp_walk_tree_without_duplicates (&arg
, find_abi_tags_r
, &data
);
1515 // If we found some tags on our template arguments, add them to our
1516 // abi_tag attribute.
1519 tree attr
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (t
));
1521 TREE_VALUE (attr
) = chainon (data
.tags
, TREE_VALUE (attr
));
1524 = tree_cons (get_identifier ("abi_tag"), data
.tags
,
1525 TYPE_ATTRIBUTES (t
));
1528 mark_type_abi_tags (t
, false);
1531 /* Return true, iff class T has a non-virtual destructor that is
1532 accessible from outside the class heirarchy (i.e. is public, or
1533 there's a suitable friend. */
1536 accessible_nvdtor_p (tree t
)
1538 tree dtor
= CLASSTYPE_DESTRUCTORS (t
);
1540 /* An implicitly declared destructor is always public. And,
1541 if it were virtual, we would have created it by now. */
1545 if (DECL_VINDEX (dtor
))
1546 return false; /* Virtual */
1548 if (!TREE_PRIVATE (dtor
) && !TREE_PROTECTED (dtor
))
1549 return true; /* Public */
1551 if (CLASSTYPE_FRIEND_CLASSES (t
)
1552 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
1553 return true; /* Has friends */
1558 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1559 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1560 properties of the bases. */
1563 check_bases (tree t
,
1564 int* cant_have_const_ctor_p
,
1565 int* no_const_asn_ref_p
)
1568 bool seen_non_virtual_nearly_empty_base_p
= 0;
1569 int seen_tm_mask
= 0;
1572 tree field
= NULL_TREE
;
1574 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1575 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
1576 if (TREE_CODE (field
) == FIELD_DECL
)
1579 for (binfo
= TYPE_BINFO (t
), i
= 0;
1580 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1582 tree basetype
= TREE_TYPE (base_binfo
);
1584 gcc_assert (COMPLETE_TYPE_P (basetype
));
1586 if (CLASSTYPE_FINAL (basetype
))
1587 error ("cannot derive from %<final%> base %qT in derived type %qT",
1590 /* If any base class is non-literal, so is the derived class. */
1591 if (!CLASSTYPE_LITERAL_P (basetype
))
1592 CLASSTYPE_LITERAL_P (t
) = false;
1594 /* If the base class doesn't have copy constructors or
1595 assignment operators that take const references, then the
1596 derived class cannot have such a member automatically
1598 if (TYPE_HAS_COPY_CTOR (basetype
)
1599 && ! TYPE_HAS_CONST_COPY_CTOR (basetype
))
1600 *cant_have_const_ctor_p
= 1;
1601 if (TYPE_HAS_COPY_ASSIGN (basetype
)
1602 && !TYPE_HAS_CONST_COPY_ASSIGN (basetype
))
1603 *no_const_asn_ref_p
= 1;
1605 if (BINFO_VIRTUAL_P (base_binfo
))
1606 /* A virtual base does not effect nearly emptiness. */
1608 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype
))
1610 if (seen_non_virtual_nearly_empty_base_p
)
1611 /* And if there is more than one nearly empty base, then the
1612 derived class is not nearly empty either. */
1613 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1615 /* Remember we've seen one. */
1616 seen_non_virtual_nearly_empty_base_p
= 1;
1618 else if (!is_empty_class (basetype
))
1619 /* If the base class is not empty or nearly empty, then this
1620 class cannot be nearly empty. */
1621 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1623 /* A lot of properties from the bases also apply to the derived
1625 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (basetype
);
1626 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1627 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
);
1628 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
)
1629 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (basetype
)
1630 || !TYPE_HAS_COPY_ASSIGN (basetype
));
1631 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= (TYPE_HAS_COMPLEX_COPY_CTOR (basetype
)
1632 || !TYPE_HAS_COPY_CTOR (basetype
));
1633 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
1634 |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (basetype
);
1635 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_HAS_COMPLEX_MOVE_CTOR (basetype
);
1636 TYPE_POLYMORPHIC_P (t
) |= TYPE_POLYMORPHIC_P (basetype
);
1637 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
)
1638 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype
);
1639 TYPE_HAS_COMPLEX_DFLT (t
) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
1640 || TYPE_HAS_COMPLEX_DFLT (basetype
));
1641 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT
1642 (t
, CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
1643 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (basetype
));
1644 SET_CLASSTYPE_REF_FIELDS_NEED_INIT
1645 (t
, CLASSTYPE_REF_FIELDS_NEED_INIT (t
)
1646 | CLASSTYPE_REF_FIELDS_NEED_INIT (basetype
));
1648 /* A standard-layout class is a class that:
1650 * has no non-standard-layout base classes, */
1651 CLASSTYPE_NON_STD_LAYOUT (t
) |= CLASSTYPE_NON_STD_LAYOUT (basetype
);
1652 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1655 /* ...has no base classes of the same type as the first non-static
1657 if (field
&& DECL_CONTEXT (field
) == t
1658 && (same_type_ignoring_top_level_qualifiers_p
1659 (TREE_TYPE (field
), basetype
)))
1660 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1662 /* ...either has no non-static data members in the most-derived
1663 class and at most one base class with non-static data
1664 members, or has no base classes with non-static data
1666 for (basefield
= TYPE_FIELDS (basetype
); basefield
;
1667 basefield
= DECL_CHAIN (basefield
))
1668 if (TREE_CODE (basefield
) == FIELD_DECL
)
1671 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1678 /* Don't bother collecting tm attributes if transactional memory
1679 support is not enabled. */
1682 tree tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (basetype
));
1684 seen_tm_mask
|= tm_attr_to_mask (tm_attr
);
1687 check_abi_tags (t
, basetype
);
1690 /* If one of the base classes had TM attributes, and the current class
1691 doesn't define its own, then the current class inherits one. */
1692 if (seen_tm_mask
&& !find_tm_attribute (TYPE_ATTRIBUTES (t
)))
1694 tree tm_attr
= tm_mask_to_attr (seen_tm_mask
& -seen_tm_mask
);
1695 TYPE_ATTRIBUTES (t
) = tree_cons (tm_attr
, NULL
, TYPE_ATTRIBUTES (t
));
1699 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1700 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1701 that have had a nearly-empty virtual primary base stolen by some
1702 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1706 determine_primary_bases (tree t
)
1709 tree primary
= NULL_TREE
;
1710 tree type_binfo
= TYPE_BINFO (t
);
1713 /* Determine the primary bases of our bases. */
1714 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1715 base_binfo
= TREE_CHAIN (base_binfo
))
1717 tree primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo
));
1719 /* See if we're the non-virtual primary of our inheritance
1721 if (!BINFO_VIRTUAL_P (base_binfo
))
1723 tree parent
= BINFO_INHERITANCE_CHAIN (base_binfo
);
1724 tree parent_primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent
));
1727 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
1728 BINFO_TYPE (parent_primary
)))
1729 /* We are the primary binfo. */
1730 BINFO_PRIMARY_P (base_binfo
) = 1;
1732 /* Determine if we have a virtual primary base, and mark it so.
1734 if (primary
&& BINFO_VIRTUAL_P (primary
))
1736 tree this_primary
= copied_binfo (primary
, base_binfo
);
1738 if (BINFO_PRIMARY_P (this_primary
))
1739 /* Someone already claimed this base. */
1740 BINFO_LOST_PRIMARY_P (base_binfo
) = 1;
1745 BINFO_PRIMARY_P (this_primary
) = 1;
1746 BINFO_INHERITANCE_CHAIN (this_primary
) = base_binfo
;
1748 /* A virtual binfo might have been copied from within
1749 another hierarchy. As we're about to use it as a
1750 primary base, make sure the offsets match. */
1751 delta
= size_diffop_loc (input_location
,
1753 BINFO_OFFSET (base_binfo
)),
1755 BINFO_OFFSET (this_primary
)));
1757 propagate_binfo_offsets (this_primary
, delta
);
1762 /* First look for a dynamic direct non-virtual base. */
1763 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, base_binfo
); i
++)
1765 tree basetype
= BINFO_TYPE (base_binfo
);
1767 if (TYPE_CONTAINS_VPTR_P (basetype
) && !BINFO_VIRTUAL_P (base_binfo
))
1769 primary
= base_binfo
;
1774 /* A "nearly-empty" virtual base class can be the primary base
1775 class, if no non-virtual polymorphic base can be found. Look for
1776 a nearly-empty virtual dynamic base that is not already a primary
1777 base of something in the hierarchy. If there is no such base,
1778 just pick the first nearly-empty virtual base. */
1780 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1781 base_binfo
= TREE_CHAIN (base_binfo
))
1782 if (BINFO_VIRTUAL_P (base_binfo
)
1783 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo
)))
1785 if (!BINFO_PRIMARY_P (base_binfo
))
1787 /* Found one that is not primary. */
1788 primary
= base_binfo
;
1792 /* Remember the first candidate. */
1793 primary
= base_binfo
;
1797 /* If we've got a primary base, use it. */
1800 tree basetype
= BINFO_TYPE (primary
);
1802 CLASSTYPE_PRIMARY_BINFO (t
) = primary
;
1803 if (BINFO_PRIMARY_P (primary
))
1804 /* We are stealing a primary base. */
1805 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary
)) = 1;
1806 BINFO_PRIMARY_P (primary
) = 1;
1807 if (BINFO_VIRTUAL_P (primary
))
1811 BINFO_INHERITANCE_CHAIN (primary
) = type_binfo
;
1812 /* A virtual binfo might have been copied from within
1813 another hierarchy. As we're about to use it as a primary
1814 base, make sure the offsets match. */
1815 delta
= size_diffop_loc (input_location
, ssize_int (0),
1816 convert (ssizetype
, BINFO_OFFSET (primary
)));
1818 propagate_binfo_offsets (primary
, delta
);
1821 primary
= TYPE_BINFO (basetype
);
1823 TYPE_VFIELD (t
) = TYPE_VFIELD (basetype
);
1824 BINFO_VTABLE (type_binfo
) = BINFO_VTABLE (primary
);
1825 BINFO_VIRTUALS (type_binfo
) = BINFO_VIRTUALS (primary
);
1829 /* Update the variant types of T. */
1832 fixup_type_variants (tree t
)
1839 for (variants
= TYPE_NEXT_VARIANT (t
);
1841 variants
= TYPE_NEXT_VARIANT (variants
))
1843 /* These fields are in the _TYPE part of the node, not in
1844 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1845 TYPE_HAS_USER_CONSTRUCTOR (variants
) = TYPE_HAS_USER_CONSTRUCTOR (t
);
1846 TYPE_NEEDS_CONSTRUCTING (variants
) = TYPE_NEEDS_CONSTRUCTING (t
);
1847 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants
)
1848 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
1850 TYPE_POLYMORPHIC_P (variants
) = TYPE_POLYMORPHIC_P (t
);
1852 TYPE_BINFO (variants
) = TYPE_BINFO (t
);
1854 /* Copy whatever these are holding today. */
1855 TYPE_VFIELD (variants
) = TYPE_VFIELD (t
);
1856 TYPE_METHODS (variants
) = TYPE_METHODS (t
);
1857 TYPE_FIELDS (variants
) = TYPE_FIELDS (t
);
1861 /* Early variant fixups: we apply attributes at the beginning of the class
1862 definition, and we need to fix up any variants that have already been
1863 made via elaborated-type-specifier so that check_qualified_type works. */
1866 fixup_attribute_variants (tree t
)
1873 for (variants
= TYPE_NEXT_VARIANT (t
);
1875 variants
= TYPE_NEXT_VARIANT (variants
))
1877 /* These are the two fields that check_qualified_type looks at and
1878 are affected by attributes. */
1879 TYPE_ATTRIBUTES (variants
) = TYPE_ATTRIBUTES (t
);
1880 TYPE_ALIGN (variants
) = TYPE_ALIGN (t
);
1884 /* Set memoizing fields and bits of T (and its variants) for later
1888 finish_struct_bits (tree t
)
1890 /* Fix up variants (if any). */
1891 fixup_type_variants (t
);
1893 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) && TYPE_POLYMORPHIC_P (t
))
1894 /* For a class w/o baseclasses, 'finish_struct' has set
1895 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1896 Similarly for a class whose base classes do not have vtables.
1897 When neither of these is true, we might have removed abstract
1898 virtuals (by providing a definition), added some (by declaring
1899 new ones), or redeclared ones from a base class. We need to
1900 recalculate what's really an abstract virtual at this point (by
1901 looking in the vtables). */
1902 get_pure_virtuals (t
);
1904 /* If this type has a copy constructor or a destructor, force its
1905 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1906 nonzero. This will cause it to be passed by invisible reference
1907 and prevent it from being returned in a register. */
1908 if (type_has_nontrivial_copy_init (t
)
1909 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
1912 DECL_MODE (TYPE_MAIN_DECL (t
)) = BLKmode
;
1913 for (variants
= t
; variants
; variants
= TYPE_NEXT_VARIANT (variants
))
1915 SET_TYPE_MODE (variants
, BLKmode
);
1916 TREE_ADDRESSABLE (variants
) = 1;
1921 /* Issue warnings about T having private constructors, but no friends,
1924 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1925 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1926 non-private static member functions. */
1929 maybe_warn_about_overly_private_class (tree t
)
1931 int has_member_fn
= 0;
1932 int has_nonprivate_method
= 0;
1935 if (!warn_ctor_dtor_privacy
1936 /* If the class has friends, those entities might create and
1937 access instances, so we should not warn. */
1938 || (CLASSTYPE_FRIEND_CLASSES (t
)
1939 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
1940 /* We will have warned when the template was declared; there's
1941 no need to warn on every instantiation. */
1942 || CLASSTYPE_TEMPLATE_INSTANTIATION (t
))
1943 /* There's no reason to even consider warning about this
1947 /* We only issue one warning, if more than one applies, because
1948 otherwise, on code like:
1951 // Oops - forgot `public:'
1957 we warn several times about essentially the same problem. */
1959 /* Check to see if all (non-constructor, non-destructor) member
1960 functions are private. (Since there are no friends or
1961 non-private statics, we can't ever call any of the private member
1963 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
1964 /* We're not interested in compiler-generated methods; they don't
1965 provide any way to call private members. */
1966 if (!DECL_ARTIFICIAL (fn
))
1968 if (!TREE_PRIVATE (fn
))
1970 if (DECL_STATIC_FUNCTION_P (fn
))
1971 /* A non-private static member function is just like a
1972 friend; it can create and invoke private member
1973 functions, and be accessed without a class
1977 has_nonprivate_method
= 1;
1978 /* Keep searching for a static member function. */
1980 else if (!DECL_CONSTRUCTOR_P (fn
) && !DECL_DESTRUCTOR_P (fn
))
1984 if (!has_nonprivate_method
&& has_member_fn
)
1986 /* There are no non-private methods, and there's at least one
1987 private member function that isn't a constructor or
1988 destructor. (If all the private members are
1989 constructors/destructors we want to use the code below that
1990 issues error messages specifically referring to
1991 constructors/destructors.) */
1993 tree binfo
= TYPE_BINFO (t
);
1995 for (i
= 0; i
!= BINFO_N_BASE_BINFOS (binfo
); i
++)
1996 if (BINFO_BASE_ACCESS (binfo
, i
) != access_private_node
)
1998 has_nonprivate_method
= 1;
2001 if (!has_nonprivate_method
)
2003 warning (OPT_Wctor_dtor_privacy
,
2004 "all member functions in class %qT are private", t
);
2009 /* Even if some of the member functions are non-private, the class
2010 won't be useful for much if all the constructors or destructors
2011 are private: such an object can never be created or destroyed. */
2012 fn
= CLASSTYPE_DESTRUCTORS (t
);
2013 if (fn
&& TREE_PRIVATE (fn
))
2015 warning (OPT_Wctor_dtor_privacy
,
2016 "%q#T only defines a private destructor and has no friends",
2021 /* Warn about classes that have private constructors and no friends. */
2022 if (TYPE_HAS_USER_CONSTRUCTOR (t
)
2023 /* Implicitly generated constructors are always public. */
2024 && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t
)
2025 || !CLASSTYPE_LAZY_COPY_CTOR (t
)))
2027 int nonprivate_ctor
= 0;
2029 /* If a non-template class does not define a copy
2030 constructor, one is defined for it, enabling it to avoid
2031 this warning. For a template class, this does not
2032 happen, and so we would normally get a warning on:
2034 template <class T> class C { private: C(); };
2036 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All
2037 complete non-template or fully instantiated classes have this
2039 if (!TYPE_HAS_COPY_CTOR (t
))
2040 nonprivate_ctor
= 1;
2042 for (fn
= CLASSTYPE_CONSTRUCTORS (t
); fn
; fn
= OVL_NEXT (fn
))
2044 tree ctor
= OVL_CURRENT (fn
);
2045 /* Ideally, we wouldn't count copy constructors (or, in
2046 fact, any constructor that takes an argument of the
2047 class type as a parameter) because such things cannot
2048 be used to construct an instance of the class unless
2049 you already have one. But, for now at least, we're
2051 if (! TREE_PRIVATE (ctor
))
2053 nonprivate_ctor
= 1;
2058 if (nonprivate_ctor
== 0)
2060 warning (OPT_Wctor_dtor_privacy
,
2061 "%q#T only defines private constructors and has no friends",
2069 gt_pointer_operator new_value
;
2073 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
2076 method_name_cmp (const void* m1_p
, const void* m2_p
)
2078 const tree
*const m1
= (const tree
*) m1_p
;
2079 const tree
*const m2
= (const tree
*) m2_p
;
2081 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
2083 if (*m1
== NULL_TREE
)
2085 if (*m2
== NULL_TREE
)
2087 if (DECL_NAME (OVL_CURRENT (*m1
)) < DECL_NAME (OVL_CURRENT (*m2
)))
2092 /* This routine compares two fields like method_name_cmp but using the
2093 pointer operator in resort_field_decl_data. */
2096 resort_method_name_cmp (const void* m1_p
, const void* m2_p
)
2098 const tree
*const m1
= (const tree
*) m1_p
;
2099 const tree
*const m2
= (const tree
*) m2_p
;
2100 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
2102 if (*m1
== NULL_TREE
)
2104 if (*m2
== NULL_TREE
)
2107 tree d1
= DECL_NAME (OVL_CURRENT (*m1
));
2108 tree d2
= DECL_NAME (OVL_CURRENT (*m2
));
2109 resort_data
.new_value (&d1
, resort_data
.cookie
);
2110 resort_data
.new_value (&d2
, resort_data
.cookie
);
2117 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
2120 resort_type_method_vec (void* obj
,
2122 gt_pointer_operator new_value
,
2125 vec
<tree
, va_gc
> *method_vec
= (vec
<tree
, va_gc
> *) obj
;
2126 int len
= vec_safe_length (method_vec
);
2130 /* The type conversion ops have to live at the front of the vec, so we
2132 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2133 vec_safe_iterate (method_vec
, slot
, &fn
);
2135 if (!DECL_CONV_FN_P (OVL_CURRENT (fn
)))
2140 resort_data
.new_value
= new_value
;
2141 resort_data
.cookie
= cookie
;
2142 qsort (method_vec
->address () + slot
, len
- slot
, sizeof (tree
),
2143 resort_method_name_cmp
);
2147 /* Warn about duplicate methods in fn_fields.
2149 Sort methods that are not special (i.e., constructors, destructors,
2150 and type conversion operators) so that we can find them faster in
2154 finish_struct_methods (tree t
)
2157 vec
<tree
, va_gc
> *method_vec
;
2160 method_vec
= CLASSTYPE_METHOD_VEC (t
);
2164 len
= method_vec
->length ();
2166 /* Clear DECL_IN_AGGR_P for all functions. */
2167 for (fn_fields
= TYPE_METHODS (t
); fn_fields
;
2168 fn_fields
= DECL_CHAIN (fn_fields
))
2169 DECL_IN_AGGR_P (fn_fields
) = 0;
2171 /* Issue warnings about private constructors and such. If there are
2172 no methods, then some public defaults are generated. */
2173 maybe_warn_about_overly_private_class (t
);
2175 /* The type conversion ops have to live at the front of the vec, so we
2177 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2178 method_vec
->iterate (slot
, &fn_fields
);
2180 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields
)))
2183 qsort (method_vec
->address () + slot
,
2184 len
-slot
, sizeof (tree
), method_name_cmp
);
2187 /* Make BINFO's vtable have N entries, including RTTI entries,
2188 vbase and vcall offsets, etc. Set its type and call the back end
2192 layout_vtable_decl (tree binfo
, int n
)
2197 atype
= build_array_of_n_type (vtable_entry_type
, n
);
2198 layout_type (atype
);
2200 /* We may have to grow the vtable. */
2201 vtable
= get_vtbl_decl_for_binfo (binfo
);
2202 if (!same_type_p (TREE_TYPE (vtable
), atype
))
2204 TREE_TYPE (vtable
) = atype
;
2205 DECL_SIZE (vtable
) = DECL_SIZE_UNIT (vtable
) = NULL_TREE
;
2206 layout_decl (vtable
, 0);
2210 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
2211 have the same signature. */
2214 same_signature_p (const_tree fndecl
, const_tree base_fndecl
)
2216 /* One destructor overrides another if they are the same kind of
2218 if (DECL_DESTRUCTOR_P (base_fndecl
) && DECL_DESTRUCTOR_P (fndecl
)
2219 && special_function_p (base_fndecl
) == special_function_p (fndecl
))
2221 /* But a non-destructor never overrides a destructor, nor vice
2222 versa, nor do different kinds of destructors override
2223 one-another. For example, a complete object destructor does not
2224 override a deleting destructor. */
2225 if (DECL_DESTRUCTOR_P (base_fndecl
) || DECL_DESTRUCTOR_P (fndecl
))
2228 if (DECL_NAME (fndecl
) == DECL_NAME (base_fndecl
)
2229 || (DECL_CONV_FN_P (fndecl
)
2230 && DECL_CONV_FN_P (base_fndecl
)
2231 && same_type_p (DECL_CONV_FN_TYPE (fndecl
),
2232 DECL_CONV_FN_TYPE (base_fndecl
))))
2234 tree fntype
= TREE_TYPE (fndecl
);
2235 tree base_fntype
= TREE_TYPE (base_fndecl
);
2236 if (type_memfn_quals (fntype
) == type_memfn_quals (base_fntype
)
2237 && type_memfn_rqual (fntype
) == type_memfn_rqual (base_fntype
)
2238 && compparms (FUNCTION_FIRST_USER_PARMTYPE (fndecl
),
2239 FUNCTION_FIRST_USER_PARMTYPE (base_fndecl
)))
2245 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
2249 base_derived_from (tree derived
, tree base
)
2253 for (probe
= base
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
2255 if (probe
== derived
)
2257 else if (BINFO_VIRTUAL_P (probe
))
2258 /* If we meet a virtual base, we can't follow the inheritance
2259 any more. See if the complete type of DERIVED contains
2260 such a virtual base. */
2261 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (derived
))
2267 typedef struct find_final_overrider_data_s
{
2268 /* The function for which we are trying to find a final overrider. */
2270 /* The base class in which the function was declared. */
2271 tree declaring_base
;
2272 /* The candidate overriders. */
2274 /* Path to most derived. */
2276 } find_final_overrider_data
;
2278 /* Add the overrider along the current path to FFOD->CANDIDATES.
2279 Returns true if an overrider was found; false otherwise. */
2282 dfs_find_final_overrider_1 (tree binfo
,
2283 find_final_overrider_data
*ffod
,
2288 /* If BINFO is not the most derived type, try a more derived class.
2289 A definition there will overrider a definition here. */
2293 if (dfs_find_final_overrider_1
2294 (ffod
->path
[depth
], ffod
, depth
))
2298 method
= look_for_overrides_here (BINFO_TYPE (binfo
), ffod
->fn
);
2301 tree
*candidate
= &ffod
->candidates
;
2303 /* Remove any candidates overridden by this new function. */
2306 /* If *CANDIDATE overrides METHOD, then METHOD
2307 cannot override anything else on the list. */
2308 if (base_derived_from (TREE_VALUE (*candidate
), binfo
))
2310 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
2311 if (base_derived_from (binfo
, TREE_VALUE (*candidate
)))
2312 *candidate
= TREE_CHAIN (*candidate
);
2314 candidate
= &TREE_CHAIN (*candidate
);
2317 /* Add the new function. */
2318 ffod
->candidates
= tree_cons (method
, binfo
, ffod
->candidates
);
2325 /* Called from find_final_overrider via dfs_walk. */
2328 dfs_find_final_overrider_pre (tree binfo
, void *data
)
2330 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
2332 if (binfo
== ffod
->declaring_base
)
2333 dfs_find_final_overrider_1 (binfo
, ffod
, ffod
->path
.length ());
2334 ffod
->path
.safe_push (binfo
);
2340 dfs_find_final_overrider_post (tree
/*binfo*/, void *data
)
2342 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
2348 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2349 FN and whose TREE_VALUE is the binfo for the base where the
2350 overriding occurs. BINFO (in the hierarchy dominated by the binfo
2351 DERIVED) is the base object in which FN is declared. */
2354 find_final_overrider (tree derived
, tree binfo
, tree fn
)
2356 find_final_overrider_data ffod
;
2358 /* Getting this right is a little tricky. This is valid:
2360 struct S { virtual void f (); };
2361 struct T { virtual void f (); };
2362 struct U : public S, public T { };
2364 even though calling `f' in `U' is ambiguous. But,
2366 struct R { virtual void f(); };
2367 struct S : virtual public R { virtual void f (); };
2368 struct T : virtual public R { virtual void f (); };
2369 struct U : public S, public T { };
2371 is not -- there's no way to decide whether to put `S::f' or
2372 `T::f' in the vtable for `R'.
2374 The solution is to look at all paths to BINFO. If we find
2375 different overriders along any two, then there is a problem. */
2376 if (DECL_THUNK_P (fn
))
2377 fn
= THUNK_TARGET (fn
);
2379 /* Determine the depth of the hierarchy. */
2381 ffod
.declaring_base
= binfo
;
2382 ffod
.candidates
= NULL_TREE
;
2383 ffod
.path
.create (30);
2385 dfs_walk_all (derived
, dfs_find_final_overrider_pre
,
2386 dfs_find_final_overrider_post
, &ffod
);
2388 ffod
.path
.release ();
2390 /* If there was no winner, issue an error message. */
2391 if (!ffod
.candidates
|| TREE_CHAIN (ffod
.candidates
))
2392 return error_mark_node
;
2394 return ffod
.candidates
;
2397 /* Return the index of the vcall offset for FN when TYPE is used as a
2401 get_vcall_index (tree fn
, tree type
)
2403 vec
<tree_pair_s
, va_gc
> *indices
= CLASSTYPE_VCALL_INDICES (type
);
2407 FOR_EACH_VEC_SAFE_ELT (indices
, ix
, p
)
2408 if ((DECL_DESTRUCTOR_P (fn
) && DECL_DESTRUCTOR_P (p
->purpose
))
2409 || same_signature_p (fn
, p
->purpose
))
2412 /* There should always be an appropriate index. */
2416 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2417 dominated by T. FN is the old function; VIRTUALS points to the
2418 corresponding position in the new BINFO_VIRTUALS list. IX is the index
2419 of that entry in the list. */
2422 update_vtable_entry_for_fn (tree t
, tree binfo
, tree fn
, tree
* virtuals
,
2430 tree overrider_fn
, overrider_target
;
2431 tree target_fn
= DECL_THUNK_P (fn
) ? THUNK_TARGET (fn
) : fn
;
2432 tree over_return
, base_return
;
2435 /* Find the nearest primary base (possibly binfo itself) which defines
2436 this function; this is the class the caller will convert to when
2437 calling FN through BINFO. */
2438 for (b
= binfo
; ; b
= get_primary_binfo (b
))
2441 if (look_for_overrides_here (BINFO_TYPE (b
), target_fn
))
2444 /* The nearest definition is from a lost primary. */
2445 if (BINFO_LOST_PRIMARY_P (b
))
2450 /* Find the final overrider. */
2451 overrider
= find_final_overrider (TYPE_BINFO (t
), b
, target_fn
);
2452 if (overrider
== error_mark_node
)
2454 error ("no unique final overrider for %qD in %qT", target_fn
, t
);
2457 overrider_target
= overrider_fn
= TREE_PURPOSE (overrider
);
2459 /* Check for adjusting covariant return types. */
2460 over_return
= TREE_TYPE (TREE_TYPE (overrider_target
));
2461 base_return
= TREE_TYPE (TREE_TYPE (target_fn
));
2463 if (POINTER_TYPE_P (over_return
)
2464 && TREE_CODE (over_return
) == TREE_CODE (base_return
)
2465 && CLASS_TYPE_P (TREE_TYPE (over_return
))
2466 && CLASS_TYPE_P (TREE_TYPE (base_return
))
2467 /* If the overrider is invalid, don't even try. */
2468 && !DECL_INVALID_OVERRIDER_P (overrider_target
))
2470 /* If FN is a covariant thunk, we must figure out the adjustment
2471 to the final base FN was converting to. As OVERRIDER_TARGET might
2472 also be converting to the return type of FN, we have to
2473 combine the two conversions here. */
2474 tree fixed_offset
, virtual_offset
;
2476 over_return
= TREE_TYPE (over_return
);
2477 base_return
= TREE_TYPE (base_return
);
2479 if (DECL_THUNK_P (fn
))
2481 gcc_assert (DECL_RESULT_THUNK_P (fn
));
2482 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn
));
2483 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn
);
2486 fixed_offset
= virtual_offset
= NULL_TREE
;
2489 /* Find the equivalent binfo within the return type of the
2490 overriding function. We will want the vbase offset from
2492 virtual_offset
= binfo_for_vbase (BINFO_TYPE (virtual_offset
),
2494 else if (!same_type_ignoring_top_level_qualifiers_p
2495 (over_return
, base_return
))
2497 /* There was no existing virtual thunk (which takes
2498 precedence). So find the binfo of the base function's
2499 return type within the overriding function's return type.
2500 We cannot call lookup base here, because we're inside a
2501 dfs_walk, and will therefore clobber the BINFO_MARKED
2502 flags. Fortunately we know the covariancy is valid (it
2503 has already been checked), so we can just iterate along
2504 the binfos, which have been chained in inheritance graph
2505 order. Of course it is lame that we have to repeat the
2506 search here anyway -- we should really be caching pieces
2507 of the vtable and avoiding this repeated work. */
2508 tree thunk_binfo
, base_binfo
;
2510 /* Find the base binfo within the overriding function's
2511 return type. We will always find a thunk_binfo, except
2512 when the covariancy is invalid (which we will have
2513 already diagnosed). */
2514 for (base_binfo
= TYPE_BINFO (base_return
),
2515 thunk_binfo
= TYPE_BINFO (over_return
);
2517 thunk_binfo
= TREE_CHAIN (thunk_binfo
))
2518 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo
),
2519 BINFO_TYPE (base_binfo
)))
2522 /* See if virtual inheritance is involved. */
2523 for (virtual_offset
= thunk_binfo
;
2525 virtual_offset
= BINFO_INHERITANCE_CHAIN (virtual_offset
))
2526 if (BINFO_VIRTUAL_P (virtual_offset
))
2530 || (thunk_binfo
&& !BINFO_OFFSET_ZEROP (thunk_binfo
)))
2532 tree offset
= convert (ssizetype
, BINFO_OFFSET (thunk_binfo
));
2536 /* We convert via virtual base. Adjust the fixed
2537 offset to be from there. */
2539 size_diffop (offset
,
2541 BINFO_OFFSET (virtual_offset
)));
2544 /* There was an existing fixed offset, this must be
2545 from the base just converted to, and the base the
2546 FN was thunking to. */
2547 fixed_offset
= size_binop (PLUS_EXPR
, fixed_offset
, offset
);
2549 fixed_offset
= offset
;
2553 if (fixed_offset
|| virtual_offset
)
2554 /* Replace the overriding function with a covariant thunk. We
2555 will emit the overriding function in its own slot as
2557 overrider_fn
= make_thunk (overrider_target
, /*this_adjusting=*/0,
2558 fixed_offset
, virtual_offset
);
2561 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target
) ||
2562 !DECL_THUNK_P (fn
));
2564 /* If we need a covariant thunk, then we may need to adjust first_defn.
2565 The ABI specifies that the thunks emitted with a function are
2566 determined by which bases the function overrides, so we need to be
2567 sure that we're using a thunk for some overridden base; even if we
2568 know that the necessary this adjustment is zero, there may not be an
2569 appropriate zero-this-adjusment thunk for us to use since thunks for
2570 overriding virtual bases always use the vcall offset.
2572 Furthermore, just choosing any base that overrides this function isn't
2573 quite right, as this slot won't be used for calls through a type that
2574 puts a covariant thunk here. Calling the function through such a type
2575 will use a different slot, and that slot is the one that determines
2576 the thunk emitted for that base.
2578 So, keep looking until we find the base that we're really overriding
2579 in this slot: the nearest primary base that doesn't use a covariant
2580 thunk in this slot. */
2581 if (overrider_target
!= overrider_fn
)
2583 if (BINFO_TYPE (b
) == DECL_CONTEXT (overrider_target
))
2584 /* We already know that the overrider needs a covariant thunk. */
2585 b
= get_primary_binfo (b
);
2586 for (; ; b
= get_primary_binfo (b
))
2588 tree main_binfo
= TYPE_BINFO (BINFO_TYPE (b
));
2589 tree bv
= chain_index (ix
, BINFO_VIRTUALS (main_binfo
));
2590 if (!DECL_THUNK_P (TREE_VALUE (bv
)))
2592 if (BINFO_LOST_PRIMARY_P (b
))
2598 /* Assume that we will produce a thunk that convert all the way to
2599 the final overrider, and not to an intermediate virtual base. */
2600 virtual_base
= NULL_TREE
;
2602 /* See if we can convert to an intermediate virtual base first, and then
2603 use the vcall offset located there to finish the conversion. */
2604 for (; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
2606 /* If we find the final overrider, then we can stop
2608 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b
),
2609 BINFO_TYPE (TREE_VALUE (overrider
))))
2612 /* If we find a virtual base, and we haven't yet found the
2613 overrider, then there is a virtual base between the
2614 declaring base (first_defn) and the final overrider. */
2615 if (BINFO_VIRTUAL_P (b
))
2622 /* Compute the constant adjustment to the `this' pointer. The
2623 `this' pointer, when this function is called, will point at BINFO
2624 (or one of its primary bases, which are at the same offset). */
2626 /* The `this' pointer needs to be adjusted from the declaration to
2627 the nearest virtual base. */
2628 delta
= size_diffop_loc (input_location
,
2629 convert (ssizetype
, BINFO_OFFSET (virtual_base
)),
2630 convert (ssizetype
, BINFO_OFFSET (first_defn
)));
2632 /* If the nearest definition is in a lost primary, we don't need an
2633 entry in our vtable. Except possibly in a constructor vtable,
2634 if we happen to get our primary back. In that case, the offset
2635 will be zero, as it will be a primary base. */
2636 delta
= size_zero_node
;
2638 /* The `this' pointer needs to be adjusted from pointing to
2639 BINFO to pointing at the base where the final overrider
2641 delta
= size_diffop_loc (input_location
,
2643 BINFO_OFFSET (TREE_VALUE (overrider
))),
2644 convert (ssizetype
, BINFO_OFFSET (binfo
)));
2646 modify_vtable_entry (t
, binfo
, overrider_fn
, delta
, virtuals
);
2649 BV_VCALL_INDEX (*virtuals
)
2650 = get_vcall_index (overrider_target
, BINFO_TYPE (virtual_base
));
2652 BV_VCALL_INDEX (*virtuals
) = NULL_TREE
;
2654 BV_LOST_PRIMARY (*virtuals
) = lost
;
2657 /* Called from modify_all_vtables via dfs_walk. */
2660 dfs_modify_vtables (tree binfo
, void* data
)
2662 tree t
= (tree
) data
;
2667 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
2668 /* A base without a vtable needs no modification, and its bases
2669 are uninteresting. */
2670 return dfs_skip_bases
;
2672 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
)
2673 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
2674 /* Don't do the primary vtable, if it's new. */
2677 if (BINFO_PRIMARY_P (binfo
) && !BINFO_VIRTUAL_P (binfo
))
2678 /* There's no need to modify the vtable for a non-virtual primary
2679 base; we're not going to use that vtable anyhow. We do still
2680 need to do this for virtual primary bases, as they could become
2681 non-primary in a construction vtable. */
2684 make_new_vtable (t
, binfo
);
2686 /* Now, go through each of the virtual functions in the virtual
2687 function table for BINFO. Find the final overrider, and update
2688 the BINFO_VIRTUALS list appropriately. */
2689 for (ix
= 0, virtuals
= BINFO_VIRTUALS (binfo
),
2690 old_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
2692 ix
++, virtuals
= TREE_CHAIN (virtuals
),
2693 old_virtuals
= TREE_CHAIN (old_virtuals
))
2694 update_vtable_entry_for_fn (t
,
2696 BV_FN (old_virtuals
),
2702 /* Update all of the primary and secondary vtables for T. Create new
2703 vtables as required, and initialize their RTTI information. Each
2704 of the functions in VIRTUALS is declared in T and may override a
2705 virtual function from a base class; find and modify the appropriate
2706 entries to point to the overriding functions. Returns a list, in
2707 declaration order, of the virtual functions that are declared in T,
2708 but do not appear in the primary base class vtable, and which
2709 should therefore be appended to the end of the vtable for T. */
2712 modify_all_vtables (tree t
, tree virtuals
)
2714 tree binfo
= TYPE_BINFO (t
);
2717 /* Mangle the vtable name before entering dfs_walk (c++/51884). */
2718 if (TYPE_CONTAINS_VPTR_P (t
))
2719 get_vtable_decl (t
, false);
2721 /* Update all of the vtables. */
2722 dfs_walk_once (binfo
, dfs_modify_vtables
, NULL
, t
);
2724 /* Add virtual functions not already in our primary vtable. These
2725 will be both those introduced by this class, and those overridden
2726 from secondary bases. It does not include virtuals merely
2727 inherited from secondary bases. */
2728 for (fnsp
= &virtuals
; *fnsp
; )
2730 tree fn
= TREE_VALUE (*fnsp
);
2732 if (!value_member (fn
, BINFO_VIRTUALS (binfo
))
2733 || DECL_VINDEX (fn
) == error_mark_node
)
2735 /* We don't need to adjust the `this' pointer when
2736 calling this function. */
2737 BV_DELTA (*fnsp
) = integer_zero_node
;
2738 BV_VCALL_INDEX (*fnsp
) = NULL_TREE
;
2740 /* This is a function not already in our vtable. Keep it. */
2741 fnsp
= &TREE_CHAIN (*fnsp
);
2744 /* We've already got an entry for this function. Skip it. */
2745 *fnsp
= TREE_CHAIN (*fnsp
);
2751 /* Get the base virtual function declarations in T that have the
2755 get_basefndecls (tree name
, tree t
, vec
<tree
> *base_fndecls
)
2758 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
2761 /* Find virtual functions in T with the indicated NAME. */
2762 i
= lookup_fnfields_1 (t
, name
);
2763 bool found_decls
= false;
2765 for (methods
= (*CLASSTYPE_METHOD_VEC (t
))[i
];
2767 methods
= OVL_NEXT (methods
))
2769 tree method
= OVL_CURRENT (methods
);
2771 if (TREE_CODE (method
) == FUNCTION_DECL
2772 && DECL_VINDEX (method
))
2774 base_fndecls
->safe_push (method
);
2782 for (i
= 0; i
< n_baseclasses
; i
++)
2784 tree basetype
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t
), i
));
2785 get_basefndecls (name
, basetype
, base_fndecls
);
2789 /* If this declaration supersedes the declaration of
2790 a method declared virtual in the base class, then
2791 mark this field as being virtual as well. */
2794 check_for_override (tree decl
, tree ctype
)
2796 bool overrides_found
= false;
2797 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2798 /* In [temp.mem] we have:
2800 A specialization of a member function template does not
2801 override a virtual function from a base class. */
2803 if ((DECL_DESTRUCTOR_P (decl
)
2804 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
))
2805 || DECL_CONV_FN_P (decl
))
2806 && look_for_overrides (ctype
, decl
)
2807 && !DECL_STATIC_FUNCTION_P (decl
))
2808 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2809 the error_mark_node so that we know it is an overriding
2812 DECL_VINDEX (decl
) = decl
;
2813 overrides_found
= true;
2816 if (DECL_VIRTUAL_P (decl
))
2818 if (!DECL_VINDEX (decl
))
2819 DECL_VINDEX (decl
) = error_mark_node
;
2820 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
2821 if (DECL_DESTRUCTOR_P (decl
))
2822 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype
) = true;
2824 else if (DECL_FINAL_P (decl
))
2825 error ("%q+#D marked %<final%>, but is not virtual", decl
);
2826 if (DECL_OVERRIDE_P (decl
) && !overrides_found
)
2827 error ("%q+#D marked %<override%>, but does not override", decl
);
2830 /* Warn about hidden virtual functions that are not overridden in t.
2831 We know that constructors and destructors don't apply. */
2834 warn_hidden (tree t
)
2836 vec
<tree
, va_gc
> *method_vec
= CLASSTYPE_METHOD_VEC (t
);
2840 /* We go through each separately named virtual function. */
2841 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2842 vec_safe_iterate (method_vec
, i
, &fns
);
2852 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2853 have the same name. Figure out what name that is. */
2854 name
= DECL_NAME (OVL_CURRENT (fns
));
2855 /* There are no possibly hidden functions yet. */
2856 auto_vec
<tree
, 20> base_fndecls
;
2857 /* Iterate through all of the base classes looking for possibly
2858 hidden functions. */
2859 for (binfo
= TYPE_BINFO (t
), j
= 0;
2860 BINFO_BASE_ITERATE (binfo
, j
, base_binfo
); j
++)
2862 tree basetype
= BINFO_TYPE (base_binfo
);
2863 get_basefndecls (name
, basetype
, &base_fndecls
);
2866 /* If there are no functions to hide, continue. */
2867 if (base_fndecls
.is_empty ())
2870 /* Remove any overridden functions. */
2871 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
2873 fndecl
= OVL_CURRENT (fn
);
2874 if (TREE_CODE (fndecl
) == FUNCTION_DECL
2875 && DECL_VINDEX (fndecl
))
2877 /* If the method from the base class has the same
2878 signature as the method from the derived class, it
2879 has been overridden. */
2880 for (size_t k
= 0; k
< base_fndecls
.length (); k
++)
2882 && same_signature_p (fndecl
, base_fndecls
[k
]))
2883 base_fndecls
[k
] = NULL_TREE
;
2887 /* Now give a warning for all base functions without overriders,
2888 as they are hidden. */
2891 FOR_EACH_VEC_ELT (base_fndecls
, k
, base_fndecl
)
2894 /* Here we know it is a hider, and no overrider exists. */
2895 warning (OPT_Woverloaded_virtual
, "%q+D was hidden", base_fndecl
);
2896 warning (OPT_Woverloaded_virtual
, " by %q+D", fns
);
2901 /* Recursive helper for finish_struct_anon. */
2904 finish_struct_anon_r (tree field
, bool complain
)
2906 bool is_union
= TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
;
2907 tree elt
= TYPE_FIELDS (TREE_TYPE (field
));
2908 for (; elt
; elt
= DECL_CHAIN (elt
))
2910 /* We're generally only interested in entities the user
2911 declared, but we also find nested classes by noticing
2912 the TYPE_DECL that we create implicitly. You're
2913 allowed to put one anonymous union inside another,
2914 though, so we explicitly tolerate that. We use
2915 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2916 we also allow unnamed types used for defining fields. */
2917 if (DECL_ARTIFICIAL (elt
)
2918 && (!DECL_IMPLICIT_TYPEDEF_P (elt
)
2919 || TYPE_ANONYMOUS_P (TREE_TYPE (elt
))))
2922 if (TREE_CODE (elt
) != FIELD_DECL
)
2924 /* We already complained about static data members in
2925 finish_static_data_member_decl. */
2926 if (complain
&& TREE_CODE (elt
) != VAR_DECL
)
2929 permerror (input_location
,
2930 "%q+#D invalid; an anonymous union can "
2931 "only have non-static data members", elt
);
2933 permerror (input_location
,
2934 "%q+#D invalid; an anonymous struct can "
2935 "only have non-static data members", elt
);
2942 if (TREE_PRIVATE (elt
))
2945 permerror (input_location
,
2946 "private member %q+#D in anonymous union", elt
);
2948 permerror (input_location
,
2949 "private member %q+#D in anonymous struct", elt
);
2951 else if (TREE_PROTECTED (elt
))
2954 permerror (input_location
,
2955 "protected member %q+#D in anonymous union", elt
);
2957 permerror (input_location
,
2958 "protected member %q+#D in anonymous struct", elt
);
2962 TREE_PRIVATE (elt
) = TREE_PRIVATE (field
);
2963 TREE_PROTECTED (elt
) = TREE_PROTECTED (field
);
2965 /* Recurse into the anonymous aggregates to handle correctly
2966 access control (c++/24926):
2977 if (DECL_NAME (elt
) == NULL_TREE
2978 && ANON_AGGR_TYPE_P (TREE_TYPE (elt
)))
2979 finish_struct_anon_r (elt
, /*complain=*/false);
2983 /* Check for things that are invalid. There are probably plenty of other
2984 things we should check for also. */
2987 finish_struct_anon (tree t
)
2989 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
2991 if (TREE_STATIC (field
))
2993 if (TREE_CODE (field
) != FIELD_DECL
)
2996 if (DECL_NAME (field
) == NULL_TREE
2997 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
2998 finish_struct_anon_r (field
, /*complain=*/true);
3002 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
3003 will be used later during class template instantiation.
3004 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
3005 a non-static member data (FIELD_DECL), a member function
3006 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
3007 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
3008 When FRIEND_P is nonzero, T is either a friend class
3009 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
3010 (FUNCTION_DECL, TEMPLATE_DECL). */
3013 maybe_add_class_template_decl_list (tree type
, tree t
, int friend_p
)
3015 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
3016 if (CLASSTYPE_TEMPLATE_INFO (type
))
3017 CLASSTYPE_DECL_LIST (type
)
3018 = tree_cons (friend_p
? NULL_TREE
: type
,
3019 t
, CLASSTYPE_DECL_LIST (type
));
3022 /* This function is called from declare_virt_assop_and_dtor via
3025 DATA is a type that direcly or indirectly inherits the base
3026 represented by BINFO. If BINFO contains a virtual assignment [copy
3027 assignment or move assigment] operator or a virtual constructor,
3028 declare that function in DATA if it hasn't been already declared. */
3031 dfs_declare_virt_assop_and_dtor (tree binfo
, void *data
)
3033 tree bv
, fn
, t
= (tree
)data
;
3034 tree opname
= ansi_assopname (NOP_EXPR
);
3036 gcc_assert (t
&& CLASS_TYPE_P (t
));
3037 gcc_assert (binfo
&& TREE_CODE (binfo
) == TREE_BINFO
);
3039 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
3040 /* A base without a vtable needs no modification, and its bases
3041 are uninteresting. */
3042 return dfs_skip_bases
;
3044 if (BINFO_PRIMARY_P (binfo
))
3045 /* If this is a primary base, then we have already looked at the
3046 virtual functions of its vtable. */
3049 for (bv
= BINFO_VIRTUALS (binfo
); bv
; bv
= TREE_CHAIN (bv
))
3053 if (DECL_NAME (fn
) == opname
)
3055 if (CLASSTYPE_LAZY_COPY_ASSIGN (t
))
3056 lazily_declare_fn (sfk_copy_assignment
, t
);
3057 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
3058 lazily_declare_fn (sfk_move_assignment
, t
);
3060 else if (DECL_DESTRUCTOR_P (fn
)
3061 && CLASSTYPE_LAZY_DESTRUCTOR (t
))
3062 lazily_declare_fn (sfk_destructor
, t
);
3068 /* If the class type T has a direct or indirect base that contains a
3069 virtual assignment operator or a virtual destructor, declare that
3070 function in T if it hasn't been already declared. */
3073 declare_virt_assop_and_dtor (tree t
)
3075 if (!(TYPE_POLYMORPHIC_P (t
)
3076 && (CLASSTYPE_LAZY_COPY_ASSIGN (t
)
3077 || CLASSTYPE_LAZY_MOVE_ASSIGN (t
)
3078 || CLASSTYPE_LAZY_DESTRUCTOR (t
))))
3081 dfs_walk_all (TYPE_BINFO (t
),
3082 dfs_declare_virt_assop_and_dtor
,
3086 /* Declare the inheriting constructor for class T inherited from base
3087 constructor CTOR with the parameter array PARMS of size NPARMS. */
3090 one_inheriting_sig (tree t
, tree ctor
, tree
*parms
, int nparms
)
3092 /* We don't declare an inheriting ctor that would be a default,
3093 copy or move ctor for derived or base. */
3097 && TREE_CODE (parms
[0]) == REFERENCE_TYPE
)
3099 tree parm
= TYPE_MAIN_VARIANT (TREE_TYPE (parms
[0]));
3100 if (parm
== t
|| parm
== DECL_CONTEXT (ctor
))
3104 tree parmlist
= void_list_node
;
3105 for (int i
= nparms
- 1; i
>= 0; i
--)
3106 parmlist
= tree_cons (NULL_TREE
, parms
[i
], parmlist
);
3107 tree fn
= implicitly_declare_fn (sfk_inheriting_constructor
,
3108 t
, false, ctor
, parmlist
);
3109 if (add_method (t
, fn
, NULL_TREE
))
3111 DECL_CHAIN (fn
) = TYPE_METHODS (t
);
3112 TYPE_METHODS (t
) = fn
;
3116 /* Declare all the inheriting constructors for class T inherited from base
3117 constructor CTOR. */
3120 one_inherited_ctor (tree ctor
, tree t
)
3122 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (ctor
);
3124 tree
*new_parms
= XALLOCAVEC (tree
, list_length (parms
));
3126 for (; parms
&& parms
!= void_list_node
; parms
= TREE_CHAIN (parms
))
3128 if (TREE_PURPOSE (parms
))
3129 one_inheriting_sig (t
, ctor
, new_parms
, i
);
3130 new_parms
[i
++] = TREE_VALUE (parms
);
3132 one_inheriting_sig (t
, ctor
, new_parms
, i
);
3133 if (parms
== NULL_TREE
)
3135 if (warning (OPT_Winherited_variadic_ctor
,
3136 "the ellipsis in %qD is not inherited", ctor
))
3137 inform (DECL_SOURCE_LOCATION (ctor
), "%qD declared here", ctor
);
3141 /* Create default constructors, assignment operators, and so forth for
3142 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
3143 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
3144 the class cannot have a default constructor, copy constructor
3145 taking a const reference argument, or an assignment operator taking
3146 a const reference, respectively. */
3149 add_implicitly_declared_members (tree t
, tree
* access_decls
,
3150 int cant_have_const_cctor
,
3151 int cant_have_const_assignment
)
3153 bool move_ok
= false;
3155 if (cxx_dialect
>= cxx11
&& !CLASSTYPE_DESTRUCTORS (t
)
3156 && !TYPE_HAS_COPY_CTOR (t
) && !TYPE_HAS_COPY_ASSIGN (t
)
3157 && !type_has_move_constructor (t
) && !type_has_move_assign (t
))
3161 if (!CLASSTYPE_DESTRUCTORS (t
))
3163 /* In general, we create destructors lazily. */
3164 CLASSTYPE_LAZY_DESTRUCTOR (t
) = 1;
3166 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3167 && TYPE_FOR_JAVA (t
))
3168 /* But if this is a Java class, any non-trivial destructor is
3169 invalid, even if compiler-generated. Therefore, if the
3170 destructor is non-trivial we create it now. */
3171 lazily_declare_fn (sfk_destructor
, t
);
3176 If there is no user-declared constructor for a class, a default
3177 constructor is implicitly declared. */
3178 if (! TYPE_HAS_USER_CONSTRUCTOR (t
))
3180 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 1;
3181 CLASSTYPE_LAZY_DEFAULT_CTOR (t
) = 1;
3182 if (cxx_dialect
>= cxx11
)
3183 TYPE_HAS_CONSTEXPR_CTOR (t
)
3184 /* This might force the declaration. */
3185 = type_has_constexpr_default_constructor (t
);
3190 If a class definition does not explicitly declare a copy
3191 constructor, one is declared implicitly. */
3192 if (! TYPE_HAS_COPY_CTOR (t
) && ! TYPE_FOR_JAVA (t
))
3194 TYPE_HAS_COPY_CTOR (t
) = 1;
3195 TYPE_HAS_CONST_COPY_CTOR (t
) = !cant_have_const_cctor
;
3196 CLASSTYPE_LAZY_COPY_CTOR (t
) = 1;
3198 CLASSTYPE_LAZY_MOVE_CTOR (t
) = 1;
3201 /* If there is no assignment operator, one will be created if and
3202 when it is needed. For now, just record whether or not the type
3203 of the parameter to the assignment operator will be a const or
3204 non-const reference. */
3205 if (!TYPE_HAS_COPY_ASSIGN (t
) && !TYPE_FOR_JAVA (t
))
3207 TYPE_HAS_COPY_ASSIGN (t
) = 1;
3208 TYPE_HAS_CONST_COPY_ASSIGN (t
) = !cant_have_const_assignment
;
3209 CLASSTYPE_LAZY_COPY_ASSIGN (t
) = 1;
3210 if (move_ok
&& !LAMBDA_TYPE_P (t
))
3211 CLASSTYPE_LAZY_MOVE_ASSIGN (t
) = 1;
3214 /* We can't be lazy about declaring functions that might override
3215 a virtual function from a base class. */
3216 declare_virt_assop_and_dtor (t
);
3218 while (*access_decls
)
3220 tree using_decl
= TREE_VALUE (*access_decls
);
3221 tree decl
= USING_DECL_DECLS (using_decl
);
3222 if (DECL_NAME (using_decl
) == ctor_identifier
)
3224 /* declare, then remove the decl */
3225 tree ctor_list
= decl
;
3226 location_t loc
= input_location
;
3227 input_location
= DECL_SOURCE_LOCATION (using_decl
);
3229 for (; ctor_list
; ctor_list
= OVL_NEXT (ctor_list
))
3230 one_inherited_ctor (OVL_CURRENT (ctor_list
), t
);
3231 *access_decls
= TREE_CHAIN (*access_decls
);
3232 input_location
= loc
;
3235 access_decls
= &TREE_CHAIN (*access_decls
);
3239 /* Subroutine of insert_into_classtype_sorted_fields. Recursively
3240 count the number of fields in TYPE, including anonymous union
3244 count_fields (tree fields
)
3248 for (x
= fields
; x
; x
= DECL_CHAIN (x
))
3250 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3251 n_fields
+= count_fields (TYPE_FIELDS (TREE_TYPE (x
)));
3258 /* Subroutine of insert_into_classtype_sorted_fields. Recursively add
3259 all the fields in the TREE_LIST FIELDS to the SORTED_FIELDS_TYPE
3260 elts, starting at offset IDX. */
3263 add_fields_to_record_type (tree fields
, struct sorted_fields_type
*field_vec
, int idx
)
3266 for (x
= fields
; x
; x
= DECL_CHAIN (x
))
3268 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3269 idx
= add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x
)), field_vec
, idx
);
3271 field_vec
->elts
[idx
++] = x
;
3276 /* Add all of the enum values of ENUMTYPE, to the FIELD_VEC elts,
3277 starting at offset IDX. */
3280 add_enum_fields_to_record_type (tree enumtype
,
3281 struct sorted_fields_type
*field_vec
,
3285 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
3286 field_vec
->elts
[idx
++] = TREE_VALUE (values
);
3290 /* FIELD is a bit-field. We are finishing the processing for its
3291 enclosing type. Issue any appropriate messages and set appropriate
3292 flags. Returns false if an error has been diagnosed. */
3295 check_bitfield_decl (tree field
)
3297 tree type
= TREE_TYPE (field
);
3300 /* Extract the declared width of the bitfield, which has been
3301 temporarily stashed in DECL_INITIAL. */
3302 w
= DECL_INITIAL (field
);
3303 gcc_assert (w
!= NULL_TREE
);
3304 /* Remove the bit-field width indicator so that the rest of the
3305 compiler does not treat that value as an initializer. */
3306 DECL_INITIAL (field
) = NULL_TREE
;
3308 /* Detect invalid bit-field type. */
3309 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3311 error ("bit-field %q+#D with non-integral type", field
);
3312 w
= error_mark_node
;
3316 location_t loc
= input_location
;
3317 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
3320 /* detect invalid field size. */
3321 input_location
= DECL_SOURCE_LOCATION (field
);
3322 w
= cxx_constant_value (w
);
3323 input_location
= loc
;
3325 if (TREE_CODE (w
) != INTEGER_CST
)
3327 error ("bit-field %q+D width not an integer constant", field
);
3328 w
= error_mark_node
;
3330 else if (tree_int_cst_sgn (w
) < 0)
3332 error ("negative width in bit-field %q+D", field
);
3333 w
= error_mark_node
;
3335 else if (integer_zerop (w
) && DECL_NAME (field
) != 0)
3337 error ("zero width for bit-field %q+D", field
);
3338 w
= error_mark_node
;
3340 else if ((TREE_CODE (type
) != ENUMERAL_TYPE
3341 && TREE_CODE (type
) != BOOLEAN_TYPE
3342 && compare_tree_int (w
, TYPE_PRECISION (type
)) > 0)
3343 || ((TREE_CODE (type
) == ENUMERAL_TYPE
3344 || TREE_CODE (type
) == BOOLEAN_TYPE
)
3345 && tree_int_cst_lt (TYPE_SIZE (type
), w
)))
3346 warning (0, "width of %q+D exceeds its type", field
);
3347 else if (TREE_CODE (type
) == ENUMERAL_TYPE
3348 && (0 > (compare_tree_int
3349 (w
, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type
))))))
3350 warning (0, "%q+D is too small to hold all values of %q#T", field
, type
);
3353 if (w
!= error_mark_node
)
3355 DECL_SIZE (field
) = convert (bitsizetype
, w
);
3356 DECL_BIT_FIELD (field
) = 1;
3361 /* Non-bit-fields are aligned for their type. */
3362 DECL_BIT_FIELD (field
) = 0;
3363 CLEAR_DECL_C_BIT_FIELD (field
);
3368 /* FIELD is a non bit-field. We are finishing the processing for its
3369 enclosing type T. Issue any appropriate messages and set appropriate
3373 check_field_decl (tree field
,
3375 int* cant_have_const_ctor
,
3376 int* no_const_asn_ref
,
3377 int* any_default_members
)
3379 tree type
= strip_array_types (TREE_TYPE (field
));
3381 /* In C++98 an anonymous union cannot contain any fields which would change
3382 the settings of CANT_HAVE_CONST_CTOR and friends. */
3383 if (ANON_UNION_TYPE_P (type
) && cxx_dialect
< cxx11
)
3385 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
3386 structs. So, we recurse through their fields here. */
3387 else if (ANON_AGGR_TYPE_P (type
))
3391 for (fields
= TYPE_FIELDS (type
); fields
; fields
= DECL_CHAIN (fields
))
3392 if (TREE_CODE (fields
) == FIELD_DECL
&& !DECL_C_BIT_FIELD (field
))
3393 check_field_decl (fields
, t
, cant_have_const_ctor
,
3394 no_const_asn_ref
, any_default_members
);
3396 /* Check members with class type for constructors, destructors,
3398 else if (CLASS_TYPE_P (type
))
3400 /* Never let anything with uninheritable virtuals
3401 make it through without complaint. */
3402 abstract_virtuals_error (field
, type
);
3404 if (TREE_CODE (t
) == UNION_TYPE
&& cxx_dialect
< cxx11
)
3407 int oldcount
= errorcount
;
3408 if (TYPE_NEEDS_CONSTRUCTING (type
))
3409 error ("member %q+#D with constructor not allowed in union",
3411 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3412 error ("member %q+#D with destructor not allowed in union", field
);
3413 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
3414 error ("member %q+#D with copy assignment operator not allowed in union",
3416 if (!warned
&& errorcount
> oldcount
)
3418 inform (DECL_SOURCE_LOCATION (field
), "unrestricted unions "
3419 "only available with -std=c++11 or -std=gnu++11");
3425 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (type
);
3426 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3427 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
);
3428 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
)
3429 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
)
3430 || !TYPE_HAS_COPY_ASSIGN (type
));
3431 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= (TYPE_HAS_COMPLEX_COPY_CTOR (type
)
3432 || !TYPE_HAS_COPY_CTOR (type
));
3433 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type
);
3434 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_HAS_COMPLEX_MOVE_CTOR (type
);
3435 TYPE_HAS_COMPLEX_DFLT (t
) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)
3436 || TYPE_HAS_COMPLEX_DFLT (type
));
3439 if (TYPE_HAS_COPY_CTOR (type
)
3440 && !TYPE_HAS_CONST_COPY_CTOR (type
))
3441 *cant_have_const_ctor
= 1;
3443 if (TYPE_HAS_COPY_ASSIGN (type
)
3444 && !TYPE_HAS_CONST_COPY_ASSIGN (type
))
3445 *no_const_asn_ref
= 1;
3448 check_abi_tags (t
, field
);
3450 if (DECL_INITIAL (field
) != NULL_TREE
)
3452 /* `build_class_init_list' does not recognize
3454 if (TREE_CODE (t
) == UNION_TYPE
&& *any_default_members
!= 0)
3455 error ("multiple fields in union %qT initialized", t
);
3456 *any_default_members
= 1;
3460 /* Check the data members (both static and non-static), class-scoped
3461 typedefs, etc., appearing in the declaration of T. Issue
3462 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3463 declaration order) of access declarations; each TREE_VALUE in this
3464 list is a USING_DECL.
3466 In addition, set the following flags:
3469 The class is empty, i.e., contains no non-static data members.
3471 CANT_HAVE_CONST_CTOR_P
3472 This class cannot have an implicitly generated copy constructor
3473 taking a const reference.
3475 CANT_HAVE_CONST_ASN_REF
3476 This class cannot have an implicitly generated assignment
3477 operator taking a const reference.
3479 All of these flags should be initialized before calling this
3482 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3483 fields can be added by adding to this chain. */
3486 check_field_decls (tree t
, tree
*access_decls
,
3487 int *cant_have_const_ctor_p
,
3488 int *no_const_asn_ref_p
)
3493 int any_default_members
;
3495 int field_access
= -1;
3497 /* Assume there are no access declarations. */
3498 *access_decls
= NULL_TREE
;
3499 /* Assume this class has no pointer members. */
3500 has_pointers
= false;
3501 /* Assume none of the members of this class have default
3503 any_default_members
= 0;
3505 for (field
= &TYPE_FIELDS (t
); *field
; field
= next
)
3508 tree type
= TREE_TYPE (x
);
3509 int this_field_access
;
3511 next
= &DECL_CHAIN (x
);
3513 if (TREE_CODE (x
) == USING_DECL
)
3515 /* Save the access declarations for our caller. */
3516 *access_decls
= tree_cons (NULL_TREE
, x
, *access_decls
);
3520 if (TREE_CODE (x
) == TYPE_DECL
3521 || TREE_CODE (x
) == TEMPLATE_DECL
)
3524 /* If we've gotten this far, it's a data member, possibly static,
3525 or an enumerator. */
3526 if (TREE_CODE (x
) != CONST_DECL
)
3527 DECL_CONTEXT (x
) = t
;
3529 /* When this goes into scope, it will be a non-local reference. */
3530 DECL_NONLOCAL (x
) = 1;
3532 if (TREE_CODE (t
) == UNION_TYPE
3533 && cxx_dialect
< cxx11
)
3535 /* [class.union] (C++98)
3537 If a union contains a static data member, or a member of
3538 reference type, the program is ill-formed.
3540 In C++11 this limitation doesn't exist anymore. */
3543 error ("in C++98 %q+D may not be static because it is "
3544 "a member of a union", x
);
3547 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3549 error ("in C++98 %q+D may not have reference type %qT "
3550 "because it is a member of a union", x
, type
);
3555 /* Perform error checking that did not get done in
3557 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3559 error ("field %q+D invalidly declared function type", x
);
3560 type
= build_pointer_type (type
);
3561 TREE_TYPE (x
) = type
;
3563 else if (TREE_CODE (type
) == METHOD_TYPE
)
3565 error ("field %q+D invalidly declared method type", x
);
3566 type
= build_pointer_type (type
);
3567 TREE_TYPE (x
) = type
;
3570 if (type
== error_mark_node
)
3573 if (TREE_CODE (x
) == CONST_DECL
|| VAR_P (x
))
3576 /* Now it can only be a FIELD_DECL. */
3578 if (TREE_PRIVATE (x
) || TREE_PROTECTED (x
))
3579 CLASSTYPE_NON_AGGREGATE (t
) = 1;
3581 /* If at least one non-static data member is non-literal, the whole
3582 class becomes non-literal. Per Core/1453, volatile non-static
3583 data members and base classes are also not allowed.
3584 Note: if the type is incomplete we will complain later on. */
3585 if (COMPLETE_TYPE_P (type
)
3586 && (!literal_type_p (type
) || CP_TYPE_VOLATILE_P (type
)))
3587 CLASSTYPE_LITERAL_P (t
) = false;
3589 /* A standard-layout class is a class that:
3591 has the same access control (Clause 11) for all non-static data members,
3593 this_field_access
= TREE_PROTECTED (x
) ? 1 : TREE_PRIVATE (x
) ? 2 : 0;
3594 if (field_access
== -1)
3595 field_access
= this_field_access
;
3596 else if (this_field_access
!= field_access
)
3597 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3599 /* If this is of reference type, check if it needs an init. */
3600 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3602 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3603 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3604 if (DECL_INITIAL (x
) == NULL_TREE
)
3605 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3607 /* ARM $12.6.2: [A member initializer list] (or, for an
3608 aggregate, initialization by a brace-enclosed list) is the
3609 only way to initialize nonstatic const and reference
3611 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
3612 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) = 1;
3615 type
= strip_array_types (type
);
3617 if (TYPE_PACKED (t
))
3619 if (!layout_pod_type_p (type
) && !TYPE_PACKED (type
))
3623 "ignoring packed attribute because of unpacked non-POD field %q+#D",
3627 else if (DECL_C_BIT_FIELD (x
)
3628 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
)
3629 DECL_PACKED (x
) = 1;
3632 if (DECL_C_BIT_FIELD (x
) && integer_zerop (DECL_INITIAL (x
)))
3633 /* We don't treat zero-width bitfields as making a class
3638 /* The class is non-empty. */
3639 CLASSTYPE_EMPTY_P (t
) = 0;
3640 /* The class is not even nearly empty. */
3641 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3642 /* If one of the data members contains an empty class,
3644 if (CLASS_TYPE_P (type
)
3645 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3646 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
3649 /* This is used by -Weffc++ (see below). Warn only for pointers
3650 to members which might hold dynamic memory. So do not warn
3651 for pointers to functions or pointers to members. */
3652 if (TYPE_PTR_P (type
)
3653 && !TYPE_PTRFN_P (type
))
3654 has_pointers
= true;
3656 if (CLASS_TYPE_P (type
))
3658 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type
))
3659 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3660 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
))
3661 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3664 if (DECL_MUTABLE_P (x
) || TYPE_HAS_MUTABLE_P (type
))
3665 CLASSTYPE_HAS_MUTABLE (t
) = 1;
3667 if (DECL_MUTABLE_P (x
))
3669 if (CP_TYPE_CONST_P (type
))
3671 error ("member %q+D cannot be declared both %<const%> "
3672 "and %<mutable%>", x
);
3675 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3677 error ("member %q+D cannot be declared as a %<mutable%> "
3683 if (! layout_pod_type_p (type
))
3684 /* DR 148 now allows pointers to members (which are POD themselves),
3685 to be allowed in POD structs. */
3686 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3688 if (!std_layout_type_p (type
))
3689 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3691 if (! zero_init_p (type
))
3692 CLASSTYPE_NON_ZERO_INIT_P (t
) = 1;
3694 /* We set DECL_C_BIT_FIELD in grokbitfield.
3695 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3696 if (! DECL_C_BIT_FIELD (x
) || ! check_bitfield_decl (x
))
3697 check_field_decl (x
, t
,
3698 cant_have_const_ctor_p
,
3700 &any_default_members
);
3702 /* Now that we've removed bit-field widths from DECL_INITIAL,
3703 anything left in DECL_INITIAL is an NSDMI that makes the class
3704 non-aggregate in C++11. */
3705 if (DECL_INITIAL (x
) && cxx_dialect
< cxx14
)
3706 CLASSTYPE_NON_AGGREGATE (t
) = true;
3708 /* If any field is const, the structure type is pseudo-const. */
3709 if (CP_TYPE_CONST_P (type
))
3711 C_TYPE_FIELDS_READONLY (t
) = 1;
3712 if (DECL_INITIAL (x
) == NULL_TREE
)
3713 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3715 /* ARM $12.6.2: [A member initializer list] (or, for an
3716 aggregate, initialization by a brace-enclosed list) is the
3717 only way to initialize nonstatic const and reference
3719 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
3720 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) = 1;
3722 /* A field that is pseudo-const makes the structure likewise. */
3723 else if (CLASS_TYPE_P (type
))
3725 C_TYPE_FIELDS_READONLY (t
) |= C_TYPE_FIELDS_READONLY (type
);
3726 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
,
3727 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
3728 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
));
3731 /* Core issue 80: A nonstatic data member is required to have a
3732 different name from the class iff the class has a
3733 user-declared constructor. */
3734 if (constructor_name_p (DECL_NAME (x
), t
)
3735 && TYPE_HAS_USER_CONSTRUCTOR (t
))
3736 permerror (input_location
, "field %q+#D with same name as class", x
);
3739 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3740 it should also define a copy constructor and an assignment operator to
3741 implement the correct copy semantic (deep vs shallow, etc.). As it is
3742 not feasible to check whether the constructors do allocate dynamic memory
3743 and store it within members, we approximate the warning like this:
3745 -- Warn only if there are members which are pointers
3746 -- Warn only if there is a non-trivial constructor (otherwise,
3747 there cannot be memory allocated).
3748 -- Warn only if there is a non-trivial destructor. We assume that the
3749 user at least implemented the cleanup correctly, and a destructor
3750 is needed to free dynamic memory.
3752 This seems enough for practical purposes. */
3755 && TYPE_HAS_USER_CONSTRUCTOR (t
)
3756 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3757 && !(TYPE_HAS_COPY_CTOR (t
) && TYPE_HAS_COPY_ASSIGN (t
)))
3759 warning (OPT_Weffc__
, "%q#T has pointer data members", t
);
3761 if (! TYPE_HAS_COPY_CTOR (t
))
3763 warning (OPT_Weffc__
,
3764 " but does not override %<%T(const %T&)%>", t
, t
);
3765 if (!TYPE_HAS_COPY_ASSIGN (t
))
3766 warning (OPT_Weffc__
, " or %<operator=(const %T&)%>", t
);
3768 else if (! TYPE_HAS_COPY_ASSIGN (t
))
3769 warning (OPT_Weffc__
,
3770 " but does not override %<operator=(const %T&)%>", t
);
3773 /* Non-static data member initializers make the default constructor
3775 if (any_default_members
)
3777 TYPE_NEEDS_CONSTRUCTING (t
) = true;
3778 TYPE_HAS_COMPLEX_DFLT (t
) = true;
3781 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3783 TYPE_PACKED (t
) = 0;
3785 /* Check anonymous struct/anonymous union fields. */
3786 finish_struct_anon (t
);
3788 /* We've built up the list of access declarations in reverse order.
3790 *access_decls
= nreverse (*access_decls
);
3793 /* If TYPE is an empty class type, records its OFFSET in the table of
3797 record_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3801 if (!is_empty_class (type
))
3804 /* Record the location of this empty object in OFFSETS. */
3805 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3807 n
= splay_tree_insert (offsets
,
3808 (splay_tree_key
) offset
,
3809 (splay_tree_value
) NULL_TREE
);
3810 n
->value
= ((splay_tree_value
)
3811 tree_cons (NULL_TREE
,
3818 /* Returns nonzero if TYPE is an empty class type and there is
3819 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3822 check_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3827 if (!is_empty_class (type
))
3830 /* Record the location of this empty object in OFFSETS. */
3831 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3835 for (t
= (tree
) n
->value
; t
; t
= TREE_CHAIN (t
))
3836 if (same_type_p (TREE_VALUE (t
), type
))
3842 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3843 F for every subobject, passing it the type, offset, and table of
3844 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3847 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3848 than MAX_OFFSET will not be walked.
3850 If F returns a nonzero value, the traversal ceases, and that value
3851 is returned. Otherwise, returns zero. */
3854 walk_subobject_offsets (tree type
,
3855 subobject_offset_fn f
,
3862 tree type_binfo
= NULL_TREE
;
3864 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3866 if (max_offset
&& tree_int_cst_lt (max_offset
, offset
))
3869 if (type
== error_mark_node
)
3875 type
= BINFO_TYPE (type
);
3878 if (CLASS_TYPE_P (type
))
3884 /* Avoid recursing into objects that are not interesting. */
3885 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3888 /* Record the location of TYPE. */
3889 r
= (*f
) (type
, offset
, offsets
);
3893 /* Iterate through the direct base classes of TYPE. */
3895 type_binfo
= TYPE_BINFO (type
);
3896 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, binfo
); i
++)
3900 if (BINFO_VIRTUAL_P (binfo
))
3904 /* We cannot rely on BINFO_OFFSET being set for the base
3905 class yet, but the offsets for direct non-virtual
3906 bases can be calculated by going back to the TYPE. */
3907 orig_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
3908 binfo_offset
= size_binop (PLUS_EXPR
,
3910 BINFO_OFFSET (orig_binfo
));
3912 r
= walk_subobject_offsets (binfo
,
3922 if (CLASSTYPE_VBASECLASSES (type
))
3925 vec
<tree
, va_gc
> *vbases
;
3927 /* Iterate through the virtual base classes of TYPE. In G++
3928 3.2, we included virtual bases in the direct base class
3929 loop above, which results in incorrect results; the
3930 correct offsets for virtual bases are only known when
3931 working with the most derived type. */
3933 for (vbases
= CLASSTYPE_VBASECLASSES (type
), ix
= 0;
3934 vec_safe_iterate (vbases
, ix
, &binfo
); ix
++)
3936 r
= walk_subobject_offsets (binfo
,
3938 size_binop (PLUS_EXPR
,
3940 BINFO_OFFSET (binfo
)),
3949 /* We still have to walk the primary base, if it is
3950 virtual. (If it is non-virtual, then it was walked
3952 tree vbase
= get_primary_binfo (type_binfo
);
3954 if (vbase
&& BINFO_VIRTUAL_P (vbase
)
3955 && BINFO_PRIMARY_P (vbase
)
3956 && BINFO_INHERITANCE_CHAIN (vbase
) == type_binfo
)
3958 r
= (walk_subobject_offsets
3960 offsets
, max_offset
, /*vbases_p=*/0));
3967 /* Iterate through the fields of TYPE. */
3968 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3969 if (TREE_CODE (field
) == FIELD_DECL
3970 && TREE_TYPE (field
) != error_mark_node
3971 && !DECL_ARTIFICIAL (field
))
3975 field_offset
= byte_position (field
);
3977 r
= walk_subobject_offsets (TREE_TYPE (field
),
3979 size_binop (PLUS_EXPR
,
3989 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3991 tree element_type
= strip_array_types (type
);
3992 tree domain
= TYPE_DOMAIN (type
);
3995 /* Avoid recursing into objects that are not interesting. */
3996 if (!CLASS_TYPE_P (element_type
)
3997 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type
))
4000 /* Step through each of the elements in the array. */
4001 for (index
= size_zero_node
;
4002 !tree_int_cst_lt (TYPE_MAX_VALUE (domain
), index
);
4003 index
= size_binop (PLUS_EXPR
, index
, size_one_node
))
4005 r
= walk_subobject_offsets (TREE_TYPE (type
),
4013 offset
= size_binop (PLUS_EXPR
, offset
,
4014 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
4015 /* If this new OFFSET is bigger than the MAX_OFFSET, then
4016 there's no point in iterating through the remaining
4017 elements of the array. */
4018 if (max_offset
&& tree_int_cst_lt (max_offset
, offset
))
4026 /* Record all of the empty subobjects of TYPE (either a type or a
4027 binfo). If IS_DATA_MEMBER is true, then a non-static data member
4028 is being placed at OFFSET; otherwise, it is a base class that is
4029 being placed at OFFSET. */
4032 record_subobject_offsets (tree type
,
4035 bool is_data_member
)
4038 /* If recording subobjects for a non-static data member or a
4039 non-empty base class , we do not need to record offsets beyond
4040 the size of the biggest empty class. Additional data members
4041 will go at the end of the class. Additional base classes will go
4042 either at offset zero (if empty, in which case they cannot
4043 overlap with offsets past the size of the biggest empty class) or
4044 at the end of the class.
4046 However, if we are placing an empty base class, then we must record
4047 all offsets, as either the empty class is at offset zero (where
4048 other empty classes might later be placed) or at the end of the
4049 class (where other objects might then be placed, so other empty
4050 subobjects might later overlap). */
4052 || !is_empty_class (BINFO_TYPE (type
)))
4053 max_offset
= sizeof_biggest_empty_class
;
4055 max_offset
= NULL_TREE
;
4056 walk_subobject_offsets (type
, record_subobject_offset
, offset
,
4057 offsets
, max_offset
, is_data_member
);
4060 /* Returns nonzero if any of the empty subobjects of TYPE (located at
4061 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
4062 virtual bases of TYPE are examined. */
4065 layout_conflict_p (tree type
,
4070 splay_tree_node max_node
;
4072 /* Get the node in OFFSETS that indicates the maximum offset where
4073 an empty subobject is located. */
4074 max_node
= splay_tree_max (offsets
);
4075 /* If there aren't any empty subobjects, then there's no point in
4076 performing this check. */
4080 return walk_subobject_offsets (type
, check_subobject_offset
, offset
,
4081 offsets
, (tree
) (max_node
->key
),
4085 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
4086 non-static data member of the type indicated by RLI. BINFO is the
4087 binfo corresponding to the base subobject, OFFSETS maps offsets to
4088 types already located at those offsets. This function determines
4089 the position of the DECL. */
4092 layout_nonempty_base_or_field (record_layout_info rli
,
4097 tree offset
= NULL_TREE
;
4103 /* For the purposes of determining layout conflicts, we want to
4104 use the class type of BINFO; TREE_TYPE (DECL) will be the
4105 CLASSTYPE_AS_BASE version, which does not contain entries for
4106 zero-sized bases. */
4107 type
= TREE_TYPE (binfo
);
4112 type
= TREE_TYPE (decl
);
4116 /* Try to place the field. It may take more than one try if we have
4117 a hard time placing the field without putting two objects of the
4118 same type at the same address. */
4121 struct record_layout_info_s old_rli
= *rli
;
4123 /* Place this field. */
4124 place_field (rli
, decl
);
4125 offset
= byte_position (decl
);
4127 /* We have to check to see whether or not there is already
4128 something of the same type at the offset we're about to use.
4129 For example, consider:
4132 struct T : public S { int i; };
4133 struct U : public S, public T {};
4135 Here, we put S at offset zero in U. Then, we can't put T at
4136 offset zero -- its S component would be at the same address
4137 as the S we already allocated. So, we have to skip ahead.
4138 Since all data members, including those whose type is an
4139 empty class, have nonzero size, any overlap can happen only
4140 with a direct or indirect base-class -- it can't happen with
4142 /* In a union, overlap is permitted; all members are placed at
4144 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
4146 if (layout_conflict_p (field_p
? type
: binfo
, offset
,
4149 /* Strip off the size allocated to this field. That puts us
4150 at the first place we could have put the field with
4151 proper alignment. */
4154 /* Bump up by the alignment required for the type. */
4156 = size_binop (PLUS_EXPR
, rli
->bitpos
,
4158 ? CLASSTYPE_ALIGN (type
)
4159 : TYPE_ALIGN (type
)));
4160 normalize_rli (rli
);
4163 /* There was no conflict. We're done laying out this field. */
4167 /* Now that we know where it will be placed, update its
4169 if (binfo
&& CLASS_TYPE_P (BINFO_TYPE (binfo
)))
4170 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
4171 this point because their BINFO_OFFSET is copied from another
4172 hierarchy. Therefore, we may not need to add the entire
4174 propagate_binfo_offsets (binfo
,
4175 size_diffop_loc (input_location
,
4176 convert (ssizetype
, offset
),
4178 BINFO_OFFSET (binfo
))));
4181 /* Returns true if TYPE is empty and OFFSET is nonzero. */
4184 empty_base_at_nonzero_offset_p (tree type
,
4186 splay_tree
/*offsets*/)
4188 return is_empty_class (type
) && !integer_zerop (offset
);
4191 /* Layout the empty base BINFO. EOC indicates the byte currently just
4192 past the end of the class, and should be correctly aligned for a
4193 class of the type indicated by BINFO; OFFSETS gives the offsets of
4194 the empty bases allocated so far. T is the most derived
4195 type. Return nonzero iff we added it at the end. */
4198 layout_empty_base (record_layout_info rli
, tree binfo
,
4199 tree eoc
, splay_tree offsets
)
4202 tree basetype
= BINFO_TYPE (binfo
);
4205 /* This routine should only be used for empty classes. */
4206 gcc_assert (is_empty_class (basetype
));
4207 alignment
= ssize_int (CLASSTYPE_ALIGN_UNIT (basetype
));
4209 if (!integer_zerop (BINFO_OFFSET (binfo
)))
4210 propagate_binfo_offsets
4211 (binfo
, size_diffop_loc (input_location
,
4212 size_zero_node
, BINFO_OFFSET (binfo
)));
4214 /* This is an empty base class. We first try to put it at offset
4216 if (layout_conflict_p (binfo
,
4217 BINFO_OFFSET (binfo
),
4221 /* That didn't work. Now, we move forward from the next
4222 available spot in the class. */
4224 propagate_binfo_offsets (binfo
, convert (ssizetype
, eoc
));
4227 if (!layout_conflict_p (binfo
,
4228 BINFO_OFFSET (binfo
),
4231 /* We finally found a spot where there's no overlap. */
4234 /* There's overlap here, too. Bump along to the next spot. */
4235 propagate_binfo_offsets (binfo
, alignment
);
4239 if (CLASSTYPE_USER_ALIGN (basetype
))
4241 rli
->record_align
= MAX (rli
->record_align
, CLASSTYPE_ALIGN (basetype
));
4243 rli
->unpacked_align
= MAX (rli
->unpacked_align
, CLASSTYPE_ALIGN (basetype
));
4244 TYPE_USER_ALIGN (rli
->t
) = 1;
4250 /* Layout the base given by BINFO in the class indicated by RLI.
4251 *BASE_ALIGN is a running maximum of the alignments of
4252 any base class. OFFSETS gives the location of empty base
4253 subobjects. T is the most derived type. Return nonzero if the new
4254 object cannot be nearly-empty. A new FIELD_DECL is inserted at
4255 *NEXT_FIELD, unless BINFO is for an empty base class.
4257 Returns the location at which the next field should be inserted. */
4260 build_base_field (record_layout_info rli
, tree binfo
,
4261 splay_tree offsets
, tree
*next_field
)
4264 tree basetype
= BINFO_TYPE (binfo
);
4266 if (!COMPLETE_TYPE_P (basetype
))
4267 /* This error is now reported in xref_tag, thus giving better
4268 location information. */
4271 /* Place the base class. */
4272 if (!is_empty_class (basetype
))
4276 /* The containing class is non-empty because it has a non-empty
4278 CLASSTYPE_EMPTY_P (t
) = 0;
4280 /* Create the FIELD_DECL. */
4281 decl
= build_decl (input_location
,
4282 FIELD_DECL
, NULL_TREE
, CLASSTYPE_AS_BASE (basetype
));
4283 DECL_ARTIFICIAL (decl
) = 1;
4284 DECL_IGNORED_P (decl
) = 1;
4285 DECL_FIELD_CONTEXT (decl
) = t
;
4286 if (CLASSTYPE_AS_BASE (basetype
))
4288 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
4289 DECL_SIZE_UNIT (decl
) = CLASSTYPE_SIZE_UNIT (basetype
);
4290 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
4291 DECL_USER_ALIGN (decl
) = CLASSTYPE_USER_ALIGN (basetype
);
4292 DECL_MODE (decl
) = TYPE_MODE (basetype
);
4293 DECL_FIELD_IS_BASE (decl
) = 1;
4295 /* Try to place the field. It may take more than one try if we
4296 have a hard time placing the field without putting two
4297 objects of the same type at the same address. */
4298 layout_nonempty_base_or_field (rli
, decl
, binfo
, offsets
);
4299 /* Add the new FIELD_DECL to the list of fields for T. */
4300 DECL_CHAIN (decl
) = *next_field
;
4302 next_field
= &DECL_CHAIN (decl
);
4310 /* On some platforms (ARM), even empty classes will not be
4312 eoc
= round_up_loc (input_location
,
4313 rli_size_unit_so_far (rli
),
4314 CLASSTYPE_ALIGN_UNIT (basetype
));
4315 atend
= layout_empty_base (rli
, binfo
, eoc
, offsets
);
4316 /* A nearly-empty class "has no proper base class that is empty,
4317 not morally virtual, and at an offset other than zero." */
4318 if (!BINFO_VIRTUAL_P (binfo
) && CLASSTYPE_NEARLY_EMPTY_P (t
))
4321 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4322 /* The check above (used in G++ 3.2) is insufficient because
4323 an empty class placed at offset zero might itself have an
4324 empty base at a nonzero offset. */
4325 else if (walk_subobject_offsets (basetype
,
4326 empty_base_at_nonzero_offset_p
,
4329 /*max_offset=*/NULL_TREE
,
4331 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4334 /* We do not create a FIELD_DECL for empty base classes because
4335 it might overlap some other field. We want to be able to
4336 create CONSTRUCTORs for the class by iterating over the
4337 FIELD_DECLs, and the back end does not handle overlapping
4340 /* An empty virtual base causes a class to be non-empty
4341 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
4342 here because that was already done when the virtual table
4343 pointer was created. */
4346 /* Record the offsets of BINFO and its base subobjects. */
4347 record_subobject_offsets (binfo
,
4348 BINFO_OFFSET (binfo
),
4350 /*is_data_member=*/false);
4355 /* Layout all of the non-virtual base classes. Record empty
4356 subobjects in OFFSETS. T is the most derived type. Return nonzero
4357 if the type cannot be nearly empty. The fields created
4358 corresponding to the base classes will be inserted at
4362 build_base_fields (record_layout_info rli
,
4363 splay_tree offsets
, tree
*next_field
)
4365 /* Chain to hold all the new FIELD_DECLs which stand in for base class
4368 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
4371 /* The primary base class is always allocated first. */
4372 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
4373 next_field
= build_base_field (rli
, CLASSTYPE_PRIMARY_BINFO (t
),
4374 offsets
, next_field
);
4376 /* Now allocate the rest of the bases. */
4377 for (i
= 0; i
< n_baseclasses
; ++i
)
4381 base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (t
), i
);
4383 /* The primary base was already allocated above, so we don't
4384 need to allocate it again here. */
4385 if (base_binfo
== CLASSTYPE_PRIMARY_BINFO (t
))
4388 /* Virtual bases are added at the end (a primary virtual base
4389 will have already been added). */
4390 if (BINFO_VIRTUAL_P (base_binfo
))
4393 next_field
= build_base_field (rli
, base_binfo
,
4394 offsets
, next_field
);
4398 /* Go through the TYPE_METHODS of T issuing any appropriate
4399 diagnostics, figuring out which methods override which other
4400 methods, and so forth. */
4403 check_methods (tree t
)
4407 for (x
= TYPE_METHODS (t
); x
; x
= DECL_CHAIN (x
))
4409 check_for_override (x
, t
);
4410 if (DECL_PURE_VIRTUAL_P (x
) && (TREE_CODE (x
) != FUNCTION_DECL
|| ! DECL_VINDEX (x
)))
4411 error ("initializer specified for non-virtual method %q+D", x
);
4412 /* The name of the field is the original field name
4413 Save this in auxiliary field for later overloading. */
4414 if (TREE_CODE (x
) == FUNCTION_DECL
&& DECL_VINDEX (x
))
4416 TYPE_POLYMORPHIC_P (t
) = 1;
4417 if (DECL_PURE_VIRTUAL_P (x
))
4418 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t
), x
);
4420 /* All user-provided destructors are non-trivial.
4421 Constructors and assignment ops are handled in
4422 grok_special_member_properties. */
4423 if (DECL_DESTRUCTOR_P (x
) && user_provided_p (x
))
4424 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = 1;
4428 /* FN is a constructor or destructor. Clone the declaration to create
4429 a specialized in-charge or not-in-charge version, as indicated by
4433 build_clone (tree fn
, tree name
)
4438 /* Copy the function. */
4439 clone
= copy_decl (fn
);
4440 /* Reset the function name. */
4441 DECL_NAME (clone
) = name
;
4442 /* Remember where this function came from. */
4443 DECL_ABSTRACT_ORIGIN (clone
) = fn
;
4444 /* Make it easy to find the CLONE given the FN. */
4445 DECL_CHAIN (clone
) = DECL_CHAIN (fn
);
4446 DECL_CHAIN (fn
) = clone
;
4448 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
4449 if (TREE_CODE (clone
) == TEMPLATE_DECL
)
4451 tree result
= build_clone (DECL_TEMPLATE_RESULT (clone
), name
);
4452 DECL_TEMPLATE_RESULT (clone
) = result
;
4453 DECL_TEMPLATE_INFO (result
) = copy_node (DECL_TEMPLATE_INFO (result
));
4454 DECL_TI_TEMPLATE (result
) = clone
;
4455 TREE_TYPE (clone
) = TREE_TYPE (result
);
4459 SET_DECL_ASSEMBLER_NAME (clone
, NULL_TREE
);
4460 DECL_CLONED_FUNCTION (clone
) = fn
;
4461 /* There's no pending inline data for this function. */
4462 DECL_PENDING_INLINE_INFO (clone
) = NULL
;
4463 DECL_PENDING_INLINE_P (clone
) = 0;
4465 /* The base-class destructor is not virtual. */
4466 if (name
== base_dtor_identifier
)
4468 DECL_VIRTUAL_P (clone
) = 0;
4469 if (TREE_CODE (clone
) != TEMPLATE_DECL
)
4470 DECL_VINDEX (clone
) = NULL_TREE
;
4473 /* If there was an in-charge parameter, drop it from the function
4475 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
4481 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4482 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4483 parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4484 /* Skip the `this' parameter. */
4485 parmtypes
= TREE_CHAIN (parmtypes
);
4486 /* Skip the in-charge parameter. */
4487 parmtypes
= TREE_CHAIN (parmtypes
);
4488 /* And the VTT parm, in a complete [cd]tor. */
4489 if (DECL_HAS_VTT_PARM_P (fn
)
4490 && ! DECL_NEEDS_VTT_PARM_P (clone
))
4491 parmtypes
= TREE_CHAIN (parmtypes
);
4492 /* If this is subobject constructor or destructor, add the vtt
4495 = build_method_type_directly (basetype
,
4496 TREE_TYPE (TREE_TYPE (clone
)),
4499 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
),
4502 = cp_build_type_attribute_variant (TREE_TYPE (clone
),
4503 TYPE_ATTRIBUTES (TREE_TYPE (fn
)));
4506 /* Copy the function parameters. */
4507 DECL_ARGUMENTS (clone
) = copy_list (DECL_ARGUMENTS (clone
));
4508 /* Remove the in-charge parameter. */
4509 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
4511 DECL_CHAIN (DECL_ARGUMENTS (clone
))
4512 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
)));
4513 DECL_HAS_IN_CHARGE_PARM_P (clone
) = 0;
4515 /* And the VTT parm, in a complete [cd]tor. */
4516 if (DECL_HAS_VTT_PARM_P (fn
))
4518 if (DECL_NEEDS_VTT_PARM_P (clone
))
4519 DECL_HAS_VTT_PARM_P (clone
) = 1;
4522 DECL_CHAIN (DECL_ARGUMENTS (clone
))
4523 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
)));
4524 DECL_HAS_VTT_PARM_P (clone
) = 0;
4528 for (parms
= DECL_ARGUMENTS (clone
); parms
; parms
= DECL_CHAIN (parms
))
4530 DECL_CONTEXT (parms
) = clone
;
4531 cxx_dup_lang_specific_decl (parms
);
4534 /* Create the RTL for this function. */
4535 SET_DECL_RTL (clone
, NULL
);
4536 rest_of_decl_compilation (clone
, /*top_level=*/1, at_eof
);
4539 note_decl_for_pch (clone
);
4544 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
4545 not invoke this function directly.
4547 For a non-thunk function, returns the address of the slot for storing
4548 the function it is a clone of. Otherwise returns NULL_TREE.
4550 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
4551 cloned_function is unset. This is to support the separate
4552 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
4553 on a template makes sense, but not the former. */
4556 decl_cloned_function_p (const_tree decl
, bool just_testing
)
4560 decl
= STRIP_TEMPLATE (decl
);
4562 if (TREE_CODE (decl
) != FUNCTION_DECL
4563 || !DECL_LANG_SPECIFIC (decl
)
4564 || DECL_LANG_SPECIFIC (decl
)->u
.fn
.thunk_p
)
4566 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4568 lang_check_failed (__FILE__
, __LINE__
, __FUNCTION__
);
4574 ptr
= &DECL_LANG_SPECIFIC (decl
)->u
.fn
.u5
.cloned_function
;
4575 if (just_testing
&& *ptr
== NULL_TREE
)
4581 /* Produce declarations for all appropriate clones of FN. If
4582 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4583 CLASTYPE_METHOD_VEC as well. */
4586 clone_function_decl (tree fn
, int update_method_vec_p
)
4590 /* Avoid inappropriate cloning. */
4592 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (fn
)))
4595 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
4597 /* For each constructor, we need two variants: an in-charge version
4598 and a not-in-charge version. */
4599 clone
= build_clone (fn
, complete_ctor_identifier
);
4600 if (update_method_vec_p
)
4601 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4602 clone
= build_clone (fn
, base_ctor_identifier
);
4603 if (update_method_vec_p
)
4604 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4608 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
));
4610 /* For each destructor, we need three variants: an in-charge
4611 version, a not-in-charge version, and an in-charge deleting
4612 version. We clone the deleting version first because that
4613 means it will go second on the TYPE_METHODS list -- and that
4614 corresponds to the correct layout order in the virtual
4617 For a non-virtual destructor, we do not build a deleting
4619 if (DECL_VIRTUAL_P (fn
))
4621 clone
= build_clone (fn
, deleting_dtor_identifier
);
4622 if (update_method_vec_p
)
4623 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4625 clone
= build_clone (fn
, complete_dtor_identifier
);
4626 if (update_method_vec_p
)
4627 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4628 clone
= build_clone (fn
, base_dtor_identifier
);
4629 if (update_method_vec_p
)
4630 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4633 /* Note that this is an abstract function that is never emitted. */
4634 DECL_ABSTRACT_P (fn
) = true;
4637 /* DECL is an in charge constructor, which is being defined. This will
4638 have had an in class declaration, from whence clones were
4639 declared. An out-of-class definition can specify additional default
4640 arguments. As it is the clones that are involved in overload
4641 resolution, we must propagate the information from the DECL to its
4645 adjust_clone_args (tree decl
)
4649 for (clone
= DECL_CHAIN (decl
); clone
&& DECL_CLONED_FUNCTION_P (clone
);
4650 clone
= DECL_CHAIN (clone
))
4652 tree orig_clone_parms
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4653 tree orig_decl_parms
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
4654 tree decl_parms
, clone_parms
;
4656 clone_parms
= orig_clone_parms
;
4658 /* Skip the 'this' parameter. */
4659 orig_clone_parms
= TREE_CHAIN (orig_clone_parms
);
4660 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4662 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
4663 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4664 if (DECL_HAS_VTT_PARM_P (decl
))
4665 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4667 clone_parms
= orig_clone_parms
;
4668 if (DECL_HAS_VTT_PARM_P (clone
))
4669 clone_parms
= TREE_CHAIN (clone_parms
);
4671 for (decl_parms
= orig_decl_parms
; decl_parms
;
4672 decl_parms
= TREE_CHAIN (decl_parms
),
4673 clone_parms
= TREE_CHAIN (clone_parms
))
4675 gcc_assert (same_type_p (TREE_TYPE (decl_parms
),
4676 TREE_TYPE (clone_parms
)));
4678 if (TREE_PURPOSE (decl_parms
) && !TREE_PURPOSE (clone_parms
))
4680 /* A default parameter has been added. Adjust the
4681 clone's parameters. */
4682 tree exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4683 tree attrs
= TYPE_ATTRIBUTES (TREE_TYPE (clone
));
4684 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4687 clone_parms
= orig_decl_parms
;
4689 if (DECL_HAS_VTT_PARM_P (clone
))
4691 clone_parms
= tree_cons (TREE_PURPOSE (orig_clone_parms
),
4692 TREE_VALUE (orig_clone_parms
),
4694 TREE_TYPE (clone_parms
) = TREE_TYPE (orig_clone_parms
);
4696 type
= build_method_type_directly (basetype
,
4697 TREE_TYPE (TREE_TYPE (clone
)),
4700 type
= build_exception_variant (type
, exceptions
);
4702 type
= cp_build_type_attribute_variant (type
, attrs
);
4703 TREE_TYPE (clone
) = type
;
4705 clone_parms
= NULL_TREE
;
4709 gcc_assert (!clone_parms
);
4713 /* For each of the constructors and destructors in T, create an
4714 in-charge and not-in-charge variant. */
4717 clone_constructors_and_destructors (tree t
)
4721 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4723 if (!CLASSTYPE_METHOD_VEC (t
))
4726 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4727 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
4728 for (fns
= CLASSTYPE_DESTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4729 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
4732 /* Deduce noexcept for a destructor DTOR. */
4735 deduce_noexcept_on_destructor (tree dtor
)
4737 if (!TYPE_RAISES_EXCEPTIONS (TREE_TYPE (dtor
)))
4739 tree eh_spec
= unevaluated_noexcept_spec ();
4740 TREE_TYPE (dtor
) = build_exception_variant (TREE_TYPE (dtor
), eh_spec
);
4744 /* For each destructor in T, deduce noexcept:
4746 12.4/3: A declaration of a destructor that does not have an
4747 exception-specification is implicitly considered to have the
4748 same exception-specification as an implicit declaration (15.4). */
4751 deduce_noexcept_on_destructors (tree t
)
4753 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4755 if (!CLASSTYPE_METHOD_VEC (t
))
4758 for (tree fns
= CLASSTYPE_DESTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4759 deduce_noexcept_on_destructor (OVL_CURRENT (fns
));
4762 /* Subroutine of set_one_vmethod_tm_attributes. Search base classes
4763 of TYPE for virtual functions which FNDECL overrides. Return a
4764 mask of the tm attributes found therein. */
4767 look_for_tm_attr_overrides (tree type
, tree fndecl
)
4769 tree binfo
= TYPE_BINFO (type
);
4773 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ++ix
)
4775 tree o
, basetype
= BINFO_TYPE (base_binfo
);
4777 if (!TYPE_POLYMORPHIC_P (basetype
))
4780 o
= look_for_overrides_here (basetype
, fndecl
);
4782 found
|= tm_attr_to_mask (find_tm_attribute
4783 (TYPE_ATTRIBUTES (TREE_TYPE (o
))));
4785 found
|= look_for_tm_attr_overrides (basetype
, fndecl
);
4791 /* Subroutine of set_method_tm_attributes. Handle the checks and
4792 inheritance for one virtual method FNDECL. */
4795 set_one_vmethod_tm_attributes (tree type
, tree fndecl
)
4800 found
= look_for_tm_attr_overrides (type
, fndecl
);
4802 /* If FNDECL doesn't actually override anything (i.e. T is the
4803 class that first declares FNDECL virtual), then we're done. */
4807 tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl
)));
4808 have
= tm_attr_to_mask (tm_attr
);
4810 /* Intel STM Language Extension 3.0, Section 4.2 table 4:
4811 tm_pure must match exactly, otherwise no weakening of
4812 tm_safe > tm_callable > nothing. */
4813 /* ??? The tm_pure attribute didn't make the transition to the
4814 multivendor language spec. */
4815 if (have
== TM_ATTR_PURE
)
4817 if (found
!= TM_ATTR_PURE
)
4823 /* If the overridden function is tm_pure, then FNDECL must be. */
4824 else if (found
== TM_ATTR_PURE
&& tm_attr
)
4826 /* Look for base class combinations that cannot be satisfied. */
4827 else if (found
!= TM_ATTR_PURE
&& (found
& TM_ATTR_PURE
))
4829 found
&= ~TM_ATTR_PURE
;
4831 error_at (DECL_SOURCE_LOCATION (fndecl
),
4832 "method overrides both %<transaction_pure%> and %qE methods",
4833 tm_mask_to_attr (found
));
4835 /* If FNDECL did not declare an attribute, then inherit the most
4837 else if (tm_attr
== NULL
)
4839 apply_tm_attr (fndecl
, tm_mask_to_attr (found
& -found
));
4841 /* Otherwise validate that we're not weaker than a function
4842 that is being overridden. */
4846 if (found
<= TM_ATTR_CALLABLE
&& have
> found
)
4852 error_at (DECL_SOURCE_LOCATION (fndecl
),
4853 "method declared %qE overriding %qE method",
4854 tm_attr
, tm_mask_to_attr (found
));
4857 /* For each of the methods in T, propagate a class-level tm attribute. */
4860 set_method_tm_attributes (tree t
)
4862 tree class_tm_attr
, fndecl
;
4864 /* Don't bother collecting tm attributes if transactional memory
4865 support is not enabled. */
4869 /* Process virtual methods first, as they inherit directly from the
4870 base virtual function and also require validation of new attributes. */
4871 if (TYPE_CONTAINS_VPTR_P (t
))
4874 for (vchain
= BINFO_VIRTUALS (TYPE_BINFO (t
)); vchain
;
4875 vchain
= TREE_CHAIN (vchain
))
4877 fndecl
= BV_FN (vchain
);
4878 if (DECL_THUNK_P (fndecl
))
4879 fndecl
= THUNK_TARGET (fndecl
);
4880 set_one_vmethod_tm_attributes (t
, fndecl
);
4884 /* If the class doesn't have an attribute, nothing more to do. */
4885 class_tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (t
));
4886 if (class_tm_attr
== NULL
)
4889 /* Any method that does not yet have a tm attribute inherits
4890 the one from the class. */
4891 for (fndecl
= TYPE_METHODS (t
); fndecl
; fndecl
= TREE_CHAIN (fndecl
))
4893 if (!find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
4894 apply_tm_attr (fndecl
, class_tm_attr
);
4898 /* Returns true iff class T has a user-defined constructor other than
4899 the default constructor. */
4902 type_has_user_nondefault_constructor (tree t
)
4906 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4909 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4911 tree fn
= OVL_CURRENT (fns
);
4912 if (!DECL_ARTIFICIAL (fn
)
4913 && (TREE_CODE (fn
) == TEMPLATE_DECL
4914 || (skip_artificial_parms_for (fn
, DECL_ARGUMENTS (fn
))
4922 /* Returns the defaulted constructor if T has one. Otherwise, returns
4926 in_class_defaulted_default_constructor (tree t
)
4930 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4933 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4935 tree fn
= OVL_CURRENT (fns
);
4937 if (DECL_DEFAULTED_IN_CLASS_P (fn
))
4939 args
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
4940 while (args
&& TREE_PURPOSE (args
))
4941 args
= TREE_CHAIN (args
);
4942 if (!args
|| args
== void_list_node
)
4950 /* Returns true iff FN is a user-provided function, i.e. user-declared
4951 and not defaulted at its first declaration; or explicit, private,
4952 protected, or non-const. */
4955 user_provided_p (tree fn
)
4957 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4960 return (!DECL_ARTIFICIAL (fn
)
4961 && !(DECL_INITIALIZED_IN_CLASS_P (fn
)
4962 && (DECL_DEFAULTED_FN (fn
) || DECL_DELETED_FN (fn
))));
4965 /* Returns true iff class T has a user-provided constructor. */
4968 type_has_user_provided_constructor (tree t
)
4972 if (!CLASS_TYPE_P (t
))
4975 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4978 /* This can happen in error cases; avoid crashing. */
4979 if (!CLASSTYPE_METHOD_VEC (t
))
4982 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4983 if (user_provided_p (OVL_CURRENT (fns
)))
4989 /* Returns true iff class T has a non-user-provided (i.e. implicitly
4990 declared or explicitly defaulted in the class body) default
4994 type_has_non_user_provided_default_constructor (tree t
)
4998 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (t
))
5000 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t
))
5003 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5005 tree fn
= OVL_CURRENT (fns
);
5006 if (TREE_CODE (fn
) == FUNCTION_DECL
5007 && !user_provided_p (fn
)
5008 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)))
5015 /* TYPE is being used as a virtual base, and has a non-trivial move
5016 assignment. Return true if this is due to there being a user-provided
5017 move assignment in TYPE or one of its subobjects; if there isn't, then
5018 multiple move assignment can't cause any harm. */
5021 vbase_has_user_provided_move_assign (tree type
)
5023 /* Does the type itself have a user-provided move assignment operator? */
5025 = lookup_fnfields_slot_nolazy (type
, ansi_assopname (NOP_EXPR
));
5026 fns
; fns
= OVL_NEXT (fns
))
5028 tree fn
= OVL_CURRENT (fns
);
5029 if (move_fn_p (fn
) && user_provided_p (fn
))
5033 /* Do any of its bases? */
5034 tree binfo
= TYPE_BINFO (type
);
5036 for (int i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5037 if (vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo
)))
5040 /* Or non-static data members? */
5041 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5043 if (TREE_CODE (field
) == FIELD_DECL
5044 && CLASS_TYPE_P (TREE_TYPE (field
))
5045 && vbase_has_user_provided_move_assign (TREE_TYPE (field
)))
5053 /* If default-initialization leaves part of TYPE uninitialized, returns
5054 a DECL for the field or TYPE itself (DR 253). */
5057 default_init_uninitialized_part (tree type
)
5062 type
= strip_array_types (type
);
5063 if (!CLASS_TYPE_P (type
))
5065 if (!type_has_non_user_provided_default_constructor (type
))
5067 for (binfo
= TYPE_BINFO (type
), i
= 0;
5068 BINFO_BASE_ITERATE (binfo
, i
, t
); ++i
)
5070 r
= default_init_uninitialized_part (BINFO_TYPE (t
));
5074 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
5075 if (TREE_CODE (t
) == FIELD_DECL
5076 && !DECL_ARTIFICIAL (t
)
5077 && !DECL_INITIAL (t
))
5079 r
= default_init_uninitialized_part (TREE_TYPE (t
));
5081 return DECL_P (r
) ? r
: t
;
5087 /* Returns true iff for class T, a trivial synthesized default constructor
5088 would be constexpr. */
5091 trivial_default_constructor_is_constexpr (tree t
)
5093 /* A defaulted trivial default constructor is constexpr
5094 if there is nothing to initialize. */
5095 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (t
));
5096 return is_really_empty_class (t
);
5099 /* Returns true iff class T has a constexpr default constructor. */
5102 type_has_constexpr_default_constructor (tree t
)
5106 if (!CLASS_TYPE_P (t
))
5108 /* The caller should have stripped an enclosing array. */
5109 gcc_assert (TREE_CODE (t
) != ARRAY_TYPE
);
5112 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t
))
5114 if (!TYPE_HAS_COMPLEX_DFLT (t
))
5115 return trivial_default_constructor_is_constexpr (t
);
5116 /* Non-trivial, we need to check subobject constructors. */
5117 lazily_declare_fn (sfk_constructor
, t
);
5119 fns
= locate_ctor (t
);
5120 return (fns
&& DECL_DECLARED_CONSTEXPR_P (fns
));
5123 /* Returns true iff class TYPE has a virtual destructor. */
5126 type_has_virtual_destructor (tree type
)
5130 if (!CLASS_TYPE_P (type
))
5133 gcc_assert (COMPLETE_TYPE_P (type
));
5134 dtor
= CLASSTYPE_DESTRUCTORS (type
);
5135 return (dtor
&& DECL_VIRTUAL_P (dtor
));
5138 /* Returns true iff class T has a move constructor. */
5141 type_has_move_constructor (tree t
)
5145 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
5147 gcc_assert (COMPLETE_TYPE_P (t
));
5148 lazily_declare_fn (sfk_move_constructor
, t
);
5151 if (!CLASSTYPE_METHOD_VEC (t
))
5154 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5155 if (move_fn_p (OVL_CURRENT (fns
)))
5161 /* Returns true iff class T has a move assignment operator. */
5164 type_has_move_assign (tree t
)
5168 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
5170 gcc_assert (COMPLETE_TYPE_P (t
));
5171 lazily_declare_fn (sfk_move_assignment
, t
);
5174 for (fns
= lookup_fnfields_slot_nolazy (t
, ansi_assopname (NOP_EXPR
));
5175 fns
; fns
= OVL_NEXT (fns
))
5176 if (move_fn_p (OVL_CURRENT (fns
)))
5182 /* Returns true iff class T has a move constructor that was explicitly
5183 declared in the class body. Note that this is different from
5184 "user-provided", which doesn't include functions that are defaulted in
5188 type_has_user_declared_move_constructor (tree t
)
5192 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
5195 if (!CLASSTYPE_METHOD_VEC (t
))
5198 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5200 tree fn
= OVL_CURRENT (fns
);
5201 if (move_fn_p (fn
) && !DECL_ARTIFICIAL (fn
))
5208 /* Returns true iff class T has a move assignment operator that was
5209 explicitly declared in the class body. */
5212 type_has_user_declared_move_assign (tree t
)
5216 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
5219 for (fns
= lookup_fnfields_slot_nolazy (t
, ansi_assopname (NOP_EXPR
));
5220 fns
; fns
= OVL_NEXT (fns
))
5222 tree fn
= OVL_CURRENT (fns
);
5223 if (move_fn_p (fn
) && !DECL_ARTIFICIAL (fn
))
5230 /* Nonzero if we need to build up a constructor call when initializing an
5231 object of this class, either because it has a user-declared constructor
5232 or because it doesn't have a default constructor (so we need to give an
5233 error if no initializer is provided). Use TYPE_NEEDS_CONSTRUCTING when
5234 what you care about is whether or not an object can be produced by a
5235 constructor (e.g. so we don't set TREE_READONLY on const variables of
5236 such type); use this function when what you care about is whether or not
5237 to try to call a constructor to create an object. The latter case is
5238 the former plus some cases of constructors that cannot be called. */
5241 type_build_ctor_call (tree t
)
5244 if (TYPE_NEEDS_CONSTRUCTING (t
))
5246 inner
= strip_array_types (t
);
5247 if (!CLASS_TYPE_P (inner
) || ANON_AGGR_TYPE_P (inner
))
5249 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (inner
))
5251 if (cxx_dialect
< cxx11
)
5253 /* A user-declared constructor might be private, and a constructor might
5254 be trivial but deleted. */
5255 for (tree fns
= lookup_fnfields_slot (inner
, complete_ctor_identifier
);
5256 fns
; fns
= OVL_NEXT (fns
))
5258 tree fn
= OVL_CURRENT (fns
);
5259 if (!DECL_ARTIFICIAL (fn
)
5260 || DECL_DELETED_FN (fn
))
5266 /* Like type_build_ctor_call, but for destructors. */
5269 type_build_dtor_call (tree t
)
5272 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5274 inner
= strip_array_types (t
);
5275 if (!CLASS_TYPE_P (inner
) || ANON_AGGR_TYPE_P (inner
)
5276 || !COMPLETE_TYPE_P (inner
))
5278 if (cxx_dialect
< cxx11
)
5280 /* A user-declared destructor might be private, and a destructor might
5281 be trivial but deleted. */
5282 for (tree fns
= lookup_fnfields_slot (inner
, complete_dtor_identifier
);
5283 fns
; fns
= OVL_NEXT (fns
))
5285 tree fn
= OVL_CURRENT (fns
);
5286 if (!DECL_ARTIFICIAL (fn
)
5287 || DECL_DELETED_FN (fn
))
5293 /* Remove all zero-width bit-fields from T. */
5296 remove_zero_width_bit_fields (tree t
)
5300 fieldsp
= &TYPE_FIELDS (t
);
5303 if (TREE_CODE (*fieldsp
) == FIELD_DECL
5304 && DECL_C_BIT_FIELD (*fieldsp
)
5305 /* We should not be confused by the fact that grokbitfield
5306 temporarily sets the width of the bit field into
5307 DECL_INITIAL (*fieldsp).
5308 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
5310 && integer_zerop (DECL_SIZE (*fieldsp
)))
5311 *fieldsp
= DECL_CHAIN (*fieldsp
);
5313 fieldsp
= &DECL_CHAIN (*fieldsp
);
5317 /* Returns TRUE iff we need a cookie when dynamically allocating an
5318 array whose elements have the indicated class TYPE. */
5321 type_requires_array_cookie (tree type
)
5324 bool has_two_argument_delete_p
= false;
5326 gcc_assert (CLASS_TYPE_P (type
));
5328 /* If there's a non-trivial destructor, we need a cookie. In order
5329 to iterate through the array calling the destructor for each
5330 element, we'll have to know how many elements there are. */
5331 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
5334 /* If the usual deallocation function is a two-argument whose second
5335 argument is of type `size_t', then we have to pass the size of
5336 the array to the deallocation function, so we will need to store
5338 fns
= lookup_fnfields (TYPE_BINFO (type
),
5339 ansi_opname (VEC_DELETE_EXPR
),
5341 /* If there are no `operator []' members, or the lookup is
5342 ambiguous, then we don't need a cookie. */
5343 if (!fns
|| fns
== error_mark_node
)
5345 /* Loop through all of the functions. */
5346 for (fns
= BASELINK_FUNCTIONS (fns
); fns
; fns
= OVL_NEXT (fns
))
5351 /* Select the current function. */
5352 fn
= OVL_CURRENT (fns
);
5353 /* See if this function is a one-argument delete function. If
5354 it is, then it will be the usual deallocation function. */
5355 second_parm
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn
)));
5356 if (second_parm
== void_list_node
)
5358 /* Do not consider this function if its second argument is an
5362 /* Otherwise, if we have a two-argument function and the second
5363 argument is `size_t', it will be the usual deallocation
5364 function -- unless there is one-argument function, too. */
5365 if (TREE_CHAIN (second_parm
) == void_list_node
5366 && same_type_p (TREE_VALUE (second_parm
), size_type_node
))
5367 has_two_argument_delete_p
= true;
5370 return has_two_argument_delete_p
;
5373 /* Finish computing the `literal type' property of class type T.
5375 At this point, we have already processed base classes and
5376 non-static data members. We need to check whether the copy
5377 constructor is trivial, the destructor is trivial, and there
5378 is a trivial default constructor or at least one constexpr
5379 constructor other than the copy constructor. */
5382 finalize_literal_type_property (tree t
)
5386 if (cxx_dialect
< cxx11
5387 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5388 CLASSTYPE_LITERAL_P (t
) = false;
5389 else if (CLASSTYPE_LITERAL_P (t
) && !TYPE_HAS_TRIVIAL_DFLT (t
)
5390 && CLASSTYPE_NON_AGGREGATE (t
)
5391 && !TYPE_HAS_CONSTEXPR_CTOR (t
))
5392 CLASSTYPE_LITERAL_P (t
) = false;
5394 if (!CLASSTYPE_LITERAL_P (t
))
5395 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5396 if (DECL_DECLARED_CONSTEXPR_P (fn
)
5397 && TREE_CODE (fn
) != TEMPLATE_DECL
5398 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
5399 && !DECL_CONSTRUCTOR_P (fn
))
5401 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
5402 if (!DECL_GENERATED_P (fn
))
5404 error ("enclosing class of constexpr non-static member "
5405 "function %q+#D is not a literal type", fn
);
5406 explain_non_literal_class (t
);
5411 /* T is a non-literal type used in a context which requires a constant
5412 expression. Explain why it isn't literal. */
5415 explain_non_literal_class (tree t
)
5417 static hash_set
<tree
> *diagnosed
;
5419 if (!CLASS_TYPE_P (t
))
5421 t
= TYPE_MAIN_VARIANT (t
);
5423 if (diagnosed
== NULL
)
5424 diagnosed
= new hash_set
<tree
>;
5425 if (diagnosed
->add (t
))
5426 /* Already explained. */
5429 inform (0, "%q+T is not literal because:", t
);
5430 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5431 inform (0, " %q+T has a non-trivial destructor", t
);
5432 else if (CLASSTYPE_NON_AGGREGATE (t
)
5433 && !TYPE_HAS_TRIVIAL_DFLT (t
)
5434 && !TYPE_HAS_CONSTEXPR_CTOR (t
))
5436 inform (0, " %q+T is not an aggregate, does not have a trivial "
5437 "default constructor, and has no constexpr constructor that "
5438 "is not a copy or move constructor", t
);
5439 if (type_has_non_user_provided_default_constructor (t
))
5441 /* Note that we can't simply call locate_ctor because when the
5442 constructor is deleted it just returns NULL_TREE. */
5444 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5446 tree fn
= OVL_CURRENT (fns
);
5447 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
5449 parms
= skip_artificial_parms_for (fn
, parms
);
5451 if (sufficient_parms_p (parms
))
5453 if (DECL_DELETED_FN (fn
))
5454 maybe_explain_implicit_delete (fn
);
5456 explain_invalid_constexpr_fn (fn
);
5464 tree binfo
, base_binfo
, field
; int i
;
5465 for (binfo
= TYPE_BINFO (t
), i
= 0;
5466 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5468 tree basetype
= TREE_TYPE (base_binfo
);
5469 if (!CLASSTYPE_LITERAL_P (basetype
))
5471 inform (0, " base class %qT of %q+T is non-literal",
5473 explain_non_literal_class (basetype
);
5477 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
5480 if (TREE_CODE (field
) != FIELD_DECL
)
5482 ftype
= TREE_TYPE (field
);
5483 if (!literal_type_p (ftype
))
5485 inform (0, " non-static data member %q+D has "
5486 "non-literal type", field
);
5487 if (CLASS_TYPE_P (ftype
))
5488 explain_non_literal_class (ftype
);
5490 if (CP_TYPE_VOLATILE_P (ftype
))
5491 inform (0, " non-static data member %q+D has "
5492 "volatile type", field
);
5497 /* Check the validity of the bases and members declared in T. Add any
5498 implicitly-generated functions (like copy-constructors and
5499 assignment operators). Compute various flag bits (like
5500 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
5501 level: i.e., independently of the ABI in use. */
5504 check_bases_and_members (tree t
)
5506 /* Nonzero if the implicitly generated copy constructor should take
5507 a non-const reference argument. */
5508 int cant_have_const_ctor
;
5509 /* Nonzero if the implicitly generated assignment operator
5510 should take a non-const reference argument. */
5511 int no_const_asn_ref
;
5513 bool saved_complex_asn_ref
;
5514 bool saved_nontrivial_dtor
;
5517 /* By default, we use const reference arguments and generate default
5519 cant_have_const_ctor
= 0;
5520 no_const_asn_ref
= 0;
5522 /* Check all the base-classes. */
5523 check_bases (t
, &cant_have_const_ctor
,
5526 /* Deduce noexcept on destructors. This needs to happen after we've set
5527 triviality flags appropriately for our bases. */
5528 if (cxx_dialect
>= cxx11
)
5529 deduce_noexcept_on_destructors (t
);
5531 /* Check all the method declarations. */
5534 /* Save the initial values of these flags which only indicate whether
5535 or not the class has user-provided functions. As we analyze the
5536 bases and members we can set these flags for other reasons. */
5537 saved_complex_asn_ref
= TYPE_HAS_COMPLEX_COPY_ASSIGN (t
);
5538 saved_nontrivial_dtor
= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
5540 /* Check all the data member declarations. We cannot call
5541 check_field_decls until we have called check_bases check_methods,
5542 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5543 being set appropriately. */
5544 check_field_decls (t
, &access_decls
,
5545 &cant_have_const_ctor
,
5548 /* A nearly-empty class has to be vptr-containing; a nearly empty
5549 class contains just a vptr. */
5550 if (!TYPE_CONTAINS_VPTR_P (t
))
5551 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
5553 /* Do some bookkeeping that will guide the generation of implicitly
5554 declared member functions. */
5555 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5556 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5557 /* We need to call a constructor for this class if it has a
5558 user-provided constructor, or if the default constructor is going
5559 to initialize the vptr. (This is not an if-and-only-if;
5560 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
5561 themselves need constructing.) */
5562 TYPE_NEEDS_CONSTRUCTING (t
)
5563 |= (type_has_user_provided_constructor (t
) || TYPE_CONTAINS_VPTR_P (t
));
5566 An aggregate is an array or a class with no user-provided
5567 constructors ... and no virtual functions.
5569 Again, other conditions for being an aggregate are checked
5571 CLASSTYPE_NON_AGGREGATE (t
)
5572 |= (type_has_user_provided_constructor (t
) || TYPE_POLYMORPHIC_P (t
));
5573 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
5574 retain the old definition internally for ABI reasons. */
5575 CLASSTYPE_NON_LAYOUT_POD_P (t
)
5576 |= (CLASSTYPE_NON_AGGREGATE (t
)
5577 || saved_nontrivial_dtor
|| saved_complex_asn_ref
);
5578 CLASSTYPE_NON_STD_LAYOUT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5579 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5580 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5581 TYPE_HAS_COMPLEX_DFLT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5583 /* If the only explicitly declared default constructor is user-provided,
5584 set TYPE_HAS_COMPLEX_DFLT. */
5585 if (!TYPE_HAS_COMPLEX_DFLT (t
)
5586 && TYPE_HAS_DEFAULT_CONSTRUCTOR (t
)
5587 && !type_has_non_user_provided_default_constructor (t
))
5588 TYPE_HAS_COMPLEX_DFLT (t
) = true;
5590 /* Warn if a public base of a polymorphic type has an accessible
5591 non-virtual destructor. It is only now that we know the class is
5592 polymorphic. Although a polymorphic base will have a already
5593 been diagnosed during its definition, we warn on use too. */
5594 if (TYPE_POLYMORPHIC_P (t
) && warn_nonvdtor
)
5596 tree binfo
= TYPE_BINFO (t
);
5597 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
5601 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5603 tree basetype
= TREE_TYPE (base_binfo
);
5605 if ((*accesses
)[i
] == access_public_node
5606 && (TYPE_POLYMORPHIC_P (basetype
) || warn_ecpp
)
5607 && accessible_nvdtor_p (basetype
))
5608 warning (OPT_Wnon_virtual_dtor
,
5609 "base class %q#T has accessible non-virtual destructor",
5614 /* If the class has no user-declared constructor, but does have
5615 non-static const or reference data members that can never be
5616 initialized, issue a warning. */
5617 if (warn_uninitialized
5618 /* Classes with user-declared constructors are presumed to
5619 initialize these members. */
5620 && !TYPE_HAS_USER_CONSTRUCTOR (t
)
5621 /* Aggregates can be initialized with brace-enclosed
5623 && CLASSTYPE_NON_AGGREGATE (t
))
5627 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
5631 if (TREE_CODE (field
) != FIELD_DECL
5632 || DECL_INITIAL (field
) != NULL_TREE
)
5635 type
= TREE_TYPE (field
);
5636 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5637 warning (OPT_Wuninitialized
, "non-static reference %q+#D "
5638 "in class without a constructor", field
);
5639 else if (CP_TYPE_CONST_P (type
)
5640 && (!CLASS_TYPE_P (type
)
5641 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
5642 warning (OPT_Wuninitialized
, "non-static const member %q+#D "
5643 "in class without a constructor", field
);
5647 /* Synthesize any needed methods. */
5648 add_implicitly_declared_members (t
, &access_decls
,
5649 cant_have_const_ctor
,
5652 /* Check defaulted declarations here so we have cant_have_const_ctor
5653 and don't need to worry about clones. */
5654 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5655 if (!DECL_ARTIFICIAL (fn
) && DECL_DEFAULTED_IN_CLASS_P (fn
))
5657 int copy
= copy_fn_p (fn
);
5661 = (DECL_CONSTRUCTOR_P (fn
) ? !cant_have_const_ctor
5662 : !no_const_asn_ref
);
5663 bool fn_const_p
= (copy
== 2);
5665 if (fn_const_p
&& !imp_const_p
)
5666 /* If the function is defaulted outside the class, we just
5667 give the synthesis error. */
5668 error ("%q+D declared to take const reference, but implicit "
5669 "declaration would take non-const", fn
);
5671 defaulted_late_check (fn
);
5674 if (LAMBDA_TYPE_P (t
))
5676 /* "This class type is not an aggregate." */
5677 CLASSTYPE_NON_AGGREGATE (t
) = 1;
5680 /* Compute the 'literal type' property before we
5681 do anything with non-static member functions. */
5682 finalize_literal_type_property (t
);
5684 /* Create the in-charge and not-in-charge variants of constructors
5686 clone_constructors_and_destructors (t
);
5688 /* Process the using-declarations. */
5689 for (; access_decls
; access_decls
= TREE_CHAIN (access_decls
))
5690 handle_using_decl (TREE_VALUE (access_decls
), t
);
5692 /* Build and sort the CLASSTYPE_METHOD_VEC. */
5693 finish_struct_methods (t
);
5695 /* Figure out whether or not we will need a cookie when dynamically
5696 allocating an array of this type. */
5697 TYPE_LANG_SPECIFIC (t
)->u
.c
.vec_new_uses_cookie
5698 = type_requires_array_cookie (t
);
5701 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
5702 accordingly. If a new vfield was created (because T doesn't have a
5703 primary base class), then the newly created field is returned. It
5704 is not added to the TYPE_FIELDS list; it is the caller's
5705 responsibility to do that. Accumulate declared virtual functions
5709 create_vtable_ptr (tree t
, tree
* virtuals_p
)
5713 /* Collect the virtual functions declared in T. */
5714 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5715 if (TREE_CODE (fn
) == FUNCTION_DECL
5716 && DECL_VINDEX (fn
) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
)
5717 && TREE_CODE (DECL_VINDEX (fn
)) != INTEGER_CST
)
5719 tree new_virtual
= make_node (TREE_LIST
);
5721 BV_FN (new_virtual
) = fn
;
5722 BV_DELTA (new_virtual
) = integer_zero_node
;
5723 BV_VCALL_INDEX (new_virtual
) = NULL_TREE
;
5725 TREE_CHAIN (new_virtual
) = *virtuals_p
;
5726 *virtuals_p
= new_virtual
;
5729 /* If we couldn't find an appropriate base class, create a new field
5730 here. Even if there weren't any new virtual functions, we might need a
5731 new virtual function table if we're supposed to include vptrs in
5732 all classes that need them. */
5733 if (!TYPE_VFIELD (t
) && (*virtuals_p
|| TYPE_CONTAINS_VPTR_P (t
)))
5735 /* We build this decl with vtbl_ptr_type_node, which is a
5736 `vtable_entry_type*'. It might seem more precise to use
5737 `vtable_entry_type (*)[N]' where N is the number of virtual
5738 functions. However, that would require the vtable pointer in
5739 base classes to have a different type than the vtable pointer
5740 in derived classes. We could make that happen, but that
5741 still wouldn't solve all the problems. In particular, the
5742 type-based alias analysis code would decide that assignments
5743 to the base class vtable pointer can't alias assignments to
5744 the derived class vtable pointer, since they have different
5745 types. Thus, in a derived class destructor, where the base
5746 class constructor was inlined, we could generate bad code for
5747 setting up the vtable pointer.
5749 Therefore, we use one type for all vtable pointers. We still
5750 use a type-correct type; it's just doesn't indicate the array
5751 bounds. That's better than using `void*' or some such; it's
5752 cleaner, and it let's the alias analysis code know that these
5753 stores cannot alias stores to void*! */
5756 field
= build_decl (input_location
,
5757 FIELD_DECL
, get_vfield_name (t
), vtbl_ptr_type_node
);
5758 DECL_VIRTUAL_P (field
) = 1;
5759 DECL_ARTIFICIAL (field
) = 1;
5760 DECL_FIELD_CONTEXT (field
) = t
;
5761 DECL_FCONTEXT (field
) = t
;
5762 if (TYPE_PACKED (t
))
5763 DECL_PACKED (field
) = 1;
5765 TYPE_VFIELD (t
) = field
;
5767 /* This class is non-empty. */
5768 CLASSTYPE_EMPTY_P (t
) = 0;
5776 /* Add OFFSET to all base types of BINFO which is a base in the
5777 hierarchy dominated by T.
5779 OFFSET, which is a type offset, is number of bytes. */
5782 propagate_binfo_offsets (tree binfo
, tree offset
)
5788 /* Update BINFO's offset. */
5789 BINFO_OFFSET (binfo
)
5790 = convert (sizetype
,
5791 size_binop (PLUS_EXPR
,
5792 convert (ssizetype
, BINFO_OFFSET (binfo
)),
5795 /* Find the primary base class. */
5796 primary_binfo
= get_primary_binfo (binfo
);
5798 if (primary_binfo
&& BINFO_INHERITANCE_CHAIN (primary_binfo
) == binfo
)
5799 propagate_binfo_offsets (primary_binfo
, offset
);
5801 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
5803 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5805 /* Don't do the primary base twice. */
5806 if (base_binfo
== primary_binfo
)
5809 if (BINFO_VIRTUAL_P (base_binfo
))
5812 propagate_binfo_offsets (base_binfo
, offset
);
5816 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
5817 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
5818 empty subobjects of T. */
5821 layout_virtual_bases (record_layout_info rli
, splay_tree offsets
)
5827 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) == 0)
5830 /* Find the last field. The artificial fields created for virtual
5831 bases will go after the last extant field to date. */
5832 next_field
= &TYPE_FIELDS (t
);
5834 next_field
= &DECL_CHAIN (*next_field
);
5836 /* Go through the virtual bases, allocating space for each virtual
5837 base that is not already a primary base class. These are
5838 allocated in inheritance graph order. */
5839 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
5841 if (!BINFO_VIRTUAL_P (vbase
))
5844 if (!BINFO_PRIMARY_P (vbase
))
5846 /* This virtual base is not a primary base of any class in the
5847 hierarchy, so we have to add space for it. */
5848 next_field
= build_base_field (rli
, vbase
,
5849 offsets
, next_field
);
5854 /* Returns the offset of the byte just past the end of the base class
5858 end_of_base (tree binfo
)
5862 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo
)))
5863 size
= TYPE_SIZE_UNIT (char_type_node
);
5864 else if (is_empty_class (BINFO_TYPE (binfo
)))
5865 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5866 allocate some space for it. It cannot have virtual bases, so
5867 TYPE_SIZE_UNIT is fine. */
5868 size
= TYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
5870 size
= CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
5872 return size_binop (PLUS_EXPR
, BINFO_OFFSET (binfo
), size
);
5875 /* Returns the offset of the byte just past the end of the base class
5876 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
5877 only non-virtual bases are included. */
5880 end_of_class (tree t
, int include_virtuals_p
)
5882 tree result
= size_zero_node
;
5883 vec
<tree
, va_gc
> *vbases
;
5889 for (binfo
= TYPE_BINFO (t
), i
= 0;
5890 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5892 if (!include_virtuals_p
5893 && BINFO_VIRTUAL_P (base_binfo
)
5894 && (!BINFO_PRIMARY_P (base_binfo
)
5895 || BINFO_INHERITANCE_CHAIN (base_binfo
) != TYPE_BINFO (t
)))
5898 offset
= end_of_base (base_binfo
);
5899 if (tree_int_cst_lt (result
, offset
))
5903 if (include_virtuals_p
)
5904 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
5905 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
5907 offset
= end_of_base (base_binfo
);
5908 if (tree_int_cst_lt (result
, offset
))
5915 /* Warn about bases of T that are inaccessible because they are
5916 ambiguous. For example:
5919 struct T : public S {};
5920 struct U : public S, public T {};
5922 Here, `(S*) new U' is not allowed because there are two `S'
5926 warn_about_ambiguous_bases (tree t
)
5929 vec
<tree
, va_gc
> *vbases
;
5934 /* If there are no repeated bases, nothing can be ambiguous. */
5935 if (!CLASSTYPE_REPEATED_BASE_P (t
))
5938 /* Check direct bases. */
5939 for (binfo
= TYPE_BINFO (t
), i
= 0;
5940 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5942 basetype
= BINFO_TYPE (base_binfo
);
5944 if (!uniquely_derived_from_p (basetype
, t
))
5945 warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
5949 /* Check for ambiguous virtual bases. */
5951 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
5952 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
5954 basetype
= BINFO_TYPE (binfo
);
5956 if (!uniquely_derived_from_p (basetype
, t
))
5957 warning (OPT_Wextra
, "virtual base %qT inaccessible in %qT due "
5958 "to ambiguity", basetype
, t
);
5962 /* Compare two INTEGER_CSTs K1 and K2. */
5965 splay_tree_compare_integer_csts (splay_tree_key k1
, splay_tree_key k2
)
5967 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5970 /* Increase the size indicated in RLI to account for empty classes
5971 that are "off the end" of the class. */
5974 include_empty_classes (record_layout_info rli
)
5979 /* It might be the case that we grew the class to allocate a
5980 zero-sized base class. That won't be reflected in RLI, yet,
5981 because we are willing to overlay multiple bases at the same
5982 offset. However, now we need to make sure that RLI is big enough
5983 to reflect the entire class. */
5984 eoc
= end_of_class (rli
->t
,
5985 CLASSTYPE_AS_BASE (rli
->t
) != NULL_TREE
);
5986 rli_size
= rli_size_unit_so_far (rli
);
5987 if (TREE_CODE (rli_size
) == INTEGER_CST
5988 && tree_int_cst_lt (rli_size
, eoc
))
5990 /* The size should have been rounded to a whole byte. */
5991 gcc_assert (tree_int_cst_equal
5992 (rli
->bitpos
, round_down (rli
->bitpos
, BITS_PER_UNIT
)));
5994 = size_binop (PLUS_EXPR
,
5996 size_binop (MULT_EXPR
,
5997 convert (bitsizetype
,
5998 size_binop (MINUS_EXPR
,
6000 bitsize_int (BITS_PER_UNIT
)));
6001 normalize_rli (rli
);
6005 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
6006 BINFO_OFFSETs for all of the base-classes. Position the vtable
6007 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
6010 layout_class_type (tree t
, tree
*virtuals_p
)
6012 tree non_static_data_members
;
6015 record_layout_info rli
;
6016 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
6017 types that appear at that offset. */
6018 splay_tree empty_base_offsets
;
6019 /* True if the last field laid out was a bit-field. */
6020 bool last_field_was_bitfield
= false;
6021 /* The location at which the next field should be inserted. */
6023 /* T, as a base class. */
6026 /* Keep track of the first non-static data member. */
6027 non_static_data_members
= TYPE_FIELDS (t
);
6029 /* Start laying out the record. */
6030 rli
= start_record_layout (t
);
6032 /* Mark all the primary bases in the hierarchy. */
6033 determine_primary_bases (t
);
6035 /* Create a pointer to our virtual function table. */
6036 vptr
= create_vtable_ptr (t
, virtuals_p
);
6038 /* The vptr is always the first thing in the class. */
6041 DECL_CHAIN (vptr
) = TYPE_FIELDS (t
);
6042 TYPE_FIELDS (t
) = vptr
;
6043 next_field
= &DECL_CHAIN (vptr
);
6044 place_field (rli
, vptr
);
6047 next_field
= &TYPE_FIELDS (t
);
6049 /* Build FIELD_DECLs for all of the non-virtual base-types. */
6050 empty_base_offsets
= splay_tree_new (splay_tree_compare_integer_csts
,
6052 build_base_fields (rli
, empty_base_offsets
, next_field
);
6054 /* Layout the non-static data members. */
6055 for (field
= non_static_data_members
; field
; field
= DECL_CHAIN (field
))
6060 /* We still pass things that aren't non-static data members to
6061 the back end, in case it wants to do something with them. */
6062 if (TREE_CODE (field
) != FIELD_DECL
)
6064 place_field (rli
, field
);
6065 /* If the static data member has incomplete type, keep track
6066 of it so that it can be completed later. (The handling
6067 of pending statics in finish_record_layout is
6068 insufficient; consider:
6071 struct S2 { static S1 s1; };
6073 At this point, finish_record_layout will be called, but
6074 S1 is still incomplete.) */
6077 maybe_register_incomplete_var (field
);
6078 /* The visibility of static data members is determined
6079 at their point of declaration, not their point of
6081 determine_visibility (field
);
6086 type
= TREE_TYPE (field
);
6087 if (type
== error_mark_node
)
6090 padding
= NULL_TREE
;
6092 /* If this field is a bit-field whose width is greater than its
6093 type, then there are some special rules for allocating
6095 if (DECL_C_BIT_FIELD (field
)
6096 && tree_int_cst_lt (TYPE_SIZE (type
), DECL_SIZE (field
)))
6100 bool was_unnamed_p
= false;
6101 /* We must allocate the bits as if suitably aligned for the
6102 longest integer type that fits in this many bits. type
6103 of the field. Then, we are supposed to use the left over
6104 bits as additional padding. */
6105 for (itk
= itk_char
; itk
!= itk_none
; ++itk
)
6106 if (integer_types
[itk
] != NULL_TREE
6107 && (tree_int_cst_lt (size_int (MAX_FIXED_MODE_SIZE
),
6108 TYPE_SIZE (integer_types
[itk
]))
6109 || tree_int_cst_lt (DECL_SIZE (field
),
6110 TYPE_SIZE (integer_types
[itk
]))))
6113 /* ITK now indicates a type that is too large for the
6114 field. We have to back up by one to find the largest
6119 integer_type
= integer_types
[itk
];
6120 } while (itk
> 0 && integer_type
== NULL_TREE
);
6122 /* Figure out how much additional padding is required. */
6123 if (tree_int_cst_lt (TYPE_SIZE (integer_type
), DECL_SIZE (field
)))
6125 if (TREE_CODE (t
) == UNION_TYPE
)
6126 /* In a union, the padding field must have the full width
6127 of the bit-field; all fields start at offset zero. */
6128 padding
= DECL_SIZE (field
);
6130 padding
= size_binop (MINUS_EXPR
, DECL_SIZE (field
),
6131 TYPE_SIZE (integer_type
));
6133 #ifdef PCC_BITFIELD_TYPE_MATTERS
6134 /* An unnamed bitfield does not normally affect the
6135 alignment of the containing class on a target where
6136 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
6137 make any exceptions for unnamed bitfields when the
6138 bitfields are longer than their types. Therefore, we
6139 temporarily give the field a name. */
6140 if (PCC_BITFIELD_TYPE_MATTERS
&& !DECL_NAME (field
))
6142 was_unnamed_p
= true;
6143 DECL_NAME (field
) = make_anon_name ();
6146 DECL_SIZE (field
) = TYPE_SIZE (integer_type
);
6147 DECL_ALIGN (field
) = TYPE_ALIGN (integer_type
);
6148 DECL_USER_ALIGN (field
) = TYPE_USER_ALIGN (integer_type
);
6149 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
6150 empty_base_offsets
);
6152 DECL_NAME (field
) = NULL_TREE
;
6153 /* Now that layout has been performed, set the size of the
6154 field to the size of its declared type; the rest of the
6155 field is effectively invisible. */
6156 DECL_SIZE (field
) = TYPE_SIZE (type
);
6157 /* We must also reset the DECL_MODE of the field. */
6158 DECL_MODE (field
) = TYPE_MODE (type
);
6161 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
6162 empty_base_offsets
);
6164 /* Remember the location of any empty classes in FIELD. */
6165 record_subobject_offsets (TREE_TYPE (field
),
6166 byte_position(field
),
6168 /*is_data_member=*/true);
6170 /* If a bit-field does not immediately follow another bit-field,
6171 and yet it starts in the middle of a byte, we have failed to
6172 comply with the ABI. */
6174 && DECL_C_BIT_FIELD (field
)
6175 /* The TREE_NO_WARNING flag gets set by Objective-C when
6176 laying out an Objective-C class. The ObjC ABI differs
6177 from the C++ ABI, and so we do not want a warning
6179 && !TREE_NO_WARNING (field
)
6180 && !last_field_was_bitfield
6181 && !integer_zerop (size_binop (TRUNC_MOD_EXPR
,
6182 DECL_FIELD_BIT_OFFSET (field
),
6183 bitsize_unit_node
)))
6184 warning (OPT_Wabi
, "offset of %q+D is not ABI-compliant and may "
6185 "change in a future version of GCC", field
);
6187 /* The middle end uses the type of expressions to determine the
6188 possible range of expression values. In order to optimize
6189 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
6190 must be made aware of the width of "i", via its type.
6192 Because C++ does not have integer types of arbitrary width,
6193 we must (for the purposes of the front end) convert from the
6194 type assigned here to the declared type of the bitfield
6195 whenever a bitfield expression is used as an rvalue.
6196 Similarly, when assigning a value to a bitfield, the value
6197 must be converted to the type given the bitfield here. */
6198 if (DECL_C_BIT_FIELD (field
))
6200 unsigned HOST_WIDE_INT width
;
6201 tree ftype
= TREE_TYPE (field
);
6202 width
= tree_to_uhwi (DECL_SIZE (field
));
6203 if (width
!= TYPE_PRECISION (ftype
))
6206 = c_build_bitfield_integer_type (width
,
6207 TYPE_UNSIGNED (ftype
));
6209 = cp_build_qualified_type (TREE_TYPE (field
),
6210 cp_type_quals (ftype
));
6214 /* If we needed additional padding after this field, add it
6220 padding_field
= build_decl (input_location
,
6224 DECL_BIT_FIELD (padding_field
) = 1;
6225 DECL_SIZE (padding_field
) = padding
;
6226 DECL_CONTEXT (padding_field
) = t
;
6227 DECL_ARTIFICIAL (padding_field
) = 1;
6228 DECL_IGNORED_P (padding_field
) = 1;
6229 layout_nonempty_base_or_field (rli
, padding_field
,
6231 empty_base_offsets
);
6234 last_field_was_bitfield
= DECL_C_BIT_FIELD (field
);
6237 if (!integer_zerop (rli
->bitpos
))
6239 /* Make sure that we are on a byte boundary so that the size of
6240 the class without virtual bases will always be a round number
6242 rli
->bitpos
= round_up_loc (input_location
, rli
->bitpos
, BITS_PER_UNIT
);
6243 normalize_rli (rli
);
6246 /* Delete all zero-width bit-fields from the list of fields. Now
6247 that the type is laid out they are no longer important. */
6248 remove_zero_width_bit_fields (t
);
6250 /* Create the version of T used for virtual bases. We do not use
6251 make_class_type for this version; this is an artificial type. For
6252 a POD type, we just reuse T. */
6253 if (CLASSTYPE_NON_LAYOUT_POD_P (t
) || CLASSTYPE_EMPTY_P (t
))
6255 base_t
= make_node (TREE_CODE (t
));
6257 /* Set the size and alignment for the new type. */
6260 /* If the ABI version is not at least two, and the last
6261 field was a bit-field, RLI may not be on a byte
6262 boundary. In particular, rli_size_unit_so_far might
6263 indicate the last complete byte, while rli_size_so_far
6264 indicates the total number of bits used. Therefore,
6265 rli_size_so_far, rather than rli_size_unit_so_far, is
6266 used to compute TYPE_SIZE_UNIT. */
6267 eoc
= end_of_class (t
, /*include_virtuals_p=*/0);
6268 TYPE_SIZE_UNIT (base_t
)
6269 = size_binop (MAX_EXPR
,
6271 size_binop (CEIL_DIV_EXPR
,
6272 rli_size_so_far (rli
),
6273 bitsize_int (BITS_PER_UNIT
))),
6276 = size_binop (MAX_EXPR
,
6277 rli_size_so_far (rli
),
6278 size_binop (MULT_EXPR
,
6279 convert (bitsizetype
, eoc
),
6280 bitsize_int (BITS_PER_UNIT
)));
6281 TYPE_ALIGN (base_t
) = rli
->record_align
;
6282 TYPE_USER_ALIGN (base_t
) = TYPE_USER_ALIGN (t
);
6284 /* Copy the fields from T. */
6285 next_field
= &TYPE_FIELDS (base_t
);
6286 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
6287 if (TREE_CODE (field
) == FIELD_DECL
)
6289 *next_field
= build_decl (input_location
,
6293 DECL_CONTEXT (*next_field
) = base_t
;
6294 DECL_FIELD_OFFSET (*next_field
) = DECL_FIELD_OFFSET (field
);
6295 DECL_FIELD_BIT_OFFSET (*next_field
)
6296 = DECL_FIELD_BIT_OFFSET (field
);
6297 DECL_SIZE (*next_field
) = DECL_SIZE (field
);
6298 DECL_MODE (*next_field
) = DECL_MODE (field
);
6299 next_field
= &DECL_CHAIN (*next_field
);
6302 /* Record the base version of the type. */
6303 CLASSTYPE_AS_BASE (t
) = base_t
;
6304 TYPE_CONTEXT (base_t
) = t
;
6307 CLASSTYPE_AS_BASE (t
) = t
;
6309 /* Every empty class contains an empty class. */
6310 if (CLASSTYPE_EMPTY_P (t
))
6311 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
6313 /* Set the TYPE_DECL for this type to contain the right
6314 value for DECL_OFFSET, so that we can use it as part
6315 of a COMPONENT_REF for multiple inheritance. */
6316 layout_decl (TYPE_MAIN_DECL (t
), 0);
6318 /* Now fix up any virtual base class types that we left lying
6319 around. We must get these done before we try to lay out the
6320 virtual function table. As a side-effect, this will remove the
6321 base subobject fields. */
6322 layout_virtual_bases (rli
, empty_base_offsets
);
6324 /* Make sure that empty classes are reflected in RLI at this
6326 include_empty_classes(rli
);
6328 /* Make sure not to create any structures with zero size. */
6329 if (integer_zerop (rli_size_unit_so_far (rli
)) && CLASSTYPE_EMPTY_P (t
))
6331 build_decl (input_location
,
6332 FIELD_DECL
, NULL_TREE
, char_type_node
));
6334 /* If this is a non-POD, declaring it packed makes a difference to how it
6335 can be used as a field; don't let finalize_record_size undo it. */
6336 if (TYPE_PACKED (t
) && !layout_pod_type_p (t
))
6337 rli
->packed_maybe_necessary
= true;
6339 /* Let the back end lay out the type. */
6340 finish_record_layout (rli
, /*free_p=*/true);
6342 if (TYPE_SIZE_UNIT (t
)
6343 && TREE_CODE (TYPE_SIZE_UNIT (t
)) == INTEGER_CST
6344 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t
))
6345 && !valid_constant_size_p (TYPE_SIZE_UNIT (t
)))
6346 error ("type %qT is too large", t
);
6348 /* Warn about bases that can't be talked about due to ambiguity. */
6349 warn_about_ambiguous_bases (t
);
6351 /* Now that we're done with layout, give the base fields the real types. */
6352 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
6353 if (DECL_ARTIFICIAL (field
) && IS_FAKE_BASE_TYPE (TREE_TYPE (field
)))
6354 TREE_TYPE (field
) = TYPE_CONTEXT (TREE_TYPE (field
));
6357 splay_tree_delete (empty_base_offsets
);
6359 if (CLASSTYPE_EMPTY_P (t
)
6360 && tree_int_cst_lt (sizeof_biggest_empty_class
,
6361 TYPE_SIZE_UNIT (t
)))
6362 sizeof_biggest_empty_class
= TYPE_SIZE_UNIT (t
);
6365 /* Determine the "key method" for the class type indicated by TYPE,
6366 and set CLASSTYPE_KEY_METHOD accordingly. */
6369 determine_key_method (tree type
)
6373 if (TYPE_FOR_JAVA (type
)
6374 || processing_template_decl
6375 || CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
6376 || CLASSTYPE_INTERFACE_KNOWN (type
))
6379 /* The key method is the first non-pure virtual function that is not
6380 inline at the point of class definition. On some targets the
6381 key function may not be inline; those targets should not call
6382 this function until the end of the translation unit. */
6383 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
6384 method
= DECL_CHAIN (method
))
6385 if (TREE_CODE (method
) == FUNCTION_DECL
6386 && DECL_VINDEX (method
) != NULL_TREE
6387 && ! DECL_DECLARED_INLINE_P (method
)
6388 && ! DECL_PURE_VIRTUAL_P (method
))
6390 CLASSTYPE_KEY_METHOD (type
) = method
;
6398 /* Allocate and return an instance of struct sorted_fields_type with
6401 static struct sorted_fields_type
*
6402 sorted_fields_type_new (int n
)
6404 struct sorted_fields_type
*sft
;
6405 sft
= (sorted_fields_type
*) ggc_internal_alloc (sizeof (sorted_fields_type
)
6406 + n
* sizeof (tree
));
6413 /* Perform processing required when the definition of T (a class type)
6417 finish_struct_1 (tree t
)
6420 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
6421 tree virtuals
= NULL_TREE
;
6423 if (COMPLETE_TYPE_P (t
))
6425 gcc_assert (MAYBE_CLASS_TYPE_P (t
));
6426 error ("redefinition of %q#T", t
);
6431 /* If this type was previously laid out as a forward reference,
6432 make sure we lay it out again. */
6433 TYPE_SIZE (t
) = NULL_TREE
;
6434 CLASSTYPE_PRIMARY_BINFO (t
) = NULL_TREE
;
6436 /* Make assumptions about the class; we'll reset the flags if
6438 CLASSTYPE_EMPTY_P (t
) = 1;
6439 CLASSTYPE_NEARLY_EMPTY_P (t
) = 1;
6440 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 0;
6441 CLASSTYPE_LITERAL_P (t
) = true;
6443 /* Do end-of-class semantic processing: checking the validity of the
6444 bases and members and add implicitly generated methods. */
6445 check_bases_and_members (t
);
6447 /* Find the key method. */
6448 if (TYPE_CONTAINS_VPTR_P (t
))
6450 /* The Itanium C++ ABI permits the key method to be chosen when
6451 the class is defined -- even though the key method so
6452 selected may later turn out to be an inline function. On
6453 some systems (such as ARM Symbian OS) the key method cannot
6454 be determined until the end of the translation unit. On such
6455 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
6456 will cause the class to be added to KEYED_CLASSES. Then, in
6457 finish_file we will determine the key method. */
6458 if (targetm
.cxx
.key_method_may_be_inline ())
6459 determine_key_method (t
);
6461 /* If a polymorphic class has no key method, we may emit the vtable
6462 in every translation unit where the class definition appears. If
6463 we're devirtualizing, we can look into the vtable even if we
6464 aren't emitting it. */
6465 if (CLASSTYPE_KEY_METHOD (t
) == NULL_TREE
)
6466 keyed_classes
= tree_cons (NULL_TREE
, t
, keyed_classes
);
6469 /* Layout the class itself. */
6470 layout_class_type (t
, &virtuals
);
6471 if (CLASSTYPE_AS_BASE (t
) != t
)
6472 /* We use the base type for trivial assignments, and hence it
6474 compute_record_mode (CLASSTYPE_AS_BASE (t
));
6476 virtuals
= modify_all_vtables (t
, nreverse (virtuals
));
6478 /* If necessary, create the primary vtable for this class. */
6479 if (virtuals
|| TYPE_CONTAINS_VPTR_P (t
))
6481 /* We must enter these virtuals into the table. */
6482 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6483 build_primary_vtable (NULL_TREE
, t
);
6484 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t
)))
6485 /* Here we know enough to change the type of our virtual
6486 function table, but we will wait until later this function. */
6487 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t
), t
);
6489 /* If we're warning about ABI tags, check the types of the new
6490 virtual functions. */
6492 for (tree v
= virtuals
; v
; v
= TREE_CHAIN (v
))
6493 check_abi_tags (t
, TREE_VALUE (v
));
6496 if (TYPE_CONTAINS_VPTR_P (t
))
6501 if (BINFO_VTABLE (TYPE_BINFO (t
)))
6502 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t
))));
6503 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6504 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t
)) == NULL_TREE
);
6506 /* Add entries for virtual functions introduced by this class. */
6507 BINFO_VIRTUALS (TYPE_BINFO (t
))
6508 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t
)), virtuals
);
6510 /* Set DECL_VINDEX for all functions declared in this class. */
6511 for (vindex
= 0, fn
= BINFO_VIRTUALS (TYPE_BINFO (t
));
6513 fn
= TREE_CHAIN (fn
),
6514 vindex
+= (TARGET_VTABLE_USES_DESCRIPTORS
6515 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1))
6517 tree fndecl
= BV_FN (fn
);
6519 if (DECL_THUNK_P (fndecl
))
6520 /* A thunk. We should never be calling this entry directly
6521 from this vtable -- we'd use the entry for the non
6522 thunk base function. */
6523 DECL_VINDEX (fndecl
) = NULL_TREE
;
6524 else if (TREE_CODE (DECL_VINDEX (fndecl
)) != INTEGER_CST
)
6525 DECL_VINDEX (fndecl
) = build_int_cst (NULL_TREE
, vindex
);
6529 finish_struct_bits (t
);
6530 set_method_tm_attributes (t
);
6532 /* Complete the rtl for any static member objects of the type we're
6534 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
6535 if (VAR_P (x
) && TREE_STATIC (x
)
6536 && TREE_TYPE (x
) != error_mark_node
6537 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x
)), t
))
6538 DECL_MODE (x
) = TYPE_MODE (t
);
6540 /* Done with FIELDS...now decide whether to sort these for
6541 faster lookups later.
6543 We use a small number because most searches fail (succeeding
6544 ultimately as the search bores through the inheritance
6545 hierarchy), and we want this failure to occur quickly. */
6547 insert_into_classtype_sorted_fields (TYPE_FIELDS (t
), t
, 8);
6549 /* Complain if one of the field types requires lower visibility. */
6550 constrain_class_visibility (t
);
6552 /* Make the rtl for any new vtables we have created, and unmark
6553 the base types we marked. */
6556 /* Build the VTT for T. */
6559 /* This warning does not make sense for Java classes, since they
6560 cannot have destructors. */
6561 if (!TYPE_FOR_JAVA (t
) && warn_nonvdtor
6562 && TYPE_POLYMORPHIC_P (t
) && accessible_nvdtor_p (t
)
6563 && !CLASSTYPE_FINAL (t
))
6564 warning (OPT_Wnon_virtual_dtor
,
6565 "%q#T has virtual functions and accessible"
6566 " non-virtual destructor", t
);
6570 if (warn_overloaded_virtual
)
6573 /* Class layout, assignment of virtual table slots, etc., is now
6574 complete. Give the back end a chance to tweak the visibility of
6575 the class or perform any other required target modifications. */
6576 targetm
.cxx
.adjust_class_at_definition (t
);
6578 maybe_suppress_debug_info (t
);
6580 if (flag_vtable_verify
)
6581 vtv_save_class_info (t
);
6583 dump_class_hierarchy (t
);
6585 /* Finish debugging output for this type. */
6586 rest_of_type_compilation (t
, ! LOCAL_CLASS_P (t
));
6588 if (TYPE_TRANSPARENT_AGGR (t
))
6590 tree field
= first_field (t
);
6591 if (field
== NULL_TREE
|| error_operand_p (field
))
6593 error ("type transparent %q#T does not have any fields", t
);
6594 TYPE_TRANSPARENT_AGGR (t
) = 0;
6596 else if (DECL_ARTIFICIAL (field
))
6598 if (DECL_FIELD_IS_BASE (field
))
6599 error ("type transparent class %qT has base classes", t
);
6602 gcc_checking_assert (DECL_VIRTUAL_P (field
));
6603 error ("type transparent class %qT has virtual functions", t
);
6605 TYPE_TRANSPARENT_AGGR (t
) = 0;
6607 else if (TYPE_MODE (t
) != DECL_MODE (field
))
6609 error ("type transparent %q#T cannot be made transparent because "
6610 "the type of the first field has a different ABI from the "
6611 "class overall", t
);
6612 TYPE_TRANSPARENT_AGGR (t
) = 0;
6617 /* Insert FIELDS into T for the sorted case if the FIELDS count is
6618 equal to THRESHOLD or greater than THRESHOLD. */
6621 insert_into_classtype_sorted_fields (tree fields
, tree t
, int threshold
)
6623 int n_fields
= count_fields (fields
);
6624 if (n_fields
>= threshold
)
6626 struct sorted_fields_type
*field_vec
= sorted_fields_type_new (n_fields
);
6627 add_fields_to_record_type (fields
, field_vec
, 0);
6628 qsort (field_vec
->elts
, n_fields
, sizeof (tree
), field_decl_cmp
);
6629 CLASSTYPE_SORTED_FIELDS (t
) = field_vec
;
6633 /* Insert lately defined enum ENUMTYPE into T for the sorted case. */
6636 insert_late_enum_def_into_classtype_sorted_fields (tree enumtype
, tree t
)
6638 struct sorted_fields_type
*sorted_fields
= CLASSTYPE_SORTED_FIELDS (t
);
6643 = list_length (TYPE_VALUES (enumtype
)) + sorted_fields
->len
;
6644 struct sorted_fields_type
*field_vec
= sorted_fields_type_new (n_fields
);
6646 for (i
= 0; i
< sorted_fields
->len
; ++i
)
6647 field_vec
->elts
[i
] = sorted_fields
->elts
[i
];
6649 add_enum_fields_to_record_type (enumtype
, field_vec
,
6650 sorted_fields
->len
);
6651 qsort (field_vec
->elts
, n_fields
, sizeof (tree
), field_decl_cmp
);
6652 CLASSTYPE_SORTED_FIELDS (t
) = field_vec
;
6656 /* When T was built up, the member declarations were added in reverse
6657 order. Rearrange them to declaration order. */
6660 unreverse_member_declarations (tree t
)
6666 /* The following lists are all in reverse order. Put them in
6667 declaration order now. */
6668 TYPE_METHODS (t
) = nreverse (TYPE_METHODS (t
));
6669 CLASSTYPE_DECL_LIST (t
) = nreverse (CLASSTYPE_DECL_LIST (t
));
6671 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
6672 reverse order, so we can't just use nreverse. */
6674 for (x
= TYPE_FIELDS (t
);
6675 x
&& TREE_CODE (x
) != TYPE_DECL
;
6678 next
= DECL_CHAIN (x
);
6679 DECL_CHAIN (x
) = prev
;
6684 DECL_CHAIN (TYPE_FIELDS (t
)) = x
;
6686 TYPE_FIELDS (t
) = prev
;
6691 finish_struct (tree t
, tree attributes
)
6693 location_t saved_loc
= input_location
;
6695 /* Now that we've got all the field declarations, reverse everything
6697 unreverse_member_declarations (t
);
6699 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
6701 /* Nadger the current location so that diagnostics point to the start of
6702 the struct, not the end. */
6703 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (t
));
6705 if (processing_template_decl
)
6709 finish_struct_methods (t
);
6710 TYPE_SIZE (t
) = bitsize_zero_node
;
6711 TYPE_SIZE_UNIT (t
) = size_zero_node
;
6713 /* We need to emit an error message if this type was used as a parameter
6714 and it is an abstract type, even if it is a template. We construct
6715 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
6716 account and we call complete_vars with this type, which will check
6717 the PARM_DECLS. Note that while the type is being defined,
6718 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
6719 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
6720 CLASSTYPE_PURE_VIRTUALS (t
) = NULL
;
6721 for (x
= TYPE_METHODS (t
); x
; x
= DECL_CHAIN (x
))
6722 if (DECL_PURE_VIRTUAL_P (x
))
6723 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t
), x
);
6725 /* We need to add the target functions to the CLASSTYPE_METHOD_VEC if
6726 an enclosing scope is a template class, so that this function be
6727 found by lookup_fnfields_1 when the using declaration is not
6728 instantiated yet. */
6729 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
6730 if (TREE_CODE (x
) == USING_DECL
)
6732 tree fn
= strip_using_decl (x
);
6733 if (is_overloaded_fn (fn
))
6734 for (; fn
; fn
= OVL_NEXT (fn
))
6735 add_method (t
, OVL_CURRENT (fn
), x
);
6738 /* Remember current #pragma pack value. */
6739 TYPE_PRECISION (t
) = maximum_field_alignment
;
6741 /* Fix up any variants we've already built. */
6742 for (x
= TYPE_NEXT_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
6744 TYPE_SIZE (x
) = TYPE_SIZE (t
);
6745 TYPE_SIZE_UNIT (x
) = TYPE_SIZE_UNIT (t
);
6746 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
6747 TYPE_METHODS (x
) = TYPE_METHODS (t
);
6751 finish_struct_1 (t
);
6753 if (is_std_init_list (t
))
6755 /* People keep complaining that the compiler crashes on an invalid
6756 definition of initializer_list, so I guess we should explicitly
6757 reject it. What the compiler internals care about is that it's a
6758 template and has a pointer field followed by an integer field. */
6760 if (processing_template_decl
)
6762 tree f
= next_initializable_field (TYPE_FIELDS (t
));
6763 if (f
&& TREE_CODE (TREE_TYPE (f
)) == POINTER_TYPE
)
6765 f
= next_initializable_field (DECL_CHAIN (f
));
6766 if (f
&& TREE_CODE (TREE_TYPE (f
)) == INTEGER_TYPE
)
6771 fatal_error ("definition of std::initializer_list does not match "
6772 "#include <initializer_list>");
6775 input_location
= saved_loc
;
6777 TYPE_BEING_DEFINED (t
) = 0;
6779 if (current_class_type
)
6782 error ("trying to finish struct, but kicked out due to previous parse errors");
6784 if (processing_template_decl
&& at_function_scope_p ()
6785 /* Lambdas are defined by the LAMBDA_EXPR. */
6786 && !LAMBDA_TYPE_P (t
))
6787 add_stmt (build_min (TAG_DEFN
, t
));
6792 /* Hash table to avoid endless recursion when handling references. */
6793 static hash_table
<pointer_hash
<tree_node
> > *fixed_type_or_null_ref_ht
;
6795 /* Return the dynamic type of INSTANCE, if known.
6796 Used to determine whether the virtual function table is needed
6799 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6800 of our knowledge of its type. *NONNULL should be initialized
6801 before this function is called. */
6804 fixed_type_or_null (tree instance
, int *nonnull
, int *cdtorp
)
6806 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
6808 switch (TREE_CODE (instance
))
6811 if (POINTER_TYPE_P (TREE_TYPE (instance
)))
6814 return RECUR (TREE_OPERAND (instance
, 0));
6817 /* This is a call to a constructor, hence it's never zero. */
6818 if (TREE_HAS_CONSTRUCTOR (instance
))
6822 return TREE_TYPE (instance
);
6827 /* This is a call to a constructor, hence it's never zero. */
6828 if (TREE_HAS_CONSTRUCTOR (instance
))
6832 return TREE_TYPE (instance
);
6834 return RECUR (TREE_OPERAND (instance
, 0));
6836 case POINTER_PLUS_EXPR
:
6839 if (TREE_CODE (TREE_OPERAND (instance
, 0)) == ADDR_EXPR
)
6840 return RECUR (TREE_OPERAND (instance
, 0));
6841 if (TREE_CODE (TREE_OPERAND (instance
, 1)) == INTEGER_CST
)
6842 /* Propagate nonnull. */
6843 return RECUR (TREE_OPERAND (instance
, 0));
6848 return RECUR (TREE_OPERAND (instance
, 0));
6851 instance
= TREE_OPERAND (instance
, 0);
6854 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
6855 with a real object -- given &p->f, p can still be null. */
6856 tree t
= get_base_address (instance
);
6857 /* ??? Probably should check DECL_WEAK here. */
6858 if (t
&& DECL_P (t
))
6861 return RECUR (instance
);
6864 /* If this component is really a base class reference, then the field
6865 itself isn't definitive. */
6866 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance
, 1)))
6867 return RECUR (TREE_OPERAND (instance
, 0));
6868 return RECUR (TREE_OPERAND (instance
, 1));
6872 if (TREE_CODE (TREE_TYPE (instance
)) == ARRAY_TYPE
6873 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance
))))
6877 return TREE_TYPE (TREE_TYPE (instance
));
6879 /* fall through... */
6883 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance
)))
6887 return TREE_TYPE (instance
);
6889 else if (instance
== current_class_ptr
)
6894 /* if we're in a ctor or dtor, we know our type. If
6895 current_class_ptr is set but we aren't in a function, we're in
6896 an NSDMI (and therefore a constructor). */
6897 if (current_scope () != current_function_decl
6898 || (DECL_LANG_SPECIFIC (current_function_decl
)
6899 && (DECL_CONSTRUCTOR_P (current_function_decl
)
6900 || DECL_DESTRUCTOR_P (current_function_decl
))))
6904 return TREE_TYPE (TREE_TYPE (instance
));
6907 else if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
6909 /* We only need one hash table because it is always left empty. */
6910 if (!fixed_type_or_null_ref_ht
)
6911 fixed_type_or_null_ref_ht
6912 = new hash_table
<pointer_hash
<tree_node
> > (37);
6914 /* Reference variables should be references to objects. */
6918 /* Enter the INSTANCE in a table to prevent recursion; a
6919 variable's initializer may refer to the variable
6921 if (VAR_P (instance
)
6922 && DECL_INITIAL (instance
)
6923 && !type_dependent_expression_p_push (DECL_INITIAL (instance
))
6924 && !fixed_type_or_null_ref_ht
->find (instance
))
6929 slot
= fixed_type_or_null_ref_ht
->find_slot (instance
, INSERT
);
6931 type
= RECUR (DECL_INITIAL (instance
));
6932 fixed_type_or_null_ref_ht
->remove_elt (instance
);
6945 /* Return nonzero if the dynamic type of INSTANCE is known, and
6946 equivalent to the static type. We also handle the case where
6947 INSTANCE is really a pointer. Return negative if this is a
6948 ctor/dtor. There the dynamic type is known, but this might not be
6949 the most derived base of the original object, and hence virtual
6950 bases may not be laid out according to this type.
6952 Used to determine whether the virtual function table is needed
6955 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6956 of our knowledge of its type. *NONNULL should be initialized
6957 before this function is called. */
6960 resolves_to_fixed_type_p (tree instance
, int* nonnull
)
6962 tree t
= TREE_TYPE (instance
);
6966 /* processing_template_decl can be false in a template if we're in
6967 instantiate_non_dependent_expr, but we still want to suppress
6969 if (in_template_function ())
6971 /* In a template we only care about the type of the result. */
6977 fixed
= fixed_type_or_null (instance
, nonnull
, &cdtorp
);
6978 if (fixed
== NULL_TREE
)
6980 if (POINTER_TYPE_P (t
))
6982 if (!same_type_ignoring_top_level_qualifiers_p (t
, fixed
))
6984 return cdtorp
? -1 : 1;
6989 init_class_processing (void)
6991 current_class_depth
= 0;
6992 current_class_stack_size
= 10;
6994 = XNEWVEC (struct class_stack_node
, current_class_stack_size
);
6995 vec_alloc (local_classes
, 8);
6996 sizeof_biggest_empty_class
= size_zero_node
;
6998 ridpointers
[(int) RID_PUBLIC
] = access_public_node
;
6999 ridpointers
[(int) RID_PRIVATE
] = access_private_node
;
7000 ridpointers
[(int) RID_PROTECTED
] = access_protected_node
;
7003 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
7006 restore_class_cache (void)
7010 /* We are re-entering the same class we just left, so we don't
7011 have to search the whole inheritance matrix to find all the
7012 decls to bind again. Instead, we install the cached
7013 class_shadowed list and walk through it binding names. */
7014 push_binding_level (previous_class_level
);
7015 class_binding_level
= previous_class_level
;
7016 /* Restore IDENTIFIER_TYPE_VALUE. */
7017 for (type
= class_binding_level
->type_shadowed
;
7019 type
= TREE_CHAIN (type
))
7020 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type
), TREE_TYPE (type
));
7023 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
7024 appropriate for TYPE.
7026 So that we may avoid calls to lookup_name, we cache the _TYPE
7027 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
7029 For multiple inheritance, we perform a two-pass depth-first search
7030 of the type lattice. */
7033 pushclass (tree type
)
7035 class_stack_node_t csn
;
7037 type
= TYPE_MAIN_VARIANT (type
);
7039 /* Make sure there is enough room for the new entry on the stack. */
7040 if (current_class_depth
+ 1 >= current_class_stack_size
)
7042 current_class_stack_size
*= 2;
7044 = XRESIZEVEC (struct class_stack_node
, current_class_stack
,
7045 current_class_stack_size
);
7048 /* Insert a new entry on the class stack. */
7049 csn
= current_class_stack
+ current_class_depth
;
7050 csn
->name
= current_class_name
;
7051 csn
->type
= current_class_type
;
7052 csn
->access
= current_access_specifier
;
7053 csn
->names_used
= 0;
7055 current_class_depth
++;
7057 /* Now set up the new type. */
7058 current_class_name
= TYPE_NAME (type
);
7059 if (TREE_CODE (current_class_name
) == TYPE_DECL
)
7060 current_class_name
= DECL_NAME (current_class_name
);
7061 current_class_type
= type
;
7063 /* By default, things in classes are private, while things in
7064 structures or unions are public. */
7065 current_access_specifier
= (CLASSTYPE_DECLARED_CLASS (type
)
7066 ? access_private_node
7067 : access_public_node
);
7069 if (previous_class_level
7070 && type
!= previous_class_level
->this_entity
7071 && current_class_depth
== 1)
7073 /* Forcibly remove any old class remnants. */
7074 invalidate_class_lookup_cache ();
7077 if (!previous_class_level
7078 || type
!= previous_class_level
->this_entity
7079 || current_class_depth
> 1)
7082 restore_class_cache ();
7085 /* When we exit a toplevel class scope, we save its binding level so
7086 that we can restore it quickly. Here, we've entered some other
7087 class, so we must invalidate our cache. */
7090 invalidate_class_lookup_cache (void)
7092 previous_class_level
= NULL
;
7095 /* Get out of the current class scope. If we were in a class scope
7096 previously, that is the one popped to. */
7103 current_class_depth
--;
7104 current_class_name
= current_class_stack
[current_class_depth
].name
;
7105 current_class_type
= current_class_stack
[current_class_depth
].type
;
7106 current_access_specifier
= current_class_stack
[current_class_depth
].access
;
7107 if (current_class_stack
[current_class_depth
].names_used
)
7108 splay_tree_delete (current_class_stack
[current_class_depth
].names_used
);
7111 /* Mark the top of the class stack as hidden. */
7114 push_class_stack (void)
7116 if (current_class_depth
)
7117 ++current_class_stack
[current_class_depth
- 1].hidden
;
7120 /* Mark the top of the class stack as un-hidden. */
7123 pop_class_stack (void)
7125 if (current_class_depth
)
7126 --current_class_stack
[current_class_depth
- 1].hidden
;
7129 /* Returns 1 if the class type currently being defined is either T or
7130 a nested type of T. */
7133 currently_open_class (tree t
)
7137 if (!CLASS_TYPE_P (t
))
7140 t
= TYPE_MAIN_VARIANT (t
);
7142 /* We start looking from 1 because entry 0 is from global scope,
7144 for (i
= current_class_depth
; i
> 0; --i
)
7147 if (i
== current_class_depth
)
7148 c
= current_class_type
;
7151 if (current_class_stack
[i
].hidden
)
7153 c
= current_class_stack
[i
].type
;
7157 if (same_type_p (c
, t
))
7163 /* If either current_class_type or one of its enclosing classes are derived
7164 from T, return the appropriate type. Used to determine how we found
7165 something via unqualified lookup. */
7168 currently_open_derived_class (tree t
)
7172 /* The bases of a dependent type are unknown. */
7173 if (dependent_type_p (t
))
7176 if (!current_class_type
)
7179 if (DERIVED_FROM_P (t
, current_class_type
))
7180 return current_class_type
;
7182 for (i
= current_class_depth
- 1; i
> 0; --i
)
7184 if (current_class_stack
[i
].hidden
)
7186 if (DERIVED_FROM_P (t
, current_class_stack
[i
].type
))
7187 return current_class_stack
[i
].type
;
7193 /* Return the outermost enclosing class type that is still open, or
7197 outermost_open_class (void)
7199 if (!current_class_type
)
7202 if (TYPE_BEING_DEFINED (current_class_type
))
7203 r
= current_class_type
;
7204 for (int i
= current_class_depth
- 1; i
> 0; --i
)
7206 if (current_class_stack
[i
].hidden
)
7208 tree t
= current_class_stack
[i
].type
;
7209 if (!TYPE_BEING_DEFINED (t
))
7216 /* Returns the innermost class type which is not a lambda closure type. */
7219 current_nonlambda_class_type (void)
7223 /* We start looking from 1 because entry 0 is from global scope,
7225 for (i
= current_class_depth
; i
> 0; --i
)
7228 if (i
== current_class_depth
)
7229 c
= current_class_type
;
7232 if (current_class_stack
[i
].hidden
)
7234 c
= current_class_stack
[i
].type
;
7238 if (!LAMBDA_TYPE_P (c
))
7244 /* When entering a class scope, all enclosing class scopes' names with
7245 static meaning (static variables, static functions, types and
7246 enumerators) have to be visible. This recursive function calls
7247 pushclass for all enclosing class contexts until global or a local
7248 scope is reached. TYPE is the enclosed class. */
7251 push_nested_class (tree type
)
7253 /* A namespace might be passed in error cases, like A::B:C. */
7254 if (type
== NULL_TREE
7255 || !CLASS_TYPE_P (type
))
7258 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type
)));
7263 /* Undoes a push_nested_class call. */
7266 pop_nested_class (void)
7268 tree context
= DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type
));
7271 if (context
&& CLASS_TYPE_P (context
))
7272 pop_nested_class ();
7275 /* Returns the number of extern "LANG" blocks we are nested within. */
7278 current_lang_depth (void)
7280 return vec_safe_length (current_lang_base
);
7283 /* Set global variables CURRENT_LANG_NAME to appropriate value
7284 so that behavior of name-mangling machinery is correct. */
7287 push_lang_context (tree name
)
7289 vec_safe_push (current_lang_base
, current_lang_name
);
7291 if (name
== lang_name_cplusplus
)
7293 current_lang_name
= name
;
7295 else if (name
== lang_name_java
)
7297 current_lang_name
= name
;
7298 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
7299 (See record_builtin_java_type in decl.c.) However, that causes
7300 incorrect debug entries if these types are actually used.
7301 So we re-enable debug output after extern "Java". */
7302 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node
)) = 0;
7303 DECL_IGNORED_P (TYPE_NAME (java_short_type_node
)) = 0;
7304 DECL_IGNORED_P (TYPE_NAME (java_int_type_node
)) = 0;
7305 DECL_IGNORED_P (TYPE_NAME (java_long_type_node
)) = 0;
7306 DECL_IGNORED_P (TYPE_NAME (java_float_type_node
)) = 0;
7307 DECL_IGNORED_P (TYPE_NAME (java_double_type_node
)) = 0;
7308 DECL_IGNORED_P (TYPE_NAME (java_char_type_node
)) = 0;
7309 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node
)) = 0;
7311 else if (name
== lang_name_c
)
7313 current_lang_name
= name
;
7316 error ("language string %<\"%E\"%> not recognized", name
);
7319 /* Get out of the current language scope. */
7322 pop_lang_context (void)
7324 current_lang_name
= current_lang_base
->pop ();
7327 /* Type instantiation routines. */
7329 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
7330 matches the TARGET_TYPE. If there is no satisfactory match, return
7331 error_mark_node, and issue an error & warning messages under
7332 control of FLAGS. Permit pointers to member function if FLAGS
7333 permits. If TEMPLATE_ONLY, the name of the overloaded function was
7334 a template-id, and EXPLICIT_TARGS are the explicitly provided
7337 If OVERLOAD is for one or more member functions, then ACCESS_PATH
7338 is the base path used to reference those member functions. If
7339 the address is resolved to a member function, access checks will be
7340 performed and errors issued if appropriate. */
7343 resolve_address_of_overloaded_function (tree target_type
,
7345 tsubst_flags_t flags
,
7347 tree explicit_targs
,
7350 /* Here's what the standard says:
7354 If the name is a function template, template argument deduction
7355 is done, and if the argument deduction succeeds, the deduced
7356 arguments are used to generate a single template function, which
7357 is added to the set of overloaded functions considered.
7359 Non-member functions and static member functions match targets of
7360 type "pointer-to-function" or "reference-to-function." Nonstatic
7361 member functions match targets of type "pointer-to-member
7362 function;" the function type of the pointer to member is used to
7363 select the member function from the set of overloaded member
7364 functions. If a nonstatic member function is selected, the
7365 reference to the overloaded function name is required to have the
7366 form of a pointer to member as described in 5.3.1.
7368 If more than one function is selected, any template functions in
7369 the set are eliminated if the set also contains a non-template
7370 function, and any given template function is eliminated if the
7371 set contains a second template function that is more specialized
7372 than the first according to the partial ordering rules 14.5.5.2.
7373 After such eliminations, if any, there shall remain exactly one
7374 selected function. */
7377 /* We store the matches in a TREE_LIST rooted here. The functions
7378 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
7379 interoperability with most_specialized_instantiation. */
7380 tree matches
= NULL_TREE
;
7382 tree target_fn_type
;
7384 /* By the time we get here, we should be seeing only real
7385 pointer-to-member types, not the internal POINTER_TYPE to
7386 METHOD_TYPE representation. */
7387 gcc_assert (!TYPE_PTR_P (target_type
)
7388 || TREE_CODE (TREE_TYPE (target_type
)) != METHOD_TYPE
);
7390 gcc_assert (is_overloaded_fn (overload
));
7392 /* Check that the TARGET_TYPE is reasonable. */
7393 if (TYPE_PTRFN_P (target_type
)
7394 || TYPE_REFFN_P (target_type
))
7396 else if (TYPE_PTRMEMFUNC_P (target_type
))
7397 /* This is OK, too. */
7399 else if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
7400 /* This is OK, too. This comes from a conversion to reference
7402 target_type
= build_reference_type (target_type
);
7405 if (flags
& tf_error
)
7406 error ("cannot resolve overloaded function %qD based on"
7407 " conversion to type %qT",
7408 DECL_NAME (OVL_FUNCTION (overload
)), target_type
);
7409 return error_mark_node
;
7412 /* Non-member functions and static member functions match targets of type
7413 "pointer-to-function" or "reference-to-function." Nonstatic member
7414 functions match targets of type "pointer-to-member-function;" the
7415 function type of the pointer to member is used to select the member
7416 function from the set of overloaded member functions.
7418 So figure out the FUNCTION_TYPE that we want to match against. */
7419 target_fn_type
= static_fn_type (target_type
);
7421 /* If we can find a non-template function that matches, we can just
7422 use it. There's no point in generating template instantiations
7423 if we're just going to throw them out anyhow. But, of course, we
7424 can only do this when we don't *need* a template function. */
7429 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
7431 tree fn
= OVL_CURRENT (fns
);
7433 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
7434 /* We're not looking for templates just yet. */
7437 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7439 /* We're looking for a non-static member, and this isn't
7440 one, or vice versa. */
7443 /* Ignore functions which haven't been explicitly
7445 if (DECL_ANTICIPATED (fn
))
7448 /* See if there's a match. */
7449 if (same_type_p (target_fn_type
, static_fn_type (fn
)))
7450 matches
= tree_cons (fn
, NULL_TREE
, matches
);
7454 /* Now, if we've already got a match (or matches), there's no need
7455 to proceed to the template functions. But, if we don't have a
7456 match we need to look at them, too. */
7459 tree target_arg_types
;
7460 tree target_ret_type
;
7463 unsigned int nargs
, ia
;
7466 target_arg_types
= TYPE_ARG_TYPES (target_fn_type
);
7467 target_ret_type
= TREE_TYPE (target_fn_type
);
7469 nargs
= list_length (target_arg_types
);
7470 args
= XALLOCAVEC (tree
, nargs
);
7471 for (arg
= target_arg_types
, ia
= 0;
7472 arg
!= NULL_TREE
&& arg
!= void_list_node
;
7473 arg
= TREE_CHAIN (arg
), ++ia
)
7474 args
[ia
] = TREE_VALUE (arg
);
7477 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
7479 tree fn
= OVL_CURRENT (fns
);
7483 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7484 /* We're only looking for templates. */
7487 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7489 /* We're not looking for a non-static member, and this is
7490 one, or vice versa. */
7493 tree ret
= target_ret_type
;
7495 /* If the template has a deduced return type, don't expose it to
7496 template argument deduction. */
7497 if (undeduced_auto_decl (fn
))
7500 /* Try to do argument deduction. */
7501 targs
= make_tree_vec (DECL_NTPARMS (fn
));
7502 instantiation
= fn_type_unification (fn
, explicit_targs
, targs
, args
,
7504 DEDUCE_EXACT
, LOOKUP_NORMAL
,
7506 if (instantiation
== error_mark_node
)
7507 /* Instantiation failed. */
7510 /* And now force instantiation to do return type deduction. */
7511 if (undeduced_auto_decl (instantiation
))
7514 instantiate_decl (instantiation
, /*defer*/false, /*class*/false);
7517 require_deduced_type (instantiation
);
7520 /* See if there's a match. */
7521 if (same_type_p (target_fn_type
, static_fn_type (instantiation
)))
7522 matches
= tree_cons (instantiation
, fn
, matches
);
7525 /* Now, remove all but the most specialized of the matches. */
7528 tree match
= most_specialized_instantiation (matches
);
7530 if (match
!= error_mark_node
)
7531 matches
= tree_cons (TREE_PURPOSE (match
),
7537 /* Now we should have exactly one function in MATCHES. */
7538 if (matches
== NULL_TREE
)
7540 /* There were *no* matches. */
7541 if (flags
& tf_error
)
7543 error ("no matches converting function %qD to type %q#T",
7544 DECL_NAME (OVL_CURRENT (overload
)),
7547 print_candidates (overload
);
7549 return error_mark_node
;
7551 else if (TREE_CHAIN (matches
))
7553 /* There were too many matches. First check if they're all
7554 the same function. */
7555 tree match
= NULL_TREE
;
7557 fn
= TREE_PURPOSE (matches
);
7559 /* For multi-versioned functions, more than one match is just fine and
7560 decls_match will return false as they are different. */
7561 for (match
= TREE_CHAIN (matches
); match
; match
= TREE_CHAIN (match
))
7562 if (!decls_match (fn
, TREE_PURPOSE (match
))
7563 && !targetm
.target_option
.function_versions
7564 (fn
, TREE_PURPOSE (match
)))
7569 if (flags
& tf_error
)
7571 error ("converting overloaded function %qD to type %q#T is ambiguous",
7572 DECL_NAME (OVL_FUNCTION (overload
)),
7575 /* Since print_candidates expects the functions in the
7576 TREE_VALUE slot, we flip them here. */
7577 for (match
= matches
; match
; match
= TREE_CHAIN (match
))
7578 TREE_VALUE (match
) = TREE_PURPOSE (match
);
7580 print_candidates (matches
);
7583 return error_mark_node
;
7587 /* Good, exactly one match. Now, convert it to the correct type. */
7588 fn
= TREE_PURPOSE (matches
);
7590 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
7591 && !(flags
& tf_ptrmem_ok
) && !flag_ms_extensions
)
7593 static int explained
;
7595 if (!(flags
& tf_error
))
7596 return error_mark_node
;
7598 permerror (input_location
, "assuming pointer to member %qD", fn
);
7601 inform (input_location
, "(a pointer to member can only be formed with %<&%E%>)", fn
);
7606 /* If a pointer to a function that is multi-versioned is requested, the
7607 pointer to the dispatcher function is returned instead. This works
7608 well because indirectly calling the function will dispatch the right
7609 function version at run-time. */
7610 if (DECL_FUNCTION_VERSIONED (fn
))
7612 fn
= get_function_version_dispatcher (fn
);
7614 return error_mark_node
;
7615 /* Mark all the versions corresponding to the dispatcher as used. */
7616 if (!(flags
& tf_conv
))
7617 mark_versions_used (fn
);
7620 /* If we're doing overload resolution purely for the purpose of
7621 determining conversion sequences, we should not consider the
7622 function used. If this conversion sequence is selected, the
7623 function will be marked as used at this point. */
7624 if (!(flags
& tf_conv
))
7626 /* Make =delete work with SFINAE. */
7627 if (DECL_DELETED_FN (fn
) && !(flags
& tf_error
))
7628 return error_mark_node
;
7633 /* We could not check access to member functions when this
7634 expression was originally created since we did not know at that
7635 time to which function the expression referred. */
7636 if (DECL_FUNCTION_MEMBER_P (fn
))
7638 gcc_assert (access_path
);
7639 perform_or_defer_access_check (access_path
, fn
, fn
, flags
);
7642 if (TYPE_PTRFN_P (target_type
) || TYPE_PTRMEMFUNC_P (target_type
))
7643 return cp_build_addr_expr (fn
, flags
);
7646 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
7647 will mark the function as addressed, but here we must do it
7649 cxx_mark_addressable (fn
);
7655 /* This function will instantiate the type of the expression given in
7656 RHS to match the type of LHSTYPE. If errors exist, then return
7657 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
7658 we complain on errors. If we are not complaining, never modify rhs,
7659 as overload resolution wants to try many possible instantiations, in
7660 the hope that at least one will work.
7662 For non-recursive calls, LHSTYPE should be a function, pointer to
7663 function, or a pointer to member function. */
7666 instantiate_type (tree lhstype
, tree rhs
, tsubst_flags_t flags
)
7668 tsubst_flags_t flags_in
= flags
;
7669 tree access_path
= NULL_TREE
;
7671 flags
&= ~tf_ptrmem_ok
;
7673 if (lhstype
== unknown_type_node
)
7675 if (flags
& tf_error
)
7676 error ("not enough type information");
7677 return error_mark_node
;
7680 if (TREE_TYPE (rhs
) != NULL_TREE
&& ! (type_unknown_p (rhs
)))
7682 tree fntype
= non_reference (lhstype
);
7683 if (same_type_p (fntype
, TREE_TYPE (rhs
)))
7685 if (flag_ms_extensions
7686 && TYPE_PTRMEMFUNC_P (fntype
)
7687 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
7688 /* Microsoft allows `A::f' to be resolved to a
7689 pointer-to-member. */
7693 if (flags
& tf_error
)
7694 error ("cannot convert %qE from type %qT to type %qT",
7695 rhs
, TREE_TYPE (rhs
), fntype
);
7696 return error_mark_node
;
7700 if (BASELINK_P (rhs
))
7702 access_path
= BASELINK_ACCESS_BINFO (rhs
);
7703 rhs
= BASELINK_FUNCTIONS (rhs
);
7706 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
7707 deduce any type information. */
7708 if (TREE_CODE (rhs
) == NON_DEPENDENT_EXPR
)
7710 if (flags
& tf_error
)
7711 error ("not enough type information");
7712 return error_mark_node
;
7715 /* There only a few kinds of expressions that may have a type
7716 dependent on overload resolution. */
7717 gcc_assert (TREE_CODE (rhs
) == ADDR_EXPR
7718 || TREE_CODE (rhs
) == COMPONENT_REF
7719 || is_overloaded_fn (rhs
)
7720 || (flag_ms_extensions
&& TREE_CODE (rhs
) == FUNCTION_DECL
));
7722 /* This should really only be used when attempting to distinguish
7723 what sort of a pointer to function we have. For now, any
7724 arithmetic operation which is not supported on pointers
7725 is rejected as an error. */
7727 switch (TREE_CODE (rhs
))
7731 tree member
= TREE_OPERAND (rhs
, 1);
7733 member
= instantiate_type (lhstype
, member
, flags
);
7734 if (member
!= error_mark_node
7735 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs
, 0)))
7736 /* Do not lose object's side effects. */
7737 return build2 (COMPOUND_EXPR
, TREE_TYPE (member
),
7738 TREE_OPERAND (rhs
, 0), member
);
7743 rhs
= TREE_OPERAND (rhs
, 1);
7744 if (BASELINK_P (rhs
))
7745 return instantiate_type (lhstype
, rhs
, flags_in
);
7747 /* This can happen if we are forming a pointer-to-member for a
7749 gcc_assert (TREE_CODE (rhs
) == TEMPLATE_ID_EXPR
);
7753 case TEMPLATE_ID_EXPR
:
7755 tree fns
= TREE_OPERAND (rhs
, 0);
7756 tree args
= TREE_OPERAND (rhs
, 1);
7759 resolve_address_of_overloaded_function (lhstype
, fns
, flags_in
,
7760 /*template_only=*/true,
7767 resolve_address_of_overloaded_function (lhstype
, rhs
, flags_in
,
7768 /*template_only=*/false,
7769 /*explicit_targs=*/NULL_TREE
,
7774 if (PTRMEM_OK_P (rhs
))
7775 flags
|= tf_ptrmem_ok
;
7777 return instantiate_type (lhstype
, TREE_OPERAND (rhs
, 0), flags
);
7781 return error_mark_node
;
7786 return error_mark_node
;
7789 /* Return the name of the virtual function pointer field
7790 (as an IDENTIFIER_NODE) for the given TYPE. Note that
7791 this may have to look back through base types to find the
7792 ultimate field name. (For single inheritance, these could
7793 all be the same name. Who knows for multiple inheritance). */
7796 get_vfield_name (tree type
)
7798 tree binfo
, base_binfo
;
7801 for (binfo
= TYPE_BINFO (type
);
7802 BINFO_N_BASE_BINFOS (binfo
);
7805 base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
7807 if (BINFO_VIRTUAL_P (base_binfo
)
7808 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo
)))
7812 type
= BINFO_TYPE (binfo
);
7813 buf
= (char *) alloca (sizeof (VFIELD_NAME_FORMAT
)
7814 + TYPE_NAME_LENGTH (type
) + 2);
7815 sprintf (buf
, VFIELD_NAME_FORMAT
,
7816 IDENTIFIER_POINTER (constructor_name (type
)));
7817 return get_identifier (buf
);
7821 print_class_statistics (void)
7823 if (! GATHER_STATISTICS
)
7826 fprintf (stderr
, "convert_harshness = %d\n", n_convert_harshness
);
7827 fprintf (stderr
, "compute_conversion_costs = %d\n", n_compute_conversion_costs
);
7830 fprintf (stderr
, "vtables = %d; vtable searches = %d\n",
7831 n_vtables
, n_vtable_searches
);
7832 fprintf (stderr
, "vtable entries = %d; vtable elems = %d\n",
7833 n_vtable_entries
, n_vtable_elems
);
7837 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
7838 according to [class]:
7839 The class-name is also inserted
7840 into the scope of the class itself. For purposes of access checking,
7841 the inserted class name is treated as if it were a public member name. */
7844 build_self_reference (void)
7846 tree name
= constructor_name (current_class_type
);
7847 tree value
= build_lang_decl (TYPE_DECL
, name
, current_class_type
);
7850 DECL_NONLOCAL (value
) = 1;
7851 DECL_CONTEXT (value
) = current_class_type
;
7852 DECL_ARTIFICIAL (value
) = 1;
7853 SET_DECL_SELF_REFERENCE_P (value
);
7854 set_underlying_type (value
);
7856 if (processing_template_decl
)
7857 value
= push_template_decl (value
);
7859 saved_cas
= current_access_specifier
;
7860 current_access_specifier
= access_public_node
;
7861 finish_member_declaration (value
);
7862 current_access_specifier
= saved_cas
;
7865 /* Returns 1 if TYPE contains only padding bytes. */
7868 is_empty_class (tree type
)
7870 if (type
== error_mark_node
)
7873 if (! CLASS_TYPE_P (type
))
7876 return CLASSTYPE_EMPTY_P (type
);
7879 /* Returns true if TYPE contains no actual data, just various
7880 possible combinations of empty classes and possibly a vptr. */
7883 is_really_empty_class (tree type
)
7885 if (CLASS_TYPE_P (type
))
7892 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
7893 out, but we'd like to be able to check this before then. */
7894 if (COMPLETE_TYPE_P (type
) && is_empty_class (type
))
7897 for (binfo
= TYPE_BINFO (type
), i
= 0;
7898 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
7899 if (!is_really_empty_class (BINFO_TYPE (base_binfo
)))
7901 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7902 if (TREE_CODE (field
) == FIELD_DECL
7903 && !DECL_ARTIFICIAL (field
)
7904 && !is_really_empty_class (TREE_TYPE (field
)))
7908 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7909 return is_really_empty_class (TREE_TYPE (type
));
7913 /* Note that NAME was looked up while the current class was being
7914 defined and that the result of that lookup was DECL. */
7917 maybe_note_name_used_in_class (tree name
, tree decl
)
7919 splay_tree names_used
;
7921 /* If we're not defining a class, there's nothing to do. */
7922 if (!(innermost_scope_kind() == sk_class
7923 && TYPE_BEING_DEFINED (current_class_type
)
7924 && !LAMBDA_TYPE_P (current_class_type
)))
7927 /* If there's already a binding for this NAME, then we don't have
7928 anything to worry about. */
7929 if (lookup_member (current_class_type
, name
,
7930 /*protect=*/0, /*want_type=*/false, tf_warning_or_error
))
7933 if (!current_class_stack
[current_class_depth
- 1].names_used
)
7934 current_class_stack
[current_class_depth
- 1].names_used
7935 = splay_tree_new (splay_tree_compare_pointers
, 0, 0);
7936 names_used
= current_class_stack
[current_class_depth
- 1].names_used
;
7938 splay_tree_insert (names_used
,
7939 (splay_tree_key
) name
,
7940 (splay_tree_value
) decl
);
7943 /* Note that NAME was declared (as DECL) in the current class. Check
7944 to see that the declaration is valid. */
7947 note_name_declared_in_class (tree name
, tree decl
)
7949 splay_tree names_used
;
7952 /* Look to see if we ever used this name. */
7954 = current_class_stack
[current_class_depth
- 1].names_used
;
7957 /* The C language allows members to be declared with a type of the same
7958 name, and the C++ standard says this diagnostic is not required. So
7959 allow it in extern "C" blocks unless predantic is specified.
7960 Allow it in all cases if -ms-extensions is specified. */
7961 if ((!pedantic
&& current_lang_name
== lang_name_c
)
7962 || flag_ms_extensions
)
7964 n
= splay_tree_lookup (names_used
, (splay_tree_key
) name
);
7967 /* [basic.scope.class]
7969 A name N used in a class S shall refer to the same declaration
7970 in its context and when re-evaluated in the completed scope of
7972 permerror (input_location
, "declaration of %q#D", decl
);
7973 permerror (input_location
, "changes meaning of %qD from %q+#D",
7974 DECL_NAME (OVL_CURRENT (decl
)), (tree
) n
->value
);
7978 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
7979 Secondary vtables are merged with primary vtables; this function
7980 will return the VAR_DECL for the primary vtable. */
7983 get_vtbl_decl_for_binfo (tree binfo
)
7987 decl
= BINFO_VTABLE (binfo
);
7988 if (decl
&& TREE_CODE (decl
) == POINTER_PLUS_EXPR
)
7990 gcc_assert (TREE_CODE (TREE_OPERAND (decl
, 0)) == ADDR_EXPR
);
7991 decl
= TREE_OPERAND (TREE_OPERAND (decl
, 0), 0);
7994 gcc_assert (VAR_P (decl
));
7999 /* Returns the binfo for the primary base of BINFO. If the resulting
8000 BINFO is a virtual base, and it is inherited elsewhere in the
8001 hierarchy, then the returned binfo might not be the primary base of
8002 BINFO in the complete object. Check BINFO_PRIMARY_P or
8003 BINFO_LOST_PRIMARY_P to be sure. */
8006 get_primary_binfo (tree binfo
)
8010 primary_base
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo
));
8014 return copied_binfo (primary_base
, binfo
);
8017 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
8020 maybe_indent_hierarchy (FILE * stream
, int indent
, int indented_p
)
8023 fprintf (stream
, "%*s", indent
, "");
8027 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
8028 INDENT should be zero when called from the top level; it is
8029 incremented recursively. IGO indicates the next expected BINFO in
8030 inheritance graph ordering. */
8033 dump_class_hierarchy_r (FILE *stream
,
8043 indented
= maybe_indent_hierarchy (stream
, indent
, 0);
8044 fprintf (stream
, "%s (0x" HOST_WIDE_INT_PRINT_HEX
") ",
8045 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
),
8046 (HOST_WIDE_INT
) (uintptr_t) binfo
);
8049 fprintf (stream
, "alternative-path\n");
8052 igo
= TREE_CHAIN (binfo
);
8054 fprintf (stream
, HOST_WIDE_INT_PRINT_DEC
,
8055 tree_to_shwi (BINFO_OFFSET (binfo
)));
8056 if (is_empty_class (BINFO_TYPE (binfo
)))
8057 fprintf (stream
, " empty");
8058 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo
)))
8059 fprintf (stream
, " nearly-empty");
8060 if (BINFO_VIRTUAL_P (binfo
))
8061 fprintf (stream
, " virtual");
8062 fprintf (stream
, "\n");
8065 if (BINFO_PRIMARY_P (binfo
))
8067 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8068 fprintf (stream
, " primary-for %s (0x" HOST_WIDE_INT_PRINT_HEX
")",
8069 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo
)),
8070 TFF_PLAIN_IDENTIFIER
),
8071 (HOST_WIDE_INT
) (uintptr_t) BINFO_INHERITANCE_CHAIN (binfo
));
8073 if (BINFO_LOST_PRIMARY_P (binfo
))
8075 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8076 fprintf (stream
, " lost-primary");
8079 fprintf (stream
, "\n");
8081 if (!(flags
& TDF_SLIM
))
8085 if (BINFO_SUBVTT_INDEX (binfo
))
8087 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8088 fprintf (stream
, " subvttidx=%s",
8089 expr_as_string (BINFO_SUBVTT_INDEX (binfo
),
8090 TFF_PLAIN_IDENTIFIER
));
8092 if (BINFO_VPTR_INDEX (binfo
))
8094 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8095 fprintf (stream
, " vptridx=%s",
8096 expr_as_string (BINFO_VPTR_INDEX (binfo
),
8097 TFF_PLAIN_IDENTIFIER
));
8099 if (BINFO_VPTR_FIELD (binfo
))
8101 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8102 fprintf (stream
, " vbaseoffset=%s",
8103 expr_as_string (BINFO_VPTR_FIELD (binfo
),
8104 TFF_PLAIN_IDENTIFIER
));
8106 if (BINFO_VTABLE (binfo
))
8108 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8109 fprintf (stream
, " vptr=%s",
8110 expr_as_string (BINFO_VTABLE (binfo
),
8111 TFF_PLAIN_IDENTIFIER
));
8115 fprintf (stream
, "\n");
8118 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
8119 igo
= dump_class_hierarchy_r (stream
, flags
, base_binfo
, igo
, indent
+ 2);
8124 /* Dump the BINFO hierarchy for T. */
8127 dump_class_hierarchy_1 (FILE *stream
, int flags
, tree t
)
8129 fprintf (stream
, "Class %s\n", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8130 fprintf (stream
, " size=%lu align=%lu\n",
8131 (unsigned long)(tree_to_shwi (TYPE_SIZE (t
)) / BITS_PER_UNIT
),
8132 (unsigned long)(TYPE_ALIGN (t
) / BITS_PER_UNIT
));
8133 fprintf (stream
, " base size=%lu base align=%lu\n",
8134 (unsigned long)(tree_to_shwi (TYPE_SIZE (CLASSTYPE_AS_BASE (t
)))
8136 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t
))
8138 dump_class_hierarchy_r (stream
, flags
, TYPE_BINFO (t
), TYPE_BINFO (t
), 0);
8139 fprintf (stream
, "\n");
8142 /* Debug interface to hierarchy dumping. */
8145 debug_class (tree t
)
8147 dump_class_hierarchy_1 (stderr
, TDF_SLIM
, t
);
8151 dump_class_hierarchy (tree t
)
8154 FILE *stream
= get_dump_info (TDI_class
, &flags
);
8158 dump_class_hierarchy_1 (stream
, flags
, t
);
8163 dump_array (FILE * stream
, tree decl
)
8166 unsigned HOST_WIDE_INT ix
;
8168 tree size
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl
)));
8170 elt
= (tree_to_shwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
))))
8172 fprintf (stream
, "%s:", decl_as_string (decl
, TFF_PLAIN_IDENTIFIER
));
8173 fprintf (stream
, " %s entries",
8174 expr_as_string (size_binop (PLUS_EXPR
, size
, size_one_node
),
8175 TFF_PLAIN_IDENTIFIER
));
8176 fprintf (stream
, "\n");
8178 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
)),
8180 fprintf (stream
, "%-4ld %s\n", (long)(ix
* elt
),
8181 expr_as_string (value
, TFF_PLAIN_IDENTIFIER
));
8185 dump_vtable (tree t
, tree binfo
, tree vtable
)
8188 FILE *stream
= get_dump_info (TDI_class
, &flags
);
8193 if (!(flags
& TDF_SLIM
))
8195 int ctor_vtbl_p
= TYPE_BINFO (t
) != binfo
;
8197 fprintf (stream
, "%s for %s",
8198 ctor_vtbl_p
? "Construction vtable" : "Vtable",
8199 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
));
8202 if (!BINFO_VIRTUAL_P (binfo
))
8203 fprintf (stream
, " (0x" HOST_WIDE_INT_PRINT_HEX
" instance)",
8204 (HOST_WIDE_INT
) (uintptr_t) binfo
);
8205 fprintf (stream
, " in %s", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8207 fprintf (stream
, "\n");
8208 dump_array (stream
, vtable
);
8209 fprintf (stream
, "\n");
8214 dump_vtt (tree t
, tree vtt
)
8217 FILE *stream
= get_dump_info (TDI_class
, &flags
);
8222 if (!(flags
& TDF_SLIM
))
8224 fprintf (stream
, "VTT for %s\n",
8225 type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8226 dump_array (stream
, vtt
);
8227 fprintf (stream
, "\n");
8231 /* Dump a function or thunk and its thunkees. */
8234 dump_thunk (FILE *stream
, int indent
, tree thunk
)
8236 static const char spaces
[] = " ";
8237 tree name
= DECL_NAME (thunk
);
8240 fprintf (stream
, "%.*s%p %s %s", indent
, spaces
,
8242 !DECL_THUNK_P (thunk
) ? "function"
8243 : DECL_THIS_THUNK_P (thunk
) ? "this-thunk" : "covariant-thunk",
8244 name
? IDENTIFIER_POINTER (name
) : "<unset>");
8245 if (DECL_THUNK_P (thunk
))
8247 HOST_WIDE_INT fixed_adjust
= THUNK_FIXED_OFFSET (thunk
);
8248 tree virtual_adjust
= THUNK_VIRTUAL_OFFSET (thunk
);
8250 fprintf (stream
, " fixed=" HOST_WIDE_INT_PRINT_DEC
, fixed_adjust
);
8251 if (!virtual_adjust
)
8253 else if (DECL_THIS_THUNK_P (thunk
))
8254 fprintf (stream
, " vcall=" HOST_WIDE_INT_PRINT_DEC
,
8255 tree_to_shwi (virtual_adjust
));
8257 fprintf (stream
, " vbase=" HOST_WIDE_INT_PRINT_DEC
"(%s)",
8258 tree_to_shwi (BINFO_VPTR_FIELD (virtual_adjust
)),
8259 type_as_string (BINFO_TYPE (virtual_adjust
), TFF_SCOPE
));
8260 if (THUNK_ALIAS (thunk
))
8261 fprintf (stream
, " alias to %p", (void *)THUNK_ALIAS (thunk
));
8263 fprintf (stream
, "\n");
8264 for (thunks
= DECL_THUNKS (thunk
); thunks
; thunks
= TREE_CHAIN (thunks
))
8265 dump_thunk (stream
, indent
+ 2, thunks
);
8268 /* Dump the thunks for FN. */
8271 debug_thunks (tree fn
)
8273 dump_thunk (stderr
, 0, fn
);
8276 /* Virtual function table initialization. */
8278 /* Create all the necessary vtables for T and its base classes. */
8281 finish_vtbls (tree t
)
8284 vec
<constructor_elt
, va_gc
> *v
= NULL
;
8285 tree vtable
= BINFO_VTABLE (TYPE_BINFO (t
));
8287 /* We lay out the primary and secondary vtables in one contiguous
8288 vtable. The primary vtable is first, followed by the non-virtual
8289 secondary vtables in inheritance graph order. */
8290 accumulate_vtbl_inits (TYPE_BINFO (t
), TYPE_BINFO (t
), TYPE_BINFO (t
),
8293 /* Then come the virtual bases, also in inheritance graph order. */
8294 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
8296 if (!BINFO_VIRTUAL_P (vbase
))
8298 accumulate_vtbl_inits (vbase
, vbase
, TYPE_BINFO (t
), vtable
, t
, &v
);
8301 if (BINFO_VTABLE (TYPE_BINFO (t
)))
8302 initialize_vtable (TYPE_BINFO (t
), v
);
8305 /* Initialize the vtable for BINFO with the INITS. */
8308 initialize_vtable (tree binfo
, vec
<constructor_elt
, va_gc
> *inits
)
8312 layout_vtable_decl (binfo
, vec_safe_length (inits
));
8313 decl
= get_vtbl_decl_for_binfo (binfo
);
8314 initialize_artificial_var (decl
, inits
);
8315 dump_vtable (BINFO_TYPE (binfo
), binfo
, decl
);
8318 /* Build the VTT (virtual table table) for T.
8319 A class requires a VTT if it has virtual bases.
8322 1 - primary virtual pointer for complete object T
8323 2 - secondary VTTs for each direct non-virtual base of T which requires a
8325 3 - secondary virtual pointers for each direct or indirect base of T which
8326 has virtual bases or is reachable via a virtual path from T.
8327 4 - secondary VTTs for each direct or indirect virtual base of T.
8329 Secondary VTTs look like complete object VTTs without part 4. */
8337 vec
<constructor_elt
, va_gc
> *inits
;
8339 /* Build up the initializers for the VTT. */
8341 index
= size_zero_node
;
8342 build_vtt_inits (TYPE_BINFO (t
), t
, &inits
, &index
);
8344 /* If we didn't need a VTT, we're done. */
8348 /* Figure out the type of the VTT. */
8349 type
= build_array_of_n_type (const_ptr_type_node
,
8352 /* Now, build the VTT object itself. */
8353 vtt
= build_vtable (t
, mangle_vtt_for_type (t
), type
);
8354 initialize_artificial_var (vtt
, inits
);
8355 /* Add the VTT to the vtables list. */
8356 DECL_CHAIN (vtt
) = DECL_CHAIN (CLASSTYPE_VTABLES (t
));
8357 DECL_CHAIN (CLASSTYPE_VTABLES (t
)) = vtt
;
8362 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
8363 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
8364 and CHAIN the vtable pointer for this binfo after construction is
8365 complete. VALUE can also be another BINFO, in which case we recurse. */
8368 binfo_ctor_vtable (tree binfo
)
8374 vt
= BINFO_VTABLE (binfo
);
8375 if (TREE_CODE (vt
) == TREE_LIST
)
8376 vt
= TREE_VALUE (vt
);
8377 if (TREE_CODE (vt
) == TREE_BINFO
)
8386 /* Data for secondary VTT initialization. */
8387 typedef struct secondary_vptr_vtt_init_data_s
8389 /* Is this the primary VTT? */
8392 /* Current index into the VTT. */
8395 /* Vector of initializers built up. */
8396 vec
<constructor_elt
, va_gc
> *inits
;
8398 /* The type being constructed by this secondary VTT. */
8399 tree type_being_constructed
;
8400 } secondary_vptr_vtt_init_data
;
8402 /* Recursively build the VTT-initializer for BINFO (which is in the
8403 hierarchy dominated by T). INITS points to the end of the initializer
8404 list to date. INDEX is the VTT index where the next element will be
8405 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
8406 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
8407 for virtual bases of T. When it is not so, we build the constructor
8408 vtables for the BINFO-in-T variant. */
8411 build_vtt_inits (tree binfo
, tree t
, vec
<constructor_elt
, va_gc
> **inits
,
8417 secondary_vptr_vtt_init_data data
;
8418 int top_level_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
8420 /* We only need VTTs for subobjects with virtual bases. */
8421 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
8424 /* We need to use a construction vtable if this is not the primary
8428 build_ctor_vtbl_group (binfo
, t
);
8430 /* Record the offset in the VTT where this sub-VTT can be found. */
8431 BINFO_SUBVTT_INDEX (binfo
) = *index
;
8434 /* Add the address of the primary vtable for the complete object. */
8435 init
= binfo_ctor_vtable (binfo
);
8436 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8439 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
8440 BINFO_VPTR_INDEX (binfo
) = *index
;
8442 *index
= size_binop (PLUS_EXPR
, *index
, TYPE_SIZE_UNIT (ptr_type_node
));
8444 /* Recursively add the secondary VTTs for non-virtual bases. */
8445 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, b
); ++i
)
8446 if (!BINFO_VIRTUAL_P (b
))
8447 build_vtt_inits (b
, t
, inits
, index
);
8449 /* Add secondary virtual pointers for all subobjects of BINFO with
8450 either virtual bases or reachable along a virtual path, except
8451 subobjects that are non-virtual primary bases. */
8452 data
.top_level_p
= top_level_p
;
8453 data
.index
= *index
;
8454 data
.inits
= *inits
;
8455 data
.type_being_constructed
= BINFO_TYPE (binfo
);
8457 dfs_walk_once (binfo
, dfs_build_secondary_vptr_vtt_inits
, NULL
, &data
);
8459 *index
= data
.index
;
8461 /* data.inits might have grown as we added secondary virtual pointers.
8462 Make sure our caller knows about the new vector. */
8463 *inits
= data
.inits
;
8466 /* Add the secondary VTTs for virtual bases in inheritance graph
8468 for (b
= TYPE_BINFO (BINFO_TYPE (binfo
)); b
; b
= TREE_CHAIN (b
))
8470 if (!BINFO_VIRTUAL_P (b
))
8473 build_vtt_inits (b
, t
, inits
, index
);
8476 /* Remove the ctor vtables we created. */
8477 dfs_walk_all (binfo
, dfs_fixup_binfo_vtbls
, NULL
, binfo
);
8480 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
8481 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
8484 dfs_build_secondary_vptr_vtt_inits (tree binfo
, void *data_
)
8486 secondary_vptr_vtt_init_data
*data
= (secondary_vptr_vtt_init_data
*)data_
;
8488 /* We don't care about bases that don't have vtables. */
8489 if (!TYPE_VFIELD (BINFO_TYPE (binfo
)))
8490 return dfs_skip_bases
;
8492 /* We're only interested in proper subobjects of the type being
8494 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->type_being_constructed
))
8497 /* We're only interested in bases with virtual bases or reachable
8498 via a virtual path from the type being constructed. */
8499 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
8500 || binfo_via_virtual (binfo
, data
->type_being_constructed
)))
8501 return dfs_skip_bases
;
8503 /* We're not interested in non-virtual primary bases. */
8504 if (!BINFO_VIRTUAL_P (binfo
) && BINFO_PRIMARY_P (binfo
))
8507 /* Record the index where this secondary vptr can be found. */
8508 if (data
->top_level_p
)
8510 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
8511 BINFO_VPTR_INDEX (binfo
) = data
->index
;
8513 if (BINFO_VIRTUAL_P (binfo
))
8515 /* It's a primary virtual base, and this is not a
8516 construction vtable. Find the base this is primary of in
8517 the inheritance graph, and use that base's vtable
8519 while (BINFO_PRIMARY_P (binfo
))
8520 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
8524 /* Add the initializer for the secondary vptr itself. */
8525 CONSTRUCTOR_APPEND_ELT (data
->inits
, NULL_TREE
, binfo_ctor_vtable (binfo
));
8527 /* Advance the vtt index. */
8528 data
->index
= size_binop (PLUS_EXPR
, data
->index
,
8529 TYPE_SIZE_UNIT (ptr_type_node
));
8534 /* Called from build_vtt_inits via dfs_walk. After building
8535 constructor vtables and generating the sub-vtt from them, we need
8536 to restore the BINFO_VTABLES that were scribbled on. DATA is the
8537 binfo of the base whose sub vtt was generated. */
8540 dfs_fixup_binfo_vtbls (tree binfo
, void* data
)
8542 tree vtable
= BINFO_VTABLE (binfo
);
8544 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
8545 /* If this class has no vtable, none of its bases do. */
8546 return dfs_skip_bases
;
8549 /* This might be a primary base, so have no vtable in this
8553 /* If we scribbled the construction vtable vptr into BINFO, clear it
8555 if (TREE_CODE (vtable
) == TREE_LIST
8556 && (TREE_PURPOSE (vtable
) == (tree
) data
))
8557 BINFO_VTABLE (binfo
) = TREE_CHAIN (vtable
);
8562 /* Build the construction vtable group for BINFO which is in the
8563 hierarchy dominated by T. */
8566 build_ctor_vtbl_group (tree binfo
, tree t
)
8572 vec
<constructor_elt
, va_gc
> *v
;
8574 /* See if we've already created this construction vtable group. */
8575 id
= mangle_ctor_vtbl_for_type (t
, binfo
);
8576 if (IDENTIFIER_GLOBAL_VALUE (id
))
8579 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
));
8580 /* Build a version of VTBL (with the wrong type) for use in
8581 constructing the addresses of secondary vtables in the
8582 construction vtable group. */
8583 vtbl
= build_vtable (t
, id
, ptr_type_node
);
8584 DECL_CONSTRUCTION_VTABLE_P (vtbl
) = 1;
8585 /* Don't export construction vtables from shared libraries. Even on
8586 targets that don't support hidden visibility, this tells
8587 can_refer_decl_in_current_unit_p not to assume that it's safe to
8588 access from a different compilation unit (bz 54314). */
8589 DECL_VISIBILITY (vtbl
) = VISIBILITY_HIDDEN
;
8590 DECL_VISIBILITY_SPECIFIED (vtbl
) = true;
8593 accumulate_vtbl_inits (binfo
, TYPE_BINFO (TREE_TYPE (binfo
)),
8594 binfo
, vtbl
, t
, &v
);
8596 /* Add the vtables for each of our virtual bases using the vbase in T
8598 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
8600 vbase
= TREE_CHAIN (vbase
))
8604 if (!BINFO_VIRTUAL_P (vbase
))
8606 b
= copied_binfo (vbase
, binfo
);
8608 accumulate_vtbl_inits (b
, vbase
, binfo
, vtbl
, t
, &v
);
8611 /* Figure out the type of the construction vtable. */
8612 type
= build_array_of_n_type (vtable_entry_type
, v
->length ());
8614 TREE_TYPE (vtbl
) = type
;
8615 DECL_SIZE (vtbl
) = DECL_SIZE_UNIT (vtbl
) = NULL_TREE
;
8616 layout_decl (vtbl
, 0);
8618 /* Initialize the construction vtable. */
8619 CLASSTYPE_VTABLES (t
) = chainon (CLASSTYPE_VTABLES (t
), vtbl
);
8620 initialize_artificial_var (vtbl
, v
);
8621 dump_vtable (t
, binfo
, vtbl
);
8624 /* Add the vtbl initializers for BINFO (and its bases other than
8625 non-virtual primaries) to the list of INITS. BINFO is in the
8626 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
8627 the constructor the vtbl inits should be accumulated for. (If this
8628 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
8629 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
8630 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
8631 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
8632 but are not necessarily the same in terms of layout. */
8635 accumulate_vtbl_inits (tree binfo
,
8640 vec
<constructor_elt
, va_gc
> **inits
)
8644 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8646 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (orig_binfo
)));
8648 /* If it doesn't have a vptr, we don't do anything. */
8649 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
8652 /* If we're building a construction vtable, we're not interested in
8653 subobjects that don't require construction vtables. */
8655 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
8656 && !binfo_via_virtual (orig_binfo
, BINFO_TYPE (rtti_binfo
)))
8659 /* Build the initializers for the BINFO-in-T vtable. */
8660 dfs_accumulate_vtbl_inits (binfo
, orig_binfo
, rtti_binfo
, vtbl
, t
, inits
);
8662 /* Walk the BINFO and its bases. We walk in preorder so that as we
8663 initialize each vtable we can figure out at what offset the
8664 secondary vtable lies from the primary vtable. We can't use
8665 dfs_walk here because we need to iterate through bases of BINFO
8666 and RTTI_BINFO simultaneously. */
8667 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
8669 /* Skip virtual bases. */
8670 if (BINFO_VIRTUAL_P (base_binfo
))
8672 accumulate_vtbl_inits (base_binfo
,
8673 BINFO_BASE_BINFO (orig_binfo
, i
),
8674 rtti_binfo
, vtbl
, t
,
8679 /* Called from accumulate_vtbl_inits. Adds the initializers for the
8680 BINFO vtable to L. */
8683 dfs_accumulate_vtbl_inits (tree binfo
,
8688 vec
<constructor_elt
, va_gc
> **l
)
8690 tree vtbl
= NULL_TREE
;
8691 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8695 && BINFO_VIRTUAL_P (orig_binfo
) && BINFO_PRIMARY_P (orig_binfo
))
8697 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
8698 primary virtual base. If it is not the same primary in
8699 the hierarchy of T, we'll need to generate a ctor vtable
8700 for it, to place at its location in T. If it is the same
8701 primary, we still need a VTT entry for the vtable, but it
8702 should point to the ctor vtable for the base it is a
8703 primary for within the sub-hierarchy of RTTI_BINFO.
8705 There are three possible cases:
8707 1) We are in the same place.
8708 2) We are a primary base within a lost primary virtual base of
8710 3) We are primary to something not a base of RTTI_BINFO. */
8713 tree last
= NULL_TREE
;
8715 /* First, look through the bases we are primary to for RTTI_BINFO
8716 or a virtual base. */
8718 while (BINFO_PRIMARY_P (b
))
8720 b
= BINFO_INHERITANCE_CHAIN (b
);
8722 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
8725 /* If we run out of primary links, keep looking down our
8726 inheritance chain; we might be an indirect primary. */
8727 for (b
= last
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
8728 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
8732 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
8733 base B and it is a base of RTTI_BINFO, this is case 2. In
8734 either case, we share our vtable with LAST, i.e. the
8735 derived-most base within B of which we are a primary. */
8737 || (b
&& binfo_for_vbase (BINFO_TYPE (b
), BINFO_TYPE (rtti_binfo
))))
8738 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
8739 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
8740 binfo_ctor_vtable after everything's been set up. */
8743 /* Otherwise, this is case 3 and we get our own. */
8745 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo
))
8748 n_inits
= vec_safe_length (*l
);
8755 /* Add the initializer for this vtable. */
8756 build_vtbl_initializer (binfo
, orig_binfo
, t
, rtti_binfo
,
8757 &non_fn_entries
, l
);
8759 /* Figure out the position to which the VPTR should point. */
8760 vtbl
= build1 (ADDR_EXPR
, vtbl_ptr_type_node
, orig_vtbl
);
8761 index
= size_binop (MULT_EXPR
,
8762 TYPE_SIZE_UNIT (vtable_entry_type
),
8763 size_int (non_fn_entries
+ n_inits
));
8764 vtbl
= fold_build_pointer_plus (vtbl
, index
);
8768 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
8769 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
8770 straighten this out. */
8771 BINFO_VTABLE (binfo
) = tree_cons (rtti_binfo
, vtbl
, BINFO_VTABLE (binfo
));
8772 else if (BINFO_PRIMARY_P (binfo
) && BINFO_VIRTUAL_P (binfo
))
8773 /* Throw away any unneeded intializers. */
8774 (*l
)->truncate (n_inits
);
8776 /* For an ordinary vtable, set BINFO_VTABLE. */
8777 BINFO_VTABLE (binfo
) = vtbl
;
8780 static GTY(()) tree abort_fndecl_addr
;
8782 /* Construct the initializer for BINFO's virtual function table. BINFO
8783 is part of the hierarchy dominated by T. If we're building a
8784 construction vtable, the ORIG_BINFO is the binfo we should use to
8785 find the actual function pointers to put in the vtable - but they
8786 can be overridden on the path to most-derived in the graph that
8787 ORIG_BINFO belongs. Otherwise,
8788 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
8789 BINFO that should be indicated by the RTTI information in the
8790 vtable; it will be a base class of T, rather than T itself, if we
8791 are building a construction vtable.
8793 The value returned is a TREE_LIST suitable for wrapping in a
8794 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
8795 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
8796 number of non-function entries in the vtable.
8798 It might seem that this function should never be called with a
8799 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
8800 base is always subsumed by a derived class vtable. However, when
8801 we are building construction vtables, we do build vtables for
8802 primary bases; we need these while the primary base is being
8806 build_vtbl_initializer (tree binfo
,
8810 int* non_fn_entries_p
,
8811 vec
<constructor_elt
, va_gc
> **inits
)
8817 vec
<tree
, va_gc
> *vbases
;
8820 /* Initialize VID. */
8821 memset (&vid
, 0, sizeof (vid
));
8824 vid
.rtti_binfo
= rtti_binfo
;
8825 vid
.primary_vtbl_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
8826 vid
.ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8827 vid
.generate_vcall_entries
= true;
8828 /* The first vbase or vcall offset is at index -3 in the vtable. */
8829 vid
.index
= ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
8831 /* Add entries to the vtable for RTTI. */
8832 build_rtti_vtbl_entries (binfo
, &vid
);
8834 /* Create an array for keeping track of the functions we've
8835 processed. When we see multiple functions with the same
8836 signature, we share the vcall offsets. */
8837 vec_alloc (vid
.fns
, 32);
8838 /* Add the vcall and vbase offset entries. */
8839 build_vcall_and_vbase_vtbl_entries (binfo
, &vid
);
8841 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
8842 build_vbase_offset_vtbl_entries. */
8843 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
8844 vec_safe_iterate (vbases
, ix
, &vbinfo
); ix
++)
8845 BINFO_VTABLE_PATH_MARKED (vbinfo
) = 0;
8847 /* If the target requires padding between data entries, add that now. */
8848 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE
> 1)
8850 int n_entries
= vec_safe_length (vid
.inits
);
8852 vec_safe_grow (vid
.inits
, TARGET_VTABLE_DATA_ENTRY_DISTANCE
* n_entries
);
8854 /* Move data entries into their new positions and add padding
8855 after the new positions. Iterate backwards so we don't
8856 overwrite entries that we would need to process later. */
8857 for (ix
= n_entries
- 1;
8858 vid
.inits
->iterate (ix
, &e
);
8862 int new_position
= (TARGET_VTABLE_DATA_ENTRY_DISTANCE
* ix
8863 + (TARGET_VTABLE_DATA_ENTRY_DISTANCE
- 1));
8865 (*vid
.inits
)[new_position
] = *e
;
8867 for (j
= 1; j
< TARGET_VTABLE_DATA_ENTRY_DISTANCE
; ++j
)
8869 constructor_elt
*f
= &(*vid
.inits
)[new_position
- j
];
8870 f
->index
= NULL_TREE
;
8871 f
->value
= build1 (NOP_EXPR
, vtable_entry_type
,
8877 if (non_fn_entries_p
)
8878 *non_fn_entries_p
= vec_safe_length (vid
.inits
);
8880 /* The initializers for virtual functions were built up in reverse
8881 order. Straighten them out and add them to the running list in one
8883 jx
= vec_safe_length (*inits
);
8884 vec_safe_grow (*inits
, jx
+ vid
.inits
->length ());
8886 for (ix
= vid
.inits
->length () - 1;
8887 vid
.inits
->iterate (ix
, &e
);
8891 /* Go through all the ordinary virtual functions, building up
8893 for (v
= BINFO_VIRTUALS (orig_binfo
); v
; v
= TREE_CHAIN (v
))
8897 tree fn
, fn_original
;
8898 tree init
= NULL_TREE
;
8902 if (DECL_THUNK_P (fn
))
8904 if (!DECL_NAME (fn
))
8906 if (THUNK_ALIAS (fn
))
8908 fn
= THUNK_ALIAS (fn
);
8911 fn_original
= THUNK_TARGET (fn
);
8914 /* If the only definition of this function signature along our
8915 primary base chain is from a lost primary, this vtable slot will
8916 never be used, so just zero it out. This is important to avoid
8917 requiring extra thunks which cannot be generated with the function.
8919 We first check this in update_vtable_entry_for_fn, so we handle
8920 restored primary bases properly; we also need to do it here so we
8921 zero out unused slots in ctor vtables, rather than filling them
8922 with erroneous values (though harmless, apart from relocation
8924 if (BV_LOST_PRIMARY (v
))
8925 init
= size_zero_node
;
8929 /* Pull the offset for `this', and the function to call, out of
8931 delta
= BV_DELTA (v
);
8932 vcall_index
= BV_VCALL_INDEX (v
);
8934 gcc_assert (TREE_CODE (delta
) == INTEGER_CST
);
8935 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
8937 /* You can't call an abstract virtual function; it's abstract.
8938 So, we replace these functions with __pure_virtual. */
8939 if (DECL_PURE_VIRTUAL_P (fn_original
))
8942 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8944 if (abort_fndecl_addr
== NULL
)
8946 = fold_convert (vfunc_ptr_type_node
,
8947 build_fold_addr_expr (fn
));
8948 init
= abort_fndecl_addr
;
8951 /* Likewise for deleted virtuals. */
8952 else if (DECL_DELETED_FN (fn_original
))
8954 fn
= get_identifier ("__cxa_deleted_virtual");
8955 if (!get_global_value_if_present (fn
, &fn
))
8956 fn
= push_library_fn (fn
, (build_function_type_list
8957 (void_type_node
, NULL_TREE
)),
8958 NULL_TREE
, ECF_NORETURN
);
8959 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8960 init
= fold_convert (vfunc_ptr_type_node
,
8961 build_fold_addr_expr (fn
));
8965 if (!integer_zerop (delta
) || vcall_index
)
8967 fn
= make_thunk (fn
, /*this_adjusting=*/1, delta
, vcall_index
);
8968 if (!DECL_NAME (fn
))
8971 /* Take the address of the function, considering it to be of an
8972 appropriate generic type. */
8973 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8974 init
= fold_convert (vfunc_ptr_type_node
,
8975 build_fold_addr_expr (fn
));
8976 /* Don't refer to a virtual destructor from a constructor
8977 vtable or a vtable for an abstract class, since destroying
8978 an object under construction is undefined behavior and we
8979 don't want it to be considered a candidate for speculative
8980 devirtualization. But do create the thunk for ABI
8982 if (DECL_DESTRUCTOR_P (fn_original
)
8983 && (CLASSTYPE_PURE_VIRTUALS (DECL_CONTEXT (fn_original
))
8984 || orig_binfo
!= binfo
))
8985 init
= size_zero_node
;
8989 /* And add it to the chain of initializers. */
8990 if (TARGET_VTABLE_USES_DESCRIPTORS
)
8993 if (init
== size_zero_node
)
8994 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
8995 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8997 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
8999 tree fdesc
= build2 (FDESC_EXPR
, vfunc_ptr_type_node
,
9000 fn
, build_int_cst (NULL_TREE
, i
));
9001 TREE_CONSTANT (fdesc
) = 1;
9003 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, fdesc
);
9007 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
9011 /* Adds to vid->inits the initializers for the vbase and vcall
9012 offsets in BINFO, which is in the hierarchy dominated by T. */
9015 build_vcall_and_vbase_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9019 /* If this is a derived class, we must first create entries
9020 corresponding to the primary base class. */
9021 b
= get_primary_binfo (binfo
);
9023 build_vcall_and_vbase_vtbl_entries (b
, vid
);
9025 /* Add the vbase entries for this base. */
9026 build_vbase_offset_vtbl_entries (binfo
, vid
);
9027 /* Add the vcall entries for this base. */
9028 build_vcall_offset_vtbl_entries (binfo
, vid
);
9031 /* Returns the initializers for the vbase offset entries in the vtable
9032 for BINFO (which is part of the class hierarchy dominated by T), in
9033 reverse order. VBASE_OFFSET_INDEX gives the vtable index
9034 where the next vbase offset will go. */
9037 build_vbase_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9041 tree non_primary_binfo
;
9043 /* If there are no virtual baseclasses, then there is nothing to
9045 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
9050 /* We might be a primary base class. Go up the inheritance hierarchy
9051 until we find the most derived class of which we are a primary base:
9052 it is the offset of that which we need to use. */
9053 non_primary_binfo
= binfo
;
9054 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
9058 /* If we have reached a virtual base, then it must be a primary
9059 base (possibly multi-level) of vid->binfo, or we wouldn't
9060 have called build_vcall_and_vbase_vtbl_entries for it. But it
9061 might be a lost primary, so just skip down to vid->binfo. */
9062 if (BINFO_VIRTUAL_P (non_primary_binfo
))
9064 non_primary_binfo
= vid
->binfo
;
9068 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
9069 if (get_primary_binfo (b
) != non_primary_binfo
)
9071 non_primary_binfo
= b
;
9074 /* Go through the virtual bases, adding the offsets. */
9075 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
9077 vbase
= TREE_CHAIN (vbase
))
9082 if (!BINFO_VIRTUAL_P (vbase
))
9085 /* Find the instance of this virtual base in the complete
9087 b
= copied_binfo (vbase
, binfo
);
9089 /* If we've already got an offset for this virtual base, we
9090 don't need another one. */
9091 if (BINFO_VTABLE_PATH_MARKED (b
))
9093 BINFO_VTABLE_PATH_MARKED (b
) = 1;
9095 /* Figure out where we can find this vbase offset. */
9096 delta
= size_binop (MULT_EXPR
,
9099 TYPE_SIZE_UNIT (vtable_entry_type
)));
9100 if (vid
->primary_vtbl_p
)
9101 BINFO_VPTR_FIELD (b
) = delta
;
9103 if (binfo
!= TYPE_BINFO (t
))
9104 /* The vbase offset had better be the same. */
9105 gcc_assert (tree_int_cst_equal (delta
, BINFO_VPTR_FIELD (vbase
)));
9107 /* The next vbase will come at a more negative offset. */
9108 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
9109 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
9111 /* The initializer is the delta from BINFO to this virtual base.
9112 The vbase offsets go in reverse inheritance-graph order, and
9113 we are walking in inheritance graph order so these end up in
9115 delta
= size_diffop_loc (input_location
,
9116 BINFO_OFFSET (b
), BINFO_OFFSET (non_primary_binfo
));
9118 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
,
9119 fold_build1_loc (input_location
, NOP_EXPR
,
9120 vtable_entry_type
, delta
));
9124 /* Adds the initializers for the vcall offset entries in the vtable
9125 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
9129 build_vcall_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9131 /* We only need these entries if this base is a virtual base. We
9132 compute the indices -- but do not add to the vtable -- when
9133 building the main vtable for a class. */
9134 if (binfo
== TYPE_BINFO (vid
->derived
)
9135 || (BINFO_VIRTUAL_P (binfo
)
9136 /* If BINFO is RTTI_BINFO, then (since BINFO does not
9137 correspond to VID->DERIVED), we are building a primary
9138 construction virtual table. Since this is a primary
9139 virtual table, we do not need the vcall offsets for
9141 && binfo
!= vid
->rtti_binfo
))
9143 /* We need a vcall offset for each of the virtual functions in this
9144 vtable. For example:
9146 class A { virtual void f (); };
9147 class B1 : virtual public A { virtual void f (); };
9148 class B2 : virtual public A { virtual void f (); };
9149 class C: public B1, public B2 { virtual void f (); };
9151 A C object has a primary base of B1, which has a primary base of A. A
9152 C also has a secondary base of B2, which no longer has a primary base
9153 of A. So the B2-in-C construction vtable needs a secondary vtable for
9154 A, which will adjust the A* to a B2* to call f. We have no way of
9155 knowing what (or even whether) this offset will be when we define B2,
9156 so we store this "vcall offset" in the A sub-vtable and look it up in
9157 a "virtual thunk" for B2::f.
9159 We need entries for all the functions in our primary vtable and
9160 in our non-virtual bases' secondary vtables. */
9162 /* If we are just computing the vcall indices -- but do not need
9163 the actual entries -- not that. */
9164 if (!BINFO_VIRTUAL_P (binfo
))
9165 vid
->generate_vcall_entries
= false;
9166 /* Now, walk through the non-virtual bases, adding vcall offsets. */
9167 add_vcall_offset_vtbl_entries_r (binfo
, vid
);
9171 /* Build vcall offsets, starting with those for BINFO. */
9174 add_vcall_offset_vtbl_entries_r (tree binfo
, vtbl_init_data
* vid
)
9180 /* Don't walk into virtual bases -- except, of course, for the
9181 virtual base for which we are building vcall offsets. Any
9182 primary virtual base will have already had its offsets generated
9183 through the recursion in build_vcall_and_vbase_vtbl_entries. */
9184 if (BINFO_VIRTUAL_P (binfo
) && vid
->vbase
!= binfo
)
9187 /* If BINFO has a primary base, process it first. */
9188 primary_binfo
= get_primary_binfo (binfo
);
9190 add_vcall_offset_vtbl_entries_r (primary_binfo
, vid
);
9192 /* Add BINFO itself to the list. */
9193 add_vcall_offset_vtbl_entries_1 (binfo
, vid
);
9195 /* Scan the non-primary bases of BINFO. */
9196 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
9197 if (base_binfo
!= primary_binfo
)
9198 add_vcall_offset_vtbl_entries_r (base_binfo
, vid
);
9201 /* Called from build_vcall_offset_vtbl_entries_r. */
9204 add_vcall_offset_vtbl_entries_1 (tree binfo
, vtbl_init_data
* vid
)
9206 /* Make entries for the rest of the virtuals. */
9209 /* The ABI requires that the methods be processed in declaration
9211 for (orig_fn
= TYPE_METHODS (BINFO_TYPE (binfo
));
9213 orig_fn
= DECL_CHAIN (orig_fn
))
9214 if (TREE_CODE (orig_fn
) == FUNCTION_DECL
&& DECL_VINDEX (orig_fn
))
9215 add_vcall_offset (orig_fn
, binfo
, vid
);
9218 /* Add a vcall offset entry for ORIG_FN to the vtable. */
9221 add_vcall_offset (tree orig_fn
, tree binfo
, vtbl_init_data
*vid
)
9227 /* If there is already an entry for a function with the same
9228 signature as FN, then we do not need a second vcall offset.
9229 Check the list of functions already present in the derived
9231 FOR_EACH_VEC_SAFE_ELT (vid
->fns
, i
, derived_entry
)
9233 if (same_signature_p (derived_entry
, orig_fn
)
9234 /* We only use one vcall offset for virtual destructors,
9235 even though there are two virtual table entries. */
9236 || (DECL_DESTRUCTOR_P (derived_entry
)
9237 && DECL_DESTRUCTOR_P (orig_fn
)))
9241 /* If we are building these vcall offsets as part of building
9242 the vtable for the most derived class, remember the vcall
9244 if (vid
->binfo
== TYPE_BINFO (vid
->derived
))
9246 tree_pair_s elt
= {orig_fn
, vid
->index
};
9247 vec_safe_push (CLASSTYPE_VCALL_INDICES (vid
->derived
), elt
);
9250 /* The next vcall offset will be found at a more negative
9252 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
9253 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
9255 /* Keep track of this function. */
9256 vec_safe_push (vid
->fns
, orig_fn
);
9258 if (vid
->generate_vcall_entries
)
9263 /* Find the overriding function. */
9264 fn
= find_final_overrider (vid
->rtti_binfo
, binfo
, orig_fn
);
9265 if (fn
== error_mark_node
)
9266 vcall_offset
= build_zero_cst (vtable_entry_type
);
9269 base
= TREE_VALUE (fn
);
9271 /* The vbase we're working on is a primary base of
9272 vid->binfo. But it might be a lost primary, so its
9273 BINFO_OFFSET might be wrong, so we just use the
9274 BINFO_OFFSET from vid->binfo. */
9275 vcall_offset
= size_diffop_loc (input_location
,
9276 BINFO_OFFSET (base
),
9277 BINFO_OFFSET (vid
->binfo
));
9278 vcall_offset
= fold_build1_loc (input_location
,
9279 NOP_EXPR
, vtable_entry_type
,
9282 /* Add the initializer to the vtable. */
9283 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, vcall_offset
);
9287 /* Return vtbl initializers for the RTTI entries corresponding to the
9288 BINFO's vtable. The RTTI entries should indicate the object given
9289 by VID->rtti_binfo. */
9292 build_rtti_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9300 t
= BINFO_TYPE (vid
->rtti_binfo
);
9302 /* To find the complete object, we will first convert to our most
9303 primary base, and then add the offset in the vtbl to that value. */
9305 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b
))
9306 && !BINFO_LOST_PRIMARY_P (b
))
9310 primary_base
= get_primary_binfo (b
);
9311 gcc_assert (BINFO_PRIMARY_P (primary_base
)
9312 && BINFO_INHERITANCE_CHAIN (primary_base
) == b
);
9315 offset
= size_diffop_loc (input_location
,
9316 BINFO_OFFSET (vid
->rtti_binfo
), BINFO_OFFSET (b
));
9318 /* The second entry is the address of the typeinfo object. */
9320 decl
= build_address (get_tinfo_decl (t
));
9322 decl
= integer_zero_node
;
9324 /* Convert the declaration to a type that can be stored in the
9326 init
= build_nop (vfunc_ptr_type_node
, decl
);
9327 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, init
);
9329 /* Add the offset-to-top entry. It comes earlier in the vtable than
9330 the typeinfo entry. Convert the offset to look like a
9331 function pointer, so that we can put it in the vtable. */
9332 init
= build_nop (vfunc_ptr_type_node
, offset
);
9333 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, init
);
9336 /* TRUE iff TYPE is uniquely derived from PARENT. Ignores
9340 uniquely_derived_from_p (tree parent
, tree type
)
9342 tree base
= lookup_base (type
, parent
, ba_unique
, NULL
, tf_none
);
9343 return base
&& base
!= error_mark_node
;
9346 /* TRUE iff TYPE is publicly & uniquely derived from PARENT. */
9349 publicly_uniquely_derived_p (tree parent
, tree type
)
9351 tree base
= lookup_base (type
, parent
, ba_ignore_scope
| ba_check
,
9353 return base
&& base
!= error_mark_node
;
9356 /* CTX1 and CTX2 are declaration contexts. Return the innermost common
9357 class between them, if any. */
9360 common_enclosing_class (tree ctx1
, tree ctx2
)
9362 if (!TYPE_P (ctx1
) || !TYPE_P (ctx2
))
9364 gcc_assert (ctx1
== TYPE_MAIN_VARIANT (ctx1
)
9365 && ctx2
== TYPE_MAIN_VARIANT (ctx2
));
9368 for (tree t
= ctx1
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9369 TYPE_MARKED_P (t
) = true;
9370 tree found
= NULL_TREE
;
9371 for (tree t
= ctx2
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9372 if (TYPE_MARKED_P (t
))
9377 for (tree t
= ctx1
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9378 TYPE_MARKED_P (t
) = false;
9382 #include "gt-cp-class.h"