gcc/lto-symtab.c

   1 /* LTO symbol table.
   2    Copyright 2009 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 "toplev.h"
  25 #include "tree.h"
  26 #include "gimple.h"
  27 #include "ggc.h"        /* lambda.h needs this */
  28 #include "lambda.h"     /* gcd */
  29 #include "hashtab.h"
  30 #include "plugin-api.h"
  31 #include "lto-streamer.h"
  32
  33 /* Vector to keep track of external variables we've seen so far.  */
  34 VEC(tree,gc) *lto_global_var_decls;
  35
  36 /* Symbol table entry.  */
  37
  38 struct GTY(()) lto_symtab_entry_def
  39 {
  40   /* The symbol table entry key, an IDENTIFIER.  */
  41   tree id;
  42   /* The symbol table entry, a DECL.  */
  43   tree decl;
  44   /* The cgraph node if decl is a function decl.  Filled in during the
  45      merging process.  */
  46   struct cgraph_node *node;
  47   /* The varpool node if decl is a variable decl.  Filled in during the
  48      merging process.  */
  49   struct varpool_node *vnode;
  50   /* LTO file-data and symbol resolution for this decl.  */
  51   struct lto_file_decl_data * GTY((skip (""))) file_data;
  52   enum ld_plugin_symbol_resolution resolution;
  53   /* Pointer to the next entry with the same key.  Before decl merging
  54      this links all symbols from the different TUs.  After decl merging
  55      this links merged but incompatible decls, thus all prevailing ones
  56      remaining.  */
  57   struct lto_symtab_entry_def *next;
  58 };
  59 typedef struct lto_symtab_entry_def *lto_symtab_entry_t;
  60
  61 /* A poor man's symbol table. This hashes identifier to prevailing DECL
  62    if there is one. */
  63
  64 static GTY ((if_marked ("lto_symtab_entry_marked_p"),
  65              param_is (struct lto_symtab_entry_def)))
  66   htab_t lto_symtab_identifiers;
  67
  68 /* Return the hash value of an lto_symtab_entry_t object pointed to by P.  */
  69
  70 static hashval_t
  71 lto_symtab_entry_hash (const void *p)
  72 {
  73   const struct lto_symtab_entry_def *base =
  74     (const struct lto_symtab_entry_def *) p;
  75   return htab_hash_string (IDENTIFIER_POINTER (base->id));
  76 }
  77
  78 /* Return non-zero if P1 and P2 points to lto_symtab_entry_def structs
  79    corresponding to the same symbol.  */
  80
  81 static int
  82 lto_symtab_entry_eq (const void *p1, const void *p2)
  83 {
  84   const struct lto_symtab_entry_def *base1 =
  85      (const struct lto_symtab_entry_def *) p1;
  86   const struct lto_symtab_entry_def *base2 =
  87      (const struct lto_symtab_entry_def *) p2;
  88   return (base1->id == base2->id);
  89 }
  90
  91 /* Returns non-zero if P points to an lto_symtab_entry_def struct that needs
  92    to be marked for GC.  */
  93
  94 static int
  95 lto_symtab_entry_marked_p (const void *p)
  96 {
  97   const struct lto_symtab_entry_def *base =
  98      (const struct lto_symtab_entry_def *) p;
  99
 100   /* Keep this only if the decl or the chain is marked.  */
 101   return (ggc_marked_p (base->decl)
 102           || (base->next && ggc_marked_p (base->next)));
 103 }
 104
 105 /* Lazily initialize resolution hash tables.  */
 106
 107 static void
 108 lto_symtab_maybe_init_hash_table (void)
 109 {
 110   if (lto_symtab_identifiers)
 111     return;
 112
 113   lto_symtab_identifiers =
 114     htab_create_ggc (1021, lto_symtab_entry_hash,
 115                      lto_symtab_entry_eq, NULL);
 116 }
 117
 118 /* Registers DECL with the LTO symbol table as having resolution RESOLUTION
 119    and read from FILE_DATA. */
 120
 121 void
 122 lto_symtab_register_decl (tree decl,
 123                           ld_plugin_symbol_resolution_t resolution,
 124                           struct lto_file_decl_data *file_data)
 125 {
 126   lto_symtab_entry_t new_entry;
 127   void **slot;
 128
 129   /* Check that declarations reaching this function do not have
 130      properties inconsistent with having external linkage.  If any of
 131      these asertions fail, then the object file reader has failed to
 132      detect these cases and issue appropriate error messages.  */
 133   gcc_assert (decl
 134               && TREE_PUBLIC (decl)
 135               && (TREE_CODE (decl) == VAR_DECL
 136                   || TREE_CODE (decl) == FUNCTION_DECL)
 137               && DECL_ASSEMBLER_NAME_SET_P (decl));
 138   if (TREE_CODE (decl) == VAR_DECL
 139       && DECL_INITIAL (decl))
 140     gcc_assert (!DECL_EXTERNAL (decl)
 141                 || (TREE_STATIC (decl) && TREE_READONLY (decl)));
 142   if (TREE_CODE (decl) == FUNCTION_DECL)
 143     gcc_assert (!DECL_ABSTRACT (decl));
 144
 145   new_entry = GGC_CNEW (struct lto_symtab_entry_def);
 146   new_entry->id = DECL_ASSEMBLER_NAME (decl);
 147   new_entry->decl = decl;
 148   new_entry->resolution = resolution;
 149   new_entry->file_data = file_data;
 150
 151   lto_symtab_maybe_init_hash_table ();
 152   slot = htab_find_slot (lto_symtab_identifiers, new_entry, INSERT);
 153   new_entry->next = (lto_symtab_entry_t) *slot;
 154   *slot = new_entry;
 155 }
 156
 157 /* Get the lto_symtab_entry_def struct associated with ID
 158    if there is one.  */
 159
 160 static lto_symtab_entry_t
 161 lto_symtab_get (tree id)
 162 {
 163   struct lto_symtab_entry_def temp;
 164   void **slot;
 165
 166   lto_symtab_maybe_init_hash_table ();
 167   temp.id = id;
 168   slot = htab_find_slot (lto_symtab_identifiers, &temp, NO_INSERT);
 169   return slot ? (lto_symtab_entry_t) *slot : NULL;
 170 }
 171
 172 /* Get the linker resolution for DECL.  */
 173
 174 enum ld_plugin_symbol_resolution
 175 lto_symtab_get_resolution (tree decl)
 176 {
 177   lto_symtab_entry_t e;
 178
 179   gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
 180
 181   e = lto_symtab_get (DECL_ASSEMBLER_NAME (decl));
 182   while (e && e->decl != decl)
 183     e = e->next;
 184   if (!e)
 185     return LDPR_UNKNOWN;
 186
 187   return e->resolution;
 188 }
 189
 190
 191 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
 192    all edges and removing the old node.  */
 193
 194 static void
 195 lto_cgraph_replace_node (struct cgraph_node *node,
 196                          struct cgraph_node *prevailing_node)
 197 {
 198   struct cgraph_edge *e, *next;
 199
 200   /* Merge node flags.  */
 201   if (node->needed)
 202     cgraph_mark_needed_node (prevailing_node);
 203   if (node->reachable)
 204     cgraph_mark_reachable_node (prevailing_node);
 205   if (node->address_taken)
 206     {
 207       gcc_assert (!prevailing_node->global.inlined_to);
 208       cgraph_mark_address_taken_node (prevailing_node);
 209     }
 210
 211   /* Redirect all incoming edges.  */
 212   for (e = node->callers; e; e = next)
 213     {
 214       next = e->next_caller;
 215       cgraph_redirect_edge_callee (e, prevailing_node);
 216     }
 217
 218   /* There are not supposed to be any outgoing edges from a node we
 219      replace.  Still this can happen for multiple instances of weak
 220      functions.  */
 221   for (e = node->callees; e; e = next)
 222     {
 223       next = e->next_callee;
 224       cgraph_remove_edge (e);
 225     }
 226
 227   if (node->same_body)
 228     {
 229       struct cgraph_node *alias;
 230
 231       for (alias = node->same_body; alias; alias = alias->next)
 232         if (DECL_ASSEMBLER_NAME_SET_P (alias->decl))
 233           {
 234             lto_symtab_entry_t se
 235               = lto_symtab_get (DECL_ASSEMBLER_NAME (alias->decl));
 236
 237             for (; se; se = se->next)
 238               if (se->node == node)
 239                 {
 240                   se->node = NULL;
 241                   break;
 242                 }
 243           }
 244     }
 245
 246   /* Finally remove the replaced node.  */
 247   cgraph_remove_node (node);
 248 }
 249
 250 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
 251    all edges and removing the old node.  */
 252
 253 static void
 254 lto_varpool_replace_node (struct varpool_node *vnode,
 255                           struct varpool_node *prevailing_node)
 256 {
 257   /* Merge node flags.  */
 258   if (vnode->needed)
 259     {
 260       gcc_assert (prevailing_node->analyzed);
 261       varpool_mark_needed_node (prevailing_node);
 262     }
 263   gcc_assert (!vnode->finalized || prevailing_node->finalized);
 264   gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
 265
 266   /* Finally remove the replaced node.  */
 267   varpool_remove_node (vnode);
 268 }
 269
 270 /* Merge two variable or function symbol table entries PREVAILING and ENTRY.
 271    Return false if the symbols are not fully compatible and a diagnostic
 272    should be emitted.  */
 273
 274 static bool
 275 lto_symtab_merge (lto_symtab_entry_t prevailing, lto_symtab_entry_t entry)
 276 {
 277   tree prevailing_decl = prevailing->decl;
 278   tree decl = entry->decl;
 279   tree prevailing_type, type;
 280
 281   /* Merge decl state in both directions, we may still end up using
 282      the new decl.  */
 283   TREE_ADDRESSABLE (prevailing_decl) |= TREE_ADDRESSABLE (decl);
 284   TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (prevailing_decl);
 285
 286   /* The linker may ask us to combine two incompatible symbols.
 287      Detect this case and notify the caller of required diagnostics.  */
 288
 289   if (TREE_CODE (decl) == FUNCTION_DECL)
 290     {
 291       if (TREE_TYPE (prevailing_decl) != TREE_TYPE (decl))
 292         /* If we don't have a merged type yet...sigh.  The linker
 293            wouldn't complain if the types were mismatched, so we
 294            probably shouldn't either.  Just use the type from
 295            whichever decl appears to be associated with the
 296            definition.  If for some odd reason neither decl is, the
 297            older one wins.  */
 298         (void) 0;
 299
 300       return true;
 301     }
 302
 303   /* Now we exclusively deal with VAR_DECLs.  */
 304
 305   /* Sharing a global symbol is a strong hint that two types are
 306      compatible.  We could use this information to complete
 307      incomplete pointed-to types more aggressively here, ignoring
 308      mismatches in both field and tag names.  It's difficult though
 309      to guarantee that this does not have side-effects on merging
 310      more compatible types from other translation units though.  */
 311
 312   /* We can tolerate differences in type qualification, the
 313      qualification of the prevailing definition will prevail.
 314      ???  In principle we might want to only warn for structurally
 315      incompatible types here, but unless we have protective measures
 316      for TBAA in place that would hide useful information.  */
 317   prevailing_type = TYPE_MAIN_VARIANT (TREE_TYPE (prevailing_decl));
 318   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
 319
 320   /* We have to register and fetch canonical types here as the global
 321      fixup process didn't yet run.  */
 322   prevailing_type = gimple_register_type (prevailing_type);
 323   type = gimple_register_type (type);
 324   if (prevailing_type != type)
 325     {
 326       if (COMPLETE_TYPE_P (type))
 327         return false;
 328
 329       /* If type is incomplete then avoid warnings in the cases
 330          that TBAA handles just fine.  */
 331
 332       if (TREE_CODE (prevailing_type) != TREE_CODE (type))
 333         return false;
 334
 335       if (TREE_CODE (prevailing_type) == ARRAY_TYPE)
 336         {
 337           tree tem1 = TREE_TYPE (prevailing_type);
 338           tree tem2 = TREE_TYPE (type);
 339           while (TREE_CODE (tem1) == ARRAY_TYPE
 340                  && TREE_CODE (tem2) == ARRAY_TYPE)
 341             {
 342               tem1 = TREE_TYPE (tem1);
 343               tem2 = TREE_TYPE (tem2);
 344             }
 345
 346           if (TREE_CODE (tem1) != TREE_CODE (tem2))
 347             return false;
 348
 349           if (gimple_register_type (tem1) != gimple_register_type (tem2))
 350             return false;
 351         }
 352
 353       /* Fallthru.  Compatible enough.  */
 354     }
 355
 356   /* ???  We might want to emit a warning here if type qualification
 357      differences were spotted.  Do not do this unconditionally though.  */
 358
 359   /* There is no point in comparing too many details of the decls here.
 360      The type compatibility checks or the completing of types has properly
 361      dealt with most issues.  */
 362
 363   /* The following should all not invoke fatal errors as in non-LTO
 364      mode the linker wouldn't complain either.  Just emit warnings.  */
 365
 366   /* Report a warning if user-specified alignments do not match.  */
 367   if ((DECL_USER_ALIGN (prevailing_decl) && DECL_USER_ALIGN (decl))
 368       && DECL_ALIGN (prevailing_decl) < DECL_ALIGN (decl))
 369     return false;
 370
 371   return true;
 372 }
 373
 374 /* Return true if the symtab entry E can be replaced by another symtab
 375    entry.  */
 376
 377 static bool
 378 lto_symtab_resolve_replaceable_p (lto_symtab_entry_t e)
 379 {
 380   if (DECL_EXTERNAL (e->decl)
 381       || DECL_COMDAT (e->decl)
 382       || DECL_WEAK (e->decl))
 383     return true;
 384
 385   if (TREE_CODE (e->decl) == VAR_DECL)
 386     return (DECL_COMMON (e->decl)
 387             || (!flag_no_common && !DECL_INITIAL (e->decl)));
 388
 389   return false;
 390 }
 391
 392 /* Return true if the symtab entry E can be the prevailing one.  */
 393
 394 static bool
 395 lto_symtab_resolve_can_prevail_p (lto_symtab_entry_t e)
 396 {
 397   /* The C++ frontend ends up neither setting TREE_STATIC nor
 398      DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
 399      So do not reject !TREE_STATIC here but only DECL_EXTERNAL.  */
 400   if (DECL_EXTERNAL (e->decl))
 401     return false;
 402
 403   /* For functions we need a non-discarded body.  */
 404   if (TREE_CODE (e->decl) == FUNCTION_DECL)
 405     return (e->node && e->node->analyzed);
 406
 407   /* A variable should have a size.  */
 408   else if (TREE_CODE (e->decl) == VAR_DECL)
 409     return (e->vnode && e->vnode->finalized);
 410
 411   gcc_unreachable ();
 412 }
 413
 414 /* Resolve the symbol with the candidates in the chain *SLOT and store
 415    their resolutions.  */
 416
 417 static void
 418 lto_symtab_resolve_symbols (void **slot)
 419 {
 420   lto_symtab_entry_t e;
 421   lto_symtab_entry_t prevailing = NULL;
 422
 423   /* Always set e->node so that edges are updated to reflect decl merging. */
 424   for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
 425     {
 426       if (TREE_CODE (e->decl) == FUNCTION_DECL)
 427         e->node = cgraph_get_node (e->decl);
 428       else if (TREE_CODE (e->decl) == VAR_DECL)
 429         e->vnode = varpool_get_node (e->decl);
 430     }
 431
 432   e = (lto_symtab_entry_t) *slot;
 433
 434   /* If the chain is already resolved there is nothing else to do.  */
 435   if (e->resolution != LDPR_UNKNOWN)
 436     return;
 437
 438   /* Find the single non-replaceable prevailing symbol and
 439      diagnose ODR violations.  */
 440   for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
 441     {
 442       if (!lto_symtab_resolve_can_prevail_p (e))
 443         {
 444           e->resolution = LDPR_RESOLVED_IR;
 445           continue;
 446         }
 447
 448       /* Set a default resolution - the final prevailing one will get
 449          adjusted later.  */
 450       e->resolution = LDPR_PREEMPTED_IR;
 451       if (!lto_symtab_resolve_replaceable_p (e))
 452         {
 453           if (prevailing)
 454             {
 455               error_at (DECL_SOURCE_LOCATION (e->decl),
 456                         "%qD has already been defined", e->decl);
 457               inform (DECL_SOURCE_LOCATION (prevailing->decl),
 458                       "previously defined here");
 459             }
 460           prevailing = e;
 461         }
 462     }
 463   if (prevailing)
 464     goto found;
 465
 466   /* Do a second round choosing one from the replaceable prevailing decls.  */
 467   for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
 468     {
 469       if (e->resolution != LDPR_PREEMPTED_IR)
 470         continue;
 471
 472       /* Choose the first function that can prevail as prevailing.  */
 473       if (TREE_CODE (e->decl) == FUNCTION_DECL)
 474         {
 475           prevailing = e;
 476           break;
 477         }
 478
 479       /* From variables that can prevail choose the largest one.  */
 480       if (!prevailing
 481           || tree_int_cst_lt (DECL_SIZE (prevailing->decl),
 482                               DECL_SIZE (e->decl)))
 483         prevailing = e;
 484     }
 485
 486   if (!prevailing)
 487     return;
 488
 489 found:
 490   if (TREE_CODE (prevailing->decl) == VAR_DECL
 491       && TREE_READONLY (prevailing->decl))
 492     prevailing->resolution = LDPR_PREVAILING_DEF_IRONLY;
 493   else
 494     prevailing->resolution = LDPR_PREVAILING_DEF;
 495 }
 496
 497 /* Merge all decls in the symbol table chain to the prevailing decl and
 498    issue diagnostics about type mismatches.  */
 499
 500 static void
 501 lto_symtab_merge_decls_2 (void **slot)
 502 {
 503   lto_symtab_entry_t prevailing, e;
 504   VEC(tree, heap) *mismatches = NULL;
 505   unsigned i;
 506   tree decl;
 507   bool diagnosed_p = false;
 508
 509   /* Nothing to do for a single entry.  */
 510   prevailing = (lto_symtab_entry_t) *slot;
 511   if (!prevailing->next)
 512     return;
 513
 514   /* Try to merge each entry with the prevailing one.  */
 515   for (e = prevailing->next; e; e = e->next)
 516     {
 517       if (!lto_symtab_merge (prevailing, e))
 518         VEC_safe_push (tree, heap, mismatches, e->decl);
 519     }
 520   if (VEC_empty (tree, mismatches))
 521     return;
 522
 523   /* Diagnose all mismatched re-declarations.  */
 524   for (i = 0; VEC_iterate (tree, mismatches, i, decl); ++i)
 525     {
 526       if (TREE_TYPE (prevailing->decl) != TREE_TYPE (decl))
 527         diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 0,
 528                                    "type of %qD does not match original "
 529                                    "declaration", decl);
 530
 531       else if ((DECL_USER_ALIGN (prevailing->decl) && DECL_USER_ALIGN (decl))
 532                && DECL_ALIGN (prevailing->decl) < DECL_ALIGN (decl))
 533         {
 534           diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 0,
 535                                      "alignment of %qD is bigger than "
 536                                      "original declaration", decl);
 537         }
 538     }
 539   if (diagnosed_p)
 540     inform (DECL_SOURCE_LOCATION (prevailing->decl),
 541             "previously declared here");
 542
 543   VEC_free (tree, heap, mismatches);
 544 }
 545
 546 /* Helper to process the decl chain for the symbol table entry *SLOT.  */
 547
 548 static int
 549 lto_symtab_merge_decls_1 (void **slot, void *data ATTRIBUTE_UNUSED)
 550 {
 551   lto_symtab_entry_t e, prevailing;
 552   bool diagnosed_p = false;
 553
 554   /* Compute the symbol resolutions.  This is a no-op when using the
 555      linker plugin.  */
 556   lto_symtab_resolve_symbols (slot);
 557
 558   /* Find the prevailing decl.  */
 559   for (prevailing = (lto_symtab_entry_t) *slot;
 560        prevailing
 561        && prevailing->resolution != LDPR_PREVAILING_DEF_IRONLY
 562        && prevailing->resolution != LDPR_PREVAILING_DEF;
 563        prevailing = prevailing->next)
 564     ;
 565
 566   /* Assert it's the only one.  */
 567   if (prevailing)
 568     for (e = prevailing->next; e; e = e->next)
 569       gcc_assert (e->resolution != LDPR_PREVAILING_DEF_IRONLY
 570                   && e->resolution != LDPR_PREVAILING_DEF);
 571
 572   /* If there's not a prevailing symbol yet it's an external reference.
 573      Happens a lot during ltrans.  Choose the first symbol with a
 574      cgraph or a varpool node.  */
 575   if (!prevailing)
 576     {
 577       prevailing = (lto_symtab_entry_t) *slot;
 578       /* For functions choose one with a cgraph node.  */
 579       if (TREE_CODE (prevailing->decl) == FUNCTION_DECL)
 580         while (!prevailing->node
 581                && prevailing->next)
 582           prevailing = prevailing->next;
 583       if (TREE_CODE (prevailing->decl) == VAR_DECL)
 584         while (!prevailing->vnode
 585                && prevailing->next)
 586           prevailing = prevailing->next;
 587     }
 588
 589   /* Move it first in the list.  */
 590   if ((lto_symtab_entry_t) *slot != prevailing)
 591     {
 592       for (e = (lto_symtab_entry_t) *slot; e->next != prevailing; e = e->next)
 593         ;
 594       e->next = prevailing->next;
 595       prevailing->next = (lto_symtab_entry_t) *slot;
 596       *slot = (void *) prevailing;
 597     }
 598
 599   /* Record the prevailing variable.  */
 600   if (TREE_CODE (prevailing->decl) == VAR_DECL)
 601     VEC_safe_push (tree, gc, lto_global_var_decls, prevailing->decl);
 602
 603   /* Diagnose mismatched objects.  */
 604   for (e = prevailing->next; e; e = e->next)
 605     {
 606       if (TREE_CODE (prevailing->decl) == TREE_CODE (e->decl))
 607         continue;
 608
 609       switch (TREE_CODE (prevailing->decl))
 610         {
 611         case VAR_DECL:
 612           gcc_assert (TREE_CODE (e->decl) == FUNCTION_DECL);
 613           error_at (DECL_SOURCE_LOCATION (e->decl),
 614                     "variable %qD redeclared as function", prevailing->decl);
 615           break;
 616
 617         case FUNCTION_DECL:
 618           gcc_assert (TREE_CODE (e->decl) == VAR_DECL);
 619           error_at (DECL_SOURCE_LOCATION (e->decl),
 620                     "function %qD redeclared as variable", prevailing->decl);
 621           break;
 622
 623         default:
 624           gcc_unreachable ();
 625         }
 626
 627       diagnosed_p = true;
 628     }
 629   if (diagnosed_p)
 630       inform (DECL_SOURCE_LOCATION (prevailing->decl),
 631               "previously declared here");
 632
 633   /* Register and adjust types of the entries.  */
 634   for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
 635     TREE_TYPE (e->decl) = gimple_register_type (TREE_TYPE (e->decl));
 636
 637   /* Merge the chain to the single prevailing decl and diagnose
 638      mismatches.  */
 639   lto_symtab_merge_decls_2 (slot);
 640
 641   /* Drop all but the prevailing decl from the symtab.  */
 642   if (TREE_CODE (prevailing->decl) != FUNCTION_DECL
 643       && TREE_CODE (prevailing->decl) != VAR_DECL)
 644     prevailing->next = NULL;
 645
 646   return 1;
 647 }
 648
 649 /* Resolve and merge all symbol table chains to a prevailing decl.  */
 650
 651 void
 652 lto_symtab_merge_decls (void)
 653 {
 654   lto_symtab_maybe_init_hash_table ();
 655   htab_traverse (lto_symtab_identifiers, lto_symtab_merge_decls_1, NULL);
 656 }
 657
 658 /* Helper to process the decl chain for the symbol table entry *SLOT.  */
 659
 660 static int
 661 lto_symtab_merge_cgraph_nodes_1 (void **slot, void *data ATTRIBUTE_UNUSED)
 662 {
 663   lto_symtab_entry_t e, prevailing = (lto_symtab_entry_t) *slot;
 664
 665   if (!prevailing->next)
 666     return 1;
 667
 668   /* Replace the cgraph node of each entry with the prevailing one.  */
 669   for (e = prevailing->next; e; e = e->next)
 670     {
 671       if (e->node != NULL)
 672         {
 673           if (e->node->decl != e->decl && e->node->same_body)
 674             {
 675               struct cgraph_node *alias;
 676
 677               for (alias = e->node->same_body; alias; alias = alias->next)
 678                 if (alias->decl == e->decl)
 679                   break;
 680               if (alias)
 681                 {
 682                   cgraph_remove_same_body_alias (alias);
 683                   continue;
 684                 }
 685             }
 686           lto_cgraph_replace_node (e->node, prevailing->node);
 687         }
 688       if (e->vnode != NULL)
 689         lto_varpool_replace_node (e->vnode, prevailing->vnode);
 690     }
 691
 692   /* Drop all but the prevailing decl from the symtab.  */
 693   prevailing->next = NULL;
 694
 695   return 1;
 696 }
 697
 698 /* Merge cgraph nodes according to the symbol merging done by
 699    lto_symtab_merge_decls.  */
 700
 701 void
 702 lto_symtab_merge_cgraph_nodes (void)
 703 {
 704   lto_symtab_maybe_init_hash_table ();
 705   htab_traverse (lto_symtab_identifiers, lto_symtab_merge_cgraph_nodes_1, NULL);
 706 }
 707
 708 /* Given the decl DECL, return the prevailing decl with the same name. */
 709
 710 tree
 711 lto_symtab_prevailing_decl (tree decl)
 712 {
 713   lto_symtab_entry_t ret;
 714
 715   /* Builtins and local symbols are their own prevailing decl.  */
 716   if (!TREE_PUBLIC (decl) || is_builtin_fn (decl))
 717     return decl;
 718
 719   /* DECL_ABSTRACTs are their own prevailng decl.  */
 720   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_ABSTRACT (decl))
 721     return decl;
 722
 723   /* Ensure DECL_ASSEMBLER_NAME will not set assembler name.  */
 724   gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
 725
 726   /* Walk through the list of candidates and return the one we merged to.  */
 727   ret = lto_symtab_get (DECL_ASSEMBLER_NAME (decl));
 728   if (!ret)
 729     return NULL_TREE;
 730
 731   return ret->decl;
 732 }
 733
 734 #include "gt-lto-symtab.h"