1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* High-level class interface. */
26 #include "coretypes.h"
29 #include "stringpool.h"
30 #include "stor-layout.h"
32 #include "hash-table.h"
40 #include "splay-tree.h"
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
;
72 typedef struct vtbl_init_data_s
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 tree
get_basefndecls (tree
, 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 finish_struct_methods (tree
);
133 static void maybe_warn_about_overly_private_class (tree
);
134 static int method_name_cmp (const void *, const void *);
135 static int resort_method_name_cmp (const void *, const void *);
136 static void add_implicitly_declared_members (tree
, tree
*, int, int);
137 static tree
fixed_type_or_null (tree
, int *, int *);
138 static tree
build_simple_base_path (tree expr
, tree binfo
);
139 static tree
build_vtbl_ref_1 (tree
, tree
);
140 static void build_vtbl_initializer (tree
, tree
, tree
, tree
, int *,
141 vec
<constructor_elt
, va_gc
> **);
142 static int count_fields (tree
);
143 static int add_fields_to_record_type (tree
, struct sorted_fields_type
*, int);
144 static void insert_into_classtype_sorted_fields (tree
, tree
, int);
145 static bool check_bitfield_decl (tree
);
146 static void check_field_decl (tree
, tree
, int *, int *, int *);
147 static void check_field_decls (tree
, tree
*, int *, int *);
148 static tree
*build_base_field (record_layout_info
, tree
, splay_tree
, tree
*);
149 static void build_base_fields (record_layout_info
, splay_tree
, tree
*);
150 static void check_methods (tree
);
151 static void remove_zero_width_bit_fields (tree
);
152 static bool accessible_nvdtor_p (tree
);
153 static void check_bases (tree
, int *, int *);
154 static void check_bases_and_members (tree
);
155 static tree
create_vtable_ptr (tree
, tree
*);
156 static void include_empty_classes (record_layout_info
);
157 static void layout_class_type (tree
, tree
*);
158 static void propagate_binfo_offsets (tree
, tree
);
159 static void layout_virtual_bases (record_layout_info
, splay_tree
);
160 static void build_vbase_offset_vtbl_entries (tree
, vtbl_init_data
*);
161 static void add_vcall_offset_vtbl_entries_r (tree
, vtbl_init_data
*);
162 static void add_vcall_offset_vtbl_entries_1 (tree
, vtbl_init_data
*);
163 static void build_vcall_offset_vtbl_entries (tree
, vtbl_init_data
*);
164 static void add_vcall_offset (tree
, tree
, vtbl_init_data
*);
165 static void layout_vtable_decl (tree
, int);
166 static tree
dfs_find_final_overrider_pre (tree
, void *);
167 static tree
dfs_find_final_overrider_post (tree
, void *);
168 static tree
find_final_overrider (tree
, tree
, tree
);
169 static int make_new_vtable (tree
, tree
);
170 static tree
get_primary_binfo (tree
);
171 static int maybe_indent_hierarchy (FILE *, int, int);
172 static tree
dump_class_hierarchy_r (FILE *, int, tree
, tree
, int);
173 static void dump_class_hierarchy (tree
);
174 static void dump_class_hierarchy_1 (FILE *, int, tree
);
175 static void dump_array (FILE *, tree
);
176 static void dump_vtable (tree
, tree
, tree
);
177 static void dump_vtt (tree
, tree
);
178 static void dump_thunk (FILE *, int, tree
);
179 static tree
build_vtable (tree
, tree
, tree
);
180 static void initialize_vtable (tree
, vec
<constructor_elt
, va_gc
> *);
181 static void layout_nonempty_base_or_field (record_layout_info
,
182 tree
, tree
, splay_tree
);
183 static tree
end_of_class (tree
, int);
184 static bool layout_empty_base (record_layout_info
, tree
, tree
, splay_tree
);
185 static void accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
,
186 vec
<constructor_elt
, va_gc
> **);
187 static void dfs_accumulate_vtbl_inits (tree
, tree
, tree
, tree
, tree
,
188 vec
<constructor_elt
, va_gc
> **);
189 static void build_rtti_vtbl_entries (tree
, vtbl_init_data
*);
190 static void build_vcall_and_vbase_vtbl_entries (tree
, vtbl_init_data
*);
191 static void clone_constructors_and_destructors (tree
);
192 static tree
build_clone (tree
, tree
);
193 static void update_vtable_entry_for_fn (tree
, tree
, tree
, tree
*, unsigned);
194 static void build_ctor_vtbl_group (tree
, tree
);
195 static void build_vtt (tree
);
196 static tree
binfo_ctor_vtable (tree
);
197 static void build_vtt_inits (tree
, tree
, vec
<constructor_elt
, va_gc
> **,
199 static tree
dfs_build_secondary_vptr_vtt_inits (tree
, void *);
200 static tree
dfs_fixup_binfo_vtbls (tree
, void *);
201 static int record_subobject_offset (tree
, tree
, splay_tree
);
202 static int check_subobject_offset (tree
, tree
, splay_tree
);
203 static int walk_subobject_offsets (tree
, subobject_offset_fn
,
204 tree
, splay_tree
, tree
, int);
205 static void record_subobject_offsets (tree
, tree
, splay_tree
, bool);
206 static int layout_conflict_p (tree
, tree
, splay_tree
, int);
207 static int splay_tree_compare_integer_csts (splay_tree_key k1
,
209 static void warn_about_ambiguous_bases (tree
);
210 static bool type_requires_array_cookie (tree
);
211 static bool base_derived_from (tree
, tree
);
212 static int empty_base_at_nonzero_offset_p (tree
, tree
, splay_tree
);
213 static tree
end_of_base (tree
);
214 static tree
get_vcall_index (tree
, tree
);
216 /* Variables shared between class.c and call.c. */
219 int n_vtable_entries
= 0;
220 int n_vtable_searches
= 0;
221 int n_vtable_elems
= 0;
222 int n_convert_harshness
= 0;
223 int n_compute_conversion_costs
= 0;
224 int n_inner_fields_searched
= 0;
226 /* Convert to or from a base subobject. EXPR is an expression of type
227 `A' or `A*', an expression of type `B' or `B*' is returned. To
228 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
229 the B base instance within A. To convert base A to derived B, CODE
230 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
231 In this latter case, A must not be a morally virtual base of B.
232 NONNULL is true if EXPR is known to be non-NULL (this is only
233 needed when EXPR is of pointer type). CV qualifiers are preserved
237 build_base_path (enum tree_code code
,
241 tsubst_flags_t complain
)
243 tree v_binfo
= NULL_TREE
;
244 tree d_binfo
= NULL_TREE
;
248 tree null_test
= NULL
;
249 tree ptr_target_type
;
251 int want_pointer
= TYPE_PTR_P (TREE_TYPE (expr
));
252 bool has_empty
= false;
255 if (expr
== error_mark_node
|| binfo
== error_mark_node
|| !binfo
)
256 return error_mark_node
;
258 for (probe
= binfo
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
261 if (is_empty_class (BINFO_TYPE (probe
)))
263 if (!v_binfo
&& BINFO_VIRTUAL_P (probe
))
267 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
269 probe
= TYPE_MAIN_VARIANT (TREE_TYPE (probe
));
271 if (code
== PLUS_EXPR
272 && !SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo
), probe
))
274 /* This can happen when adjust_result_of_qualified_name_lookup can't
275 find a unique base binfo in a call to a member function. We
276 couldn't give the diagnostic then since we might have been calling
277 a static member function, so we do it now. */
278 if (complain
& tf_error
)
280 tree base
= lookup_base (probe
, BINFO_TYPE (d_binfo
),
281 ba_unique
, NULL
, complain
);
282 gcc_assert (base
== error_mark_node
);
284 return error_mark_node
;
287 gcc_assert ((code
== MINUS_EXPR
288 && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), probe
))
289 || code
== PLUS_EXPR
);
291 if (binfo
== d_binfo
)
295 if (code
== MINUS_EXPR
&& v_binfo
)
297 if (complain
& tf_error
)
299 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (v_binfo
)))
302 error ("cannot convert from pointer to base class %qT to "
303 "pointer to derived class %qT because the base is "
304 "virtual", BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
));
306 error ("cannot convert from base class %qT to derived "
307 "class %qT because the base is virtual",
308 BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
));
313 error ("cannot convert from pointer to base class %qT to "
314 "pointer to derived class %qT via virtual base %qT",
315 BINFO_TYPE (binfo
), BINFO_TYPE (d_binfo
),
316 BINFO_TYPE (v_binfo
));
318 error ("cannot convert from base class %qT to derived "
319 "class %qT via virtual base %qT", BINFO_TYPE (binfo
),
320 BINFO_TYPE (d_binfo
), BINFO_TYPE (v_binfo
));
323 return error_mark_node
;
327 /* This must happen before the call to save_expr. */
328 expr
= cp_build_addr_expr (expr
, complain
);
330 expr
= mark_rvalue_use (expr
);
332 offset
= BINFO_OFFSET (binfo
);
333 fixed_type_p
= resolves_to_fixed_type_p (expr
, &nonnull
);
334 target_type
= code
== PLUS_EXPR
? BINFO_TYPE (binfo
) : BINFO_TYPE (d_binfo
);
335 /* TARGET_TYPE has been extracted from BINFO, and, is therefore always
336 cv-unqualified. Extract the cv-qualifiers from EXPR so that the
337 expression returned matches the input. */
338 target_type
= cp_build_qualified_type
339 (target_type
, cp_type_quals (TREE_TYPE (TREE_TYPE (expr
))));
340 ptr_target_type
= build_pointer_type (target_type
);
342 /* Do we need to look in the vtable for the real offset? */
343 virtual_access
= (v_binfo
&& fixed_type_p
<= 0);
345 /* Don't bother with the calculations inside sizeof; they'll ICE if the
346 source type is incomplete and the pointer value doesn't matter. In a
347 template (even in fold_non_dependent_expr), we don't have vtables set
348 up properly yet, and the value doesn't matter there either; we're just
349 interested in the result of overload resolution. */
350 if (cp_unevaluated_operand
!= 0
351 || in_template_function ())
353 expr
= build_nop (ptr_target_type
, expr
);
355 expr
= build_indirect_ref (EXPR_LOCATION (expr
), expr
, RO_NULL
);
359 /* If we're in an NSDMI, we don't have the full constructor context yet
360 that we need for converting to a virtual base, so just build a stub
361 CONVERT_EXPR and expand it later in bot_replace. */
362 if (virtual_access
&& fixed_type_p
< 0
363 && current_scope () != current_function_decl
)
365 expr
= build1 (CONVERT_EXPR
, ptr_target_type
, expr
);
366 CONVERT_EXPR_VBASE_PATH (expr
) = true;
368 expr
= build_indirect_ref (EXPR_LOCATION (expr
), expr
, RO_NULL
);
372 /* Do we need to check for a null pointer? */
373 if (want_pointer
&& !nonnull
)
375 /* If we know the conversion will not actually change the value
376 of EXPR, then we can avoid testing the expression for NULL.
377 We have to avoid generating a COMPONENT_REF for a base class
378 field, because other parts of the compiler know that such
379 expressions are always non-NULL. */
380 if (!virtual_access
&& integer_zerop (offset
))
381 return build_nop (ptr_target_type
, expr
);
382 null_test
= error_mark_node
;
385 /* Protect against multiple evaluation if necessary. */
386 if (TREE_SIDE_EFFECTS (expr
) && (null_test
|| virtual_access
))
387 expr
= save_expr (expr
);
389 /* Now that we've saved expr, build the real null test. */
392 tree zero
= cp_convert (TREE_TYPE (expr
), nullptr_node
, complain
);
393 null_test
= fold_build2_loc (input_location
, NE_EXPR
, boolean_type_node
,
397 /* If this is a simple base reference, express it as a COMPONENT_REF. */
398 if (code
== PLUS_EXPR
&& !virtual_access
399 /* We don't build base fields for empty bases, and they aren't very
400 interesting to the optimizers anyway. */
403 expr
= cp_build_indirect_ref (expr
, RO_NULL
, complain
);
404 expr
= build_simple_base_path (expr
, binfo
);
406 expr
= build_address (expr
);
407 target_type
= TREE_TYPE (expr
);
413 /* Going via virtual base V_BINFO. We need the static offset
414 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
415 V_BINFO. That offset is an entry in D_BINFO's vtable. */
418 if (fixed_type_p
< 0 && in_base_initializer
)
420 /* In a base member initializer, we cannot rely on the
421 vtable being set up. We have to indirect via the
425 t
= TREE_TYPE (TYPE_VFIELD (current_class_type
));
426 t
= build_pointer_type (t
);
427 v_offset
= convert (t
, current_vtt_parm
);
428 v_offset
= cp_build_indirect_ref (v_offset
, RO_NULL
, complain
);
431 v_offset
= build_vfield_ref (cp_build_indirect_ref (expr
, RO_NULL
,
433 TREE_TYPE (TREE_TYPE (expr
)));
435 if (v_offset
== error_mark_node
)
436 return error_mark_node
;
438 v_offset
= fold_build_pointer_plus (v_offset
, BINFO_VPTR_FIELD (v_binfo
));
439 v_offset
= build1 (NOP_EXPR
,
440 build_pointer_type (ptrdiff_type_node
),
442 v_offset
= cp_build_indirect_ref (v_offset
, RO_NULL
, complain
);
443 TREE_CONSTANT (v_offset
) = 1;
445 offset
= convert_to_integer (ptrdiff_type_node
,
446 size_diffop_loc (input_location
, offset
,
447 BINFO_OFFSET (v_binfo
)));
449 if (!integer_zerop (offset
))
450 v_offset
= build2 (code
, ptrdiff_type_node
, v_offset
, offset
);
452 if (fixed_type_p
< 0)
453 /* Negative fixed_type_p means this is a constructor or destructor;
454 virtual base layout is fixed in in-charge [cd]tors, but not in
456 offset
= build3 (COND_EXPR
, ptrdiff_type_node
,
457 build2 (EQ_EXPR
, boolean_type_node
,
458 current_in_charge_parm
, integer_zero_node
),
460 convert_to_integer (ptrdiff_type_node
,
461 BINFO_OFFSET (binfo
)));
467 target_type
= ptr_target_type
;
469 expr
= build1 (NOP_EXPR
, ptr_target_type
, expr
);
471 if (!integer_zerop (offset
))
473 offset
= fold_convert (sizetype
, offset
);
474 if (code
== MINUS_EXPR
)
475 offset
= fold_build1_loc (input_location
, NEGATE_EXPR
, sizetype
, offset
);
476 expr
= fold_build_pointer_plus (expr
, offset
);
482 expr
= cp_build_indirect_ref (expr
, RO_NULL
, complain
);
486 expr
= fold_build3_loc (input_location
, COND_EXPR
, target_type
, null_test
, expr
,
487 build_zero_cst (target_type
));
492 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
493 Perform a derived-to-base conversion by recursively building up a
494 sequence of COMPONENT_REFs to the appropriate base fields. */
497 build_simple_base_path (tree expr
, tree binfo
)
499 tree type
= BINFO_TYPE (binfo
);
500 tree d_binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
503 if (d_binfo
== NULL_TREE
)
507 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)) == type
);
509 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
510 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
511 an lvalue in the front end; only _DECLs and _REFs are lvalues
513 temp
= unary_complex_lvalue (ADDR_EXPR
, expr
);
515 expr
= cp_build_indirect_ref (temp
, RO_NULL
, tf_warning_or_error
);
521 expr
= build_simple_base_path (expr
, d_binfo
);
523 for (field
= TYPE_FIELDS (BINFO_TYPE (d_binfo
));
524 field
; field
= DECL_CHAIN (field
))
525 /* Is this the base field created by build_base_field? */
526 if (TREE_CODE (field
) == FIELD_DECL
527 && DECL_FIELD_IS_BASE (field
)
528 && TREE_TYPE (field
) == type
529 /* If we're looking for a field in the most-derived class,
530 also check the field offset; we can have two base fields
531 of the same type if one is an indirect virtual base and one
532 is a direct non-virtual base. */
533 && (BINFO_INHERITANCE_CHAIN (d_binfo
)
534 || tree_int_cst_equal (byte_position (field
),
535 BINFO_OFFSET (binfo
))))
537 /* We don't use build_class_member_access_expr here, as that
538 has unnecessary checks, and more importantly results in
539 recursive calls to dfs_walk_once. */
540 int type_quals
= cp_type_quals (TREE_TYPE (expr
));
542 expr
= build3 (COMPONENT_REF
,
543 cp_build_qualified_type (type
, type_quals
),
544 expr
, field
, NULL_TREE
);
545 expr
= fold_if_not_in_template (expr
);
547 /* Mark the expression const or volatile, as appropriate.
548 Even though we've dealt with the type above, we still have
549 to mark the expression itself. */
550 if (type_quals
& TYPE_QUAL_CONST
)
551 TREE_READONLY (expr
) = 1;
552 if (type_quals
& TYPE_QUAL_VOLATILE
)
553 TREE_THIS_VOLATILE (expr
) = 1;
558 /* Didn't find the base field?!? */
562 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
563 type is a class type or a pointer to a class type. In the former
564 case, TYPE is also a class type; in the latter it is another
565 pointer type. If CHECK_ACCESS is true, an error message is emitted
566 if TYPE is inaccessible. If OBJECT has pointer type, the value is
567 assumed to be non-NULL. */
570 convert_to_base (tree object
, tree type
, bool check_access
, bool nonnull
,
571 tsubst_flags_t complain
)
576 if (TYPE_PTR_P (TREE_TYPE (object
)))
578 object_type
= TREE_TYPE (TREE_TYPE (object
));
579 type
= TREE_TYPE (type
);
582 object_type
= TREE_TYPE (object
);
584 binfo
= lookup_base (object_type
, type
, check_access
? ba_check
: ba_unique
,
586 if (!binfo
|| binfo
== error_mark_node
)
587 return error_mark_node
;
589 return build_base_path (PLUS_EXPR
, object
, binfo
, nonnull
, complain
);
592 /* EXPR is an expression with unqualified class type. BASE is a base
593 binfo of that class type. Returns EXPR, converted to the BASE
594 type. This function assumes that EXPR is the most derived class;
595 therefore virtual bases can be found at their static offsets. */
598 convert_to_base_statically (tree expr
, tree base
)
602 expr_type
= TREE_TYPE (expr
);
603 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base
), expr_type
))
605 /* If this is a non-empty base, use a COMPONENT_REF. */
606 if (!is_empty_class (BINFO_TYPE (base
)))
607 return build_simple_base_path (expr
, base
);
609 /* We use fold_build2 and fold_convert below to simplify the trees
610 provided to the optimizers. It is not safe to call these functions
611 when processing a template because they do not handle C++-specific
613 gcc_assert (!processing_template_decl
);
614 expr
= cp_build_addr_expr (expr
, tf_warning_or_error
);
615 if (!integer_zerop (BINFO_OFFSET (base
)))
616 expr
= fold_build_pointer_plus_loc (input_location
,
617 expr
, BINFO_OFFSET (base
));
618 expr
= fold_convert (build_pointer_type (BINFO_TYPE (base
)), expr
);
619 expr
= build_fold_indirect_ref_loc (input_location
, expr
);
627 build_vfield_ref (tree datum
, tree type
)
629 tree vfield
, vcontext
;
631 if (datum
== error_mark_node
632 /* Can happen in case of duplicate base types (c++/59082). */
633 || !TYPE_VFIELD (type
))
634 return error_mark_node
;
636 /* First, convert to the requested type. */
637 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum
), type
))
638 datum
= convert_to_base (datum
, type
, /*check_access=*/false,
639 /*nonnull=*/true, tf_warning_or_error
);
641 /* Second, the requested type may not be the owner of its own vptr.
642 If not, convert to the base class that owns it. We cannot use
643 convert_to_base here, because VCONTEXT may appear more than once
644 in the inheritance hierarchy of TYPE, and thus direct conversion
645 between the types may be ambiguous. Following the path back up
646 one step at a time via primary bases avoids the problem. */
647 vfield
= TYPE_VFIELD (type
);
648 vcontext
= DECL_CONTEXT (vfield
);
649 while (!same_type_ignoring_top_level_qualifiers_p (vcontext
, type
))
651 datum
= build_simple_base_path (datum
, CLASSTYPE_PRIMARY_BINFO (type
));
652 type
= TREE_TYPE (datum
);
655 return build3 (COMPONENT_REF
, TREE_TYPE (vfield
), datum
, vfield
, NULL_TREE
);
658 /* Given an object INSTANCE, return an expression which yields the
659 vtable element corresponding to INDEX. There are many special
660 cases for INSTANCE which we take care of here, mainly to avoid
661 creating extra tree nodes when we don't have to. */
664 build_vtbl_ref_1 (tree instance
, tree idx
)
667 tree vtbl
= NULL_TREE
;
669 /* Try to figure out what a reference refers to, and
670 access its virtual function table directly. */
673 tree fixed_type
= fixed_type_or_null (instance
, NULL
, &cdtorp
);
675 tree basetype
= non_reference (TREE_TYPE (instance
));
677 if (fixed_type
&& !cdtorp
)
679 tree binfo
= lookup_base (fixed_type
, basetype
,
680 ba_unique
, NULL
, tf_none
);
681 if (binfo
&& binfo
!= error_mark_node
)
682 vtbl
= unshare_expr (BINFO_VTABLE (binfo
));
686 vtbl
= build_vfield_ref (instance
, basetype
);
688 aref
= build_array_ref (input_location
, vtbl
, idx
);
689 TREE_CONSTANT (aref
) |= TREE_CONSTANT (vtbl
) && TREE_CONSTANT (idx
);
695 build_vtbl_ref (tree instance
, tree idx
)
697 tree aref
= build_vtbl_ref_1 (instance
, idx
);
702 /* Given a stable object pointer INSTANCE_PTR, return an expression which
703 yields a function pointer corresponding to vtable element INDEX. */
706 build_vfn_ref (tree instance_ptr
, tree idx
)
710 aref
= build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr
, RO_NULL
,
711 tf_warning_or_error
),
714 /* When using function descriptors, the address of the
715 vtable entry is treated as a function pointer. */
716 if (TARGET_VTABLE_USES_DESCRIPTORS
)
717 aref
= build1 (NOP_EXPR
, TREE_TYPE (aref
),
718 cp_build_addr_expr (aref
, tf_warning_or_error
));
720 /* Remember this as a method reference, for later devirtualization. */
721 aref
= build3 (OBJ_TYPE_REF
, TREE_TYPE (aref
), aref
, instance_ptr
, idx
);
726 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
727 for the given TYPE. */
730 get_vtable_name (tree type
)
732 return mangle_vtbl_for_type (type
);
735 /* DECL is an entity associated with TYPE, like a virtual table or an
736 implicitly generated constructor. Determine whether or not DECL
737 should have external or internal linkage at the object file
738 level. This routine does not deal with COMDAT linkage and other
739 similar complexities; it simply sets TREE_PUBLIC if it possible for
740 entities in other translation units to contain copies of DECL, in
744 set_linkage_according_to_type (tree
/*type*/, tree decl
)
746 TREE_PUBLIC (decl
) = 1;
747 determine_visibility (decl
);
750 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
751 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
752 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
755 build_vtable (tree class_type
, tree name
, tree vtable_type
)
759 decl
= build_lang_decl (VAR_DECL
, name
, vtable_type
);
760 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
761 now to avoid confusion in mangle_decl. */
762 SET_DECL_ASSEMBLER_NAME (decl
, name
);
763 DECL_CONTEXT (decl
) = class_type
;
764 DECL_ARTIFICIAL (decl
) = 1;
765 TREE_STATIC (decl
) = 1;
766 TREE_READONLY (decl
) = 1;
767 DECL_VIRTUAL_P (decl
) = 1;
768 DECL_ALIGN (decl
) = TARGET_VTABLE_ENTRY_ALIGN
;
769 DECL_USER_ALIGN (decl
) = true;
770 DECL_VTABLE_OR_VTT_P (decl
) = 1;
771 set_linkage_according_to_type (class_type
, decl
);
772 /* The vtable has not been defined -- yet. */
773 DECL_EXTERNAL (decl
) = 1;
774 DECL_NOT_REALLY_EXTERN (decl
) = 1;
776 /* Mark the VAR_DECL node representing the vtable itself as a
777 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
778 is rather important that such things be ignored because any
779 effort to actually generate DWARF for them will run into
780 trouble when/if we encounter code like:
783 struct S { virtual void member (); };
785 because the artificial declaration of the vtable itself (as
786 manufactured by the g++ front end) will say that the vtable is
787 a static member of `S' but only *after* the debug output for
788 the definition of `S' has already been output. This causes
789 grief because the DWARF entry for the definition of the vtable
790 will try to refer back to an earlier *declaration* of the
791 vtable as a static member of `S' and there won't be one. We
792 might be able to arrange to have the "vtable static member"
793 attached to the member list for `S' before the debug info for
794 `S' get written (which would solve the problem) but that would
795 require more intrusive changes to the g++ front end. */
796 DECL_IGNORED_P (decl
) = 1;
801 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
802 or even complete. If this does not exist, create it. If COMPLETE is
803 nonzero, then complete the definition of it -- that will render it
804 impossible to actually build the vtable, but is useful to get at those
805 which are known to exist in the runtime. */
808 get_vtable_decl (tree type
, int complete
)
812 if (CLASSTYPE_VTABLES (type
))
813 return CLASSTYPE_VTABLES (type
);
815 decl
= build_vtable (type
, get_vtable_name (type
), vtbl_type_node
);
816 CLASSTYPE_VTABLES (type
) = decl
;
820 DECL_EXTERNAL (decl
) = 1;
821 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
827 /* Build the primary virtual function table for TYPE. If BINFO is
828 non-NULL, build the vtable starting with the initial approximation
829 that it is the same as the one which is the head of the association
830 list. Returns a nonzero value if a new vtable is actually
834 build_primary_vtable (tree binfo
, tree type
)
839 decl
= get_vtable_decl (type
, /*complete=*/0);
843 if (BINFO_NEW_VTABLE_MARKED (binfo
))
844 /* We have already created a vtable for this base, so there's
845 no need to do it again. */
848 virtuals
= copy_list (BINFO_VIRTUALS (binfo
));
849 TREE_TYPE (decl
) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo
));
850 DECL_SIZE (decl
) = TYPE_SIZE (TREE_TYPE (decl
));
851 DECL_SIZE_UNIT (decl
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
855 gcc_assert (TREE_TYPE (decl
) == vtbl_type_node
);
856 virtuals
= NULL_TREE
;
859 if (GATHER_STATISTICS
)
862 n_vtable_elems
+= list_length (virtuals
);
865 /* Initialize the association list for this type, based
866 on our first approximation. */
867 BINFO_VTABLE (TYPE_BINFO (type
)) = decl
;
868 BINFO_VIRTUALS (TYPE_BINFO (type
)) = virtuals
;
869 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type
));
873 /* Give BINFO a new virtual function table which is initialized
874 with a skeleton-copy of its original initialization. The only
875 entry that changes is the `delta' entry, so we can really
876 share a lot of structure.
878 FOR_TYPE is the most derived type which caused this table to
881 Returns nonzero if we haven't met BINFO before.
883 The order in which vtables are built (by calling this function) for
884 an object must remain the same, otherwise a binary incompatibility
888 build_secondary_vtable (tree binfo
)
890 if (BINFO_NEW_VTABLE_MARKED (binfo
))
891 /* We already created a vtable for this base. There's no need to
895 /* Remember that we've created a vtable for this BINFO, so that we
896 don't try to do so again. */
897 SET_BINFO_NEW_VTABLE_MARKED (binfo
);
899 /* Make fresh virtual list, so we can smash it later. */
900 BINFO_VIRTUALS (binfo
) = copy_list (BINFO_VIRTUALS (binfo
));
902 /* Secondary vtables are laid out as part of the same structure as
903 the primary vtable. */
904 BINFO_VTABLE (binfo
) = NULL_TREE
;
908 /* Create a new vtable for BINFO which is the hierarchy dominated by
909 T. Return nonzero if we actually created a new vtable. */
912 make_new_vtable (tree t
, tree binfo
)
914 if (binfo
== TYPE_BINFO (t
))
915 /* In this case, it is *type*'s vtable we are modifying. We start
916 with the approximation that its vtable is that of the
917 immediate base class. */
918 return build_primary_vtable (binfo
, t
);
920 /* This is our very own copy of `basetype' to play with. Later,
921 we will fill in all the virtual functions that override the
922 virtual functions in these base classes which are not defined
923 by the current type. */
924 return build_secondary_vtable (binfo
);
927 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
928 (which is in the hierarchy dominated by T) list FNDECL as its
929 BV_FN. DELTA is the required constant adjustment from the `this'
930 pointer where the vtable entry appears to the `this' required when
931 the function is actually called. */
934 modify_vtable_entry (tree t
,
944 if (fndecl
!= BV_FN (v
)
945 || !tree_int_cst_equal (delta
, BV_DELTA (v
)))
947 /* We need a new vtable for BINFO. */
948 if (make_new_vtable (t
, binfo
))
950 /* If we really did make a new vtable, we also made a copy
951 of the BINFO_VIRTUALS list. Now, we have to find the
952 corresponding entry in that list. */
953 *virtuals
= BINFO_VIRTUALS (binfo
);
954 while (BV_FN (*virtuals
) != BV_FN (v
))
955 *virtuals
= TREE_CHAIN (*virtuals
);
959 BV_DELTA (v
) = delta
;
960 BV_VCALL_INDEX (v
) = NULL_TREE
;
966 /* Add method METHOD to class TYPE. If USING_DECL is non-null, it is
967 the USING_DECL naming METHOD. Returns true if the method could be
968 added to the method vec. */
971 add_method (tree type
, tree method
, tree using_decl
)
975 bool template_conv_p
= false;
977 vec
<tree
, va_gc
> *method_vec
;
979 bool insert_p
= false;
983 if (method
== error_mark_node
)
986 complete_p
= COMPLETE_TYPE_P (type
);
987 conv_p
= DECL_CONV_FN_P (method
);
989 template_conv_p
= (TREE_CODE (method
) == TEMPLATE_DECL
990 && DECL_TEMPLATE_CONV_FN_P (method
));
992 method_vec
= CLASSTYPE_METHOD_VEC (type
);
995 /* Make a new method vector. We start with 8 entries. We must
996 allocate at least two (for constructors and destructors), and
997 we're going to end up with an assignment operator at some
999 vec_alloc (method_vec
, 8);
1000 /* Create slots for constructors and destructors. */
1001 method_vec
->quick_push (NULL_TREE
);
1002 method_vec
->quick_push (NULL_TREE
);
1003 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
1006 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
1007 grok_special_member_properties (method
);
1009 /* Constructors and destructors go in special slots. */
1010 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method
))
1011 slot
= CLASSTYPE_CONSTRUCTOR_SLOT
;
1012 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
1014 slot
= CLASSTYPE_DESTRUCTOR_SLOT
;
1016 if (TYPE_FOR_JAVA (type
))
1018 if (!DECL_ARTIFICIAL (method
))
1019 error ("Java class %qT cannot have a destructor", type
);
1020 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
1021 error ("Java class %qT cannot have an implicit non-trivial "
1031 /* See if we already have an entry with this name. */
1032 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
1033 vec_safe_iterate (method_vec
, slot
, &m
);
1036 m
= OVL_CURRENT (m
);
1037 if (template_conv_p
)
1039 if (TREE_CODE (m
) == TEMPLATE_DECL
1040 && DECL_TEMPLATE_CONV_FN_P (m
))
1044 if (conv_p
&& !DECL_CONV_FN_P (m
))
1046 if (DECL_NAME (m
) == DECL_NAME (method
))
1052 && !DECL_CONV_FN_P (m
)
1053 && DECL_NAME (m
) > DECL_NAME (method
))
1057 current_fns
= insert_p
? NULL_TREE
: (*method_vec
)[slot
];
1059 /* Check to see if we've already got this method. */
1060 for (fns
= current_fns
; fns
; fns
= OVL_NEXT (fns
))
1062 tree fn
= OVL_CURRENT (fns
);
1068 if (TREE_CODE (fn
) != TREE_CODE (method
))
1071 /* [over.load] Member function declarations with the
1072 same name and the same parameter types cannot be
1073 overloaded if any of them is a static member
1074 function declaration.
1076 [over.load] Member function declarations with the same name and
1077 the same parameter-type-list as well as member function template
1078 declarations with the same name, the same parameter-type-list, and
1079 the same template parameter lists cannot be overloaded if any of
1080 them, but not all, have a ref-qualifier.
1082 [namespace.udecl] When a using-declaration brings names
1083 from a base class into a derived class scope, member
1084 functions in the derived class override and/or hide member
1085 functions with the same name and parameter types in a base
1086 class (rather than conflicting). */
1087 fn_type
= TREE_TYPE (fn
);
1088 method_type
= TREE_TYPE (method
);
1089 parms1
= TYPE_ARG_TYPES (fn_type
);
1090 parms2
= TYPE_ARG_TYPES (method_type
);
1092 /* Compare the quals on the 'this' parm. Don't compare
1093 the whole types, as used functions are treated as
1094 coming from the using class in overload resolution. */
1095 if (! DECL_STATIC_FUNCTION_P (fn
)
1096 && ! DECL_STATIC_FUNCTION_P (method
)
1097 /* Either both or neither need to be ref-qualified for
1098 differing quals to allow overloading. */
1099 && (FUNCTION_REF_QUALIFIED (fn_type
)
1100 == FUNCTION_REF_QUALIFIED (method_type
))
1101 && (type_memfn_quals (fn_type
) != type_memfn_quals (method_type
)
1102 || type_memfn_rqual (fn_type
) != type_memfn_rqual (method_type
)))
1105 /* For templates, the return type and template parameters
1106 must be identical. */
1107 if (TREE_CODE (fn
) == TEMPLATE_DECL
1108 && (!same_type_p (TREE_TYPE (fn_type
),
1109 TREE_TYPE (method_type
))
1110 || !comp_template_parms (DECL_TEMPLATE_PARMS (fn
),
1111 DECL_TEMPLATE_PARMS (method
))))
1114 if (! DECL_STATIC_FUNCTION_P (fn
))
1115 parms1
= TREE_CHAIN (parms1
);
1116 if (! DECL_STATIC_FUNCTION_P (method
))
1117 parms2
= TREE_CHAIN (parms2
);
1119 if (compparms (parms1
, parms2
)
1120 && (!DECL_CONV_FN_P (fn
)
1121 || same_type_p (TREE_TYPE (fn_type
),
1122 TREE_TYPE (method_type
))))
1124 /* For function versions, their parms and types match
1125 but they are not duplicates. Record function versions
1126 as and when they are found. extern "C" functions are
1127 not treated as versions. */
1128 if (TREE_CODE (fn
) == FUNCTION_DECL
1129 && TREE_CODE (method
) == FUNCTION_DECL
1130 && !DECL_EXTERN_C_P (fn
)
1131 && !DECL_EXTERN_C_P (method
)
1132 && targetm
.target_option
.function_versions (fn
, method
))
1134 /* Mark functions as versions if necessary. Modify the mangled
1135 decl name if necessary. */
1136 if (!DECL_FUNCTION_VERSIONED (fn
))
1138 DECL_FUNCTION_VERSIONED (fn
) = 1;
1139 if (DECL_ASSEMBLER_NAME_SET_P (fn
))
1142 if (!DECL_FUNCTION_VERSIONED (method
))
1144 DECL_FUNCTION_VERSIONED (method
) = 1;
1145 if (DECL_ASSEMBLER_NAME_SET_P (method
))
1146 mangle_decl (method
);
1148 cgraph_node::record_function_versions (fn
, method
);
1151 if (DECL_INHERITED_CTOR_BASE (method
))
1153 if (DECL_INHERITED_CTOR_BASE (fn
))
1155 error_at (DECL_SOURCE_LOCATION (method
),
1156 "%q#D inherited from %qT", method
,
1157 DECL_INHERITED_CTOR_BASE (method
));
1158 error_at (DECL_SOURCE_LOCATION (fn
),
1159 "conflicts with version inherited from %qT",
1160 DECL_INHERITED_CTOR_BASE (fn
));
1162 /* Otherwise defer to the other function. */
1167 if (DECL_CONTEXT (fn
) == type
)
1168 /* Defer to the local function. */
1173 error ("%q+#D cannot be overloaded", method
);
1174 error ("with %q+#D", fn
);
1177 /* We don't call duplicate_decls here to merge the
1178 declarations because that will confuse things if the
1179 methods have inline definitions. In particular, we
1180 will crash while processing the definitions. */
1185 /* A class should never have more than one destructor. */
1186 if (current_fns
&& DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method
))
1189 /* Add the new binding. */
1192 overload
= ovl_cons (method
, current_fns
);
1193 OVL_USED (overload
) = true;
1196 overload
= build_overload (method
, current_fns
);
1199 TYPE_HAS_CONVERSION (type
) = 1;
1200 else if (slot
>= CLASSTYPE_FIRST_CONVERSION_SLOT
&& !complete_p
)
1201 push_class_level_binding (DECL_NAME (method
), overload
);
1207 /* We only expect to add few methods in the COMPLETE_P case, so
1208 just make room for one more method in that case. */
1210 reallocated
= vec_safe_reserve_exact (method_vec
, 1);
1212 reallocated
= vec_safe_reserve (method_vec
, 1);
1214 CLASSTYPE_METHOD_VEC (type
) = method_vec
;
1215 if (slot
== method_vec
->length ())
1216 method_vec
->quick_push (overload
);
1218 method_vec
->quick_insert (slot
, overload
);
1221 /* Replace the current slot. */
1222 (*method_vec
)[slot
] = overload
;
1226 /* Subroutines of finish_struct. */
1228 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1229 legit, otherwise return 0. */
1232 alter_access (tree t
, tree fdecl
, tree access
)
1236 if (!DECL_LANG_SPECIFIC (fdecl
))
1237 retrofit_lang_decl (fdecl
);
1239 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl
));
1241 elem
= purpose_member (t
, DECL_ACCESS (fdecl
));
1244 if (TREE_VALUE (elem
) != access
)
1246 if (TREE_CODE (TREE_TYPE (fdecl
)) == FUNCTION_DECL
)
1247 error ("conflicting access specifications for method"
1248 " %q+D, ignored", TREE_TYPE (fdecl
));
1250 error ("conflicting access specifications for field %qE, ignored",
1255 /* They're changing the access to the same thing they changed
1256 it to before. That's OK. */
1262 perform_or_defer_access_check (TYPE_BINFO (t
), fdecl
, fdecl
,
1263 tf_warning_or_error
);
1264 DECL_ACCESS (fdecl
) = tree_cons (t
, access
, DECL_ACCESS (fdecl
));
1270 /* Process the USING_DECL, which is a member of T. */
1273 handle_using_decl (tree using_decl
, tree t
)
1275 tree decl
= USING_DECL_DECLS (using_decl
);
1276 tree name
= DECL_NAME (using_decl
);
1278 = TREE_PRIVATE (using_decl
) ? access_private_node
1279 : TREE_PROTECTED (using_decl
) ? access_protected_node
1280 : access_public_node
;
1281 tree flist
= NULL_TREE
;
1284 gcc_assert (!processing_template_decl
&& decl
);
1286 old_value
= lookup_member (t
, name
, /*protect=*/0, /*want_type=*/false,
1287 tf_warning_or_error
);
1290 if (is_overloaded_fn (old_value
))
1291 old_value
= OVL_CURRENT (old_value
);
1293 if (DECL_P (old_value
) && DECL_CONTEXT (old_value
) == t
)
1296 old_value
= NULL_TREE
;
1299 cp_emit_debug_info_for_using (decl
, t
);
1301 if (is_overloaded_fn (decl
))
1306 else if (is_overloaded_fn (old_value
))
1309 /* It's OK to use functions from a base when there are functions with
1310 the same name already present in the current class. */;
1313 error ("%q+D invalid in %q#T", using_decl
, t
);
1314 error (" because of local method %q+#D with same name",
1315 OVL_CURRENT (old_value
));
1319 else if (!DECL_ARTIFICIAL (old_value
))
1321 error ("%q+D invalid in %q#T", using_decl
, t
);
1322 error (" because of local member %q+#D with same name", old_value
);
1326 /* Make type T see field decl FDECL with access ACCESS. */
1328 for (; flist
; flist
= OVL_NEXT (flist
))
1330 add_method (t
, OVL_CURRENT (flist
), using_decl
);
1331 alter_access (t
, OVL_CURRENT (flist
), access
);
1334 alter_access (t
, decl
, access
);
1337 /* walk_tree callback for check_abi_tags: if the type at *TP involves any
1338 types with abi tags, add the corresponding identifiers to the VEC in
1339 *DATA and set IDENTIFIER_MARKED. */
1345 // error_mark_node to get diagnostics; otherwise collect missing tags here
1350 find_abi_tags_r (tree
*tp
, int *walk_subtrees
, void *data
)
1352 if (!OVERLOAD_TYPE_P (*tp
))
1355 /* walk_tree shouldn't be walking into any subtrees of a RECORD_TYPE
1356 anyway, but let's make sure of it. */
1357 *walk_subtrees
= false;
1359 if (tree attributes
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (*tp
)))
1361 struct abi_tag_data
*p
= static_cast<struct abi_tag_data
*>(data
);
1362 for (tree list
= TREE_VALUE (attributes
); list
;
1363 list
= TREE_CHAIN (list
))
1365 tree tag
= TREE_VALUE (list
);
1366 tree id
= get_identifier (TREE_STRING_POINTER (tag
));
1367 if (!IDENTIFIER_MARKED (id
))
1369 if (p
->tags
!= error_mark_node
)
1371 /* We're collecting tags from template arguments. */
1372 tree str
= build_string (IDENTIFIER_LENGTH (id
),
1373 IDENTIFIER_POINTER (id
));
1374 p
->tags
= tree_cons (NULL_TREE
, str
, p
->tags
);
1375 ABI_TAG_IMPLICIT (p
->tags
) = true;
1377 /* Don't inherit this tag multiple times. */
1378 IDENTIFIER_MARKED (id
) = true;
1381 /* Otherwise we're diagnosing missing tags. */
1382 else if (TYPE_P (p
->subob
))
1384 if (warning (OPT_Wabi_tag
, "%qT does not have the %E abi tag "
1385 "that base %qT has", p
->t
, tag
, p
->subob
))
1386 inform (location_of (p
->subob
), "%qT declared here",
1391 if (warning (OPT_Wabi_tag
, "%qT does not have the %E abi tag "
1392 "that %qT (used in the type of %qD) has",
1393 p
->t
, tag
, *tp
, p
->subob
))
1395 inform (location_of (p
->subob
), "%qD declared here",
1397 inform (location_of (*tp
), "%qT declared here", *tp
);
1406 /* Set IDENTIFIER_MARKED on all the ABI tags on T and its (transitively
1407 complete) template arguments. */
1410 mark_type_abi_tags (tree t
, bool val
)
1412 tree attributes
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (t
));
1415 for (tree list
= TREE_VALUE (attributes
); list
;
1416 list
= TREE_CHAIN (list
))
1418 tree tag
= TREE_VALUE (list
);
1419 tree id
= get_identifier (TREE_STRING_POINTER (tag
));
1420 IDENTIFIER_MARKED (id
) = val
;
1425 /* Check that class T has all the abi tags that subobject SUBOB has, or
1429 check_abi_tags (tree t
, tree subob
)
1431 mark_type_abi_tags (t
, true);
1433 tree subtype
= TYPE_P (subob
) ? subob
: TREE_TYPE (subob
);
1434 struct abi_tag_data data
= { t
, subob
, error_mark_node
};
1436 cp_walk_tree_without_duplicates (&subtype
, find_abi_tags_r
, &data
);
1438 mark_type_abi_tags (t
, false);
1442 inherit_targ_abi_tags (tree t
)
1444 if (CLASSTYPE_TEMPLATE_INFO (t
) == NULL_TREE
)
1447 mark_type_abi_tags (t
, true);
1449 tree args
= CLASSTYPE_TI_ARGS (t
);
1450 struct abi_tag_data data
= { t
, NULL_TREE
, NULL_TREE
};
1451 for (int i
= 0; i
< TMPL_ARGS_DEPTH (args
); ++i
)
1453 tree level
= TMPL_ARGS_LEVEL (args
, i
+1);
1454 for (int j
= 0; j
< TREE_VEC_LENGTH (level
); ++j
)
1456 tree arg
= TREE_VEC_ELT (level
, j
);
1458 cp_walk_tree_without_duplicates (&arg
, find_abi_tags_r
, &data
);
1462 // If we found some tags on our template arguments, add them to our
1463 // abi_tag attribute.
1466 tree attr
= lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (t
));
1468 TREE_VALUE (attr
) = chainon (data
.tags
, TREE_VALUE (attr
));
1471 = tree_cons (get_identifier ("abi_tag"), data
.tags
,
1472 TYPE_ATTRIBUTES (t
));
1475 mark_type_abi_tags (t
, false);
1478 /* Return true, iff class T has a non-virtual destructor that is
1479 accessible from outside the class heirarchy (i.e. is public, or
1480 there's a suitable friend. */
1483 accessible_nvdtor_p (tree t
)
1485 tree dtor
= CLASSTYPE_DESTRUCTORS (t
);
1487 /* An implicitly declared destructor is always public. And,
1488 if it were virtual, we would have created it by now. */
1492 if (DECL_VINDEX (dtor
))
1493 return false; /* Virtual */
1495 if (!TREE_PRIVATE (dtor
) && !TREE_PROTECTED (dtor
))
1496 return true; /* Public */
1498 if (CLASSTYPE_FRIEND_CLASSES (t
)
1499 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
1500 return true; /* Has friends */
1505 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1506 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1507 properties of the bases. */
1510 check_bases (tree t
,
1511 int* cant_have_const_ctor_p
,
1512 int* no_const_asn_ref_p
)
1515 bool seen_non_virtual_nearly_empty_base_p
= 0;
1516 int seen_tm_mask
= 0;
1519 tree field
= NULL_TREE
;
1521 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1522 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
1523 if (TREE_CODE (field
) == FIELD_DECL
)
1526 for (binfo
= TYPE_BINFO (t
), i
= 0;
1527 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1529 tree basetype
= TREE_TYPE (base_binfo
);
1531 gcc_assert (COMPLETE_TYPE_P (basetype
));
1533 if (CLASSTYPE_FINAL (basetype
))
1534 error ("cannot derive from %<final%> base %qT in derived type %qT",
1537 /* If any base class is non-literal, so is the derived class. */
1538 if (!CLASSTYPE_LITERAL_P (basetype
))
1539 CLASSTYPE_LITERAL_P (t
) = false;
1541 /* If the base class doesn't have copy constructors or
1542 assignment operators that take const references, then the
1543 derived class cannot have such a member automatically
1545 if (TYPE_HAS_COPY_CTOR (basetype
)
1546 && ! TYPE_HAS_CONST_COPY_CTOR (basetype
))
1547 *cant_have_const_ctor_p
= 1;
1548 if (TYPE_HAS_COPY_ASSIGN (basetype
)
1549 && !TYPE_HAS_CONST_COPY_ASSIGN (basetype
))
1550 *no_const_asn_ref_p
= 1;
1552 if (BINFO_VIRTUAL_P (base_binfo
))
1553 /* A virtual base does not effect nearly emptiness. */
1555 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype
))
1557 if (seen_non_virtual_nearly_empty_base_p
)
1558 /* And if there is more than one nearly empty base, then the
1559 derived class is not nearly empty either. */
1560 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1562 /* Remember we've seen one. */
1563 seen_non_virtual_nearly_empty_base_p
= 1;
1565 else if (!is_empty_class (basetype
))
1566 /* If the base class is not empty or nearly empty, then this
1567 class cannot be nearly empty. */
1568 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
1570 /* A lot of properties from the bases also apply to the derived
1572 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (basetype
);
1573 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1574 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype
);
1575 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
)
1576 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (basetype
)
1577 || !TYPE_HAS_COPY_ASSIGN (basetype
));
1578 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= (TYPE_HAS_COMPLEX_COPY_CTOR (basetype
)
1579 || !TYPE_HAS_COPY_CTOR (basetype
));
1580 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
1581 |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (basetype
);
1582 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_HAS_COMPLEX_MOVE_CTOR (basetype
);
1583 TYPE_POLYMORPHIC_P (t
) |= TYPE_POLYMORPHIC_P (basetype
);
1584 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
)
1585 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype
);
1586 TYPE_HAS_COMPLEX_DFLT (t
) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype
)
1587 || TYPE_HAS_COMPLEX_DFLT (basetype
));
1588 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT
1589 (t
, CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
1590 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (basetype
));
1591 SET_CLASSTYPE_REF_FIELDS_NEED_INIT
1592 (t
, CLASSTYPE_REF_FIELDS_NEED_INIT (t
)
1593 | CLASSTYPE_REF_FIELDS_NEED_INIT (basetype
));
1595 /* A standard-layout class is a class that:
1597 * has no non-standard-layout base classes, */
1598 CLASSTYPE_NON_STD_LAYOUT (t
) |= CLASSTYPE_NON_STD_LAYOUT (basetype
);
1599 if (!CLASSTYPE_NON_STD_LAYOUT (t
))
1602 /* ...has no base classes of the same type as the first non-static
1604 if (field
&& DECL_CONTEXT (field
) == t
1605 && (same_type_ignoring_top_level_qualifiers_p
1606 (TREE_TYPE (field
), basetype
)))
1607 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1609 /* ...either has no non-static data members in the most-derived
1610 class and at most one base class with non-static data
1611 members, or has no base classes with non-static data
1613 for (basefield
= TYPE_FIELDS (basetype
); basefield
;
1614 basefield
= DECL_CHAIN (basefield
))
1615 if (TREE_CODE (basefield
) == FIELD_DECL
)
1618 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
1625 /* Don't bother collecting tm attributes if transactional memory
1626 support is not enabled. */
1629 tree tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (basetype
));
1631 seen_tm_mask
|= tm_attr_to_mask (tm_attr
);
1634 check_abi_tags (t
, basetype
);
1637 /* If one of the base classes had TM attributes, and the current class
1638 doesn't define its own, then the current class inherits one. */
1639 if (seen_tm_mask
&& !find_tm_attribute (TYPE_ATTRIBUTES (t
)))
1641 tree tm_attr
= tm_mask_to_attr (seen_tm_mask
& -seen_tm_mask
);
1642 TYPE_ATTRIBUTES (t
) = tree_cons (tm_attr
, NULL
, TYPE_ATTRIBUTES (t
));
1646 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1647 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1648 that have had a nearly-empty virtual primary base stolen by some
1649 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1653 determine_primary_bases (tree t
)
1656 tree primary
= NULL_TREE
;
1657 tree type_binfo
= TYPE_BINFO (t
);
1660 /* Determine the primary bases of our bases. */
1661 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1662 base_binfo
= TREE_CHAIN (base_binfo
))
1664 tree primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo
));
1666 /* See if we're the non-virtual primary of our inheritance
1668 if (!BINFO_VIRTUAL_P (base_binfo
))
1670 tree parent
= BINFO_INHERITANCE_CHAIN (base_binfo
);
1671 tree parent_primary
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent
));
1674 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo
),
1675 BINFO_TYPE (parent_primary
)))
1676 /* We are the primary binfo. */
1677 BINFO_PRIMARY_P (base_binfo
) = 1;
1679 /* Determine if we have a virtual primary base, and mark it so.
1681 if (primary
&& BINFO_VIRTUAL_P (primary
))
1683 tree this_primary
= copied_binfo (primary
, base_binfo
);
1685 if (BINFO_PRIMARY_P (this_primary
))
1686 /* Someone already claimed this base. */
1687 BINFO_LOST_PRIMARY_P (base_binfo
) = 1;
1692 BINFO_PRIMARY_P (this_primary
) = 1;
1693 BINFO_INHERITANCE_CHAIN (this_primary
) = base_binfo
;
1695 /* A virtual binfo might have been copied from within
1696 another hierarchy. As we're about to use it as a
1697 primary base, make sure the offsets match. */
1698 delta
= size_diffop_loc (input_location
,
1700 BINFO_OFFSET (base_binfo
)),
1702 BINFO_OFFSET (this_primary
)));
1704 propagate_binfo_offsets (this_primary
, delta
);
1709 /* First look for a dynamic direct non-virtual base. */
1710 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, base_binfo
); i
++)
1712 tree basetype
= BINFO_TYPE (base_binfo
);
1714 if (TYPE_CONTAINS_VPTR_P (basetype
) && !BINFO_VIRTUAL_P (base_binfo
))
1716 primary
= base_binfo
;
1721 /* A "nearly-empty" virtual base class can be the primary base
1722 class, if no non-virtual polymorphic base can be found. Look for
1723 a nearly-empty virtual dynamic base that is not already a primary
1724 base of something in the hierarchy. If there is no such base,
1725 just pick the first nearly-empty virtual base. */
1727 for (base_binfo
= TREE_CHAIN (type_binfo
); base_binfo
;
1728 base_binfo
= TREE_CHAIN (base_binfo
))
1729 if (BINFO_VIRTUAL_P (base_binfo
)
1730 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo
)))
1732 if (!BINFO_PRIMARY_P (base_binfo
))
1734 /* Found one that is not primary. */
1735 primary
= base_binfo
;
1739 /* Remember the first candidate. */
1740 primary
= base_binfo
;
1744 /* If we've got a primary base, use it. */
1747 tree basetype
= BINFO_TYPE (primary
);
1749 CLASSTYPE_PRIMARY_BINFO (t
) = primary
;
1750 if (BINFO_PRIMARY_P (primary
))
1751 /* We are stealing a primary base. */
1752 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary
)) = 1;
1753 BINFO_PRIMARY_P (primary
) = 1;
1754 if (BINFO_VIRTUAL_P (primary
))
1758 BINFO_INHERITANCE_CHAIN (primary
) = type_binfo
;
1759 /* A virtual binfo might have been copied from within
1760 another hierarchy. As we're about to use it as a primary
1761 base, make sure the offsets match. */
1762 delta
= size_diffop_loc (input_location
, ssize_int (0),
1763 convert (ssizetype
, BINFO_OFFSET (primary
)));
1765 propagate_binfo_offsets (primary
, delta
);
1768 primary
= TYPE_BINFO (basetype
);
1770 TYPE_VFIELD (t
) = TYPE_VFIELD (basetype
);
1771 BINFO_VTABLE (type_binfo
) = BINFO_VTABLE (primary
);
1772 BINFO_VIRTUALS (type_binfo
) = BINFO_VIRTUALS (primary
);
1776 /* Update the variant types of T. */
1779 fixup_type_variants (tree t
)
1786 for (variants
= TYPE_NEXT_VARIANT (t
);
1788 variants
= TYPE_NEXT_VARIANT (variants
))
1790 /* These fields are in the _TYPE part of the node, not in
1791 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1792 TYPE_HAS_USER_CONSTRUCTOR (variants
) = TYPE_HAS_USER_CONSTRUCTOR (t
);
1793 TYPE_NEEDS_CONSTRUCTING (variants
) = TYPE_NEEDS_CONSTRUCTING (t
);
1794 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants
)
1795 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
1797 TYPE_POLYMORPHIC_P (variants
) = TYPE_POLYMORPHIC_P (t
);
1799 TYPE_BINFO (variants
) = TYPE_BINFO (t
);
1801 /* Copy whatever these are holding today. */
1802 TYPE_VFIELD (variants
) = TYPE_VFIELD (t
);
1803 TYPE_METHODS (variants
) = TYPE_METHODS (t
);
1804 TYPE_FIELDS (variants
) = TYPE_FIELDS (t
);
1808 /* Early variant fixups: we apply attributes at the beginning of the class
1809 definition, and we need to fix up any variants that have already been
1810 made via elaborated-type-specifier so that check_qualified_type works. */
1813 fixup_attribute_variants (tree t
)
1820 for (variants
= TYPE_NEXT_VARIANT (t
);
1822 variants
= TYPE_NEXT_VARIANT (variants
))
1824 /* These are the two fields that check_qualified_type looks at and
1825 are affected by attributes. */
1826 TYPE_ATTRIBUTES (variants
) = TYPE_ATTRIBUTES (t
);
1827 TYPE_ALIGN (variants
) = TYPE_ALIGN (t
);
1831 /* Set memoizing fields and bits of T (and its variants) for later
1835 finish_struct_bits (tree t
)
1837 /* Fix up variants (if any). */
1838 fixup_type_variants (t
);
1840 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) && TYPE_POLYMORPHIC_P (t
))
1841 /* For a class w/o baseclasses, 'finish_struct' has set
1842 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1843 Similarly for a class whose base classes do not have vtables.
1844 When neither of these is true, we might have removed abstract
1845 virtuals (by providing a definition), added some (by declaring
1846 new ones), or redeclared ones from a base class. We need to
1847 recalculate what's really an abstract virtual at this point (by
1848 looking in the vtables). */
1849 get_pure_virtuals (t
);
1851 /* If this type has a copy constructor or a destructor, force its
1852 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1853 nonzero. This will cause it to be passed by invisible reference
1854 and prevent it from being returned in a register. */
1855 if (type_has_nontrivial_copy_init (t
)
1856 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
1859 DECL_MODE (TYPE_MAIN_DECL (t
)) = BLKmode
;
1860 for (variants
= t
; variants
; variants
= TYPE_NEXT_VARIANT (variants
))
1862 SET_TYPE_MODE (variants
, BLKmode
);
1863 TREE_ADDRESSABLE (variants
) = 1;
1868 /* Issue warnings about T having private constructors, but no friends,
1871 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1872 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1873 non-private static member functions. */
1876 maybe_warn_about_overly_private_class (tree t
)
1878 int has_member_fn
= 0;
1879 int has_nonprivate_method
= 0;
1882 if (!warn_ctor_dtor_privacy
1883 /* If the class has friends, those entities might create and
1884 access instances, so we should not warn. */
1885 || (CLASSTYPE_FRIEND_CLASSES (t
)
1886 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t
)))
1887 /* We will have warned when the template was declared; there's
1888 no need to warn on every instantiation. */
1889 || CLASSTYPE_TEMPLATE_INSTANTIATION (t
))
1890 /* There's no reason to even consider warning about this
1894 /* We only issue one warning, if more than one applies, because
1895 otherwise, on code like:
1898 // Oops - forgot `public:'
1904 we warn several times about essentially the same problem. */
1906 /* Check to see if all (non-constructor, non-destructor) member
1907 functions are private. (Since there are no friends or
1908 non-private statics, we can't ever call any of the private member
1910 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
1911 /* We're not interested in compiler-generated methods; they don't
1912 provide any way to call private members. */
1913 if (!DECL_ARTIFICIAL (fn
))
1915 if (!TREE_PRIVATE (fn
))
1917 if (DECL_STATIC_FUNCTION_P (fn
))
1918 /* A non-private static member function is just like a
1919 friend; it can create and invoke private member
1920 functions, and be accessed without a class
1924 has_nonprivate_method
= 1;
1925 /* Keep searching for a static member function. */
1927 else if (!DECL_CONSTRUCTOR_P (fn
) && !DECL_DESTRUCTOR_P (fn
))
1931 if (!has_nonprivate_method
&& has_member_fn
)
1933 /* There are no non-private methods, and there's at least one
1934 private member function that isn't a constructor or
1935 destructor. (If all the private members are
1936 constructors/destructors we want to use the code below that
1937 issues error messages specifically referring to
1938 constructors/destructors.) */
1940 tree binfo
= TYPE_BINFO (t
);
1942 for (i
= 0; i
!= BINFO_N_BASE_BINFOS (binfo
); i
++)
1943 if (BINFO_BASE_ACCESS (binfo
, i
) != access_private_node
)
1945 has_nonprivate_method
= 1;
1948 if (!has_nonprivate_method
)
1950 warning (OPT_Wctor_dtor_privacy
,
1951 "all member functions in class %qT are private", t
);
1956 /* Even if some of the member functions are non-private, the class
1957 won't be useful for much if all the constructors or destructors
1958 are private: such an object can never be created or destroyed. */
1959 fn
= CLASSTYPE_DESTRUCTORS (t
);
1960 if (fn
&& TREE_PRIVATE (fn
))
1962 warning (OPT_Wctor_dtor_privacy
,
1963 "%q#T only defines a private destructor and has no friends",
1968 /* Warn about classes that have private constructors and no friends. */
1969 if (TYPE_HAS_USER_CONSTRUCTOR (t
)
1970 /* Implicitly generated constructors are always public. */
1971 && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t
)
1972 || !CLASSTYPE_LAZY_COPY_CTOR (t
)))
1974 int nonprivate_ctor
= 0;
1976 /* If a non-template class does not define a copy
1977 constructor, one is defined for it, enabling it to avoid
1978 this warning. For a template class, this does not
1979 happen, and so we would normally get a warning on:
1981 template <class T> class C { private: C(); };
1983 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All
1984 complete non-template or fully instantiated classes have this
1986 if (!TYPE_HAS_COPY_CTOR (t
))
1987 nonprivate_ctor
= 1;
1989 for (fn
= CLASSTYPE_CONSTRUCTORS (t
); fn
; fn
= OVL_NEXT (fn
))
1991 tree ctor
= OVL_CURRENT (fn
);
1992 /* Ideally, we wouldn't count copy constructors (or, in
1993 fact, any constructor that takes an argument of the
1994 class type as a parameter) because such things cannot
1995 be used to construct an instance of the class unless
1996 you already have one. But, for now at least, we're
1998 if (! TREE_PRIVATE (ctor
))
2000 nonprivate_ctor
= 1;
2005 if (nonprivate_ctor
== 0)
2007 warning (OPT_Wctor_dtor_privacy
,
2008 "%q#T only defines private constructors and has no friends",
2016 gt_pointer_operator new_value
;
2020 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
2023 method_name_cmp (const void* m1_p
, const void* m2_p
)
2025 const tree
*const m1
= (const tree
*) m1_p
;
2026 const tree
*const m2
= (const tree
*) m2_p
;
2028 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
2030 if (*m1
== NULL_TREE
)
2032 if (*m2
== NULL_TREE
)
2034 if (DECL_NAME (OVL_CURRENT (*m1
)) < DECL_NAME (OVL_CURRENT (*m2
)))
2039 /* This routine compares two fields like method_name_cmp but using the
2040 pointer operator in resort_field_decl_data. */
2043 resort_method_name_cmp (const void* m1_p
, const void* m2_p
)
2045 const tree
*const m1
= (const tree
*) m1_p
;
2046 const tree
*const m2
= (const tree
*) m2_p
;
2047 if (*m1
== NULL_TREE
&& *m2
== NULL_TREE
)
2049 if (*m1
== NULL_TREE
)
2051 if (*m2
== NULL_TREE
)
2054 tree d1
= DECL_NAME (OVL_CURRENT (*m1
));
2055 tree d2
= DECL_NAME (OVL_CURRENT (*m2
));
2056 resort_data
.new_value (&d1
, resort_data
.cookie
);
2057 resort_data
.new_value (&d2
, resort_data
.cookie
);
2064 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
2067 resort_type_method_vec (void* obj
,
2069 gt_pointer_operator new_value
,
2072 vec
<tree
, va_gc
> *method_vec
= (vec
<tree
, va_gc
> *) obj
;
2073 int len
= vec_safe_length (method_vec
);
2077 /* The type conversion ops have to live at the front of the vec, so we
2079 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2080 vec_safe_iterate (method_vec
, slot
, &fn
);
2082 if (!DECL_CONV_FN_P (OVL_CURRENT (fn
)))
2087 resort_data
.new_value
= new_value
;
2088 resort_data
.cookie
= cookie
;
2089 qsort (method_vec
->address () + slot
, len
- slot
, sizeof (tree
),
2090 resort_method_name_cmp
);
2094 /* Warn about duplicate methods in fn_fields.
2096 Sort methods that are not special (i.e., constructors, destructors,
2097 and type conversion operators) so that we can find them faster in
2101 finish_struct_methods (tree t
)
2104 vec
<tree
, va_gc
> *method_vec
;
2107 method_vec
= CLASSTYPE_METHOD_VEC (t
);
2111 len
= method_vec
->length ();
2113 /* Clear DECL_IN_AGGR_P for all functions. */
2114 for (fn_fields
= TYPE_METHODS (t
); fn_fields
;
2115 fn_fields
= DECL_CHAIN (fn_fields
))
2116 DECL_IN_AGGR_P (fn_fields
) = 0;
2118 /* Issue warnings about private constructors and such. If there are
2119 no methods, then some public defaults are generated. */
2120 maybe_warn_about_overly_private_class (t
);
2122 /* The type conversion ops have to live at the front of the vec, so we
2124 for (slot
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2125 method_vec
->iterate (slot
, &fn_fields
);
2127 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields
)))
2130 qsort (method_vec
->address () + slot
,
2131 len
-slot
, sizeof (tree
), method_name_cmp
);
2134 /* Make BINFO's vtable have N entries, including RTTI entries,
2135 vbase and vcall offsets, etc. Set its type and call the back end
2139 layout_vtable_decl (tree binfo
, int n
)
2144 atype
= build_array_of_n_type (vtable_entry_type
, n
);
2145 layout_type (atype
);
2147 /* We may have to grow the vtable. */
2148 vtable
= get_vtbl_decl_for_binfo (binfo
);
2149 if (!same_type_p (TREE_TYPE (vtable
), atype
))
2151 TREE_TYPE (vtable
) = atype
;
2152 DECL_SIZE (vtable
) = DECL_SIZE_UNIT (vtable
) = NULL_TREE
;
2153 layout_decl (vtable
, 0);
2157 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
2158 have the same signature. */
2161 same_signature_p (const_tree fndecl
, const_tree base_fndecl
)
2163 /* One destructor overrides another if they are the same kind of
2165 if (DECL_DESTRUCTOR_P (base_fndecl
) && DECL_DESTRUCTOR_P (fndecl
)
2166 && special_function_p (base_fndecl
) == special_function_p (fndecl
))
2168 /* But a non-destructor never overrides a destructor, nor vice
2169 versa, nor do different kinds of destructors override
2170 one-another. For example, a complete object destructor does not
2171 override a deleting destructor. */
2172 if (DECL_DESTRUCTOR_P (base_fndecl
) || DECL_DESTRUCTOR_P (fndecl
))
2175 if (DECL_NAME (fndecl
) == DECL_NAME (base_fndecl
)
2176 || (DECL_CONV_FN_P (fndecl
)
2177 && DECL_CONV_FN_P (base_fndecl
)
2178 && same_type_p (DECL_CONV_FN_TYPE (fndecl
),
2179 DECL_CONV_FN_TYPE (base_fndecl
))))
2181 tree fntype
= TREE_TYPE (fndecl
);
2182 tree base_fntype
= TREE_TYPE (base_fndecl
);
2183 if (type_memfn_quals (fntype
) == type_memfn_quals (base_fntype
)
2184 && type_memfn_rqual (fntype
) == type_memfn_rqual (base_fntype
)
2185 && compparms (FUNCTION_FIRST_USER_PARMTYPE (fndecl
),
2186 FUNCTION_FIRST_USER_PARMTYPE (base_fndecl
)))
2192 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
2196 base_derived_from (tree derived
, tree base
)
2200 for (probe
= base
; probe
; probe
= BINFO_INHERITANCE_CHAIN (probe
))
2202 if (probe
== derived
)
2204 else if (BINFO_VIRTUAL_P (probe
))
2205 /* If we meet a virtual base, we can't follow the inheritance
2206 any more. See if the complete type of DERIVED contains
2207 such a virtual base. */
2208 return (binfo_for_vbase (BINFO_TYPE (probe
), BINFO_TYPE (derived
))
2214 typedef struct find_final_overrider_data_s
{
2215 /* The function for which we are trying to find a final overrider. */
2217 /* The base class in which the function was declared. */
2218 tree declaring_base
;
2219 /* The candidate overriders. */
2221 /* Path to most derived. */
2223 } find_final_overrider_data
;
2225 /* Add the overrider along the current path to FFOD->CANDIDATES.
2226 Returns true if an overrider was found; false otherwise. */
2229 dfs_find_final_overrider_1 (tree binfo
,
2230 find_final_overrider_data
*ffod
,
2235 /* If BINFO is not the most derived type, try a more derived class.
2236 A definition there will overrider a definition here. */
2240 if (dfs_find_final_overrider_1
2241 (ffod
->path
[depth
], ffod
, depth
))
2245 method
= look_for_overrides_here (BINFO_TYPE (binfo
), ffod
->fn
);
2248 tree
*candidate
= &ffod
->candidates
;
2250 /* Remove any candidates overridden by this new function. */
2253 /* If *CANDIDATE overrides METHOD, then METHOD
2254 cannot override anything else on the list. */
2255 if (base_derived_from (TREE_VALUE (*candidate
), binfo
))
2257 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
2258 if (base_derived_from (binfo
, TREE_VALUE (*candidate
)))
2259 *candidate
= TREE_CHAIN (*candidate
);
2261 candidate
= &TREE_CHAIN (*candidate
);
2264 /* Add the new function. */
2265 ffod
->candidates
= tree_cons (method
, binfo
, ffod
->candidates
);
2272 /* Called from find_final_overrider via dfs_walk. */
2275 dfs_find_final_overrider_pre (tree binfo
, void *data
)
2277 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
2279 if (binfo
== ffod
->declaring_base
)
2280 dfs_find_final_overrider_1 (binfo
, ffod
, ffod
->path
.length ());
2281 ffod
->path
.safe_push (binfo
);
2287 dfs_find_final_overrider_post (tree
/*binfo*/, void *data
)
2289 find_final_overrider_data
*ffod
= (find_final_overrider_data
*) data
;
2295 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2296 FN and whose TREE_VALUE is the binfo for the base where the
2297 overriding occurs. BINFO (in the hierarchy dominated by the binfo
2298 DERIVED) is the base object in which FN is declared. */
2301 find_final_overrider (tree derived
, tree binfo
, tree fn
)
2303 find_final_overrider_data ffod
;
2305 /* Getting this right is a little tricky. This is valid:
2307 struct S { virtual void f (); };
2308 struct T { virtual void f (); };
2309 struct U : public S, public T { };
2311 even though calling `f' in `U' is ambiguous. But,
2313 struct R { virtual void f(); };
2314 struct S : virtual public R { virtual void f (); };
2315 struct T : virtual public R { virtual void f (); };
2316 struct U : public S, public T { };
2318 is not -- there's no way to decide whether to put `S::f' or
2319 `T::f' in the vtable for `R'.
2321 The solution is to look at all paths to BINFO. If we find
2322 different overriders along any two, then there is a problem. */
2323 if (DECL_THUNK_P (fn
))
2324 fn
= THUNK_TARGET (fn
);
2326 /* Determine the depth of the hierarchy. */
2328 ffod
.declaring_base
= binfo
;
2329 ffod
.candidates
= NULL_TREE
;
2330 ffod
.path
.create (30);
2332 dfs_walk_all (derived
, dfs_find_final_overrider_pre
,
2333 dfs_find_final_overrider_post
, &ffod
);
2335 ffod
.path
.release ();
2337 /* If there was no winner, issue an error message. */
2338 if (!ffod
.candidates
|| TREE_CHAIN (ffod
.candidates
))
2339 return error_mark_node
;
2341 return ffod
.candidates
;
2344 /* Return the index of the vcall offset for FN when TYPE is used as a
2348 get_vcall_index (tree fn
, tree type
)
2350 vec
<tree_pair_s
, va_gc
> *indices
= CLASSTYPE_VCALL_INDICES (type
);
2354 FOR_EACH_VEC_SAFE_ELT (indices
, ix
, p
)
2355 if ((DECL_DESTRUCTOR_P (fn
) && DECL_DESTRUCTOR_P (p
->purpose
))
2356 || same_signature_p (fn
, p
->purpose
))
2359 /* There should always be an appropriate index. */
2363 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2364 dominated by T. FN is the old function; VIRTUALS points to the
2365 corresponding position in the new BINFO_VIRTUALS list. IX is the index
2366 of that entry in the list. */
2369 update_vtable_entry_for_fn (tree t
, tree binfo
, tree fn
, tree
* virtuals
,
2377 tree overrider_fn
, overrider_target
;
2378 tree target_fn
= DECL_THUNK_P (fn
) ? THUNK_TARGET (fn
) : fn
;
2379 tree over_return
, base_return
;
2382 /* Find the nearest primary base (possibly binfo itself) which defines
2383 this function; this is the class the caller will convert to when
2384 calling FN through BINFO. */
2385 for (b
= binfo
; ; b
= get_primary_binfo (b
))
2388 if (look_for_overrides_here (BINFO_TYPE (b
), target_fn
))
2391 /* The nearest definition is from a lost primary. */
2392 if (BINFO_LOST_PRIMARY_P (b
))
2397 /* Find the final overrider. */
2398 overrider
= find_final_overrider (TYPE_BINFO (t
), b
, target_fn
);
2399 if (overrider
== error_mark_node
)
2401 error ("no unique final overrider for %qD in %qT", target_fn
, t
);
2404 overrider_target
= overrider_fn
= TREE_PURPOSE (overrider
);
2406 /* Check for adjusting covariant return types. */
2407 over_return
= TREE_TYPE (TREE_TYPE (overrider_target
));
2408 base_return
= TREE_TYPE (TREE_TYPE (target_fn
));
2410 if (POINTER_TYPE_P (over_return
)
2411 && TREE_CODE (over_return
) == TREE_CODE (base_return
)
2412 && CLASS_TYPE_P (TREE_TYPE (over_return
))
2413 && CLASS_TYPE_P (TREE_TYPE (base_return
))
2414 /* If the overrider is invalid, don't even try. */
2415 && !DECL_INVALID_OVERRIDER_P (overrider_target
))
2417 /* If FN is a covariant thunk, we must figure out the adjustment
2418 to the final base FN was converting to. As OVERRIDER_TARGET might
2419 also be converting to the return type of FN, we have to
2420 combine the two conversions here. */
2421 tree fixed_offset
, virtual_offset
;
2423 over_return
= TREE_TYPE (over_return
);
2424 base_return
= TREE_TYPE (base_return
);
2426 if (DECL_THUNK_P (fn
))
2428 gcc_assert (DECL_RESULT_THUNK_P (fn
));
2429 fixed_offset
= ssize_int (THUNK_FIXED_OFFSET (fn
));
2430 virtual_offset
= THUNK_VIRTUAL_OFFSET (fn
);
2433 fixed_offset
= virtual_offset
= NULL_TREE
;
2436 /* Find the equivalent binfo within the return type of the
2437 overriding function. We will want the vbase offset from
2439 virtual_offset
= binfo_for_vbase (BINFO_TYPE (virtual_offset
),
2441 else if (!same_type_ignoring_top_level_qualifiers_p
2442 (over_return
, base_return
))
2444 /* There was no existing virtual thunk (which takes
2445 precedence). So find the binfo of the base function's
2446 return type within the overriding function's return type.
2447 We cannot call lookup base here, because we're inside a
2448 dfs_walk, and will therefore clobber the BINFO_MARKED
2449 flags. Fortunately we know the covariancy is valid (it
2450 has already been checked), so we can just iterate along
2451 the binfos, which have been chained in inheritance graph
2452 order. Of course it is lame that we have to repeat the
2453 search here anyway -- we should really be caching pieces
2454 of the vtable and avoiding this repeated work. */
2455 tree thunk_binfo
, base_binfo
;
2457 /* Find the base binfo within the overriding function's
2458 return type. We will always find a thunk_binfo, except
2459 when the covariancy is invalid (which we will have
2460 already diagnosed). */
2461 for (base_binfo
= TYPE_BINFO (base_return
),
2462 thunk_binfo
= TYPE_BINFO (over_return
);
2464 thunk_binfo
= TREE_CHAIN (thunk_binfo
))
2465 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo
),
2466 BINFO_TYPE (base_binfo
)))
2469 /* See if virtual inheritance is involved. */
2470 for (virtual_offset
= thunk_binfo
;
2472 virtual_offset
= BINFO_INHERITANCE_CHAIN (virtual_offset
))
2473 if (BINFO_VIRTUAL_P (virtual_offset
))
2477 || (thunk_binfo
&& !BINFO_OFFSET_ZEROP (thunk_binfo
)))
2479 tree offset
= convert (ssizetype
, BINFO_OFFSET (thunk_binfo
));
2483 /* We convert via virtual base. Adjust the fixed
2484 offset to be from there. */
2486 size_diffop (offset
,
2488 BINFO_OFFSET (virtual_offset
)));
2491 /* There was an existing fixed offset, this must be
2492 from the base just converted to, and the base the
2493 FN was thunking to. */
2494 fixed_offset
= size_binop (PLUS_EXPR
, fixed_offset
, offset
);
2496 fixed_offset
= offset
;
2500 if (fixed_offset
|| virtual_offset
)
2501 /* Replace the overriding function with a covariant thunk. We
2502 will emit the overriding function in its own slot as
2504 overrider_fn
= make_thunk (overrider_target
, /*this_adjusting=*/0,
2505 fixed_offset
, virtual_offset
);
2508 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target
) ||
2509 !DECL_THUNK_P (fn
));
2511 /* If we need a covariant thunk, then we may need to adjust first_defn.
2512 The ABI specifies that the thunks emitted with a function are
2513 determined by which bases the function overrides, so we need to be
2514 sure that we're using a thunk for some overridden base; even if we
2515 know that the necessary this adjustment is zero, there may not be an
2516 appropriate zero-this-adjusment thunk for us to use since thunks for
2517 overriding virtual bases always use the vcall offset.
2519 Furthermore, just choosing any base that overrides this function isn't
2520 quite right, as this slot won't be used for calls through a type that
2521 puts a covariant thunk here. Calling the function through such a type
2522 will use a different slot, and that slot is the one that determines
2523 the thunk emitted for that base.
2525 So, keep looking until we find the base that we're really overriding
2526 in this slot: the nearest primary base that doesn't use a covariant
2527 thunk in this slot. */
2528 if (overrider_target
!= overrider_fn
)
2530 if (BINFO_TYPE (b
) == DECL_CONTEXT (overrider_target
))
2531 /* We already know that the overrider needs a covariant thunk. */
2532 b
= get_primary_binfo (b
);
2533 for (; ; b
= get_primary_binfo (b
))
2535 tree main_binfo
= TYPE_BINFO (BINFO_TYPE (b
));
2536 tree bv
= chain_index (ix
, BINFO_VIRTUALS (main_binfo
));
2537 if (!DECL_THUNK_P (TREE_VALUE (bv
)))
2539 if (BINFO_LOST_PRIMARY_P (b
))
2545 /* Assume that we will produce a thunk that convert all the way to
2546 the final overrider, and not to an intermediate virtual base. */
2547 virtual_base
= NULL_TREE
;
2549 /* See if we can convert to an intermediate virtual base first, and then
2550 use the vcall offset located there to finish the conversion. */
2551 for (; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
2553 /* If we find the final overrider, then we can stop
2555 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b
),
2556 BINFO_TYPE (TREE_VALUE (overrider
))))
2559 /* If we find a virtual base, and we haven't yet found the
2560 overrider, then there is a virtual base between the
2561 declaring base (first_defn) and the final overrider. */
2562 if (BINFO_VIRTUAL_P (b
))
2569 /* Compute the constant adjustment to the `this' pointer. The
2570 `this' pointer, when this function is called, will point at BINFO
2571 (or one of its primary bases, which are at the same offset). */
2573 /* The `this' pointer needs to be adjusted from the declaration to
2574 the nearest virtual base. */
2575 delta
= size_diffop_loc (input_location
,
2576 convert (ssizetype
, BINFO_OFFSET (virtual_base
)),
2577 convert (ssizetype
, BINFO_OFFSET (first_defn
)));
2579 /* If the nearest definition is in a lost primary, we don't need an
2580 entry in our vtable. Except possibly in a constructor vtable,
2581 if we happen to get our primary back. In that case, the offset
2582 will be zero, as it will be a primary base. */
2583 delta
= size_zero_node
;
2585 /* The `this' pointer needs to be adjusted from pointing to
2586 BINFO to pointing at the base where the final overrider
2588 delta
= size_diffop_loc (input_location
,
2590 BINFO_OFFSET (TREE_VALUE (overrider
))),
2591 convert (ssizetype
, BINFO_OFFSET (binfo
)));
2593 modify_vtable_entry (t
, binfo
, overrider_fn
, delta
, virtuals
);
2596 BV_VCALL_INDEX (*virtuals
)
2597 = get_vcall_index (overrider_target
, BINFO_TYPE (virtual_base
));
2599 BV_VCALL_INDEX (*virtuals
) = NULL_TREE
;
2601 BV_LOST_PRIMARY (*virtuals
) = lost
;
2604 /* Called from modify_all_vtables via dfs_walk. */
2607 dfs_modify_vtables (tree binfo
, void* data
)
2609 tree t
= (tree
) data
;
2614 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
2615 /* A base without a vtable needs no modification, and its bases
2616 are uninteresting. */
2617 return dfs_skip_bases
;
2619 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
)
2620 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
2621 /* Don't do the primary vtable, if it's new. */
2624 if (BINFO_PRIMARY_P (binfo
) && !BINFO_VIRTUAL_P (binfo
))
2625 /* There's no need to modify the vtable for a non-virtual primary
2626 base; we're not going to use that vtable anyhow. We do still
2627 need to do this for virtual primary bases, as they could become
2628 non-primary in a construction vtable. */
2631 make_new_vtable (t
, binfo
);
2633 /* Now, go through each of the virtual functions in the virtual
2634 function table for BINFO. Find the final overrider, and update
2635 the BINFO_VIRTUALS list appropriately. */
2636 for (ix
= 0, virtuals
= BINFO_VIRTUALS (binfo
),
2637 old_virtuals
= BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo
)));
2639 ix
++, virtuals
= TREE_CHAIN (virtuals
),
2640 old_virtuals
= TREE_CHAIN (old_virtuals
))
2641 update_vtable_entry_for_fn (t
,
2643 BV_FN (old_virtuals
),
2649 /* Update all of the primary and secondary vtables for T. Create new
2650 vtables as required, and initialize their RTTI information. Each
2651 of the functions in VIRTUALS is declared in T and may override a
2652 virtual function from a base class; find and modify the appropriate
2653 entries to point to the overriding functions. Returns a list, in
2654 declaration order, of the virtual functions that are declared in T,
2655 but do not appear in the primary base class vtable, and which
2656 should therefore be appended to the end of the vtable for T. */
2659 modify_all_vtables (tree t
, tree virtuals
)
2661 tree binfo
= TYPE_BINFO (t
);
2664 /* Mangle the vtable name before entering dfs_walk (c++/51884). */
2665 if (TYPE_CONTAINS_VPTR_P (t
))
2666 get_vtable_decl (t
, false);
2668 /* Update all of the vtables. */
2669 dfs_walk_once (binfo
, dfs_modify_vtables
, NULL
, t
);
2671 /* Add virtual functions not already in our primary vtable. These
2672 will be both those introduced by this class, and those overridden
2673 from secondary bases. It does not include virtuals merely
2674 inherited from secondary bases. */
2675 for (fnsp
= &virtuals
; *fnsp
; )
2677 tree fn
= TREE_VALUE (*fnsp
);
2679 if (!value_member (fn
, BINFO_VIRTUALS (binfo
))
2680 || DECL_VINDEX (fn
) == error_mark_node
)
2682 /* We don't need to adjust the `this' pointer when
2683 calling this function. */
2684 BV_DELTA (*fnsp
) = integer_zero_node
;
2685 BV_VCALL_INDEX (*fnsp
) = NULL_TREE
;
2687 /* This is a function not already in our vtable. Keep it. */
2688 fnsp
= &TREE_CHAIN (*fnsp
);
2691 /* We've already got an entry for this function. Skip it. */
2692 *fnsp
= TREE_CHAIN (*fnsp
);
2698 /* Get the base virtual function declarations in T that have the
2702 get_basefndecls (tree name
, tree t
)
2705 tree base_fndecls
= NULL_TREE
;
2706 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
2709 /* Find virtual functions in T with the indicated NAME. */
2710 i
= lookup_fnfields_1 (t
, name
);
2712 for (methods
= (*CLASSTYPE_METHOD_VEC (t
))[i
];
2714 methods
= OVL_NEXT (methods
))
2716 tree method
= OVL_CURRENT (methods
);
2718 if (TREE_CODE (method
) == FUNCTION_DECL
2719 && DECL_VINDEX (method
))
2720 base_fndecls
= tree_cons (NULL_TREE
, method
, base_fndecls
);
2724 return base_fndecls
;
2726 for (i
= 0; i
< n_baseclasses
; i
++)
2728 tree basetype
= BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t
), i
));
2729 base_fndecls
= chainon (get_basefndecls (name
, basetype
),
2733 return base_fndecls
;
2736 /* If this declaration supersedes the declaration of
2737 a method declared virtual in the base class, then
2738 mark this field as being virtual as well. */
2741 check_for_override (tree decl
, tree ctype
)
2743 bool overrides_found
= false;
2744 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2745 /* In [temp.mem] we have:
2747 A specialization of a member function template does not
2748 override a virtual function from a base class. */
2750 if ((DECL_DESTRUCTOR_P (decl
)
2751 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
))
2752 || DECL_CONV_FN_P (decl
))
2753 && look_for_overrides (ctype
, decl
)
2754 && !DECL_STATIC_FUNCTION_P (decl
))
2755 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2756 the error_mark_node so that we know it is an overriding
2759 DECL_VINDEX (decl
) = decl
;
2760 overrides_found
= true;
2763 if (DECL_VIRTUAL_P (decl
))
2765 if (!DECL_VINDEX (decl
))
2766 DECL_VINDEX (decl
) = error_mark_node
;
2767 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
2768 if (DECL_DESTRUCTOR_P (decl
))
2769 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype
) = true;
2771 else if (DECL_FINAL_P (decl
))
2772 error ("%q+#D marked %<final%>, but is not virtual", decl
);
2773 if (DECL_OVERRIDE_P (decl
) && !overrides_found
)
2774 error ("%q+#D marked %<override%>, but does not override", decl
);
2777 /* Warn about hidden virtual functions that are not overridden in t.
2778 We know that constructors and destructors don't apply. */
2781 warn_hidden (tree t
)
2783 vec
<tree
, va_gc
> *method_vec
= CLASSTYPE_METHOD_VEC (t
);
2787 /* We go through each separately named virtual function. */
2788 for (i
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
2789 vec_safe_iterate (method_vec
, i
, &fns
);
2800 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2801 have the same name. Figure out what name that is. */
2802 name
= DECL_NAME (OVL_CURRENT (fns
));
2803 /* There are no possibly hidden functions yet. */
2804 base_fndecls
= NULL_TREE
;
2805 /* Iterate through all of the base classes looking for possibly
2806 hidden functions. */
2807 for (binfo
= TYPE_BINFO (t
), j
= 0;
2808 BINFO_BASE_ITERATE (binfo
, j
, base_binfo
); j
++)
2810 tree basetype
= BINFO_TYPE (base_binfo
);
2811 base_fndecls
= chainon (get_basefndecls (name
, basetype
),
2815 /* If there are no functions to hide, continue. */
2819 /* Remove any overridden functions. */
2820 for (fn
= fns
; fn
; fn
= OVL_NEXT (fn
))
2822 fndecl
= OVL_CURRENT (fn
);
2823 if (DECL_VINDEX (fndecl
))
2825 tree
*prev
= &base_fndecls
;
2828 /* If the method from the base class has the same
2829 signature as the method from the derived class, it
2830 has been overridden. */
2831 if (same_signature_p (fndecl
, TREE_VALUE (*prev
)))
2832 *prev
= TREE_CHAIN (*prev
);
2834 prev
= &TREE_CHAIN (*prev
);
2838 /* Now give a warning for all base functions without overriders,
2839 as they are hidden. */
2840 while (base_fndecls
)
2842 /* Here we know it is a hider, and no overrider exists. */
2843 warning (OPT_Woverloaded_virtual
, "%q+D was hidden", TREE_VALUE (base_fndecls
));
2844 warning (OPT_Woverloaded_virtual
, " by %q+D", fns
);
2845 base_fndecls
= TREE_CHAIN (base_fndecls
);
2850 /* Recursive helper for finish_struct_anon. */
2853 finish_struct_anon_r (tree field
, bool complain
)
2855 bool is_union
= TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
;
2856 tree elt
= TYPE_FIELDS (TREE_TYPE (field
));
2857 for (; elt
; elt
= DECL_CHAIN (elt
))
2859 /* We're generally only interested in entities the user
2860 declared, but we also find nested classes by noticing
2861 the TYPE_DECL that we create implicitly. You're
2862 allowed to put one anonymous union inside another,
2863 though, so we explicitly tolerate that. We use
2864 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2865 we also allow unnamed types used for defining fields. */
2866 if (DECL_ARTIFICIAL (elt
)
2867 && (!DECL_IMPLICIT_TYPEDEF_P (elt
)
2868 || TYPE_ANONYMOUS_P (TREE_TYPE (elt
))))
2871 if (TREE_CODE (elt
) != FIELD_DECL
)
2873 /* We already complained about static data members in
2874 finish_static_data_member_decl. */
2875 if (complain
&& TREE_CODE (elt
) != VAR_DECL
)
2878 permerror (input_location
,
2879 "%q+#D invalid; an anonymous union can "
2880 "only have non-static data members", elt
);
2882 permerror (input_location
,
2883 "%q+#D invalid; an anonymous struct can "
2884 "only have non-static data members", elt
);
2891 if (TREE_PRIVATE (elt
))
2894 permerror (input_location
,
2895 "private member %q+#D in anonymous union", elt
);
2897 permerror (input_location
,
2898 "private member %q+#D in anonymous struct", elt
);
2900 else if (TREE_PROTECTED (elt
))
2903 permerror (input_location
,
2904 "protected member %q+#D in anonymous union", elt
);
2906 permerror (input_location
,
2907 "protected member %q+#D in anonymous struct", elt
);
2911 TREE_PRIVATE (elt
) = TREE_PRIVATE (field
);
2912 TREE_PROTECTED (elt
) = TREE_PROTECTED (field
);
2914 /* Recurse into the anonymous aggregates to handle correctly
2915 access control (c++/24926):
2926 if (DECL_NAME (elt
) == NULL_TREE
2927 && ANON_AGGR_TYPE_P (TREE_TYPE (elt
)))
2928 finish_struct_anon_r (elt
, /*complain=*/false);
2932 /* Check for things that are invalid. There are probably plenty of other
2933 things we should check for also. */
2936 finish_struct_anon (tree t
)
2938 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
2940 if (TREE_STATIC (field
))
2942 if (TREE_CODE (field
) != FIELD_DECL
)
2945 if (DECL_NAME (field
) == NULL_TREE
2946 && ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
2947 finish_struct_anon_r (field
, /*complain=*/true);
2951 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2952 will be used later during class template instantiation.
2953 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2954 a non-static member data (FIELD_DECL), a member function
2955 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2956 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2957 When FRIEND_P is nonzero, T is either a friend class
2958 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2959 (FUNCTION_DECL, TEMPLATE_DECL). */
2962 maybe_add_class_template_decl_list (tree type
, tree t
, int friend_p
)
2964 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2965 if (CLASSTYPE_TEMPLATE_INFO (type
))
2966 CLASSTYPE_DECL_LIST (type
)
2967 = tree_cons (friend_p
? NULL_TREE
: type
,
2968 t
, CLASSTYPE_DECL_LIST (type
));
2971 /* This function is called from declare_virt_assop_and_dtor via
2974 DATA is a type that direcly or indirectly inherits the base
2975 represented by BINFO. If BINFO contains a virtual assignment [copy
2976 assignment or move assigment] operator or a virtual constructor,
2977 declare that function in DATA if it hasn't been already declared. */
2980 dfs_declare_virt_assop_and_dtor (tree binfo
, void *data
)
2982 tree bv
, fn
, t
= (tree
)data
;
2983 tree opname
= ansi_assopname (NOP_EXPR
);
2985 gcc_assert (t
&& CLASS_TYPE_P (t
));
2986 gcc_assert (binfo
&& TREE_CODE (binfo
) == TREE_BINFO
);
2988 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
2989 /* A base without a vtable needs no modification, and its bases
2990 are uninteresting. */
2991 return dfs_skip_bases
;
2993 if (BINFO_PRIMARY_P (binfo
))
2994 /* If this is a primary base, then we have already looked at the
2995 virtual functions of its vtable. */
2998 for (bv
= BINFO_VIRTUALS (binfo
); bv
; bv
= TREE_CHAIN (bv
))
3002 if (DECL_NAME (fn
) == opname
)
3004 if (CLASSTYPE_LAZY_COPY_ASSIGN (t
))
3005 lazily_declare_fn (sfk_copy_assignment
, t
);
3006 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
3007 lazily_declare_fn (sfk_move_assignment
, t
);
3009 else if (DECL_DESTRUCTOR_P (fn
)
3010 && CLASSTYPE_LAZY_DESTRUCTOR (t
))
3011 lazily_declare_fn (sfk_destructor
, t
);
3017 /* If the class type T has a direct or indirect base that contains a
3018 virtual assignment operator or a virtual destructor, declare that
3019 function in T if it hasn't been already declared. */
3022 declare_virt_assop_and_dtor (tree t
)
3024 if (!(TYPE_POLYMORPHIC_P (t
)
3025 && (CLASSTYPE_LAZY_COPY_ASSIGN (t
)
3026 || CLASSTYPE_LAZY_MOVE_ASSIGN (t
)
3027 || CLASSTYPE_LAZY_DESTRUCTOR (t
))))
3030 dfs_walk_all (TYPE_BINFO (t
),
3031 dfs_declare_virt_assop_and_dtor
,
3035 /* Declare the inheriting constructor for class T inherited from base
3036 constructor CTOR with the parameter array PARMS of size NPARMS. */
3039 one_inheriting_sig (tree t
, tree ctor
, tree
*parms
, int nparms
)
3041 /* We don't declare an inheriting ctor that would be a default,
3042 copy or move ctor for derived or base. */
3046 && TREE_CODE (parms
[0]) == REFERENCE_TYPE
)
3048 tree parm
= TYPE_MAIN_VARIANT (TREE_TYPE (parms
[0]));
3049 if (parm
== t
|| parm
== DECL_CONTEXT (ctor
))
3053 tree parmlist
= void_list_node
;
3054 for (int i
= nparms
- 1; i
>= 0; i
--)
3055 parmlist
= tree_cons (NULL_TREE
, parms
[i
], parmlist
);
3056 tree fn
= implicitly_declare_fn (sfk_inheriting_constructor
,
3057 t
, false, ctor
, parmlist
);
3058 if (add_method (t
, fn
, NULL_TREE
))
3060 DECL_CHAIN (fn
) = TYPE_METHODS (t
);
3061 TYPE_METHODS (t
) = fn
;
3065 /* Declare all the inheriting constructors for class T inherited from base
3066 constructor CTOR. */
3069 one_inherited_ctor (tree ctor
, tree t
)
3071 tree parms
= FUNCTION_FIRST_USER_PARMTYPE (ctor
);
3073 tree
*new_parms
= XALLOCAVEC (tree
, list_length (parms
));
3075 for (; parms
&& parms
!= void_list_node
; parms
= TREE_CHAIN (parms
))
3077 if (TREE_PURPOSE (parms
))
3078 one_inheriting_sig (t
, ctor
, new_parms
, i
);
3079 new_parms
[i
++] = TREE_VALUE (parms
);
3081 one_inheriting_sig (t
, ctor
, new_parms
, i
);
3082 if (parms
== NULL_TREE
)
3084 if (warning (OPT_Winherited_variadic_ctor
,
3085 "the ellipsis in %qD is not inherited", ctor
))
3086 inform (DECL_SOURCE_LOCATION (ctor
), "%qD declared here", ctor
);
3090 /* Create default constructors, assignment operators, and so forth for
3091 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
3092 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
3093 the class cannot have a default constructor, copy constructor
3094 taking a const reference argument, or an assignment operator taking
3095 a const reference, respectively. */
3098 add_implicitly_declared_members (tree t
, tree
* access_decls
,
3099 int cant_have_const_cctor
,
3100 int cant_have_const_assignment
)
3102 bool move_ok
= false;
3104 if (cxx_dialect
>= cxx11
&& !CLASSTYPE_DESTRUCTORS (t
)
3105 && !TYPE_HAS_COPY_CTOR (t
) && !TYPE_HAS_COPY_ASSIGN (t
)
3106 && !type_has_move_constructor (t
) && !type_has_move_assign (t
))
3110 if (!CLASSTYPE_DESTRUCTORS (t
))
3112 /* In general, we create destructors lazily. */
3113 CLASSTYPE_LAZY_DESTRUCTOR (t
) = 1;
3115 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3116 && TYPE_FOR_JAVA (t
))
3117 /* But if this is a Java class, any non-trivial destructor is
3118 invalid, even if compiler-generated. Therefore, if the
3119 destructor is non-trivial we create it now. */
3120 lazily_declare_fn (sfk_destructor
, t
);
3125 If there is no user-declared constructor for a class, a default
3126 constructor is implicitly declared. */
3127 if (! TYPE_HAS_USER_CONSTRUCTOR (t
))
3129 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 1;
3130 CLASSTYPE_LAZY_DEFAULT_CTOR (t
) = 1;
3131 if (cxx_dialect
>= cxx11
)
3132 TYPE_HAS_CONSTEXPR_CTOR (t
)
3133 /* This might force the declaration. */
3134 = type_has_constexpr_default_constructor (t
);
3139 If a class definition does not explicitly declare a copy
3140 constructor, one is declared implicitly. */
3141 if (! TYPE_HAS_COPY_CTOR (t
) && ! TYPE_FOR_JAVA (t
))
3143 TYPE_HAS_COPY_CTOR (t
) = 1;
3144 TYPE_HAS_CONST_COPY_CTOR (t
) = !cant_have_const_cctor
;
3145 CLASSTYPE_LAZY_COPY_CTOR (t
) = 1;
3147 CLASSTYPE_LAZY_MOVE_CTOR (t
) = 1;
3150 /* If there is no assignment operator, one will be created if and
3151 when it is needed. For now, just record whether or not the type
3152 of the parameter to the assignment operator will be a const or
3153 non-const reference. */
3154 if (!TYPE_HAS_COPY_ASSIGN (t
) && !TYPE_FOR_JAVA (t
))
3156 TYPE_HAS_COPY_ASSIGN (t
) = 1;
3157 TYPE_HAS_CONST_COPY_ASSIGN (t
) = !cant_have_const_assignment
;
3158 CLASSTYPE_LAZY_COPY_ASSIGN (t
) = 1;
3160 CLASSTYPE_LAZY_MOVE_ASSIGN (t
) = 1;
3163 /* We can't be lazy about declaring functions that might override
3164 a virtual function from a base class. */
3165 declare_virt_assop_and_dtor (t
);
3167 while (*access_decls
)
3169 tree using_decl
= TREE_VALUE (*access_decls
);
3170 tree decl
= USING_DECL_DECLS (using_decl
);
3171 if (DECL_NAME (using_decl
) == ctor_identifier
)
3173 /* declare, then remove the decl */
3174 tree ctor_list
= decl
;
3175 location_t loc
= input_location
;
3176 input_location
= DECL_SOURCE_LOCATION (using_decl
);
3178 for (; ctor_list
; ctor_list
= OVL_NEXT (ctor_list
))
3179 one_inherited_ctor (OVL_CURRENT (ctor_list
), t
);
3180 *access_decls
= TREE_CHAIN (*access_decls
);
3181 input_location
= loc
;
3184 access_decls
= &TREE_CHAIN (*access_decls
);
3188 /* Subroutine of insert_into_classtype_sorted_fields. Recursively
3189 count the number of fields in TYPE, including anonymous union
3193 count_fields (tree fields
)
3197 for (x
= fields
; x
; x
= DECL_CHAIN (x
))
3199 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3200 n_fields
+= count_fields (TYPE_FIELDS (TREE_TYPE (x
)));
3207 /* Subroutine of insert_into_classtype_sorted_fields. Recursively add
3208 all the fields in the TREE_LIST FIELDS to the SORTED_FIELDS_TYPE
3209 elts, starting at offset IDX. */
3212 add_fields_to_record_type (tree fields
, struct sorted_fields_type
*field_vec
, int idx
)
3215 for (x
= fields
; x
; x
= DECL_CHAIN (x
))
3217 if (TREE_CODE (x
) == FIELD_DECL
&& ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
3218 idx
= add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x
)), field_vec
, idx
);
3220 field_vec
->elts
[idx
++] = x
;
3225 /* Add all of the enum values of ENUMTYPE, to the FIELD_VEC elts,
3226 starting at offset IDX. */
3229 add_enum_fields_to_record_type (tree enumtype
,
3230 struct sorted_fields_type
*field_vec
,
3234 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
3235 field_vec
->elts
[idx
++] = TREE_VALUE (values
);
3239 /* FIELD is a bit-field. We are finishing the processing for its
3240 enclosing type. Issue any appropriate messages and set appropriate
3241 flags. Returns false if an error has been diagnosed. */
3244 check_bitfield_decl (tree field
)
3246 tree type
= TREE_TYPE (field
);
3249 /* Extract the declared width of the bitfield, which has been
3250 temporarily stashed in DECL_INITIAL. */
3251 w
= DECL_INITIAL (field
);
3252 gcc_assert (w
!= NULL_TREE
);
3253 /* Remove the bit-field width indicator so that the rest of the
3254 compiler does not treat that value as an initializer. */
3255 DECL_INITIAL (field
) = NULL_TREE
;
3257 /* Detect invalid bit-field type. */
3258 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
3260 error ("bit-field %q+#D with non-integral type", field
);
3261 w
= error_mark_node
;
3265 location_t loc
= input_location
;
3266 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
3269 /* detect invalid field size. */
3270 input_location
= DECL_SOURCE_LOCATION (field
);
3271 w
= cxx_constant_value (w
);
3272 input_location
= loc
;
3274 if (TREE_CODE (w
) != INTEGER_CST
)
3276 error ("bit-field %q+D width not an integer constant", field
);
3277 w
= error_mark_node
;
3279 else if (tree_int_cst_sgn (w
) < 0)
3281 error ("negative width in bit-field %q+D", field
);
3282 w
= error_mark_node
;
3284 else if (integer_zerop (w
) && DECL_NAME (field
) != 0)
3286 error ("zero width for bit-field %q+D", field
);
3287 w
= error_mark_node
;
3289 else if ((TREE_CODE (type
) != ENUMERAL_TYPE
3290 && TREE_CODE (type
) != BOOLEAN_TYPE
3291 && compare_tree_int (w
, TYPE_PRECISION (type
)) > 0)
3292 || ((TREE_CODE (type
) == ENUMERAL_TYPE
3293 || TREE_CODE (type
) == BOOLEAN_TYPE
)
3294 && tree_int_cst_lt (TYPE_SIZE (type
), w
)))
3295 warning (0, "width of %q+D exceeds its type", field
);
3296 else if (TREE_CODE (type
) == ENUMERAL_TYPE
3297 && (0 > (compare_tree_int
3298 (w
, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type
))))))
3299 warning (0, "%q+D is too small to hold all values of %q#T", field
, type
);
3302 if (w
!= error_mark_node
)
3304 DECL_SIZE (field
) = convert (bitsizetype
, w
);
3305 DECL_BIT_FIELD (field
) = 1;
3310 /* Non-bit-fields are aligned for their type. */
3311 DECL_BIT_FIELD (field
) = 0;
3312 CLEAR_DECL_C_BIT_FIELD (field
);
3317 /* FIELD is a non bit-field. We are finishing the processing for its
3318 enclosing type T. Issue any appropriate messages and set appropriate
3322 check_field_decl (tree field
,
3324 int* cant_have_const_ctor
,
3325 int* no_const_asn_ref
,
3326 int* any_default_members
)
3328 tree type
= strip_array_types (TREE_TYPE (field
));
3330 /* In C++98 an anonymous union cannot contain any fields which would change
3331 the settings of CANT_HAVE_CONST_CTOR and friends. */
3332 if (ANON_UNION_TYPE_P (type
) && cxx_dialect
< cxx11
)
3334 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
3335 structs. So, we recurse through their fields here. */
3336 else if (ANON_AGGR_TYPE_P (type
))
3340 for (fields
= TYPE_FIELDS (type
); fields
; fields
= DECL_CHAIN (fields
))
3341 if (TREE_CODE (fields
) == FIELD_DECL
&& !DECL_C_BIT_FIELD (field
))
3342 check_field_decl (fields
, t
, cant_have_const_ctor
,
3343 no_const_asn_ref
, any_default_members
);
3345 /* Check members with class type for constructors, destructors,
3347 else if (CLASS_TYPE_P (type
))
3349 /* Never let anything with uninheritable virtuals
3350 make it through without complaint. */
3351 abstract_virtuals_error (field
, type
);
3353 if (TREE_CODE (t
) == UNION_TYPE
&& cxx_dialect
< cxx11
)
3356 int oldcount
= errorcount
;
3357 if (TYPE_NEEDS_CONSTRUCTING (type
))
3358 error ("member %q+#D with constructor not allowed in union",
3360 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3361 error ("member %q+#D with destructor not allowed in union", field
);
3362 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
3363 error ("member %q+#D with copy assignment operator not allowed in union",
3365 if (!warned
&& errorcount
> oldcount
)
3367 inform (DECL_SOURCE_LOCATION (field
), "unrestricted unions "
3368 "only available with -std=c++11 or -std=gnu++11");
3374 TYPE_NEEDS_CONSTRUCTING (t
) |= TYPE_NEEDS_CONSTRUCTING (type
);
3375 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3376 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
);
3377 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
)
3378 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
)
3379 || !TYPE_HAS_COPY_ASSIGN (type
));
3380 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= (TYPE_HAS_COMPLEX_COPY_CTOR (type
)
3381 || !TYPE_HAS_COPY_CTOR (type
));
3382 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type
);
3383 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_HAS_COMPLEX_MOVE_CTOR (type
);
3384 TYPE_HAS_COMPLEX_DFLT (t
) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)
3385 || TYPE_HAS_COMPLEX_DFLT (type
));
3388 if (TYPE_HAS_COPY_CTOR (type
)
3389 && !TYPE_HAS_CONST_COPY_CTOR (type
))
3390 *cant_have_const_ctor
= 1;
3392 if (TYPE_HAS_COPY_ASSIGN (type
)
3393 && !TYPE_HAS_CONST_COPY_ASSIGN (type
))
3394 *no_const_asn_ref
= 1;
3397 check_abi_tags (t
, field
);
3399 if (DECL_INITIAL (field
) != NULL_TREE
)
3401 /* `build_class_init_list' does not recognize
3403 if (TREE_CODE (t
) == UNION_TYPE
&& *any_default_members
!= 0)
3404 error ("multiple fields in union %qT initialized", t
);
3405 *any_default_members
= 1;
3409 /* Check the data members (both static and non-static), class-scoped
3410 typedefs, etc., appearing in the declaration of T. Issue
3411 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3412 declaration order) of access declarations; each TREE_VALUE in this
3413 list is a USING_DECL.
3415 In addition, set the following flags:
3418 The class is empty, i.e., contains no non-static data members.
3420 CANT_HAVE_CONST_CTOR_P
3421 This class cannot have an implicitly generated copy constructor
3422 taking a const reference.
3424 CANT_HAVE_CONST_ASN_REF
3425 This class cannot have an implicitly generated assignment
3426 operator taking a const reference.
3428 All of these flags should be initialized before calling this
3431 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3432 fields can be added by adding to this chain. */
3435 check_field_decls (tree t
, tree
*access_decls
,
3436 int *cant_have_const_ctor_p
,
3437 int *no_const_asn_ref_p
)
3442 int any_default_members
;
3444 int field_access
= -1;
3446 /* Assume there are no access declarations. */
3447 *access_decls
= NULL_TREE
;
3448 /* Assume this class has no pointer members. */
3449 has_pointers
= false;
3450 /* Assume none of the members of this class have default
3452 any_default_members
= 0;
3454 for (field
= &TYPE_FIELDS (t
); *field
; field
= next
)
3457 tree type
= TREE_TYPE (x
);
3458 int this_field_access
;
3460 next
= &DECL_CHAIN (x
);
3462 if (TREE_CODE (x
) == USING_DECL
)
3464 /* Save the access declarations for our caller. */
3465 *access_decls
= tree_cons (NULL_TREE
, x
, *access_decls
);
3469 if (TREE_CODE (x
) == TYPE_DECL
3470 || TREE_CODE (x
) == TEMPLATE_DECL
)
3473 /* If we've gotten this far, it's a data member, possibly static,
3474 or an enumerator. */
3475 if (TREE_CODE (x
) != CONST_DECL
)
3476 DECL_CONTEXT (x
) = t
;
3478 /* When this goes into scope, it will be a non-local reference. */
3479 DECL_NONLOCAL (x
) = 1;
3481 if (TREE_CODE (t
) == UNION_TYPE
3482 && cxx_dialect
< cxx11
)
3484 /* [class.union] (C++98)
3486 If a union contains a static data member, or a member of
3487 reference type, the program is ill-formed.
3489 In C++11 this limitation doesn't exist anymore. */
3492 error ("in C++98 %q+D may not be static because it is "
3493 "a member of a union", x
);
3496 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3498 error ("in C++98 %q+D may not have reference type %qT "
3499 "because it is a member of a union", x
, type
);
3504 /* Perform error checking that did not get done in
3506 if (TREE_CODE (type
) == FUNCTION_TYPE
)
3508 error ("field %q+D invalidly declared function type", x
);
3509 type
= build_pointer_type (type
);
3510 TREE_TYPE (x
) = type
;
3512 else if (TREE_CODE (type
) == METHOD_TYPE
)
3514 error ("field %q+D invalidly declared method type", x
);
3515 type
= build_pointer_type (type
);
3516 TREE_TYPE (x
) = type
;
3519 if (type
== error_mark_node
)
3522 if (TREE_CODE (x
) == CONST_DECL
|| VAR_P (x
))
3525 /* Now it can only be a FIELD_DECL. */
3527 if (TREE_PRIVATE (x
) || TREE_PROTECTED (x
))
3528 CLASSTYPE_NON_AGGREGATE (t
) = 1;
3530 /* If at least one non-static data member is non-literal, the whole
3531 class becomes non-literal. Note: if the type is incomplete we
3532 will complain later on. */
3533 if (COMPLETE_TYPE_P (type
) && !literal_type_p (type
))
3534 CLASSTYPE_LITERAL_P (t
) = false;
3536 /* A standard-layout class is a class that:
3538 has the same access control (Clause 11) for all non-static data members,
3540 this_field_access
= TREE_PROTECTED (x
) ? 1 : TREE_PRIVATE (x
) ? 2 : 0;
3541 if (field_access
== -1)
3542 field_access
= this_field_access
;
3543 else if (this_field_access
!= field_access
)
3544 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3546 /* If this is of reference type, check if it needs an init. */
3547 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3549 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3550 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3551 if (DECL_INITIAL (x
) == NULL_TREE
)
3552 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3554 /* ARM $12.6.2: [A member initializer list] (or, for an
3555 aggregate, initialization by a brace-enclosed list) is the
3556 only way to initialize nonstatic const and reference
3558 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
3559 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) = 1;
3562 type
= strip_array_types (type
);
3564 if (TYPE_PACKED (t
))
3566 if (!layout_pod_type_p (type
) && !TYPE_PACKED (type
))
3570 "ignoring packed attribute because of unpacked non-POD field %q+#D",
3574 else if (DECL_C_BIT_FIELD (x
)
3575 || TYPE_ALIGN (TREE_TYPE (x
)) > BITS_PER_UNIT
)
3576 DECL_PACKED (x
) = 1;
3579 if (DECL_C_BIT_FIELD (x
) && integer_zerop (DECL_INITIAL (x
)))
3580 /* We don't treat zero-width bitfields as making a class
3585 /* The class is non-empty. */
3586 CLASSTYPE_EMPTY_P (t
) = 0;
3587 /* The class is not even nearly empty. */
3588 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
3589 /* If one of the data members contains an empty class,
3591 if (CLASS_TYPE_P (type
)
3592 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3593 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 1;
3596 /* This is used by -Weffc++ (see below). Warn only for pointers
3597 to members which might hold dynamic memory. So do not warn
3598 for pointers to functions or pointers to members. */
3599 if (TYPE_PTR_P (type
)
3600 && !TYPE_PTRFN_P (type
))
3601 has_pointers
= true;
3603 if (CLASS_TYPE_P (type
))
3605 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type
))
3606 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t
, 1);
3607 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
))
3608 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3611 if (DECL_MUTABLE_P (x
) || TYPE_HAS_MUTABLE_P (type
))
3612 CLASSTYPE_HAS_MUTABLE (t
) = 1;
3614 if (DECL_MUTABLE_P (x
))
3616 if (CP_TYPE_CONST_P (type
))
3618 error ("member %q+D cannot be declared both %<const%> "
3619 "and %<mutable%>", x
);
3622 if (TREE_CODE (type
) == REFERENCE_TYPE
)
3624 error ("member %q+D cannot be declared as a %<mutable%> "
3630 if (! layout_pod_type_p (type
))
3631 /* DR 148 now allows pointers to members (which are POD themselves),
3632 to be allowed in POD structs. */
3633 CLASSTYPE_NON_LAYOUT_POD_P (t
) = 1;
3635 if (!std_layout_type_p (type
))
3636 CLASSTYPE_NON_STD_LAYOUT (t
) = 1;
3638 if (! zero_init_p (type
))
3639 CLASSTYPE_NON_ZERO_INIT_P (t
) = 1;
3641 /* We set DECL_C_BIT_FIELD in grokbitfield.
3642 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3643 if (! DECL_C_BIT_FIELD (x
) || ! check_bitfield_decl (x
))
3644 check_field_decl (x
, t
,
3645 cant_have_const_ctor_p
,
3647 &any_default_members
);
3649 /* Now that we've removed bit-field widths from DECL_INITIAL,
3650 anything left in DECL_INITIAL is an NSDMI that makes the class
3652 if (DECL_INITIAL (x
))
3653 CLASSTYPE_NON_AGGREGATE (t
) = true;
3655 /* If any field is const, the structure type is pseudo-const. */
3656 if (CP_TYPE_CONST_P (type
))
3658 C_TYPE_FIELDS_READONLY (t
) = 1;
3659 if (DECL_INITIAL (x
) == NULL_TREE
)
3660 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
, 1);
3662 /* ARM $12.6.2: [A member initializer list] (or, for an
3663 aggregate, initialization by a brace-enclosed list) is the
3664 only way to initialize nonstatic const and reference
3666 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
3667 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) = 1;
3669 /* A field that is pseudo-const makes the structure likewise. */
3670 else if (CLASS_TYPE_P (type
))
3672 C_TYPE_FIELDS_READONLY (t
) |= C_TYPE_FIELDS_READONLY (type
);
3673 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
,
3674 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t
)
3675 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type
));
3678 /* Core issue 80: A nonstatic data member is required to have a
3679 different name from the class iff the class has a
3680 user-declared constructor. */
3681 if (constructor_name_p (DECL_NAME (x
), t
)
3682 && TYPE_HAS_USER_CONSTRUCTOR (t
))
3683 permerror (input_location
, "field %q+#D with same name as class", x
);
3686 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3687 it should also define a copy constructor and an assignment operator to
3688 implement the correct copy semantic (deep vs shallow, etc.). As it is
3689 not feasible to check whether the constructors do allocate dynamic memory
3690 and store it within members, we approximate the warning like this:
3692 -- Warn only if there are members which are pointers
3693 -- Warn only if there is a non-trivial constructor (otherwise,
3694 there cannot be memory allocated).
3695 -- Warn only if there is a non-trivial destructor. We assume that the
3696 user at least implemented the cleanup correctly, and a destructor
3697 is needed to free dynamic memory.
3699 This seems enough for practical purposes. */
3702 && TYPE_HAS_USER_CONSTRUCTOR (t
)
3703 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
3704 && !(TYPE_HAS_COPY_CTOR (t
) && TYPE_HAS_COPY_ASSIGN (t
)))
3706 warning (OPT_Weffc__
, "%q#T has pointer data members", t
);
3708 if (! TYPE_HAS_COPY_CTOR (t
))
3710 warning (OPT_Weffc__
,
3711 " but does not override %<%T(const %T&)%>", t
, t
);
3712 if (!TYPE_HAS_COPY_ASSIGN (t
))
3713 warning (OPT_Weffc__
, " or %<operator=(const %T&)%>", t
);
3715 else if (! TYPE_HAS_COPY_ASSIGN (t
))
3716 warning (OPT_Weffc__
,
3717 " but does not override %<operator=(const %T&)%>", t
);
3720 /* Non-static data member initializers make the default constructor
3722 if (any_default_members
)
3724 TYPE_NEEDS_CONSTRUCTING (t
) = true;
3725 TYPE_HAS_COMPLEX_DFLT (t
) = true;
3728 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3730 TYPE_PACKED (t
) = 0;
3732 /* Check anonymous struct/anonymous union fields. */
3733 finish_struct_anon (t
);
3735 /* We've built up the list of access declarations in reverse order.
3737 *access_decls
= nreverse (*access_decls
);
3740 /* If TYPE is an empty class type, records its OFFSET in the table of
3744 record_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
);
3754 n
= splay_tree_insert (offsets
,
3755 (splay_tree_key
) offset
,
3756 (splay_tree_value
) NULL_TREE
);
3757 n
->value
= ((splay_tree_value
)
3758 tree_cons (NULL_TREE
,
3765 /* Returns nonzero if TYPE is an empty class type and there is
3766 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3769 check_subobject_offset (tree type
, tree offset
, splay_tree offsets
)
3774 if (!is_empty_class (type
))
3777 /* Record the location of this empty object in OFFSETS. */
3778 n
= splay_tree_lookup (offsets
, (splay_tree_key
) offset
);
3782 for (t
= (tree
) n
->value
; t
; t
= TREE_CHAIN (t
))
3783 if (same_type_p (TREE_VALUE (t
), type
))
3789 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3790 F for every subobject, passing it the type, offset, and table of
3791 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3794 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3795 than MAX_OFFSET will not be walked.
3797 If F returns a nonzero value, the traversal ceases, and that value
3798 is returned. Otherwise, returns zero. */
3801 walk_subobject_offsets (tree type
,
3802 subobject_offset_fn f
,
3809 tree type_binfo
= NULL_TREE
;
3811 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3813 if (max_offset
&& tree_int_cst_lt (max_offset
, offset
))
3816 if (type
== error_mark_node
)
3822 type
= BINFO_TYPE (type
);
3825 if (CLASS_TYPE_P (type
))
3831 /* Avoid recursing into objects that are not interesting. */
3832 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type
))
3835 /* Record the location of TYPE. */
3836 r
= (*f
) (type
, offset
, offsets
);
3840 /* Iterate through the direct base classes of TYPE. */
3842 type_binfo
= TYPE_BINFO (type
);
3843 for (i
= 0; BINFO_BASE_ITERATE (type_binfo
, i
, binfo
); i
++)
3847 if (BINFO_VIRTUAL_P (binfo
))
3851 /* We cannot rely on BINFO_OFFSET being set for the base
3852 class yet, but the offsets for direct non-virtual
3853 bases can be calculated by going back to the TYPE. */
3854 orig_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
3855 binfo_offset
= size_binop (PLUS_EXPR
,
3857 BINFO_OFFSET (orig_binfo
));
3859 r
= walk_subobject_offsets (binfo
,
3869 if (CLASSTYPE_VBASECLASSES (type
))
3872 vec
<tree
, va_gc
> *vbases
;
3874 /* Iterate through the virtual base classes of TYPE. In G++
3875 3.2, we included virtual bases in the direct base class
3876 loop above, which results in incorrect results; the
3877 correct offsets for virtual bases are only known when
3878 working with the most derived type. */
3880 for (vbases
= CLASSTYPE_VBASECLASSES (type
), ix
= 0;
3881 vec_safe_iterate (vbases
, ix
, &binfo
); ix
++)
3883 r
= walk_subobject_offsets (binfo
,
3885 size_binop (PLUS_EXPR
,
3887 BINFO_OFFSET (binfo
)),
3896 /* We still have to walk the primary base, if it is
3897 virtual. (If it is non-virtual, then it was walked
3899 tree vbase
= get_primary_binfo (type_binfo
);
3901 if (vbase
&& BINFO_VIRTUAL_P (vbase
)
3902 && BINFO_PRIMARY_P (vbase
)
3903 && BINFO_INHERITANCE_CHAIN (vbase
) == type_binfo
)
3905 r
= (walk_subobject_offsets
3907 offsets
, max_offset
, /*vbases_p=*/0));
3914 /* Iterate through the fields of TYPE. */
3915 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
3916 if (TREE_CODE (field
) == FIELD_DECL
3917 && TREE_TYPE (field
) != error_mark_node
3918 && !DECL_ARTIFICIAL (field
))
3922 field_offset
= byte_position (field
);
3924 r
= walk_subobject_offsets (TREE_TYPE (field
),
3926 size_binop (PLUS_EXPR
,
3936 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3938 tree element_type
= strip_array_types (type
);
3939 tree domain
= TYPE_DOMAIN (type
);
3942 /* Avoid recursing into objects that are not interesting. */
3943 if (!CLASS_TYPE_P (element_type
)
3944 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type
))
3947 /* Step through each of the elements in the array. */
3948 for (index
= size_zero_node
;
3949 !tree_int_cst_lt (TYPE_MAX_VALUE (domain
), index
);
3950 index
= size_binop (PLUS_EXPR
, index
, size_one_node
))
3952 r
= walk_subobject_offsets (TREE_TYPE (type
),
3960 offset
= size_binop (PLUS_EXPR
, offset
,
3961 TYPE_SIZE_UNIT (TREE_TYPE (type
)));
3962 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3963 there's no point in iterating through the remaining
3964 elements of the array. */
3965 if (max_offset
&& tree_int_cst_lt (max_offset
, offset
))
3973 /* Record all of the empty subobjects of TYPE (either a type or a
3974 binfo). If IS_DATA_MEMBER is true, then a non-static data member
3975 is being placed at OFFSET; otherwise, it is a base class that is
3976 being placed at OFFSET. */
3979 record_subobject_offsets (tree type
,
3982 bool is_data_member
)
3985 /* If recording subobjects for a non-static data member or a
3986 non-empty base class , we do not need to record offsets beyond
3987 the size of the biggest empty class. Additional data members
3988 will go at the end of the class. Additional base classes will go
3989 either at offset zero (if empty, in which case they cannot
3990 overlap with offsets past the size of the biggest empty class) or
3991 at the end of the class.
3993 However, if we are placing an empty base class, then we must record
3994 all offsets, as either the empty class is at offset zero (where
3995 other empty classes might later be placed) or at the end of the
3996 class (where other objects might then be placed, so other empty
3997 subobjects might later overlap). */
3999 || !is_empty_class (BINFO_TYPE (type
)))
4000 max_offset
= sizeof_biggest_empty_class
;
4002 max_offset
= NULL_TREE
;
4003 walk_subobject_offsets (type
, record_subobject_offset
, offset
,
4004 offsets
, max_offset
, is_data_member
);
4007 /* Returns nonzero if any of the empty subobjects of TYPE (located at
4008 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
4009 virtual bases of TYPE are examined. */
4012 layout_conflict_p (tree type
,
4017 splay_tree_node max_node
;
4019 /* Get the node in OFFSETS that indicates the maximum offset where
4020 an empty subobject is located. */
4021 max_node
= splay_tree_max (offsets
);
4022 /* If there aren't any empty subobjects, then there's no point in
4023 performing this check. */
4027 return walk_subobject_offsets (type
, check_subobject_offset
, offset
,
4028 offsets
, (tree
) (max_node
->key
),
4032 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
4033 non-static data member of the type indicated by RLI. BINFO is the
4034 binfo corresponding to the base subobject, OFFSETS maps offsets to
4035 types already located at those offsets. This function determines
4036 the position of the DECL. */
4039 layout_nonempty_base_or_field (record_layout_info rli
,
4044 tree offset
= NULL_TREE
;
4050 /* For the purposes of determining layout conflicts, we want to
4051 use the class type of BINFO; TREE_TYPE (DECL) will be the
4052 CLASSTYPE_AS_BASE version, which does not contain entries for
4053 zero-sized bases. */
4054 type
= TREE_TYPE (binfo
);
4059 type
= TREE_TYPE (decl
);
4063 /* Try to place the field. It may take more than one try if we have
4064 a hard time placing the field without putting two objects of the
4065 same type at the same address. */
4068 struct record_layout_info_s old_rli
= *rli
;
4070 /* Place this field. */
4071 place_field (rli
, decl
);
4072 offset
= byte_position (decl
);
4074 /* We have to check to see whether or not there is already
4075 something of the same type at the offset we're about to use.
4076 For example, consider:
4079 struct T : public S { int i; };
4080 struct U : public S, public T {};
4082 Here, we put S at offset zero in U. Then, we can't put T at
4083 offset zero -- its S component would be at the same address
4084 as the S we already allocated. So, we have to skip ahead.
4085 Since all data members, including those whose type is an
4086 empty class, have nonzero size, any overlap can happen only
4087 with a direct or indirect base-class -- it can't happen with
4089 /* In a union, overlap is permitted; all members are placed at
4091 if (TREE_CODE (rli
->t
) == UNION_TYPE
)
4093 if (layout_conflict_p (field_p
? type
: binfo
, offset
,
4096 /* Strip off the size allocated to this field. That puts us
4097 at the first place we could have put the field with
4098 proper alignment. */
4101 /* Bump up by the alignment required for the type. */
4103 = size_binop (PLUS_EXPR
, rli
->bitpos
,
4105 ? CLASSTYPE_ALIGN (type
)
4106 : TYPE_ALIGN (type
)));
4107 normalize_rli (rli
);
4110 /* There was no conflict. We're done laying out this field. */
4114 /* Now that we know where it will be placed, update its
4116 if (binfo
&& CLASS_TYPE_P (BINFO_TYPE (binfo
)))
4117 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
4118 this point because their BINFO_OFFSET is copied from another
4119 hierarchy. Therefore, we may not need to add the entire
4121 propagate_binfo_offsets (binfo
,
4122 size_diffop_loc (input_location
,
4123 convert (ssizetype
, offset
),
4125 BINFO_OFFSET (binfo
))));
4128 /* Returns true if TYPE is empty and OFFSET is nonzero. */
4131 empty_base_at_nonzero_offset_p (tree type
,
4133 splay_tree
/*offsets*/)
4135 return is_empty_class (type
) && !integer_zerop (offset
);
4138 /* Layout the empty base BINFO. EOC indicates the byte currently just
4139 past the end of the class, and should be correctly aligned for a
4140 class of the type indicated by BINFO; OFFSETS gives the offsets of
4141 the empty bases allocated so far. T is the most derived
4142 type. Return nonzero iff we added it at the end. */
4145 layout_empty_base (record_layout_info rli
, tree binfo
,
4146 tree eoc
, splay_tree offsets
)
4149 tree basetype
= BINFO_TYPE (binfo
);
4152 /* This routine should only be used for empty classes. */
4153 gcc_assert (is_empty_class (basetype
));
4154 alignment
= ssize_int (CLASSTYPE_ALIGN_UNIT (basetype
));
4156 if (!integer_zerop (BINFO_OFFSET (binfo
)))
4157 propagate_binfo_offsets
4158 (binfo
, size_diffop_loc (input_location
,
4159 size_zero_node
, BINFO_OFFSET (binfo
)));
4161 /* This is an empty base class. We first try to put it at offset
4163 if (layout_conflict_p (binfo
,
4164 BINFO_OFFSET (binfo
),
4168 /* That didn't work. Now, we move forward from the next
4169 available spot in the class. */
4171 propagate_binfo_offsets (binfo
, convert (ssizetype
, eoc
));
4174 if (!layout_conflict_p (binfo
,
4175 BINFO_OFFSET (binfo
),
4178 /* We finally found a spot where there's no overlap. */
4181 /* There's overlap here, too. Bump along to the next spot. */
4182 propagate_binfo_offsets (binfo
, alignment
);
4186 if (CLASSTYPE_USER_ALIGN (basetype
))
4188 rli
->record_align
= MAX (rli
->record_align
, CLASSTYPE_ALIGN (basetype
));
4190 rli
->unpacked_align
= MAX (rli
->unpacked_align
, CLASSTYPE_ALIGN (basetype
));
4191 TYPE_USER_ALIGN (rli
->t
) = 1;
4197 /* Layout the base given by BINFO in the class indicated by RLI.
4198 *BASE_ALIGN is a running maximum of the alignments of
4199 any base class. OFFSETS gives the location of empty base
4200 subobjects. T is the most derived type. Return nonzero if the new
4201 object cannot be nearly-empty. A new FIELD_DECL is inserted at
4202 *NEXT_FIELD, unless BINFO is for an empty base class.
4204 Returns the location at which the next field should be inserted. */
4207 build_base_field (record_layout_info rli
, tree binfo
,
4208 splay_tree offsets
, tree
*next_field
)
4211 tree basetype
= BINFO_TYPE (binfo
);
4213 if (!COMPLETE_TYPE_P (basetype
))
4214 /* This error is now reported in xref_tag, thus giving better
4215 location information. */
4218 /* Place the base class. */
4219 if (!is_empty_class (basetype
))
4223 /* The containing class is non-empty because it has a non-empty
4225 CLASSTYPE_EMPTY_P (t
) = 0;
4227 /* Create the FIELD_DECL. */
4228 decl
= build_decl (input_location
,
4229 FIELD_DECL
, NULL_TREE
, CLASSTYPE_AS_BASE (basetype
));
4230 DECL_ARTIFICIAL (decl
) = 1;
4231 DECL_IGNORED_P (decl
) = 1;
4232 DECL_FIELD_CONTEXT (decl
) = t
;
4233 if (CLASSTYPE_AS_BASE (basetype
))
4235 DECL_SIZE (decl
) = CLASSTYPE_SIZE (basetype
);
4236 DECL_SIZE_UNIT (decl
) = CLASSTYPE_SIZE_UNIT (basetype
);
4237 DECL_ALIGN (decl
) = CLASSTYPE_ALIGN (basetype
);
4238 DECL_USER_ALIGN (decl
) = CLASSTYPE_USER_ALIGN (basetype
);
4239 DECL_MODE (decl
) = TYPE_MODE (basetype
);
4240 DECL_FIELD_IS_BASE (decl
) = 1;
4242 /* Try to place the field. It may take more than one try if we
4243 have a hard time placing the field without putting two
4244 objects of the same type at the same address. */
4245 layout_nonempty_base_or_field (rli
, decl
, binfo
, offsets
);
4246 /* Add the new FIELD_DECL to the list of fields for T. */
4247 DECL_CHAIN (decl
) = *next_field
;
4249 next_field
= &DECL_CHAIN (decl
);
4257 /* On some platforms (ARM), even empty classes will not be
4259 eoc
= round_up_loc (input_location
,
4260 rli_size_unit_so_far (rli
),
4261 CLASSTYPE_ALIGN_UNIT (basetype
));
4262 atend
= layout_empty_base (rli
, binfo
, eoc
, offsets
);
4263 /* A nearly-empty class "has no proper base class that is empty,
4264 not morally virtual, and at an offset other than zero." */
4265 if (!BINFO_VIRTUAL_P (binfo
) && CLASSTYPE_NEARLY_EMPTY_P (t
))
4268 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4269 /* The check above (used in G++ 3.2) is insufficient because
4270 an empty class placed at offset zero might itself have an
4271 empty base at a nonzero offset. */
4272 else if (walk_subobject_offsets (basetype
,
4273 empty_base_at_nonzero_offset_p
,
4276 /*max_offset=*/NULL_TREE
,
4278 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
4281 /* We do not create a FIELD_DECL for empty base classes because
4282 it might overlap some other field. We want to be able to
4283 create CONSTRUCTORs for the class by iterating over the
4284 FIELD_DECLs, and the back end does not handle overlapping
4287 /* An empty virtual base causes a class to be non-empty
4288 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
4289 here because that was already done when the virtual table
4290 pointer was created. */
4293 /* Record the offsets of BINFO and its base subobjects. */
4294 record_subobject_offsets (binfo
,
4295 BINFO_OFFSET (binfo
),
4297 /*is_data_member=*/false);
4302 /* Layout all of the non-virtual base classes. Record empty
4303 subobjects in OFFSETS. T is the most derived type. Return nonzero
4304 if the type cannot be nearly empty. The fields created
4305 corresponding to the base classes will be inserted at
4309 build_base_fields (record_layout_info rli
,
4310 splay_tree offsets
, tree
*next_field
)
4312 /* Chain to hold all the new FIELD_DECLs which stand in for base class
4315 int n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (t
));
4318 /* The primary base class is always allocated first. */
4319 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
4320 next_field
= build_base_field (rli
, CLASSTYPE_PRIMARY_BINFO (t
),
4321 offsets
, next_field
);
4323 /* Now allocate the rest of the bases. */
4324 for (i
= 0; i
< n_baseclasses
; ++i
)
4328 base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (t
), i
);
4330 /* The primary base was already allocated above, so we don't
4331 need to allocate it again here. */
4332 if (base_binfo
== CLASSTYPE_PRIMARY_BINFO (t
))
4335 /* Virtual bases are added at the end (a primary virtual base
4336 will have already been added). */
4337 if (BINFO_VIRTUAL_P (base_binfo
))
4340 next_field
= build_base_field (rli
, base_binfo
,
4341 offsets
, next_field
);
4345 /* Go through the TYPE_METHODS of T issuing any appropriate
4346 diagnostics, figuring out which methods override which other
4347 methods, and so forth. */
4350 check_methods (tree t
)
4354 for (x
= TYPE_METHODS (t
); x
; x
= DECL_CHAIN (x
))
4356 check_for_override (x
, t
);
4357 if (DECL_PURE_VIRTUAL_P (x
) && (TREE_CODE (x
) != FUNCTION_DECL
|| ! DECL_VINDEX (x
)))
4358 error ("initializer specified for non-virtual method %q+D", x
);
4359 /* The name of the field is the original field name
4360 Save this in auxiliary field for later overloading. */
4361 if (TREE_CODE (x
) == FUNCTION_DECL
&& DECL_VINDEX (x
))
4363 TYPE_POLYMORPHIC_P (t
) = 1;
4364 if (DECL_PURE_VIRTUAL_P (x
))
4365 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t
), x
);
4367 /* All user-provided destructors are non-trivial.
4368 Constructors and assignment ops are handled in
4369 grok_special_member_properties. */
4370 if (DECL_DESTRUCTOR_P (x
) && user_provided_p (x
))
4371 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
) = 1;
4375 /* FN is a constructor or destructor. Clone the declaration to create
4376 a specialized in-charge or not-in-charge version, as indicated by
4380 build_clone (tree fn
, tree name
)
4385 /* Copy the function. */
4386 clone
= copy_decl (fn
);
4387 /* Reset the function name. */
4388 DECL_NAME (clone
) = name
;
4389 /* Remember where this function came from. */
4390 DECL_ABSTRACT_ORIGIN (clone
) = fn
;
4391 /* Make it easy to find the CLONE given the FN. */
4392 DECL_CHAIN (clone
) = DECL_CHAIN (fn
);
4393 DECL_CHAIN (fn
) = clone
;
4395 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
4396 if (TREE_CODE (clone
) == TEMPLATE_DECL
)
4398 tree result
= build_clone (DECL_TEMPLATE_RESULT (clone
), name
);
4399 DECL_TEMPLATE_RESULT (clone
) = result
;
4400 DECL_TEMPLATE_INFO (result
) = copy_node (DECL_TEMPLATE_INFO (result
));
4401 DECL_TI_TEMPLATE (result
) = clone
;
4402 TREE_TYPE (clone
) = TREE_TYPE (result
);
4406 SET_DECL_ASSEMBLER_NAME (clone
, NULL_TREE
);
4407 DECL_CLONED_FUNCTION (clone
) = fn
;
4408 /* There's no pending inline data for this function. */
4409 DECL_PENDING_INLINE_INFO (clone
) = NULL
;
4410 DECL_PENDING_INLINE_P (clone
) = 0;
4412 /* The base-class destructor is not virtual. */
4413 if (name
== base_dtor_identifier
)
4415 DECL_VIRTUAL_P (clone
) = 0;
4416 if (TREE_CODE (clone
) != TEMPLATE_DECL
)
4417 DECL_VINDEX (clone
) = NULL_TREE
;
4420 /* If there was an in-charge parameter, drop it from the function
4422 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
4428 exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4429 basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4430 parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4431 /* Skip the `this' parameter. */
4432 parmtypes
= TREE_CHAIN (parmtypes
);
4433 /* Skip the in-charge parameter. */
4434 parmtypes
= TREE_CHAIN (parmtypes
);
4435 /* And the VTT parm, in a complete [cd]tor. */
4436 if (DECL_HAS_VTT_PARM_P (fn
)
4437 && ! DECL_NEEDS_VTT_PARM_P (clone
))
4438 parmtypes
= TREE_CHAIN (parmtypes
);
4439 /* If this is subobject constructor or destructor, add the vtt
4442 = build_method_type_directly (basetype
,
4443 TREE_TYPE (TREE_TYPE (clone
)),
4446 TREE_TYPE (clone
) = build_exception_variant (TREE_TYPE (clone
),
4449 = cp_build_type_attribute_variant (TREE_TYPE (clone
),
4450 TYPE_ATTRIBUTES (TREE_TYPE (fn
)));
4453 /* Copy the function parameters. */
4454 DECL_ARGUMENTS (clone
) = copy_list (DECL_ARGUMENTS (clone
));
4455 /* Remove the in-charge parameter. */
4456 if (DECL_HAS_IN_CHARGE_PARM_P (clone
))
4458 DECL_CHAIN (DECL_ARGUMENTS (clone
))
4459 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
)));
4460 DECL_HAS_IN_CHARGE_PARM_P (clone
) = 0;
4462 /* And the VTT parm, in a complete [cd]tor. */
4463 if (DECL_HAS_VTT_PARM_P (fn
))
4465 if (DECL_NEEDS_VTT_PARM_P (clone
))
4466 DECL_HAS_VTT_PARM_P (clone
) = 1;
4469 DECL_CHAIN (DECL_ARGUMENTS (clone
))
4470 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone
)));
4471 DECL_HAS_VTT_PARM_P (clone
) = 0;
4475 for (parms
= DECL_ARGUMENTS (clone
); parms
; parms
= DECL_CHAIN (parms
))
4477 DECL_CONTEXT (parms
) = clone
;
4478 cxx_dup_lang_specific_decl (parms
);
4481 /* Create the RTL for this function. */
4482 SET_DECL_RTL (clone
, NULL
);
4483 rest_of_decl_compilation (clone
, /*top_level=*/1, at_eof
);
4486 note_decl_for_pch (clone
);
4491 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
4492 not invoke this function directly.
4494 For a non-thunk function, returns the address of the slot for storing
4495 the function it is a clone of. Otherwise returns NULL_TREE.
4497 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
4498 cloned_function is unset. This is to support the separate
4499 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
4500 on a template makes sense, but not the former. */
4503 decl_cloned_function_p (const_tree decl
, bool just_testing
)
4507 decl
= STRIP_TEMPLATE (decl
);
4509 if (TREE_CODE (decl
) != FUNCTION_DECL
4510 || !DECL_LANG_SPECIFIC (decl
)
4511 || DECL_LANG_SPECIFIC (decl
)->u
.fn
.thunk_p
)
4513 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4515 lang_check_failed (__FILE__
, __LINE__
, __FUNCTION__
);
4521 ptr
= &DECL_LANG_SPECIFIC (decl
)->u
.fn
.u5
.cloned_function
;
4522 if (just_testing
&& *ptr
== NULL_TREE
)
4528 /* Produce declarations for all appropriate clones of FN. If
4529 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4530 CLASTYPE_METHOD_VEC as well. */
4533 clone_function_decl (tree fn
, int update_method_vec_p
)
4537 /* Avoid inappropriate cloning. */
4539 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (fn
)))
4542 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn
))
4544 /* For each constructor, we need two variants: an in-charge version
4545 and a not-in-charge version. */
4546 clone
= build_clone (fn
, complete_ctor_identifier
);
4547 if (update_method_vec_p
)
4548 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4549 clone
= build_clone (fn
, base_ctor_identifier
);
4550 if (update_method_vec_p
)
4551 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4555 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
));
4557 /* For each destructor, we need three variants: an in-charge
4558 version, a not-in-charge version, and an in-charge deleting
4559 version. We clone the deleting version first because that
4560 means it will go second on the TYPE_METHODS list -- and that
4561 corresponds to the correct layout order in the virtual
4564 For a non-virtual destructor, we do not build a deleting
4566 if (DECL_VIRTUAL_P (fn
))
4568 clone
= build_clone (fn
, deleting_dtor_identifier
);
4569 if (update_method_vec_p
)
4570 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4572 clone
= build_clone (fn
, complete_dtor_identifier
);
4573 if (update_method_vec_p
)
4574 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4575 clone
= build_clone (fn
, base_dtor_identifier
);
4576 if (update_method_vec_p
)
4577 add_method (DECL_CONTEXT (clone
), clone
, NULL_TREE
);
4580 /* Note that this is an abstract function that is never emitted. */
4581 DECL_ABSTRACT (fn
) = 1;
4584 /* DECL is an in charge constructor, which is being defined. This will
4585 have had an in class declaration, from whence clones were
4586 declared. An out-of-class definition can specify additional default
4587 arguments. As it is the clones that are involved in overload
4588 resolution, we must propagate the information from the DECL to its
4592 adjust_clone_args (tree decl
)
4596 for (clone
= DECL_CHAIN (decl
); clone
&& DECL_CLONED_FUNCTION_P (clone
);
4597 clone
= DECL_CHAIN (clone
))
4599 tree orig_clone_parms
= TYPE_ARG_TYPES (TREE_TYPE (clone
));
4600 tree orig_decl_parms
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
4601 tree decl_parms
, clone_parms
;
4603 clone_parms
= orig_clone_parms
;
4605 /* Skip the 'this' parameter. */
4606 orig_clone_parms
= TREE_CHAIN (orig_clone_parms
);
4607 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4609 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
4610 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4611 if (DECL_HAS_VTT_PARM_P (decl
))
4612 orig_decl_parms
= TREE_CHAIN (orig_decl_parms
);
4614 clone_parms
= orig_clone_parms
;
4615 if (DECL_HAS_VTT_PARM_P (clone
))
4616 clone_parms
= TREE_CHAIN (clone_parms
);
4618 for (decl_parms
= orig_decl_parms
; decl_parms
;
4619 decl_parms
= TREE_CHAIN (decl_parms
),
4620 clone_parms
= TREE_CHAIN (clone_parms
))
4622 gcc_assert (same_type_p (TREE_TYPE (decl_parms
),
4623 TREE_TYPE (clone_parms
)));
4625 if (TREE_PURPOSE (decl_parms
) && !TREE_PURPOSE (clone_parms
))
4627 /* A default parameter has been added. Adjust the
4628 clone's parameters. */
4629 tree exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone
));
4630 tree attrs
= TYPE_ATTRIBUTES (TREE_TYPE (clone
));
4631 tree basetype
= TYPE_METHOD_BASETYPE (TREE_TYPE (clone
));
4634 clone_parms
= orig_decl_parms
;
4636 if (DECL_HAS_VTT_PARM_P (clone
))
4638 clone_parms
= tree_cons (TREE_PURPOSE (orig_clone_parms
),
4639 TREE_VALUE (orig_clone_parms
),
4641 TREE_TYPE (clone_parms
) = TREE_TYPE (orig_clone_parms
);
4643 type
= build_method_type_directly (basetype
,
4644 TREE_TYPE (TREE_TYPE (clone
)),
4647 type
= build_exception_variant (type
, exceptions
);
4649 type
= cp_build_type_attribute_variant (type
, attrs
);
4650 TREE_TYPE (clone
) = type
;
4652 clone_parms
= NULL_TREE
;
4656 gcc_assert (!clone_parms
);
4660 /* For each of the constructors and destructors in T, create an
4661 in-charge and not-in-charge variant. */
4664 clone_constructors_and_destructors (tree t
)
4668 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4670 if (!CLASSTYPE_METHOD_VEC (t
))
4673 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4674 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
4675 for (fns
= CLASSTYPE_DESTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4676 clone_function_decl (OVL_CURRENT (fns
), /*update_method_vec_p=*/1);
4679 /* Deduce noexcept for a destructor DTOR. */
4682 deduce_noexcept_on_destructor (tree dtor
)
4684 if (!TYPE_RAISES_EXCEPTIONS (TREE_TYPE (dtor
)))
4686 tree eh_spec
= unevaluated_noexcept_spec ();
4687 TREE_TYPE (dtor
) = build_exception_variant (TREE_TYPE (dtor
), eh_spec
);
4691 /* For each destructor in T, deduce noexcept:
4693 12.4/3: A declaration of a destructor that does not have an
4694 exception-specification is implicitly considered to have the
4695 same exception-specification as an implicit declaration (15.4). */
4698 deduce_noexcept_on_destructors (tree t
)
4700 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4702 if (!CLASSTYPE_METHOD_VEC (t
))
4705 for (tree fns
= CLASSTYPE_DESTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4706 deduce_noexcept_on_destructor (OVL_CURRENT (fns
));
4709 /* Subroutine of set_one_vmethod_tm_attributes. Search base classes
4710 of TYPE for virtual functions which FNDECL overrides. Return a
4711 mask of the tm attributes found therein. */
4714 look_for_tm_attr_overrides (tree type
, tree fndecl
)
4716 tree binfo
= TYPE_BINFO (type
);
4720 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ++ix
)
4722 tree o
, basetype
= BINFO_TYPE (base_binfo
);
4724 if (!TYPE_POLYMORPHIC_P (basetype
))
4727 o
= look_for_overrides_here (basetype
, fndecl
);
4729 found
|= tm_attr_to_mask (find_tm_attribute
4730 (TYPE_ATTRIBUTES (TREE_TYPE (o
))));
4732 found
|= look_for_tm_attr_overrides (basetype
, fndecl
);
4738 /* Subroutine of set_method_tm_attributes. Handle the checks and
4739 inheritance for one virtual method FNDECL. */
4742 set_one_vmethod_tm_attributes (tree type
, tree fndecl
)
4747 found
= look_for_tm_attr_overrides (type
, fndecl
);
4749 /* If FNDECL doesn't actually override anything (i.e. T is the
4750 class that first declares FNDECL virtual), then we're done. */
4754 tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl
)));
4755 have
= tm_attr_to_mask (tm_attr
);
4757 /* Intel STM Language Extension 3.0, Section 4.2 table 4:
4758 tm_pure must match exactly, otherwise no weakening of
4759 tm_safe > tm_callable > nothing. */
4760 /* ??? The tm_pure attribute didn't make the transition to the
4761 multivendor language spec. */
4762 if (have
== TM_ATTR_PURE
)
4764 if (found
!= TM_ATTR_PURE
)
4770 /* If the overridden function is tm_pure, then FNDECL must be. */
4771 else if (found
== TM_ATTR_PURE
&& tm_attr
)
4773 /* Look for base class combinations that cannot be satisfied. */
4774 else if (found
!= TM_ATTR_PURE
&& (found
& TM_ATTR_PURE
))
4776 found
&= ~TM_ATTR_PURE
;
4778 error_at (DECL_SOURCE_LOCATION (fndecl
),
4779 "method overrides both %<transaction_pure%> and %qE methods",
4780 tm_mask_to_attr (found
));
4782 /* If FNDECL did not declare an attribute, then inherit the most
4784 else if (tm_attr
== NULL
)
4786 apply_tm_attr (fndecl
, tm_mask_to_attr (found
& -found
));
4788 /* Otherwise validate that we're not weaker than a function
4789 that is being overridden. */
4793 if (found
<= TM_ATTR_CALLABLE
&& have
> found
)
4799 error_at (DECL_SOURCE_LOCATION (fndecl
),
4800 "method declared %qE overriding %qE method",
4801 tm_attr
, tm_mask_to_attr (found
));
4804 /* For each of the methods in T, propagate a class-level tm attribute. */
4807 set_method_tm_attributes (tree t
)
4809 tree class_tm_attr
, fndecl
;
4811 /* Don't bother collecting tm attributes if transactional memory
4812 support is not enabled. */
4816 /* Process virtual methods first, as they inherit directly from the
4817 base virtual function and also require validation of new attributes. */
4818 if (TYPE_CONTAINS_VPTR_P (t
))
4821 for (vchain
= BINFO_VIRTUALS (TYPE_BINFO (t
)); vchain
;
4822 vchain
= TREE_CHAIN (vchain
))
4824 fndecl
= BV_FN (vchain
);
4825 if (DECL_THUNK_P (fndecl
))
4826 fndecl
= THUNK_TARGET (fndecl
);
4827 set_one_vmethod_tm_attributes (t
, fndecl
);
4831 /* If the class doesn't have an attribute, nothing more to do. */
4832 class_tm_attr
= find_tm_attribute (TYPE_ATTRIBUTES (t
));
4833 if (class_tm_attr
== NULL
)
4836 /* Any method that does not yet have a tm attribute inherits
4837 the one from the class. */
4838 for (fndecl
= TYPE_METHODS (t
); fndecl
; fndecl
= TREE_CHAIN (fndecl
))
4840 if (!find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
4841 apply_tm_attr (fndecl
, class_tm_attr
);
4845 /* Returns true iff class T has a user-defined constructor other than
4846 the default constructor. */
4849 type_has_user_nondefault_constructor (tree t
)
4853 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4856 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4858 tree fn
= OVL_CURRENT (fns
);
4859 if (!DECL_ARTIFICIAL (fn
)
4860 && (TREE_CODE (fn
) == TEMPLATE_DECL
4861 || (skip_artificial_parms_for (fn
, DECL_ARGUMENTS (fn
))
4869 /* Returns the defaulted constructor if T has one. Otherwise, returns
4873 in_class_defaulted_default_constructor (tree t
)
4877 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4880 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4882 tree fn
= OVL_CURRENT (fns
);
4884 if (DECL_DEFAULTED_IN_CLASS_P (fn
))
4886 args
= FUNCTION_FIRST_USER_PARMTYPE (fn
);
4887 while (args
&& TREE_PURPOSE (args
))
4888 args
= TREE_CHAIN (args
);
4889 if (!args
|| args
== void_list_node
)
4897 /* Returns true iff FN is a user-provided function, i.e. user-declared
4898 and not defaulted at its first declaration; or explicit, private,
4899 protected, or non-const. */
4902 user_provided_p (tree fn
)
4904 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
4907 return (!DECL_ARTIFICIAL (fn
)
4908 && !(DECL_INITIALIZED_IN_CLASS_P (fn
)
4909 && (DECL_DEFAULTED_FN (fn
) || DECL_DELETED_FN (fn
))));
4912 /* Returns true iff class T has a user-provided constructor. */
4915 type_has_user_provided_constructor (tree t
)
4919 if (!CLASS_TYPE_P (t
))
4922 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4925 /* This can happen in error cases; avoid crashing. */
4926 if (!CLASSTYPE_METHOD_VEC (t
))
4929 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4930 if (user_provided_p (OVL_CURRENT (fns
)))
4936 /* Returns true iff class T has a user-provided default constructor. */
4939 type_has_user_provided_default_constructor (tree t
)
4943 if (!TYPE_HAS_USER_CONSTRUCTOR (t
))
4946 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
4948 tree fn
= OVL_CURRENT (fns
);
4949 if (TREE_CODE (fn
) == FUNCTION_DECL
4950 && user_provided_p (fn
)
4951 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)))
4958 /* TYPE is being used as a virtual base, and has a non-trivial move
4959 assignment. Return true if this is due to there being a user-provided
4960 move assignment in TYPE or one of its subobjects; if there isn't, then
4961 multiple move assignment can't cause any harm. */
4964 vbase_has_user_provided_move_assign (tree type
)
4966 /* Does the type itself have a user-provided move assignment operator? */
4968 = lookup_fnfields_slot_nolazy (type
, ansi_assopname (NOP_EXPR
));
4969 fns
; fns
= OVL_NEXT (fns
))
4971 tree fn
= OVL_CURRENT (fns
);
4972 if (move_fn_p (fn
) && user_provided_p (fn
))
4976 /* Do any of its bases? */
4977 tree binfo
= TYPE_BINFO (type
);
4979 for (int i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
4980 if (vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo
)))
4983 /* Or non-static data members? */
4984 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
4986 if (TREE_CODE (field
) == FIELD_DECL
4987 && CLASS_TYPE_P (TREE_TYPE (field
))
4988 && vbase_has_user_provided_move_assign (TREE_TYPE (field
)))
4996 /* If default-initialization leaves part of TYPE uninitialized, returns
4997 a DECL for the field or TYPE itself (DR 253). */
5000 default_init_uninitialized_part (tree type
)
5005 type
= strip_array_types (type
);
5006 if (!CLASS_TYPE_P (type
))
5008 if (type_has_user_provided_default_constructor (type
))
5010 for (binfo
= TYPE_BINFO (type
), i
= 0;
5011 BINFO_BASE_ITERATE (binfo
, i
, t
); ++i
)
5013 r
= default_init_uninitialized_part (BINFO_TYPE (t
));
5017 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
5018 if (TREE_CODE (t
) == FIELD_DECL
5019 && !DECL_ARTIFICIAL (t
)
5020 && !DECL_INITIAL (t
))
5022 r
= default_init_uninitialized_part (TREE_TYPE (t
));
5024 return DECL_P (r
) ? r
: t
;
5030 /* Returns true iff for class T, a trivial synthesized default constructor
5031 would be constexpr. */
5034 trivial_default_constructor_is_constexpr (tree t
)
5036 /* A defaulted trivial default constructor is constexpr
5037 if there is nothing to initialize. */
5038 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (t
));
5039 return is_really_empty_class (t
);
5042 /* Returns true iff class T has a constexpr default constructor. */
5045 type_has_constexpr_default_constructor (tree t
)
5049 if (!CLASS_TYPE_P (t
))
5051 /* The caller should have stripped an enclosing array. */
5052 gcc_assert (TREE_CODE (t
) != ARRAY_TYPE
);
5055 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t
))
5057 if (!TYPE_HAS_COMPLEX_DFLT (t
))
5058 return trivial_default_constructor_is_constexpr (t
);
5059 /* Non-trivial, we need to check subobject constructors. */
5060 lazily_declare_fn (sfk_constructor
, t
);
5062 fns
= locate_ctor (t
);
5063 return (fns
&& DECL_DECLARED_CONSTEXPR_P (fns
));
5066 /* Returns true iff class TYPE has a virtual destructor. */
5069 type_has_virtual_destructor (tree type
)
5073 if (!CLASS_TYPE_P (type
))
5076 gcc_assert (COMPLETE_TYPE_P (type
));
5077 dtor
= CLASSTYPE_DESTRUCTORS (type
);
5078 return (dtor
&& DECL_VIRTUAL_P (dtor
));
5081 /* Returns true iff class T has a move constructor. */
5084 type_has_move_constructor (tree t
)
5088 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
5090 gcc_assert (COMPLETE_TYPE_P (t
));
5091 lazily_declare_fn (sfk_move_constructor
, t
);
5094 if (!CLASSTYPE_METHOD_VEC (t
))
5097 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5098 if (move_fn_p (OVL_CURRENT (fns
)))
5104 /* Returns true iff class T has a move assignment operator. */
5107 type_has_move_assign (tree t
)
5111 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
5113 gcc_assert (COMPLETE_TYPE_P (t
));
5114 lazily_declare_fn (sfk_move_assignment
, t
);
5117 for (fns
= lookup_fnfields_slot_nolazy (t
, ansi_assopname (NOP_EXPR
));
5118 fns
; fns
= OVL_NEXT (fns
))
5119 if (move_fn_p (OVL_CURRENT (fns
)))
5125 /* Returns true iff class T has a move constructor that was explicitly
5126 declared in the class body. Note that this is different from
5127 "user-provided", which doesn't include functions that are defaulted in
5131 type_has_user_declared_move_constructor (tree t
)
5135 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
5138 if (!CLASSTYPE_METHOD_VEC (t
))
5141 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5143 tree fn
= OVL_CURRENT (fns
);
5144 if (move_fn_p (fn
) && !DECL_ARTIFICIAL (fn
))
5151 /* Returns true iff class T has a move assignment operator that was
5152 explicitly declared in the class body. */
5155 type_has_user_declared_move_assign (tree t
)
5159 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t
))
5162 for (fns
= lookup_fnfields_slot_nolazy (t
, ansi_assopname (NOP_EXPR
));
5163 fns
; fns
= OVL_NEXT (fns
))
5165 tree fn
= OVL_CURRENT (fns
);
5166 if (move_fn_p (fn
) && !DECL_ARTIFICIAL (fn
))
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 (tree fns
= lookup_fnfields_slot (inner
, complete_ctor_identifier
);
5199 fns
; fns
= OVL_NEXT (fns
))
5201 tree fn
= OVL_CURRENT (fns
);
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 (tree fns
= lookup_fnfields_slot (inner
, complete_dtor_identifier
);
5226 fns
; fns
= OVL_NEXT (fns
))
5228 tree fn
= OVL_CURRENT (fns
);
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_INITIAL (*fieldsp).
5251 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
5253 && integer_zerop (DECL_SIZE (*fieldsp
)))
5254 *fieldsp
= DECL_CHAIN (*fieldsp
);
5256 fieldsp
= &DECL_CHAIN (*fieldsp
);
5260 /* Returns TRUE iff we need a cookie when dynamically allocating an
5261 array whose elements have the indicated class TYPE. */
5264 type_requires_array_cookie (tree type
)
5267 bool has_two_argument_delete_p
= false;
5269 gcc_assert (CLASS_TYPE_P (type
));
5271 /* If there's a non-trivial destructor, we need a cookie. In order
5272 to iterate through the array calling the destructor for each
5273 element, we'll have to know how many elements there are. */
5274 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
5277 /* If the usual deallocation function is a two-argument whose second
5278 argument is of type `size_t', then we have to pass the size of
5279 the array to the deallocation function, so we will need to store
5281 fns
= lookup_fnfields (TYPE_BINFO (type
),
5282 ansi_opname (VEC_DELETE_EXPR
),
5284 /* If there are no `operator []' members, or the lookup is
5285 ambiguous, then we don't need a cookie. */
5286 if (!fns
|| fns
== error_mark_node
)
5288 /* Loop through all of the functions. */
5289 for (fns
= BASELINK_FUNCTIONS (fns
); fns
; fns
= OVL_NEXT (fns
))
5294 /* Select the current function. */
5295 fn
= OVL_CURRENT (fns
);
5296 /* See if this function is a one-argument delete function. If
5297 it is, then it will be the usual deallocation function. */
5298 second_parm
= TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn
)));
5299 if (second_parm
== void_list_node
)
5301 /* Do not consider this function if its second argument is an
5305 /* Otherwise, if we have a two-argument function and the second
5306 argument is `size_t', it will be the usual deallocation
5307 function -- unless there is one-argument function, too. */
5308 if (TREE_CHAIN (second_parm
) == void_list_node
5309 && same_type_p (TREE_VALUE (second_parm
), size_type_node
))
5310 has_two_argument_delete_p
= true;
5313 return has_two_argument_delete_p
;
5316 /* Finish computing the `literal type' property of class type T.
5318 At this point, we have already processed base classes and
5319 non-static data members. We need to check whether the copy
5320 constructor is trivial, the destructor is trivial, and there
5321 is a trivial default constructor or at least one constexpr
5322 constructor other than the copy constructor. */
5325 finalize_literal_type_property (tree t
)
5329 if (cxx_dialect
< cxx11
5330 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5331 CLASSTYPE_LITERAL_P (t
) = false;
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 if (!CLASSTYPE_LITERAL_P (t
))
5338 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5339 if (DECL_DECLARED_CONSTEXPR_P (fn
)
5340 && TREE_CODE (fn
) != TEMPLATE_DECL
5341 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
5342 && !DECL_CONSTRUCTOR_P (fn
))
5344 DECL_DECLARED_CONSTEXPR_P (fn
) = false;
5345 if (!DECL_GENERATED_P (fn
))
5347 error ("enclosing class of constexpr non-static member "
5348 "function %q+#D is not a literal type", fn
);
5349 explain_non_literal_class (t
);
5354 /* T is a non-literal type used in a context which requires a constant
5355 expression. Explain why it isn't literal. */
5358 explain_non_literal_class (tree t
)
5360 static hash_set
<tree
> *diagnosed
;
5362 if (!CLASS_TYPE_P (t
))
5364 t
= TYPE_MAIN_VARIANT (t
);
5366 if (diagnosed
== NULL
)
5367 diagnosed
= new hash_set
<tree
>;
5368 if (diagnosed
->add (t
))
5369 /* Already explained. */
5372 inform (0, "%q+T is not literal because:", t
);
5373 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
))
5374 inform (0, " %q+T has a non-trivial destructor", t
);
5375 else if (CLASSTYPE_NON_AGGREGATE (t
)
5376 && !TYPE_HAS_TRIVIAL_DFLT (t
)
5377 && !TYPE_HAS_CONSTEXPR_CTOR (t
))
5379 inform (0, " %q+T is not an aggregate, does not have a trivial "
5380 "default constructor, and has no constexpr constructor that "
5381 "is not a copy or move constructor", t
);
5382 if (TYPE_HAS_DEFAULT_CONSTRUCTOR (t
)
5383 && !type_has_user_provided_default_constructor (t
))
5385 /* Note that we can't simply call locate_ctor because when the
5386 constructor is deleted it just returns NULL_TREE. */
5388 for (fns
= CLASSTYPE_CONSTRUCTORS (t
); fns
; fns
= OVL_NEXT (fns
))
5390 tree fn
= OVL_CURRENT (fns
);
5391 tree parms
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
5393 parms
= skip_artificial_parms_for (fn
, parms
);
5395 if (sufficient_parms_p (parms
))
5397 if (DECL_DELETED_FN (fn
))
5398 maybe_explain_implicit_delete (fn
);
5400 explain_invalid_constexpr_fn (fn
);
5408 tree binfo
, base_binfo
, field
; int i
;
5409 for (binfo
= TYPE_BINFO (t
), i
= 0;
5410 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5412 tree basetype
= TREE_TYPE (base_binfo
);
5413 if (!CLASSTYPE_LITERAL_P (basetype
))
5415 inform (0, " base class %qT of %q+T is non-literal",
5417 explain_non_literal_class (basetype
);
5421 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
5424 if (TREE_CODE (field
) != FIELD_DECL
)
5426 ftype
= TREE_TYPE (field
);
5427 if (!literal_type_p (ftype
))
5429 inform (0, " non-static data member %q+D has "
5430 "non-literal type", field
);
5431 if (CLASS_TYPE_P (ftype
))
5432 explain_non_literal_class (ftype
);
5438 /* Check the validity of the bases and members declared in T. Add any
5439 implicitly-generated functions (like copy-constructors and
5440 assignment operators). Compute various flag bits (like
5441 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
5442 level: i.e., independently of the ABI in use. */
5445 check_bases_and_members (tree t
)
5447 /* Nonzero if the implicitly generated copy constructor should take
5448 a non-const reference argument. */
5449 int cant_have_const_ctor
;
5450 /* Nonzero if the implicitly generated assignment operator
5451 should take a non-const reference argument. */
5452 int no_const_asn_ref
;
5454 bool saved_complex_asn_ref
;
5455 bool saved_nontrivial_dtor
;
5458 /* Pick up any abi_tags from our template arguments before checking. */
5459 inherit_targ_abi_tags (t
);
5461 /* By default, we use const reference arguments and generate default
5463 cant_have_const_ctor
= 0;
5464 no_const_asn_ref
= 0;
5466 /* Check all the base-classes. */
5467 check_bases (t
, &cant_have_const_ctor
,
5470 /* Deduce noexcept on destructors. This needs to happen after we've set
5471 triviality flags appropriately for our bases. */
5472 if (cxx_dialect
>= cxx11
)
5473 deduce_noexcept_on_destructors (t
);
5475 /* Check all the method declarations. */
5478 /* Save the initial values of these flags which only indicate whether
5479 or not the class has user-provided functions. As we analyze the
5480 bases and members we can set these flags for other reasons. */
5481 saved_complex_asn_ref
= TYPE_HAS_COMPLEX_COPY_ASSIGN (t
);
5482 saved_nontrivial_dtor
= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
);
5484 /* Check all the data member declarations. We cannot call
5485 check_field_decls until we have called check_bases check_methods,
5486 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5487 being set appropriately. */
5488 check_field_decls (t
, &access_decls
,
5489 &cant_have_const_ctor
,
5492 /* A nearly-empty class has to be vptr-containing; a nearly empty
5493 class contains just a vptr. */
5494 if (!TYPE_CONTAINS_VPTR_P (t
))
5495 CLASSTYPE_NEARLY_EMPTY_P (t
) = 0;
5497 /* Do some bookkeeping that will guide the generation of implicitly
5498 declared member functions. */
5499 TYPE_HAS_COMPLEX_COPY_CTOR (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5500 TYPE_HAS_COMPLEX_MOVE_CTOR (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5501 /* We need to call a constructor for this class if it has a
5502 user-provided constructor, or if the default constructor is going
5503 to initialize the vptr. (This is not an if-and-only-if;
5504 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
5505 themselves need constructing.) */
5506 TYPE_NEEDS_CONSTRUCTING (t
)
5507 |= (type_has_user_provided_constructor (t
) || TYPE_CONTAINS_VPTR_P (t
));
5510 An aggregate is an array or a class with no user-provided
5511 constructors ... and no virtual functions.
5513 Again, other conditions for being an aggregate are checked
5515 CLASSTYPE_NON_AGGREGATE (t
)
5516 |= (type_has_user_provided_constructor (t
) || TYPE_POLYMORPHIC_P (t
));
5517 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
5518 retain the old definition internally for ABI reasons. */
5519 CLASSTYPE_NON_LAYOUT_POD_P (t
)
5520 |= (CLASSTYPE_NON_AGGREGATE (t
)
5521 || saved_nontrivial_dtor
|| saved_complex_asn_ref
);
5522 CLASSTYPE_NON_STD_LAYOUT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5523 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5524 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5525 TYPE_HAS_COMPLEX_DFLT (t
) |= TYPE_CONTAINS_VPTR_P (t
);
5527 /* Warn if a public base of a polymorphic type has an accessible
5528 non-virtual destructor. It is only now that we know the class is
5529 polymorphic. Although a polymorphic base will have a already
5530 been diagnosed during its definition, we warn on use too. */
5531 if (TYPE_POLYMORPHIC_P (t
) && warn_nonvdtor
)
5533 tree binfo
= TYPE_BINFO (t
);
5534 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
5538 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
5540 tree basetype
= TREE_TYPE (base_binfo
);
5542 if ((*accesses
)[i
] == access_public_node
5543 && (TYPE_POLYMORPHIC_P (basetype
) || warn_ecpp
)
5544 && accessible_nvdtor_p (basetype
))
5545 warning (OPT_Wnon_virtual_dtor
,
5546 "base class %q#T has accessible non-virtual destructor",
5551 /* If the class has no user-declared constructor, but does have
5552 non-static const or reference data members that can never be
5553 initialized, issue a warning. */
5554 if (warn_uninitialized
5555 /* Classes with user-declared constructors are presumed to
5556 initialize these members. */
5557 && !TYPE_HAS_USER_CONSTRUCTOR (t
)
5558 /* Aggregates can be initialized with brace-enclosed
5560 && CLASSTYPE_NON_AGGREGATE (t
))
5564 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
5568 if (TREE_CODE (field
) != FIELD_DECL
5569 || DECL_INITIAL (field
) != NULL_TREE
)
5572 type
= TREE_TYPE (field
);
5573 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5574 warning (OPT_Wuninitialized
, "non-static reference %q+#D "
5575 "in class without a constructor", field
);
5576 else if (CP_TYPE_CONST_P (type
)
5577 && (!CLASS_TYPE_P (type
)
5578 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
5579 warning (OPT_Wuninitialized
, "non-static const member %q+#D "
5580 "in class without a constructor", field
);
5584 /* Synthesize any needed methods. */
5585 add_implicitly_declared_members (t
, &access_decls
,
5586 cant_have_const_ctor
,
5589 /* Check defaulted declarations here so we have cant_have_const_ctor
5590 and don't need to worry about clones. */
5591 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5592 if (!DECL_ARTIFICIAL (fn
) && DECL_DEFAULTED_IN_CLASS_P (fn
))
5594 int copy
= copy_fn_p (fn
);
5598 = (DECL_CONSTRUCTOR_P (fn
) ? !cant_have_const_ctor
5599 : !no_const_asn_ref
);
5600 bool fn_const_p
= (copy
== 2);
5602 if (fn_const_p
&& !imp_const_p
)
5603 /* If the function is defaulted outside the class, we just
5604 give the synthesis error. */
5605 error ("%q+D declared to take const reference, but implicit "
5606 "declaration would take non-const", fn
);
5608 defaulted_late_check (fn
);
5611 if (LAMBDA_TYPE_P (t
))
5613 /* "The closure type associated with a lambda-expression has a deleted
5614 default constructor and a deleted copy assignment operator." */
5615 TYPE_NEEDS_CONSTRUCTING (t
) = 1;
5616 TYPE_HAS_COMPLEX_DFLT (t
) = 1;
5617 TYPE_HAS_COMPLEX_COPY_ASSIGN (t
) = 1;
5618 CLASSTYPE_LAZY_MOVE_ASSIGN (t
) = 0;
5620 /* "This class type is not an aggregate." */
5621 CLASSTYPE_NON_AGGREGATE (t
) = 1;
5624 /* Compute the 'literal type' property before we
5625 do anything with non-static member functions. */
5626 finalize_literal_type_property (t
);
5628 /* Create the in-charge and not-in-charge variants of constructors
5630 clone_constructors_and_destructors (t
);
5632 /* Process the using-declarations. */
5633 for (; access_decls
; access_decls
= TREE_CHAIN (access_decls
))
5634 handle_using_decl (TREE_VALUE (access_decls
), t
);
5636 /* Build and sort the CLASSTYPE_METHOD_VEC. */
5637 finish_struct_methods (t
);
5639 /* Figure out whether or not we will need a cookie when dynamically
5640 allocating an array of this type. */
5641 TYPE_LANG_SPECIFIC (t
)->u
.c
.vec_new_uses_cookie
5642 = type_requires_array_cookie (t
);
5645 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
5646 accordingly. If a new vfield was created (because T doesn't have a
5647 primary base class), then the newly created field is returned. It
5648 is not added to the TYPE_FIELDS list; it is the caller's
5649 responsibility to do that. Accumulate declared virtual functions
5653 create_vtable_ptr (tree t
, tree
* virtuals_p
)
5657 /* Collect the virtual functions declared in T. */
5658 for (fn
= TYPE_METHODS (t
); fn
; fn
= DECL_CHAIN (fn
))
5659 if (TREE_CODE (fn
) == FUNCTION_DECL
5660 && DECL_VINDEX (fn
) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn
)
5661 && TREE_CODE (DECL_VINDEX (fn
)) != INTEGER_CST
)
5663 tree new_virtual
= make_node (TREE_LIST
);
5665 BV_FN (new_virtual
) = fn
;
5666 BV_DELTA (new_virtual
) = integer_zero_node
;
5667 BV_VCALL_INDEX (new_virtual
) = NULL_TREE
;
5669 TREE_CHAIN (new_virtual
) = *virtuals_p
;
5670 *virtuals_p
= new_virtual
;
5673 /* If we couldn't find an appropriate base class, create a new field
5674 here. Even if there weren't any new virtual functions, we might need a
5675 new virtual function table if we're supposed to include vptrs in
5676 all classes that need them. */
5677 if (!TYPE_VFIELD (t
) && (*virtuals_p
|| TYPE_CONTAINS_VPTR_P (t
)))
5679 /* We build this decl with vtbl_ptr_type_node, which is a
5680 `vtable_entry_type*'. It might seem more precise to use
5681 `vtable_entry_type (*)[N]' where N is the number of virtual
5682 functions. However, that would require the vtable pointer in
5683 base classes to have a different type than the vtable pointer
5684 in derived classes. We could make that happen, but that
5685 still wouldn't solve all the problems. In particular, the
5686 type-based alias analysis code would decide that assignments
5687 to the base class vtable pointer can't alias assignments to
5688 the derived class vtable pointer, since they have different
5689 types. Thus, in a derived class destructor, where the base
5690 class constructor was inlined, we could generate bad code for
5691 setting up the vtable pointer.
5693 Therefore, we use one type for all vtable pointers. We still
5694 use a type-correct type; it's just doesn't indicate the array
5695 bounds. That's better than using `void*' or some such; it's
5696 cleaner, and it let's the alias analysis code know that these
5697 stores cannot alias stores to void*! */
5700 field
= build_decl (input_location
,
5701 FIELD_DECL
, get_vfield_name (t
), vtbl_ptr_type_node
);
5702 DECL_VIRTUAL_P (field
) = 1;
5703 DECL_ARTIFICIAL (field
) = 1;
5704 DECL_FIELD_CONTEXT (field
) = t
;
5705 DECL_FCONTEXT (field
) = t
;
5706 if (TYPE_PACKED (t
))
5707 DECL_PACKED (field
) = 1;
5709 TYPE_VFIELD (t
) = field
;
5711 /* This class is non-empty. */
5712 CLASSTYPE_EMPTY_P (t
) = 0;
5720 /* Add OFFSET to all base types of BINFO which is a base in the
5721 hierarchy dominated by T.
5723 OFFSET, which is a type offset, is number of bytes. */
5726 propagate_binfo_offsets (tree binfo
, tree offset
)
5732 /* Update BINFO's offset. */
5733 BINFO_OFFSET (binfo
)
5734 = convert (sizetype
,
5735 size_binop (PLUS_EXPR
,
5736 convert (ssizetype
, BINFO_OFFSET (binfo
)),
5739 /* Find the primary base class. */
5740 primary_binfo
= get_primary_binfo (binfo
);
5742 if (primary_binfo
&& BINFO_INHERITANCE_CHAIN (primary_binfo
) == binfo
)
5743 propagate_binfo_offsets (primary_binfo
, offset
);
5745 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
5747 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5749 /* Don't do the primary base twice. */
5750 if (base_binfo
== primary_binfo
)
5753 if (BINFO_VIRTUAL_P (base_binfo
))
5756 propagate_binfo_offsets (base_binfo
, offset
);
5760 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
5761 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
5762 empty subobjects of T. */
5765 layout_virtual_bases (record_layout_info rli
, splay_tree offsets
)
5771 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t
)) == 0)
5774 /* Find the last field. The artificial fields created for virtual
5775 bases will go after the last extant field to date. */
5776 next_field
= &TYPE_FIELDS (t
);
5778 next_field
= &DECL_CHAIN (*next_field
);
5780 /* Go through the virtual bases, allocating space for each virtual
5781 base that is not already a primary base class. These are
5782 allocated in inheritance graph order. */
5783 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
5785 if (!BINFO_VIRTUAL_P (vbase
))
5788 if (!BINFO_PRIMARY_P (vbase
))
5790 /* This virtual base is not a primary base of any class in the
5791 hierarchy, so we have to add space for it. */
5792 next_field
= build_base_field (rli
, vbase
,
5793 offsets
, next_field
);
5798 /* Returns the offset of the byte just past the end of the base class
5802 end_of_base (tree binfo
)
5806 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo
)))
5807 size
= TYPE_SIZE_UNIT (char_type_node
);
5808 else if (is_empty_class (BINFO_TYPE (binfo
)))
5809 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5810 allocate some space for it. It cannot have virtual bases, so
5811 TYPE_SIZE_UNIT is fine. */
5812 size
= TYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
5814 size
= CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo
));
5816 return size_binop (PLUS_EXPR
, BINFO_OFFSET (binfo
), size
);
5819 /* Returns the offset of the byte just past the end of the base class
5820 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
5821 only non-virtual bases are included. */
5824 end_of_class (tree t
, int include_virtuals_p
)
5826 tree result
= size_zero_node
;
5827 vec
<tree
, va_gc
> *vbases
;
5833 for (binfo
= TYPE_BINFO (t
), i
= 0;
5834 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5836 if (!include_virtuals_p
5837 && BINFO_VIRTUAL_P (base_binfo
)
5838 && (!BINFO_PRIMARY_P (base_binfo
)
5839 || BINFO_INHERITANCE_CHAIN (base_binfo
) != TYPE_BINFO (t
)))
5842 offset
= end_of_base (base_binfo
);
5843 if (tree_int_cst_lt (result
, offset
))
5847 if (include_virtuals_p
)
5848 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
5849 vec_safe_iterate (vbases
, i
, &base_binfo
); i
++)
5851 offset
= end_of_base (base_binfo
);
5852 if (tree_int_cst_lt (result
, offset
))
5859 /* Warn about bases of T that are inaccessible because they are
5860 ambiguous. For example:
5863 struct T : public S {};
5864 struct U : public S, public T {};
5866 Here, `(S*) new U' is not allowed because there are two `S'
5870 warn_about_ambiguous_bases (tree t
)
5873 vec
<tree
, va_gc
> *vbases
;
5878 /* If there are no repeated bases, nothing can be ambiguous. */
5879 if (!CLASSTYPE_REPEATED_BASE_P (t
))
5882 /* Check direct bases. */
5883 for (binfo
= TYPE_BINFO (t
), i
= 0;
5884 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
5886 basetype
= BINFO_TYPE (base_binfo
);
5888 if (!uniquely_derived_from_p (basetype
, t
))
5889 warning (0, "direct base %qT inaccessible in %qT due to ambiguity",
5893 /* Check for ambiguous virtual bases. */
5895 for (vbases
= CLASSTYPE_VBASECLASSES (t
), i
= 0;
5896 vec_safe_iterate (vbases
, i
, &binfo
); i
++)
5898 basetype
= BINFO_TYPE (binfo
);
5900 if (!uniquely_derived_from_p (basetype
, t
))
5901 warning (OPT_Wextra
, "virtual base %qT inaccessible in %qT due "
5902 "to ambiguity", basetype
, t
);
5906 /* Compare two INTEGER_CSTs K1 and K2. */
5909 splay_tree_compare_integer_csts (splay_tree_key k1
, splay_tree_key k2
)
5911 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5914 /* Increase the size indicated in RLI to account for empty classes
5915 that are "off the end" of the class. */
5918 include_empty_classes (record_layout_info rli
)
5923 /* It might be the case that we grew the class to allocate a
5924 zero-sized base class. That won't be reflected in RLI, yet,
5925 because we are willing to overlay multiple bases at the same
5926 offset. However, now we need to make sure that RLI is big enough
5927 to reflect the entire class. */
5928 eoc
= end_of_class (rli
->t
,
5929 CLASSTYPE_AS_BASE (rli
->t
) != NULL_TREE
);
5930 rli_size
= rli_size_unit_so_far (rli
);
5931 if (TREE_CODE (rli_size
) == INTEGER_CST
5932 && tree_int_cst_lt (rli_size
, eoc
))
5934 /* The size should have been rounded to a whole byte. */
5935 gcc_assert (tree_int_cst_equal
5936 (rli
->bitpos
, round_down (rli
->bitpos
, BITS_PER_UNIT
)));
5938 = size_binop (PLUS_EXPR
,
5940 size_binop (MULT_EXPR
,
5941 convert (bitsizetype
,
5942 size_binop (MINUS_EXPR
,
5944 bitsize_int (BITS_PER_UNIT
)));
5945 normalize_rli (rli
);
5949 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5950 BINFO_OFFSETs for all of the base-classes. Position the vtable
5951 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
5954 layout_class_type (tree t
, tree
*virtuals_p
)
5956 tree non_static_data_members
;
5959 record_layout_info rli
;
5960 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5961 types that appear at that offset. */
5962 splay_tree empty_base_offsets
;
5963 /* True if the last field laid out was a bit-field. */
5964 bool last_field_was_bitfield
= false;
5965 /* The location at which the next field should be inserted. */
5967 /* T, as a base class. */
5970 /* Keep track of the first non-static data member. */
5971 non_static_data_members
= TYPE_FIELDS (t
);
5973 /* Start laying out the record. */
5974 rli
= start_record_layout (t
);
5976 /* Mark all the primary bases in the hierarchy. */
5977 determine_primary_bases (t
);
5979 /* Create a pointer to our virtual function table. */
5980 vptr
= create_vtable_ptr (t
, virtuals_p
);
5982 /* The vptr is always the first thing in the class. */
5985 DECL_CHAIN (vptr
) = TYPE_FIELDS (t
);
5986 TYPE_FIELDS (t
) = vptr
;
5987 next_field
= &DECL_CHAIN (vptr
);
5988 place_field (rli
, vptr
);
5991 next_field
= &TYPE_FIELDS (t
);
5993 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5994 empty_base_offsets
= splay_tree_new (splay_tree_compare_integer_csts
,
5996 build_base_fields (rli
, empty_base_offsets
, next_field
);
5998 /* Layout the non-static data members. */
5999 for (field
= non_static_data_members
; field
; field
= DECL_CHAIN (field
))
6004 /* We still pass things that aren't non-static data members to
6005 the back end, in case it wants to do something with them. */
6006 if (TREE_CODE (field
) != FIELD_DECL
)
6008 place_field (rli
, field
);
6009 /* If the static data member has incomplete type, keep track
6010 of it so that it can be completed later. (The handling
6011 of pending statics in finish_record_layout is
6012 insufficient; consider:
6015 struct S2 { static S1 s1; };
6017 At this point, finish_record_layout will be called, but
6018 S1 is still incomplete.) */
6021 maybe_register_incomplete_var (field
);
6022 /* The visibility of static data members is determined
6023 at their point of declaration, not their point of
6025 determine_visibility (field
);
6030 type
= TREE_TYPE (field
);
6031 if (type
== error_mark_node
)
6034 padding
= NULL_TREE
;
6036 /* If this field is a bit-field whose width is greater than its
6037 type, then there are some special rules for allocating
6039 if (DECL_C_BIT_FIELD (field
)
6040 && tree_int_cst_lt (TYPE_SIZE (type
), DECL_SIZE (field
)))
6044 bool was_unnamed_p
= false;
6045 /* We must allocate the bits as if suitably aligned for the
6046 longest integer type that fits in this many bits. type
6047 of the field. Then, we are supposed to use the left over
6048 bits as additional padding. */
6049 for (itk
= itk_char
; itk
!= itk_none
; ++itk
)
6050 if (integer_types
[itk
] != NULL_TREE
6051 && (tree_int_cst_lt (size_int (MAX_FIXED_MODE_SIZE
),
6052 TYPE_SIZE (integer_types
[itk
]))
6053 || tree_int_cst_lt (DECL_SIZE (field
),
6054 TYPE_SIZE (integer_types
[itk
]))))
6057 /* ITK now indicates a type that is too large for the
6058 field. We have to back up by one to find the largest
6063 integer_type
= integer_types
[itk
];
6064 } while (itk
> 0 && integer_type
== NULL_TREE
);
6066 /* Figure out how much additional padding is required. */
6067 if (tree_int_cst_lt (TYPE_SIZE (integer_type
), DECL_SIZE (field
)))
6069 if (TREE_CODE (t
) == UNION_TYPE
)
6070 /* In a union, the padding field must have the full width
6071 of the bit-field; all fields start at offset zero. */
6072 padding
= DECL_SIZE (field
);
6074 padding
= size_binop (MINUS_EXPR
, DECL_SIZE (field
),
6075 TYPE_SIZE (integer_type
));
6077 #ifdef PCC_BITFIELD_TYPE_MATTERS
6078 /* An unnamed bitfield does not normally affect the
6079 alignment of the containing class on a target where
6080 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
6081 make any exceptions for unnamed bitfields when the
6082 bitfields are longer than their types. Therefore, we
6083 temporarily give the field a name. */
6084 if (PCC_BITFIELD_TYPE_MATTERS
&& !DECL_NAME (field
))
6086 was_unnamed_p
= true;
6087 DECL_NAME (field
) = make_anon_name ();
6090 DECL_SIZE (field
) = TYPE_SIZE (integer_type
);
6091 DECL_ALIGN (field
) = TYPE_ALIGN (integer_type
);
6092 DECL_USER_ALIGN (field
) = TYPE_USER_ALIGN (integer_type
);
6093 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
6094 empty_base_offsets
);
6096 DECL_NAME (field
) = NULL_TREE
;
6097 /* Now that layout has been performed, set the size of the
6098 field to the size of its declared type; the rest of the
6099 field is effectively invisible. */
6100 DECL_SIZE (field
) = TYPE_SIZE (type
);
6101 /* We must also reset the DECL_MODE of the field. */
6102 DECL_MODE (field
) = TYPE_MODE (type
);
6105 layout_nonempty_base_or_field (rli
, field
, NULL_TREE
,
6106 empty_base_offsets
);
6108 /* Remember the location of any empty classes in FIELD. */
6109 record_subobject_offsets (TREE_TYPE (field
),
6110 byte_position(field
),
6112 /*is_data_member=*/true);
6114 /* If a bit-field does not immediately follow another bit-field,
6115 and yet it starts in the middle of a byte, we have failed to
6116 comply with the ABI. */
6118 && DECL_C_BIT_FIELD (field
)
6119 /* The TREE_NO_WARNING flag gets set by Objective-C when
6120 laying out an Objective-C class. The ObjC ABI differs
6121 from the C++ ABI, and so we do not want a warning
6123 && !TREE_NO_WARNING (field
)
6124 && !last_field_was_bitfield
6125 && !integer_zerop (size_binop (TRUNC_MOD_EXPR
,
6126 DECL_FIELD_BIT_OFFSET (field
),
6127 bitsize_unit_node
)))
6128 warning (OPT_Wabi
, "offset of %q+D is not ABI-compliant and may "
6129 "change in a future version of GCC", field
);
6131 /* The middle end uses the type of expressions to determine the
6132 possible range of expression values. In order to optimize
6133 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
6134 must be made aware of the width of "i", via its type.
6136 Because C++ does not have integer types of arbitrary width,
6137 we must (for the purposes of the front end) convert from the
6138 type assigned here to the declared type of the bitfield
6139 whenever a bitfield expression is used as an rvalue.
6140 Similarly, when assigning a value to a bitfield, the value
6141 must be converted to the type given the bitfield here. */
6142 if (DECL_C_BIT_FIELD (field
))
6144 unsigned HOST_WIDE_INT width
;
6145 tree ftype
= TREE_TYPE (field
);
6146 width
= tree_to_uhwi (DECL_SIZE (field
));
6147 if (width
!= TYPE_PRECISION (ftype
))
6150 = c_build_bitfield_integer_type (width
,
6151 TYPE_UNSIGNED (ftype
));
6153 = cp_build_qualified_type (TREE_TYPE (field
),
6154 cp_type_quals (ftype
));
6158 /* If we needed additional padding after this field, add it
6164 padding_field
= build_decl (input_location
,
6168 DECL_BIT_FIELD (padding_field
) = 1;
6169 DECL_SIZE (padding_field
) = padding
;
6170 DECL_CONTEXT (padding_field
) = t
;
6171 DECL_ARTIFICIAL (padding_field
) = 1;
6172 DECL_IGNORED_P (padding_field
) = 1;
6173 layout_nonempty_base_or_field (rli
, padding_field
,
6175 empty_base_offsets
);
6178 last_field_was_bitfield
= DECL_C_BIT_FIELD (field
);
6181 if (!integer_zerop (rli
->bitpos
))
6183 /* Make sure that we are on a byte boundary so that the size of
6184 the class without virtual bases will always be a round number
6186 rli
->bitpos
= round_up_loc (input_location
, rli
->bitpos
, BITS_PER_UNIT
);
6187 normalize_rli (rli
);
6190 /* Delete all zero-width bit-fields from the list of fields. Now
6191 that the type is laid out they are no longer important. */
6192 remove_zero_width_bit_fields (t
);
6194 /* Create the version of T used for virtual bases. We do not use
6195 make_class_type for this version; this is an artificial type. For
6196 a POD type, we just reuse T. */
6197 if (CLASSTYPE_NON_LAYOUT_POD_P (t
) || CLASSTYPE_EMPTY_P (t
))
6199 base_t
= make_node (TREE_CODE (t
));
6201 /* Set the size and alignment for the new type. */
6204 /* If the ABI version is not at least two, and the last
6205 field was a bit-field, RLI may not be on a byte
6206 boundary. In particular, rli_size_unit_so_far might
6207 indicate the last complete byte, while rli_size_so_far
6208 indicates the total number of bits used. Therefore,
6209 rli_size_so_far, rather than rli_size_unit_so_far, is
6210 used to compute TYPE_SIZE_UNIT. */
6211 eoc
= end_of_class (t
, /*include_virtuals_p=*/0);
6212 TYPE_SIZE_UNIT (base_t
)
6213 = size_binop (MAX_EXPR
,
6215 size_binop (CEIL_DIV_EXPR
,
6216 rli_size_so_far (rli
),
6217 bitsize_int (BITS_PER_UNIT
))),
6220 = size_binop (MAX_EXPR
,
6221 rli_size_so_far (rli
),
6222 size_binop (MULT_EXPR
,
6223 convert (bitsizetype
, eoc
),
6224 bitsize_int (BITS_PER_UNIT
)));
6225 TYPE_ALIGN (base_t
) = rli
->record_align
;
6226 TYPE_USER_ALIGN (base_t
) = TYPE_USER_ALIGN (t
);
6228 /* Copy the fields from T. */
6229 next_field
= &TYPE_FIELDS (base_t
);
6230 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
6231 if (TREE_CODE (field
) == FIELD_DECL
)
6233 *next_field
= build_decl (input_location
,
6237 DECL_CONTEXT (*next_field
) = base_t
;
6238 DECL_FIELD_OFFSET (*next_field
) = DECL_FIELD_OFFSET (field
);
6239 DECL_FIELD_BIT_OFFSET (*next_field
)
6240 = DECL_FIELD_BIT_OFFSET (field
);
6241 DECL_SIZE (*next_field
) = DECL_SIZE (field
);
6242 DECL_MODE (*next_field
) = DECL_MODE (field
);
6243 next_field
= &DECL_CHAIN (*next_field
);
6246 /* Record the base version of the type. */
6247 CLASSTYPE_AS_BASE (t
) = base_t
;
6248 TYPE_CONTEXT (base_t
) = 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 ("type %qT is too large", 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 (TYPE_FOR_JAVA (type
)
6318 || processing_template_decl
6319 || CLASSTYPE_TEMPLATE_INSTANTIATION (type
)
6320 || CLASSTYPE_INTERFACE_KNOWN (type
))
6323 /* The key method is the first non-pure virtual function that is not
6324 inline at the point of class definition. On some targets the
6325 key function may not be inline; those targets should not call
6326 this function until the end of the translation unit. */
6327 for (method
= TYPE_METHODS (type
); method
!= NULL_TREE
;
6328 method
= DECL_CHAIN (method
))
6329 if (TREE_CODE (method
) == FUNCTION_DECL
6330 && DECL_VINDEX (method
) != NULL_TREE
6331 && ! DECL_DECLARED_INLINE_P (method
)
6332 && ! DECL_PURE_VIRTUAL_P (method
))
6334 CLASSTYPE_KEY_METHOD (type
) = method
;
6342 /* Allocate and return an instance of struct sorted_fields_type with
6345 static struct sorted_fields_type
*
6346 sorted_fields_type_new (int n
)
6348 struct sorted_fields_type
*sft
;
6349 sft
= (sorted_fields_type
*) ggc_internal_alloc (sizeof (sorted_fields_type
)
6350 + n
* sizeof (tree
));
6357 /* Perform processing required when the definition of T (a class type)
6361 finish_struct_1 (tree t
)
6364 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
6365 tree virtuals
= NULL_TREE
;
6367 if (COMPLETE_TYPE_P (t
))
6369 gcc_assert (MAYBE_CLASS_TYPE_P (t
));
6370 error ("redefinition of %q#T", t
);
6375 /* If this type was previously laid out as a forward reference,
6376 make sure we lay it out again. */
6377 TYPE_SIZE (t
) = NULL_TREE
;
6378 CLASSTYPE_PRIMARY_BINFO (t
) = NULL_TREE
;
6380 /* Make assumptions about the class; we'll reset the flags if
6382 CLASSTYPE_EMPTY_P (t
) = 1;
6383 CLASSTYPE_NEARLY_EMPTY_P (t
) = 1;
6384 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t
) = 0;
6385 CLASSTYPE_LITERAL_P (t
) = true;
6387 /* Do end-of-class semantic processing: checking the validity of the
6388 bases and members and add implicitly generated methods. */
6389 check_bases_and_members (t
);
6391 /* Find the key method. */
6392 if (TYPE_CONTAINS_VPTR_P (t
))
6394 /* The Itanium C++ ABI permits the key method to be chosen when
6395 the class is defined -- even though the key method so
6396 selected may later turn out to be an inline function. On
6397 some systems (such as ARM Symbian OS) the key method cannot
6398 be determined until the end of the translation unit. On such
6399 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
6400 will cause the class to be added to KEYED_CLASSES. Then, in
6401 finish_file we will determine the key method. */
6402 if (targetm
.cxx
.key_method_may_be_inline ())
6403 determine_key_method (t
);
6405 /* If a polymorphic class has no key method, we may emit the vtable
6406 in every translation unit where the class definition appears. If
6407 we're devirtualizing, we can look into the vtable even if we
6408 aren't emitting it. */
6409 if (CLASSTYPE_KEY_METHOD (t
) == NULL_TREE
)
6410 keyed_classes
= tree_cons (NULL_TREE
, t
, keyed_classes
);
6413 /* Layout the class itself. */
6414 layout_class_type (t
, &virtuals
);
6415 if (CLASSTYPE_AS_BASE (t
) != t
)
6416 /* We use the base type for trivial assignments, and hence it
6418 compute_record_mode (CLASSTYPE_AS_BASE (t
));
6420 virtuals
= modify_all_vtables (t
, nreverse (virtuals
));
6422 /* If necessary, create the primary vtable for this class. */
6423 if (virtuals
|| TYPE_CONTAINS_VPTR_P (t
))
6425 /* We must enter these virtuals into the table. */
6426 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6427 build_primary_vtable (NULL_TREE
, t
);
6428 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t
)))
6429 /* Here we know enough to change the type of our virtual
6430 function table, but we will wait until later this function. */
6431 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t
), t
);
6433 /* If we're warning about ABI tags, check the types of the new
6434 virtual functions. */
6436 for (tree v
= virtuals
; v
; v
= TREE_CHAIN (v
))
6437 check_abi_tags (t
, TREE_VALUE (v
));
6440 if (TYPE_CONTAINS_VPTR_P (t
))
6445 if (BINFO_VTABLE (TYPE_BINFO (t
)))
6446 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t
))));
6447 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t
))
6448 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t
)) == NULL_TREE
);
6450 /* Add entries for virtual functions introduced by this class. */
6451 BINFO_VIRTUALS (TYPE_BINFO (t
))
6452 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t
)), virtuals
);
6454 /* Set DECL_VINDEX for all functions declared in this class. */
6455 for (vindex
= 0, fn
= BINFO_VIRTUALS (TYPE_BINFO (t
));
6457 fn
= TREE_CHAIN (fn
),
6458 vindex
+= (TARGET_VTABLE_USES_DESCRIPTORS
6459 ? TARGET_VTABLE_USES_DESCRIPTORS
: 1))
6461 tree fndecl
= BV_FN (fn
);
6463 if (DECL_THUNK_P (fndecl
))
6464 /* A thunk. We should never be calling this entry directly
6465 from this vtable -- we'd use the entry for the non
6466 thunk base function. */
6467 DECL_VINDEX (fndecl
) = NULL_TREE
;
6468 else if (TREE_CODE (DECL_VINDEX (fndecl
)) != INTEGER_CST
)
6469 DECL_VINDEX (fndecl
) = build_int_cst (NULL_TREE
, vindex
);
6473 finish_struct_bits (t
);
6474 set_method_tm_attributes (t
);
6476 /* Complete the rtl for any static member objects of the type we're
6478 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
6479 if (VAR_P (x
) && TREE_STATIC (x
)
6480 && TREE_TYPE (x
) != error_mark_node
6481 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x
)), t
))
6482 DECL_MODE (x
) = TYPE_MODE (t
);
6484 /* Done with FIELDS...now decide whether to sort these for
6485 faster lookups later.
6487 We use a small number because most searches fail (succeeding
6488 ultimately as the search bores through the inheritance
6489 hierarchy), and we want this failure to occur quickly. */
6491 insert_into_classtype_sorted_fields (TYPE_FIELDS (t
), t
, 8);
6493 /* Complain if one of the field types requires lower visibility. */
6494 constrain_class_visibility (t
);
6496 /* Make the rtl for any new vtables we have created, and unmark
6497 the base types we marked. */
6500 /* Build the VTT for T. */
6503 /* This warning does not make sense for Java classes, since they
6504 cannot have destructors. */
6505 if (!TYPE_FOR_JAVA (t
) && warn_nonvdtor
6506 && TYPE_POLYMORPHIC_P (t
) && accessible_nvdtor_p (t
))
6507 warning (OPT_Wnon_virtual_dtor
,
6508 "%q#T has virtual functions and accessible"
6509 " non-virtual destructor", t
);
6513 if (warn_overloaded_virtual
)
6516 /* Class layout, assignment of virtual table slots, etc., is now
6517 complete. Give the back end a chance to tweak the visibility of
6518 the class or perform any other required target modifications. */
6519 targetm
.cxx
.adjust_class_at_definition (t
);
6521 maybe_suppress_debug_info (t
);
6523 if (flag_vtable_verify
)
6524 vtv_save_class_info (t
);
6526 dump_class_hierarchy (t
);
6528 /* Finish debugging output for this type. */
6529 rest_of_type_compilation (t
, ! LOCAL_CLASS_P (t
));
6531 if (TYPE_TRANSPARENT_AGGR (t
))
6533 tree field
= first_field (t
);
6534 if (field
== NULL_TREE
|| error_operand_p (field
))
6536 error ("type transparent %q#T does not have any fields", t
);
6537 TYPE_TRANSPARENT_AGGR (t
) = 0;
6539 else if (DECL_ARTIFICIAL (field
))
6541 if (DECL_FIELD_IS_BASE (field
))
6542 error ("type transparent class %qT has base classes", t
);
6545 gcc_checking_assert (DECL_VIRTUAL_P (field
));
6546 error ("type transparent class %qT has virtual functions", t
);
6548 TYPE_TRANSPARENT_AGGR (t
) = 0;
6550 else if (TYPE_MODE (t
) != DECL_MODE (field
))
6552 error ("type transparent %q#T cannot be made transparent because "
6553 "the type of the first field has a different ABI from the "
6554 "class overall", t
);
6555 TYPE_TRANSPARENT_AGGR (t
) = 0;
6560 /* Insert FIELDS into T for the sorted case if the FIELDS count is
6561 equal to THRESHOLD or greater than THRESHOLD. */
6564 insert_into_classtype_sorted_fields (tree fields
, tree t
, int threshold
)
6566 int n_fields
= count_fields (fields
);
6567 if (n_fields
>= threshold
)
6569 struct sorted_fields_type
*field_vec
= sorted_fields_type_new (n_fields
);
6570 add_fields_to_record_type (fields
, field_vec
, 0);
6571 qsort (field_vec
->elts
, n_fields
, sizeof (tree
), field_decl_cmp
);
6572 CLASSTYPE_SORTED_FIELDS (t
) = field_vec
;
6576 /* Insert lately defined enum ENUMTYPE into T for the sorted case. */
6579 insert_late_enum_def_into_classtype_sorted_fields (tree enumtype
, tree t
)
6581 struct sorted_fields_type
*sorted_fields
= CLASSTYPE_SORTED_FIELDS (t
);
6586 = list_length (TYPE_VALUES (enumtype
)) + sorted_fields
->len
;
6587 struct sorted_fields_type
*field_vec
= sorted_fields_type_new (n_fields
);
6589 for (i
= 0; i
< sorted_fields
->len
; ++i
)
6590 field_vec
->elts
[i
] = sorted_fields
->elts
[i
];
6592 add_enum_fields_to_record_type (enumtype
, field_vec
,
6593 sorted_fields
->len
);
6594 qsort (field_vec
->elts
, n_fields
, sizeof (tree
), field_decl_cmp
);
6595 CLASSTYPE_SORTED_FIELDS (t
) = field_vec
;
6599 /* When T was built up, the member declarations were added in reverse
6600 order. Rearrange them to declaration order. */
6603 unreverse_member_declarations (tree t
)
6609 /* The following lists are all in reverse order. Put them in
6610 declaration order now. */
6611 TYPE_METHODS (t
) = nreverse (TYPE_METHODS (t
));
6612 CLASSTYPE_DECL_LIST (t
) = nreverse (CLASSTYPE_DECL_LIST (t
));
6614 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
6615 reverse order, so we can't just use nreverse. */
6617 for (x
= TYPE_FIELDS (t
);
6618 x
&& TREE_CODE (x
) != TYPE_DECL
;
6621 next
= DECL_CHAIN (x
);
6622 DECL_CHAIN (x
) = prev
;
6627 DECL_CHAIN (TYPE_FIELDS (t
)) = x
;
6629 TYPE_FIELDS (t
) = prev
;
6634 finish_struct (tree t
, tree attributes
)
6636 location_t saved_loc
= input_location
;
6638 /* Now that we've got all the field declarations, reverse everything
6640 unreverse_member_declarations (t
);
6642 cplus_decl_attributes (&t
, attributes
, (int) ATTR_FLAG_TYPE_IN_PLACE
);
6644 /* Nadger the current location so that diagnostics point to the start of
6645 the struct, not the end. */
6646 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (t
));
6648 if (processing_template_decl
)
6652 finish_struct_methods (t
);
6653 TYPE_SIZE (t
) = bitsize_zero_node
;
6654 TYPE_SIZE_UNIT (t
) = size_zero_node
;
6656 /* We need to emit an error message if this type was used as a parameter
6657 and it is an abstract type, even if it is a template. We construct
6658 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
6659 account and we call complete_vars with this type, which will check
6660 the PARM_DECLS. Note that while the type is being defined,
6661 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
6662 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
6663 CLASSTYPE_PURE_VIRTUALS (t
) = NULL
;
6664 for (x
= TYPE_METHODS (t
); x
; x
= DECL_CHAIN (x
))
6665 if (DECL_PURE_VIRTUAL_P (x
))
6666 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t
), x
);
6668 /* We need to add the target functions to the CLASSTYPE_METHOD_VEC if
6669 an enclosing scope is a template class, so that this function be
6670 found by lookup_fnfields_1 when the using declaration is not
6671 instantiated yet. */
6672 for (x
= TYPE_FIELDS (t
); x
; x
= DECL_CHAIN (x
))
6673 if (TREE_CODE (x
) == USING_DECL
)
6675 tree fn
= strip_using_decl (x
);
6676 if (is_overloaded_fn (fn
))
6677 for (; fn
; fn
= OVL_NEXT (fn
))
6678 add_method (t
, OVL_CURRENT (fn
), x
);
6681 /* Remember current #pragma pack value. */
6682 TYPE_PRECISION (t
) = maximum_field_alignment
;
6684 /* Fix up any variants we've already built. */
6685 for (x
= TYPE_NEXT_VARIANT (t
); x
; x
= TYPE_NEXT_VARIANT (x
))
6687 TYPE_SIZE (x
) = TYPE_SIZE (t
);
6688 TYPE_SIZE_UNIT (x
) = TYPE_SIZE_UNIT (t
);
6689 TYPE_FIELDS (x
) = TYPE_FIELDS (t
);
6690 TYPE_METHODS (x
) = TYPE_METHODS (t
);
6694 finish_struct_1 (t
);
6696 if (is_std_init_list (t
))
6698 /* People keep complaining that the compiler crashes on an invalid
6699 definition of initializer_list, so I guess we should explicitly
6700 reject it. What the compiler internals care about is that it's a
6701 template and has a pointer field followed by an integer field. */
6703 if (processing_template_decl
)
6705 tree f
= next_initializable_field (TYPE_FIELDS (t
));
6706 if (f
&& TREE_CODE (TREE_TYPE (f
)) == POINTER_TYPE
)
6708 f
= next_initializable_field (DECL_CHAIN (f
));
6709 if (f
&& TREE_CODE (TREE_TYPE (f
)) == INTEGER_TYPE
)
6714 fatal_error ("definition of std::initializer_list does not match "
6715 "#include <initializer_list>");
6718 input_location
= saved_loc
;
6720 TYPE_BEING_DEFINED (t
) = 0;
6722 if (current_class_type
)
6725 error ("trying to finish struct, but kicked out due to previous parse errors");
6727 if (processing_template_decl
&& at_function_scope_p ()
6728 /* Lambdas are defined by the LAMBDA_EXPR. */
6729 && !LAMBDA_TYPE_P (t
))
6730 add_stmt (build_min (TAG_DEFN
, t
));
6735 /* Hash table to avoid endless recursion when handling references. */
6736 static hash_table
<pointer_hash
<tree_node
> > *fixed_type_or_null_ref_ht
;
6738 /* Return the dynamic type of INSTANCE, if known.
6739 Used to determine whether the virtual function table is needed
6742 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6743 of our knowledge of its type. *NONNULL should be initialized
6744 before this function is called. */
6747 fixed_type_or_null (tree instance
, int *nonnull
, int *cdtorp
)
6749 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
6751 switch (TREE_CODE (instance
))
6754 if (POINTER_TYPE_P (TREE_TYPE (instance
)))
6757 return RECUR (TREE_OPERAND (instance
, 0));
6760 /* This is a call to a constructor, hence it's never zero. */
6761 if (TREE_HAS_CONSTRUCTOR (instance
))
6765 return TREE_TYPE (instance
);
6770 /* This is a call to a constructor, hence it's never zero. */
6771 if (TREE_HAS_CONSTRUCTOR (instance
))
6775 return TREE_TYPE (instance
);
6777 return RECUR (TREE_OPERAND (instance
, 0));
6779 case POINTER_PLUS_EXPR
:
6782 if (TREE_CODE (TREE_OPERAND (instance
, 0)) == ADDR_EXPR
)
6783 return RECUR (TREE_OPERAND (instance
, 0));
6784 if (TREE_CODE (TREE_OPERAND (instance
, 1)) == INTEGER_CST
)
6785 /* Propagate nonnull. */
6786 return RECUR (TREE_OPERAND (instance
, 0));
6791 return RECUR (TREE_OPERAND (instance
, 0));
6794 instance
= TREE_OPERAND (instance
, 0);
6797 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
6798 with a real object -- given &p->f, p can still be null. */
6799 tree t
= get_base_address (instance
);
6800 /* ??? Probably should check DECL_WEAK here. */
6801 if (t
&& DECL_P (t
))
6804 return RECUR (instance
);
6807 /* If this component is really a base class reference, then the field
6808 itself isn't definitive. */
6809 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance
, 1)))
6810 return RECUR (TREE_OPERAND (instance
, 0));
6811 return RECUR (TREE_OPERAND (instance
, 1));
6815 if (TREE_CODE (TREE_TYPE (instance
)) == ARRAY_TYPE
6816 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance
))))
6820 return TREE_TYPE (TREE_TYPE (instance
));
6822 /* fall through... */
6826 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance
)))
6830 return TREE_TYPE (instance
);
6832 else if (instance
== current_class_ptr
)
6837 /* if we're in a ctor or dtor, we know our type. If
6838 current_class_ptr is set but we aren't in a function, we're in
6839 an NSDMI (and therefore a constructor). */
6840 if (current_scope () != current_function_decl
6841 || (DECL_LANG_SPECIFIC (current_function_decl
)
6842 && (DECL_CONSTRUCTOR_P (current_function_decl
)
6843 || DECL_DESTRUCTOR_P (current_function_decl
))))
6847 return TREE_TYPE (TREE_TYPE (instance
));
6850 else if (TREE_CODE (TREE_TYPE (instance
)) == REFERENCE_TYPE
)
6852 /* We only need one hash table because it is always left empty. */
6853 if (!fixed_type_or_null_ref_ht
)
6854 fixed_type_or_null_ref_ht
6855 = new hash_table
<pointer_hash
<tree_node
> > (37);
6857 /* Reference variables should be references to objects. */
6861 /* Enter the INSTANCE in a table to prevent recursion; a
6862 variable's initializer may refer to the variable
6864 if (VAR_P (instance
)
6865 && DECL_INITIAL (instance
)
6866 && !type_dependent_expression_p_push (DECL_INITIAL (instance
))
6867 && !fixed_type_or_null_ref_ht
->find (instance
))
6872 slot
= fixed_type_or_null_ref_ht
->find_slot (instance
, INSERT
);
6874 type
= RECUR (DECL_INITIAL (instance
));
6875 fixed_type_or_null_ref_ht
->remove_elt (instance
);
6888 /* Return nonzero if the dynamic type of INSTANCE is known, and
6889 equivalent to the static type. We also handle the case where
6890 INSTANCE is really a pointer. Return negative if this is a
6891 ctor/dtor. There the dynamic type is known, but this might not be
6892 the most derived base of the original object, and hence virtual
6893 bases may not be laid out according to this type.
6895 Used to determine whether the virtual function table is needed
6898 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6899 of our knowledge of its type. *NONNULL should be initialized
6900 before this function is called. */
6903 resolves_to_fixed_type_p (tree instance
, int* nonnull
)
6905 tree t
= TREE_TYPE (instance
);
6909 /* processing_template_decl can be false in a template if we're in
6910 fold_non_dependent_expr, but we still want to suppress this check. */
6911 if (in_template_function ())
6913 /* In a template we only care about the type of the result. */
6919 fixed
= fixed_type_or_null (instance
, nonnull
, &cdtorp
);
6920 if (fixed
== NULL_TREE
)
6922 if (POINTER_TYPE_P (t
))
6924 if (!same_type_ignoring_top_level_qualifiers_p (t
, fixed
))
6926 return cdtorp
? -1 : 1;
6931 init_class_processing (void)
6933 current_class_depth
= 0;
6934 current_class_stack_size
= 10;
6936 = XNEWVEC (struct class_stack_node
, current_class_stack_size
);
6937 vec_alloc (local_classes
, 8);
6938 sizeof_biggest_empty_class
= size_zero_node
;
6940 ridpointers
[(int) RID_PUBLIC
] = access_public_node
;
6941 ridpointers
[(int) RID_PRIVATE
] = access_private_node
;
6942 ridpointers
[(int) RID_PROTECTED
] = access_protected_node
;
6945 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
6948 restore_class_cache (void)
6952 /* We are re-entering the same class we just left, so we don't
6953 have to search the whole inheritance matrix to find all the
6954 decls to bind again. Instead, we install the cached
6955 class_shadowed list and walk through it binding names. */
6956 push_binding_level (previous_class_level
);
6957 class_binding_level
= previous_class_level
;
6958 /* Restore IDENTIFIER_TYPE_VALUE. */
6959 for (type
= class_binding_level
->type_shadowed
;
6961 type
= TREE_CHAIN (type
))
6962 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type
), TREE_TYPE (type
));
6965 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
6966 appropriate for TYPE.
6968 So that we may avoid calls to lookup_name, we cache the _TYPE
6969 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
6971 For multiple inheritance, we perform a two-pass depth-first search
6972 of the type lattice. */
6975 pushclass (tree type
)
6977 class_stack_node_t csn
;
6979 type
= TYPE_MAIN_VARIANT (type
);
6981 /* Make sure there is enough room for the new entry on the stack. */
6982 if (current_class_depth
+ 1 >= current_class_stack_size
)
6984 current_class_stack_size
*= 2;
6986 = XRESIZEVEC (struct class_stack_node
, current_class_stack
,
6987 current_class_stack_size
);
6990 /* Insert a new entry on the class stack. */
6991 csn
= current_class_stack
+ current_class_depth
;
6992 csn
->name
= current_class_name
;
6993 csn
->type
= current_class_type
;
6994 csn
->access
= current_access_specifier
;
6995 csn
->names_used
= 0;
6997 current_class_depth
++;
6999 /* Now set up the new type. */
7000 current_class_name
= TYPE_NAME (type
);
7001 if (TREE_CODE (current_class_name
) == TYPE_DECL
)
7002 current_class_name
= DECL_NAME (current_class_name
);
7003 current_class_type
= type
;
7005 /* By default, things in classes are private, while things in
7006 structures or unions are public. */
7007 current_access_specifier
= (CLASSTYPE_DECLARED_CLASS (type
)
7008 ? access_private_node
7009 : access_public_node
);
7011 if (previous_class_level
7012 && type
!= previous_class_level
->this_entity
7013 && current_class_depth
== 1)
7015 /* Forcibly remove any old class remnants. */
7016 invalidate_class_lookup_cache ();
7019 if (!previous_class_level
7020 || type
!= previous_class_level
->this_entity
7021 || current_class_depth
> 1)
7024 restore_class_cache ();
7027 /* When we exit a toplevel class scope, we save its binding level so
7028 that we can restore it quickly. Here, we've entered some other
7029 class, so we must invalidate our cache. */
7032 invalidate_class_lookup_cache (void)
7034 previous_class_level
= NULL
;
7037 /* Get out of the current class scope. If we were in a class scope
7038 previously, that is the one popped to. */
7045 current_class_depth
--;
7046 current_class_name
= current_class_stack
[current_class_depth
].name
;
7047 current_class_type
= current_class_stack
[current_class_depth
].type
;
7048 current_access_specifier
= current_class_stack
[current_class_depth
].access
;
7049 if (current_class_stack
[current_class_depth
].names_used
)
7050 splay_tree_delete (current_class_stack
[current_class_depth
].names_used
);
7053 /* Mark the top of the class stack as hidden. */
7056 push_class_stack (void)
7058 if (current_class_depth
)
7059 ++current_class_stack
[current_class_depth
- 1].hidden
;
7062 /* Mark the top of the class stack as un-hidden. */
7065 pop_class_stack (void)
7067 if (current_class_depth
)
7068 --current_class_stack
[current_class_depth
- 1].hidden
;
7071 /* Returns 1 if the class type currently being defined is either T or
7072 a nested type of T. */
7075 currently_open_class (tree t
)
7079 if (!CLASS_TYPE_P (t
))
7082 t
= TYPE_MAIN_VARIANT (t
);
7084 /* We start looking from 1 because entry 0 is from global scope,
7086 for (i
= current_class_depth
; i
> 0; --i
)
7089 if (i
== current_class_depth
)
7090 c
= current_class_type
;
7093 if (current_class_stack
[i
].hidden
)
7095 c
= current_class_stack
[i
].type
;
7099 if (same_type_p (c
, t
))
7105 /* If either current_class_type or one of its enclosing classes are derived
7106 from T, return the appropriate type. Used to determine how we found
7107 something via unqualified lookup. */
7110 currently_open_derived_class (tree t
)
7114 /* The bases of a dependent type are unknown. */
7115 if (dependent_type_p (t
))
7118 if (!current_class_type
)
7121 if (DERIVED_FROM_P (t
, current_class_type
))
7122 return current_class_type
;
7124 for (i
= current_class_depth
- 1; i
> 0; --i
)
7126 if (current_class_stack
[i
].hidden
)
7128 if (DERIVED_FROM_P (t
, current_class_stack
[i
].type
))
7129 return current_class_stack
[i
].type
;
7135 /* Return the outermost enclosing class type that is still open, or
7139 outermost_open_class (void)
7141 if (!current_class_type
)
7144 for (int i
= current_class_depth
; i
> 0; --i
)
7146 if (current_class_stack
[i
].hidden
)
7148 tree t
= current_class_stack
[i
].type
;
7149 if (!TYPE_BEING_DEFINED (t
))
7156 /* Returns the innermost class type which is not a lambda closure type. */
7159 current_nonlambda_class_type (void)
7163 /* We start looking from 1 because entry 0 is from global scope,
7165 for (i
= current_class_depth
; i
> 0; --i
)
7168 if (i
== current_class_depth
)
7169 c
= current_class_type
;
7172 if (current_class_stack
[i
].hidden
)
7174 c
= current_class_stack
[i
].type
;
7178 if (!LAMBDA_TYPE_P (c
))
7184 /* When entering a class scope, all enclosing class scopes' names with
7185 static meaning (static variables, static functions, types and
7186 enumerators) have to be visible. This recursive function calls
7187 pushclass for all enclosing class contexts until global or a local
7188 scope is reached. TYPE is the enclosed class. */
7191 push_nested_class (tree type
)
7193 /* A namespace might be passed in error cases, like A::B:C. */
7194 if (type
== NULL_TREE
7195 || !CLASS_TYPE_P (type
))
7198 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type
)));
7203 /* Undoes a push_nested_class call. */
7206 pop_nested_class (void)
7208 tree context
= DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type
));
7211 if (context
&& CLASS_TYPE_P (context
))
7212 pop_nested_class ();
7215 /* Returns the number of extern "LANG" blocks we are nested within. */
7218 current_lang_depth (void)
7220 return vec_safe_length (current_lang_base
);
7223 /* Set global variables CURRENT_LANG_NAME to appropriate value
7224 so that behavior of name-mangling machinery is correct. */
7227 push_lang_context (tree name
)
7229 vec_safe_push (current_lang_base
, current_lang_name
);
7231 if (name
== lang_name_cplusplus
)
7233 current_lang_name
= name
;
7235 else if (name
== lang_name_java
)
7237 current_lang_name
= name
;
7238 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
7239 (See record_builtin_java_type in decl.c.) However, that causes
7240 incorrect debug entries if these types are actually used.
7241 So we re-enable debug output after extern "Java". */
7242 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node
)) = 0;
7243 DECL_IGNORED_P (TYPE_NAME (java_short_type_node
)) = 0;
7244 DECL_IGNORED_P (TYPE_NAME (java_int_type_node
)) = 0;
7245 DECL_IGNORED_P (TYPE_NAME (java_long_type_node
)) = 0;
7246 DECL_IGNORED_P (TYPE_NAME (java_float_type_node
)) = 0;
7247 DECL_IGNORED_P (TYPE_NAME (java_double_type_node
)) = 0;
7248 DECL_IGNORED_P (TYPE_NAME (java_char_type_node
)) = 0;
7249 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node
)) = 0;
7251 else if (name
== lang_name_c
)
7253 current_lang_name
= name
;
7256 error ("language string %<\"%E\"%> not recognized", name
);
7259 /* Get out of the current language scope. */
7262 pop_lang_context (void)
7264 current_lang_name
= current_lang_base
->pop ();
7267 /* Type instantiation routines. */
7269 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
7270 matches the TARGET_TYPE. If there is no satisfactory match, return
7271 error_mark_node, and issue an error & warning messages under
7272 control of FLAGS. Permit pointers to member function if FLAGS
7273 permits. If TEMPLATE_ONLY, the name of the overloaded function was
7274 a template-id, and EXPLICIT_TARGS are the explicitly provided
7277 If OVERLOAD is for one or more member functions, then ACCESS_PATH
7278 is the base path used to reference those member functions. If
7279 the address is resolved to a member function, access checks will be
7280 performed and errors issued if appropriate. */
7283 resolve_address_of_overloaded_function (tree target_type
,
7285 tsubst_flags_t flags
,
7287 tree explicit_targs
,
7290 /* Here's what the standard says:
7294 If the name is a function template, template argument deduction
7295 is done, and if the argument deduction succeeds, the deduced
7296 arguments are used to generate a single template function, which
7297 is added to the set of overloaded functions considered.
7299 Non-member functions and static member functions match targets of
7300 type "pointer-to-function" or "reference-to-function." Nonstatic
7301 member functions match targets of type "pointer-to-member
7302 function;" the function type of the pointer to member is used to
7303 select the member function from the set of overloaded member
7304 functions. If a nonstatic member function is selected, the
7305 reference to the overloaded function name is required to have the
7306 form of a pointer to member as described in 5.3.1.
7308 If more than one function is selected, any template functions in
7309 the set are eliminated if the set also contains a non-template
7310 function, and any given template function is eliminated if the
7311 set contains a second template function that is more specialized
7312 than the first according to the partial ordering rules 14.5.5.2.
7313 After such eliminations, if any, there shall remain exactly one
7314 selected function. */
7317 /* We store the matches in a TREE_LIST rooted here. The functions
7318 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
7319 interoperability with most_specialized_instantiation. */
7320 tree matches
= NULL_TREE
;
7322 tree target_fn_type
;
7324 /* By the time we get here, we should be seeing only real
7325 pointer-to-member types, not the internal POINTER_TYPE to
7326 METHOD_TYPE representation. */
7327 gcc_assert (!TYPE_PTR_P (target_type
)
7328 || TREE_CODE (TREE_TYPE (target_type
)) != METHOD_TYPE
);
7330 gcc_assert (is_overloaded_fn (overload
));
7332 /* Check that the TARGET_TYPE is reasonable. */
7333 if (TYPE_PTRFN_P (target_type
)
7334 || TYPE_REFFN_P (target_type
))
7336 else if (TYPE_PTRMEMFUNC_P (target_type
))
7337 /* This is OK, too. */
7339 else if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
7340 /* This is OK, too. This comes from a conversion to reference
7342 target_type
= build_reference_type (target_type
);
7345 if (flags
& tf_error
)
7346 error ("cannot resolve overloaded function %qD based on"
7347 " conversion to type %qT",
7348 DECL_NAME (OVL_FUNCTION (overload
)), target_type
);
7349 return error_mark_node
;
7352 /* Non-member functions and static member functions match targets of type
7353 "pointer-to-function" or "reference-to-function." Nonstatic member
7354 functions match targets of type "pointer-to-member-function;" the
7355 function type of the pointer to member is used to select the member
7356 function from the set of overloaded member functions.
7358 So figure out the FUNCTION_TYPE that we want to match against. */
7359 target_fn_type
= static_fn_type (target_type
);
7361 /* If we can find a non-template function that matches, we can just
7362 use it. There's no point in generating template instantiations
7363 if we're just going to throw them out anyhow. But, of course, we
7364 can only do this when we don't *need* a template function. */
7369 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
7371 tree fn
= OVL_CURRENT (fns
);
7373 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
7374 /* We're not looking for templates just yet. */
7377 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7379 /* We're looking for a non-static member, and this isn't
7380 one, or vice versa. */
7383 /* Ignore functions which haven't been explicitly
7385 if (DECL_ANTICIPATED (fn
))
7388 /* See if there's a match. */
7389 if (same_type_p (target_fn_type
, static_fn_type (fn
)))
7390 matches
= tree_cons (fn
, NULL_TREE
, matches
);
7394 /* Now, if we've already got a match (or matches), there's no need
7395 to proceed to the template functions. But, if we don't have a
7396 match we need to look at them, too. */
7399 tree target_arg_types
;
7400 tree target_ret_type
;
7403 unsigned int nargs
, ia
;
7406 target_arg_types
= TYPE_ARG_TYPES (target_fn_type
);
7407 target_ret_type
= TREE_TYPE (target_fn_type
);
7409 nargs
= list_length (target_arg_types
);
7410 args
= XALLOCAVEC (tree
, nargs
);
7411 for (arg
= target_arg_types
, ia
= 0;
7412 arg
!= NULL_TREE
&& arg
!= void_list_node
;
7413 arg
= TREE_CHAIN (arg
), ++ia
)
7414 args
[ia
] = TREE_VALUE (arg
);
7417 for (fns
= overload
; fns
; fns
= OVL_NEXT (fns
))
7419 tree fn
= OVL_CURRENT (fns
);
7423 if (TREE_CODE (fn
) != TEMPLATE_DECL
)
7424 /* We're only looking for templates. */
7427 if ((TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
7429 /* We're not looking for a non-static member, and this is
7430 one, or vice versa. */
7433 tree ret
= target_ret_type
;
7435 /* If the template has a deduced return type, don't expose it to
7436 template argument deduction. */
7437 if (undeduced_auto_decl (fn
))
7440 /* Try to do argument deduction. */
7441 targs
= make_tree_vec (DECL_NTPARMS (fn
));
7442 instantiation
= fn_type_unification (fn
, explicit_targs
, targs
, args
,
7444 DEDUCE_EXACT
, LOOKUP_NORMAL
,
7446 if (instantiation
== error_mark_node
)
7447 /* Instantiation failed. */
7450 /* And now force instantiation to do return type deduction. */
7451 if (undeduced_auto_decl (instantiation
))
7454 instantiate_decl (instantiation
, /*defer*/false, /*class*/false);
7457 require_deduced_type (instantiation
);
7460 /* See if there's a match. */
7461 if (same_type_p (target_fn_type
, static_fn_type (instantiation
)))
7462 matches
= tree_cons (instantiation
, fn
, matches
);
7465 /* Now, remove all but the most specialized of the matches. */
7468 tree match
= most_specialized_instantiation (matches
);
7470 if (match
!= error_mark_node
)
7471 matches
= tree_cons (TREE_PURPOSE (match
),
7477 /* Now we should have exactly one function in MATCHES. */
7478 if (matches
== NULL_TREE
)
7480 /* There were *no* matches. */
7481 if (flags
& tf_error
)
7483 error ("no matches converting function %qD to type %q#T",
7484 DECL_NAME (OVL_CURRENT (overload
)),
7487 print_candidates (overload
);
7489 return error_mark_node
;
7491 else if (TREE_CHAIN (matches
))
7493 /* There were too many matches. First check if they're all
7494 the same function. */
7495 tree match
= NULL_TREE
;
7497 fn
= TREE_PURPOSE (matches
);
7499 /* For multi-versioned functions, more than one match is just fine and
7500 decls_match will return false as they are different. */
7501 for (match
= TREE_CHAIN (matches
); match
; match
= TREE_CHAIN (match
))
7502 if (!decls_match (fn
, TREE_PURPOSE (match
))
7503 && !targetm
.target_option
.function_versions
7504 (fn
, TREE_PURPOSE (match
)))
7509 if (flags
& tf_error
)
7511 error ("converting overloaded function %qD to type %q#T is ambiguous",
7512 DECL_NAME (OVL_FUNCTION (overload
)),
7515 /* Since print_candidates expects the functions in the
7516 TREE_VALUE slot, we flip them here. */
7517 for (match
= matches
; match
; match
= TREE_CHAIN (match
))
7518 TREE_VALUE (match
) = TREE_PURPOSE (match
);
7520 print_candidates (matches
);
7523 return error_mark_node
;
7527 /* Good, exactly one match. Now, convert it to the correct type. */
7528 fn
= TREE_PURPOSE (matches
);
7530 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn
)
7531 && !(flags
& tf_ptrmem_ok
) && !flag_ms_extensions
)
7533 static int explained
;
7535 if (!(flags
& tf_error
))
7536 return error_mark_node
;
7538 permerror (input_location
, "assuming pointer to member %qD", fn
);
7541 inform (input_location
, "(a pointer to member can only be formed with %<&%E%>)", fn
);
7546 /* If a pointer to a function that is multi-versioned is requested, the
7547 pointer to the dispatcher function is returned instead. This works
7548 well because indirectly calling the function will dispatch the right
7549 function version at run-time. */
7550 if (DECL_FUNCTION_VERSIONED (fn
))
7552 fn
= get_function_version_dispatcher (fn
);
7554 return error_mark_node
;
7555 /* Mark all the versions corresponding to the dispatcher as used. */
7556 if (!(flags
& tf_conv
))
7557 mark_versions_used (fn
);
7560 /* If we're doing overload resolution purely for the purpose of
7561 determining conversion sequences, we should not consider the
7562 function used. If this conversion sequence is selected, the
7563 function will be marked as used at this point. */
7564 if (!(flags
& tf_conv
))
7566 /* Make =delete work with SFINAE. */
7567 if (DECL_DELETED_FN (fn
) && !(flags
& tf_error
))
7568 return error_mark_node
;
7573 /* We could not check access to member functions when this
7574 expression was originally created since we did not know at that
7575 time to which function the expression referred. */
7576 if (DECL_FUNCTION_MEMBER_P (fn
))
7578 gcc_assert (access_path
);
7579 perform_or_defer_access_check (access_path
, fn
, fn
, flags
);
7582 if (TYPE_PTRFN_P (target_type
) || TYPE_PTRMEMFUNC_P (target_type
))
7583 return cp_build_addr_expr (fn
, flags
);
7586 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
7587 will mark the function as addressed, but here we must do it
7589 cxx_mark_addressable (fn
);
7595 /* This function will instantiate the type of the expression given in
7596 RHS to match the type of LHSTYPE. If errors exist, then return
7597 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
7598 we complain on errors. If we are not complaining, never modify rhs,
7599 as overload resolution wants to try many possible instantiations, in
7600 the hope that at least one will work.
7602 For non-recursive calls, LHSTYPE should be a function, pointer to
7603 function, or a pointer to member function. */
7606 instantiate_type (tree lhstype
, tree rhs
, tsubst_flags_t flags
)
7608 tsubst_flags_t flags_in
= flags
;
7609 tree access_path
= NULL_TREE
;
7611 flags
&= ~tf_ptrmem_ok
;
7613 if (lhstype
== unknown_type_node
)
7615 if (flags
& tf_error
)
7616 error ("not enough type information");
7617 return error_mark_node
;
7620 if (TREE_TYPE (rhs
) != NULL_TREE
&& ! (type_unknown_p (rhs
)))
7622 tree fntype
= non_reference (lhstype
);
7623 if (same_type_p (fntype
, TREE_TYPE (rhs
)))
7625 if (flag_ms_extensions
7626 && TYPE_PTRMEMFUNC_P (fntype
)
7627 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs
)))
7628 /* Microsoft allows `A::f' to be resolved to a
7629 pointer-to-member. */
7633 if (flags
& tf_error
)
7634 error ("cannot convert %qE from type %qT to type %qT",
7635 rhs
, TREE_TYPE (rhs
), fntype
);
7636 return error_mark_node
;
7640 if (BASELINK_P (rhs
))
7642 access_path
= BASELINK_ACCESS_BINFO (rhs
);
7643 rhs
= BASELINK_FUNCTIONS (rhs
);
7646 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
7647 deduce any type information. */
7648 if (TREE_CODE (rhs
) == NON_DEPENDENT_EXPR
)
7650 if (flags
& tf_error
)
7651 error ("not enough type information");
7652 return error_mark_node
;
7655 /* There only a few kinds of expressions that may have a type
7656 dependent on overload resolution. */
7657 gcc_assert (TREE_CODE (rhs
) == ADDR_EXPR
7658 || TREE_CODE (rhs
) == COMPONENT_REF
7659 || is_overloaded_fn (rhs
)
7660 || (flag_ms_extensions
&& TREE_CODE (rhs
) == FUNCTION_DECL
));
7662 /* This should really only be used when attempting to distinguish
7663 what sort of a pointer to function we have. For now, any
7664 arithmetic operation which is not supported on pointers
7665 is rejected as an error. */
7667 switch (TREE_CODE (rhs
))
7671 tree member
= TREE_OPERAND (rhs
, 1);
7673 member
= instantiate_type (lhstype
, member
, flags
);
7674 if (member
!= error_mark_node
7675 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs
, 0)))
7676 /* Do not lose object's side effects. */
7677 return build2 (COMPOUND_EXPR
, TREE_TYPE (member
),
7678 TREE_OPERAND (rhs
, 0), member
);
7683 rhs
= TREE_OPERAND (rhs
, 1);
7684 if (BASELINK_P (rhs
))
7685 return instantiate_type (lhstype
, rhs
, flags_in
);
7687 /* This can happen if we are forming a pointer-to-member for a
7689 gcc_assert (TREE_CODE (rhs
) == TEMPLATE_ID_EXPR
);
7693 case TEMPLATE_ID_EXPR
:
7695 tree fns
= TREE_OPERAND (rhs
, 0);
7696 tree args
= TREE_OPERAND (rhs
, 1);
7699 resolve_address_of_overloaded_function (lhstype
, fns
, flags_in
,
7700 /*template_only=*/true,
7707 resolve_address_of_overloaded_function (lhstype
, rhs
, flags_in
,
7708 /*template_only=*/false,
7709 /*explicit_targs=*/NULL_TREE
,
7714 if (PTRMEM_OK_P (rhs
))
7715 flags
|= tf_ptrmem_ok
;
7717 return instantiate_type (lhstype
, TREE_OPERAND (rhs
, 0), flags
);
7721 return error_mark_node
;
7726 return error_mark_node
;
7729 /* Return the name of the virtual function pointer field
7730 (as an IDENTIFIER_NODE) for the given TYPE. Note that
7731 this may have to look back through base types to find the
7732 ultimate field name. (For single inheritance, these could
7733 all be the same name. Who knows for multiple inheritance). */
7736 get_vfield_name (tree type
)
7738 tree binfo
, base_binfo
;
7741 for (binfo
= TYPE_BINFO (type
);
7742 BINFO_N_BASE_BINFOS (binfo
);
7745 base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
7747 if (BINFO_VIRTUAL_P (base_binfo
)
7748 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo
)))
7752 type
= BINFO_TYPE (binfo
);
7753 buf
= (char *) alloca (sizeof (VFIELD_NAME_FORMAT
)
7754 + TYPE_NAME_LENGTH (type
) + 2);
7755 sprintf (buf
, VFIELD_NAME_FORMAT
,
7756 IDENTIFIER_POINTER (constructor_name (type
)));
7757 return get_identifier (buf
);
7761 print_class_statistics (void)
7763 if (! GATHER_STATISTICS
)
7766 fprintf (stderr
, "convert_harshness = %d\n", n_convert_harshness
);
7767 fprintf (stderr
, "compute_conversion_costs = %d\n", n_compute_conversion_costs
);
7770 fprintf (stderr
, "vtables = %d; vtable searches = %d\n",
7771 n_vtables
, n_vtable_searches
);
7772 fprintf (stderr
, "vtable entries = %d; vtable elems = %d\n",
7773 n_vtable_entries
, n_vtable_elems
);
7777 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
7778 according to [class]:
7779 The class-name is also inserted
7780 into the scope of the class itself. For purposes of access checking,
7781 the inserted class name is treated as if it were a public member name. */
7784 build_self_reference (void)
7786 tree name
= constructor_name (current_class_type
);
7787 tree value
= build_lang_decl (TYPE_DECL
, name
, current_class_type
);
7790 DECL_NONLOCAL (value
) = 1;
7791 DECL_CONTEXT (value
) = current_class_type
;
7792 DECL_ARTIFICIAL (value
) = 1;
7793 SET_DECL_SELF_REFERENCE_P (value
);
7794 set_underlying_type (value
);
7796 if (processing_template_decl
)
7797 value
= push_template_decl (value
);
7799 saved_cas
= current_access_specifier
;
7800 current_access_specifier
= access_public_node
;
7801 finish_member_declaration (value
);
7802 current_access_specifier
= saved_cas
;
7805 /* Returns 1 if TYPE contains only padding bytes. */
7808 is_empty_class (tree type
)
7810 if (type
== error_mark_node
)
7813 if (! CLASS_TYPE_P (type
))
7816 return CLASSTYPE_EMPTY_P (type
);
7819 /* Returns true if TYPE contains no actual data, just various
7820 possible combinations of empty classes and possibly a vptr. */
7823 is_really_empty_class (tree type
)
7825 if (CLASS_TYPE_P (type
))
7832 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
7833 out, but we'd like to be able to check this before then. */
7834 if (COMPLETE_TYPE_P (type
) && is_empty_class (type
))
7837 for (binfo
= TYPE_BINFO (type
), i
= 0;
7838 BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
7839 if (!is_really_empty_class (BINFO_TYPE (base_binfo
)))
7841 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7842 if (TREE_CODE (field
) == FIELD_DECL
7843 && !DECL_ARTIFICIAL (field
)
7844 && !is_really_empty_class (TREE_TYPE (field
)))
7848 else if (TREE_CODE (type
) == ARRAY_TYPE
)
7849 return is_really_empty_class (TREE_TYPE (type
));
7853 /* Note that NAME was looked up while the current class was being
7854 defined and that the result of that lookup was DECL. */
7857 maybe_note_name_used_in_class (tree name
, tree decl
)
7859 splay_tree names_used
;
7861 /* If we're not defining a class, there's nothing to do. */
7862 if (!(innermost_scope_kind() == sk_class
7863 && TYPE_BEING_DEFINED (current_class_type
)
7864 && !LAMBDA_TYPE_P (current_class_type
)))
7867 /* If there's already a binding for this NAME, then we don't have
7868 anything to worry about. */
7869 if (lookup_member (current_class_type
, name
,
7870 /*protect=*/0, /*want_type=*/false, tf_warning_or_error
))
7873 if (!current_class_stack
[current_class_depth
- 1].names_used
)
7874 current_class_stack
[current_class_depth
- 1].names_used
7875 = splay_tree_new (splay_tree_compare_pointers
, 0, 0);
7876 names_used
= current_class_stack
[current_class_depth
- 1].names_used
;
7878 splay_tree_insert (names_used
,
7879 (splay_tree_key
) name
,
7880 (splay_tree_value
) decl
);
7883 /* Note that NAME was declared (as DECL) in the current class. Check
7884 to see that the declaration is valid. */
7887 note_name_declared_in_class (tree name
, tree decl
)
7889 splay_tree names_used
;
7892 /* Look to see if we ever used this name. */
7894 = current_class_stack
[current_class_depth
- 1].names_used
;
7897 /* The C language allows members to be declared with a type of the same
7898 name, and the C++ standard says this diagnostic is not required. So
7899 allow it in extern "C" blocks unless predantic is specified.
7900 Allow it in all cases if -ms-extensions is specified. */
7901 if ((!pedantic
&& current_lang_name
== lang_name_c
)
7902 || flag_ms_extensions
)
7904 n
= splay_tree_lookup (names_used
, (splay_tree_key
) name
);
7907 /* [basic.scope.class]
7909 A name N used in a class S shall refer to the same declaration
7910 in its context and when re-evaluated in the completed scope of
7912 permerror (input_location
, "declaration of %q#D", decl
);
7913 permerror (input_location
, "changes meaning of %qD from %q+#D",
7914 DECL_NAME (OVL_CURRENT (decl
)), (tree
) n
->value
);
7918 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
7919 Secondary vtables are merged with primary vtables; this function
7920 will return the VAR_DECL for the primary vtable. */
7923 get_vtbl_decl_for_binfo (tree binfo
)
7927 decl
= BINFO_VTABLE (binfo
);
7928 if (decl
&& TREE_CODE (decl
) == POINTER_PLUS_EXPR
)
7930 gcc_assert (TREE_CODE (TREE_OPERAND (decl
, 0)) == ADDR_EXPR
);
7931 decl
= TREE_OPERAND (TREE_OPERAND (decl
, 0), 0);
7934 gcc_assert (VAR_P (decl
));
7939 /* Returns the binfo for the primary base of BINFO. If the resulting
7940 BINFO is a virtual base, and it is inherited elsewhere in the
7941 hierarchy, then the returned binfo might not be the primary base of
7942 BINFO in the complete object. Check BINFO_PRIMARY_P or
7943 BINFO_LOST_PRIMARY_P to be sure. */
7946 get_primary_binfo (tree binfo
)
7950 primary_base
= CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo
));
7954 return copied_binfo (primary_base
, binfo
);
7957 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
7960 maybe_indent_hierarchy (FILE * stream
, int indent
, int indented_p
)
7963 fprintf (stream
, "%*s", indent
, "");
7967 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
7968 INDENT should be zero when called from the top level; it is
7969 incremented recursively. IGO indicates the next expected BINFO in
7970 inheritance graph ordering. */
7973 dump_class_hierarchy_r (FILE *stream
,
7983 indented
= maybe_indent_hierarchy (stream
, indent
, 0);
7984 fprintf (stream
, "%s (0x" HOST_WIDE_INT_PRINT_HEX
") ",
7985 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
),
7986 (HOST_WIDE_INT
) (uintptr_t) binfo
);
7989 fprintf (stream
, "alternative-path\n");
7992 igo
= TREE_CHAIN (binfo
);
7994 fprintf (stream
, HOST_WIDE_INT_PRINT_DEC
,
7995 tree_to_shwi (BINFO_OFFSET (binfo
)));
7996 if (is_empty_class (BINFO_TYPE (binfo
)))
7997 fprintf (stream
, " empty");
7998 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo
)))
7999 fprintf (stream
, " nearly-empty");
8000 if (BINFO_VIRTUAL_P (binfo
))
8001 fprintf (stream
, " virtual");
8002 fprintf (stream
, "\n");
8005 if (BINFO_PRIMARY_P (binfo
))
8007 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8008 fprintf (stream
, " primary-for %s (0x" HOST_WIDE_INT_PRINT_HEX
")",
8009 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo
)),
8010 TFF_PLAIN_IDENTIFIER
),
8011 (HOST_WIDE_INT
) (uintptr_t) BINFO_INHERITANCE_CHAIN (binfo
));
8013 if (BINFO_LOST_PRIMARY_P (binfo
))
8015 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8016 fprintf (stream
, " lost-primary");
8019 fprintf (stream
, "\n");
8021 if (!(flags
& TDF_SLIM
))
8025 if (BINFO_SUBVTT_INDEX (binfo
))
8027 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8028 fprintf (stream
, " subvttidx=%s",
8029 expr_as_string (BINFO_SUBVTT_INDEX (binfo
),
8030 TFF_PLAIN_IDENTIFIER
));
8032 if (BINFO_VPTR_INDEX (binfo
))
8034 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8035 fprintf (stream
, " vptridx=%s",
8036 expr_as_string (BINFO_VPTR_INDEX (binfo
),
8037 TFF_PLAIN_IDENTIFIER
));
8039 if (BINFO_VPTR_FIELD (binfo
))
8041 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8042 fprintf (stream
, " vbaseoffset=%s",
8043 expr_as_string (BINFO_VPTR_FIELD (binfo
),
8044 TFF_PLAIN_IDENTIFIER
));
8046 if (BINFO_VTABLE (binfo
))
8048 indented
= maybe_indent_hierarchy (stream
, indent
+ 3, indented
);
8049 fprintf (stream
, " vptr=%s",
8050 expr_as_string (BINFO_VTABLE (binfo
),
8051 TFF_PLAIN_IDENTIFIER
));
8055 fprintf (stream
, "\n");
8058 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
8059 igo
= dump_class_hierarchy_r (stream
, flags
, base_binfo
, igo
, indent
+ 2);
8064 /* Dump the BINFO hierarchy for T. */
8067 dump_class_hierarchy_1 (FILE *stream
, int flags
, tree t
)
8069 fprintf (stream
, "Class %s\n", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8070 fprintf (stream
, " size=%lu align=%lu\n",
8071 (unsigned long)(tree_to_shwi (TYPE_SIZE (t
)) / BITS_PER_UNIT
),
8072 (unsigned long)(TYPE_ALIGN (t
) / BITS_PER_UNIT
));
8073 fprintf (stream
, " base size=%lu base align=%lu\n",
8074 (unsigned long)(tree_to_shwi (TYPE_SIZE (CLASSTYPE_AS_BASE (t
)))
8076 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t
))
8078 dump_class_hierarchy_r (stream
, flags
, TYPE_BINFO (t
), TYPE_BINFO (t
), 0);
8079 fprintf (stream
, "\n");
8082 /* Debug interface to hierarchy dumping. */
8085 debug_class (tree t
)
8087 dump_class_hierarchy_1 (stderr
, TDF_SLIM
, t
);
8091 dump_class_hierarchy (tree t
)
8094 FILE *stream
= get_dump_info (TDI_class
, &flags
);
8098 dump_class_hierarchy_1 (stream
, flags
, t
);
8103 dump_array (FILE * stream
, tree decl
)
8106 unsigned HOST_WIDE_INT ix
;
8108 tree size
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl
)));
8110 elt
= (tree_to_shwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
))))
8112 fprintf (stream
, "%s:", decl_as_string (decl
, TFF_PLAIN_IDENTIFIER
));
8113 fprintf (stream
, " %s entries",
8114 expr_as_string (size_binop (PLUS_EXPR
, size
, size_one_node
),
8115 TFF_PLAIN_IDENTIFIER
));
8116 fprintf (stream
, "\n");
8118 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
)),
8120 fprintf (stream
, "%-4ld %s\n", (long)(ix
* elt
),
8121 expr_as_string (value
, TFF_PLAIN_IDENTIFIER
));
8125 dump_vtable (tree t
, tree binfo
, tree vtable
)
8128 FILE *stream
= get_dump_info (TDI_class
, &flags
);
8133 if (!(flags
& TDF_SLIM
))
8135 int ctor_vtbl_p
= TYPE_BINFO (t
) != binfo
;
8137 fprintf (stream
, "%s for %s",
8138 ctor_vtbl_p
? "Construction vtable" : "Vtable",
8139 type_as_string (BINFO_TYPE (binfo
), TFF_PLAIN_IDENTIFIER
));
8142 if (!BINFO_VIRTUAL_P (binfo
))
8143 fprintf (stream
, " (0x" HOST_WIDE_INT_PRINT_HEX
" instance)",
8144 (HOST_WIDE_INT
) (uintptr_t) binfo
);
8145 fprintf (stream
, " in %s", type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8147 fprintf (stream
, "\n");
8148 dump_array (stream
, vtable
);
8149 fprintf (stream
, "\n");
8154 dump_vtt (tree t
, tree vtt
)
8157 FILE *stream
= get_dump_info (TDI_class
, &flags
);
8162 if (!(flags
& TDF_SLIM
))
8164 fprintf (stream
, "VTT for %s\n",
8165 type_as_string (t
, TFF_PLAIN_IDENTIFIER
));
8166 dump_array (stream
, vtt
);
8167 fprintf (stream
, "\n");
8171 /* Dump a function or thunk and its thunkees. */
8174 dump_thunk (FILE *stream
, int indent
, tree thunk
)
8176 static const char spaces
[] = " ";
8177 tree name
= DECL_NAME (thunk
);
8180 fprintf (stream
, "%.*s%p %s %s", indent
, spaces
,
8182 !DECL_THUNK_P (thunk
) ? "function"
8183 : DECL_THIS_THUNK_P (thunk
) ? "this-thunk" : "covariant-thunk",
8184 name
? IDENTIFIER_POINTER (name
) : "<unset>");
8185 if (DECL_THUNK_P (thunk
))
8187 HOST_WIDE_INT fixed_adjust
= THUNK_FIXED_OFFSET (thunk
);
8188 tree virtual_adjust
= THUNK_VIRTUAL_OFFSET (thunk
);
8190 fprintf (stream
, " fixed=" HOST_WIDE_INT_PRINT_DEC
, fixed_adjust
);
8191 if (!virtual_adjust
)
8193 else if (DECL_THIS_THUNK_P (thunk
))
8194 fprintf (stream
, " vcall=" HOST_WIDE_INT_PRINT_DEC
,
8195 tree_to_shwi (virtual_adjust
));
8197 fprintf (stream
, " vbase=" HOST_WIDE_INT_PRINT_DEC
"(%s)",
8198 tree_to_shwi (BINFO_VPTR_FIELD (virtual_adjust
)),
8199 type_as_string (BINFO_TYPE (virtual_adjust
), TFF_SCOPE
));
8200 if (THUNK_ALIAS (thunk
))
8201 fprintf (stream
, " alias to %p", (void *)THUNK_ALIAS (thunk
));
8203 fprintf (stream
, "\n");
8204 for (thunks
= DECL_THUNKS (thunk
); thunks
; thunks
= TREE_CHAIN (thunks
))
8205 dump_thunk (stream
, indent
+ 2, thunks
);
8208 /* Dump the thunks for FN. */
8211 debug_thunks (tree fn
)
8213 dump_thunk (stderr
, 0, fn
);
8216 /* Virtual function table initialization. */
8218 /* Create all the necessary vtables for T and its base classes. */
8221 finish_vtbls (tree t
)
8224 vec
<constructor_elt
, va_gc
> *v
= NULL
;
8225 tree vtable
= BINFO_VTABLE (TYPE_BINFO (t
));
8227 /* We lay out the primary and secondary vtables in one contiguous
8228 vtable. The primary vtable is first, followed by the non-virtual
8229 secondary vtables in inheritance graph order. */
8230 accumulate_vtbl_inits (TYPE_BINFO (t
), TYPE_BINFO (t
), TYPE_BINFO (t
),
8233 /* Then come the virtual bases, also in inheritance graph order. */
8234 for (vbase
= TYPE_BINFO (t
); vbase
; vbase
= TREE_CHAIN (vbase
))
8236 if (!BINFO_VIRTUAL_P (vbase
))
8238 accumulate_vtbl_inits (vbase
, vbase
, TYPE_BINFO (t
), vtable
, t
, &v
);
8241 if (BINFO_VTABLE (TYPE_BINFO (t
)))
8242 initialize_vtable (TYPE_BINFO (t
), v
);
8245 /* Initialize the vtable for BINFO with the INITS. */
8248 initialize_vtable (tree binfo
, vec
<constructor_elt
, va_gc
> *inits
)
8252 layout_vtable_decl (binfo
, vec_safe_length (inits
));
8253 decl
= get_vtbl_decl_for_binfo (binfo
);
8254 initialize_artificial_var (decl
, inits
);
8255 dump_vtable (BINFO_TYPE (binfo
), binfo
, decl
);
8258 /* Build the VTT (virtual table table) for T.
8259 A class requires a VTT if it has virtual bases.
8262 1 - primary virtual pointer for complete object T
8263 2 - secondary VTTs for each direct non-virtual base of T which requires a
8265 3 - secondary virtual pointers for each direct or indirect base of T which
8266 has virtual bases or is reachable via a virtual path from T.
8267 4 - secondary VTTs for each direct or indirect virtual base of T.
8269 Secondary VTTs look like complete object VTTs without part 4. */
8277 vec
<constructor_elt
, va_gc
> *inits
;
8279 /* Build up the initializers for the VTT. */
8281 index
= size_zero_node
;
8282 build_vtt_inits (TYPE_BINFO (t
), t
, &inits
, &index
);
8284 /* If we didn't need a VTT, we're done. */
8288 /* Figure out the type of the VTT. */
8289 type
= build_array_of_n_type (const_ptr_type_node
,
8292 /* Now, build the VTT object itself. */
8293 vtt
= build_vtable (t
, mangle_vtt_for_type (t
), type
);
8294 initialize_artificial_var (vtt
, inits
);
8295 /* Add the VTT to the vtables list. */
8296 DECL_CHAIN (vtt
) = DECL_CHAIN (CLASSTYPE_VTABLES (t
));
8297 DECL_CHAIN (CLASSTYPE_VTABLES (t
)) = vtt
;
8302 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
8303 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
8304 and CHAIN the vtable pointer for this binfo after construction is
8305 complete. VALUE can also be another BINFO, in which case we recurse. */
8308 binfo_ctor_vtable (tree binfo
)
8314 vt
= BINFO_VTABLE (binfo
);
8315 if (TREE_CODE (vt
) == TREE_LIST
)
8316 vt
= TREE_VALUE (vt
);
8317 if (TREE_CODE (vt
) == TREE_BINFO
)
8326 /* Data for secondary VTT initialization. */
8327 typedef struct secondary_vptr_vtt_init_data_s
8329 /* Is this the primary VTT? */
8332 /* Current index into the VTT. */
8335 /* Vector of initializers built up. */
8336 vec
<constructor_elt
, va_gc
> *inits
;
8338 /* The type being constructed by this secondary VTT. */
8339 tree type_being_constructed
;
8340 } secondary_vptr_vtt_init_data
;
8342 /* Recursively build the VTT-initializer for BINFO (which is in the
8343 hierarchy dominated by T). INITS points to the end of the initializer
8344 list to date. INDEX is the VTT index where the next element will be
8345 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
8346 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
8347 for virtual bases of T. When it is not so, we build the constructor
8348 vtables for the BINFO-in-T variant. */
8351 build_vtt_inits (tree binfo
, tree t
, vec
<constructor_elt
, va_gc
> **inits
,
8357 secondary_vptr_vtt_init_data data
;
8358 int top_level_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
8360 /* We only need VTTs for subobjects with virtual bases. */
8361 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
8364 /* We need to use a construction vtable if this is not the primary
8368 build_ctor_vtbl_group (binfo
, t
);
8370 /* Record the offset in the VTT where this sub-VTT can be found. */
8371 BINFO_SUBVTT_INDEX (binfo
) = *index
;
8374 /* Add the address of the primary vtable for the complete object. */
8375 init
= binfo_ctor_vtable (binfo
);
8376 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8379 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
8380 BINFO_VPTR_INDEX (binfo
) = *index
;
8382 *index
= size_binop (PLUS_EXPR
, *index
, TYPE_SIZE_UNIT (ptr_type_node
));
8384 /* Recursively add the secondary VTTs for non-virtual bases. */
8385 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, b
); ++i
)
8386 if (!BINFO_VIRTUAL_P (b
))
8387 build_vtt_inits (b
, t
, inits
, index
);
8389 /* Add secondary virtual pointers for all subobjects of BINFO with
8390 either virtual bases or reachable along a virtual path, except
8391 subobjects that are non-virtual primary bases. */
8392 data
.top_level_p
= top_level_p
;
8393 data
.index
= *index
;
8394 data
.inits
= *inits
;
8395 data
.type_being_constructed
= BINFO_TYPE (binfo
);
8397 dfs_walk_once (binfo
, dfs_build_secondary_vptr_vtt_inits
, NULL
, &data
);
8399 *index
= data
.index
;
8401 /* data.inits might have grown as we added secondary virtual pointers.
8402 Make sure our caller knows about the new vector. */
8403 *inits
= data
.inits
;
8406 /* Add the secondary VTTs for virtual bases in inheritance graph
8408 for (b
= TYPE_BINFO (BINFO_TYPE (binfo
)); b
; b
= TREE_CHAIN (b
))
8410 if (!BINFO_VIRTUAL_P (b
))
8413 build_vtt_inits (b
, t
, inits
, index
);
8416 /* Remove the ctor vtables we created. */
8417 dfs_walk_all (binfo
, dfs_fixup_binfo_vtbls
, NULL
, binfo
);
8420 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
8421 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
8424 dfs_build_secondary_vptr_vtt_inits (tree binfo
, void *data_
)
8426 secondary_vptr_vtt_init_data
*data
= (secondary_vptr_vtt_init_data
*)data_
;
8428 /* We don't care about bases that don't have vtables. */
8429 if (!TYPE_VFIELD (BINFO_TYPE (binfo
)))
8430 return dfs_skip_bases
;
8432 /* We're only interested in proper subobjects of the type being
8434 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), data
->type_being_constructed
))
8437 /* We're only interested in bases with virtual bases or reachable
8438 via a virtual path from the type being constructed. */
8439 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
8440 || binfo_via_virtual (binfo
, data
->type_being_constructed
)))
8441 return dfs_skip_bases
;
8443 /* We're not interested in non-virtual primary bases. */
8444 if (!BINFO_VIRTUAL_P (binfo
) && BINFO_PRIMARY_P (binfo
))
8447 /* Record the index where this secondary vptr can be found. */
8448 if (data
->top_level_p
)
8450 gcc_assert (!BINFO_VPTR_INDEX (binfo
));
8451 BINFO_VPTR_INDEX (binfo
) = data
->index
;
8453 if (BINFO_VIRTUAL_P (binfo
))
8455 /* It's a primary virtual base, and this is not a
8456 construction vtable. Find the base this is primary of in
8457 the inheritance graph, and use that base's vtable
8459 while (BINFO_PRIMARY_P (binfo
))
8460 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
8464 /* Add the initializer for the secondary vptr itself. */
8465 CONSTRUCTOR_APPEND_ELT (data
->inits
, NULL_TREE
, binfo_ctor_vtable (binfo
));
8467 /* Advance the vtt index. */
8468 data
->index
= size_binop (PLUS_EXPR
, data
->index
,
8469 TYPE_SIZE_UNIT (ptr_type_node
));
8474 /* Called from build_vtt_inits via dfs_walk. After building
8475 constructor vtables and generating the sub-vtt from them, we need
8476 to restore the BINFO_VTABLES that were scribbled on. DATA is the
8477 binfo of the base whose sub vtt was generated. */
8480 dfs_fixup_binfo_vtbls (tree binfo
, void* data
)
8482 tree vtable
= BINFO_VTABLE (binfo
);
8484 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
8485 /* If this class has no vtable, none of its bases do. */
8486 return dfs_skip_bases
;
8489 /* This might be a primary base, so have no vtable in this
8493 /* If we scribbled the construction vtable vptr into BINFO, clear it
8495 if (TREE_CODE (vtable
) == TREE_LIST
8496 && (TREE_PURPOSE (vtable
) == (tree
) data
))
8497 BINFO_VTABLE (binfo
) = TREE_CHAIN (vtable
);
8502 /* Build the construction vtable group for BINFO which is in the
8503 hierarchy dominated by T. */
8506 build_ctor_vtbl_group (tree binfo
, tree t
)
8512 vec
<constructor_elt
, va_gc
> *v
;
8514 /* See if we've already created this construction vtable group. */
8515 id
= mangle_ctor_vtbl_for_type (t
, binfo
);
8516 if (IDENTIFIER_GLOBAL_VALUE (id
))
8519 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
));
8520 /* Build a version of VTBL (with the wrong type) for use in
8521 constructing the addresses of secondary vtables in the
8522 construction vtable group. */
8523 vtbl
= build_vtable (t
, id
, ptr_type_node
);
8524 DECL_CONSTRUCTION_VTABLE_P (vtbl
) = 1;
8525 /* Don't export construction vtables from shared libraries. Even on
8526 targets that don't support hidden visibility, this tells
8527 can_refer_decl_in_current_unit_p not to assume that it's safe to
8528 access from a different compilation unit (bz 54314). */
8529 DECL_VISIBILITY (vtbl
) = VISIBILITY_HIDDEN
;
8530 DECL_VISIBILITY_SPECIFIED (vtbl
) = true;
8533 accumulate_vtbl_inits (binfo
, TYPE_BINFO (TREE_TYPE (binfo
)),
8534 binfo
, vtbl
, t
, &v
);
8536 /* Add the vtables for each of our virtual bases using the vbase in T
8538 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
8540 vbase
= TREE_CHAIN (vbase
))
8544 if (!BINFO_VIRTUAL_P (vbase
))
8546 b
= copied_binfo (vbase
, binfo
);
8548 accumulate_vtbl_inits (b
, vbase
, binfo
, vtbl
, t
, &v
);
8551 /* Figure out the type of the construction vtable. */
8552 type
= build_array_of_n_type (vtable_entry_type
, v
->length ());
8554 TREE_TYPE (vtbl
) = type
;
8555 DECL_SIZE (vtbl
) = DECL_SIZE_UNIT (vtbl
) = NULL_TREE
;
8556 layout_decl (vtbl
, 0);
8558 /* Initialize the construction vtable. */
8559 CLASSTYPE_VTABLES (t
) = chainon (CLASSTYPE_VTABLES (t
), vtbl
);
8560 initialize_artificial_var (vtbl
, v
);
8561 dump_vtable (t
, binfo
, vtbl
);
8564 /* Add the vtbl initializers for BINFO (and its bases other than
8565 non-virtual primaries) to the list of INITS. BINFO is in the
8566 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
8567 the constructor the vtbl inits should be accumulated for. (If this
8568 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
8569 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
8570 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
8571 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
8572 but are not necessarily the same in terms of layout. */
8575 accumulate_vtbl_inits (tree binfo
,
8580 vec
<constructor_elt
, va_gc
> **inits
)
8584 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8586 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), BINFO_TYPE (orig_binfo
)));
8588 /* If it doesn't have a vptr, we don't do anything. */
8589 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo
)))
8592 /* If we're building a construction vtable, we're not interested in
8593 subobjects that don't require construction vtables. */
8595 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
))
8596 && !binfo_via_virtual (orig_binfo
, BINFO_TYPE (rtti_binfo
)))
8599 /* Build the initializers for the BINFO-in-T vtable. */
8600 dfs_accumulate_vtbl_inits (binfo
, orig_binfo
, rtti_binfo
, vtbl
, t
, inits
);
8602 /* Walk the BINFO and its bases. We walk in preorder so that as we
8603 initialize each vtable we can figure out at what offset the
8604 secondary vtable lies from the primary vtable. We can't use
8605 dfs_walk here because we need to iterate through bases of BINFO
8606 and RTTI_BINFO simultaneously. */
8607 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
8609 /* Skip virtual bases. */
8610 if (BINFO_VIRTUAL_P (base_binfo
))
8612 accumulate_vtbl_inits (base_binfo
,
8613 BINFO_BASE_BINFO (orig_binfo
, i
),
8614 rtti_binfo
, vtbl
, t
,
8619 /* Called from accumulate_vtbl_inits. Adds the initializers for the
8620 BINFO vtable to L. */
8623 dfs_accumulate_vtbl_inits (tree binfo
,
8628 vec
<constructor_elt
, va_gc
> **l
)
8630 tree vtbl
= NULL_TREE
;
8631 int ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8635 && BINFO_VIRTUAL_P (orig_binfo
) && BINFO_PRIMARY_P (orig_binfo
))
8637 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
8638 primary virtual base. If it is not the same primary in
8639 the hierarchy of T, we'll need to generate a ctor vtable
8640 for it, to place at its location in T. If it is the same
8641 primary, we still need a VTT entry for the vtable, but it
8642 should point to the ctor vtable for the base it is a
8643 primary for within the sub-hierarchy of RTTI_BINFO.
8645 There are three possible cases:
8647 1) We are in the same place.
8648 2) We are a primary base within a lost primary virtual base of
8650 3) We are primary to something not a base of RTTI_BINFO. */
8653 tree last
= NULL_TREE
;
8655 /* First, look through the bases we are primary to for RTTI_BINFO
8656 or a virtual base. */
8658 while (BINFO_PRIMARY_P (b
))
8660 b
= BINFO_INHERITANCE_CHAIN (b
);
8662 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
8665 /* If we run out of primary links, keep looking down our
8666 inheritance chain; we might be an indirect primary. */
8667 for (b
= last
; b
; b
= BINFO_INHERITANCE_CHAIN (b
))
8668 if (BINFO_VIRTUAL_P (b
) || b
== rtti_binfo
)
8672 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
8673 base B and it is a base of RTTI_BINFO, this is case 2. In
8674 either case, we share our vtable with LAST, i.e. the
8675 derived-most base within B of which we are a primary. */
8677 || (b
&& binfo_for_vbase (BINFO_TYPE (b
), BINFO_TYPE (rtti_binfo
))))
8678 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
8679 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
8680 binfo_ctor_vtable after everything's been set up. */
8683 /* Otherwise, this is case 3 and we get our own. */
8685 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo
))
8688 n_inits
= vec_safe_length (*l
);
8695 /* Add the initializer for this vtable. */
8696 build_vtbl_initializer (binfo
, orig_binfo
, t
, rtti_binfo
,
8697 &non_fn_entries
, l
);
8699 /* Figure out the position to which the VPTR should point. */
8700 vtbl
= build1 (ADDR_EXPR
, vtbl_ptr_type_node
, orig_vtbl
);
8701 index
= size_binop (MULT_EXPR
,
8702 TYPE_SIZE_UNIT (vtable_entry_type
),
8703 size_int (non_fn_entries
+ n_inits
));
8704 vtbl
= fold_build_pointer_plus (vtbl
, index
);
8708 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
8709 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
8710 straighten this out. */
8711 BINFO_VTABLE (binfo
) = tree_cons (rtti_binfo
, vtbl
, BINFO_VTABLE (binfo
));
8712 else if (BINFO_PRIMARY_P (binfo
) && BINFO_VIRTUAL_P (binfo
))
8713 /* Throw away any unneeded intializers. */
8714 (*l
)->truncate (n_inits
);
8716 /* For an ordinary vtable, set BINFO_VTABLE. */
8717 BINFO_VTABLE (binfo
) = vtbl
;
8720 static GTY(()) tree abort_fndecl_addr
;
8722 /* Construct the initializer for BINFO's virtual function table. BINFO
8723 is part of the hierarchy dominated by T. If we're building a
8724 construction vtable, the ORIG_BINFO is the binfo we should use to
8725 find the actual function pointers to put in the vtable - but they
8726 can be overridden on the path to most-derived in the graph that
8727 ORIG_BINFO belongs. Otherwise,
8728 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
8729 BINFO that should be indicated by the RTTI information in the
8730 vtable; it will be a base class of T, rather than T itself, if we
8731 are building a construction vtable.
8733 The value returned is a TREE_LIST suitable for wrapping in a
8734 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
8735 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
8736 number of non-function entries in the vtable.
8738 It might seem that this function should never be called with a
8739 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
8740 base is always subsumed by a derived class vtable. However, when
8741 we are building construction vtables, we do build vtables for
8742 primary bases; we need these while the primary base is being
8746 build_vtbl_initializer (tree binfo
,
8750 int* non_fn_entries_p
,
8751 vec
<constructor_elt
, va_gc
> **inits
)
8757 vec
<tree
, va_gc
> *vbases
;
8760 /* Initialize VID. */
8761 memset (&vid
, 0, sizeof (vid
));
8764 vid
.rtti_binfo
= rtti_binfo
;
8765 vid
.primary_vtbl_p
= SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), t
);
8766 vid
.ctor_vtbl_p
= !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo
), t
);
8767 vid
.generate_vcall_entries
= true;
8768 /* The first vbase or vcall offset is at index -3 in the vtable. */
8769 vid
.index
= ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
8771 /* Add entries to the vtable for RTTI. */
8772 build_rtti_vtbl_entries (binfo
, &vid
);
8774 /* Create an array for keeping track of the functions we've
8775 processed. When we see multiple functions with the same
8776 signature, we share the vcall offsets. */
8777 vec_alloc (vid
.fns
, 32);
8778 /* Add the vcall and vbase offset entries. */
8779 build_vcall_and_vbase_vtbl_entries (binfo
, &vid
);
8781 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
8782 build_vbase_offset_vtbl_entries. */
8783 for (vbases
= CLASSTYPE_VBASECLASSES (t
), ix
= 0;
8784 vec_safe_iterate (vbases
, ix
, &vbinfo
); ix
++)
8785 BINFO_VTABLE_PATH_MARKED (vbinfo
) = 0;
8787 /* If the target requires padding between data entries, add that now. */
8788 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE
> 1)
8790 int n_entries
= vec_safe_length (vid
.inits
);
8792 vec_safe_grow (vid
.inits
, TARGET_VTABLE_DATA_ENTRY_DISTANCE
* n_entries
);
8794 /* Move data entries into their new positions and add padding
8795 after the new positions. Iterate backwards so we don't
8796 overwrite entries that we would need to process later. */
8797 for (ix
= n_entries
- 1;
8798 vid
.inits
->iterate (ix
, &e
);
8802 int new_position
= (TARGET_VTABLE_DATA_ENTRY_DISTANCE
* ix
8803 + (TARGET_VTABLE_DATA_ENTRY_DISTANCE
- 1));
8805 (*vid
.inits
)[new_position
] = *e
;
8807 for (j
= 1; j
< TARGET_VTABLE_DATA_ENTRY_DISTANCE
; ++j
)
8809 constructor_elt
*f
= &(*vid
.inits
)[new_position
- j
];
8810 f
->index
= NULL_TREE
;
8811 f
->value
= build1 (NOP_EXPR
, vtable_entry_type
,
8817 if (non_fn_entries_p
)
8818 *non_fn_entries_p
= vec_safe_length (vid
.inits
);
8820 /* The initializers for virtual functions were built up in reverse
8821 order. Straighten them out and add them to the running list in one
8823 jx
= vec_safe_length (*inits
);
8824 vec_safe_grow (*inits
, jx
+ vid
.inits
->length ());
8826 for (ix
= vid
.inits
->length () - 1;
8827 vid
.inits
->iterate (ix
, &e
);
8831 /* Go through all the ordinary virtual functions, building up
8833 for (v
= BINFO_VIRTUALS (orig_binfo
); v
; v
= TREE_CHAIN (v
))
8837 tree fn
, fn_original
;
8838 tree init
= NULL_TREE
;
8842 if (DECL_THUNK_P (fn
))
8844 if (!DECL_NAME (fn
))
8846 if (THUNK_ALIAS (fn
))
8848 fn
= THUNK_ALIAS (fn
);
8851 fn_original
= THUNK_TARGET (fn
);
8854 /* If the only definition of this function signature along our
8855 primary base chain is from a lost primary, this vtable slot will
8856 never be used, so just zero it out. This is important to avoid
8857 requiring extra thunks which cannot be generated with the function.
8859 We first check this in update_vtable_entry_for_fn, so we handle
8860 restored primary bases properly; we also need to do it here so we
8861 zero out unused slots in ctor vtables, rather than filling them
8862 with erroneous values (though harmless, apart from relocation
8864 if (BV_LOST_PRIMARY (v
))
8865 init
= size_zero_node
;
8869 /* Pull the offset for `this', and the function to call, out of
8871 delta
= BV_DELTA (v
);
8872 vcall_index
= BV_VCALL_INDEX (v
);
8874 gcc_assert (TREE_CODE (delta
) == INTEGER_CST
);
8875 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
8877 /* You can't call an abstract virtual function; it's abstract.
8878 So, we replace these functions with __pure_virtual. */
8879 if (DECL_PURE_VIRTUAL_P (fn_original
))
8882 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8884 if (abort_fndecl_addr
== NULL
)
8886 = fold_convert (vfunc_ptr_type_node
,
8887 build_fold_addr_expr (fn
));
8888 init
= abort_fndecl_addr
;
8891 /* Likewise for deleted virtuals. */
8892 else if (DECL_DELETED_FN (fn_original
))
8894 fn
= get_identifier ("__cxa_deleted_virtual");
8895 if (!get_global_value_if_present (fn
, &fn
))
8896 fn
= push_library_fn (fn
, (build_function_type_list
8897 (void_type_node
, NULL_TREE
)),
8898 NULL_TREE
, ECF_NORETURN
);
8899 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8900 init
= fold_convert (vfunc_ptr_type_node
,
8901 build_fold_addr_expr (fn
));
8905 if (!integer_zerop (delta
) || vcall_index
)
8907 fn
= make_thunk (fn
, /*this_adjusting=*/1, delta
, vcall_index
);
8908 if (!DECL_NAME (fn
))
8911 /* Take the address of the function, considering it to be of an
8912 appropriate generic type. */
8913 if (!TARGET_VTABLE_USES_DESCRIPTORS
)
8914 init
= fold_convert (vfunc_ptr_type_node
,
8915 build_fold_addr_expr (fn
));
8916 /* Don't refer to a virtual destructor from a constructor
8917 vtable or a vtable for an abstract class, since destroying
8918 an object under construction is undefined behavior and we
8919 don't want it to be considered a candidate for speculative
8920 devirtualization. But do create the thunk for ABI
8922 if (DECL_DESTRUCTOR_P (fn_original
)
8923 && (CLASSTYPE_PURE_VIRTUALS (DECL_CONTEXT (fn_original
))
8924 || orig_binfo
!= binfo
))
8925 init
= size_zero_node
;
8929 /* And add it to the chain of initializers. */
8930 if (TARGET_VTABLE_USES_DESCRIPTORS
)
8933 if (init
== size_zero_node
)
8934 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
8935 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8937 for (i
= 0; i
< TARGET_VTABLE_USES_DESCRIPTORS
; ++i
)
8939 tree fdesc
= build2 (FDESC_EXPR
, vfunc_ptr_type_node
,
8940 fn
, build_int_cst (NULL_TREE
, i
));
8941 TREE_CONSTANT (fdesc
) = 1;
8943 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, fdesc
);
8947 CONSTRUCTOR_APPEND_ELT (*inits
, NULL_TREE
, init
);
8951 /* Adds to vid->inits the initializers for the vbase and vcall
8952 offsets in BINFO, which is in the hierarchy dominated by T. */
8955 build_vcall_and_vbase_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
8959 /* If this is a derived class, we must first create entries
8960 corresponding to the primary base class. */
8961 b
= get_primary_binfo (binfo
);
8963 build_vcall_and_vbase_vtbl_entries (b
, vid
);
8965 /* Add the vbase entries for this base. */
8966 build_vbase_offset_vtbl_entries (binfo
, vid
);
8967 /* Add the vcall entries for this base. */
8968 build_vcall_offset_vtbl_entries (binfo
, vid
);
8971 /* Returns the initializers for the vbase offset entries in the vtable
8972 for BINFO (which is part of the class hierarchy dominated by T), in
8973 reverse order. VBASE_OFFSET_INDEX gives the vtable index
8974 where the next vbase offset will go. */
8977 build_vbase_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
8981 tree non_primary_binfo
;
8983 /* If there are no virtual baseclasses, then there is nothing to
8985 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo
)))
8990 /* We might be a primary base class. Go up the inheritance hierarchy
8991 until we find the most derived class of which we are a primary base:
8992 it is the offset of that which we need to use. */
8993 non_primary_binfo
= binfo
;
8994 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo
))
8998 /* If we have reached a virtual base, then it must be a primary
8999 base (possibly multi-level) of vid->binfo, or we wouldn't
9000 have called build_vcall_and_vbase_vtbl_entries for it. But it
9001 might be a lost primary, so just skip down to vid->binfo. */
9002 if (BINFO_VIRTUAL_P (non_primary_binfo
))
9004 non_primary_binfo
= vid
->binfo
;
9008 b
= BINFO_INHERITANCE_CHAIN (non_primary_binfo
);
9009 if (get_primary_binfo (b
) != non_primary_binfo
)
9011 non_primary_binfo
= b
;
9014 /* Go through the virtual bases, adding the offsets. */
9015 for (vbase
= TYPE_BINFO (BINFO_TYPE (binfo
));
9017 vbase
= TREE_CHAIN (vbase
))
9022 if (!BINFO_VIRTUAL_P (vbase
))
9025 /* Find the instance of this virtual base in the complete
9027 b
= copied_binfo (vbase
, binfo
);
9029 /* If we've already got an offset for this virtual base, we
9030 don't need another one. */
9031 if (BINFO_VTABLE_PATH_MARKED (b
))
9033 BINFO_VTABLE_PATH_MARKED (b
) = 1;
9035 /* Figure out where we can find this vbase offset. */
9036 delta
= size_binop (MULT_EXPR
,
9039 TYPE_SIZE_UNIT (vtable_entry_type
)));
9040 if (vid
->primary_vtbl_p
)
9041 BINFO_VPTR_FIELD (b
) = delta
;
9043 if (binfo
!= TYPE_BINFO (t
))
9044 /* The vbase offset had better be the same. */
9045 gcc_assert (tree_int_cst_equal (delta
, BINFO_VPTR_FIELD (vbase
)));
9047 /* The next vbase will come at a more negative offset. */
9048 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
9049 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
9051 /* The initializer is the delta from BINFO to this virtual base.
9052 The vbase offsets go in reverse inheritance-graph order, and
9053 we are walking in inheritance graph order so these end up in
9055 delta
= size_diffop_loc (input_location
,
9056 BINFO_OFFSET (b
), BINFO_OFFSET (non_primary_binfo
));
9058 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
,
9059 fold_build1_loc (input_location
, NOP_EXPR
,
9060 vtable_entry_type
, delta
));
9064 /* Adds the initializers for the vcall offset entries in the vtable
9065 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
9069 build_vcall_offset_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9071 /* We only need these entries if this base is a virtual base. We
9072 compute the indices -- but do not add to the vtable -- when
9073 building the main vtable for a class. */
9074 if (binfo
== TYPE_BINFO (vid
->derived
)
9075 || (BINFO_VIRTUAL_P (binfo
)
9076 /* If BINFO is RTTI_BINFO, then (since BINFO does not
9077 correspond to VID->DERIVED), we are building a primary
9078 construction virtual table. Since this is a primary
9079 virtual table, we do not need the vcall offsets for
9081 && binfo
!= vid
->rtti_binfo
))
9083 /* We need a vcall offset for each of the virtual functions in this
9084 vtable. For example:
9086 class A { virtual void f (); };
9087 class B1 : virtual public A { virtual void f (); };
9088 class B2 : virtual public A { virtual void f (); };
9089 class C: public B1, public B2 { virtual void f (); };
9091 A C object has a primary base of B1, which has a primary base of A. A
9092 C also has a secondary base of B2, which no longer has a primary base
9093 of A. So the B2-in-C construction vtable needs a secondary vtable for
9094 A, which will adjust the A* to a B2* to call f. We have no way of
9095 knowing what (or even whether) this offset will be when we define B2,
9096 so we store this "vcall offset" in the A sub-vtable and look it up in
9097 a "virtual thunk" for B2::f.
9099 We need entries for all the functions in our primary vtable and
9100 in our non-virtual bases' secondary vtables. */
9102 /* If we are just computing the vcall indices -- but do not need
9103 the actual entries -- not that. */
9104 if (!BINFO_VIRTUAL_P (binfo
))
9105 vid
->generate_vcall_entries
= false;
9106 /* Now, walk through the non-virtual bases, adding vcall offsets. */
9107 add_vcall_offset_vtbl_entries_r (binfo
, vid
);
9111 /* Build vcall offsets, starting with those for BINFO. */
9114 add_vcall_offset_vtbl_entries_r (tree binfo
, vtbl_init_data
* vid
)
9120 /* Don't walk into virtual bases -- except, of course, for the
9121 virtual base for which we are building vcall offsets. Any
9122 primary virtual base will have already had its offsets generated
9123 through the recursion in build_vcall_and_vbase_vtbl_entries. */
9124 if (BINFO_VIRTUAL_P (binfo
) && vid
->vbase
!= binfo
)
9127 /* If BINFO has a primary base, process it first. */
9128 primary_binfo
= get_primary_binfo (binfo
);
9130 add_vcall_offset_vtbl_entries_r (primary_binfo
, vid
);
9132 /* Add BINFO itself to the list. */
9133 add_vcall_offset_vtbl_entries_1 (binfo
, vid
);
9135 /* Scan the non-primary bases of BINFO. */
9136 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); ++i
)
9137 if (base_binfo
!= primary_binfo
)
9138 add_vcall_offset_vtbl_entries_r (base_binfo
, vid
);
9141 /* Called from build_vcall_offset_vtbl_entries_r. */
9144 add_vcall_offset_vtbl_entries_1 (tree binfo
, vtbl_init_data
* vid
)
9146 /* Make entries for the rest of the virtuals. */
9149 /* The ABI requires that the methods be processed in declaration
9151 for (orig_fn
= TYPE_METHODS (BINFO_TYPE (binfo
));
9153 orig_fn
= DECL_CHAIN (orig_fn
))
9154 if (TREE_CODE (orig_fn
) == FUNCTION_DECL
&& DECL_VINDEX (orig_fn
))
9155 add_vcall_offset (orig_fn
, binfo
, vid
);
9158 /* Add a vcall offset entry for ORIG_FN to the vtable. */
9161 add_vcall_offset (tree orig_fn
, tree binfo
, vtbl_init_data
*vid
)
9167 /* If there is already an entry for a function with the same
9168 signature as FN, then we do not need a second vcall offset.
9169 Check the list of functions already present in the derived
9171 FOR_EACH_VEC_SAFE_ELT (vid
->fns
, i
, derived_entry
)
9173 if (same_signature_p (derived_entry
, orig_fn
)
9174 /* We only use one vcall offset for virtual destructors,
9175 even though there are two virtual table entries. */
9176 || (DECL_DESTRUCTOR_P (derived_entry
)
9177 && DECL_DESTRUCTOR_P (orig_fn
)))
9181 /* If we are building these vcall offsets as part of building
9182 the vtable for the most derived class, remember the vcall
9184 if (vid
->binfo
== TYPE_BINFO (vid
->derived
))
9186 tree_pair_s elt
= {orig_fn
, vid
->index
};
9187 vec_safe_push (CLASSTYPE_VCALL_INDICES (vid
->derived
), elt
);
9190 /* The next vcall offset will be found at a more negative
9192 vid
->index
= size_binop (MINUS_EXPR
, vid
->index
,
9193 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE
));
9195 /* Keep track of this function. */
9196 vec_safe_push (vid
->fns
, orig_fn
);
9198 if (vid
->generate_vcall_entries
)
9203 /* Find the overriding function. */
9204 fn
= find_final_overrider (vid
->rtti_binfo
, binfo
, orig_fn
);
9205 if (fn
== error_mark_node
)
9206 vcall_offset
= build_zero_cst (vtable_entry_type
);
9209 base
= TREE_VALUE (fn
);
9211 /* The vbase we're working on is a primary base of
9212 vid->binfo. But it might be a lost primary, so its
9213 BINFO_OFFSET might be wrong, so we just use the
9214 BINFO_OFFSET from vid->binfo. */
9215 vcall_offset
= size_diffop_loc (input_location
,
9216 BINFO_OFFSET (base
),
9217 BINFO_OFFSET (vid
->binfo
));
9218 vcall_offset
= fold_build1_loc (input_location
,
9219 NOP_EXPR
, vtable_entry_type
,
9222 /* Add the initializer to the vtable. */
9223 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, vcall_offset
);
9227 /* Return vtbl initializers for the RTTI entries corresponding to the
9228 BINFO's vtable. The RTTI entries should indicate the object given
9229 by VID->rtti_binfo. */
9232 build_rtti_vtbl_entries (tree binfo
, vtbl_init_data
* vid
)
9240 t
= BINFO_TYPE (vid
->rtti_binfo
);
9242 /* To find the complete object, we will first convert to our most
9243 primary base, and then add the offset in the vtbl to that value. */
9245 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b
))
9246 && !BINFO_LOST_PRIMARY_P (b
))
9250 primary_base
= get_primary_binfo (b
);
9251 gcc_assert (BINFO_PRIMARY_P (primary_base
)
9252 && BINFO_INHERITANCE_CHAIN (primary_base
) == b
);
9255 offset
= size_diffop_loc (input_location
,
9256 BINFO_OFFSET (vid
->rtti_binfo
), BINFO_OFFSET (b
));
9258 /* The second entry is the address of the typeinfo object. */
9260 decl
= build_address (get_tinfo_decl (t
));
9262 decl
= integer_zero_node
;
9264 /* Convert the declaration to a type that can be stored in the
9266 init
= build_nop (vfunc_ptr_type_node
, decl
);
9267 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, init
);
9269 /* Add the offset-to-top entry. It comes earlier in the vtable than
9270 the typeinfo entry. Convert the offset to look like a
9271 function pointer, so that we can put it in the vtable. */
9272 init
= build_nop (vfunc_ptr_type_node
, offset
);
9273 CONSTRUCTOR_APPEND_ELT (vid
->inits
, NULL_TREE
, init
);
9276 /* TRUE iff TYPE is uniquely derived from PARENT. Ignores
9280 uniquely_derived_from_p (tree parent
, tree type
)
9282 tree base
= lookup_base (type
, parent
, ba_unique
, NULL
, tf_none
);
9283 return base
&& base
!= error_mark_node
;
9286 /* TRUE iff TYPE is publicly & uniquely derived from PARENT. */
9289 publicly_uniquely_derived_p (tree parent
, tree type
)
9291 tree base
= lookup_base (type
, parent
, ba_ignore_scope
| ba_check
,
9293 return base
&& base
!= error_mark_node
;
9296 /* CTX1 and CTX2 are declaration contexts. Return the innermost common
9297 class between them, if any. */
9300 common_enclosing_class (tree ctx1
, tree ctx2
)
9302 if (!TYPE_P (ctx1
) || !TYPE_P (ctx2
))
9304 gcc_assert (ctx1
== TYPE_MAIN_VARIANT (ctx1
)
9305 && ctx2
== TYPE_MAIN_VARIANT (ctx2
));
9308 for (tree t
= ctx1
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9309 TYPE_MARKED_P (t
) = true;
9310 tree found
= NULL_TREE
;
9311 for (tree t
= ctx2
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9312 if (TYPE_MARKED_P (t
))
9317 for (tree t
= ctx1
; TYPE_P (t
); t
= TYPE_CONTEXT (t
))
9318 TYPE_MARKED_P (t
) = false;
9322 #include "gt-cp-class.h"