1/* Functions related to building classes and their related objects. 2 Copyright (C) 1987-2015 Free Software Foundation, Inc. 3 Contributed by Michael Tiemann (tiemann@cygnus.com) 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 3, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21 22/* High-level class interface. */ 23 24#include "config.h" 25#include "system.h" 26#include "coretypes.h" 27#include "hash-set.h" 28#include "machmode.h" 29#include "vec.h" 30#include "double-int.h" 31#include "input.h" 32#include "alias.h" 33#include "symtab.h" 34#include "options.h" 35#include "wide-int.h" 36#include "inchash.h" 37#include "tm.h" 38#include "tree.h" 39#include "stringpool.h" 40#include "stor-layout.h" 41#include "attribs.h" 42#include "hash-table.h" 43#include "cp-tree.h" 44#include "flags.h" 45#include "toplev.h" 46#include "target.h" 47#include "convert.h" 48#include "hash-map.h" 49#include "is-a.h" 50#include "plugin-api.h" 51#include "hard-reg-set.h" 52#include "input.h" 53#include "function.h" 54#include "ipa-ref.h" 55#include "cgraph.h" 56#include "dumpfile.h" 57#include "splay-tree.h" 58#include "gimplify.h" 59#include "wide-int.h" 60 61/* The number of nested classes being processed. If we are not in the 62 scope of any class, this is zero. */ 63 64int current_class_depth; 65 66/* In order to deal with nested classes, we keep a stack of classes. 67 The topmost entry is the innermost class, and is the entry at index 68 CURRENT_CLASS_DEPTH */ 69 70typedef struct class_stack_node { 71 /* The name of the class. */ 72 tree name; 73 74 /* The _TYPE node for the class. */ 75 tree type; 76 77 /* The access specifier pending for new declarations in the scope of 78 this class. */ 79 tree access; 80 81 /* If were defining TYPE, the names used in this class. */ 82 splay_tree names_used; 83 84 /* Nonzero if this class is no longer open, because of a call to 85 push_to_top_level. */ 86 size_t hidden; 87}* class_stack_node_t; 88 89typedef struct vtbl_init_data_s 90{ 91 /* The base for which we're building initializers. */ 92 tree binfo; 93 /* The type of the most-derived type. */ 94 tree derived; 95 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived), 96 unless ctor_vtbl_p is true. */ 97 tree rtti_binfo; 98 /* The negative-index vtable initializers built up so far. These 99 are in order from least negative index to most negative index. */ 100 vec<constructor_elt, va_gc> *inits; 101 /* The binfo for the virtual base for which we're building 102 vcall offset initializers. */ 103 tree vbase; 104 /* The functions in vbase for which we have already provided vcall 105 offsets. */ 106 vec<tree, va_gc> *fns; 107 /* The vtable index of the next vcall or vbase offset. */ 108 tree index; 109 /* Nonzero if we are building the initializer for the primary 110 vtable. */ 111 int primary_vtbl_p; 112 /* Nonzero if we are building the initializer for a construction 113 vtable. */ 114 int ctor_vtbl_p; 115 /* True when adding vcall offset entries to the vtable. False when 116 merely computing the indices. */ 117 bool generate_vcall_entries; 118} vtbl_init_data; 119 120/* The type of a function passed to walk_subobject_offsets. */ 121typedef int (*subobject_offset_fn) (tree, tree, splay_tree); 122 123/* The stack itself. This is a dynamically resized array. The 124 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */ 125static int current_class_stack_size; 126static class_stack_node_t current_class_stack; 127 128/* The size of the largest empty class seen in this translation unit. */ 129static GTY (()) tree sizeof_biggest_empty_class; 130 131/* An array of all local classes present in this translation unit, in 132 declaration order. */ 133vec<tree, va_gc> *local_classes; 134 135static tree get_vfield_name (tree); 136static void finish_struct_anon (tree); 137static tree get_vtable_name (tree); 138static void get_basefndecls (tree, tree, vec<tree> *); 139static int build_primary_vtable (tree, tree); 140static int build_secondary_vtable (tree); 141static void finish_vtbls (tree); 142static void modify_vtable_entry (tree, tree, tree, tree, tree *); 143static void finish_struct_bits (tree); 144static int alter_access (tree, tree, tree); 145static void handle_using_decl (tree, tree); 146static tree dfs_modify_vtables (tree, void *); 147static tree modify_all_vtables (tree, tree); 148static void determine_primary_bases (tree); 149static void finish_struct_methods (tree); 150static void maybe_warn_about_overly_private_class (tree); 151static int method_name_cmp (const void *, const void *); 152static int resort_method_name_cmp (const void *, const void *); 153static void add_implicitly_declared_members (tree, tree*, int, int); 154static tree fixed_type_or_null (tree, int *, int *); 155static tree build_simple_base_path (tree expr, tree binfo); 156static tree build_vtbl_ref_1 (tree, tree); 157static void build_vtbl_initializer (tree, tree, tree, tree, int *, 158 vec<constructor_elt, va_gc> **); 159static int count_fields (tree); 160static int add_fields_to_record_type (tree, struct sorted_fields_type*, int); 161static void insert_into_classtype_sorted_fields (tree, tree, int); 162static bool check_bitfield_decl (tree); 163static void check_field_decl (tree, tree, int *, int *, int *); 164static void check_field_decls (tree, tree *, int *, int *); 165static tree *build_base_field (record_layout_info, tree, splay_tree, tree *); 166static void build_base_fields (record_layout_info, splay_tree, tree *); 167static void check_methods (tree); 168static void remove_zero_width_bit_fields (tree); 169static bool accessible_nvdtor_p (tree); 170static void check_bases (tree, int *, int *); 171static void check_bases_and_members (tree); 172static tree create_vtable_ptr (tree, tree *); 173static void include_empty_classes (record_layout_info); 174static void layout_class_type (tree, tree *); 175static void propagate_binfo_offsets (tree, tree); 176static void layout_virtual_bases (record_layout_info, splay_tree); 177static void build_vbase_offset_vtbl_entries (tree, vtbl_init_data *); 178static void add_vcall_offset_vtbl_entries_r (tree, vtbl_init_data *); 179static void add_vcall_offset_vtbl_entries_1 (tree, vtbl_init_data *); 180static void build_vcall_offset_vtbl_entries (tree, vtbl_init_data *); 181static void add_vcall_offset (tree, tree, vtbl_init_data *); 182static void layout_vtable_decl (tree, int); 183static tree dfs_find_final_overrider_pre (tree, void *); 184static tree dfs_find_final_overrider_post (tree, void *); 185static tree find_final_overrider (tree, tree, tree); 186static int make_new_vtable (tree, tree); 187static tree get_primary_binfo (tree); 188static int maybe_indent_hierarchy (FILE *, int, int); 189static tree dump_class_hierarchy_r (FILE *, int, tree, tree, int); 190static void dump_class_hierarchy (tree); 191static void dump_class_hierarchy_1 (FILE *, int, tree); 192static void dump_array (FILE *, tree); 193static void dump_vtable (tree, tree, tree); 194static void dump_vtt (tree, tree); 195static void dump_thunk (FILE *, int, tree); 196static tree build_vtable (tree, tree, tree); 197static void initialize_vtable (tree, vec<constructor_elt, va_gc> *); 198static void layout_nonempty_base_or_field (record_layout_info, 199 tree, tree, splay_tree); 200static tree end_of_class (tree, int); 201static bool layout_empty_base (record_layout_info, tree, tree, splay_tree); 202static void accumulate_vtbl_inits (tree, tree, tree, tree, tree, 203 vec<constructor_elt, va_gc> **); 204static void dfs_accumulate_vtbl_inits (tree, tree, tree, tree, tree, 205 vec<constructor_elt, va_gc> **); 206static void build_rtti_vtbl_entries (tree, vtbl_init_data *); 207static void build_vcall_and_vbase_vtbl_entries (tree, vtbl_init_data *); 208static void clone_constructors_and_destructors (tree); 209static tree build_clone (tree, tree); 210static void update_vtable_entry_for_fn (tree, tree, tree, tree *, unsigned); 211static void build_ctor_vtbl_group (tree, tree); 212static void build_vtt (tree); 213static tree binfo_ctor_vtable (tree); 214static void build_vtt_inits (tree, tree, vec<constructor_elt, va_gc> **, 215 tree *); 216static tree dfs_build_secondary_vptr_vtt_inits (tree, void *); 217static tree dfs_fixup_binfo_vtbls (tree, void *); 218static int record_subobject_offset (tree, tree, splay_tree); 219static int check_subobject_offset (tree, tree, splay_tree); 220static int walk_subobject_offsets (tree, subobject_offset_fn, 221 tree, splay_tree, tree, int); 222static void record_subobject_offsets (tree, tree, splay_tree, bool); 223static int layout_conflict_p (tree, tree, splay_tree, int); 224static int splay_tree_compare_integer_csts (splay_tree_key k1, 225 splay_tree_key k2); 226static void warn_about_ambiguous_bases (tree); 227static bool type_requires_array_cookie (tree); 228static bool base_derived_from (tree, tree); 229static int empty_base_at_nonzero_offset_p (tree, tree, splay_tree); 230static tree end_of_base (tree); 231static tree get_vcall_index (tree, tree); 232 233/* Variables shared between class.c and call.c. */ 234 235int n_vtables = 0; 236int n_vtable_entries = 0; 237int n_vtable_searches = 0; 238int n_vtable_elems = 0; 239int n_convert_harshness = 0; 240int n_compute_conversion_costs = 0; 241int n_inner_fields_searched = 0; 242 243/* Convert to or from a base subobject. EXPR is an expression of type 244 `A' or `A*', an expression of type `B' or `B*' is returned. To 245 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for 246 the B base instance within A. To convert base A to derived B, CODE 247 is MINUS_EXPR and BINFO is the binfo for the A instance within B. 248 In this latter case, A must not be a morally virtual base of B. 249 NONNULL is true if EXPR is known to be non-NULL (this is only 250 needed when EXPR is of pointer type). CV qualifiers are preserved 251 from EXPR. */ 252 253tree 254build_base_path (enum tree_code code, 255 tree expr, 256 tree binfo, 257 int nonnull, 258 tsubst_flags_t complain) 259{ 260 tree v_binfo = NULL_TREE; 261 tree d_binfo = NULL_TREE; 262 tree probe; 263 tree offset; 264 tree target_type; 265 tree null_test = NULL; 266 tree ptr_target_type; 267 int fixed_type_p; 268 int want_pointer = TYPE_PTR_P (TREE_TYPE (expr)); 269 bool has_empty = false; 270 bool virtual_access; 271 bool rvalue = false; 272 273 if (expr == error_mark_node || binfo == error_mark_node || !binfo) 274 return error_mark_node; 275 276 for (probe = binfo; probe; probe = BINFO_INHERITANCE_CHAIN (probe)) 277 { 278 d_binfo = probe; 279 if (is_empty_class (BINFO_TYPE (probe))) 280 has_empty = true; 281 if (!v_binfo && BINFO_VIRTUAL_P (probe)) 282 v_binfo = probe; 283 } 284 285 probe = TYPE_MAIN_VARIANT (TREE_TYPE (expr)); 286 if (want_pointer) 287 probe = TYPE_MAIN_VARIANT (TREE_TYPE (probe)); 288 289 if (code == PLUS_EXPR 290 && !SAME_BINFO_TYPE_P (BINFO_TYPE (d_binfo), probe)) 291 { 292 /* This can happen when adjust_result_of_qualified_name_lookup can't 293 find a unique base binfo in a call to a member function. We 294 couldn't give the diagnostic then since we might have been calling 295 a static member function, so we do it now. */ 296 if (complain & tf_error) 297 { 298 tree base = lookup_base (probe, BINFO_TYPE (d_binfo), 299 ba_unique, NULL, complain); 300 gcc_assert (base == error_mark_node); 301 } 302 return error_mark_node; 303 } 304 305 gcc_assert ((code == MINUS_EXPR 306 && SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), probe)) 307 || code == PLUS_EXPR); 308 309 if (binfo == d_binfo) 310 /* Nothing to do. */ 311 return expr; 312 313 if (code == MINUS_EXPR && v_binfo) 314 { 315 if (complain & tf_error) 316 { 317 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (v_binfo))) 318 { 319 if (want_pointer) 320 error ("cannot convert from pointer to base class %qT to " 321 "pointer to derived class %qT because the base is " 322 "virtual", BINFO_TYPE (binfo), BINFO_TYPE (d_binfo)); 323 else 324 error ("cannot convert from base class %qT to derived " 325 "class %qT because the base is virtual", 326 BINFO_TYPE (binfo), BINFO_TYPE (d_binfo)); 327 } 328 else 329 { 330 if (want_pointer) 331 error ("cannot convert from pointer to base class %qT to " 332 "pointer to derived class %qT via virtual base %qT", 333 BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), 334 BINFO_TYPE (v_binfo)); 335 else 336 error ("cannot convert from base class %qT to derived " 337 "class %qT via virtual base %qT", BINFO_TYPE (binfo), 338 BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo)); 339 } 340 } 341 return error_mark_node; 342 } 343 344 if (!want_pointer) 345 { 346 rvalue = !real_lvalue_p (expr); 347 /* This must happen before the call to save_expr. */ 348 expr = cp_build_addr_expr (expr, complain); 349 } 350 else 351 expr = mark_rvalue_use (expr); 352 353 offset = BINFO_OFFSET (binfo); 354 fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull); 355 target_type = code == PLUS_EXPR ? BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo); 356 /* TARGET_TYPE has been extracted from BINFO, and, is therefore always 357 cv-unqualified. Extract the cv-qualifiers from EXPR so that the 358 expression returned matches the input. */ 359 target_type = cp_build_qualified_type 360 (target_type, cp_type_quals (TREE_TYPE (TREE_TYPE (expr)))); 361 ptr_target_type = build_pointer_type (target_type); 362 363 /* Do we need to look in the vtable for the real offset? */ 364 virtual_access = (v_binfo && fixed_type_p <= 0); 365 366 /* Don't bother with the calculations inside sizeof; they'll ICE if the 367 source type is incomplete and the pointer value doesn't matter. In a 368 template (even in instantiate_non_dependent_expr), we don't have vtables 369 set up properly yet, and the value doesn't matter there either; we're 370 just interested in the result of overload resolution. */ 371 if (cp_unevaluated_operand != 0 372 || in_template_function ()) 373 { 374 expr = build_nop (ptr_target_type, expr); 375 goto indout; 376 } 377 378 /* If we're in an NSDMI, we don't have the full constructor context yet 379 that we need for converting to a virtual base, so just build a stub 380 CONVERT_EXPR and expand it later in bot_replace. */ 381 if (virtual_access && fixed_type_p < 0 382 && current_scope () != current_function_decl) 383 { 384 expr = build1 (CONVERT_EXPR, ptr_target_type, expr); 385 CONVERT_EXPR_VBASE_PATH (expr) = true; 386 goto indout; 387 } 388 389 /* Do we need to check for a null pointer? */ 390 if (want_pointer && !nonnull) 391 { 392 /* If we know the conversion will not actually change the value 393 of EXPR, then we can avoid testing the expression for NULL. 394 We have to avoid generating a COMPONENT_REF for a base class 395 field, because other parts of the compiler know that such 396 expressions are always non-NULL. */ 397 if (!virtual_access && integer_zerop (offset)) 398 return build_nop (ptr_target_type, expr); 399 null_test = error_mark_node; 400 } 401 402 /* Protect against multiple evaluation if necessary. */ 403 if (TREE_SIDE_EFFECTS (expr) && (null_test || virtual_access)) 404 expr = save_expr (expr); 405 406 /* Now that we've saved expr, build the real null test. */ 407 if (null_test) 408 { 409 tree zero = cp_convert (TREE_TYPE (expr), nullptr_node, complain); 410 null_test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, 411 expr, zero); 412 } 413 414 /* If this is a simple base reference, express it as a COMPONENT_REF. */ 415 if (code == PLUS_EXPR && !virtual_access 416 /* We don't build base fields for empty bases, and they aren't very 417 interesting to the optimizers anyway. */ 418 && !has_empty) 419 { 420 expr = cp_build_indirect_ref (expr, RO_NULL, complain); 421 expr = build_simple_base_path (expr, binfo); 422 if (rvalue) 423 expr = move (expr); 424 if (want_pointer) 425 expr = build_address (expr); 426 target_type = TREE_TYPE (expr); 427 goto out; 428 } 429 430 if (virtual_access) 431 { 432 /* Going via virtual base V_BINFO. We need the static offset 433 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to 434 V_BINFO. That offset is an entry in D_BINFO's vtable. */ 435 tree v_offset; 436 437 if (fixed_type_p < 0 && in_base_initializer) 438 { 439 /* In a base member initializer, we cannot rely on the 440 vtable being set up. We have to indirect via the 441 vtt_parm. */ 442 tree t; 443 444 t = TREE_TYPE (TYPE_VFIELD (current_class_type)); 445 t = build_pointer_type (t); 446 v_offset = convert (t, current_vtt_parm); 447 v_offset = cp_build_indirect_ref (v_offset, RO_NULL, complain); 448 } 449 else 450 { 451 tree t = expr; 452 if ((flag_sanitize & SANITIZE_VPTR) && fixed_type_p == 0) 453 { 454 t = cp_ubsan_maybe_instrument_cast_to_vbase (input_location, 455 probe, expr); 456 if (t == NULL_TREE) 457 t = expr; 458 } 459 v_offset = build_vfield_ref (cp_build_indirect_ref (t, RO_NULL, 460 complain), 461 TREE_TYPE (TREE_TYPE (expr))); 462 } 463 464 if (v_offset == error_mark_node) 465 return error_mark_node; 466 467 v_offset = fold_build_pointer_plus (v_offset, BINFO_VPTR_FIELD (v_binfo)); 468 v_offset = build1 (NOP_EXPR, 469 build_pointer_type (ptrdiff_type_node), 470 v_offset); 471 v_offset = cp_build_indirect_ref (v_offset, RO_NULL, complain); 472 TREE_CONSTANT (v_offset) = 1; 473 474 offset = convert_to_integer (ptrdiff_type_node, 475 size_diffop_loc (input_location, offset, 476 BINFO_OFFSET (v_binfo))); 477 478 if (!integer_zerop (offset)) 479 v_offset = build2 (code, ptrdiff_type_node, v_offset, offset); 480 481 if (fixed_type_p < 0) 482 /* Negative fixed_type_p means this is a constructor or destructor; 483 virtual base layout is fixed in in-charge [cd]tors, but not in 484 base [cd]tors. */ 485 offset = build3 (COND_EXPR, ptrdiff_type_node, 486 build2 (EQ_EXPR, boolean_type_node, 487 current_in_charge_parm, integer_zero_node), 488 v_offset, 489 convert_to_integer (ptrdiff_type_node, 490 BINFO_OFFSET (binfo))); 491 else 492 offset = v_offset; 493 } 494 495 if (want_pointer) 496 target_type = ptr_target_type; 497 498 expr = build1 (NOP_EXPR, ptr_target_type, expr); 499 500 if (!integer_zerop (offset)) 501 { 502 offset = fold_convert (sizetype, offset); 503 if (code == MINUS_EXPR) 504 offset = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, offset); 505 expr = fold_build_pointer_plus (expr, offset); 506 } 507 else 508 null_test = NULL; 509 510 indout: 511 if (!want_pointer) 512 { 513 expr = cp_build_indirect_ref (expr, RO_NULL, complain); 514 if (rvalue) 515 expr = move (expr); 516 } 517 518 out: 519 if (null_test) 520 expr = fold_build3_loc (input_location, COND_EXPR, target_type, null_test, expr, 521 build_zero_cst (target_type)); 522 523 return expr; 524} 525 526/* Subroutine of build_base_path; EXPR and BINFO are as in that function. 527 Perform a derived-to-base conversion by recursively building up a 528 sequence of COMPONENT_REFs to the appropriate base fields. */ 529 530static tree 531build_simple_base_path (tree expr, tree binfo) 532{ 533 tree type = BINFO_TYPE (binfo); 534 tree d_binfo = BINFO_INHERITANCE_CHAIN (binfo); 535 tree field; 536 537 if (d_binfo == NULL_TREE) 538 { 539 tree temp; 540 541 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type); 542 543 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' 544 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only 545 an lvalue in the front end; only _DECLs and _REFs are lvalues 546 in the back end. */ 547 temp = unary_complex_lvalue (ADDR_EXPR, expr); 548 if (temp) 549 expr = cp_build_indirect_ref (temp, RO_NULL, tf_warning_or_error); 550 551 return expr; 552 } 553 554 /* Recurse. */ 555 expr = build_simple_base_path (expr, d_binfo); 556 557 for (field = TYPE_FIELDS (BINFO_TYPE (d_binfo)); 558 field; field = DECL_CHAIN (field)) 559 /* Is this the base field created by build_base_field? */ 560 if (TREE_CODE (field) == FIELD_DECL 561 && DECL_FIELD_IS_BASE (field) 562 && TREE_TYPE (field) == type 563 /* If we're looking for a field in the most-derived class, 564 also check the field offset; we can have two base fields 565 of the same type if one is an indirect virtual base and one 566 is a direct non-virtual base. */ 567 && (BINFO_INHERITANCE_CHAIN (d_binfo) 568 || tree_int_cst_equal (byte_position (field), 569 BINFO_OFFSET (binfo)))) 570 { 571 /* We don't use build_class_member_access_expr here, as that 572 has unnecessary checks, and more importantly results in 573 recursive calls to dfs_walk_once. */ 574 int type_quals = cp_type_quals (TREE_TYPE (expr)); 575 576 expr = build3 (COMPONENT_REF, 577 cp_build_qualified_type (type, type_quals), 578 expr, field, NULL_TREE); 579 expr = fold_if_not_in_template (expr); 580 581 /* Mark the expression const or volatile, as appropriate. 582 Even though we've dealt with the type above, we still have 583 to mark the expression itself. */ 584 if (type_quals & TYPE_QUAL_CONST) 585 TREE_READONLY (expr) = 1; 586 if (type_quals & TYPE_QUAL_VOLATILE) 587 TREE_THIS_VOLATILE (expr) = 1; 588 589 return expr; 590 } 591 592 /* Didn't find the base field?!? */ 593 gcc_unreachable (); 594} 595 596/* Convert OBJECT to the base TYPE. OBJECT is an expression whose 597 type is a class type or a pointer to a class type. In the former 598 case, TYPE is also a class type; in the latter it is another 599 pointer type. If CHECK_ACCESS is true, an error message is emitted 600 if TYPE is inaccessible. If OBJECT has pointer type, the value is 601 assumed to be non-NULL. */ 602 603tree 604convert_to_base (tree object, tree type, bool check_access, bool nonnull, 605 tsubst_flags_t complain) 606{ 607 tree binfo; 608 tree object_type; 609 610 if (TYPE_PTR_P (TREE_TYPE (object))) 611 { 612 object_type = TREE_TYPE (TREE_TYPE (object)); 613 type = TREE_TYPE (type); 614 } 615 else 616 object_type = TREE_TYPE (object); 617 618 binfo = lookup_base (object_type, type, check_access ? ba_check : ba_unique, 619 NULL, complain); 620 if (!binfo || binfo == error_mark_node) 621 return error_mark_node; 622 623 return build_base_path (PLUS_EXPR, object, binfo, nonnull, complain); 624} 625 626/* EXPR is an expression with unqualified class type. BASE is a base 627 binfo of that class type. Returns EXPR, converted to the BASE 628 type. This function assumes that EXPR is the most derived class; 629 therefore virtual bases can be found at their static offsets. */ 630 631tree 632convert_to_base_statically (tree expr, tree base) 633{ 634 tree expr_type; 635 636 expr_type = TREE_TYPE (expr); 637 if (!SAME_BINFO_TYPE_P (BINFO_TYPE (base), expr_type)) 638 { 639 /* If this is a non-empty base, use a COMPONENT_REF. */ 640 if (!is_empty_class (BINFO_TYPE (base))) 641 return build_simple_base_path (expr, base); 642 643 /* We use fold_build2 and fold_convert below to simplify the trees 644 provided to the optimizers. It is not safe to call these functions 645 when processing a template because they do not handle C++-specific 646 trees. */ 647 gcc_assert (!processing_template_decl); 648 expr = cp_build_addr_expr (expr, tf_warning_or_error); 649 if (!integer_zerop (BINFO_OFFSET (base))) 650 expr = fold_build_pointer_plus_loc (input_location, 651 expr, BINFO_OFFSET (base)); 652 expr = fold_convert (build_pointer_type (BINFO_TYPE (base)), expr); 653 expr = build_fold_indirect_ref_loc (input_location, expr); 654 } 655 656 return expr; 657} 658 659 660tree 661build_vfield_ref (tree datum, tree type) 662{ 663 tree vfield, vcontext; 664 665 if (datum == error_mark_node 666 /* Can happen in case of duplicate base types (c++/59082). */ 667 || !TYPE_VFIELD (type)) 668 return error_mark_node; 669 670 /* First, convert to the requested type. */ 671 if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type)) 672 datum = convert_to_base (datum, type, /*check_access=*/false, 673 /*nonnull=*/true, tf_warning_or_error); 674 675 /* Second, the requested type may not be the owner of its own vptr. 676 If not, convert to the base class that owns it. We cannot use 677 convert_to_base here, because VCONTEXT may appear more than once 678 in the inheritance hierarchy of TYPE, and thus direct conversion 679 between the types may be ambiguous. Following the path back up 680 one step at a time via primary bases avoids the problem. */ 681 vfield = TYPE_VFIELD (type); 682 vcontext = DECL_CONTEXT (vfield); 683 while (!same_type_ignoring_top_level_qualifiers_p (vcontext, type)) 684 { 685 datum = build_simple_base_path (datum, CLASSTYPE_PRIMARY_BINFO (type)); 686 type = TREE_TYPE (datum); 687 } 688 689 return build3 (COMPONENT_REF, TREE_TYPE (vfield), datum, vfield, NULL_TREE); 690} 691 692/* Given an object INSTANCE, return an expression which yields the 693 vtable element corresponding to INDEX. There are many special 694 cases for INSTANCE which we take care of here, mainly to avoid 695 creating extra tree nodes when we don't have to. */ 696 697static tree 698build_vtbl_ref_1 (tree instance, tree idx) 699{ 700 tree aref; 701 tree vtbl = NULL_TREE; 702 703 /* Try to figure out what a reference refers to, and 704 access its virtual function table directly. */ 705 706 int cdtorp = 0; 707 tree fixed_type = fixed_type_or_null (instance, NULL, &cdtorp); 708 709 tree basetype = non_reference (TREE_TYPE (instance)); 710 711 if (fixed_type && !cdtorp) 712 { 713 tree binfo = lookup_base (fixed_type, basetype, 714 ba_unique, NULL, tf_none); 715 if (binfo && binfo != error_mark_node) 716 vtbl = unshare_expr (BINFO_VTABLE (binfo)); 717 } 718 719 if (!vtbl) 720 vtbl = build_vfield_ref (instance, basetype); 721 722 aref = build_array_ref (input_location, vtbl, idx); 723 TREE_CONSTANT (aref) |= TREE_CONSTANT (vtbl) && TREE_CONSTANT (idx); 724 725 return aref; 726} 727 728tree 729build_vtbl_ref (tree instance, tree idx) 730{ 731 tree aref = build_vtbl_ref_1 (instance, idx); 732 733 return aref; 734} 735 736/* Given a stable object pointer INSTANCE_PTR, return an expression which 737 yields a function pointer corresponding to vtable element INDEX. */ 738 739tree 740build_vfn_ref (tree instance_ptr, tree idx) 741{ 742 tree aref; 743 744 aref = build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr, RO_NULL, 745 tf_warning_or_error), 746 idx); 747 748 /* When using function descriptors, the address of the 749 vtable entry is treated as a function pointer. */ 750 if (TARGET_VTABLE_USES_DESCRIPTORS) 751 aref = build1 (NOP_EXPR, TREE_TYPE (aref), 752 cp_build_addr_expr (aref, tf_warning_or_error)); 753 754 /* Remember this as a method reference, for later devirtualization. */ 755 aref = build3 (OBJ_TYPE_REF, TREE_TYPE (aref), aref, instance_ptr, idx); 756 757 return aref; 758} 759 760/* Return the name of the virtual function table (as an IDENTIFIER_NODE) 761 for the given TYPE. */ 762 763static tree 764get_vtable_name (tree type) 765{ 766 return mangle_vtbl_for_type (type); 767} 768 769/* DECL is an entity associated with TYPE, like a virtual table or an 770 implicitly generated constructor. Determine whether or not DECL 771 should have external or internal linkage at the object file 772 level. This routine does not deal with COMDAT linkage and other 773 similar complexities; it simply sets TREE_PUBLIC if it possible for 774 entities in other translation units to contain copies of DECL, in 775 the abstract. */ 776 777void 778set_linkage_according_to_type (tree /*type*/, tree decl) 779{ 780 TREE_PUBLIC (decl) = 1; 781 determine_visibility (decl); 782} 783 784/* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE. 785 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.) 786 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */ 787 788static tree 789build_vtable (tree class_type, tree name, tree vtable_type) 790{ 791 tree decl; 792 793 decl = build_lang_decl (VAR_DECL, name, vtable_type); 794 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME 795 now to avoid confusion in mangle_decl. */ 796 SET_DECL_ASSEMBLER_NAME (decl, name); 797 DECL_CONTEXT (decl) = class_type; 798 DECL_ARTIFICIAL (decl) = 1; 799 TREE_STATIC (decl) = 1; 800 TREE_READONLY (decl) = 1; 801 DECL_VIRTUAL_P (decl) = 1; 802 DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN; 803 DECL_USER_ALIGN (decl) = true; 804 DECL_VTABLE_OR_VTT_P (decl) = 1; 805 set_linkage_according_to_type (class_type, decl); 806 /* The vtable has not been defined -- yet. */ 807 DECL_EXTERNAL (decl) = 1; 808 DECL_NOT_REALLY_EXTERN (decl) = 1; 809 810 /* Mark the VAR_DECL node representing the vtable itself as a 811 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It 812 is rather important that such things be ignored because any 813 effort to actually generate DWARF for them will run into 814 trouble when/if we encounter code like: 815 816 #pragma interface 817 struct S { virtual void member (); }; 818 819 because the artificial declaration of the vtable itself (as 820 manufactured by the g++ front end) will say that the vtable is 821 a static member of `S' but only *after* the debug output for 822 the definition of `S' has already been output. This causes 823 grief because the DWARF entry for the definition of the vtable 824 will try to refer back to an earlier *declaration* of the 825 vtable as a static member of `S' and there won't be one. We 826 might be able to arrange to have the "vtable static member" 827 attached to the member list for `S' before the debug info for 828 `S' get written (which would solve the problem) but that would 829 require more intrusive changes to the g++ front end. */ 830 DECL_IGNORED_P (decl) = 1; 831 832 return decl; 833} 834 835/* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic, 836 or even complete. If this does not exist, create it. If COMPLETE is 837 nonzero, then complete the definition of it -- that will render it 838 impossible to actually build the vtable, but is useful to get at those 839 which are known to exist in the runtime. */ 840 841tree 842get_vtable_decl (tree type, int complete) 843{ 844 tree decl; 845 846 if (CLASSTYPE_VTABLES (type)) 847 return CLASSTYPE_VTABLES (type); 848 849 decl = build_vtable (type, get_vtable_name (type), vtbl_type_node); 850 CLASSTYPE_VTABLES (type) = decl; 851 852 if (complete) 853 { 854 DECL_EXTERNAL (decl) = 1; 855 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0); 856 } 857 858 return decl; 859} 860 861/* Build the primary virtual function table for TYPE. If BINFO is 862 non-NULL, build the vtable starting with the initial approximation 863 that it is the same as the one which is the head of the association 864 list. Returns a nonzero value if a new vtable is actually 865 created. */ 866 867static int 868build_primary_vtable (tree binfo, tree type) 869{ 870 tree decl; 871 tree virtuals; 872 873 decl = get_vtable_decl (type, /*complete=*/0); 874 875 if (binfo) 876 { 877 if (BINFO_NEW_VTABLE_MARKED (binfo)) 878 /* We have already created a vtable for this base, so there's 879 no need to do it again. */ 880 return 0; 881 882 virtuals = copy_list (BINFO_VIRTUALS (binfo)); 883 TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo)); 884 DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl)); 885 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl)); 886 } 887 else 888 { 889 gcc_assert (TREE_TYPE (decl) == vtbl_type_node); 890 virtuals = NULL_TREE; 891 } 892 893 if (GATHER_STATISTICS) 894 { 895 n_vtables += 1; 896 n_vtable_elems += list_length (virtuals); 897 } 898 899 /* Initialize the association list for this type, based 900 on our first approximation. */ 901 BINFO_VTABLE (TYPE_BINFO (type)) = decl; 902 BINFO_VIRTUALS (TYPE_BINFO (type)) = virtuals; 903 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type)); 904 return 1; 905} 906 907/* Give BINFO a new virtual function table which is initialized 908 with a skeleton-copy of its original initialization. The only 909 entry that changes is the `delta' entry, so we can really 910 share a lot of structure. 911 912 FOR_TYPE is the most derived type which caused this table to 913 be needed. 914 915 Returns nonzero if we haven't met BINFO before. 916 917 The order in which vtables are built (by calling this function) for 918 an object must remain the same, otherwise a binary incompatibility 919 can result. */ 920 921static int 922build_secondary_vtable (tree binfo) 923{ 924 if (BINFO_NEW_VTABLE_MARKED (binfo)) 925 /* We already created a vtable for this base. There's no need to 926 do it again. */ 927 return 0; 928 929 /* Remember that we've created a vtable for this BINFO, so that we 930 don't try to do so again. */ 931 SET_BINFO_NEW_VTABLE_MARKED (binfo); 932 933 /* Make fresh virtual list, so we can smash it later. */ 934 BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo)); 935 936 /* Secondary vtables are laid out as part of the same structure as 937 the primary vtable. */ 938 BINFO_VTABLE (binfo) = NULL_TREE; 939 return 1; 940} 941 942/* Create a new vtable for BINFO which is the hierarchy dominated by 943 T. Return nonzero if we actually created a new vtable. */ 944 945static int 946make_new_vtable (tree t, tree binfo) 947{ 948 if (binfo == TYPE_BINFO (t)) 949 /* In this case, it is *type*'s vtable we are modifying. We start 950 with the approximation that its vtable is that of the 951 immediate base class. */ 952 return build_primary_vtable (binfo, t); 953 else 954 /* This is our very own copy of `basetype' to play with. Later, 955 we will fill in all the virtual functions that override the 956 virtual functions in these base classes which are not defined 957 by the current type. */ 958 return build_secondary_vtable (binfo); 959} 960 961/* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO 962 (which is in the hierarchy dominated by T) list FNDECL as its 963 BV_FN. DELTA is the required constant adjustment from the `this' 964 pointer where the vtable entry appears to the `this' required when 965 the function is actually called. */ 966 967static void 968modify_vtable_entry (tree t, 969 tree binfo, 970 tree fndecl, 971 tree delta, 972 tree *virtuals) 973{ 974 tree v; 975 976 v = *virtuals; 977 978 if (fndecl != BV_FN (v) 979 || !tree_int_cst_equal (delta, BV_DELTA (v))) 980 { 981 /* We need a new vtable for BINFO. */ 982 if (make_new_vtable (t, binfo)) 983 { 984 /* If we really did make a new vtable, we also made a copy 985 of the BINFO_VIRTUALS list. Now, we have to find the 986 corresponding entry in that list. */ 987 *virtuals = BINFO_VIRTUALS (binfo); 988 while (BV_FN (*virtuals) != BV_FN (v)) 989 *virtuals = TREE_CHAIN (*virtuals); 990 v = *virtuals; 991 } 992 993 BV_DELTA (v) = delta; 994 BV_VCALL_INDEX (v) = NULL_TREE; 995 BV_FN (v) = fndecl; 996 } 997} 998 999 1000/* Add method METHOD to class TYPE. If USING_DECL is non-null, it is 1001 the USING_DECL naming METHOD. Returns true if the method could be 1002 added to the method vec. */ 1003 1004bool 1005add_method (tree type, tree method, tree using_decl) 1006{ 1007 unsigned slot; 1008 tree overload; 1009 bool template_conv_p = false; 1010 bool conv_p; 1011 vec<tree, va_gc> *method_vec; 1012 bool complete_p; 1013 bool insert_p = false; 1014 tree current_fns; 1015 tree fns; 1016 1017 if (method == error_mark_node) 1018 return false; 1019 1020 complete_p = COMPLETE_TYPE_P (type); 1021 conv_p = DECL_CONV_FN_P (method); 1022 if (conv_p) 1023 template_conv_p = (TREE_CODE (method) == TEMPLATE_DECL 1024 && DECL_TEMPLATE_CONV_FN_P (method)); 1025 1026 method_vec = CLASSTYPE_METHOD_VEC (type); 1027 if (!method_vec) 1028 { 1029 /* Make a new method vector. We start with 8 entries. We must 1030 allocate at least two (for constructors and destructors), and 1031 we're going to end up with an assignment operator at some 1032 point as well. */ 1033 vec_alloc (method_vec, 8); 1034 /* Create slots for constructors and destructors. */ 1035 method_vec->quick_push (NULL_TREE); 1036 method_vec->quick_push (NULL_TREE); 1037 CLASSTYPE_METHOD_VEC (type) = method_vec; 1038 } 1039 1040 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */ 1041 grok_special_member_properties (method); 1042 1043 /* Constructors and destructors go in special slots. */ 1044 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (method)) 1045 slot = CLASSTYPE_CONSTRUCTOR_SLOT; 1046 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method)) 1047 { 1048 slot = CLASSTYPE_DESTRUCTOR_SLOT; 1049 1050 if (TYPE_FOR_JAVA (type)) 1051 { 1052 if (!DECL_ARTIFICIAL (method)) 1053 error ("Java class %qT cannot have a destructor", type); 1054 else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 1055 error ("Java class %qT cannot have an implicit non-trivial " 1056 "destructor", 1057 type); 1058 } 1059 } 1060 else 1061 { 1062 tree m; 1063 1064 insert_p = true; 1065 /* See if we already have an entry with this name. */ 1066 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; 1067 vec_safe_iterate (method_vec, slot, &m); 1068 ++slot) 1069 { 1070 m = OVL_CURRENT (m); 1071 if (template_conv_p) 1072 { 1073 if (TREE_CODE (m) == TEMPLATE_DECL 1074 && DECL_TEMPLATE_CONV_FN_P (m)) 1075 insert_p = false; 1076 break; 1077 } 1078 if (conv_p && !DECL_CONV_FN_P (m)) 1079 break; 1080 if (DECL_NAME (m) == DECL_NAME (method)) 1081 { 1082 insert_p = false; 1083 break; 1084 } 1085 if (complete_p 1086 && !DECL_CONV_FN_P (m) 1087 && DECL_NAME (m) > DECL_NAME (method)) 1088 break; 1089 } 1090 } 1091 current_fns = insert_p ? NULL_TREE : (*method_vec)[slot]; 1092 1093 /* Check to see if we've already got this method. */ 1094 for (fns = current_fns; fns; fns = OVL_NEXT (fns)) 1095 { 1096 tree fn = OVL_CURRENT (fns); 1097 tree fn_type; 1098 tree method_type; 1099 tree parms1; 1100 tree parms2; 1101 1102 if (TREE_CODE (fn) != TREE_CODE (method)) 1103 continue; 1104 1105 /* [over.load] Member function declarations with the 1106 same name and the same parameter types cannot be 1107 overloaded if any of them is a static member 1108 function declaration. 1109 1110 [over.load] Member function declarations with the same name and 1111 the same parameter-type-list as well as member function template 1112 declarations with the same name, the same parameter-type-list, and 1113 the same template parameter lists cannot be overloaded if any of 1114 them, but not all, have a ref-qualifier. 1115 1116 [namespace.udecl] When a using-declaration brings names 1117 from a base class into a derived class scope, member 1118 functions in the derived class override and/or hide member 1119 functions with the same name and parameter types in a base 1120 class (rather than conflicting). */ 1121 fn_type = TREE_TYPE (fn); 1122 method_type = TREE_TYPE (method); 1123 parms1 = TYPE_ARG_TYPES (fn_type); 1124 parms2 = TYPE_ARG_TYPES (method_type); 1125 1126 /* Compare the quals on the 'this' parm. Don't compare 1127 the whole types, as used functions are treated as 1128 coming from the using class in overload resolution. */ 1129 if (! DECL_STATIC_FUNCTION_P (fn) 1130 && ! DECL_STATIC_FUNCTION_P (method) 1131 /* Either both or neither need to be ref-qualified for 1132 differing quals to allow overloading. */ 1133 && (FUNCTION_REF_QUALIFIED (fn_type) 1134 == FUNCTION_REF_QUALIFIED (method_type)) 1135 && (type_memfn_quals (fn_type) != type_memfn_quals (method_type) 1136 || type_memfn_rqual (fn_type) != type_memfn_rqual (method_type))) 1137 continue; 1138 1139 /* For templates, the return type and template parameters 1140 must be identical. */ 1141 if (TREE_CODE (fn) == TEMPLATE_DECL 1142 && (!same_type_p (TREE_TYPE (fn_type), 1143 TREE_TYPE (method_type)) 1144 || !comp_template_parms (DECL_TEMPLATE_PARMS (fn), 1145 DECL_TEMPLATE_PARMS (method)))) 1146 continue; 1147 1148 if (! DECL_STATIC_FUNCTION_P (fn)) 1149 parms1 = TREE_CHAIN (parms1); 1150 if (! DECL_STATIC_FUNCTION_P (method)) 1151 parms2 = TREE_CHAIN (parms2); 1152 1153 if (compparms (parms1, parms2) 1154 && (!DECL_CONV_FN_P (fn) 1155 || same_type_p (TREE_TYPE (fn_type), 1156 TREE_TYPE (method_type)))) 1157 { 1158 /* For function versions, their parms and types match 1159 but they are not duplicates. Record function versions 1160 as and when they are found. extern "C" functions are 1161 not treated as versions. */ 1162 if (TREE_CODE (fn) == FUNCTION_DECL 1163 && TREE_CODE (method) == FUNCTION_DECL 1164 && !DECL_EXTERN_C_P (fn) 1165 && !DECL_EXTERN_C_P (method) 1166 && targetm.target_option.function_versions (fn, method)) 1167 { 1168 /* Mark functions as versions if necessary. Modify the mangled 1169 decl name if necessary. */ 1170 if (!DECL_FUNCTION_VERSIONED (fn)) 1171 { 1172 DECL_FUNCTION_VERSIONED (fn) = 1; 1173 if (DECL_ASSEMBLER_NAME_SET_P (fn)) 1174 mangle_decl (fn); 1175 } 1176 if (!DECL_FUNCTION_VERSIONED (method)) 1177 { 1178 DECL_FUNCTION_VERSIONED (method) = 1; 1179 if (DECL_ASSEMBLER_NAME_SET_P (method)) 1180 mangle_decl (method); 1181 } 1182 cgraph_node::record_function_versions (fn, method); 1183 continue; 1184 } 1185 if (DECL_INHERITED_CTOR_BASE (method)) 1186 { 1187 if (DECL_INHERITED_CTOR_BASE (fn)) 1188 { 1189 error_at (DECL_SOURCE_LOCATION (method), 1190 "%q#D inherited from %qT", method, 1191 DECL_INHERITED_CTOR_BASE (method)); 1192 error_at (DECL_SOURCE_LOCATION (fn), 1193 "conflicts with version inherited from %qT", 1194 DECL_INHERITED_CTOR_BASE (fn)); 1195 } 1196 /* Otherwise defer to the other function. */ 1197 return false; 1198 } 1199 if (using_decl) 1200 { 1201 if (DECL_CONTEXT (fn) == type) 1202 /* Defer to the local function. */ 1203 return false; 1204 } 1205 else 1206 { 1207 error ("%q+#D cannot be overloaded", method); 1208 error ("with %q+#D", fn); 1209 } 1210 1211 /* We don't call duplicate_decls here to merge the 1212 declarations because that will confuse things if the 1213 methods have inline definitions. In particular, we 1214 will crash while processing the definitions. */ 1215 return false; 1216 } 1217 } 1218 1219 /* A class should never have more than one destructor. */ 1220 if (current_fns && DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (method)) 1221 return false; 1222 1223 /* Add the new binding. */ 1224 if (using_decl) 1225 { 1226 overload = ovl_cons (method, current_fns); 1227 OVL_USED (overload) = true; 1228 } 1229 else 1230 overload = build_overload (method, current_fns); 1231 1232 if (conv_p) 1233 TYPE_HAS_CONVERSION (type) = 1; 1234 else if (slot >= CLASSTYPE_FIRST_CONVERSION_SLOT && !complete_p) 1235 push_class_level_binding (DECL_NAME (method), overload); 1236 1237 if (insert_p) 1238 { 1239 bool reallocated; 1240 1241 /* We only expect to add few methods in the COMPLETE_P case, so 1242 just make room for one more method in that case. */ 1243 if (complete_p) 1244 reallocated = vec_safe_reserve_exact (method_vec, 1); 1245 else 1246 reallocated = vec_safe_reserve (method_vec, 1); 1247 if (reallocated) 1248 CLASSTYPE_METHOD_VEC (type) = method_vec; 1249 if (slot == method_vec->length ()) 1250 method_vec->quick_push (overload); 1251 else 1252 method_vec->quick_insert (slot, overload); 1253 } 1254 else 1255 /* Replace the current slot. */ 1256 (*method_vec)[slot] = overload; 1257 return true; 1258} 1259 1260/* Subroutines of finish_struct. */ 1261 1262/* Change the access of FDECL to ACCESS in T. Return 1 if change was 1263 legit, otherwise return 0. */ 1264 1265static int 1266alter_access (tree t, tree fdecl, tree access) 1267{ 1268 tree elem; 1269 1270 if (!DECL_LANG_SPECIFIC (fdecl)) 1271 retrofit_lang_decl (fdecl); 1272 1273 gcc_assert (!DECL_DISCRIMINATOR_P (fdecl)); 1274 1275 elem = purpose_member (t, DECL_ACCESS (fdecl)); 1276 if (elem) 1277 { 1278 if (TREE_VALUE (elem) != access) 1279 { 1280 if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL) 1281 error ("conflicting access specifications for method" 1282 " %q+D, ignored", TREE_TYPE (fdecl)); 1283 else 1284 error ("conflicting access specifications for field %qE, ignored", 1285 DECL_NAME (fdecl)); 1286 } 1287 else 1288 { 1289 /* They're changing the access to the same thing they changed 1290 it to before. That's OK. */ 1291 ; 1292 } 1293 } 1294 else 1295 { 1296 perform_or_defer_access_check (TYPE_BINFO (t), fdecl, fdecl, 1297 tf_warning_or_error); 1298 DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl)); 1299 return 1; 1300 } 1301 return 0; 1302} 1303 1304/* Process the USING_DECL, which is a member of T. */ 1305 1306static void 1307handle_using_decl (tree using_decl, tree t) 1308{ 1309 tree decl = USING_DECL_DECLS (using_decl); 1310 tree name = DECL_NAME (using_decl); 1311 tree access 1312 = TREE_PRIVATE (using_decl) ? access_private_node 1313 : TREE_PROTECTED (using_decl) ? access_protected_node 1314 : access_public_node; 1315 tree flist = NULL_TREE; 1316 tree old_value; 1317 1318 gcc_assert (!processing_template_decl && decl); 1319 1320 old_value = lookup_member (t, name, /*protect=*/0, /*want_type=*/false, 1321 tf_warning_or_error); 1322 if (old_value) 1323 { 1324 if (is_overloaded_fn (old_value)) 1325 old_value = OVL_CURRENT (old_value); 1326 1327 if (DECL_P (old_value) && DECL_CONTEXT (old_value) == t) 1328 /* OK */; 1329 else 1330 old_value = NULL_TREE; 1331 } 1332 1333 cp_emit_debug_info_for_using (decl, t); 1334 1335 if (is_overloaded_fn (decl)) 1336 flist = decl; 1337 1338 if (! old_value) 1339 ; 1340 else if (is_overloaded_fn (old_value)) 1341 { 1342 if (flist) 1343 /* It's OK to use functions from a base when there are functions with 1344 the same name already present in the current class. */; 1345 else 1346 { 1347 error ("%q+D invalid in %q#T", using_decl, t); 1348 error (" because of local method %q+#D with same name", 1349 OVL_CURRENT (old_value)); 1350 return; 1351 } 1352 } 1353 else if (!DECL_ARTIFICIAL (old_value)) 1354 { 1355 error ("%q+D invalid in %q#T", using_decl, t); 1356 error (" because of local member %q+#D with same name", old_value); 1357 return; 1358 } 1359 1360 /* Make type T see field decl FDECL with access ACCESS. */ 1361 if (flist) 1362 for (; flist; flist = OVL_NEXT (flist)) 1363 { 1364 add_method (t, OVL_CURRENT (flist), using_decl); 1365 alter_access (t, OVL_CURRENT (flist), access); 1366 } 1367 else 1368 alter_access (t, decl, access); 1369} 1370 1371/* Data structure for find_abi_tags_r, below. */ 1372 1373struct abi_tag_data 1374{ 1375 tree t; // The type that we're checking for missing tags. 1376 tree subob; // The subobject of T that we're getting tags from. 1377 tree tags; // error_mark_node for diagnostics, or a list of missing tags. 1378}; 1379 1380/* Subroutine of find_abi_tags_r. Handle a single TAG found on the class TP 1381 in the context of P. TAG can be either an identifier (the DECL_NAME of 1382 a tag NAMESPACE_DECL) or a STRING_CST (a tag attribute). */ 1383 1384static void 1385check_tag (tree tag, tree id, tree *tp, abi_tag_data *p) 1386{ 1387 if (!IDENTIFIER_MARKED (id)) 1388 { 1389 if (p->tags != error_mark_node) 1390 { 1391 /* We're collecting tags from template arguments or from 1392 the type of a variable or function return type. */ 1393 p->tags = tree_cons (NULL_TREE, tag, p->tags); 1394 1395 /* Don't inherit this tag multiple times. */ 1396 IDENTIFIER_MARKED (id) = true; 1397 1398 if (TYPE_P (p->t)) 1399 { 1400 /* Tags inherited from type template arguments are only used 1401 to avoid warnings. */ 1402 ABI_TAG_IMPLICIT (p->tags) = true; 1403 return; 1404 } 1405 /* For functions and variables we want to warn, too. */ 1406 } 1407 1408 /* Otherwise we're diagnosing missing tags. */ 1409 if (TREE_CODE (p->t) == FUNCTION_DECL) 1410 { 1411 if (warning (OPT_Wabi_tag, "%qD inherits the %E ABI tag " 1412 "that %qT (used in its return type) has", 1413 p->t, tag, *tp)) 1414 inform (location_of (*tp), "%qT declared here", *tp); 1415 } 1416 else if (TREE_CODE (p->t) == VAR_DECL) 1417 { 1418 if (warning (OPT_Wabi_tag, "%qD inherits the %E ABI tag " 1419 "that %qT (used in its type) has", p->t, tag, *tp)) 1420 inform (location_of (*tp), "%qT declared here", *tp); 1421 } 1422 else if (TYPE_P (p->subob)) 1423 { 1424 if (warning (OPT_Wabi_tag, "%qT does not have the %E ABI tag " 1425 "that base %qT has", p->t, tag, p->subob)) 1426 inform (location_of (p->subob), "%qT declared here", 1427 p->subob); 1428 } 1429 else 1430 { 1431 if (warning (OPT_Wabi_tag, "%qT does not have the %E ABI tag " 1432 "that %qT (used in the type of %qD) has", 1433 p->t, tag, *tp, p->subob)) 1434 { 1435 inform (location_of (p->subob), "%qD declared here", 1436 p->subob); 1437 inform (location_of (*tp), "%qT declared here", *tp); 1438 } 1439 } 1440 } 1441} 1442 1443/* Find all the ABI tags in the attribute list ATTR and either call 1444 check_tag (if TP is non-null) or set IDENTIFIER_MARKED to val. */ 1445 1446static void 1447mark_or_check_attr_tags (tree attr, tree *tp, abi_tag_data *p, bool val) 1448{ 1449 if (!attr) 1450 return; 1451 for (; (attr = lookup_attribute ("abi_tag", attr)); 1452 attr = TREE_CHAIN (attr)) 1453 for (tree list = TREE_VALUE (attr); list; 1454 list = TREE_CHAIN (list)) 1455 { 1456 tree tag = TREE_VALUE (list); 1457 tree id = get_identifier (TREE_STRING_POINTER (tag)); 1458 if (tp) 1459 check_tag (tag, id, tp, p); 1460 else 1461 IDENTIFIER_MARKED (id) = val; 1462 } 1463} 1464 1465/* Find all the ABI tags on T and its enclosing scopes and either call 1466 check_tag (if TP is non-null) or set IDENTIFIER_MARKED to val. */ 1467 1468static void 1469mark_or_check_tags (tree t, tree *tp, abi_tag_data *p, bool val) 1470{ 1471 while (t != global_namespace) 1472 { 1473 tree attr; 1474 if (TYPE_P (t)) 1475 { 1476 attr = TYPE_ATTRIBUTES (t); 1477 t = CP_TYPE_CONTEXT (t); 1478 } 1479 else 1480 { 1481 attr = DECL_ATTRIBUTES (t); 1482 t = CP_DECL_CONTEXT (t); 1483 } 1484 mark_or_check_attr_tags (attr, tp, p, val); 1485 } 1486} 1487 1488/* walk_tree callback for check_abi_tags: if the type at *TP involves any 1489 types with ABI tags, add the corresponding identifiers to the VEC in 1490 *DATA and set IDENTIFIER_MARKED. */ 1491 1492static tree 1493find_abi_tags_r (tree *tp, int *walk_subtrees, void *data) 1494{ 1495 if (!OVERLOAD_TYPE_P (*tp)) 1496 return NULL_TREE; 1497 1498 /* walk_tree shouldn't be walking into any subtrees of a RECORD_TYPE 1499 anyway, but let's make sure of it. */ 1500 *walk_subtrees = false; 1501 1502 abi_tag_data *p = static_cast<struct abi_tag_data*>(data); 1503 1504 mark_or_check_tags (*tp, tp, p, false); 1505 1506 return NULL_TREE; 1507} 1508 1509/* walk_tree callback for mark_abi_tags: if *TP is a class, set 1510 IDENTIFIER_MARKED on its ABI tags. */ 1511 1512static tree 1513mark_abi_tags_r (tree *tp, int *walk_subtrees, void *data) 1514{ 1515 if (!OVERLOAD_TYPE_P (*tp)) 1516 return NULL_TREE; 1517 1518 /* walk_tree shouldn't be walking into any subtrees of a RECORD_TYPE 1519 anyway, but let's make sure of it. */ 1520 *walk_subtrees = false; 1521 1522 bool *valp = static_cast<bool*>(data); 1523 1524 mark_or_check_tags (*tp, NULL, NULL, *valp); 1525 1526 return NULL_TREE; 1527} 1528 1529/* Set IDENTIFIER_MARKED on all the ABI tags on T and its enclosing 1530 scopes. */ 1531 1532static void 1533mark_abi_tags (tree t, bool val) 1534{ 1535 mark_or_check_tags (t, NULL, NULL, val); 1536 if (DECL_P (t)) 1537 { 1538 if (DECL_LANG_SPECIFIC (t) && DECL_USE_TEMPLATE (t) 1539 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))) 1540 { 1541 /* Template arguments are part of the signature. */ 1542 tree level = INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (t)); 1543 for (int j = 0; j < TREE_VEC_LENGTH (level); ++j) 1544 { 1545 tree arg = TREE_VEC_ELT (level, j); 1546 cp_walk_tree_without_duplicates (&arg, mark_abi_tags_r, &val); 1547 } 1548 } 1549 if (TREE_CODE (t) == FUNCTION_DECL) 1550 /* A function's parameter types are part of the signature, so 1551 we don't need to inherit any tags that are also in them. */ 1552 for (tree arg = FUNCTION_FIRST_USER_PARMTYPE (t); arg; 1553 arg = TREE_CHAIN (arg)) 1554 cp_walk_tree_without_duplicates (&TREE_VALUE (arg), 1555 mark_abi_tags_r, &val); 1556 } 1557} 1558 1559/* Check that T has all the ABI tags that subobject SUBOB has, or 1560 warn if not. If T is a (variable or function) declaration, also 1561 add any missing tags. */ 1562 1563static void 1564check_abi_tags (tree t, tree subob) 1565{ 1566 bool inherit = DECL_P (t); 1567 1568 if (!inherit && !warn_abi_tag) 1569 return; 1570 1571 tree decl = TYPE_P (t) ? TYPE_NAME (t) : t; 1572 if (!TREE_PUBLIC (decl)) 1573 /* No need to worry about things local to this TU. */ 1574 return; 1575 1576 mark_abi_tags (t, true); 1577 1578 tree subtype = TYPE_P (subob) ? subob : TREE_TYPE (subob); 1579 struct abi_tag_data data = { t, subob, error_mark_node }; 1580 if (inherit) 1581 data.tags = NULL_TREE; 1582 1583 cp_walk_tree_without_duplicates (&subtype, find_abi_tags_r, &data); 1584 1585 if (inherit && data.tags) 1586 { 1587 tree attr = lookup_attribute ("abi_tag", DECL_ATTRIBUTES (t)); 1588 if (attr) 1589 TREE_VALUE (attr) = chainon (data.tags, TREE_VALUE (attr)); 1590 else 1591 DECL_ATTRIBUTES (t) 1592 = tree_cons (get_identifier ("abi_tag"), data.tags, 1593 DECL_ATTRIBUTES (t)); 1594 } 1595 1596 mark_abi_tags (t, false); 1597} 1598 1599/* Check that DECL has all the ABI tags that are used in parts of its type 1600 that are not reflected in its mangled name. */ 1601 1602void 1603check_abi_tags (tree decl) 1604{ 1605 if (TREE_CODE (decl) == VAR_DECL) 1606 check_abi_tags (decl, TREE_TYPE (decl)); 1607 else if (TREE_CODE (decl) == FUNCTION_DECL 1608 && !mangle_return_type_p (decl)) 1609 check_abi_tags (decl, TREE_TYPE (TREE_TYPE (decl))); 1610} 1611 1612void 1613inherit_targ_abi_tags (tree t) 1614{ 1615 if (!CLASS_TYPE_P (t) 1616 || CLASSTYPE_TEMPLATE_INFO (t) == NULL_TREE) 1617 return; 1618 1619 mark_abi_tags (t, true); 1620 1621 tree args = CLASSTYPE_TI_ARGS (t); 1622 struct abi_tag_data data = { t, NULL_TREE, NULL_TREE }; 1623 for (int i = 0; i < TMPL_ARGS_DEPTH (args); ++i) 1624 { 1625 tree level = TMPL_ARGS_LEVEL (args, i+1); 1626 for (int j = 0; j < TREE_VEC_LENGTH (level); ++j) 1627 { 1628 tree arg = TREE_VEC_ELT (level, j); 1629 data.subob = arg; 1630 cp_walk_tree_without_duplicates (&arg, find_abi_tags_r, &data); 1631 } 1632 } 1633 1634 // If we found some tags on our template arguments, add them to our 1635 // abi_tag attribute. 1636 if (data.tags) 1637 { 1638 tree attr = lookup_attribute ("abi_tag", TYPE_ATTRIBUTES (t)); 1639 if (attr) 1640 TREE_VALUE (attr) = chainon (data.tags, TREE_VALUE (attr)); 1641 else 1642 TYPE_ATTRIBUTES (t) 1643 = tree_cons (get_identifier ("abi_tag"), data.tags, 1644 TYPE_ATTRIBUTES (t)); 1645 } 1646 1647 mark_abi_tags (t, false); 1648} 1649 1650/* Return true, iff class T has a non-virtual destructor that is 1651 accessible from outside the class heirarchy (i.e. is public, or 1652 there's a suitable friend. */ 1653 1654static bool 1655accessible_nvdtor_p (tree t) 1656{ 1657 tree dtor = CLASSTYPE_DESTRUCTORS (t); 1658 1659 /* An implicitly declared destructor is always public. And, 1660 if it were virtual, we would have created it by now. */ 1661 if (!dtor) 1662 return true; 1663 1664 if (DECL_VINDEX (dtor)) 1665 return false; /* Virtual */ 1666 1667 if (!TREE_PRIVATE (dtor) && !TREE_PROTECTED (dtor)) 1668 return true; /* Public */ 1669 1670 if (CLASSTYPE_FRIEND_CLASSES (t) 1671 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t))) 1672 return true; /* Has friends */ 1673 1674 return false; 1675} 1676 1677/* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P, 1678 and NO_CONST_ASN_REF_P. Also set flag bits in T based on 1679 properties of the bases. */ 1680 1681static void 1682check_bases (tree t, 1683 int* cant_have_const_ctor_p, 1684 int* no_const_asn_ref_p) 1685{ 1686 int i; 1687 bool seen_non_virtual_nearly_empty_base_p = 0; 1688 int seen_tm_mask = 0; 1689 tree base_binfo; 1690 tree binfo; 1691 tree field = NULL_TREE; 1692 1693 if (!CLASSTYPE_NON_STD_LAYOUT (t)) 1694 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 1695 if (TREE_CODE (field) == FIELD_DECL) 1696 break; 1697 1698 for (binfo = TYPE_BINFO (t), i = 0; 1699 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 1700 { 1701 tree basetype = TREE_TYPE (base_binfo); 1702 1703 gcc_assert (COMPLETE_TYPE_P (basetype)); 1704 1705 if (CLASSTYPE_FINAL (basetype)) 1706 error ("cannot derive from %<final%> base %qT in derived type %qT", 1707 basetype, t); 1708 1709 /* If any base class is non-literal, so is the derived class. */ 1710 if (!CLASSTYPE_LITERAL_P (basetype)) 1711 CLASSTYPE_LITERAL_P (t) = false; 1712 1713 /* If the base class doesn't have copy constructors or 1714 assignment operators that take const references, then the 1715 derived class cannot have such a member automatically 1716 generated. */ 1717 if (TYPE_HAS_COPY_CTOR (basetype) 1718 && ! TYPE_HAS_CONST_COPY_CTOR (basetype)) 1719 *cant_have_const_ctor_p = 1; 1720 if (TYPE_HAS_COPY_ASSIGN (basetype) 1721 && !TYPE_HAS_CONST_COPY_ASSIGN (basetype)) 1722 *no_const_asn_ref_p = 1; 1723 1724 if (BINFO_VIRTUAL_P (base_binfo)) 1725 /* A virtual base does not effect nearly emptiness. */ 1726 ; 1727 else if (CLASSTYPE_NEARLY_EMPTY_P (basetype)) 1728 { 1729 if (seen_non_virtual_nearly_empty_base_p) 1730 /* And if there is more than one nearly empty base, then the 1731 derived class is not nearly empty either. */ 1732 CLASSTYPE_NEARLY_EMPTY_P (t) = 0; 1733 else 1734 /* Remember we've seen one. */ 1735 seen_non_virtual_nearly_empty_base_p = 1; 1736 } 1737 else if (!is_empty_class (basetype)) 1738 /* If the base class is not empty or nearly empty, then this 1739 class cannot be nearly empty. */ 1740 CLASSTYPE_NEARLY_EMPTY_P (t) = 0; 1741 1742 /* A lot of properties from the bases also apply to the derived 1743 class. */ 1744 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype); 1745 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) 1746 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (basetype); 1747 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) 1748 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (basetype) 1749 || !TYPE_HAS_COPY_ASSIGN (basetype)); 1750 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= (TYPE_HAS_COMPLEX_COPY_CTOR (basetype) 1751 || !TYPE_HAS_COPY_CTOR (basetype)); 1752 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) 1753 |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (basetype); 1754 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_HAS_COMPLEX_MOVE_CTOR (basetype); 1755 TYPE_POLYMORPHIC_P (t) |= TYPE_POLYMORPHIC_P (basetype); 1756 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) 1757 |= CLASSTYPE_CONTAINS_EMPTY_CLASS_P (basetype); 1758 TYPE_HAS_COMPLEX_DFLT (t) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype) 1759 || TYPE_HAS_COMPLEX_DFLT (basetype)); 1760 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT 1761 (t, CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) 1762 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (basetype)); 1763 SET_CLASSTYPE_REF_FIELDS_NEED_INIT 1764 (t, CLASSTYPE_REF_FIELDS_NEED_INIT (t) 1765 | CLASSTYPE_REF_FIELDS_NEED_INIT (basetype)); 1766 1767 /* A standard-layout class is a class that: 1768 ... 1769 * has no non-standard-layout base classes, */ 1770 CLASSTYPE_NON_STD_LAYOUT (t) |= CLASSTYPE_NON_STD_LAYOUT (basetype); 1771 if (!CLASSTYPE_NON_STD_LAYOUT (t)) 1772 { 1773 tree basefield; 1774 /* ...has no base classes of the same type as the first non-static 1775 data member... */ 1776 if (field && DECL_CONTEXT (field) == t 1777 && (same_type_ignoring_top_level_qualifiers_p 1778 (TREE_TYPE (field), basetype))) 1779 CLASSTYPE_NON_STD_LAYOUT (t) = 1; 1780 else 1781 /* ...either has no non-static data members in the most-derived 1782 class and at most one base class with non-static data 1783 members, or has no base classes with non-static data 1784 members */ 1785 for (basefield = TYPE_FIELDS (basetype); basefield; 1786 basefield = DECL_CHAIN (basefield)) 1787 if (TREE_CODE (basefield) == FIELD_DECL) 1788 { 1789 if (field) 1790 CLASSTYPE_NON_STD_LAYOUT (t) = 1; 1791 else 1792 field = basefield; 1793 break; 1794 } 1795 } 1796 1797 /* Don't bother collecting tm attributes if transactional memory 1798 support is not enabled. */ 1799 if (flag_tm) 1800 { 1801 tree tm_attr = find_tm_attribute (TYPE_ATTRIBUTES (basetype)); 1802 if (tm_attr) 1803 seen_tm_mask |= tm_attr_to_mask (tm_attr); 1804 } 1805 1806 check_abi_tags (t, basetype); 1807 } 1808 1809 /* If one of the base classes had TM attributes, and the current class 1810 doesn't define its own, then the current class inherits one. */ 1811 if (seen_tm_mask && !find_tm_attribute (TYPE_ATTRIBUTES (t))) 1812 { 1813 tree tm_attr = tm_mask_to_attr (seen_tm_mask & -seen_tm_mask); 1814 TYPE_ATTRIBUTES (t) = tree_cons (tm_attr, NULL, TYPE_ATTRIBUTES (t)); 1815 } 1816} 1817 1818/* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for 1819 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those 1820 that have had a nearly-empty virtual primary base stolen by some 1821 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for 1822 T. */ 1823 1824static void 1825determine_primary_bases (tree t) 1826{ 1827 unsigned i; 1828 tree primary = NULL_TREE; 1829 tree type_binfo = TYPE_BINFO (t); 1830 tree base_binfo; 1831 1832 /* Determine the primary bases of our bases. */ 1833 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo; 1834 base_binfo = TREE_CHAIN (base_binfo)) 1835 { 1836 tree primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (base_binfo)); 1837 1838 /* See if we're the non-virtual primary of our inheritance 1839 chain. */ 1840 if (!BINFO_VIRTUAL_P (base_binfo)) 1841 { 1842 tree parent = BINFO_INHERITANCE_CHAIN (base_binfo); 1843 tree parent_primary = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (parent)); 1844 1845 if (parent_primary 1846 && SAME_BINFO_TYPE_P (BINFO_TYPE (base_binfo), 1847 BINFO_TYPE (parent_primary))) 1848 /* We are the primary binfo. */ 1849 BINFO_PRIMARY_P (base_binfo) = 1; 1850 } 1851 /* Determine if we have a virtual primary base, and mark it so. 1852 */ 1853 if (primary && BINFO_VIRTUAL_P (primary)) 1854 { 1855 tree this_primary = copied_binfo (primary, base_binfo); 1856 1857 if (BINFO_PRIMARY_P (this_primary)) 1858 /* Someone already claimed this base. */ 1859 BINFO_LOST_PRIMARY_P (base_binfo) = 1; 1860 else 1861 { 1862 tree delta; 1863 1864 BINFO_PRIMARY_P (this_primary) = 1; 1865 BINFO_INHERITANCE_CHAIN (this_primary) = base_binfo; 1866 1867 /* A virtual binfo might have been copied from within 1868 another hierarchy. As we're about to use it as a 1869 primary base, make sure the offsets match. */ 1870 delta = size_diffop_loc (input_location, 1871 convert (ssizetype, 1872 BINFO_OFFSET (base_binfo)), 1873 convert (ssizetype, 1874 BINFO_OFFSET (this_primary))); 1875 1876 propagate_binfo_offsets (this_primary, delta); 1877 } 1878 } 1879 } 1880 1881 /* First look for a dynamic direct non-virtual base. */ 1882 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, base_binfo); i++) 1883 { 1884 tree basetype = BINFO_TYPE (base_binfo); 1885 1886 if (TYPE_CONTAINS_VPTR_P (basetype) && !BINFO_VIRTUAL_P (base_binfo)) 1887 { 1888 primary = base_binfo; 1889 goto found; 1890 } 1891 } 1892 1893 /* A "nearly-empty" virtual base class can be the primary base 1894 class, if no non-virtual polymorphic base can be found. Look for 1895 a nearly-empty virtual dynamic base that is not already a primary 1896 base of something in the hierarchy. If there is no such base, 1897 just pick the first nearly-empty virtual base. */ 1898 1899 for (base_binfo = TREE_CHAIN (type_binfo); base_binfo; 1900 base_binfo = TREE_CHAIN (base_binfo)) 1901 if (BINFO_VIRTUAL_P (base_binfo) 1902 && CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (base_binfo))) 1903 { 1904 if (!BINFO_PRIMARY_P (base_binfo)) 1905 { 1906 /* Found one that is not primary. */ 1907 primary = base_binfo; 1908 goto found; 1909 } 1910 else if (!primary) 1911 /* Remember the first candidate. */ 1912 primary = base_binfo; 1913 } 1914 1915 found: 1916 /* If we've got a primary base, use it. */ 1917 if (primary) 1918 { 1919 tree basetype = BINFO_TYPE (primary); 1920 1921 CLASSTYPE_PRIMARY_BINFO (t) = primary; 1922 if (BINFO_PRIMARY_P (primary)) 1923 /* We are stealing a primary base. */ 1924 BINFO_LOST_PRIMARY_P (BINFO_INHERITANCE_CHAIN (primary)) = 1; 1925 BINFO_PRIMARY_P (primary) = 1; 1926 if (BINFO_VIRTUAL_P (primary)) 1927 { 1928 tree delta; 1929 1930 BINFO_INHERITANCE_CHAIN (primary) = type_binfo; 1931 /* A virtual binfo might have been copied from within 1932 another hierarchy. As we're about to use it as a primary 1933 base, make sure the offsets match. */ 1934 delta = size_diffop_loc (input_location, ssize_int (0), 1935 convert (ssizetype, BINFO_OFFSET (primary))); 1936 1937 propagate_binfo_offsets (primary, delta); 1938 } 1939 1940 primary = TYPE_BINFO (basetype); 1941 1942 TYPE_VFIELD (t) = TYPE_VFIELD (basetype); 1943 BINFO_VTABLE (type_binfo) = BINFO_VTABLE (primary); 1944 BINFO_VIRTUALS (type_binfo) = BINFO_VIRTUALS (primary); 1945 } 1946} 1947 1948/* Update the variant types of T. */ 1949 1950void 1951fixup_type_variants (tree t) 1952{ 1953 tree variants; 1954 1955 if (!t) 1956 return; 1957 1958 for (variants = TYPE_NEXT_VARIANT (t); 1959 variants; 1960 variants = TYPE_NEXT_VARIANT (variants)) 1961 { 1962 /* These fields are in the _TYPE part of the node, not in 1963 the TYPE_LANG_SPECIFIC component, so they are not shared. */ 1964 TYPE_HAS_USER_CONSTRUCTOR (variants) = TYPE_HAS_USER_CONSTRUCTOR (t); 1965 TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t); 1966 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (variants) 1967 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t); 1968 1969 TYPE_POLYMORPHIC_P (variants) = TYPE_POLYMORPHIC_P (t); 1970 1971 TYPE_BINFO (variants) = TYPE_BINFO (t); 1972 1973 /* Copy whatever these are holding today. */ 1974 TYPE_VFIELD (variants) = TYPE_VFIELD (t); 1975 TYPE_METHODS (variants) = TYPE_METHODS (t); 1976 TYPE_FIELDS (variants) = TYPE_FIELDS (t); 1977 } 1978} 1979 1980/* Early variant fixups: we apply attributes at the beginning of the class 1981 definition, and we need to fix up any variants that have already been 1982 made via elaborated-type-specifier so that check_qualified_type works. */ 1983 1984void 1985fixup_attribute_variants (tree t) 1986{ 1987 tree variants; 1988 1989 if (!t) 1990 return; 1991 1992 tree attrs = TYPE_ATTRIBUTES (t); 1993 unsigned align = TYPE_ALIGN (t); 1994 bool user_align = TYPE_USER_ALIGN (t); 1995 1996 for (variants = TYPE_NEXT_VARIANT (t); 1997 variants; 1998 variants = TYPE_NEXT_VARIANT (variants)) 1999 { 2000 /* These are the two fields that check_qualified_type looks at and 2001 are affected by attributes. */ 2002 TYPE_ATTRIBUTES (variants) = attrs; 2003 unsigned valign = align; 2004 if (TYPE_USER_ALIGN (variants)) 2005 valign = MAX (valign, TYPE_ALIGN (variants)); 2006 else 2007 TYPE_USER_ALIGN (variants) = user_align; 2008 TYPE_ALIGN (variants) = valign; 2009 } 2010} 2011 2012/* Set memoizing fields and bits of T (and its variants) for later 2013 use. */ 2014 2015static void 2016finish_struct_bits (tree t) 2017{ 2018 /* Fix up variants (if any). */ 2019 fixup_type_variants (t); 2020 2021 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) && TYPE_POLYMORPHIC_P (t)) 2022 /* For a class w/o baseclasses, 'finish_struct' has set 2023 CLASSTYPE_PURE_VIRTUALS correctly (by definition). 2024 Similarly for a class whose base classes do not have vtables. 2025 When neither of these is true, we might have removed abstract 2026 virtuals (by providing a definition), added some (by declaring 2027 new ones), or redeclared ones from a base class. We need to 2028 recalculate what's really an abstract virtual at this point (by 2029 looking in the vtables). */ 2030 get_pure_virtuals (t); 2031 2032 /* If this type has a copy constructor or a destructor, force its 2033 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be 2034 nonzero. This will cause it to be passed by invisible reference 2035 and prevent it from being returned in a register. */ 2036 if (type_has_nontrivial_copy_init (t) 2037 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)) 2038 { 2039 tree variants; 2040 DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode; 2041 for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants)) 2042 { 2043 SET_TYPE_MODE (variants, BLKmode); 2044 TREE_ADDRESSABLE (variants) = 1; 2045 } 2046 } 2047} 2048 2049/* Issue warnings about T having private constructors, but no friends, 2050 and so forth. 2051 2052 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or 2053 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any 2054 non-private static member functions. */ 2055 2056static void 2057maybe_warn_about_overly_private_class (tree t) 2058{ 2059 int has_member_fn = 0; 2060 int has_nonprivate_method = 0; 2061 tree fn; 2062 2063 if (!warn_ctor_dtor_privacy 2064 /* If the class has friends, those entities might create and 2065 access instances, so we should not warn. */ 2066 || (CLASSTYPE_FRIEND_CLASSES (t) 2067 || DECL_FRIENDLIST (TYPE_MAIN_DECL (t))) 2068 /* We will have warned when the template was declared; there's 2069 no need to warn on every instantiation. */ 2070 || CLASSTYPE_TEMPLATE_INSTANTIATION (t)) 2071 /* There's no reason to even consider warning about this 2072 class. */ 2073 return; 2074 2075 /* We only issue one warning, if more than one applies, because 2076 otherwise, on code like: 2077 2078 class A { 2079 // Oops - forgot `public:' 2080 A(); 2081 A(const A&); 2082 ~A(); 2083 }; 2084 2085 we warn several times about essentially the same problem. */ 2086 2087 /* Check to see if all (non-constructor, non-destructor) member 2088 functions are private. (Since there are no friends or 2089 non-private statics, we can't ever call any of the private member 2090 functions.) */ 2091 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn)) 2092 /* We're not interested in compiler-generated methods; they don't 2093 provide any way to call private members. */ 2094 if (!DECL_ARTIFICIAL (fn)) 2095 { 2096 if (!TREE_PRIVATE (fn)) 2097 { 2098 if (DECL_STATIC_FUNCTION_P (fn)) 2099 /* A non-private static member function is just like a 2100 friend; it can create and invoke private member 2101 functions, and be accessed without a class 2102 instance. */ 2103 return; 2104 2105 has_nonprivate_method = 1; 2106 /* Keep searching for a static member function. */ 2107 } 2108 else if (!DECL_CONSTRUCTOR_P (fn) && !DECL_DESTRUCTOR_P (fn)) 2109 has_member_fn = 1; 2110 } 2111 2112 if (!has_nonprivate_method && has_member_fn) 2113 { 2114 /* There are no non-private methods, and there's at least one 2115 private member function that isn't a constructor or 2116 destructor. (If all the private members are 2117 constructors/destructors we want to use the code below that 2118 issues error messages specifically referring to 2119 constructors/destructors.) */ 2120 unsigned i; 2121 tree binfo = TYPE_BINFO (t); 2122 2123 for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++) 2124 if (BINFO_BASE_ACCESS (binfo, i) != access_private_node) 2125 { 2126 has_nonprivate_method = 1; 2127 break; 2128 } 2129 if (!has_nonprivate_method) 2130 { 2131 warning (OPT_Wctor_dtor_privacy, 2132 "all member functions in class %qT are private", t); 2133 return; 2134 } 2135 } 2136 2137 /* Even if some of the member functions are non-private, the class 2138 won't be useful for much if all the constructors or destructors 2139 are private: such an object can never be created or destroyed. */ 2140 fn = CLASSTYPE_DESTRUCTORS (t); 2141 if (fn && TREE_PRIVATE (fn)) 2142 { 2143 warning (OPT_Wctor_dtor_privacy, 2144 "%q#T only defines a private destructor and has no friends", 2145 t); 2146 return; 2147 } 2148 2149 /* Warn about classes that have private constructors and no friends. */ 2150 if (TYPE_HAS_USER_CONSTRUCTOR (t) 2151 /* Implicitly generated constructors are always public. */ 2152 && (!CLASSTYPE_LAZY_DEFAULT_CTOR (t) 2153 || !CLASSTYPE_LAZY_COPY_CTOR (t))) 2154 { 2155 int nonprivate_ctor = 0; 2156 2157 /* If a non-template class does not define a copy 2158 constructor, one is defined for it, enabling it to avoid 2159 this warning. For a template class, this does not 2160 happen, and so we would normally get a warning on: 2161 2162 template <class T> class C { private: C(); }; 2163 2164 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All 2165 complete non-template or fully instantiated classes have this 2166 flag set. */ 2167 if (!TYPE_HAS_COPY_CTOR (t)) 2168 nonprivate_ctor = 1; 2169 else 2170 for (fn = CLASSTYPE_CONSTRUCTORS (t); fn; fn = OVL_NEXT (fn)) 2171 { 2172 tree ctor = OVL_CURRENT (fn); 2173 /* Ideally, we wouldn't count copy constructors (or, in 2174 fact, any constructor that takes an argument of the 2175 class type as a parameter) because such things cannot 2176 be used to construct an instance of the class unless 2177 you already have one. But, for now at least, we're 2178 more generous. */ 2179 if (! TREE_PRIVATE (ctor)) 2180 { 2181 nonprivate_ctor = 1; 2182 break; 2183 } 2184 } 2185 2186 if (nonprivate_ctor == 0) 2187 { 2188 warning (OPT_Wctor_dtor_privacy, 2189 "%q#T only defines private constructors and has no friends", 2190 t); 2191 return; 2192 } 2193 } 2194} 2195 2196static struct { 2197 gt_pointer_operator new_value; 2198 void *cookie; 2199} resort_data; 2200 2201/* Comparison function to compare two TYPE_METHOD_VEC entries by name. */ 2202 2203static int 2204method_name_cmp (const void* m1_p, const void* m2_p) 2205{ 2206 const tree *const m1 = (const tree *) m1_p; 2207 const tree *const m2 = (const tree *) m2_p; 2208 2209 if (*m1 == NULL_TREE && *m2 == NULL_TREE) 2210 return 0; 2211 if (*m1 == NULL_TREE) 2212 return -1; 2213 if (*m2 == NULL_TREE) 2214 return 1; 2215 if (DECL_NAME (OVL_CURRENT (*m1)) < DECL_NAME (OVL_CURRENT (*m2))) 2216 return -1; 2217 return 1; 2218} 2219 2220/* This routine compares two fields like method_name_cmp but using the 2221 pointer operator in resort_field_decl_data. */ 2222 2223static int 2224resort_method_name_cmp (const void* m1_p, const void* m2_p) 2225{ 2226 const tree *const m1 = (const tree *) m1_p; 2227 const tree *const m2 = (const tree *) m2_p; 2228 if (*m1 == NULL_TREE && *m2 == NULL_TREE) 2229 return 0; 2230 if (*m1 == NULL_TREE) 2231 return -1; 2232 if (*m2 == NULL_TREE) 2233 return 1; 2234 { 2235 tree d1 = DECL_NAME (OVL_CURRENT (*m1)); 2236 tree d2 = DECL_NAME (OVL_CURRENT (*m2)); 2237 resort_data.new_value (&d1, resort_data.cookie); 2238 resort_data.new_value (&d2, resort_data.cookie); 2239 if (d1 < d2) 2240 return -1; 2241 } 2242 return 1; 2243} 2244 2245/* Resort TYPE_METHOD_VEC because pointers have been reordered. */ 2246 2247void 2248resort_type_method_vec (void* obj, 2249 void* /*orig_obj*/, 2250 gt_pointer_operator new_value, 2251 void* cookie) 2252{ 2253 vec<tree, va_gc> *method_vec = (vec<tree, va_gc> *) obj; 2254 int len = vec_safe_length (method_vec); 2255 size_t slot; 2256 tree fn; 2257 2258 /* The type conversion ops have to live at the front of the vec, so we 2259 can't sort them. */ 2260 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; 2261 vec_safe_iterate (method_vec, slot, &fn); 2262 ++slot) 2263 if (!DECL_CONV_FN_P (OVL_CURRENT (fn))) 2264 break; 2265 2266 if (len - slot > 1) 2267 { 2268 resort_data.new_value = new_value; 2269 resort_data.cookie = cookie; 2270 qsort (method_vec->address () + slot, len - slot, sizeof (tree), 2271 resort_method_name_cmp); 2272 } 2273} 2274 2275/* Warn about duplicate methods in fn_fields. 2276 2277 Sort methods that are not special (i.e., constructors, destructors, 2278 and type conversion operators) so that we can find them faster in 2279 search. */ 2280 2281static void 2282finish_struct_methods (tree t) 2283{ 2284 tree fn_fields; 2285 vec<tree, va_gc> *method_vec; 2286 int slot, len; 2287 2288 method_vec = CLASSTYPE_METHOD_VEC (t); 2289 if (!method_vec) 2290 return; 2291 2292 len = method_vec->length (); 2293 2294 /* Clear DECL_IN_AGGR_P for all functions. */ 2295 for (fn_fields = TYPE_METHODS (t); fn_fields; 2296 fn_fields = DECL_CHAIN (fn_fields)) 2297 DECL_IN_AGGR_P (fn_fields) = 0; 2298 2299 /* Issue warnings about private constructors and such. If there are 2300 no methods, then some public defaults are generated. */ 2301 maybe_warn_about_overly_private_class (t); 2302 2303 /* The type conversion ops have to live at the front of the vec, so we 2304 can't sort them. */ 2305 for (slot = CLASSTYPE_FIRST_CONVERSION_SLOT; 2306 method_vec->iterate (slot, &fn_fields); 2307 ++slot) 2308 if (!DECL_CONV_FN_P (OVL_CURRENT (fn_fields))) 2309 break; 2310 if (len - slot > 1) 2311 qsort (method_vec->address () + slot, 2312 len-slot, sizeof (tree), method_name_cmp); 2313} 2314 2315/* Make BINFO's vtable have N entries, including RTTI entries, 2316 vbase and vcall offsets, etc. Set its type and call the back end 2317 to lay it out. */ 2318 2319static void 2320layout_vtable_decl (tree binfo, int n) 2321{ 2322 tree atype; 2323 tree vtable; 2324 2325 atype = build_array_of_n_type (vtable_entry_type, n); 2326 layout_type (atype); 2327 2328 /* We may have to grow the vtable. */ 2329 vtable = get_vtbl_decl_for_binfo (binfo); 2330 if (!same_type_p (TREE_TYPE (vtable), atype)) 2331 { 2332 TREE_TYPE (vtable) = atype; 2333 DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE; 2334 layout_decl (vtable, 0); 2335 } 2336} 2337 2338/* True iff FNDECL and BASE_FNDECL (both non-static member functions) 2339 have the same signature. */ 2340 2341int 2342same_signature_p (const_tree fndecl, const_tree base_fndecl) 2343{ 2344 /* One destructor overrides another if they are the same kind of 2345 destructor. */ 2346 if (DECL_DESTRUCTOR_P (base_fndecl) && DECL_DESTRUCTOR_P (fndecl) 2347 && special_function_p (base_fndecl) == special_function_p (fndecl)) 2348 return 1; 2349 /* But a non-destructor never overrides a destructor, nor vice 2350 versa, nor do different kinds of destructors override 2351 one-another. For example, a complete object destructor does not 2352 override a deleting destructor. */ 2353 if (DECL_DESTRUCTOR_P (base_fndecl) || DECL_DESTRUCTOR_P (fndecl)) 2354 return 0; 2355 2356 if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl) 2357 || (DECL_CONV_FN_P (fndecl) 2358 && DECL_CONV_FN_P (base_fndecl) 2359 && same_type_p (DECL_CONV_FN_TYPE (fndecl), 2360 DECL_CONV_FN_TYPE (base_fndecl)))) 2361 { 2362 tree fntype = TREE_TYPE (fndecl); 2363 tree base_fntype = TREE_TYPE (base_fndecl); 2364 if (type_memfn_quals (fntype) == type_memfn_quals (base_fntype) 2365 && type_memfn_rqual (fntype) == type_memfn_rqual (base_fntype) 2366 && compparms (FUNCTION_FIRST_USER_PARMTYPE (fndecl), 2367 FUNCTION_FIRST_USER_PARMTYPE (base_fndecl))) 2368 return 1; 2369 } 2370 return 0; 2371} 2372 2373/* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a 2374 subobject. */ 2375 2376static bool 2377base_derived_from (tree derived, tree base) 2378{ 2379 tree probe; 2380 2381 for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe)) 2382 { 2383 if (probe == derived) 2384 return true; 2385 else if (BINFO_VIRTUAL_P (probe)) 2386 /* If we meet a virtual base, we can't follow the inheritance 2387 any more. See if the complete type of DERIVED contains 2388 such a virtual base. */ 2389 return (binfo_for_vbase (BINFO_TYPE (probe), BINFO_TYPE (derived)) 2390 != NULL_TREE); 2391 } 2392 return false; 2393} 2394 2395typedef struct find_final_overrider_data_s { 2396 /* The function for which we are trying to find a final overrider. */ 2397 tree fn; 2398 /* The base class in which the function was declared. */ 2399 tree declaring_base; 2400 /* The candidate overriders. */ 2401 tree candidates; 2402 /* Path to most derived. */ 2403 vec<tree> path; 2404} find_final_overrider_data; 2405 2406/* Add the overrider along the current path to FFOD->CANDIDATES. 2407 Returns true if an overrider was found; false otherwise. */ 2408 2409static bool 2410dfs_find_final_overrider_1 (tree binfo, 2411 find_final_overrider_data *ffod, 2412 unsigned depth) 2413{ 2414 tree method; 2415 2416 /* If BINFO is not the most derived type, try a more derived class. 2417 A definition there will overrider a definition here. */ 2418 if (depth) 2419 { 2420 depth--; 2421 if (dfs_find_final_overrider_1 2422 (ffod->path[depth], ffod, depth)) 2423 return true; 2424 } 2425 2426 method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn); 2427 if (method) 2428 { 2429 tree *candidate = &ffod->candidates; 2430 2431 /* Remove any candidates overridden by this new function. */ 2432 while (*candidate) 2433 { 2434 /* If *CANDIDATE overrides METHOD, then METHOD 2435 cannot override anything else on the list. */ 2436 if (base_derived_from (TREE_VALUE (*candidate), binfo)) 2437 return true; 2438 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */ 2439 if (base_derived_from (binfo, TREE_VALUE (*candidate))) 2440 *candidate = TREE_CHAIN (*candidate); 2441 else 2442 candidate = &TREE_CHAIN (*candidate); 2443 } 2444 2445 /* Add the new function. */ 2446 ffod->candidates = tree_cons (method, binfo, ffod->candidates); 2447 return true; 2448 } 2449 2450 return false; 2451} 2452 2453/* Called from find_final_overrider via dfs_walk. */ 2454 2455static tree 2456dfs_find_final_overrider_pre (tree binfo, void *data) 2457{ 2458 find_final_overrider_data *ffod = (find_final_overrider_data *) data; 2459 2460 if (binfo == ffod->declaring_base) 2461 dfs_find_final_overrider_1 (binfo, ffod, ffod->path.length ()); 2462 ffod->path.safe_push (binfo); 2463 2464 return NULL_TREE; 2465} 2466 2467static tree 2468dfs_find_final_overrider_post (tree /*binfo*/, void *data) 2469{ 2470 find_final_overrider_data *ffod = (find_final_overrider_data *) data; 2471 ffod->path.pop (); 2472 2473 return NULL_TREE; 2474} 2475 2476/* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for 2477 FN and whose TREE_VALUE is the binfo for the base where the 2478 overriding occurs. BINFO (in the hierarchy dominated by the binfo 2479 DERIVED) is the base object in which FN is declared. */ 2480 2481static tree 2482find_final_overrider (tree derived, tree binfo, tree fn) 2483{ 2484 find_final_overrider_data ffod; 2485 2486 /* Getting this right is a little tricky. This is valid: 2487 2488 struct S { virtual void f (); }; 2489 struct T { virtual void f (); }; 2490 struct U : public S, public T { }; 2491 2492 even though calling `f' in `U' is ambiguous. But, 2493 2494 struct R { virtual void f(); }; 2495 struct S : virtual public R { virtual void f (); }; 2496 struct T : virtual public R { virtual void f (); }; 2497 struct U : public S, public T { }; 2498 2499 is not -- there's no way to decide whether to put `S::f' or 2500 `T::f' in the vtable for `R'. 2501 2502 The solution is to look at all paths to BINFO. If we find 2503 different overriders along any two, then there is a problem. */ 2504 if (DECL_THUNK_P (fn)) 2505 fn = THUNK_TARGET (fn); 2506 2507 /* Determine the depth of the hierarchy. */ 2508 ffod.fn = fn; 2509 ffod.declaring_base = binfo; 2510 ffod.candidates = NULL_TREE; 2511 ffod.path.create (30); 2512 2513 dfs_walk_all (derived, dfs_find_final_overrider_pre, 2514 dfs_find_final_overrider_post, &ffod); 2515 2516 ffod.path.release (); 2517 2518 /* If there was no winner, issue an error message. */ 2519 if (!ffod.candidates || TREE_CHAIN (ffod.candidates)) 2520 return error_mark_node; 2521 2522 return ffod.candidates; 2523} 2524 2525/* Return the index of the vcall offset for FN when TYPE is used as a 2526 virtual base. */ 2527 2528static tree 2529get_vcall_index (tree fn, tree type) 2530{ 2531 vec<tree_pair_s, va_gc> *indices = CLASSTYPE_VCALL_INDICES (type); 2532 tree_pair_p p; 2533 unsigned ix; 2534 2535 FOR_EACH_VEC_SAFE_ELT (indices, ix, p) 2536 if ((DECL_DESTRUCTOR_P (fn) && DECL_DESTRUCTOR_P (p->purpose)) 2537 || same_signature_p (fn, p->purpose)) 2538 return p->value; 2539 2540 /* There should always be an appropriate index. */ 2541 gcc_unreachable (); 2542} 2543 2544/* Update an entry in the vtable for BINFO, which is in the hierarchy 2545 dominated by T. FN is the old function; VIRTUALS points to the 2546 corresponding position in the new BINFO_VIRTUALS list. IX is the index 2547 of that entry in the list. */ 2548 2549static void 2550update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals, 2551 unsigned ix) 2552{ 2553 tree b; 2554 tree overrider; 2555 tree delta; 2556 tree virtual_base; 2557 tree first_defn; 2558 tree overrider_fn, overrider_target; 2559 tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn; 2560 tree over_return, base_return; 2561 bool lost = false; 2562 2563 /* Find the nearest primary base (possibly binfo itself) which defines 2564 this function; this is the class the caller will convert to when 2565 calling FN through BINFO. */ 2566 for (b = binfo; ; b = get_primary_binfo (b)) 2567 { 2568 gcc_assert (b); 2569 if (look_for_overrides_here (BINFO_TYPE (b), target_fn)) 2570 break; 2571 2572 /* The nearest definition is from a lost primary. */ 2573 if (BINFO_LOST_PRIMARY_P (b)) 2574 lost = true; 2575 } 2576 first_defn = b; 2577 2578 /* Find the final overrider. */ 2579 overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn); 2580 if (overrider == error_mark_node) 2581 { 2582 error ("no unique final overrider for %qD in %qT", target_fn, t); 2583 return; 2584 } 2585 overrider_target = overrider_fn = TREE_PURPOSE (overrider); 2586 2587 /* Check for adjusting covariant return types. */ 2588 over_return = TREE_TYPE (TREE_TYPE (overrider_target)); 2589 base_return = TREE_TYPE (TREE_TYPE (target_fn)); 2590 2591 if (POINTER_TYPE_P (over_return) 2592 && TREE_CODE (over_return) == TREE_CODE (base_return) 2593 && CLASS_TYPE_P (TREE_TYPE (over_return)) 2594 && CLASS_TYPE_P (TREE_TYPE (base_return)) 2595 /* If the overrider is invalid, don't even try. */ 2596 && !DECL_INVALID_OVERRIDER_P (overrider_target)) 2597 { 2598 /* If FN is a covariant thunk, we must figure out the adjustment 2599 to the final base FN was converting to. As OVERRIDER_TARGET might 2600 also be converting to the return type of FN, we have to 2601 combine the two conversions here. */ 2602 tree fixed_offset, virtual_offset; 2603 2604 over_return = TREE_TYPE (over_return); 2605 base_return = TREE_TYPE (base_return); 2606 2607 if (DECL_THUNK_P (fn)) 2608 { 2609 gcc_assert (DECL_RESULT_THUNK_P (fn)); 2610 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn)); 2611 virtual_offset = THUNK_VIRTUAL_OFFSET (fn); 2612 } 2613 else 2614 fixed_offset = virtual_offset = NULL_TREE; 2615 2616 if (virtual_offset) 2617 /* Find the equivalent binfo within the return type of the 2618 overriding function. We will want the vbase offset from 2619 there. */ 2620 virtual_offset = binfo_for_vbase (BINFO_TYPE (virtual_offset), 2621 over_return); 2622 else if (!same_type_ignoring_top_level_qualifiers_p 2623 (over_return, base_return)) 2624 { 2625 /* There was no existing virtual thunk (which takes 2626 precedence). So find the binfo of the base function's 2627 return type within the overriding function's return type. 2628 We cannot call lookup base here, because we're inside a 2629 dfs_walk, and will therefore clobber the BINFO_MARKED 2630 flags. Fortunately we know the covariancy is valid (it 2631 has already been checked), so we can just iterate along 2632 the binfos, which have been chained in inheritance graph 2633 order. Of course it is lame that we have to repeat the 2634 search here anyway -- we should really be caching pieces 2635 of the vtable and avoiding this repeated work. */ 2636 tree thunk_binfo, base_binfo; 2637 2638 /* Find the base binfo within the overriding function's 2639 return type. We will always find a thunk_binfo, except 2640 when the covariancy is invalid (which we will have 2641 already diagnosed). */ 2642 for (base_binfo = TYPE_BINFO (base_return), 2643 thunk_binfo = TYPE_BINFO (over_return); 2644 thunk_binfo; 2645 thunk_binfo = TREE_CHAIN (thunk_binfo)) 2646 if (SAME_BINFO_TYPE_P (BINFO_TYPE (thunk_binfo), 2647 BINFO_TYPE (base_binfo))) 2648 break; 2649 2650 /* See if virtual inheritance is involved. */ 2651 for (virtual_offset = thunk_binfo; 2652 virtual_offset; 2653 virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset)) 2654 if (BINFO_VIRTUAL_P (virtual_offset)) 2655 break; 2656 2657 if (virtual_offset 2658 || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo))) 2659 { 2660 tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo)); 2661 2662 if (virtual_offset) 2663 { 2664 /* We convert via virtual base. Adjust the fixed 2665 offset to be from there. */ 2666 offset = 2667 size_diffop (offset, 2668 convert (ssizetype, 2669 BINFO_OFFSET (virtual_offset))); 2670 } 2671 if (fixed_offset) 2672 /* There was an existing fixed offset, this must be 2673 from the base just converted to, and the base the 2674 FN was thunking to. */ 2675 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset); 2676 else 2677 fixed_offset = offset; 2678 } 2679 } 2680 2681 if (fixed_offset || virtual_offset) 2682 /* Replace the overriding function with a covariant thunk. We 2683 will emit the overriding function in its own slot as 2684 well. */ 2685 overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/0, 2686 fixed_offset, virtual_offset); 2687 } 2688 else 2689 gcc_assert (DECL_INVALID_OVERRIDER_P (overrider_target) || 2690 !DECL_THUNK_P (fn)); 2691 2692 /* If we need a covariant thunk, then we may need to adjust first_defn. 2693 The ABI specifies that the thunks emitted with a function are 2694 determined by which bases the function overrides, so we need to be 2695 sure that we're using a thunk for some overridden base; even if we 2696 know that the necessary this adjustment is zero, there may not be an 2697 appropriate zero-this-adjusment thunk for us to use since thunks for 2698 overriding virtual bases always use the vcall offset. 2699 2700 Furthermore, just choosing any base that overrides this function isn't 2701 quite right, as this slot won't be used for calls through a type that 2702 puts a covariant thunk here. Calling the function through such a type 2703 will use a different slot, and that slot is the one that determines 2704 the thunk emitted for that base. 2705 2706 So, keep looking until we find the base that we're really overriding 2707 in this slot: the nearest primary base that doesn't use a covariant 2708 thunk in this slot. */ 2709 if (overrider_target != overrider_fn) 2710 { 2711 if (BINFO_TYPE (b) == DECL_CONTEXT (overrider_target)) 2712 /* We already know that the overrider needs a covariant thunk. */ 2713 b = get_primary_binfo (b); 2714 for (; ; b = get_primary_binfo (b)) 2715 { 2716 tree main_binfo = TYPE_BINFO (BINFO_TYPE (b)); 2717 tree bv = chain_index (ix, BINFO_VIRTUALS (main_binfo)); 2718 if (!DECL_THUNK_P (TREE_VALUE (bv))) 2719 break; 2720 if (BINFO_LOST_PRIMARY_P (b)) 2721 lost = true; 2722 } 2723 first_defn = b; 2724 } 2725 2726 /* Assume that we will produce a thunk that convert all the way to 2727 the final overrider, and not to an intermediate virtual base. */ 2728 virtual_base = NULL_TREE; 2729 2730 /* See if we can convert to an intermediate virtual base first, and then 2731 use the vcall offset located there to finish the conversion. */ 2732 for (; b; b = BINFO_INHERITANCE_CHAIN (b)) 2733 { 2734 /* If we find the final overrider, then we can stop 2735 walking. */ 2736 if (SAME_BINFO_TYPE_P (BINFO_TYPE (b), 2737 BINFO_TYPE (TREE_VALUE (overrider)))) 2738 break; 2739 2740 /* If we find a virtual base, and we haven't yet found the 2741 overrider, then there is a virtual base between the 2742 declaring base (first_defn) and the final overrider. */ 2743 if (BINFO_VIRTUAL_P (b)) 2744 { 2745 virtual_base = b; 2746 break; 2747 } 2748 } 2749 2750 /* Compute the constant adjustment to the `this' pointer. The 2751 `this' pointer, when this function is called, will point at BINFO 2752 (or one of its primary bases, which are at the same offset). */ 2753 if (virtual_base) 2754 /* The `this' pointer needs to be adjusted from the declaration to 2755 the nearest virtual base. */ 2756 delta = size_diffop_loc (input_location, 2757 convert (ssizetype, BINFO_OFFSET (virtual_base)), 2758 convert (ssizetype, BINFO_OFFSET (first_defn))); 2759 else if (lost) 2760 /* If the nearest definition is in a lost primary, we don't need an 2761 entry in our vtable. Except possibly in a constructor vtable, 2762 if we happen to get our primary back. In that case, the offset 2763 will be zero, as it will be a primary base. */ 2764 delta = size_zero_node; 2765 else 2766 /* The `this' pointer needs to be adjusted from pointing to 2767 BINFO to pointing at the base where the final overrider 2768 appears. */ 2769 delta = size_diffop_loc (input_location, 2770 convert (ssizetype, 2771 BINFO_OFFSET (TREE_VALUE (overrider))), 2772 convert (ssizetype, BINFO_OFFSET (binfo))); 2773 2774 modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals); 2775 2776 if (virtual_base) 2777 BV_VCALL_INDEX (*virtuals) 2778 = get_vcall_index (overrider_target, BINFO_TYPE (virtual_base)); 2779 else 2780 BV_VCALL_INDEX (*virtuals) = NULL_TREE; 2781 2782 BV_LOST_PRIMARY (*virtuals) = lost; 2783} 2784 2785/* Called from modify_all_vtables via dfs_walk. */ 2786 2787static tree 2788dfs_modify_vtables (tree binfo, void* data) 2789{ 2790 tree t = (tree) data; 2791 tree virtuals; 2792 tree old_virtuals; 2793 unsigned ix; 2794 2795 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) 2796 /* A base without a vtable needs no modification, and its bases 2797 are uninteresting. */ 2798 return dfs_skip_bases; 2799 2800 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t) 2801 && !CLASSTYPE_HAS_PRIMARY_BASE_P (t)) 2802 /* Don't do the primary vtable, if it's new. */ 2803 return NULL_TREE; 2804 2805 if (BINFO_PRIMARY_P (binfo) && !BINFO_VIRTUAL_P (binfo)) 2806 /* There's no need to modify the vtable for a non-virtual primary 2807 base; we're not going to use that vtable anyhow. We do still 2808 need to do this for virtual primary bases, as they could become 2809 non-primary in a construction vtable. */ 2810 return NULL_TREE; 2811 2812 make_new_vtable (t, binfo); 2813 2814 /* Now, go through each of the virtual functions in the virtual 2815 function table for BINFO. Find the final overrider, and update 2816 the BINFO_VIRTUALS list appropriately. */ 2817 for (ix = 0, virtuals = BINFO_VIRTUALS (binfo), 2818 old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo))); 2819 virtuals; 2820 ix++, virtuals = TREE_CHAIN (virtuals), 2821 old_virtuals = TREE_CHAIN (old_virtuals)) 2822 update_vtable_entry_for_fn (t, 2823 binfo, 2824 BV_FN (old_virtuals), 2825 &virtuals, ix); 2826 2827 return NULL_TREE; 2828} 2829 2830/* Update all of the primary and secondary vtables for T. Create new 2831 vtables as required, and initialize their RTTI information. Each 2832 of the functions in VIRTUALS is declared in T and may override a 2833 virtual function from a base class; find and modify the appropriate 2834 entries to point to the overriding functions. Returns a list, in 2835 declaration order, of the virtual functions that are declared in T, 2836 but do not appear in the primary base class vtable, and which 2837 should therefore be appended to the end of the vtable for T. */ 2838 2839static tree 2840modify_all_vtables (tree t, tree virtuals) 2841{ 2842 tree binfo = TYPE_BINFO (t); 2843 tree *fnsp; 2844 2845 /* Mangle the vtable name before entering dfs_walk (c++/51884). */ 2846 if (TYPE_CONTAINS_VPTR_P (t)) 2847 get_vtable_decl (t, false); 2848 2849 /* Update all of the vtables. */ 2850 dfs_walk_once (binfo, dfs_modify_vtables, NULL, t); 2851 2852 /* Add virtual functions not already in our primary vtable. These 2853 will be both those introduced by this class, and those overridden 2854 from secondary bases. It does not include virtuals merely 2855 inherited from secondary bases. */ 2856 for (fnsp = &virtuals; *fnsp; ) 2857 { 2858 tree fn = TREE_VALUE (*fnsp); 2859 2860 if (!value_member (fn, BINFO_VIRTUALS (binfo)) 2861 || DECL_VINDEX (fn) == error_mark_node) 2862 { 2863 /* We don't need to adjust the `this' pointer when 2864 calling this function. */ 2865 BV_DELTA (*fnsp) = integer_zero_node; 2866 BV_VCALL_INDEX (*fnsp) = NULL_TREE; 2867 2868 /* This is a function not already in our vtable. Keep it. */ 2869 fnsp = &TREE_CHAIN (*fnsp); 2870 } 2871 else 2872 /* We've already got an entry for this function. Skip it. */ 2873 *fnsp = TREE_CHAIN (*fnsp); 2874 } 2875 2876 return virtuals; 2877} 2878 2879/* Get the base virtual function declarations in T that have the 2880 indicated NAME. */ 2881 2882static void 2883get_basefndecls (tree name, tree t, vec<tree> *base_fndecls) 2884{ 2885 tree methods; 2886 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t)); 2887 int i; 2888 2889 /* Find virtual functions in T with the indicated NAME. */ 2890 i = lookup_fnfields_1 (t, name); 2891 bool found_decls = false; 2892 if (i != -1) 2893 for (methods = (*CLASSTYPE_METHOD_VEC (t))[i]; 2894 methods; 2895 methods = OVL_NEXT (methods)) 2896 { 2897 tree method = OVL_CURRENT (methods); 2898 2899 if (TREE_CODE (method) == FUNCTION_DECL 2900 && DECL_VINDEX (method)) 2901 { 2902 base_fndecls->safe_push (method); 2903 found_decls = true; 2904 } 2905 } 2906 2907 if (found_decls) 2908 return; 2909 2910 for (i = 0; i < n_baseclasses; i++) 2911 { 2912 tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (t), i)); 2913 get_basefndecls (name, basetype, base_fndecls); 2914 } 2915} 2916 2917/* If this declaration supersedes the declaration of 2918 a method declared virtual in the base class, then 2919 mark this field as being virtual as well. */ 2920 2921void 2922check_for_override (tree decl, tree ctype) 2923{ 2924 bool overrides_found = false; 2925 if (TREE_CODE (decl) == TEMPLATE_DECL) 2926 /* In [temp.mem] we have: 2927 2928 A specialization of a member function template does not 2929 override a virtual function from a base class. */ 2930 return; 2931 if ((DECL_DESTRUCTOR_P (decl) 2932 || IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) 2933 || DECL_CONV_FN_P (decl)) 2934 && look_for_overrides (ctype, decl) 2935 && !DECL_STATIC_FUNCTION_P (decl)) 2936 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor 2937 the error_mark_node so that we know it is an overriding 2938 function. */ 2939 { 2940 DECL_VINDEX (decl) = decl; 2941 overrides_found = true; 2942 if (warn_override && !DECL_OVERRIDE_P (decl) 2943 && !DECL_DESTRUCTOR_P (decl)) 2944 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wsuggest_override, 2945 "%q+D can be marked override", decl); 2946 } 2947 2948 if (DECL_VIRTUAL_P (decl)) 2949 { 2950 if (!DECL_VINDEX (decl)) 2951 DECL_VINDEX (decl) = error_mark_node; 2952 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1; 2953 if (DECL_DESTRUCTOR_P (decl)) 2954 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (ctype) = true; 2955 } 2956 else if (DECL_FINAL_P (decl)) 2957 error ("%q+#D marked %<final%>, but is not virtual", decl); 2958 if (DECL_OVERRIDE_P (decl) && !overrides_found) 2959 error ("%q+#D marked %<override%>, but does not override", decl); 2960} 2961 2962/* Warn about hidden virtual functions that are not overridden in t. 2963 We know that constructors and destructors don't apply. */ 2964 2965static void 2966warn_hidden (tree t) 2967{ 2968 vec<tree, va_gc> *method_vec = CLASSTYPE_METHOD_VEC (t); 2969 tree fns; 2970 size_t i; 2971 2972 /* We go through each separately named virtual function. */ 2973 for (i = CLASSTYPE_FIRST_CONVERSION_SLOT; 2974 vec_safe_iterate (method_vec, i, &fns); 2975 ++i) 2976 { 2977 tree fn; 2978 tree name; 2979 tree fndecl; 2980 tree base_binfo; 2981 tree binfo; 2982 int j; 2983 2984 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will 2985 have the same name. Figure out what name that is. */ 2986 name = DECL_NAME (OVL_CURRENT (fns)); 2987 /* There are no possibly hidden functions yet. */ 2988 auto_vec<tree, 20> base_fndecls; 2989 /* Iterate through all of the base classes looking for possibly 2990 hidden functions. */ 2991 for (binfo = TYPE_BINFO (t), j = 0; 2992 BINFO_BASE_ITERATE (binfo, j, base_binfo); j++) 2993 { 2994 tree basetype = BINFO_TYPE (base_binfo); 2995 get_basefndecls (name, basetype, &base_fndecls); 2996 } 2997 2998 /* If there are no functions to hide, continue. */ 2999 if (base_fndecls.is_empty ()) 3000 continue; 3001 3002 /* Remove any overridden functions. */ 3003 for (fn = fns; fn; fn = OVL_NEXT (fn)) 3004 { 3005 fndecl = OVL_CURRENT (fn); 3006 if (TREE_CODE (fndecl) == FUNCTION_DECL 3007 && DECL_VINDEX (fndecl)) 3008 { 3009 /* If the method from the base class has the same 3010 signature as the method from the derived class, it 3011 has been overridden. */ 3012 for (size_t k = 0; k < base_fndecls.length (); k++) 3013 if (base_fndecls[k] 3014 && same_signature_p (fndecl, base_fndecls[k])) 3015 base_fndecls[k] = NULL_TREE; 3016 } 3017 } 3018 3019 /* Now give a warning for all base functions without overriders, 3020 as they are hidden. */ 3021 size_t k; 3022 tree base_fndecl; 3023 FOR_EACH_VEC_ELT (base_fndecls, k, base_fndecl) 3024 if (base_fndecl) 3025 { 3026 /* Here we know it is a hider, and no overrider exists. */ 3027 warning (OPT_Woverloaded_virtual, "%q+D was hidden", base_fndecl); 3028 warning (OPT_Woverloaded_virtual, " by %q+D", fns); 3029 } 3030 } 3031} 3032 3033/* Recursive helper for finish_struct_anon. */ 3034 3035static void 3036finish_struct_anon_r (tree field, bool complain) 3037{ 3038 bool is_union = TREE_CODE (TREE_TYPE (field)) == UNION_TYPE; 3039 tree elt = TYPE_FIELDS (TREE_TYPE (field)); 3040 for (; elt; elt = DECL_CHAIN (elt)) 3041 { 3042 /* We're generally only interested in entities the user 3043 declared, but we also find nested classes by noticing 3044 the TYPE_DECL that we create implicitly. You're 3045 allowed to put one anonymous union inside another, 3046 though, so we explicitly tolerate that. We use 3047 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that 3048 we also allow unnamed types used for defining fields. */ 3049 if (DECL_ARTIFICIAL (elt) 3050 && (!DECL_IMPLICIT_TYPEDEF_P (elt) 3051 || TYPE_ANONYMOUS_P (TREE_TYPE (elt)))) 3052 continue; 3053 3054 if (TREE_CODE (elt) != FIELD_DECL) 3055 { 3056 /* We already complained about static data members in 3057 finish_static_data_member_decl. */ 3058 if (complain && TREE_CODE (elt) != VAR_DECL) 3059 { 3060 if (is_union) 3061 permerror (input_location, 3062 "%q+#D invalid; an anonymous union can " 3063 "only have non-static data members", elt); 3064 else 3065 permerror (input_location, 3066 "%q+#D invalid; an anonymous struct can " 3067 "only have non-static data members", elt); 3068 } 3069 continue; 3070 } 3071 3072 if (complain) 3073 { 3074 if (TREE_PRIVATE (elt)) 3075 { 3076 if (is_union) 3077 permerror (input_location, 3078 "private member %q+#D in anonymous union", elt); 3079 else 3080 permerror (input_location, 3081 "private member %q+#D in anonymous struct", elt); 3082 } 3083 else if (TREE_PROTECTED (elt)) 3084 { 3085 if (is_union) 3086 permerror (input_location, 3087 "protected member %q+#D in anonymous union", elt); 3088 else 3089 permerror (input_location, 3090 "protected member %q+#D in anonymous struct", elt); 3091 } 3092 } 3093 3094 TREE_PRIVATE (elt) = TREE_PRIVATE (field); 3095 TREE_PROTECTED (elt) = TREE_PROTECTED (field); 3096 3097 /* Recurse into the anonymous aggregates to handle correctly 3098 access control (c++/24926): 3099 3100 class A { 3101 union { 3102 union { 3103 int i; 3104 }; 3105 }; 3106 }; 3107 3108 int j=A().i; */ 3109 if (DECL_NAME (elt) == NULL_TREE 3110 && ANON_AGGR_TYPE_P (TREE_TYPE (elt))) 3111 finish_struct_anon_r (elt, /*complain=*/false); 3112 } 3113} 3114 3115/* Check for things that are invalid. There are probably plenty of other 3116 things we should check for also. */ 3117 3118static void 3119finish_struct_anon (tree t) 3120{ 3121 for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 3122 { 3123 if (TREE_STATIC (field)) 3124 continue; 3125 if (TREE_CODE (field) != FIELD_DECL) 3126 continue; 3127 3128 if (DECL_NAME (field) == NULL_TREE 3129 && ANON_AGGR_TYPE_P (TREE_TYPE (field))) 3130 finish_struct_anon_r (field, /*complain=*/true); 3131 } 3132} 3133 3134/* Add T to CLASSTYPE_DECL_LIST of current_class_type which 3135 will be used later during class template instantiation. 3136 When FRIEND_P is zero, T can be a static member data (VAR_DECL), 3137 a non-static member data (FIELD_DECL), a member function 3138 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE), 3139 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL) 3140 When FRIEND_P is nonzero, T is either a friend class 3141 (RECORD_TYPE, TEMPLATE_DECL) or a friend function 3142 (FUNCTION_DECL, TEMPLATE_DECL). */ 3143 3144void 3145maybe_add_class_template_decl_list (tree type, tree t, int friend_p) 3146{ 3147 /* Save some memory by not creating TREE_LIST if TYPE is not template. */ 3148 if (CLASSTYPE_TEMPLATE_INFO (type)) 3149 CLASSTYPE_DECL_LIST (type) 3150 = tree_cons (friend_p ? NULL_TREE : type, 3151 t, CLASSTYPE_DECL_LIST (type)); 3152} 3153 3154/* This function is called from declare_virt_assop_and_dtor via 3155 dfs_walk_all. 3156 3157 DATA is a type that direcly or indirectly inherits the base 3158 represented by BINFO. If BINFO contains a virtual assignment [copy 3159 assignment or move assigment] operator or a virtual constructor, 3160 declare that function in DATA if it hasn't been already declared. */ 3161 3162static tree 3163dfs_declare_virt_assop_and_dtor (tree binfo, void *data) 3164{ 3165 tree bv, fn, t = (tree)data; 3166 tree opname = ansi_assopname (NOP_EXPR); 3167 3168 gcc_assert (t && CLASS_TYPE_P (t)); 3169 gcc_assert (binfo && TREE_CODE (binfo) == TREE_BINFO); 3170 3171 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) 3172 /* A base without a vtable needs no modification, and its bases 3173 are uninteresting. */ 3174 return dfs_skip_bases; 3175 3176 if (BINFO_PRIMARY_P (binfo)) 3177 /* If this is a primary base, then we have already looked at the 3178 virtual functions of its vtable. */ 3179 return NULL_TREE; 3180 3181 for (bv = BINFO_VIRTUALS (binfo); bv; bv = TREE_CHAIN (bv)) 3182 { 3183 fn = BV_FN (bv); 3184 3185 if (DECL_NAME (fn) == opname) 3186 { 3187 if (CLASSTYPE_LAZY_COPY_ASSIGN (t)) 3188 lazily_declare_fn (sfk_copy_assignment, t); 3189 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t)) 3190 lazily_declare_fn (sfk_move_assignment, t); 3191 } 3192 else if (DECL_DESTRUCTOR_P (fn) 3193 && CLASSTYPE_LAZY_DESTRUCTOR (t)) 3194 lazily_declare_fn (sfk_destructor, t); 3195 } 3196 3197 return NULL_TREE; 3198} 3199 3200/* If the class type T has a direct or indirect base that contains a 3201 virtual assignment operator or a virtual destructor, declare that 3202 function in T if it hasn't been already declared. */ 3203 3204static void 3205declare_virt_assop_and_dtor (tree t) 3206{ 3207 if (!(TYPE_POLYMORPHIC_P (t) 3208 && (CLASSTYPE_LAZY_COPY_ASSIGN (t) 3209 || CLASSTYPE_LAZY_MOVE_ASSIGN (t) 3210 || CLASSTYPE_LAZY_DESTRUCTOR (t)))) 3211 return; 3212 3213 dfs_walk_all (TYPE_BINFO (t), 3214 dfs_declare_virt_assop_and_dtor, 3215 NULL, t); 3216} 3217 3218/* Declare the inheriting constructor for class T inherited from base 3219 constructor CTOR with the parameter array PARMS of size NPARMS. */ 3220 3221static void 3222one_inheriting_sig (tree t, tree ctor, tree *parms, int nparms) 3223{ 3224 /* We don't declare an inheriting ctor that would be a default, 3225 copy or move ctor for derived or base. */ 3226 if (nparms == 0) 3227 return; 3228 if (nparms == 1 3229 && TREE_CODE (parms[0]) == REFERENCE_TYPE) 3230 { 3231 tree parm = TYPE_MAIN_VARIANT (TREE_TYPE (parms[0])); 3232 if (parm == t || parm == DECL_CONTEXT (ctor)) 3233 return; 3234 } 3235 3236 tree parmlist = void_list_node; 3237 for (int i = nparms - 1; i >= 0; i--) 3238 parmlist = tree_cons (NULL_TREE, parms[i], parmlist); 3239 tree fn = implicitly_declare_fn (sfk_inheriting_constructor, 3240 t, false, ctor, parmlist); 3241 if (add_method (t, fn, NULL_TREE)) 3242 { 3243 DECL_CHAIN (fn) = TYPE_METHODS (t); 3244 TYPE_METHODS (t) = fn; 3245 } 3246} 3247 3248/* Declare all the inheriting constructors for class T inherited from base 3249 constructor CTOR. */ 3250 3251static void 3252one_inherited_ctor (tree ctor, tree t) 3253{ 3254 tree parms = FUNCTION_FIRST_USER_PARMTYPE (ctor); 3255 3256 tree *new_parms = XALLOCAVEC (tree, list_length (parms)); 3257 int i = 0; 3258 for (; parms && parms != void_list_node; parms = TREE_CHAIN (parms)) 3259 { 3260 if (TREE_PURPOSE (parms)) 3261 one_inheriting_sig (t, ctor, new_parms, i); 3262 new_parms[i++] = TREE_VALUE (parms); 3263 } 3264 one_inheriting_sig (t, ctor, new_parms, i); 3265 if (parms == NULL_TREE) 3266 { 3267 if (warning (OPT_Winherited_variadic_ctor, 3268 "the ellipsis in %qD is not inherited", ctor)) 3269 inform (DECL_SOURCE_LOCATION (ctor), "%qD declared here", ctor); 3270 } 3271} 3272 3273/* Create default constructors, assignment operators, and so forth for 3274 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR, 3275 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, 3276 the class cannot have a default constructor, copy constructor 3277 taking a const reference argument, or an assignment operator taking 3278 a const reference, respectively. */ 3279 3280static void 3281add_implicitly_declared_members (tree t, tree* access_decls, 3282 int cant_have_const_cctor, 3283 int cant_have_const_assignment) 3284{ 3285 bool move_ok = false; 3286 3287 if (cxx_dialect >= cxx11 && !CLASSTYPE_DESTRUCTORS (t) 3288 && !TYPE_HAS_COPY_CTOR (t) && !TYPE_HAS_COPY_ASSIGN (t) 3289 && !type_has_move_constructor (t) && !type_has_move_assign (t)) 3290 move_ok = true; 3291 3292 /* Destructor. */ 3293 if (!CLASSTYPE_DESTRUCTORS (t)) 3294 { 3295 /* In general, we create destructors lazily. */ 3296 CLASSTYPE_LAZY_DESTRUCTOR (t) = 1; 3297 3298 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) 3299 && TYPE_FOR_JAVA (t)) 3300 /* But if this is a Java class, any non-trivial destructor is 3301 invalid, even if compiler-generated. Therefore, if the 3302 destructor is non-trivial we create it now. */ 3303 lazily_declare_fn (sfk_destructor, t); 3304 } 3305 3306 /* [class.ctor] 3307 3308 If there is no user-declared constructor for a class, a default 3309 constructor is implicitly declared. */ 3310 if (! TYPE_HAS_USER_CONSTRUCTOR (t)) 3311 { 3312 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 1; 3313 CLASSTYPE_LAZY_DEFAULT_CTOR (t) = 1; 3314 if (cxx_dialect >= cxx11) 3315 TYPE_HAS_CONSTEXPR_CTOR (t) 3316 /* This might force the declaration. */ 3317 = type_has_constexpr_default_constructor (t); 3318 } 3319 3320 /* [class.ctor] 3321 3322 If a class definition does not explicitly declare a copy 3323 constructor, one is declared implicitly. */ 3324 if (! TYPE_HAS_COPY_CTOR (t) && ! TYPE_FOR_JAVA (t)) 3325 { 3326 TYPE_HAS_COPY_CTOR (t) = 1; 3327 TYPE_HAS_CONST_COPY_CTOR (t) = !cant_have_const_cctor; 3328 CLASSTYPE_LAZY_COPY_CTOR (t) = 1; 3329 if (move_ok) 3330 CLASSTYPE_LAZY_MOVE_CTOR (t) = 1; 3331 } 3332 3333 /* If there is no assignment operator, one will be created if and 3334 when it is needed. For now, just record whether or not the type 3335 of the parameter to the assignment operator will be a const or 3336 non-const reference. */ 3337 if (!TYPE_HAS_COPY_ASSIGN (t) && !TYPE_FOR_JAVA (t)) 3338 { 3339 TYPE_HAS_COPY_ASSIGN (t) = 1; 3340 TYPE_HAS_CONST_COPY_ASSIGN (t) = !cant_have_const_assignment; 3341 CLASSTYPE_LAZY_COPY_ASSIGN (t) = 1; 3342 if (move_ok && !LAMBDA_TYPE_P (t)) 3343 CLASSTYPE_LAZY_MOVE_ASSIGN (t) = 1; 3344 } 3345 3346 /* We can't be lazy about declaring functions that might override 3347 a virtual function from a base class. */ 3348 declare_virt_assop_and_dtor (t); 3349 3350 while (*access_decls) 3351 { 3352 tree using_decl = TREE_VALUE (*access_decls); 3353 tree decl = USING_DECL_DECLS (using_decl); 3354 if (DECL_NAME (using_decl) == ctor_identifier) 3355 { 3356 /* declare, then remove the decl */ 3357 tree ctor_list = decl; 3358 location_t loc = input_location; 3359 input_location = DECL_SOURCE_LOCATION (using_decl); 3360 if (ctor_list) 3361 for (; ctor_list; ctor_list = OVL_NEXT (ctor_list)) 3362 one_inherited_ctor (OVL_CURRENT (ctor_list), t); 3363 *access_decls = TREE_CHAIN (*access_decls); 3364 input_location = loc; 3365 } 3366 else 3367 access_decls = &TREE_CHAIN (*access_decls); 3368 } 3369} 3370 3371/* Subroutine of insert_into_classtype_sorted_fields. Recursively 3372 count the number of fields in TYPE, including anonymous union 3373 members. */ 3374 3375static int 3376count_fields (tree fields) 3377{ 3378 tree x; 3379 int n_fields = 0; 3380 for (x = fields; x; x = DECL_CHAIN (x)) 3381 { 3382 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x))) 3383 n_fields += count_fields (TYPE_FIELDS (TREE_TYPE (x))); 3384 else 3385 n_fields += 1; 3386 } 3387 return n_fields; 3388} 3389 3390/* Subroutine of insert_into_classtype_sorted_fields. Recursively add 3391 all the fields in the TREE_LIST FIELDS to the SORTED_FIELDS_TYPE 3392 elts, starting at offset IDX. */ 3393 3394static int 3395add_fields_to_record_type (tree fields, struct sorted_fields_type *field_vec, int idx) 3396{ 3397 tree x; 3398 for (x = fields; x; x = DECL_CHAIN (x)) 3399 { 3400 if (TREE_CODE (x) == FIELD_DECL && ANON_AGGR_TYPE_P (TREE_TYPE (x))) 3401 idx = add_fields_to_record_type (TYPE_FIELDS (TREE_TYPE (x)), field_vec, idx); 3402 else 3403 field_vec->elts[idx++] = x; 3404 } 3405 return idx; 3406} 3407 3408/* Add all of the enum values of ENUMTYPE, to the FIELD_VEC elts, 3409 starting at offset IDX. */ 3410 3411static int 3412add_enum_fields_to_record_type (tree enumtype, 3413 struct sorted_fields_type *field_vec, 3414 int idx) 3415{ 3416 tree values; 3417 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values)) 3418 field_vec->elts[idx++] = TREE_VALUE (values); 3419 return idx; 3420} 3421 3422/* FIELD is a bit-field. We are finishing the processing for its 3423 enclosing type. Issue any appropriate messages and set appropriate 3424 flags. Returns false if an error has been diagnosed. */ 3425 3426static bool 3427check_bitfield_decl (tree field) 3428{ 3429 tree type = TREE_TYPE (field); 3430 tree w; 3431 3432 /* Extract the declared width of the bitfield, which has been 3433 temporarily stashed in DECL_INITIAL. */ 3434 w = DECL_INITIAL (field); 3435 gcc_assert (w != NULL_TREE); 3436 /* Remove the bit-field width indicator so that the rest of the 3437 compiler does not treat that value as an initializer. */ 3438 DECL_INITIAL (field) = NULL_TREE; 3439 3440 /* Detect invalid bit-field type. */ 3441 if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type)) 3442 { 3443 error ("bit-field %q+#D with non-integral type", field); 3444 w = error_mark_node; 3445 } 3446 else 3447 { 3448 location_t loc = input_location; 3449 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */ 3450 STRIP_NOPS (w); 3451 3452 /* detect invalid field size. */ 3453 input_location = DECL_SOURCE_LOCATION (field); 3454 w = cxx_constant_value (w); 3455 input_location = loc; 3456 3457 if (TREE_CODE (w) != INTEGER_CST) 3458 { 3459 error ("bit-field %q+D width not an integer constant", field); 3460 w = error_mark_node; 3461 } 3462 else if (tree_int_cst_sgn (w) < 0) 3463 { 3464 error ("negative width in bit-field %q+D", field); 3465 w = error_mark_node; 3466 } 3467 else if (integer_zerop (w) && DECL_NAME (field) != 0) 3468 { 3469 error ("zero width for bit-field %q+D", field); 3470 w = error_mark_node; 3471 } 3472 else if ((TREE_CODE (type) != ENUMERAL_TYPE 3473 && TREE_CODE (type) != BOOLEAN_TYPE 3474 && compare_tree_int (w, TYPE_PRECISION (type)) > 0) 3475 || ((TREE_CODE (type) == ENUMERAL_TYPE 3476 || TREE_CODE (type) == BOOLEAN_TYPE) 3477 && tree_int_cst_lt (TYPE_SIZE (type), w))) 3478 warning (0, "width of %q+D exceeds its type", field); 3479 else if (TREE_CODE (type) == ENUMERAL_TYPE 3480 && (0 > (compare_tree_int 3481 (w, TYPE_PRECISION (ENUM_UNDERLYING_TYPE (type)))))) 3482 warning (0, "%q+D is too small to hold all values of %q#T", field, type); 3483 } 3484 3485 if (w != error_mark_node) 3486 { 3487 DECL_SIZE (field) = convert (bitsizetype, w); 3488 DECL_BIT_FIELD (field) = 1; 3489 return true; 3490 } 3491 else 3492 { 3493 /* Non-bit-fields are aligned for their type. */ 3494 DECL_BIT_FIELD (field) = 0; 3495 CLEAR_DECL_C_BIT_FIELD (field); 3496 return false; 3497 } 3498} 3499 3500/* FIELD is a non bit-field. We are finishing the processing for its 3501 enclosing type T. Issue any appropriate messages and set appropriate 3502 flags. */ 3503 3504static void 3505check_field_decl (tree field, 3506 tree t, 3507 int* cant_have_const_ctor, 3508 int* no_const_asn_ref, 3509 int* any_default_members) 3510{ 3511 tree type = strip_array_types (TREE_TYPE (field)); 3512 3513 /* In C++98 an anonymous union cannot contain any fields which would change 3514 the settings of CANT_HAVE_CONST_CTOR and friends. */ 3515 if (ANON_UNION_TYPE_P (type) && cxx_dialect < cxx11) 3516 ; 3517 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous 3518 structs. So, we recurse through their fields here. */ 3519 else if (ANON_AGGR_TYPE_P (type)) 3520 { 3521 tree fields; 3522 3523 for (fields = TYPE_FIELDS (type); fields; fields = DECL_CHAIN (fields)) 3524 if (TREE_CODE (fields) == FIELD_DECL && !DECL_C_BIT_FIELD (field)) 3525 check_field_decl (fields, t, cant_have_const_ctor, 3526 no_const_asn_ref, any_default_members); 3527 } 3528 /* Check members with class type for constructors, destructors, 3529 etc. */ 3530 else if (CLASS_TYPE_P (type)) 3531 { 3532 /* Never let anything with uninheritable virtuals 3533 make it through without complaint. */ 3534 abstract_virtuals_error (field, type); 3535 3536 if (TREE_CODE (t) == UNION_TYPE && cxx_dialect < cxx11) 3537 { 3538 static bool warned; 3539 int oldcount = errorcount; 3540 if (TYPE_NEEDS_CONSTRUCTING (type)) 3541 error ("member %q+#D with constructor not allowed in union", 3542 field); 3543 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 3544 error ("member %q+#D with destructor not allowed in union", field); 3545 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type)) 3546 error ("member %q+#D with copy assignment operator not allowed in union", 3547 field); 3548 if (!warned && errorcount > oldcount) 3549 { 3550 inform (DECL_SOURCE_LOCATION (field), "unrestricted unions " 3551 "only available with -std=c++11 or -std=gnu++11"); 3552 warned = true; 3553 } 3554 } 3555 else 3556 { 3557 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type); 3558 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) 3559 |= TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type); 3560 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) 3561 |= (TYPE_HAS_COMPLEX_COPY_ASSIGN (type) 3562 || !TYPE_HAS_COPY_ASSIGN (type)); 3563 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= (TYPE_HAS_COMPLEX_COPY_CTOR (type) 3564 || !TYPE_HAS_COPY_CTOR (type)); 3565 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_HAS_COMPLEX_MOVE_ASSIGN (type); 3566 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_HAS_COMPLEX_MOVE_CTOR (type); 3567 TYPE_HAS_COMPLEX_DFLT (t) |= (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type) 3568 || TYPE_HAS_COMPLEX_DFLT (type)); 3569 } 3570 3571 if (TYPE_HAS_COPY_CTOR (type) 3572 && !TYPE_HAS_CONST_COPY_CTOR (type)) 3573 *cant_have_const_ctor = 1; 3574 3575 if (TYPE_HAS_COPY_ASSIGN (type) 3576 && !TYPE_HAS_CONST_COPY_ASSIGN (type)) 3577 *no_const_asn_ref = 1; 3578 } 3579 3580 check_abi_tags (t, field); 3581 3582 if (DECL_INITIAL (field) != NULL_TREE) 3583 { 3584 /* `build_class_init_list' does not recognize 3585 non-FIELD_DECLs. */ 3586 if (TREE_CODE (t) == UNION_TYPE && *any_default_members != 0) 3587 error ("multiple fields in union %qT initialized", t); 3588 *any_default_members = 1; 3589 } 3590} 3591 3592/* Check the data members (both static and non-static), class-scoped 3593 typedefs, etc., appearing in the declaration of T. Issue 3594 appropriate diagnostics. Sets ACCESS_DECLS to a list (in 3595 declaration order) of access declarations; each TREE_VALUE in this 3596 list is a USING_DECL. 3597 3598 In addition, set the following flags: 3599 3600 EMPTY_P 3601 The class is empty, i.e., contains no non-static data members. 3602 3603 CANT_HAVE_CONST_CTOR_P 3604 This class cannot have an implicitly generated copy constructor 3605 taking a const reference. 3606 3607 CANT_HAVE_CONST_ASN_REF 3608 This class cannot have an implicitly generated assignment 3609 operator taking a const reference. 3610 3611 All of these flags should be initialized before calling this 3612 function. 3613 3614 Returns a pointer to the end of the TYPE_FIELDs chain; additional 3615 fields can be added by adding to this chain. */ 3616 3617static void 3618check_field_decls (tree t, tree *access_decls, 3619 int *cant_have_const_ctor_p, 3620 int *no_const_asn_ref_p) 3621{ 3622 tree *field; 3623 tree *next; 3624 bool has_pointers; 3625 int any_default_members; 3626 int cant_pack = 0; 3627 int field_access = -1; 3628 3629 /* Assume there are no access declarations. */ 3630 *access_decls = NULL_TREE; 3631 /* Assume this class has no pointer members. */ 3632 has_pointers = false; 3633 /* Assume none of the members of this class have default 3634 initializations. */ 3635 any_default_members = 0; 3636 3637 for (field = &TYPE_FIELDS (t); *field; field = next) 3638 { 3639 tree x = *field; 3640 tree type = TREE_TYPE (x); 3641 int this_field_access; 3642 3643 next = &DECL_CHAIN (x); 3644 3645 if (TREE_CODE (x) == USING_DECL) 3646 { 3647 /* Save the access declarations for our caller. */ 3648 *access_decls = tree_cons (NULL_TREE, x, *access_decls); 3649 continue; 3650 } 3651 3652 if (TREE_CODE (x) == TYPE_DECL 3653 || TREE_CODE (x) == TEMPLATE_DECL) 3654 continue; 3655 3656 /* If we've gotten this far, it's a data member, possibly static, 3657 or an enumerator. */ 3658 if (TREE_CODE (x) != CONST_DECL) 3659 DECL_CONTEXT (x) = t; 3660 3661 /* When this goes into scope, it will be a non-local reference. */ 3662 DECL_NONLOCAL (x) = 1; 3663 3664 if (TREE_CODE (t) == UNION_TYPE 3665 && cxx_dialect < cxx11) 3666 { 3667 /* [class.union] (C++98) 3668 3669 If a union contains a static data member, or a member of 3670 reference type, the program is ill-formed. 3671 3672 In C++11 this limitation doesn't exist anymore. */ 3673 if (VAR_P (x)) 3674 { 3675 error ("in C++98 %q+D may not be static because it is " 3676 "a member of a union", x); 3677 continue; 3678 } 3679 if (TREE_CODE (type) == REFERENCE_TYPE) 3680 { 3681 error ("in C++98 %q+D may not have reference type %qT " 3682 "because it is a member of a union", x, type); 3683 continue; 3684 } 3685 } 3686 3687 /* Perform error checking that did not get done in 3688 grokdeclarator. */ 3689 if (TREE_CODE (type) == FUNCTION_TYPE) 3690 { 3691 error ("field %q+D invalidly declared function type", x); 3692 type = build_pointer_type (type); 3693 TREE_TYPE (x) = type; 3694 } 3695 else if (TREE_CODE (type) == METHOD_TYPE) 3696 { 3697 error ("field %q+D invalidly declared method type", x); 3698 type = build_pointer_type (type); 3699 TREE_TYPE (x) = type; 3700 } 3701 3702 if (type == error_mark_node) 3703 continue; 3704 3705 if (TREE_CODE (x) == CONST_DECL || VAR_P (x)) 3706 continue; 3707 3708 /* Now it can only be a FIELD_DECL. */ 3709 3710 if (TREE_PRIVATE (x) || TREE_PROTECTED (x)) 3711 CLASSTYPE_NON_AGGREGATE (t) = 1; 3712 3713 /* If at least one non-static data member is non-literal, the whole 3714 class becomes non-literal. Per Core/1453, volatile non-static 3715 data members and base classes are also not allowed. 3716 Note: if the type is incomplete we will complain later on. */ 3717 if (COMPLETE_TYPE_P (type) 3718 && (!literal_type_p (type) || CP_TYPE_VOLATILE_P (type))) 3719 CLASSTYPE_LITERAL_P (t) = false; 3720 3721 /* A standard-layout class is a class that: 3722 ... 3723 has the same access control (Clause 11) for all non-static data members, 3724 ... */ 3725 this_field_access = TREE_PROTECTED (x) ? 1 : TREE_PRIVATE (x) ? 2 : 0; 3726 if (field_access == -1) 3727 field_access = this_field_access; 3728 else if (this_field_access != field_access) 3729 CLASSTYPE_NON_STD_LAYOUT (t) = 1; 3730 3731 /* If this is of reference type, check if it needs an init. */ 3732 if (TREE_CODE (type) == REFERENCE_TYPE) 3733 { 3734 CLASSTYPE_NON_LAYOUT_POD_P (t) = 1; 3735 CLASSTYPE_NON_STD_LAYOUT (t) = 1; 3736 if (DECL_INITIAL (x) == NULL_TREE) 3737 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1); 3738 if (cxx_dialect < cxx11) 3739 { 3740 /* ARM $12.6.2: [A member initializer list] (or, for an 3741 aggregate, initialization by a brace-enclosed list) is the 3742 only way to initialize nonstatic const and reference 3743 members. */ 3744 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1; 3745 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) = 1; 3746 } 3747 } 3748 3749 type = strip_array_types (type); 3750 3751 if (TYPE_PACKED (t)) 3752 { 3753 if (!layout_pod_type_p (type) && !TYPE_PACKED (type)) 3754 { 3755 warning 3756 (0, 3757 "ignoring packed attribute because of unpacked non-POD field %q+#D", 3758 x); 3759 cant_pack = 1; 3760 } 3761 else if (DECL_C_BIT_FIELD (x) 3762 || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT) 3763 DECL_PACKED (x) = 1; 3764 } 3765 3766 if (DECL_C_BIT_FIELD (x) && integer_zerop (DECL_INITIAL (x))) 3767 /* We don't treat zero-width bitfields as making a class 3768 non-empty. */ 3769 ; 3770 else 3771 { 3772 /* The class is non-empty. */ 3773 CLASSTYPE_EMPTY_P (t) = 0; 3774 /* The class is not even nearly empty. */ 3775 CLASSTYPE_NEARLY_EMPTY_P (t) = 0; 3776 /* If one of the data members contains an empty class, 3777 so does T. */ 3778 if (CLASS_TYPE_P (type) 3779 && CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type)) 3780 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1; 3781 } 3782 3783 /* This is used by -Weffc++ (see below). Warn only for pointers 3784 to members which might hold dynamic memory. So do not warn 3785 for pointers to functions or pointers to members. */ 3786 if (TYPE_PTR_P (type) 3787 && !TYPE_PTRFN_P (type)) 3788 has_pointers = true; 3789 3790 if (CLASS_TYPE_P (type)) 3791 { 3792 if (CLASSTYPE_REF_FIELDS_NEED_INIT (type)) 3793 SET_CLASSTYPE_REF_FIELDS_NEED_INIT (t, 1); 3794 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (type)) 3795 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1); 3796 } 3797 3798 if (DECL_MUTABLE_P (x) || TYPE_HAS_MUTABLE_P (type)) 3799 CLASSTYPE_HAS_MUTABLE (t) = 1; 3800 3801 if (DECL_MUTABLE_P (x)) 3802 { 3803 if (CP_TYPE_CONST_P (type)) 3804 { 3805 error ("member %q+D cannot be declared both %<const%> " 3806 "and %<mutable%>", x); 3807 continue; 3808 } 3809 if (TREE_CODE (type) == REFERENCE_TYPE) 3810 { 3811 error ("member %q+D cannot be declared as a %<mutable%> " 3812 "reference", x); 3813 continue; 3814 } 3815 } 3816 3817 if (! layout_pod_type_p (type)) 3818 /* DR 148 now allows pointers to members (which are POD themselves), 3819 to be allowed in POD structs. */ 3820 CLASSTYPE_NON_LAYOUT_POD_P (t) = 1; 3821 3822 if (!std_layout_type_p (type)) 3823 CLASSTYPE_NON_STD_LAYOUT (t) = 1; 3824 3825 if (! zero_init_p (type)) 3826 CLASSTYPE_NON_ZERO_INIT_P (t) = 1; 3827 3828 /* We set DECL_C_BIT_FIELD in grokbitfield. 3829 If the type and width are valid, we'll also set DECL_BIT_FIELD. */ 3830 if (! DECL_C_BIT_FIELD (x) || ! check_bitfield_decl (x)) 3831 check_field_decl (x, t, 3832 cant_have_const_ctor_p, 3833 no_const_asn_ref_p, 3834 &any_default_members); 3835 3836 /* Now that we've removed bit-field widths from DECL_INITIAL, 3837 anything left in DECL_INITIAL is an NSDMI that makes the class 3838 non-aggregate in C++11. */ 3839 if (DECL_INITIAL (x) && cxx_dialect < cxx14) 3840 CLASSTYPE_NON_AGGREGATE (t) = true; 3841 3842 /* If any field is const, the structure type is pseudo-const. */ 3843 if (CP_TYPE_CONST_P (type)) 3844 { 3845 C_TYPE_FIELDS_READONLY (t) = 1; 3846 if (DECL_INITIAL (x) == NULL_TREE) 3847 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 1); 3848 if (cxx_dialect < cxx11) 3849 { 3850 /* ARM $12.6.2: [A member initializer list] (or, for an 3851 aggregate, initialization by a brace-enclosed list) is the 3852 only way to initialize nonstatic const and reference 3853 members. */ 3854 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) = 1; 3855 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) = 1; 3856 } 3857 } 3858 /* A field that is pseudo-const makes the structure likewise. */ 3859 else if (CLASS_TYPE_P (type)) 3860 { 3861 C_TYPE_FIELDS_READONLY (t) |= C_TYPE_FIELDS_READONLY (type); 3862 SET_CLASSTYPE_READONLY_FIELDS_NEED_INIT (t, 3863 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) 3864 | CLASSTYPE_READONLY_FIELDS_NEED_INIT (type)); 3865 } 3866 3867 /* Core issue 80: A nonstatic data member is required to have a 3868 different name from the class iff the class has a 3869 user-declared constructor. */ 3870 if (constructor_name_p (DECL_NAME (x), t) 3871 && TYPE_HAS_USER_CONSTRUCTOR (t)) 3872 permerror (input_location, "field %q+#D with same name as class", x); 3873 } 3874 3875 /* Effective C++ rule 11: if a class has dynamic memory held by pointers, 3876 it should also define a copy constructor and an assignment operator to 3877 implement the correct copy semantic (deep vs shallow, etc.). As it is 3878 not feasible to check whether the constructors do allocate dynamic memory 3879 and store it within members, we approximate the warning like this: 3880 3881 -- Warn only if there are members which are pointers 3882 -- Warn only if there is a non-trivial constructor (otherwise, 3883 there cannot be memory allocated). 3884 -- Warn only if there is a non-trivial destructor. We assume that the 3885 user at least implemented the cleanup correctly, and a destructor 3886 is needed to free dynamic memory. 3887 3888 This seems enough for practical purposes. */ 3889 if (warn_ecpp 3890 && has_pointers 3891 && TYPE_HAS_USER_CONSTRUCTOR (t) 3892 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) 3893 && !(TYPE_HAS_COPY_CTOR (t) && TYPE_HAS_COPY_ASSIGN (t))) 3894 { 3895 warning (OPT_Weffc__, "%q#T has pointer data members", t); 3896 3897 if (! TYPE_HAS_COPY_CTOR (t)) 3898 { 3899 warning (OPT_Weffc__, 3900 " but does not override %<%T(const %T&)%>", t, t); 3901 if (!TYPE_HAS_COPY_ASSIGN (t)) 3902 warning (OPT_Weffc__, " or %<operator=(const %T&)%>", t); 3903 } 3904 else if (! TYPE_HAS_COPY_ASSIGN (t)) 3905 warning (OPT_Weffc__, 3906 " but does not override %<operator=(const %T&)%>", t); 3907 } 3908 3909 /* Non-static data member initializers make the default constructor 3910 non-trivial. */ 3911 if (any_default_members) 3912 { 3913 TYPE_NEEDS_CONSTRUCTING (t) = true; 3914 TYPE_HAS_COMPLEX_DFLT (t) = true; 3915 } 3916 3917 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */ 3918 if (cant_pack) 3919 TYPE_PACKED (t) = 0; 3920 3921 /* Check anonymous struct/anonymous union fields. */ 3922 finish_struct_anon (t); 3923 3924 /* We've built up the list of access declarations in reverse order. 3925 Fix that now. */ 3926 *access_decls = nreverse (*access_decls); 3927} 3928 3929/* If TYPE is an empty class type, records its OFFSET in the table of 3930 OFFSETS. */ 3931 3932static int 3933record_subobject_offset (tree type, tree offset, splay_tree offsets) 3934{ 3935 splay_tree_node n; 3936 3937 if (!is_empty_class (type)) 3938 return 0; 3939 3940 /* Record the location of this empty object in OFFSETS. */ 3941 n = splay_tree_lookup (offsets, (splay_tree_key) offset); 3942 if (!n) 3943 n = splay_tree_insert (offsets, 3944 (splay_tree_key) offset, 3945 (splay_tree_value) NULL_TREE); 3946 n->value = ((splay_tree_value) 3947 tree_cons (NULL_TREE, 3948 type, 3949 (tree) n->value)); 3950 3951 return 0; 3952} 3953 3954/* Returns nonzero if TYPE is an empty class type and there is 3955 already an entry in OFFSETS for the same TYPE as the same OFFSET. */ 3956 3957static int 3958check_subobject_offset (tree type, tree offset, splay_tree offsets) 3959{ 3960 splay_tree_node n; 3961 tree t; 3962 3963 if (!is_empty_class (type)) 3964 return 0; 3965 3966 /* Record the location of this empty object in OFFSETS. */ 3967 n = splay_tree_lookup (offsets, (splay_tree_key) offset); 3968 if (!n) 3969 return 0; 3970 3971 for (t = (tree) n->value; t; t = TREE_CHAIN (t)) 3972 if (same_type_p (TREE_VALUE (t), type)) 3973 return 1; 3974 3975 return 0; 3976} 3977 3978/* Walk through all the subobjects of TYPE (located at OFFSET). Call 3979 F for every subobject, passing it the type, offset, and table of 3980 OFFSETS. If VBASES_P is one, then virtual non-primary bases should 3981 be traversed. 3982 3983 If MAX_OFFSET is non-NULL, then subobjects with an offset greater 3984 than MAX_OFFSET will not be walked. 3985 3986 If F returns a nonzero value, the traversal ceases, and that value 3987 is returned. Otherwise, returns zero. */ 3988 3989static int 3990walk_subobject_offsets (tree type, 3991 subobject_offset_fn f, 3992 tree offset, 3993 splay_tree offsets, 3994 tree max_offset, 3995 int vbases_p) 3996{ 3997 int r = 0; 3998 tree type_binfo = NULL_TREE; 3999 4000 /* If this OFFSET is bigger than the MAX_OFFSET, then we should 4001 stop. */ 4002 if (max_offset && tree_int_cst_lt (max_offset, offset)) 4003 return 0; 4004 4005 if (type == error_mark_node) 4006 return 0; 4007 4008 if (!TYPE_P (type)) 4009 { 4010 type_binfo = type; 4011 type = BINFO_TYPE (type); 4012 } 4013 4014 if (CLASS_TYPE_P (type)) 4015 { 4016 tree field; 4017 tree binfo; 4018 int i; 4019 4020 /* Avoid recursing into objects that are not interesting. */ 4021 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type)) 4022 return 0; 4023 4024 /* Record the location of TYPE. */ 4025 r = (*f) (type, offset, offsets); 4026 if (r) 4027 return r; 4028 4029 /* Iterate through the direct base classes of TYPE. */ 4030 if (!type_binfo) 4031 type_binfo = TYPE_BINFO (type); 4032 for (i = 0; BINFO_BASE_ITERATE (type_binfo, i, binfo); i++) 4033 { 4034 tree binfo_offset; 4035 4036 if (BINFO_VIRTUAL_P (binfo)) 4037 continue; 4038 4039 tree orig_binfo; 4040 /* We cannot rely on BINFO_OFFSET being set for the base 4041 class yet, but the offsets for direct non-virtual 4042 bases can be calculated by going back to the TYPE. */ 4043 orig_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), i); 4044 binfo_offset = size_binop (PLUS_EXPR, 4045 offset, 4046 BINFO_OFFSET (orig_binfo)); 4047 4048 r = walk_subobject_offsets (binfo, 4049 f, 4050 binfo_offset, 4051 offsets, 4052 max_offset, 4053 /*vbases_p=*/0); 4054 if (r) 4055 return r; 4056 } 4057 4058 if (CLASSTYPE_VBASECLASSES (type)) 4059 { 4060 unsigned ix; 4061 vec<tree, va_gc> *vbases; 4062 4063 /* Iterate through the virtual base classes of TYPE. In G++ 4064 3.2, we included virtual bases in the direct base class 4065 loop above, which results in incorrect results; the 4066 correct offsets for virtual bases are only known when 4067 working with the most derived type. */ 4068 if (vbases_p) 4069 for (vbases = CLASSTYPE_VBASECLASSES (type), ix = 0; 4070 vec_safe_iterate (vbases, ix, &binfo); ix++) 4071 { 4072 r = walk_subobject_offsets (binfo, 4073 f, 4074 size_binop (PLUS_EXPR, 4075 offset, 4076 BINFO_OFFSET (binfo)), 4077 offsets, 4078 max_offset, 4079 /*vbases_p=*/0); 4080 if (r) 4081 return r; 4082 } 4083 else 4084 { 4085 /* We still have to walk the primary base, if it is 4086 virtual. (If it is non-virtual, then it was walked 4087 above.) */ 4088 tree vbase = get_primary_binfo (type_binfo); 4089 4090 if (vbase && BINFO_VIRTUAL_P (vbase) 4091 && BINFO_PRIMARY_P (vbase) 4092 && BINFO_INHERITANCE_CHAIN (vbase) == type_binfo) 4093 { 4094 r = (walk_subobject_offsets 4095 (vbase, f, offset, 4096 offsets, max_offset, /*vbases_p=*/0)); 4097 if (r) 4098 return r; 4099 } 4100 } 4101 } 4102 4103 /* Iterate through the fields of TYPE. */ 4104 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 4105 if (TREE_CODE (field) == FIELD_DECL 4106 && TREE_TYPE (field) != error_mark_node 4107 && !DECL_ARTIFICIAL (field)) 4108 { 4109 tree field_offset; 4110 4111 field_offset = byte_position (field); 4112 4113 r = walk_subobject_offsets (TREE_TYPE (field), 4114 f, 4115 size_binop (PLUS_EXPR, 4116 offset, 4117 field_offset), 4118 offsets, 4119 max_offset, 4120 /*vbases_p=*/1); 4121 if (r) 4122 return r; 4123 } 4124 } 4125 else if (TREE_CODE (type) == ARRAY_TYPE) 4126 { 4127 tree element_type = strip_array_types (type); 4128 tree domain = TYPE_DOMAIN (type); 4129 tree index; 4130 4131 /* Avoid recursing into objects that are not interesting. */ 4132 if (!CLASS_TYPE_P (element_type) 4133 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type)) 4134 return 0; 4135 4136 /* Step through each of the elements in the array. */ 4137 for (index = size_zero_node; 4138 !tree_int_cst_lt (TYPE_MAX_VALUE (domain), index); 4139 index = size_binop (PLUS_EXPR, index, size_one_node)) 4140 { 4141 r = walk_subobject_offsets (TREE_TYPE (type), 4142 f, 4143 offset, 4144 offsets, 4145 max_offset, 4146 /*vbases_p=*/1); 4147 if (r) 4148 return r; 4149 offset = size_binop (PLUS_EXPR, offset, 4150 TYPE_SIZE_UNIT (TREE_TYPE (type))); 4151 /* If this new OFFSET is bigger than the MAX_OFFSET, then 4152 there's no point in iterating through the remaining 4153 elements of the array. */ 4154 if (max_offset && tree_int_cst_lt (max_offset, offset)) 4155 break; 4156 } 4157 } 4158 4159 return 0; 4160} 4161 4162/* Record all of the empty subobjects of TYPE (either a type or a 4163 binfo). If IS_DATA_MEMBER is true, then a non-static data member 4164 is being placed at OFFSET; otherwise, it is a base class that is 4165 being placed at OFFSET. */ 4166 4167static void 4168record_subobject_offsets (tree type, 4169 tree offset, 4170 splay_tree offsets, 4171 bool is_data_member) 4172{ 4173 tree max_offset; 4174 /* If recording subobjects for a non-static data member or a 4175 non-empty base class , we do not need to record offsets beyond 4176 the size of the biggest empty class. Additional data members 4177 will go at the end of the class. Additional base classes will go 4178 either at offset zero (if empty, in which case they cannot 4179 overlap with offsets past the size of the biggest empty class) or 4180 at the end of the class. 4181 4182 However, if we are placing an empty base class, then we must record 4183 all offsets, as either the empty class is at offset zero (where 4184 other empty classes might later be placed) or at the end of the 4185 class (where other objects might then be placed, so other empty 4186 subobjects might later overlap). */ 4187 if (is_data_member 4188 || !is_empty_class (BINFO_TYPE (type))) 4189 max_offset = sizeof_biggest_empty_class; 4190 else 4191 max_offset = NULL_TREE; 4192 walk_subobject_offsets (type, record_subobject_offset, offset, 4193 offsets, max_offset, is_data_member); 4194} 4195 4196/* Returns nonzero if any of the empty subobjects of TYPE (located at 4197 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero, 4198 virtual bases of TYPE are examined. */ 4199 4200static int 4201layout_conflict_p (tree type, 4202 tree offset, 4203 splay_tree offsets, 4204 int vbases_p) 4205{ 4206 splay_tree_node max_node; 4207 4208 /* Get the node in OFFSETS that indicates the maximum offset where 4209 an empty subobject is located. */ 4210 max_node = splay_tree_max (offsets); 4211 /* If there aren't any empty subobjects, then there's no point in 4212 performing this check. */ 4213 if (!max_node) 4214 return 0; 4215 4216 return walk_subobject_offsets (type, check_subobject_offset, offset, 4217 offsets, (tree) (max_node->key), 4218 vbases_p); 4219} 4220 4221/* DECL is a FIELD_DECL corresponding either to a base subobject of a 4222 non-static data member of the type indicated by RLI. BINFO is the 4223 binfo corresponding to the base subobject, OFFSETS maps offsets to 4224 types already located at those offsets. This function determines 4225 the position of the DECL. */ 4226 4227static void 4228layout_nonempty_base_or_field (record_layout_info rli, 4229 tree decl, 4230 tree binfo, 4231 splay_tree offsets) 4232{ 4233 tree offset = NULL_TREE; 4234 bool field_p; 4235 tree type; 4236 4237 if (binfo) 4238 { 4239 /* For the purposes of determining layout conflicts, we want to 4240 use the class type of BINFO; TREE_TYPE (DECL) will be the 4241 CLASSTYPE_AS_BASE version, which does not contain entries for 4242 zero-sized bases. */ 4243 type = TREE_TYPE (binfo); 4244 field_p = false; 4245 } 4246 else 4247 { 4248 type = TREE_TYPE (decl); 4249 field_p = true; 4250 } 4251 4252 /* Try to place the field. It may take more than one try if we have 4253 a hard time placing the field without putting two objects of the 4254 same type at the same address. */ 4255 while (1) 4256 { 4257 struct record_layout_info_s old_rli = *rli; 4258 4259 /* Place this field. */ 4260 place_field (rli, decl); 4261 offset = byte_position (decl); 4262 4263 /* We have to check to see whether or not there is already 4264 something of the same type at the offset we're about to use. 4265 For example, consider: 4266 4267 struct S {}; 4268 struct T : public S { int i; }; 4269 struct U : public S, public T {}; 4270 4271 Here, we put S at offset zero in U. Then, we can't put T at 4272 offset zero -- its S component would be at the same address 4273 as the S we already allocated. So, we have to skip ahead. 4274 Since all data members, including those whose type is an 4275 empty class, have nonzero size, any overlap can happen only 4276 with a direct or indirect base-class -- it can't happen with 4277 a data member. */ 4278 /* In a union, overlap is permitted; all members are placed at 4279 offset zero. */ 4280 if (TREE_CODE (rli->t) == UNION_TYPE) 4281 break; 4282 if (layout_conflict_p (field_p ? type : binfo, offset, 4283 offsets, field_p)) 4284 { 4285 /* Strip off the size allocated to this field. That puts us 4286 at the first place we could have put the field with 4287 proper alignment. */ 4288 *rli = old_rli; 4289 4290 /* Bump up by the alignment required for the type. */ 4291 rli->bitpos 4292 = size_binop (PLUS_EXPR, rli->bitpos, 4293 bitsize_int (binfo 4294 ? CLASSTYPE_ALIGN (type) 4295 : TYPE_ALIGN (type))); 4296 normalize_rli (rli); 4297 } 4298 else if (TREE_CODE (type) == NULLPTR_TYPE 4299 && warn_abi && abi_version_crosses (9)) 4300 { 4301 /* Before ABI v9, we were giving nullptr_t alignment of 1; if 4302 the offset wasn't aligned like a pointer when we started to 4303 layout this field, that affects its position. */ 4304 tree pos = rli_size_unit_so_far (&old_rli); 4305 if (int_cst_value (pos) % TYPE_ALIGN_UNIT (ptr_type_node) != 0) 4306 { 4307 if (abi_version_at_least (9)) 4308 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wabi, 4309 "alignment of %qD increased in -fabi-version=9 " 4310 "(GCC 5.2)", decl); 4311 else 4312 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wabi, "alignment " 4313 "of %qD will increase in -fabi-version=9", decl); 4314 } 4315 break; 4316 } 4317 else 4318 /* There was no conflict. We're done laying out this field. */ 4319 break; 4320 } 4321 4322 /* Now that we know where it will be placed, update its 4323 BINFO_OFFSET. */ 4324 if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo))) 4325 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at 4326 this point because their BINFO_OFFSET is copied from another 4327 hierarchy. Therefore, we may not need to add the entire 4328 OFFSET. */ 4329 propagate_binfo_offsets (binfo, 4330 size_diffop_loc (input_location, 4331 convert (ssizetype, offset), 4332 convert (ssizetype, 4333 BINFO_OFFSET (binfo)))); 4334} 4335 4336/* Returns true if TYPE is empty and OFFSET is nonzero. */ 4337 4338static int 4339empty_base_at_nonzero_offset_p (tree type, 4340 tree offset, 4341 splay_tree /*offsets*/) 4342{ 4343 return is_empty_class (type) && !integer_zerop (offset); 4344} 4345 4346/* Layout the empty base BINFO. EOC indicates the byte currently just 4347 past the end of the class, and should be correctly aligned for a 4348 class of the type indicated by BINFO; OFFSETS gives the offsets of 4349 the empty bases allocated so far. T is the most derived 4350 type. Return nonzero iff we added it at the end. */ 4351 4352static bool 4353layout_empty_base (record_layout_info rli, tree binfo, 4354 tree eoc, splay_tree offsets) 4355{ 4356 tree alignment; 4357 tree basetype = BINFO_TYPE (binfo); 4358 bool atend = false; 4359 4360 /* This routine should only be used for empty classes. */ 4361 gcc_assert (is_empty_class (basetype)); 4362 alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype)); 4363 4364 if (!integer_zerop (BINFO_OFFSET (binfo))) 4365 propagate_binfo_offsets 4366 (binfo, size_diffop_loc (input_location, 4367 size_zero_node, BINFO_OFFSET (binfo))); 4368 4369 /* This is an empty base class. We first try to put it at offset 4370 zero. */ 4371 if (layout_conflict_p (binfo, 4372 BINFO_OFFSET (binfo), 4373 offsets, 4374 /*vbases_p=*/0)) 4375 { 4376 /* That didn't work. Now, we move forward from the next 4377 available spot in the class. */ 4378 atend = true; 4379 propagate_binfo_offsets (binfo, convert (ssizetype, eoc)); 4380 while (1) 4381 { 4382 if (!layout_conflict_p (binfo, 4383 BINFO_OFFSET (binfo), 4384 offsets, 4385 /*vbases_p=*/0)) 4386 /* We finally found a spot where there's no overlap. */ 4387 break; 4388 4389 /* There's overlap here, too. Bump along to the next spot. */ 4390 propagate_binfo_offsets (binfo, alignment); 4391 } 4392 } 4393 4394 if (CLASSTYPE_USER_ALIGN (basetype)) 4395 { 4396 rli->record_align = MAX (rli->record_align, CLASSTYPE_ALIGN (basetype)); 4397 if (warn_packed) 4398 rli->unpacked_align = MAX (rli->unpacked_align, CLASSTYPE_ALIGN (basetype)); 4399 TYPE_USER_ALIGN (rli->t) = 1; 4400 } 4401 4402 return atend; 4403} 4404 4405/* Layout the base given by BINFO in the class indicated by RLI. 4406 *BASE_ALIGN is a running maximum of the alignments of 4407 any base class. OFFSETS gives the location of empty base 4408 subobjects. T is the most derived type. Return nonzero if the new 4409 object cannot be nearly-empty. A new FIELD_DECL is inserted at 4410 *NEXT_FIELD, unless BINFO is for an empty base class. 4411 4412 Returns the location at which the next field should be inserted. */ 4413 4414static tree * 4415build_base_field (record_layout_info rli, tree binfo, 4416 splay_tree offsets, tree *next_field) 4417{ 4418 tree t = rli->t; 4419 tree basetype = BINFO_TYPE (binfo); 4420 4421 if (!COMPLETE_TYPE_P (basetype)) 4422 /* This error is now reported in xref_tag, thus giving better 4423 location information. */ 4424 return next_field; 4425 4426 /* Place the base class. */ 4427 if (!is_empty_class (basetype)) 4428 { 4429 tree decl; 4430 4431 /* The containing class is non-empty because it has a non-empty 4432 base class. */ 4433 CLASSTYPE_EMPTY_P (t) = 0; 4434 4435 /* Create the FIELD_DECL. */ 4436 decl = build_decl (input_location, 4437 FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype)); 4438 DECL_ARTIFICIAL (decl) = 1; 4439 DECL_IGNORED_P (decl) = 1; 4440 DECL_FIELD_CONTEXT (decl) = t; 4441 if (CLASSTYPE_AS_BASE (basetype)) 4442 { 4443 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype); 4444 DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype); 4445 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype); 4446 DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype); 4447 DECL_MODE (decl) = TYPE_MODE (basetype); 4448 DECL_FIELD_IS_BASE (decl) = 1; 4449 4450 /* Try to place the field. It may take more than one try if we 4451 have a hard time placing the field without putting two 4452 objects of the same type at the same address. */ 4453 layout_nonempty_base_or_field (rli, decl, binfo, offsets); 4454 /* Add the new FIELD_DECL to the list of fields for T. */ 4455 DECL_CHAIN (decl) = *next_field; 4456 *next_field = decl; 4457 next_field = &DECL_CHAIN (decl); 4458 } 4459 } 4460 else 4461 { 4462 tree eoc; 4463 bool atend; 4464 4465 /* On some platforms (ARM), even empty classes will not be 4466 byte-aligned. */ 4467 eoc = round_up_loc (input_location, 4468 rli_size_unit_so_far (rli), 4469 CLASSTYPE_ALIGN_UNIT (basetype)); 4470 atend = layout_empty_base (rli, binfo, eoc, offsets); 4471 /* A nearly-empty class "has no proper base class that is empty, 4472 not morally virtual, and at an offset other than zero." */ 4473 if (!BINFO_VIRTUAL_P (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t)) 4474 { 4475 if (atend) 4476 CLASSTYPE_NEARLY_EMPTY_P (t) = 0; 4477 /* The check above (used in G++ 3.2) is insufficient because 4478 an empty class placed at offset zero might itself have an 4479 empty base at a nonzero offset. */ 4480 else if (walk_subobject_offsets (basetype, 4481 empty_base_at_nonzero_offset_p, 4482 size_zero_node, 4483 /*offsets=*/NULL, 4484 /*max_offset=*/NULL_TREE, 4485 /*vbases_p=*/true)) 4486 CLASSTYPE_NEARLY_EMPTY_P (t) = 0; 4487 } 4488 4489 /* We do not create a FIELD_DECL for empty base classes because 4490 it might overlap some other field. We want to be able to 4491 create CONSTRUCTORs for the class by iterating over the 4492 FIELD_DECLs, and the back end does not handle overlapping 4493 FIELD_DECLs. */ 4494 4495 /* An empty virtual base causes a class to be non-empty 4496 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P 4497 here because that was already done when the virtual table 4498 pointer was created. */ 4499 } 4500 4501 /* Record the offsets of BINFO and its base subobjects. */ 4502 record_subobject_offsets (binfo, 4503 BINFO_OFFSET (binfo), 4504 offsets, 4505 /*is_data_member=*/false); 4506 4507 return next_field; 4508} 4509 4510/* Layout all of the non-virtual base classes. Record empty 4511 subobjects in OFFSETS. T is the most derived type. Return nonzero 4512 if the type cannot be nearly empty. The fields created 4513 corresponding to the base classes will be inserted at 4514 *NEXT_FIELD. */ 4515 4516static void 4517build_base_fields (record_layout_info rli, 4518 splay_tree offsets, tree *next_field) 4519{ 4520 /* Chain to hold all the new FIELD_DECLs which stand in for base class 4521 subobjects. */ 4522 tree t = rli->t; 4523 int n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (t)); 4524 int i; 4525 4526 /* The primary base class is always allocated first. */ 4527 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t)) 4528 next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t), 4529 offsets, next_field); 4530 4531 /* Now allocate the rest of the bases. */ 4532 for (i = 0; i < n_baseclasses; ++i) 4533 { 4534 tree base_binfo; 4535 4536 base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (t), i); 4537 4538 /* The primary base was already allocated above, so we don't 4539 need to allocate it again here. */ 4540 if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t)) 4541 continue; 4542 4543 /* Virtual bases are added at the end (a primary virtual base 4544 will have already been added). */ 4545 if (BINFO_VIRTUAL_P (base_binfo)) 4546 continue; 4547 4548 next_field = build_base_field (rli, base_binfo, 4549 offsets, next_field); 4550 } 4551} 4552 4553/* Go through the TYPE_METHODS of T issuing any appropriate 4554 diagnostics, figuring out which methods override which other 4555 methods, and so forth. */ 4556 4557static void 4558check_methods (tree t) 4559{ 4560 tree x; 4561 4562 for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x)) 4563 { 4564 check_for_override (x, t); 4565 if (DECL_PURE_VIRTUAL_P (x) && (TREE_CODE (x) != FUNCTION_DECL || ! DECL_VINDEX (x))) 4566 error ("initializer specified for non-virtual method %q+D", x); 4567 /* The name of the field is the original field name 4568 Save this in auxiliary field for later overloading. */ 4569 if (TREE_CODE (x) == FUNCTION_DECL && DECL_VINDEX (x)) 4570 { 4571 TYPE_POLYMORPHIC_P (t) = 1; 4572 if (DECL_PURE_VIRTUAL_P (x)) 4573 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t), x); 4574 } 4575 /* All user-provided destructors are non-trivial. 4576 Constructors and assignment ops are handled in 4577 grok_special_member_properties. */ 4578 if (DECL_DESTRUCTOR_P (x) && user_provided_p (x)) 4579 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = 1; 4580 } 4581} 4582 4583/* FN is a constructor or destructor. Clone the declaration to create 4584 a specialized in-charge or not-in-charge version, as indicated by 4585 NAME. */ 4586 4587static tree 4588build_clone (tree fn, tree name) 4589{ 4590 tree parms; 4591 tree clone; 4592 4593 /* Copy the function. */ 4594 clone = copy_decl (fn); 4595 /* Reset the function name. */ 4596 DECL_NAME (clone) = name; 4597 /* Remember where this function came from. */ 4598 DECL_ABSTRACT_ORIGIN (clone) = fn; 4599 /* Make it easy to find the CLONE given the FN. */ 4600 DECL_CHAIN (clone) = DECL_CHAIN (fn); 4601 DECL_CHAIN (fn) = clone; 4602 4603 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */ 4604 if (TREE_CODE (clone) == TEMPLATE_DECL) 4605 { 4606 tree result = build_clone (DECL_TEMPLATE_RESULT (clone), name); 4607 DECL_TEMPLATE_RESULT (clone) = result; 4608 DECL_TEMPLATE_INFO (result) = copy_node (DECL_TEMPLATE_INFO (result)); 4609 DECL_TI_TEMPLATE (result) = clone; 4610 TREE_TYPE (clone) = TREE_TYPE (result); 4611 return clone; 4612 } 4613 4614 SET_DECL_ASSEMBLER_NAME (clone, NULL_TREE); 4615 DECL_CLONED_FUNCTION (clone) = fn; 4616 /* There's no pending inline data for this function. */ 4617 DECL_PENDING_INLINE_INFO (clone) = NULL; 4618 DECL_PENDING_INLINE_P (clone) = 0; 4619 4620 /* The base-class destructor is not virtual. */ 4621 if (name == base_dtor_identifier) 4622 { 4623 DECL_VIRTUAL_P (clone) = 0; 4624 if (TREE_CODE (clone) != TEMPLATE_DECL) 4625 DECL_VINDEX (clone) = NULL_TREE; 4626 } 4627 4628 /* If there was an in-charge parameter, drop it from the function 4629 type. */ 4630 if (DECL_HAS_IN_CHARGE_PARM_P (clone)) 4631 { 4632 tree basetype; 4633 tree parmtypes; 4634 tree exceptions; 4635 4636 exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone)); 4637 basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone)); 4638 parmtypes = TYPE_ARG_TYPES (TREE_TYPE (clone)); 4639 /* Skip the `this' parameter. */ 4640 parmtypes = TREE_CHAIN (parmtypes); 4641 /* Skip the in-charge parameter. */ 4642 parmtypes = TREE_CHAIN (parmtypes); 4643 /* And the VTT parm, in a complete [cd]tor. */ 4644 if (DECL_HAS_VTT_PARM_P (fn) 4645 && ! DECL_NEEDS_VTT_PARM_P (clone)) 4646 parmtypes = TREE_CHAIN (parmtypes); 4647 /* If this is subobject constructor or destructor, add the vtt 4648 parameter. */ 4649 TREE_TYPE (clone) 4650 = build_method_type_directly (basetype, 4651 TREE_TYPE (TREE_TYPE (clone)), 4652 parmtypes); 4653 if (exceptions) 4654 TREE_TYPE (clone) = build_exception_variant (TREE_TYPE (clone), 4655 exceptions); 4656 TREE_TYPE (clone) 4657 = cp_build_type_attribute_variant (TREE_TYPE (clone), 4658 TYPE_ATTRIBUTES (TREE_TYPE (fn))); 4659 } 4660 4661 /* Copy the function parameters. */ 4662 DECL_ARGUMENTS (clone) = copy_list (DECL_ARGUMENTS (clone)); 4663 /* Remove the in-charge parameter. */ 4664 if (DECL_HAS_IN_CHARGE_PARM_P (clone)) 4665 { 4666 DECL_CHAIN (DECL_ARGUMENTS (clone)) 4667 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone))); 4668 DECL_HAS_IN_CHARGE_PARM_P (clone) = 0; 4669 } 4670 /* And the VTT parm, in a complete [cd]tor. */ 4671 if (DECL_HAS_VTT_PARM_P (fn)) 4672 { 4673 if (DECL_NEEDS_VTT_PARM_P (clone)) 4674 DECL_HAS_VTT_PARM_P (clone) = 1; 4675 else 4676 { 4677 DECL_CHAIN (DECL_ARGUMENTS (clone)) 4678 = DECL_CHAIN (DECL_CHAIN (DECL_ARGUMENTS (clone))); 4679 DECL_HAS_VTT_PARM_P (clone) = 0; 4680 } 4681 } 4682 4683 for (parms = DECL_ARGUMENTS (clone); parms; parms = DECL_CHAIN (parms)) 4684 { 4685 DECL_CONTEXT (parms) = clone; 4686 cxx_dup_lang_specific_decl (parms); 4687 } 4688 4689 /* Create the RTL for this function. */ 4690 SET_DECL_RTL (clone, NULL); 4691 rest_of_decl_compilation (clone, /*top_level=*/1, at_eof); 4692 4693 if (pch_file) 4694 note_decl_for_pch (clone); 4695 4696 return clone; 4697} 4698 4699/* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do 4700 not invoke this function directly. 4701 4702 For a non-thunk function, returns the address of the slot for storing 4703 the function it is a clone of. Otherwise returns NULL_TREE. 4704 4705 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if 4706 cloned_function is unset. This is to support the separate 4707 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter 4708 on a template makes sense, but not the former. */ 4709 4710tree * 4711decl_cloned_function_p (const_tree decl, bool just_testing) 4712{ 4713 tree *ptr; 4714 if (just_testing) 4715 decl = STRIP_TEMPLATE (decl); 4716 4717 if (TREE_CODE (decl) != FUNCTION_DECL 4718 || !DECL_LANG_SPECIFIC (decl) 4719 || DECL_LANG_SPECIFIC (decl)->u.fn.thunk_p) 4720 { 4721#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 4722 if (!just_testing) 4723 lang_check_failed (__FILE__, __LINE__, __FUNCTION__); 4724 else 4725#endif 4726 return NULL; 4727 } 4728 4729 ptr = &DECL_LANG_SPECIFIC (decl)->u.fn.u5.cloned_function; 4730 if (just_testing && *ptr == NULL_TREE) 4731 return NULL; 4732 else 4733 return ptr; 4734} 4735 4736/* Produce declarations for all appropriate clones of FN. If 4737 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the 4738 CLASTYPE_METHOD_VEC as well. */ 4739 4740void 4741clone_function_decl (tree fn, int update_method_vec_p) 4742{ 4743 tree clone; 4744 4745 /* Avoid inappropriate cloning. */ 4746 if (DECL_CHAIN (fn) 4747 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (fn))) 4748 return; 4749 4750 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)) 4751 { 4752 /* For each constructor, we need two variants: an in-charge version 4753 and a not-in-charge version. */ 4754 clone = build_clone (fn, complete_ctor_identifier); 4755 if (update_method_vec_p) 4756 add_method (DECL_CONTEXT (clone), clone, NULL_TREE); 4757 clone = build_clone (fn, base_ctor_identifier); 4758 if (update_method_vec_p) 4759 add_method (DECL_CONTEXT (clone), clone, NULL_TREE); 4760 } 4761 else 4762 { 4763 gcc_assert (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)); 4764 4765 /* For each destructor, we need three variants: an in-charge 4766 version, a not-in-charge version, and an in-charge deleting 4767 version. We clone the deleting version first because that 4768 means it will go second on the TYPE_METHODS list -- and that 4769 corresponds to the correct layout order in the virtual 4770 function table. 4771 4772 For a non-virtual destructor, we do not build a deleting 4773 destructor. */ 4774 if (DECL_VIRTUAL_P (fn)) 4775 { 4776 clone = build_clone (fn, deleting_dtor_identifier); 4777 if (update_method_vec_p) 4778 add_method (DECL_CONTEXT (clone), clone, NULL_TREE); 4779 } 4780 clone = build_clone (fn, complete_dtor_identifier); 4781 if (update_method_vec_p) 4782 add_method (DECL_CONTEXT (clone), clone, NULL_TREE); 4783 clone = build_clone (fn, base_dtor_identifier); 4784 if (update_method_vec_p) 4785 add_method (DECL_CONTEXT (clone), clone, NULL_TREE); 4786 } 4787 4788 /* Note that this is an abstract function that is never emitted. */ 4789 DECL_ABSTRACT_P (fn) = true; 4790} 4791 4792/* DECL is an in charge constructor, which is being defined. This will 4793 have had an in class declaration, from whence clones were 4794 declared. An out-of-class definition can specify additional default 4795 arguments. As it is the clones that are involved in overload 4796 resolution, we must propagate the information from the DECL to its 4797 clones. */ 4798 4799void 4800adjust_clone_args (tree decl) 4801{ 4802 tree clone; 4803 4804 for (clone = DECL_CHAIN (decl); clone && DECL_CLONED_FUNCTION_P (clone); 4805 clone = DECL_CHAIN (clone)) 4806 { 4807 tree orig_clone_parms = TYPE_ARG_TYPES (TREE_TYPE (clone)); 4808 tree orig_decl_parms = TYPE_ARG_TYPES (TREE_TYPE (decl)); 4809 tree decl_parms, clone_parms; 4810 4811 clone_parms = orig_clone_parms; 4812 4813 /* Skip the 'this' parameter. */ 4814 orig_clone_parms = TREE_CHAIN (orig_clone_parms); 4815 orig_decl_parms = TREE_CHAIN (orig_decl_parms); 4816 4817 if (DECL_HAS_IN_CHARGE_PARM_P (decl)) 4818 orig_decl_parms = TREE_CHAIN (orig_decl_parms); 4819 if (DECL_HAS_VTT_PARM_P (decl)) 4820 orig_decl_parms = TREE_CHAIN (orig_decl_parms); 4821 4822 clone_parms = orig_clone_parms; 4823 if (DECL_HAS_VTT_PARM_P (clone)) 4824 clone_parms = TREE_CHAIN (clone_parms); 4825 4826 for (decl_parms = orig_decl_parms; decl_parms; 4827 decl_parms = TREE_CHAIN (decl_parms), 4828 clone_parms = TREE_CHAIN (clone_parms)) 4829 { 4830 gcc_assert (same_type_p (TREE_TYPE (decl_parms), 4831 TREE_TYPE (clone_parms))); 4832 4833 if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms)) 4834 { 4835 /* A default parameter has been added. Adjust the 4836 clone's parameters. */ 4837 tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone)); 4838 tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (clone)); 4839 tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone)); 4840 tree type; 4841 4842 clone_parms = orig_decl_parms; 4843 4844 if (DECL_HAS_VTT_PARM_P (clone)) 4845 { 4846 clone_parms = tree_cons (TREE_PURPOSE (orig_clone_parms), 4847 TREE_VALUE (orig_clone_parms), 4848 clone_parms); 4849 TREE_TYPE (clone_parms) = TREE_TYPE (orig_clone_parms); 4850 } 4851 type = build_method_type_directly (basetype, 4852 TREE_TYPE (TREE_TYPE (clone)), 4853 clone_parms); 4854 if (exceptions) 4855 type = build_exception_variant (type, exceptions); 4856 if (attrs) 4857 type = cp_build_type_attribute_variant (type, attrs); 4858 TREE_TYPE (clone) = type; 4859 4860 clone_parms = NULL_TREE; 4861 break; 4862 } 4863 } 4864 gcc_assert (!clone_parms); 4865 } 4866} 4867 4868/* For each of the constructors and destructors in T, create an 4869 in-charge and not-in-charge variant. */ 4870 4871static void 4872clone_constructors_and_destructors (tree t) 4873{ 4874 tree fns; 4875 4876 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail 4877 out now. */ 4878 if (!CLASSTYPE_METHOD_VEC (t)) 4879 return; 4880 4881 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 4882 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1); 4883 for (fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 4884 clone_function_decl (OVL_CURRENT (fns), /*update_method_vec_p=*/1); 4885} 4886 4887/* Deduce noexcept for a destructor DTOR. */ 4888 4889void 4890deduce_noexcept_on_destructor (tree dtor) 4891{ 4892 if (!TYPE_RAISES_EXCEPTIONS (TREE_TYPE (dtor))) 4893 { 4894 tree eh_spec = unevaluated_noexcept_spec (); 4895 TREE_TYPE (dtor) = build_exception_variant (TREE_TYPE (dtor), eh_spec); 4896 } 4897} 4898 4899/* For each destructor in T, deduce noexcept: 4900 4901 12.4/3: A declaration of a destructor that does not have an 4902 exception-specification is implicitly considered to have the 4903 same exception-specification as an implicit declaration (15.4). */ 4904 4905static void 4906deduce_noexcept_on_destructors (tree t) 4907{ 4908 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail 4909 out now. */ 4910 if (!CLASSTYPE_METHOD_VEC (t)) 4911 return; 4912 4913 for (tree fns = CLASSTYPE_DESTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 4914 deduce_noexcept_on_destructor (OVL_CURRENT (fns)); 4915} 4916 4917/* Subroutine of set_one_vmethod_tm_attributes. Search base classes 4918 of TYPE for virtual functions which FNDECL overrides. Return a 4919 mask of the tm attributes found therein. */ 4920 4921static int 4922look_for_tm_attr_overrides (tree type, tree fndecl) 4923{ 4924 tree binfo = TYPE_BINFO (type); 4925 tree base_binfo; 4926 int ix, found = 0; 4927 4928 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ++ix) 4929 { 4930 tree o, basetype = BINFO_TYPE (base_binfo); 4931 4932 if (!TYPE_POLYMORPHIC_P (basetype)) 4933 continue; 4934 4935 o = look_for_overrides_here (basetype, fndecl); 4936 if (o) 4937 found |= tm_attr_to_mask (find_tm_attribute 4938 (TYPE_ATTRIBUTES (TREE_TYPE (o)))); 4939 else 4940 found |= look_for_tm_attr_overrides (basetype, fndecl); 4941 } 4942 4943 return found; 4944} 4945 4946/* Subroutine of set_method_tm_attributes. Handle the checks and 4947 inheritance for one virtual method FNDECL. */ 4948 4949static void 4950set_one_vmethod_tm_attributes (tree type, tree fndecl) 4951{ 4952 tree tm_attr; 4953 int found, have; 4954 4955 found = look_for_tm_attr_overrides (type, fndecl); 4956 4957 /* If FNDECL doesn't actually override anything (i.e. T is the 4958 class that first declares FNDECL virtual), then we're done. */ 4959 if (found == 0) 4960 return; 4961 4962 tm_attr = find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl))); 4963 have = tm_attr_to_mask (tm_attr); 4964 4965 /* Intel STM Language Extension 3.0, Section 4.2 table 4: 4966 tm_pure must match exactly, otherwise no weakening of 4967 tm_safe > tm_callable > nothing. */ 4968 /* ??? The tm_pure attribute didn't make the transition to the 4969 multivendor language spec. */ 4970 if (have == TM_ATTR_PURE) 4971 { 4972 if (found != TM_ATTR_PURE) 4973 { 4974 found &= -found; 4975 goto err_override; 4976 } 4977 } 4978 /* If the overridden function is tm_pure, then FNDECL must be. */ 4979 else if (found == TM_ATTR_PURE && tm_attr) 4980 goto err_override; 4981 /* Look for base class combinations that cannot be satisfied. */ 4982 else if (found != TM_ATTR_PURE && (found & TM_ATTR_PURE)) 4983 { 4984 found &= ~TM_ATTR_PURE; 4985 found &= -found; 4986 error_at (DECL_SOURCE_LOCATION (fndecl), 4987 "method overrides both %<transaction_pure%> and %qE methods", 4988 tm_mask_to_attr (found)); 4989 } 4990 /* If FNDECL did not declare an attribute, then inherit the most 4991 restrictive one. */ 4992 else if (tm_attr == NULL) 4993 { 4994 apply_tm_attr (fndecl, tm_mask_to_attr (found & -found)); 4995 } 4996 /* Otherwise validate that we're not weaker than a function 4997 that is being overridden. */ 4998 else 4999 { 5000 found &= -found; 5001 if (found <= TM_ATTR_CALLABLE && have > found) 5002 goto err_override; 5003 } 5004 return; 5005 5006 err_override: 5007 error_at (DECL_SOURCE_LOCATION (fndecl), 5008 "method declared %qE overriding %qE method", 5009 tm_attr, tm_mask_to_attr (found)); 5010} 5011 5012/* For each of the methods in T, propagate a class-level tm attribute. */ 5013 5014static void 5015set_method_tm_attributes (tree t) 5016{ 5017 tree class_tm_attr, fndecl; 5018 5019 /* Don't bother collecting tm attributes if transactional memory 5020 support is not enabled. */ 5021 if (!flag_tm) 5022 return; 5023 5024 /* Process virtual methods first, as they inherit directly from the 5025 base virtual function and also require validation of new attributes. */ 5026 if (TYPE_CONTAINS_VPTR_P (t)) 5027 { 5028 tree vchain; 5029 for (vchain = BINFO_VIRTUALS (TYPE_BINFO (t)); vchain; 5030 vchain = TREE_CHAIN (vchain)) 5031 { 5032 fndecl = BV_FN (vchain); 5033 if (DECL_THUNK_P (fndecl)) 5034 fndecl = THUNK_TARGET (fndecl); 5035 set_one_vmethod_tm_attributes (t, fndecl); 5036 } 5037 } 5038 5039 /* If the class doesn't have an attribute, nothing more to do. */ 5040 class_tm_attr = find_tm_attribute (TYPE_ATTRIBUTES (t)); 5041 if (class_tm_attr == NULL) 5042 return; 5043 5044 /* Any method that does not yet have a tm attribute inherits 5045 the one from the class. */ 5046 for (fndecl = TYPE_METHODS (t); fndecl; fndecl = TREE_CHAIN (fndecl)) 5047 { 5048 if (!find_tm_attribute (TYPE_ATTRIBUTES (TREE_TYPE (fndecl)))) 5049 apply_tm_attr (fndecl, class_tm_attr); 5050 } 5051} 5052 5053/* Returns true iff class T has a user-defined constructor other than 5054 the default constructor. */ 5055 5056bool 5057type_has_user_nondefault_constructor (tree t) 5058{ 5059 tree fns; 5060 5061 if (!TYPE_HAS_USER_CONSTRUCTOR (t)) 5062 return false; 5063 5064 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 5065 { 5066 tree fn = OVL_CURRENT (fns); 5067 if (!DECL_ARTIFICIAL (fn) 5068 && (TREE_CODE (fn) == TEMPLATE_DECL 5069 || (skip_artificial_parms_for (fn, DECL_ARGUMENTS (fn)) 5070 != NULL_TREE))) 5071 return true; 5072 } 5073 5074 return false; 5075} 5076 5077/* Returns the defaulted constructor if T has one. Otherwise, returns 5078 NULL_TREE. */ 5079 5080tree 5081in_class_defaulted_default_constructor (tree t) 5082{ 5083 tree fns, args; 5084 5085 if (!TYPE_HAS_USER_CONSTRUCTOR (t)) 5086 return NULL_TREE; 5087 5088 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 5089 { 5090 tree fn = OVL_CURRENT (fns); 5091 5092 if (DECL_DEFAULTED_IN_CLASS_P (fn)) 5093 { 5094 args = FUNCTION_FIRST_USER_PARMTYPE (fn); 5095 while (args && TREE_PURPOSE (args)) 5096 args = TREE_CHAIN (args); 5097 if (!args || args == void_list_node) 5098 return fn; 5099 } 5100 } 5101 5102 return NULL_TREE; 5103} 5104 5105/* Returns true iff FN is a user-provided function, i.e. user-declared 5106 and not defaulted at its first declaration; or explicit, private, 5107 protected, or non-const. */ 5108 5109bool 5110user_provided_p (tree fn) 5111{ 5112 if (TREE_CODE (fn) == TEMPLATE_DECL) 5113 return true; 5114 else 5115 return (!DECL_ARTIFICIAL (fn) 5116 && !(DECL_INITIALIZED_IN_CLASS_P (fn) 5117 && (DECL_DEFAULTED_FN (fn) || DECL_DELETED_FN (fn)))); 5118} 5119 5120/* Returns true iff class T has a user-provided constructor. */ 5121 5122bool 5123type_has_user_provided_constructor (tree t) 5124{ 5125 tree fns; 5126 5127 if (!CLASS_TYPE_P (t)) 5128 return false; 5129 5130 if (!TYPE_HAS_USER_CONSTRUCTOR (t)) 5131 return false; 5132 5133 /* This can happen in error cases; avoid crashing. */ 5134 if (!CLASSTYPE_METHOD_VEC (t)) 5135 return false; 5136 5137 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 5138 if (user_provided_p (OVL_CURRENT (fns))) 5139 return true; 5140 5141 return false; 5142} 5143 5144/* Returns true iff class T has a non-user-provided (i.e. implicitly 5145 declared or explicitly defaulted in the class body) default 5146 constructor. */ 5147 5148bool 5149type_has_non_user_provided_default_constructor (tree t) 5150{ 5151 tree fns; 5152 5153 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (t)) 5154 return false; 5155 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t)) 5156 return true; 5157 5158 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 5159 { 5160 tree fn = OVL_CURRENT (fns); 5161 if (TREE_CODE (fn) == FUNCTION_DECL 5162 && !user_provided_p (fn) 5163 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn))) 5164 return true; 5165 } 5166 5167 return false; 5168} 5169 5170/* TYPE is being used as a virtual base, and has a non-trivial move 5171 assignment. Return true if this is due to there being a user-provided 5172 move assignment in TYPE or one of its subobjects; if there isn't, then 5173 multiple move assignment can't cause any harm. */ 5174 5175bool 5176vbase_has_user_provided_move_assign (tree type) 5177{ 5178 /* Does the type itself have a user-provided move assignment operator? */ 5179 for (tree fns 5180 = lookup_fnfields_slot_nolazy (type, ansi_assopname (NOP_EXPR)); 5181 fns; fns = OVL_NEXT (fns)) 5182 { 5183 tree fn = OVL_CURRENT (fns); 5184 if (move_fn_p (fn) && user_provided_p (fn)) 5185 return true; 5186 } 5187 5188 /* Do any of its bases? */ 5189 tree binfo = TYPE_BINFO (type); 5190 tree base_binfo; 5191 for (int i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 5192 if (vbase_has_user_provided_move_assign (BINFO_TYPE (base_binfo))) 5193 return true; 5194 5195 /* Or non-static data members? */ 5196 for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 5197 { 5198 if (TREE_CODE (field) == FIELD_DECL 5199 && CLASS_TYPE_P (TREE_TYPE (field)) 5200 && vbase_has_user_provided_move_assign (TREE_TYPE (field))) 5201 return true; 5202 } 5203 5204 /* Seems not. */ 5205 return false; 5206} 5207 5208/* If default-initialization leaves part of TYPE uninitialized, returns 5209 a DECL for the field or TYPE itself (DR 253). */ 5210 5211tree 5212default_init_uninitialized_part (tree type) 5213{ 5214 tree t, r, binfo; 5215 int i; 5216 5217 type = strip_array_types (type); 5218 if (!CLASS_TYPE_P (type)) 5219 return type; 5220 if (!type_has_non_user_provided_default_constructor (type)) 5221 return NULL_TREE; 5222 for (binfo = TYPE_BINFO (type), i = 0; 5223 BINFO_BASE_ITERATE (binfo, i, t); ++i) 5224 { 5225 r = default_init_uninitialized_part (BINFO_TYPE (t)); 5226 if (r) 5227 return r; 5228 } 5229 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t)) 5230 if (TREE_CODE (t) == FIELD_DECL 5231 && !DECL_ARTIFICIAL (t) 5232 && !DECL_INITIAL (t)) 5233 { 5234 r = default_init_uninitialized_part (TREE_TYPE (t)); 5235 if (r) 5236 return DECL_P (r) ? r : t; 5237 } 5238 5239 return NULL_TREE; 5240} 5241 5242/* Returns true iff for class T, a trivial synthesized default constructor 5243 would be constexpr. */ 5244 5245bool 5246trivial_default_constructor_is_constexpr (tree t) 5247{ 5248 /* A defaulted trivial default constructor is constexpr 5249 if there is nothing to initialize. */ 5250 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (t)); 5251 return is_really_empty_class (t); 5252} 5253 5254/* Returns true iff class T has a constexpr default constructor. */ 5255 5256bool 5257type_has_constexpr_default_constructor (tree t) 5258{ 5259 tree fns; 5260 5261 if (!CLASS_TYPE_P (t)) 5262 { 5263 /* The caller should have stripped an enclosing array. */ 5264 gcc_assert (TREE_CODE (t) != ARRAY_TYPE); 5265 return false; 5266 } 5267 if (CLASSTYPE_LAZY_DEFAULT_CTOR (t)) 5268 { 5269 if (!TYPE_HAS_COMPLEX_DFLT (t)) 5270 return trivial_default_constructor_is_constexpr (t); 5271 /* Non-trivial, we need to check subobject constructors. */ 5272 lazily_declare_fn (sfk_constructor, t); 5273 } 5274 fns = locate_ctor (t); 5275 return (fns && DECL_DECLARED_CONSTEXPR_P (fns)); 5276} 5277 5278/* Returns true iff class TYPE has a virtual destructor. */ 5279 5280bool 5281type_has_virtual_destructor (tree type) 5282{ 5283 tree dtor; 5284 5285 if (!CLASS_TYPE_P (type)) 5286 return false; 5287 5288 gcc_assert (COMPLETE_TYPE_P (type)); 5289 dtor = CLASSTYPE_DESTRUCTORS (type); 5290 return (dtor && DECL_VIRTUAL_P (dtor)); 5291} 5292 5293/* Returns true iff class T has a move constructor. */ 5294 5295bool 5296type_has_move_constructor (tree t) 5297{ 5298 tree fns; 5299 5300 if (CLASSTYPE_LAZY_MOVE_CTOR (t)) 5301 { 5302 gcc_assert (COMPLETE_TYPE_P (t)); 5303 lazily_declare_fn (sfk_move_constructor, t); 5304 } 5305 5306 if (!CLASSTYPE_METHOD_VEC (t)) 5307 return false; 5308 5309 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 5310 if (move_fn_p (OVL_CURRENT (fns))) 5311 return true; 5312 5313 return false; 5314} 5315 5316/* Returns true iff class T has a move assignment operator. */ 5317 5318bool 5319type_has_move_assign (tree t) 5320{ 5321 tree fns; 5322 5323 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t)) 5324 { 5325 gcc_assert (COMPLETE_TYPE_P (t)); 5326 lazily_declare_fn (sfk_move_assignment, t); 5327 } 5328 5329 for (fns = lookup_fnfields_slot_nolazy (t, ansi_assopname (NOP_EXPR)); 5330 fns; fns = OVL_NEXT (fns)) 5331 if (move_fn_p (OVL_CURRENT (fns))) 5332 return true; 5333 5334 return false; 5335} 5336 5337/* Returns true iff class T has a move constructor that was explicitly 5338 declared in the class body. Note that this is different from 5339 "user-provided", which doesn't include functions that are defaulted in 5340 the class. */ 5341 5342bool 5343type_has_user_declared_move_constructor (tree t) 5344{ 5345 tree fns; 5346 5347 if (CLASSTYPE_LAZY_MOVE_CTOR (t)) 5348 return false; 5349 5350 if (!CLASSTYPE_METHOD_VEC (t)) 5351 return false; 5352 5353 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 5354 { 5355 tree fn = OVL_CURRENT (fns); 5356 if (move_fn_p (fn) && !DECL_ARTIFICIAL (fn)) 5357 return true; 5358 } 5359 5360 return false; 5361} 5362 5363/* Returns true iff class T has a move assignment operator that was 5364 explicitly declared in the class body. */ 5365 5366bool 5367type_has_user_declared_move_assign (tree t) 5368{ 5369 tree fns; 5370 5371 if (CLASSTYPE_LAZY_MOVE_ASSIGN (t)) 5372 return false; 5373 5374 for (fns = lookup_fnfields_slot_nolazy (t, ansi_assopname (NOP_EXPR)); 5375 fns; fns = OVL_NEXT (fns)) 5376 { 5377 tree fn = OVL_CURRENT (fns); 5378 if (move_fn_p (fn) && !DECL_ARTIFICIAL (fn)) 5379 return true; 5380 } 5381 5382 return false; 5383} 5384 5385/* Nonzero if we need to build up a constructor call when initializing an 5386 object of this class, either because it has a user-declared constructor 5387 or because it doesn't have a default constructor (so we need to give an 5388 error if no initializer is provided). Use TYPE_NEEDS_CONSTRUCTING when 5389 what you care about is whether or not an object can be produced by a 5390 constructor (e.g. so we don't set TREE_READONLY on const variables of 5391 such type); use this function when what you care about is whether or not 5392 to try to call a constructor to create an object. The latter case is 5393 the former plus some cases of constructors that cannot be called. */ 5394 5395bool 5396type_build_ctor_call (tree t) 5397{ 5398 tree inner; 5399 if (TYPE_NEEDS_CONSTRUCTING (t)) 5400 return true; 5401 inner = strip_array_types (t); 5402 if (!CLASS_TYPE_P (inner) || ANON_AGGR_TYPE_P (inner)) 5403 return false; 5404 if (!TYPE_HAS_DEFAULT_CONSTRUCTOR (inner)) 5405 return true; 5406 if (cxx_dialect < cxx11) 5407 return false; 5408 /* A user-declared constructor might be private, and a constructor might 5409 be trivial but deleted. */ 5410 for (tree fns = lookup_fnfields_slot (inner, complete_ctor_identifier); 5411 fns; fns = OVL_NEXT (fns)) 5412 { 5413 tree fn = OVL_CURRENT (fns); 5414 if (!DECL_ARTIFICIAL (fn) 5415 || DECL_DELETED_FN (fn)) 5416 return true; 5417 } 5418 return false; 5419} 5420 5421/* Like type_build_ctor_call, but for destructors. */ 5422 5423bool 5424type_build_dtor_call (tree t) 5425{ 5426 tree inner; 5427 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)) 5428 return true; 5429 inner = strip_array_types (t); 5430 if (!CLASS_TYPE_P (inner) || ANON_AGGR_TYPE_P (inner) 5431 || !COMPLETE_TYPE_P (inner)) 5432 return false; 5433 if (cxx_dialect < cxx11) 5434 return false; 5435 /* A user-declared destructor might be private, and a destructor might 5436 be trivial but deleted. */ 5437 for (tree fns = lookup_fnfields_slot (inner, complete_dtor_identifier); 5438 fns; fns = OVL_NEXT (fns)) 5439 { 5440 tree fn = OVL_CURRENT (fns); 5441 if (!DECL_ARTIFICIAL (fn) 5442 || DECL_DELETED_FN (fn)) 5443 return true; 5444 } 5445 return false; 5446} 5447 5448/* Remove all zero-width bit-fields from T. */ 5449 5450static void 5451remove_zero_width_bit_fields (tree t) 5452{ 5453 tree *fieldsp; 5454 5455 fieldsp = &TYPE_FIELDS (t); 5456 while (*fieldsp) 5457 { 5458 if (TREE_CODE (*fieldsp) == FIELD_DECL 5459 && DECL_C_BIT_FIELD (*fieldsp) 5460 /* We should not be confused by the fact that grokbitfield 5461 temporarily sets the width of the bit field into 5462 DECL_INITIAL (*fieldsp). 5463 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp) 5464 to that width. */ 5465 && (DECL_SIZE (*fieldsp) == NULL_TREE 5466 || integer_zerop (DECL_SIZE (*fieldsp)))) 5467 *fieldsp = DECL_CHAIN (*fieldsp); 5468 else 5469 fieldsp = &DECL_CHAIN (*fieldsp); 5470 } 5471} 5472 5473/* Returns TRUE iff we need a cookie when dynamically allocating an 5474 array whose elements have the indicated class TYPE. */ 5475 5476static bool 5477type_requires_array_cookie (tree type) 5478{ 5479 tree fns; 5480 bool has_two_argument_delete_p = false; 5481 5482 gcc_assert (CLASS_TYPE_P (type)); 5483 5484 /* If there's a non-trivial destructor, we need a cookie. In order 5485 to iterate through the array calling the destructor for each 5486 element, we'll have to know how many elements there are. */ 5487 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 5488 return true; 5489 5490 /* If the usual deallocation function is a two-argument whose second 5491 argument is of type `size_t', then we have to pass the size of 5492 the array to the deallocation function, so we will need to store 5493 a cookie. */ 5494 fns = lookup_fnfields (TYPE_BINFO (type), 5495 ansi_opname (VEC_DELETE_EXPR), 5496 /*protect=*/0); 5497 /* If there are no `operator []' members, or the lookup is 5498 ambiguous, then we don't need a cookie. */ 5499 if (!fns || fns == error_mark_node) 5500 return false; 5501 /* Loop through all of the functions. */ 5502 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns)) 5503 { 5504 tree fn; 5505 tree second_parm; 5506 5507 /* Select the current function. */ 5508 fn = OVL_CURRENT (fns); 5509 /* See if this function is a one-argument delete function. If 5510 it is, then it will be the usual deallocation function. */ 5511 second_parm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn))); 5512 if (second_parm == void_list_node) 5513 return false; 5514 /* Do not consider this function if its second argument is an 5515 ellipsis. */ 5516 if (!second_parm) 5517 continue; 5518 /* Otherwise, if we have a two-argument function and the second 5519 argument is `size_t', it will be the usual deallocation 5520 function -- unless there is one-argument function, too. */ 5521 if (TREE_CHAIN (second_parm) == void_list_node 5522 && same_type_p (TREE_VALUE (second_parm), size_type_node)) 5523 has_two_argument_delete_p = true; 5524 } 5525 5526 return has_two_argument_delete_p; 5527} 5528 5529/* Finish computing the `literal type' property of class type T. 5530 5531 At this point, we have already processed base classes and 5532 non-static data members. We need to check whether the copy 5533 constructor is trivial, the destructor is trivial, and there 5534 is a trivial default constructor or at least one constexpr 5535 constructor other than the copy constructor. */ 5536 5537static void 5538finalize_literal_type_property (tree t) 5539{ 5540 tree fn; 5541 5542 if (cxx_dialect < cxx11 5543 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)) 5544 CLASSTYPE_LITERAL_P (t) = false; 5545 else if (CLASSTYPE_LITERAL_P (t) && !TYPE_HAS_TRIVIAL_DFLT (t) 5546 && CLASSTYPE_NON_AGGREGATE (t) 5547 && !TYPE_HAS_CONSTEXPR_CTOR (t)) 5548 CLASSTYPE_LITERAL_P (t) = false; 5549 5550 if (!CLASSTYPE_LITERAL_P (t)) 5551 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn)) 5552 if (DECL_DECLARED_CONSTEXPR_P (fn) 5553 && TREE_CODE (fn) != TEMPLATE_DECL 5554 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) 5555 && !DECL_CONSTRUCTOR_P (fn)) 5556 { 5557 DECL_DECLARED_CONSTEXPR_P (fn) = false; 5558 if (!DECL_GENERATED_P (fn)) 5559 { 5560 error ("enclosing class of constexpr non-static member " 5561 "function %q+#D is not a literal type", fn); 5562 explain_non_literal_class (t); 5563 } 5564 } 5565} 5566 5567/* T is a non-literal type used in a context which requires a constant 5568 expression. Explain why it isn't literal. */ 5569 5570void 5571explain_non_literal_class (tree t) 5572{ 5573 static hash_set<tree> *diagnosed; 5574 5575 if (!CLASS_TYPE_P (t)) 5576 return; 5577 t = TYPE_MAIN_VARIANT (t); 5578 5579 if (diagnosed == NULL) 5580 diagnosed = new hash_set<tree>; 5581 if (diagnosed->add (t)) 5582 /* Already explained. */ 5583 return; 5584 5585 inform (0, "%q+T is not literal because:", t); 5586 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)) 5587 inform (0, " %q+T has a non-trivial destructor", t); 5588 else if (CLASSTYPE_NON_AGGREGATE (t) 5589 && !TYPE_HAS_TRIVIAL_DFLT (t) 5590 && !TYPE_HAS_CONSTEXPR_CTOR (t)) 5591 { 5592 inform (0, " %q+T is not an aggregate, does not have a trivial " 5593 "default constructor, and has no constexpr constructor that " 5594 "is not a copy or move constructor", t); 5595 if (type_has_non_user_provided_default_constructor (t)) 5596 { 5597 /* Note that we can't simply call locate_ctor because when the 5598 constructor is deleted it just returns NULL_TREE. */ 5599 tree fns; 5600 for (fns = CLASSTYPE_CONSTRUCTORS (t); fns; fns = OVL_NEXT (fns)) 5601 { 5602 tree fn = OVL_CURRENT (fns); 5603 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 5604 5605 parms = skip_artificial_parms_for (fn, parms); 5606 5607 if (sufficient_parms_p (parms)) 5608 { 5609 if (DECL_DELETED_FN (fn)) 5610 maybe_explain_implicit_delete (fn); 5611 else 5612 explain_invalid_constexpr_fn (fn); 5613 break; 5614 } 5615 } 5616 } 5617 } 5618 else 5619 { 5620 tree binfo, base_binfo, field; int i; 5621 for (binfo = TYPE_BINFO (t), i = 0; 5622 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 5623 { 5624 tree basetype = TREE_TYPE (base_binfo); 5625 if (!CLASSTYPE_LITERAL_P (basetype)) 5626 { 5627 inform (0, " base class %qT of %q+T is non-literal", 5628 basetype, t); 5629 explain_non_literal_class (basetype); 5630 return; 5631 } 5632 } 5633 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) 5634 { 5635 tree ftype; 5636 if (TREE_CODE (field) != FIELD_DECL) 5637 continue; 5638 ftype = TREE_TYPE (field); 5639 if (!literal_type_p (ftype)) 5640 { 5641 inform (0, " non-static data member %q+D has " 5642 "non-literal type", field); 5643 if (CLASS_TYPE_P (ftype)) 5644 explain_non_literal_class (ftype); 5645 } 5646 if (CP_TYPE_VOLATILE_P (ftype)) 5647 inform (0, " non-static data member %q+D has " 5648 "volatile type", field); 5649 } 5650 } 5651} 5652 5653/* Check the validity of the bases and members declared in T. Add any 5654 implicitly-generated functions (like copy-constructors and 5655 assignment operators). Compute various flag bits (like 5656 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++ 5657 level: i.e., independently of the ABI in use. */ 5658 5659static void 5660check_bases_and_members (tree t) 5661{ 5662 /* Nonzero if the implicitly generated copy constructor should take 5663 a non-const reference argument. */ 5664 int cant_have_const_ctor; 5665 /* Nonzero if the implicitly generated assignment operator 5666 should take a non-const reference argument. */ 5667 int no_const_asn_ref; 5668 tree access_decls; 5669 bool saved_complex_asn_ref; 5670 bool saved_nontrivial_dtor; 5671 tree fn; 5672 5673 /* By default, we use const reference arguments and generate default 5674 constructors. */ 5675 cant_have_const_ctor = 0; 5676 no_const_asn_ref = 0; 5677 5678 /* Check all the base-classes. */ 5679 check_bases (t, &cant_have_const_ctor, 5680 &no_const_asn_ref); 5681 5682 /* Deduce noexcept on destructors. This needs to happen after we've set 5683 triviality flags appropriately for our bases. */ 5684 if (cxx_dialect >= cxx11) 5685 deduce_noexcept_on_destructors (t); 5686 5687 /* Check all the method declarations. */ 5688 check_methods (t); 5689 5690 /* Save the initial values of these flags which only indicate whether 5691 or not the class has user-provided functions. As we analyze the 5692 bases and members we can set these flags for other reasons. */ 5693 saved_complex_asn_ref = TYPE_HAS_COMPLEX_COPY_ASSIGN (t); 5694 saved_nontrivial_dtor = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t); 5695 5696 /* Check all the data member declarations. We cannot call 5697 check_field_decls until we have called check_bases check_methods, 5698 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR 5699 being set appropriately. */ 5700 check_field_decls (t, &access_decls, 5701 &cant_have_const_ctor, 5702 &no_const_asn_ref); 5703 5704 /* A nearly-empty class has to be vptr-containing; a nearly empty 5705 class contains just a vptr. */ 5706 if (!TYPE_CONTAINS_VPTR_P (t)) 5707 CLASSTYPE_NEARLY_EMPTY_P (t) = 0; 5708 5709 /* Do some bookkeeping that will guide the generation of implicitly 5710 declared member functions. */ 5711 TYPE_HAS_COMPLEX_COPY_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t); 5712 TYPE_HAS_COMPLEX_MOVE_CTOR (t) |= TYPE_CONTAINS_VPTR_P (t); 5713 /* We need to call a constructor for this class if it has a 5714 user-provided constructor, or if the default constructor is going 5715 to initialize the vptr. (This is not an if-and-only-if; 5716 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members 5717 themselves need constructing.) */ 5718 TYPE_NEEDS_CONSTRUCTING (t) 5719 |= (type_has_user_provided_constructor (t) || TYPE_CONTAINS_VPTR_P (t)); 5720 /* [dcl.init.aggr] 5721 5722 An aggregate is an array or a class with no user-provided 5723 constructors ... and no virtual functions. 5724 5725 Again, other conditions for being an aggregate are checked 5726 elsewhere. */ 5727 CLASSTYPE_NON_AGGREGATE (t) 5728 |= (type_has_user_provided_constructor (t) || TYPE_POLYMORPHIC_P (t)); 5729 /* This is the C++98/03 definition of POD; it changed in C++0x, but we 5730 retain the old definition internally for ABI reasons. */ 5731 CLASSTYPE_NON_LAYOUT_POD_P (t) 5732 |= (CLASSTYPE_NON_AGGREGATE (t) 5733 || saved_nontrivial_dtor || saved_complex_asn_ref); 5734 CLASSTYPE_NON_STD_LAYOUT (t) |= TYPE_CONTAINS_VPTR_P (t); 5735 TYPE_HAS_COMPLEX_COPY_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t); 5736 TYPE_HAS_COMPLEX_MOVE_ASSIGN (t) |= TYPE_CONTAINS_VPTR_P (t); 5737 TYPE_HAS_COMPLEX_DFLT (t) |= TYPE_CONTAINS_VPTR_P (t); 5738 5739 /* If the only explicitly declared default constructor is user-provided, 5740 set TYPE_HAS_COMPLEX_DFLT. */ 5741 if (!TYPE_HAS_COMPLEX_DFLT (t) 5742 && TYPE_HAS_DEFAULT_CONSTRUCTOR (t) 5743 && !type_has_non_user_provided_default_constructor (t)) 5744 TYPE_HAS_COMPLEX_DFLT (t) = true; 5745 5746 /* Warn if a public base of a polymorphic type has an accessible 5747 non-virtual destructor. It is only now that we know the class is 5748 polymorphic. Although a polymorphic base will have a already 5749 been diagnosed during its definition, we warn on use too. */ 5750 if (TYPE_POLYMORPHIC_P (t) && warn_nonvdtor) 5751 { 5752 tree binfo = TYPE_BINFO (t); 5753 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo); 5754 tree base_binfo; 5755 unsigned i; 5756 5757 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 5758 { 5759 tree basetype = TREE_TYPE (base_binfo); 5760 5761 if ((*accesses)[i] == access_public_node 5762 && (TYPE_POLYMORPHIC_P (basetype) || warn_ecpp) 5763 && accessible_nvdtor_p (basetype)) 5764 warning (OPT_Wnon_virtual_dtor, 5765 "base class %q#T has accessible non-virtual destructor", 5766 basetype); 5767 } 5768 } 5769 5770 /* If the class has no user-declared constructor, but does have 5771 non-static const or reference data members that can never be 5772 initialized, issue a warning. */ 5773 if (warn_uninitialized 5774 /* Classes with user-declared constructors are presumed to 5775 initialize these members. */ 5776 && !TYPE_HAS_USER_CONSTRUCTOR (t) 5777 /* Aggregates can be initialized with brace-enclosed 5778 initializers. */ 5779 && CLASSTYPE_NON_AGGREGATE (t)) 5780 { 5781 tree field; 5782 5783 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 5784 { 5785 tree type; 5786 5787 if (TREE_CODE (field) != FIELD_DECL 5788 || DECL_INITIAL (field) != NULL_TREE) 5789 continue; 5790 5791 type = TREE_TYPE (field); 5792 if (TREE_CODE (type) == REFERENCE_TYPE) 5793 warning (OPT_Wuninitialized, "non-static reference %q+#D " 5794 "in class without a constructor", field); 5795 else if (CP_TYPE_CONST_P (type) 5796 && (!CLASS_TYPE_P (type) 5797 || !TYPE_HAS_DEFAULT_CONSTRUCTOR (type))) 5798 warning (OPT_Wuninitialized, "non-static const member %q+#D " 5799 "in class without a constructor", field); 5800 } 5801 } 5802 5803 /* Synthesize any needed methods. */ 5804 add_implicitly_declared_members (t, &access_decls, 5805 cant_have_const_ctor, 5806 no_const_asn_ref); 5807 5808 /* Check defaulted declarations here so we have cant_have_const_ctor 5809 and don't need to worry about clones. */ 5810 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn)) 5811 if (!DECL_ARTIFICIAL (fn) && DECL_DEFAULTED_IN_CLASS_P (fn)) 5812 { 5813 int copy = copy_fn_p (fn); 5814 if (copy > 0) 5815 { 5816 bool imp_const_p 5817 = (DECL_CONSTRUCTOR_P (fn) ? !cant_have_const_ctor 5818 : !no_const_asn_ref); 5819 bool fn_const_p = (copy == 2); 5820 5821 if (fn_const_p && !imp_const_p) 5822 /* If the function is defaulted outside the class, we just 5823 give the synthesis error. */ 5824 error ("%q+D declared to take const reference, but implicit " 5825 "declaration would take non-const", fn); 5826 } 5827 defaulted_late_check (fn); 5828 } 5829 5830 if (LAMBDA_TYPE_P (t)) 5831 { 5832 /* "This class type is not an aggregate." */ 5833 CLASSTYPE_NON_AGGREGATE (t) = 1; 5834 } 5835 5836 /* Compute the 'literal type' property before we 5837 do anything with non-static member functions. */ 5838 finalize_literal_type_property (t); 5839 5840 /* Create the in-charge and not-in-charge variants of constructors 5841 and destructors. */ 5842 clone_constructors_and_destructors (t); 5843 5844 /* Process the using-declarations. */ 5845 for (; access_decls; access_decls = TREE_CHAIN (access_decls)) 5846 handle_using_decl (TREE_VALUE (access_decls), t); 5847 5848 /* Build and sort the CLASSTYPE_METHOD_VEC. */ 5849 finish_struct_methods (t); 5850 5851 /* Figure out whether or not we will need a cookie when dynamically 5852 allocating an array of this type. */ 5853 TYPE_LANG_SPECIFIC (t)->u.c.vec_new_uses_cookie 5854 = type_requires_array_cookie (t); 5855} 5856 5857/* If T needs a pointer to its virtual function table, set TYPE_VFIELD 5858 accordingly. If a new vfield was created (because T doesn't have a 5859 primary base class), then the newly created field is returned. It 5860 is not added to the TYPE_FIELDS list; it is the caller's 5861 responsibility to do that. Accumulate declared virtual functions 5862 on VIRTUALS_P. */ 5863 5864static tree 5865create_vtable_ptr (tree t, tree* virtuals_p) 5866{ 5867 tree fn; 5868 5869 /* Collect the virtual functions declared in T. */ 5870 for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn)) 5871 if (TREE_CODE (fn) == FUNCTION_DECL 5872 && DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn) 5873 && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST) 5874 { 5875 tree new_virtual = make_node (TREE_LIST); 5876 5877 BV_FN (new_virtual) = fn; 5878 BV_DELTA (new_virtual) = integer_zero_node; 5879 BV_VCALL_INDEX (new_virtual) = NULL_TREE; 5880 5881 TREE_CHAIN (new_virtual) = *virtuals_p; 5882 *virtuals_p = new_virtual; 5883 } 5884 5885 /* If we couldn't find an appropriate base class, create a new field 5886 here. Even if there weren't any new virtual functions, we might need a 5887 new virtual function table if we're supposed to include vptrs in 5888 all classes that need them. */ 5889 if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t))) 5890 { 5891 /* We build this decl with vtbl_ptr_type_node, which is a 5892 `vtable_entry_type*'. It might seem more precise to use 5893 `vtable_entry_type (*)[N]' where N is the number of virtual 5894 functions. However, that would require the vtable pointer in 5895 base classes to have a different type than the vtable pointer 5896 in derived classes. We could make that happen, but that 5897 still wouldn't solve all the problems. In particular, the 5898 type-based alias analysis code would decide that assignments 5899 to the base class vtable pointer can't alias assignments to 5900 the derived class vtable pointer, since they have different 5901 types. Thus, in a derived class destructor, where the base 5902 class constructor was inlined, we could generate bad code for 5903 setting up the vtable pointer. 5904 5905 Therefore, we use one type for all vtable pointers. We still 5906 use a type-correct type; it's just doesn't indicate the array 5907 bounds. That's better than using `void*' or some such; it's 5908 cleaner, and it let's the alias analysis code know that these 5909 stores cannot alias stores to void*! */ 5910 tree field; 5911 5912 field = build_decl (input_location, 5913 FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node); 5914 DECL_VIRTUAL_P (field) = 1; 5915 DECL_ARTIFICIAL (field) = 1; 5916 DECL_FIELD_CONTEXT (field) = t; 5917 DECL_FCONTEXT (field) = t; 5918 if (TYPE_PACKED (t)) 5919 DECL_PACKED (field) = 1; 5920 5921 TYPE_VFIELD (t) = field; 5922 5923 /* This class is non-empty. */ 5924 CLASSTYPE_EMPTY_P (t) = 0; 5925 5926 return field; 5927 } 5928 5929 return NULL_TREE; 5930} 5931 5932/* Add OFFSET to all base types of BINFO which is a base in the 5933 hierarchy dominated by T. 5934 5935 OFFSET, which is a type offset, is number of bytes. */ 5936 5937static void 5938propagate_binfo_offsets (tree binfo, tree offset) 5939{ 5940 int i; 5941 tree primary_binfo; 5942 tree base_binfo; 5943 5944 /* Update BINFO's offset. */ 5945 BINFO_OFFSET (binfo) 5946 = convert (sizetype, 5947 size_binop (PLUS_EXPR, 5948 convert (ssizetype, BINFO_OFFSET (binfo)), 5949 offset)); 5950 5951 /* Find the primary base class. */ 5952 primary_binfo = get_primary_binfo (binfo); 5953 5954 if (primary_binfo && BINFO_INHERITANCE_CHAIN (primary_binfo) == binfo) 5955 propagate_binfo_offsets (primary_binfo, offset); 5956 5957 /* Scan all of the bases, pushing the BINFO_OFFSET adjust 5958 downwards. */ 5959 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 5960 { 5961 /* Don't do the primary base twice. */ 5962 if (base_binfo == primary_binfo) 5963 continue; 5964 5965 if (BINFO_VIRTUAL_P (base_binfo)) 5966 continue; 5967 5968 propagate_binfo_offsets (base_binfo, offset); 5969 } 5970} 5971 5972/* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update 5973 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of 5974 empty subobjects of T. */ 5975 5976static void 5977layout_virtual_bases (record_layout_info rli, splay_tree offsets) 5978{ 5979 tree vbase; 5980 tree t = rli->t; 5981 tree *next_field; 5982 5983 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (t)) == 0) 5984 return; 5985 5986 /* Find the last field. The artificial fields created for virtual 5987 bases will go after the last extant field to date. */ 5988 next_field = &TYPE_FIELDS (t); 5989 while (*next_field) 5990 next_field = &DECL_CHAIN (*next_field); 5991 5992 /* Go through the virtual bases, allocating space for each virtual 5993 base that is not already a primary base class. These are 5994 allocated in inheritance graph order. */ 5995 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase)) 5996 { 5997 if (!BINFO_VIRTUAL_P (vbase)) 5998 continue; 5999 6000 if (!BINFO_PRIMARY_P (vbase)) 6001 { 6002 /* This virtual base is not a primary base of any class in the 6003 hierarchy, so we have to add space for it. */ 6004 next_field = build_base_field (rli, vbase, 6005 offsets, next_field); 6006 } 6007 } 6008} 6009 6010/* Returns the offset of the byte just past the end of the base class 6011 BINFO. */ 6012 6013static tree 6014end_of_base (tree binfo) 6015{ 6016 tree size; 6017 6018 if (!CLASSTYPE_AS_BASE (BINFO_TYPE (binfo))) 6019 size = TYPE_SIZE_UNIT (char_type_node); 6020 else if (is_empty_class (BINFO_TYPE (binfo))) 6021 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to 6022 allocate some space for it. It cannot have virtual bases, so 6023 TYPE_SIZE_UNIT is fine. */ 6024 size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo)); 6025 else 6026 size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE (binfo)); 6027 6028 return size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size); 6029} 6030 6031/* Returns the offset of the byte just past the end of the base class 6032 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then 6033 only non-virtual bases are included. */ 6034 6035static tree 6036end_of_class (tree t, int include_virtuals_p) 6037{ 6038 tree result = size_zero_node; 6039 vec<tree, va_gc> *vbases; 6040 tree binfo; 6041 tree base_binfo; 6042 tree offset; 6043 int i; 6044 6045 for (binfo = TYPE_BINFO (t), i = 0; 6046 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 6047 { 6048 if (!include_virtuals_p 6049 && BINFO_VIRTUAL_P (base_binfo) 6050 && (!BINFO_PRIMARY_P (base_binfo) 6051 || BINFO_INHERITANCE_CHAIN (base_binfo) != TYPE_BINFO (t))) 6052 continue; 6053 6054 offset = end_of_base (base_binfo); 6055 if (tree_int_cst_lt (result, offset)) 6056 result = offset; 6057 } 6058 6059 if (include_virtuals_p) 6060 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0; 6061 vec_safe_iterate (vbases, i, &base_binfo); i++) 6062 { 6063 offset = end_of_base (base_binfo); 6064 if (tree_int_cst_lt (result, offset)) 6065 result = offset; 6066 } 6067 6068 return result; 6069} 6070 6071/* Warn about bases of T that are inaccessible because they are 6072 ambiguous. For example: 6073 6074 struct S {}; 6075 struct T : public S {}; 6076 struct U : public S, public T {}; 6077 6078 Here, `(S*) new U' is not allowed because there are two `S' 6079 subobjects of U. */ 6080 6081static void 6082warn_about_ambiguous_bases (tree t) 6083{ 6084 int i; 6085 vec<tree, va_gc> *vbases; 6086 tree basetype; 6087 tree binfo; 6088 tree base_binfo; 6089 6090 /* If there are no repeated bases, nothing can be ambiguous. */ 6091 if (!CLASSTYPE_REPEATED_BASE_P (t)) 6092 return; 6093 6094 /* Check direct bases. */ 6095 for (binfo = TYPE_BINFO (t), i = 0; 6096 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 6097 { 6098 basetype = BINFO_TYPE (base_binfo); 6099 6100 if (!uniquely_derived_from_p (basetype, t)) 6101 warning (0, "direct base %qT inaccessible in %qT due to ambiguity", 6102 basetype, t); 6103 } 6104 6105 /* Check for ambiguous virtual bases. */ 6106 if (extra_warnings) 6107 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0; 6108 vec_safe_iterate (vbases, i, &binfo); i++) 6109 { 6110 basetype = BINFO_TYPE (binfo); 6111 6112 if (!uniquely_derived_from_p (basetype, t)) 6113 warning (OPT_Wextra, "virtual base %qT inaccessible in %qT due " 6114 "to ambiguity", basetype, t); 6115 } 6116} 6117 6118/* Compare two INTEGER_CSTs K1 and K2. */ 6119 6120static int 6121splay_tree_compare_integer_csts (splay_tree_key k1, splay_tree_key k2) 6122{ 6123 return tree_int_cst_compare ((tree) k1, (tree) k2); 6124} 6125 6126/* Increase the size indicated in RLI to account for empty classes 6127 that are "off the end" of the class. */ 6128 6129static void 6130include_empty_classes (record_layout_info rli) 6131{ 6132 tree eoc; 6133 tree rli_size; 6134 6135 /* It might be the case that we grew the class to allocate a 6136 zero-sized base class. That won't be reflected in RLI, yet, 6137 because we are willing to overlay multiple bases at the same 6138 offset. However, now we need to make sure that RLI is big enough 6139 to reflect the entire class. */ 6140 eoc = end_of_class (rli->t, 6141 CLASSTYPE_AS_BASE (rli->t) != NULL_TREE); 6142 rli_size = rli_size_unit_so_far (rli); 6143 if (TREE_CODE (rli_size) == INTEGER_CST 6144 && tree_int_cst_lt (rli_size, eoc)) 6145 { 6146 /* The size should have been rounded to a whole byte. */ 6147 gcc_assert (tree_int_cst_equal 6148 (rli->bitpos, round_down (rli->bitpos, BITS_PER_UNIT))); 6149 rli->bitpos 6150 = size_binop (PLUS_EXPR, 6151 rli->bitpos, 6152 size_binop (MULT_EXPR, 6153 convert (bitsizetype, 6154 size_binop (MINUS_EXPR, 6155 eoc, rli_size)), 6156 bitsize_int (BITS_PER_UNIT))); 6157 normalize_rli (rli); 6158 } 6159} 6160 6161/* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate 6162 BINFO_OFFSETs for all of the base-classes. Position the vtable 6163 pointer. Accumulate declared virtual functions on VIRTUALS_P. */ 6164 6165static void 6166layout_class_type (tree t, tree *virtuals_p) 6167{ 6168 tree non_static_data_members; 6169 tree field; 6170 tree vptr; 6171 record_layout_info rli; 6172 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of 6173 types that appear at that offset. */ 6174 splay_tree empty_base_offsets; 6175 /* True if the last field laid out was a bit-field. */ 6176 bool last_field_was_bitfield = false; 6177 /* The location at which the next field should be inserted. */ 6178 tree *next_field; 6179 /* T, as a base class. */ 6180 tree base_t; 6181 6182 /* Keep track of the first non-static data member. */ 6183 non_static_data_members = TYPE_FIELDS (t); 6184 6185 /* Start laying out the record. */ 6186 rli = start_record_layout (t); 6187 6188 /* Mark all the primary bases in the hierarchy. */ 6189 determine_primary_bases (t); 6190 6191 /* Create a pointer to our virtual function table. */ 6192 vptr = create_vtable_ptr (t, virtuals_p); 6193 6194 /* The vptr is always the first thing in the class. */ 6195 if (vptr) 6196 { 6197 DECL_CHAIN (vptr) = TYPE_FIELDS (t); 6198 TYPE_FIELDS (t) = vptr; 6199 next_field = &DECL_CHAIN (vptr); 6200 place_field (rli, vptr); 6201 } 6202 else 6203 next_field = &TYPE_FIELDS (t); 6204 6205 /* Build FIELD_DECLs for all of the non-virtual base-types. */ 6206 empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts, 6207 NULL, NULL); 6208 build_base_fields (rli, empty_base_offsets, next_field); 6209 6210 /* Layout the non-static data members. */ 6211 for (field = non_static_data_members; field; field = DECL_CHAIN (field)) 6212 { 6213 tree type; 6214 tree padding; 6215 6216 /* We still pass things that aren't non-static data members to 6217 the back end, in case it wants to do something with them. */ 6218 if (TREE_CODE (field) != FIELD_DECL) 6219 { 6220 place_field (rli, field); 6221 /* If the static data member has incomplete type, keep track 6222 of it so that it can be completed later. (The handling 6223 of pending statics in finish_record_layout is 6224 insufficient; consider: 6225 6226 struct S1; 6227 struct S2 { static S1 s1; }; 6228 6229 At this point, finish_record_layout will be called, but 6230 S1 is still incomplete.) */ 6231 if (VAR_P (field)) 6232 { 6233 maybe_register_incomplete_var (field); 6234 /* The visibility of static data members is determined 6235 at their point of declaration, not their point of 6236 definition. */ 6237 determine_visibility (field); 6238 } 6239 continue; 6240 } 6241 6242 type = TREE_TYPE (field); 6243 if (type == error_mark_node) 6244 continue; 6245 6246 padding = NULL_TREE; 6247 6248 /* If this field is a bit-field whose width is greater than its 6249 type, then there are some special rules for allocating 6250 it. */ 6251 if (DECL_C_BIT_FIELD (field) 6252 && tree_int_cst_lt (TYPE_SIZE (type), DECL_SIZE (field))) 6253 { 6254 unsigned int itk; 6255 tree integer_type; 6256 bool was_unnamed_p = false; 6257 /* We must allocate the bits as if suitably aligned for the 6258 longest integer type that fits in this many bits. type 6259 of the field. Then, we are supposed to use the left over 6260 bits as additional padding. */ 6261 for (itk = itk_char; itk != itk_none; ++itk) 6262 if (integer_types[itk] != NULL_TREE 6263 && (tree_int_cst_lt (size_int (MAX_FIXED_MODE_SIZE), 6264 TYPE_SIZE (integer_types[itk])) 6265 || tree_int_cst_lt (DECL_SIZE (field), 6266 TYPE_SIZE (integer_types[itk])))) 6267 break; 6268 6269 /* ITK now indicates a type that is too large for the 6270 field. We have to back up by one to find the largest 6271 type that fits. */ 6272 do 6273 { 6274 --itk; 6275 integer_type = integer_types[itk]; 6276 } while (itk > 0 && integer_type == NULL_TREE); 6277 6278 /* Figure out how much additional padding is required. */ 6279 if (tree_int_cst_lt (TYPE_SIZE (integer_type), DECL_SIZE (field))) 6280 { 6281 if (TREE_CODE (t) == UNION_TYPE) 6282 /* In a union, the padding field must have the full width 6283 of the bit-field; all fields start at offset zero. */ 6284 padding = DECL_SIZE (field); 6285 else 6286 padding = size_binop (MINUS_EXPR, DECL_SIZE (field), 6287 TYPE_SIZE (integer_type)); 6288 } 6289#ifdef PCC_BITFIELD_TYPE_MATTERS 6290 /* An unnamed bitfield does not normally affect the 6291 alignment of the containing class on a target where 6292 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not 6293 make any exceptions for unnamed bitfields when the 6294 bitfields are longer than their types. Therefore, we 6295 temporarily give the field a name. */ 6296 if (PCC_BITFIELD_TYPE_MATTERS && !DECL_NAME (field)) 6297 { 6298 was_unnamed_p = true; 6299 DECL_NAME (field) = make_anon_name (); 6300 } 6301#endif 6302 DECL_SIZE (field) = TYPE_SIZE (integer_type); 6303 DECL_ALIGN (field) = TYPE_ALIGN (integer_type); 6304 DECL_USER_ALIGN (field) = TYPE_USER_ALIGN (integer_type); 6305 layout_nonempty_base_or_field (rli, field, NULL_TREE, 6306 empty_base_offsets); 6307 if (was_unnamed_p) 6308 DECL_NAME (field) = NULL_TREE; 6309 /* Now that layout has been performed, set the size of the 6310 field to the size of its declared type; the rest of the 6311 field is effectively invisible. */ 6312 DECL_SIZE (field) = TYPE_SIZE (type); 6313 /* We must also reset the DECL_MODE of the field. */ 6314 DECL_MODE (field) = TYPE_MODE (type); 6315 } 6316 else 6317 layout_nonempty_base_or_field (rli, field, NULL_TREE, 6318 empty_base_offsets); 6319 6320 /* Remember the location of any empty classes in FIELD. */ 6321 record_subobject_offsets (TREE_TYPE (field), 6322 byte_position(field), 6323 empty_base_offsets, 6324 /*is_data_member=*/true); 6325 6326 /* If a bit-field does not immediately follow another bit-field, 6327 and yet it starts in the middle of a byte, we have failed to 6328 comply with the ABI. */ 6329 if (warn_abi 6330 && DECL_C_BIT_FIELD (field) 6331 /* The TREE_NO_WARNING flag gets set by Objective-C when 6332 laying out an Objective-C class. The ObjC ABI differs 6333 from the C++ ABI, and so we do not want a warning 6334 here. */ 6335 && !TREE_NO_WARNING (field) 6336 && !last_field_was_bitfield 6337 && !integer_zerop (size_binop (TRUNC_MOD_EXPR, 6338 DECL_FIELD_BIT_OFFSET (field), 6339 bitsize_unit_node))) 6340 warning (OPT_Wabi, "offset of %q+D is not ABI-compliant and may " 6341 "change in a future version of GCC", field); 6342 6343 /* The middle end uses the type of expressions to determine the 6344 possible range of expression values. In order to optimize 6345 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end 6346 must be made aware of the width of "i", via its type. 6347 6348 Because C++ does not have integer types of arbitrary width, 6349 we must (for the purposes of the front end) convert from the 6350 type assigned here to the declared type of the bitfield 6351 whenever a bitfield expression is used as an rvalue. 6352 Similarly, when assigning a value to a bitfield, the value 6353 must be converted to the type given the bitfield here. */ 6354 if (DECL_C_BIT_FIELD (field)) 6355 { 6356 unsigned HOST_WIDE_INT width; 6357 tree ftype = TREE_TYPE (field); 6358 width = tree_to_uhwi (DECL_SIZE (field)); 6359 if (width != TYPE_PRECISION (ftype)) 6360 { 6361 TREE_TYPE (field) 6362 = c_build_bitfield_integer_type (width, 6363 TYPE_UNSIGNED (ftype)); 6364 TREE_TYPE (field) 6365 = cp_build_qualified_type (TREE_TYPE (field), 6366 cp_type_quals (ftype)); 6367 } 6368 } 6369 6370 /* If we needed additional padding after this field, add it 6371 now. */ 6372 if (padding) 6373 { 6374 tree padding_field; 6375 6376 padding_field = build_decl (input_location, 6377 FIELD_DECL, 6378 NULL_TREE, 6379 char_type_node); 6380 DECL_BIT_FIELD (padding_field) = 1; 6381 DECL_SIZE (padding_field) = padding; 6382 DECL_CONTEXT (padding_field) = t; 6383 DECL_ARTIFICIAL (padding_field) = 1; 6384 DECL_IGNORED_P (padding_field) = 1; 6385 layout_nonempty_base_or_field (rli, padding_field, 6386 NULL_TREE, 6387 empty_base_offsets); 6388 } 6389 6390 last_field_was_bitfield = DECL_C_BIT_FIELD (field); 6391 } 6392 6393 if (!integer_zerop (rli->bitpos)) 6394 { 6395 /* Make sure that we are on a byte boundary so that the size of 6396 the class without virtual bases will always be a round number 6397 of bytes. */ 6398 rli->bitpos = round_up_loc (input_location, rli->bitpos, BITS_PER_UNIT); 6399 normalize_rli (rli); 6400 } 6401 6402 /* Delete all zero-width bit-fields from the list of fields. Now 6403 that the type is laid out they are no longer important. */ 6404 remove_zero_width_bit_fields (t); 6405 6406 /* Create the version of T used for virtual bases. We do not use 6407 make_class_type for this version; this is an artificial type. For 6408 a POD type, we just reuse T. */ 6409 if (CLASSTYPE_NON_LAYOUT_POD_P (t) || CLASSTYPE_EMPTY_P (t)) 6410 { 6411 base_t = make_node (TREE_CODE (t)); 6412 6413 /* Set the size and alignment for the new type. */ 6414 tree eoc; 6415 6416 /* If the ABI version is not at least two, and the last 6417 field was a bit-field, RLI may not be on a byte 6418 boundary. In particular, rli_size_unit_so_far might 6419 indicate the last complete byte, while rli_size_so_far 6420 indicates the total number of bits used. Therefore, 6421 rli_size_so_far, rather than rli_size_unit_so_far, is 6422 used to compute TYPE_SIZE_UNIT. */ 6423 eoc = end_of_class (t, /*include_virtuals_p=*/0); 6424 TYPE_SIZE_UNIT (base_t) 6425 = size_binop (MAX_EXPR, 6426 convert (sizetype, 6427 size_binop (CEIL_DIV_EXPR, 6428 rli_size_so_far (rli), 6429 bitsize_int (BITS_PER_UNIT))), 6430 eoc); 6431 TYPE_SIZE (base_t) 6432 = size_binop (MAX_EXPR, 6433 rli_size_so_far (rli), 6434 size_binop (MULT_EXPR, 6435 convert (bitsizetype, eoc), 6436 bitsize_int (BITS_PER_UNIT))); 6437 TYPE_ALIGN (base_t) = rli->record_align; 6438 TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t); 6439 6440 /* Copy the fields from T. */ 6441 next_field = &TYPE_FIELDS (base_t); 6442 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 6443 if (TREE_CODE (field) == FIELD_DECL) 6444 { 6445 *next_field = build_decl (input_location, 6446 FIELD_DECL, 6447 DECL_NAME (field), 6448 TREE_TYPE (field)); 6449 DECL_CONTEXT (*next_field) = base_t; 6450 DECL_FIELD_OFFSET (*next_field) = DECL_FIELD_OFFSET (field); 6451 DECL_FIELD_BIT_OFFSET (*next_field) 6452 = DECL_FIELD_BIT_OFFSET (field); 6453 DECL_SIZE (*next_field) = DECL_SIZE (field); 6454 DECL_MODE (*next_field) = DECL_MODE (field); 6455 next_field = &DECL_CHAIN (*next_field); 6456 } 6457 6458 /* Record the base version of the type. */ 6459 CLASSTYPE_AS_BASE (t) = base_t; 6460 TYPE_CONTEXT (base_t) = t; 6461 } 6462 else 6463 CLASSTYPE_AS_BASE (t) = t; 6464 6465 /* Every empty class contains an empty class. */ 6466 if (CLASSTYPE_EMPTY_P (t)) 6467 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1; 6468 6469 /* Set the TYPE_DECL for this type to contain the right 6470 value for DECL_OFFSET, so that we can use it as part 6471 of a COMPONENT_REF for multiple inheritance. */ 6472 layout_decl (TYPE_MAIN_DECL (t), 0); 6473 6474 /* Now fix up any virtual base class types that we left lying 6475 around. We must get these done before we try to lay out the 6476 virtual function table. As a side-effect, this will remove the 6477 base subobject fields. */ 6478 layout_virtual_bases (rli, empty_base_offsets); 6479 6480 /* Make sure that empty classes are reflected in RLI at this 6481 point. */ 6482 include_empty_classes(rli); 6483 6484 /* Make sure not to create any structures with zero size. */ 6485 if (integer_zerop (rli_size_unit_so_far (rli)) && CLASSTYPE_EMPTY_P (t)) 6486 place_field (rli, 6487 build_decl (input_location, 6488 FIELD_DECL, NULL_TREE, char_type_node)); 6489 6490 /* If this is a non-POD, declaring it packed makes a difference to how it 6491 can be used as a field; don't let finalize_record_size undo it. */ 6492 if (TYPE_PACKED (t) && !layout_pod_type_p (t)) 6493 rli->packed_maybe_necessary = true; 6494 6495 /* Let the back end lay out the type. */ 6496 finish_record_layout (rli, /*free_p=*/true); 6497 6498 if (TYPE_SIZE_UNIT (t) 6499 && TREE_CODE (TYPE_SIZE_UNIT (t)) == INTEGER_CST 6500 && !TREE_OVERFLOW (TYPE_SIZE_UNIT (t)) 6501 && !valid_constant_size_p (TYPE_SIZE_UNIT (t))) 6502 error ("type %qT is too large", t); 6503 6504 /* Warn about bases that can't be talked about due to ambiguity. */ 6505 warn_about_ambiguous_bases (t); 6506 6507 /* Now that we're done with layout, give the base fields the real types. */ 6508 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field)) 6509 if (DECL_ARTIFICIAL (field) && IS_FAKE_BASE_TYPE (TREE_TYPE (field))) 6510 TREE_TYPE (field) = TYPE_CONTEXT (TREE_TYPE (field)); 6511 6512 /* Clean up. */ 6513 splay_tree_delete (empty_base_offsets); 6514 6515 if (CLASSTYPE_EMPTY_P (t) 6516 && tree_int_cst_lt (sizeof_biggest_empty_class, 6517 TYPE_SIZE_UNIT (t))) 6518 sizeof_biggest_empty_class = TYPE_SIZE_UNIT (t); 6519} 6520 6521/* Determine the "key method" for the class type indicated by TYPE, 6522 and set CLASSTYPE_KEY_METHOD accordingly. */ 6523 6524void 6525determine_key_method (tree type) 6526{ 6527 tree method; 6528 6529 if (TYPE_FOR_JAVA (type) 6530 || processing_template_decl 6531 || CLASSTYPE_TEMPLATE_INSTANTIATION (type) 6532 || CLASSTYPE_INTERFACE_KNOWN (type)) 6533 return; 6534 6535 /* The key method is the first non-pure virtual function that is not 6536 inline at the point of class definition. On some targets the 6537 key function may not be inline; those targets should not call 6538 this function until the end of the translation unit. */ 6539 for (method = TYPE_METHODS (type); method != NULL_TREE; 6540 method = DECL_CHAIN (method)) 6541 if (TREE_CODE (method) == FUNCTION_DECL 6542 && DECL_VINDEX (method) != NULL_TREE 6543 && ! DECL_DECLARED_INLINE_P (method) 6544 && ! DECL_PURE_VIRTUAL_P (method)) 6545 { 6546 CLASSTYPE_KEY_METHOD (type) = method; 6547 break; 6548 } 6549 6550 return; 6551} 6552 6553 6554/* Allocate and return an instance of struct sorted_fields_type with 6555 N fields. */ 6556 6557static struct sorted_fields_type * 6558sorted_fields_type_new (int n) 6559{ 6560 struct sorted_fields_type *sft; 6561 sft = (sorted_fields_type *) ggc_internal_alloc (sizeof (sorted_fields_type) 6562 + n * sizeof (tree)); 6563 sft->len = n; 6564 6565 return sft; 6566} 6567 6568 6569/* Perform processing required when the definition of T (a class type) 6570 is complete. */ 6571 6572void 6573finish_struct_1 (tree t) 6574{ 6575 tree x; 6576 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */ 6577 tree virtuals = NULL_TREE; 6578 6579 if (COMPLETE_TYPE_P (t)) 6580 { 6581 gcc_assert (MAYBE_CLASS_TYPE_P (t)); 6582 error ("redefinition of %q#T", t); 6583 popclass (); 6584 return; 6585 } 6586 6587 /* If this type was previously laid out as a forward reference, 6588 make sure we lay it out again. */ 6589 TYPE_SIZE (t) = NULL_TREE; 6590 CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE; 6591 6592 /* Make assumptions about the class; we'll reset the flags if 6593 necessary. */ 6594 CLASSTYPE_EMPTY_P (t) = 1; 6595 CLASSTYPE_NEARLY_EMPTY_P (t) = 1; 6596 CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0; 6597 CLASSTYPE_LITERAL_P (t) = true; 6598 6599 /* Do end-of-class semantic processing: checking the validity of the 6600 bases and members and add implicitly generated methods. */ 6601 check_bases_and_members (t); 6602 6603 /* Find the key method. */ 6604 if (TYPE_CONTAINS_VPTR_P (t)) 6605 { 6606 /* The Itanium C++ ABI permits the key method to be chosen when 6607 the class is defined -- even though the key method so 6608 selected may later turn out to be an inline function. On 6609 some systems (such as ARM Symbian OS) the key method cannot 6610 be determined until the end of the translation unit. On such 6611 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which 6612 will cause the class to be added to KEYED_CLASSES. Then, in 6613 finish_file we will determine the key method. */ 6614 if (targetm.cxx.key_method_may_be_inline ()) 6615 determine_key_method (t); 6616 6617 /* If a polymorphic class has no key method, we may emit the vtable 6618 in every translation unit where the class definition appears. If 6619 we're devirtualizing, we can look into the vtable even if we 6620 aren't emitting it. */ 6621 if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE) 6622 keyed_classes = tree_cons (NULL_TREE, t, keyed_classes); 6623 } 6624 6625 /* Layout the class itself. */ 6626 layout_class_type (t, &virtuals); 6627 if (CLASSTYPE_AS_BASE (t) != t) 6628 /* We use the base type for trivial assignments, and hence it 6629 needs a mode. */ 6630 compute_record_mode (CLASSTYPE_AS_BASE (t)); 6631 6632 virtuals = modify_all_vtables (t, nreverse (virtuals)); 6633 6634 /* If necessary, create the primary vtable for this class. */ 6635 if (virtuals || TYPE_CONTAINS_VPTR_P (t)) 6636 { 6637 /* We must enter these virtuals into the table. */ 6638 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) 6639 build_primary_vtable (NULL_TREE, t); 6640 else if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t))) 6641 /* Here we know enough to change the type of our virtual 6642 function table, but we will wait until later this function. */ 6643 build_primary_vtable (CLASSTYPE_PRIMARY_BINFO (t), t); 6644 6645 /* If we're warning about ABI tags, check the types of the new 6646 virtual functions. */ 6647 if (warn_abi_tag) 6648 for (tree v = virtuals; v; v = TREE_CHAIN (v)) 6649 check_abi_tags (t, TREE_VALUE (v)); 6650 } 6651 6652 if (TYPE_CONTAINS_VPTR_P (t)) 6653 { 6654 int vindex; 6655 tree fn; 6656 6657 if (BINFO_VTABLE (TYPE_BINFO (t))) 6658 gcc_assert (DECL_VIRTUAL_P (BINFO_VTABLE (TYPE_BINFO (t)))); 6659 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t)) 6660 gcc_assert (BINFO_VIRTUALS (TYPE_BINFO (t)) == NULL_TREE); 6661 6662 /* Add entries for virtual functions introduced by this class. */ 6663 BINFO_VIRTUALS (TYPE_BINFO (t)) 6664 = chainon (BINFO_VIRTUALS (TYPE_BINFO (t)), virtuals); 6665 6666 /* Set DECL_VINDEX for all functions declared in this class. */ 6667 for (vindex = 0, fn = BINFO_VIRTUALS (TYPE_BINFO (t)); 6668 fn; 6669 fn = TREE_CHAIN (fn), 6670 vindex += (TARGET_VTABLE_USES_DESCRIPTORS 6671 ? TARGET_VTABLE_USES_DESCRIPTORS : 1)) 6672 { 6673 tree fndecl = BV_FN (fn); 6674 6675 if (DECL_THUNK_P (fndecl)) 6676 /* A thunk. We should never be calling this entry directly 6677 from this vtable -- we'd use the entry for the non 6678 thunk base function. */ 6679 DECL_VINDEX (fndecl) = NULL_TREE; 6680 else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST) 6681 DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex); 6682 } 6683 } 6684 6685 finish_struct_bits (t); 6686 set_method_tm_attributes (t); 6687 6688 /* Complete the rtl for any static member objects of the type we're 6689 working on. */ 6690 for (x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x)) 6691 if (VAR_P (x) && TREE_STATIC (x) 6692 && TREE_TYPE (x) != error_mark_node 6693 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t)) 6694 DECL_MODE (x) = TYPE_MODE (t); 6695 6696 /* Done with FIELDS...now decide whether to sort these for 6697 faster lookups later. 6698 6699 We use a small number because most searches fail (succeeding 6700 ultimately as the search bores through the inheritance 6701 hierarchy), and we want this failure to occur quickly. */ 6702 6703 insert_into_classtype_sorted_fields (TYPE_FIELDS (t), t, 8); 6704 6705 /* Complain if one of the field types requires lower visibility. */ 6706 constrain_class_visibility (t); 6707 6708 /* Make the rtl for any new vtables we have created, and unmark 6709 the base types we marked. */ 6710 finish_vtbls (t); 6711 6712 /* Build the VTT for T. */ 6713 build_vtt (t); 6714 6715 /* This warning does not make sense for Java classes, since they 6716 cannot have destructors. */ 6717 if (!TYPE_FOR_JAVA (t) && warn_nonvdtor 6718 && TYPE_POLYMORPHIC_P (t) && accessible_nvdtor_p (t) 6719 && !CLASSTYPE_FINAL (t)) 6720 warning (OPT_Wnon_virtual_dtor, 6721 "%q#T has virtual functions and accessible" 6722 " non-virtual destructor", t); 6723 6724 complete_vars (t); 6725 6726 if (warn_overloaded_virtual) 6727 warn_hidden (t); 6728 6729 /* Class layout, assignment of virtual table slots, etc., is now 6730 complete. Give the back end a chance to tweak the visibility of 6731 the class or perform any other required target modifications. */ 6732 targetm.cxx.adjust_class_at_definition (t); 6733 6734 maybe_suppress_debug_info (t); 6735 6736 if (flag_vtable_verify) 6737 vtv_save_class_info (t); 6738 6739 dump_class_hierarchy (t); 6740 6741 /* Finish debugging output for this type. */ 6742 rest_of_type_compilation (t, ! LOCAL_CLASS_P (t)); 6743 6744 if (TYPE_TRANSPARENT_AGGR (t)) 6745 { 6746 tree field = first_field (t); 6747 if (field == NULL_TREE || error_operand_p (field)) 6748 { 6749 error ("type transparent %q#T does not have any fields", t); 6750 TYPE_TRANSPARENT_AGGR (t) = 0; 6751 } 6752 else if (DECL_ARTIFICIAL (field)) 6753 { 6754 if (DECL_FIELD_IS_BASE (field)) 6755 error ("type transparent class %qT has base classes", t); 6756 else 6757 { 6758 gcc_checking_assert (DECL_VIRTUAL_P (field)); 6759 error ("type transparent class %qT has virtual functions", t); 6760 } 6761 TYPE_TRANSPARENT_AGGR (t) = 0; 6762 } 6763 else if (TYPE_MODE (t) != DECL_MODE (field)) 6764 { 6765 error ("type transparent %q#T cannot be made transparent because " 6766 "the type of the first field has a different ABI from the " 6767 "class overall", t); 6768 TYPE_TRANSPARENT_AGGR (t) = 0; 6769 } 6770 } 6771} 6772 6773/* Insert FIELDS into T for the sorted case if the FIELDS count is 6774 equal to THRESHOLD or greater than THRESHOLD. */ 6775 6776static void 6777insert_into_classtype_sorted_fields (tree fields, tree t, int threshold) 6778{ 6779 int n_fields = count_fields (fields); 6780 if (n_fields >= threshold) 6781 { 6782 struct sorted_fields_type *field_vec = sorted_fields_type_new (n_fields); 6783 add_fields_to_record_type (fields, field_vec, 0); 6784 qsort (field_vec->elts, n_fields, sizeof (tree), field_decl_cmp); 6785 CLASSTYPE_SORTED_FIELDS (t) = field_vec; 6786 } 6787} 6788 6789/* Insert lately defined enum ENUMTYPE into T for the sorted case. */ 6790 6791void 6792insert_late_enum_def_into_classtype_sorted_fields (tree enumtype, tree t) 6793{ 6794 struct sorted_fields_type *sorted_fields = CLASSTYPE_SORTED_FIELDS (t); 6795 if (sorted_fields) 6796 { 6797 int i; 6798 int n_fields 6799 = list_length (TYPE_VALUES (enumtype)) + sorted_fields->len; 6800 struct sorted_fields_type *field_vec = sorted_fields_type_new (n_fields); 6801 6802 for (i = 0; i < sorted_fields->len; ++i) 6803 field_vec->elts[i] = sorted_fields->elts[i]; 6804 6805 add_enum_fields_to_record_type (enumtype, field_vec, 6806 sorted_fields->len); 6807 qsort (field_vec->elts, n_fields, sizeof (tree), field_decl_cmp); 6808 CLASSTYPE_SORTED_FIELDS (t) = field_vec; 6809 } 6810} 6811 6812/* When T was built up, the member declarations were added in reverse 6813 order. Rearrange them to declaration order. */ 6814 6815void 6816unreverse_member_declarations (tree t) 6817{ 6818 tree next; 6819 tree prev; 6820 tree x; 6821 6822 /* The following lists are all in reverse order. Put them in 6823 declaration order now. */ 6824 TYPE_METHODS (t) = nreverse (TYPE_METHODS (t)); 6825 CLASSTYPE_DECL_LIST (t) = nreverse (CLASSTYPE_DECL_LIST (t)); 6826 6827 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in 6828 reverse order, so we can't just use nreverse. */ 6829 prev = NULL_TREE; 6830 for (x = TYPE_FIELDS (t); 6831 x && TREE_CODE (x) != TYPE_DECL; 6832 x = next) 6833 { 6834 next = DECL_CHAIN (x); 6835 DECL_CHAIN (x) = prev; 6836 prev = x; 6837 } 6838 if (prev) 6839 { 6840 DECL_CHAIN (TYPE_FIELDS (t)) = x; 6841 if (prev) 6842 TYPE_FIELDS (t) = prev; 6843 } 6844} 6845 6846tree 6847finish_struct (tree t, tree attributes) 6848{ 6849 location_t saved_loc = input_location; 6850 6851 /* Now that we've got all the field declarations, reverse everything 6852 as necessary. */ 6853 unreverse_member_declarations (t); 6854 6855 cplus_decl_attributes (&t, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE); 6856 fixup_attribute_variants (t); 6857 6858 /* Nadger the current location so that diagnostics point to the start of 6859 the struct, not the end. */ 6860 input_location = DECL_SOURCE_LOCATION (TYPE_NAME (t)); 6861 6862 if (processing_template_decl) 6863 { 6864 tree x; 6865 6866 finish_struct_methods (t); 6867 TYPE_SIZE (t) = bitsize_zero_node; 6868 TYPE_SIZE_UNIT (t) = size_zero_node; 6869 6870 /* We need to emit an error message if this type was used as a parameter 6871 and it is an abstract type, even if it is a template. We construct 6872 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into 6873 account and we call complete_vars with this type, which will check 6874 the PARM_DECLS. Note that while the type is being defined, 6875 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends 6876 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */ 6877 CLASSTYPE_PURE_VIRTUALS (t) = NULL; 6878 for (x = TYPE_METHODS (t); x; x = DECL_CHAIN (x)) 6879 if (DECL_PURE_VIRTUAL_P (x)) 6880 vec_safe_push (CLASSTYPE_PURE_VIRTUALS (t), x); 6881 complete_vars (t); 6882 /* We need to add the target functions to the CLASSTYPE_METHOD_VEC if 6883 an enclosing scope is a template class, so that this function be 6884 found by lookup_fnfields_1 when the using declaration is not 6885 instantiated yet. */ 6886 for (x = TYPE_FIELDS (t); x; x = DECL_CHAIN (x)) 6887 if (TREE_CODE (x) == USING_DECL) 6888 { 6889 tree fn = strip_using_decl (x); 6890 if (is_overloaded_fn (fn)) 6891 for (; fn; fn = OVL_NEXT (fn)) 6892 add_method (t, OVL_CURRENT (fn), x); 6893 } 6894 6895 /* Remember current #pragma pack value. */ 6896 TYPE_PRECISION (t) = maximum_field_alignment; 6897 6898 /* Fix up any variants we've already built. */ 6899 for (x = TYPE_NEXT_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x)) 6900 { 6901 TYPE_SIZE (x) = TYPE_SIZE (t); 6902 TYPE_SIZE_UNIT (x) = TYPE_SIZE_UNIT (t); 6903 TYPE_FIELDS (x) = TYPE_FIELDS (t); 6904 TYPE_METHODS (x) = TYPE_METHODS (t); 6905 } 6906 } 6907 else 6908 finish_struct_1 (t); 6909 6910 if (is_std_init_list (t)) 6911 { 6912 /* People keep complaining that the compiler crashes on an invalid 6913 definition of initializer_list, so I guess we should explicitly 6914 reject it. What the compiler internals care about is that it's a 6915 template and has a pointer field followed by an integer field. */ 6916 bool ok = false; 6917 if (processing_template_decl) 6918 { 6919 tree f = next_initializable_field (TYPE_FIELDS (t)); 6920 if (f && TREE_CODE (TREE_TYPE (f)) == POINTER_TYPE) 6921 { 6922 f = next_initializable_field (DECL_CHAIN (f)); 6923 if (f && same_type_p (TREE_TYPE (f), size_type_node)) 6924 ok = true; 6925 } 6926 } 6927 if (!ok) 6928 fatal_error (input_location, 6929 "definition of std::initializer_list does not match " 6930 "#include <initializer_list>"); 6931 } 6932 6933 input_location = saved_loc; 6934 6935 TYPE_BEING_DEFINED (t) = 0; 6936 6937 if (current_class_type) 6938 popclass (); 6939 else 6940 error ("trying to finish struct, but kicked out due to previous parse errors"); 6941 6942 if (processing_template_decl && at_function_scope_p () 6943 /* Lambdas are defined by the LAMBDA_EXPR. */ 6944 && !LAMBDA_TYPE_P (t)) 6945 add_stmt (build_min (TAG_DEFN, t)); 6946 6947 return t; 6948} 6949 6950/* Hash table to avoid endless recursion when handling references. */ 6951static hash_table<pointer_hash<tree_node> > *fixed_type_or_null_ref_ht; 6952 6953/* Return the dynamic type of INSTANCE, if known. 6954 Used to determine whether the virtual function table is needed 6955 or not. 6956 6957 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless 6958 of our knowledge of its type. *NONNULL should be initialized 6959 before this function is called. */ 6960 6961static tree 6962fixed_type_or_null (tree instance, int *nonnull, int *cdtorp) 6963{ 6964#define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp) 6965 6966 switch (TREE_CODE (instance)) 6967 { 6968 case INDIRECT_REF: 6969 if (POINTER_TYPE_P (TREE_TYPE (instance))) 6970 return NULL_TREE; 6971 else 6972 return RECUR (TREE_OPERAND (instance, 0)); 6973 6974 case CALL_EXPR: 6975 /* This is a call to a constructor, hence it's never zero. */ 6976 if (TREE_HAS_CONSTRUCTOR (instance)) 6977 { 6978 if (nonnull) 6979 *nonnull = 1; 6980 return TREE_TYPE (instance); 6981 } 6982 return NULL_TREE; 6983 6984 case SAVE_EXPR: 6985 /* This is a call to a constructor, hence it's never zero. */ 6986 if (TREE_HAS_CONSTRUCTOR (instance)) 6987 { 6988 if (nonnull) 6989 *nonnull = 1; 6990 return TREE_TYPE (instance); 6991 } 6992 return RECUR (TREE_OPERAND (instance, 0)); 6993 6994 case POINTER_PLUS_EXPR: 6995 case PLUS_EXPR: 6996 case MINUS_EXPR: 6997 if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR) 6998 return RECUR (TREE_OPERAND (instance, 0)); 6999 if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST) 7000 /* Propagate nonnull. */ 7001 return RECUR (TREE_OPERAND (instance, 0)); 7002 7003 return NULL_TREE; 7004 7005 CASE_CONVERT: 7006 return RECUR (TREE_OPERAND (instance, 0)); 7007 7008 case ADDR_EXPR: 7009 instance = TREE_OPERAND (instance, 0); 7010 if (nonnull) 7011 { 7012 /* Just because we see an ADDR_EXPR doesn't mean we're dealing 7013 with a real object -- given &p->f, p can still be null. */ 7014 tree t = get_base_address (instance); 7015 /* ??? Probably should check DECL_WEAK here. */ 7016 if (t && DECL_P (t)) 7017 *nonnull = 1; 7018 } 7019 return RECUR (instance); 7020 7021 case COMPONENT_REF: 7022 /* If this component is really a base class reference, then the field 7023 itself isn't definitive. */ 7024 if (DECL_FIELD_IS_BASE (TREE_OPERAND (instance, 1))) 7025 return RECUR (TREE_OPERAND (instance, 0)); 7026 return RECUR (TREE_OPERAND (instance, 1)); 7027 7028 case VAR_DECL: 7029 case FIELD_DECL: 7030 if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE 7031 && MAYBE_CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (instance)))) 7032 { 7033 if (nonnull) 7034 *nonnull = 1; 7035 return TREE_TYPE (TREE_TYPE (instance)); 7036 } 7037 /* fall through... */ 7038 case TARGET_EXPR: 7039 case PARM_DECL: 7040 case RESULT_DECL: 7041 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (instance))) 7042 { 7043 if (nonnull) 7044 *nonnull = 1; 7045 return TREE_TYPE (instance); 7046 } 7047 else if (instance == current_class_ptr) 7048 { 7049 if (nonnull) 7050 *nonnull = 1; 7051 7052 /* if we're in a ctor or dtor, we know our type. If 7053 current_class_ptr is set but we aren't in a function, we're in 7054 an NSDMI (and therefore a constructor). */ 7055 if (current_scope () != current_function_decl 7056 || (DECL_LANG_SPECIFIC (current_function_decl) 7057 && (DECL_CONSTRUCTOR_P (current_function_decl) 7058 || DECL_DESTRUCTOR_P (current_function_decl)))) 7059 { 7060 if (cdtorp) 7061 *cdtorp = 1; 7062 return TREE_TYPE (TREE_TYPE (instance)); 7063 } 7064 } 7065 else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE) 7066 { 7067 /* We only need one hash table because it is always left empty. */ 7068 if (!fixed_type_or_null_ref_ht) 7069 fixed_type_or_null_ref_ht 7070 = new hash_table<pointer_hash<tree_node> > (37); 7071 7072 /* Reference variables should be references to objects. */ 7073 if (nonnull) 7074 *nonnull = 1; 7075 7076 /* Enter the INSTANCE in a table to prevent recursion; a 7077 variable's initializer may refer to the variable 7078 itself. */ 7079 if (VAR_P (instance) 7080 && DECL_INITIAL (instance) 7081 && !type_dependent_expression_p_push (DECL_INITIAL (instance)) 7082 && !fixed_type_or_null_ref_ht->find (instance)) 7083 { 7084 tree type; 7085 tree_node **slot; 7086 7087 slot = fixed_type_or_null_ref_ht->find_slot (instance, INSERT); 7088 *slot = instance; 7089 type = RECUR (DECL_INITIAL (instance)); 7090 fixed_type_or_null_ref_ht->remove_elt (instance); 7091 7092 return type; 7093 } 7094 } 7095 return NULL_TREE; 7096 7097 default: 7098 return NULL_TREE; 7099 } 7100#undef RECUR 7101} 7102 7103/* Return nonzero if the dynamic type of INSTANCE is known, and 7104 equivalent to the static type. We also handle the case where 7105 INSTANCE is really a pointer. Return negative if this is a 7106 ctor/dtor. There the dynamic type is known, but this might not be 7107 the most derived base of the original object, and hence virtual 7108 bases may not be laid out according to this type. 7109 7110 Used to determine whether the virtual function table is needed 7111 or not. 7112 7113 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless 7114 of our knowledge of its type. *NONNULL should be initialized 7115 before this function is called. */ 7116 7117int 7118resolves_to_fixed_type_p (tree instance, int* nonnull) 7119{ 7120 tree t = TREE_TYPE (instance); 7121 int cdtorp = 0; 7122 tree fixed; 7123 7124 /* processing_template_decl can be false in a template if we're in 7125 instantiate_non_dependent_expr, but we still want to suppress 7126 this check. */ 7127 if (in_template_function ()) 7128 { 7129 /* In a template we only care about the type of the result. */ 7130 if (nonnull) 7131 *nonnull = true; 7132 return true; 7133 } 7134 7135 fixed = fixed_type_or_null (instance, nonnull, &cdtorp); 7136 if (fixed == NULL_TREE) 7137 return 0; 7138 if (POINTER_TYPE_P (t)) 7139 t = TREE_TYPE (t); 7140 if (!same_type_ignoring_top_level_qualifiers_p (t, fixed)) 7141 return 0; 7142 return cdtorp ? -1 : 1; 7143} 7144 7145 7146void 7147init_class_processing (void) 7148{ 7149 current_class_depth = 0; 7150 current_class_stack_size = 10; 7151 current_class_stack 7152 = XNEWVEC (struct class_stack_node, current_class_stack_size); 7153 vec_alloc (local_classes, 8); 7154 sizeof_biggest_empty_class = size_zero_node; 7155 7156 ridpointers[(int) RID_PUBLIC] = access_public_node; 7157 ridpointers[(int) RID_PRIVATE] = access_private_node; 7158 ridpointers[(int) RID_PROTECTED] = access_protected_node; 7159} 7160 7161/* Restore the cached PREVIOUS_CLASS_LEVEL. */ 7162 7163static void 7164restore_class_cache (void) 7165{ 7166 tree type; 7167 7168 /* We are re-entering the same class we just left, so we don't 7169 have to search the whole inheritance matrix to find all the 7170 decls to bind again. Instead, we install the cached 7171 class_shadowed list and walk through it binding names. */ 7172 push_binding_level (previous_class_level); 7173 class_binding_level = previous_class_level; 7174 /* Restore IDENTIFIER_TYPE_VALUE. */ 7175 for (type = class_binding_level->type_shadowed; 7176 type; 7177 type = TREE_CHAIN (type)) 7178 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (type), TREE_TYPE (type)); 7179} 7180 7181/* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as 7182 appropriate for TYPE. 7183 7184 So that we may avoid calls to lookup_name, we cache the _TYPE 7185 nodes of local TYPE_DECLs in the TREE_TYPE field of the name. 7186 7187 For multiple inheritance, we perform a two-pass depth-first search 7188 of the type lattice. */ 7189 7190void 7191pushclass (tree type) 7192{ 7193 class_stack_node_t csn; 7194 7195 type = TYPE_MAIN_VARIANT (type); 7196 7197 /* Make sure there is enough room for the new entry on the stack. */ 7198 if (current_class_depth + 1 >= current_class_stack_size) 7199 { 7200 current_class_stack_size *= 2; 7201 current_class_stack 7202 = XRESIZEVEC (struct class_stack_node, current_class_stack, 7203 current_class_stack_size); 7204 } 7205 7206 /* Insert a new entry on the class stack. */ 7207 csn = current_class_stack + current_class_depth; 7208 csn->name = current_class_name; 7209 csn->type = current_class_type; 7210 csn->access = current_access_specifier; 7211 csn->names_used = 0; 7212 csn->hidden = 0; 7213 current_class_depth++; 7214 7215 /* Now set up the new type. */ 7216 current_class_name = TYPE_NAME (type); 7217 if (TREE_CODE (current_class_name) == TYPE_DECL) 7218 current_class_name = DECL_NAME (current_class_name); 7219 current_class_type = type; 7220 7221 /* By default, things in classes are private, while things in 7222 structures or unions are public. */ 7223 current_access_specifier = (CLASSTYPE_DECLARED_CLASS (type) 7224 ? access_private_node 7225 : access_public_node); 7226 7227 if (previous_class_level 7228 && type != previous_class_level->this_entity 7229 && current_class_depth == 1) 7230 { 7231 /* Forcibly remove any old class remnants. */ 7232 invalidate_class_lookup_cache (); 7233 } 7234 7235 if (!previous_class_level 7236 || type != previous_class_level->this_entity 7237 || current_class_depth > 1) 7238 pushlevel_class (); 7239 else 7240 restore_class_cache (); 7241} 7242 7243/* When we exit a toplevel class scope, we save its binding level so 7244 that we can restore it quickly. Here, we've entered some other 7245 class, so we must invalidate our cache. */ 7246 7247void 7248invalidate_class_lookup_cache (void) 7249{ 7250 previous_class_level = NULL; 7251} 7252 7253/* Get out of the current class scope. If we were in a class scope 7254 previously, that is the one popped to. */ 7255 7256void 7257popclass (void) 7258{ 7259 poplevel_class (); 7260 7261 current_class_depth--; 7262 current_class_name = current_class_stack[current_class_depth].name; 7263 current_class_type = current_class_stack[current_class_depth].type; 7264 current_access_specifier = current_class_stack[current_class_depth].access; 7265 if (current_class_stack[current_class_depth].names_used) 7266 splay_tree_delete (current_class_stack[current_class_depth].names_used); 7267} 7268 7269/* Mark the top of the class stack as hidden. */ 7270 7271void 7272push_class_stack (void) 7273{ 7274 if (current_class_depth) 7275 ++current_class_stack[current_class_depth - 1].hidden; 7276} 7277 7278/* Mark the top of the class stack as un-hidden. */ 7279 7280void 7281pop_class_stack (void) 7282{ 7283 if (current_class_depth) 7284 --current_class_stack[current_class_depth - 1].hidden; 7285} 7286 7287/* Returns 1 if the class type currently being defined is either T or 7288 a nested type of T. */ 7289 7290bool 7291currently_open_class (tree t) 7292{ 7293 int i; 7294 7295 if (!CLASS_TYPE_P (t)) 7296 return false; 7297 7298 t = TYPE_MAIN_VARIANT (t); 7299 7300 /* We start looking from 1 because entry 0 is from global scope, 7301 and has no type. */ 7302 for (i = current_class_depth; i > 0; --i) 7303 { 7304 tree c; 7305 if (i == current_class_depth) 7306 c = current_class_type; 7307 else 7308 { 7309 if (current_class_stack[i].hidden) 7310 break; 7311 c = current_class_stack[i].type; 7312 } 7313 if (!c) 7314 continue; 7315 if (same_type_p (c, t)) 7316 return true; 7317 } 7318 return false; 7319} 7320 7321/* If either current_class_type or one of its enclosing classes are derived 7322 from T, return the appropriate type. Used to determine how we found 7323 something via unqualified lookup. */ 7324 7325tree 7326currently_open_derived_class (tree t) 7327{ 7328 int i; 7329 7330 /* The bases of a dependent type are unknown. */ 7331 if (dependent_type_p (t)) 7332 return NULL_TREE; 7333 7334 if (!current_class_type) 7335 return NULL_TREE; 7336 7337 if (DERIVED_FROM_P (t, current_class_type)) 7338 return current_class_type; 7339 7340 for (i = current_class_depth - 1; i > 0; --i) 7341 { 7342 if (current_class_stack[i].hidden) 7343 break; 7344 if (DERIVED_FROM_P (t, current_class_stack[i].type)) 7345 return current_class_stack[i].type; 7346 } 7347 7348 return NULL_TREE; 7349} 7350 7351/* Return the outermost enclosing class type that is still open, or 7352 NULL_TREE. */ 7353 7354tree 7355outermost_open_class (void) 7356{ 7357 if (!current_class_type) 7358 return NULL_TREE; 7359 tree r = NULL_TREE; 7360 if (TYPE_BEING_DEFINED (current_class_type)) 7361 r = current_class_type; 7362 for (int i = current_class_depth - 1; i > 0; --i) 7363 { 7364 if (current_class_stack[i].hidden) 7365 break; 7366 tree t = current_class_stack[i].type; 7367 if (!TYPE_BEING_DEFINED (t)) 7368 break; 7369 r = t; 7370 } 7371 return r; 7372} 7373 7374/* Returns the innermost class type which is not a lambda closure type. */ 7375 7376tree 7377current_nonlambda_class_type (void) 7378{ 7379 int i; 7380 7381 /* We start looking from 1 because entry 0 is from global scope, 7382 and has no type. */ 7383 for (i = current_class_depth; i > 0; --i) 7384 { 7385 tree c; 7386 if (i == current_class_depth) 7387 c = current_class_type; 7388 else 7389 { 7390 if (current_class_stack[i].hidden) 7391 break; 7392 c = current_class_stack[i].type; 7393 } 7394 if (!c) 7395 continue; 7396 if (!LAMBDA_TYPE_P (c)) 7397 return c; 7398 } 7399 return NULL_TREE; 7400} 7401 7402/* When entering a class scope, all enclosing class scopes' names with 7403 static meaning (static variables, static functions, types and 7404 enumerators) have to be visible. This recursive function calls 7405 pushclass for all enclosing class contexts until global or a local 7406 scope is reached. TYPE is the enclosed class. */ 7407 7408void 7409push_nested_class (tree type) 7410{ 7411 /* A namespace might be passed in error cases, like A::B:C. */ 7412 if (type == NULL_TREE 7413 || !CLASS_TYPE_P (type)) 7414 return; 7415 7416 push_nested_class (DECL_CONTEXT (TYPE_MAIN_DECL (type))); 7417 7418 pushclass (type); 7419} 7420 7421/* Undoes a push_nested_class call. */ 7422 7423void 7424pop_nested_class (void) 7425{ 7426 tree context = DECL_CONTEXT (TYPE_MAIN_DECL (current_class_type)); 7427 7428 popclass (); 7429 if (context && CLASS_TYPE_P (context)) 7430 pop_nested_class (); 7431} 7432 7433/* Returns the number of extern "LANG" blocks we are nested within. */ 7434 7435int 7436current_lang_depth (void) 7437{ 7438 return vec_safe_length (current_lang_base); 7439} 7440 7441/* Set global variables CURRENT_LANG_NAME to appropriate value 7442 so that behavior of name-mangling machinery is correct. */ 7443 7444void 7445push_lang_context (tree name) 7446{ 7447 vec_safe_push (current_lang_base, current_lang_name); 7448 7449 if (name == lang_name_cplusplus) 7450 { 7451 current_lang_name = name; 7452 } 7453 else if (name == lang_name_java) 7454 { 7455 current_lang_name = name; 7456 /* DECL_IGNORED_P is initially set for these types, to avoid clutter. 7457 (See record_builtin_java_type in decl.c.) However, that causes 7458 incorrect debug entries if these types are actually used. 7459 So we re-enable debug output after extern "Java". */ 7460 DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0; 7461 DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0; 7462 DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0; 7463 DECL_IGNORED_P (TYPE_NAME (java_long_type_node)) = 0; 7464 DECL_IGNORED_P (TYPE_NAME (java_float_type_node)) = 0; 7465 DECL_IGNORED_P (TYPE_NAME (java_double_type_node)) = 0; 7466 DECL_IGNORED_P (TYPE_NAME (java_char_type_node)) = 0; 7467 DECL_IGNORED_P (TYPE_NAME (java_boolean_type_node)) = 0; 7468 } 7469 else if (name == lang_name_c) 7470 { 7471 current_lang_name = name; 7472 } 7473 else 7474 error ("language string %<\"%E\"%> not recognized", name); 7475} 7476 7477/* Get out of the current language scope. */ 7478 7479void 7480pop_lang_context (void) 7481{ 7482 current_lang_name = current_lang_base->pop (); 7483} 7484 7485/* Type instantiation routines. */ 7486 7487/* Given an OVERLOAD and a TARGET_TYPE, return the function that 7488 matches the TARGET_TYPE. If there is no satisfactory match, return 7489 error_mark_node, and issue an error & warning messages under 7490 control of FLAGS. Permit pointers to member function if FLAGS 7491 permits. If TEMPLATE_ONLY, the name of the overloaded function was 7492 a template-id, and EXPLICIT_TARGS are the explicitly provided 7493 template arguments. 7494 7495 If OVERLOAD is for one or more member functions, then ACCESS_PATH 7496 is the base path used to reference those member functions. If 7497 the address is resolved to a member function, access checks will be 7498 performed and errors issued if appropriate. */ 7499 7500static tree 7501resolve_address_of_overloaded_function (tree target_type, 7502 tree overload, 7503 tsubst_flags_t flags, 7504 bool template_only, 7505 tree explicit_targs, 7506 tree access_path) 7507{ 7508 /* Here's what the standard says: 7509 7510 [over.over] 7511 7512 If the name is a function template, template argument deduction 7513 is done, and if the argument deduction succeeds, the deduced 7514 arguments are used to generate a single template function, which 7515 is added to the set of overloaded functions considered. 7516 7517 Non-member functions and static member functions match targets of 7518 type "pointer-to-function" or "reference-to-function." Nonstatic 7519 member functions match targets of type "pointer-to-member 7520 function;" the function type of the pointer to member is used to 7521 select the member function from the set of overloaded member 7522 functions. If a nonstatic member function is selected, the 7523 reference to the overloaded function name is required to have the 7524 form of a pointer to member as described in 5.3.1. 7525 7526 If more than one function is selected, any template functions in 7527 the set are eliminated if the set also contains a non-template 7528 function, and any given template function is eliminated if the 7529 set contains a second template function that is more specialized 7530 than the first according to the partial ordering rules 14.5.5.2. 7531 After such eliminations, if any, there shall remain exactly one 7532 selected function. */ 7533 7534 int is_ptrmem = 0; 7535 /* We store the matches in a TREE_LIST rooted here. The functions 7536 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy 7537 interoperability with most_specialized_instantiation. */ 7538 tree matches = NULL_TREE; 7539 tree fn; 7540 tree target_fn_type; 7541 7542 /* By the time we get here, we should be seeing only real 7543 pointer-to-member types, not the internal POINTER_TYPE to 7544 METHOD_TYPE representation. */ 7545 gcc_assert (!TYPE_PTR_P (target_type) 7546 || TREE_CODE (TREE_TYPE (target_type)) != METHOD_TYPE); 7547 7548 gcc_assert (is_overloaded_fn (overload)); 7549 7550 /* Check that the TARGET_TYPE is reasonable. */ 7551 if (TYPE_PTRFN_P (target_type) 7552 || TYPE_REFFN_P (target_type)) 7553 /* This is OK. */; 7554 else if (TYPE_PTRMEMFUNC_P (target_type)) 7555 /* This is OK, too. */ 7556 is_ptrmem = 1; 7557 else if (TREE_CODE (target_type) == FUNCTION_TYPE) 7558 /* This is OK, too. This comes from a conversion to reference 7559 type. */ 7560 target_type = build_reference_type (target_type); 7561 else 7562 { 7563 if (flags & tf_error) 7564 error ("cannot resolve overloaded function %qD based on" 7565 " conversion to type %qT", 7566 DECL_NAME (OVL_FUNCTION (overload)), target_type); 7567 return error_mark_node; 7568 } 7569 7570 /* Non-member functions and static member functions match targets of type 7571 "pointer-to-function" or "reference-to-function." Nonstatic member 7572 functions match targets of type "pointer-to-member-function;" the 7573 function type of the pointer to member is used to select the member 7574 function from the set of overloaded member functions. 7575 7576 So figure out the FUNCTION_TYPE that we want to match against. */ 7577 target_fn_type = static_fn_type (target_type); 7578 7579 /* If we can find a non-template function that matches, we can just 7580 use it. There's no point in generating template instantiations 7581 if we're just going to throw them out anyhow. But, of course, we 7582 can only do this when we don't *need* a template function. */ 7583 if (!template_only) 7584 { 7585 tree fns; 7586 7587 for (fns = overload; fns; fns = OVL_NEXT (fns)) 7588 { 7589 tree fn = OVL_CURRENT (fns); 7590 7591 if (TREE_CODE (fn) == TEMPLATE_DECL) 7592 /* We're not looking for templates just yet. */ 7593 continue; 7594 7595 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) 7596 != is_ptrmem) 7597 /* We're looking for a non-static member, and this isn't 7598 one, or vice versa. */ 7599 continue; 7600 7601 /* Ignore functions which haven't been explicitly 7602 declared. */ 7603 if (DECL_ANTICIPATED (fn)) 7604 continue; 7605 7606 /* See if there's a match. */ 7607 if (same_type_p (target_fn_type, static_fn_type (fn))) 7608 matches = tree_cons (fn, NULL_TREE, matches); 7609 } 7610 } 7611 7612 /* Now, if we've already got a match (or matches), there's no need 7613 to proceed to the template functions. But, if we don't have a 7614 match we need to look at them, too. */ 7615 if (!matches) 7616 { 7617 tree target_arg_types; 7618 tree target_ret_type; 7619 tree fns; 7620 tree *args; 7621 unsigned int nargs, ia; 7622 tree arg; 7623 7624 target_arg_types = TYPE_ARG_TYPES (target_fn_type); 7625 target_ret_type = TREE_TYPE (target_fn_type); 7626 7627 nargs = list_length (target_arg_types); 7628 args = XALLOCAVEC (tree, nargs); 7629 for (arg = target_arg_types, ia = 0; 7630 arg != NULL_TREE && arg != void_list_node; 7631 arg = TREE_CHAIN (arg), ++ia) 7632 args[ia] = TREE_VALUE (arg); 7633 nargs = ia; 7634 7635 for (fns = overload; fns; fns = OVL_NEXT (fns)) 7636 { 7637 tree fn = OVL_CURRENT (fns); 7638 tree instantiation; 7639 tree targs; 7640 7641 if (TREE_CODE (fn) != TEMPLATE_DECL) 7642 /* We're only looking for templates. */ 7643 continue; 7644 7645 if ((TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) 7646 != is_ptrmem) 7647 /* We're not looking for a non-static member, and this is 7648 one, or vice versa. */ 7649 continue; 7650 7651 tree ret = target_ret_type; 7652 7653 /* If the template has a deduced return type, don't expose it to 7654 template argument deduction. */ 7655 if (undeduced_auto_decl (fn)) 7656 ret = NULL_TREE; 7657 7658 /* Try to do argument deduction. */ 7659 targs = make_tree_vec (DECL_NTPARMS (fn)); 7660 instantiation = fn_type_unification (fn, explicit_targs, targs, args, 7661 nargs, ret, 7662 DEDUCE_EXACT, LOOKUP_NORMAL, 7663 false, false); 7664 if (instantiation == error_mark_node) 7665 /* Instantiation failed. */ 7666 continue; 7667 7668 /* And now force instantiation to do return type deduction. */ 7669 if (undeduced_auto_decl (instantiation)) 7670 { 7671 ++function_depth; 7672 instantiate_decl (instantiation, /*defer*/false, /*class*/false); 7673 --function_depth; 7674 7675 require_deduced_type (instantiation); 7676 } 7677 7678 /* See if there's a match. */ 7679 if (same_type_p (target_fn_type, static_fn_type (instantiation))) 7680 matches = tree_cons (instantiation, fn, matches); 7681 } 7682 7683 /* Now, remove all but the most specialized of the matches. */ 7684 if (matches) 7685 { 7686 tree match = most_specialized_instantiation (matches); 7687 7688 if (match != error_mark_node) 7689 matches = tree_cons (TREE_PURPOSE (match), 7690 NULL_TREE, 7691 NULL_TREE); 7692 } 7693 } 7694 7695 /* Now we should have exactly one function in MATCHES. */ 7696 if (matches == NULL_TREE) 7697 { 7698 /* There were *no* matches. */ 7699 if (flags & tf_error) 7700 { 7701 error ("no matches converting function %qD to type %q#T", 7702 DECL_NAME (OVL_CURRENT (overload)), 7703 target_type); 7704 7705 print_candidates (overload); 7706 } 7707 return error_mark_node; 7708 } 7709 else if (TREE_CHAIN (matches)) 7710 { 7711 /* There were too many matches. First check if they're all 7712 the same function. */ 7713 tree match = NULL_TREE; 7714 7715 fn = TREE_PURPOSE (matches); 7716 7717 /* For multi-versioned functions, more than one match is just fine and 7718 decls_match will return false as they are different. */ 7719 for (match = TREE_CHAIN (matches); match; match = TREE_CHAIN (match)) 7720 if (!decls_match (fn, TREE_PURPOSE (match)) 7721 && !targetm.target_option.function_versions 7722 (fn, TREE_PURPOSE (match))) 7723 break; 7724 7725 if (match) 7726 { 7727 if (flags & tf_error) 7728 { 7729 error ("converting overloaded function %qD to type %q#T is ambiguous", 7730 DECL_NAME (OVL_FUNCTION (overload)), 7731 target_type); 7732 7733 /* Since print_candidates expects the functions in the 7734 TREE_VALUE slot, we flip them here. */ 7735 for (match = matches; match; match = TREE_CHAIN (match)) 7736 TREE_VALUE (match) = TREE_PURPOSE (match); 7737 7738 print_candidates (matches); 7739 } 7740 7741 return error_mark_node; 7742 } 7743 } 7744 7745 /* Good, exactly one match. Now, convert it to the correct type. */ 7746 fn = TREE_PURPOSE (matches); 7747 7748 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) 7749 && !(flags & tf_ptrmem_ok) && !flag_ms_extensions) 7750 { 7751 static int explained; 7752 7753 if (!(flags & tf_error)) 7754 return error_mark_node; 7755 7756 permerror (input_location, "assuming pointer to member %qD", fn); 7757 if (!explained) 7758 { 7759 inform (input_location, "(a pointer to member can only be formed with %<&%E%>)", fn); 7760 explained = 1; 7761 } 7762 } 7763 7764 /* If a pointer to a function that is multi-versioned is requested, the 7765 pointer to the dispatcher function is returned instead. This works 7766 well because indirectly calling the function will dispatch the right 7767 function version at run-time. */ 7768 if (DECL_FUNCTION_VERSIONED (fn)) 7769 { 7770 fn = get_function_version_dispatcher (fn); 7771 if (fn == NULL) 7772 return error_mark_node; 7773 /* Mark all the versions corresponding to the dispatcher as used. */ 7774 if (!(flags & tf_conv)) 7775 mark_versions_used (fn); 7776 } 7777 7778 /* If we're doing overload resolution purely for the purpose of 7779 determining conversion sequences, we should not consider the 7780 function used. If this conversion sequence is selected, the 7781 function will be marked as used at this point. */ 7782 if (!(flags & tf_conv)) 7783 { 7784 /* Make =delete work with SFINAE. */ 7785 if (DECL_DELETED_FN (fn) && !(flags & tf_error)) 7786 return error_mark_node; 7787 if (!mark_used (fn, flags) && !(flags & tf_error)) 7788 return error_mark_node; 7789 } 7790 7791 /* We could not check access to member functions when this 7792 expression was originally created since we did not know at that 7793 time to which function the expression referred. */ 7794 if (DECL_FUNCTION_MEMBER_P (fn)) 7795 { 7796 gcc_assert (access_path); 7797 perform_or_defer_access_check (access_path, fn, fn, flags); 7798 } 7799 7800 if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type)) 7801 return cp_build_addr_expr (fn, flags); 7802 else 7803 { 7804 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op 7805 will mark the function as addressed, but here we must do it 7806 explicitly. */ 7807 cxx_mark_addressable (fn); 7808 7809 return fn; 7810 } 7811} 7812 7813/* This function will instantiate the type of the expression given in 7814 RHS to match the type of LHSTYPE. If errors exist, then return 7815 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then 7816 we complain on errors. If we are not complaining, never modify rhs, 7817 as overload resolution wants to try many possible instantiations, in 7818 the hope that at least one will work. 7819 7820 For non-recursive calls, LHSTYPE should be a function, pointer to 7821 function, or a pointer to member function. */ 7822 7823tree 7824instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags) 7825{ 7826 tsubst_flags_t flags_in = flags; 7827 tree access_path = NULL_TREE; 7828 7829 flags &= ~tf_ptrmem_ok; 7830 7831 if (lhstype == unknown_type_node) 7832 { 7833 if (flags & tf_error) 7834 error ("not enough type information"); 7835 return error_mark_node; 7836 } 7837 7838 if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs))) 7839 { 7840 tree fntype = non_reference (lhstype); 7841 if (same_type_p (fntype, TREE_TYPE (rhs))) 7842 return rhs; 7843 if (flag_ms_extensions 7844 && TYPE_PTRMEMFUNC_P (fntype) 7845 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs))) 7846 /* Microsoft allows `A::f' to be resolved to a 7847 pointer-to-member. */ 7848 ; 7849 else 7850 { 7851 if (flags & tf_error) 7852 error ("cannot convert %qE from type %qT to type %qT", 7853 rhs, TREE_TYPE (rhs), fntype); 7854 return error_mark_node; 7855 } 7856 } 7857 7858 if (BASELINK_P (rhs)) 7859 { 7860 access_path = BASELINK_ACCESS_BINFO (rhs); 7861 rhs = BASELINK_FUNCTIONS (rhs); 7862 } 7863 7864 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot 7865 deduce any type information. */ 7866 if (TREE_CODE (rhs) == NON_DEPENDENT_EXPR) 7867 { 7868 if (flags & tf_error) 7869 error ("not enough type information"); 7870 return error_mark_node; 7871 } 7872 7873 /* There only a few kinds of expressions that may have a type 7874 dependent on overload resolution. */ 7875 gcc_assert (TREE_CODE (rhs) == ADDR_EXPR 7876 || TREE_CODE (rhs) == COMPONENT_REF 7877 || is_overloaded_fn (rhs) 7878 || (flag_ms_extensions && TREE_CODE (rhs) == FUNCTION_DECL)); 7879 7880 /* This should really only be used when attempting to distinguish 7881 what sort of a pointer to function we have. For now, any 7882 arithmetic operation which is not supported on pointers 7883 is rejected as an error. */ 7884 7885 switch (TREE_CODE (rhs)) 7886 { 7887 case COMPONENT_REF: 7888 { 7889 tree member = TREE_OPERAND (rhs, 1); 7890 7891 member = instantiate_type (lhstype, member, flags); 7892 if (member != error_mark_node 7893 && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0))) 7894 /* Do not lose object's side effects. */ 7895 return build2 (COMPOUND_EXPR, TREE_TYPE (member), 7896 TREE_OPERAND (rhs, 0), member); 7897 return member; 7898 } 7899 7900 case OFFSET_REF: 7901 rhs = TREE_OPERAND (rhs, 1); 7902 if (BASELINK_P (rhs)) 7903 return instantiate_type (lhstype, rhs, flags_in); 7904 7905 /* This can happen if we are forming a pointer-to-member for a 7906 member template. */ 7907 gcc_assert (TREE_CODE (rhs) == TEMPLATE_ID_EXPR); 7908 7909 /* Fall through. */ 7910 7911 case TEMPLATE_ID_EXPR: 7912 { 7913 tree fns = TREE_OPERAND (rhs, 0); 7914 tree args = TREE_OPERAND (rhs, 1); 7915 7916 return 7917 resolve_address_of_overloaded_function (lhstype, fns, flags_in, 7918 /*template_only=*/true, 7919 args, access_path); 7920 } 7921 7922 case OVERLOAD: 7923 case FUNCTION_DECL: 7924 return 7925 resolve_address_of_overloaded_function (lhstype, rhs, flags_in, 7926 /*template_only=*/false, 7927 /*explicit_targs=*/NULL_TREE, 7928 access_path); 7929 7930 case ADDR_EXPR: 7931 { 7932 if (PTRMEM_OK_P (rhs)) 7933 flags |= tf_ptrmem_ok; 7934 7935 return instantiate_type (lhstype, TREE_OPERAND (rhs, 0), flags); 7936 } 7937 7938 case ERROR_MARK: 7939 return error_mark_node; 7940 7941 default: 7942 gcc_unreachable (); 7943 } 7944 return error_mark_node; 7945} 7946 7947/* Return the name of the virtual function pointer field 7948 (as an IDENTIFIER_NODE) for the given TYPE. Note that 7949 this may have to look back through base types to find the 7950 ultimate field name. (For single inheritance, these could 7951 all be the same name. Who knows for multiple inheritance). */ 7952 7953static tree 7954get_vfield_name (tree type) 7955{ 7956 tree binfo, base_binfo; 7957 char *buf; 7958 7959 for (binfo = TYPE_BINFO (type); 7960 BINFO_N_BASE_BINFOS (binfo); 7961 binfo = base_binfo) 7962 { 7963 base_binfo = BINFO_BASE_BINFO (binfo, 0); 7964 7965 if (BINFO_VIRTUAL_P (base_binfo) 7966 || !TYPE_CONTAINS_VPTR_P (BINFO_TYPE (base_binfo))) 7967 break; 7968 } 7969 7970 type = BINFO_TYPE (binfo); 7971 buf = (char *) alloca (sizeof (VFIELD_NAME_FORMAT) 7972 + TYPE_NAME_LENGTH (type) + 2); 7973 sprintf (buf, VFIELD_NAME_FORMAT, 7974 IDENTIFIER_POINTER (constructor_name (type))); 7975 return get_identifier (buf); 7976} 7977 7978void 7979print_class_statistics (void) 7980{ 7981 if (! GATHER_STATISTICS) 7982 return; 7983 7984 fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness); 7985 fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs); 7986 if (n_vtables) 7987 { 7988 fprintf (stderr, "vtables = %d; vtable searches = %d\n", 7989 n_vtables, n_vtable_searches); 7990 fprintf (stderr, "vtable entries = %d; vtable elems = %d\n", 7991 n_vtable_entries, n_vtable_elems); 7992 } 7993} 7994 7995/* Build a dummy reference to ourselves so Derived::Base (and A::A) works, 7996 according to [class]: 7997 The class-name is also inserted 7998 into the scope of the class itself. For purposes of access checking, 7999 the inserted class name is treated as if it were a public member name. */ 8000 8001void 8002build_self_reference (void) 8003{ 8004 tree name = constructor_name (current_class_type); 8005 tree value = build_lang_decl (TYPE_DECL, name, current_class_type); 8006 tree saved_cas; 8007 8008 DECL_NONLOCAL (value) = 1; 8009 DECL_CONTEXT (value) = current_class_type; 8010 DECL_ARTIFICIAL (value) = 1; 8011 SET_DECL_SELF_REFERENCE_P (value); 8012 set_underlying_type (value); 8013 8014 if (processing_template_decl) 8015 value = push_template_decl (value); 8016 8017 saved_cas = current_access_specifier; 8018 current_access_specifier = access_public_node; 8019 finish_member_declaration (value); 8020 current_access_specifier = saved_cas; 8021} 8022 8023/* Returns 1 if TYPE contains only padding bytes. */ 8024 8025int 8026is_empty_class (tree type) 8027{ 8028 if (type == error_mark_node) 8029 return 0; 8030 8031 if (! CLASS_TYPE_P (type)) 8032 return 0; 8033 8034 return CLASSTYPE_EMPTY_P (type); 8035} 8036 8037/* Returns true if TYPE contains no actual data, just various 8038 possible combinations of empty classes and possibly a vptr. */ 8039 8040bool 8041is_really_empty_class (tree type) 8042{ 8043 if (CLASS_TYPE_P (type)) 8044 { 8045 tree field; 8046 tree binfo; 8047 tree base_binfo; 8048 int i; 8049 8050 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid 8051 out, but we'd like to be able to check this before then. */ 8052 if (COMPLETE_TYPE_P (type) && is_empty_class (type)) 8053 return true; 8054 8055 for (binfo = TYPE_BINFO (type), i = 0; 8056 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 8057 if (!is_really_empty_class (BINFO_TYPE (base_binfo))) 8058 return false; 8059 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 8060 if (TREE_CODE (field) == FIELD_DECL 8061 && !DECL_ARTIFICIAL (field) 8062 && !is_really_empty_class (TREE_TYPE (field))) 8063 return false; 8064 return true; 8065 } 8066 else if (TREE_CODE (type) == ARRAY_TYPE) 8067 return is_really_empty_class (TREE_TYPE (type)); 8068 return false; 8069} 8070 8071/* Note that NAME was looked up while the current class was being 8072 defined and that the result of that lookup was DECL. */ 8073 8074void 8075maybe_note_name_used_in_class (tree name, tree decl) 8076{ 8077 splay_tree names_used; 8078 8079 /* If we're not defining a class, there's nothing to do. */ 8080 if (!(innermost_scope_kind() == sk_class 8081 && TYPE_BEING_DEFINED (current_class_type) 8082 && !LAMBDA_TYPE_P (current_class_type))) 8083 return; 8084 8085 /* If there's already a binding for this NAME, then we don't have 8086 anything to worry about. */ 8087 if (lookup_member (current_class_type, name, 8088 /*protect=*/0, /*want_type=*/false, tf_warning_or_error)) 8089 return; 8090 8091 if (!current_class_stack[current_class_depth - 1].names_used) 8092 current_class_stack[current_class_depth - 1].names_used 8093 = splay_tree_new (splay_tree_compare_pointers, 0, 0); 8094 names_used = current_class_stack[current_class_depth - 1].names_used; 8095 8096 splay_tree_insert (names_used, 8097 (splay_tree_key) name, 8098 (splay_tree_value) decl); 8099} 8100 8101/* Note that NAME was declared (as DECL) in the current class. Check 8102 to see that the declaration is valid. */ 8103 8104void 8105note_name_declared_in_class (tree name, tree decl) 8106{ 8107 splay_tree names_used; 8108 splay_tree_node n; 8109 8110 /* Look to see if we ever used this name. */ 8111 names_used 8112 = current_class_stack[current_class_depth - 1].names_used; 8113 if (!names_used) 8114 return; 8115 /* The C language allows members to be declared with a type of the same 8116 name, and the C++ standard says this diagnostic is not required. So 8117 allow it in extern "C" blocks unless predantic is specified. 8118 Allow it in all cases if -ms-extensions is specified. */ 8119 if ((!pedantic && current_lang_name == lang_name_c) 8120 || flag_ms_extensions) 8121 return; 8122 n = splay_tree_lookup (names_used, (splay_tree_key) name); 8123 if (n) 8124 { 8125 /* [basic.scope.class] 8126 8127 A name N used in a class S shall refer to the same declaration 8128 in its context and when re-evaluated in the completed scope of 8129 S. */ 8130 permerror (input_location, "declaration of %q#D", decl); 8131 permerror (input_location, "changes meaning of %qD from %q+#D", 8132 DECL_NAME (OVL_CURRENT (decl)), (tree) n->value); 8133 } 8134} 8135 8136/* Returns the VAR_DECL for the complete vtable associated with BINFO. 8137 Secondary vtables are merged with primary vtables; this function 8138 will return the VAR_DECL for the primary vtable. */ 8139 8140tree 8141get_vtbl_decl_for_binfo (tree binfo) 8142{ 8143 tree decl; 8144 8145 decl = BINFO_VTABLE (binfo); 8146 if (decl && TREE_CODE (decl) == POINTER_PLUS_EXPR) 8147 { 8148 gcc_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR); 8149 decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0); 8150 } 8151 if (decl) 8152 gcc_assert (VAR_P (decl)); 8153 return decl; 8154} 8155 8156 8157/* Returns the binfo for the primary base of BINFO. If the resulting 8158 BINFO is a virtual base, and it is inherited elsewhere in the 8159 hierarchy, then the returned binfo might not be the primary base of 8160 BINFO in the complete object. Check BINFO_PRIMARY_P or 8161 BINFO_LOST_PRIMARY_P to be sure. */ 8162 8163static tree 8164get_primary_binfo (tree binfo) 8165{ 8166 tree primary_base; 8167 8168 primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo)); 8169 if (!primary_base) 8170 return NULL_TREE; 8171 8172 return copied_binfo (primary_base, binfo); 8173} 8174 8175/* If INDENTED_P is zero, indent to INDENT. Return nonzero. */ 8176 8177static int 8178maybe_indent_hierarchy (FILE * stream, int indent, int indented_p) 8179{ 8180 if (!indented_p) 8181 fprintf (stream, "%*s", indent, ""); 8182 return 1; 8183} 8184 8185/* Dump the offsets of all the bases rooted at BINFO to STREAM. 8186 INDENT should be zero when called from the top level; it is 8187 incremented recursively. IGO indicates the next expected BINFO in 8188 inheritance graph ordering. */ 8189 8190static tree 8191dump_class_hierarchy_r (FILE *stream, 8192 int flags, 8193 tree binfo, 8194 tree igo, 8195 int indent) 8196{ 8197 int indented = 0; 8198 tree base_binfo; 8199 int i; 8200 8201 indented = maybe_indent_hierarchy (stream, indent, 0); 8202 fprintf (stream, "%s (0x" HOST_WIDE_INT_PRINT_HEX ") ", 8203 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER), 8204 (HOST_WIDE_INT) (uintptr_t) binfo); 8205 if (binfo != igo) 8206 { 8207 fprintf (stream, "alternative-path\n"); 8208 return igo; 8209 } 8210 igo = TREE_CHAIN (binfo); 8211 8212 fprintf (stream, HOST_WIDE_INT_PRINT_DEC, 8213 tree_to_shwi (BINFO_OFFSET (binfo))); 8214 if (is_empty_class (BINFO_TYPE (binfo))) 8215 fprintf (stream, " empty"); 8216 else if (CLASSTYPE_NEARLY_EMPTY_P (BINFO_TYPE (binfo))) 8217 fprintf (stream, " nearly-empty"); 8218 if (BINFO_VIRTUAL_P (binfo)) 8219 fprintf (stream, " virtual"); 8220 fprintf (stream, "\n"); 8221 8222 indented = 0; 8223 if (BINFO_PRIMARY_P (binfo)) 8224 { 8225 indented = maybe_indent_hierarchy (stream, indent + 3, indented); 8226 fprintf (stream, " primary-for %s (0x" HOST_WIDE_INT_PRINT_HEX ")", 8227 type_as_string (BINFO_TYPE (BINFO_INHERITANCE_CHAIN (binfo)), 8228 TFF_PLAIN_IDENTIFIER), 8229 (HOST_WIDE_INT) (uintptr_t) BINFO_INHERITANCE_CHAIN (binfo)); 8230 } 8231 if (BINFO_LOST_PRIMARY_P (binfo)) 8232 { 8233 indented = maybe_indent_hierarchy (stream, indent + 3, indented); 8234 fprintf (stream, " lost-primary"); 8235 } 8236 if (indented) 8237 fprintf (stream, "\n"); 8238 8239 if (!(flags & TDF_SLIM)) 8240 { 8241 int indented = 0; 8242 8243 if (BINFO_SUBVTT_INDEX (binfo)) 8244 { 8245 indented = maybe_indent_hierarchy (stream, indent + 3, indented); 8246 fprintf (stream, " subvttidx=%s", 8247 expr_as_string (BINFO_SUBVTT_INDEX (binfo), 8248 TFF_PLAIN_IDENTIFIER)); 8249 } 8250 if (BINFO_VPTR_INDEX (binfo)) 8251 { 8252 indented = maybe_indent_hierarchy (stream, indent + 3, indented); 8253 fprintf (stream, " vptridx=%s", 8254 expr_as_string (BINFO_VPTR_INDEX (binfo), 8255 TFF_PLAIN_IDENTIFIER)); 8256 } 8257 if (BINFO_VPTR_FIELD (binfo)) 8258 { 8259 indented = maybe_indent_hierarchy (stream, indent + 3, indented); 8260 fprintf (stream, " vbaseoffset=%s", 8261 expr_as_string (BINFO_VPTR_FIELD (binfo), 8262 TFF_PLAIN_IDENTIFIER)); 8263 } 8264 if (BINFO_VTABLE (binfo)) 8265 { 8266 indented = maybe_indent_hierarchy (stream, indent + 3, indented); 8267 fprintf (stream, " vptr=%s", 8268 expr_as_string (BINFO_VTABLE (binfo), 8269 TFF_PLAIN_IDENTIFIER)); 8270 } 8271 8272 if (indented) 8273 fprintf (stream, "\n"); 8274 } 8275 8276 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 8277 igo = dump_class_hierarchy_r (stream, flags, base_binfo, igo, indent + 2); 8278 8279 return igo; 8280} 8281 8282/* Dump the BINFO hierarchy for T. */ 8283 8284static void 8285dump_class_hierarchy_1 (FILE *stream, int flags, tree t) 8286{ 8287 fprintf (stream, "Class %s\n", type_as_string (t, TFF_PLAIN_IDENTIFIER)); 8288 fprintf (stream, " size=%lu align=%lu\n", 8289 (unsigned long)(tree_to_shwi (TYPE_SIZE (t)) / BITS_PER_UNIT), 8290 (unsigned long)(TYPE_ALIGN (t) / BITS_PER_UNIT)); 8291 fprintf (stream, " base size=%lu base align=%lu\n", 8292 (unsigned long)(tree_to_shwi (TYPE_SIZE (CLASSTYPE_AS_BASE (t))) 8293 / BITS_PER_UNIT), 8294 (unsigned long)(TYPE_ALIGN (CLASSTYPE_AS_BASE (t)) 8295 / BITS_PER_UNIT)); 8296 dump_class_hierarchy_r (stream, flags, TYPE_BINFO (t), TYPE_BINFO (t), 0); 8297 fprintf (stream, "\n"); 8298} 8299 8300/* Debug interface to hierarchy dumping. */ 8301 8302void 8303debug_class (tree t) 8304{ 8305 dump_class_hierarchy_1 (stderr, TDF_SLIM, t); 8306} 8307 8308static void 8309dump_class_hierarchy (tree t) 8310{ 8311 int flags; 8312 FILE *stream = get_dump_info (TDI_class, &flags); 8313 8314 if (stream) 8315 { 8316 dump_class_hierarchy_1 (stream, flags, t); 8317 } 8318} 8319 8320static void 8321dump_array (FILE * stream, tree decl) 8322{ 8323 tree value; 8324 unsigned HOST_WIDE_INT ix; 8325 HOST_WIDE_INT elt; 8326 tree size = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (decl))); 8327 8328 elt = (tree_to_shwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl)))) 8329 / BITS_PER_UNIT); 8330 fprintf (stream, "%s:", decl_as_string (decl, TFF_PLAIN_IDENTIFIER)); 8331 fprintf (stream, " %s entries", 8332 expr_as_string (size_binop (PLUS_EXPR, size, size_one_node), 8333 TFF_PLAIN_IDENTIFIER)); 8334 fprintf (stream, "\n"); 8335 8336 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)), 8337 ix, value) 8338 fprintf (stream, "%-4ld %s\n", (long)(ix * elt), 8339 expr_as_string (value, TFF_PLAIN_IDENTIFIER)); 8340} 8341 8342static void 8343dump_vtable (tree t, tree binfo, tree vtable) 8344{ 8345 int flags; 8346 FILE *stream = get_dump_info (TDI_class, &flags); 8347 8348 if (!stream) 8349 return; 8350 8351 if (!(flags & TDF_SLIM)) 8352 { 8353 int ctor_vtbl_p = TYPE_BINFO (t) != binfo; 8354 8355 fprintf (stream, "%s for %s", 8356 ctor_vtbl_p ? "Construction vtable" : "Vtable", 8357 type_as_string (BINFO_TYPE (binfo), TFF_PLAIN_IDENTIFIER)); 8358 if (ctor_vtbl_p) 8359 { 8360 if (!BINFO_VIRTUAL_P (binfo)) 8361 fprintf (stream, " (0x" HOST_WIDE_INT_PRINT_HEX " instance)", 8362 (HOST_WIDE_INT) (uintptr_t) binfo); 8363 fprintf (stream, " in %s", type_as_string (t, TFF_PLAIN_IDENTIFIER)); 8364 } 8365 fprintf (stream, "\n"); 8366 dump_array (stream, vtable); 8367 fprintf (stream, "\n"); 8368 } 8369} 8370 8371static void 8372dump_vtt (tree t, tree vtt) 8373{ 8374 int flags; 8375 FILE *stream = get_dump_info (TDI_class, &flags); 8376 8377 if (!stream) 8378 return; 8379 8380 if (!(flags & TDF_SLIM)) 8381 { 8382 fprintf (stream, "VTT for %s\n", 8383 type_as_string (t, TFF_PLAIN_IDENTIFIER)); 8384 dump_array (stream, vtt); 8385 fprintf (stream, "\n"); 8386 } 8387} 8388 8389/* Dump a function or thunk and its thunkees. */ 8390 8391static void 8392dump_thunk (FILE *stream, int indent, tree thunk) 8393{ 8394 static const char spaces[] = " "; 8395 tree name = DECL_NAME (thunk); 8396 tree thunks; 8397 8398 fprintf (stream, "%.*s%p %s %s", indent, spaces, 8399 (void *)thunk, 8400 !DECL_THUNK_P (thunk) ? "function" 8401 : DECL_THIS_THUNK_P (thunk) ? "this-thunk" : "covariant-thunk", 8402 name ? IDENTIFIER_POINTER (name) : "<unset>"); 8403 if (DECL_THUNK_P (thunk)) 8404 { 8405 HOST_WIDE_INT fixed_adjust = THUNK_FIXED_OFFSET (thunk); 8406 tree virtual_adjust = THUNK_VIRTUAL_OFFSET (thunk); 8407 8408 fprintf (stream, " fixed=" HOST_WIDE_INT_PRINT_DEC, fixed_adjust); 8409 if (!virtual_adjust) 8410 /*NOP*/; 8411 else if (DECL_THIS_THUNK_P (thunk)) 8412 fprintf (stream, " vcall=" HOST_WIDE_INT_PRINT_DEC, 8413 tree_to_shwi (virtual_adjust)); 8414 else 8415 fprintf (stream, " vbase=" HOST_WIDE_INT_PRINT_DEC "(%s)", 8416 tree_to_shwi (BINFO_VPTR_FIELD (virtual_adjust)), 8417 type_as_string (BINFO_TYPE (virtual_adjust), TFF_SCOPE)); 8418 if (THUNK_ALIAS (thunk)) 8419 fprintf (stream, " alias to %p", (void *)THUNK_ALIAS (thunk)); 8420 } 8421 fprintf (stream, "\n"); 8422 for (thunks = DECL_THUNKS (thunk); thunks; thunks = TREE_CHAIN (thunks)) 8423 dump_thunk (stream, indent + 2, thunks); 8424} 8425 8426/* Dump the thunks for FN. */ 8427 8428void 8429debug_thunks (tree fn) 8430{ 8431 dump_thunk (stderr, 0, fn); 8432} 8433 8434/* Virtual function table initialization. */ 8435 8436/* Create all the necessary vtables for T and its base classes. */ 8437 8438static void 8439finish_vtbls (tree t) 8440{ 8441 tree vbase; 8442 vec<constructor_elt, va_gc> *v = NULL; 8443 tree vtable = BINFO_VTABLE (TYPE_BINFO (t)); 8444 8445 /* We lay out the primary and secondary vtables in one contiguous 8446 vtable. The primary vtable is first, followed by the non-virtual 8447 secondary vtables in inheritance graph order. */ 8448 accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t), TYPE_BINFO (t), 8449 vtable, t, &v); 8450 8451 /* Then come the virtual bases, also in inheritance graph order. */ 8452 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase)) 8453 { 8454 if (!BINFO_VIRTUAL_P (vbase)) 8455 continue; 8456 accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), vtable, t, &v); 8457 } 8458 8459 if (BINFO_VTABLE (TYPE_BINFO (t))) 8460 initialize_vtable (TYPE_BINFO (t), v); 8461} 8462 8463/* Initialize the vtable for BINFO with the INITS. */ 8464 8465static void 8466initialize_vtable (tree binfo, vec<constructor_elt, va_gc> *inits) 8467{ 8468 tree decl; 8469 8470 layout_vtable_decl (binfo, vec_safe_length (inits)); 8471 decl = get_vtbl_decl_for_binfo (binfo); 8472 initialize_artificial_var (decl, inits); 8473 dump_vtable (BINFO_TYPE (binfo), binfo, decl); 8474} 8475 8476/* Build the VTT (virtual table table) for T. 8477 A class requires a VTT if it has virtual bases. 8478 8479 This holds 8480 1 - primary virtual pointer for complete object T 8481 2 - secondary VTTs for each direct non-virtual base of T which requires a 8482 VTT 8483 3 - secondary virtual pointers for each direct or indirect base of T which 8484 has virtual bases or is reachable via a virtual path from T. 8485 4 - secondary VTTs for each direct or indirect virtual base of T. 8486 8487 Secondary VTTs look like complete object VTTs without part 4. */ 8488 8489static void 8490build_vtt (tree t) 8491{ 8492 tree type; 8493 tree vtt; 8494 tree index; 8495 vec<constructor_elt, va_gc> *inits; 8496 8497 /* Build up the initializers for the VTT. */ 8498 inits = NULL; 8499 index = size_zero_node; 8500 build_vtt_inits (TYPE_BINFO (t), t, &inits, &index); 8501 8502 /* If we didn't need a VTT, we're done. */ 8503 if (!inits) 8504 return; 8505 8506 /* Figure out the type of the VTT. */ 8507 type = build_array_of_n_type (const_ptr_type_node, 8508 inits->length ()); 8509 8510 /* Now, build the VTT object itself. */ 8511 vtt = build_vtable (t, mangle_vtt_for_type (t), type); 8512 initialize_artificial_var (vtt, inits); 8513 /* Add the VTT to the vtables list. */ 8514 DECL_CHAIN (vtt) = DECL_CHAIN (CLASSTYPE_VTABLES (t)); 8515 DECL_CHAIN (CLASSTYPE_VTABLES (t)) = vtt; 8516 8517 dump_vtt (t, vtt); 8518} 8519 8520/* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with 8521 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo, 8522 and CHAIN the vtable pointer for this binfo after construction is 8523 complete. VALUE can also be another BINFO, in which case we recurse. */ 8524 8525static tree 8526binfo_ctor_vtable (tree binfo) 8527{ 8528 tree vt; 8529 8530 while (1) 8531 { 8532 vt = BINFO_VTABLE (binfo); 8533 if (TREE_CODE (vt) == TREE_LIST) 8534 vt = TREE_VALUE (vt); 8535 if (TREE_CODE (vt) == TREE_BINFO) 8536 binfo = vt; 8537 else 8538 break; 8539 } 8540 8541 return vt; 8542} 8543 8544/* Data for secondary VTT initialization. */ 8545typedef struct secondary_vptr_vtt_init_data_s 8546{ 8547 /* Is this the primary VTT? */ 8548 bool top_level_p; 8549 8550 /* Current index into the VTT. */ 8551 tree index; 8552 8553 /* Vector of initializers built up. */ 8554 vec<constructor_elt, va_gc> *inits; 8555 8556 /* The type being constructed by this secondary VTT. */ 8557 tree type_being_constructed; 8558} secondary_vptr_vtt_init_data; 8559 8560/* Recursively build the VTT-initializer for BINFO (which is in the 8561 hierarchy dominated by T). INITS points to the end of the initializer 8562 list to date. INDEX is the VTT index where the next element will be 8563 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e. 8564 not a subvtt for some base of T). When that is so, we emit the sub-VTTs 8565 for virtual bases of T. When it is not so, we build the constructor 8566 vtables for the BINFO-in-T variant. */ 8567 8568static void 8569build_vtt_inits (tree binfo, tree t, vec<constructor_elt, va_gc> **inits, 8570 tree *index) 8571{ 8572 int i; 8573 tree b; 8574 tree init; 8575 secondary_vptr_vtt_init_data data; 8576 int top_level_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t); 8577 8578 /* We only need VTTs for subobjects with virtual bases. */ 8579 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))) 8580 return; 8581 8582 /* We need to use a construction vtable if this is not the primary 8583 VTT. */ 8584 if (!top_level_p) 8585 { 8586 build_ctor_vtbl_group (binfo, t); 8587 8588 /* Record the offset in the VTT where this sub-VTT can be found. */ 8589 BINFO_SUBVTT_INDEX (binfo) = *index; 8590 } 8591 8592 /* Add the address of the primary vtable for the complete object. */ 8593 init = binfo_ctor_vtable (binfo); 8594 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init); 8595 if (top_level_p) 8596 { 8597 gcc_assert (!BINFO_VPTR_INDEX (binfo)); 8598 BINFO_VPTR_INDEX (binfo) = *index; 8599 } 8600 *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node)); 8601 8602 /* Recursively add the secondary VTTs for non-virtual bases. */ 8603 for (i = 0; BINFO_BASE_ITERATE (binfo, i, b); ++i) 8604 if (!BINFO_VIRTUAL_P (b)) 8605 build_vtt_inits (b, t, inits, index); 8606 8607 /* Add secondary virtual pointers for all subobjects of BINFO with 8608 either virtual bases or reachable along a virtual path, except 8609 subobjects that are non-virtual primary bases. */ 8610 data.top_level_p = top_level_p; 8611 data.index = *index; 8612 data.inits = *inits; 8613 data.type_being_constructed = BINFO_TYPE (binfo); 8614 8615 dfs_walk_once (binfo, dfs_build_secondary_vptr_vtt_inits, NULL, &data); 8616 8617 *index = data.index; 8618 8619 /* data.inits might have grown as we added secondary virtual pointers. 8620 Make sure our caller knows about the new vector. */ 8621 *inits = data.inits; 8622 8623 if (top_level_p) 8624 /* Add the secondary VTTs for virtual bases in inheritance graph 8625 order. */ 8626 for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b)) 8627 { 8628 if (!BINFO_VIRTUAL_P (b)) 8629 continue; 8630 8631 build_vtt_inits (b, t, inits, index); 8632 } 8633 else 8634 /* Remove the ctor vtables we created. */ 8635 dfs_walk_all (binfo, dfs_fixup_binfo_vtbls, NULL, binfo); 8636} 8637 8638/* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base 8639 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */ 8640 8641static tree 8642dfs_build_secondary_vptr_vtt_inits (tree binfo, void *data_) 8643{ 8644 secondary_vptr_vtt_init_data *data = (secondary_vptr_vtt_init_data *)data_; 8645 8646 /* We don't care about bases that don't have vtables. */ 8647 if (!TYPE_VFIELD (BINFO_TYPE (binfo))) 8648 return dfs_skip_bases; 8649 8650 /* We're only interested in proper subobjects of the type being 8651 constructed. */ 8652 if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), data->type_being_constructed)) 8653 return NULL_TREE; 8654 8655 /* We're only interested in bases with virtual bases or reachable 8656 via a virtual path from the type being constructed. */ 8657 if (!(CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)) 8658 || binfo_via_virtual (binfo, data->type_being_constructed))) 8659 return dfs_skip_bases; 8660 8661 /* We're not interested in non-virtual primary bases. */ 8662 if (!BINFO_VIRTUAL_P (binfo) && BINFO_PRIMARY_P (binfo)) 8663 return NULL_TREE; 8664 8665 /* Record the index where this secondary vptr can be found. */ 8666 if (data->top_level_p) 8667 { 8668 gcc_assert (!BINFO_VPTR_INDEX (binfo)); 8669 BINFO_VPTR_INDEX (binfo) = data->index; 8670 8671 if (BINFO_VIRTUAL_P (binfo)) 8672 { 8673 /* It's a primary virtual base, and this is not a 8674 construction vtable. Find the base this is primary of in 8675 the inheritance graph, and use that base's vtable 8676 now. */ 8677 while (BINFO_PRIMARY_P (binfo)) 8678 binfo = BINFO_INHERITANCE_CHAIN (binfo); 8679 } 8680 } 8681 8682 /* Add the initializer for the secondary vptr itself. */ 8683 CONSTRUCTOR_APPEND_ELT (data->inits, NULL_TREE, binfo_ctor_vtable (binfo)); 8684 8685 /* Advance the vtt index. */ 8686 data->index = size_binop (PLUS_EXPR, data->index, 8687 TYPE_SIZE_UNIT (ptr_type_node)); 8688 8689 return NULL_TREE; 8690} 8691 8692/* Called from build_vtt_inits via dfs_walk. After building 8693 constructor vtables and generating the sub-vtt from them, we need 8694 to restore the BINFO_VTABLES that were scribbled on. DATA is the 8695 binfo of the base whose sub vtt was generated. */ 8696 8697static tree 8698dfs_fixup_binfo_vtbls (tree binfo, void* data) 8699{ 8700 tree vtable = BINFO_VTABLE (binfo); 8701 8702 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) 8703 /* If this class has no vtable, none of its bases do. */ 8704 return dfs_skip_bases; 8705 8706 if (!vtable) 8707 /* This might be a primary base, so have no vtable in this 8708 hierarchy. */ 8709 return NULL_TREE; 8710 8711 /* If we scribbled the construction vtable vptr into BINFO, clear it 8712 out now. */ 8713 if (TREE_CODE (vtable) == TREE_LIST 8714 && (TREE_PURPOSE (vtable) == (tree) data)) 8715 BINFO_VTABLE (binfo) = TREE_CHAIN (vtable); 8716 8717 return NULL_TREE; 8718} 8719 8720/* Build the construction vtable group for BINFO which is in the 8721 hierarchy dominated by T. */ 8722 8723static void 8724build_ctor_vtbl_group (tree binfo, tree t) 8725{ 8726 tree type; 8727 tree vtbl; 8728 tree id; 8729 tree vbase; 8730 vec<constructor_elt, va_gc> *v; 8731 8732 /* See if we've already created this construction vtable group. */ 8733 id = mangle_ctor_vtbl_for_type (t, binfo); 8734 if (IDENTIFIER_GLOBAL_VALUE (id)) 8735 return; 8736 8737 gcc_assert (!SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t)); 8738 /* Build a version of VTBL (with the wrong type) for use in 8739 constructing the addresses of secondary vtables in the 8740 construction vtable group. */ 8741 vtbl = build_vtable (t, id, ptr_type_node); 8742 DECL_CONSTRUCTION_VTABLE_P (vtbl) = 1; 8743 /* Don't export construction vtables from shared libraries. Even on 8744 targets that don't support hidden visibility, this tells 8745 can_refer_decl_in_current_unit_p not to assume that it's safe to 8746 access from a different compilation unit (bz 54314). */ 8747 DECL_VISIBILITY (vtbl) = VISIBILITY_HIDDEN; 8748 DECL_VISIBILITY_SPECIFIED (vtbl) = true; 8749 8750 v = NULL; 8751 accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)), 8752 binfo, vtbl, t, &v); 8753 8754 /* Add the vtables for each of our virtual bases using the vbase in T 8755 binfo. */ 8756 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo)); 8757 vbase; 8758 vbase = TREE_CHAIN (vbase)) 8759 { 8760 tree b; 8761 8762 if (!BINFO_VIRTUAL_P (vbase)) 8763 continue; 8764 b = copied_binfo (vbase, binfo); 8765 8766 accumulate_vtbl_inits (b, vbase, binfo, vtbl, t, &v); 8767 } 8768 8769 /* Figure out the type of the construction vtable. */ 8770 type = build_array_of_n_type (vtable_entry_type, v->length ()); 8771 layout_type (type); 8772 TREE_TYPE (vtbl) = type; 8773 DECL_SIZE (vtbl) = DECL_SIZE_UNIT (vtbl) = NULL_TREE; 8774 layout_decl (vtbl, 0); 8775 8776 /* Initialize the construction vtable. */ 8777 CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl); 8778 initialize_artificial_var (vtbl, v); 8779 dump_vtable (t, binfo, vtbl); 8780} 8781 8782/* Add the vtbl initializers for BINFO (and its bases other than 8783 non-virtual primaries) to the list of INITS. BINFO is in the 8784 hierarchy dominated by T. RTTI_BINFO is the binfo within T of 8785 the constructor the vtbl inits should be accumulated for. (If this 8786 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).) 8787 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO). 8788 BINFO is the active base equivalent of ORIG_BINFO in the inheritance 8789 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE, 8790 but are not necessarily the same in terms of layout. */ 8791 8792static void 8793accumulate_vtbl_inits (tree binfo, 8794 tree orig_binfo, 8795 tree rtti_binfo, 8796 tree vtbl, 8797 tree t, 8798 vec<constructor_elt, va_gc> **inits) 8799{ 8800 int i; 8801 tree base_binfo; 8802 int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t); 8803 8804 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (orig_binfo))); 8805 8806 /* If it doesn't have a vptr, we don't do anything. */ 8807 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) 8808 return; 8809 8810 /* If we're building a construction vtable, we're not interested in 8811 subobjects that don't require construction vtables. */ 8812 if (ctor_vtbl_p 8813 && !CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo)) 8814 && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo))) 8815 return; 8816 8817 /* Build the initializers for the BINFO-in-T vtable. */ 8818 dfs_accumulate_vtbl_inits (binfo, orig_binfo, rtti_binfo, vtbl, t, inits); 8819 8820 /* Walk the BINFO and its bases. We walk in preorder so that as we 8821 initialize each vtable we can figure out at what offset the 8822 secondary vtable lies from the primary vtable. We can't use 8823 dfs_walk here because we need to iterate through bases of BINFO 8824 and RTTI_BINFO simultaneously. */ 8825 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 8826 { 8827 /* Skip virtual bases. */ 8828 if (BINFO_VIRTUAL_P (base_binfo)) 8829 continue; 8830 accumulate_vtbl_inits (base_binfo, 8831 BINFO_BASE_BINFO (orig_binfo, i), 8832 rtti_binfo, vtbl, t, 8833 inits); 8834 } 8835} 8836 8837/* Called from accumulate_vtbl_inits. Adds the initializers for the 8838 BINFO vtable to L. */ 8839 8840static void 8841dfs_accumulate_vtbl_inits (tree binfo, 8842 tree orig_binfo, 8843 tree rtti_binfo, 8844 tree orig_vtbl, 8845 tree t, 8846 vec<constructor_elt, va_gc> **l) 8847{ 8848 tree vtbl = NULL_TREE; 8849 int ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t); 8850 int n_inits; 8851 8852 if (ctor_vtbl_p 8853 && BINFO_VIRTUAL_P (orig_binfo) && BINFO_PRIMARY_P (orig_binfo)) 8854 { 8855 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a 8856 primary virtual base. If it is not the same primary in 8857 the hierarchy of T, we'll need to generate a ctor vtable 8858 for it, to place at its location in T. If it is the same 8859 primary, we still need a VTT entry for the vtable, but it 8860 should point to the ctor vtable for the base it is a 8861 primary for within the sub-hierarchy of RTTI_BINFO. 8862 8863 There are three possible cases: 8864 8865 1) We are in the same place. 8866 2) We are a primary base within a lost primary virtual base of 8867 RTTI_BINFO. 8868 3) We are primary to something not a base of RTTI_BINFO. */ 8869 8870 tree b; 8871 tree last = NULL_TREE; 8872 8873 /* First, look through the bases we are primary to for RTTI_BINFO 8874 or a virtual base. */ 8875 b = binfo; 8876 while (BINFO_PRIMARY_P (b)) 8877 { 8878 b = BINFO_INHERITANCE_CHAIN (b); 8879 last = b; 8880 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo) 8881 goto found; 8882 } 8883 /* If we run out of primary links, keep looking down our 8884 inheritance chain; we might be an indirect primary. */ 8885 for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b)) 8886 if (BINFO_VIRTUAL_P (b) || b == rtti_binfo) 8887 break; 8888 found: 8889 8890 /* If we found RTTI_BINFO, this is case 1. If we found a virtual 8891 base B and it is a base of RTTI_BINFO, this is case 2. In 8892 either case, we share our vtable with LAST, i.e. the 8893 derived-most base within B of which we are a primary. */ 8894 if (b == rtti_binfo 8895 || (b && binfo_for_vbase (BINFO_TYPE (b), BINFO_TYPE (rtti_binfo)))) 8896 /* Just set our BINFO_VTABLE to point to LAST, as we may not have 8897 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in 8898 binfo_ctor_vtable after everything's been set up. */ 8899 vtbl = last; 8900 8901 /* Otherwise, this is case 3 and we get our own. */ 8902 } 8903 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo)) 8904 return; 8905 8906 n_inits = vec_safe_length (*l); 8907 8908 if (!vtbl) 8909 { 8910 tree index; 8911 int non_fn_entries; 8912 8913 /* Add the initializer for this vtable. */ 8914 build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo, 8915 &non_fn_entries, l); 8916 8917 /* Figure out the position to which the VPTR should point. */ 8918 vtbl = build1 (ADDR_EXPR, vtbl_ptr_type_node, orig_vtbl); 8919 index = size_binop (MULT_EXPR, 8920 TYPE_SIZE_UNIT (vtable_entry_type), 8921 size_int (non_fn_entries + n_inits)); 8922 vtbl = fold_build_pointer_plus (vtbl, index); 8923 } 8924 8925 if (ctor_vtbl_p) 8926 /* For a construction vtable, we can't overwrite BINFO_VTABLE. 8927 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will 8928 straighten this out. */ 8929 BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo)); 8930 else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo)) 8931 /* Throw away any unneeded intializers. */ 8932 (*l)->truncate (n_inits); 8933 else 8934 /* For an ordinary vtable, set BINFO_VTABLE. */ 8935 BINFO_VTABLE (binfo) = vtbl; 8936} 8937 8938static GTY(()) tree abort_fndecl_addr; 8939 8940/* Construct the initializer for BINFO's virtual function table. BINFO 8941 is part of the hierarchy dominated by T. If we're building a 8942 construction vtable, the ORIG_BINFO is the binfo we should use to 8943 find the actual function pointers to put in the vtable - but they 8944 can be overridden on the path to most-derived in the graph that 8945 ORIG_BINFO belongs. Otherwise, 8946 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the 8947 BINFO that should be indicated by the RTTI information in the 8948 vtable; it will be a base class of T, rather than T itself, if we 8949 are building a construction vtable. 8950 8951 The value returned is a TREE_LIST suitable for wrapping in a 8952 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If 8953 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the 8954 number of non-function entries in the vtable. 8955 8956 It might seem that this function should never be called with a 8957 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a 8958 base is always subsumed by a derived class vtable. However, when 8959 we are building construction vtables, we do build vtables for 8960 primary bases; we need these while the primary base is being 8961 constructed. */ 8962 8963static void 8964build_vtbl_initializer (tree binfo, 8965 tree orig_binfo, 8966 tree t, 8967 tree rtti_binfo, 8968 int* non_fn_entries_p, 8969 vec<constructor_elt, va_gc> **inits) 8970{ 8971 tree v; 8972 vtbl_init_data vid; 8973 unsigned ix, jx; 8974 tree vbinfo; 8975 vec<tree, va_gc> *vbases; 8976 constructor_elt *e; 8977 8978 /* Initialize VID. */ 8979 memset (&vid, 0, sizeof (vid)); 8980 vid.binfo = binfo; 8981 vid.derived = t; 8982 vid.rtti_binfo = rtti_binfo; 8983 vid.primary_vtbl_p = SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), t); 8984 vid.ctor_vtbl_p = !SAME_BINFO_TYPE_P (BINFO_TYPE (rtti_binfo), t); 8985 vid.generate_vcall_entries = true; 8986 /* The first vbase or vcall offset is at index -3 in the vtable. */ 8987 vid.index = ssize_int(-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE); 8988 8989 /* Add entries to the vtable for RTTI. */ 8990 build_rtti_vtbl_entries (binfo, &vid); 8991 8992 /* Create an array for keeping track of the functions we've 8993 processed. When we see multiple functions with the same 8994 signature, we share the vcall offsets. */ 8995 vec_alloc (vid.fns, 32); 8996 /* Add the vcall and vbase offset entries. */ 8997 build_vcall_and_vbase_vtbl_entries (binfo, &vid); 8998 8999 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by 9000 build_vbase_offset_vtbl_entries. */ 9001 for (vbases = CLASSTYPE_VBASECLASSES (t), ix = 0; 9002 vec_safe_iterate (vbases, ix, &vbinfo); ix++) 9003 BINFO_VTABLE_PATH_MARKED (vbinfo) = 0; 9004 9005 /* If the target requires padding between data entries, add that now. */ 9006 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1) 9007 { 9008 int n_entries = vec_safe_length (vid.inits); 9009 9010 vec_safe_grow (vid.inits, TARGET_VTABLE_DATA_ENTRY_DISTANCE * n_entries); 9011 9012 /* Move data entries into their new positions and add padding 9013 after the new positions. Iterate backwards so we don't 9014 overwrite entries that we would need to process later. */ 9015 for (ix = n_entries - 1; 9016 vid.inits->iterate (ix, &e); 9017 ix--) 9018 { 9019 int j; 9020 int new_position = (TARGET_VTABLE_DATA_ENTRY_DISTANCE * ix 9021 + (TARGET_VTABLE_DATA_ENTRY_DISTANCE - 1)); 9022 9023 (*vid.inits)[new_position] = *e; 9024 9025 for (j = 1; j < TARGET_VTABLE_DATA_ENTRY_DISTANCE; ++j) 9026 { 9027 constructor_elt *f = &(*vid.inits)[new_position - j]; 9028 f->index = NULL_TREE; 9029 f->value = build1 (NOP_EXPR, vtable_entry_type, 9030 null_pointer_node); 9031 } 9032 } 9033 } 9034 9035 if (non_fn_entries_p) 9036 *non_fn_entries_p = vec_safe_length (vid.inits); 9037 9038 /* The initializers for virtual functions were built up in reverse 9039 order. Straighten them out and add them to the running list in one 9040 step. */ 9041 jx = vec_safe_length (*inits); 9042 vec_safe_grow (*inits, jx + vid.inits->length ()); 9043 9044 for (ix = vid.inits->length () - 1; 9045 vid.inits->iterate (ix, &e); 9046 ix--, jx++) 9047 (**inits)[jx] = *e; 9048 9049 /* Go through all the ordinary virtual functions, building up 9050 initializers. */ 9051 for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v)) 9052 { 9053 tree delta; 9054 tree vcall_index; 9055 tree fn, fn_original; 9056 tree init = NULL_TREE; 9057 9058 fn = BV_FN (v); 9059 fn_original = fn; 9060 if (DECL_THUNK_P (fn)) 9061 { 9062 if (!DECL_NAME (fn)) 9063 finish_thunk (fn); 9064 if (THUNK_ALIAS (fn)) 9065 { 9066 fn = THUNK_ALIAS (fn); 9067 BV_FN (v) = fn; 9068 } 9069 fn_original = THUNK_TARGET (fn); 9070 } 9071 9072 /* If the only definition of this function signature along our 9073 primary base chain is from a lost primary, this vtable slot will 9074 never be used, so just zero it out. This is important to avoid 9075 requiring extra thunks which cannot be generated with the function. 9076 9077 We first check this in update_vtable_entry_for_fn, so we handle 9078 restored primary bases properly; we also need to do it here so we 9079 zero out unused slots in ctor vtables, rather than filling them 9080 with erroneous values (though harmless, apart from relocation 9081 costs). */ 9082 if (BV_LOST_PRIMARY (v)) 9083 init = size_zero_node; 9084 9085 if (! init) 9086 { 9087 /* Pull the offset for `this', and the function to call, out of 9088 the list. */ 9089 delta = BV_DELTA (v); 9090 vcall_index = BV_VCALL_INDEX (v); 9091 9092 gcc_assert (TREE_CODE (delta) == INTEGER_CST); 9093 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL); 9094 9095 /* You can't call an abstract virtual function; it's abstract. 9096 So, we replace these functions with __pure_virtual. */ 9097 if (DECL_PURE_VIRTUAL_P (fn_original)) 9098 { 9099 fn = abort_fndecl; 9100 if (!TARGET_VTABLE_USES_DESCRIPTORS) 9101 { 9102 if (abort_fndecl_addr == NULL) 9103 abort_fndecl_addr 9104 = fold_convert (vfunc_ptr_type_node, 9105 build_fold_addr_expr (fn)); 9106 init = abort_fndecl_addr; 9107 } 9108 } 9109 /* Likewise for deleted virtuals. */ 9110 else if (DECL_DELETED_FN (fn_original)) 9111 { 9112 fn = get_identifier ("__cxa_deleted_virtual"); 9113 if (!get_global_value_if_present (fn, &fn)) 9114 fn = push_library_fn (fn, (build_function_type_list 9115 (void_type_node, NULL_TREE)), 9116 NULL_TREE, ECF_NORETURN); 9117 if (!TARGET_VTABLE_USES_DESCRIPTORS) 9118 init = fold_convert (vfunc_ptr_type_node, 9119 build_fold_addr_expr (fn)); 9120 } 9121 else 9122 { 9123 if (!integer_zerop (delta) || vcall_index) 9124 { 9125 fn = make_thunk (fn, /*this_adjusting=*/1, delta, vcall_index); 9126 if (!DECL_NAME (fn)) 9127 finish_thunk (fn); 9128 } 9129 /* Take the address of the function, considering it to be of an 9130 appropriate generic type. */ 9131 if (!TARGET_VTABLE_USES_DESCRIPTORS) 9132 init = fold_convert (vfunc_ptr_type_node, 9133 build_fold_addr_expr (fn)); 9134 /* Don't refer to a virtual destructor from a constructor 9135 vtable or a vtable for an abstract class, since destroying 9136 an object under construction is undefined behavior and we 9137 don't want it to be considered a candidate for speculative 9138 devirtualization. But do create the thunk for ABI 9139 compliance. */ 9140 if (DECL_DESTRUCTOR_P (fn_original) 9141 && (CLASSTYPE_PURE_VIRTUALS (DECL_CONTEXT (fn_original)) 9142 || orig_binfo != binfo)) 9143 init = size_zero_node; 9144 } 9145 } 9146 9147 /* And add it to the chain of initializers. */ 9148 if (TARGET_VTABLE_USES_DESCRIPTORS) 9149 { 9150 int i; 9151 if (init == size_zero_node) 9152 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i) 9153 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init); 9154 else 9155 for (i = 0; i < TARGET_VTABLE_USES_DESCRIPTORS; ++i) 9156 { 9157 tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node, 9158 fn, build_int_cst (NULL_TREE, i)); 9159 TREE_CONSTANT (fdesc) = 1; 9160 9161 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, fdesc); 9162 } 9163 } 9164 else 9165 CONSTRUCTOR_APPEND_ELT (*inits, NULL_TREE, init); 9166 } 9167} 9168 9169/* Adds to vid->inits the initializers for the vbase and vcall 9170 offsets in BINFO, which is in the hierarchy dominated by T. */ 9171 9172static void 9173build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data* vid) 9174{ 9175 tree b; 9176 9177 /* If this is a derived class, we must first create entries 9178 corresponding to the primary base class. */ 9179 b = get_primary_binfo (binfo); 9180 if (b) 9181 build_vcall_and_vbase_vtbl_entries (b, vid); 9182 9183 /* Add the vbase entries for this base. */ 9184 build_vbase_offset_vtbl_entries (binfo, vid); 9185 /* Add the vcall entries for this base. */ 9186 build_vcall_offset_vtbl_entries (binfo, vid); 9187} 9188 9189/* Returns the initializers for the vbase offset entries in the vtable 9190 for BINFO (which is part of the class hierarchy dominated by T), in 9191 reverse order. VBASE_OFFSET_INDEX gives the vtable index 9192 where the next vbase offset will go. */ 9193 9194static void 9195build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid) 9196{ 9197 tree vbase; 9198 tree t; 9199 tree non_primary_binfo; 9200 9201 /* If there are no virtual baseclasses, then there is nothing to 9202 do. */ 9203 if (!CLASSTYPE_VBASECLASSES (BINFO_TYPE (binfo))) 9204 return; 9205 9206 t = vid->derived; 9207 9208 /* We might be a primary base class. Go up the inheritance hierarchy 9209 until we find the most derived class of which we are a primary base: 9210 it is the offset of that which we need to use. */ 9211 non_primary_binfo = binfo; 9212 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo)) 9213 { 9214 tree b; 9215 9216 /* If we have reached a virtual base, then it must be a primary 9217 base (possibly multi-level) of vid->binfo, or we wouldn't 9218 have called build_vcall_and_vbase_vtbl_entries for it. But it 9219 might be a lost primary, so just skip down to vid->binfo. */ 9220 if (BINFO_VIRTUAL_P (non_primary_binfo)) 9221 { 9222 non_primary_binfo = vid->binfo; 9223 break; 9224 } 9225 9226 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo); 9227 if (get_primary_binfo (b) != non_primary_binfo) 9228 break; 9229 non_primary_binfo = b; 9230 } 9231 9232 /* Go through the virtual bases, adding the offsets. */ 9233 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo)); 9234 vbase; 9235 vbase = TREE_CHAIN (vbase)) 9236 { 9237 tree b; 9238 tree delta; 9239 9240 if (!BINFO_VIRTUAL_P (vbase)) 9241 continue; 9242 9243 /* Find the instance of this virtual base in the complete 9244 object. */ 9245 b = copied_binfo (vbase, binfo); 9246 9247 /* If we've already got an offset for this virtual base, we 9248 don't need another one. */ 9249 if (BINFO_VTABLE_PATH_MARKED (b)) 9250 continue; 9251 BINFO_VTABLE_PATH_MARKED (b) = 1; 9252 9253 /* Figure out where we can find this vbase offset. */ 9254 delta = size_binop (MULT_EXPR, 9255 vid->index, 9256 convert (ssizetype, 9257 TYPE_SIZE_UNIT (vtable_entry_type))); 9258 if (vid->primary_vtbl_p) 9259 BINFO_VPTR_FIELD (b) = delta; 9260 9261 if (binfo != TYPE_BINFO (t)) 9262 /* The vbase offset had better be the same. */ 9263 gcc_assert (tree_int_cst_equal (delta, BINFO_VPTR_FIELD (vbase))); 9264 9265 /* The next vbase will come at a more negative offset. */ 9266 vid->index = size_binop (MINUS_EXPR, vid->index, 9267 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE)); 9268 9269 /* The initializer is the delta from BINFO to this virtual base. 9270 The vbase offsets go in reverse inheritance-graph order, and 9271 we are walking in inheritance graph order so these end up in 9272 the right order. */ 9273 delta = size_diffop_loc (input_location, 9274 BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo)); 9275 9276 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, 9277 fold_build1_loc (input_location, NOP_EXPR, 9278 vtable_entry_type, delta)); 9279 } 9280} 9281 9282/* Adds the initializers for the vcall offset entries in the vtable 9283 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED) 9284 to VID->INITS. */ 9285 9286static void 9287build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data* vid) 9288{ 9289 /* We only need these entries if this base is a virtual base. We 9290 compute the indices -- but do not add to the vtable -- when 9291 building the main vtable for a class. */ 9292 if (binfo == TYPE_BINFO (vid->derived) 9293 || (BINFO_VIRTUAL_P (binfo) 9294 /* If BINFO is RTTI_BINFO, then (since BINFO does not 9295 correspond to VID->DERIVED), we are building a primary 9296 construction virtual table. Since this is a primary 9297 virtual table, we do not need the vcall offsets for 9298 BINFO. */ 9299 && binfo != vid->rtti_binfo)) 9300 { 9301 /* We need a vcall offset for each of the virtual functions in this 9302 vtable. For example: 9303 9304 class A { virtual void f (); }; 9305 class B1 : virtual public A { virtual void f (); }; 9306 class B2 : virtual public A { virtual void f (); }; 9307 class C: public B1, public B2 { virtual void f (); }; 9308 9309 A C object has a primary base of B1, which has a primary base of A. A 9310 C also has a secondary base of B2, which no longer has a primary base 9311 of A. So the B2-in-C construction vtable needs a secondary vtable for 9312 A, which will adjust the A* to a B2* to call f. We have no way of 9313 knowing what (or even whether) this offset will be when we define B2, 9314 so we store this "vcall offset" in the A sub-vtable and look it up in 9315 a "virtual thunk" for B2::f. 9316 9317 We need entries for all the functions in our primary vtable and 9318 in our non-virtual bases' secondary vtables. */ 9319 vid->vbase = binfo; 9320 /* If we are just computing the vcall indices -- but do not need 9321 the actual entries -- not that. */ 9322 if (!BINFO_VIRTUAL_P (binfo)) 9323 vid->generate_vcall_entries = false; 9324 /* Now, walk through the non-virtual bases, adding vcall offsets. */ 9325 add_vcall_offset_vtbl_entries_r (binfo, vid); 9326 } 9327} 9328 9329/* Build vcall offsets, starting with those for BINFO. */ 9330 9331static void 9332add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data* vid) 9333{ 9334 int i; 9335 tree primary_binfo; 9336 tree base_binfo; 9337 9338 /* Don't walk into virtual bases -- except, of course, for the 9339 virtual base for which we are building vcall offsets. Any 9340 primary virtual base will have already had its offsets generated 9341 through the recursion in build_vcall_and_vbase_vtbl_entries. */ 9342 if (BINFO_VIRTUAL_P (binfo) && vid->vbase != binfo) 9343 return; 9344 9345 /* If BINFO has a primary base, process it first. */ 9346 primary_binfo = get_primary_binfo (binfo); 9347 if (primary_binfo) 9348 add_vcall_offset_vtbl_entries_r (primary_binfo, vid); 9349 9350 /* Add BINFO itself to the list. */ 9351 add_vcall_offset_vtbl_entries_1 (binfo, vid); 9352 9353 /* Scan the non-primary bases of BINFO. */ 9354 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 9355 if (base_binfo != primary_binfo) 9356 add_vcall_offset_vtbl_entries_r (base_binfo, vid); 9357} 9358 9359/* Called from build_vcall_offset_vtbl_entries_r. */ 9360 9361static void 9362add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data* vid) 9363{ 9364 /* Make entries for the rest of the virtuals. */ 9365 tree orig_fn; 9366 9367 /* The ABI requires that the methods be processed in declaration 9368 order. */ 9369 for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo)); 9370 orig_fn; 9371 orig_fn = DECL_CHAIN (orig_fn)) 9372 if (TREE_CODE (orig_fn) == FUNCTION_DECL && DECL_VINDEX (orig_fn)) 9373 add_vcall_offset (orig_fn, binfo, vid); 9374} 9375 9376/* Add a vcall offset entry for ORIG_FN to the vtable. */ 9377 9378static void 9379add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid) 9380{ 9381 size_t i; 9382 tree vcall_offset; 9383 tree derived_entry; 9384 9385 /* If there is already an entry for a function with the same 9386 signature as FN, then we do not need a second vcall offset. 9387 Check the list of functions already present in the derived 9388 class vtable. */ 9389 FOR_EACH_VEC_SAFE_ELT (vid->fns, i, derived_entry) 9390 { 9391 if (same_signature_p (derived_entry, orig_fn) 9392 /* We only use one vcall offset for virtual destructors, 9393 even though there are two virtual table entries. */ 9394 || (DECL_DESTRUCTOR_P (derived_entry) 9395 && DECL_DESTRUCTOR_P (orig_fn))) 9396 return; 9397 } 9398 9399 /* If we are building these vcall offsets as part of building 9400 the vtable for the most derived class, remember the vcall 9401 offset. */ 9402 if (vid->binfo == TYPE_BINFO (vid->derived)) 9403 { 9404 tree_pair_s elt = {orig_fn, vid->index}; 9405 vec_safe_push (CLASSTYPE_VCALL_INDICES (vid->derived), elt); 9406 } 9407 9408 /* The next vcall offset will be found at a more negative 9409 offset. */ 9410 vid->index = size_binop (MINUS_EXPR, vid->index, 9411 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE)); 9412 9413 /* Keep track of this function. */ 9414 vec_safe_push (vid->fns, orig_fn); 9415 9416 if (vid->generate_vcall_entries) 9417 { 9418 tree base; 9419 tree fn; 9420 9421 /* Find the overriding function. */ 9422 fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn); 9423 if (fn == error_mark_node) 9424 vcall_offset = build_zero_cst (vtable_entry_type); 9425 else 9426 { 9427 base = TREE_VALUE (fn); 9428 9429 /* The vbase we're working on is a primary base of 9430 vid->binfo. But it might be a lost primary, so its 9431 BINFO_OFFSET might be wrong, so we just use the 9432 BINFO_OFFSET from vid->binfo. */ 9433 vcall_offset = size_diffop_loc (input_location, 9434 BINFO_OFFSET (base), 9435 BINFO_OFFSET (vid->binfo)); 9436 vcall_offset = fold_build1_loc (input_location, 9437 NOP_EXPR, vtable_entry_type, 9438 vcall_offset); 9439 } 9440 /* Add the initializer to the vtable. */ 9441 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, vcall_offset); 9442 } 9443} 9444 9445/* Return vtbl initializers for the RTTI entries corresponding to the 9446 BINFO's vtable. The RTTI entries should indicate the object given 9447 by VID->rtti_binfo. */ 9448 9449static void 9450build_rtti_vtbl_entries (tree binfo, vtbl_init_data* vid) 9451{ 9452 tree b; 9453 tree t; 9454 tree offset; 9455 tree decl; 9456 tree init; 9457 9458 t = BINFO_TYPE (vid->rtti_binfo); 9459 9460 /* To find the complete object, we will first convert to our most 9461 primary base, and then add the offset in the vtbl to that value. */ 9462 b = binfo; 9463 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b)) 9464 && !BINFO_LOST_PRIMARY_P (b)) 9465 { 9466 tree primary_base; 9467 9468 primary_base = get_primary_binfo (b); 9469 gcc_assert (BINFO_PRIMARY_P (primary_base) 9470 && BINFO_INHERITANCE_CHAIN (primary_base) == b); 9471 b = primary_base; 9472 } 9473 offset = size_diffop_loc (input_location, 9474 BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b)); 9475 9476 /* The second entry is the address of the typeinfo object. */ 9477 if (flag_rtti) 9478 decl = build_address (get_tinfo_decl (t)); 9479 else 9480 decl = integer_zero_node; 9481 9482 /* Convert the declaration to a type that can be stored in the 9483 vtable. */ 9484 init = build_nop (vfunc_ptr_type_node, decl); 9485 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init); 9486 9487 /* Add the offset-to-top entry. It comes earlier in the vtable than 9488 the typeinfo entry. Convert the offset to look like a 9489 function pointer, so that we can put it in the vtable. */ 9490 init = build_nop (vfunc_ptr_type_node, offset); 9491 CONSTRUCTOR_APPEND_ELT (vid->inits, NULL_TREE, init); 9492} 9493 9494/* TRUE iff TYPE is uniquely derived from PARENT. Ignores 9495 accessibility. */ 9496 9497bool 9498uniquely_derived_from_p (tree parent, tree type) 9499{ 9500 tree base = lookup_base (type, parent, ba_unique, NULL, tf_none); 9501 return base && base != error_mark_node; 9502} 9503 9504/* TRUE iff TYPE is publicly & uniquely derived from PARENT. */ 9505 9506bool 9507publicly_uniquely_derived_p (tree parent, tree type) 9508{ 9509 tree base = lookup_base (type, parent, ba_ignore_scope | ba_check, 9510 NULL, tf_none); 9511 return base && base != error_mark_node; 9512} 9513 9514/* CTX1 and CTX2 are declaration contexts. Return the innermost common 9515 class between them, if any. */ 9516 9517tree 9518common_enclosing_class (tree ctx1, tree ctx2) 9519{ 9520 if (!TYPE_P (ctx1) || !TYPE_P (ctx2)) 9521 return NULL_TREE; 9522 gcc_assert (ctx1 == TYPE_MAIN_VARIANT (ctx1) 9523 && ctx2 == TYPE_MAIN_VARIANT (ctx2)); 9524 if (ctx1 == ctx2) 9525 return ctx1; 9526 for (tree t = ctx1; TYPE_P (t); t = TYPE_CONTEXT (t)) 9527 TYPE_MARKED_P (t) = true; 9528 tree found = NULL_TREE; 9529 for (tree t = ctx2; TYPE_P (t); t = TYPE_CONTEXT (t)) 9530 if (TYPE_MARKED_P (t)) 9531 { 9532 found = t; 9533 break; 9534 } 9535 for (tree t = ctx1; TYPE_P (t); t = TYPE_CONTEXT (t)) 9536 TYPE_MARKED_P (t) = false; 9537 return found; 9538} 9539 9540#include "gt-cp-class.h" 9541