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