1 /* Basic IPA utilities for type inheritance graph construction and 2 devirtualization. 3 Copyright (C) 2013-2020 Free Software Foundation, Inc. 4 Contributed by Jan Hubicka 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 /* Brief vocabulary: 23 ODR = One Definition Rule 24 In short, the ODR states that: 25 1 In any translation unit, a template, type, function, or object can 26 have no more than one definition. Some of these can have any number 27 of declarations. A definition provides an instance. 28 2 In the entire program, an object or non-inline function cannot have 29 more than one definition; if an object or function is used, it must 30 have exactly one definition. You can declare an object or function 31 that is never used, in which case you don't have to provide 32 a definition. In no event can there be more than one definition. 33 3 Some things, like types, templates, and extern inline functions, can 34 be defined in more than one translation unit. For a given entity, 35 each definition must be the same. Non-extern objects and functions 36 in different translation units are different entities, even if their 37 names and types are the same. 38 39 OTR = OBJ_TYPE_REF 40 This is the Gimple representation of type information of a polymorphic call. 41 It contains two parameters: 42 otr_type is a type of class whose method is called. 43 otr_token is the index into virtual table where address is taken. 44 45 BINFO 46 This is the type inheritance information attached to each tree 47 RECORD_TYPE by the C++ frontend. It provides information about base 48 types and virtual tables. 49 50 BINFO is linked to the RECORD_TYPE by TYPE_BINFO. 51 BINFO also links to its type by BINFO_TYPE and to the virtual table by 52 BINFO_VTABLE. 53 54 Base types of a given type are enumerated by BINFO_BASE_BINFO 55 vector. Members of this vectors are not BINFOs associated 56 with a base type. Rather they are new copies of BINFOs 57 (base BINFOs). Their virtual tables may differ from 58 virtual table of the base type. Also BINFO_OFFSET specifies 59 offset of the base within the type. 60 61 In the case of single inheritance, the virtual table is shared 62 and BINFO_VTABLE of base BINFO is NULL. In the case of multiple 63 inheritance the individual virtual tables are pointer to by 64 BINFO_VTABLE of base binfos (that differs of BINFO_VTABLE of 65 binfo associated to the base type). 66 67 BINFO lookup for a given base type and offset can be done by 68 get_binfo_at_offset. It returns proper BINFO whose virtual table 69 can be used for lookup of virtual methods associated with the 70 base type. 71 72 token 73 This is an index of virtual method in virtual table associated 74 to the type defining it. Token can be looked up from OBJ_TYPE_REF 75 or from DECL_VINDEX of a given virtual table. 76 77 polymorphic (indirect) call 78 This is callgraph representation of virtual method call. Every 79 polymorphic call contains otr_type and otr_token taken from 80 original OBJ_TYPE_REF at callgraph construction time. 81 82 What we do here: 83 84 build_type_inheritance_graph triggers a construction of the type inheritance 85 graph. 86 87 We reconstruct it based on types of methods we see in the unit. 88 This means that the graph is not complete. Types with no methods are not 89 inserted into the graph. Also types without virtual methods are not 90 represented at all, though it may be easy to add this. 91 92 The inheritance graph is represented as follows: 93 94 Vertices are structures odr_type. Every odr_type may correspond 95 to one or more tree type nodes that are equivalent by ODR rule. 96 (the multiple type nodes appear only with linktime optimization) 97 98 Edges are represented by odr_type->base and odr_type->derived_types. 99 At the moment we do not track offsets of types for multiple inheritance. 100 Adding this is easy. 101 102 possible_polymorphic_call_targets returns, given an parameters found in 103 indirect polymorphic edge all possible polymorphic call targets of the call. 104 105 pass_ipa_devirt performs simple speculative devirtualization. 106 */ 107 108 #include "config.h" 109 #include "system.h" 110 #include "coretypes.h" 111 #include "backend.h" 112 #include "rtl.h" 113 #include "tree.h" 114 #include "gimple.h" 115 #include "alloc-pool.h" 116 #include "tree-pass.h" 117 #include "cgraph.h" 118 #include "lto-streamer.h" 119 #include "fold-const.h" 120 #include "print-tree.h" 121 #include "calls.h" 122 #include "ipa-utils.h" 123 #include "gimple-fold.h" 124 #include "symbol-summary.h" 125 #include "tree-vrp.h" 126 #include "ipa-prop.h" 127 #include "ipa-fnsummary.h" 128 #include "demangle.h" 129 #include "dbgcnt.h" 130 #include "gimple-pretty-print.h" 131 #include "intl.h" 132 #include "stringpool.h" 133 #include "attribs.h" 134 #include "data-streamer.h" 135 #include "lto-streamer.h" 136 #include "streamer-hooks.h" 137 138 /* Hash based set of pairs of types. */ 139 struct type_pair 140 { 141 tree first; 142 tree second; 143 }; 144 145 template <> 146 struct default_hash_traits <type_pair> 147 : typed_noop_remove <type_pair> 148 { 149 GTY((skip)) typedef type_pair value_type; 150 GTY((skip)) typedef type_pair compare_type; 151 static hashval_t 152 hash (type_pair p) 153 { 154 return TYPE_UID (p.first) ^ TYPE_UID (p.second); 155 } 156 static const bool empty_zero_p = true; 157 static bool 158 is_empty (type_pair p) 159 { 160 return p.first == NULL; 161 } 162 static bool 163 is_deleted (type_pair p ATTRIBUTE_UNUSED) 164 { 165 return false; 166 } 167 static bool 168 equal (const type_pair &a, const type_pair &b) 169 { 170 return a.first==b.first && a.second == b.second; 171 } 172 static void 173 mark_empty (type_pair &e) 174 { 175 e.first = NULL; 176 } 177 }; 178 179 /* HACK alert: this is used to communicate with ipa-inline-transform that 180 thunk is being expanded and there is no need to clear the polymorphic 181 call target cache. */ 182 bool thunk_expansion; 183 184 static bool odr_types_equivalent_p (tree, tree, bool, bool *, 185 hash_set<type_pair> *, 186 location_t, location_t); 187 static void warn_odr (tree t1, tree t2, tree st1, tree st2, 188 bool warn, bool *warned, const char *reason); 189 190 static bool odr_violation_reported = false; 191 192 193 /* Pointer set of all call targets appearing in the cache. */ 194 static hash_set<cgraph_node *> *cached_polymorphic_call_targets; 195 196 /* The node of type inheritance graph. For each type unique in 197 One Definition Rule (ODR) sense, we produce one node linking all 198 main variants of types equivalent to it, bases and derived types. */ 199 200 struct GTY(()) odr_type_d 201 { 202 /* leader type. */ 203 tree type; 204 /* All bases; built only for main variants of types. */ 205 vec<odr_type> GTY((skip)) bases; 206 /* All derived types with virtual methods seen in unit; 207 built only for main variants of types. */ 208 vec<odr_type> GTY((skip)) derived_types; 209 210 /* All equivalent types, if more than one. */ 211 vec<tree, va_gc> *types; 212 /* Set of all equivalent types, if NON-NULL. */ 213 hash_set<tree> * GTY((skip)) types_set; 214 215 /* Unique ID indexing the type in odr_types array. */ 216 int id; 217 /* Is it in anonymous namespace? */ 218 bool anonymous_namespace; 219 /* Do we know about all derivations of given type? */ 220 bool all_derivations_known; 221 /* Did we report ODR violation here? */ 222 bool odr_violated; 223 /* Set when virtual table without RTTI prevailed table with. */ 224 bool rtti_broken; 225 /* Set when the canonical type is determined using the type name. */ 226 bool tbaa_enabled; 227 }; 228 229 /* Return TRUE if all derived types of T are known and thus 230 we may consider the walk of derived type complete. 231 232 This is typically true only for final anonymous namespace types and types 233 defined within functions (that may be COMDAT and thus shared across units, 234 but with the same set of derived types). */ 235 236 bool 237 type_all_derivations_known_p (const_tree t) 238 { 239 if (TYPE_FINAL_P (t)) 240 return true; 241 if (flag_ltrans) 242 return false; 243 /* Non-C++ types may have IDENTIFIER_NODE here, do not crash. */ 244 if (!TYPE_NAME (t) || TREE_CODE (TYPE_NAME (t)) != TYPE_DECL) 245 return true; 246 if (type_in_anonymous_namespace_p (t)) 247 return true; 248 return (decl_function_context (TYPE_NAME (t)) != NULL); 249 } 250 251 /* Return TRUE if type's constructors are all visible. */ 252 253 static bool 254 type_all_ctors_visible_p (tree t) 255 { 256 return !flag_ltrans 257 && symtab->state >= CONSTRUCTION 258 /* We cannot always use type_all_derivations_known_p. 259 For function local types we must assume case where 260 the function is COMDAT and shared in between units. 261 262 TODO: These cases are quite easy to get, but we need 263 to keep track of C++ privatizing via -Wno-weak 264 as well as the IPA privatizing. */ 265 && type_in_anonymous_namespace_p (t); 266 } 267 268 /* Return TRUE if type may have instance. */ 269 270 static bool 271 type_possibly_instantiated_p (tree t) 272 { 273 tree vtable; 274 varpool_node *vnode; 275 276 /* TODO: Add abstract types here. */ 277 if (!type_all_ctors_visible_p (t)) 278 return true; 279 280 vtable = BINFO_VTABLE (TYPE_BINFO (t)); 281 if (TREE_CODE (vtable) == POINTER_PLUS_EXPR) 282 vtable = TREE_OPERAND (TREE_OPERAND (vtable, 0), 0); 283 vnode = varpool_node::get (vtable); 284 return vnode && vnode->definition; 285 } 286 287 /* Hash used to unify ODR types based on their mangled name and for anonymous 288 namespace types. */ 289 290 struct odr_name_hasher : pointer_hash <odr_type_d> 291 { 292 typedef union tree_node *compare_type; 293 static inline hashval_t hash (const odr_type_d *); 294 static inline bool equal (const odr_type_d *, const tree_node *); 295 static inline void remove (odr_type_d *); 296 }; 297 298 static bool 299 can_be_name_hashed_p (tree t) 300 { 301 return (!in_lto_p || odr_type_p (t)); 302 } 303 304 /* Hash type by its ODR name. */ 305 306 static hashval_t 307 hash_odr_name (const_tree t) 308 { 309 gcc_checking_assert (TYPE_MAIN_VARIANT (t) == t); 310 311 /* If not in LTO, all main variants are unique, so we can do 312 pointer hash. */ 313 if (!in_lto_p) 314 return htab_hash_pointer (t); 315 316 /* Anonymous types are unique. */ 317 if (type_with_linkage_p (t) && type_in_anonymous_namespace_p (t)) 318 return htab_hash_pointer (t); 319 320 gcc_checking_assert (TYPE_NAME (t) 321 && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t))); 322 return IDENTIFIER_HASH_VALUE (DECL_ASSEMBLER_NAME (TYPE_NAME (t))); 323 } 324 325 /* Return the computed hashcode for ODR_TYPE. */ 326 327 inline hashval_t 328 odr_name_hasher::hash (const odr_type_d *odr_type) 329 { 330 return hash_odr_name (odr_type->type); 331 } 332 333 /* For languages with One Definition Rule, work out if 334 types are the same based on their name. 335 336 This is non-trivial for LTO where minor differences in 337 the type representation may have prevented type merging 338 to merge two copies of otherwise equivalent type. 339 340 Until we start streaming mangled type names, this function works 341 only for polymorphic types. 342 */ 343 344 bool 345 types_same_for_odr (const_tree type1, const_tree type2) 346 { 347 gcc_checking_assert (TYPE_P (type1) && TYPE_P (type2)); 348 349 type1 = TYPE_MAIN_VARIANT (type1); 350 type2 = TYPE_MAIN_VARIANT (type2); 351 352 if (type1 == type2) 353 return true; 354 355 if (!in_lto_p) 356 return false; 357 358 /* Anonymous namespace types are never duplicated. */ 359 if ((type_with_linkage_p (type1) && type_in_anonymous_namespace_p (type1)) 360 || (type_with_linkage_p (type2) && type_in_anonymous_namespace_p (type2))) 361 return false; 362 363 /* If both type has mangled defined check if they are same. 364 Watch for anonymous types which are all mangled as "<anon">. */ 365 if (!type_with_linkage_p (type1) || !type_with_linkage_p (type2)) 366 return false; 367 if (type_in_anonymous_namespace_p (type1) 368 || type_in_anonymous_namespace_p (type2)) 369 return false; 370 return (DECL_ASSEMBLER_NAME (TYPE_NAME (type1)) 371 == DECL_ASSEMBLER_NAME (TYPE_NAME (type2))); 372 } 373 374 /* Return true if we can decide on ODR equivalency. 375 376 In non-LTO it is always decide, in LTO however it depends in the type has 377 ODR info attached. */ 378 379 bool 380 types_odr_comparable (tree t1, tree t2) 381 { 382 return (!in_lto_p 383 || TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2) 384 || (odr_type_p (TYPE_MAIN_VARIANT (t1)) 385 && odr_type_p (TYPE_MAIN_VARIANT (t2)))); 386 } 387 388 /* Return true if T1 and T2 are ODR equivalent. If ODR equivalency is not 389 known, be conservative and return false. */ 390 391 bool 392 types_must_be_same_for_odr (tree t1, tree t2) 393 { 394 if (types_odr_comparable (t1, t2)) 395 return types_same_for_odr (t1, t2); 396 else 397 return TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2); 398 } 399 400 /* If T is compound type, return type it is based on. */ 401 402 static tree 403 compound_type_base (const_tree t) 404 { 405 if (TREE_CODE (t) == ARRAY_TYPE 406 || POINTER_TYPE_P (t) 407 || TREE_CODE (t) == COMPLEX_TYPE 408 || VECTOR_TYPE_P (t)) 409 return TREE_TYPE (t); 410 if (TREE_CODE (t) == METHOD_TYPE) 411 return TYPE_METHOD_BASETYPE (t); 412 if (TREE_CODE (t) == OFFSET_TYPE) 413 return TYPE_OFFSET_BASETYPE (t); 414 return NULL_TREE; 415 } 416 417 /* Return true if T is either ODR type or compound type based from it. 418 If the function return true, we know that T is a type originating from C++ 419 source even at link-time. */ 420 421 bool 422 odr_or_derived_type_p (const_tree t) 423 { 424 do 425 { 426 if (odr_type_p (TYPE_MAIN_VARIANT (t))) 427 return true; 428 /* Function type is a tricky one. Basically we can consider it 429 ODR derived if return type or any of the parameters is. 430 We need to check all parameters because LTO streaming merges 431 common types (such as void) and they are not considered ODR then. */ 432 if (TREE_CODE (t) == FUNCTION_TYPE) 433 { 434 if (TYPE_METHOD_BASETYPE (t)) 435 t = TYPE_METHOD_BASETYPE (t); 436 else 437 { 438 if (TREE_TYPE (t) && odr_or_derived_type_p (TREE_TYPE (t))) 439 return true; 440 for (t = TYPE_ARG_TYPES (t); t; t = TREE_CHAIN (t)) 441 if (odr_or_derived_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (t)))) 442 return true; 443 return false; 444 } 445 } 446 else 447 t = compound_type_base (t); 448 } 449 while (t); 450 return t; 451 } 452 453 /* Compare types T1 and T2 and return true if they are 454 equivalent. */ 455 456 inline bool 457 odr_name_hasher::equal (const odr_type_d *o1, const tree_node *t2) 458 { 459 tree t1 = o1->type; 460 461 gcc_checking_assert (TYPE_MAIN_VARIANT (t2) == t2); 462 gcc_checking_assert (TYPE_MAIN_VARIANT (t1) == t1); 463 if (t1 == t2) 464 return true; 465 if (!in_lto_p) 466 return false; 467 /* Check for anonymous namespaces. */ 468 if ((type_with_linkage_p (t1) && type_in_anonymous_namespace_p (t1)) 469 || (type_with_linkage_p (t2) && type_in_anonymous_namespace_p (t2))) 470 return false; 471 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t1))); 472 gcc_checking_assert (DECL_ASSEMBLER_NAME (TYPE_NAME (t2))); 473 return (DECL_ASSEMBLER_NAME (TYPE_NAME (t1)) 474 == DECL_ASSEMBLER_NAME (TYPE_NAME (t2))); 475 } 476 477 /* Free ODR type V. */ 478 479 inline void 480 odr_name_hasher::remove (odr_type_d *v) 481 { 482 v->bases.release (); 483 v->derived_types.release (); 484 if (v->types_set) 485 delete v->types_set; 486 ggc_free (v); 487 } 488 489 /* ODR type hash used to look up ODR type based on tree type node. */ 490 491 typedef hash_table<odr_name_hasher> odr_hash_type; 492 static odr_hash_type *odr_hash; 493 494 /* ODR types are also stored into ODR_TYPE vector to allow consistent 495 walking. Bases appear before derived types. Vector is garbage collected 496 so we won't end up visiting empty types. */ 497 498 static GTY(()) vec <odr_type, va_gc> *odr_types_ptr; 499 #define odr_types (*odr_types_ptr) 500 501 /* All enums defined and accessible for the unit. */ 502 static GTY(()) vec <tree, va_gc> *odr_enums; 503 504 /* Information we hold about value defined by an enum type. */ 505 struct odr_enum_val 506 { 507 const char *name; 508 wide_int val; 509 location_t locus; 510 }; 511 512 /* Information about enum values. */ 513 struct odr_enum 514 { 515 location_t locus; 516 auto_vec<odr_enum_val, 0> vals; 517 bool warned; 518 }; 519 520 /* A table of all ODR enum definitions. */ 521 static hash_map <nofree_string_hash, odr_enum> *odr_enum_map = NULL; 522 static struct obstack odr_enum_obstack; 523 524 /* Set TYPE_BINFO of TYPE and its variants to BINFO. */ 525 void 526 set_type_binfo (tree type, tree binfo) 527 { 528 for (; type; type = TYPE_NEXT_VARIANT (type)) 529 if (COMPLETE_TYPE_P (type)) 530 TYPE_BINFO (type) = binfo; 531 else 532 gcc_assert (!TYPE_BINFO (type)); 533 } 534 535 /* Return true if type variants match. 536 This assumes that we already verified that T1 and T2 are variants of the 537 same type. */ 538 539 static bool 540 type_variants_equivalent_p (tree t1, tree t2) 541 { 542 if (TYPE_QUALS (t1) != TYPE_QUALS (t2)) 543 return false; 544 545 if (comp_type_attributes (t1, t2) != 1) 546 return false; 547 548 if (COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2) 549 && TYPE_ALIGN (t1) != TYPE_ALIGN (t2)) 550 return false; 551 552 return true; 553 } 554 555 /* Compare T1 and T2 based on name or structure. */ 556 557 static bool 558 odr_subtypes_equivalent_p (tree t1, tree t2, 559 hash_set<type_pair> *visited, 560 location_t loc1, location_t loc2) 561 { 562 563 /* This can happen in incomplete types that should be handled earlier. */ 564 gcc_assert (t1 && t2); 565 566 if (t1 == t2) 567 return true; 568 569 /* Anonymous namespace types must match exactly. */ 570 if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1)) 571 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1))) 572 || (type_with_linkage_p (TYPE_MAIN_VARIANT (t2)) 573 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2)))) 574 return false; 575 576 /* For ODR types be sure to compare their names. 577 To support -Wno-odr-type-merging we allow one type to be non-ODR 578 and other ODR even though it is a violation. */ 579 if (types_odr_comparable (t1, t2)) 580 { 581 if (t1 != t2 582 && odr_type_p (TYPE_MAIN_VARIANT (t1)) 583 && get_odr_type (TYPE_MAIN_VARIANT (t1), true)->odr_violated) 584 return false; 585 if (!types_same_for_odr (t1, t2)) 586 return false; 587 if (!type_variants_equivalent_p (t1, t2)) 588 return false; 589 /* Limit recursion: If subtypes are ODR types and we know 590 that they are same, be happy. */ 591 if (odr_type_p (TYPE_MAIN_VARIANT (t1))) 592 return true; 593 } 594 595 /* Component types, builtins and possibly violating ODR types 596 have to be compared structurally. */ 597 if (TREE_CODE (t1) != TREE_CODE (t2)) 598 return false; 599 if (AGGREGATE_TYPE_P (t1) 600 && (TYPE_NAME (t1) == NULL_TREE) != (TYPE_NAME (t2) == NULL_TREE)) 601 return false; 602 603 type_pair pair={TYPE_MAIN_VARIANT (t1), TYPE_MAIN_VARIANT (t2)}; 604 if (TYPE_UID (TYPE_MAIN_VARIANT (t1)) > TYPE_UID (TYPE_MAIN_VARIANT (t2))) 605 { 606 pair.first = TYPE_MAIN_VARIANT (t2); 607 pair.second = TYPE_MAIN_VARIANT (t1); 608 } 609 if (visited->add (pair)) 610 return true; 611 if (!odr_types_equivalent_p (TYPE_MAIN_VARIANT (t1), TYPE_MAIN_VARIANT (t2), 612 false, NULL, visited, loc1, loc2)) 613 return false; 614 if (!type_variants_equivalent_p (t1, t2)) 615 return false; 616 return true; 617 } 618 619 /* Return true if DECL1 and DECL2 are identical methods. Consider 620 name equivalent to name.localalias.xyz. */ 621 622 static bool 623 methods_equal_p (tree decl1, tree decl2) 624 { 625 if (DECL_ASSEMBLER_NAME (decl1) == DECL_ASSEMBLER_NAME (decl2)) 626 return true; 627 const char sep = symbol_table::symbol_suffix_separator (); 628 629 const char *name1 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl1)); 630 const char *ptr1 = strchr (name1, sep); 631 int len1 = ptr1 ? ptr1 - name1 : strlen (name1); 632 633 const char *name2 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl2)); 634 const char *ptr2 = strchr (name2, sep); 635 int len2 = ptr2 ? ptr2 - name2 : strlen (name2); 636 637 if (len1 != len2) 638 return false; 639 return !strncmp (name1, name2, len1); 640 } 641 642 /* Compare two virtual tables, PREVAILING and VTABLE and output ODR 643 violation warnings. */ 644 645 void 646 compare_virtual_tables (varpool_node *prevailing, varpool_node *vtable) 647 { 648 int n1, n2; 649 650 if (DECL_VIRTUAL_P (prevailing->decl) != DECL_VIRTUAL_P (vtable->decl)) 651 { 652 odr_violation_reported = true; 653 if (DECL_VIRTUAL_P (prevailing->decl)) 654 { 655 varpool_node *tmp = prevailing; 656 prevailing = vtable; 657 vtable = tmp; 658 } 659 auto_diagnostic_group d; 660 if (warning_at (DECL_SOURCE_LOCATION 661 (TYPE_NAME (DECL_CONTEXT (vtable->decl))), 662 OPT_Wodr, 663 "virtual table of type %qD violates one definition rule", 664 DECL_CONTEXT (vtable->decl))) 665 inform (DECL_SOURCE_LOCATION (prevailing->decl), 666 "variable of same assembler name as the virtual table is " 667 "defined in another translation unit"); 668 return; 669 } 670 if (!prevailing->definition || !vtable->definition) 671 return; 672 673 /* If we do not stream ODR type info, do not bother to do useful compare. */ 674 if (!TYPE_BINFO (DECL_CONTEXT (vtable->decl)) 675 || !polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (vtable->decl)))) 676 return; 677 678 odr_type class_type = get_odr_type (DECL_CONTEXT (vtable->decl), true); 679 680 if (class_type->odr_violated) 681 return; 682 683 for (n1 = 0, n2 = 0; true; n1++, n2++) 684 { 685 struct ipa_ref *ref1, *ref2; 686 bool end1, end2; 687 688 end1 = !prevailing->iterate_reference (n1, ref1); 689 end2 = !vtable->iterate_reference (n2, ref2); 690 691 /* !DECL_VIRTUAL_P means RTTI entry; 692 We warn when RTTI is lost because non-RTTI prevails; we silently 693 accept the other case. */ 694 while (!end2 695 && (end1 696 || (methods_equal_p (ref1->referred->decl, 697 ref2->referred->decl) 698 && TREE_CODE (ref1->referred->decl) == FUNCTION_DECL)) 699 && TREE_CODE (ref2->referred->decl) != FUNCTION_DECL) 700 { 701 if (!class_type->rtti_broken) 702 { 703 auto_diagnostic_group d; 704 if (warning_at (DECL_SOURCE_LOCATION 705 (TYPE_NAME (DECL_CONTEXT (vtable->decl))), 706 OPT_Wodr, 707 "virtual table of type %qD contains RTTI " 708 "information", 709 DECL_CONTEXT (vtable->decl))) 710 { 711 inform (DECL_SOURCE_LOCATION 712 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))), 713 "but is prevailed by one without from other" 714 " translation unit"); 715 inform (DECL_SOURCE_LOCATION 716 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))), 717 "RTTI will not work on this type"); 718 class_type->rtti_broken = true; 719 } 720 } 721 n2++; 722 end2 = !vtable->iterate_reference (n2, ref2); 723 } 724 while (!end1 725 && (end2 726 || (methods_equal_p (ref2->referred->decl, ref1->referred->decl) 727 && TREE_CODE (ref2->referred->decl) == FUNCTION_DECL)) 728 && TREE_CODE (ref1->referred->decl) != FUNCTION_DECL) 729 { 730 n1++; 731 end1 = !prevailing->iterate_reference (n1, ref1); 732 } 733 734 /* Finished? */ 735 if (end1 && end2) 736 { 737 /* Extra paranoia; compare the sizes. We do not have information 738 about virtual inheritance offsets, so just be sure that these 739 match. 740 Do this as very last check so the not very informative error 741 is not output too often. */ 742 if (DECL_SIZE (prevailing->decl) != DECL_SIZE (vtable->decl)) 743 { 744 class_type->odr_violated = true; 745 auto_diagnostic_group d; 746 tree ctx = TYPE_NAME (DECL_CONTEXT (vtable->decl)); 747 if (warning_at (DECL_SOURCE_LOCATION (ctx), OPT_Wodr, 748 "virtual table of type %qD violates " 749 "one definition rule", 750 DECL_CONTEXT (vtable->decl))) 751 { 752 ctx = TYPE_NAME (DECL_CONTEXT (prevailing->decl)); 753 inform (DECL_SOURCE_LOCATION (ctx), 754 "the conflicting type defined in another translation" 755 " unit has virtual table of different size"); 756 } 757 } 758 return; 759 } 760 761 if (!end1 && !end2) 762 { 763 if (methods_equal_p (ref1->referred->decl, ref2->referred->decl)) 764 continue; 765 766 class_type->odr_violated = true; 767 768 /* If the loops above stopped on non-virtual pointer, we have 769 mismatch in RTTI information mangling. */ 770 if (TREE_CODE (ref1->referred->decl) != FUNCTION_DECL 771 && TREE_CODE (ref2->referred->decl) != FUNCTION_DECL) 772 { 773 auto_diagnostic_group d; 774 if (warning_at (DECL_SOURCE_LOCATION 775 (TYPE_NAME (DECL_CONTEXT (vtable->decl))), 776 OPT_Wodr, 777 "virtual table of type %qD violates " 778 "one definition rule", 779 DECL_CONTEXT (vtable->decl))) 780 { 781 inform (DECL_SOURCE_LOCATION 782 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))), 783 "the conflicting type defined in another translation " 784 "unit with different RTTI information"); 785 } 786 return; 787 } 788 /* At this point both REF1 and REF2 points either to virtual table 789 or virtual method. If one points to virtual table and other to 790 method we can complain the same way as if one table was shorter 791 than other pointing out the extra method. */ 792 if (TREE_CODE (ref1->referred->decl) 793 != TREE_CODE (ref2->referred->decl)) 794 { 795 if (VAR_P (ref1->referred->decl)) 796 end1 = true; 797 else if (VAR_P (ref2->referred->decl)) 798 end2 = true; 799 } 800 } 801 802 class_type->odr_violated = true; 803 804 /* Complain about size mismatch. Either we have too many virtual 805 functions or too many virtual table pointers. */ 806 if (end1 || end2) 807 { 808 if (end1) 809 { 810 varpool_node *tmp = prevailing; 811 prevailing = vtable; 812 vtable = tmp; 813 ref1 = ref2; 814 } 815 auto_diagnostic_group d; 816 if (warning_at (DECL_SOURCE_LOCATION 817 (TYPE_NAME (DECL_CONTEXT (vtable->decl))), 818 OPT_Wodr, 819 "virtual table of type %qD violates " 820 "one definition rule", 821 DECL_CONTEXT (vtable->decl))) 822 { 823 if (TREE_CODE (ref1->referring->decl) == FUNCTION_DECL) 824 { 825 inform (DECL_SOURCE_LOCATION 826 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))), 827 "the conflicting type defined in another translation " 828 "unit"); 829 inform (DECL_SOURCE_LOCATION 830 (TYPE_NAME (DECL_CONTEXT (ref1->referring->decl))), 831 "contains additional virtual method %qD", 832 ref1->referred->decl); 833 } 834 else 835 { 836 inform (DECL_SOURCE_LOCATION 837 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))), 838 "the conflicting type defined in another translation " 839 "unit has virtual table with more entries"); 840 } 841 } 842 return; 843 } 844 845 /* And in the last case we have either mismatch in between two virtual 846 methods or two virtual table pointers. */ 847 auto_diagnostic_group d; 848 if (warning_at (DECL_SOURCE_LOCATION 849 (TYPE_NAME (DECL_CONTEXT (vtable->decl))), OPT_Wodr, 850 "virtual table of type %qD violates " 851 "one definition rule", 852 DECL_CONTEXT (vtable->decl))) 853 { 854 if (TREE_CODE (ref1->referred->decl) == FUNCTION_DECL) 855 { 856 inform (DECL_SOURCE_LOCATION 857 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))), 858 "the conflicting type defined in another translation " 859 "unit"); 860 gcc_assert (TREE_CODE (ref2->referred->decl) 861 == FUNCTION_DECL); 862 inform (DECL_SOURCE_LOCATION 863 (ref1->referred->ultimate_alias_target ()->decl), 864 "virtual method %qD", 865 ref1->referred->ultimate_alias_target ()->decl); 866 inform (DECL_SOURCE_LOCATION 867 (ref2->referred->ultimate_alias_target ()->decl), 868 "ought to match virtual method %qD but does not", 869 ref2->referred->ultimate_alias_target ()->decl); 870 } 871 else 872 inform (DECL_SOURCE_LOCATION 873 (TYPE_NAME (DECL_CONTEXT (prevailing->decl))), 874 "the conflicting type defined in another translation " 875 "unit has virtual table with different contents"); 876 return; 877 } 878 } 879 } 880 881 /* Output ODR violation warning about T1 and T2 with REASON. 882 Display location of ST1 and ST2 if REASON speaks about field or 883 method of the type. 884 If WARN is false, do nothing. Set WARNED if warning was indeed 885 output. */ 886 887 static void 888 warn_odr (tree t1, tree t2, tree st1, tree st2, 889 bool warn, bool *warned, const char *reason) 890 { 891 tree decl2 = TYPE_NAME (TYPE_MAIN_VARIANT (t2)); 892 if (warned) 893 *warned = false; 894 895 if (!warn || !TYPE_NAME(TYPE_MAIN_VARIANT (t1))) 896 return; 897 898 /* ODR warnings are output during LTO streaming; we must apply location 899 cache for potential warnings to be output correctly. */ 900 if (lto_location_cache::current_cache) 901 lto_location_cache::current_cache->apply_location_cache (); 902 903 auto_diagnostic_group d; 904 if (t1 != TYPE_MAIN_VARIANT (t1) 905 && TYPE_NAME (t1) != TYPE_NAME (TYPE_MAIN_VARIANT (t1))) 906 { 907 if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (TYPE_MAIN_VARIANT (t1))), 908 OPT_Wodr, "type %qT (typedef of %qT) violates the " 909 "C++ One Definition Rule", 910 t1, TYPE_MAIN_VARIANT (t1))) 911 return; 912 } 913 else 914 { 915 if (!warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (TYPE_MAIN_VARIANT (t1))), 916 OPT_Wodr, "type %qT violates the C++ One Definition Rule", 917 t1)) 918 return; 919 } 920 if (!st1 && !st2) 921 ; 922 /* For FIELD_DECL support also case where one of fields is 923 NULL - this is used when the structures have mismatching number of 924 elements. */ 925 else if (!st1 || TREE_CODE (st1) == FIELD_DECL) 926 { 927 inform (DECL_SOURCE_LOCATION (decl2), 928 "a different type is defined in another translation unit"); 929 if (!st1) 930 { 931 st1 = st2; 932 st2 = NULL; 933 } 934 inform (DECL_SOURCE_LOCATION (st1), 935 "the first difference of corresponding definitions is field %qD", 936 st1); 937 if (st2) 938 decl2 = st2; 939 } 940 else if (TREE_CODE (st1) == FUNCTION_DECL) 941 { 942 inform (DECL_SOURCE_LOCATION (decl2), 943 "a different type is defined in another translation unit"); 944 inform (DECL_SOURCE_LOCATION (st1), 945 "the first difference of corresponding definitions is method %qD", 946 st1); 947 decl2 = st2; 948 } 949 else 950 return; 951 inform (DECL_SOURCE_LOCATION (decl2), reason); 952 953 if (warned) 954 *warned = true; 955 } 956 957 /* Return true if T1 and T2 are incompatible and we want to recursively 958 dive into them from warn_type_mismatch to give sensible answer. */ 959 960 static bool 961 type_mismatch_p (tree t1, tree t2) 962 { 963 if (odr_or_derived_type_p (t1) && odr_or_derived_type_p (t2) 964 && !odr_types_equivalent_p (t1, t2)) 965 return true; 966 return !types_compatible_p (t1, t2); 967 } 968 969 970 /* Types T1 and T2 was found to be incompatible in a context they can't 971 (either used to declare a symbol of same assembler name or unified by 972 ODR rule). We already output warning about this, but if possible, output 973 extra information on how the types mismatch. 974 975 This is hard to do in general. We basically handle the common cases. 976 977 If LOC1 and LOC2 are meaningful locations, use it in the case the types 978 themselves do not have one. */ 979 980 void 981 warn_types_mismatch (tree t1, tree t2, location_t loc1, location_t loc2) 982 { 983 /* Location of type is known only if it has TYPE_NAME and the name is 984 TYPE_DECL. */ 985 location_t loc_t1 = TYPE_NAME (t1) && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL 986 ? DECL_SOURCE_LOCATION (TYPE_NAME (t1)) 987 : UNKNOWN_LOCATION; 988 location_t loc_t2 = TYPE_NAME (t2) && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL 989 ? DECL_SOURCE_LOCATION (TYPE_NAME (t2)) 990 : UNKNOWN_LOCATION; 991 bool loc_t2_useful = false; 992 993 /* With LTO it is a common case that the location of both types match. 994 See if T2 has a location that is different from T1. If so, we will 995 inform user about the location. 996 Do not consider the location passed to us in LOC1/LOC2 as those are 997 already output. */ 998 if (loc_t2 > BUILTINS_LOCATION && loc_t2 != loc_t1) 999 { 1000 if (loc_t1 <= BUILTINS_LOCATION) 1001 loc_t2_useful = true; 1002 else 1003 { 1004 expanded_location xloc1 = expand_location (loc_t1); 1005 expanded_location xloc2 = expand_location (loc_t2); 1006 1007 if (strcmp (xloc1.file, xloc2.file) 1008 || xloc1.line != xloc2.line 1009 || xloc1.column != xloc2.column) 1010 loc_t2_useful = true; 1011 } 1012 } 1013 1014 if (loc_t1 <= BUILTINS_LOCATION) 1015 loc_t1 = loc1; 1016 if (loc_t2 <= BUILTINS_LOCATION) 1017 loc_t2 = loc2; 1018 1019 location_t loc = loc_t1 <= BUILTINS_LOCATION ? loc_t2 : loc_t1; 1020 1021 /* It is a quite common bug to reference anonymous namespace type in 1022 non-anonymous namespace class. */ 1023 tree mt1 = TYPE_MAIN_VARIANT (t1); 1024 tree mt2 = TYPE_MAIN_VARIANT (t2); 1025 if ((type_with_linkage_p (mt1) 1026 && type_in_anonymous_namespace_p (mt1)) 1027 || (type_with_linkage_p (mt2) 1028 && type_in_anonymous_namespace_p (mt2))) 1029 { 1030 if (!type_with_linkage_p (mt1) 1031 || !type_in_anonymous_namespace_p (mt1)) 1032 { 1033 std::swap (t1, t2); 1034 std::swap (mt1, mt2); 1035 std::swap (loc_t1, loc_t2); 1036 } 1037 gcc_assert (TYPE_NAME (mt1) 1038 && TREE_CODE (TYPE_NAME (mt1)) == TYPE_DECL); 1039 tree n1 = TYPE_NAME (mt1); 1040 tree n2 = TYPE_NAME (mt2) ? TYPE_NAME (mt2) : NULL; 1041 1042 if (TREE_CODE (n1) == TYPE_DECL) 1043 n1 = DECL_NAME (n1); 1044 if (n2 && TREE_CODE (n2) == TYPE_DECL) 1045 n2 = DECL_NAME (n2); 1046 /* Most of the time, the type names will match, do not be unnecessarily 1047 verbose. */ 1048 if (n1 != n2) 1049 inform (loc_t1, 1050 "type %qT defined in anonymous namespace cannot match " 1051 "type %qT across the translation unit boundary", 1052 t1, t2); 1053 else 1054 inform (loc_t1, 1055 "type %qT defined in anonymous namespace cannot match " 1056 "across the translation unit boundary", 1057 t1); 1058 if (loc_t2_useful) 1059 inform (loc_t2, 1060 "the incompatible type defined in another translation unit"); 1061 return; 1062 } 1063 /* If types have mangled ODR names and they are different, it is most 1064 informative to output those. 1065 This also covers types defined in different namespaces. */ 1066 const char *odr1 = get_odr_name_for_type (mt1); 1067 const char *odr2 = get_odr_name_for_type (mt2); 1068 if (odr1 != NULL && odr2 != NULL && odr1 != odr2) 1069 { 1070 const int opts = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES; 1071 char *name1 = xstrdup (cplus_demangle (odr1, opts)); 1072 char *name2 = cplus_demangle (odr2, opts); 1073 if (name1 && name2 && strcmp (name1, name2)) 1074 { 1075 inform (loc_t1, 1076 "type name %qs should match type name %qs", 1077 name1, name2); 1078 if (loc_t2_useful) 1079 inform (loc_t2, 1080 "the incompatible type is defined here"); 1081 free (name1); 1082 return; 1083 } 1084 free (name1); 1085 } 1086 /* A tricky case are compound types. Often they appear the same in source 1087 code and the mismatch is dragged in by type they are build from. 1088 Look for those differences in subtypes and try to be informative. In other 1089 cases just output nothing because the source code is probably different 1090 and in this case we already output a all necessary info. */ 1091 if (!TYPE_NAME (t1) || !TYPE_NAME (t2)) 1092 { 1093 if (TREE_CODE (t1) == TREE_CODE (t2)) 1094 { 1095 if (TREE_CODE (t1) == ARRAY_TYPE 1096 && COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2)) 1097 { 1098 tree i1 = TYPE_DOMAIN (t1); 1099 tree i2 = TYPE_DOMAIN (t2); 1100 1101 if (i1 && i2 1102 && TYPE_MAX_VALUE (i1) 1103 && TYPE_MAX_VALUE (i2) 1104 && !operand_equal_p (TYPE_MAX_VALUE (i1), 1105 TYPE_MAX_VALUE (i2), 0)) 1106 { 1107 inform (loc, 1108 "array types have different bounds"); 1109 return; 1110 } 1111 } 1112 if ((POINTER_TYPE_P (t1) || TREE_CODE (t1) == ARRAY_TYPE) 1113 && type_mismatch_p (TREE_TYPE (t1), TREE_TYPE (t2))) 1114 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc_t1, loc_t2); 1115 else if (TREE_CODE (t1) == METHOD_TYPE 1116 || TREE_CODE (t1) == FUNCTION_TYPE) 1117 { 1118 tree parms1 = NULL, parms2 = NULL; 1119 int count = 1; 1120 1121 if (type_mismatch_p (TREE_TYPE (t1), TREE_TYPE (t2))) 1122 { 1123 inform (loc, "return value type mismatch"); 1124 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc_t1, 1125 loc_t2); 1126 return; 1127 } 1128 if (prototype_p (t1) && prototype_p (t2)) 1129 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2); 1130 parms1 && parms2; 1131 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2), 1132 count++) 1133 { 1134 if (type_mismatch_p (TREE_VALUE (parms1), TREE_VALUE (parms2))) 1135 { 1136 if (count == 1 && TREE_CODE (t1) == METHOD_TYPE) 1137 inform (loc, 1138 "implicit this pointer type mismatch"); 1139 else 1140 inform (loc, 1141 "type mismatch in parameter %i", 1142 count - (TREE_CODE (t1) == METHOD_TYPE)); 1143 warn_types_mismatch (TREE_VALUE (parms1), 1144 TREE_VALUE (parms2), 1145 loc_t1, loc_t2); 1146 return; 1147 } 1148 } 1149 if (parms1 || parms2) 1150 { 1151 inform (loc, 1152 "types have different parameter counts"); 1153 return; 1154 } 1155 } 1156 } 1157 return; 1158 } 1159 1160 if (types_odr_comparable (t1, t2) 1161 /* We make assign integers mangled names to be able to handle 1162 signed/unsigned chars. Accepting them here would however lead to 1163 confusing message like 1164 "type ‘const int’ itself violates the C++ One Definition Rule" */ 1165 && TREE_CODE (t1) != INTEGER_TYPE 1166 && types_same_for_odr (t1, t2)) 1167 inform (loc_t1, 1168 "type %qT itself violates the C++ One Definition Rule", t1); 1169 /* Prevent pointless warnings like "struct aa" should match "struct aa". */ 1170 else if (TYPE_NAME (t1) == TYPE_NAME (t2) 1171 && TREE_CODE (t1) == TREE_CODE (t2) && !loc_t2_useful) 1172 return; 1173 else 1174 inform (loc_t1, "type %qT should match type %qT", 1175 t1, t2); 1176 if (loc_t2_useful) 1177 inform (loc_t2, "the incompatible type is defined here"); 1178 } 1179 1180 /* Return true if T should be ignored in TYPE_FIELDS for ODR comparison. */ 1181 1182 static bool 1183 skip_in_fields_list_p (tree t) 1184 { 1185 if (TREE_CODE (t) != FIELD_DECL) 1186 return true; 1187 /* C++ FE introduces zero sized fields depending on -std setting, see 1188 PR89358. */ 1189 if (DECL_SIZE (t) 1190 && integer_zerop (DECL_SIZE (t)) 1191 && DECL_ARTIFICIAL (t) 1192 && DECL_IGNORED_P (t) 1193 && !DECL_NAME (t)) 1194 return true; 1195 return false; 1196 } 1197 1198 /* Compare T1 and T2, report ODR violations if WARN is true and set 1199 WARNED to true if anything is reported. Return true if types match. 1200 If true is returned, the types are also compatible in the sense of 1201 gimple_canonical_types_compatible_p. 1202 If LOC1 and LOC2 is not UNKNOWN_LOCATION it may be used to output a warning 1203 about the type if the type itself do not have location. */ 1204 1205 static bool 1206 odr_types_equivalent_p (tree t1, tree t2, bool warn, bool *warned, 1207 hash_set<type_pair> *visited, 1208 location_t loc1, location_t loc2) 1209 { 1210 /* Check first for the obvious case of pointer identity. */ 1211 if (t1 == t2) 1212 return true; 1213 1214 /* Can't be the same type if the types don't have the same code. */ 1215 if (TREE_CODE (t1) != TREE_CODE (t2)) 1216 { 1217 warn_odr (t1, t2, NULL, NULL, warn, warned, 1218 G_("a different type is defined in another translation unit")); 1219 return false; 1220 } 1221 1222 if ((type_with_linkage_p (TYPE_MAIN_VARIANT (t1)) 1223 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t1))) 1224 || (type_with_linkage_p (TYPE_MAIN_VARIANT (t2)) 1225 && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2)))) 1226 { 1227 /* We cannot trip this when comparing ODR types, only when trying to 1228 match different ODR derivations from different declarations. 1229 So WARN should be always false. */ 1230 gcc_assert (!warn); 1231 return false; 1232 } 1233 1234 /* Non-aggregate types can be handled cheaply. */ 1235 if (INTEGRAL_TYPE_P (t1) 1236 || SCALAR_FLOAT_TYPE_P (t1) 1237 || FIXED_POINT_TYPE_P (t1) 1238 || TREE_CODE (t1) == VECTOR_TYPE 1239 || TREE_CODE (t1) == COMPLEX_TYPE 1240 || TREE_CODE (t1) == OFFSET_TYPE 1241 || POINTER_TYPE_P (t1)) 1242 { 1243 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2)) 1244 { 1245 warn_odr (t1, t2, NULL, NULL, warn, warned, 1246 G_("a type with different precision is defined " 1247 "in another translation unit")); 1248 return false; 1249 } 1250 if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2)) 1251 { 1252 warn_odr (t1, t2, NULL, NULL, warn, warned, 1253 G_("a type with different signedness is defined " 1254 "in another translation unit")); 1255 return false; 1256 } 1257 1258 if (TREE_CODE (t1) == INTEGER_TYPE 1259 && TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)) 1260 { 1261 /* char WRT uint_8? */ 1262 warn_odr (t1, t2, NULL, NULL, warn, warned, 1263 G_("a different type is defined in another " 1264 "translation unit")); 1265 return false; 1266 } 1267 1268 /* For canonical type comparisons we do not want to build SCCs 1269 so we cannot compare pointed-to types. But we can, for now, 1270 require the same pointed-to type kind and match what 1271 useless_type_conversion_p would do. */ 1272 if (POINTER_TYPE_P (t1)) 1273 { 1274 if (TYPE_ADDR_SPACE (TREE_TYPE (t1)) 1275 != TYPE_ADDR_SPACE (TREE_TYPE (t2))) 1276 { 1277 warn_odr (t1, t2, NULL, NULL, warn, warned, 1278 G_("it is defined as a pointer in different address " 1279 "space in another translation unit")); 1280 return false; 1281 } 1282 1283 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2), 1284 visited, loc1, loc2)) 1285 { 1286 warn_odr (t1, t2, NULL, NULL, warn, warned, 1287 G_("it is defined as a pointer to different type " 1288 "in another translation unit")); 1289 if (warn && warned) 1290 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), 1291 loc1, loc2); 1292 return false; 1293 } 1294 } 1295 1296 if ((TREE_CODE (t1) == VECTOR_TYPE || TREE_CODE (t1) == COMPLEX_TYPE) 1297 && !odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2), 1298 visited, loc1, loc2)) 1299 { 1300 /* Probably specific enough. */ 1301 warn_odr (t1, t2, NULL, NULL, warn, warned, 1302 G_("a different type is defined " 1303 "in another translation unit")); 1304 if (warn && warned) 1305 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc1, loc2); 1306 return false; 1307 } 1308 } 1309 /* Do type-specific comparisons. */ 1310 else switch (TREE_CODE (t1)) 1311 { 1312 case ARRAY_TYPE: 1313 { 1314 /* Array types are the same if the element types are the same and 1315 the number of elements are the same. */ 1316 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2), 1317 visited, loc1, loc2)) 1318 { 1319 warn_odr (t1, t2, NULL, NULL, warn, warned, 1320 G_("a different type is defined in another " 1321 "translation unit")); 1322 if (warn && warned) 1323 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc1, loc2); 1324 } 1325 gcc_assert (TYPE_STRING_FLAG (t1) == TYPE_STRING_FLAG (t2)); 1326 gcc_assert (TYPE_NONALIASED_COMPONENT (t1) 1327 == TYPE_NONALIASED_COMPONENT (t2)); 1328 1329 tree i1 = TYPE_DOMAIN (t1); 1330 tree i2 = TYPE_DOMAIN (t2); 1331 1332 /* For an incomplete external array, the type domain can be 1333 NULL_TREE. Check this condition also. */ 1334 if (i1 == NULL_TREE || i2 == NULL_TREE) 1335 return type_variants_equivalent_p (t1, t2); 1336 1337 tree min1 = TYPE_MIN_VALUE (i1); 1338 tree min2 = TYPE_MIN_VALUE (i2); 1339 tree max1 = TYPE_MAX_VALUE (i1); 1340 tree max2 = TYPE_MAX_VALUE (i2); 1341 1342 /* In C++, minimums should be always 0. */ 1343 gcc_assert (min1 == min2); 1344 if (!operand_equal_p (max1, max2, 0)) 1345 { 1346 warn_odr (t1, t2, NULL, NULL, warn, warned, 1347 G_("an array of different size is defined " 1348 "in another translation unit")); 1349 return false; 1350 } 1351 } 1352 break; 1353 1354 case METHOD_TYPE: 1355 case FUNCTION_TYPE: 1356 /* Function types are the same if the return type and arguments types 1357 are the same. */ 1358 if (!odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2), 1359 visited, loc1, loc2)) 1360 { 1361 warn_odr (t1, t2, NULL, NULL, warn, warned, 1362 G_("has different return value " 1363 "in another translation unit")); 1364 if (warn && warned) 1365 warn_types_mismatch (TREE_TYPE (t1), TREE_TYPE (t2), loc1, loc2); 1366 return false; 1367 } 1368 1369 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2) 1370 || !prototype_p (t1) || !prototype_p (t2)) 1371 return type_variants_equivalent_p (t1, t2); 1372 else 1373 { 1374 tree parms1, parms2; 1375 1376 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2); 1377 parms1 && parms2; 1378 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2)) 1379 { 1380 if (!odr_subtypes_equivalent_p 1381 (TREE_VALUE (parms1), TREE_VALUE (parms2), 1382 visited, loc1, loc2)) 1383 { 1384 warn_odr (t1, t2, NULL, NULL, warn, warned, 1385 G_("has different parameters in another " 1386 "translation unit")); 1387 if (warn && warned) 1388 warn_types_mismatch (TREE_VALUE (parms1), 1389 TREE_VALUE (parms2), loc1, loc2); 1390 return false; 1391 } 1392 } 1393 1394 if (parms1 || parms2) 1395 { 1396 warn_odr (t1, t2, NULL, NULL, warn, warned, 1397 G_("has different parameters " 1398 "in another translation unit")); 1399 return false; 1400 } 1401 1402 return type_variants_equivalent_p (t1, t2); 1403 } 1404 1405 case RECORD_TYPE: 1406 case UNION_TYPE: 1407 case QUAL_UNION_TYPE: 1408 { 1409 tree f1, f2; 1410 1411 /* For aggregate types, all the fields must be the same. */ 1412 if (COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2)) 1413 { 1414 if (TYPE_BINFO (t1) && TYPE_BINFO (t2) 1415 && polymorphic_type_binfo_p (TYPE_BINFO (t1)) 1416 != polymorphic_type_binfo_p (TYPE_BINFO (t2))) 1417 { 1418 if (polymorphic_type_binfo_p (TYPE_BINFO (t1))) 1419 warn_odr (t1, t2, NULL, NULL, warn, warned, 1420 G_("a type defined in another translation unit " 1421 "is not polymorphic")); 1422 else 1423 warn_odr (t1, t2, NULL, NULL, warn, warned, 1424 G_("a type defined in another translation unit " 1425 "is polymorphic")); 1426 return false; 1427 } 1428 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2); 1429 f1 || f2; 1430 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2)) 1431 { 1432 /* Skip non-fields. */ 1433 while (f1 && skip_in_fields_list_p (f1)) 1434 f1 = TREE_CHAIN (f1); 1435 while (f2 && skip_in_fields_list_p (f2)) 1436 f2 = TREE_CHAIN (f2); 1437 if (!f1 || !f2) 1438 break; 1439 if (DECL_VIRTUAL_P (f1) != DECL_VIRTUAL_P (f2)) 1440 { 1441 warn_odr (t1, t2, NULL, NULL, warn, warned, 1442 G_("a type with different virtual table pointers" 1443 " is defined in another translation unit")); 1444 return false; 1445 } 1446 if (DECL_ARTIFICIAL (f1) != DECL_ARTIFICIAL (f2)) 1447 { 1448 warn_odr (t1, t2, NULL, NULL, warn, warned, 1449 G_("a type with different bases is defined " 1450 "in another translation unit")); 1451 return false; 1452 } 1453 if (DECL_NAME (f1) != DECL_NAME (f2) 1454 && !DECL_ARTIFICIAL (f1)) 1455 { 1456 warn_odr (t1, t2, f1, f2, warn, warned, 1457 G_("a field with different name is defined " 1458 "in another translation unit")); 1459 return false; 1460 } 1461 if (!odr_subtypes_equivalent_p (TREE_TYPE (f1), 1462 TREE_TYPE (f2), 1463 visited, loc1, loc2)) 1464 { 1465 /* Do not warn about artificial fields and just go into 1466 generic field mismatch warning. */ 1467 if (DECL_ARTIFICIAL (f1)) 1468 break; 1469 1470 warn_odr (t1, t2, f1, f2, warn, warned, 1471 G_("a field of same name but different type " 1472 "is defined in another translation unit")); 1473 if (warn && warned) 1474 warn_types_mismatch (TREE_TYPE (f1), TREE_TYPE (f2), loc1, loc2); 1475 return false; 1476 } 1477 if (!gimple_compare_field_offset (f1, f2)) 1478 { 1479 /* Do not warn about artificial fields and just go into 1480 generic field mismatch warning. */ 1481 if (DECL_ARTIFICIAL (f1)) 1482 break; 1483 warn_odr (t1, t2, f1, f2, warn, warned, 1484 G_("fields have different layout " 1485 "in another translation unit")); 1486 return false; 1487 } 1488 if (DECL_BIT_FIELD (f1) != DECL_BIT_FIELD (f2)) 1489 { 1490 warn_odr (t1, t2, f1, f2, warn, warned, 1491 G_("one field is a bitfield while the other " 1492 "is not")); 1493 return false; 1494 } 1495 else 1496 gcc_assert (DECL_NONADDRESSABLE_P (f1) 1497 == DECL_NONADDRESSABLE_P (f2)); 1498 } 1499 1500 /* If one aggregate has more fields than the other, they 1501 are not the same. */ 1502 if (f1 || f2) 1503 { 1504 if ((f1 && DECL_VIRTUAL_P (f1)) || (f2 && DECL_VIRTUAL_P (f2))) 1505 warn_odr (t1, t2, NULL, NULL, warn, warned, 1506 G_("a type with different virtual table pointers" 1507 " is defined in another translation unit")); 1508 else if ((f1 && DECL_ARTIFICIAL (f1)) 1509 || (f2 && DECL_ARTIFICIAL (f2))) 1510 warn_odr (t1, t2, NULL, NULL, warn, warned, 1511 G_("a type with different bases is defined " 1512 "in another translation unit")); 1513 else 1514 warn_odr (t1, t2, f1, f2, warn, warned, 1515 G_("a type with different number of fields " 1516 "is defined in another translation unit")); 1517 1518 return false; 1519 } 1520 } 1521 break; 1522 } 1523 case VOID_TYPE: 1524 case NULLPTR_TYPE: 1525 break; 1526 1527 default: 1528 debug_tree (t1); 1529 gcc_unreachable (); 1530 } 1531 1532 /* Those are better to come last as they are utterly uninformative. */ 1533 if (TYPE_SIZE (t1) && TYPE_SIZE (t2) 1534 && !operand_equal_p (TYPE_SIZE (t1), TYPE_SIZE (t2), 0)) 1535 { 1536 warn_odr (t1, t2, NULL, NULL, warn, warned, 1537 G_("a type with different size " 1538 "is defined in another translation unit")); 1539 return false; 1540 } 1541 1542 if (TREE_ADDRESSABLE (t1) != TREE_ADDRESSABLE (t2) 1543 && COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2)) 1544 { 1545 warn_odr (t1, t2, NULL, NULL, warn, warned, 1546 G_("one type needs to be constructed while the other does not")); 1547 gcc_checking_assert (RECORD_OR_UNION_TYPE_P (t1)); 1548 return false; 1549 } 1550 /* There is no really good user facing warning for this. 1551 Either the original reason for modes being different is lost during 1552 streaming or we should catch earlier warnings. We however must detect 1553 the mismatch to avoid type verifier from cmplaining on mismatched 1554 types between type and canonical type. See PR91576. */ 1555 if (TYPE_MODE (t1) != TYPE_MODE (t2) 1556 && COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2)) 1557 { 1558 warn_odr (t1, t2, NULL, NULL, warn, warned, 1559 G_("memory layout mismatch")); 1560 return false; 1561 } 1562 1563 gcc_assert (!TYPE_SIZE_UNIT (t1) || !TYPE_SIZE_UNIT (t2) 1564 || operand_equal_p (TYPE_SIZE_UNIT (t1), 1565 TYPE_SIZE_UNIT (t2), 0)); 1566 return type_variants_equivalent_p (t1, t2); 1567 } 1568 1569 /* Return true if TYPE1 and TYPE2 are equivalent for One Definition Rule. */ 1570 1571 bool 1572 odr_types_equivalent_p (tree type1, tree type2) 1573 { 1574 gcc_checking_assert (odr_or_derived_type_p (type1) 1575 && odr_or_derived_type_p (type2)); 1576 1577 hash_set<type_pair> visited; 1578 return odr_types_equivalent_p (type1, type2, false, NULL, 1579 &visited, UNKNOWN_LOCATION, UNKNOWN_LOCATION); 1580 } 1581 1582 /* TYPE is equivalent to VAL by ODR, but its tree representation differs 1583 from VAL->type. This may happen in LTO where tree merging did not merge 1584 all variants of the same type or due to ODR violation. 1585 1586 Analyze and report ODR violations and add type to duplicate list. 1587 If TYPE is more specified than VAL->type, prevail VAL->type. Also if 1588 this is first time we see definition of a class return true so the 1589 base types are analyzed. */ 1590 1591 static bool 1592 add_type_duplicate (odr_type val, tree type) 1593 { 1594 bool build_bases = false; 1595 bool prevail = false; 1596 bool odr_must_violate = false; 1597 1598 if (!val->types_set) 1599 val->types_set = new hash_set<tree>; 1600 1601 /* Chose polymorphic type as leader (this happens only in case of ODR 1602 violations. */ 1603 if ((TREE_CODE (type) == RECORD_TYPE && TYPE_BINFO (type) 1604 && polymorphic_type_binfo_p (TYPE_BINFO (type))) 1605 && (TREE_CODE (val->type) != RECORD_TYPE || !TYPE_BINFO (val->type) 1606 || !polymorphic_type_binfo_p (TYPE_BINFO (val->type)))) 1607 { 1608 prevail = true; 1609 build_bases = true; 1610 } 1611 /* Always prefer complete type to be the leader. */ 1612 else if (!COMPLETE_TYPE_P (val->type) && COMPLETE_TYPE_P (type)) 1613 { 1614 prevail = true; 1615 if (TREE_CODE (type) == RECORD_TYPE) 1616 build_bases = TYPE_BINFO (type); 1617 } 1618 else if (COMPLETE_TYPE_P (val->type) && !COMPLETE_TYPE_P (type)) 1619 ; 1620 else if (TREE_CODE (val->type) == RECORD_TYPE 1621 && TREE_CODE (type) == RECORD_TYPE 1622 && TYPE_BINFO (type) && !TYPE_BINFO (val->type)) 1623 { 1624 gcc_assert (!val->bases.length ()); 1625 build_bases = true; 1626 prevail = true; 1627 } 1628 1629 if (prevail) 1630 std::swap (val->type, type); 1631 1632 val->types_set->add (type); 1633 1634 if (!odr_hash) 1635 return false; 1636 1637 gcc_checking_assert (can_be_name_hashed_p (type) 1638 && can_be_name_hashed_p (val->type)); 1639 1640 bool merge = true; 1641 bool base_mismatch = false; 1642 unsigned int i; 1643 bool warned = false; 1644 hash_set<type_pair> visited; 1645 1646 gcc_assert (in_lto_p); 1647 vec_safe_push (val->types, type); 1648 1649 /* If both are class types, compare the bases. */ 1650 if (COMPLETE_TYPE_P (type) && COMPLETE_TYPE_P (val->type) 1651 && TREE_CODE (val->type) == RECORD_TYPE 1652 && TREE_CODE (type) == RECORD_TYPE 1653 && TYPE_BINFO (val->type) && TYPE_BINFO (type)) 1654 { 1655 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) 1656 != BINFO_N_BASE_BINFOS (TYPE_BINFO (val->type))) 1657 { 1658 if (!flag_ltrans && !warned && !val->odr_violated) 1659 { 1660 tree extra_base; 1661 warn_odr (type, val->type, NULL, NULL, !warned, &warned, 1662 "a type with the same name but different " 1663 "number of polymorphic bases is " 1664 "defined in another translation unit"); 1665 if (warned) 1666 { 1667 if (BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) 1668 > BINFO_N_BASE_BINFOS (TYPE_BINFO (val->type))) 1669 extra_base = BINFO_BASE_BINFO 1670 (TYPE_BINFO (type), 1671 BINFO_N_BASE_BINFOS (TYPE_BINFO (val->type))); 1672 else 1673 extra_base = BINFO_BASE_BINFO 1674 (TYPE_BINFO (val->type), 1675 BINFO_N_BASE_BINFOS (TYPE_BINFO (type))); 1676 tree extra_base_type = BINFO_TYPE (extra_base); 1677 inform (DECL_SOURCE_LOCATION (TYPE_NAME (extra_base_type)), 1678 "the extra base is defined here"); 1679 } 1680 } 1681 base_mismatch = true; 1682 } 1683 else 1684 for (i = 0; i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); i++) 1685 { 1686 tree base1 = BINFO_BASE_BINFO (TYPE_BINFO (type), i); 1687 tree base2 = BINFO_BASE_BINFO (TYPE_BINFO (val->type), i); 1688 tree type1 = BINFO_TYPE (base1); 1689 tree type2 = BINFO_TYPE (base2); 1690 1691 if (types_odr_comparable (type1, type2)) 1692 { 1693 if (!types_same_for_odr (type1, type2)) 1694 base_mismatch = true; 1695 } 1696 else 1697 if (!odr_types_equivalent_p (type1, type2)) 1698 base_mismatch = true; 1699 if (base_mismatch) 1700 { 1701 if (!warned && !val->odr_violated) 1702 { 1703 warn_odr (type, val->type, NULL, NULL, 1704 !warned, &warned, 1705 "a type with the same name but different base " 1706 "type is defined in another translation unit"); 1707 if (warned) 1708 warn_types_mismatch (type1, type2, 1709 UNKNOWN_LOCATION, UNKNOWN_LOCATION); 1710 } 1711 break; 1712 } 1713 if (BINFO_OFFSET (base1) != BINFO_OFFSET (base2)) 1714 { 1715 base_mismatch = true; 1716 if (!warned && !val->odr_violated) 1717 warn_odr (type, val->type, NULL, NULL, 1718 !warned, &warned, 1719 "a type with the same name but different base " 1720 "layout is defined in another translation unit"); 1721 break; 1722 } 1723 /* One of bases is not of complete type. */ 1724 if (!TYPE_BINFO (type1) != !TYPE_BINFO (type2)) 1725 { 1726 /* If we have a polymorphic type info specified for TYPE1 1727 but not for TYPE2 we possibly missed a base when recording 1728 VAL->type earlier. 1729 Be sure this does not happen. */ 1730 if (TYPE_BINFO (type1) 1731 && polymorphic_type_binfo_p (TYPE_BINFO (type1)) 1732 && !build_bases) 1733 odr_must_violate = true; 1734 break; 1735 } 1736 /* One base is polymorphic and the other not. 1737 This ought to be diagnosed earlier, but do not ICE in the 1738 checking bellow. */ 1739 else if (TYPE_BINFO (type1) 1740 && polymorphic_type_binfo_p (TYPE_BINFO (type1)) 1741 != polymorphic_type_binfo_p (TYPE_BINFO (type2))) 1742 { 1743 if (!warned && !val->odr_violated) 1744 warn_odr (type, val->type, NULL, NULL, 1745 !warned, &warned, 1746 "a base of the type is polymorphic only in one " 1747 "translation unit"); 1748 base_mismatch = true; 1749 break; 1750 } 1751 } 1752 if (base_mismatch) 1753 { 1754 merge = false; 1755 odr_violation_reported = true; 1756 val->odr_violated = true; 1757 1758 if (symtab->dump_file) 1759 { 1760 fprintf (symtab->dump_file, "ODR base violation\n"); 1761 1762 print_node (symtab->dump_file, "", val->type, 0); 1763 putc ('\n',symtab->dump_file); 1764 print_node (symtab->dump_file, "", type, 0); 1765 putc ('\n',symtab->dump_file); 1766 } 1767 } 1768 } 1769 1770 /* Next compare memory layout. 1771 The DECL_SOURCE_LOCATIONs in this invocation came from LTO streaming. 1772 We must apply the location cache to ensure that they are valid 1773 before we can pass them to odr_types_equivalent_p (PR lto/83121). */ 1774 if (lto_location_cache::current_cache) 1775 lto_location_cache::current_cache->apply_location_cache (); 1776 /* As a special case we stream mangles names of integer types so we can see 1777 if they are believed to be same even though they have different 1778 representation. Avoid bogus warning on mismatches in these. */ 1779 if (TREE_CODE (type) != INTEGER_TYPE 1780 && TREE_CODE (val->type) != INTEGER_TYPE 1781 && !odr_types_equivalent_p (val->type, type, 1782 !flag_ltrans && !val->odr_violated && !warned, 1783 &warned, &visited, 1784 DECL_SOURCE_LOCATION (TYPE_NAME (val->type)), 1785 DECL_SOURCE_LOCATION (TYPE_NAME (type)))) 1786 { 1787 merge = false; 1788 odr_violation_reported = true; 1789 val->odr_violated = true; 1790 } 1791 gcc_assert (val->odr_violated || !odr_must_violate); 1792 /* Sanity check that all bases will be build same way again. */ 1793 if (flag_checking 1794 && COMPLETE_TYPE_P (type) && COMPLETE_TYPE_P (val->type) 1795 && TREE_CODE (val->type) == RECORD_TYPE 1796 && TREE_CODE (type) == RECORD_TYPE 1797 && TYPE_BINFO (val->type) && TYPE_BINFO (type) 1798 && !val->odr_violated 1799 && !base_mismatch && val->bases.length ()) 1800 { 1801 unsigned int num_poly_bases = 0; 1802 unsigned int j; 1803 1804 for (i = 0; i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); i++) 1805 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO 1806 (TYPE_BINFO (type), i))) 1807 num_poly_bases++; 1808 gcc_assert (num_poly_bases == val->bases.length ()); 1809 for (j = 0, i = 0; i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); 1810 i++) 1811 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO 1812 (TYPE_BINFO (type), i))) 1813 { 1814 odr_type base = get_odr_type 1815 (BINFO_TYPE 1816 (BINFO_BASE_BINFO (TYPE_BINFO (type), 1817 i)), 1818 true); 1819 gcc_assert (val->bases[j] == base); 1820 j++; 1821 } 1822 } 1823 1824 1825 /* Regularize things a little. During LTO same types may come with 1826 different BINFOs. Either because their virtual table was 1827 not merged by tree merging and only later at decl merging or 1828 because one type comes with external vtable, while other 1829 with internal. We want to merge equivalent binfos to conserve 1830 memory and streaming overhead. 1831 1832 The external vtables are more harmful: they contain references 1833 to external declarations of methods that may be defined in the 1834 merged LTO unit. For this reason we absolutely need to remove 1835 them and replace by internal variants. Not doing so will lead 1836 to incomplete answers from possible_polymorphic_call_targets. 1837 1838 FIXME: disable for now; because ODR types are now build during 1839 streaming in, the variants do not need to be linked to the type, 1840 yet. We need to do the merging in cleanup pass to be implemented 1841 soon. */ 1842 if (!flag_ltrans && merge 1843 && 0 1844 && TREE_CODE (val->type) == RECORD_TYPE 1845 && TREE_CODE (type) == RECORD_TYPE 1846 && TYPE_BINFO (val->type) && TYPE_BINFO (type) 1847 && TYPE_MAIN_VARIANT (type) == type 1848 && TYPE_MAIN_VARIANT (val->type) == val->type 1849 && BINFO_VTABLE (TYPE_BINFO (val->type)) 1850 && BINFO_VTABLE (TYPE_BINFO (type))) 1851 { 1852 tree master_binfo = TYPE_BINFO (val->type); 1853 tree v1 = BINFO_VTABLE (master_binfo); 1854 tree v2 = BINFO_VTABLE (TYPE_BINFO (type)); 1855 1856 if (TREE_CODE (v1) == POINTER_PLUS_EXPR) 1857 { 1858 gcc_assert (TREE_CODE (v2) == POINTER_PLUS_EXPR 1859 && operand_equal_p (TREE_OPERAND (v1, 1), 1860 TREE_OPERAND (v2, 1), 0)); 1861 v1 = TREE_OPERAND (TREE_OPERAND (v1, 0), 0); 1862 v2 = TREE_OPERAND (TREE_OPERAND (v2, 0), 0); 1863 } 1864 gcc_assert (DECL_ASSEMBLER_NAME (v1) 1865 == DECL_ASSEMBLER_NAME (v2)); 1866 1867 if (DECL_EXTERNAL (v1) && !DECL_EXTERNAL (v2)) 1868 { 1869 unsigned int i; 1870 1871 set_type_binfo (val->type, TYPE_BINFO (type)); 1872 for (i = 0; i < val->types->length (); i++) 1873 { 1874 if (TYPE_BINFO ((*val->types)[i]) 1875 == master_binfo) 1876 set_type_binfo ((*val->types)[i], TYPE_BINFO (type)); 1877 } 1878 BINFO_TYPE (TYPE_BINFO (type)) = val->type; 1879 } 1880 else 1881 set_type_binfo (type, master_binfo); 1882 } 1883 return build_bases; 1884 } 1885 1886 /* REF is OBJ_TYPE_REF, return the class the ref corresponds to. 1887 FOR_DUMP_P is true when being called from the dump routines. */ 1888 1889 tree 1890 obj_type_ref_class (const_tree ref, bool for_dump_p) 1891 { 1892 gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF); 1893 ref = TREE_TYPE (ref); 1894 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE); 1895 ref = TREE_TYPE (ref); 1896 /* We look for type THIS points to. ObjC also builds 1897 OBJ_TYPE_REF with non-method calls, Their first parameter 1898 ID however also corresponds to class type. */ 1899 gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE 1900 || TREE_CODE (ref) == FUNCTION_TYPE); 1901 ref = TREE_VALUE (TYPE_ARG_TYPES (ref)); 1902 gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE); 1903 tree ret = TREE_TYPE (ref); 1904 if (!in_lto_p && !TYPE_STRUCTURAL_EQUALITY_P (ret)) 1905 ret = TYPE_CANONICAL (ret); 1906 else if (odr_type ot = get_odr_type (ret, !for_dump_p)) 1907 ret = ot->type; 1908 else 1909 gcc_assert (for_dump_p); 1910 return ret; 1911 } 1912 1913 /* Get ODR type hash entry for TYPE. If INSERT is true, create 1914 possibly new entry. */ 1915 1916 odr_type 1917 get_odr_type (tree type, bool insert) 1918 { 1919 odr_type_d **slot = NULL; 1920 odr_type val = NULL; 1921 hashval_t hash; 1922 bool build_bases = false; 1923 bool insert_to_odr_array = false; 1924 int base_id = -1; 1925 1926 type = TYPE_MAIN_VARIANT (type); 1927 if (!in_lto_p && !TYPE_STRUCTURAL_EQUALITY_P (type)) 1928 type = TYPE_CANONICAL (type); 1929 1930 gcc_checking_assert (can_be_name_hashed_p (type)); 1931 1932 hash = hash_odr_name (type); 1933 slot = odr_hash->find_slot_with_hash (type, hash, 1934 insert ? INSERT : NO_INSERT); 1935 1936 if (!slot) 1937 return NULL; 1938 1939 /* See if we already have entry for type. */ 1940 if (*slot) 1941 { 1942 val = *slot; 1943 1944 if (val->type != type && insert 1945 && (!val->types_set || !val->types_set->add (type))) 1946 build_bases = add_type_duplicate (val, type); 1947 } 1948 else 1949 { 1950 val = ggc_cleared_alloc<odr_type_d> (); 1951 val->type = type; 1952 val->bases = vNULL; 1953 val->derived_types = vNULL; 1954 if (type_with_linkage_p (type)) 1955 val->anonymous_namespace = type_in_anonymous_namespace_p (type); 1956 else 1957 val->anonymous_namespace = 0; 1958 build_bases = COMPLETE_TYPE_P (val->type); 1959 insert_to_odr_array = true; 1960 *slot = val; 1961 } 1962 1963 if (build_bases && TREE_CODE (type) == RECORD_TYPE && TYPE_BINFO (type) 1964 && type_with_linkage_p (type) 1965 && type == TYPE_MAIN_VARIANT (type)) 1966 { 1967 tree binfo = TYPE_BINFO (type); 1968 unsigned int i; 1969 1970 gcc_assert (BINFO_TYPE (TYPE_BINFO (val->type)) == type); 1971 1972 val->all_derivations_known = type_all_derivations_known_p (type); 1973 for (i = 0; i < BINFO_N_BASE_BINFOS (binfo); i++) 1974 /* For now record only polymorphic types. other are 1975 pointless for devirtualization and we cannot precisely 1976 determine ODR equivalency of these during LTO. */ 1977 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (binfo, i))) 1978 { 1979 tree base_type= BINFO_TYPE (BINFO_BASE_BINFO (binfo, i)); 1980 odr_type base = get_odr_type (base_type, true); 1981 gcc_assert (TYPE_MAIN_VARIANT (base_type) == base_type); 1982 base->derived_types.safe_push (val); 1983 val->bases.safe_push (base); 1984 if (base->id > base_id) 1985 base_id = base->id; 1986 } 1987 } 1988 /* Ensure that type always appears after bases. */ 1989 if (insert_to_odr_array) 1990 { 1991 if (odr_types_ptr) 1992 val->id = odr_types.length (); 1993 vec_safe_push (odr_types_ptr, val); 1994 } 1995 else if (base_id > val->id) 1996 { 1997 odr_types[val->id] = 0; 1998 /* Be sure we did not recorded any derived types; these may need 1999 renumbering too. */ 2000 gcc_assert (val->derived_types.length() == 0); 2001 val->id = odr_types.length (); 2002 vec_safe_push (odr_types_ptr, val); 2003 } 2004 return val; 2005 } 2006 2007 /* Return type that in ODR type hash prevailed TYPE. Be careful and punt 2008 on ODR violations. */ 2009 2010 tree 2011 prevailing_odr_type (tree type) 2012 { 2013 odr_type t = get_odr_type (type, false); 2014 if (!t || t->odr_violated) 2015 return type; 2016 return t->type; 2017 } 2018 2019 /* Set tbaa_enabled flag for TYPE. */ 2020 2021 void 2022 enable_odr_based_tbaa (tree type) 2023 { 2024 odr_type t = get_odr_type (type, true); 2025 t->tbaa_enabled = true; 2026 } 2027 2028 /* True if canonical type of TYPE is determined using ODR name. */ 2029 2030 bool 2031 odr_based_tbaa_p (const_tree type) 2032 { 2033 if (!RECORD_OR_UNION_TYPE_P (type)) 2034 return false; 2035 odr_type t = get_odr_type (const_cast <tree> (type), false); 2036 if (!t || !t->tbaa_enabled) 2037 return false; 2038 return true; 2039 } 2040 2041 /* Set TYPE_CANONICAL of type and all its variants and duplicates 2042 to CANONICAL. */ 2043 2044 void 2045 set_type_canonical_for_odr_type (tree type, tree canonical) 2046 { 2047 odr_type t = get_odr_type (type, false); 2048 unsigned int i; 2049 tree tt; 2050 2051 for (tree t2 = t->type; t2; t2 = TYPE_NEXT_VARIANT (t2)) 2052 TYPE_CANONICAL (t2) = canonical; 2053 if (t->types) 2054 FOR_EACH_VEC_ELT (*t->types, i, tt) 2055 for (tree t2 = tt; t2; t2 = TYPE_NEXT_VARIANT (t2)) 2056 TYPE_CANONICAL (t2) = canonical; 2057 } 2058 2059 /* Return true if we reported some ODR violation on TYPE. */ 2060 2061 bool 2062 odr_type_violation_reported_p (tree type) 2063 { 2064 return get_odr_type (type, false)->odr_violated; 2065 } 2066 2067 /* Add TYPE of ODR type hash. */ 2068 2069 void 2070 register_odr_type (tree type) 2071 { 2072 if (!odr_hash) 2073 odr_hash = new odr_hash_type (23); 2074 if (type == TYPE_MAIN_VARIANT (type)) 2075 { 2076 /* To get ODR warnings right, first register all sub-types. */ 2077 if (RECORD_OR_UNION_TYPE_P (type) 2078 && COMPLETE_TYPE_P (type)) 2079 { 2080 /* Limit recursion on types which are already registered. */ 2081 odr_type ot = get_odr_type (type, false); 2082 if (ot 2083 && (ot->type == type 2084 || (ot->types_set 2085 && ot->types_set->contains (type)))) 2086 return; 2087 for (tree f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f)) 2088 if (TREE_CODE (f) == FIELD_DECL) 2089 { 2090 tree subtype = TREE_TYPE (f); 2091 2092 while (TREE_CODE (subtype) == ARRAY_TYPE) 2093 subtype = TREE_TYPE (subtype); 2094 if (type_with_linkage_p (TYPE_MAIN_VARIANT (subtype))) 2095 register_odr_type (TYPE_MAIN_VARIANT (subtype)); 2096 } 2097 if (TYPE_BINFO (type)) 2098 for (unsigned int i = 0; 2099 i < BINFO_N_BASE_BINFOS (TYPE_BINFO (type)); i++) 2100 register_odr_type (BINFO_TYPE (BINFO_BASE_BINFO 2101 (TYPE_BINFO (type), i))); 2102 } 2103 get_odr_type (type, true); 2104 } 2105 } 2106 2107 /* Return true if type is known to have no derivations. */ 2108 2109 bool 2110 type_known_to_have_no_derivations_p (tree t) 2111 { 2112 return (type_all_derivations_known_p (t) 2113 && (TYPE_FINAL_P (t) 2114 || (odr_hash 2115 && !get_odr_type (t, true)->derived_types.length()))); 2116 } 2117 2118 /* Dump ODR type T and all its derived types. INDENT specifies indentation for 2119 recursive printing. */ 2120 2121 static void 2122 dump_odr_type (FILE *f, odr_type t, int indent=0) 2123 { 2124 unsigned int i; 2125 fprintf (f, "%*s type %i: ", indent * 2, "", t->id); 2126 print_generic_expr (f, t->type, TDF_SLIM); 2127 fprintf (f, "%s", t->anonymous_namespace ? " (anonymous namespace)":""); 2128 fprintf (f, "%s\n", t->all_derivations_known ? " (derivations known)":""); 2129 if (TYPE_NAME (t->type)) 2130 { 2131 if (DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t->type))) 2132 fprintf (f, "%*s mangled name: %s\n", indent * 2, "", 2133 IDENTIFIER_POINTER 2134 (DECL_ASSEMBLER_NAME (TYPE_NAME (t->type)))); 2135 } 2136 if (t->bases.length ()) 2137 { 2138 fprintf (f, "%*s base odr type ids: ", indent * 2, ""); 2139 for (i = 0; i < t->bases.length (); i++) 2140 fprintf (f, " %i", t->bases[i]->id); 2141 fprintf (f, "\n"); 2142 } 2143 if (t->derived_types.length ()) 2144 { 2145 fprintf (f, "%*s derived types:\n", indent * 2, ""); 2146 for (i = 0; i < t->derived_types.length (); i++) 2147 dump_odr_type (f, t->derived_types[i], indent + 1); 2148 } 2149 fprintf (f, "\n"); 2150 } 2151 2152 /* Dump the type inheritance graph. */ 2153 2154 static void 2155 dump_type_inheritance_graph (FILE *f) 2156 { 2157 unsigned int i; 2158 unsigned int num_all_types = 0, num_types = 0, num_duplicates = 0; 2159 if (!odr_types_ptr) 2160 return; 2161 fprintf (f, "\n\nType inheritance graph:\n"); 2162 for (i = 0; i < odr_types.length (); i++) 2163 { 2164 if (odr_types[i] && odr_types[i]->bases.length () == 0) 2165 dump_odr_type (f, odr_types[i]); 2166 } 2167 for (i = 0; i < odr_types.length (); i++) 2168 { 2169 if (!odr_types[i]) 2170 continue; 2171 2172 num_all_types++; 2173 if (!odr_types[i]->types || !odr_types[i]->types->length ()) 2174 continue; 2175 2176 /* To aid ODR warnings we also mangle integer constants but do 2177 not consider duplicates there. */ 2178 if (TREE_CODE (odr_types[i]->type) == INTEGER_TYPE) 2179 continue; 2180 2181 /* It is normal to have one duplicate and one normal variant. */ 2182 if (odr_types[i]->types->length () == 1 2183 && COMPLETE_TYPE_P (odr_types[i]->type) 2184 && !COMPLETE_TYPE_P ((*odr_types[i]->types)[0])) 2185 continue; 2186 2187 num_types ++; 2188 2189 unsigned int j; 2190 fprintf (f, "Duplicate tree types for odr type %i\n", i); 2191 print_node (f, "", odr_types[i]->type, 0); 2192 print_node (f, "", TYPE_NAME (odr_types[i]->type), 0); 2193 putc ('\n',f); 2194 for (j = 0; j < odr_types[i]->types->length (); j++) 2195 { 2196 tree t; 2197 num_duplicates ++; 2198 fprintf (f, "duplicate #%i\n", j); 2199 print_node (f, "", (*odr_types[i]->types)[j], 0); 2200 t = (*odr_types[i]->types)[j]; 2201 while (TYPE_P (t) && TYPE_CONTEXT (t)) 2202 { 2203 t = TYPE_CONTEXT (t); 2204 print_node (f, "", t, 0); 2205 } 2206 print_node (f, "", TYPE_NAME ((*odr_types[i]->types)[j]), 0); 2207 putc ('\n',f); 2208 } 2209 } 2210 fprintf (f, "Out of %i types there are %i types with duplicates; " 2211 "%i duplicates overall\n", num_all_types, num_types, num_duplicates); 2212 } 2213 2214 /* Save some WPA->ltrans streaming by freeing stuff needed only for good 2215 ODR warnings. 2216 We make TYPE_DECLs to not point back 2217 to the type (which is needed to keep them in the same SCC and preserve 2218 location information to output warnings) and subsequently we make all 2219 TYPE_DECLS of same assembler name equivalent. */ 2220 2221 static void 2222 free_odr_warning_data () 2223 { 2224 static bool odr_data_freed = false; 2225 2226 if (odr_data_freed || !flag_wpa || !odr_types_ptr) 2227 return; 2228 2229 odr_data_freed = true; 2230 2231 for (unsigned int i = 0; i < odr_types.length (); i++) 2232 if (odr_types[i]) 2233 { 2234 tree t = odr_types[i]->type; 2235 2236 TREE_TYPE (TYPE_NAME (t)) = void_type_node; 2237 2238 if (odr_types[i]->types) 2239 for (unsigned int j = 0; j < odr_types[i]->types->length (); j++) 2240 { 2241 tree td = (*odr_types[i]->types)[j]; 2242 2243 TYPE_NAME (td) = TYPE_NAME (t); 2244 } 2245 } 2246 odr_data_freed = true; 2247 } 2248 2249 /* Initialize IPA devirt and build inheritance tree graph. */ 2250 2251 void 2252 build_type_inheritance_graph (void) 2253 { 2254 struct symtab_node *n; 2255 FILE *inheritance_dump_file; 2256 dump_flags_t flags; 2257 2258 if (odr_hash) 2259 { 2260 free_odr_warning_data (); 2261 return; 2262 } 2263 timevar_push (TV_IPA_INHERITANCE); 2264 inheritance_dump_file = dump_begin (TDI_inheritance, &flags); 2265 odr_hash = new odr_hash_type (23); 2266 2267 /* We reconstruct the graph starting of types of all methods seen in the 2268 unit. */ 2269 FOR_EACH_SYMBOL (n) 2270 if (is_a <cgraph_node *> (n) 2271 && DECL_VIRTUAL_P (n->decl) 2272 && n->real_symbol_p ()) 2273 get_odr_type (TYPE_METHOD_BASETYPE (TREE_TYPE (n->decl)), true); 2274 2275 /* Look also for virtual tables of types that do not define any methods. 2276 2277 We need it in a case where class B has virtual base of class A 2278 re-defining its virtual method and there is class C with no virtual 2279 methods with B as virtual base. 2280 2281 Here we output B's virtual method in two variant - for non-virtual 2282 and virtual inheritance. B's virtual table has non-virtual version, 2283 while C's has virtual. 2284 2285 For this reason we need to know about C in order to include both 2286 variants of B. More correctly, record_target_from_binfo should 2287 add both variants of the method when walking B, but we have no 2288 link in between them. 2289 2290 We rely on fact that either the method is exported and thus we 2291 assume it is called externally or C is in anonymous namespace and 2292 thus we will see the vtable. */ 2293 2294 else if (is_a <varpool_node *> (n) 2295 && DECL_VIRTUAL_P (n->decl) 2296 && TREE_CODE (DECL_CONTEXT (n->decl)) == RECORD_TYPE 2297 && TYPE_BINFO (DECL_CONTEXT (n->decl)) 2298 && polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (n->decl)))) 2299 get_odr_type (TYPE_MAIN_VARIANT (DECL_CONTEXT (n->decl)), true); 2300 if (inheritance_dump_file) 2301 { 2302 dump_type_inheritance_graph (inheritance_dump_file); 2303 dump_end (TDI_inheritance, inheritance_dump_file); 2304 } 2305 free_odr_warning_data (); 2306 timevar_pop (TV_IPA_INHERITANCE); 2307 } 2308 2309 /* Return true if N has reference from live virtual table 2310 (and thus can be a destination of polymorphic call). 2311 Be conservatively correct when callgraph is not built or 2312 if the method may be referred externally. */ 2313 2314 static bool 2315 referenced_from_vtable_p (struct cgraph_node *node) 2316 { 2317 int i; 2318 struct ipa_ref *ref; 2319 bool found = false; 2320 2321 if (node->externally_visible 2322 || DECL_EXTERNAL (node->decl) 2323 || node->used_from_other_partition) 2324 return true; 2325 2326 /* Keep this test constant time. 2327 It is unlikely this can happen except for the case where speculative 2328 devirtualization introduced many speculative edges to this node. 2329 In this case the target is very likely alive anyway. */ 2330 if (node->ref_list.referring.length () > 100) 2331 return true; 2332 2333 /* We need references built. */ 2334 if (symtab->state <= CONSTRUCTION) 2335 return true; 2336 2337 for (i = 0; node->iterate_referring (i, ref); i++) 2338 if ((ref->use == IPA_REF_ALIAS 2339 && referenced_from_vtable_p (dyn_cast<cgraph_node *> (ref->referring))) 2340 || (ref->use == IPA_REF_ADDR 2341 && VAR_P (ref->referring->decl) 2342 && DECL_VIRTUAL_P (ref->referring->decl))) 2343 { 2344 found = true; 2345 break; 2346 } 2347 return found; 2348 } 2349 2350 /* Return if TARGET is cxa_pure_virtual. */ 2351 2352 static bool 2353 is_cxa_pure_virtual_p (tree target) 2354 { 2355 return target && TREE_CODE (TREE_TYPE (target)) != METHOD_TYPE 2356 && DECL_NAME (target) 2357 && id_equal (DECL_NAME (target), 2358 "__cxa_pure_virtual"); 2359 } 2360 2361 /* If TARGET has associated node, record it in the NODES array. 2362 CAN_REFER specify if program can refer to the target directly. 2363 if TARGET is unknown (NULL) or it cannot be inserted (for example because 2364 its body was already removed and there is no way to refer to it), clear 2365 COMPLETEP. */ 2366 2367 static void 2368 maybe_record_node (vec <cgraph_node *> &nodes, 2369 tree target, hash_set<tree> *inserted, 2370 bool can_refer, 2371 bool *completep) 2372 { 2373 struct cgraph_node *target_node, *alias_target; 2374 enum availability avail; 2375 bool pure_virtual = is_cxa_pure_virtual_p (target); 2376 2377 /* __builtin_unreachable do not need to be added into 2378 list of targets; the runtime effect of calling them is undefined. 2379 Only "real" virtual methods should be accounted. */ 2380 if (target && TREE_CODE (TREE_TYPE (target)) != METHOD_TYPE && !pure_virtual) 2381 return; 2382 2383 if (!can_refer) 2384 { 2385 /* The only case when method of anonymous namespace becomes unreferable 2386 is when we completely optimized it out. */ 2387 if (flag_ltrans 2388 || !target 2389 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target))) 2390 *completep = false; 2391 return; 2392 } 2393 2394 if (!target) 2395 return; 2396 2397 target_node = cgraph_node::get (target); 2398 2399 /* Prefer alias target over aliases, so we do not get confused by 2400 fake duplicates. */ 2401 if (target_node) 2402 { 2403 alias_target = target_node->ultimate_alias_target (&avail); 2404 if (target_node != alias_target 2405 && avail >= AVAIL_AVAILABLE 2406 && target_node->get_availability ()) 2407 target_node = alias_target; 2408 } 2409 2410 /* Method can only be called by polymorphic call if any 2411 of vtables referring to it are alive. 2412 2413 While this holds for non-anonymous functions, too, there are 2414 cases where we want to keep them in the list; for example 2415 inline functions with -fno-weak are static, but we still 2416 may devirtualize them when instance comes from other unit. 2417 The same holds for LTO. 2418 2419 Currently we ignore these functions in speculative devirtualization. 2420 ??? Maybe it would make sense to be more aggressive for LTO even 2421 elsewhere. */ 2422 if (!flag_ltrans 2423 && !pure_virtual 2424 && type_in_anonymous_namespace_p (DECL_CONTEXT (target)) 2425 && (!target_node 2426 || !referenced_from_vtable_p (target_node))) 2427 ; 2428 /* See if TARGET is useful function we can deal with. */ 2429 else if (target_node != NULL 2430 && (TREE_PUBLIC (target) 2431 || DECL_EXTERNAL (target) 2432 || target_node->definition) 2433 && target_node->real_symbol_p ()) 2434 { 2435 gcc_assert (!target_node->inlined_to); 2436 gcc_assert (target_node->real_symbol_p ()); 2437 /* When sanitizing, do not assume that __cxa_pure_virtual is not called 2438 by valid program. */ 2439 if (flag_sanitize & SANITIZE_UNREACHABLE) 2440 ; 2441 /* Only add pure virtual if it is the only possible target. This way 2442 we will preserve the diagnostics about pure virtual called in many 2443 cases without disabling optimization in other. */ 2444 else if (pure_virtual) 2445 { 2446 if (nodes.length ()) 2447 return; 2448 } 2449 /* If we found a real target, take away cxa_pure_virtual. */ 2450 else if (!pure_virtual && nodes.length () == 1 2451 && is_cxa_pure_virtual_p (nodes[0]->decl)) 2452 nodes.pop (); 2453 if (pure_virtual && nodes.length ()) 2454 return; 2455 if (!inserted->add (target)) 2456 { 2457 cached_polymorphic_call_targets->add (target_node); 2458 nodes.safe_push (target_node); 2459 } 2460 } 2461 else if (!completep) 2462 ; 2463 /* We have definition of __cxa_pure_virtual that is not accessible (it is 2464 optimized out or partitioned to other unit) so we cannot add it. When 2465 not sanitizing, there is nothing to do. 2466 Otherwise declare the list incomplete. */ 2467 else if (pure_virtual) 2468 { 2469 if (flag_sanitize & SANITIZE_UNREACHABLE) 2470 *completep = false; 2471 } 2472 else if (flag_ltrans 2473 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target))) 2474 *completep = false; 2475 } 2476 2477 /* See if BINFO's type matches OUTER_TYPE. If so, look up 2478 BINFO of subtype of OTR_TYPE at OFFSET and in that BINFO find 2479 method in vtable and insert method to NODES array 2480 or BASES_TO_CONSIDER if this array is non-NULL. 2481 Otherwise recurse to base BINFOs. 2482 This matches what get_binfo_at_offset does, but with offset 2483 being unknown. 2484 2485 TYPE_BINFOS is a stack of BINFOS of types with defined 2486 virtual table seen on way from class type to BINFO. 2487 2488 MATCHED_VTABLES tracks virtual tables we already did lookup 2489 for virtual function in. INSERTED tracks nodes we already 2490 inserted. 2491 2492 ANONYMOUS is true if BINFO is part of anonymous namespace. 2493 2494 Clear COMPLETEP when we hit unreferable target. 2495 */ 2496 2497 static void 2498 record_target_from_binfo (vec <cgraph_node *> &nodes, 2499 vec <tree> *bases_to_consider, 2500 tree binfo, 2501 tree otr_type, 2502 vec <tree> &type_binfos, 2503 HOST_WIDE_INT otr_token, 2504 tree outer_type, 2505 HOST_WIDE_INT offset, 2506 hash_set<tree> *inserted, 2507 hash_set<tree> *matched_vtables, 2508 bool anonymous, 2509 bool *completep) 2510 { 2511 tree type = BINFO_TYPE (binfo); 2512 int i; 2513 tree base_binfo; 2514 2515 2516 if (BINFO_VTABLE (binfo)) 2517 type_binfos.safe_push (binfo); 2518 if (types_same_for_odr (type, outer_type)) 2519 { 2520 int i; 2521 tree type_binfo = NULL; 2522 2523 /* Look up BINFO with virtual table. For normal types it is always last 2524 binfo on stack. */ 2525 for (i = type_binfos.length () - 1; i >= 0; i--) 2526 if (BINFO_OFFSET (type_binfos[i]) == BINFO_OFFSET (binfo)) 2527 { 2528 type_binfo = type_binfos[i]; 2529 break; 2530 } 2531 if (BINFO_VTABLE (binfo)) 2532 type_binfos.pop (); 2533 /* If this is duplicated BINFO for base shared by virtual inheritance, 2534 we may not have its associated vtable. This is not a problem, since 2535 we will walk it on the other path. */ 2536 if (!type_binfo) 2537 return; 2538 tree inner_binfo = get_binfo_at_offset (type_binfo, 2539 offset, otr_type); 2540 if (!inner_binfo) 2541 { 2542 gcc_assert (odr_violation_reported); 2543 return; 2544 } 2545 /* For types in anonymous namespace first check if the respective vtable 2546 is alive. If not, we know the type can't be called. */ 2547 if (!flag_ltrans && anonymous) 2548 { 2549 tree vtable = BINFO_VTABLE (inner_binfo); 2550 varpool_node *vnode; 2551 2552 if (TREE_CODE (vtable) == POINTER_PLUS_EXPR) 2553 vtable = TREE_OPERAND (TREE_OPERAND (vtable, 0), 0); 2554 vnode = varpool_node::get (vtable); 2555 if (!vnode || !vnode->definition) 2556 return; 2557 } 2558 gcc_assert (inner_binfo); 2559 if (bases_to_consider 2560 ? !matched_vtables->contains (BINFO_VTABLE (inner_binfo)) 2561 : !matched_vtables->add (BINFO_VTABLE (inner_binfo))) 2562 { 2563 bool can_refer; 2564 tree target = gimple_get_virt_method_for_binfo (otr_token, 2565 inner_binfo, 2566 &can_refer); 2567 if (!bases_to_consider) 2568 maybe_record_node (nodes, target, inserted, can_refer, completep); 2569 /* Destructors are never called via construction vtables. */ 2570 else if (!target || !DECL_CXX_DESTRUCTOR_P (target)) 2571 bases_to_consider->safe_push (target); 2572 } 2573 return; 2574 } 2575 2576 /* Walk bases. */ 2577 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 2578 /* Walking bases that have no virtual method is pointless exercise. */ 2579 if (polymorphic_type_binfo_p (base_binfo)) 2580 record_target_from_binfo (nodes, bases_to_consider, base_binfo, otr_type, 2581 type_binfos, 2582 otr_token, outer_type, offset, inserted, 2583 matched_vtables, anonymous, completep); 2584 if (BINFO_VTABLE (binfo)) 2585 type_binfos.pop (); 2586 } 2587 2588 /* Look up virtual methods matching OTR_TYPE (with OFFSET and OTR_TOKEN) 2589 of TYPE, insert them to NODES, recurse into derived nodes. 2590 INSERTED is used to avoid duplicate insertions of methods into NODES. 2591 MATCHED_VTABLES are used to avoid duplicate walking vtables. 2592 Clear COMPLETEP if unreferable target is found. 2593 2594 If CONSIDER_CONSTRUCTION is true, record to BASES_TO_CONSIDER 2595 all cases where BASE_SKIPPED is true (because the base is abstract 2596 class). */ 2597 2598 static void 2599 possible_polymorphic_call_targets_1 (vec <cgraph_node *> &nodes, 2600 hash_set<tree> *inserted, 2601 hash_set<tree> *matched_vtables, 2602 tree otr_type, 2603 odr_type type, 2604 HOST_WIDE_INT otr_token, 2605 tree outer_type, 2606 HOST_WIDE_INT offset, 2607 bool *completep, 2608 vec <tree> &bases_to_consider, 2609 bool consider_construction) 2610 { 2611 tree binfo = TYPE_BINFO (type->type); 2612 unsigned int i; 2613 auto_vec <tree, 8> type_binfos; 2614 bool possibly_instantiated = type_possibly_instantiated_p (type->type); 2615 2616 /* We may need to consider types w/o instances because of possible derived 2617 types using their methods either directly or via construction vtables. 2618 We are safe to skip them when all derivations are known, since we will 2619 handle them later. 2620 This is done by recording them to BASES_TO_CONSIDER array. */ 2621 if (possibly_instantiated || consider_construction) 2622 { 2623 record_target_from_binfo (nodes, 2624 (!possibly_instantiated 2625 && type_all_derivations_known_p (type->type)) 2626 ? &bases_to_consider : NULL, 2627 binfo, otr_type, type_binfos, otr_token, 2628 outer_type, offset, 2629 inserted, matched_vtables, 2630 type->anonymous_namespace, completep); 2631 } 2632 for (i = 0; i < type->derived_types.length (); i++) 2633 possible_polymorphic_call_targets_1 (nodes, inserted, 2634 matched_vtables, 2635 otr_type, 2636 type->derived_types[i], 2637 otr_token, outer_type, offset, completep, 2638 bases_to_consider, consider_construction); 2639 } 2640 2641 /* Cache of queries for polymorphic call targets. 2642 2643 Enumerating all call targets may get expensive when there are many 2644 polymorphic calls in the program, so we memoize all the previous 2645 queries and avoid duplicated work. */ 2646 2647 class polymorphic_call_target_d 2648 { 2649 public: 2650 HOST_WIDE_INT otr_token; 2651 ipa_polymorphic_call_context context; 2652 odr_type type; 2653 vec <cgraph_node *> targets; 2654 tree decl_warning; 2655 int type_warning; 2656 unsigned int n_odr_types; 2657 bool complete; 2658 bool speculative; 2659 }; 2660 2661 /* Polymorphic call target cache helpers. */ 2662 2663 struct polymorphic_call_target_hasher 2664 : pointer_hash <polymorphic_call_target_d> 2665 { 2666 static inline hashval_t hash (const polymorphic_call_target_d *); 2667 static inline bool equal (const polymorphic_call_target_d *, 2668 const polymorphic_call_target_d *); 2669 static inline void remove (polymorphic_call_target_d *); 2670 }; 2671 2672 /* Return the computed hashcode for ODR_QUERY. */ 2673 2674 inline hashval_t 2675 polymorphic_call_target_hasher::hash (const polymorphic_call_target_d *odr_query) 2676 { 2677 inchash::hash hstate (odr_query->otr_token); 2678 2679 hstate.add_hwi (odr_query->type->id); 2680 hstate.merge_hash (TYPE_UID (odr_query->context.outer_type)); 2681 hstate.add_hwi (odr_query->context.offset); 2682 hstate.add_hwi (odr_query->n_odr_types); 2683 2684 if (odr_query->context.speculative_outer_type) 2685 { 2686 hstate.merge_hash (TYPE_UID (odr_query->context.speculative_outer_type)); 2687 hstate.add_hwi (odr_query->context.speculative_offset); 2688 } 2689 hstate.add_flag (odr_query->speculative); 2690 hstate.add_flag (odr_query->context.maybe_in_construction); 2691 hstate.add_flag (odr_query->context.maybe_derived_type); 2692 hstate.add_flag (odr_query->context.speculative_maybe_derived_type); 2693 hstate.commit_flag (); 2694 return hstate.end (); 2695 } 2696 2697 /* Compare cache entries T1 and T2. */ 2698 2699 inline bool 2700 polymorphic_call_target_hasher::equal (const polymorphic_call_target_d *t1, 2701 const polymorphic_call_target_d *t2) 2702 { 2703 return (t1->type == t2->type && t1->otr_token == t2->otr_token 2704 && t1->speculative == t2->speculative 2705 && t1->context.offset == t2->context.offset 2706 && t1->context.speculative_offset == t2->context.speculative_offset 2707 && t1->context.outer_type == t2->context.outer_type 2708 && t1->context.speculative_outer_type == t2->context.speculative_outer_type 2709 && t1->context.maybe_in_construction 2710 == t2->context.maybe_in_construction 2711 && t1->context.maybe_derived_type == t2->context.maybe_derived_type 2712 && (t1->context.speculative_maybe_derived_type 2713 == t2->context.speculative_maybe_derived_type) 2714 /* Adding new type may affect outcome of target search. */ 2715 && t1->n_odr_types == t2->n_odr_types); 2716 } 2717 2718 /* Remove entry in polymorphic call target cache hash. */ 2719 2720 inline void 2721 polymorphic_call_target_hasher::remove (polymorphic_call_target_d *v) 2722 { 2723 v->targets.release (); 2724 free (v); 2725 } 2726 2727 /* Polymorphic call target query cache. */ 2728 2729 typedef hash_table<polymorphic_call_target_hasher> 2730 polymorphic_call_target_hash_type; 2731 static polymorphic_call_target_hash_type *polymorphic_call_target_hash; 2732 2733 /* Destroy polymorphic call target query cache. */ 2734 2735 static void 2736 free_polymorphic_call_targets_hash () 2737 { 2738 if (cached_polymorphic_call_targets) 2739 { 2740 delete polymorphic_call_target_hash; 2741 polymorphic_call_target_hash = NULL; 2742 delete cached_polymorphic_call_targets; 2743 cached_polymorphic_call_targets = NULL; 2744 } 2745 } 2746 2747 /* Force rebuilding type inheritance graph from scratch. 2748 This is use to make sure that we do not keep references to types 2749 which was not visible to free_lang_data. */ 2750 2751 void 2752 rebuild_type_inheritance_graph () 2753 { 2754 if (!odr_hash) 2755 return; 2756 delete odr_hash; 2757 odr_hash = NULL; 2758 odr_types_ptr = NULL; 2759 free_polymorphic_call_targets_hash (); 2760 } 2761 2762 /* When virtual function is removed, we may need to flush the cache. */ 2763 2764 static void 2765 devirt_node_removal_hook (struct cgraph_node *n, void *d ATTRIBUTE_UNUSED) 2766 { 2767 if (cached_polymorphic_call_targets 2768 && !thunk_expansion 2769 && cached_polymorphic_call_targets->contains (n)) 2770 free_polymorphic_call_targets_hash (); 2771 } 2772 2773 /* Look up base of BINFO that has virtual table VTABLE with OFFSET. */ 2774 2775 tree 2776 subbinfo_with_vtable_at_offset (tree binfo, unsigned HOST_WIDE_INT offset, 2777 tree vtable) 2778 { 2779 tree v = BINFO_VTABLE (binfo); 2780 int i; 2781 tree base_binfo; 2782 unsigned HOST_WIDE_INT this_offset; 2783 2784 if (v) 2785 { 2786 if (!vtable_pointer_value_to_vtable (v, &v, &this_offset)) 2787 gcc_unreachable (); 2788 2789 if (offset == this_offset 2790 && DECL_ASSEMBLER_NAME (v) == DECL_ASSEMBLER_NAME (vtable)) 2791 return binfo; 2792 } 2793 2794 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 2795 if (polymorphic_type_binfo_p (base_binfo)) 2796 { 2797 base_binfo = subbinfo_with_vtable_at_offset (base_binfo, offset, vtable); 2798 if (base_binfo) 2799 return base_binfo; 2800 } 2801 return NULL; 2802 } 2803 2804 /* T is known constant value of virtual table pointer. 2805 Store virtual table to V and its offset to OFFSET. 2806 Return false if T does not look like virtual table reference. */ 2807 2808 bool 2809 vtable_pointer_value_to_vtable (const_tree t, tree *v, 2810 unsigned HOST_WIDE_INT *offset) 2811 { 2812 /* We expect &MEM[(void *)&virtual_table + 16B]. 2813 We obtain object's BINFO from the context of the virtual table. 2814 This one contains pointer to virtual table represented via 2815 POINTER_PLUS_EXPR. Verify that this pointer matches what 2816 we propagated through. 2817 2818 In the case of virtual inheritance, the virtual tables may 2819 be nested, i.e. the offset may be different from 16 and we may 2820 need to dive into the type representation. */ 2821 if (TREE_CODE (t) == ADDR_EXPR 2822 && TREE_CODE (TREE_OPERAND (t, 0)) == MEM_REF 2823 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == ADDR_EXPR 2824 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 1)) == INTEGER_CST 2825 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 0)) 2826 == VAR_DECL) 2827 && DECL_VIRTUAL_P (TREE_OPERAND (TREE_OPERAND 2828 (TREE_OPERAND (t, 0), 0), 0))) 2829 { 2830 *v = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 0); 2831 *offset = tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (t, 0), 1)); 2832 return true; 2833 } 2834 2835 /* Alternative representation, used by C++ frontend is POINTER_PLUS_EXPR. 2836 We need to handle it when T comes from static variable initializer or 2837 BINFO. */ 2838 if (TREE_CODE (t) == POINTER_PLUS_EXPR) 2839 { 2840 *offset = tree_to_uhwi (TREE_OPERAND (t, 1)); 2841 t = TREE_OPERAND (t, 0); 2842 } 2843 else 2844 *offset = 0; 2845 2846 if (TREE_CODE (t) != ADDR_EXPR) 2847 return false; 2848 *v = TREE_OPERAND (t, 0); 2849 return true; 2850 } 2851 2852 /* T is known constant value of virtual table pointer. Return BINFO of the 2853 instance type. */ 2854 2855 tree 2856 vtable_pointer_value_to_binfo (const_tree t) 2857 { 2858 tree vtable; 2859 unsigned HOST_WIDE_INT offset; 2860 2861 if (!vtable_pointer_value_to_vtable (t, &vtable, &offset)) 2862 return NULL_TREE; 2863 2864 /* FIXME: for stores of construction vtables we return NULL, 2865 because we do not have BINFO for those. Eventually we should fix 2866 our representation to allow this case to be handled, too. 2867 In the case we see store of BINFO we however may assume 2868 that standard folding will be able to cope with it. */ 2869 return subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable)), 2870 offset, vtable); 2871 } 2872 2873 /* Walk bases of OUTER_TYPE that contain OTR_TYPE at OFFSET. 2874 Look up their respective virtual methods for OTR_TOKEN and OTR_TYPE 2875 and insert them in NODES. 2876 2877 MATCHED_VTABLES and INSERTED is used to avoid duplicated work. */ 2878 2879 static void 2880 record_targets_from_bases (tree otr_type, 2881 HOST_WIDE_INT otr_token, 2882 tree outer_type, 2883 HOST_WIDE_INT offset, 2884 vec <cgraph_node *> &nodes, 2885 hash_set<tree> *inserted, 2886 hash_set<tree> *matched_vtables, 2887 bool *completep) 2888 { 2889 while (true) 2890 { 2891 HOST_WIDE_INT pos, size; 2892 tree base_binfo; 2893 tree fld; 2894 2895 if (types_same_for_odr (outer_type, otr_type)) 2896 return; 2897 2898 for (fld = TYPE_FIELDS (outer_type); fld; fld = DECL_CHAIN (fld)) 2899 { 2900 if (TREE_CODE (fld) != FIELD_DECL) 2901 continue; 2902 2903 pos = int_bit_position (fld); 2904 size = tree_to_shwi (DECL_SIZE (fld)); 2905 if (pos <= offset && (pos + size) > offset 2906 /* Do not get confused by zero sized bases. */ 2907 && polymorphic_type_binfo_p (TYPE_BINFO (TREE_TYPE (fld)))) 2908 break; 2909 } 2910 /* Within a class type we should always find corresponding fields. */ 2911 gcc_assert (fld && TREE_CODE (TREE_TYPE (fld)) == RECORD_TYPE); 2912 2913 /* Nonbase types should have been stripped by outer_class_type. */ 2914 gcc_assert (DECL_ARTIFICIAL (fld)); 2915 2916 outer_type = TREE_TYPE (fld); 2917 offset -= pos; 2918 2919 base_binfo = get_binfo_at_offset (TYPE_BINFO (outer_type), 2920 offset, otr_type); 2921 if (!base_binfo) 2922 { 2923 gcc_assert (odr_violation_reported); 2924 return; 2925 } 2926 gcc_assert (base_binfo); 2927 if (!matched_vtables->add (BINFO_VTABLE (base_binfo))) 2928 { 2929 bool can_refer; 2930 tree target = gimple_get_virt_method_for_binfo (otr_token, 2931 base_binfo, 2932 &can_refer); 2933 if (!target || ! DECL_CXX_DESTRUCTOR_P (target)) 2934 maybe_record_node (nodes, target, inserted, can_refer, completep); 2935 matched_vtables->add (BINFO_VTABLE (base_binfo)); 2936 } 2937 } 2938 } 2939 2940 /* When virtual table is removed, we may need to flush the cache. */ 2941 2942 static void 2943 devirt_variable_node_removal_hook (varpool_node *n, 2944 void *d ATTRIBUTE_UNUSED) 2945 { 2946 if (cached_polymorphic_call_targets 2947 && DECL_VIRTUAL_P (n->decl) 2948 && type_in_anonymous_namespace_p (DECL_CONTEXT (n->decl))) 2949 free_polymorphic_call_targets_hash (); 2950 } 2951 2952 /* Record about how many calls would benefit from given type to be final. */ 2953 2954 struct odr_type_warn_count 2955 { 2956 tree type; 2957 int count; 2958 profile_count dyn_count; 2959 }; 2960 2961 /* Record about how many calls would benefit from given method to be final. */ 2962 2963 struct decl_warn_count 2964 { 2965 tree decl; 2966 int count; 2967 profile_count dyn_count; 2968 }; 2969 2970 /* Information about type and decl warnings. */ 2971 2972 class final_warning_record 2973 { 2974 public: 2975 /* If needed grow type_warnings vector and initialize new decl_warn_count 2976 to have dyn_count set to profile_count::zero (). */ 2977 void grow_type_warnings (unsigned newlen); 2978 2979 profile_count dyn_count; 2980 auto_vec<odr_type_warn_count> type_warnings; 2981 hash_map<tree, decl_warn_count> decl_warnings; 2982 }; 2983 2984 void 2985 final_warning_record::grow_type_warnings (unsigned newlen) 2986 { 2987 unsigned len = type_warnings.length (); 2988 if (newlen > len) 2989 { 2990 type_warnings.safe_grow_cleared (newlen); 2991 for (unsigned i = len; i < newlen; i++) 2992 type_warnings[i].dyn_count = profile_count::zero (); 2993 } 2994 } 2995 2996 class final_warning_record *final_warning_records; 2997 2998 /* Return vector containing possible targets of polymorphic call of type 2999 OTR_TYPE calling method OTR_TOKEN within type of OTR_OUTER_TYPE and OFFSET. 3000 If INCLUDE_BASES is true, walk also base types of OUTER_TYPES containing 3001 OTR_TYPE and include their virtual method. This is useful for types 3002 possibly in construction or destruction where the virtual table may 3003 temporarily change to one of base types. INCLUDE_DERIVED_TYPES make 3004 us to walk the inheritance graph for all derivations. 3005 3006 If COMPLETEP is non-NULL, store true if the list is complete. 3007 CACHE_TOKEN (if non-NULL) will get stored to an unique ID of entry 3008 in the target cache. If user needs to visit every target list 3009 just once, it can memoize them. 3010 3011 If SPECULATIVE is set, the list will not contain targets that 3012 are not speculatively taken. 3013 3014 Returned vector is placed into cache. It is NOT caller's responsibility 3015 to free it. The vector can be freed on cgraph_remove_node call if 3016 the particular node is a virtual function present in the cache. */ 3017 3018 vec <cgraph_node *> 3019 possible_polymorphic_call_targets (tree otr_type, 3020 HOST_WIDE_INT otr_token, 3021 ipa_polymorphic_call_context context, 3022 bool *completep, 3023 void **cache_token, 3024 bool speculative) 3025 { 3026 static struct cgraph_node_hook_list *node_removal_hook_holder; 3027 vec <cgraph_node *> nodes = vNULL; 3028 auto_vec <tree, 8> bases_to_consider; 3029 odr_type type, outer_type; 3030 polymorphic_call_target_d key; 3031 polymorphic_call_target_d **slot; 3032 unsigned int i; 3033 tree binfo, target; 3034 bool complete; 3035 bool can_refer = false; 3036 bool skipped = false; 3037 3038 otr_type = TYPE_MAIN_VARIANT (otr_type); 3039 3040 /* If ODR is not initialized or the context is invalid, return empty 3041 incomplete list. */ 3042 if (!odr_hash || context.invalid || !TYPE_BINFO (otr_type)) 3043 { 3044 if (completep) 3045 *completep = context.invalid; 3046 if (cache_token) 3047 *cache_token = NULL; 3048 return nodes; 3049 } 3050 3051 /* Do not bother to compute speculative info when user do not asks for it. */ 3052 if (!speculative || !context.speculative_outer_type) 3053 context.clear_speculation (); 3054 3055 type = get_odr_type (otr_type, true); 3056 3057 /* Recording type variants would waste results cache. */ 3058 gcc_assert (!context.outer_type 3059 || TYPE_MAIN_VARIANT (context.outer_type) == context.outer_type); 3060 3061 /* Look up the outer class type we want to walk. 3062 If we fail to do so, the context is invalid. */ 3063 if ((context.outer_type || context.speculative_outer_type) 3064 && !context.restrict_to_inner_class (otr_type)) 3065 { 3066 if (completep) 3067 *completep = true; 3068 if (cache_token) 3069 *cache_token = NULL; 3070 return nodes; 3071 } 3072 gcc_assert (!context.invalid); 3073 3074 /* Check that restrict_to_inner_class kept the main variant. */ 3075 gcc_assert (!context.outer_type 3076 || TYPE_MAIN_VARIANT (context.outer_type) == context.outer_type); 3077 3078 /* We canonicalize our query, so we do not need extra hashtable entries. */ 3079 3080 /* Without outer type, we have no use for offset. Just do the 3081 basic search from inner type. */ 3082 if (!context.outer_type) 3083 context.clear_outer_type (otr_type); 3084 /* We need to update our hierarchy if the type does not exist. */ 3085 outer_type = get_odr_type (context.outer_type, true); 3086 /* If the type is complete, there are no derivations. */ 3087 if (TYPE_FINAL_P (outer_type->type)) 3088 context.maybe_derived_type = false; 3089 3090 /* Initialize query cache. */ 3091 if (!cached_polymorphic_call_targets) 3092 { 3093 cached_polymorphic_call_targets = new hash_set<cgraph_node *>; 3094 polymorphic_call_target_hash 3095 = new polymorphic_call_target_hash_type (23); 3096 if (!node_removal_hook_holder) 3097 { 3098 node_removal_hook_holder = 3099 symtab->add_cgraph_removal_hook (&devirt_node_removal_hook, NULL); 3100 symtab->add_varpool_removal_hook (&devirt_variable_node_removal_hook, 3101 NULL); 3102 } 3103 } 3104 3105 if (in_lto_p) 3106 { 3107 if (context.outer_type != otr_type) 3108 context.outer_type 3109 = get_odr_type (context.outer_type, true)->type; 3110 if (context.speculative_outer_type) 3111 context.speculative_outer_type 3112 = get_odr_type (context.speculative_outer_type, true)->type; 3113 } 3114 3115 /* Look up cached answer. */ 3116 key.type = type; 3117 key.otr_token = otr_token; 3118 key.speculative = speculative; 3119 key.context = context; 3120 key.n_odr_types = odr_types.length (); 3121 slot = polymorphic_call_target_hash->find_slot (&key, INSERT); 3122 if (cache_token) 3123 *cache_token = (void *)*slot; 3124 if (*slot) 3125 { 3126 if (completep) 3127 *completep = (*slot)->complete; 3128 if ((*slot)->type_warning && final_warning_records) 3129 { 3130 final_warning_records->type_warnings[(*slot)->type_warning - 1].count++; 3131 if (!final_warning_records->type_warnings 3132 [(*slot)->type_warning - 1].dyn_count.initialized_p ()) 3133 final_warning_records->type_warnings 3134 [(*slot)->type_warning - 1].dyn_count = profile_count::zero (); 3135 if (final_warning_records->dyn_count > 0) 3136 final_warning_records->type_warnings[(*slot)->type_warning - 1].dyn_count 3137 = final_warning_records->type_warnings[(*slot)->type_warning - 1].dyn_count 3138 + final_warning_records->dyn_count; 3139 } 3140 if (!speculative && (*slot)->decl_warning && final_warning_records) 3141 { 3142 struct decl_warn_count *c = 3143 final_warning_records->decl_warnings.get ((*slot)->decl_warning); 3144 c->count++; 3145 if (final_warning_records->dyn_count > 0) 3146 c->dyn_count += final_warning_records->dyn_count; 3147 } 3148 return (*slot)->targets; 3149 } 3150 3151 complete = true; 3152 3153 /* Do actual search. */ 3154 timevar_push (TV_IPA_VIRTUAL_CALL); 3155 *slot = XCNEW (polymorphic_call_target_d); 3156 if (cache_token) 3157 *cache_token = (void *)*slot; 3158 (*slot)->type = type; 3159 (*slot)->otr_token = otr_token; 3160 (*slot)->context = context; 3161 (*slot)->speculative = speculative; 3162 3163 hash_set<tree> inserted; 3164 hash_set<tree> matched_vtables; 3165 3166 /* First insert targets we speculatively identified as likely. */ 3167 if (context.speculative_outer_type) 3168 { 3169 odr_type speculative_outer_type; 3170 bool speculation_complete = true; 3171 3172 /* First insert target from type itself and check if it may have 3173 derived types. */ 3174 speculative_outer_type = get_odr_type (context.speculative_outer_type, true); 3175 if (TYPE_FINAL_P (speculative_outer_type->type)) 3176 context.speculative_maybe_derived_type = false; 3177 binfo = get_binfo_at_offset (TYPE_BINFO (speculative_outer_type->type), 3178 context.speculative_offset, otr_type); 3179 if (binfo) 3180 target = gimple_get_virt_method_for_binfo (otr_token, binfo, 3181 &can_refer); 3182 else 3183 target = NULL; 3184 3185 /* In the case we get complete method, we don't need 3186 to walk derivations. */ 3187 if (target && DECL_FINAL_P (target)) 3188 context.speculative_maybe_derived_type = false; 3189 if (type_possibly_instantiated_p (speculative_outer_type->type)) 3190 maybe_record_node (nodes, target, &inserted, can_refer, &speculation_complete); 3191 if (binfo) 3192 matched_vtables.add (BINFO_VTABLE (binfo)); 3193 3194 3195 /* Next walk recursively all derived types. */ 3196 if (context.speculative_maybe_derived_type) 3197 for (i = 0; i < speculative_outer_type->derived_types.length(); i++) 3198 possible_polymorphic_call_targets_1 (nodes, &inserted, 3199 &matched_vtables, 3200 otr_type, 3201 speculative_outer_type->derived_types[i], 3202 otr_token, speculative_outer_type->type, 3203 context.speculative_offset, 3204 &speculation_complete, 3205 bases_to_consider, 3206 false); 3207 } 3208 3209 if (!speculative || !nodes.length ()) 3210 { 3211 /* First see virtual method of type itself. */ 3212 binfo = get_binfo_at_offset (TYPE_BINFO (outer_type->type), 3213 context.offset, otr_type); 3214 if (binfo) 3215 target = gimple_get_virt_method_for_binfo (otr_token, binfo, 3216 &can_refer); 3217 else 3218 { 3219 gcc_assert (odr_violation_reported); 3220 target = NULL; 3221 } 3222 3223 /* Destructors are never called through construction virtual tables, 3224 because the type is always known. */ 3225 if (target && DECL_CXX_DESTRUCTOR_P (target)) 3226 context.maybe_in_construction = false; 3227 3228 if (target) 3229 { 3230 /* In the case we get complete method, we don't need 3231 to walk derivations. */ 3232 if (DECL_FINAL_P (target)) 3233 context.maybe_derived_type = false; 3234 } 3235 3236 /* If OUTER_TYPE is abstract, we know we are not seeing its instance. */ 3237 if (type_possibly_instantiated_p (outer_type->type)) 3238 maybe_record_node (nodes, target, &inserted, can_refer, &complete); 3239 else 3240 skipped = true; 3241 3242 if (binfo) 3243 matched_vtables.add (BINFO_VTABLE (binfo)); 3244 3245 /* Next walk recursively all derived types. */ 3246 if (context.maybe_derived_type) 3247 { 3248 for (i = 0; i < outer_type->derived_types.length(); i++) 3249 possible_polymorphic_call_targets_1 (nodes, &inserted, 3250 &matched_vtables, 3251 otr_type, 3252 outer_type->derived_types[i], 3253 otr_token, outer_type->type, 3254 context.offset, &complete, 3255 bases_to_consider, 3256 context.maybe_in_construction); 3257 3258 if (!outer_type->all_derivations_known) 3259 { 3260 if (!speculative && final_warning_records 3261 && nodes.length () == 1 3262 && TREE_CODE (TREE_TYPE (nodes[0]->decl)) == METHOD_TYPE) 3263 { 3264 if (complete 3265 && warn_suggest_final_types 3266 && !outer_type->derived_types.length ()) 3267 { 3268 final_warning_records->grow_type_warnings 3269 (outer_type->id); 3270 final_warning_records->type_warnings[outer_type->id].count++; 3271 if (!final_warning_records->type_warnings 3272 [outer_type->id].dyn_count.initialized_p ()) 3273 final_warning_records->type_warnings 3274 [outer_type->id].dyn_count = profile_count::zero (); 3275 final_warning_records->type_warnings[outer_type->id].dyn_count 3276 += final_warning_records->dyn_count; 3277 final_warning_records->type_warnings[outer_type->id].type 3278 = outer_type->type; 3279 (*slot)->type_warning = outer_type->id + 1; 3280 } 3281 if (complete 3282 && warn_suggest_final_methods 3283 && types_same_for_odr (DECL_CONTEXT (nodes[0]->decl), 3284 outer_type->type)) 3285 { 3286 bool existed; 3287 struct decl_warn_count &c = 3288 final_warning_records->decl_warnings.get_or_insert 3289 (nodes[0]->decl, &existed); 3290 3291 if (existed) 3292 { 3293 c.count++; 3294 c.dyn_count += final_warning_records->dyn_count; 3295 } 3296 else 3297 { 3298 c.count = 1; 3299 c.dyn_count = final_warning_records->dyn_count; 3300 c.decl = nodes[0]->decl; 3301 } 3302 (*slot)->decl_warning = nodes[0]->decl; 3303 } 3304 } 3305 complete = false; 3306 } 3307 } 3308 3309 if (!speculative) 3310 { 3311 /* Destructors are never called through construction virtual tables, 3312 because the type is always known. One of entries may be 3313 cxa_pure_virtual so look to at least two of them. */ 3314 if (context.maybe_in_construction) 3315 for (i =0 ; i < MIN (nodes.length (), 2); i++) 3316 if (DECL_CXX_DESTRUCTOR_P (nodes[i]->decl)) 3317 context.maybe_in_construction = false; 3318 if (context.maybe_in_construction) 3319 { 3320 if (type != outer_type 3321 && (!skipped 3322 || (context.maybe_derived_type 3323 && !type_all_derivations_known_p (outer_type->type)))) 3324 record_targets_from_bases (otr_type, otr_token, outer_type->type, 3325 context.offset, nodes, &inserted, 3326 &matched_vtables, &complete); 3327 if (skipped) 3328 maybe_record_node (nodes, target, &inserted, can_refer, &complete); 3329 for (i = 0; i < bases_to_consider.length(); i++) 3330 maybe_record_node (nodes, bases_to_consider[i], &inserted, can_refer, &complete); 3331 } 3332 } 3333 } 3334 3335 (*slot)->targets = nodes; 3336 (*slot)->complete = complete; 3337 (*slot)->n_odr_types = odr_types.length (); 3338 if (completep) 3339 *completep = complete; 3340 3341 timevar_pop (TV_IPA_VIRTUAL_CALL); 3342 return nodes; 3343 } 3344 3345 bool 3346 add_decl_warning (const tree &key ATTRIBUTE_UNUSED, const decl_warn_count &value, 3347 vec<const decl_warn_count*> *vec) 3348 { 3349 vec->safe_push (&value); 3350 return true; 3351 } 3352 3353 /* Dump target list TARGETS into FILE. */ 3354 3355 static void 3356 dump_targets (FILE *f, vec <cgraph_node *> targets, bool verbose) 3357 { 3358 unsigned int i; 3359 3360 for (i = 0; i < targets.length (); i++) 3361 { 3362 char *name = NULL; 3363 if (in_lto_p) 3364 name = cplus_demangle_v3 (targets[i]->asm_name (), 0); 3365 fprintf (f, " %s", name ? name : targets[i]->dump_name ()); 3366 if (in_lto_p) 3367 free (name); 3368 if (!targets[i]->definition) 3369 fprintf (f, " (no definition%s)", 3370 DECL_DECLARED_INLINE_P (targets[i]->decl) 3371 ? " inline" : ""); 3372 /* With many targets for every call polymorphic dumps are going to 3373 be quadratic in size. */ 3374 if (i > 10 && !verbose) 3375 { 3376 fprintf (f, " ... and %i more targets\n", targets.length () - i); 3377 return; 3378 } 3379 } 3380 fprintf (f, "\n"); 3381 } 3382 3383 /* Dump all possible targets of a polymorphic call. */ 3384 3385 void 3386 dump_possible_polymorphic_call_targets (FILE *f, 3387 tree otr_type, 3388 HOST_WIDE_INT otr_token, 3389 const ipa_polymorphic_call_context &ctx, 3390 bool verbose) 3391 { 3392 vec <cgraph_node *> targets; 3393 bool final; 3394 odr_type type = get_odr_type (TYPE_MAIN_VARIANT (otr_type), false); 3395 unsigned int len; 3396 3397 if (!type) 3398 return; 3399 targets = possible_polymorphic_call_targets (otr_type, otr_token, 3400 ctx, 3401 &final, NULL, false); 3402 fprintf (f, " Targets of polymorphic call of type %i:", type->id); 3403 print_generic_expr (f, type->type, TDF_SLIM); 3404 fprintf (f, " token %i\n", (int)otr_token); 3405 3406 ctx.dump (f); 3407 3408 fprintf (f, " %s%s%s%s\n ", 3409 final ? "This is a complete list." : 3410 "This is partial list; extra targets may be defined in other units.", 3411 ctx.maybe_in_construction ? " (base types included)" : "", 3412 ctx.maybe_derived_type ? " (derived types included)" : "", 3413 ctx.speculative_maybe_derived_type ? " (speculative derived types included)" : ""); 3414 len = targets.length (); 3415 dump_targets (f, targets, verbose); 3416 3417 targets = possible_polymorphic_call_targets (otr_type, otr_token, 3418 ctx, 3419 &final, NULL, true); 3420 if (targets.length () != len) 3421 { 3422 fprintf (f, " Speculative targets:"); 3423 dump_targets (f, targets, verbose); 3424 } 3425 /* Ugly: during callgraph construction the target cache may get populated 3426 before all targets are found. While this is harmless (because all local 3427 types are discovered and only in those case we devirtualize fully and we 3428 don't do speculative devirtualization before IPA stage) it triggers 3429 assert here when dumping at that stage also populates the case with 3430 speculative targets. Quietly ignore this. */ 3431 gcc_assert (symtab->state < IPA_SSA || targets.length () <= len); 3432 fprintf (f, "\n"); 3433 } 3434 3435 3436 /* Return true if N can be possibly target of a polymorphic call of 3437 OTR_TYPE/OTR_TOKEN. */ 3438 3439 bool 3440 possible_polymorphic_call_target_p (tree otr_type, 3441 HOST_WIDE_INT otr_token, 3442 const ipa_polymorphic_call_context &ctx, 3443 struct cgraph_node *n) 3444 { 3445 vec <cgraph_node *> targets; 3446 unsigned int i; 3447 bool final; 3448 3449 if (fndecl_built_in_p (n->decl, BUILT_IN_UNREACHABLE) 3450 || fndecl_built_in_p (n->decl, BUILT_IN_TRAP)) 3451 return true; 3452 3453 if (is_cxa_pure_virtual_p (n->decl)) 3454 return true; 3455 3456 if (!odr_hash) 3457 return true; 3458 targets = possible_polymorphic_call_targets (otr_type, otr_token, ctx, &final); 3459 for (i = 0; i < targets.length (); i++) 3460 if (n->semantically_equivalent_p (targets[i])) 3461 return true; 3462 3463 /* At a moment we allow middle end to dig out new external declarations 3464 as a targets of polymorphic calls. */ 3465 if (!final && !n->definition) 3466 return true; 3467 return false; 3468 } 3469 3470 3471 3472 /* Return true if N can be possibly target of a polymorphic call of 3473 OBJ_TYPE_REF expression REF in STMT. */ 3474 3475 bool 3476 possible_polymorphic_call_target_p (tree ref, 3477 gimple *stmt, 3478 struct cgraph_node *n) 3479 { 3480 ipa_polymorphic_call_context context (current_function_decl, ref, stmt); 3481 tree call_fn = gimple_call_fn (stmt); 3482 3483 return possible_polymorphic_call_target_p (obj_type_ref_class (call_fn), 3484 tree_to_uhwi 3485 (OBJ_TYPE_REF_TOKEN (call_fn)), 3486 context, 3487 n); 3488 } 3489 3490 3491 /* After callgraph construction new external nodes may appear. 3492 Add them into the graph. */ 3493 3494 void 3495 update_type_inheritance_graph (void) 3496 { 3497 struct cgraph_node *n; 3498 3499 if (!odr_hash) 3500 return; 3501 free_polymorphic_call_targets_hash (); 3502 timevar_push (TV_IPA_INHERITANCE); 3503 /* We reconstruct the graph starting from types of all methods seen in the 3504 unit. */ 3505 FOR_EACH_FUNCTION (n) 3506 if (DECL_VIRTUAL_P (n->decl) 3507 && !n->definition 3508 && n->real_symbol_p ()) 3509 get_odr_type (TYPE_METHOD_BASETYPE (TREE_TYPE (n->decl)), true); 3510 timevar_pop (TV_IPA_INHERITANCE); 3511 } 3512 3513 3514 /* Return true if N looks like likely target of a polymorphic call. 3515 Rule out cxa_pure_virtual, noreturns, function declared cold and 3516 other obvious cases. */ 3517 3518 bool 3519 likely_target_p (struct cgraph_node *n) 3520 { 3521 int flags; 3522 /* cxa_pure_virtual and similar things are not likely. */ 3523 if (TREE_CODE (TREE_TYPE (n->decl)) != METHOD_TYPE) 3524 return false; 3525 flags = flags_from_decl_or_type (n->decl); 3526 if (flags & ECF_NORETURN) 3527 return false; 3528 if (lookup_attribute ("cold", 3529 DECL_ATTRIBUTES (n->decl))) 3530 return false; 3531 if (n->frequency < NODE_FREQUENCY_NORMAL) 3532 return false; 3533 /* If there are no live virtual tables referring the target, 3534 the only way the target can be called is an instance coming from other 3535 compilation unit; speculative devirtualization is built around an 3536 assumption that won't happen. */ 3537 if (!referenced_from_vtable_p (n)) 3538 return false; 3539 return true; 3540 } 3541 3542 /* Compare type warning records P1 and P2 and choose one with larger count; 3543 helper for qsort. */ 3544 3545 static int 3546 type_warning_cmp (const void *p1, const void *p2) 3547 { 3548 const odr_type_warn_count *t1 = (const odr_type_warn_count *)p1; 3549 const odr_type_warn_count *t2 = (const odr_type_warn_count *)p2; 3550 3551 if (t1->dyn_count < t2->dyn_count) 3552 return 1; 3553 if (t1->dyn_count > t2->dyn_count) 3554 return -1; 3555 return t2->count - t1->count; 3556 } 3557 3558 /* Compare decl warning records P1 and P2 and choose one with larger count; 3559 helper for qsort. */ 3560 3561 static int 3562 decl_warning_cmp (const void *p1, const void *p2) 3563 { 3564 const decl_warn_count *t1 = *(const decl_warn_count * const *)p1; 3565 const decl_warn_count *t2 = *(const decl_warn_count * const *)p2; 3566 3567 if (t1->dyn_count < t2->dyn_count) 3568 return 1; 3569 if (t1->dyn_count > t2->dyn_count) 3570 return -1; 3571 return t2->count - t1->count; 3572 } 3573 3574 3575 /* Try to speculatively devirtualize call to OTR_TYPE with OTR_TOKEN with 3576 context CTX. */ 3577 3578 struct cgraph_node * 3579 try_speculative_devirtualization (tree otr_type, HOST_WIDE_INT otr_token, 3580 ipa_polymorphic_call_context ctx) 3581 { 3582 vec <cgraph_node *>targets 3583 = possible_polymorphic_call_targets 3584 (otr_type, otr_token, ctx, NULL, NULL, true); 3585 unsigned int i; 3586 struct cgraph_node *likely_target = NULL; 3587 3588 for (i = 0; i < targets.length (); i++) 3589 if (likely_target_p (targets[i])) 3590 { 3591 if (likely_target) 3592 return NULL; 3593 likely_target = targets[i]; 3594 } 3595 if (!likely_target 3596 ||!likely_target->definition 3597 || DECL_EXTERNAL (likely_target->decl)) 3598 return NULL; 3599 3600 /* Don't use an implicitly-declared destructor (c++/58678). */ 3601 struct cgraph_node *non_thunk_target 3602 = likely_target->function_symbol (); 3603 if (DECL_ARTIFICIAL (non_thunk_target->decl)) 3604 return NULL; 3605 if (likely_target->get_availability () <= AVAIL_INTERPOSABLE 3606 && likely_target->can_be_discarded_p ()) 3607 return NULL; 3608 return likely_target; 3609 } 3610 3611 /* The ipa-devirt pass. 3612 When polymorphic call has only one likely target in the unit, 3613 turn it into a speculative call. */ 3614 3615 static unsigned int 3616 ipa_devirt (void) 3617 { 3618 struct cgraph_node *n; 3619 hash_set<void *> bad_call_targets; 3620 struct cgraph_edge *e; 3621 3622 int npolymorphic = 0, nspeculated = 0, nconverted = 0, ncold = 0; 3623 int nmultiple = 0, noverwritable = 0, ndevirtualized = 0, nnotdefined = 0; 3624 int nwrong = 0, nok = 0, nexternal = 0, nartificial = 0; 3625 int ndropped = 0; 3626 3627 if (!odr_types_ptr) 3628 return 0; 3629 3630 if (dump_file) 3631 dump_type_inheritance_graph (dump_file); 3632 3633 /* We can output -Wsuggest-final-methods and -Wsuggest-final-types warnings. 3634 This is implemented by setting up final_warning_records that are updated 3635 by get_polymorphic_call_targets. 3636 We need to clear cache in this case to trigger recomputation of all 3637 entries. */ 3638 if (warn_suggest_final_methods || warn_suggest_final_types) 3639 { 3640 final_warning_records = new (final_warning_record); 3641 final_warning_records->dyn_count = profile_count::zero (); 3642 final_warning_records->grow_type_warnings (odr_types.length ()); 3643 free_polymorphic_call_targets_hash (); 3644 } 3645 3646 FOR_EACH_DEFINED_FUNCTION (n) 3647 { 3648 bool update = false; 3649 if (!opt_for_fn (n->decl, flag_devirtualize)) 3650 continue; 3651 if (dump_file && n->indirect_calls) 3652 fprintf (dump_file, "\n\nProcesing function %s\n", 3653 n->dump_name ()); 3654 for (e = n->indirect_calls; e; e = e->next_callee) 3655 if (e->indirect_info->polymorphic) 3656 { 3657 struct cgraph_node *likely_target = NULL; 3658 void *cache_token; 3659 bool final; 3660 3661 if (final_warning_records) 3662 final_warning_records->dyn_count = e->count.ipa (); 3663 3664 vec <cgraph_node *>targets 3665 = possible_polymorphic_call_targets 3666 (e, &final, &cache_token, true); 3667 unsigned int i; 3668 3669 /* Trigger warnings by calculating non-speculative targets. */ 3670 if (warn_suggest_final_methods || warn_suggest_final_types) 3671 possible_polymorphic_call_targets (e); 3672 3673 if (dump_file) 3674 dump_possible_polymorphic_call_targets 3675 (dump_file, e, (dump_flags & TDF_DETAILS)); 3676 3677 npolymorphic++; 3678 3679 /* See if the call can be devirtualized by means of ipa-prop's 3680 polymorphic call context propagation. If not, we can just 3681 forget about this call being polymorphic and avoid some heavy 3682 lifting in remove_unreachable_nodes that will otherwise try to 3683 keep all possible targets alive until inlining and in the inliner 3684 itself. 3685 3686 This may need to be revisited once we add further ways to use 3687 the may edges, but it is a reasonable thing to do right now. */ 3688 3689 if ((e->indirect_info->param_index == -1 3690 || (!opt_for_fn (n->decl, flag_devirtualize_speculatively) 3691 && e->indirect_info->vptr_changed)) 3692 && !flag_ltrans_devirtualize) 3693 { 3694 e->indirect_info->polymorphic = false; 3695 ndropped++; 3696 if (dump_file) 3697 fprintf (dump_file, "Dropping polymorphic call info;" 3698 " it cannot be used by ipa-prop\n"); 3699 } 3700 3701 if (!opt_for_fn (n->decl, flag_devirtualize_speculatively)) 3702 continue; 3703 3704 if (!e->maybe_hot_p ()) 3705 { 3706 if (dump_file) 3707 fprintf (dump_file, "Call is cold\n\n"); 3708 ncold++; 3709 continue; 3710 } 3711 if (e->speculative) 3712 { 3713 if (dump_file) 3714 fprintf (dump_file, "Call is already speculated\n\n"); 3715 nspeculated++; 3716 3717 /* When dumping see if we agree with speculation. */ 3718 if (!dump_file) 3719 continue; 3720 } 3721 if (bad_call_targets.contains (cache_token)) 3722 { 3723 if (dump_file) 3724 fprintf (dump_file, "Target list is known to be useless\n\n"); 3725 nmultiple++; 3726 continue; 3727 } 3728 for (i = 0; i < targets.length (); i++) 3729 if (likely_target_p (targets[i])) 3730 { 3731 if (likely_target) 3732 { 3733 likely_target = NULL; 3734 if (dump_file) 3735 fprintf (dump_file, "More than one likely target\n\n"); 3736 nmultiple++; 3737 break; 3738 } 3739 likely_target = targets[i]; 3740 } 3741 if (!likely_target) 3742 { 3743 bad_call_targets.add (cache_token); 3744 continue; 3745 } 3746 /* This is reached only when dumping; check if we agree or disagree 3747 with the speculation. */ 3748 if (e->speculative) 3749 { 3750 bool found = e->speculative_call_for_target (likely_target); 3751 if (found) 3752 { 3753 fprintf (dump_file, "We agree with speculation\n\n"); 3754 nok++; 3755 } 3756 else 3757 { 3758 fprintf (dump_file, "We disagree with speculation\n\n"); 3759 nwrong++; 3760 } 3761 continue; 3762 } 3763 if (!likely_target->definition) 3764 { 3765 if (dump_file) 3766 fprintf (dump_file, "Target is not a definition\n\n"); 3767 nnotdefined++; 3768 continue; 3769 } 3770 /* Do not introduce new references to external symbols. While we 3771 can handle these just well, it is common for programs to 3772 incorrectly with headers defining methods they are linked 3773 with. */ 3774 if (DECL_EXTERNAL (likely_target->decl)) 3775 { 3776 if (dump_file) 3777 fprintf (dump_file, "Target is external\n\n"); 3778 nexternal++; 3779 continue; 3780 } 3781 /* Don't use an implicitly-declared destructor (c++/58678). */ 3782 struct cgraph_node *non_thunk_target 3783 = likely_target->function_symbol (); 3784 if (DECL_ARTIFICIAL (non_thunk_target->decl)) 3785 { 3786 if (dump_file) 3787 fprintf (dump_file, "Target is artificial\n\n"); 3788 nartificial++; 3789 continue; 3790 } 3791 if (likely_target->get_availability () <= AVAIL_INTERPOSABLE 3792 && likely_target->can_be_discarded_p ()) 3793 { 3794 if (dump_file) 3795 fprintf (dump_file, "Target is overwritable\n\n"); 3796 noverwritable++; 3797 continue; 3798 } 3799 else if (dbg_cnt (devirt)) 3800 { 3801 if (dump_enabled_p ()) 3802 { 3803 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, e->call_stmt, 3804 "speculatively devirtualizing call " 3805 "in %s to %s\n", 3806 n->dump_name (), 3807 likely_target->dump_name ()); 3808 } 3809 if (!likely_target->can_be_discarded_p ()) 3810 { 3811 cgraph_node *alias; 3812 alias = dyn_cast<cgraph_node *> (likely_target->noninterposable_alias ()); 3813 if (alias) 3814 likely_target = alias; 3815 } 3816 nconverted++; 3817 update = true; 3818 e->make_speculative 3819 (likely_target, e->count.apply_scale (8, 10)); 3820 } 3821 } 3822 if (update) 3823 ipa_update_overall_fn_summary (n); 3824 } 3825 if (warn_suggest_final_methods || warn_suggest_final_types) 3826 { 3827 if (warn_suggest_final_types) 3828 { 3829 final_warning_records->type_warnings.qsort (type_warning_cmp); 3830 for (unsigned int i = 0; 3831 i < final_warning_records->type_warnings.length (); i++) 3832 if (final_warning_records->type_warnings[i].count) 3833 { 3834 tree type = final_warning_records->type_warnings[i].type; 3835 int count = final_warning_records->type_warnings[i].count; 3836 profile_count dyn_count 3837 = final_warning_records->type_warnings[i].dyn_count; 3838 3839 if (!(dyn_count > 0)) 3840 warning_n (DECL_SOURCE_LOCATION (TYPE_NAME (type)), 3841 OPT_Wsuggest_final_types, count, 3842 "Declaring type %qD final " 3843 "would enable devirtualization of %i call", 3844 "Declaring type %qD final " 3845 "would enable devirtualization of %i calls", 3846 type, 3847 count); 3848 else 3849 warning_n (DECL_SOURCE_LOCATION (TYPE_NAME (type)), 3850 OPT_Wsuggest_final_types, count, 3851 "Declaring type %qD final " 3852 "would enable devirtualization of %i call " 3853 "executed %lli times", 3854 "Declaring type %qD final " 3855 "would enable devirtualization of %i calls " 3856 "executed %lli times", 3857 type, 3858 count, 3859 (long long) dyn_count.to_gcov_type ()); 3860 } 3861 } 3862 3863 if (warn_suggest_final_methods) 3864 { 3865 auto_vec<const decl_warn_count*> decl_warnings_vec; 3866 3867 final_warning_records->decl_warnings.traverse 3868 <vec<const decl_warn_count *> *, add_decl_warning> (&decl_warnings_vec); 3869 decl_warnings_vec.qsort (decl_warning_cmp); 3870 for (unsigned int i = 0; i < decl_warnings_vec.length (); i++) 3871 { 3872 tree decl = decl_warnings_vec[i]->decl; 3873 int count = decl_warnings_vec[i]->count; 3874 profile_count dyn_count 3875 = decl_warnings_vec[i]->dyn_count; 3876 3877 if (!(dyn_count > 0)) 3878 if (DECL_CXX_DESTRUCTOR_P (decl)) 3879 warning_n (DECL_SOURCE_LOCATION (decl), 3880 OPT_Wsuggest_final_methods, count, 3881 "Declaring virtual destructor of %qD final " 3882 "would enable devirtualization of %i call", 3883 "Declaring virtual destructor of %qD final " 3884 "would enable devirtualization of %i calls", 3885 DECL_CONTEXT (decl), count); 3886 else 3887 warning_n (DECL_SOURCE_LOCATION (decl), 3888 OPT_Wsuggest_final_methods, count, 3889 "Declaring method %qD final " 3890 "would enable devirtualization of %i call", 3891 "Declaring method %qD final " 3892 "would enable devirtualization of %i calls", 3893 decl, count); 3894 else if (DECL_CXX_DESTRUCTOR_P (decl)) 3895 warning_n (DECL_SOURCE_LOCATION (decl), 3896 OPT_Wsuggest_final_methods, count, 3897 "Declaring virtual destructor of %qD final " 3898 "would enable devirtualization of %i call " 3899 "executed %lli times", 3900 "Declaring virtual destructor of %qD final " 3901 "would enable devirtualization of %i calls " 3902 "executed %lli times", 3903 DECL_CONTEXT (decl), count, 3904 (long long)dyn_count.to_gcov_type ()); 3905 else 3906 warning_n (DECL_SOURCE_LOCATION (decl), 3907 OPT_Wsuggest_final_methods, count, 3908 "Declaring method %qD final " 3909 "would enable devirtualization of %i call " 3910 "executed %lli times", 3911 "Declaring method %qD final " 3912 "would enable devirtualization of %i calls " 3913 "executed %lli times", 3914 decl, count, 3915 (long long)dyn_count.to_gcov_type ()); 3916 } 3917 } 3918 3919 delete (final_warning_records); 3920 final_warning_records = 0; 3921 } 3922 3923 if (dump_file) 3924 fprintf (dump_file, 3925 "%i polymorphic calls, %i devirtualized," 3926 " %i speculatively devirtualized, %i cold\n" 3927 "%i have multiple targets, %i overwritable," 3928 " %i already speculated (%i agree, %i disagree)," 3929 " %i external, %i not defined, %i artificial, %i infos dropped\n", 3930 npolymorphic, ndevirtualized, nconverted, ncold, 3931 nmultiple, noverwritable, nspeculated, nok, nwrong, 3932 nexternal, nnotdefined, nartificial, ndropped); 3933 return ndevirtualized || ndropped ? TODO_remove_functions : 0; 3934 } 3935 3936 namespace { 3937 3938 const pass_data pass_data_ipa_devirt = 3939 { 3940 IPA_PASS, /* type */ 3941 "devirt", /* name */ 3942 OPTGROUP_NONE, /* optinfo_flags */ 3943 TV_IPA_DEVIRT, /* tv_id */ 3944 0, /* properties_required */ 3945 0, /* properties_provided */ 3946 0, /* properties_destroyed */ 3947 0, /* todo_flags_start */ 3948 ( TODO_dump_symtab ), /* todo_flags_finish */ 3949 }; 3950 3951 class pass_ipa_devirt : public ipa_opt_pass_d 3952 { 3953 public: 3954 pass_ipa_devirt (gcc::context *ctxt) 3955 : ipa_opt_pass_d (pass_data_ipa_devirt, ctxt, 3956 NULL, /* generate_summary */ 3957 NULL, /* write_summary */ 3958 NULL, /* read_summary */ 3959 NULL, /* write_optimization_summary */ 3960 NULL, /* read_optimization_summary */ 3961 NULL, /* stmt_fixup */ 3962 0, /* function_transform_todo_flags_start */ 3963 NULL, /* function_transform */ 3964 NULL) /* variable_transform */ 3965 {} 3966 3967 /* opt_pass methods: */ 3968 virtual bool gate (function *) 3969 { 3970 /* In LTO, always run the IPA passes and decide on function basis if the 3971 pass is enabled. */ 3972 if (in_lto_p) 3973 return true; 3974 return (flag_devirtualize 3975 && (flag_devirtualize_speculatively 3976 || (warn_suggest_final_methods 3977 || warn_suggest_final_types)) 3978 && optimize); 3979 } 3980 3981 virtual unsigned int execute (function *) { return ipa_devirt (); } 3982 3983 }; // class pass_ipa_devirt 3984 3985 } // anon namespace 3986 3987 ipa_opt_pass_d * 3988 make_pass_ipa_devirt (gcc::context *ctxt) 3989 { 3990 return new pass_ipa_devirt (ctxt); 3991 } 3992 3993 /* Print ODR name of a TYPE if available. 3994 Use demangler when option DEMANGLE is used. */ 3995 3996 DEBUG_FUNCTION void 3997 debug_tree_odr_name (tree type, bool demangle) 3998 { 3999 const char *odr = get_odr_name_for_type (type); 4000 if (demangle) 4001 { 4002 const int opts = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES; 4003 odr = cplus_demangle (odr, opts); 4004 } 4005 4006 fprintf (stderr, "%s\n", odr); 4007 } 4008 4009 /* Register ODR enum so we later stream record about its values. */ 4010 4011 void 4012 register_odr_enum (tree t) 4013 { 4014 if (flag_lto) 4015 vec_safe_push (odr_enums, t); 4016 } 4017 4018 /* Write ODR enums to LTO stream file. */ 4019 4020 static void 4021 ipa_odr_summary_write (void) 4022 { 4023 if (!odr_enums && !odr_enum_map) 4024 return; 4025 struct output_block *ob = create_output_block (LTO_section_odr_types); 4026 unsigned int i; 4027 tree t; 4028 4029 if (odr_enums) 4030 { 4031 streamer_write_uhwi (ob, odr_enums->length ()); 4032 4033 /* For every ODR enum stream out 4034 - its ODR name 4035 - number of values, 4036 - value names and constant their represent 4037 - bitpack of locations so we can do good diagnostics. */ 4038 FOR_EACH_VEC_ELT (*odr_enums, i, t) 4039 { 4040 streamer_write_string (ob, ob->main_stream, 4041 IDENTIFIER_POINTER 4042 (DECL_ASSEMBLER_NAME (TYPE_NAME (t))), 4043 true); 4044 4045 int n = 0; 4046 for (tree e = TYPE_VALUES (t); e; e = TREE_CHAIN (e)) 4047 n++; 4048 streamer_write_uhwi (ob, n); 4049 for (tree e = TYPE_VALUES (t); e; e = TREE_CHAIN (e)) 4050 { 4051 streamer_write_string (ob, ob->main_stream, 4052 IDENTIFIER_POINTER (TREE_PURPOSE (e)), 4053 true); 4054 streamer_write_wide_int (ob, 4055 wi::to_wide (DECL_INITIAL 4056 (TREE_VALUE (e)))); 4057 } 4058 4059 bitpack_d bp = bitpack_create (ob->main_stream); 4060 lto_output_location (ob, &bp, DECL_SOURCE_LOCATION (TYPE_NAME (t))); 4061 for (tree e = TYPE_VALUES (t); e; e = TREE_CHAIN (e)) 4062 lto_output_location (ob, &bp, 4063 DECL_SOURCE_LOCATION (TREE_VALUE (e))); 4064 streamer_write_bitpack (&bp); 4065 } 4066 vec_free (odr_enums); 4067 odr_enums = NULL; 4068 } 4069 /* During LTO incremental linking we already have streamed in types. */ 4070 else if (odr_enum_map) 4071 { 4072 gcc_checking_assert (!odr_enums); 4073 streamer_write_uhwi (ob, odr_enum_map->elements ()); 4074 4075 hash_map<nofree_string_hash, odr_enum>::iterator iter 4076 = odr_enum_map->begin (); 4077 for (; iter != odr_enum_map->end (); ++iter) 4078 { 4079 odr_enum &this_enum = (*iter).second; 4080 streamer_write_string (ob, ob->main_stream, (*iter).first, true); 4081 4082 streamer_write_uhwi (ob, this_enum.vals.length ()); 4083 for (unsigned j = 0; j < this_enum.vals.length (); j++) 4084 { 4085 streamer_write_string (ob, ob->main_stream, 4086 this_enum.vals[j].name, true); 4087 streamer_write_wide_int (ob, this_enum.vals[j].val); 4088 } 4089 4090 bitpack_d bp = bitpack_create (ob->main_stream); 4091 lto_output_location (ob, &bp, this_enum.locus); 4092 for (unsigned j = 0; j < this_enum.vals.length (); j++) 4093 lto_output_location (ob, &bp, this_enum.vals[j].locus); 4094 streamer_write_bitpack (&bp); 4095 } 4096 4097 delete odr_enum_map; 4098 obstack_free (&odr_enum_obstack, NULL); 4099 odr_enum_map = NULL; 4100 } 4101 4102 produce_asm (ob, NULL); 4103 destroy_output_block (ob); 4104 } 4105 4106 /* Write ODR enums from LTO stream file and warn on mismatches. */ 4107 4108 static void 4109 ipa_odr_read_section (struct lto_file_decl_data *file_data, const char *data, 4110 size_t len) 4111 { 4112 const struct lto_function_header *header 4113 = (const struct lto_function_header *) data; 4114 const int cfg_offset = sizeof (struct lto_function_header); 4115 const int main_offset = cfg_offset + header->cfg_size; 4116 const int string_offset = main_offset + header->main_size; 4117 class data_in *data_in; 4118 4119 lto_input_block ib ((const char *) data + main_offset, header->main_size, 4120 file_data->mode_table); 4121 4122 data_in 4123 = lto_data_in_create (file_data, (const char *) data + string_offset, 4124 header->string_size, vNULL); 4125 unsigned int n = streamer_read_uhwi (&ib); 4126 4127 if (!odr_enum_map) 4128 { 4129 gcc_obstack_init (&odr_enum_obstack); 4130 odr_enum_map = new (hash_map <nofree_string_hash, odr_enum>); 4131 } 4132 4133 for (unsigned i = 0; i < n; i++) 4134 { 4135 const char *rname = streamer_read_string (data_in, &ib); 4136 unsigned int nvals = streamer_read_uhwi (&ib); 4137 char *name; 4138 4139 obstack_grow (&odr_enum_obstack, rname, strlen (rname) + 1); 4140 name = XOBFINISH (&odr_enum_obstack, char *); 4141 4142 bool existed_p; 4143 class odr_enum &this_enum 4144 = odr_enum_map->get_or_insert (xstrdup (name), &existed_p); 4145 4146 /* If this is first time we see the enum, remember its definition. */ 4147 if (!existed_p) 4148 { 4149 this_enum.vals.safe_grow_cleared (nvals); 4150 this_enum.warned = false; 4151 if (dump_file) 4152 fprintf (dump_file, "enum %s\n{\n", name); 4153 for (unsigned j = 0; j < nvals; j++) 4154 { 4155 const char *val_name = streamer_read_string (data_in, &ib); 4156 obstack_grow (&odr_enum_obstack, val_name, strlen (val_name) + 1); 4157 this_enum.vals[j].name = XOBFINISH (&odr_enum_obstack, char *); 4158 this_enum.vals[j].val = streamer_read_wide_int (&ib); 4159 if (dump_file) 4160 fprintf (dump_file, " %s = " HOST_WIDE_INT_PRINT_DEC ",\n", 4161 val_name, wi::fits_shwi_p (this_enum.vals[j].val) 4162 ? this_enum.vals[j].val.to_shwi () : -1); 4163 } 4164 bitpack_d bp = streamer_read_bitpack (&ib); 4165 stream_input_location (&this_enum.locus, &bp, data_in); 4166 for (unsigned j = 0; j < nvals; j++) 4167 stream_input_location (&this_enum.vals[j].locus, &bp, data_in); 4168 data_in->location_cache.apply_location_cache (); 4169 if (dump_file) 4170 fprintf (dump_file, "}\n"); 4171 } 4172 /* If we already have definition, compare it with new one and output 4173 warnings if they differs. */ 4174 else 4175 { 4176 int do_warning = -1; 4177 char *warn_name = NULL; 4178 wide_int warn_value = wi::zero (1); 4179 4180 if (dump_file) 4181 fprintf (dump_file, "Comparing enum %s\n", name); 4182 4183 /* Look for differences which we will warn about later once locations 4184 are streamed. */ 4185 for (unsigned j = 0; j < nvals; j++) 4186 { 4187 const char *id = streamer_read_string (data_in, &ib); 4188 wide_int val = streamer_read_wide_int (&ib); 4189 4190 if (do_warning != -1 || j >= this_enum.vals.length ()) 4191 continue; 4192 if (strcmp (id, this_enum.vals[j].name) 4193 || val != this_enum.vals[j].val) 4194 { 4195 warn_name = xstrdup (id); 4196 warn_value = val; 4197 do_warning = j; 4198 if (dump_file) 4199 fprintf (dump_file, " Different on entry %i\n", j); 4200 } 4201 } 4202 4203 /* Stream in locations, but do not apply them unless we are going 4204 to warn. */ 4205 bitpack_d bp = streamer_read_bitpack (&ib); 4206 location_t locus; 4207 4208 stream_input_location (&locus, &bp, data_in); 4209 4210 /* Did we find a difference? */ 4211 if (do_warning != -1 || nvals != this_enum.vals.length ()) 4212 { 4213 data_in->location_cache.apply_location_cache (); 4214 4215 const int opts = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES; 4216 char *dmgname = cplus_demangle (name, opts); 4217 if (this_enum.warned 4218 || !warning_at (this_enum.locus, 4219 OPT_Wodr, "type %qs violates the " 4220 "C++ One Definition Rule", 4221 dmgname)) 4222 do_warning = -1; 4223 else 4224 { 4225 this_enum.warned = true; 4226 if (do_warning == -1) 4227 inform (locus, 4228 "an enum with different number of values is defined" 4229 " in another translation unit"); 4230 else if (warn_name) 4231 inform (locus, 4232 "an enum with different value name" 4233 " is defined in another translation unit"); 4234 else 4235 inform (locus, 4236 "an enum with different values" 4237 " is defined in another translation unit"); 4238 } 4239 } 4240 else 4241 data_in->location_cache.revert_location_cache (); 4242 4243 /* Finally look up for location of the actual value that diverged. */ 4244 for (unsigned j = 0; j < nvals; j++) 4245 { 4246 location_t id_locus; 4247 4248 data_in->location_cache.revert_location_cache (); 4249 stream_input_location (&id_locus, &bp, data_in); 4250 4251 if ((int) j == do_warning) 4252 { 4253 data_in->location_cache.apply_location_cache (); 4254 4255 if (strcmp (warn_name, this_enum.vals[j].name)) 4256 inform (this_enum.vals[j].locus, 4257 "name %qs differs from name %qs defined" 4258 " in another translation unit", 4259 this_enum.vals[j].name, warn_name); 4260 /* FIXME: In case there is easy way to print wide_ints, 4261 perhaps we could do it here instead of overlfow checpl. */ 4262 else if (wi::fits_shwi_p (this_enum.vals[j].val) 4263 && wi::fits_shwi_p (warn_value)) 4264 inform (this_enum.vals[j].locus, 4265 "name %qs is defined to " HOST_WIDE_INT_PRINT_DEC 4266 " while another translation unit defines " 4267 "it as " HOST_WIDE_INT_PRINT_DEC, 4268 warn_name, this_enum.vals[j].val.to_shwi (), 4269 warn_value.to_shwi ()); 4270 else 4271 inform (this_enum.vals[j].locus, 4272 "name %qs is defined to different value " 4273 "in another translation unit", 4274 warn_name); 4275 4276 inform (id_locus, 4277 "mismatching definition"); 4278 } 4279 else 4280 data_in->location_cache.revert_location_cache (); 4281 } 4282 if (warn_name) 4283 free (warn_name); 4284 obstack_free (&odr_enum_obstack, name); 4285 } 4286 } 4287 lto_free_section_data (file_data, LTO_section_ipa_fn_summary, NULL, data, 4288 len); 4289 lto_data_in_delete (data_in); 4290 } 4291 4292 /* Read all ODR type sections. */ 4293 4294 static void 4295 ipa_odr_summary_read (void) 4296 { 4297 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data (); 4298 struct lto_file_decl_data *file_data; 4299 unsigned int j = 0; 4300 4301 while ((file_data = file_data_vec[j++])) 4302 { 4303 size_t len; 4304 const char *data 4305 = lto_get_summary_section_data (file_data, LTO_section_odr_types, 4306 &len); 4307 if (data) 4308 ipa_odr_read_section (file_data, data, len); 4309 } 4310 /* Enum info is used only to produce warnings. Only case we will need it 4311 again is streaming for incremental LTO. */ 4312 if (flag_incremental_link != INCREMENTAL_LINK_LTO) 4313 { 4314 delete odr_enum_map; 4315 obstack_free (&odr_enum_obstack, NULL); 4316 odr_enum_map = NULL; 4317 } 4318 } 4319 4320 namespace { 4321 4322 const pass_data pass_data_ipa_odr = 4323 { 4324 IPA_PASS, /* type */ 4325 "odr", /* name */ 4326 OPTGROUP_NONE, /* optinfo_flags */ 4327 TV_IPA_ODR, /* tv_id */ 4328 0, /* properties_required */ 4329 0, /* properties_provided */ 4330 0, /* properties_destroyed */ 4331 0, /* todo_flags_start */ 4332 0, /* todo_flags_finish */ 4333 }; 4334 4335 class pass_ipa_odr : public ipa_opt_pass_d 4336 { 4337 public: 4338 pass_ipa_odr (gcc::context *ctxt) 4339 : ipa_opt_pass_d (pass_data_ipa_odr, ctxt, 4340 NULL, /* generate_summary */ 4341 ipa_odr_summary_write, /* write_summary */ 4342 ipa_odr_summary_read, /* read_summary */ 4343 NULL, /* write_optimization_summary */ 4344 NULL, /* read_optimization_summary */ 4345 NULL, /* stmt_fixup */ 4346 0, /* function_transform_todo_flags_start */ 4347 NULL, /* function_transform */ 4348 NULL) /* variable_transform */ 4349 {} 4350 4351 /* opt_pass methods: */ 4352 virtual bool gate (function *) 4353 { 4354 return (in_lto_p || flag_lto); 4355 } 4356 4357 virtual unsigned int execute (function *) 4358 { 4359 return 0; 4360 } 4361 4362 }; // class pass_ipa_odr 4363 4364 } // anon namespace 4365 4366 ipa_opt_pass_d * 4367 make_pass_ipa_odr (gcc::context *ctxt) 4368 { 4369 return new pass_ipa_odr (ctxt); 4370 } 4371 4372 4373 #include "gt-ipa-devirt.h" 4374