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