1 /* LTO symbol table. 2 Copyright (C) 2009-2018 Free Software Foundation, Inc. 3 Contributed by CodeSourcery, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "target.h" 25 #include "function.h" 26 #include "basic-block.h" 27 #include "tree.h" 28 #include "gimple.h" 29 #include "cgraph.h" 30 #include "lto-streamer.h" 31 #include "ipa-utils.h" 32 #include "builtins.h" 33 #include "alias.h" 34 #include "lto-symtab.h" 35 #include "stringpool.h" 36 #include "attribs.h" 37 38 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging 39 all edges and removing the old node. */ 40 41 static void 42 lto_cgraph_replace_node (struct cgraph_node *node, 43 struct cgraph_node *prevailing_node) 44 { 45 struct cgraph_edge *e, *next; 46 bool compatible_p; 47 48 if (symtab->dump_file) 49 { 50 fprintf (symtab->dump_file, "Replacing cgraph node %s by %s" 51 " for symbol %s\n", 52 node->dump_name (), 53 prevailing_node->dump_name (), 54 IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) 55 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl))))); 56 } 57 58 /* Merge node flags. */ 59 if (node->force_output) 60 prevailing_node->mark_force_output (); 61 if (node->forced_by_abi) 62 prevailing_node->forced_by_abi = true; 63 if (node->address_taken) 64 { 65 gcc_assert (!prevailing_node->global.inlined_to); 66 prevailing_node->mark_address_taken (); 67 } 68 if (node->definition && prevailing_node->definition 69 && DECL_COMDAT (node->decl) && DECL_COMDAT (prevailing_node->decl)) 70 prevailing_node->merged_comdat = true; 71 72 /* Redirect all incoming edges. */ 73 compatible_p 74 = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node->decl)), 75 TREE_TYPE (TREE_TYPE (node->decl))); 76 for (e = node->callers; e; e = next) 77 { 78 next = e->next_caller; 79 e->redirect_callee (prevailing_node); 80 /* If there is a mismatch between the supposed callee return type and 81 the real one do not attempt to inline this function. 82 ??? We really need a way to match function signatures for ABI 83 compatibility and perform related promotions at inlining time. */ 84 if (!compatible_p) 85 { 86 e->inline_failed = CIF_LTO_MISMATCHED_DECLARATIONS; 87 e->call_stmt_cannot_inline_p = 1; 88 } 89 } 90 /* Redirect incomming references. */ 91 prevailing_node->clone_referring (node); 92 93 /* Fix instrumentation references. */ 94 if (node->instrumented_version) 95 { 96 gcc_assert (node->instrumentation_clone 97 == prevailing_node->instrumentation_clone); 98 node->instrumented_version->instrumented_version = prevailing_node; 99 if (!prevailing_node->instrumented_version) 100 prevailing_node->instrumented_version = node->instrumented_version; 101 /* Need to reset node->instrumented_version to NULL, 102 otherwise node removal code would reset 103 node->instrumented_version->instrumented_version. */ 104 node->instrumented_version = NULL; 105 } 106 107 lto_free_function_in_decl_state_for_node (node); 108 109 if (node->decl != prevailing_node->decl) 110 node->release_body (); 111 112 /* Finally remove the replaced node. */ 113 node->remove (); 114 } 115 116 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging 117 all edges and removing the old node. */ 118 119 static void 120 lto_varpool_replace_node (varpool_node *vnode, 121 varpool_node *prevailing_node) 122 { 123 gcc_assert (!vnode->definition || prevailing_node->definition); 124 gcc_assert (!vnode->analyzed || prevailing_node->analyzed); 125 126 prevailing_node->clone_referring (vnode); 127 if (vnode->force_output) 128 prevailing_node->force_output = true; 129 if (vnode->forced_by_abi) 130 prevailing_node->forced_by_abi = true; 131 132 /* Be sure we can garbage collect the initializer. */ 133 if (DECL_INITIAL (vnode->decl) 134 && vnode->decl != prevailing_node->decl) 135 DECL_INITIAL (vnode->decl) = error_mark_node; 136 137 /* Check and report ODR violations on virtual tables. */ 138 if (DECL_VIRTUAL_P (vnode->decl) || DECL_VIRTUAL_P (prevailing_node->decl)) 139 compare_virtual_tables (prevailing_node, vnode); 140 141 if (vnode->tls_model != prevailing_node->tls_model) 142 { 143 bool error = false; 144 145 /* Non-TLS and TLS never mix together. Also emulated model is not 146 compatible with anything else. */ 147 if (prevailing_node->tls_model == TLS_MODEL_NONE 148 || prevailing_node->tls_model == TLS_MODEL_EMULATED 149 || vnode->tls_model == TLS_MODEL_NONE 150 || vnode->tls_model == TLS_MODEL_EMULATED) 151 error = true; 152 /* Linked is silently supporting transitions 153 GD -> IE, GD -> LE, LD -> LE, IE -> LE, LD -> IE. 154 Do the same transitions and error out on others. */ 155 else if ((prevailing_node->tls_model == TLS_MODEL_REAL 156 || prevailing_node->tls_model == TLS_MODEL_LOCAL_DYNAMIC) 157 && (vnode->tls_model == TLS_MODEL_INITIAL_EXEC 158 || vnode->tls_model == TLS_MODEL_LOCAL_EXEC)) 159 prevailing_node->tls_model = vnode->tls_model; 160 else if ((vnode->tls_model == TLS_MODEL_REAL 161 || vnode->tls_model == TLS_MODEL_LOCAL_DYNAMIC) 162 && (prevailing_node->tls_model == TLS_MODEL_INITIAL_EXEC 163 || prevailing_node->tls_model == TLS_MODEL_LOCAL_EXEC)) 164 ; 165 else if (prevailing_node->tls_model == TLS_MODEL_INITIAL_EXEC 166 && vnode->tls_model == TLS_MODEL_LOCAL_EXEC) 167 prevailing_node->tls_model = vnode->tls_model; 168 else if (vnode->tls_model == TLS_MODEL_INITIAL_EXEC 169 && prevailing_node->tls_model == TLS_MODEL_LOCAL_EXEC) 170 ; 171 else 172 error = true; 173 if (error) 174 { 175 error_at (DECL_SOURCE_LOCATION (vnode->decl), 176 "%qD is defined with tls model %s", vnode->decl, tls_model_names [vnode->tls_model]); 177 inform (DECL_SOURCE_LOCATION (prevailing_node->decl), 178 "previously defined here as %s", 179 tls_model_names [prevailing_node->tls_model]); 180 } 181 } 182 /* Finally remove the replaced node. */ 183 vnode->remove (); 184 } 185 186 /* Return non-zero if we want to output waring about T1 and T2. 187 Return value is a bitmask of reasons of violation: 188 Bit 0 indicates that types are not compatible. 189 Bit 1 indicates that types are not compatible because of C++ ODR rule. 190 If COMMON_OR_EXTERN is true, do not warn on size mismatches of arrays. 191 Bit 2 indicates that types are not ODR compatible 192 193 The interoperability rules are language specific. At present we do only 194 full checking for C++ ODR rule and for other languages we do basic check 195 that data structures are of same size and TBAA compatible. Our TBAA 196 implementation should be coarse enough so all valid type transitions 197 across different languages are allowed. 198 199 In partiucular we thus allow almost arbitrary type changes with 200 -fno-strict-aliasing which may be tough of as a feature rather than bug 201 as it allows to implement dodgy tricks in the language runtimes. 202 203 Naturally this code can be strenghtened significantly if we could track 204 down the language of origin. */ 205 206 static int 207 warn_type_compatibility_p (tree prevailing_type, tree type, 208 bool common_or_extern) 209 { 210 int lev = 0; 211 bool odr_p = odr_or_derived_type_p (prevailing_type) 212 && odr_or_derived_type_p (type); 213 214 if (prevailing_type == type) 215 return 0; 216 217 /* C++ provide a robust way to check for type compatibility via the ODR 218 rule. */ 219 if (odr_p && !odr_types_equivalent_p (prevailing_type, type)) 220 lev |= 2; 221 222 /* Function types needs special care, because types_compatible_p never 223 thinks prototype is compatible to non-prototype. */ 224 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE) 225 { 226 if (TREE_CODE (type) != TREE_CODE (prevailing_type)) 227 lev |= 1; 228 lev |= warn_type_compatibility_p (TREE_TYPE (prevailing_type), 229 TREE_TYPE (type), false); 230 if (TREE_CODE (type) == METHOD_TYPE 231 && TREE_CODE (prevailing_type) == METHOD_TYPE) 232 lev |= warn_type_compatibility_p (TYPE_METHOD_BASETYPE (prevailing_type), 233 TYPE_METHOD_BASETYPE (type), false); 234 if (prototype_p (prevailing_type) && prototype_p (type) 235 && TYPE_ARG_TYPES (prevailing_type) != TYPE_ARG_TYPES (type)) 236 { 237 tree parm1, parm2; 238 for (parm1 = TYPE_ARG_TYPES (prevailing_type), 239 parm2 = TYPE_ARG_TYPES (type); 240 parm1 && parm2; 241 parm1 = TREE_CHAIN (parm1), 242 parm2 = TREE_CHAIN (parm2)) 243 lev |= warn_type_compatibility_p (TREE_VALUE (parm1), 244 TREE_VALUE (parm2), false); 245 if (parm1 || parm2) 246 lev |= odr_p ? 3 : 1; 247 } 248 if (comp_type_attributes (prevailing_type, type) == 0) 249 lev |= 1; 250 return lev; 251 } 252 253 /* Get complete type. */ 254 prevailing_type = TYPE_MAIN_VARIANT (prevailing_type); 255 type = TYPE_MAIN_VARIANT (type); 256 257 /* We can not use types_compatible_p because we permit some changes 258 across types. For example unsigned size_t and "signed size_t" may be 259 compatible when merging C and Fortran types. */ 260 if (COMPLETE_TYPE_P (prevailing_type) 261 && COMPLETE_TYPE_P (type) 262 /* While global declarations are never variadic, we can recurse here 263 for function parameter types. */ 264 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 265 && TREE_CODE (TYPE_SIZE (prevailing_type)) == INTEGER_CST 266 && !tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prevailing_type))) 267 { 268 /* As a special case do not warn about merging 269 int a[]; 270 and 271 int a[]={1,2,3}; 272 here the first declaration is COMMON or EXTERN 273 and sizeof(a) == sizeof (int). */ 274 if (!common_or_extern 275 || TREE_CODE (type) != ARRAY_TYPE 276 || TYPE_SIZE (type) != TYPE_SIZE (TREE_TYPE (type))) 277 lev |= 1; 278 } 279 280 /* Verify TBAA compatibility. Take care of alias set 0 and the fact that 281 we make ptr_type_node to TBAA compatible with every other type. */ 282 if (type_with_alias_set_p (type) && type_with_alias_set_p (prevailing_type)) 283 { 284 alias_set_type set1 = get_alias_set (type); 285 alias_set_type set2 = get_alias_set (prevailing_type); 286 287 if (set1 && set2 && set1 != set2) 288 { 289 tree t1 = type, t2 = prevailing_type; 290 291 /* Alias sets of arrays with aliased components are the same as alias 292 sets of the inner types. */ 293 while (TREE_CODE (t1) == ARRAY_TYPE 294 && !TYPE_NONALIASED_COMPONENT (t1) 295 && TREE_CODE (t2) == ARRAY_TYPE 296 && !TYPE_NONALIASED_COMPONENT (t2)) 297 { 298 t1 = TREE_TYPE (t1); 299 t2 = TREE_TYPE (t2); 300 } 301 if ((!POINTER_TYPE_P (t1) || !POINTER_TYPE_P (t2)) 302 || (set1 != TYPE_ALIAS_SET (ptr_type_node) 303 && set2 != TYPE_ALIAS_SET (ptr_type_node))) 304 lev |= 5; 305 } 306 } 307 308 return lev; 309 } 310 311 /* Merge two variable or function symbol table entries PREVAILING and ENTRY. 312 Return false if the symbols are not fully compatible and a diagnostic 313 should be emitted. */ 314 315 static bool 316 lto_symtab_merge (symtab_node *prevailing, symtab_node *entry) 317 { 318 tree prevailing_decl = prevailing->decl; 319 tree decl = entry->decl; 320 321 if (prevailing_decl == decl) 322 return true; 323 324 if (TREE_CODE (decl) != TREE_CODE (prevailing_decl)) 325 return false; 326 327 /* Merge decl state in both directions, we may still end up using 328 the new decl. */ 329 TREE_ADDRESSABLE (prevailing_decl) |= TREE_ADDRESSABLE (decl); 330 TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (prevailing_decl); 331 332 /* The linker may ask us to combine two incompatible symbols. 333 Detect this case and notify the caller of required diagnostics. */ 334 335 if (TREE_CODE (decl) == FUNCTION_DECL) 336 { 337 /* Merge decl state in both directions, we may still end up using 338 the new decl. */ 339 DECL_POSSIBLY_INLINED (prevailing_decl) |= DECL_POSSIBLY_INLINED (decl); 340 DECL_POSSIBLY_INLINED (decl) |= DECL_POSSIBLY_INLINED (prevailing_decl); 341 342 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl), 343 TREE_TYPE (decl), 344 DECL_COMMON (decl) 345 || DECL_EXTERNAL (decl))) 346 return false; 347 348 return true; 349 } 350 351 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl), 352 TREE_TYPE (decl), 353 DECL_COMMON (decl) || DECL_EXTERNAL (decl))) 354 return false; 355 356 /* There is no point in comparing too many details of the decls here. 357 The type compatibility checks or the completing of types has properly 358 dealt with most issues. */ 359 360 /* The following should all not invoke fatal errors as in non-LTO 361 mode the linker wouldn't complain either. Just emit warnings. */ 362 363 /* Report a warning if user-specified alignments do not match. */ 364 if ((DECL_USER_ALIGN (prevailing_decl) && DECL_USER_ALIGN (decl)) 365 && DECL_ALIGN (prevailing_decl) < DECL_ALIGN (decl)) 366 return false; 367 368 if (DECL_SIZE (decl) && DECL_SIZE (prevailing_decl) 369 && !tree_int_cst_equal (DECL_SIZE (decl), DECL_SIZE (prevailing_decl))) 370 { 371 if (!DECL_COMMON (decl) && !DECL_EXTERNAL (decl)) 372 return false; 373 374 tree type = TREE_TYPE (decl); 375 376 /* For record type, check for array at the end of the structure. */ 377 if (TREE_CODE (type) == RECORD_TYPE) 378 { 379 tree field = TYPE_FIELDS (type); 380 while (DECL_CHAIN (field) != NULL_TREE) 381 field = DECL_CHAIN (field); 382 383 return TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE; 384 } 385 /* As a special case do not warn about merging 386 int a[]; 387 and 388 int a[]={1,2,3}; 389 here the first declaration is COMMON 390 and sizeof(a) == sizeof (int). */ 391 else if (TREE_CODE (type) == ARRAY_TYPE) 392 return (TYPE_SIZE (decl) == TYPE_SIZE (TREE_TYPE (type))); 393 } 394 395 return true; 396 } 397 398 /* Return true if the symtab entry E can be replaced by another symtab 399 entry. */ 400 401 static bool 402 lto_symtab_resolve_replaceable_p (symtab_node *e) 403 { 404 if (DECL_EXTERNAL (e->decl) 405 || DECL_COMDAT (e->decl) 406 || DECL_ONE_ONLY (e->decl) 407 || DECL_WEAK (e->decl)) 408 return true; 409 410 if (TREE_CODE (e->decl) == VAR_DECL) 411 return (DECL_COMMON (e->decl) 412 || (!flag_no_common && !DECL_INITIAL (e->decl))); 413 414 return false; 415 } 416 417 /* Return true, if the symbol E should be resolved by lto-symtab. 418 Those are all external symbols and all real symbols that are not static (we 419 handle renaming of static later in partitioning). */ 420 421 static bool 422 lto_symtab_symbol_p (symtab_node *e) 423 { 424 if (!TREE_PUBLIC (e->decl) && !DECL_EXTERNAL (e->decl)) 425 return false; 426 return e->real_symbol_p (); 427 } 428 429 /* Return true if the symtab entry E can be the prevailing one. */ 430 431 static bool 432 lto_symtab_resolve_can_prevail_p (symtab_node *e) 433 { 434 if (!lto_symtab_symbol_p (e)) 435 return false; 436 437 /* The C++ frontend ends up neither setting TREE_STATIC nor 438 DECL_EXTERNAL on virtual methods but only TREE_PUBLIC. 439 So do not reject !TREE_STATIC here but only DECL_EXTERNAL. */ 440 if (DECL_EXTERNAL (e->decl)) 441 return false; 442 443 return e->definition; 444 } 445 446 /* Resolve the symbol with the candidates in the chain *SLOT and store 447 their resolutions. */ 448 449 static symtab_node * 450 lto_symtab_resolve_symbols (symtab_node *first) 451 { 452 symtab_node *e; 453 symtab_node *prevailing = NULL; 454 455 /* Always set e->node so that edges are updated to reflect decl merging. */ 456 for (e = first; e; e = e->next_sharing_asm_name) 457 if (lto_symtab_symbol_p (e) 458 && (e->resolution == LDPR_PREVAILING_DEF_IRONLY 459 || e->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP 460 || e->resolution == LDPR_PREVAILING_DEF)) 461 { 462 prevailing = e; 463 break; 464 } 465 466 /* If the chain is already resolved there is nothing else to do. */ 467 if (prevailing) 468 { 469 /* Assert it's the only one. 470 GCC should silence multiple PREVAILING_DEF_IRONLY defs error 471 on COMMON symbols since it isn't error. 472 See: https://sourceware.org/bugzilla/show_bug.cgi?id=23079. */ 473 for (e = prevailing->next_sharing_asm_name; e; e = e->next_sharing_asm_name) 474 if (lto_symtab_symbol_p (e) 475 && !DECL_COMMON (prevailing->decl) 476 && !DECL_COMMON (e->decl) 477 && (e->resolution == LDPR_PREVAILING_DEF_IRONLY 478 || e->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP 479 || e->resolution == LDPR_PREVAILING_DEF)) 480 fatal_error (input_location, "multiple prevailing defs for %qE", 481 DECL_NAME (prevailing->decl)); 482 return prevailing; 483 } 484 485 /* Find the single non-replaceable prevailing symbol and 486 diagnose ODR violations. */ 487 for (e = first; e; e = e->next_sharing_asm_name) 488 { 489 if (!lto_symtab_resolve_can_prevail_p (e)) 490 continue; 491 492 /* If we have a non-replaceable definition it prevails. */ 493 if (!lto_symtab_resolve_replaceable_p (e)) 494 { 495 if (prevailing) 496 { 497 error_at (DECL_SOURCE_LOCATION (e->decl), 498 "%qD has already been defined", e->decl); 499 inform (DECL_SOURCE_LOCATION (prevailing->decl), 500 "previously defined here"); 501 } 502 prevailing = e; 503 } 504 } 505 if (prevailing) 506 return prevailing; 507 508 /* Do a second round choosing one from the replaceable prevailing decls. */ 509 for (e = first; e; e = e->next_sharing_asm_name) 510 { 511 if (!lto_symtab_resolve_can_prevail_p (e)) 512 continue; 513 514 /* Choose the first function that can prevail as prevailing. */ 515 if (TREE_CODE (e->decl) == FUNCTION_DECL) 516 { 517 prevailing = e; 518 break; 519 } 520 521 /* From variables that can prevail choose the largest one. */ 522 if (!prevailing 523 || tree_int_cst_lt (DECL_SIZE (prevailing->decl), 524 DECL_SIZE (e->decl)) 525 /* When variables are equivalent try to chose one that has useful 526 DECL_INITIAL. This makes sense for keyed vtables that are 527 DECL_EXTERNAL but initialized. In units that do not need them 528 we replace the initializer by error_mark_node to conserve 529 memory. 530 531 We know that the vtable is keyed outside the LTO unit - otherwise 532 the keyed instance would prevail. We still can preserve useful 533 info in the initializer. */ 534 || (DECL_SIZE (prevailing->decl) == DECL_SIZE (e->decl) 535 && (DECL_INITIAL (e->decl) 536 && DECL_INITIAL (e->decl) != error_mark_node) 537 && (!DECL_INITIAL (prevailing->decl) 538 || DECL_INITIAL (prevailing->decl) == error_mark_node))) 539 prevailing = e; 540 } 541 542 return prevailing; 543 } 544 545 /* Decide if it is OK to merge DECL into PREVAILING. 546 Because we wrap most of uses of declarations in MEM_REF, we can tolerate 547 some differences but other code may inspect directly the DECL. */ 548 549 static bool 550 lto_symtab_merge_p (tree prevailing, tree decl) 551 { 552 if (TREE_CODE (prevailing) != TREE_CODE (decl)) 553 { 554 if (symtab->dump_file) 555 fprintf (symtab->dump_file, "Not merging decls; " 556 "TREE_CODE mismatch\n"); 557 return false; 558 } 559 gcc_checking_assert (TREE_CHAIN (prevailing) == TREE_CHAIN (decl)); 560 561 if (TREE_CODE (prevailing) == FUNCTION_DECL) 562 { 563 if (DECL_BUILT_IN (prevailing) != DECL_BUILT_IN (decl)) 564 { 565 if (symtab->dump_file) 566 fprintf (symtab->dump_file, "Not merging decls; " 567 "DECL_BUILT_IN mismatch\n"); 568 return false; 569 } 570 if (DECL_BUILT_IN (prevailing) 571 && (DECL_BUILT_IN_CLASS (prevailing) != DECL_BUILT_IN_CLASS (decl) 572 || DECL_FUNCTION_CODE (prevailing) != DECL_FUNCTION_CODE (decl))) 573 { 574 if (symtab->dump_file) 575 fprintf (symtab->dump_file, "Not merging decls; " 576 "DECL_BUILT_IN_CLASS or CODE mismatch\n"); 577 return false; 578 } 579 } 580 581 /* FIXME: after MPX is removed, use flags_from_decl_or_type 582 function instead. PR lto/85248. */ 583 if (DECL_ATTRIBUTES (prevailing) != DECL_ATTRIBUTES (decl)) 584 { 585 tree prev_attr = lookup_attribute ("error", DECL_ATTRIBUTES (prevailing)); 586 tree attr = lookup_attribute ("error", DECL_ATTRIBUTES (decl)); 587 if ((prev_attr == NULL) != (attr == NULL) 588 || (prev_attr && !attribute_value_equal (prev_attr, attr))) 589 { 590 if (symtab->dump_file) 591 fprintf (symtab->dump_file, "Not merging decls; " 592 "error attribute mismatch\n"); 593 return false; 594 } 595 596 prev_attr = lookup_attribute ("warning", DECL_ATTRIBUTES (prevailing)); 597 attr = lookup_attribute ("warning", DECL_ATTRIBUTES (decl)); 598 if ((prev_attr == NULL) != (attr == NULL) 599 || (prev_attr && !attribute_value_equal (prev_attr, attr))) 600 { 601 if (symtab->dump_file) 602 fprintf (symtab->dump_file, "Not merging decls; " 603 "warning attribute mismatch\n"); 604 return false; 605 } 606 607 prev_attr = lookup_attribute ("noreturn", DECL_ATTRIBUTES (prevailing)); 608 attr = lookup_attribute ("noreturn", DECL_ATTRIBUTES (decl)); 609 if ((prev_attr == NULL) != (attr == NULL)) 610 { 611 if (symtab->dump_file) 612 fprintf (symtab->dump_file, "Not merging decls; " 613 "noreturn attribute mismatch\n"); 614 return false; 615 } 616 } 617 return true; 618 } 619 620 /* Merge all decls in the symbol table chain to the prevailing decl and 621 issue diagnostics about type mismatches. If DIAGNOSED_P is true 622 do not issue further diagnostics.*/ 623 624 static void 625 lto_symtab_merge_decls_2 (symtab_node *first, bool diagnosed_p) 626 { 627 symtab_node *prevailing; 628 symtab_node *e; 629 vec<tree> mismatches = vNULL; 630 unsigned i; 631 tree decl; 632 bool tbaa_p = false; 633 634 /* Nothing to do for a single entry. */ 635 prevailing = first; 636 if (!prevailing->next_sharing_asm_name) 637 return; 638 639 /* Try to merge each entry with the prevailing one. */ 640 symtab_node *last_prevailing = prevailing, *next; 641 for (e = prevailing->next_sharing_asm_name; e; e = next) 642 { 643 next = e->next_sharing_asm_name; 644 645 /* Skip non-LTO symbols and symbols whose declaration we already 646 visited. */ 647 if (lto_symtab_prevailing_decl (e->decl) != e->decl 648 || !lto_symtab_symbol_p (e) 649 || e->decl == prevailing->decl) 650 continue; 651 652 if (!lto_symtab_merge (prevailing, e) 653 && !diagnosed_p 654 && !DECL_ARTIFICIAL (e->decl)) 655 mismatches.safe_push (e->decl); 656 657 symtab_node *this_prevailing; 658 for (this_prevailing = prevailing; ; 659 this_prevailing = this_prevailing->next_sharing_asm_name) 660 { 661 if (this_prevailing->decl != e->decl 662 && lto_symtab_merge_p (this_prevailing->decl, e->decl)) 663 break; 664 if (this_prevailing == last_prevailing) 665 { 666 this_prevailing = NULL; 667 break; 668 } 669 } 670 671 if (this_prevailing) 672 lto_symtab_prevail_decl (this_prevailing->decl, e->decl); 673 /* Maintain LRU list: relink the new prevaililng symbol 674 just after previaling node in the chain and update last_prevailing. 675 Since the number of possible declarations of a given symbol is 676 small, this should be faster than building a hash. */ 677 else if (e == prevailing->next_sharing_asm_name) 678 last_prevailing = e; 679 else 680 { 681 if (e->next_sharing_asm_name) 682 e->next_sharing_asm_name->previous_sharing_asm_name 683 = e->previous_sharing_asm_name; 684 e->previous_sharing_asm_name->next_sharing_asm_name 685 = e->next_sharing_asm_name; 686 e->previous_sharing_asm_name = prevailing; 687 e->next_sharing_asm_name = prevailing->next_sharing_asm_name; 688 prevailing->next_sharing_asm_name->previous_sharing_asm_name = e; 689 prevailing->next_sharing_asm_name = e; 690 if (last_prevailing == prevailing) 691 last_prevailing = e; 692 } 693 } 694 if (mismatches.is_empty ()) 695 return; 696 697 /* Diagnose all mismatched re-declarations. */ 698 FOR_EACH_VEC_ELT (mismatches, i, decl) 699 { 700 /* Do not diagnose two built-in declarations, there is no useful 701 location in that case. It also happens for AVR if two built-ins 702 use the same asm name because their libgcc assembler code is the 703 same, see PR78562. */ 704 if (DECL_IS_BUILTIN (prevailing->decl) 705 && DECL_IS_BUILTIN (decl)) 706 continue; 707 708 int level = warn_type_compatibility_p (TREE_TYPE (prevailing->decl), 709 TREE_TYPE (decl), 710 DECL_COMDAT (decl)); 711 if (level) 712 { 713 bool diag = false; 714 if (level & 2) 715 diag = warning_at (DECL_SOURCE_LOCATION (decl), 716 OPT_Wodr, 717 "%qD violates the C++ One Definition Rule ", 718 decl); 719 if (!diag && (level & 1)) 720 diag = warning_at (DECL_SOURCE_LOCATION (decl), 721 OPT_Wlto_type_mismatch, 722 "type of %qD does not match original " 723 "declaration", decl); 724 if (diag) 725 { 726 warn_types_mismatch (TREE_TYPE (prevailing->decl), 727 TREE_TYPE (decl), 728 DECL_SOURCE_LOCATION (prevailing->decl), 729 DECL_SOURCE_LOCATION (decl)); 730 if ((level & 4) 731 && !TREE_READONLY (prevailing->decl)) 732 tbaa_p = true; 733 } 734 diagnosed_p |= diag; 735 } 736 else if ((DECL_USER_ALIGN (prevailing->decl) 737 && DECL_USER_ALIGN (decl)) 738 && DECL_ALIGN (prevailing->decl) < DECL_ALIGN (decl)) 739 { 740 diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 741 OPT_Wlto_type_mismatch, 742 "alignment of %qD is bigger than " 743 "original declaration", decl); 744 } 745 else 746 diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 747 OPT_Wlto_type_mismatch, 748 "size of %qD differ from the size of " 749 "original declaration", decl); 750 } 751 if (diagnosed_p) 752 inform (DECL_SOURCE_LOCATION (prevailing->decl), 753 "%qD was previously declared here", prevailing->decl); 754 if (tbaa_p) 755 inform (DECL_SOURCE_LOCATION (prevailing->decl), 756 "code may be misoptimized unless " 757 "-fno-strict-aliasing is used"); 758 759 mismatches.release (); 760 } 761 762 /* Helper to process the decl chain for the symbol table entry *SLOT. */ 763 764 static void 765 lto_symtab_merge_decls_1 (symtab_node *first) 766 { 767 symtab_node *e; 768 symtab_node *prevailing; 769 bool diagnosed_p = false; 770 771 if (symtab->dump_file) 772 { 773 fprintf (symtab->dump_file, "Merging nodes for %s. Candidates:\n", 774 first->asm_name ()); 775 for (e = first; e; e = e->next_sharing_asm_name) 776 if (TREE_PUBLIC (e->decl)) 777 e->dump (symtab->dump_file); 778 } 779 780 /* Compute the symbol resolutions. This is a no-op when using the 781 linker plugin and resolution was decided by the linker. */ 782 prevailing = lto_symtab_resolve_symbols (first); 783 784 /* If there's not a prevailing symbol yet it's an external reference. 785 Happens a lot during ltrans. Choose the first symbol with a 786 cgraph or a varpool node. */ 787 if (!prevailing) 788 { 789 for (prevailing = first; 790 prevailing; prevailing = prevailing->next_sharing_asm_name) 791 if (lto_symtab_symbol_p (prevailing)) 792 break; 793 if (!prevailing) 794 return; 795 /* For variables chose with a priority variant with vnode 796 attached (i.e. from unit where external declaration of 797 variable is actually used). 798 When there are multiple variants, chose one with size. 799 This is needed for C++ typeinfos, for example in 800 lto/20081204-1 there are typeifos in both units, just 801 one of them do have size. */ 802 if (TREE_CODE (prevailing->decl) == VAR_DECL) 803 { 804 for (e = prevailing->next_sharing_asm_name; 805 e; e = e->next_sharing_asm_name) 806 if (!COMPLETE_TYPE_P (TREE_TYPE (prevailing->decl)) 807 && COMPLETE_TYPE_P (TREE_TYPE (e->decl)) 808 && lto_symtab_symbol_p (e)) 809 prevailing = e; 810 } 811 /* For functions prefer the non-builtin if one is available. */ 812 else if (TREE_CODE (prevailing->decl) == FUNCTION_DECL) 813 { 814 for (e = first; e; e = e->next_sharing_asm_name) 815 if (TREE_CODE (e->decl) == FUNCTION_DECL 816 && !DECL_BUILT_IN (e->decl) 817 && lto_symtab_symbol_p (e)) 818 { 819 prevailing = e; 820 break; 821 } 822 } 823 } 824 825 symtab->symtab_prevail_in_asm_name_hash (prevailing); 826 827 /* Diagnose mismatched objects. */ 828 for (e = prevailing->next_sharing_asm_name; 829 e; e = e->next_sharing_asm_name) 830 { 831 if (TREE_CODE (prevailing->decl) 832 == TREE_CODE (e->decl)) 833 continue; 834 if (!lto_symtab_symbol_p (e)) 835 continue; 836 837 switch (TREE_CODE (prevailing->decl)) 838 { 839 case VAR_DECL: 840 gcc_assert (TREE_CODE (e->decl) == FUNCTION_DECL); 841 error_at (DECL_SOURCE_LOCATION (e->decl), 842 "variable %qD redeclared as function", 843 prevailing->decl); 844 break; 845 846 case FUNCTION_DECL: 847 gcc_assert (TREE_CODE (e->decl) == VAR_DECL); 848 error_at (DECL_SOURCE_LOCATION (e->decl), 849 "function %qD redeclared as variable", 850 prevailing->decl); 851 break; 852 853 default: 854 gcc_unreachable (); 855 } 856 857 diagnosed_p = true; 858 } 859 if (diagnosed_p) 860 inform (DECL_SOURCE_LOCATION (prevailing->decl), 861 "previously declared here"); 862 863 /* Merge the chain to the single prevailing decl and diagnose 864 mismatches. */ 865 lto_symtab_merge_decls_2 (prevailing, diagnosed_p); 866 867 if (symtab->dump_file) 868 { 869 fprintf (symtab->dump_file, "After resolution:\n"); 870 for (e = prevailing; e; e = e->next_sharing_asm_name) 871 e->dump (symtab->dump_file); 872 } 873 } 874 875 /* Resolve and merge all symbol table chains to a prevailing decl. */ 876 877 void 878 lto_symtab_merge_decls (void) 879 { 880 symtab_node *node; 881 882 /* Populate assembler name hash. */ 883 symtab->symtab_initialize_asm_name_hash (); 884 885 FOR_EACH_SYMBOL (node) 886 if (!node->previous_sharing_asm_name 887 && node->next_sharing_asm_name) 888 lto_symtab_merge_decls_1 (node); 889 } 890 891 /* Helper to process the decl chain for the symbol table entry *SLOT. */ 892 893 static void 894 lto_symtab_merge_symbols_1 (symtab_node *prevailing) 895 { 896 symtab_node *e; 897 symtab_node *next; 898 899 prevailing->decl->decl_with_vis.symtab_node = prevailing; 900 901 /* Replace the cgraph node of each entry with the prevailing one. */ 902 for (e = prevailing->next_sharing_asm_name; e; 903 e = next) 904 { 905 next = e->next_sharing_asm_name; 906 907 if (!lto_symtab_symbol_p (e)) 908 continue; 909 cgraph_node *ce = dyn_cast <cgraph_node *> (e); 910 symtab_node *to = symtab_node::get (lto_symtab_prevailing_decl (e->decl)); 911 912 /* No matter how we are going to deal with resolution, we will ultimately 913 use prevailing definition. */ 914 if (ce) 915 ipa_merge_profiles (dyn_cast<cgraph_node *> (prevailing), 916 dyn_cast<cgraph_node *> (e)); 917 918 /* If we decided to replace the node by TO, do it. */ 919 if (e != to) 920 { 921 if (ce) 922 lto_cgraph_replace_node (ce, dyn_cast<cgraph_node *> (to)); 923 else if (varpool_node *ve = dyn_cast <varpool_node *> (e)) 924 lto_varpool_replace_node (ve, dyn_cast<varpool_node *> (to)); 925 } 926 /* Watch out for duplicated symbols for a given declaration. */ 927 else if (!e->transparent_alias 928 || !e->definition || e->get_alias_target () != to) 929 { 930 /* We got a new declaration we do not want to merge. In this case 931 get rid of the existing definition and create a transparent 932 alias. */ 933 if (ce) 934 { 935 lto_free_function_in_decl_state_for_node (ce); 936 if (!ce->weakref) 937 ce->release_body (); 938 ce->reset (); 939 symtab->call_cgraph_removal_hooks (ce); 940 } 941 else 942 { 943 DECL_INITIAL (e->decl) = error_mark_node; 944 if (e->lto_file_data) 945 { 946 lto_free_function_in_decl_state_for_node (e); 947 e->lto_file_data = NULL; 948 } 949 symtab->call_varpool_removal_hooks (dyn_cast<varpool_node *> (e)); 950 } 951 e->remove_all_references (); 952 e->analyzed = e->body_removed = false; 953 e->resolve_alias (prevailing, true); 954 gcc_assert (e != prevailing); 955 } 956 } 957 958 return; 959 } 960 961 /* Merge cgraph nodes according to the symbol merging done by 962 lto_symtab_merge_decls. */ 963 964 void 965 lto_symtab_merge_symbols (void) 966 { 967 symtab_node *node; 968 969 if (!flag_ltrans) 970 { 971 symtab->symtab_initialize_asm_name_hash (); 972 973 /* Do the actual merging. 974 At this point we invalidate hash translating decls into symtab nodes 975 because after removing one of duplicate decls the hash is not correcly 976 updated to the ohter dupliate. */ 977 FOR_EACH_SYMBOL (node) 978 if (lto_symtab_symbol_p (node) 979 && node->next_sharing_asm_name 980 && !node->previous_sharing_asm_name) 981 lto_symtab_merge_symbols_1 (node); 982 983 /* Resolve weakref aliases whose target are now in the compilation unit. 984 also re-populate the hash translating decls into symtab nodes*/ 985 FOR_EACH_SYMBOL (node) 986 { 987 cgraph_node *cnode, *cnode2; 988 varpool_node *vnode; 989 symtab_node *node2; 990 991 if (!node->analyzed && node->alias_target) 992 { 993 symtab_node *tgt = symtab_node::get_for_asmname (node->alias_target); 994 gcc_assert (node->weakref); 995 if (tgt) 996 node->resolve_alias (tgt, true); 997 } 998 /* If the symbol was preempted outside IR, see if we want to get rid 999 of the definition. */ 1000 if (node->analyzed 1001 && !DECL_EXTERNAL (node->decl) 1002 && (node->resolution == LDPR_PREEMPTED_REG 1003 || node->resolution == LDPR_RESOLVED_IR 1004 || node->resolution == LDPR_RESOLVED_EXEC 1005 || node->resolution == LDPR_RESOLVED_DYN)) 1006 { 1007 DECL_EXTERNAL (node->decl) = 1; 1008 /* If alias to local symbol was preempted by external definition, 1009 we know it is not pointing to the local symbol. Remove it. */ 1010 if (node->alias 1011 && !node->weakref 1012 && !node->transparent_alias 1013 && node->get_alias_target ()->binds_to_current_def_p ()) 1014 { 1015 node->alias = false; 1016 node->remove_all_references (); 1017 node->definition = false; 1018 node->analyzed = false; 1019 node->cpp_implicit_alias = false; 1020 } 1021 else if (!node->alias 1022 && node->definition 1023 && node->get_availability () <= AVAIL_INTERPOSABLE) 1024 { 1025 if ((cnode = dyn_cast <cgraph_node *> (node)) != NULL) 1026 cnode->reset (); 1027 else 1028 { 1029 node->analyzed = node->definition = false; 1030 node->remove_all_references (); 1031 } 1032 } 1033 } 1034 1035 if (!(cnode = dyn_cast <cgraph_node *> (node)) 1036 || !cnode->clone_of 1037 || cnode->clone_of->decl != cnode->decl) 1038 { 1039 /* Builtins are not merged via decl merging. It is however 1040 possible that tree merging unified the declaration. We 1041 do not want duplicate entries in symbol table. */ 1042 if (cnode && DECL_BUILT_IN (node->decl) 1043 && (cnode2 = cgraph_node::get (node->decl)) 1044 && cnode2 != cnode) 1045 lto_cgraph_replace_node (cnode2, cnode); 1046 1047 /* The user defined assembler variables are also not unified by their 1048 symbol name (since it is irrelevant), but we need to unify symbol 1049 nodes if tree merging occurred. */ 1050 if ((vnode = dyn_cast <varpool_node *> (node)) 1051 && DECL_HARD_REGISTER (vnode->decl) 1052 && (node2 = symtab_node::get (vnode->decl)) 1053 && node2 != node) 1054 lto_varpool_replace_node (dyn_cast <varpool_node *> (node2), 1055 vnode); 1056 1057 1058 /* Abstract functions may have duplicated cgraph nodes attached; 1059 remove them. */ 1060 else if (cnode && DECL_ABSTRACT_P (cnode->decl) 1061 && (cnode2 = cgraph_node::get (node->decl)) 1062 && cnode2 != cnode) 1063 cnode2->remove (); 1064 1065 node->decl->decl_with_vis.symtab_node = node; 1066 } 1067 } 1068 } 1069 } 1070 1071 /* Virtual tables may matter for code generation even if they are not 1072 directly refernced by the code because they may be used for devirtualizaiton. 1073 For this reason it is important to merge even virtual tables that have no 1074 associated symbol table entries. Without doing so we lose optimization 1075 oppurtunities by losing track of the vtable constructor. 1076 FIXME: we probably ought to introduce explicit symbol table entries for 1077 those before streaming. */ 1078 1079 tree 1080 lto_symtab_prevailing_virtual_decl (tree decl) 1081 { 1082 if (DECL_ABSTRACT_P (decl)) 1083 return decl; 1084 gcc_checking_assert (!type_in_anonymous_namespace_p (DECL_CONTEXT (decl)) 1085 && DECL_ASSEMBLER_NAME_SET_P (decl)); 1086 1087 symtab_node *n = symtab_node::get_for_asmname 1088 (DECL_ASSEMBLER_NAME (decl)); 1089 while (n && ((!DECL_EXTERNAL (n->decl) && !TREE_PUBLIC (n->decl)) 1090 || !DECL_VIRTUAL_P (n->decl))) 1091 n = n->next_sharing_asm_name; 1092 if (n) 1093 { 1094 /* Merge decl state in both directions, we may still end up using 1095 the other decl. */ 1096 TREE_ADDRESSABLE (n->decl) |= TREE_ADDRESSABLE (decl); 1097 TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (n->decl); 1098 1099 if (TREE_CODE (decl) == FUNCTION_DECL) 1100 { 1101 /* Merge decl state in both directions, we may still end up using 1102 the other decl. */ 1103 DECL_POSSIBLY_INLINED (n->decl) |= DECL_POSSIBLY_INLINED (decl); 1104 DECL_POSSIBLY_INLINED (decl) |= DECL_POSSIBLY_INLINED (n->decl); 1105 } 1106 lto_symtab_prevail_decl (n->decl, decl); 1107 decl = n->decl; 1108 } 1109 else 1110 symtab_node::get_create (decl); 1111 1112 return decl; 1113 } 1114