1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987-2018 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"
31 #include "stor-layout.h"
41 /* Id for dumping the class hierarchy. */
44 /* The number of nested classes being processed. If we are not in the
45 scope of any class, this is zero. */
47 int current_class_depth
;
49 /* In order to deal with nested classes, we keep a stack of classes.
50 The topmost entry is the innermost class, and is the entry at index
51 CURRENT_CLASS_DEPTH */
53 typedef struct class_stack_node
{
54 /* The name of the class. */
57 /* The _TYPE node for the class. */
60 /* The access specifier pending for new declarations in the scope of
64 /* If were defining TYPE, the names used in this class. */
65 splay_tree names_used
;
67 /* Nonzero if this class is no longer open, because of a call to
70 }* class_stack_node_t
;
74 /* The base for which we're building initializers. */
76 /* The type of the most-derived type. */
78 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
79 unless ctor_vtbl_p is true. */
81 /* The negative-index vtable initializers built up so far. These
82 are in order from least negative index to most negative index. */
83 vec
<constructor_elt
, va_gc
> *inits
;
84 /* The binfo for the virtual base for which we're building
85 vcall offset initializers. */
87 /* The functions in vbase for which we have already provided vcall
89 vec
<tree
, va_gc
> *fns
;
90 /* The vtable index of the next vcall or vbase offset. */
92 /* Nonzero if we are building the initializer for the primary
95 /* Nonzero if we are building the initializer for a construction
98 /* True when adding vcall offset entries to the vtable. False when
99 merely computing the indices. */
100 bool generate_vcall_entries
;
103 /* The type of a function passed to walk_subobject_offsets. */
104 typedef int (*subobject_offset_fn
) (tree
, tree
, splay_tree
);
106 /* The stack itself. This is a dynamically resized array. The
107 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
108 static int current_class_stack_size
;
109 static class_stack_node_t current_class_stack
;
111 /* The size of the largest empty class seen in this translation unit. */
112 static GTY (()) tree sizeof_biggest_empty_class
;
114 /* An array of all local classes present in this translation unit, in
115 declaration order. */
116 vec
<tree
, va_gc
> *local_classes
;
118 static tree
get_vfield_name (tree
);
119 static void finish_struct_anon (tree
);
120 static tree
get_vtable_name (tree
);
121 static void get_basefndecls (tree
, tree
, vec
<tree
> *);
122 static int build_primary_vtable (tree
, tree
);
123 static int build_secondary_vtable (tree
);
124 static void finish_vtbls (tree
);
125 static void modify_vtable_entry (tree
, tree
, tree
, tree
, tree
*);
126 static void finish_struct_bits (tree
);
127 static int alter_access (tree
, tree
, tree
);
128 static void handle_using_decl (tree
, tree
);
129 static tree
dfs_modify_vtables (tree
, void *);
130 static tree
modify_all_vtables (tree
, tree
);
131 static void determine_primary_bases (tree
);
132 static void maybe_warn_about_overly_private_class (tree
);
133 static void add_implicitly_declared_members (tree
, tree
*, int, int);
134 static tree
fixed_type_or_null (tree
, int *, int *);
135 static tree
build_simple_base_path (tree expr
, tree binfo
);
136 static tree
build_vtbl_ref_1 (tree
, tree
);
137 static void build_vtbl_initializer (tree
, tree
, tree
, tree
, int *,
138 vec
<constructor_elt
, va_gc
> **);
139 static bool check_bitfield_decl (tree
);
140 static bool check_field_decl (tree
, tree
, int *, int *);
141 static void check_field_decls (tree
, tree
*, int *, int *);
142 static tree
*build_base_field (record_layout_info
, tree
, splay_tree
, tree
*);
143 static void build_base_fields (record_layout_info
, splay_tree
, tree
*);
144 static void check_methods (tree
);
145 static void remove_zero_width_bit_fields (tree
);
146 static bool accessible_nvdtor_p (tree
);
148 /* Used by find_flexarrays and related functions. */
150 static void diagnose_flexarrays (tree
, const flexmems_t
*);
151 static void find_flexarrays (tree
, flexmems_t
*, bool = false,
152 tree
= NULL_TREE
, tree
= NULL_TREE
);
153 static void check_flexarrays (tree
, flexmems_t
* = NULL
, bool = false);
154 static void check_bases (tree
, int *, int *);
155 static void check_bases_and_members (tree
);
156 static tree
create_vtable_ptr (tree
, tree
*);
157 static void include_empty_classes (record_layout_info
);
158 static void layout_class_type (tree
, tree
*);
159 static void propagate_binfo_offsets (tree
, tree
);
160 static void layout_virtual_bases (record_layout_info
, splay_tree
);
161 static void build_vbase_offset_vtbl_entries (tree
, vtbl_init_data
*);
162 static void add_vcall_offset_vtbl_entries_r (tree
, vtbl_init_data
*);
163 static void add_vcall_offset_vtbl_entries_1 (tree
, vtbl_init_data
*);
164 static void build_vcall_offset_vtbl_entries (tree
, vtbl_init_data
*);
165 static void add_vcall_offset (tree
, tree
, vtbl_init_data
*);
166 static void layout_vtable_decl (tree
, int);
167 static tree
dfs_find_final_overrider_pre (tree
, void *);
168 static tree
dfs_find_final_overrider_post (tree
, void *);
169 static tree
find_final_overrider (tree
, tree
, tree
);
170 static int make_new_vtable (tree
, tree
);
171 static tree
get_primary_binfo (tree
);
172 static int maybe_indent_hierarchy (FILE *, int, int);
173 static tree
dump_class_hierarchy_r (FILE *, dump_flags_t
, tree
, tree
, int);
174 static void dump_class_hierarchy (tree
);
175 static void dump_class_hierarchy_1 (FILE *, dump_flags_t
, tree
);
176 static void dump_array (FILE *, tree
);
177 static void dump_vtable (tree
, tree
, tree
);
178 static void dump_vtt (tree
, tree
);
179 static void dump_thunk (FILE *, int, tree
);
180 static tree
build_vtable (tree
, tree
, tree
);
181 static void initialize_vtable (tree
, vec
<constructor_elt
, va_gc
> *);
182 static void layout_nonempty_base_or_field (record_layout_info
,
183 tree
, tree
, splay_tree
);
184 static tree
end_of_class (tree
, int);
185 static bool layout_empty_base (record_layout_info
, tree
, tree
, splay_tree
);
186 static void accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
,
187 vec
<constructor_elt
, va_gc
> **);
188 static void dfs_accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
,
189 vec
<constructor_elt
, va_gc
> **);
190 static void build_rtti_vtbl_entries (tree
, vtbl_init_data
*);
191 static void build_vcall_and_vbase_vtbl_entries (tree
, vtbl_init_data
*);
192 static void clone_constructors_and_destructors (tree
);
193 static tree
build_clone (tree
, tree
);
194 static void update_vtable_entry_for_fn (tree
, tree
, tree
, tree
*, unsigned);
195 static void build_ctor_vtbl_group (tree
, tree
);
196 static void build_vtt (tree
);
197 static tree
binfo_ctor_vtable (tree
);
198 static void build_vtt_inits (tree
, tree
, vec
<constructor_elt
, va_gc
> **,
200 static tree
dfs_build_secondary_vptr_vtt_inits (tree
, void *);
201 static tree
dfs_fixup_binfo_vtbls (tree
, void *);
202 static int record_subobject_offset (tree
, tree
, splay_tree
);
203 static int check_subobject_offset (tree
, tree
, splay_tree
);
204 static int walk_subobject_offsets (tree
, subobject_offset_fn
,
205 tree
, splay_tree
, tree
, int);
206 static void record_subobject_offsets (tree
, tree
, splay_tree
, bool);
207 static int layout_conflict_p (tree
, tree
, splay_tree
, int);
208 static int splay_tree_compare_integer_csts (splay_tree_key k1
,
210 static void warn_about_ambiguous_bases (tree
);
211 static bool type_requires_array_cookie (tree
);
212 static bool base_derived_from (tree
, tree
);
213 static int empty_base_at_nonzero_offset_p (tree
, tree
, splay_tree
);
214 static tree
end_of_base (tree
);
215 static tree
get_vcall_index (tree
, tree
);
216 static bool type_maybe_constexpr_default_constructor (tree
);
218 /* Return a COND_EXPR that executes TRUE_STMT if this execution of the
219 'structor is in charge of 'structing virtual bases, or FALSE_STMT
223 build_if_in_charge (tree true_stmt
, tree false_stmt
)
225 gcc_assert (DECL_HAS_IN_CHARGE_PARM_P (current_function_decl
));
226 tree cmp
= build2 (NE_EXPR
, boolean_type_node
,
227 current_in_charge_parm
, integer_zero_node
);
228 tree type
= unlowered_expr_type (true_stmt
);
229 if (VOID_TYPE_P (type
))
230 type
= unlowered_expr_type (false_stmt
);
231 tree cond
= build3 (COND_EXPR
, type
,
232 cmp
, true_stmt
, false_stmt
);
236 /* Convert to or from a base subobject. EXPR is an expression of type
237 `A' or `A*', an expression of type `B' or `B*' is returned. To
238 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
239 the B base instance within A. To convert base A to derived B, CODE
240 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
241 In this latter case, A must not be a morally virtual base of B.
242 NONNULL is true if EXPR is known to be non-NULL (this is only
243 needed when EXPR is of pointer type). CV qualifiers are preserved
247 build_base_path (enum tree_code code
,
251 tsubst_flags_t complain
)
253 tree v_binfo
= NULL_TREE
;
254 tree d_binfo
= NULL_TREE
;
258 tree null_test
= NULL
;
259 tree ptr_target_type
;
261 int want_pointer
= TYPE_PTR_P (TREE_TYPE (expr
));
262 bool has_empty
= false;
266 if (expr
== error_mark_node
|| binfo
== error_mark_node
|| !binfo
)
267 return error_mark_node
;
269 for (probe
= binfo
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
272 if (is_empty_class (BINFO_TYPE (probe
)))
274 if (!v_binfo
&& BINFO_VIRTUAL_P (probe
))
278 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
280 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (probe
));
282 if (code
== PLUS_EXPR
283 && !SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo
), probe
))
285 /* This can happen when adjust_result_of_qualified_name_lookup can't
286 find a unique base binfo in a call to a member function. We
287 couldn't give the diagnostic then since we might have been calling
288 a static member function, so we do it now. In other cases, eg.
289 during error recovery (c++/71979), we may not have a base at all. */
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
|| !base
);
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
= !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 || processing_template_decl
367 || in_template_function ())
369 expr
= build_nop (ptr_target_type
, expr
);
373 /* If we're in an NSDMI, we don't have the full constructor context yet
374 that we need for converting to a virtual base, so just build a stub
375 CONVERT_EXPR and expand it later in bot_replace. */
376 if (virtual_access
&& fixed_type_p
< 0
377 && current_scope () != current_function_decl
)
379 expr
= build1 (CONVERT_EXPR
, ptr_target_type
, expr
);
380 CONVERT_EXPR_VBASE_PATH (expr
) = true;
384 /* Do we need to check for a null pointer? */
385 if (want_pointer
&& !nonnull
)
387 /* If we know the conversion will not actually change the value
388 of EXPR, then we can avoid testing the expression for NULL.
389 We have to avoid generating a COMPONENT_REF for a base class
390 field, because other parts of the compiler know that such
391 expressions are always non-NULL. */
392 if (!virtual_access
&& integer_zerop (offset
))
393 return build_nop (ptr_target_type
, expr
);
394 null_test
= error_mark_node
;
397 /* Protect against multiple evaluation if necessary. */
398 if (TREE_SIDE_EFFECTS (expr
) && (null_test
|| virtual_access
))
399 expr
= save_expr (expr
);
401 /* Now that we've saved expr, build the real null test. */
404 tree zero
= cp_convert (TREE_TYPE (expr
), nullptr_node
, complain
);
405 null_test
= build2_loc (input_location
, NE_EXPR
, boolean_type_node
,
407 /* This is a compiler generated comparison, don't emit
408 e.g. -Wnonnull-compare warning for it. */
409 TREE_NO_WARNING (null_test
) = 1;
412 /* If this is a simple base reference, express it as a COMPONENT_REF. */
413 if (code
== PLUS_EXPR
&& !virtual_access
414 /* We don't build base fields for empty bases, and they aren't very
415 interesting to the optimizers anyway. */
418 expr
= cp_build_fold_indirect_ref (expr
);
419 expr
= build_simple_base_path (expr
, binfo
);
423 expr
= build_address (expr
);
424 target_type
= TREE_TYPE (expr
);
430 /* Going via virtual base V_BINFO. We need the static offset
431 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
432 V_BINFO. That offset is an entry in D_BINFO's vtable. */
435 if (fixed_type_p
< 0 && in_base_initializer
)
437 /* In a base member initializer, we cannot rely on the
438 vtable being set up. We have to indirect via the
442 t
= TREE_TYPE (TYPE_VFIELD (current_class_type
));
443 t
= build_pointer_type (t
);
444 v_offset
= fold_convert (t
, current_vtt_parm
);
445 v_offset
= cp_build_fold_indirect_ref (v_offset
);
450 if (sanitize_flags_p (SANITIZE_VPTR
)
451 && fixed_type_p
== 0)
453 t
= cp_ubsan_maybe_instrument_cast_to_vbase (input_location
,
458 v_offset
= build_vfield_ref (cp_build_fold_indirect_ref (t
),
459 TREE_TYPE (TREE_TYPE (expr
)));
462 if (v_offset
== error_mark_node
)
463 return error_mark_node
;
465 v_offset
= fold_build_pointer_plus (v_offset
, BINFO_VPTR_FIELD (v_binfo
));
466 v_offset
= build1 (NOP_EXPR
,
467 build_pointer_type (ptrdiff_type_node
),
469 v_offset
= cp_build_fold_indirect_ref (v_offset
);
470 TREE_CONSTANT (v_offset
) = 1;
472 offset
= convert_to_integer (ptrdiff_type_node
,
473 size_diffop_loc (input_location
, offset
,
474 BINFO_OFFSET (v_binfo
)));
476 if (!integer_zerop (offset
))
477 v_offset
= build2 (code
, ptrdiff_type_node
, v_offset
, offset
);
479 if (fixed_type_p
< 0)
480 /* Negative fixed_type_p means this is a constructor or destructor;
481 virtual base layout is fixed in in-charge [cd]tors, but not in
483 offset
= build_if_in_charge
484 (convert_to_integer (ptrdiff_type_node
, BINFO_OFFSET (binfo
)),
491 target_type
= ptr_target_type
;
493 expr
= build1 (NOP_EXPR
, ptr_target_type
, expr
);
495 if (!integer_zerop (offset
))
497 offset
= fold_convert (sizetype
, offset
);
498 if (code
== MINUS_EXPR
)
499 offset
= fold_build1_loc (input_location
, NEGATE_EXPR
, sizetype
, offset
);
500 expr
= fold_build_pointer_plus (expr
, offset
);
508 expr
= cp_build_fold_indirect_ref (expr
);
515 expr
= fold_build3_loc (input_location
, COND_EXPR
, target_type
, null_test
, expr
,
516 build_zero_cst (target_type
));
521 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
522 Perform a derived-to-base conversion by recursively building up a
523 sequence of COMPONENT_REFs to the appropriate base fields. */
526 build_simple_base_path (tree expr
, tree binfo
)
528 tree type
= BINFO_TYPE (binfo
);
529 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
532 if (d_binfo
== NULL_TREE
)
536 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)) == type
);
538 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
539 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
540 an lvalue in the front end; only _DECLs and _REFs are lvalues
542 temp
= unary_complex_lvalue (ADDR_EXPR
, expr
);
544 expr
= cp_build_fold_indirect_ref (temp
);
550 expr
= build_simple_base_path (expr
, d_binfo
);
552 for (field
= TYPE_FIELDS (BINFO_TYPE (d_binfo
));
553 field
; field
= DECL_CHAIN (field
))
554 /* Is this the base field created by build_base_field? */
555 if (TREE_CODE (field
) == FIELD_DECL
556 && DECL_FIELD_IS_BASE (field
)
557 && TREE_TYPE (field
) == type
558 /* If we're looking for a field in the most-derived class,
559 also check the field offset; we can have two base fields
560 of the same type if one is an indirect virtual base and one
561 is a direct non-virtual base. */
562 && (BINFO_INHERITANCE_CHAIN (d_binfo
)
563 || tree_int_cst_equal (byte_position (field
),
564 BINFO_OFFSET (binfo
))))
566 /* We don't use build_class_member_access_expr here, as that
567 has unnecessary checks, and more importantly results in
568 recursive calls to dfs_walk_once. */
569 int type_quals
= cp_type_quals (TREE_TYPE (expr
));
571 expr
= build3 (COMPONENT_REF
,
572 cp_build_qualified_type (type
, type_quals
),
573 expr
, field
, NULL_TREE
);
574 /* Mark the expression const or volatile, as appropriate.
575 Even though we've dealt with the type above, we still have
576 to mark the expression itself. */
577 if (type_quals
& TYPE_QUAL_CONST
)
578 TREE_READONLY (expr
) = 1;
579 if (type_quals
& TYPE_QUAL_VOLATILE
)
580 TREE_THIS_VOLATILE (expr
) = 1;
585 /* Didn't find the base field?!? */
589 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
590 type is a class type or a pointer to a class type. In the former
591 case, TYPE is also a class type; in the latter it is another
592 pointer type. If CHECK_ACCESS is true, an error message is emitted
593 if TYPE is inaccessible. If OBJECT has pointer type, the value is
594 assumed to be non-NULL. */
597 convert_to_base (tree object
, tree type
, bool check_access
, bool nonnull
,
598 tsubst_flags_t complain
)
603 if (TYPE_PTR_P (TREE_TYPE (object
)))
605 object_type
= TREE_TYPE (TREE_TYPE (object
));
606 type
= TREE_TYPE (type
);
609 object_type
= TREE_TYPE (object
);
611 binfo
= lookup_base (object_type
, type
, check_access
? ba_check
: ba_unique
,
613 if (!binfo
|| binfo
== error_mark_node
)
614 return error_mark_node
;
616 return build_base_path (PLUS_EXPR
, object
, binfo
, nonnull
, complain
);
619 /* EXPR is an expression with unqualified class type. BASE is a base
620 binfo of that class type. Returns EXPR, converted to the BASE
621 type. This function assumes that EXPR is the most derived class;
622 therefore virtual bases can be found at their static offsets. */
625 convert_to_base_statically (tree expr
, tree base
)
629 expr_type
= TREE_TYPE (expr
);
630 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base
), expr_type
))
632 /* If this is a non-empty base, use a COMPONENT_REF. */
633 if (!is_empty_class (BINFO_TYPE (base
)))
634 return build_simple_base_path (expr
, base
);
636 /* We use fold_build2 and fold_convert below to simplify the trees
637 provided to the optimizers. It is not safe to call these functions
638 when processing a template because they do not handle C++-specific
640 gcc_assert (!processing_template_decl
);
641 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
642 if (!integer_zerop (BINFO_OFFSET (base
)))
643 expr
= fold_build_pointer_plus_loc (input_location
,
644 expr
, BINFO_OFFSET (base
));
645 expr
= fold_convert (build_pointer_type (BINFO_TYPE (base
)), expr
);
646 expr
= build_fold_indirect_ref_loc (input_location
, expr
);
654 build_vfield_ref (tree datum
, tree type
)
656 tree vfield
, vcontext
;
658 if (datum
== error_mark_node
659 /* Can happen in case of duplicate base types (c++/59082). */
660 || !TYPE_VFIELD (type
))
661 return error_mark_node
;
663 /* First, convert to the requested type. */
664 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum
), type
))
665 datum
= convert_to_base (datum
, type
, /*check_access=*/false,
666 /*nonnull=*/true, tf_warning_or_error
);
668 /* Second, the requested type may not be the owner of its own vptr.
669 If not, convert to the base class that owns it. We cannot use
670 convert_to_base here, because VCONTEXT may appear more than once
671 in the inheritance hierarchy of TYPE, and thus direct conversion
672 between the types may be ambiguous. Following the path back up
673 one step at a time via primary bases avoids the problem. */
674 vfield
= TYPE_VFIELD (type
);
675 vcontext
= DECL_CONTEXT (vfield
);
676 while (!same_type_ignoring_top_level_qualifiers_p (vcontext
, type
))
678 datum
= build_simple_base_path (datum
, CLASSTYPE_PRIMARY_BINFO (type
));
679 type
= TREE_TYPE (datum
);
682 return build3 (COMPONENT_REF
, TREE_TYPE (vfield
), datum
, vfield
, NULL_TREE
);
685 /* Given an object INSTANCE, return an expression which yields the
686 vtable element corresponding to INDEX. There are many special
687 cases for INSTANCE which we take care of here, mainly to avoid
688 creating extra tree nodes when we don't have to. */
691 build_vtbl_ref_1 (tree instance
, tree idx
)
694 tree vtbl
= NULL_TREE
;
696 /* Try to figure out what a reference refers to, and
697 access its virtual function table directly. */
700 tree fixed_type
= fixed_type_or_null (instance
, NULL
, &cdtorp
);
702 tree basetype
= non_reference (TREE_TYPE (instance
));
704 if (fixed_type
&& !cdtorp
)
706 tree binfo
= lookup_base (fixed_type
, basetype
,
707 ba_unique
, NULL
, tf_none
);
708 if (binfo
&& binfo
!= error_mark_node
)
709 vtbl
= unshare_expr (BINFO_VTABLE (binfo
));
713 vtbl
= build_vfield_ref (instance
, basetype
);
715 aref
= build_array_ref (input_location
, vtbl
, idx
);
716 TREE_CONSTANT (aref
) |= TREE_CONSTANT (vtbl
) && TREE_CONSTANT (idx
);
722 build_vtbl_ref (tree instance
, tree idx
)
724 tree aref
= build_vtbl_ref_1 (instance
, idx
);
729 /* Given a stable object pointer INSTANCE_PTR, return an expression which
730 yields a function pointer corresponding to vtable element INDEX. */
733 build_vfn_ref (tree instance_ptr
, tree idx
)
737 aref
= build_vtbl_ref_1 (cp_build_fold_indirect_ref (instance_ptr
),
740 /* When using function descriptors, the address of the
741 vtable entry is treated as a function pointer. */
742 if (TARGET_VTABLE_USES_DESCRIPTORS
)
743 aref
= build1 (NOP_EXPR
, TREE_TYPE (aref
),
744 cp_build_addr_expr (aref
, tf_warning_or_error
));
746 /* Remember this as a method reference, for later devirtualization. */
747 aref
= build3 (OBJ_TYPE_REF
, TREE_TYPE (aref
), aref
, instance_ptr
, idx
);
752 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
753 for the given TYPE. */
756 get_vtable_name (tree type
)
758 return mangle_vtbl_for_type (type
);
761 /* DECL is an entity associated with TYPE, like a virtual table or an
762 implicitly generated constructor. Determine whether or not DECL
763 should have external or internal linkage at the object file
764 level. This routine does not deal with COMDAT linkage and other
765 similar complexities; it simply sets TREE_PUBLIC if it possible for
766 entities in other translation units to contain copies of DECL, in
770 set_linkage_according_to_type (tree
/*type*/, tree decl
)
772 TREE_PUBLIC (decl
) = 1;
773 determine_visibility (decl
);
776 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
777 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
778 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
781 build_vtable (tree class_type
, tree name
, tree vtable_type
)
785 decl
= build_lang_decl (VAR_DECL
, name
, vtable_type
);
786 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
787 now to avoid confusion in mangle_decl. */
788 SET_DECL_ASSEMBLER_NAME (decl
, name
);
789 DECL_CONTEXT (decl
) = class_type
;
790 DECL_ARTIFICIAL (decl
) = 1;
791 TREE_STATIC (decl
) = 1;
792 TREE_READONLY (decl
) = 1;
793 DECL_VIRTUAL_P (decl
) = 1;
794 SET_DECL_ALIGN (decl
, TARGET_VTABLE_ENTRY_ALIGN
);
795 DECL_USER_ALIGN (decl
) = true;
796 DECL_VTABLE_OR_VTT_P (decl
) = 1;
797 set_linkage_according_to_type (class_type
, decl
);
798 /* The vtable has not been defined -- yet. */
799 DECL_EXTERNAL (decl
) = 1;
800 DECL_NOT_REALLY_EXTERN (decl
) = 1;
802 /* Mark the VAR_DECL node representing the vtable itself as a
803 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
804 is rather important that such things be ignored because any
805 effort to actually generate DWARF for them will run into
806 trouble when/if we encounter code like:
809 struct S { virtual void member (); };
811 because the artificial declaration of the vtable itself (as
812 manufactured by the g++ front end) will say that the vtable is
813 a static member of `S' but only *after* the debug output for
814 the definition of `S' has already been output. This causes
815 grief because the DWARF entry for the definition of the vtable
816 will try to refer back to an earlier *declaration* of the
817 vtable as a static member of `S' and there won't be one. We
818 might be able to arrange to have the "vtable static member"
819 attached to the member list for `S' before the debug info for
820 `S' get written (which would solve the problem) but that would
821 require more intrusive changes to the g++ front end. */
822 DECL_IGNORED_P (decl
) = 1;
827 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
828 or even complete. If this does not exist, create it. If COMPLETE is
829 nonzero, then complete the definition of it -- that will render it
830 impossible to actually build the vtable, but is useful to get at those
831 which are known to exist in the runtime. */
834 get_vtable_decl (tree type
, int complete
)
838 if (CLASSTYPE_VTABLES (type
))
839 return CLASSTYPE_VTABLES (type
);
841 decl
= build_vtable (type
, get_vtable_name (type
), vtbl_type_node
);
842 CLASSTYPE_VTABLES (type
) = decl
;
846 DECL_EXTERNAL (decl
) = 1;
847 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
853 /* Build the primary virtual function table for TYPE. If BINFO is
854 non-NULL, build the vtable starting with the initial approximation
855 that it is the same as the one which is the head of the association
856 list. Returns a nonzero value if a new vtable is actually
860 build_primary_vtable (tree binfo
, tree type
)
865 decl
= get_vtable_decl (type
, /*complete=*/0);
869 if (BINFO_NEW_VTABLE_MARKED (binfo
))
870 /* We have already created a vtable for this base, so there's
871 no need to do it again. */
874 virtuals
= copy_list (BINFO_VIRTUALS (binfo
));
875 TREE_TYPE (decl
) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo
));
876 DECL_SIZE (decl
) = TYPE_SIZE (TREE_TYPE (decl
));
877 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
881 gcc_assert (TREE_TYPE (decl
) == vtbl_type_node
);
882 virtuals
= NULL_TREE
;
885 /* Initialize the association list for this type, based
886 on our first approximation. */
887 BINFO_VTABLE (TYPE_BINFO (type
)) = decl
;
888 BINFO_VIRTUALS (TYPE_BINFO (type
)) = virtuals
;
889 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type
));
893 /* Give BINFO a new virtual function table which is initialized
894 with a skeleton-copy of its original initialization. The only
895 entry that changes is the `delta' entry, so we can really
896 share a lot of structure.
898 FOR_TYPE is the most derived type which caused this table to
901 Returns nonzero if we haven't met BINFO before.
903 The order in which vtables are built (by calling this function) for
904 an object must remain the same, otherwise a binary incompatibility
908 build_secondary_vtable (tree binfo
)
910 if (BINFO_NEW_VTABLE_MARKED (binfo
))
911 /* We already created a vtable for this base. There's no need to
915 /* Remember that we've created a vtable for this BINFO, so that we
916 don't try to do so again. */
917 SET_BINFO_NEW_VTABLE_MARKED (binfo
);
919 /* Make fresh virtual list, so we can smash it later. */
920 BINFO_VIRTUALS (binfo
) = copy_list (BINFO_VIRTUALS (binfo
));
922 /* Secondary vtables are laid out as part of the same structure as
923 the primary vtable. */
924 BINFO_VTABLE (binfo
) = NULL_TREE
;
928 /* Create a new vtable for BINFO which is the hierarchy dominated by
929 T. Return nonzero if we actually created a new vtable. */
932 make_new_vtable (tree t
, tree binfo
)
934 if (binfo
== TYPE_BINFO (t
))
935 /* In this case, it is *type*'s vtable we are modifying. We start
936 with the approximation that its vtable is that of the
937 immediate base class. */
938 return build_primary_vtable (binfo
, t
);
940 /* This is our very own copy of `basetype' to play with. Later,
941 we will fill in all the virtual functions that override the
942 virtual functions in these base classes which are not defined
943 by the current type. */
944 return build_secondary_vtable (binfo
);
947 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
948 (which is in the hierarchy dominated by T) list FNDECL as its
949 BV_FN. DELTA is the required constant adjustment from the `this'
950 pointer where the vtable entry appears to the `this' required when
951 the function is actually called. */
954 modify_vtable_entry (tree t
,
964 if (fndecl
!= BV_FN (v
)
965 || !tree_int_cst_equal (delta
, BV_DELTA (v
)))
967 /* We need a new vtable for BINFO. */
968 if (make_new_vtable (t
, binfo
))
970 /* If we really did make a new vtable, we also made a copy
971 of the BINFO_VIRTUALS list. Now, we have to find the
972 corresponding entry in that list. */
973 *virtuals
= BINFO_VIRTUALS (binfo
);
974 while (BV_FN (*virtuals
) != BV_FN (v
))
975 *virtuals
= TREE_CHAIN (*virtuals
);
979 BV_DELTA (v
) = delta
;
980 BV_VCALL_INDEX (v
) = NULL_TREE
;
986 /* Add method METHOD to class TYPE. If VIA_USING indicates whether
987 METHOD is being injected via a using_decl. Returns true if the
988 method could be added to the method vec. */
991 add_method (tree type
, tree method
, bool via_using
)
993 if (method
== error_mark_node
)
996 gcc_assert (!DECL_EXTERN_C_P (method
));
998 tree
*slot
= find_member_slot (type
, DECL_NAME (method
));
999 tree current_fns
= slot
? *slot
: NULL_TREE
;
1001 /* Check to see if we've already got this method. */
1002 for (ovl_iterator
iter (current_fns
); iter
; ++iter
)
1010 if (TREE_CODE (fn
) != TREE_CODE (method
))
1013 /* Two using-declarations can coexist, we'll complain about ambiguity in
1014 overload resolution. */
1015 if (via_using
&& iter
.using_p ()
1016 /* Except handle inherited constructors specially. */
1017 && ! DECL_CONSTRUCTOR_P (fn
))
1020 /* [over.load] Member function declarations with the
1021 same name and the same parameter types cannot be
1022 overloaded if any of them is a static member
1023 function declaration.
1025 [over.load] Member function declarations with the same name and
1026 the same parameter-type-list as well as member function template
1027 declarations with the same name, the same parameter-type-list, and
1028 the same template parameter lists cannot be overloaded if any of
1029 them, but not all, have a ref-qualifier.
1031 [namespace.udecl] When a using-declaration brings names
1032 from a base class into a derived class scope, member
1033 functions in the derived class override and/or hide member
1034 functions with the same name and parameter types in a base
1035 class (rather than conflicting). */
1036 fn_type
= TREE_TYPE (fn
);
1037 method_type
= TREE_TYPE (method
);
1038 parms1
= TYPE_ARG_TYPES (fn_type
);
1039 parms2
= TYPE_ARG_TYPES (method_type
);
1041 /* Compare the quals on the 'this' parm. Don't compare
1042 the whole types, as used functions are treated as
1043 coming from the using class in overload resolution. */
1044 if (! DECL_STATIC_FUNCTION_P (fn
)
1045 && ! DECL_STATIC_FUNCTION_P (method
)
1046 /* Either both or neither need to be ref-qualified for
1047 differing quals to allow overloading. */
1048 && (FUNCTION_REF_QUALIFIED (fn_type
)
1049 == FUNCTION_REF_QUALIFIED (method_type
))
1050 && (type_memfn_quals (fn_type
) != type_memfn_quals (method_type
)
1051 || type_memfn_rqual (fn_type
) != type_memfn_rqual (method_type
)))
1054 /* For templates, the return type and template parameters
1055 must be identical. */
1056 if (TREE_CODE (fn
) == TEMPLATE_DECL
1057 && (!same_type_p (TREE_TYPE (fn_type
),
1058 TREE_TYPE (method_type
))
1059 || !comp_template_parms (DECL_TEMPLATE_PARMS (fn
),
1060 DECL_TEMPLATE_PARMS (method
))))
1063 if (! DECL_STATIC_FUNCTION_P (fn
))
1064 parms1
= TREE_CHAIN (parms1
);
1065 if (! DECL_STATIC_FUNCTION_P (method
))
1066 parms2
= TREE_CHAIN (parms2
);
1068 /* Bring back parameters omitted from an inherited ctor. */
1069 if (ctor_omit_inherited_parms (fn
))
1070 parms1
= FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (fn
));
1071 if (ctor_omit_inherited_parms (method
))
1072 parms2
= FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (method
));
1074 if (compparms (parms1
, parms2
)
1075 && (!DECL_CONV_FN_P (fn
)
1076 || same_type_p (TREE_TYPE (fn_type
),
1077 TREE_TYPE (method_type
)))
1078 && equivalently_constrained (fn
, method
))
1080 /* If these are versions of the same function, process and
1082 if (TREE_CODE (fn
) == FUNCTION_DECL
1083 && maybe_version_functions (method
, fn
, true))
1086 if (DECL_INHERITED_CTOR (method
))
1088 if (DECL_INHERITED_CTOR (fn
))
1090 tree basem
= DECL_INHERITED_CTOR_BASE (method
);
1091 tree basef
= DECL_INHERITED_CTOR_BASE (fn
);
1092 if (flag_new_inheriting_ctors
)
1096 /* Inheriting the same constructor along different
1097 paths, combine them. */
1098 SET_DECL_INHERITED_CTOR
1099 (fn
, ovl_make (DECL_INHERITED_CTOR (method
),
1100 DECL_INHERITED_CTOR (fn
)));
1101 /* And discard the new one. */
1105 /* Inherited ctors can coexist until overload
1109 error_at (DECL_SOURCE_LOCATION (method
),
1110 "%q#D conflicts with version inherited from %qT",
1112 inform (DECL_SOURCE_LOCATION (fn
),
1113 "version inherited from %qT declared here",
1116 /* Otherwise defer to the other function. */
1121 /* Defer to the local function. */
1123 else if (flag_new_inheriting_ctors
1124 && DECL_INHERITED_CTOR (fn
))
1126 /* Remove the inherited constructor. */
1127 current_fns
= iter
.remove_node (current_fns
);
1132 error_at (DECL_SOURCE_LOCATION (method
),
1133 "%q#D cannot be overloaded with %q#D", method
, fn
);
1134 inform (DECL_SOURCE_LOCATION (fn
),
1135 "previous declaration %q#D", fn
);
1141 /* A class should never have more than one destructor. */
1142 gcc_assert (!current_fns
|| !DECL_DESTRUCTOR_P (method
));
1144 current_fns
= ovl_insert (method
, current_fns
, via_using
);
1146 if (!COMPLETE_TYPE_P (type
) && !DECL_CONV_FN_P (method
)
1147 && !push_class_level_binding (DECL_NAME (method
), current_fns
))
1151 slot
= add_member_slot (type
, DECL_NAME (method
));
1153 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
1154 grok_special_member_properties (method
);
1156 *slot
= current_fns
;
1161 /* Subroutines of finish_struct. */
1163 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1164 legit, otherwise return 0. */
1167 alter_access (tree t
, tree fdecl
, tree access
)
1171 retrofit_lang_decl (fdecl
);
1173 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl
));
1175 elem
= purpose_member (t
, DECL_ACCESS (fdecl
));
1178 if (TREE_VALUE (elem
) != access
)
1180 if (TREE_CODE (TREE_TYPE (fdecl
)) == FUNCTION_DECL
)
1181 error ("conflicting access specifications for method"
1182 " %q+D, ignored", TREE_TYPE (fdecl
));
1184 error ("conflicting access specifications for field %qE, ignored",
1189 /* They're changing the access to the same thing they changed
1190 it to before. That's OK. */
1196 perform_or_defer_access_check (TYPE_BINFO (t
), fdecl
, fdecl
,
1197 tf_warning_or_error
);
1198 DECL_ACCESS (fdecl
) = tree_cons (t
, access
, DECL_ACCESS (fdecl
));
1204 /* Return the access node for DECL's access in its enclosing class. */
1207 declared_access (tree decl
)
1209 return (TREE_PRIVATE (decl
) ? access_private_node
1210 : TREE_PROTECTED (decl
) ? access_protected_node
1211 : access_public_node
);
1214 /* Process the USING_DECL, which is a member of T. */
1217 handle_using_decl (tree using_decl
, tree t
)
1219 tree decl
= USING_DECL_DECLS (using_decl
);
1220 tree name
= DECL_NAME (using_decl
);
1221 tree access
= declared_access (using_decl
);
1222 tree flist
= NULL_TREE
;
1225 gcc_assert (!processing_template_decl
&& decl
);
1227 old_value
= lookup_member (t
, name
, /*protect=*/0, /*want_type=*/false,
1228 tf_warning_or_error
);
1231 old_value
= OVL_FIRST (old_value
);
1233 if (DECL_P (old_value
) && DECL_CONTEXT (old_value
) == t
)
1236 old_value
= NULL_TREE
;
1239 cp_emit_debug_info_for_using (decl
, t
);
1241 if (is_overloaded_fn (decl
))
1246 else if (is_overloaded_fn (old_value
))
1249 /* It's OK to use functions from a base when there are functions with
1250 the same name already present in the current class. */;
1253 error_at (DECL_SOURCE_LOCATION (using_decl
), "%qD invalid in %q#T "
1254 "because of local method %q#D with same name",
1255 using_decl
, t
, old_value
);
1256 inform (DECL_SOURCE_LOCATION (old_value
),
1257 "local method %q#D declared here", old_value
);
1261 else if (!DECL_ARTIFICIAL (old_value
))
1263 error_at (DECL_SOURCE_LOCATION (using_decl
), "%qD invalid in %q#T "
1264 "because of local member %q#D with same name",
1265 using_decl
, t
, old_value
);
1266 inform (DECL_SOURCE_LOCATION (old_value
),
1267 "local member %q#D declared here", old_value
);
1271 /* Make type T see field decl FDECL with access ACCESS. */
1273 for (ovl_iterator
iter (flist
); iter
; ++iter
)
1275 add_method (t
, *iter
, true);
1276 alter_access (t
, *iter
, access
);
1279 alter_access (t
, decl
, access
);
1282 /* Data structure for find_abi_tags_r, below. */
1286 tree t
; // The type that we're checking for missing tags.
1287 tree subob
; // The subobject of T that we're getting tags from.
1288 tree tags
; // error_mark_node for diagnostics, or a list of missing tags.
1291 /* Subroutine of find_abi_tags_r. Handle a single TAG found on the class TP
1292 in the context of P. TAG can be either an identifier (the DECL_NAME of
1293 a tag NAMESPACE_DECL) or a STRING_CST (a tag attribute). */
1296 check_tag (tree tag
, tree id
, tree
*tp
, abi_tag_data
*p
)
1298 if (!IDENTIFIER_MARKED (id
))
1300 if (p
->tags
!= error_mark_node
)
1302 /* We're collecting tags from template arguments or from
1303 the type of a variable or function return type. */
1304 p
->tags
= tree_cons (NULL_TREE
, tag
, p
->tags
);
1306 /* Don't inherit this tag multiple times. */
1307 IDENTIFIER_MARKED (id
) = true;
1311 /* Tags inherited from type template arguments are only used
1312 to avoid warnings. */
1313 ABI_TAG_IMPLICIT (p
->tags
) = true;
1316 /* For functions and variables we want to warn, too. */
1319 /* Otherwise we're diagnosing missing tags. */
1320 if (TREE_CODE (p
->t
) == FUNCTION_DECL
)
1322 if (warning (OPT_Wabi_tag
, "%qD inherits the %E ABI tag "
1323 "that %qT (used in its return type) has",
1325 inform (location_of (*tp
), "%qT declared here", *tp
);
1327 else if (VAR_P (p
->t
))
1329 if (warning (OPT_Wabi_tag
, "%qD inherits the %E ABI tag "
1330 "that %qT (used in its type) has", p
->t
, tag
, *tp
))
1331 inform (location_of (*tp
), "%qT declared here", *tp
);
1333 else if (TYPE_P (p
->subob
))
1335 if (warning (OPT_Wabi_tag
, "%qT does not have the %E ABI tag "
1336 "that base %qT has", p
->t
, tag
, p
->subob
))
1337 inform (location_of (p
->subob
), "%qT declared here",
1342 if (warning (OPT_Wabi_tag
, "%qT does not have the %E ABI tag "
1343 "that %qT (used in the type of %qD) has",
1344 p
->t
, tag
, *tp
, p
->subob
))
1346 inform (location_of (p
->subob
), "%qD declared here",
1348 inform (location_of (*tp
), "%qT declared here", *tp
);
1354 /* Find all the ABI tags in the attribute list ATTR and either call
1355 check_tag (if TP is non-null) or set IDENTIFIER_MARKED to val. */
1358 mark_or_check_attr_tags (tree attr
, tree
*tp
, abi_tag_data
*p
, bool val
)
1362 for (; (attr
= lookup_attribute ("abi_tag", attr
));
1363 attr
= TREE_CHAIN (attr
))
1364 for (tree list
= TREE_VALUE (attr
); list
;
1365 list
= TREE_CHAIN (list
))
1367 tree tag
= TREE_VALUE (list
);
1368 tree id
= get_identifier (TREE_STRING_POINTER (tag
));
1370 check_tag (tag
, id
, tp
, p
);
1372 IDENTIFIER_MARKED (id
) = val
;
1376 /* Find all the ABI tags on T and its enclosing scopes and either call
1377 check_tag (if TP is non-null) or set IDENTIFIER_MARKED to val. */
1380 mark_or_check_tags (tree t
, tree
*tp
, abi_tag_data
*p
, bool val
)
1382 while (t
!= global_namespace
)
1387 attr
= TYPE_ATTRIBUTES (t
);
1388 t
= CP_TYPE_CONTEXT (t
);
1392 attr
= DECL_ATTRIBUTES (t
);
1393 t
= CP_DECL_CONTEXT (t
);
1395 mark_or_check_attr_tags (attr
, tp
, p
, val
);
1399 /* walk_tree callback for check_abi_tags: if the type at *TP involves any
1400 types with ABI tags, add the corresponding identifiers to the VEC in
1401 *DATA and set IDENTIFIER_MARKED. */
1404 find_abi_tags_r (tree
*tp
, int *walk_subtrees
, void *data
)
1406 if (!OVERLOAD_TYPE_P (*tp
))
1409 /* walk_tree shouldn't be walking into any subtrees of a RECORD_TYPE
1410 anyway, but let's make sure of it. */
1411 *walk_subtrees
= false;
1413 abi_tag_data
*p
= static_cast<struct abi_tag_data
*>(data
);
1415 mark_or_check_tags (*tp
, tp
, p
, false);
1420 /* walk_tree callback for mark_abi_tags: if *TP is a class, set
1421 IDENTIFIER_MARKED on its ABI tags. */
1424 mark_abi_tags_r (tree
*tp
, int *walk_subtrees
, void *data
)
1426 if (!OVERLOAD_TYPE_P (*tp
))
1429 /* walk_tree shouldn't be walking into any subtrees of a RECORD_TYPE
1430 anyway, but let's make sure of it. */
1431 *walk_subtrees
= false;
1433 bool *valp
= static_cast<bool*>(data
);
1435 mark_or_check_tags (*tp
, NULL
, NULL
, *valp
);
1440 /* Set IDENTIFIER_MARKED on all the ABI tags on T and its enclosing
1444 mark_abi_tags (tree t
, bool val
)
1446 mark_or_check_tags (t
, NULL
, NULL
, val
);
1449 if (DECL_LANG_SPECIFIC (t
) && DECL_USE_TEMPLATE (t
)
1450 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
)))
1452 /* Template arguments are part of the signature. */
1453 tree level
= INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t
));
1454 for (int j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
1456 tree arg
= TREE_VEC_ELT (level
, j
);
1457 cp_walk_tree_without_duplicates (&arg
, mark_abi_tags_r
, &val
);
1460 if (TREE_CODE (t
) == FUNCTION_DECL
)
1461 /* A function's parameter types are part of the signature, so
1462 we don't need to inherit any tags that are also in them. */
1463 for (tree arg
= FUNCTION_FIRST_USER_PARMTYPE (t
); arg
;
1464 arg
= TREE_CHAIN (arg
))
1465 cp_walk_tree_without_duplicates (&TREE_VALUE (arg
),
1466 mark_abi_tags_r
, &val
);
1470 /* Check that T has all the ABI tags that subobject SUBOB has, or
1471 warn if not. If T is a (variable or function) declaration, also
1472 return any missing tags, and add them to T if JUST_CHECKING is false. */
1475 check_abi_tags (tree t
, tree subob
, bool just_checking
= false)
1477 bool inherit
= DECL_P (t
);
1479 if (!inherit
&& !warn_abi_tag
)
1482 tree decl
= TYPE_P (t
) ? TYPE_NAME (t
) : t
;
1483 if (!TREE_PUBLIC (decl
))
1484 /* No need to worry about things local to this TU. */
1487 mark_abi_tags (t
, true);
1489 tree subtype
= TYPE_P (subob
) ? subob
: TREE_TYPE (subob
);
1490 struct abi_tag_data data
= { t
, subob
, error_mark_node
};
1492 data
.tags
= NULL_TREE
;
1494 cp_walk_tree_without_duplicates (&subtype
, find_abi_tags_r
, &data
);
1496 if (!(inherit
&& data
.tags
))
1497 /* We don't need to do anything with data.tags. */;
1498 else if (just_checking
)
1499 for (tree t
= data
.tags
; t
; t
= TREE_CHAIN (t
))
1501 tree id
= get_identifier (TREE_STRING_POINTER (TREE_VALUE (t
)));
1502 IDENTIFIER_MARKED (id
) = false;
1506 tree attr
= lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t
));
1508 TREE_VALUE (attr
) = chainon (data
.tags
, TREE_VALUE (attr
));
1511 = tree_cons (get_identifier ("abi_tag"), data
.tags
,
1512 DECL_ATTRIBUTES (t
));
1515 mark_abi_tags (t
, false);
1520 /* Check that DECL has all the ABI tags that are used in parts of its type
1521 that are not reflected in its mangled name. */
1524 check_abi_tags (tree decl
)
1527 check_abi_tags (decl
, TREE_TYPE (decl
));
1528 else if (TREE_CODE (decl
) == FUNCTION_DECL
1529 && !DECL_CONV_FN_P (decl
)
1530 && !mangle_return_type_p (decl
))
1531 check_abi_tags (decl
, TREE_TYPE (TREE_TYPE (decl
)));
1534 /* Return any ABI tags that are used in parts of the type of DECL
1535 that are not reflected in its mangled name. This function is only
1536 used in backward-compatible mangling for ABI <11. */
1539 missing_abi_tags (tree decl
)
1542 return check_abi_tags (decl
, TREE_TYPE (decl
), true);
1543 else if (TREE_CODE (decl
) == FUNCTION_DECL
1544 /* Don't check DECL_CONV_FN_P here like we do in check_abi_tags, so
1545 that we can use this function for setting need_abi_warning
1546 regardless of the current flag_abi_version. */
1547 && !mangle_return_type_p (decl
))
1548 return check_abi_tags (decl
, TREE_TYPE (TREE_TYPE (decl
)), true);
1554 inherit_targ_abi_tags (tree t
)
1556 if (!CLASS_TYPE_P (t
)
1557 || CLASSTYPE_TEMPLATE_INFO (t
) == NULL_TREE
)
1560 mark_abi_tags (t
, true);
1562 tree args
= CLASSTYPE_TI_ARGS (t
);
1563 struct abi_tag_data data
= { t
, NULL_TREE
, NULL_TREE
};
1564 for (int i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
1566 tree level
= TMPL_ARGS_LEVEL (args
, i
+1);
1567 for (int j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
1569 tree arg
= TREE_VEC_ELT (level
, j
);
1571 cp_walk_tree_without_duplicates (&arg
, find_abi_tags_r
, &data
);
1575 // If we found some tags on our template arguments, add them to our
1576 // abi_tag attribute.
1579 tree attr
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (t
));
1581 TREE_VALUE (attr
) = chainon (data
.tags
, TREE_VALUE (attr
));
1584 = tree_cons (get_identifier ("abi_tag"), data
.tags
,
1585 TYPE_ATTRIBUTES (t
));
1588 mark_abi_tags (t
, false);
1591 /* Return true, iff class T has a non-virtual destructor that is
1592 accessible from outside the class heirarchy (i.e. is public, or
1593 there's a suitable friend. */
1596 accessible_nvdtor_p (tree t
)
1598 tree dtor
= CLASSTYPE_DESTRUCTOR (t
);
1600 /* An implicitly declared destructor is always public. And,
1601 if it were virtual, we would have created it by now. */
1605 if (DECL_VINDEX (dtor
))
1606 return false; /* Virtual */
1608 if (!TREE_PRIVATE (dtor
) && !TREE_PROTECTED (dtor
))
1609 return true; /* Public */
1611 if (CLASSTYPE_FRIEND_CLASSES (t
)
1612 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
1613 return true; /* Has friends */
1618 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1619 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1620 properties of the bases. */
1623 check_bases (tree t
,
1624 int* cant_have_const_ctor_p
,
1625 int* no_const_asn_ref_p
)
1628 bool seen_non_virtual_nearly_empty_base_p
= 0;
1629 int seen_tm_mask
= 0;
1632 tree field
= NULL_TREE
;
1634 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1635 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
1636 if (TREE_CODE (field
) == FIELD_DECL
)
1639 for (binfo
= TYPE_BINFO (t
), i
= 0;
1640 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1642 tree basetype
= TREE_TYPE (base_binfo
);
1644 gcc_assert (COMPLETE_TYPE_P (basetype
));
1646 if (CLASSTYPE_FINAL (basetype
))
1647 error ("cannot derive from %<final%> base %qT in derived type %qT",
1650 /* If any base class is non-literal, so is the derived class. */
1651 if (!CLASSTYPE_LITERAL_P (basetype
))
1652 CLASSTYPE_LITERAL_P (t
) = false;
1654 /* If the base class doesn't have copy constructors or
1655 assignment operators that take const references, then the
1656 derived class cannot have such a member automatically
1658 if (TYPE_HAS_COPY_CTOR (basetype
)
1659 && ! TYPE_HAS_CONST_COPY_CTOR (basetype
))
1660 *cant_have_const_ctor_p
= 1;
1661 if (TYPE_HAS_COPY_ASSIGN (basetype
)
1662 && !TYPE_HAS_CONST_COPY_ASSIGN (basetype
))
1663 *no_const_asn_ref_p
= 1;
1665 if (BINFO_VIRTUAL_P (base_binfo
))
1666 /* A virtual base does not effect nearly emptiness. */
1668 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype
))
1670 if (seen_non_virtual_nearly_empty_base_p
)
1671 /* And if there is more than one nearly empty base, then the
1672 derived class is not nearly empty either. */
1673 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1675 /* Remember we've seen one. */
1676 seen_non_virtual_nearly_empty_base_p
= 1;
1678 else if (!is_empty_class (basetype
))
1679 /* If the base class is not empty or nearly empty, then this
1680 class cannot be nearly empty. */
1681 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1683 /* A lot of properties from the bases also apply to the derived
1685 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (basetype
);
1686 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1687 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
);
1688 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
)
1689 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (basetype
)
1690 || !TYPE_HAS_COPY_ASSIGN (basetype
));
1691 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= (TYPE_HAS_COMPLEX_COPY_CTOR (basetype
)
1692 || !TYPE_HAS_COPY_CTOR (basetype
));
1693 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
1694 |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (basetype
);
1695 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_HAS_COMPLEX_MOVE_CTOR (basetype
);
1696 TYPE_POLYMORPHIC_P (t
) |= TYPE_POLYMORPHIC_P (basetype
);
1697 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
)
1698 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype
);
1699 TYPE_HAS_COMPLEX_DFLT (t
) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
1700 || TYPE_HAS_COMPLEX_DFLT (basetype
));
1701 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT
1702 (t
, CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
1703 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (basetype
));
1704 SET_CLASSTYPE_REF_FIELDS_NEED_INIT
1705 (t
, CLASSTYPE_REF_FIELDS_NEED_INIT (t
)
1706 | CLASSTYPE_REF_FIELDS_NEED_INIT (basetype
));
1707 if (TYPE_HAS_MUTABLE_P (basetype
))
1708 CLASSTYPE_HAS_MUTABLE (t
) = 1;
1710 /* A standard-layout class is a class that:
1712 * has no non-standard-layout base classes, */
1713 CLASSTYPE_NON_STD_LAYOUT (t
) |= CLASSTYPE_NON_STD_LAYOUT (basetype
);
1714 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1717 /* ...has no base classes of the same type as the first non-static
1719 if (field
&& DECL_CONTEXT (field
) == t
1720 && (same_type_ignoring_top_level_qualifiers_p
1721 (TREE_TYPE (field
), basetype
)))
1722 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1724 /* ...either has no non-static data members in the most-derived
1725 class and at most one base class with non-static data
1726 members, or has no base classes with non-static data
1728 for (basefield
= TYPE_FIELDS (basetype
); basefield
;
1729 basefield
= DECL_CHAIN (basefield
))
1730 if (TREE_CODE (basefield
) == FIELD_DECL
1731 && !(DECL_FIELD_IS_BASE (basefield
)
1732 && integer_zerop (DECL_SIZE (basefield
))))
1735 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1742 /* Don't bother collecting tm attributes if transactional memory
1743 support is not enabled. */
1746 tree tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (basetype
));
1748 seen_tm_mask
|= tm_attr_to_mask (tm_attr
);
1751 check_abi_tags (t
, basetype
);
1754 /* If one of the base classes had TM attributes, and the current class
1755 doesn't define its own, then the current class inherits one. */
1756 if (seen_tm_mask
&& !find_tm_attribute (TYPE_ATTRIBUTES (t
)))
1758 tree tm_attr
= tm_mask_to_attr (least_bit_hwi (seen_tm_mask
));
1759 TYPE_ATTRIBUTES (t
) = tree_cons (tm_attr
, NULL
, TYPE_ATTRIBUTES (t
));
1763 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1764 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1765 that have had a nearly-empty virtual primary base stolen by some
1766 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1770 determine_primary_bases (tree t
)
1773 tree primary
= NULL_TREE
;
1774 tree type_binfo
= TYPE_BINFO (t
);
1777 /* Determine the primary bases of our bases. */
1778 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1779 base_binfo
= TREE_CHAIN (base_binfo
))
1781 tree primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo
));
1783 /* See if we're the non-virtual primary of our inheritance
1785 if (!BINFO_VIRTUAL_P (base_binfo
))
1787 tree parent
= BINFO_INHERITANCE_CHAIN (base_binfo
);
1788 tree parent_primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent
));
1791 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
1792 BINFO_TYPE (parent_primary
)))
1793 /* We are the primary binfo. */
1794 BINFO_PRIMARY_P (base_binfo
) = 1;
1796 /* Determine if we have a virtual primary base, and mark it so.
1798 if (primary
&& BINFO_VIRTUAL_P (primary
))
1800 tree this_primary
= copied_binfo (primary
, base_binfo
);
1802 if (BINFO_PRIMARY_P (this_primary
))
1803 /* Someone already claimed this base. */
1804 BINFO_LOST_PRIMARY_P (base_binfo
) = 1;
1809 BINFO_PRIMARY_P (this_primary
) = 1;
1810 BINFO_INHERITANCE_CHAIN (this_primary
) = base_binfo
;
1812 /* A virtual binfo might have been copied from within
1813 another hierarchy. As we're about to use it as a
1814 primary base, make sure the offsets match. */
1815 delta
= size_diffop_loc (input_location
,
1816 fold_convert (ssizetype
,
1817 BINFO_OFFSET (base_binfo
)),
1818 fold_convert (ssizetype
,
1819 BINFO_OFFSET (this_primary
)));
1821 propagate_binfo_offsets (this_primary
, delta
);
1826 /* First look for a dynamic direct non-virtual base. */
1827 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, base_binfo
); i
++)
1829 tree basetype
= BINFO_TYPE (base_binfo
);
1831 if (TYPE_CONTAINS_VPTR_P (basetype
) && !BINFO_VIRTUAL_P (base_binfo
))
1833 primary
= base_binfo
;
1838 /* A "nearly-empty" virtual base class can be the primary base
1839 class, if no non-virtual polymorphic base can be found. Look for
1840 a nearly-empty virtual dynamic base that is not already a primary
1841 base of something in the hierarchy. If there is no such base,
1842 just pick the first nearly-empty virtual base. */
1844 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1845 base_binfo
= TREE_CHAIN (base_binfo
))
1846 if (BINFO_VIRTUAL_P (base_binfo
)
1847 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo
)))
1849 if (!BINFO_PRIMARY_P (base_binfo
))
1851 /* Found one that is not primary. */
1852 primary
= base_binfo
;
1856 /* Remember the first candidate. */
1857 primary
= base_binfo
;
1861 /* If we've got a primary base, use it. */
1864 tree basetype
= BINFO_TYPE (primary
);
1866 CLASSTYPE_PRIMARY_BINFO (t
) = primary
;
1867 if (BINFO_PRIMARY_P (primary
))
1868 /* We are stealing a primary base. */
1869 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary
)) = 1;
1870 BINFO_PRIMARY_P (primary
) = 1;
1871 if (BINFO_VIRTUAL_P (primary
))
1875 BINFO_INHERITANCE_CHAIN (primary
) = type_binfo
;
1876 /* A virtual binfo might have been copied from within
1877 another hierarchy. As we're about to use it as a primary
1878 base, make sure the offsets match. */
1879 delta
= size_diffop_loc (input_location
, ssize_int (0),
1880 fold_convert (ssizetype
, BINFO_OFFSET (primary
)));
1882 propagate_binfo_offsets (primary
, delta
);
1885 primary
= TYPE_BINFO (basetype
);
1887 TYPE_VFIELD (t
) = TYPE_VFIELD (basetype
);
1888 BINFO_VTABLE (type_binfo
) = BINFO_VTABLE (primary
);
1889 BINFO_VIRTUALS (type_binfo
) = BINFO_VIRTUALS (primary
);
1893 /* Update the variant types of T. */
1896 fixup_type_variants (tree t
)
1903 for (variants
= TYPE_NEXT_VARIANT (t
);
1905 variants
= TYPE_NEXT_VARIANT (variants
))
1907 /* These fields are in the _TYPE part of the node, not in
1908 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1909 TYPE_HAS_USER_CONSTRUCTOR (variants
) = TYPE_HAS_USER_CONSTRUCTOR (t
);
1910 TYPE_NEEDS_CONSTRUCTING (variants
) = TYPE_NEEDS_CONSTRUCTING (t
);
1911 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants
)
1912 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
1914 TYPE_POLYMORPHIC_P (variants
) = TYPE_POLYMORPHIC_P (t
);
1916 TYPE_BINFO (variants
) = TYPE_BINFO (t
);
1918 /* Copy whatever these are holding today. */
1919 TYPE_VFIELD (variants
) = TYPE_VFIELD (t
);
1920 TYPE_FIELDS (variants
) = TYPE_FIELDS (t
);
1924 /* KLASS is a class that we're applying may_alias to after the body is
1925 parsed. Fixup any POINTER_TO and REFERENCE_TO types. The
1926 canonical type(s) will be implicitly updated. */
1929 fixup_may_alias (tree klass
)
1933 for (t
= TYPE_POINTER_TO (klass
); t
; t
= TYPE_NEXT_PTR_TO (t
))
1934 for (v
= TYPE_MAIN_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1935 TYPE_REF_CAN_ALIAS_ALL (v
) = true;
1936 for (t
= TYPE_REFERENCE_TO (klass
); t
; t
= TYPE_NEXT_REF_TO (t
))
1937 for (v
= TYPE_MAIN_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1938 TYPE_REF_CAN_ALIAS_ALL (v
) = true;
1941 /* Early variant fixups: we apply attributes at the beginning of the class
1942 definition, and we need to fix up any variants that have already been
1943 made via elaborated-type-specifier so that check_qualified_type works. */
1946 fixup_attribute_variants (tree t
)
1953 tree attrs
= TYPE_ATTRIBUTES (t
);
1954 unsigned align
= TYPE_ALIGN (t
);
1955 bool user_align
= TYPE_USER_ALIGN (t
);
1956 bool may_alias
= lookup_attribute ("may_alias", attrs
);
1959 fixup_may_alias (t
);
1961 for (variants
= TYPE_NEXT_VARIANT (t
);
1963 variants
= TYPE_NEXT_VARIANT (variants
))
1965 /* These are the two fields that check_qualified_type looks at and
1966 are affected by attributes. */
1967 TYPE_ATTRIBUTES (variants
) = attrs
;
1968 unsigned valign
= align
;
1969 if (TYPE_USER_ALIGN (variants
))
1970 valign
= MAX (valign
, TYPE_ALIGN (variants
));
1972 TYPE_USER_ALIGN (variants
) = user_align
;
1973 SET_TYPE_ALIGN (variants
, valign
);
1975 fixup_may_alias (variants
);
1979 /* Set memoizing fields and bits of T (and its variants) for later
1983 finish_struct_bits (tree t
)
1985 /* Fix up variants (if any). */
1986 fixup_type_variants (t
);
1988 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) && TYPE_POLYMORPHIC_P (t
))
1989 /* For a class w/o baseclasses, 'finish_struct' has set
1990 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1991 Similarly for a class whose base classes do not have vtables.
1992 When neither of these is true, we might have removed abstract
1993 virtuals (by providing a definition), added some (by declaring
1994 new ones), or redeclared ones from a base class. We need to
1995 recalculate what's really an abstract virtual at this point (by
1996 looking in the vtables). */
1997 get_pure_virtuals (t
);
1999 /* If this type has a copy constructor or a destructor, force its
2000 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
2001 nonzero. This will cause it to be passed by invisible reference
2002 and prevent it from being returned in a register. */
2003 if (type_has_nontrivial_copy_init (t
)
2004 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
2007 SET_DECL_MODE (TYPE_MAIN_DECL (t
), BLKmode
);
2008 for (variants
= t
; variants
; variants
= TYPE_NEXT_VARIANT (variants
))
2010 SET_TYPE_MODE (variants
, BLKmode
);
2011 TREE_ADDRESSABLE (variants
) = 1;
2016 /* Issue warnings about T having private constructors, but no friends,
2019 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
2020 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
2021 non-private static member functions. */
2024 maybe_warn_about_overly_private_class (tree t
)
2026 int has_member_fn
= 0;
2027 int has_nonprivate_method
= 0;
2029 if (!warn_ctor_dtor_privacy
2030 /* If the class has friends, those entities might create and
2031 access instances, so we should not warn. */
2032 || (CLASSTYPE_FRIEND_CLASSES (t
)
2033 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
2034 /* We will have warned when the template was declared; there's
2035 no need to warn on every instantiation. */
2036 || CLASSTYPE_TEMPLATE_INSTANTIATION (t
))
2037 /* There's no reason to even consider warning about this
2041 /* We only issue one warning, if more than one applies, because
2042 otherwise, on code like:
2045 // Oops - forgot `public:'
2051 we warn several times about essentially the same problem. */
2053 /* Check to see if all (non-constructor, non-destructor) member
2054 functions are private. (Since there are no friends or
2055 non-private statics, we can't ever call any of the private member
2057 for (tree fn
= TYPE_FIELDS (t
); fn
; fn
= DECL_CHAIN (fn
))
2058 if (!DECL_DECLARES_FUNCTION_P (fn
))
2059 /* Not a function. */;
2060 else if (DECL_ARTIFICIAL (fn
))
2061 /* We're not interested in compiler-generated methods; they don't
2062 provide any way to call private members. */;
2063 else if (!TREE_PRIVATE (fn
))
2065 if (DECL_STATIC_FUNCTION_P (fn
))
2066 /* A non-private static member function is just like a
2067 friend; it can create and invoke private member
2068 functions, and be accessed without a class
2072 has_nonprivate_method
= 1;
2073 /* Keep searching for a static member function. */
2075 else if (!DECL_CONSTRUCTOR_P (fn
) && !DECL_DESTRUCTOR_P (fn
))
2078 if (!has_nonprivate_method
&& has_member_fn
)
2080 /* There are no non-private methods, and there's at least one
2081 private member function that isn't a constructor or
2082 destructor. (If all the private members are
2083 constructors/destructors we want to use the code below that
2084 issues error messages specifically referring to
2085 constructors/destructors.) */
2087 tree binfo
= TYPE_BINFO (t
);
2089 for (i
= 0; i
!= BINFO_N_BASE_BINFOS (binfo
); i
++)
2090 if (BINFO_BASE_ACCESS (binfo
, i
) != access_private_node
)
2092 has_nonprivate_method
= 1;
2095 if (!has_nonprivate_method
)
2097 warning (OPT_Wctor_dtor_privacy
,
2098 "all member functions in class %qT are private", t
);
2103 /* Even if some of the member functions are non-private, the class
2104 won't be useful for much if all the constructors or destructors
2105 are private: such an object can never be created or destroyed. */
2106 if (tree dtor
= CLASSTYPE_DESTRUCTOR (t
))
2107 if (TREE_PRIVATE (dtor
))
2109 warning (OPT_Wctor_dtor_privacy
,
2110 "%q#T only defines a private destructor and has no friends",
2115 /* Warn about classes that have private constructors and no friends. */
2116 if (TYPE_HAS_USER_CONSTRUCTOR (t
)
2117 /* Implicitly generated constructors are always public. */
2118 && !CLASSTYPE_LAZY_DEFAULT_CTOR (t
))
2120 bool nonprivate_ctor
= false;
2121 tree copy_or_move
= NULL_TREE
;
2123 /* If a non-template class does not define a copy
2124 constructor, one is defined for it, enabling it to avoid
2125 this warning. For a template class, this does not
2126 happen, and so we would normally get a warning on:
2128 template <class T> class C { private: C(); };
2130 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All
2131 complete non-template or fully instantiated classes have this
2133 if (!TYPE_HAS_COPY_CTOR (t
))
2134 nonprivate_ctor
= true;
2136 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
));
2137 !nonprivate_ctor
&& iter
; ++iter
)
2138 if (TREE_PRIVATE (*iter
))
2140 else if (copy_fn_p (*iter
) || move_fn_p (*iter
))
2141 /* Ideally, we wouldn't count any constructor that takes
2142 an argument of the class type as a parameter, because
2143 such things cannot be used to construct an instance of
2144 the class unless you already have one. */
2145 copy_or_move
= *iter
;
2147 nonprivate_ctor
= true;
2149 if (!nonprivate_ctor
)
2151 warning (OPT_Wctor_dtor_privacy
,
2152 "%q#T only defines private constructors and has no friends",
2155 inform (DECL_SOURCE_LOCATION (copy_or_move
),
2156 "%q#D is public, but requires an existing %q#T object",
2163 /* Make BINFO's vtable have N entries, including RTTI entries,
2164 vbase and vcall offsets, etc. Set its type and call the back end
2168 layout_vtable_decl (tree binfo
, int n
)
2173 atype
= build_array_of_n_type (vtable_entry_type
, n
);
2174 layout_type (atype
);
2176 /* We may have to grow the vtable. */
2177 vtable
= get_vtbl_decl_for_binfo (binfo
);
2178 if (!same_type_p (TREE_TYPE (vtable
), atype
))
2180 TREE_TYPE (vtable
) = atype
;
2181 DECL_SIZE (vtable
) = DECL_SIZE_UNIT (vtable
) = NULL_TREE
;
2182 layout_decl (vtable
, 0);
2186 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
2187 have the same signature. */
2190 same_signature_p (const_tree fndecl
, const_tree base_fndecl
)
2192 /* One destructor overrides another if they are the same kind of
2194 if (DECL_DESTRUCTOR_P (base_fndecl
) && DECL_DESTRUCTOR_P (fndecl
)
2195 && special_function_p (base_fndecl
) == special_function_p (fndecl
))
2197 /* But a non-destructor never overrides a destructor, nor vice
2198 versa, nor do different kinds of destructors override
2199 one-another. For example, a complete object destructor does not
2200 override a deleting destructor. */
2201 if (DECL_DESTRUCTOR_P (base_fndecl
) || DECL_DESTRUCTOR_P (fndecl
))
2204 if (DECL_NAME (fndecl
) == DECL_NAME (base_fndecl
)
2205 || (DECL_CONV_FN_P (fndecl
)
2206 && DECL_CONV_FN_P (base_fndecl
)
2207 && same_type_p (DECL_CONV_FN_TYPE (fndecl
),
2208 DECL_CONV_FN_TYPE (base_fndecl
))))
2210 tree fntype
= TREE_TYPE (fndecl
);
2211 tree base_fntype
= TREE_TYPE (base_fndecl
);
2212 if (type_memfn_quals (fntype
) == type_memfn_quals (base_fntype
)
2213 && type_memfn_rqual (fntype
) == type_memfn_rqual (base_fntype
)
2214 && compparms (FUNCTION_FIRST_USER_PARMTYPE (fndecl
),
2215 FUNCTION_FIRST_USER_PARMTYPE (base_fndecl
)))
2221 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
2225 base_derived_from (tree derived
, tree base
)
2229 for (probe
= base
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
2231 if (probe
== derived
)
2233 else if (BINFO_VIRTUAL_P (probe
))
2234 /* If we meet a virtual base, we can't follow the inheritance
2235 any more. See if the complete type of DERIVED contains
2236 such a virtual base. */
2237 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (derived
))
2243 struct find_final_overrider_data
{
2244 /* The function for which we are trying to find a final overrider. */
2246 /* The base class in which the function was declared. */
2247 tree declaring_base
;
2248 /* The candidate overriders. */
2250 /* Path to most derived. */
2254 /* Add the overrider along the current path to FFOD->CANDIDATES.
2255 Returns true if an overrider was found; false otherwise. */
2258 dfs_find_final_overrider_1 (tree binfo
,
2259 find_final_overrider_data
*ffod
,
2264 /* If BINFO is not the most derived type, try a more derived class.
2265 A definition there will overrider a definition here. */
2269 if (dfs_find_final_overrider_1
2270 (ffod
->path
[depth
], ffod
, depth
))
2274 method
= look_for_overrides_here (BINFO_TYPE (binfo
), ffod
->fn
);
2277 tree
*candidate
= &ffod
->candidates
;
2279 /* Remove any candidates overridden by this new function. */
2282 /* If *CANDIDATE overrides METHOD, then METHOD
2283 cannot override anything else on the list. */
2284 if (base_derived_from (TREE_VALUE (*candidate
), binfo
))
2286 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
2287 if (base_derived_from (binfo
, TREE_VALUE (*candidate
)))
2288 *candidate
= TREE_CHAIN (*candidate
);
2290 candidate
= &TREE_CHAIN (*candidate
);
2293 /* Add the new function. */
2294 ffod
->candidates
= tree_cons (method
, binfo
, ffod
->candidates
);
2301 /* Called from find_final_overrider via dfs_walk. */
2304 dfs_find_final_overrider_pre (tree binfo
, void *data
)
2306 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
2308 if (binfo
== ffod
->declaring_base
)
2309 dfs_find_final_overrider_1 (binfo
, ffod
, ffod
->path
.length ());
2310 ffod
->path
.safe_push (binfo
);
2316 dfs_find_final_overrider_post (tree
/*binfo*/, void *data
)
2318 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
2324 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2325 FN and whose TREE_VALUE is the binfo for the base where the
2326 overriding occurs. BINFO (in the hierarchy dominated by the binfo
2327 DERIVED) is the base object in which FN is declared. */
2330 find_final_overrider (tree derived
, tree binfo
, tree fn
)
2332 find_final_overrider_data ffod
;
2334 /* Getting this right is a little tricky. This is valid:
2336 struct S { virtual void f (); };
2337 struct T { virtual void f (); };
2338 struct U : public S, public T { };
2340 even though calling `f' in `U' is ambiguous. But,
2342 struct R { virtual void f(); };
2343 struct S : virtual public R { virtual void f (); };
2344 struct T : virtual public R { virtual void f (); };
2345 struct U : public S, public T { };
2347 is not -- there's no way to decide whether to put `S::f' or
2348 `T::f' in the vtable for `R'.
2350 The solution is to look at all paths to BINFO. If we find
2351 different overriders along any two, then there is a problem. */
2352 if (DECL_THUNK_P (fn
))
2353 fn
= THUNK_TARGET (fn
);
2355 /* Determine the depth of the hierarchy. */
2357 ffod
.declaring_base
= binfo
;
2358 ffod
.candidates
= NULL_TREE
;
2359 ffod
.path
.create (30);
2361 dfs_walk_all (derived
, dfs_find_final_overrider_pre
,
2362 dfs_find_final_overrider_post
, &ffod
);
2364 ffod
.path
.release ();
2366 /* If there was no winner, issue an error message. */
2367 if (!ffod
.candidates
|| TREE_CHAIN (ffod
.candidates
))
2368 return error_mark_node
;
2370 return ffod
.candidates
;
2373 /* Return the index of the vcall offset for FN when TYPE is used as a
2377 get_vcall_index (tree fn
, tree type
)
2379 vec
<tree_pair_s
, va_gc
> *indices
= CLASSTYPE_VCALL_INDICES (type
);
2383 FOR_EACH_VEC_SAFE_ELT (indices
, ix
, p
)
2384 if ((DECL_DESTRUCTOR_P (fn
) && DECL_DESTRUCTOR_P (p
->purpose
))
2385 || same_signature_p (fn
, p
->purpose
))
2388 /* There should always be an appropriate index. */
2392 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2393 dominated by T. FN is the old function; VIRTUALS points to the
2394 corresponding position in the new BINFO_VIRTUALS list. IX is the index
2395 of that entry in the list. */
2398 update_vtable_entry_for_fn (tree t
, tree binfo
, tree fn
, tree
* virtuals
,
2406 tree overrider_fn
, overrider_target
;
2407 tree target_fn
= DECL_THUNK_P (fn
) ? THUNK_TARGET (fn
) : fn
;
2408 tree over_return
, base_return
;
2411 /* Find the nearest primary base (possibly binfo itself) which defines
2412 this function; this is the class the caller will convert to when
2413 calling FN through BINFO. */
2414 for (b
= binfo
; ; b
= get_primary_binfo (b
))
2417 if (look_for_overrides_here (BINFO_TYPE (b
), target_fn
))
2420 /* The nearest definition is from a lost primary. */
2421 if (BINFO_LOST_PRIMARY_P (b
))
2426 /* Find the final overrider. */
2427 overrider
= find_final_overrider (TYPE_BINFO (t
), b
, target_fn
);
2428 if (overrider
== error_mark_node
)
2430 error ("no unique final overrider for %qD in %qT", target_fn
, t
);
2433 overrider_target
= overrider_fn
= TREE_PURPOSE (overrider
);
2435 /* Check for adjusting covariant return types. */
2436 over_return
= TREE_TYPE (TREE_TYPE (overrider_target
));
2437 base_return
= TREE_TYPE (TREE_TYPE (target_fn
));
2439 if (POINTER_TYPE_P (over_return
)
2440 && TREE_CODE (over_return
) == TREE_CODE (base_return
)
2441 && CLASS_TYPE_P (TREE_TYPE (over_return
))
2442 && CLASS_TYPE_P (TREE_TYPE (base_return
))
2443 /* If the overrider is invalid, don't even try. */
2444 && !DECL_INVALID_OVERRIDER_P (overrider_target
))
2446 /* If FN is a covariant thunk, we must figure out the adjustment
2447 to the final base FN was converting to. As OVERRIDER_TARGET might
2448 also be converting to the return type of FN, we have to
2449 combine the two conversions here. */
2450 tree fixed_offset
, virtual_offset
;
2452 over_return
= TREE_TYPE (over_return
);
2453 base_return
= TREE_TYPE (base_return
);
2455 if (DECL_THUNK_P (fn
))
2457 gcc_assert (DECL_RESULT_THUNK_P (fn
));
2458 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn
));
2459 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn
);
2462 fixed_offset
= virtual_offset
= NULL_TREE
;
2465 /* Find the equivalent binfo within the return type of the
2466 overriding function. We will want the vbase offset from
2468 virtual_offset
= binfo_for_vbase (BINFO_TYPE (virtual_offset
),
2470 else if (!same_type_ignoring_top_level_qualifiers_p
2471 (over_return
, base_return
))
2473 /* There was no existing virtual thunk (which takes
2474 precedence). So find the binfo of the base function's
2475 return type within the overriding function's return type.
2476 Fortunately we know the covariancy is valid (it
2477 has already been checked), so we can just iterate along
2478 the binfos, which have been chained in inheritance graph
2479 order. Of course it is lame that we have to repeat the
2480 search here anyway -- we should really be caching pieces
2481 of the vtable and avoiding this repeated work. */
2482 tree thunk_binfo
, base_binfo
;
2484 /* Find the base binfo within the overriding function's
2485 return type. We will always find a thunk_binfo, except
2486 when the covariancy is invalid (which we will have
2487 already diagnosed). */
2488 for (base_binfo
= TYPE_BINFO (base_return
),
2489 thunk_binfo
= TYPE_BINFO (over_return
);
2491 thunk_binfo
= TREE_CHAIN (thunk_binfo
))
2492 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo
),
2493 BINFO_TYPE (base_binfo
)))
2496 /* See if virtual inheritance is involved. */
2497 for (virtual_offset
= thunk_binfo
;
2499 virtual_offset
= BINFO_INHERITANCE_CHAIN (virtual_offset
))
2500 if (BINFO_VIRTUAL_P (virtual_offset
))
2504 || (thunk_binfo
&& !BINFO_OFFSET_ZEROP (thunk_binfo
)))
2506 tree offset
= fold_convert (ssizetype
, BINFO_OFFSET (thunk_binfo
));
2510 /* We convert via virtual base. Adjust the fixed
2511 offset to be from there. */
2513 size_diffop (offset
,
2514 fold_convert (ssizetype
,
2515 BINFO_OFFSET (virtual_offset
)));
2518 /* There was an existing fixed offset, this must be
2519 from the base just converted to, and the base the
2520 FN was thunking to. */
2521 fixed_offset
= size_binop (PLUS_EXPR
, fixed_offset
, offset
);
2523 fixed_offset
= offset
;
2527 if (fixed_offset
|| virtual_offset
)
2528 /* Replace the overriding function with a covariant thunk. We
2529 will emit the overriding function in its own slot as
2531 overrider_fn
= make_thunk (overrider_target
, /*this_adjusting=*/0,
2532 fixed_offset
, virtual_offset
);
2535 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target
) ||
2536 !DECL_THUNK_P (fn
));
2538 /* If we need a covariant thunk, then we may need to adjust first_defn.
2539 The ABI specifies that the thunks emitted with a function are
2540 determined by which bases the function overrides, so we need to be
2541 sure that we're using a thunk for some overridden base; even if we
2542 know that the necessary this adjustment is zero, there may not be an
2543 appropriate zero-this-adjustment thunk for us to use since thunks for
2544 overriding virtual bases always use the vcall offset.
2546 Furthermore, just choosing any base that overrides this function isn't
2547 quite right, as this slot won't be used for calls through a type that
2548 puts a covariant thunk here. Calling the function through such a type
2549 will use a different slot, and that slot is the one that determines
2550 the thunk emitted for that base.
2552 So, keep looking until we find the base that we're really overriding
2553 in this slot: the nearest primary base that doesn't use a covariant
2554 thunk in this slot. */
2555 if (overrider_target
!= overrider_fn
)
2557 if (BINFO_TYPE (b
) == DECL_CONTEXT (overrider_target
))
2558 /* We already know that the overrider needs a covariant thunk. */
2559 b
= get_primary_binfo (b
);
2560 for (; ; b
= get_primary_binfo (b
))
2562 tree main_binfo
= TYPE_BINFO (BINFO_TYPE (b
));
2563 tree bv
= chain_index (ix
, BINFO_VIRTUALS (main_binfo
));
2564 if (!DECL_THUNK_P (TREE_VALUE (bv
)))
2566 if (BINFO_LOST_PRIMARY_P (b
))
2572 /* Assume that we will produce a thunk that convert all the way to
2573 the final overrider, and not to an intermediate virtual base. */
2574 virtual_base
= NULL_TREE
;
2576 /* See if we can convert to an intermediate virtual base first, and then
2577 use the vcall offset located there to finish the conversion. */
2578 for (; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
2580 /* If we find the final overrider, then we can stop
2582 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b
),
2583 BINFO_TYPE (TREE_VALUE (overrider
))))
2586 /* If we find a virtual base, and we haven't yet found the
2587 overrider, then there is a virtual base between the
2588 declaring base (first_defn) and the final overrider. */
2589 if (BINFO_VIRTUAL_P (b
))
2596 /* Compute the constant adjustment to the `this' pointer. The
2597 `this' pointer, when this function is called, will point at BINFO
2598 (or one of its primary bases, which are at the same offset). */
2600 /* The `this' pointer needs to be adjusted from the declaration to
2601 the nearest virtual base. */
2602 delta
= size_diffop_loc (input_location
,
2603 fold_convert (ssizetype
, BINFO_OFFSET (virtual_base
)),
2604 fold_convert (ssizetype
, BINFO_OFFSET (first_defn
)));
2606 /* If the nearest definition is in a lost primary, we don't need an
2607 entry in our vtable. Except possibly in a constructor vtable,
2608 if we happen to get our primary back. In that case, the offset
2609 will be zero, as it will be a primary base. */
2610 delta
= size_zero_node
;
2612 /* The `this' pointer needs to be adjusted from pointing to
2613 BINFO to pointing at the base where the final overrider
2615 delta
= size_diffop_loc (input_location
,
2616 fold_convert (ssizetype
,
2617 BINFO_OFFSET (TREE_VALUE (overrider
))),
2618 fold_convert (ssizetype
, BINFO_OFFSET (binfo
)));
2620 modify_vtable_entry (t
, binfo
, overrider_fn
, delta
, virtuals
);
2623 BV_VCALL_INDEX (*virtuals
)
2624 = get_vcall_index (overrider_target
, BINFO_TYPE (virtual_base
));
2626 BV_VCALL_INDEX (*virtuals
) = NULL_TREE
;
2628 BV_LOST_PRIMARY (*virtuals
) = lost
;
2631 /* Called from modify_all_vtables via dfs_walk. */
2634 dfs_modify_vtables (tree binfo
, void* data
)
2636 tree t
= (tree
) data
;
2641 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
2642 /* A base without a vtable needs no modification, and its bases
2643 are uninteresting. */
2644 return dfs_skip_bases
;
2646 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
)
2647 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
2648 /* Don't do the primary vtable, if it's new. */
2651 if (BINFO_PRIMARY_P (binfo
) && !BINFO_VIRTUAL_P (binfo
))
2652 /* There's no need to modify the vtable for a non-virtual primary
2653 base; we're not going to use that vtable anyhow. We do still
2654 need to do this for virtual primary bases, as they could become
2655 non-primary in a construction vtable. */
2658 make_new_vtable (t
, binfo
);
2660 /* Now, go through each of the virtual functions in the virtual
2661 function table for BINFO. Find the final overrider, and update
2662 the BINFO_VIRTUALS list appropriately. */
2663 for (ix
= 0, virtuals
= BINFO_VIRTUALS (binfo
),
2664 old_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
2666 ix
++, virtuals
= TREE_CHAIN (virtuals
),
2667 old_virtuals
= TREE_CHAIN (old_virtuals
))
2668 update_vtable_entry_for_fn (t
,
2670 BV_FN (old_virtuals
),
2676 /* Update all of the primary and secondary vtables for T. Create new
2677 vtables as required, and initialize their RTTI information. Each
2678 of the functions in VIRTUALS is declared in T and may override a
2679 virtual function from a base class; find and modify the appropriate
2680 entries to point to the overriding functions. Returns a list, in
2681 declaration order, of the virtual functions that are declared in T,
2682 but do not appear in the primary base class vtable, and which
2683 should therefore be appended to the end of the vtable for T. */
2686 modify_all_vtables (tree t
, tree virtuals
)
2688 tree binfo
= TYPE_BINFO (t
);
2691 /* Mangle the vtable name before entering dfs_walk (c++/51884). */
2692 if (TYPE_CONTAINS_VPTR_P (t
))
2693 get_vtable_decl (t
, false);
2695 /* Update all of the vtables. */
2696 dfs_walk_once (binfo
, dfs_modify_vtables
, NULL
, t
);
2698 /* Add virtual functions not already in our primary vtable. These
2699 will be both those introduced by this class, and those overridden
2700 from secondary bases. It does not include virtuals merely
2701 inherited from secondary bases. */
2702 for (fnsp
= &virtuals
; *fnsp
; )
2704 tree fn
= TREE_VALUE (*fnsp
);
2706 if (!value_member (fn
, BINFO_VIRTUALS (binfo
))
2707 || DECL_VINDEX (fn
) == error_mark_node
)
2709 /* We don't need to adjust the `this' pointer when
2710 calling this function. */
2711 BV_DELTA (*fnsp
) = integer_zero_node
;
2712 BV_VCALL_INDEX (*fnsp
) = NULL_TREE
;
2714 /* This is a function not already in our vtable. Keep it. */
2715 fnsp
= &TREE_CHAIN (*fnsp
);
2718 /* We've already got an entry for this function. Skip it. */
2719 *fnsp
= TREE_CHAIN (*fnsp
);
2725 /* Get the base virtual function declarations in T that have the
2729 get_basefndecls (tree name
, tree t
, vec
<tree
> *base_fndecls
)
2731 bool found_decls
= false;
2733 /* Find virtual functions in T with the indicated NAME. */
2734 for (ovl_iterator
iter (get_class_binding (t
, name
)); iter
; ++iter
)
2736 tree method
= *iter
;
2738 if (TREE_CODE (method
) == FUNCTION_DECL
&& DECL_VINDEX (method
))
2740 base_fndecls
->safe_push (method
);
2748 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
2749 for (int i
= 0; i
< n_baseclasses
; i
++)
2751 tree basetype
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t
), i
));
2752 get_basefndecls (name
, basetype
, base_fndecls
);
2756 /* If this declaration supersedes the declaration of
2757 a method declared virtual in the base class, then
2758 mark this field as being virtual as well. */
2761 check_for_override (tree decl
, tree ctype
)
2763 bool overrides_found
= false;
2764 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2765 /* In [temp.mem] we have:
2767 A specialization of a member function template does not
2768 override a virtual function from a base class. */
2770 if ((DECL_DESTRUCTOR_P (decl
)
2771 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
))
2772 || DECL_CONV_FN_P (decl
))
2773 && look_for_overrides (ctype
, decl
)
2774 && !DECL_STATIC_FUNCTION_P (decl
))
2775 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2776 the error_mark_node so that we know it is an overriding
2779 DECL_VINDEX (decl
) = decl
;
2780 overrides_found
= true;
2781 if (warn_override
&& !DECL_OVERRIDE_P (decl
)
2782 && !DECL_DESTRUCTOR_P (decl
))
2783 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wsuggest_override
,
2784 "%qD can be marked override", decl
);
2787 if (DECL_VIRTUAL_P (decl
))
2789 if (!DECL_VINDEX (decl
))
2790 DECL_VINDEX (decl
) = error_mark_node
;
2791 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
2792 if (DECL_DESTRUCTOR_P (decl
))
2793 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype
) = true;
2795 else if (DECL_FINAL_P (decl
))
2796 error ("%q+#D marked %<final%>, but is not virtual", decl
);
2797 if (DECL_OVERRIDE_P (decl
) && !overrides_found
)
2798 error ("%q+#D marked %<override%>, but does not override", decl
);
2801 /* Warn about hidden virtual functions that are not overridden in t.
2802 We know that constructors and destructors don't apply. */
2805 warn_hidden (tree t
)
2807 if (vec
<tree
, va_gc
> *member_vec
= CLASSTYPE_MEMBER_VEC (t
))
2808 for (unsigned ix
= member_vec
->length (); ix
--;)
2810 tree fns
= (*member_vec
)[ix
];
2815 tree name
= OVL_NAME (fns
);
2816 auto_vec
<tree
, 20> base_fndecls
;
2821 /* Iterate through all of the base classes looking for possibly
2822 hidden functions. */
2823 for (binfo
= TYPE_BINFO (t
), j
= 0;
2824 BINFO_BASE_ITERATE (binfo
, j
, base_binfo
); j
++)
2826 tree basetype
= BINFO_TYPE (base_binfo
);
2827 get_basefndecls (name
, basetype
, &base_fndecls
);
2830 /* If there are no functions to hide, continue. */
2831 if (base_fndecls
.is_empty ())
2834 /* Remove any overridden functions. */
2835 for (ovl_iterator
iter (fns
); iter
; ++iter
)
2837 tree fndecl
= *iter
;
2838 if (TREE_CODE (fndecl
) == FUNCTION_DECL
2839 && DECL_VINDEX (fndecl
))
2841 /* If the method from the base class has the same
2842 signature as the method from the derived class, it
2843 has been overridden. */
2844 for (size_t k
= 0; k
< base_fndecls
.length (); k
++)
2846 && same_signature_p (fndecl
, base_fndecls
[k
]))
2847 base_fndecls
[k
] = NULL_TREE
;
2851 /* Now give a warning for all base functions without overriders,
2852 as they are hidden. */
2854 FOR_EACH_VEC_ELT (base_fndecls
, j
, base_fndecl
)
2857 /* Here we know it is a hider, and no overrider exists. */
2858 warning_at (location_of (base_fndecl
),
2859 OPT_Woverloaded_virtual
,
2860 "%qD was hidden", base_fndecl
);
2861 warning_at (location_of (fns
),
2862 OPT_Woverloaded_virtual
, " by %qD", fns
);
2867 /* Recursive helper for finish_struct_anon. */
2870 finish_struct_anon_r (tree field
, bool complain
)
2872 for (tree elt
= TYPE_FIELDS (TREE_TYPE (field
)); elt
; elt
= DECL_CHAIN (elt
))
2874 /* We're generally only interested in entities the user
2875 declared, but we also find nested classes by noticing
2876 the TYPE_DECL that we create implicitly. You're
2877 allowed to put one anonymous union inside another,
2878 though, so we explicitly tolerate that. We use
2879 TYPE_UNNAMED_P rather than ANON_AGGR_TYPE_P so that
2880 we also allow unnamed types used for defining fields. */
2881 if (DECL_ARTIFICIAL (elt
)
2882 && (!DECL_IMPLICIT_TYPEDEF_P (elt
)
2883 || TYPE_UNNAMED_P (TREE_TYPE (elt
))))
2887 && (TREE_CODE (elt
) != FIELD_DECL
2888 || (TREE_PRIVATE (elt
) || TREE_PROTECTED (elt
))))
2890 /* We already complained about static data members in
2891 finish_static_data_member_decl. */
2893 && permerror (DECL_SOURCE_LOCATION (elt
),
2894 TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
2895 ? "%q#D invalid; an anonymous union may "
2896 "only have public non-static data members"
2897 : "%q#D invalid; an anonymous struct may "
2898 "only have public non-static data members", elt
))
2901 if (flag_permissive
&& !hint
)
2904 inform (DECL_SOURCE_LOCATION (elt
),
2905 "this flexibility is deprecated and will be removed");
2910 TREE_PRIVATE (elt
) = TREE_PRIVATE (field
);
2911 TREE_PROTECTED (elt
) = TREE_PROTECTED (field
);
2913 /* Recurse into the anonymous aggregates to correctly handle
2914 access control (c++/24926):
2925 if (DECL_NAME (elt
) == NULL_TREE
2926 && ANON_AGGR_TYPE_P (TREE_TYPE (elt
)))
2927 finish_struct_anon_r (elt
, /*complain=*/false);
2931 /* Check for things that are invalid. There are probably plenty of other
2932 things we should check for also. */
2935 finish_struct_anon (tree t
)
2937 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
2939 if (TREE_STATIC (field
))
2941 if (TREE_CODE (field
) != FIELD_DECL
)
2944 if (DECL_NAME (field
) == NULL_TREE
2945 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
2946 finish_struct_anon_r (field
, /*complain=*/true);
2950 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2951 will be used later during class template instantiation.
2952 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2953 a non-static member data (FIELD_DECL), a member function
2954 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2955 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2956 When FRIEND_P is nonzero, T is either a friend class
2957 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2958 (FUNCTION_DECL, TEMPLATE_DECL). */
2961 maybe_add_class_template_decl_list (tree type
, tree t
, int friend_p
)
2963 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2964 if (CLASSTYPE_TEMPLATE_INFO (type
))
2965 CLASSTYPE_DECL_LIST (type
)
2966 = tree_cons (friend_p
? NULL_TREE
: type
,
2967 t
, CLASSTYPE_DECL_LIST (type
));
2970 /* This function is called from declare_virt_assop_and_dtor via
2973 DATA is a type that direcly or indirectly inherits the base
2974 represented by BINFO. If BINFO contains a virtual assignment [copy
2975 assignment or move assigment] operator or a virtual constructor,
2976 declare that function in DATA if it hasn't been already declared. */
2979 dfs_declare_virt_assop_and_dtor (tree binfo
, void *data
)
2981 tree bv
, fn
, t
= (tree
)data
;
2982 tree opname
= assign_op_identifier
;
2984 gcc_assert (t
&& CLASS_TYPE_P (t
));
2985 gcc_assert (binfo
&& TREE_CODE (binfo
) == TREE_BINFO
);
2987 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
2988 /* A base without a vtable needs no modification, and its bases
2989 are uninteresting. */
2990 return dfs_skip_bases
;
2992 if (BINFO_PRIMARY_P (binfo
))
2993 /* If this is a primary base, then we have already looked at the
2994 virtual functions of its vtable. */
2997 for (bv
= BINFO_VIRTUALS (binfo
); bv
; bv
= TREE_CHAIN (bv
))
3001 if (DECL_NAME (fn
) == opname
)
3003 if (CLASSTYPE_LAZY_COPY_ASSIGN (t
))
3004 lazily_declare_fn (sfk_copy_assignment
, t
);
3005 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
3006 lazily_declare_fn (sfk_move_assignment
, t
);
3008 else if (DECL_DESTRUCTOR_P (fn
)
3009 && CLASSTYPE_LAZY_DESTRUCTOR (t
))
3010 lazily_declare_fn (sfk_destructor
, t
);
3016 /* If the class type T has a direct or indirect base that contains a
3017 virtual assignment operator or a virtual destructor, declare that
3018 function in T if it hasn't been already declared. */
3021 declare_virt_assop_and_dtor (tree t
)
3023 if (!(TYPE_POLYMORPHIC_P (t
)
3024 && (CLASSTYPE_LAZY_COPY_ASSIGN (t
)
3025 || CLASSTYPE_LAZY_MOVE_ASSIGN (t
)
3026 || CLASSTYPE_LAZY_DESTRUCTOR (t
))))
3029 dfs_walk_all (TYPE_BINFO (t
),
3030 dfs_declare_virt_assop_and_dtor
,
3034 /* Declare the inheriting constructor for class T inherited from base
3035 constructor CTOR with the parameter array PARMS of size NPARMS. */
3038 one_inheriting_sig (tree t
, tree ctor
, tree
*parms
, int nparms
)
3040 gcc_assert (TYPE_MAIN_VARIANT (t
) == t
);
3042 /* We don't declare an inheriting ctor that would be a default,
3043 copy or move ctor for derived or base. */
3047 && TREE_CODE (parms
[0]) == REFERENCE_TYPE
)
3049 tree parm
= TYPE_MAIN_VARIANT (TREE_TYPE (parms
[0]));
3050 if (parm
== t
|| parm
== DECL_CONTEXT (ctor
))
3054 tree parmlist
= void_list_node
;
3055 for (int i
= nparms
- 1; i
>= 0; i
--)
3056 parmlist
= tree_cons (NULL_TREE
, parms
[i
], parmlist
);
3057 tree fn
= implicitly_declare_fn (sfk_inheriting_constructor
,
3058 t
, false, ctor
, parmlist
);
3060 if (add_method (t
, fn
, false))
3062 DECL_CHAIN (fn
) = TYPE_FIELDS (t
);
3063 TYPE_FIELDS (t
) = fn
;
3067 /* Declare all the inheriting constructors for class T inherited from base
3068 constructor CTOR. */
3071 one_inherited_ctor (tree ctor
, tree t
, tree using_decl
)
3073 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (ctor
);
3075 if (flag_new_inheriting_ctors
)
3077 ctor
= implicitly_declare_fn (sfk_inheriting_constructor
,
3078 t
, /*const*/false, ctor
, parms
);
3079 add_method (t
, ctor
, using_decl
!= NULL_TREE
);
3080 TYPE_HAS_USER_CONSTRUCTOR (t
) = true;
3084 tree
*new_parms
= XALLOCAVEC (tree
, list_length (parms
));
3086 for (; parms
&& parms
!= void_list_node
; parms
= TREE_CHAIN (parms
))
3088 if (TREE_PURPOSE (parms
))
3089 one_inheriting_sig (t
, ctor
, new_parms
, i
);
3090 new_parms
[i
++] = TREE_VALUE (parms
);
3092 one_inheriting_sig (t
, ctor
, new_parms
, i
);
3093 if (parms
== NULL_TREE
)
3095 if (warning (OPT_Winherited_variadic_ctor
,
3096 "the ellipsis in %qD is not inherited", ctor
))
3097 inform (DECL_SOURCE_LOCATION (ctor
), "%qD declared here", ctor
);
3101 /* Create default constructors, assignment operators, and so forth for
3102 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
3103 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
3104 the class cannot have a default constructor, copy constructor
3105 taking a const reference argument, or an assignment operator taking
3106 a const reference, respectively. */
3109 add_implicitly_declared_members (tree t
, tree
* access_decls
,
3110 int cant_have_const_cctor
,
3111 int cant_have_const_assignment
)
3114 if (!CLASSTYPE_DESTRUCTOR (t
))
3115 /* In general, we create destructors lazily. */
3116 CLASSTYPE_LAZY_DESTRUCTOR (t
) = 1;
3118 bool move_ok
= false;
3119 if (cxx_dialect
>= cxx11
&& CLASSTYPE_LAZY_DESTRUCTOR (t
)
3120 && !TYPE_HAS_COPY_CTOR (t
) && !TYPE_HAS_COPY_ASSIGN (t
)
3121 && !classtype_has_move_assign_or_move_ctor_p (t
, false))
3126 If there is no user-declared constructor for a class, a default
3127 constructor is implicitly declared. */
3128 if (! TYPE_HAS_USER_CONSTRUCTOR (t
))
3130 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 1;
3131 CLASSTYPE_LAZY_DEFAULT_CTOR (t
) = 1;
3132 if (cxx_dialect
>= cxx11
)
3133 TYPE_HAS_CONSTEXPR_CTOR (t
)
3134 /* Don't force the declaration to get a hard answer; if the
3135 definition would have made the class non-literal, it will still be
3136 non-literal because of the base or member in question, and that
3137 gives a better diagnostic. */
3138 = type_maybe_constexpr_default_constructor (t
);
3143 If a class definition does not explicitly declare a copy
3144 constructor, one is declared implicitly. */
3145 if (! TYPE_HAS_COPY_CTOR (t
))
3147 TYPE_HAS_COPY_CTOR (t
) = 1;
3148 TYPE_HAS_CONST_COPY_CTOR (t
) = !cant_have_const_cctor
;
3149 CLASSTYPE_LAZY_COPY_CTOR (t
) = 1;
3151 CLASSTYPE_LAZY_MOVE_CTOR (t
) = 1;
3154 /* If there is no assignment operator, one will be created if and
3155 when it is needed. For now, just record whether or not the type
3156 of the parameter to the assignment operator will be a const or
3157 non-const reference. */
3158 if (!TYPE_HAS_COPY_ASSIGN (t
))
3160 TYPE_HAS_COPY_ASSIGN (t
) = 1;
3161 TYPE_HAS_CONST_COPY_ASSIGN (t
) = !cant_have_const_assignment
;
3162 CLASSTYPE_LAZY_COPY_ASSIGN (t
) = 1;
3163 if (move_ok
&& !LAMBDA_TYPE_P (t
))
3164 CLASSTYPE_LAZY_MOVE_ASSIGN (t
) = 1;
3167 /* We can't be lazy about declaring functions that might override
3168 a virtual function from a base class. */
3169 declare_virt_assop_and_dtor (t
);
3171 while (*access_decls
)
3173 tree using_decl
= TREE_VALUE (*access_decls
);
3174 tree decl
= USING_DECL_DECLS (using_decl
);
3175 if (DECL_NAME (using_decl
) == ctor_identifier
)
3177 /* declare, then remove the decl */
3178 tree ctor_list
= decl
;
3179 location_t loc
= input_location
;
3180 input_location
= DECL_SOURCE_LOCATION (using_decl
);
3181 for (ovl_iterator
iter (ctor_list
); iter
; ++iter
)
3182 one_inherited_ctor (*iter
, t
, using_decl
);
3183 *access_decls
= TREE_CHAIN (*access_decls
);
3184 input_location
= loc
;
3187 access_decls
= &TREE_CHAIN (*access_decls
);
3191 /* FIELD is a bit-field. We are finishing the processing for its
3192 enclosing type. Issue any appropriate messages and set appropriate
3193 flags. Returns false if an error has been diagnosed. */
3196 check_bitfield_decl (tree field
)
3198 tree type
= TREE_TYPE (field
);
3201 /* Extract the declared width of the bitfield, which has been
3202 temporarily stashed in DECL_BIT_FIELD_REPRESENTATIVE by grokbitfield. */
3203 w
= DECL_BIT_FIELD_REPRESENTATIVE (field
);
3204 gcc_assert (w
!= NULL_TREE
);
3205 /* Remove the bit-field width indicator so that the rest of the
3206 compiler does not treat that value as a qualifier. */
3207 DECL_BIT_FIELD_REPRESENTATIVE (field
) = NULL_TREE
;
3209 /* Detect invalid bit-field type. */
3210 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3212 error ("bit-field %q+#D with non-integral type", field
);
3213 w
= error_mark_node
;
3217 location_t loc
= input_location
;
3218 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
3221 /* detect invalid field size. */
3222 input_location
= DECL_SOURCE_LOCATION (field
);
3223 w
= cxx_constant_value (w
);
3224 input_location
= loc
;
3226 if (TREE_CODE (w
) != INTEGER_CST
)
3228 error ("bit-field %q+D width not an integer constant", field
);
3229 w
= error_mark_node
;
3231 else if (tree_int_cst_sgn (w
) < 0)
3233 error ("negative width in bit-field %q+D", field
);
3234 w
= error_mark_node
;
3236 else if (integer_zerop (w
) && DECL_NAME (field
) != 0)
3238 error ("zero width for bit-field %q+D", field
);
3239 w
= error_mark_node
;
3241 else if ((TREE_CODE (type
) != ENUMERAL_TYPE
3242 && TREE_CODE (type
) != BOOLEAN_TYPE
3243 && compare_tree_int (w
, TYPE_PRECISION (type
)) > 0)
3244 || ((TREE_CODE (type
) == ENUMERAL_TYPE
3245 || TREE_CODE (type
) == BOOLEAN_TYPE
)
3246 && tree_int_cst_lt (TYPE_SIZE (type
), w
)))
3247 warning_at (DECL_SOURCE_LOCATION (field
), 0,
3248 "width of %qD exceeds its type", field
);
3249 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
3251 int prec
= TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type
));
3252 if (compare_tree_int (w
, prec
) < 0)
3253 warning_at (DECL_SOURCE_LOCATION (field
), 0,
3254 "%qD is too small to hold all values of %q#T",
3259 if (w
!= error_mark_node
)
3261 DECL_SIZE (field
) = fold_convert (bitsizetype
, w
);
3262 DECL_BIT_FIELD (field
) = 1;
3267 /* Non-bit-fields are aligned for their type. */
3268 DECL_BIT_FIELD (field
) = 0;
3269 CLEAR_DECL_C_BIT_FIELD (field
);
3274 /* FIELD is a non bit-field. We are finishing the processing for its
3275 enclosing type T. Issue any appropriate messages and set appropriate
3279 check_field_decl (tree field
,
3281 int* cant_have_const_ctor
,
3282 int* no_const_asn_ref
)
3284 tree type
= strip_array_types (TREE_TYPE (field
));
3285 bool any_default_members
= false;
3287 /* In C++98 an anonymous union cannot contain any fields which would change
3288 the settings of CANT_HAVE_CONST_CTOR and friends. */
3289 if (ANON_UNION_TYPE_P (type
) && cxx_dialect
< cxx11
)
3291 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
3292 structs. So, we recurse through their fields here. */
3293 else if (ANON_AGGR_TYPE_P (type
))
3295 for (tree fields
= TYPE_FIELDS (type
); fields
;
3296 fields
= DECL_CHAIN (fields
))
3297 if (TREE_CODE (fields
) == FIELD_DECL
)
3298 any_default_members
|= check_field_decl (fields
, t
,
3299 cant_have_const_ctor
,
3302 /* Check members with class type for constructors, destructors,
3304 else if (CLASS_TYPE_P (type
))
3306 /* Never let anything with uninheritable virtuals
3307 make it through without complaint. */
3308 abstract_virtuals_error (field
, type
);
3310 if (TREE_CODE (t
) == UNION_TYPE
&& cxx_dialect
< cxx11
)
3313 int oldcount
= errorcount
;
3314 if (TYPE_NEEDS_CONSTRUCTING (type
))
3315 error ("member %q+#D with constructor not allowed in union",
3317 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3318 error ("member %q+#D with destructor not allowed in union", field
);
3319 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
3320 error ("member %q+#D with copy assignment operator not allowed in union",
3322 if (!warned
&& errorcount
> oldcount
)
3324 inform (DECL_SOURCE_LOCATION (field
), "unrestricted unions "
3325 "only available with -std=c++11 or -std=gnu++11");
3331 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (type
);
3332 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3333 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
);
3334 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
)
3335 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
)
3336 || !TYPE_HAS_COPY_ASSIGN (type
));
3337 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= (TYPE_HAS_COMPLEX_COPY_CTOR (type
)
3338 || !TYPE_HAS_COPY_CTOR (type
));
3339 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type
);
3340 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_HAS_COMPLEX_MOVE_CTOR (type
);
3341 TYPE_HAS_COMPLEX_DFLT (t
) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)
3342 || TYPE_HAS_COMPLEX_DFLT (type
));
3345 if (TYPE_HAS_COPY_CTOR (type
)
3346 && !TYPE_HAS_CONST_COPY_CTOR (type
))
3347 *cant_have_const_ctor
= 1;
3349 if (TYPE_HAS_COPY_ASSIGN (type
)
3350 && !TYPE_HAS_CONST_COPY_ASSIGN (type
))
3351 *no_const_asn_ref
= 1;
3354 check_abi_tags (t
, field
);
3356 if (DECL_INITIAL (field
) != NULL_TREE
)
3357 /* `build_class_init_list' does not recognize
3359 any_default_members
= true;
3361 return any_default_members
;
3364 /* Check the data members (both static and non-static), class-scoped
3365 typedefs, etc., appearing in the declaration of T. Issue
3366 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3367 declaration order) of access declarations; each TREE_VALUE in this
3368 list is a USING_DECL.
3370 In addition, set the following flags:
3373 The class is empty, i.e., contains no non-static data members.
3375 CANT_HAVE_CONST_CTOR_P
3376 This class cannot have an implicitly generated copy constructor
3377 taking a const reference.
3379 CANT_HAVE_CONST_ASN_REF
3380 This class cannot have an implicitly generated assignment
3381 operator taking a const reference.
3383 All of these flags should be initialized before calling this
3386 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3387 fields can be added by adding to this chain. */
3390 check_field_decls (tree t
, tree
*access_decls
,
3391 int *cant_have_const_ctor_p
,
3392 int *no_const_asn_ref_p
)
3397 bool any_default_members
;
3399 int field_access
= -1;
3401 /* Assume there are no access declarations. */
3402 *access_decls
= NULL_TREE
;
3403 /* Assume this class has no pointer members. */
3404 has_pointers
= false;
3405 /* Assume none of the members of this class have default
3407 any_default_members
= false;
3409 for (field
= &TYPE_FIELDS (t
); *field
; field
= next
)
3412 tree type
= TREE_TYPE (x
);
3413 int this_field_access
;
3415 next
= &DECL_CHAIN (x
);
3417 if (TREE_CODE (x
) == USING_DECL
)
3419 /* Save the access declarations for our caller. */
3420 *access_decls
= tree_cons (NULL_TREE
, x
, *access_decls
);
3424 if (TREE_CODE (x
) == TYPE_DECL
3425 || TREE_CODE (x
) == TEMPLATE_DECL
)
3428 if (TREE_CODE (x
) == FUNCTION_DECL
)
3429 /* FIXME: We should fold in the checking from check_methods. */
3432 /* If we've gotten this far, it's a data member, possibly static,
3433 or an enumerator. */
3434 if (TREE_CODE (x
) != CONST_DECL
)
3435 DECL_CONTEXT (x
) = t
;
3437 /* When this goes into scope, it will be a non-local reference. */
3438 DECL_NONLOCAL (x
) = 1;
3440 if (TREE_CODE (t
) == UNION_TYPE
)
3442 /* [class.union] (C++98)
3444 If a union contains a static data member, or a member of
3445 reference type, the program is ill-formed.
3447 In C++11 [class.union] says:
3448 If a union contains a non-static data member of reference type
3449 the program is ill-formed. */
3450 if (VAR_P (x
) && cxx_dialect
< cxx11
)
3452 error ("in C++98 %q+D may not be static because it is "
3453 "a member of a union", x
);
3456 if (TREE_CODE (type
) == REFERENCE_TYPE
3457 && TREE_CODE (x
) == FIELD_DECL
)
3459 error ("non-static data member %q+D in a union may not "
3460 "have reference type %qT", x
, type
);
3465 /* Perform error checking that did not get done in
3467 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3469 error ("field %q+D invalidly declared function type", x
);
3470 type
= build_pointer_type (type
);
3471 TREE_TYPE (x
) = type
;
3473 else if (TREE_CODE (type
) == METHOD_TYPE
)
3475 error ("field %q+D invalidly declared method type", x
);
3476 type
= build_pointer_type (type
);
3477 TREE_TYPE (x
) = type
;
3480 if (type
== error_mark_node
)
3483 if (TREE_CODE (x
) == CONST_DECL
|| VAR_P (x
))
3486 /* Now it can only be a FIELD_DECL. */
3488 if (TREE_PRIVATE (x
) || TREE_PROTECTED (x
))
3489 CLASSTYPE_NON_AGGREGATE (t
) = 1;
3491 /* If at least one non-static data member is non-literal, the whole
3492 class becomes non-literal. Per Core/1453, volatile non-static
3493 data members and base classes are also not allowed.
3494 Note: if the type is incomplete we will complain later on. */
3495 if (COMPLETE_TYPE_P (type
)
3496 && (!literal_type_p (type
) || CP_TYPE_VOLATILE_P (type
)))
3497 CLASSTYPE_LITERAL_P (t
) = false;
3499 /* A standard-layout class is a class that:
3501 has the same access control (Clause 11) for all non-static data members,
3503 this_field_access
= TREE_PROTECTED (x
) ? 1 : TREE_PRIVATE (x
) ? 2 : 0;
3504 if (field_access
== -1)
3505 field_access
= this_field_access
;
3506 else if (this_field_access
!= field_access
)
3507 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3509 /* If this is of reference type, check if it needs an init. */
3510 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3512 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3513 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3514 if (DECL_INITIAL (x
) == NULL_TREE
)
3515 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3516 if (cxx_dialect
< cxx11
)
3518 /* ARM $12.6.2: [A member initializer list] (or, for an
3519 aggregate, initialization by a brace-enclosed list) is the
3520 only way to initialize nonstatic const and reference
3522 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
3523 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) = 1;
3527 type
= strip_array_types (type
);
3529 if (TYPE_PACKED (t
))
3531 if (!layout_pod_type_p (type
) && !TYPE_PACKED (type
))
3534 (DECL_SOURCE_LOCATION (x
), 0,
3535 "ignoring packed attribute because of unpacked non-POD field %q#D",
3539 else if (DECL_C_BIT_FIELD (x
)
3540 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
)
3541 DECL_PACKED (x
) = 1;
3544 if (DECL_C_BIT_FIELD (x
)
3545 && integer_zerop (DECL_BIT_FIELD_REPRESENTATIVE (x
)))
3546 /* We don't treat zero-width bitfields as making a class
3551 /* The class is non-empty. */
3552 CLASSTYPE_EMPTY_P (t
) = 0;
3553 /* The class is not even nearly empty. */
3554 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3555 /* If one of the data members contains an empty class,
3557 if (CLASS_TYPE_P (type
)
3558 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3559 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
3562 /* This is used by -Weffc++ (see below). Warn only for pointers
3563 to members which might hold dynamic memory. So do not warn
3564 for pointers to functions or pointers to members. */
3565 if (TYPE_PTR_P (type
)
3566 && !TYPE_PTRFN_P (type
))
3567 has_pointers
= true;
3569 if (CLASS_TYPE_P (type
))
3571 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type
))
3572 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3573 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
))
3574 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3577 if (DECL_MUTABLE_P (x
) || TYPE_HAS_MUTABLE_P (type
))
3578 CLASSTYPE_HAS_MUTABLE (t
) = 1;
3580 if (DECL_MUTABLE_P (x
))
3582 if (CP_TYPE_CONST_P (type
))
3584 error ("member %q+D cannot be declared both %<const%> "
3585 "and %<mutable%>", x
);
3588 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3590 error ("member %q+D cannot be declared as a %<mutable%> "
3596 if (! layout_pod_type_p (type
))
3597 /* DR 148 now allows pointers to members (which are POD themselves),
3598 to be allowed in POD structs. */
3599 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3601 if (!std_layout_type_p (type
))
3602 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3604 if (! zero_init_p (type
))
3605 CLASSTYPE_NON_ZERO_INIT_P (t
) = 1;
3607 /* We set DECL_C_BIT_FIELD in grokbitfield.
3608 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3609 if (DECL_C_BIT_FIELD (x
))
3610 check_bitfield_decl (x
);
3612 if (check_field_decl (x
, t
, cant_have_const_ctor_p
, no_const_asn_ref_p
))
3614 if (any_default_members
3615 && TREE_CODE (t
) == UNION_TYPE
)
3616 error ("multiple fields in union %qT initialized", t
);
3617 any_default_members
= true;
3620 /* Now that we've removed bit-field widths from DECL_INITIAL,
3621 anything left in DECL_INITIAL is an NSDMI that makes the class
3622 non-aggregate in C++11. */
3623 if (DECL_INITIAL (x
) && cxx_dialect
< cxx14
)
3624 CLASSTYPE_NON_AGGREGATE (t
) = true;
3626 /* If any field is const, the structure type is pseudo-const. */
3627 if (CP_TYPE_CONST_P (type
))
3629 C_TYPE_FIELDS_READONLY (t
) = 1;
3630 if (DECL_INITIAL (x
) == NULL_TREE
)
3631 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3632 if (cxx_dialect
< cxx11
)
3634 /* ARM $12.6.2: [A member initializer list] (or, for an
3635 aggregate, initialization by a brace-enclosed list) is the
3636 only way to initialize nonstatic const and reference
3638 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
3639 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) = 1;
3642 /* A field that is pseudo-const makes the structure likewise. */
3643 else if (CLASS_TYPE_P (type
))
3645 C_TYPE_FIELDS_READONLY (t
) |= C_TYPE_FIELDS_READONLY (type
);
3646 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
,
3647 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
3648 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
));
3651 /* Core issue 80: A nonstatic data member is required to have a
3652 different name from the class iff the class has a
3653 user-declared constructor. */
3654 if (constructor_name_p (DECL_NAME (x
), t
)
3655 && TYPE_HAS_USER_CONSTRUCTOR (t
))
3656 permerror (DECL_SOURCE_LOCATION (x
),
3657 "field %q#D with same name as class", x
);
3660 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3661 it should also define a copy constructor and an assignment operator to
3662 implement the correct copy semantic (deep vs shallow, etc.). As it is
3663 not feasible to check whether the constructors do allocate dynamic memory
3664 and store it within members, we approximate the warning like this:
3666 -- Warn only if there are members which are pointers
3667 -- Warn only if there is a non-trivial constructor (otherwise,
3668 there cannot be memory allocated).
3669 -- Warn only if there is a non-trivial destructor. We assume that the
3670 user at least implemented the cleanup correctly, and a destructor
3671 is needed to free dynamic memory.
3673 This seems enough for practical purposes. */
3676 && TYPE_HAS_USER_CONSTRUCTOR (t
)
3677 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3678 && !(TYPE_HAS_COPY_CTOR (t
) && TYPE_HAS_COPY_ASSIGN (t
)))
3680 warning (OPT_Weffc__
, "%q#T has pointer data members", t
);
3682 if (! TYPE_HAS_COPY_CTOR (t
))
3684 warning (OPT_Weffc__
,
3685 " but does not override %<%T(const %T&)%>", t
, t
);
3686 if (!TYPE_HAS_COPY_ASSIGN (t
))
3687 warning (OPT_Weffc__
, " or %<operator=(const %T&)%>", t
);
3689 else if (! TYPE_HAS_COPY_ASSIGN (t
))
3690 warning (OPT_Weffc__
,
3691 " but does not override %<operator=(const %T&)%>", t
);
3694 /* Non-static data member initializers make the default constructor
3696 if (any_default_members
)
3698 TYPE_NEEDS_CONSTRUCTING (t
) = true;
3699 TYPE_HAS_COMPLEX_DFLT (t
) = true;
3702 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3704 TYPE_PACKED (t
) = 0;
3706 /* Check anonymous struct/anonymous union fields. */
3707 finish_struct_anon (t
);
3709 /* We've built up the list of access declarations in reverse order.
3711 *access_decls
= nreverse (*access_decls
);
3714 /* If TYPE is an empty class type, records its OFFSET in the table of
3718 record_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3722 if (!is_empty_class (type
))
3725 /* Record the location of this empty object in OFFSETS. */
3726 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3728 n
= splay_tree_insert (offsets
,
3729 (splay_tree_key
) offset
,
3730 (splay_tree_value
) NULL_TREE
);
3731 n
->value
= ((splay_tree_value
)
3732 tree_cons (NULL_TREE
,
3739 /* Returns nonzero if TYPE is an empty class type and there is
3740 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3743 check_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3748 if (!is_empty_class (type
))
3751 /* Record the location of this empty object in OFFSETS. */
3752 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3756 for (t
= (tree
) n
->value
; t
; t
= TREE_CHAIN (t
))
3757 if (same_type_p (TREE_VALUE (t
), type
))
3763 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3764 F for every subobject, passing it the type, offset, and table of
3765 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3768 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3769 than MAX_OFFSET will not be walked.
3771 If F returns a nonzero value, the traversal ceases, and that value
3772 is returned. Otherwise, returns zero. */
3775 walk_subobject_offsets (tree type
,
3776 subobject_offset_fn f
,
3783 tree type_binfo
= NULL_TREE
;
3785 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3787 if (max_offset
&& tree_int_cst_lt (max_offset
, offset
))
3790 if (type
== error_mark_node
)
3796 type
= BINFO_TYPE (type
);
3799 if (CLASS_TYPE_P (type
))
3805 /* Avoid recursing into objects that are not interesting. */
3806 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3809 /* Record the location of TYPE. */
3810 r
= (*f
) (type
, offset
, offsets
);
3814 /* Iterate through the direct base classes of TYPE. */
3816 type_binfo
= TYPE_BINFO (type
);
3817 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, binfo
); i
++)
3821 if (BINFO_VIRTUAL_P (binfo
))
3825 /* We cannot rely on BINFO_OFFSET being set for the base
3826 class yet, but the offsets for direct non-virtual
3827 bases can be calculated by going back to the TYPE. */
3828 orig_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
3829 binfo_offset
= size_binop (PLUS_EXPR
,
3831 BINFO_OFFSET (orig_binfo
));
3833 r
= walk_subobject_offsets (binfo
,
3843 if (CLASSTYPE_VBASECLASSES (type
))
3846 vec
<tree
, va_gc
> *vbases
;
3848 /* Iterate through the virtual base classes of TYPE. In G++
3849 3.2, we included virtual bases in the direct base class
3850 loop above, which results in incorrect results; the
3851 correct offsets for virtual bases are only known when
3852 working with the most derived type. */
3854 for (vbases
= CLASSTYPE_VBASECLASSES (type
), ix
= 0;
3855 vec_safe_iterate (vbases
, ix
, &binfo
); ix
++)
3857 r
= walk_subobject_offsets (binfo
,
3859 size_binop (PLUS_EXPR
,
3861 BINFO_OFFSET (binfo
)),
3870 /* We still have to walk the primary base, if it is
3871 virtual. (If it is non-virtual, then it was walked
3873 tree vbase
= get_primary_binfo (type_binfo
);
3875 if (vbase
&& BINFO_VIRTUAL_P (vbase
)
3876 && BINFO_PRIMARY_P (vbase
)
3877 && BINFO_INHERITANCE_CHAIN (vbase
) == type_binfo
)
3879 r
= (walk_subobject_offsets
3881 offsets
, max_offset
, /*vbases_p=*/0));
3888 /* Iterate through the fields of TYPE. */
3889 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3890 if (TREE_CODE (field
) == FIELD_DECL
3891 && TREE_TYPE (field
) != error_mark_node
3892 && !DECL_ARTIFICIAL (field
))
3896 field_offset
= byte_position (field
);
3898 r
= walk_subobject_offsets (TREE_TYPE (field
),
3900 size_binop (PLUS_EXPR
,
3910 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3912 tree element_type
= strip_array_types (type
);
3913 tree domain
= TYPE_DOMAIN (type
);
3916 /* Avoid recursing into objects that are not interesting. */
3917 if (!CLASS_TYPE_P (element_type
)
3918 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type
)
3920 || integer_minus_onep (TYPE_MAX_VALUE (domain
)))
3923 /* Step through each of the elements in the array. */
3924 for (index
= size_zero_node
;
3925 !tree_int_cst_lt (TYPE_MAX_VALUE (domain
), index
);
3926 index
= size_binop (PLUS_EXPR
, index
, size_one_node
))
3928 r
= walk_subobject_offsets (TREE_TYPE (type
),
3936 offset
= size_binop (PLUS_EXPR
, offset
,
3937 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3938 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3939 there's no point in iterating through the remaining
3940 elements of the array. */
3941 if (max_offset
&& tree_int_cst_lt (max_offset
, offset
))
3949 /* Record all of the empty subobjects of TYPE (either a type or a
3950 binfo). If IS_DATA_MEMBER is true, then a non-static data member
3951 is being placed at OFFSET; otherwise, it is a base class that is
3952 being placed at OFFSET. */
3955 record_subobject_offsets (tree type
,
3958 bool is_data_member
)
3961 /* If recording subobjects for a non-static data member or a
3962 non-empty base class , we do not need to record offsets beyond
3963 the size of the biggest empty class. Additional data members
3964 will go at the end of the class. Additional base classes will go
3965 either at offset zero (if empty, in which case they cannot
3966 overlap with offsets past the size of the biggest empty class) or
3967 at the end of the class.
3969 However, if we are placing an empty base class, then we must record
3970 all offsets, as either the empty class is at offset zero (where
3971 other empty classes might later be placed) or at the end of the
3972 class (where other objects might then be placed, so other empty
3973 subobjects might later overlap). */
3975 || !is_empty_class (BINFO_TYPE (type
)))
3976 max_offset
= sizeof_biggest_empty_class
;
3978 max_offset
= NULL_TREE
;
3979 walk_subobject_offsets (type
, record_subobject_offset
, offset
,
3980 offsets
, max_offset
, is_data_member
);
3983 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3984 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3985 virtual bases of TYPE are examined. */
3988 layout_conflict_p (tree type
,
3993 splay_tree_node max_node
;
3995 /* Get the node in OFFSETS that indicates the maximum offset where
3996 an empty subobject is located. */
3997 max_node
= splay_tree_max (offsets
);
3998 /* If there aren't any empty subobjects, then there's no point in
3999 performing this check. */
4003 return walk_subobject_offsets (type
, check_subobject_offset
, offset
,
4004 offsets
, (tree
) (max_node
->key
),
4008 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
4009 non-static data member of the type indicated by RLI. BINFO is the
4010 binfo corresponding to the base subobject, OFFSETS maps offsets to
4011 types already located at those offsets. This function determines
4012 the position of the DECL. */
4015 layout_nonempty_base_or_field (record_layout_info rli
,
4020 tree offset
= NULL_TREE
;
4026 /* For the purposes of determining layout conflicts, we want to
4027 use the class type of BINFO; TREE_TYPE (DECL) will be the
4028 CLASSTYPE_AS_BASE version, which does not contain entries for
4029 zero-sized bases. */
4030 type
= TREE_TYPE (binfo
);
4035 type
= TREE_TYPE (decl
);
4039 /* Try to place the field. It may take more than one try if we have
4040 a hard time placing the field without putting two objects of the
4041 same type at the same address. */
4044 struct record_layout_info_s old_rli
= *rli
;
4046 /* Place this field. */
4047 place_field (rli
, decl
);
4048 offset
= byte_position (decl
);
4050 /* We have to check to see whether or not there is already
4051 something of the same type at the offset we're about to use.
4052 For example, consider:
4055 struct T : public S { int i; };
4056 struct U : public S, public T {};
4058 Here, we put S at offset zero in U. Then, we can't put T at
4059 offset zero -- its S component would be at the same address
4060 as the S we already allocated. So, we have to skip ahead.
4061 Since all data members, including those whose type is an
4062 empty class, have nonzero size, any overlap can happen only
4063 with a direct or indirect base-class -- it can't happen with
4065 /* In a union, overlap is permitted; all members are placed at
4067 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
4069 if (layout_conflict_p (field_p
? type
: binfo
, offset
,
4072 /* Strip off the size allocated to this field. That puts us
4073 at the first place we could have put the field with
4074 proper alignment. */
4077 /* Bump up by the alignment required for the type. */
4079 = size_binop (PLUS_EXPR
, rli
->bitpos
,
4081 ? CLASSTYPE_ALIGN (type
)
4082 : TYPE_ALIGN (type
)));
4083 normalize_rli (rli
);
4085 else if (TREE_CODE (type
) == NULLPTR_TYPE
4086 && warn_abi
&& abi_version_crosses (9))
4088 /* Before ABI v9, we were giving nullptr_t alignment of 1; if
4089 the offset wasn't aligned like a pointer when we started to
4090 layout this field, that affects its position. */
4091 tree pos
= rli_size_unit_so_far (&old_rli
);
4092 if (int_cst_value (pos
) % TYPE_ALIGN_UNIT (ptr_type_node
) != 0)
4094 if (abi_version_at_least (9))
4095 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wabi
,
4096 "alignment of %qD increased in -fabi-version=9 "
4099 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wabi
, "alignment "
4100 "of %qD will increase in -fabi-version=9", decl
);
4105 /* There was no conflict. We're done laying out this field. */
4109 /* Now that we know where it will be placed, update its
4111 if (binfo
&& CLASS_TYPE_P (BINFO_TYPE (binfo
)))
4112 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
4113 this point because their BINFO_OFFSET is copied from another
4114 hierarchy. Therefore, we may not need to add the entire
4116 propagate_binfo_offsets (binfo
,
4117 size_diffop_loc (input_location
,
4118 fold_convert (ssizetype
, offset
),
4119 fold_convert (ssizetype
,
4120 BINFO_OFFSET (binfo
))));
4123 /* Returns true if TYPE is empty and OFFSET is nonzero. */
4126 empty_base_at_nonzero_offset_p (tree type
,
4128 splay_tree
/*offsets*/)
4130 return is_empty_class (type
) && !integer_zerop (offset
);
4133 /* Layout the empty base BINFO. EOC indicates the byte currently just
4134 past the end of the class, and should be correctly aligned for a
4135 class of the type indicated by BINFO; OFFSETS gives the offsets of
4136 the empty bases allocated so far. T is the most derived
4137 type. Return nonzero iff we added it at the end. */
4140 layout_empty_base (record_layout_info rli
, tree binfo
,
4141 tree eoc
, splay_tree offsets
)
4144 tree basetype
= BINFO_TYPE (binfo
);
4147 /* This routine should only be used for empty classes. */
4148 gcc_assert (is_empty_class (basetype
));
4149 alignment
= ssize_int (CLASSTYPE_ALIGN_UNIT (basetype
));
4151 if (!integer_zerop (BINFO_OFFSET (binfo
)))
4152 propagate_binfo_offsets
4153 (binfo
, size_diffop_loc (input_location
,
4154 size_zero_node
, BINFO_OFFSET (binfo
)));
4156 /* This is an empty base class. We first try to put it at offset
4158 if (layout_conflict_p (binfo
,
4159 BINFO_OFFSET (binfo
),
4163 /* That didn't work. Now, we move forward from the next
4164 available spot in the class. */
4166 propagate_binfo_offsets (binfo
, fold_convert (ssizetype
, eoc
));
4169 if (!layout_conflict_p (binfo
,
4170 BINFO_OFFSET (binfo
),
4173 /* We finally found a spot where there's no overlap. */
4176 /* There's overlap here, too. Bump along to the next spot. */
4177 propagate_binfo_offsets (binfo
, alignment
);
4181 if (CLASSTYPE_USER_ALIGN (basetype
))
4183 rli
->record_align
= MAX (rli
->record_align
, CLASSTYPE_ALIGN (basetype
));
4185 rli
->unpacked_align
= MAX (rli
->unpacked_align
, CLASSTYPE_ALIGN (basetype
));
4186 TYPE_USER_ALIGN (rli
->t
) = 1;
4192 /* Build the FIELD_DECL for BASETYPE as a base of T, add it to the chain of
4193 fields at NEXT_FIELD, and return it. */
4196 build_base_field_1 (tree t
, tree basetype
, tree
*&next_field
)
4198 /* Create the FIELD_DECL. */
4199 gcc_assert (CLASSTYPE_AS_BASE (basetype
));
4200 tree decl
= build_decl (input_location
,
4201 FIELD_DECL
, NULL_TREE
, CLASSTYPE_AS_BASE (basetype
));
4202 DECL_ARTIFICIAL (decl
) = 1;
4203 DECL_IGNORED_P (decl
) = 1;
4204 DECL_FIELD_CONTEXT (decl
) = t
;
4205 if (is_empty_class (basetype
))
4206 /* CLASSTYPE_SIZE is one byte, but the field needs to have size zero. */
4207 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = size_zero_node
;
4210 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
4211 DECL_SIZE_UNIT (decl
) = CLASSTYPE_SIZE_UNIT (basetype
);
4213 SET_DECL_ALIGN (decl
, CLASSTYPE_ALIGN (basetype
));
4214 DECL_USER_ALIGN (decl
) = CLASSTYPE_USER_ALIGN (basetype
);
4215 SET_DECL_MODE (decl
, TYPE_MODE (basetype
));
4216 DECL_FIELD_IS_BASE (decl
) = 1;
4218 /* Add the new FIELD_DECL to the list of fields for T. */
4219 DECL_CHAIN (decl
) = *next_field
;
4221 next_field
= &DECL_CHAIN (decl
);
4226 /* Layout the base given by BINFO in the class indicated by RLI.
4227 *BASE_ALIGN is a running maximum of the alignments of
4228 any base class. OFFSETS gives the location of empty base
4229 subobjects. T is the most derived type. Return nonzero if the new
4230 object cannot be nearly-empty. A new FIELD_DECL is inserted at
4231 *NEXT_FIELD, unless BINFO is for an empty base class.
4233 Returns the location at which the next field should be inserted. */
4236 build_base_field (record_layout_info rli
, tree binfo
,
4237 splay_tree offsets
, tree
*next_field
)
4240 tree basetype
= BINFO_TYPE (binfo
);
4242 if (!COMPLETE_TYPE_P (basetype
))
4243 /* This error is now reported in xref_tag, thus giving better
4244 location information. */
4247 /* Place the base class. */
4248 if (!is_empty_class (basetype
))
4252 /* The containing class is non-empty because it has a non-empty
4254 CLASSTYPE_EMPTY_P (t
) = 0;
4256 /* Create the FIELD_DECL. */
4257 decl
= build_base_field_1 (t
, basetype
, next_field
);
4259 /* Try to place the field. It may take more than one try if we
4260 have a hard time placing the field without putting two
4261 objects of the same type at the same address. */
4262 layout_nonempty_base_or_field (rli
, decl
, binfo
, offsets
);
4269 /* On some platforms (ARM), even empty classes will not be
4271 eoc
= round_up_loc (input_location
,
4272 rli_size_unit_so_far (rli
),
4273 CLASSTYPE_ALIGN_UNIT (basetype
));
4274 atend
= layout_empty_base (rli
, binfo
, eoc
, offsets
);
4275 /* A nearly-empty class "has no proper base class that is empty,
4276 not morally virtual, and at an offset other than zero." */
4277 if (!BINFO_VIRTUAL_P (binfo
) && CLASSTYPE_NEARLY_EMPTY_P (t
))
4280 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4281 /* The check above (used in G++ 3.2) is insufficient because
4282 an empty class placed at offset zero might itself have an
4283 empty base at a nonzero offset. */
4284 else if (walk_subobject_offsets (basetype
,
4285 empty_base_at_nonzero_offset_p
,
4288 /*max_offset=*/NULL_TREE
,
4290 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4293 /* We used to not create a FIELD_DECL for empty base classes because of
4294 back end issues with overlapping FIELD_DECLs, but that doesn't seem to
4295 be a problem anymore. We need them to handle initialization of C++17
4297 if (cxx_dialect
>= cxx17
&& !BINFO_VIRTUAL_P (binfo
))
4299 tree decl
= build_base_field_1 (t
, basetype
, next_field
);
4300 DECL_FIELD_OFFSET (decl
) = BINFO_OFFSET (binfo
);
4301 DECL_FIELD_BIT_OFFSET (decl
) = bitsize_zero_node
;
4302 SET_DECL_OFFSET_ALIGN (decl
, BITS_PER_UNIT
);
4305 /* An empty virtual base causes a class to be non-empty
4306 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
4307 here because that was already done when the virtual table
4308 pointer was created. */
4311 /* Record the offsets of BINFO and its base subobjects. */
4312 record_subobject_offsets (binfo
,
4313 BINFO_OFFSET (binfo
),
4315 /*is_data_member=*/false);
4320 /* Layout all of the non-virtual base classes. Record empty
4321 subobjects in OFFSETS. T is the most derived type. Return nonzero
4322 if the type cannot be nearly empty. The fields created
4323 corresponding to the base classes will be inserted at
4327 build_base_fields (record_layout_info rli
,
4328 splay_tree offsets
, tree
*next_field
)
4330 /* Chain to hold all the new FIELD_DECLs which stand in for base class
4333 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
4336 /* The primary base class is always allocated first. */
4337 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
4338 next_field
= build_base_field (rli
, CLASSTYPE_PRIMARY_BINFO (t
),
4339 offsets
, next_field
);
4341 /* Now allocate the rest of the bases. */
4342 for (i
= 0; i
< n_baseclasses
; ++i
)
4346 base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (t
), i
);
4348 /* The primary base was already allocated above, so we don't
4349 need to allocate it again here. */
4350 if (base_binfo
== CLASSTYPE_PRIMARY_BINFO (t
))
4353 /* Virtual bases are added at the end (a primary virtual base
4354 will have already been added). */
4355 if (BINFO_VIRTUAL_P (base_binfo
))
4358 next_field
= build_base_field (rli
, base_binfo
,
4359 offsets
, next_field
);
4363 /* Go through the TYPE_FIELDS of T issuing any appropriate
4364 diagnostics, figuring out which methods override which other
4365 methods, and so forth. */
4368 check_methods (tree t
)
4370 for (tree x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
4371 if (DECL_DECLARES_FUNCTION_P (x
))
4373 check_for_override (x
, t
);
4375 if (DECL_PURE_VIRTUAL_P (x
)
4376 && (TREE_CODE (x
) != FUNCTION_DECL
|| ! DECL_VINDEX (x
)))
4377 error ("initializer specified for non-virtual method %q+D", x
);
4378 /* The name of the field is the original field name
4379 Save this in auxiliary field for later overloading. */
4380 if (TREE_CODE (x
) == FUNCTION_DECL
&& DECL_VINDEX (x
))
4382 TYPE_POLYMORPHIC_P (t
) = 1;
4383 if (DECL_PURE_VIRTUAL_P (x
))
4384 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t
), x
);
4387 /* All user-provided destructors are non-trivial.
4388 Constructors and assignment ops are handled in
4389 grok_special_member_properties. */
4390 if (DECL_DESTRUCTOR_P (x
) && user_provided_p (x
))
4391 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = 1;
4392 if (!DECL_VIRTUAL_P (x
)
4393 && lookup_attribute ("transaction_safe_dynamic",
4394 DECL_ATTRIBUTES (x
)))
4395 error_at (DECL_SOURCE_LOCATION (x
),
4396 "%<transaction_safe_dynamic%> may only be specified for "
4397 "a virtual function");
4401 /* FN is a constructor or destructor. Clone the declaration to create
4402 a specialized in-charge or not-in-charge version, as indicated by
4406 build_clone (tree fn
, tree name
)
4411 /* Copy the function. */
4412 clone
= copy_decl (fn
);
4413 /* Reset the function name. */
4414 DECL_NAME (clone
) = name
;
4415 /* Remember where this function came from. */
4416 DECL_ABSTRACT_ORIGIN (clone
) = fn
;
4417 /* Make it easy to find the CLONE given the FN. */
4418 DECL_CHAIN (clone
) = DECL_CHAIN (fn
);
4419 DECL_CHAIN (fn
) = clone
;
4421 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
4422 if (TREE_CODE (clone
) == TEMPLATE_DECL
)
4424 tree result
= build_clone (DECL_TEMPLATE_RESULT (clone
), name
);
4425 DECL_TEMPLATE_RESULT (clone
) = result
;
4426 DECL_TEMPLATE_INFO (result
) = copy_node (DECL_TEMPLATE_INFO (result
));
4427 DECL_TI_TEMPLATE (result
) = clone
;
4428 TREE_TYPE (clone
) = TREE_TYPE (result
);
4433 // Clone constraints.
4435 if (tree ci
= get_constraints (fn
))
4436 set_constraints (clone
, copy_node (ci
));
4440 SET_DECL_ASSEMBLER_NAME (clone
, NULL_TREE
);
4441 DECL_CLONED_FUNCTION (clone
) = fn
;
4442 /* There's no pending inline data for this function. */
4443 DECL_PENDING_INLINE_INFO (clone
) = NULL
;
4444 DECL_PENDING_INLINE_P (clone
) = 0;
4446 /* The base-class destructor is not virtual. */
4447 if (name
== base_dtor_identifier
)
4449 DECL_VIRTUAL_P (clone
) = 0;
4450 if (TREE_CODE (clone
) != TEMPLATE_DECL
)
4451 DECL_VINDEX (clone
) = NULL_TREE
;
4454 bool ctor_omit_inherited_parms_p
= ctor_omit_inherited_parms (clone
);
4455 if (ctor_omit_inherited_parms_p
)
4456 gcc_assert (DECL_HAS_IN_CHARGE_PARM_P (clone
));
4458 /* If there was an in-charge parameter, drop it from the function
4460 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
4466 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4467 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4468 parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4469 /* Skip the `this' parameter. */
4470 parmtypes
= TREE_CHAIN (parmtypes
);
4471 /* Skip the in-charge parameter. */
4472 parmtypes
= TREE_CHAIN (parmtypes
);
4473 /* And the VTT parm, in a complete [cd]tor. */
4474 if (DECL_HAS_VTT_PARM_P (fn
)
4475 && ! DECL_NEEDS_VTT_PARM_P (clone
))
4476 parmtypes
= TREE_CHAIN (parmtypes
);
4477 if (ctor_omit_inherited_parms_p
)
4479 /* If we're omitting inherited parms, that just leaves the VTT. */
4480 gcc_assert (DECL_NEEDS_VTT_PARM_P (clone
));
4481 parmtypes
= tree_cons (NULL_TREE
, vtt_parm_type
, void_list_node
);
4484 = build_method_type_directly (basetype
,
4485 TREE_TYPE (TREE_TYPE (clone
)),
4488 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
),
4491 = cp_build_type_attribute_variant (TREE_TYPE (clone
),
4492 TYPE_ATTRIBUTES (TREE_TYPE (fn
)));
4495 /* Copy the function parameters. */
4496 DECL_ARGUMENTS (clone
) = copy_list (DECL_ARGUMENTS (clone
));
4497 /* Remove the in-charge parameter. */
4498 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
4500 DECL_CHAIN (DECL_ARGUMENTS (clone
))
4501 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
)));
4502 DECL_HAS_IN_CHARGE_PARM_P (clone
) = 0;
4504 /* And the VTT parm, in a complete [cd]tor. */
4505 if (DECL_HAS_VTT_PARM_P (fn
))
4507 if (DECL_NEEDS_VTT_PARM_P (clone
))
4508 DECL_HAS_VTT_PARM_P (clone
) = 1;
4511 DECL_CHAIN (DECL_ARGUMENTS (clone
))
4512 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
)));
4513 DECL_HAS_VTT_PARM_P (clone
) = 0;
4517 /* A base constructor inheriting from a virtual base doesn't get the
4519 if (ctor_omit_inherited_parms_p
)
4520 DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
))) = NULL_TREE
;
4522 for (parms
= DECL_ARGUMENTS (clone
); parms
; parms
= DECL_CHAIN (parms
))
4524 DECL_CONTEXT (parms
) = clone
;
4525 cxx_dup_lang_specific_decl (parms
);
4528 /* Create the RTL for this function. */
4529 SET_DECL_RTL (clone
, NULL
);
4530 rest_of_decl_compilation (clone
, /*top_level=*/1, at_eof
);
4535 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
4536 not invoke this function directly.
4538 For a non-thunk function, returns the address of the slot for storing
4539 the function it is a clone of. Otherwise returns NULL_TREE.
4541 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
4542 cloned_function is unset. This is to support the separate
4543 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
4544 on a template makes sense, but not the former. */
4547 decl_cloned_function_p (const_tree decl
, bool just_testing
)
4551 decl
= STRIP_TEMPLATE (decl
);
4553 if (TREE_CODE (decl
) != FUNCTION_DECL
4554 || !DECL_LANG_SPECIFIC (decl
)
4555 || DECL_LANG_SPECIFIC (decl
)->u
.fn
.thunk_p
)
4557 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4559 lang_check_failed (__FILE__
, __LINE__
, __FUNCTION__
);
4565 ptr
= &DECL_LANG_SPECIFIC (decl
)->u
.fn
.u5
.cloned_function
;
4566 if (just_testing
&& *ptr
== NULL_TREE
)
4572 /* Produce declarations for all appropriate clones of FN. If
4573 UPDATE_METHODS is true, the clones are added to the
4574 CLASSTYPE_MEMBER_VEC. */
4577 clone_function_decl (tree fn
, bool update_methods
)
4581 /* Avoid inappropriate cloning. */
4583 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (fn
)))
4586 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
4588 /* For each constructor, we need two variants: an in-charge version
4589 and a not-in-charge version. */
4590 clone
= build_clone (fn
, complete_ctor_identifier
);
4592 add_method (DECL_CONTEXT (clone
), clone
, false);
4593 clone
= build_clone (fn
, base_ctor_identifier
);
4595 add_method (DECL_CONTEXT (clone
), clone
, false);
4599 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
));
4601 /* For each destructor, we need three variants: an in-charge
4602 version, a not-in-charge version, and an in-charge deleting
4603 version. We clone the deleting version first because that
4604 means it will go second on the TYPE_FIELDS list -- and that
4605 corresponds to the correct layout order in the virtual
4608 For a non-virtual destructor, we do not build a deleting
4610 if (DECL_VIRTUAL_P (fn
))
4612 clone
= build_clone (fn
, deleting_dtor_identifier
);
4614 add_method (DECL_CONTEXT (clone
), clone
, false);
4616 clone
= build_clone (fn
, complete_dtor_identifier
);
4618 add_method (DECL_CONTEXT (clone
), clone
, false);
4619 clone
= build_clone (fn
, base_dtor_identifier
);
4621 add_method (DECL_CONTEXT (clone
), clone
, false);
4624 /* Note that this is an abstract function that is never emitted. */
4625 DECL_ABSTRACT_P (fn
) = true;
4628 /* DECL is an in charge constructor, which is being defined. This will
4629 have had an in class declaration, from whence clones were
4630 declared. An out-of-class definition can specify additional default
4631 arguments. As it is the clones that are involved in overload
4632 resolution, we must propagate the information from the DECL to its
4636 adjust_clone_args (tree decl
)
4640 for (clone
= DECL_CHAIN (decl
); clone
&& DECL_CLONED_FUNCTION_P (clone
);
4641 clone
= DECL_CHAIN (clone
))
4643 tree orig_clone_parms
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4644 tree orig_decl_parms
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
4645 tree decl_parms
, clone_parms
;
4647 clone_parms
= orig_clone_parms
;
4649 /* Skip the 'this' parameter. */
4650 orig_clone_parms
= TREE_CHAIN (orig_clone_parms
);
4651 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4653 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
4654 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4655 if (DECL_HAS_VTT_PARM_P (decl
))
4656 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4658 clone_parms
= orig_clone_parms
;
4659 if (DECL_HAS_VTT_PARM_P (clone
))
4660 clone_parms
= TREE_CHAIN (clone_parms
);
4662 for (decl_parms
= orig_decl_parms
; decl_parms
;
4663 decl_parms
= TREE_CHAIN (decl_parms
),
4664 clone_parms
= TREE_CHAIN (clone_parms
))
4666 if (clone_parms
== void_list_node
)
4668 gcc_assert (decl_parms
== clone_parms
4669 || ctor_omit_inherited_parms (clone
));
4673 gcc_assert (same_type_p (TREE_TYPE (decl_parms
),
4674 TREE_TYPE (clone_parms
)));
4676 if (TREE_PURPOSE (decl_parms
) && !TREE_PURPOSE (clone_parms
))
4678 /* A default parameter has been added. Adjust the
4679 clone's parameters. */
4680 tree exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4681 tree attrs
= TYPE_ATTRIBUTES (TREE_TYPE (clone
));
4682 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4685 clone_parms
= orig_decl_parms
;
4687 if (DECL_HAS_VTT_PARM_P (clone
))
4689 clone_parms
= tree_cons (TREE_PURPOSE (orig_clone_parms
),
4690 TREE_VALUE (orig_clone_parms
),
4692 TREE_TYPE (clone_parms
) = TREE_TYPE (orig_clone_parms
);
4694 type
= build_method_type_directly (basetype
,
4695 TREE_TYPE (TREE_TYPE (clone
)),
4698 type
= build_exception_variant (type
, exceptions
);
4700 type
= cp_build_type_attribute_variant (type
, attrs
);
4701 TREE_TYPE (clone
) = type
;
4703 clone_parms
= NULL_TREE
;
4707 gcc_assert (!clone_parms
|| clone_parms
== void_list_node
);
4711 /* For each of the constructors and destructors in T, create an
4712 in-charge and not-in-charge variant. */
4715 clone_constructors_and_destructors (tree t
)
4717 /* While constructors can be via a using declaration, at this point
4718 we no longer need to know that. */
4719 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4720 clone_function_decl (*iter
, /*update_methods=*/true);
4722 if (tree dtor
= CLASSTYPE_DESTRUCTOR (t
))
4723 clone_function_decl (dtor
, /*update_methods=*/true);
4726 /* Deduce noexcept for a destructor DTOR. */
4729 deduce_noexcept_on_destructor (tree dtor
)
4731 if (!TYPE_RAISES_EXCEPTIONS (TREE_TYPE (dtor
)))
4732 TREE_TYPE (dtor
) = build_exception_variant (TREE_TYPE (dtor
),
4733 noexcept_deferred_spec
);
4736 /* Subroutine of set_one_vmethod_tm_attributes. Search base classes
4737 of TYPE for virtual functions which FNDECL overrides. Return a
4738 mask of the tm attributes found therein. */
4741 look_for_tm_attr_overrides (tree type
, tree fndecl
)
4743 tree binfo
= TYPE_BINFO (type
);
4747 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ++ix
)
4749 tree o
, basetype
= BINFO_TYPE (base_binfo
);
4751 if (!TYPE_POLYMORPHIC_P (basetype
))
4754 o
= look_for_overrides_here (basetype
, fndecl
);
4757 if (lookup_attribute ("transaction_safe_dynamic",
4758 DECL_ATTRIBUTES (o
)))
4759 /* transaction_safe_dynamic is not inherited. */;
4761 found
|= tm_attr_to_mask (find_tm_attribute
4762 (TYPE_ATTRIBUTES (TREE_TYPE (o
))));
4765 found
|= look_for_tm_attr_overrides (basetype
, fndecl
);
4771 /* Subroutine of set_method_tm_attributes. Handle the checks and
4772 inheritance for one virtual method FNDECL. */
4775 set_one_vmethod_tm_attributes (tree type
, tree fndecl
)
4780 found
= look_for_tm_attr_overrides (type
, fndecl
);
4782 /* If FNDECL doesn't actually override anything (i.e. T is the
4783 class that first declares FNDECL virtual), then we're done. */
4787 tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl
)));
4788 have
= tm_attr_to_mask (tm_attr
);
4790 /* Intel STM Language Extension 3.0, Section 4.2 table 4:
4791 tm_pure must match exactly, otherwise no weakening of
4792 tm_safe > tm_callable > nothing. */
4793 /* ??? The tm_pure attribute didn't make the transition to the
4794 multivendor language spec. */
4795 if (have
== TM_ATTR_PURE
)
4797 if (found
!= TM_ATTR_PURE
)
4803 /* If the overridden function is tm_pure, then FNDECL must be. */
4804 else if (found
== TM_ATTR_PURE
&& tm_attr
)
4806 /* Look for base class combinations that cannot be satisfied. */
4807 else if (found
!= TM_ATTR_PURE
&& (found
& TM_ATTR_PURE
))
4809 found
&= ~TM_ATTR_PURE
;
4811 error_at (DECL_SOURCE_LOCATION (fndecl
),
4812 "method overrides both %<transaction_pure%> and %qE methods",
4813 tm_mask_to_attr (found
));
4815 /* If FNDECL did not declare an attribute, then inherit the most
4817 else if (tm_attr
== NULL
)
4819 apply_tm_attr (fndecl
, tm_mask_to_attr (least_bit_hwi (found
)));
4821 /* Otherwise validate that we're not weaker than a function
4822 that is being overridden. */
4826 if (found
<= TM_ATTR_CALLABLE
&& have
> found
)
4832 error_at (DECL_SOURCE_LOCATION (fndecl
),
4833 "method declared %qE overriding %qE method",
4834 tm_attr
, tm_mask_to_attr (found
));
4837 /* For each of the methods in T, propagate a class-level tm attribute. */
4840 set_method_tm_attributes (tree t
)
4842 tree class_tm_attr
, fndecl
;
4844 /* Don't bother collecting tm attributes if transactional memory
4845 support is not enabled. */
4849 /* Process virtual methods first, as they inherit directly from the
4850 base virtual function and also require validation of new attributes. */
4851 if (TYPE_CONTAINS_VPTR_P (t
))
4854 for (vchain
= BINFO_VIRTUALS (TYPE_BINFO (t
)); vchain
;
4855 vchain
= TREE_CHAIN (vchain
))
4857 fndecl
= BV_FN (vchain
);
4858 if (DECL_THUNK_P (fndecl
))
4859 fndecl
= THUNK_TARGET (fndecl
);
4860 set_one_vmethod_tm_attributes (t
, fndecl
);
4864 /* If the class doesn't have an attribute, nothing more to do. */
4865 class_tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (t
));
4866 if (class_tm_attr
== NULL
)
4869 /* Any method that does not yet have a tm attribute inherits
4870 the one from the class. */
4871 for (fndecl
= TYPE_FIELDS (t
); fndecl
; fndecl
= DECL_CHAIN (fndecl
))
4872 if (DECL_DECLARES_FUNCTION_P (fndecl
)
4873 && !find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
4874 apply_tm_attr (fndecl
, class_tm_attr
);
4877 /* Returns true if FN is a default constructor. */
4880 default_ctor_p (tree fn
)
4882 return (DECL_CONSTRUCTOR_P (fn
)
4883 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
4886 /* Returns true iff class T has a user-defined constructor that can be called
4887 with more than zero arguments. */
4890 type_has_user_nondefault_constructor (tree t
)
4892 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4895 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4898 if (!DECL_ARTIFICIAL (fn
)
4899 && (TREE_CODE (fn
) == TEMPLATE_DECL
4900 || (skip_artificial_parms_for (fn
, DECL_ARGUMENTS (fn
))
4908 /* Returns the defaulted constructor if T has one. Otherwise, returns
4912 in_class_defaulted_default_constructor (tree t
)
4914 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4917 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4921 if (DECL_DEFAULTED_IN_CLASS_P (fn
)
4922 && default_ctor_p (fn
))
4929 /* Returns true iff FN is a user-provided function, i.e. user-declared
4930 and not defaulted at its first declaration. */
4933 user_provided_p (tree fn
)
4935 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4938 return (!DECL_ARTIFICIAL (fn
)
4939 && !(DECL_INITIALIZED_IN_CLASS_P (fn
)
4940 && (DECL_DEFAULTED_FN (fn
) || DECL_DELETED_FN (fn
))));
4943 /* Returns true iff class T has a user-provided constructor. */
4946 type_has_user_provided_constructor (tree t
)
4948 if (!CLASS_TYPE_P (t
))
4951 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4954 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4955 if (user_provided_p (*iter
))
4961 /* Returns true iff class T has a user-provided or explicit constructor. */
4964 type_has_user_provided_or_explicit_constructor (tree t
)
4966 if (!CLASS_TYPE_P (t
))
4969 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4972 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4975 if (user_provided_p (fn
) || DECL_NONCONVERTING_P (fn
))
4982 /* Returns true iff class T has a non-user-provided (i.e. implicitly
4983 declared or explicitly defaulted in the class body) default
4987 type_has_non_user_provided_default_constructor (tree t
)
4989 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (t
))
4991 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t
))
4994 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4997 if (TREE_CODE (fn
) == FUNCTION_DECL
4998 && default_ctor_p (fn
)
4999 && !user_provided_p (fn
))
5006 /* TYPE is being used as a virtual base, and has a non-trivial move
5007 assignment. Return true if this is due to there being a user-provided
5008 move assignment in TYPE or one of its subobjects; if there isn't, then
5009 multiple move assignment can't cause any harm. */
5012 vbase_has_user_provided_move_assign (tree type
)
5014 /* Does the type itself have a user-provided move assignment operator? */
5015 if (!CLASSTYPE_LAZY_MOVE_ASSIGN (type
))
5016 for (ovl_iterator
iter (get_class_binding_direct
5017 (type
, assign_op_identifier
));
5019 if (!DECL_ARTIFICIAL (*iter
) && move_fn_p (*iter
))
5022 /* Do any of its bases? */
5023 tree binfo
= TYPE_BINFO (type
);
5025 for (int i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5026 if (vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo
)))
5029 /* Or non-static data members? */
5030 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5032 if (TREE_CODE (field
) == FIELD_DECL
5033 && CLASS_TYPE_P (TREE_TYPE (field
))
5034 && vbase_has_user_provided_move_assign (TREE_TYPE (field
)))
5042 /* If default-initialization leaves part of TYPE uninitialized, returns
5043 a DECL for the field or TYPE itself (DR 253). */
5046 default_init_uninitialized_part (tree type
)
5051 type
= strip_array_types (type
);
5052 if (!CLASS_TYPE_P (type
))
5054 if (!type_has_non_user_provided_default_constructor (type
))
5056 for (binfo
= TYPE_BINFO (type
), i
= 0;
5057 BINFO_BASE_ITERATE (binfo
, i
, t
); ++i
)
5059 r
= default_init_uninitialized_part (BINFO_TYPE (t
));
5063 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
5064 if (TREE_CODE (t
) == FIELD_DECL
5065 && !DECL_ARTIFICIAL (t
)
5066 && !DECL_INITIAL (t
))
5068 r
= default_init_uninitialized_part (TREE_TYPE (t
));
5070 return DECL_P (r
) ? r
: t
;
5076 /* Returns true iff for class T, a trivial synthesized default constructor
5077 would be constexpr. */
5080 trivial_default_constructor_is_constexpr (tree t
)
5082 /* A defaulted trivial default constructor is constexpr
5083 if there is nothing to initialize. */
5084 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (t
));
5085 return is_really_empty_class (t
);
5088 /* Returns true iff class T has a constexpr default constructor. */
5091 type_has_constexpr_default_constructor (tree t
)
5095 if (!CLASS_TYPE_P (t
))
5097 /* The caller should have stripped an enclosing array. */
5098 gcc_assert (TREE_CODE (t
) != ARRAY_TYPE
);
5101 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t
))
5103 if (!TYPE_HAS_COMPLEX_DFLT (t
))
5104 return trivial_default_constructor_is_constexpr (t
);
5105 /* Non-trivial, we need to check subobject constructors. */
5106 lazily_declare_fn (sfk_constructor
, t
);
5108 fns
= locate_ctor (t
);
5109 return (fns
&& DECL_DECLARED_CONSTEXPR_P (fns
));
5112 /* Returns true iff class T has a constexpr default constructor or has an
5113 implicitly declared default constructor that we can't tell if it's constexpr
5114 without forcing a lazy declaration (which might cause undesired
5118 type_maybe_constexpr_default_constructor (tree t
)
5120 if (CLASS_TYPE_P (t
) && CLASSTYPE_LAZY_DEFAULT_CTOR (t
)
5121 && TYPE_HAS_COMPLEX_DFLT (t
))
5122 /* Assume it's constexpr. */
5124 return type_has_constexpr_default_constructor (t
);
5127 /* Returns true iff class TYPE has a virtual destructor. */
5130 type_has_virtual_destructor (tree type
)
5134 if (!CLASS_TYPE_P (type
))
5137 gcc_assert (COMPLETE_TYPE_P (type
));
5138 dtor
= CLASSTYPE_DESTRUCTOR (type
);
5139 return (dtor
&& DECL_VIRTUAL_P (dtor
));
5142 /* Returns true iff T, a class, has a move-assignment or
5143 move-constructor. Does not lazily declare either.
5144 If USER_P is false, any move function will do. If it is true, the
5145 move function must be user-declared.
5147 Note that user-declared here is different from "user-provided",
5148 which doesn't include functions that are defaulted in the
5152 classtype_has_move_assign_or_move_ctor_p (tree t
, bool user_p
)
5155 || (!CLASSTYPE_LAZY_MOVE_CTOR (t
)
5156 && !CLASSTYPE_LAZY_MOVE_ASSIGN (t
)));
5158 if (!CLASSTYPE_LAZY_MOVE_CTOR (t
))
5159 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
5160 if ((!user_p
|| !DECL_ARTIFICIAL (*iter
)) && move_fn_p (*iter
))
5163 if (!CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
5164 for (ovl_iterator
iter (get_class_binding_direct
5165 (t
, assign_op_identifier
));
5167 if ((!user_p
|| !DECL_ARTIFICIAL (*iter
)) && move_fn_p (*iter
))
5173 /* Nonzero if we need to build up a constructor call when initializing an
5174 object of this class, either because it has a user-declared constructor
5175 or because it doesn't have a default constructor (so we need to give an
5176 error if no initializer is provided). Use TYPE_NEEDS_CONSTRUCTING when
5177 what you care about is whether or not an object can be produced by a
5178 constructor (e.g. so we don't set TREE_READONLY on const variables of
5179 such type); use this function when what you care about is whether or not
5180 to try to call a constructor to create an object. The latter case is
5181 the former plus some cases of constructors that cannot be called. */
5184 type_build_ctor_call (tree t
)
5187 if (TYPE_NEEDS_CONSTRUCTING (t
))
5189 inner
= strip_array_types (t
);
5190 if (!CLASS_TYPE_P (inner
) || ANON_AGGR_TYPE_P (inner
))
5192 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (inner
))
5194 if (cxx_dialect
< cxx11
)
5196 /* A user-declared constructor might be private, and a constructor might
5197 be trivial but deleted. */
5198 for (ovl_iterator
iter (get_class_binding (inner
, complete_ctor_identifier
));
5202 if (!DECL_ARTIFICIAL (fn
)
5203 || DECL_DELETED_FN (fn
))
5209 /* Like type_build_ctor_call, but for destructors. */
5212 type_build_dtor_call (tree t
)
5215 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5217 inner
= strip_array_types (t
);
5218 if (!CLASS_TYPE_P (inner
) || ANON_AGGR_TYPE_P (inner
)
5219 || !COMPLETE_TYPE_P (inner
))
5221 if (cxx_dialect
< cxx11
)
5223 /* A user-declared destructor might be private, and a destructor might
5224 be trivial but deleted. */
5225 for (ovl_iterator
iter (get_class_binding (inner
, complete_dtor_identifier
));
5229 if (!DECL_ARTIFICIAL (fn
)
5230 || DECL_DELETED_FN (fn
))
5236 /* Remove all zero-width bit-fields from T. */
5239 remove_zero_width_bit_fields (tree t
)
5243 fieldsp
= &TYPE_FIELDS (t
);
5246 if (TREE_CODE (*fieldsp
) == FIELD_DECL
5247 && DECL_C_BIT_FIELD (*fieldsp
)
5248 /* We should not be confused by the fact that grokbitfield
5249 temporarily sets the width of the bit field into
5250 DECL_BIT_FIELD_REPRESENTATIVE (*fieldsp).
5251 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
5253 && (DECL_SIZE (*fieldsp
) == NULL_TREE
5254 || integer_zerop (DECL_SIZE (*fieldsp
))))
5255 *fieldsp
= DECL_CHAIN (*fieldsp
);
5257 fieldsp
= &DECL_CHAIN (*fieldsp
);
5261 /* Returns TRUE iff we need a cookie when dynamically allocating an
5262 array whose elements have the indicated class TYPE. */
5265 type_requires_array_cookie (tree type
)
5268 bool has_two_argument_delete_p
= false;
5270 gcc_assert (CLASS_TYPE_P (type
));
5272 /* If there's a non-trivial destructor, we need a cookie. In order
5273 to iterate through the array calling the destructor for each
5274 element, we'll have to know how many elements there are. */
5275 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
5278 /* If the usual deallocation function is a two-argument whose second
5279 argument is of type `size_t', then we have to pass the size of
5280 the array to the deallocation function, so we will need to store
5282 fns
= lookup_fnfields (TYPE_BINFO (type
),
5283 ovl_op_identifier (false, VEC_DELETE_EXPR
),
5285 /* If there are no `operator []' members, or the lookup is
5286 ambiguous, then we don't need a cookie. */
5287 if (!fns
|| fns
== error_mark_node
)
5289 /* Loop through all of the functions. */
5290 for (lkp_iterator
iter (BASELINK_FUNCTIONS (fns
)); iter
; ++iter
)
5294 /* See if this function is a one-argument delete function. If
5295 it is, then it will be the usual deallocation function. */
5296 tree second_parm
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn
)));
5297 if (second_parm
== void_list_node
)
5299 /* Do not consider this function if its second argument is an
5303 /* Otherwise, if we have a two-argument function and the second
5304 argument is `size_t', it will be the usual deallocation
5305 function -- unless there is one-argument function, too. */
5306 if (TREE_CHAIN (second_parm
) == void_list_node
5307 && same_type_p (TREE_VALUE (second_parm
), size_type_node
))
5308 has_two_argument_delete_p
= true;
5311 return has_two_argument_delete_p
;
5314 /* Finish computing the `literal type' property of class type T.
5316 At this point, we have already processed base classes and
5317 non-static data members. We need to check whether the copy
5318 constructor is trivial, the destructor is trivial, and there
5319 is a trivial default constructor or at least one constexpr
5320 constructor other than the copy constructor. */
5323 finalize_literal_type_property (tree t
)
5327 if (cxx_dialect
< cxx11
5328 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5329 CLASSTYPE_LITERAL_P (t
) = false;
5330 else if (CLASSTYPE_LITERAL_P (t
) && LAMBDA_TYPE_P (t
))
5331 CLASSTYPE_LITERAL_P (t
) = (cxx_dialect
>= cxx17
);
5332 else if (CLASSTYPE_LITERAL_P (t
) && !TYPE_HAS_TRIVIAL_DFLT (t
)
5333 && CLASSTYPE_NON_AGGREGATE (t
)
5334 && !TYPE_HAS_CONSTEXPR_CTOR (t
))
5335 CLASSTYPE_LITERAL_P (t
) = false;
5337 /* C++14 DR 1684 removed this restriction. */
5338 if (cxx_dialect
< cxx14
5339 && !CLASSTYPE_LITERAL_P (t
) && !LAMBDA_TYPE_P (t
))
5340 for (fn
= TYPE_FIELDS (t
); fn
; fn
= DECL_CHAIN (fn
))
5341 if (TREE_CODE (fn
) == FUNCTION_DECL
5342 && DECL_DECLARED_CONSTEXPR_P (fn
)
5343 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
5344 && !DECL_CONSTRUCTOR_P (fn
))
5346 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
5347 if (!DECL_GENERATED_P (fn
)
5348 && pedwarn (DECL_SOURCE_LOCATION (fn
), OPT_Wpedantic
,
5349 "enclosing class of %<constexpr%> non-static member "
5350 "function %q+#D is not a literal type", fn
))
5351 explain_non_literal_class (t
);
5355 /* T is a non-literal type used in a context which requires a constant
5356 expression. Explain why it isn't literal. */
5359 explain_non_literal_class (tree t
)
5361 static hash_set
<tree
> *diagnosed
;
5363 if (!CLASS_TYPE_P (t
))
5365 t
= TYPE_MAIN_VARIANT (t
);
5367 if (diagnosed
== NULL
)
5368 diagnosed
= new hash_set
<tree
>;
5369 if (diagnosed
->add (t
))
5370 /* Already explained. */
5373 inform (UNKNOWN_LOCATION
, "%q+T is not literal because:", t
);
5374 if (cxx_dialect
< cxx17
&& LAMBDA_TYPE_P (t
))
5375 inform (UNKNOWN_LOCATION
,
5376 " %qT is a closure type, which is only literal in "
5377 "C++17 and later", t
);
5378 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5379 inform (UNKNOWN_LOCATION
, " %q+T has a non-trivial destructor", t
);
5380 else if (CLASSTYPE_NON_AGGREGATE (t
)
5381 && !TYPE_HAS_TRIVIAL_DFLT (t
)
5382 && !LAMBDA_TYPE_P (t
)
5383 && !TYPE_HAS_CONSTEXPR_CTOR (t
))
5385 inform (UNKNOWN_LOCATION
,
5386 " %q+T is not an aggregate, does not have a trivial "
5387 "default constructor, and has no %<constexpr%> constructor that "
5388 "is not a copy or move constructor", t
);
5389 if (type_has_non_user_provided_default_constructor (t
))
5390 /* Note that we can't simply call locate_ctor because when the
5391 constructor is deleted it just returns NULL_TREE. */
5392 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
5395 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
5397 parms
= skip_artificial_parms_for (fn
, parms
);
5399 if (sufficient_parms_p (parms
))
5401 if (DECL_DELETED_FN (fn
))
5402 maybe_explain_implicit_delete (fn
);
5404 explain_invalid_constexpr_fn (fn
);
5411 tree binfo
, base_binfo
, field
; int i
;
5412 for (binfo
= TYPE_BINFO (t
), i
= 0;
5413 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5415 tree basetype
= TREE_TYPE (base_binfo
);
5416 if (!CLASSTYPE_LITERAL_P (basetype
))
5418 inform (UNKNOWN_LOCATION
,
5419 " base class %qT of %q+T is non-literal",
5421 explain_non_literal_class (basetype
);
5425 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
5428 if (TREE_CODE (field
) != FIELD_DECL
)
5430 ftype
= TREE_TYPE (field
);
5431 if (!literal_type_p (ftype
))
5433 inform (DECL_SOURCE_LOCATION (field
),
5434 " non-static data member %qD has non-literal type",
5436 if (CLASS_TYPE_P (ftype
))
5437 explain_non_literal_class (ftype
);
5439 if (CP_TYPE_VOLATILE_P (ftype
))
5440 inform (DECL_SOURCE_LOCATION (field
),
5441 " non-static data member %qD has volatile type", field
);
5446 /* Check the validity of the bases and members declared in T. Add any
5447 implicitly-generated functions (like copy-constructors and
5448 assignment operators). Compute various flag bits (like
5449 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
5450 level: i.e., independently of the ABI in use. */
5453 check_bases_and_members (tree t
)
5455 /* Nonzero if the implicitly generated copy constructor should take
5456 a non-const reference argument. */
5457 int cant_have_const_ctor
;
5458 /* Nonzero if the implicitly generated assignment operator
5459 should take a non-const reference argument. */
5460 int no_const_asn_ref
;
5462 bool saved_complex_asn_ref
;
5463 bool saved_nontrivial_dtor
;
5466 /* By default, we use const reference arguments and generate default
5468 cant_have_const_ctor
= 0;
5469 no_const_asn_ref
= 0;
5471 /* Check all the base-classes and set FMEM members to point to arrays
5472 of potential interest. */
5473 check_bases (t
, &cant_have_const_ctor
, &no_const_asn_ref
);
5475 /* Deduce noexcept on destructor. This needs to happen after we've set
5476 triviality flags appropriately for our bases. */
5477 if (cxx_dialect
>= cxx11
)
5478 if (tree dtor
= CLASSTYPE_DESTRUCTOR (t
))
5479 deduce_noexcept_on_destructor (dtor
);
5481 /* Check all the method declarations. */
5484 /* Save the initial values of these flags which only indicate whether
5485 or not the class has user-provided functions. As we analyze the
5486 bases and members we can set these flags for other reasons. */
5487 saved_complex_asn_ref
= TYPE_HAS_COMPLEX_COPY_ASSIGN (t
);
5488 saved_nontrivial_dtor
= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
5490 /* Check all the data member declarations. We cannot call
5491 check_field_decls until we have called check_bases check_methods,
5492 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5493 being set appropriately. */
5494 check_field_decls (t
, &access_decls
,
5495 &cant_have_const_ctor
,
5498 /* A nearly-empty class has to be vptr-containing; a nearly empty
5499 class contains just a vptr. */
5500 if (!TYPE_CONTAINS_VPTR_P (t
))
5501 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
5503 /* Do some bookkeeping that will guide the generation of implicitly
5504 declared member functions. */
5505 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5506 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5507 /* We need to call a constructor for this class if it has a
5508 user-provided constructor, or if the default constructor is going
5509 to initialize the vptr. (This is not an if-and-only-if;
5510 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
5511 themselves need constructing.) */
5512 TYPE_NEEDS_CONSTRUCTING (t
)
5513 |= (type_has_user_provided_constructor (t
) || TYPE_CONTAINS_VPTR_P (t
));
5516 An aggregate is an array or a class with no user-provided
5517 constructors ... and no virtual functions.
5519 Again, other conditions for being an aggregate are checked
5521 CLASSTYPE_NON_AGGREGATE (t
)
5522 |= (type_has_user_provided_or_explicit_constructor (t
)
5523 || TYPE_POLYMORPHIC_P (t
));
5524 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
5525 retain the old definition internally for ABI reasons. */
5526 CLASSTYPE_NON_LAYOUT_POD_P (t
)
5527 |= (CLASSTYPE_NON_AGGREGATE (t
)
5528 || saved_nontrivial_dtor
|| saved_complex_asn_ref
);
5529 CLASSTYPE_NON_STD_LAYOUT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5530 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5531 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5532 TYPE_HAS_COMPLEX_DFLT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5534 /* If the only explicitly declared default constructor is user-provided,
5535 set TYPE_HAS_COMPLEX_DFLT. */
5536 if (!TYPE_HAS_COMPLEX_DFLT (t
)
5537 && TYPE_HAS_DEFAULT_CONSTRUCTOR (t
)
5538 && !type_has_non_user_provided_default_constructor (t
))
5539 TYPE_HAS_COMPLEX_DFLT (t
) = true;
5541 /* Warn if a public base of a polymorphic type has an accessible
5542 non-virtual destructor. It is only now that we know the class is
5543 polymorphic. Although a polymorphic base will have a already
5544 been diagnosed during its definition, we warn on use too. */
5545 if (TYPE_POLYMORPHIC_P (t
) && warn_nonvdtor
)
5547 tree binfo
= TYPE_BINFO (t
);
5548 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
5552 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5554 tree basetype
= TREE_TYPE (base_binfo
);
5556 if ((*accesses
)[i
] == access_public_node
5557 && (TYPE_POLYMORPHIC_P (basetype
) || warn_ecpp
)
5558 && accessible_nvdtor_p (basetype
))
5559 warning (OPT_Wnon_virtual_dtor
,
5560 "base class %q#T has accessible non-virtual destructor",
5565 /* If the class has no user-declared constructor, but does have
5566 non-static const or reference data members that can never be
5567 initialized, issue a warning. */
5568 if (warn_uninitialized
5569 /* Classes with user-declared constructors are presumed to
5570 initialize these members. */
5571 && !TYPE_HAS_USER_CONSTRUCTOR (t
)
5572 /* Aggregates can be initialized with brace-enclosed
5574 && CLASSTYPE_NON_AGGREGATE (t
))
5578 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
5582 if (TREE_CODE (field
) != FIELD_DECL
5583 || DECL_INITIAL (field
) != NULL_TREE
)
5586 type
= TREE_TYPE (field
);
5587 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5588 warning_at (DECL_SOURCE_LOCATION (field
),
5589 OPT_Wuninitialized
, "non-static reference %q#D "
5590 "in class without a constructor", field
);
5591 else if (CP_TYPE_CONST_P (type
)
5592 && (!CLASS_TYPE_P (type
)
5593 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
5594 warning_at (DECL_SOURCE_LOCATION (field
),
5595 OPT_Wuninitialized
, "non-static const member %q#D "
5596 "in class without a constructor", field
);
5600 /* Synthesize any needed methods. */
5601 add_implicitly_declared_members (t
, &access_decls
,
5602 cant_have_const_ctor
,
5605 /* Check defaulted declarations here so we have cant_have_const_ctor
5606 and don't need to worry about clones. */
5607 for (fn
= TYPE_FIELDS (t
); fn
; fn
= DECL_CHAIN (fn
))
5608 if (DECL_DECLARES_FUNCTION_P (fn
)
5609 && !DECL_ARTIFICIAL (fn
)
5610 && DECL_DEFAULTED_IN_CLASS_P (fn
))
5612 int copy
= copy_fn_p (fn
);
5616 = (DECL_CONSTRUCTOR_P (fn
) ? !cant_have_const_ctor
5617 : !no_const_asn_ref
);
5618 bool fn_const_p
= (copy
== 2);
5620 if (fn_const_p
&& !imp_const_p
)
5621 /* If the function is defaulted outside the class, we just
5622 give the synthesis error. */
5623 error ("%q+D declared to take const reference, but implicit "
5624 "declaration would take non-const", fn
);
5626 defaulted_late_check (fn
);
5629 if (LAMBDA_TYPE_P (t
))
5631 /* "This class type is not an aggregate." */
5632 CLASSTYPE_NON_AGGREGATE (t
) = 1;
5635 /* Compute the 'literal type' property before we
5636 do anything with non-static member functions. */
5637 finalize_literal_type_property (t
);
5639 /* Create the in-charge and not-in-charge variants of constructors
5641 clone_constructors_and_destructors (t
);
5643 /* Process the using-declarations. */
5644 for (; access_decls
; access_decls
= TREE_CHAIN (access_decls
))
5645 handle_using_decl (TREE_VALUE (access_decls
), t
);
5647 /* Figure out whether or not we will need a cookie when dynamically
5648 allocating an array of this type. */
5649 LANG_TYPE_CLASS_CHECK (t
)->vec_new_uses_cookie
5650 = type_requires_array_cookie (t
);
5653 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
5654 accordingly. If a new vfield was created (because T doesn't have a
5655 primary base class), then the newly created field is returned. It
5656 is not added to the TYPE_FIELDS list; it is the caller's
5657 responsibility to do that. Accumulate declared virtual functions
5661 create_vtable_ptr (tree t
, tree
* virtuals_p
)
5665 /* Collect the virtual functions declared in T. */
5666 for (fn
= TYPE_FIELDS (t
); fn
; fn
= DECL_CHAIN (fn
))
5667 if (TREE_CODE (fn
) == FUNCTION_DECL
5668 && DECL_VINDEX (fn
) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
)
5669 && TREE_CODE (DECL_VINDEX (fn
)) != INTEGER_CST
)
5671 tree new_virtual
= make_node (TREE_LIST
);
5673 BV_FN (new_virtual
) = fn
;
5674 BV_DELTA (new_virtual
) = integer_zero_node
;
5675 BV_VCALL_INDEX (new_virtual
) = NULL_TREE
;
5677 TREE_CHAIN (new_virtual
) = *virtuals_p
;
5678 *virtuals_p
= new_virtual
;
5681 /* If we couldn't find an appropriate base class, create a new field
5682 here. Even if there weren't any new virtual functions, we might need a
5683 new virtual function table if we're supposed to include vptrs in
5684 all classes that need them. */
5685 if (!TYPE_VFIELD (t
) && (*virtuals_p
|| TYPE_CONTAINS_VPTR_P (t
)))
5687 /* We build this decl with vtbl_ptr_type_node, which is a
5688 `vtable_entry_type*'. It might seem more precise to use
5689 `vtable_entry_type (*)[N]' where N is the number of virtual
5690 functions. However, that would require the vtable pointer in
5691 base classes to have a different type than the vtable pointer
5692 in derived classes. We could make that happen, but that
5693 still wouldn't solve all the problems. In particular, the
5694 type-based alias analysis code would decide that assignments
5695 to the base class vtable pointer can't alias assignments to
5696 the derived class vtable pointer, since they have different
5697 types. Thus, in a derived class destructor, where the base
5698 class constructor was inlined, we could generate bad code for
5699 setting up the vtable pointer.
5701 Therefore, we use one type for all vtable pointers. We still
5702 use a type-correct type; it's just doesn't indicate the array
5703 bounds. That's better than using `void*' or some such; it's
5704 cleaner, and it let's the alias analysis code know that these
5705 stores cannot alias stores to void*! */
5708 field
= build_decl (input_location
,
5709 FIELD_DECL
, get_vfield_name (t
), vtbl_ptr_type_node
);
5710 DECL_VIRTUAL_P (field
) = 1;
5711 DECL_ARTIFICIAL (field
) = 1;
5712 DECL_FIELD_CONTEXT (field
) = t
;
5713 DECL_FCONTEXT (field
) = t
;
5714 if (TYPE_PACKED (t
))
5715 DECL_PACKED (field
) = 1;
5717 TYPE_VFIELD (t
) = field
;
5719 /* This class is non-empty. */
5720 CLASSTYPE_EMPTY_P (t
) = 0;
5728 /* Add OFFSET to all base types of BINFO which is a base in the
5729 hierarchy dominated by T.
5731 OFFSET, which is a type offset, is number of bytes. */
5734 propagate_binfo_offsets (tree binfo
, tree offset
)
5740 /* Update BINFO's offset. */
5741 BINFO_OFFSET (binfo
)
5742 = fold_convert (sizetype
,
5743 size_binop (PLUS_EXPR
,
5744 fold_convert (ssizetype
, BINFO_OFFSET (binfo
)),
5747 /* Find the primary base class. */
5748 primary_binfo
= get_primary_binfo (binfo
);
5750 if (primary_binfo
&& BINFO_INHERITANCE_CHAIN (primary_binfo
) == binfo
)
5751 propagate_binfo_offsets (primary_binfo
, offset
);
5753 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
5755 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5757 /* Don't do the primary base twice. */
5758 if (base_binfo
== primary_binfo
)
5761 if (BINFO_VIRTUAL_P (base_binfo
))
5764 propagate_binfo_offsets (base_binfo
, offset
);
5768 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
5769 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
5770 empty subobjects of T. */
5773 layout_virtual_bases (record_layout_info rli
, splay_tree offsets
)
5779 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) == 0)
5782 /* Find the last field. The artificial fields created for virtual
5783 bases will go after the last extant field to date. */
5784 next_field
= &TYPE_FIELDS (t
);
5786 next_field
= &DECL_CHAIN (*next_field
);
5788 /* Go through the virtual bases, allocating space for each virtual
5789 base that is not already a primary base class. These are
5790 allocated in inheritance graph order. */
5791 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
5793 if (!BINFO_VIRTUAL_P (vbase
))
5796 if (!BINFO_PRIMARY_P (vbase
))
5798 /* This virtual base is not a primary base of any class in the
5799 hierarchy, so we have to add space for it. */
5800 next_field
= build_base_field (rli
, vbase
,
5801 offsets
, next_field
);
5806 /* Returns the offset of the byte just past the end of the base class
5810 end_of_base (tree binfo
)
5814 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo
)))
5815 size
= TYPE_SIZE_UNIT (char_type_node
);
5816 else if (is_empty_class (BINFO_TYPE (binfo
)))
5817 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5818 allocate some space for it. It cannot have virtual bases, so
5819 TYPE_SIZE_UNIT is fine. */
5820 size
= TYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
5822 size
= CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
5824 return size_binop (PLUS_EXPR
, BINFO_OFFSET (binfo
), size
);
5827 /* Returns the offset of the byte just past the end of the base class
5828 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
5829 only non-virtual bases are included. */
5832 end_of_class (tree t
, int include_virtuals_p
)
5834 tree result
= size_zero_node
;
5835 vec
<tree
, va_gc
> *vbases
;
5841 for (binfo
= TYPE_BINFO (t
), i
= 0;
5842 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5844 if (!include_virtuals_p
5845 && BINFO_VIRTUAL_P (base_binfo
)
5846 && (!BINFO_PRIMARY_P (base_binfo
)
5847 || BINFO_INHERITANCE_CHAIN (base_binfo
) != TYPE_BINFO (t
)))
5850 offset
= end_of_base (base_binfo
);
5851 if (tree_int_cst_lt (result
, offset
))
5855 if (include_virtuals_p
)
5856 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
5857 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
5859 offset
= end_of_base (base_binfo
);
5860 if (tree_int_cst_lt (result
, offset
))
5867 /* Warn about bases of T that are inaccessible because they are
5868 ambiguous. For example:
5871 struct T : public S {};
5872 struct U : public S, public T {};
5874 Here, `(S*) new U' is not allowed because there are two `S'
5878 warn_about_ambiguous_bases (tree t
)
5881 vec
<tree
, va_gc
> *vbases
;
5886 /* If there are no repeated bases, nothing can be ambiguous. */
5887 if (!CLASSTYPE_REPEATED_BASE_P (t
))
5890 /* Check direct bases. */
5891 for (binfo
= TYPE_BINFO (t
), i
= 0;
5892 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5894 basetype
= BINFO_TYPE (base_binfo
);
5896 if (!uniquely_derived_from_p (basetype
, t
))
5897 warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
5901 /* Check for ambiguous virtual bases. */
5903 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
5904 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
5906 basetype
= BINFO_TYPE (binfo
);
5908 if (!uniquely_derived_from_p (basetype
, t
))
5909 warning (OPT_Wextra
, "virtual base %qT inaccessible in %qT due "
5910 "to ambiguity", basetype
, t
);
5914 /* Compare two INTEGER_CSTs K1 and K2. */
5917 splay_tree_compare_integer_csts (splay_tree_key k1
, splay_tree_key k2
)
5919 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5922 /* Increase the size indicated in RLI to account for empty classes
5923 that are "off the end" of the class. */
5926 include_empty_classes (record_layout_info rli
)
5931 /* It might be the case that we grew the class to allocate a
5932 zero-sized base class. That won't be reflected in RLI, yet,
5933 because we are willing to overlay multiple bases at the same
5934 offset. However, now we need to make sure that RLI is big enough
5935 to reflect the entire class. */
5936 eoc
= end_of_class (rli
->t
, CLASSTYPE_AS_BASE (rli
->t
) != NULL_TREE
);
5937 rli_size
= rli_size_unit_so_far (rli
);
5938 if (TREE_CODE (rli_size
) == INTEGER_CST
5939 && tree_int_cst_lt (rli_size
, eoc
))
5941 /* The size should have been rounded to a whole byte. */
5942 gcc_assert (tree_int_cst_equal
5943 (rli
->bitpos
, round_down (rli
->bitpos
, BITS_PER_UNIT
)));
5945 = size_binop (PLUS_EXPR
,
5947 size_binop (MULT_EXPR
,
5948 fold_convert (bitsizetype
,
5949 size_binop (MINUS_EXPR
,
5951 bitsize_int (BITS_PER_UNIT
)));
5952 normalize_rli (rli
);
5956 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5957 BINFO_OFFSETs for all of the base-classes. Position the vtable
5958 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
5961 layout_class_type (tree t
, tree
*virtuals_p
)
5963 tree non_static_data_members
;
5966 record_layout_info rli
;
5967 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5968 types that appear at that offset. */
5969 splay_tree empty_base_offsets
;
5970 /* True if the last field laid out was a bit-field. */
5971 bool last_field_was_bitfield
= false;
5972 /* The location at which the next field should be inserted. */
5975 /* Keep track of the first non-static data member. */
5976 non_static_data_members
= TYPE_FIELDS (t
);
5978 /* Start laying out the record. */
5979 rli
= start_record_layout (t
);
5981 /* Mark all the primary bases in the hierarchy. */
5982 determine_primary_bases (t
);
5984 /* Create a pointer to our virtual function table. */
5985 vptr
= create_vtable_ptr (t
, virtuals_p
);
5987 /* The vptr is always the first thing in the class. */
5990 DECL_CHAIN (vptr
) = TYPE_FIELDS (t
);
5991 TYPE_FIELDS (t
) = vptr
;
5992 next_field
= &DECL_CHAIN (vptr
);
5993 place_field (rli
, vptr
);
5996 next_field
= &TYPE_FIELDS (t
);
5998 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5999 empty_base_offsets
= splay_tree_new (splay_tree_compare_integer_csts
,
6001 build_base_fields (rli
, empty_base_offsets
, next_field
);
6003 /* Layout the non-static data members. */
6004 for (field
= non_static_data_members
; field
; field
= DECL_CHAIN (field
))
6009 /* We still pass things that aren't non-static data members to
6010 the back end, in case it wants to do something with them. */
6011 if (TREE_CODE (field
) != FIELD_DECL
)
6013 place_field (rli
, field
);
6014 /* If the static data member has incomplete type, keep track
6015 of it so that it can be completed later. (The handling
6016 of pending statics in finish_record_layout is
6017 insufficient; consider:
6020 struct S2 { static S1 s1; };
6022 At this point, finish_record_layout will be called, but
6023 S1 is still incomplete.) */
6026 maybe_register_incomplete_var (field
);
6027 /* The visibility of static data members is determined
6028 at their point of declaration, not their point of
6030 determine_visibility (field
);
6035 type
= TREE_TYPE (field
);
6036 if (type
== error_mark_node
)
6039 padding
= NULL_TREE
;
6041 /* If this field is a bit-field whose width is greater than its
6042 type, then there are some special rules for allocating
6044 if (DECL_C_BIT_FIELD (field
)
6045 && tree_int_cst_lt (TYPE_SIZE (type
), DECL_SIZE (field
)))
6047 bool was_unnamed_p
= false;
6048 /* We must allocate the bits as if suitably aligned for the
6049 longest integer type that fits in this many bits. Then,
6050 we are supposed to use the left over bits as additional
6053 /* Do not pick a type bigger than MAX_FIXED_MODE_SIZE. */
6054 tree limit
= size_int (MAX_FIXED_MODE_SIZE
);
6055 if (tree_int_cst_lt (DECL_SIZE (field
), limit
))
6056 limit
= DECL_SIZE (field
);
6058 tree integer_type
= integer_types
[itk_char
];
6059 for (unsigned itk
= itk_char
; itk
!= itk_none
; itk
++)
6060 if (tree next
= integer_types
[itk
])
6062 if (tree_int_cst_lt (limit
, TYPE_SIZE (next
)))
6063 /* Too big, so our current guess is what we want. */
6065 /* Not bigger than limit, ok */
6066 integer_type
= next
;
6069 /* Figure out how much additional padding is required. */
6070 if (TREE_CODE (t
) == UNION_TYPE
)
6071 /* In a union, the padding field must have the full width
6072 of the bit-field; all fields start at offset zero. */
6073 padding
= DECL_SIZE (field
);
6075 padding
= size_binop (MINUS_EXPR
, DECL_SIZE (field
),
6076 TYPE_SIZE (integer_type
));
6078 if (integer_zerop (padding
))
6079 padding
= NULL_TREE
;
6081 /* An unnamed bitfield does not normally affect the
6082 alignment of the containing class on a target where
6083 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
6084 make any exceptions for unnamed bitfields when the
6085 bitfields are longer than their types. Therefore, we
6086 temporarily give the field a name. */
6087 if (PCC_BITFIELD_TYPE_MATTERS
&& !DECL_NAME (field
))
6089 was_unnamed_p
= true;
6090 DECL_NAME (field
) = make_anon_name ();
6093 DECL_SIZE (field
) = TYPE_SIZE (integer_type
);
6094 SET_DECL_ALIGN (field
, TYPE_ALIGN (integer_type
));
6095 DECL_USER_ALIGN (field
) = TYPE_USER_ALIGN (integer_type
);
6096 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
6097 empty_base_offsets
);
6099 DECL_NAME (field
) = NULL_TREE
;
6100 /* Now that layout has been performed, set the size of the
6101 field to the size of its declared type; the rest of the
6102 field is effectively invisible. */
6103 DECL_SIZE (field
) = TYPE_SIZE (type
);
6104 /* We must also reset the DECL_MODE of the field. */
6105 SET_DECL_MODE (field
, TYPE_MODE (type
));
6108 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
6109 empty_base_offsets
);
6111 /* Remember the location of any empty classes in FIELD. */
6112 record_subobject_offsets (TREE_TYPE (field
),
6113 byte_position(field
),
6115 /*is_data_member=*/true);
6117 /* If a bit-field does not immediately follow another bit-field,
6118 and yet it starts in the middle of a byte, we have failed to
6119 comply with the ABI. */
6121 && DECL_C_BIT_FIELD (field
)
6122 /* The TREE_NO_WARNING flag gets set by Objective-C when
6123 laying out an Objective-C class. The ObjC ABI differs
6124 from the C++ ABI, and so we do not want a warning
6126 && !TREE_NO_WARNING (field
)
6127 && !last_field_was_bitfield
6128 && !integer_zerop (size_binop (TRUNC_MOD_EXPR
,
6129 DECL_FIELD_BIT_OFFSET (field
),
6130 bitsize_unit_node
)))
6131 warning_at (DECL_SOURCE_LOCATION (field
), OPT_Wabi
,
6132 "offset of %qD is not ABI-compliant and may "
6133 "change in a future version of GCC", field
);
6135 /* The middle end uses the type of expressions to determine the
6136 possible range of expression values. In order to optimize
6137 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
6138 must be made aware of the width of "i", via its type.
6140 Because C++ does not have integer types of arbitrary width,
6141 we must (for the purposes of the front end) convert from the
6142 type assigned here to the declared type of the bitfield
6143 whenever a bitfield expression is used as an rvalue.
6144 Similarly, when assigning a value to a bitfield, the value
6145 must be converted to the type given the bitfield here. */
6146 if (DECL_C_BIT_FIELD (field
))
6148 unsigned HOST_WIDE_INT width
;
6149 tree ftype
= TREE_TYPE (field
);
6150 width
= tree_to_uhwi (DECL_SIZE (field
));
6151 if (width
!= TYPE_PRECISION (ftype
))
6154 = c_build_bitfield_integer_type (width
,
6155 TYPE_UNSIGNED (ftype
));
6157 = cp_build_qualified_type (TREE_TYPE (field
),
6158 cp_type_quals (ftype
));
6162 /* If we needed additional padding after this field, add it
6168 padding_field
= build_decl (input_location
,
6172 DECL_BIT_FIELD (padding_field
) = 1;
6173 DECL_SIZE (padding_field
) = padding
;
6174 DECL_CONTEXT (padding_field
) = t
;
6175 DECL_ARTIFICIAL (padding_field
) = 1;
6176 DECL_IGNORED_P (padding_field
) = 1;
6177 DECL_PADDING_P (padding_field
) = 1;
6178 layout_nonempty_base_or_field (rli
, padding_field
,
6180 empty_base_offsets
);
6183 last_field_was_bitfield
= DECL_C_BIT_FIELD (field
);
6186 if (!integer_zerop (rli
->bitpos
))
6188 /* Make sure that we are on a byte boundary so that the size of
6189 the class without virtual bases will always be a round number
6191 rli
->bitpos
= round_up_loc (input_location
, rli
->bitpos
, BITS_PER_UNIT
);
6192 normalize_rli (rli
);
6195 /* Delete all zero-width bit-fields from the list of fields. Now
6196 that the type is laid out they are no longer important. */
6197 remove_zero_width_bit_fields (t
);
6199 if (CLASSTYPE_NON_LAYOUT_POD_P (t
) || CLASSTYPE_EMPTY_P (t
))
6201 /* T needs a different layout as a base (eliding virtual bases
6202 or whatever). Create that version. */
6203 tree base_t
= make_node (TREE_CODE (t
));
6205 /* If the ABI version is not at least two, and the last
6206 field was a bit-field, RLI may not be on a byte
6207 boundary. In particular, rli_size_unit_so_far might
6208 indicate the last complete byte, while rli_size_so_far
6209 indicates the total number of bits used. Therefore,
6210 rli_size_so_far, rather than rli_size_unit_so_far, is
6211 used to compute TYPE_SIZE_UNIT. */
6212 tree eoc
= end_of_class (t
, /*include_virtuals_p=*/0);
6213 TYPE_SIZE_UNIT (base_t
)
6214 = size_binop (MAX_EXPR
,
6215 fold_convert (sizetype
,
6216 size_binop (CEIL_DIV_EXPR
,
6217 rli_size_so_far (rli
),
6218 bitsize_int (BITS_PER_UNIT
))),
6221 = size_binop (MAX_EXPR
,
6222 rli_size_so_far (rli
),
6223 size_binop (MULT_EXPR
,
6224 fold_convert (bitsizetype
, eoc
),
6225 bitsize_int (BITS_PER_UNIT
)));
6226 SET_TYPE_ALIGN (base_t
, rli
->record_align
);
6227 TYPE_USER_ALIGN (base_t
) = TYPE_USER_ALIGN (t
);
6229 /* Copy the non-static data members of T. This will include its
6230 direct non-virtual bases & vtable. */
6231 next_field
= &TYPE_FIELDS (base_t
);
6232 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
6233 if (TREE_CODE (field
) == FIELD_DECL
)
6235 *next_field
= copy_node (field
);
6236 DECL_CONTEXT (*next_field
) = base_t
;
6237 next_field
= &DECL_CHAIN (*next_field
);
6239 *next_field
= NULL_TREE
;
6241 /* We use the base type for trivial assignments, and hence it
6243 compute_record_mode (base_t
);
6245 TYPE_CONTEXT (base_t
) = t
;
6247 /* Record the base version of the type. */
6248 CLASSTYPE_AS_BASE (t
) = base_t
;
6251 CLASSTYPE_AS_BASE (t
) = t
;
6253 /* Every empty class contains an empty class. */
6254 if (CLASSTYPE_EMPTY_P (t
))
6255 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
6257 /* Set the TYPE_DECL for this type to contain the right
6258 value for DECL_OFFSET, so that we can use it as part
6259 of a COMPONENT_REF for multiple inheritance. */
6260 layout_decl (TYPE_MAIN_DECL (t
), 0);
6262 /* Now fix up any virtual base class types that we left lying
6263 around. We must get these done before we try to lay out the
6264 virtual function table. As a side-effect, this will remove the
6265 base subobject fields. */
6266 layout_virtual_bases (rli
, empty_base_offsets
);
6268 /* Make sure that empty classes are reflected in RLI at this
6270 include_empty_classes (rli
);
6272 /* Make sure not to create any structures with zero size. */
6273 if (integer_zerop (rli_size_unit_so_far (rli
)) && CLASSTYPE_EMPTY_P (t
))
6275 build_decl (input_location
,
6276 FIELD_DECL
, NULL_TREE
, char_type_node
));
6278 /* If this is a non-POD, declaring it packed makes a difference to how it
6279 can be used as a field; don't let finalize_record_size undo it. */
6280 if (TYPE_PACKED (t
) && !layout_pod_type_p (t
))
6281 rli
->packed_maybe_necessary
= true;
6283 /* Let the back end lay out the type. */
6284 finish_record_layout (rli
, /*free_p=*/true);
6286 if (TYPE_SIZE_UNIT (t
)
6287 && TREE_CODE (TYPE_SIZE_UNIT (t
)) == INTEGER_CST
6288 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t
))
6289 && !valid_constant_size_p (TYPE_SIZE_UNIT (t
)))
6290 error ("size of type %qT is too large (%qE bytes)", t
, TYPE_SIZE_UNIT (t
));
6292 /* Warn about bases that can't be talked about due to ambiguity. */
6293 warn_about_ambiguous_bases (t
);
6295 /* Now that we're done with layout, give the base fields the real types. */
6296 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
6297 if (DECL_ARTIFICIAL (field
) && IS_FAKE_BASE_TYPE (TREE_TYPE (field
)))
6298 TREE_TYPE (field
) = TYPE_CONTEXT (TREE_TYPE (field
));
6301 splay_tree_delete (empty_base_offsets
);
6303 if (CLASSTYPE_EMPTY_P (t
)
6304 && tree_int_cst_lt (sizeof_biggest_empty_class
,
6305 TYPE_SIZE_UNIT (t
)))
6306 sizeof_biggest_empty_class
= TYPE_SIZE_UNIT (t
);
6309 /* Determine the "key method" for the class type indicated by TYPE,
6310 and set CLASSTYPE_KEY_METHOD accordingly. */
6313 determine_key_method (tree type
)
6317 if (processing_template_decl
6318 || CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
6319 || CLASSTYPE_INTERFACE_KNOWN (type
))
6322 /* The key method is the first non-pure virtual function that is not
6323 inline at the point of class definition. On some targets the
6324 key function may not be inline; those targets should not call
6325 this function until the end of the translation unit. */
6326 for (method
= TYPE_FIELDS (type
); method
; method
= DECL_CHAIN (method
))
6327 if (TREE_CODE (method
) == FUNCTION_DECL
6328 && DECL_VINDEX (method
) != NULL_TREE
6329 && ! DECL_DECLARED_INLINE_P (method
)
6330 && ! DECL_PURE_VIRTUAL_P (method
))
6332 CLASSTYPE_KEY_METHOD (type
) = method
;
6339 /* Helper of find_flexarrays. Return true when FLD refers to a non-static
6340 class data member of non-zero size, otherwise false. */
6343 field_nonempty_p (const_tree fld
)
6345 if (TREE_CODE (fld
) == ERROR_MARK
)
6348 tree type
= TREE_TYPE (fld
);
6349 if (TREE_CODE (fld
) == FIELD_DECL
6350 && TREE_CODE (type
) != ERROR_MARK
6351 && (DECL_NAME (fld
) || RECORD_OR_UNION_TYPE_P (type
)))
6353 return TYPE_SIZE (type
)
6354 && (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
6355 || !tree_int_cst_equal (size_zero_node
, TYPE_SIZE (type
)));
6361 /* Used by find_flexarrays and related functions. */
6365 /* The first flexible array member or non-zero array member found
6366 in the order of layout. */
6368 /* First non-static non-empty data member in the class or its bases. */
6370 /* The first non-static non-empty data member following either
6371 the flexible array member, if found, or the zero-length array member
6372 otherwise. AFTER[1] refers to the first such data member of a union
6373 of which the struct containing the flexible array member or zero-length
6374 array is a member, or NULL when no such union exists. This element is
6375 only used during searching, not for diagnosing problems. AFTER[0]
6376 refers to the first such data member that is not a member of such
6380 /* Refers to a struct (not union) in which the struct of which the flexible
6381 array is member is defined. Used to diagnose strictly (according to C)
6382 invalid uses of the latter structs. */
6386 /* Find either the first flexible array member or the first zero-length
6387 array, in that order of preference, among members of class T (but not
6388 its base classes), and set members of FMEM accordingly.
6389 BASE_P is true if T is a base class of another class.
6390 PUN is set to the outermost union in which the flexible array member
6391 (or zero-length array) is defined if one such union exists, otherwise
6393 Similarly, PSTR is set to a data member of the outermost struct of
6394 which the flexible array is a member if one such struct exists,
6395 otherwise to NULL. */
6398 find_flexarrays (tree t
, flexmems_t
*fmem
, bool base_p
,
6399 tree pun
/* = NULL_TREE */,
6400 tree pstr
/* = NULL_TREE */)
6402 /* Set the "pointer" to the outermost enclosing union if not set
6403 yet and maintain it for the remainder of the recursion. */
6404 if (!pun
&& TREE_CODE (t
) == UNION_TYPE
)
6407 for (tree fld
= TYPE_FIELDS (t
); fld
; fld
= DECL_CHAIN (fld
))
6409 if (fld
== error_mark_node
)
6412 /* Is FLD a typedef for an anonymous struct? */
6414 /* FIXME: Note that typedefs (as well as arrays) need to be fully
6415 handled elsewhere so that errors like the following are detected
6417 typedef struct { int i, a[], j; } S; // bug c++/72753
6418 S s [2]; // bug c++/68489
6420 if (TREE_CODE (fld
) == TYPE_DECL
6421 && DECL_IMPLICIT_TYPEDEF_P (fld
)
6422 && CLASS_TYPE_P (TREE_TYPE (fld
))
6423 && anon_aggrname_p (DECL_NAME (fld
)))
6425 /* Check the nested unnamed type referenced via a typedef
6426 independently of FMEM (since it's not a data member of
6427 the enclosing class). */
6428 check_flexarrays (TREE_TYPE (fld
));
6432 /* Skip anything that's GCC-generated or not a (non-static) data
6434 if (DECL_ARTIFICIAL (fld
) || TREE_CODE (fld
) != FIELD_DECL
)
6437 /* Type of the member. */
6438 tree fldtype
= TREE_TYPE (fld
);
6439 if (fldtype
== error_mark_node
)
6442 /* Determine the type of the array element or object referenced
6443 by the member so that it can be checked for flexible array
6444 members if it hasn't been yet. */
6445 tree eltype
= fldtype
;
6446 while (TREE_CODE (eltype
) == ARRAY_TYPE
6447 || TREE_CODE (eltype
) == POINTER_TYPE
6448 || TREE_CODE (eltype
) == REFERENCE_TYPE
)
6449 eltype
= TREE_TYPE (eltype
);
6451 if (RECORD_OR_UNION_TYPE_P (eltype
))
6453 if (fmem
->array
&& !fmem
->after
[bool (pun
)])
6455 /* Once the member after the flexible array has been found
6457 fmem
->after
[bool (pun
)] = fld
;
6461 if (eltype
== fldtype
|| TYPE_UNNAMED_P (eltype
))
6463 /* Descend into the non-static member struct or union and try
6464 to find a flexible array member or zero-length array among
6465 its members. This is only necessary for anonymous types
6466 and types in whose context the current type T has not been
6467 defined (the latter must not be checked again because they
6468 are already in the process of being checked by one of the
6469 recursive calls). */
6471 tree first
= fmem
->first
;
6472 tree array
= fmem
->array
;
6474 /* If this member isn't anonymous and a prior non-flexible array
6475 member has been seen in one of the enclosing structs, clear
6476 the FIRST member since it doesn't contribute to the flexible
6477 array struct's members. */
6478 if (first
&& !array
&& !ANON_AGGR_TYPE_P (eltype
))
6479 fmem
->first
= NULL_TREE
;
6481 find_flexarrays (eltype
, fmem
, false, pun
,
6482 !pstr
&& TREE_CODE (t
) == RECORD_TYPE
? fld
: pstr
);
6484 if (fmem
->array
!= array
)
6487 if (first
&& !array
&& !ANON_AGGR_TYPE_P (eltype
))
6489 /* Restore the FIRST member reset above if no flexible
6490 array member has been found in this member's struct. */
6491 fmem
->first
= first
;
6494 /* If the member struct contains the first flexible array
6495 member, or if this member is a base class, continue to
6496 the next member and avoid setting the FMEM->NEXT pointer
6503 if (field_nonempty_p (fld
))
6505 /* Remember the first non-static data member. */
6509 /* Remember the first non-static data member after the flexible
6510 array member, if one has been found, or the zero-length array
6511 if it has been found. */
6512 if (fmem
->array
&& !fmem
->after
[bool (pun
)])
6513 fmem
->after
[bool (pun
)] = fld
;
6516 /* Skip non-arrays. */
6517 if (TREE_CODE (fldtype
) != ARRAY_TYPE
)
6520 /* Determine the upper bound of the array if it has one. */
6521 if (TYPE_DOMAIN (fldtype
))
6525 /* Make a record of the zero-length array if either one
6526 such field or a flexible array member has been seen to
6527 handle the pathological and unlikely case of multiple
6529 if (!fmem
->after
[bool (pun
)])
6530 fmem
->after
[bool (pun
)] = fld
;
6532 else if (integer_all_onesp (TYPE_MAX_VALUE (TYPE_DOMAIN (fldtype
))))
6534 /* Remember the first zero-length array unless a flexible array
6535 member has already been seen. */
6537 fmem
->enclosing
= pstr
;
6542 /* Flexible array members have no upper bound. */
6545 if (TYPE_DOMAIN (TREE_TYPE (fmem
->array
)))
6547 /* Replace the zero-length array if it's been stored and
6548 reset the after pointer. */
6549 fmem
->after
[bool (pun
)] = NULL_TREE
;
6551 fmem
->enclosing
= pstr
;
6553 else if (!fmem
->after
[bool (pun
)])
6554 /* Make a record of another flexible array member. */
6555 fmem
->after
[bool (pun
)] = fld
;
6560 fmem
->enclosing
= pstr
;
6566 /* Diagnose a strictly (by the C standard) invalid use of a struct with
6567 a flexible array member (or the zero-length array extension). */
6570 diagnose_invalid_flexarray (const flexmems_t
*fmem
)
6572 if (fmem
->array
&& fmem
->enclosing
6573 && pedwarn (location_of (fmem
->enclosing
), OPT_Wpedantic
,
6574 TYPE_DOMAIN (TREE_TYPE (fmem
->array
))
6575 ? G_("invalid use of %q#T with a zero-size array "
6577 : G_("invalid use of %q#T with a flexible array member "
6579 DECL_CONTEXT (fmem
->array
),
6580 DECL_CONTEXT (fmem
->enclosing
)))
6581 inform (DECL_SOURCE_LOCATION (fmem
->array
),
6582 "array member %q#D declared here", fmem
->array
);
6585 /* Issue diagnostics for invalid flexible array members or zero-length
6586 arrays that are not the last elements of the containing class or its
6587 base classes or that are its sole members. */
6590 diagnose_flexarrays (tree t
, const flexmems_t
*fmem
)
6595 if (fmem
->first
&& !fmem
->after
[0])
6597 diagnose_invalid_flexarray (fmem
);
6601 /* Has a diagnostic been issued? */
6604 const char *msg
= 0;
6606 if (TYPE_DOMAIN (TREE_TYPE (fmem
->array
)))
6609 msg
= G_("zero-size array member %qD not at end of %q#T");
6610 else if (!fmem
->first
)
6611 msg
= G_("zero-size array member %qD in an otherwise empty %q#T");
6615 location_t loc
= DECL_SOURCE_LOCATION (fmem
->array
);
6617 if (pedwarn (loc
, OPT_Wpedantic
, msg
, fmem
->array
, t
))
6619 inform (location_of (t
), "in the definition of %q#T", t
);
6627 msg
= G_("flexible array member %qD not at end of %q#T");
6628 else if (!fmem
->first
)
6629 msg
= G_("flexible array member %qD in an otherwise empty %q#T");
6633 location_t loc
= DECL_SOURCE_LOCATION (fmem
->array
);
6636 error_at (loc
, msg
, fmem
->array
, t
);
6638 /* In the unlikely event that the member following the flexible
6639 array member is declared in a different class, or the member
6640 overlaps another member of a common union, point to it.
6641 Otherwise it should be obvious. */
6643 && ((DECL_CONTEXT (fmem
->after
[0])
6644 != DECL_CONTEXT (fmem
->array
))))
6646 inform (DECL_SOURCE_LOCATION (fmem
->after
[0]),
6647 "next member %q#D declared here",
6649 inform (location_of (t
), "in the definition of %q#T", t
);
6654 if (!diagd
&& fmem
->array
&& fmem
->enclosing
)
6655 diagnose_invalid_flexarray (fmem
);
6659 /* Recursively check to make sure that any flexible array or zero-length
6660 array members of class T or its bases are valid (i.e., not the sole
6661 non-static data member of T and, if one exists, that it is the last
6662 non-static data member of T and its base classes. FMEM is expected
6663 to be initially null and is used internally by recursive calls to
6664 the function. Issue the appropriate diagnostics for the array member
6665 that fails the checks. */
6668 check_flexarrays (tree t
, flexmems_t
*fmem
/* = NULL */,
6669 bool base_p
/* = false */)
6671 /* Initialize the result of a search for flexible array and zero-length
6672 array members. Avoid doing any work if the most interesting FMEM data
6673 have already been populated. */
6674 flexmems_t flexmems
= flexmems_t ();
6677 else if (fmem
->array
&& fmem
->first
&& fmem
->after
[0])
6680 tree fam
= fmem
->array
;
6682 /* Recursively check the primary base class first. */
6683 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6685 tree basetype
= BINFO_TYPE (CLASSTYPE_PRIMARY_BINFO (t
));
6686 check_flexarrays (basetype
, fmem
, true);
6689 /* Recursively check the base classes. */
6690 int nbases
= TYPE_BINFO (t
) ? BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) : 0;
6691 for (int i
= 0; i
< nbases
; ++i
)
6693 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (t
), i
);
6695 /* The primary base class was already checked above. */
6696 if (base_binfo
== CLASSTYPE_PRIMARY_BINFO (t
))
6699 /* Virtual base classes are at the end. */
6700 if (BINFO_VIRTUAL_P (base_binfo
))
6703 /* Check the base class. */
6704 check_flexarrays (BINFO_TYPE (base_binfo
), fmem
, /*base_p=*/true);
6707 if (fmem
== &flexmems
)
6709 /* Check virtual base classes only once per derived class.
6710 I.e., this check is not performed recursively for base
6714 vec
<tree
, va_gc
> *vbases
;
6715 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
6716 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
6718 /* Check the virtual base class. */
6719 tree basetype
= TREE_TYPE (base_binfo
);
6721 check_flexarrays (basetype
, fmem
, /*base_p=*/true);
6725 /* Is the type unnamed (and therefore a member of it potentially
6726 an anonymous struct or union)? */
6727 bool maybe_anon_p
= TYPE_UNNAMED_P (t
);
6729 /* Search the members of the current (possibly derived) class, skipping
6730 unnamed structs and unions since those could be anonymous. */
6731 if (fmem
!= &flexmems
|| !maybe_anon_p
)
6732 find_flexarrays (t
, fmem
, base_p
|| fam
!= fmem
->array
);
6734 if (fmem
== &flexmems
&& !maybe_anon_p
)
6736 /* Issue diagnostics for invalid flexible and zero-length array
6737 members found in base classes or among the members of the current
6738 class. Ignore anonymous structs and unions whose members are
6739 considered to be members of the enclosing class and thus will
6740 be diagnosed when checking it. */
6741 diagnose_flexarrays (t
, fmem
);
6745 /* Perform processing required when the definition of T (a class type)
6746 is complete. Diagnose invalid definitions of flexible array members
6747 and zero-size arrays. */
6750 finish_struct_1 (tree t
)
6753 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
6754 tree virtuals
= NULL_TREE
;
6756 if (COMPLETE_TYPE_P (t
))
6758 gcc_assert (MAYBE_CLASS_TYPE_P (t
));
6759 error ("redefinition of %q#T", t
);
6764 /* If this type was previously laid out as a forward reference,
6765 make sure we lay it out again. */
6766 TYPE_SIZE (t
) = NULL_TREE
;
6767 CLASSTYPE_PRIMARY_BINFO (t
) = NULL_TREE
;
6769 /* Make assumptions about the class; we'll reset the flags if
6771 CLASSTYPE_EMPTY_P (t
) = 1;
6772 CLASSTYPE_NEARLY_EMPTY_P (t
) = 1;
6773 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 0;
6774 CLASSTYPE_LITERAL_P (t
) = true;
6776 /* Do end-of-class semantic processing: checking the validity of the
6777 bases and members and add implicitly generated methods. */
6778 check_bases_and_members (t
);
6780 /* Find the key method. */
6781 if (TYPE_CONTAINS_VPTR_P (t
))
6783 /* The Itanium C++ ABI permits the key method to be chosen when
6784 the class is defined -- even though the key method so
6785 selected may later turn out to be an inline function. On
6786 some systems (such as ARM Symbian OS) the key method cannot
6787 be determined until the end of the translation unit. On such
6788 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
6789 will cause the class to be added to KEYED_CLASSES. Then, in
6790 finish_file we will determine the key method. */
6791 if (targetm
.cxx
.key_method_may_be_inline ())
6792 determine_key_method (t
);
6794 /* If a polymorphic class has no key method, we may emit the vtable
6795 in every translation unit where the class definition appears. If
6796 we're devirtualizing, we can look into the vtable even if we
6797 aren't emitting it. */
6798 if (!CLASSTYPE_KEY_METHOD (t
))
6799 vec_safe_push (keyed_classes
, t
);
6802 /* Layout the class itself. */
6803 layout_class_type (t
, &virtuals
);
6804 /* COMPLETE_TYPE_P is now true. */
6806 set_class_bindings (t
);
6808 /* With the layout complete, check for flexible array members and
6809 zero-length arrays that might overlap other members in the final
6811 check_flexarrays (t
);
6813 virtuals
= modify_all_vtables (t
, nreverse (virtuals
));
6815 /* If necessary, create the primary vtable for this class. */
6816 if (virtuals
|| TYPE_CONTAINS_VPTR_P (t
))
6818 /* We must enter these virtuals into the table. */
6819 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6820 build_primary_vtable (NULL_TREE
, t
);
6821 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t
)))
6822 /* Here we know enough to change the type of our virtual
6823 function table, but we will wait until later this function. */
6824 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t
), t
);
6826 /* If we're warning about ABI tags, check the types of the new
6827 virtual functions. */
6829 for (tree v
= virtuals
; v
; v
= TREE_CHAIN (v
))
6830 check_abi_tags (t
, TREE_VALUE (v
));
6833 if (TYPE_CONTAINS_VPTR_P (t
))
6838 if (BINFO_VTABLE (TYPE_BINFO (t
)))
6839 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t
))));
6840 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6841 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t
)) == NULL_TREE
);
6843 /* Add entries for virtual functions introduced by this class. */
6844 BINFO_VIRTUALS (TYPE_BINFO (t
))
6845 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t
)), virtuals
);
6847 /* Set DECL_VINDEX for all functions declared in this class. */
6848 for (vindex
= 0, fn
= BINFO_VIRTUALS (TYPE_BINFO (t
));
6850 fn
= TREE_CHAIN (fn
),
6851 vindex
+= (TARGET_VTABLE_USES_DESCRIPTORS
6852 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1))
6854 tree fndecl
= BV_FN (fn
);
6856 if (DECL_THUNK_P (fndecl
))
6857 /* A thunk. We should never be calling this entry directly
6858 from this vtable -- we'd use the entry for the non
6859 thunk base function. */
6860 DECL_VINDEX (fndecl
) = NULL_TREE
;
6861 else if (TREE_CODE (DECL_VINDEX (fndecl
)) != INTEGER_CST
)
6862 DECL_VINDEX (fndecl
) = build_int_cst (NULL_TREE
, vindex
);
6866 finish_struct_bits (t
);
6868 set_method_tm_attributes (t
);
6869 if (flag_openmp
|| flag_openmp_simd
)
6870 finish_omp_declare_simd_methods (t
);
6872 /* Clear DECL_IN_AGGR_P for all member functions. Complete the rtl
6873 for any static member objects of the type we're working on. */
6874 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
6875 if (DECL_DECLARES_FUNCTION_P (x
))
6876 DECL_IN_AGGR_P (x
) = false;
6877 else if (VAR_P (x
) && TREE_STATIC (x
)
6878 && TREE_TYPE (x
) != error_mark_node
6879 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x
)), t
))
6880 SET_DECL_MODE (x
, TYPE_MODE (t
));
6882 /* Complain if one of the field types requires lower visibility. */
6883 constrain_class_visibility (t
);
6885 /* Make the rtl for any new vtables we have created, and unmark
6886 the base types we marked. */
6889 /* Build the VTT for T. */
6893 && TYPE_POLYMORPHIC_P (t
) && accessible_nvdtor_p (t
)
6894 && !CLASSTYPE_FINAL (t
))
6895 warning (OPT_Wnon_virtual_dtor
,
6896 "%q#T has virtual functions and accessible"
6897 " non-virtual destructor", t
);
6901 if (warn_overloaded_virtual
)
6904 /* Class layout, assignment of virtual table slots, etc., is now
6905 complete. Give the back end a chance to tweak the visibility of
6906 the class or perform any other required target modifications. */
6907 targetm
.cxx
.adjust_class_at_definition (t
);
6909 maybe_suppress_debug_info (t
);
6911 if (flag_vtable_verify
)
6912 vtv_save_class_info (t
);
6914 dump_class_hierarchy (t
);
6916 /* Finish debugging output for this type. */
6917 rest_of_type_compilation (t
, ! LOCAL_CLASS_P (t
));
6919 if (TYPE_TRANSPARENT_AGGR (t
))
6921 tree field
= first_field (t
);
6922 if (field
== NULL_TREE
|| error_operand_p (field
))
6924 error ("type transparent %q#T does not have any fields", t
);
6925 TYPE_TRANSPARENT_AGGR (t
) = 0;
6927 else if (DECL_ARTIFICIAL (field
))
6929 if (DECL_FIELD_IS_BASE (field
))
6930 error ("type transparent class %qT has base classes", t
);
6933 gcc_checking_assert (DECL_VIRTUAL_P (field
));
6934 error ("type transparent class %qT has virtual functions", t
);
6936 TYPE_TRANSPARENT_AGGR (t
) = 0;
6938 else if (TYPE_MODE (t
) != DECL_MODE (field
))
6940 error ("type transparent %q#T cannot be made transparent because "
6941 "the type of the first field has a different ABI from the "
6942 "class overall", t
);
6943 TYPE_TRANSPARENT_AGGR (t
) = 0;
6948 /* When T was built up, the member declarations were added in reverse
6949 order. Rearrange them to declaration order. */
6952 unreverse_member_declarations (tree t
)
6958 /* The following lists are all in reverse order. Put them in
6959 declaration order now. */
6960 CLASSTYPE_DECL_LIST (t
) = nreverse (CLASSTYPE_DECL_LIST (t
));
6962 /* For the TYPE_FIELDS, only the non TYPE_DECLs are in reverse
6963 order, so we can't just use nreverse. Due to stat_hack
6964 chicanery in finish_member_declaration. */
6966 for (x
= TYPE_FIELDS (t
);
6967 x
&& TREE_CODE (x
) != TYPE_DECL
;
6970 next
= DECL_CHAIN (x
);
6971 DECL_CHAIN (x
) = prev
;
6977 DECL_CHAIN (TYPE_FIELDS (t
)) = x
;
6978 TYPE_FIELDS (t
) = prev
;
6983 finish_struct (tree t
, tree attributes
)
6985 location_t saved_loc
= input_location
;
6987 /* Now that we've got all the field declarations, reverse everything
6989 unreverse_member_declarations (t
);
6991 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
6992 fixup_attribute_variants (t
);
6994 /* Nadger the current location so that diagnostics point to the start of
6995 the struct, not the end. */
6996 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (t
));
6998 if (processing_template_decl
)
7002 /* We need to add the target functions of USING_DECLS, so that
7003 they can be found when the using declaration is not
7004 instantiated yet. */
7005 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
7006 if (TREE_CODE (x
) == USING_DECL
)
7008 tree fn
= strip_using_decl (x
);
7010 for (lkp_iterator
iter (fn
); iter
; ++iter
)
7011 add_method (t
, *iter
, true);
7013 else if (DECL_DECLARES_FUNCTION_P (x
))
7014 DECL_IN_AGGR_P (x
) = false;
7016 TYPE_SIZE (t
) = bitsize_zero_node
;
7017 TYPE_SIZE_UNIT (t
) = size_zero_node
;
7018 /* COMPLETE_TYPE_P is now true. */
7020 set_class_bindings (t
);
7022 /* We need to emit an error message if this type was used as a parameter
7023 and it is an abstract type, even if it is a template. We construct
7024 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
7025 account and we call complete_vars with this type, which will check
7026 the PARM_DECLS. Note that while the type is being defined,
7027 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
7028 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
7029 CLASSTYPE_PURE_VIRTUALS (t
) = NULL
;
7030 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
7031 if (TREE_CODE (x
) == FUNCTION_DECL
&& DECL_PURE_VIRTUAL_P (x
))
7032 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t
), x
);
7035 /* Remember current #pragma pack value. */
7036 TYPE_PRECISION (t
) = maximum_field_alignment
;
7038 /* Fix up any variants we've already built. */
7039 for (x
= TYPE_NEXT_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
7041 TYPE_SIZE (x
) = TYPE_SIZE (t
);
7042 TYPE_SIZE_UNIT (x
) = TYPE_SIZE_UNIT (t
);
7043 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
7047 finish_struct_1 (t
);
7048 /* COMPLETE_TYPE_P is now true. */
7050 maybe_warn_about_overly_private_class (t
);
7052 if (is_std_init_list (t
))
7054 /* People keep complaining that the compiler crashes on an invalid
7055 definition of initializer_list, so I guess we should explicitly
7056 reject it. What the compiler internals care about is that it's a
7057 template and has a pointer field followed by size_type field. */
7059 if (processing_template_decl
)
7061 tree f
= next_initializable_field (TYPE_FIELDS (t
));
7062 if (f
&& TREE_CODE (TREE_TYPE (f
)) == POINTER_TYPE
)
7064 f
= next_initializable_field (DECL_CHAIN (f
));
7065 if (f
&& same_type_p (TREE_TYPE (f
), size_type_node
))
7070 fatal_error (input_location
, "definition of %qD does not match "
7071 "%<#include <initializer_list>%>", TYPE_NAME (t
));
7074 input_location
= saved_loc
;
7076 TYPE_BEING_DEFINED (t
) = 0;
7078 if (current_class_type
)
7081 error ("trying to finish struct, but kicked out due to previous parse errors");
7083 if (processing_template_decl
&& at_function_scope_p ()
7084 /* Lambdas are defined by the LAMBDA_EXPR. */
7085 && !LAMBDA_TYPE_P (t
))
7086 add_stmt (build_min (TAG_DEFN
, t
));
7091 /* Hash table to avoid endless recursion when handling references. */
7092 static hash_table
<nofree_ptr_hash
<tree_node
> > *fixed_type_or_null_ref_ht
;
7094 /* Return the dynamic type of INSTANCE, if known.
7095 Used to determine whether the virtual function table is needed
7098 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
7099 of our knowledge of its type. *NONNULL should be initialized
7100 before this function is called. */
7103 fixed_type_or_null (tree instance
, int *nonnull
, int *cdtorp
)
7105 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
7107 switch (TREE_CODE (instance
))
7110 if (POINTER_TYPE_P (TREE_TYPE (instance
)))
7113 return RECUR (TREE_OPERAND (instance
, 0));
7116 /* This is a call to a constructor, hence it's never zero. */
7117 if (CALL_EXPR_FN (instance
)
7118 && TREE_HAS_CONSTRUCTOR (instance
))
7122 return TREE_TYPE (instance
);
7127 /* This is a call to a constructor, hence it's never zero. */
7128 if (TREE_HAS_CONSTRUCTOR (instance
))
7132 return TREE_TYPE (instance
);
7134 return RECUR (TREE_OPERAND (instance
, 0));
7136 case POINTER_PLUS_EXPR
:
7139 if (TREE_CODE (TREE_OPERAND (instance
, 0)) == ADDR_EXPR
)
7140 return RECUR (TREE_OPERAND (instance
, 0));
7141 if (TREE_CODE (TREE_OPERAND (instance
, 1)) == INTEGER_CST
)
7142 /* Propagate nonnull. */
7143 return RECUR (TREE_OPERAND (instance
, 0));
7148 return RECUR (TREE_OPERAND (instance
, 0));
7151 instance
= TREE_OPERAND (instance
, 0);
7154 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
7155 with a real object -- given &p->f, p can still be null. */
7156 tree t
= get_base_address (instance
);
7157 /* ??? Probably should check DECL_WEAK here. */
7158 if (t
&& DECL_P (t
))
7161 return RECUR (instance
);
7164 /* If this component is really a base class reference, then the field
7165 itself isn't definitive. */
7166 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance
, 1)))
7167 return RECUR (TREE_OPERAND (instance
, 0));
7168 return RECUR (TREE_OPERAND (instance
, 1));
7172 if (TREE_CODE (TREE_TYPE (instance
)) == ARRAY_TYPE
7173 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance
))))
7177 return TREE_TYPE (TREE_TYPE (instance
));
7183 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance
)))
7187 return TREE_TYPE (instance
);
7189 else if (instance
== current_class_ptr
)
7194 /* if we're in a ctor or dtor, we know our type. If
7195 current_class_ptr is set but we aren't in a function, we're in
7196 an NSDMI (and therefore a constructor). */
7197 if (current_scope () != current_function_decl
7198 || (DECL_LANG_SPECIFIC (current_function_decl
)
7199 && (DECL_CONSTRUCTOR_P (current_function_decl
)
7200 || DECL_DESTRUCTOR_P (current_function_decl
))))
7204 return TREE_TYPE (TREE_TYPE (instance
));
7207 else if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
7209 /* We only need one hash table because it is always left empty. */
7210 if (!fixed_type_or_null_ref_ht
)
7211 fixed_type_or_null_ref_ht
7212 = new hash_table
<nofree_ptr_hash
<tree_node
> > (37);
7214 /* Reference variables should be references to objects. */
7218 /* Enter the INSTANCE in a table to prevent recursion; a
7219 variable's initializer may refer to the variable
7221 if (VAR_P (instance
)
7222 && DECL_INITIAL (instance
)
7223 && !type_dependent_expression_p_push (DECL_INITIAL (instance
))
7224 && !fixed_type_or_null_ref_ht
->find (instance
))
7229 slot
= fixed_type_or_null_ref_ht
->find_slot (instance
, INSERT
);
7231 type
= RECUR (DECL_INITIAL (instance
));
7232 fixed_type_or_null_ref_ht
->remove_elt (instance
);
7245 /* Return nonzero if the dynamic type of INSTANCE is known, and
7246 equivalent to the static type. We also handle the case where
7247 INSTANCE is really a pointer. Return negative if this is a
7248 ctor/dtor. There the dynamic type is known, but this might not be
7249 the most derived base of the original object, and hence virtual
7250 bases may not be laid out according to this type.
7252 Used to determine whether the virtual function table is needed
7255 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
7256 of our knowledge of its type. *NONNULL should be initialized
7257 before this function is called. */
7260 resolves_to_fixed_type_p (tree instance
, int* nonnull
)
7262 tree t
= TREE_TYPE (instance
);
7266 /* processing_template_decl can be false in a template if we're in
7267 instantiate_non_dependent_expr, but we still want to suppress
7269 if (in_template_function ())
7271 /* In a template we only care about the type of the result. */
7277 fixed
= fixed_type_or_null (instance
, nonnull
, &cdtorp
);
7278 if (fixed
== NULL_TREE
)
7280 if (POINTER_TYPE_P (t
))
7282 if (!same_type_ignoring_top_level_qualifiers_p (t
, fixed
))
7284 return cdtorp
? -1 : 1;
7289 init_class_processing (void)
7291 current_class_depth
= 0;
7292 current_class_stack_size
= 10;
7294 = XNEWVEC (struct class_stack_node
, current_class_stack_size
);
7295 vec_alloc (local_classes
, 8);
7296 sizeof_biggest_empty_class
= size_zero_node
;
7298 ridpointers
[(int) RID_PUBLIC
] = access_public_node
;
7299 ridpointers
[(int) RID_PRIVATE
] = access_private_node
;
7300 ridpointers
[(int) RID_PROTECTED
] = access_protected_node
;
7303 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
7306 restore_class_cache (void)
7310 /* We are re-entering the same class we just left, so we don't
7311 have to search the whole inheritance matrix to find all the
7312 decls to bind again. Instead, we install the cached
7313 class_shadowed list and walk through it binding names. */
7314 push_binding_level (previous_class_level
);
7315 class_binding_level
= previous_class_level
;
7316 /* Restore IDENTIFIER_TYPE_VALUE. */
7317 for (type
= class_binding_level
->type_shadowed
;
7319 type
= TREE_CHAIN (type
))
7320 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type
), TREE_TYPE (type
));
7323 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
7324 appropriate for TYPE.
7326 So that we may avoid calls to lookup_name, we cache the _TYPE
7327 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
7329 For multiple inheritance, we perform a two-pass depth-first search
7330 of the type lattice. */
7333 pushclass (tree type
)
7335 class_stack_node_t csn
;
7337 type
= TYPE_MAIN_VARIANT (type
);
7339 /* Make sure there is enough room for the new entry on the stack. */
7340 if (current_class_depth
+ 1 >= current_class_stack_size
)
7342 current_class_stack_size
*= 2;
7344 = XRESIZEVEC (struct class_stack_node
, current_class_stack
,
7345 current_class_stack_size
);
7348 /* Insert a new entry on the class stack. */
7349 csn
= current_class_stack
+ current_class_depth
;
7350 csn
->name
= current_class_name
;
7351 csn
->type
= current_class_type
;
7352 csn
->access
= current_access_specifier
;
7353 csn
->names_used
= 0;
7355 current_class_depth
++;
7357 /* Now set up the new type. */
7358 current_class_name
= TYPE_NAME (type
);
7359 if (TREE_CODE (current_class_name
) == TYPE_DECL
)
7360 current_class_name
= DECL_NAME (current_class_name
);
7361 current_class_type
= type
;
7363 /* By default, things in classes are private, while things in
7364 structures or unions are public. */
7365 current_access_specifier
= (CLASSTYPE_DECLARED_CLASS (type
)
7366 ? access_private_node
7367 : access_public_node
);
7369 if (previous_class_level
7370 && type
!= previous_class_level
->this_entity
7371 && current_class_depth
== 1)
7373 /* Forcibly remove any old class remnants. */
7374 invalidate_class_lookup_cache ();
7377 if (!previous_class_level
7378 || type
!= previous_class_level
->this_entity
7379 || current_class_depth
> 1)
7382 restore_class_cache ();
7385 /* When we exit a toplevel class scope, we save its binding level so
7386 that we can restore it quickly. Here, we've entered some other
7387 class, so we must invalidate our cache. */
7390 invalidate_class_lookup_cache (void)
7392 previous_class_level
= NULL
;
7395 /* Get out of the current class scope. If we were in a class scope
7396 previously, that is the one popped to. */
7403 current_class_depth
--;
7404 current_class_name
= current_class_stack
[current_class_depth
].name
;
7405 current_class_type
= current_class_stack
[current_class_depth
].type
;
7406 current_access_specifier
= current_class_stack
[current_class_depth
].access
;
7407 if (current_class_stack
[current_class_depth
].names_used
)
7408 splay_tree_delete (current_class_stack
[current_class_depth
].names_used
);
7411 /* Mark the top of the class stack as hidden. */
7414 push_class_stack (void)
7416 if (current_class_depth
)
7417 ++current_class_stack
[current_class_depth
- 1].hidden
;
7420 /* Mark the top of the class stack as un-hidden. */
7423 pop_class_stack (void)
7425 if (current_class_depth
)
7426 --current_class_stack
[current_class_depth
- 1].hidden
;
7429 /* Returns 1 if the class type currently being defined is either T or
7430 a nested type of T. Returns the type from the current_class_stack,
7431 which might be equivalent to but not equal to T in case of
7432 constrained partial specializations. */
7435 currently_open_class (tree t
)
7439 if (!CLASS_TYPE_P (t
))
7442 t
= TYPE_MAIN_VARIANT (t
);
7444 /* We start looking from 1 because entry 0 is from global scope,
7446 for (i
= current_class_depth
; i
> 0; --i
)
7449 if (i
== current_class_depth
)
7450 c
= current_class_type
;
7453 if (current_class_stack
[i
].hidden
)
7455 c
= current_class_stack
[i
].type
;
7459 if (same_type_p (c
, t
))
7465 /* If either current_class_type or one of its enclosing classes are derived
7466 from T, return the appropriate type. Used to determine how we found
7467 something via unqualified lookup. */
7470 currently_open_derived_class (tree t
)
7474 /* The bases of a dependent type are unknown. */
7475 if (dependent_type_p (t
))
7478 if (!current_class_type
)
7481 if (DERIVED_FROM_P (t
, current_class_type
))
7482 return current_class_type
;
7484 for (i
= current_class_depth
- 1; i
> 0; --i
)
7486 if (current_class_stack
[i
].hidden
)
7488 if (DERIVED_FROM_P (t
, current_class_stack
[i
].type
))
7489 return current_class_stack
[i
].type
;
7495 /* Return the outermost enclosing class type that is still open, or
7499 outermost_open_class (void)
7501 if (!current_class_type
)
7504 if (TYPE_BEING_DEFINED (current_class_type
))
7505 r
= current_class_type
;
7506 for (int i
= current_class_depth
- 1; i
> 0; --i
)
7508 if (current_class_stack
[i
].hidden
)
7510 tree t
= current_class_stack
[i
].type
;
7511 if (!TYPE_BEING_DEFINED (t
))
7518 /* Returns the innermost class type which is not a lambda closure type. */
7521 current_nonlambda_class_type (void)
7523 tree type
= current_class_type
;
7524 while (type
&& LAMBDA_TYPE_P (type
))
7525 type
= decl_type_context (TYPE_NAME (type
));
7529 /* When entering a class scope, all enclosing class scopes' names with
7530 static meaning (static variables, static functions, types and
7531 enumerators) have to be visible. This recursive function calls
7532 pushclass for all enclosing class contexts until global or a local
7533 scope is reached. TYPE is the enclosed class. */
7536 push_nested_class (tree type
)
7538 /* A namespace might be passed in error cases, like A::B:C. */
7539 if (type
== NULL_TREE
7540 || !CLASS_TYPE_P (type
))
7543 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type
)));
7548 /* Undoes a push_nested_class call. */
7551 pop_nested_class (void)
7553 tree context
= DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type
));
7556 if (context
&& CLASS_TYPE_P (context
))
7557 pop_nested_class ();
7560 /* Returns the number of extern "LANG" blocks we are nested within. */
7563 current_lang_depth (void)
7565 return vec_safe_length (current_lang_base
);
7568 /* Set global variables CURRENT_LANG_NAME to appropriate value
7569 so that behavior of name-mangling machinery is correct. */
7572 push_lang_context (tree name
)
7574 vec_safe_push (current_lang_base
, current_lang_name
);
7576 if (name
== lang_name_cplusplus
)
7577 current_lang_name
= name
;
7578 else if (name
== lang_name_c
)
7579 current_lang_name
= name
;
7581 error ("language string %<\"%E\"%> not recognized", name
);
7584 /* Get out of the current language scope. */
7587 pop_lang_context (void)
7589 current_lang_name
= current_lang_base
->pop ();
7592 /* Type instantiation routines. */
7594 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
7595 matches the TARGET_TYPE. If there is no satisfactory match, return
7596 error_mark_node, and issue an error & warning messages under
7597 control of FLAGS. Permit pointers to member function if FLAGS
7598 permits. If TEMPLATE_ONLY, the name of the overloaded function was
7599 a template-id, and EXPLICIT_TARGS are the explicitly provided
7602 If OVERLOAD is for one or more member functions, then ACCESS_PATH
7603 is the base path used to reference those member functions. If
7604 the address is resolved to a member function, access checks will be
7605 performed and errors issued if appropriate. */
7608 resolve_address_of_overloaded_function (tree target_type
,
7610 tsubst_flags_t complain
,
7612 tree explicit_targs
,
7615 /* Here's what the standard says:
7619 If the name is a function template, template argument deduction
7620 is done, and if the argument deduction succeeds, the deduced
7621 arguments are used to generate a single template function, which
7622 is added to the set of overloaded functions considered.
7624 Non-member functions and static member functions match targets of
7625 type "pointer-to-function" or "reference-to-function." Nonstatic
7626 member functions match targets of type "pointer-to-member
7627 function;" the function type of the pointer to member is used to
7628 select the member function from the set of overloaded member
7629 functions. If a nonstatic member function is selected, the
7630 reference to the overloaded function name is required to have the
7631 form of a pointer to member as described in 5.3.1.
7633 If more than one function is selected, any template functions in
7634 the set are eliminated if the set also contains a non-template
7635 function, and any given template function is eliminated if the
7636 set contains a second template function that is more specialized
7637 than the first according to the partial ordering rules 14.5.5.2.
7638 After such eliminations, if any, there shall remain exactly one
7639 selected function. */
7642 /* We store the matches in a TREE_LIST rooted here. The functions
7643 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
7644 interoperability with most_specialized_instantiation. */
7645 tree matches
= NULL_TREE
;
7647 tree target_fn_type
;
7649 /* By the time we get here, we should be seeing only real
7650 pointer-to-member types, not the internal POINTER_TYPE to
7651 METHOD_TYPE representation. */
7652 gcc_assert (!TYPE_PTR_P (target_type
)
7653 || TREE_CODE (TREE_TYPE (target_type
)) != METHOD_TYPE
);
7655 gcc_assert (is_overloaded_fn (overload
));
7657 /* Check that the TARGET_TYPE is reasonable. */
7658 if (TYPE_PTRFN_P (target_type
)
7659 || TYPE_REFFN_P (target_type
))
7661 else if (TYPE_PTRMEMFUNC_P (target_type
))
7662 /* This is OK, too. */
7664 else if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
7665 /* This is OK, too. This comes from a conversion to reference
7667 target_type
= build_reference_type (target_type
);
7670 if (complain
& tf_error
)
7671 error ("cannot resolve overloaded function %qD based on"
7672 " conversion to type %qT",
7673 OVL_NAME (overload
), target_type
);
7674 return error_mark_node
;
7677 /* Non-member functions and static member functions match targets of type
7678 "pointer-to-function" or "reference-to-function." Nonstatic member
7679 functions match targets of type "pointer-to-member-function;" the
7680 function type of the pointer to member is used to select the member
7681 function from the set of overloaded member functions.
7683 So figure out the FUNCTION_TYPE that we want to match against. */
7684 target_fn_type
= static_fn_type (target_type
);
7686 /* If we can find a non-template function that matches, we can just
7687 use it. There's no point in generating template instantiations
7688 if we're just going to throw them out anyhow. But, of course, we
7689 can only do this when we don't *need* a template function. */
7691 for (lkp_iterator
iter (overload
); iter
; ++iter
)
7695 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
7696 /* We're not looking for templates just yet. */
7699 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
) != is_ptrmem
)
7700 /* We're looking for a non-static member, and this isn't
7701 one, or vice versa. */
7704 /* In C++17 we need the noexcept-qualifier to compare types. */
7705 if (flag_noexcept_type
7706 && !maybe_instantiate_noexcept (fn
, complain
))
7709 /* See if there's a match. */
7710 tree fntype
= static_fn_type (fn
);
7711 if (same_type_p (target_fn_type
, fntype
)
7712 || fnptr_conv_p (target_fn_type
, fntype
))
7713 matches
= tree_cons (fn
, NULL_TREE
, matches
);
7716 /* Now, if we've already got a match (or matches), there's no need
7717 to proceed to the template functions. But, if we don't have a
7718 match we need to look at them, too. */
7721 tree target_arg_types
;
7722 tree target_ret_type
;
7724 unsigned int nargs
, ia
;
7727 target_arg_types
= TYPE_ARG_TYPES (target_fn_type
);
7728 target_ret_type
= TREE_TYPE (target_fn_type
);
7730 nargs
= list_length (target_arg_types
);
7731 args
= XALLOCAVEC (tree
, nargs
);
7732 for (arg
= target_arg_types
, ia
= 0;
7733 arg
!= NULL_TREE
&& arg
!= void_list_node
;
7734 arg
= TREE_CHAIN (arg
), ++ia
)
7735 args
[ia
] = TREE_VALUE (arg
);
7738 for (lkp_iterator
iter (overload
); iter
; ++iter
)
7744 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7745 /* We're only looking for templates. */
7748 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7750 /* We're not looking for a non-static member, and this is
7751 one, or vice versa. */
7754 tree ret
= target_ret_type
;
7756 /* If the template has a deduced return type, don't expose it to
7757 template argument deduction. */
7758 if (undeduced_auto_decl (fn
))
7761 /* Try to do argument deduction. */
7762 targs
= make_tree_vec (DECL_NTPARMS (fn
));
7763 instantiation
= fn_type_unification (fn
, explicit_targs
, targs
, args
,
7765 DEDUCE_EXACT
, LOOKUP_NORMAL
,
7767 if (instantiation
== error_mark_node
)
7768 /* Instantiation failed. */
7771 /* Constraints must be satisfied. This is done before
7772 return type deduction since that instantiates the
7774 if (flag_concepts
&& !constraints_satisfied_p (instantiation
))
7777 /* And now force instantiation to do return type deduction. */
7778 if (undeduced_auto_decl (instantiation
))
7781 instantiate_decl (instantiation
, /*defer*/false, /*class*/false);
7784 require_deduced_type (instantiation
);
7787 /* In C++17 we need the noexcept-qualifier to compare types. */
7788 if (flag_noexcept_type
)
7789 maybe_instantiate_noexcept (instantiation
, complain
);
7791 /* See if there's a match. */
7792 tree fntype
= static_fn_type (instantiation
);
7793 if (same_type_p (target_fn_type
, fntype
)
7794 || fnptr_conv_p (target_fn_type
, fntype
))
7795 matches
= tree_cons (instantiation
, fn
, matches
);
7798 /* Now, remove all but the most specialized of the matches. */
7801 tree match
= most_specialized_instantiation (matches
);
7803 if (match
!= error_mark_node
)
7804 matches
= tree_cons (TREE_PURPOSE (match
),
7810 /* Now we should have exactly one function in MATCHES. */
7811 if (matches
== NULL_TREE
)
7813 /* There were *no* matches. */
7814 if (complain
& tf_error
)
7816 error ("no matches converting function %qD to type %q#T",
7817 OVL_NAME (overload
), target_type
);
7819 print_candidates (overload
);
7821 return error_mark_node
;
7823 else if (TREE_CHAIN (matches
))
7825 /* There were too many matches. First check if they're all
7826 the same function. */
7827 tree match
= NULL_TREE
;
7829 fn
= TREE_PURPOSE (matches
);
7831 /* For multi-versioned functions, more than one match is just fine and
7832 decls_match will return false as they are different. */
7833 for (match
= TREE_CHAIN (matches
); match
; match
= TREE_CHAIN (match
))
7834 if (!decls_match (fn
, TREE_PURPOSE (match
))
7835 && !targetm
.target_option
.function_versions
7836 (fn
, TREE_PURPOSE (match
)))
7841 if (complain
& tf_error
)
7843 error ("converting overloaded function %qD to type %q#T is ambiguous",
7844 OVL_NAME (overload
), target_type
);
7846 /* Since print_candidates expects the functions in the
7847 TREE_VALUE slot, we flip them here. */
7848 for (match
= matches
; match
; match
= TREE_CHAIN (match
))
7849 TREE_VALUE (match
) = TREE_PURPOSE (match
);
7851 print_candidates (matches
);
7854 return error_mark_node
;
7858 /* Good, exactly one match. Now, convert it to the correct type. */
7859 fn
= TREE_PURPOSE (matches
);
7861 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
7862 && !(complain
& tf_ptrmem_ok
) && !flag_ms_extensions
)
7864 static int explained
;
7866 if (!(complain
& tf_error
))
7867 return error_mark_node
;
7869 permerror (input_location
, "assuming pointer to member %qD", fn
);
7872 inform (input_location
, "(a pointer to member can only be formed with %<&%E%>)", fn
);
7877 /* If a pointer to a function that is multi-versioned is requested, the
7878 pointer to the dispatcher function is returned instead. This works
7879 well because indirectly calling the function will dispatch the right
7880 function version at run-time. */
7881 if (DECL_FUNCTION_VERSIONED (fn
))
7883 fn
= get_function_version_dispatcher (fn
);
7885 return error_mark_node
;
7886 /* Mark all the versions corresponding to the dispatcher as used. */
7887 if (!(complain
& tf_conv
))
7888 mark_versions_used (fn
);
7891 /* If we're doing overload resolution purely for the purpose of
7892 determining conversion sequences, we should not consider the
7893 function used. If this conversion sequence is selected, the
7894 function will be marked as used at this point. */
7895 if (!(complain
& tf_conv
))
7897 /* Make =delete work with SFINAE. */
7898 if (DECL_DELETED_FN (fn
) && !(complain
& tf_error
))
7899 return error_mark_node
;
7900 if (!mark_used (fn
, complain
) && !(complain
& tf_error
))
7901 return error_mark_node
;
7904 /* We could not check access to member functions when this
7905 expression was originally created since we did not know at that
7906 time to which function the expression referred. */
7907 if (DECL_FUNCTION_MEMBER_P (fn
))
7909 gcc_assert (access_path
);
7910 perform_or_defer_access_check (access_path
, fn
, fn
, complain
);
7913 if (TYPE_PTRFN_P (target_type
) || TYPE_PTRMEMFUNC_P (target_type
))
7914 return cp_build_addr_expr (fn
, complain
);
7917 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
7918 will mark the function as addressed, but here we must do it
7920 cxx_mark_addressable (fn
);
7926 /* This function will instantiate the type of the expression given in
7927 RHS to match the type of LHSTYPE. If errors exist, then return
7928 error_mark_node. COMPLAIN is a bit mask. If TF_ERROR is set, then
7929 we complain on errors. If we are not complaining, never modify rhs,
7930 as overload resolution wants to try many possible instantiations, in
7931 the hope that at least one will work.
7933 For non-recursive calls, LHSTYPE should be a function, pointer to
7934 function, or a pointer to member function. */
7937 instantiate_type (tree lhstype
, tree rhs
, tsubst_flags_t complain
)
7939 tsubst_flags_t complain_in
= complain
;
7940 tree access_path
= NULL_TREE
;
7942 complain
&= ~tf_ptrmem_ok
;
7944 if (lhstype
== unknown_type_node
)
7946 if (complain
& tf_error
)
7947 error ("not enough type information");
7948 return error_mark_node
;
7951 if (TREE_TYPE (rhs
) != NULL_TREE
&& ! (type_unknown_p (rhs
)))
7953 tree fntype
= non_reference (lhstype
);
7954 if (same_type_p (fntype
, TREE_TYPE (rhs
)))
7956 if (fnptr_conv_p (fntype
, TREE_TYPE (rhs
)))
7958 if (flag_ms_extensions
7959 && TYPE_PTRMEMFUNC_P (fntype
)
7960 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
7961 /* Microsoft allows `A::f' to be resolved to a
7962 pointer-to-member. */
7966 if (complain
& tf_error
)
7967 error ("cannot convert %qE from type %qT to type %qT",
7968 rhs
, TREE_TYPE (rhs
), fntype
);
7969 return error_mark_node
;
7973 if (BASELINK_P (rhs
))
7975 access_path
= BASELINK_ACCESS_BINFO (rhs
);
7976 rhs
= BASELINK_FUNCTIONS (rhs
);
7979 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
7980 deduce any type information. */
7981 if (TREE_CODE (rhs
) == NON_DEPENDENT_EXPR
)
7983 if (complain
& tf_error
)
7984 error ("not enough type information");
7985 return error_mark_node
;
7988 /* If we instantiate a template, and it is a A ?: C expression
7989 with omitted B, look through the SAVE_EXPR. */
7990 if (TREE_CODE (rhs
) == SAVE_EXPR
)
7991 rhs
= TREE_OPERAND (rhs
, 0);
7993 /* There are only a few kinds of expressions that may have a type
7994 dependent on overload resolution. */
7995 gcc_assert (TREE_CODE (rhs
) == ADDR_EXPR
7996 || TREE_CODE (rhs
) == COMPONENT_REF
7997 || is_overloaded_fn (rhs
)
7998 || (flag_ms_extensions
&& TREE_CODE (rhs
) == FUNCTION_DECL
));
8000 /* This should really only be used when attempting to distinguish
8001 what sort of a pointer to function we have. For now, any
8002 arithmetic operation which is not supported on pointers
8003 is rejected as an error. */
8005 switch (TREE_CODE (rhs
))
8009 tree member
= TREE_OPERAND (rhs
, 1);
8011 member
= instantiate_type (lhstype
, member
, complain
);
8012 if (member
!= error_mark_node
8013 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs
, 0)))
8014 /* Do not lose object's side effects. */
8015 return build2 (COMPOUND_EXPR
, TREE_TYPE (member
),
8016 TREE_OPERAND (rhs
, 0), member
);
8021 rhs
= TREE_OPERAND (rhs
, 1);
8022 if (BASELINK_P (rhs
))
8023 return instantiate_type (lhstype
, rhs
, complain_in
);
8025 /* This can happen if we are forming a pointer-to-member for a
8027 gcc_assert (TREE_CODE (rhs
) == TEMPLATE_ID_EXPR
);
8031 case TEMPLATE_ID_EXPR
:
8033 tree fns
= TREE_OPERAND (rhs
, 0);
8034 tree args
= TREE_OPERAND (rhs
, 1);
8037 resolve_address_of_overloaded_function (lhstype
, fns
, complain_in
,
8038 /*template_only=*/true,
8045 resolve_address_of_overloaded_function (lhstype
, rhs
, complain_in
,
8046 /*template_only=*/false,
8047 /*explicit_targs=*/NULL_TREE
,
8052 if (PTRMEM_OK_P (rhs
))
8053 complain
|= tf_ptrmem_ok
;
8055 return instantiate_type (lhstype
, TREE_OPERAND (rhs
, 0), complain
);
8059 return error_mark_node
;
8064 return error_mark_node
;
8067 /* Return the name of the virtual function pointer field
8068 (as an IDENTIFIER_NODE) for the given TYPE. Note that
8069 this may have to look back through base types to find the
8070 ultimate field name. (For single inheritance, these could
8071 all be the same name. Who knows for multiple inheritance). */
8074 get_vfield_name (tree type
)
8076 tree binfo
, base_binfo
;
8078 for (binfo
= TYPE_BINFO (type
);
8079 BINFO_N_BASE_BINFOS (binfo
);
8082 base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
8084 if (BINFO_VIRTUAL_P (base_binfo
)
8085 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo
)))
8089 type
= BINFO_TYPE (binfo
);
8090 tree ctor_name
= constructor_name (type
);
8091 char *buf
= (char *) alloca (sizeof (VFIELD_NAME_FORMAT
)
8092 + IDENTIFIER_LENGTH (ctor_name
) + 2);
8093 sprintf (buf
, VFIELD_NAME_FORMAT
, IDENTIFIER_POINTER (ctor_name
));
8094 return get_identifier (buf
);
8097 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
8098 according to [class]:
8099 The class-name is also inserted
8100 into the scope of the class itself. For purposes of access checking,
8101 the inserted class name is treated as if it were a public member name. */
8104 build_self_reference (void)
8106 tree name
= DECL_NAME (TYPE_NAME (current_class_type
));
8107 tree value
= build_lang_decl (TYPE_DECL
, name
, current_class_type
);
8109 DECL_NONLOCAL (value
) = 1;
8110 DECL_CONTEXT (value
) = current_class_type
;
8111 DECL_ARTIFICIAL (value
) = 1;
8112 SET_DECL_SELF_REFERENCE_P (value
);
8113 set_underlying_type (value
);
8115 if (processing_template_decl
)
8116 value
= push_template_decl (value
);
8118 tree saved_cas
= current_access_specifier
;
8119 current_access_specifier
= access_public_node
;
8120 finish_member_declaration (value
);
8121 current_access_specifier
= saved_cas
;
8124 /* Returns 1 if TYPE contains only padding bytes. */
8127 is_empty_class (tree type
)
8129 if (type
== error_mark_node
)
8132 if (! CLASS_TYPE_P (type
))
8135 return CLASSTYPE_EMPTY_P (type
);
8138 /* Returns true if TYPE contains no actual data, just various
8139 possible combinations of empty classes and possibly a vptr. */
8142 is_really_empty_class (tree type
)
8144 if (CLASS_TYPE_P (type
))
8151 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
8152 out, but we'd like to be able to check this before then. */
8153 if (COMPLETE_TYPE_P (type
) && is_empty_class (type
))
8156 for (binfo
= TYPE_BINFO (type
), i
= 0;
8157 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
8158 if (!is_really_empty_class (BINFO_TYPE (base_binfo
)))
8160 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8161 if (TREE_CODE (field
) == FIELD_DECL
8162 && !DECL_ARTIFICIAL (field
)
8163 /* An unnamed bit-field is not a data member. */
8164 && !DECL_UNNAMED_BIT_FIELD (field
)
8165 && !is_really_empty_class (TREE_TYPE (field
)))
8169 else if (TREE_CODE (type
) == ARRAY_TYPE
)
8170 return (integer_zerop (array_type_nelts_top (type
))
8171 || is_really_empty_class (TREE_TYPE (type
)));
8175 /* Note that NAME was looked up while the current class was being
8176 defined and that the result of that lookup was DECL. */
8179 maybe_note_name_used_in_class (tree name
, tree decl
)
8181 splay_tree names_used
;
8183 /* If we're not defining a class, there's nothing to do. */
8184 if (!(innermost_scope_kind() == sk_class
8185 && TYPE_BEING_DEFINED (current_class_type
)
8186 && !LAMBDA_TYPE_P (current_class_type
)))
8189 /* If there's already a binding for this NAME, then we don't have
8190 anything to worry about. */
8191 if (lookup_member (current_class_type
, name
,
8192 /*protect=*/0, /*want_type=*/false, tf_warning_or_error
))
8195 if (!current_class_stack
[current_class_depth
- 1].names_used
)
8196 current_class_stack
[current_class_depth
- 1].names_used
8197 = splay_tree_new (splay_tree_compare_pointers
, 0, 0);
8198 names_used
= current_class_stack
[current_class_depth
- 1].names_used
;
8200 splay_tree_insert (names_used
,
8201 (splay_tree_key
) name
,
8202 (splay_tree_value
) decl
);
8205 /* Note that NAME was declared (as DECL) in the current class. Check
8206 to see that the declaration is valid. */
8209 note_name_declared_in_class (tree name
, tree decl
)
8211 splay_tree names_used
;
8214 /* Look to see if we ever used this name. */
8216 = current_class_stack
[current_class_depth
- 1].names_used
;
8219 /* The C language allows members to be declared with a type of the same
8220 name, and the C++ standard says this diagnostic is not required. So
8221 allow it in extern "C" blocks unless predantic is specified.
8222 Allow it in all cases if -ms-extensions is specified. */
8223 if ((!pedantic
&& current_lang_name
== lang_name_c
)
8224 || flag_ms_extensions
)
8226 n
= splay_tree_lookup (names_used
, (splay_tree_key
) name
);
8229 /* [basic.scope.class]
8231 A name N used in a class S shall refer to the same declaration
8232 in its context and when re-evaluated in the completed scope of
8234 permerror (input_location
, "declaration of %q#D", decl
);
8235 permerror (location_of ((tree
) n
->value
),
8236 "changes meaning of %qD from %q#D",
8237 OVL_NAME (decl
), (tree
) n
->value
);
8241 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
8242 Secondary vtables are merged with primary vtables; this function
8243 will return the VAR_DECL for the primary vtable. */
8246 get_vtbl_decl_for_binfo (tree binfo
)
8250 decl
= BINFO_VTABLE (binfo
);
8251 if (decl
&& TREE_CODE (decl
) == POINTER_PLUS_EXPR
)
8253 gcc_assert (TREE_CODE (TREE_OPERAND (decl
, 0)) == ADDR_EXPR
);
8254 decl
= TREE_OPERAND (TREE_OPERAND (decl
, 0), 0);
8257 gcc_assert (VAR_P (decl
));
8262 /* Returns the binfo for the primary base of BINFO. If the resulting
8263 BINFO is a virtual base, and it is inherited elsewhere in the
8264 hierarchy, then the returned binfo might not be the primary base of
8265 BINFO in the complete object. Check BINFO_PRIMARY_P or
8266 BINFO_LOST_PRIMARY_P to be sure. */
8269 get_primary_binfo (tree binfo
)
8273 primary_base
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo
));
8277 return copied_binfo (primary_base
, binfo
);
8280 /* As above, but iterate until we reach the binfo that actually provides the
8284 most_primary_binfo (tree binfo
)
8287 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b
))
8288 && !BINFO_LOST_PRIMARY_P (b
))
8290 tree primary_base
= get_primary_binfo (b
);
8291 gcc_assert (BINFO_PRIMARY_P (primary_base
)
8292 && BINFO_INHERITANCE_CHAIN (primary_base
) == b
);
8298 /* Returns true if BINFO gets its vptr from a virtual base of the most derived
8299 type. Note that the virtual inheritance might be above or below BINFO in
8303 vptr_via_virtual_p (tree binfo
)
8306 binfo
= TYPE_BINFO (binfo
);
8307 tree primary
= most_primary_binfo (binfo
);
8308 /* Don't limit binfo_via_virtual, we want to return true when BINFO itself is
8309 a morally virtual base. */
8310 tree virt
= binfo_via_virtual (primary
, NULL_TREE
);
8311 return virt
!= NULL_TREE
;
8314 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
8317 maybe_indent_hierarchy (FILE * stream
, int indent
, int indented_p
)
8320 fprintf (stream
, "%*s", indent
, "");
8324 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
8325 INDENT should be zero when called from the top level; it is
8326 incremented recursively. IGO indicates the next expected BINFO in
8327 inheritance graph ordering. */
8330 dump_class_hierarchy_r (FILE *stream
,
8340 indented
= maybe_indent_hierarchy (stream
, indent
, 0);
8341 fprintf (stream
, "%s (0x" HOST_WIDE_INT_PRINT_HEX
") ",
8342 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
),
8343 (HOST_WIDE_INT
) (uintptr_t) binfo
);
8346 fprintf (stream
, "alternative-path\n");
8349 igo
= TREE_CHAIN (binfo
);
8351 fprintf (stream
, HOST_WIDE_INT_PRINT_DEC
,
8352 tree_to_shwi (BINFO_OFFSET (binfo
)));
8353 if (is_empty_class (BINFO_TYPE (binfo
)))
8354 fprintf (stream
, " empty");
8355 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo
)))
8356 fprintf (stream
, " nearly-empty");
8357 if (BINFO_VIRTUAL_P (binfo
))
8358 fprintf (stream
, " virtual");
8359 fprintf (stream
, "\n");
8362 if (BINFO_PRIMARY_P (binfo
))
8364 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8365 fprintf (stream
, " primary-for %s (0x" HOST_WIDE_INT_PRINT_HEX
")",
8366 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo
)),
8367 TFF_PLAIN_IDENTIFIER
),
8368 (HOST_WIDE_INT
) (uintptr_t) BINFO_INHERITANCE_CHAIN (binfo
));
8370 if (BINFO_LOST_PRIMARY_P (binfo
))
8372 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8373 fprintf (stream
, " lost-primary");
8376 fprintf (stream
, "\n");
8378 if (!(flags
& TDF_SLIM
))
8382 if (BINFO_SUBVTT_INDEX (binfo
))
8384 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8385 fprintf (stream
, " subvttidx=%s",
8386 expr_as_string (BINFO_SUBVTT_INDEX (binfo
),
8387 TFF_PLAIN_IDENTIFIER
));
8389 if (BINFO_VPTR_INDEX (binfo
))
8391 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8392 fprintf (stream
, " vptridx=%s",
8393 expr_as_string (BINFO_VPTR_INDEX (binfo
),
8394 TFF_PLAIN_IDENTIFIER
));
8396 if (BINFO_VPTR_FIELD (binfo
))
8398 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8399 fprintf (stream
, " vbaseoffset=%s",
8400 expr_as_string (BINFO_VPTR_FIELD (binfo
),
8401 TFF_PLAIN_IDENTIFIER
));
8403 if (BINFO_VTABLE (binfo
))
8405 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8406 fprintf (stream
, " vptr=%s",
8407 expr_as_string (BINFO_VTABLE (binfo
),
8408 TFF_PLAIN_IDENTIFIER
));
8412 fprintf (stream
, "\n");
8415 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
8416 igo
= dump_class_hierarchy_r (stream
, flags
, base_binfo
, igo
, indent
+ 2);
8421 /* Dump the BINFO hierarchy for T. */
8424 dump_class_hierarchy_1 (FILE *stream
, dump_flags_t flags
, tree t
)
8426 fprintf (stream
, "Class %s\n", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8427 fprintf (stream
, " size=%lu align=%lu\n",
8428 (unsigned long)(tree_to_shwi (TYPE_SIZE (t
)) / BITS_PER_UNIT
),
8429 (unsigned long)(TYPE_ALIGN (t
) / BITS_PER_UNIT
));
8430 fprintf (stream
, " base size=%lu base align=%lu\n",
8431 (unsigned long)(tree_to_shwi (TYPE_SIZE (CLASSTYPE_AS_BASE (t
)))
8433 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t
))
8435 dump_class_hierarchy_r (stream
, flags
, TYPE_BINFO (t
), TYPE_BINFO (t
), 0);
8436 fprintf (stream
, "\n");
8439 /* Debug interface to hierarchy dumping. */
8442 debug_class (tree t
)
8444 dump_class_hierarchy_1 (stderr
, TDF_SLIM
, t
);
8448 dump_class_hierarchy (tree t
)
8451 if (FILE *stream
= dump_begin (class_dump_id
, &flags
))
8453 dump_class_hierarchy_1 (stream
, flags
, t
);
8454 dump_end (class_dump_id
, stream
);
8459 dump_array (FILE * stream
, tree decl
)
8462 unsigned HOST_WIDE_INT ix
;
8464 tree size
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl
)));
8466 elt
= (tree_to_shwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
))))
8468 fprintf (stream
, "%s:", decl_as_string (decl
, TFF_PLAIN_IDENTIFIER
));
8469 fprintf (stream
, " %s entries",
8470 expr_as_string (size_binop (PLUS_EXPR
, size
, size_one_node
),
8471 TFF_PLAIN_IDENTIFIER
));
8472 fprintf (stream
, "\n");
8474 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
)),
8476 fprintf (stream
, "%-4ld %s\n", (long)(ix
* elt
),
8477 expr_as_string (value
, TFF_PLAIN_IDENTIFIER
));
8481 dump_vtable (tree t
, tree binfo
, tree vtable
)
8484 FILE *stream
= dump_begin (class_dump_id
, &flags
);
8489 if (!(flags
& TDF_SLIM
))
8491 int ctor_vtbl_p
= TYPE_BINFO (t
) != binfo
;
8493 fprintf (stream
, "%s for %s",
8494 ctor_vtbl_p
? "Construction vtable" : "Vtable",
8495 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
));
8498 if (!BINFO_VIRTUAL_P (binfo
))
8499 fprintf (stream
, " (0x" HOST_WIDE_INT_PRINT_HEX
" instance)",
8500 (HOST_WIDE_INT
) (uintptr_t) binfo
);
8501 fprintf (stream
, " in %s", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8503 fprintf (stream
, "\n");
8504 dump_array (stream
, vtable
);
8505 fprintf (stream
, "\n");
8508 dump_end (class_dump_id
, stream
);
8512 dump_vtt (tree t
, tree vtt
)
8515 FILE *stream
= dump_begin (class_dump_id
, &flags
);
8520 if (!(flags
& TDF_SLIM
))
8522 fprintf (stream
, "VTT for %s\n",
8523 type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8524 dump_array (stream
, vtt
);
8525 fprintf (stream
, "\n");
8528 dump_end (class_dump_id
, stream
);
8531 /* Dump a function or thunk and its thunkees. */
8534 dump_thunk (FILE *stream
, int indent
, tree thunk
)
8536 static const char spaces
[] = " ";
8537 tree name
= DECL_NAME (thunk
);
8540 fprintf (stream
, "%.*s%p %s %s", indent
, spaces
,
8542 !DECL_THUNK_P (thunk
) ? "function"
8543 : DECL_THIS_THUNK_P (thunk
) ? "this-thunk" : "covariant-thunk",
8544 name
? IDENTIFIER_POINTER (name
) : "<unset>");
8545 if (DECL_THUNK_P (thunk
))
8547 HOST_WIDE_INT fixed_adjust
= THUNK_FIXED_OFFSET (thunk
);
8548 tree virtual_adjust
= THUNK_VIRTUAL_OFFSET (thunk
);
8550 fprintf (stream
, " fixed=" HOST_WIDE_INT_PRINT_DEC
, fixed_adjust
);
8551 if (!virtual_adjust
)
8553 else if (DECL_THIS_THUNK_P (thunk
))
8554 fprintf (stream
, " vcall=" HOST_WIDE_INT_PRINT_DEC
,
8555 tree_to_shwi (virtual_adjust
));
8557 fprintf (stream
, " vbase=" HOST_WIDE_INT_PRINT_DEC
"(%s)",
8558 tree_to_shwi (BINFO_VPTR_FIELD (virtual_adjust
)),
8559 type_as_string (BINFO_TYPE (virtual_adjust
), TFF_SCOPE
));
8560 if (THUNK_ALIAS (thunk
))
8561 fprintf (stream
, " alias to %p", (void *)THUNK_ALIAS (thunk
));
8563 fprintf (stream
, "\n");
8564 for (thunks
= DECL_THUNKS (thunk
); thunks
; thunks
= TREE_CHAIN (thunks
))
8565 dump_thunk (stream
, indent
+ 2, thunks
);
8568 /* Dump the thunks for FN. */
8571 debug_thunks (tree fn
)
8573 dump_thunk (stderr
, 0, fn
);
8576 /* Virtual function table initialization. */
8578 /* Create all the necessary vtables for T and its base classes. */
8581 finish_vtbls (tree t
)
8584 vec
<constructor_elt
, va_gc
> *v
= NULL
;
8585 tree vtable
= BINFO_VTABLE (TYPE_BINFO (t
));
8587 /* We lay out the primary and secondary vtables in one contiguous
8588 vtable. The primary vtable is first, followed by the non-virtual
8589 secondary vtables in inheritance graph order. */
8590 accumulate_vtbl_inits (TYPE_BINFO (t
), TYPE_BINFO (t
), TYPE_BINFO (t
),
8593 /* Then come the virtual bases, also in inheritance graph order. */
8594 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
8596 if (!BINFO_VIRTUAL_P (vbase
))
8598 accumulate_vtbl_inits (vbase
, vbase
, TYPE_BINFO (t
), vtable
, t
, &v
);
8601 if (BINFO_VTABLE (TYPE_BINFO (t
)))
8602 initialize_vtable (TYPE_BINFO (t
), v
);
8605 /* Initialize the vtable for BINFO with the INITS. */
8608 initialize_vtable (tree binfo
, vec
<constructor_elt
, va_gc
> *inits
)
8612 layout_vtable_decl (binfo
, vec_safe_length (inits
));
8613 decl
= get_vtbl_decl_for_binfo (binfo
);
8614 initialize_artificial_var (decl
, inits
);
8615 dump_vtable (BINFO_TYPE (binfo
), binfo
, decl
);
8618 /* Build the VTT (virtual table table) for T.
8619 A class requires a VTT if it has virtual bases.
8622 1 - primary virtual pointer for complete object T
8623 2 - secondary VTTs for each direct non-virtual base of T which requires a
8625 3 - secondary virtual pointers for each direct or indirect base of T which
8626 has virtual bases or is reachable via a virtual path from T.
8627 4 - secondary VTTs for each direct or indirect virtual base of T.
8629 Secondary VTTs look like complete object VTTs without part 4. */
8637 vec
<constructor_elt
, va_gc
> *inits
;
8639 /* Build up the initializers for the VTT. */
8641 index
= size_zero_node
;
8642 build_vtt_inits (TYPE_BINFO (t
), t
, &inits
, &index
);
8644 /* If we didn't need a VTT, we're done. */
8648 /* Figure out the type of the VTT. */
8649 type
= build_array_of_n_type (const_ptr_type_node
,
8652 /* Now, build the VTT object itself. */
8653 vtt
= build_vtable (t
, mangle_vtt_for_type (t
), type
);
8654 initialize_artificial_var (vtt
, inits
);
8655 /* Add the VTT to the vtables list. */
8656 DECL_CHAIN (vtt
) = DECL_CHAIN (CLASSTYPE_VTABLES (t
));
8657 DECL_CHAIN (CLASSTYPE_VTABLES (t
)) = vtt
;
8662 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
8663 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
8664 and CHAIN the vtable pointer for this binfo after construction is
8665 complete. VALUE can also be another BINFO, in which case we recurse. */
8668 binfo_ctor_vtable (tree binfo
)
8674 vt
= BINFO_VTABLE (binfo
);
8675 if (TREE_CODE (vt
) == TREE_LIST
)
8676 vt
= TREE_VALUE (vt
);
8677 if (TREE_CODE (vt
) == TREE_BINFO
)
8686 /* Data for secondary VTT initialization. */
8687 struct secondary_vptr_vtt_init_data
8689 /* Is this the primary VTT? */
8692 /* Current index into the VTT. */
8695 /* Vector of initializers built up. */
8696 vec
<constructor_elt
, va_gc
> *inits
;
8698 /* The type being constructed by this secondary VTT. */
8699 tree type_being_constructed
;
8702 /* Recursively build the VTT-initializer for BINFO (which is in the
8703 hierarchy dominated by T). INITS points to the end of the initializer
8704 list to date. INDEX is the VTT index where the next element will be
8705 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
8706 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
8707 for virtual bases of T. When it is not so, we build the constructor
8708 vtables for the BINFO-in-T variant. */
8711 build_vtt_inits (tree binfo
, tree t
, vec
<constructor_elt
, va_gc
> **inits
,
8717 secondary_vptr_vtt_init_data data
;
8718 int top_level_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
8720 /* We only need VTTs for subobjects with virtual bases. */
8721 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
8724 /* We need to use a construction vtable if this is not the primary
8728 build_ctor_vtbl_group (binfo
, t
);
8730 /* Record the offset in the VTT where this sub-VTT can be found. */
8731 BINFO_SUBVTT_INDEX (binfo
) = *index
;
8734 /* Add the address of the primary vtable for the complete object. */
8735 init
= binfo_ctor_vtable (binfo
);
8736 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8739 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
8740 BINFO_VPTR_INDEX (binfo
) = *index
;
8742 *index
= size_binop (PLUS_EXPR
, *index
, TYPE_SIZE_UNIT (ptr_type_node
));
8744 /* Recursively add the secondary VTTs for non-virtual bases. */
8745 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, b
); ++i
)
8746 if (!BINFO_VIRTUAL_P (b
))
8747 build_vtt_inits (b
, t
, inits
, index
);
8749 /* Add secondary virtual pointers for all subobjects of BINFO with
8750 either virtual bases or reachable along a virtual path, except
8751 subobjects that are non-virtual primary bases. */
8752 data
.top_level_p
= top_level_p
;
8753 data
.index
= *index
;
8754 data
.inits
= *inits
;
8755 data
.type_being_constructed
= BINFO_TYPE (binfo
);
8757 dfs_walk_once (binfo
, dfs_build_secondary_vptr_vtt_inits
, NULL
, &data
);
8759 *index
= data
.index
;
8761 /* data.inits might have grown as we added secondary virtual pointers.
8762 Make sure our caller knows about the new vector. */
8763 *inits
= data
.inits
;
8766 /* Add the secondary VTTs for virtual bases in inheritance graph
8768 for (b
= TYPE_BINFO (BINFO_TYPE (binfo
)); b
; b
= TREE_CHAIN (b
))
8770 if (!BINFO_VIRTUAL_P (b
))
8773 build_vtt_inits (b
, t
, inits
, index
);
8776 /* Remove the ctor vtables we created. */
8777 dfs_walk_all (binfo
, dfs_fixup_binfo_vtbls
, NULL
, binfo
);
8780 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
8781 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
8784 dfs_build_secondary_vptr_vtt_inits (tree binfo
, void *data_
)
8786 secondary_vptr_vtt_init_data
*data
= (secondary_vptr_vtt_init_data
*)data_
;
8788 /* We don't care about bases that don't have vtables. */
8789 if (!TYPE_VFIELD (BINFO_TYPE (binfo
)))
8790 return dfs_skip_bases
;
8792 /* We're only interested in proper subobjects of the type being
8794 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->type_being_constructed
))
8797 /* We're only interested in bases with virtual bases or reachable
8798 via a virtual path from the type being constructed. */
8799 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
8800 || binfo_via_virtual (binfo
, data
->type_being_constructed
)))
8801 return dfs_skip_bases
;
8803 /* We're not interested in non-virtual primary bases. */
8804 if (!BINFO_VIRTUAL_P (binfo
) && BINFO_PRIMARY_P (binfo
))
8807 /* Record the index where this secondary vptr can be found. */
8808 if (data
->top_level_p
)
8810 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
8811 BINFO_VPTR_INDEX (binfo
) = data
->index
;
8813 if (BINFO_VIRTUAL_P (binfo
))
8815 /* It's a primary virtual base, and this is not a
8816 construction vtable. Find the base this is primary of in
8817 the inheritance graph, and use that base's vtable
8819 while (BINFO_PRIMARY_P (binfo
))
8820 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
8824 /* Add the initializer for the secondary vptr itself. */
8825 CONSTRUCTOR_APPEND_ELT (data
->inits
, NULL_TREE
, binfo_ctor_vtable (binfo
));
8827 /* Advance the vtt index. */
8828 data
->index
= size_binop (PLUS_EXPR
, data
->index
,
8829 TYPE_SIZE_UNIT (ptr_type_node
));
8834 /* Called from build_vtt_inits via dfs_walk. After building
8835 constructor vtables and generating the sub-vtt from them, we need
8836 to restore the BINFO_VTABLES that were scribbled on. DATA is the
8837 binfo of the base whose sub vtt was generated. */
8840 dfs_fixup_binfo_vtbls (tree binfo
, void* data
)
8842 tree vtable
= BINFO_VTABLE (binfo
);
8844 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
8845 /* If this class has no vtable, none of its bases do. */
8846 return dfs_skip_bases
;
8849 /* This might be a primary base, so have no vtable in this
8853 /* If we scribbled the construction vtable vptr into BINFO, clear it
8855 if (TREE_CODE (vtable
) == TREE_LIST
8856 && (TREE_PURPOSE (vtable
) == (tree
) data
))
8857 BINFO_VTABLE (binfo
) = TREE_CHAIN (vtable
);
8862 /* Build the construction vtable group for BINFO which is in the
8863 hierarchy dominated by T. */
8866 build_ctor_vtbl_group (tree binfo
, tree t
)
8872 vec
<constructor_elt
, va_gc
> *v
;
8874 /* See if we've already created this construction vtable group. */
8875 id
= mangle_ctor_vtbl_for_type (t
, binfo
);
8876 if (get_global_binding (id
))
8879 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
));
8880 /* Build a version of VTBL (with the wrong type) for use in
8881 constructing the addresses of secondary vtables in the
8882 construction vtable group. */
8883 vtbl
= build_vtable (t
, id
, ptr_type_node
);
8884 DECL_CONSTRUCTION_VTABLE_P (vtbl
) = 1;
8885 /* Don't export construction vtables from shared libraries. Even on
8886 targets that don't support hidden visibility, this tells
8887 can_refer_decl_in_current_unit_p not to assume that it's safe to
8888 access from a different compilation unit (bz 54314). */
8889 DECL_VISIBILITY (vtbl
) = VISIBILITY_HIDDEN
;
8890 DECL_VISIBILITY_SPECIFIED (vtbl
) = true;
8893 accumulate_vtbl_inits (binfo
, TYPE_BINFO (TREE_TYPE (binfo
)),
8894 binfo
, vtbl
, t
, &v
);
8896 /* Add the vtables for each of our virtual bases using the vbase in T
8898 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
8900 vbase
= TREE_CHAIN (vbase
))
8904 if (!BINFO_VIRTUAL_P (vbase
))
8906 b
= copied_binfo (vbase
, binfo
);
8908 accumulate_vtbl_inits (b
, vbase
, binfo
, vtbl
, t
, &v
);
8911 /* Figure out the type of the construction vtable. */
8912 type
= build_array_of_n_type (vtable_entry_type
, v
->length ());
8914 TREE_TYPE (vtbl
) = type
;
8915 DECL_SIZE (vtbl
) = DECL_SIZE_UNIT (vtbl
) = NULL_TREE
;
8916 layout_decl (vtbl
, 0);
8918 /* Initialize the construction vtable. */
8919 CLASSTYPE_VTABLES (t
) = chainon (CLASSTYPE_VTABLES (t
), vtbl
);
8920 initialize_artificial_var (vtbl
, v
);
8921 dump_vtable (t
, binfo
, vtbl
);
8924 /* Add the vtbl initializers for BINFO (and its bases other than
8925 non-virtual primaries) to the list of INITS. BINFO is in the
8926 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
8927 the constructor the vtbl inits should be accumulated for. (If this
8928 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
8929 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
8930 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
8931 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
8932 but are not necessarily the same in terms of layout. */
8935 accumulate_vtbl_inits (tree binfo
,
8940 vec
<constructor_elt
, va_gc
> **inits
)
8944 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8946 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (orig_binfo
)));
8948 /* If it doesn't have a vptr, we don't do anything. */
8949 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
8952 /* If we're building a construction vtable, we're not interested in
8953 subobjects that don't require construction vtables. */
8955 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
8956 && !binfo_via_virtual (orig_binfo
, BINFO_TYPE (rtti_binfo
)))
8959 /* Build the initializers for the BINFO-in-T vtable. */
8960 dfs_accumulate_vtbl_inits (binfo
, orig_binfo
, rtti_binfo
, vtbl
, t
, inits
);
8962 /* Walk the BINFO and its bases. We walk in preorder so that as we
8963 initialize each vtable we can figure out at what offset the
8964 secondary vtable lies from the primary vtable. We can't use
8965 dfs_walk here because we need to iterate through bases of BINFO
8966 and RTTI_BINFO simultaneously. */
8967 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
8969 /* Skip virtual bases. */
8970 if (BINFO_VIRTUAL_P (base_binfo
))
8972 accumulate_vtbl_inits (base_binfo
,
8973 BINFO_BASE_BINFO (orig_binfo
, i
),
8974 rtti_binfo
, vtbl
, t
,
8979 /* Called from accumulate_vtbl_inits. Adds the initializers for the
8980 BINFO vtable to L. */
8983 dfs_accumulate_vtbl_inits (tree binfo
,
8988 vec
<constructor_elt
, va_gc
> **l
)
8990 tree vtbl
= NULL_TREE
;
8991 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8995 && BINFO_VIRTUAL_P (orig_binfo
) && BINFO_PRIMARY_P (orig_binfo
))
8997 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
8998 primary virtual base. If it is not the same primary in
8999 the hierarchy of T, we'll need to generate a ctor vtable
9000 for it, to place at its location in T. If it is the same
9001 primary, we still need a VTT entry for the vtable, but it
9002 should point to the ctor vtable for the base it is a
9003 primary for within the sub-hierarchy of RTTI_BINFO.
9005 There are three possible cases:
9007 1) We are in the same place.
9008 2) We are a primary base within a lost primary virtual base of
9010 3) We are primary to something not a base of RTTI_BINFO. */
9013 tree last
= NULL_TREE
;
9015 /* First, look through the bases we are primary to for RTTI_BINFO
9016 or a virtual base. */
9018 while (BINFO_PRIMARY_P (b
))
9020 b
= BINFO_INHERITANCE_CHAIN (b
);
9022 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
9025 /* If we run out of primary links, keep looking down our
9026 inheritance chain; we might be an indirect primary. */
9027 for (b
= last
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
9028 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
9032 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
9033 base B and it is a base of RTTI_BINFO, this is case 2. In
9034 either case, we share our vtable with LAST, i.e. the
9035 derived-most base within B of which we are a primary. */
9037 || (b
&& binfo_for_vbase (BINFO_TYPE (b
), BINFO_TYPE (rtti_binfo
))))
9038 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
9039 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
9040 binfo_ctor_vtable after everything's been set up. */
9043 /* Otherwise, this is case 3 and we get our own. */
9045 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo
))
9048 n_inits
= vec_safe_length (*l
);
9055 /* Add the initializer for this vtable. */
9056 build_vtbl_initializer (binfo
, orig_binfo
, t
, rtti_binfo
,
9057 &non_fn_entries
, l
);
9059 /* Figure out the position to which the VPTR should point. */
9060 vtbl
= build1 (ADDR_EXPR
, vtbl_ptr_type_node
, orig_vtbl
);
9061 index
= size_binop (MULT_EXPR
,
9062 TYPE_SIZE_UNIT (vtable_entry_type
),
9063 size_int (non_fn_entries
+ n_inits
));
9064 vtbl
= fold_build_pointer_plus (vtbl
, index
);
9068 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
9069 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
9070 straighten this out. */
9071 BINFO_VTABLE (binfo
) = tree_cons (rtti_binfo
, vtbl
, BINFO_VTABLE (binfo
));
9072 else if (BINFO_PRIMARY_P (binfo
) && BINFO_VIRTUAL_P (binfo
))
9073 /* Throw away any unneeded intializers. */
9074 (*l
)->truncate (n_inits
);
9076 /* For an ordinary vtable, set BINFO_VTABLE. */
9077 BINFO_VTABLE (binfo
) = vtbl
;
9080 static GTY(()) tree abort_fndecl_addr
;
9081 static GTY(()) tree dvirt_fn
;
9083 /* Construct the initializer for BINFO's virtual function table. BINFO
9084 is part of the hierarchy dominated by T. If we're building a
9085 construction vtable, the ORIG_BINFO is the binfo we should use to
9086 find the actual function pointers to put in the vtable - but they
9087 can be overridden on the path to most-derived in the graph that
9088 ORIG_BINFO belongs. Otherwise,
9089 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
9090 BINFO that should be indicated by the RTTI information in the
9091 vtable; it will be a base class of T, rather than T itself, if we
9092 are building a construction vtable.
9094 The value returned is a TREE_LIST suitable for wrapping in a
9095 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
9096 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
9097 number of non-function entries in the vtable.
9099 It might seem that this function should never be called with a
9100 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
9101 base is always subsumed by a derived class vtable. However, when
9102 we are building construction vtables, we do build vtables for
9103 primary bases; we need these while the primary base is being
9107 build_vtbl_initializer (tree binfo
,
9111 int* non_fn_entries_p
,
9112 vec
<constructor_elt
, va_gc
> **inits
)
9118 vec
<tree
, va_gc
> *vbases
;
9121 /* Initialize VID. */
9122 memset (&vid
, 0, sizeof (vid
));
9125 vid
.rtti_binfo
= rtti_binfo
;
9126 vid
.primary_vtbl_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
9127 vid
.ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
9128 vid
.generate_vcall_entries
= true;
9129 /* The first vbase or vcall offset is at index -3 in the vtable. */
9130 vid
.index
= ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
9132 /* Add entries to the vtable for RTTI. */
9133 build_rtti_vtbl_entries (binfo
, &vid
);
9135 /* Create an array for keeping track of the functions we've
9136 processed. When we see multiple functions with the same
9137 signature, we share the vcall offsets. */
9138 vec_alloc (vid
.fns
, 32);
9139 /* Add the vcall and vbase offset entries. */
9140 build_vcall_and_vbase_vtbl_entries (binfo
, &vid
);
9142 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
9143 build_vbase_offset_vtbl_entries. */
9144 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
9145 vec_safe_iterate (vbases
, ix
, &vbinfo
); ix
++)
9146 BINFO_VTABLE_PATH_MARKED (vbinfo
) = 0;
9148 /* If the target requires padding between data entries, add that now. */
9149 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE
> 1)
9151 int n_entries
= vec_safe_length (vid
.inits
);
9153 vec_safe_grow (vid
.inits
, TARGET_VTABLE_DATA_ENTRY_DISTANCE
* n_entries
);
9155 /* Move data entries into their new positions and add padding
9156 after the new positions. Iterate backwards so we don't
9157 overwrite entries that we would need to process later. */
9158 for (ix
= n_entries
- 1;
9159 vid
.inits
->iterate (ix
, &e
);
9163 int new_position
= (TARGET_VTABLE_DATA_ENTRY_DISTANCE
* ix
9164 + (TARGET_VTABLE_DATA_ENTRY_DISTANCE
- 1));
9166 (*vid
.inits
)[new_position
] = *e
;
9168 for (j
= 1; j
< TARGET_VTABLE_DATA_ENTRY_DISTANCE
; ++j
)
9170 constructor_elt
*f
= &(*vid
.inits
)[new_position
- j
];
9171 f
->index
= NULL_TREE
;
9172 f
->value
= build1 (NOP_EXPR
, vtable_entry_type
,
9178 if (non_fn_entries_p
)
9179 *non_fn_entries_p
= vec_safe_length (vid
.inits
);
9181 /* The initializers for virtual functions were built up in reverse
9182 order. Straighten them out and add them to the running list in one
9184 jx
= vec_safe_length (*inits
);
9185 vec_safe_grow (*inits
, jx
+ vid
.inits
->length ());
9187 for (ix
= vid
.inits
->length () - 1;
9188 vid
.inits
->iterate (ix
, &e
);
9192 /* Go through all the ordinary virtual functions, building up
9194 for (v
= BINFO_VIRTUALS (orig_binfo
); v
; v
= TREE_CHAIN (v
))
9198 tree fn
, fn_original
;
9199 tree init
= NULL_TREE
;
9203 if (DECL_THUNK_P (fn
))
9205 if (!DECL_NAME (fn
))
9207 if (THUNK_ALIAS (fn
))
9209 fn
= THUNK_ALIAS (fn
);
9212 fn_original
= THUNK_TARGET (fn
);
9215 /* If the only definition of this function signature along our
9216 primary base chain is from a lost primary, this vtable slot will
9217 never be used, so just zero it out. This is important to avoid
9218 requiring extra thunks which cannot be generated with the function.
9220 We first check this in update_vtable_entry_for_fn, so we handle
9221 restored primary bases properly; we also need to do it here so we
9222 zero out unused slots in ctor vtables, rather than filling them
9223 with erroneous values (though harmless, apart from relocation
9225 if (BV_LOST_PRIMARY (v
))
9226 init
= size_zero_node
;
9230 /* Pull the offset for `this', and the function to call, out of
9232 delta
= BV_DELTA (v
);
9233 vcall_index
= BV_VCALL_INDEX (v
);
9235 gcc_assert (TREE_CODE (delta
) == INTEGER_CST
);
9236 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
9238 /* You can't call an abstract virtual function; it's abstract.
9239 So, we replace these functions with __pure_virtual. */
9240 if (DECL_PURE_VIRTUAL_P (fn_original
))
9243 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
9245 if (abort_fndecl_addr
== NULL
)
9247 = fold_convert (vfunc_ptr_type_node
,
9248 build_fold_addr_expr (fn
));
9249 init
= abort_fndecl_addr
;
9252 /* Likewise for deleted virtuals. */
9253 else if (DECL_DELETED_FN (fn_original
))
9257 tree name
= get_identifier ("__cxa_deleted_virtual");
9258 dvirt_fn
= get_global_binding (name
);
9260 dvirt_fn
= push_library_fn
9262 build_function_type_list (void_type_node
, NULL_TREE
),
9263 NULL_TREE
, ECF_NORETURN
| ECF_COLD
);
9266 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
9267 init
= fold_convert (vfunc_ptr_type_node
,
9268 build_fold_addr_expr (fn
));
9272 if (!integer_zerop (delta
) || vcall_index
)
9274 fn
= make_thunk (fn
, /*this_adjusting=*/1,
9275 delta
, vcall_index
);
9276 if (!DECL_NAME (fn
))
9279 /* Take the address of the function, considering it to be of an
9280 appropriate generic type. */
9281 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
9282 init
= fold_convert (vfunc_ptr_type_node
,
9283 build_fold_addr_expr (fn
));
9284 /* Don't refer to a virtual destructor from a constructor
9285 vtable or a vtable for an abstract class, since destroying
9286 an object under construction is undefined behavior and we
9287 don't want it to be considered a candidate for speculative
9288 devirtualization. But do create the thunk for ABI
9290 if (DECL_DESTRUCTOR_P (fn_original
)
9291 && (CLASSTYPE_PURE_VIRTUALS (DECL_CONTEXT (fn_original
))
9292 || orig_binfo
!= binfo
))
9293 init
= size_zero_node
;
9297 /* And add it to the chain of initializers. */
9298 if (TARGET_VTABLE_USES_DESCRIPTORS
)
9301 if (init
== size_zero_node
)
9302 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
9303 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
9305 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
9307 tree fdesc
= build2 (FDESC_EXPR
, vfunc_ptr_type_node
,
9308 fn
, build_int_cst (NULL_TREE
, i
));
9309 TREE_CONSTANT (fdesc
) = 1;
9311 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, fdesc
);
9315 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
9319 /* Adds to vid->inits the initializers for the vbase and vcall
9320 offsets in BINFO, which is in the hierarchy dominated by T. */
9323 build_vcall_and_vbase_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9327 /* If this is a derived class, we must first create entries
9328 corresponding to the primary base class. */
9329 b
= get_primary_binfo (binfo
);
9331 build_vcall_and_vbase_vtbl_entries (b
, vid
);
9333 /* Add the vbase entries for this base. */
9334 build_vbase_offset_vtbl_entries (binfo
, vid
);
9335 /* Add the vcall entries for this base. */
9336 build_vcall_offset_vtbl_entries (binfo
, vid
);
9339 /* Returns the initializers for the vbase offset entries in the vtable
9340 for BINFO (which is part of the class hierarchy dominated by T), in
9341 reverse order. VBASE_OFFSET_INDEX gives the vtable index
9342 where the next vbase offset will go. */
9345 build_vbase_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9349 tree non_primary_binfo
;
9351 /* If there are no virtual baseclasses, then there is nothing to
9353 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
9358 /* We might be a primary base class. Go up the inheritance hierarchy
9359 until we find the most derived class of which we are a primary base:
9360 it is the offset of that which we need to use. */
9361 non_primary_binfo
= binfo
;
9362 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
9366 /* If we have reached a virtual base, then it must be a primary
9367 base (possibly multi-level) of vid->binfo, or we wouldn't
9368 have called build_vcall_and_vbase_vtbl_entries for it. But it
9369 might be a lost primary, so just skip down to vid->binfo. */
9370 if (BINFO_VIRTUAL_P (non_primary_binfo
))
9372 non_primary_binfo
= vid
->binfo
;
9376 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
9377 if (get_primary_binfo (b
) != non_primary_binfo
)
9379 non_primary_binfo
= b
;
9382 /* Go through the virtual bases, adding the offsets. */
9383 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
9385 vbase
= TREE_CHAIN (vbase
))
9390 if (!BINFO_VIRTUAL_P (vbase
))
9393 /* Find the instance of this virtual base in the complete
9395 b
= copied_binfo (vbase
, binfo
);
9397 /* If we've already got an offset for this virtual base, we
9398 don't need another one. */
9399 if (BINFO_VTABLE_PATH_MARKED (b
))
9401 BINFO_VTABLE_PATH_MARKED (b
) = 1;
9403 /* Figure out where we can find this vbase offset. */
9404 delta
= size_binop (MULT_EXPR
,
9406 fold_convert (ssizetype
,
9407 TYPE_SIZE_UNIT (vtable_entry_type
)));
9408 if (vid
->primary_vtbl_p
)
9409 BINFO_VPTR_FIELD (b
) = delta
;
9411 if (binfo
!= TYPE_BINFO (t
))
9412 /* The vbase offset had better be the same. */
9413 gcc_assert (tree_int_cst_equal (delta
, BINFO_VPTR_FIELD (vbase
)));
9415 /* The next vbase will come at a more negative offset. */
9416 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
9417 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
9419 /* The initializer is the delta from BINFO to this virtual base.
9420 The vbase offsets go in reverse inheritance-graph order, and
9421 we are walking in inheritance graph order so these end up in
9423 delta
= size_diffop_loc (input_location
,
9424 BINFO_OFFSET (b
), BINFO_OFFSET (non_primary_binfo
));
9426 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
,
9427 fold_build1_loc (input_location
, NOP_EXPR
,
9428 vtable_entry_type
, delta
));
9432 /* Adds the initializers for the vcall offset entries in the vtable
9433 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
9437 build_vcall_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9439 /* We only need these entries if this base is a virtual base. We
9440 compute the indices -- but do not add to the vtable -- when
9441 building the main vtable for a class. */
9442 if (binfo
== TYPE_BINFO (vid
->derived
)
9443 || (BINFO_VIRTUAL_P (binfo
)
9444 /* If BINFO is RTTI_BINFO, then (since BINFO does not
9445 correspond to VID->DERIVED), we are building a primary
9446 construction virtual table. Since this is a primary
9447 virtual table, we do not need the vcall offsets for
9449 && binfo
!= vid
->rtti_binfo
))
9451 /* We need a vcall offset for each of the virtual functions in this
9452 vtable. For example:
9454 class A { virtual void f (); };
9455 class B1 : virtual public A { virtual void f (); };
9456 class B2 : virtual public A { virtual void f (); };
9457 class C: public B1, public B2 { virtual void f (); };
9459 A C object has a primary base of B1, which has a primary base of A. A
9460 C also has a secondary base of B2, which no longer has a primary base
9461 of A. So the B2-in-C construction vtable needs a secondary vtable for
9462 A, which will adjust the A* to a B2* to call f. We have no way of
9463 knowing what (or even whether) this offset will be when we define B2,
9464 so we store this "vcall offset" in the A sub-vtable and look it up in
9465 a "virtual thunk" for B2::f.
9467 We need entries for all the functions in our primary vtable and
9468 in our non-virtual bases' secondary vtables. */
9470 /* If we are just computing the vcall indices -- but do not need
9471 the actual entries -- not that. */
9472 if (!BINFO_VIRTUAL_P (binfo
))
9473 vid
->generate_vcall_entries
= false;
9474 /* Now, walk through the non-virtual bases, adding vcall offsets. */
9475 add_vcall_offset_vtbl_entries_r (binfo
, vid
);
9479 /* Build vcall offsets, starting with those for BINFO. */
9482 add_vcall_offset_vtbl_entries_r (tree binfo
, vtbl_init_data
* vid
)
9488 /* Don't walk into virtual bases -- except, of course, for the
9489 virtual base for which we are building vcall offsets. Any
9490 primary virtual base will have already had its offsets generated
9491 through the recursion in build_vcall_and_vbase_vtbl_entries. */
9492 if (BINFO_VIRTUAL_P (binfo
) && vid
->vbase
!= binfo
)
9495 /* If BINFO has a primary base, process it first. */
9496 primary_binfo
= get_primary_binfo (binfo
);
9498 add_vcall_offset_vtbl_entries_r (primary_binfo
, vid
);
9500 /* Add BINFO itself to the list. */
9501 add_vcall_offset_vtbl_entries_1 (binfo
, vid
);
9503 /* Scan the non-primary bases of BINFO. */
9504 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
9505 if (base_binfo
!= primary_binfo
)
9506 add_vcall_offset_vtbl_entries_r (base_binfo
, vid
);
9509 /* Called from build_vcall_offset_vtbl_entries_r. */
9512 add_vcall_offset_vtbl_entries_1 (tree binfo
, vtbl_init_data
* vid
)
9514 /* Make entries for the rest of the virtuals. */
9517 /* The ABI requires that the methods be processed in declaration
9519 for (orig_fn
= TYPE_FIELDS (BINFO_TYPE (binfo
));
9521 orig_fn
= DECL_CHAIN (orig_fn
))
9522 if (TREE_CODE (orig_fn
) == FUNCTION_DECL
&& DECL_VINDEX (orig_fn
))
9523 add_vcall_offset (orig_fn
, binfo
, vid
);
9526 /* Add a vcall offset entry for ORIG_FN to the vtable. */
9529 add_vcall_offset (tree orig_fn
, tree binfo
, vtbl_init_data
*vid
)
9535 /* If there is already an entry for a function with the same
9536 signature as FN, then we do not need a second vcall offset.
9537 Check the list of functions already present in the derived
9539 FOR_EACH_VEC_SAFE_ELT (vid
->fns
, i
, derived_entry
)
9541 if (same_signature_p (derived_entry
, orig_fn
)
9542 /* We only use one vcall offset for virtual destructors,
9543 even though there are two virtual table entries. */
9544 || (DECL_DESTRUCTOR_P (derived_entry
)
9545 && DECL_DESTRUCTOR_P (orig_fn
)))
9549 /* If we are building these vcall offsets as part of building
9550 the vtable for the most derived class, remember the vcall
9552 if (vid
->binfo
== TYPE_BINFO (vid
->derived
))
9554 tree_pair_s elt
= {orig_fn
, vid
->index
};
9555 vec_safe_push (CLASSTYPE_VCALL_INDICES (vid
->derived
), elt
);
9558 /* The next vcall offset will be found at a more negative
9560 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
9561 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
9563 /* Keep track of this function. */
9564 vec_safe_push (vid
->fns
, orig_fn
);
9566 if (vid
->generate_vcall_entries
)
9571 /* Find the overriding function. */
9572 fn
= find_final_overrider (vid
->rtti_binfo
, binfo
, orig_fn
);
9573 if (fn
== error_mark_node
)
9574 vcall_offset
= build_zero_cst (vtable_entry_type
);
9577 base
= TREE_VALUE (fn
);
9579 /* The vbase we're working on is a primary base of
9580 vid->binfo. But it might be a lost primary, so its
9581 BINFO_OFFSET might be wrong, so we just use the
9582 BINFO_OFFSET from vid->binfo. */
9583 vcall_offset
= size_diffop_loc (input_location
,
9584 BINFO_OFFSET (base
),
9585 BINFO_OFFSET (vid
->binfo
));
9586 vcall_offset
= fold_build1_loc (input_location
,
9587 NOP_EXPR
, vtable_entry_type
,
9590 /* Add the initializer to the vtable. */
9591 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, vcall_offset
);
9595 /* Return vtbl initializers for the RTTI entries corresponding to the
9596 BINFO's vtable. The RTTI entries should indicate the object given
9597 by VID->rtti_binfo. */
9600 build_rtti_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9608 t
= BINFO_TYPE (vid
->rtti_binfo
);
9610 /* To find the complete object, we will first convert to our most
9611 primary base, and then add the offset in the vtbl to that value. */
9612 b
= most_primary_binfo (binfo
);
9613 offset
= size_diffop_loc (input_location
,
9614 BINFO_OFFSET (vid
->rtti_binfo
), BINFO_OFFSET (b
));
9616 /* The second entry is the address of the typeinfo object. */
9618 decl
= build_address (get_tinfo_decl (t
));
9620 decl
= integer_zero_node
;
9622 /* Convert the declaration to a type that can be stored in the
9624 init
= build_nop (vfunc_ptr_type_node
, decl
);
9625 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, init
);
9627 /* Add the offset-to-top entry. It comes earlier in the vtable than
9628 the typeinfo entry. Convert the offset to look like a
9629 function pointer, so that we can put it in the vtable. */
9630 init
= build_nop (vfunc_ptr_type_node
, offset
);
9631 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, init
);
9634 /* TRUE iff TYPE is uniquely derived from PARENT. Ignores
9638 uniquely_derived_from_p (tree parent
, tree type
)
9640 tree base
= lookup_base (type
, parent
, ba_unique
, NULL
, tf_none
);
9641 return base
&& base
!= error_mark_node
;
9644 /* TRUE iff TYPE is publicly & uniquely derived from PARENT. */
9647 publicly_uniquely_derived_p (tree parent
, tree type
)
9649 tree base
= lookup_base (type
, parent
, ba_ignore_scope
| ba_check
,
9651 return base
&& base
!= error_mark_node
;
9654 /* CTX1 and CTX2 are declaration contexts. Return the innermost common
9655 class between them, if any. */
9658 common_enclosing_class (tree ctx1
, tree ctx2
)
9660 if (!TYPE_P (ctx1
) || !TYPE_P (ctx2
))
9662 gcc_assert (ctx1
== TYPE_MAIN_VARIANT (ctx1
)
9663 && ctx2
== TYPE_MAIN_VARIANT (ctx2
));
9666 for (tree t
= ctx1
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9667 TYPE_MARKED_P (t
) = true;
9668 tree found
= NULL_TREE
;
9669 for (tree t
= ctx2
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9670 if (TYPE_MARKED_P (t
))
9675 for (tree t
= ctx1
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9676 TYPE_MARKED_P (t
) = false;
9680 #include "gt-cp-class.h"