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   /* Redirect incomming references.  */
 218   ipa_clone_refering (prevailing_node, NULL, &node->ref_list);
 219
 220   if (node->same_body)
 221     {
 222       struct cgraph_node *alias;
 223
 224       for (alias = node->same_body; alias; alias = alias->next)
 225         if (DECL_ASSEMBLER_NAME_SET_P (alias->decl))
 226           {
 227             lto_symtab_entry_t se
 228               = lto_symtab_get (DECL_ASSEMBLER_NAME (alias->decl));
 229
 230             for (; se; se = se->next)
 231               if (se->node == node)
 232                 {
 233                   se->node = NULL;
 234                   break;
 235                 }
 236           }
 237     }
 238
 239   /* Finally remove the replaced node.  */
 240   cgraph_remove_node (node);
 241 }
 242
 243 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
 244    all edges and removing the old node.  */
 245
 246 static void
 247 lto_varpool_replace_node (struct varpool_node *vnode,
 248                           struct varpool_node *prevailing_node)
 249 {
 250   /* Merge node flags.  */
 251   if (vnode->needed)
 252     {
 253       gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
 254       varpool_mark_needed_node (prevailing_node);
 255     }
 256   /* Relink aliases.  */
 257   if (vnode->extra_name && !vnode->alias)
 258     {
 259       struct varpool_node *alias, *last;
 260       for (alias = vnode->extra_name;
 261            alias; alias = alias->next)
 262         {
 263           last = alias;
 264           alias->extra_name = prevailing_node;
 265         }
 266
 267       if (prevailing_node->extra_name)
 268         {
 269           last->next = prevailing_node->extra_name;
 270           prevailing_node->extra_name->prev = last;
 271         }
 272       prevailing_node->extra_name = vnode->extra_name;
 273       vnode->extra_name = NULL;
 274     }
 275   gcc_assert (!vnode->finalized || prevailing_node->finalized);
 276   gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
 277
 278   /* When replacing by an alias, the references goes to the original
 279      variable.  */
 280   if (prevailing_node->alias && prevailing_node->extra_name)
 281     prevailing_node = prevailing_node->extra_name;
 282   ipa_clone_refering (NULL, prevailing_node, &vnode->ref_list);
 283
 284   /* Finally remove the replaced node.  */
 285   varpool_remove_node (vnode);
 286 }
 287
 288 /* Merge two variable or function symbol table entries PREVAILING and ENTRY.
 289    Return false if the symbols are not fully compatible and a diagnostic
 290    should be emitted.  */
 291
 292 static bool
 293 lto_symtab_merge (lto_symtab_entry_t prevailing, lto_symtab_entry_t entry)
 294 {
 295   tree prevailing_decl = prevailing->decl;
 296   tree decl = entry->decl;
 297   tree prevailing_type, type;
 298
 299   /* Merge decl state in both directions, we may still end up using
 300      the new decl.  */
 301   TREE_ADDRESSABLE (prevailing_decl) |= TREE_ADDRESSABLE (decl);
 302   TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (prevailing_decl);
 303
 304   /* The linker may ask us to combine two incompatible symbols.
 305      Detect this case and notify the caller of required diagnostics.  */
 306
 307   if (TREE_CODE (decl) == FUNCTION_DECL)
 308     {
 309       if (TREE_TYPE (prevailing_decl) != TREE_TYPE (decl))
 310         /* If we don't have a merged type yet...sigh.  The linker
 311            wouldn't complain if the types were mismatched, so we
 312            probably shouldn't either.  Just use the type from
 313            whichever decl appears to be associated with the
 314            definition.  If for some odd reason neither decl is, the
 315            older one wins.  */
 316         (void) 0;
 317
 318       return true;
 319     }
 320
 321   /* Now we exclusively deal with VAR_DECLs.  */
 322
 323   /* Sharing a global symbol is a strong hint that two types are
 324      compatible.  We could use this information to complete
 325      incomplete pointed-to types more aggressively here, ignoring
 326      mismatches in both field and tag names.  It's difficult though
 327      to guarantee that this does not have side-effects on merging
 328      more compatible types from other translation units though.  */
 329
 330   /* We can tolerate differences in type qualification, the
 331      qualification of the prevailing definition will prevail.
 332      ???  In principle we might want to only warn for structurally
 333      incompatible types here, but unless we have protective measures
 334      for TBAA in place that would hide useful information.  */
 335   prevailing_type = TYPE_MAIN_VARIANT (TREE_TYPE (prevailing_decl));
 336   type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
 337
 338   /* We have to register and fetch canonical types here as the global
 339      fixup process didn't yet run.  */
 340   prevailing_type = gimple_register_type (prevailing_type);
 341   type = gimple_register_type (type);
 342   if (prevailing_type != type)
 343     {
 344       if (COMPLETE_TYPE_P (type))
 345         return false;
 346
 347       /* If type is incomplete then avoid warnings in the cases
 348          that TBAA handles just fine.  */
 349
 350       if (TREE_CODE (prevailing_type) != TREE_CODE (type))
 351         return false;
 352
 353       if (TREE_CODE (prevailing_type) == ARRAY_TYPE)
 354         {
 355           tree tem1 = TREE_TYPE (prevailing_type);
 356           tree tem2 = TREE_TYPE (type);
 357           while (TREE_CODE (tem1) == ARRAY_TYPE
 358                  && TREE_CODE (tem2) == ARRAY_TYPE)
 359             {
 360               tem1 = TREE_TYPE (tem1);
 361               tem2 = TREE_TYPE (tem2);
 362             }
 363
 364           if (TREE_CODE (tem1) != TREE_CODE (tem2))
 365             return false;
 366
 367           if (gimple_register_type (tem1) != gimple_register_type (tem2))
 368             return false;
 369         }
 370
 371       /* Fallthru.  Compatible enough.  */
 372     }
 373
 374   /* ???  We might want to emit a warning here if type qualification
 375      differences were spotted.  Do not do this unconditionally though.  */
 376
 377   /* There is no point in comparing too many details of the decls here.
 378      The type compatibility checks or the completing of types has properly
 379      dealt with most issues.  */
 380
 381   /* The following should all not invoke fatal errors as in non-LTO
 382      mode the linker wouldn't complain either.  Just emit warnings.  */
 383
 384   /* Report a warning if user-specified alignments do not match.  */
 385   if ((DECL_USER_ALIGN (prevailing_decl) && DECL_USER_ALIGN (decl))
 386       && DECL_ALIGN (prevailing_decl) < DECL_ALIGN (decl))
 387     return false;
 388
 389   return true;
 390 }
 391
 392 /* Return true if the symtab entry E can be replaced by another symtab
 393    entry.  */
 394
 395 static bool
 396 lto_symtab_resolve_replaceable_p (lto_symtab_entry_t e)
 397 {
 398   if (DECL_EXTERNAL (e->decl)
 399       || DECL_COMDAT (e->decl)
 400       || DECL_WEAK (e->decl))
 401     return true;
 402
 403   if (TREE_CODE (e->decl) == VAR_DECL)
 404     return (DECL_COMMON (e->decl)
 405             || (!flag_no_common && !DECL_INITIAL (e->decl)));
 406
 407   return false;
 408 }
 409
 410 /* Return true if the symtab entry E can be the prevailing one.  */
 411
 412 static bool
 413 lto_symtab_resolve_can_prevail_p (lto_symtab_entry_t e)
 414 {
 415   /* The C++ frontend ends up neither setting TREE_STATIC nor
 416      DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
 417      So do not reject !TREE_STATIC here but only DECL_EXTERNAL.  */
 418   if (DECL_EXTERNAL (e->decl))
 419     return false;
 420
 421   /* For functions we need a non-discarded body.  */
 422   if (TREE_CODE (e->decl) == FUNCTION_DECL)
 423     return (e->node && e->node->analyzed);
 424
 425   /* A variable should have a size.  */
 426   else if (TREE_CODE (e->decl) == VAR_DECL)
 427     {
 428       if (!e->vnode)
 429         return false;
 430       if (e->vnode->finalized)
 431         return true;
 432       return e->vnode->alias && e->vnode->extra_name->finalized;
 433     }
 434
 435   gcc_unreachable ();
 436 }
 437
 438 /* Resolve the symbol with the candidates in the chain *SLOT and store
 439    their resolutions.  */
 440
 441 static void
 442 lto_symtab_resolve_symbols (void **slot)
 443 {
 444   lto_symtab_entry_t e;
 445   lto_symtab_entry_t prevailing = NULL;
 446
 447   /* Always set e->node so that edges are updated to reflect decl merging. */
 448   for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
 449     {
 450       if (TREE_CODE (e->decl) == FUNCTION_DECL)
 451         e->node = cgraph_get_node (e->decl);
 452       else if (TREE_CODE (e->decl) == VAR_DECL)
 453         e->vnode = varpool_get_node (e->decl);
 454     }
 455
 456   e = (lto_symtab_entry_t) *slot;
 457
 458   /* If the chain is already resolved there is nothing else to do.  */
 459   if (e->resolution != LDPR_UNKNOWN)
 460     return;
 461
 462   /* Find the single non-replaceable prevailing symbol and
 463      diagnose ODR violations.  */
 464   for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
 465     {
 466       if (!lto_symtab_resolve_can_prevail_p (e))
 467         {
 468           e->resolution = LDPR_RESOLVED_IR;
 469           continue;
 470         }
 471
 472       /* Set a default resolution - the final prevailing one will get
 473          adjusted later.  */
 474       e->resolution = LDPR_PREEMPTED_IR;
 475       if (!lto_symtab_resolve_replaceable_p (e))
 476         {
 477           if (prevailing)
 478             {
 479               error_at (DECL_SOURCE_LOCATION (e->decl),
 480                         "%qD has already been defined", e->decl);
 481               inform (DECL_SOURCE_LOCATION (prevailing->decl),
 482                       "previously defined here");
 483             }
 484           prevailing = e;
 485         }
 486     }
 487   if (prevailing)
 488     goto found;
 489
 490   /* Do a second round choosing one from the replaceable prevailing decls.  */
 491   for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
 492     {
 493       if (e->resolution != LDPR_PREEMPTED_IR)
 494         continue;
 495
 496       /* Choose the first function that can prevail as prevailing.  */
 497       if (TREE_CODE (e->decl) == FUNCTION_DECL)
 498         {
 499           prevailing = e;
 500           break;
 501         }
 502
 503       /* From variables that can prevail choose the largest one.  */
 504       if (!prevailing
 505           || tree_int_cst_lt (DECL_SIZE (prevailing->decl),
 506                               DECL_SIZE (e->decl)))
 507         prevailing = e;
 508     }
 509
 510   if (!prevailing)
 511     return;
 512
 513 found:
 514   if (TREE_CODE (prevailing->decl) == VAR_DECL
 515       && TREE_READONLY (prevailing->decl))
 516     prevailing->resolution = LDPR_PREVAILING_DEF_IRONLY;
 517   else
 518     prevailing->resolution = LDPR_PREVAILING_DEF;
 519 }
 520
 521 /* Merge all decls in the symbol table chain to the prevailing decl and
 522    issue diagnostics about type mismatches.  */
 523
 524 static void
 525 lto_symtab_merge_decls_2 (void **slot)
 526 {
 527   lto_symtab_entry_t prevailing, e;
 528   VEC(tree, heap) *mismatches = NULL;
 529   unsigned i;
 530   tree decl;
 531   bool diagnosed_p = false;
 532
 533   /* Nothing to do for a single entry.  */
 534   prevailing = (lto_symtab_entry_t) *slot;
 535   if (!prevailing->next)
 536     return;
 537
 538   /* Try to merge each entry with the prevailing one.  */
 539   for (e = prevailing->next; e; e = e->next)
 540     {
 541       if (!lto_symtab_merge (prevailing, e))
 542         VEC_safe_push (tree, heap, mismatches, e->decl);
 543     }
 544   if (VEC_empty (tree, mismatches))
 545     return;
 546
 547   /* Diagnose all mismatched re-declarations.  */
 548   for (i = 0; VEC_iterate (tree, mismatches, i, decl); ++i)
 549     {
 550       if (TREE_TYPE (prevailing->decl) != TREE_TYPE (decl))
 551         diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 0,
 552                                    "type of %qD does not match original "
 553                                    "declaration", decl);
 554
 555       else if ((DECL_USER_ALIGN (prevailing->decl) && DECL_USER_ALIGN (decl))
 556                && DECL_ALIGN (prevailing->decl) < DECL_ALIGN (decl))
 557         {
 558           diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 0,
 559                                      "alignment of %qD is bigger than "
 560                                      "original declaration", decl);
 561         }
 562     }
 563   if (diagnosed_p)
 564     inform (DECL_SOURCE_LOCATION (prevailing->decl),
 565             "previously declared here");
 566
 567   VEC_free (tree, heap, mismatches);
 568 }
 569
 570 /* Helper to process the decl chain for the symbol table entry *SLOT.  */
 571
 572 static int
 573 lto_symtab_merge_decls_1 (void **slot, void *data ATTRIBUTE_UNUSED)
 574 {
 575   lto_symtab_entry_t e, prevailing;
 576   bool diagnosed_p = false;
 577
 578   /* Compute the symbol resolutions.  This is a no-op when using the
 579      linker plugin.  */
 580   lto_symtab_resolve_symbols (slot);
 581
 582   /* Find the prevailing decl.  */
 583   for (prevailing = (lto_symtab_entry_t) *slot;
 584        prevailing
 585        && prevailing->resolution != LDPR_PREVAILING_DEF_IRONLY
 586        && prevailing->resolution != LDPR_PREVAILING_DEF;
 587        prevailing = prevailing->next)
 588     ;
 589
 590   /* Assert it's the only one.  */
 591   if (prevailing)
 592     for (e = prevailing->next; e; e = e->next)
 593       gcc_assert (e->resolution != LDPR_PREVAILING_DEF_IRONLY
 594                   && e->resolution != LDPR_PREVAILING_DEF);
 595
 596   /* If there's not a prevailing symbol yet it's an external reference.
 597      Happens a lot during ltrans.  Choose the first symbol with a
 598      cgraph or a varpool node.  */
 599   if (!prevailing)
 600     {
 601       prevailing = (lto_symtab_entry_t) *slot;
 602       /* For functions choose one with a cgraph node.  */
 603       if (TREE_CODE (prevailing->decl) == FUNCTION_DECL)
 604         while (!prevailing->node
 605                && prevailing->next)
 606           prevailing = prevailing->next;
 607       /* For variables chose with a priority variant with vnode
 608          attached (i.e. from unit where external declaration of
 609          variable is actually used).
 610          When there are multiple variants, chose one with size.
 611          This is needed for C++ typeinfos, for example in
 612          lto/20081204-1 there are typeifos in both units, just
 613          one of them do have size.  */
 614       if (TREE_CODE (prevailing->decl) == VAR_DECL)
 615         {
 616           for (e = prevailing->next; e; e = e->next)
 617             if ((!prevailing->vnode && e->vnode)
 618                 || ((prevailing->vnode != NULL) == (e->vnode != NULL)
 619                     && !COMPLETE_TYPE_P (TREE_TYPE (prevailing->decl))
 620                     && COMPLETE_TYPE_P (TREE_TYPE (e->decl))))
 621               prevailing = e;
 622         }
 623     }
 624
 625   /* Move it first in the list.  */
 626   if ((lto_symtab_entry_t) *slot != prevailing)
 627     {
 628       for (e = (lto_symtab_entry_t) *slot; e->next != prevailing; e = e->next)
 629         ;
 630       e->next = prevailing->next;
 631       prevailing->next = (lto_symtab_entry_t) *slot;
 632       *slot = (void *) prevailing;
 633     }
 634
 635   /* Record the prevailing variable.  */
 636   if (TREE_CODE (prevailing->decl) == VAR_DECL)
 637     VEC_safe_push (tree, gc, lto_global_var_decls, prevailing->decl);
 638
 639   /* Diagnose mismatched objects.  */
 640   for (e = prevailing->next; e; e = e->next)
 641     {
 642       if (TREE_CODE (prevailing->decl) == TREE_CODE (e->decl))
 643         continue;
 644
 645       switch (TREE_CODE (prevailing->decl))
 646         {
 647         case VAR_DECL:
 648           gcc_assert (TREE_CODE (e->decl) == FUNCTION_DECL);
 649           error_at (DECL_SOURCE_LOCATION (e->decl),
 650                     "variable %qD redeclared as function", prevailing->decl);
 651           break;
 652
 653         case FUNCTION_DECL:
 654           gcc_assert (TREE_CODE (e->decl) == VAR_DECL);
 655           error_at (DECL_SOURCE_LOCATION (e->decl),
 656                     "function %qD redeclared as variable", prevailing->decl);
 657           break;
 658
 659         default:
 660           gcc_unreachable ();
 661         }
 662
 663       diagnosed_p = true;
 664     }
 665   if (diagnosed_p)
 666       inform (DECL_SOURCE_LOCATION (prevailing->decl),
 667               "previously declared here");
 668
 669   /* Register and adjust types of the entries.  */
 670   for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
 671     TREE_TYPE (e->decl) = gimple_register_type (TREE_TYPE (e->decl));
 672
 673   /* Merge the chain to the single prevailing decl and diagnose
 674      mismatches.  */
 675   lto_symtab_merge_decls_2 (slot);
 676
 677   /* Drop all but the prevailing decl from the symtab.  */
 678   if (TREE_CODE (prevailing->decl) != FUNCTION_DECL
 679       && TREE_CODE (prevailing->decl) != VAR_DECL)
 680     prevailing->next = NULL;
 681
 682   return 1;
 683 }
 684
 685 /* Resolve and merge all symbol table chains to a prevailing decl.  */
 686
 687 void
 688 lto_symtab_merge_decls (void)
 689 {
 690   lto_symtab_maybe_init_hash_table ();
 691   htab_traverse (lto_symtab_identifiers, lto_symtab_merge_decls_1, NULL);
 692 }
 693
 694 /* Helper to process the decl chain for the symbol table entry *SLOT.  */
 695
 696 static int
 697 lto_symtab_merge_cgraph_nodes_1 (void **slot, void *data ATTRIBUTE_UNUSED)
 698 {
 699   lto_symtab_entry_t e, prevailing = (lto_symtab_entry_t) *slot;
 700
 701   if (!prevailing->next)
 702     return 1;
 703
 704   /* Replace the cgraph node of each entry with the prevailing one.  */
 705   for (e = prevailing->next; e; e = e->next)
 706     {
 707       if (e->node != NULL)
 708         {
 709           if (e->node->decl != e->decl && e->node->same_body)
 710             {
 711               struct cgraph_node *alias;
 712
 713               for (alias = e->node->same_body; alias; alias = alias->next)
 714                 if (alias->decl == e->decl)
 715                   break;
 716               if (alias)
 717                 {
 718                   cgraph_remove_same_body_alias (alias);
 719                   continue;
 720                 }
 721             }
 722           lto_cgraph_replace_node (e->node, prevailing->node);
 723         }
 724       if (e->vnode != NULL)
 725         lto_varpool_replace_node (e->vnode, prevailing->vnode);
 726     }
 727
 728   /* Drop all but the prevailing decl from the symtab.  */
 729   prevailing->next = NULL;
 730
 731   return 1;
 732 }
 733
 734 /* Merge cgraph nodes according to the symbol merging done by
 735    lto_symtab_merge_decls.  */
 736
 737 void
 738 lto_symtab_merge_cgraph_nodes (void)
 739 {
 740   lto_symtab_maybe_init_hash_table ();
 741   htab_traverse (lto_symtab_identifiers, lto_symtab_merge_cgraph_nodes_1, NULL);
 742 }
 743
 744 /* Given the decl DECL, return the prevailing decl with the same name. */
 745
 746 tree
 747 lto_symtab_prevailing_decl (tree decl)
 748 {
 749   lto_symtab_entry_t ret;
 750
 751   /* Builtins and local symbols are their own prevailing decl.  */
 752   if (!TREE_PUBLIC (decl) || is_builtin_fn (decl))
 753     return decl;
 754
 755   /* DECL_ABSTRACTs are their own prevailng decl.  */
 756   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_ABSTRACT (decl))
 757     return decl;
 758
 759   /* Ensure DECL_ASSEMBLER_NAME will not set assembler name.  */
 760   gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
 761
 762   /* Walk through the list of candidates and return the one we merged to.  */
 763   ret = lto_symtab_get (DECL_ASSEMBLER_NAME (decl));
 764   if (!ret)
 765     return NULL_TREE;
 766
 767   return ret->decl;
 768 }
 769
 770 #include "gt-lto-symtab.h"