gcc/lto-symtab.c

   1 /* LTO symbol table.
   2    Copyright (C) 2009-2013 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 "diagnostic-core.h"
  25 #include "tree.h"
  26 #include "gimple.h"
  27 #include "ggc.h"
  28 #include "hashtab.h"
  29 #include "plugin-api.h"
  30 #include "lto-streamer.h"
  31
  32 /* Vector to keep track of external variables we've seen so far.  */
  33 vec<tree, va_gc> *lto_global_var_decls;
  34
  35 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
  36    all edges and removing the old node.  */
  37
  38 static void
  39 lto_cgraph_replace_node (struct cgraph_node *node,
  40                          struct cgraph_node *prevailing_node)
  41 {
  42   struct cgraph_edge *e, *next;
  43   bool compatible_p;
  44
  45   if (cgraph_dump_file)
  46     {
  47       fprintf (cgraph_dump_file, "Replacing cgraph node %s/%i by %s/%i"
  48                " for symbol %s\n",
  49                cgraph_node_name (node), node->symbol.order,
  50                cgraph_node_name (prevailing_node),
  51                prevailing_node->symbol.order,
  52                IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name)
  53                  (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->symbol.decl)))));
  54     }
  55
  56   /* Merge node flags.  */
  57   if (node->symbol.force_output)
  58     cgraph_mark_force_output_node (prevailing_node);
  59   if (node->symbol.address_taken)
  60     {
  61       gcc_assert (!prevailing_node->global.inlined_to);
  62       cgraph_mark_address_taken_node (prevailing_node);
  63     }
  64
  65   /* Redirect all incoming edges.  */
  66   compatible_p
  67     = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node->symbol.decl)),
  68                           TREE_TYPE (TREE_TYPE (node->symbol.decl)));
  69   for (e = node->callers; e; e = next)
  70     {
  71       next = e->next_caller;
  72       cgraph_redirect_edge_callee (e, prevailing_node);
  73       /* If there is a mismatch between the supposed callee return type and
  74          the real one do not attempt to inline this function.
  75          ???  We really need a way to match function signatures for ABI
  76          compatibility and perform related promotions at inlining time.  */
  77       if (!compatible_p)
  78         e->call_stmt_cannot_inline_p = 1;
  79     }
  80   /* Redirect incomming references.  */
  81   ipa_clone_referring ((symtab_node)prevailing_node, &node->symbol.ref_list);
  82
  83   /* Finally remove the replaced node.  */
  84   cgraph_remove_node (node);
  85 }
  86
  87 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
  88    all edges and removing the old node.  */
  89
  90 static void
  91 lto_varpool_replace_node (struct varpool_node *vnode,
  92                           struct varpool_node *prevailing_node)
  93 {
  94   gcc_assert (!vnode->finalized || prevailing_node->finalized);
  95   gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
  96
  97   ipa_clone_referring ((symtab_node)prevailing_node, &vnode->symbol.ref_list);
  98
  99   /* Be sure we can garbage collect the initializer.  */
 100   if (DECL_INITIAL (vnode->symbol.decl))
 101     DECL_INITIAL (vnode->symbol.decl) = error_mark_node;
 102   /* Finally remove the replaced node.  */
 103   varpool_remove_node (vnode);
 104 }
 105
 106 /* Merge two variable or function symbol table entries PREVAILING and ENTRY.
 107    Return false if the symbols are not fully compatible and a diagnostic
 108    should be emitted.  */
 109
 110 static bool
 111 lto_symtab_merge (symtab_node prevailing, symtab_node entry)
 112 {
 113   tree prevailing_decl = prevailing->symbol.decl;
 114   tree decl = entry->symbol.decl;
 115   tree prevailing_type, type;
 116
 117   if (prevailing_decl == decl)
 118     return true;
 119
 120   /* Merge decl state in both directions, we may still end up using
 121      the new decl.  */
 122   TREE_ADDRESSABLE (prevailing_decl) |= TREE_ADDRESSABLE (decl);
 123   TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (prevailing_decl);
 124
 125   /* The linker may ask us to combine two incompatible symbols.
 126      Detect this case and notify the caller of required diagnostics.  */
 127
 128   if (TREE_CODE (decl) == FUNCTION_DECL)
 129     {
 130       if (!types_compatible_p (TREE_TYPE (prevailing_decl),
 131                                TREE_TYPE (decl)))
 132         /* If we don't have a merged type yet...sigh.  The linker
 133            wouldn't complain if the types were mismatched, so we
 134            probably shouldn't either.  Just use the type from
 135            whichever decl appears to be associated with the
 136            definition.  If for some odd reason neither decl is, the
 137            older one wins.  */
 138         (void) 0;
 139
 140       return true;
 141     }
 142
 143   /* Now we exclusively deal with VAR_DECLs.  */
 144
 145   /* Sharing a global symbol is a strong hint that two types are
 146      compatible.  We could use this information to complete
 147      incomplete pointed-to types more aggressively here, ignoring
 148      mismatches in both field and tag names.  It's difficult though
 149      to guarantee that this does not have side-effects on merging
 150      more compatible types from other translation units though.  */
 151
 152   /* We can tolerate differences in type qualification, the
 153      qualification of the prevailing definition will prevail.
 154      ???  In principle we might want to only warn for structurally
 155      incompatible types here, but unless we have protective measures
 156      for TBAA in place that would hide useful information.  */
 157   prevailing_type = TYPE_MAIN_VARIANT (TREE_TYPE (prevailing_decl));
 158   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
 159
 160   if (!types_compatible_p (prevailing_type, type))
 161     {
 162       if (COMPLETE_TYPE_P (type))
 163         return false;
 164
 165       /* If type is incomplete then avoid warnings in the cases
 166          that TBAA handles just fine.  */
 167
 168       if (TREE_CODE (prevailing_type) != TREE_CODE (type))
 169         return false;
 170
 171       if (TREE_CODE (prevailing_type) == ARRAY_TYPE)
 172         {
 173           tree tem1 = TREE_TYPE (prevailing_type);
 174           tree tem2 = TREE_TYPE (type);
 175           while (TREE_CODE (tem1) == ARRAY_TYPE
 176                  && TREE_CODE (tem2) == ARRAY_TYPE)
 177             {
 178               tem1 = TREE_TYPE (tem1);
 179               tem2 = TREE_TYPE (tem2);
 180             }
 181
 182           if (TREE_CODE (tem1) != TREE_CODE (tem2))
 183             return false;
 184
 185           if (!types_compatible_p (tem1, tem2))
 186             return false;
 187         }
 188
 189       /* Fallthru.  Compatible enough.  */
 190     }
 191
 192   /* ???  We might want to emit a warning here if type qualification
 193      differences were spotted.  Do not do this unconditionally though.  */
 194
 195   /* There is no point in comparing too many details of the decls here.
 196      The type compatibility checks or the completing of types has properly
 197      dealt with most issues.  */
 198
 199   /* The following should all not invoke fatal errors as in non-LTO
 200      mode the linker wouldn't complain either.  Just emit warnings.  */
 201
 202   /* Report a warning if user-specified alignments do not match.  */
 203   if ((DECL_USER_ALIGN (prevailing_decl) && DECL_USER_ALIGN (decl))
 204       && DECL_ALIGN (prevailing_decl) < DECL_ALIGN (decl))
 205     return false;
 206
 207   return true;
 208 }
 209
 210 /* Return true if the symtab entry E can be replaced by another symtab
 211    entry.  */
 212
 213 static bool
 214 lto_symtab_resolve_replaceable_p (symtab_node e)
 215 {
 216   if (DECL_EXTERNAL (e->symbol.decl)
 217       || DECL_COMDAT (e->symbol.decl)
 218       || DECL_ONE_ONLY (e->symbol.decl)
 219       || DECL_WEAK (e->symbol.decl))
 220     return true;
 221
 222   if (TREE_CODE (e->symbol.decl) == VAR_DECL)
 223     return (DECL_COMMON (e->symbol.decl)
 224             || (!flag_no_common && !DECL_INITIAL (e->symbol.decl)));
 225
 226   return false;
 227 }
 228
 229 /* Return true, if the symbol E should be resolved by lto-symtab.
 230    Those are all external symbols and all real symbols that are not static (we
 231    handle renaming of static later in partitioning).  */
 232
 233 static bool
 234 lto_symtab_symbol_p (symtab_node e)
 235 {
 236   if (!TREE_PUBLIC (e->symbol.decl) && !DECL_EXTERNAL (e->symbol.decl))
 237     return false;
 238   /* weakrefs are really static variables that are made external by a hack.  */
 239   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (e->symbol.decl)))
 240     return false;
 241   return symtab_real_symbol_p (e);
 242 }
 243
 244 /* Return true if the symtab entry E can be the prevailing one.  */
 245
 246 static bool
 247 lto_symtab_resolve_can_prevail_p (symtab_node e)
 248 {
 249   if (!lto_symtab_symbol_p (e))
 250     return false;
 251
 252   /* The C++ frontend ends up neither setting TREE_STATIC nor
 253      DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
 254      So do not reject !TREE_STATIC here but only DECL_EXTERNAL.  */
 255   if (DECL_EXTERNAL (e->symbol.decl))
 256     return false;
 257
 258   /* For functions we need a non-discarded body.  */
 259   if (TREE_CODE (e->symbol.decl) == FUNCTION_DECL)
 260     return (cgraph (e)->analyzed);
 261
 262   else if (TREE_CODE (e->symbol.decl) == VAR_DECL)
 263     return varpool (e)->finalized;
 264
 265   gcc_unreachable ();
 266 }
 267
 268 /* Resolve the symbol with the candidates in the chain *SLOT and store
 269    their resolutions.  */
 270
 271 static symtab_node
 272 lto_symtab_resolve_symbols (symtab_node first)
 273 {
 274   symtab_node e;
 275   symtab_node prevailing = NULL;
 276
 277   /* Always set e->node so that edges are updated to reflect decl merging. */
 278   for (e = first; e; e = e->symbol.next_sharing_asm_name)
 279     if (lto_symtab_symbol_p (e)
 280         && (e->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY
 281             || e->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY_EXP
 282             || e->symbol.resolution == LDPR_PREVAILING_DEF))
 283       {
 284         prevailing = e;
 285         break;
 286       }
 287
 288   /* If the chain is already resolved there is nothing else to do.  */
 289   if (prevailing)
 290     {
 291       /* Assert it's the only one.  */
 292       for (e = prevailing->symbol.next_sharing_asm_name; e; e = e->symbol.next_sharing_asm_name)
 293         if (lto_symtab_symbol_p (e)
 294             && (e->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY
 295                 || e->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY_EXP
 296                 || e->symbol.resolution == LDPR_PREVAILING_DEF))
 297           fatal_error ("multiple prevailing defs for %qE",
 298                        DECL_NAME (prevailing->symbol.decl));
 299       return prevailing;
 300     }
 301
 302   /* Find the single non-replaceable prevailing symbol and
 303      diagnose ODR violations.  */
 304   for (e = first; e; e = e->symbol.next_sharing_asm_name)
 305     {
 306       if (!lto_symtab_resolve_can_prevail_p (e))
 307         continue;
 308
 309       /* If we have a non-replaceable definition it prevails.  */
 310       if (!lto_symtab_resolve_replaceable_p (e))
 311         {
 312           if (prevailing)
 313             {
 314               error_at (DECL_SOURCE_LOCATION (e->symbol.decl),
 315                         "%qD has already been defined", e->symbol.decl);
 316               inform (DECL_SOURCE_LOCATION (prevailing->symbol.decl),
 317                       "previously defined here");
 318             }
 319           prevailing = e;
 320         }
 321     }
 322   if (prevailing)
 323     return prevailing;
 324
 325   /* Do a second round choosing one from the replaceable prevailing decls.  */
 326   for (e = first; e; e = e->symbol.next_sharing_asm_name)
 327     {
 328       if (!lto_symtab_resolve_can_prevail_p (e))
 329         continue;
 330
 331       /* Choose the first function that can prevail as prevailing.  */
 332       if (TREE_CODE (e->symbol.decl) == FUNCTION_DECL)
 333         {
 334           prevailing = e;
 335           break;
 336         }
 337
 338       /* From variables that can prevail choose the largest one.  */
 339       if (!prevailing
 340           || tree_int_cst_lt (DECL_SIZE (prevailing->symbol.decl),
 341                               DECL_SIZE (e->symbol.decl))
 342           /* When variables are equivalent try to chose one that has useful
 343              DECL_INITIAL.  This makes sense for keyed vtables that are
 344              DECL_EXTERNAL but initialized.  In units that do not need them
 345              we replace the initializer by error_mark_node to conserve
 346              memory.
 347
 348              We know that the vtable is keyed outside the LTO unit - otherwise
 349              the keyed instance would prevail.  We still can preserve useful
 350              info in the initializer.  */
 351           || (DECL_SIZE (prevailing->symbol.decl) == DECL_SIZE (e->symbol.decl)
 352               && (DECL_INITIAL (e->symbol.decl)
 353                   && DECL_INITIAL (e->symbol.decl) != error_mark_node)
 354               && (!DECL_INITIAL (prevailing->symbol.decl)
 355                   || DECL_INITIAL (prevailing->symbol.decl) == error_mark_node)))
 356         prevailing = e;
 357     }
 358
 359   return prevailing;
 360 }
 361
 362 /* Merge all decls in the symbol table chain to the prevailing decl and
 363    issue diagnostics about type mismatches.  If DIAGNOSED_P is true
 364    do not issue further diagnostics.*/
 365
 366 static void
 367 lto_symtab_merge_decls_2 (symtab_node first, bool diagnosed_p)
 368 {
 369   symtab_node prevailing, e;
 370   vec<tree> mismatches = vNULL;
 371   unsigned i;
 372   tree decl;
 373
 374   /* Nothing to do for a single entry.  */
 375   prevailing = first;
 376   if (!prevailing->symbol.next_sharing_asm_name)
 377     return;
 378
 379   /* Try to merge each entry with the prevailing one.  */
 380   for (e = prevailing->symbol.next_sharing_asm_name;
 381        e; e = e->symbol.next_sharing_asm_name)
 382     if (TREE_PUBLIC (e->symbol.decl))
 383       {
 384         if (!lto_symtab_merge (prevailing, e)
 385             && !diagnosed_p)
 386           mismatches.safe_push (e->symbol.decl);
 387       }
 388   if (mismatches.is_empty ())
 389     return;
 390
 391   /* Diagnose all mismatched re-declarations.  */
 392   FOR_EACH_VEC_ELT (mismatches, i, decl)
 393     {
 394       if (!types_compatible_p (TREE_TYPE (prevailing->symbol.decl),
 395                                TREE_TYPE (decl)))
 396         diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 0,
 397                                    "type of %qD does not match original "
 398                                    "declaration", decl);
 399
 400       else if ((DECL_USER_ALIGN (prevailing->symbol.decl)
 401                 && DECL_USER_ALIGN (decl))
 402                && DECL_ALIGN (prevailing->symbol.decl) < DECL_ALIGN (decl))
 403         {
 404           diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 0,
 405                                      "alignment of %qD is bigger than "
 406                                      "original declaration", decl);
 407         }
 408     }
 409   if (diagnosed_p)
 410     inform (DECL_SOURCE_LOCATION (prevailing->symbol.decl),
 411             "previously declared here");
 412
 413   mismatches.release ();
 414 }
 415
 416 /* Helper to process the decl chain for the symbol table entry *SLOT.  */
 417
 418 static void
 419 lto_symtab_merge_decls_1 (symtab_node first)
 420 {
 421   symtab_node e, prevailing;
 422   bool diagnosed_p = false;
 423
 424   if (cgraph_dump_file)
 425     {
 426       fprintf (cgraph_dump_file, "Merging nodes for %s. Candidates:\n",
 427                symtab_node_asm_name (first));
 428       for (e = first; e; e = e->symbol.next_sharing_asm_name)
 429         if (TREE_PUBLIC (e->symbol.decl))
 430           dump_symtab_node (cgraph_dump_file, e);
 431     }
 432
 433   /* Compute the symbol resolutions.  This is a no-op when using the
 434      linker plugin and resolution was decided by the linker.  */
 435   prevailing = lto_symtab_resolve_symbols (first);
 436
 437   /* If there's not a prevailing symbol yet it's an external reference.
 438      Happens a lot during ltrans.  Choose the first symbol with a
 439      cgraph or a varpool node.  */
 440   if (!prevailing)
 441     {
 442       prevailing = first;
 443       /* For variables chose with a priority variant with vnode
 444          attached (i.e. from unit where external declaration of
 445          variable is actually used).
 446          When there are multiple variants, chose one with size.
 447          This is needed for C++ typeinfos, for example in
 448          lto/20081204-1 there are typeifos in both units, just
 449          one of them do have size.  */
 450       if (TREE_CODE (prevailing->symbol.decl) == VAR_DECL)
 451         {
 452           for (e = prevailing->symbol.next_sharing_asm_name;
 453                e; e = e->symbol.next_sharing_asm_name)
 454             if (!COMPLETE_TYPE_P (TREE_TYPE (prevailing->symbol.decl))
 455                 && COMPLETE_TYPE_P (TREE_TYPE (e->symbol.decl))
 456                 && lto_symtab_symbol_p (e))
 457               prevailing = e;
 458         }
 459       /* For variables prefer the non-builtin if one is available.  */
 460       else if (TREE_CODE (prevailing->symbol.decl) == FUNCTION_DECL)
 461         {
 462           for (e = first; e; e = e->symbol.next_sharing_asm_name)
 463             if (TREE_CODE (e->symbol.decl) == FUNCTION_DECL
 464                 && !DECL_BUILT_IN (e->symbol.decl)
 465                 && lto_symtab_symbol_p (e))
 466               {
 467                 prevailing = e;
 468                 break;
 469               }
 470         }
 471     }
 472
 473   symtab_prevail_in_asm_name_hash (prevailing);
 474
 475   /* Diagnose mismatched objects.  */
 476   for (e = prevailing->symbol.next_sharing_asm_name;
 477        e; e = e->symbol.next_sharing_asm_name)
 478     {
 479       if (TREE_CODE (prevailing->symbol.decl)
 480           == TREE_CODE (e->symbol.decl))
 481         continue;
 482       if (!lto_symtab_symbol_p (e))
 483         continue;
 484
 485       switch (TREE_CODE (prevailing->symbol.decl))
 486         {
 487         case VAR_DECL:
 488           gcc_assert (TREE_CODE (e->symbol.decl) == FUNCTION_DECL);
 489           error_at (DECL_SOURCE_LOCATION (e->symbol.decl),
 490                     "variable %qD redeclared as function",
 491                     prevailing->symbol.decl);
 492           break;
 493
 494         case FUNCTION_DECL:
 495           gcc_assert (TREE_CODE (e->symbol.decl) == VAR_DECL);
 496           error_at (DECL_SOURCE_LOCATION (e->symbol.decl),
 497                     "function %qD redeclared as variable",
 498                     prevailing->symbol.decl);
 499           break;
 500
 501         default:
 502           gcc_unreachable ();
 503         }
 504
 505       diagnosed_p = true;
 506     }
 507   if (diagnosed_p)
 508       inform (DECL_SOURCE_LOCATION (prevailing->symbol.decl),
 509               "previously declared here");
 510
 511   /* Merge the chain to the single prevailing decl and diagnose
 512      mismatches.  */
 513   lto_symtab_merge_decls_2 (prevailing, diagnosed_p);
 514
 515   if (cgraph_dump_file)
 516     {
 517       fprintf (cgraph_dump_file, "After resolution:\n");
 518       for (e = prevailing; e; e = e->symbol.next_sharing_asm_name)
 519         dump_symtab_node (cgraph_dump_file, e);
 520     }
 521 }
 522
 523 /* Resolve and merge all symbol table chains to a prevailing decl.  */
 524
 525 void
 526 lto_symtab_merge_decls (void)
 527 {
 528   symtab_node node;
 529
 530   /* Populate assembler name hash.   */
 531   symtab_initialize_asm_name_hash ();
 532
 533   FOR_EACH_SYMBOL (node)
 534     if (lto_symtab_symbol_p (node)
 535         && node->symbol.next_sharing_asm_name)
 536       {
 537         symtab_node n;
 538
 539         /* To avoid duplicated work, see if this is first real symbol in the
 540            chain.  */
 541         for (n = node->symbol.previous_sharing_asm_name;
 542              n && !lto_symtab_symbol_p (n); n = n->symbol.previous_sharing_asm_name)
 543           ;
 544         if (!n)
 545           lto_symtab_merge_decls_1 (node);
 546       }
 547 }
 548
 549 /* Helper to process the decl chain for the symbol table entry *SLOT.  */
 550
 551 static void
 552 lto_symtab_merge_cgraph_nodes_1 (symtab_node prevailing)
 553 {
 554   symtab_node e, next;
 555
 556   /* Replace the cgraph node of each entry with the prevailing one.  */
 557   for (e = prevailing->symbol.next_sharing_asm_name; e;
 558        e = next)
 559     {
 560       next = e->symbol.next_sharing_asm_name;
 561
 562       if (!lto_symtab_symbol_p (e))
 563         continue;
 564       cgraph_node *ce = dyn_cast <cgraph_node> (e);
 565       if (ce && !DECL_BUILT_IN (e->symbol.decl))
 566         lto_cgraph_replace_node (ce, cgraph (prevailing));
 567       if (varpool_node *ve = dyn_cast <varpool_node> (e))
 568         lto_varpool_replace_node (ve, varpool (prevailing));
 569     }
 570
 571   return;
 572 }
 573
 574 /* Merge cgraph nodes according to the symbol merging done by
 575    lto_symtab_merge_decls.  */
 576
 577 void
 578 lto_symtab_merge_cgraph_nodes (void)
 579 {
 580   struct cgraph_node *cnode;
 581   struct varpool_node *vnode;
 582   symtab_node node;
 583
 584   /* Populate assembler name hash.   */
 585   symtab_initialize_asm_name_hash ();
 586
 587   if (!flag_ltrans)
 588     FOR_EACH_SYMBOL (node)
 589       if (lto_symtab_symbol_p (node)
 590           && node->symbol.next_sharing_asm_name
 591           && !node->symbol.previous_sharing_asm_name)
 592         lto_symtab_merge_cgraph_nodes_1 (node);
 593
 594   FOR_EACH_FUNCTION (cnode)
 595     {
 596       if ((cnode->thunk.thunk_p || cnode->alias)
 597           && cnode->thunk.alias)
 598         cnode->thunk.alias = lto_symtab_prevailing_decl (cnode->thunk.alias);
 599       cnode->symbol.aux = NULL;
 600     }
 601   FOR_EACH_VARIABLE (vnode)
 602     {
 603       if (vnode->alias_of)
 604         vnode->alias_of = lto_symtab_prevailing_decl (vnode->alias_of);
 605       vnode->symbol.aux = NULL;
 606     }
 607 }
 608
 609 /* Given the decl DECL, return the prevailing decl with the same name. */
 610
 611 tree
 612 lto_symtab_prevailing_decl (tree decl)
 613 {
 614   symtab_node ret;
 615
 616   /* Builtins and local symbols are their own prevailing decl.  */
 617   if ((!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) || is_builtin_fn (decl))
 618     return decl;
 619
 620   /* DECL_ABSTRACTs are their own prevailng decl.  */
 621   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_ABSTRACT (decl))
 622     return decl;
 623
 624   /* Likewise builtins are their own prevailing decl.  This preserves
 625      non-builtin vs. builtin uses from compile-time.  */
 626   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
 627     return decl;
 628
 629   /* As an anoying special cases weakrefs are really static variables with
 630      EXTERNAL flag.  */
 631   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
 632     return decl;
 633
 634   /* Ensure DECL_ASSEMBLER_NAME will not set assembler name.  */
 635   gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
 636
 637   /* Walk through the list of candidates and return the one we merged to.  */
 638   ret = symtab_node_for_asm (DECL_ASSEMBLER_NAME (decl));
 639   if (!ret)
 640     return decl;
 641
 642   return ret->symbol.decl;
 643 }