gcc/symtab.c

   1 /* Symbol table.
   2    Copyright (C) 2012-2013 Free Software Foundation, Inc.
   3    Contributed by Jan Hubicka
   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 "tm.h"
  25 #include "tree.h"
  26 #include "tree-inline.h"
  27 #include "langhooks.h"
  28 #include "hashtab.h"
  29 #include "ggc.h"
  30 #include "cgraph.h"
  31 #include "diagnostic.h"
  32 #include "timevar.h"
  33 #include "lto-streamer.h"
  34 #include "rtl.h"
  35
  36 const char * const ld_plugin_symbol_resolution_names[]=
  37 {
  38   "",
  39   "undef",
  40   "prevailing_def",
  41   "prevailing_def_ironly",
  42   "preempted_reg",
  43   "preempted_ir",
  44   "resolved_ir",
  45   "resolved_exec",
  46   "resolved_dyn",
  47   "prevailing_def_ironly_exp"
  48 };
  49
  50 /* Hash table used to convert declarations into nodes.  */
  51 static GTY((param_is (union symtab_node_def))) htab_t symtab_hash;
  52 /* Hash table used to convert assembler names into nodes.  */
  53 static GTY((param_is (union symtab_node_def))) htab_t assembler_name_hash;
  54
  55 /* Linked list of symbol table nodes.  */
  56 symtab_node symtab_nodes;
  57
  58 /* The order index of the next symtab node to be created.  This is
  59    used so that we can sort the cgraph nodes in order by when we saw
  60    them, to support -fno-toplevel-reorder.  */
  61 int symtab_order;
  62
  63 /* Returns a hash code for P.  */
  64
  65 static hashval_t
  66 hash_node (const void *p)
  67 {
  68   const_symtab_node n = (const_symtab_node ) p;
  69   return (hashval_t) DECL_UID (n->symbol.decl);
  70 }
  71
  72
  73 /* Returns nonzero if P1 and P2 are equal.  */
  74
  75 static int
  76 eq_node (const void *p1, const void *p2)
  77 {
  78   const_symtab_node n1 = (const_symtab_node) p1;
  79   const_symtab_node n2 = (const_symtab_node) p2;
  80   return DECL_UID (n1->symbol.decl) == DECL_UID (n2->symbol.decl);
  81 }
  82
  83 /* Returns a hash code for P.  */
  84
  85 static hashval_t
  86 hash_node_by_assembler_name (const void *p)
  87 {
  88   const_symtab_node n = (const_symtab_node) p;
  89   return (hashval_t) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n->symbol.decl));
  90 }
  91
  92 /* Returns nonzero if P1 and P2 are equal.  */
  93
  94 static int
  95 eq_assembler_name (const void *p1, const void *p2)
  96 {
  97   const_symtab_node n1 = (const_symtab_node) p1;
  98   const_tree name = (const_tree)p2;
  99   return (decl_assembler_name_equal (n1->symbol.decl, name));
 100 }
 101
 102 /* Insert NODE to assembler name hash.  */
 103
 104 static void
 105 insert_to_assembler_name_hash (symtab_node node, bool with_clones)
 106 {
 107   if (is_a <varpool_node> (node) && DECL_HARD_REGISTER (node->symbol.decl))
 108     return;
 109   gcc_checking_assert (!node->symbol.previous_sharing_asm_name
 110                        && !node->symbol.next_sharing_asm_name);
 111   if (assembler_name_hash)
 112     {
 113       void **aslot;
 114       struct cgraph_node *cnode;
 115       tree decl = node->symbol.decl;
 116
 117       tree name = DECL_ASSEMBLER_NAME (node->symbol.decl);
 118
 119       aslot = htab_find_slot_with_hash (assembler_name_hash, name,
 120                                         decl_assembler_name_hash (name),
 121                                         INSERT);
 122       gcc_assert (*aslot != node);
 123       node->symbol.next_sharing_asm_name = (symtab_node)*aslot;
 124       if (*aslot != NULL)
 125         ((symtab_node)*aslot)->symbol.previous_sharing_asm_name = node;
 126       *aslot = node;
 127
 128       /* Update also possible inline clones sharing a decl.  */
 129       cnode = dyn_cast <cgraph_node> (node);
 130       if (cnode && cnode->clones && with_clones)
 131         for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
 132           if (cnode->symbol.decl == decl)
 133             insert_to_assembler_name_hash ((symtab_node) cnode, true);
 134     }
 135
 136 }
 137
 138 /* Remove NODE from assembler name hash.  */
 139
 140 static void
 141 unlink_from_assembler_name_hash (symtab_node node, bool with_clones)
 142 {
 143   if (assembler_name_hash)
 144     {
 145       struct cgraph_node *cnode;
 146       tree decl = node->symbol.decl;
 147
 148       if (node->symbol.next_sharing_asm_name)
 149         node->symbol.next_sharing_asm_name->symbol.previous_sharing_asm_name
 150           = node->symbol.previous_sharing_asm_name;
 151       if (node->symbol.previous_sharing_asm_name)
 152         {
 153           node->symbol.previous_sharing_asm_name->symbol.next_sharing_asm_name
 154             = node->symbol.next_sharing_asm_name;
 155         }
 156       else
 157         {
 158           tree name = DECL_ASSEMBLER_NAME (node->symbol.decl);
 159           void **slot;
 160           slot = htab_find_slot_with_hash (assembler_name_hash, name,
 161                                            decl_assembler_name_hash (name),
 162                                            NO_INSERT);
 163           gcc_assert (*slot == node);
 164           if (!node->symbol.next_sharing_asm_name)
 165             htab_clear_slot (assembler_name_hash, slot);
 166           else
 167             *slot = node->symbol.next_sharing_asm_name;
 168         }
 169       node->symbol.next_sharing_asm_name = NULL;
 170       node->symbol.previous_sharing_asm_name = NULL;
 171
 172       /* Update also possible inline clones sharing a decl.  */
 173       cnode = dyn_cast <cgraph_node> (node);
 174       if (cnode && cnode->clones && with_clones)
 175         for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
 176           if (cnode->symbol.decl == decl)
 177             unlink_from_assembler_name_hash ((symtab_node) cnode, true);
 178     }
 179 }
 180
 181 /* Arrange node to be first in its entry of assembler_name_hash.  */
 182
 183 void
 184 symtab_prevail_in_asm_name_hash (symtab_node node)
 185 {
 186   unlink_from_assembler_name_hash (node, false);
 187   insert_to_assembler_name_hash (node, false);
 188 }
 189
 190
 191 /* Add node into symbol table.  This function is not used directly, but via
 192    cgraph/varpool node creation routines.  */
 193
 194 void
 195 symtab_register_node (symtab_node node)
 196 {
 197   struct symtab_node_base key;
 198   symtab_node *slot;
 199
 200   node->symbol.next = symtab_nodes;
 201   node->symbol.previous = NULL;
 202   if (symtab_nodes)
 203     symtab_nodes->symbol.previous = node;
 204   symtab_nodes = node;
 205
 206   if (!symtab_hash)
 207     symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
 208   key.decl = node->symbol.decl;
 209   slot = (symtab_node *) htab_find_slot (symtab_hash, &key, INSERT);
 210   if (*slot == NULL)
 211     *slot = node;
 212
 213   ipa_empty_ref_list (&node->symbol.ref_list);
 214
 215   node->symbol.order = symtab_order++;
 216
 217   /* Be sure to do this last; C++ FE might create new nodes via
 218      DECL_ASSEMBLER_NAME langhook!  */
 219   insert_to_assembler_name_hash (node, false);
 220 }
 221
 222 /* Make NODE to be the one symtab hash is pointing to.  Used when reshaping tree
 223    of inline clones.  */
 224
 225 void
 226 symtab_insert_node_to_hashtable (symtab_node node)
 227 {
 228   struct symtab_node_base key;
 229   symtab_node *slot;
 230
 231   if (!symtab_hash)
 232     symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
 233   key.decl = node->symbol.decl;
 234   slot = (symtab_node *) htab_find_slot (symtab_hash, &key, INSERT);
 235   *slot = node;
 236 }
 237
 238 /* Remove node from symbol table.  This function is not used directly, but via
 239    cgraph/varpool node removal routines.  */
 240
 241 void
 242 symtab_unregister_node (symtab_node node)
 243 {
 244   void **slot;
 245   ipa_remove_all_references (&node->symbol.ref_list);
 246   ipa_remove_all_referring (&node->symbol.ref_list);
 247
 248   if (node->symbol.same_comdat_group)
 249     {
 250       symtab_node prev;
 251       for (prev = node->symbol.same_comdat_group;
 252            prev->symbol.same_comdat_group != node;
 253            prev = prev->symbol.same_comdat_group)
 254         ;
 255       if (node->symbol.same_comdat_group == prev)
 256         prev->symbol.same_comdat_group = NULL;
 257       else
 258         prev->symbol.same_comdat_group = node->symbol.same_comdat_group;
 259       node->symbol.same_comdat_group = NULL;
 260     }
 261
 262   if (node->symbol.previous)
 263     node->symbol.previous->symbol.next = node->symbol.next;
 264   else
 265     symtab_nodes = node->symbol.next;
 266   if (node->symbol.next)
 267     node->symbol.next->symbol.previous = node->symbol.previous;
 268   node->symbol.next = NULL;
 269   node->symbol.previous = NULL;
 270
 271   slot = htab_find_slot (symtab_hash, node, NO_INSERT);
 272   if (*slot == node)
 273     {
 274       symtab_node replacement_node = NULL;
 275       if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 276         replacement_node = (symtab_node)cgraph_find_replacement_node (cnode);
 277       if (!replacement_node)
 278         htab_clear_slot (symtab_hash, slot);
 279       else
 280         *slot = replacement_node;
 281     }
 282   unlink_from_assembler_name_hash (node, false);
 283 }
 284
 285 /* Return symbol table node associated with DECL, if any,
 286    and NULL otherwise.  */
 287
 288 symtab_node
 289 symtab_get_node (const_tree decl)
 290 {
 291   symtab_node *slot;
 292   struct symtab_node_base key;
 293
 294   gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
 295                        || (TREE_CODE (decl) == VAR_DECL
 296                            && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
 297                                || in_lto_p)));
 298
 299   if (!symtab_hash)
 300     return NULL;
 301
 302   key.decl = CONST_CAST2 (tree, const_tree, decl);
 303
 304   slot = (symtab_node *) htab_find_slot (symtab_hash, &key,
 305                                          NO_INSERT);
 306
 307   if (slot)
 308     return *slot;
 309   return NULL;
 310 }
 311
 312 /* Remove symtab NODE from the symbol table.  */
 313
 314 void
 315 symtab_remove_node (symtab_node node)
 316 {
 317   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 318     cgraph_remove_node (cnode);
 319   else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
 320     varpool_remove_node (vnode);
 321 }
 322
 323 /* Initalize asm name hash unless.  */
 324
 325 void
 326 symtab_initialize_asm_name_hash (void)
 327 {
 328   symtab_node node;
 329   if (!assembler_name_hash)
 330     {
 331       assembler_name_hash =
 332         htab_create_ggc (10, hash_node_by_assembler_name, eq_assembler_name,
 333                          NULL);
 334       FOR_EACH_SYMBOL (node)
 335         insert_to_assembler_name_hash (node, false);
 336     }
 337 }
 338
 339 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
 340    Return NULL if there's no such node.  */
 341
 342 symtab_node
 343 symtab_node_for_asm (const_tree asmname)
 344 {
 345   symtab_node node;
 346   void **slot;
 347
 348   symtab_initialize_asm_name_hash ();
 349   slot = htab_find_slot_with_hash (assembler_name_hash, asmname,
 350                                    decl_assembler_name_hash (asmname),
 351                                    NO_INSERT);
 352
 353   if (slot)
 354     {
 355       node = (symtab_node) *slot;
 356       return node;
 357     }
 358   return NULL;
 359 }
 360
 361 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables.  */
 362
 363 void
 364 change_decl_assembler_name (tree decl, tree name)
 365 {
 366   symtab_node node = NULL;
 367
 368   /* We can have user ASM names on things, like global register variables, that
 369      are not in the symbol table.  */
 370   if ((TREE_CODE (decl) == VAR_DECL
 371        && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
 372       || TREE_CODE (decl) == FUNCTION_DECL)
 373     node = symtab_get_node (decl);
 374   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 375     {
 376       SET_DECL_ASSEMBLER_NAME (decl, name);
 377       if (node)
 378         insert_to_assembler_name_hash (node, true);
 379     }
 380   else
 381     {
 382       if (name == DECL_ASSEMBLER_NAME (decl))
 383         return;
 384
 385       if (node)
 386         unlink_from_assembler_name_hash (node, true);
 387       if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
 388           && DECL_RTL_SET_P (decl))
 389         warning (0, "%D renamed after being referenced in assembly", decl);
 390
 391       SET_DECL_ASSEMBLER_NAME (decl, name);
 392       if (node)
 393         insert_to_assembler_name_hash (node, true);
 394     }
 395 }
 396
 397 /* Add NEW_ to the same comdat group that OLD is in.  */
 398
 399 void
 400 symtab_add_to_same_comdat_group (symtab_node new_node,
 401                                  symtab_node old_node)
 402 {
 403   gcc_assert (DECL_ONE_ONLY (old_node->symbol.decl));
 404   gcc_assert (!new_node->symbol.same_comdat_group);
 405   gcc_assert (new_node != old_node);
 406
 407   DECL_COMDAT_GROUP (new_node->symbol.decl) = DECL_COMDAT_GROUP (old_node->symbol.decl);
 408   new_node->symbol.same_comdat_group = old_node;
 409   if (!old_node->symbol.same_comdat_group)
 410     old_node->symbol.same_comdat_group = new_node;
 411   else
 412     {
 413       symtab_node n;
 414       for (n = old_node->symbol.same_comdat_group;
 415            n->symbol.same_comdat_group != old_node;
 416            n = n->symbol.same_comdat_group)
 417         ;
 418       n->symbol.same_comdat_group = new_node;
 419     }
 420 }
 421
 422 /* Dissolve the same_comdat_group list in which NODE resides.  */
 423
 424 void
 425 symtab_dissolve_same_comdat_group_list (symtab_node node)
 426 {
 427   symtab_node n = node, next;
 428
 429   if (!node->symbol.same_comdat_group)
 430     return;
 431   do
 432     {
 433       next = n->symbol.same_comdat_group;
 434       n->symbol.same_comdat_group = NULL;
 435       n = next;
 436     }
 437   while (n != node);
 438 }
 439
 440 /* Return printable assembler name of NODE.
 441    This function is used only for debugging.  When assembler name
 442    is unknown go with identifier name.  */
 443
 444 const char *
 445 symtab_node_asm_name (symtab_node node)
 446 {
 447   if (!DECL_ASSEMBLER_NAME_SET_P (node->symbol.decl))
 448     return lang_hooks.decl_printable_name (node->symbol.decl, 2);
 449   return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->symbol.decl));
 450 }
 451
 452 /* Return printable identifier name.  */
 453
 454 const char *
 455 symtab_node_name (symtab_node node)
 456 {
 457   return lang_hooks.decl_printable_name (node->symbol.decl, 2);
 458 }
 459
 460 static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
 461
 462 /* Dump base fields of symtab nodes.  Not to be used directly.  */
 463
 464 void
 465 dump_symtab_base (FILE *f, symtab_node node)
 466 {
 467   static const char * const visibility_types[] = {
 468     "default", "protected", "hidden", "internal"
 469   };
 470
 471   fprintf (f, "%s/%i (%s)",
 472            symtab_node_asm_name (node),
 473            node->symbol.order,
 474            symtab_node_name (node));
 475   dump_addr (f, " @", (void *)node);
 476   fprintf (f, "\n  Type: %s", symtab_type_names[node->symbol.type]);
 477
 478   if (node->symbol.definition)
 479     fprintf (f, " definition");
 480   if (node->symbol.analyzed)
 481     fprintf (f, " analyzed");
 482   if (node->symbol.alias)
 483     fprintf (f, " alias");
 484   if (node->symbol.cpp_implicit_alias)
 485     fprintf (f, " cpp_implicit_alias");
 486   if (node->symbol.alias_target)
 487     fprintf (f, " target:%s",
 488              DECL_P (node->symbol.alias_target)
 489              ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
 490                                      (node->symbol.alias_target))
 491              : IDENTIFIER_POINTER (node->symbol.alias_target));
 492   fprintf (f, "\n  Visibility:");
 493   if (node->symbol.in_other_partition)
 494     fprintf (f, " in_other_partition");
 495   if (node->symbol.used_from_other_partition)
 496     fprintf (f, " used_from_other_partition");
 497   if (node->symbol.force_output)
 498     fprintf (f, " force_output");
 499   if (node->symbol.forced_by_abi)
 500     fprintf (f, " forced_by_abi");
 501   if (node->symbol.resolution != LDPR_UNKNOWN)
 502     fprintf (f, " %s",
 503              ld_plugin_symbol_resolution_names[(int)node->symbol.resolution]);
 504   if (TREE_ASM_WRITTEN (node->symbol.decl))
 505     fprintf (f, " asm_written");
 506   if (DECL_EXTERNAL (node->symbol.decl))
 507     fprintf (f, " external");
 508   if (TREE_PUBLIC (node->symbol.decl))
 509     fprintf (f, " public");
 510   if (DECL_COMMON (node->symbol.decl))
 511     fprintf (f, " common");
 512   if (DECL_WEAK (node->symbol.decl))
 513     fprintf (f, " weak");
 514   if (DECL_DLLIMPORT_P (node->symbol.decl))
 515     fprintf (f, " dll_import");
 516   if (DECL_COMDAT (node->symbol.decl))
 517     fprintf (f, " comdat");
 518   if (DECL_COMDAT_GROUP (node->symbol.decl))
 519     fprintf (f, " comdat_group:%s",
 520              IDENTIFIER_POINTER (DECL_COMDAT_GROUP (node->symbol.decl)));
 521   if (DECL_ONE_ONLY (node->symbol.decl))
 522     fprintf (f, " one_only");
 523   if (DECL_SECTION_NAME (node->symbol.decl))
 524     fprintf (f, " section_name:%s",
 525              TREE_STRING_POINTER (DECL_SECTION_NAME (node->symbol.decl)));
 526   if (DECL_VISIBILITY_SPECIFIED (node->symbol.decl))
 527     fprintf (f, " visibility_specified");
 528   if (DECL_VISIBILITY (node->symbol.decl))
 529     fprintf (f, " visibility:%s",
 530              visibility_types [DECL_VISIBILITY (node->symbol.decl)]);
 531   if (DECL_VIRTUAL_P (node->symbol.decl))
 532     fprintf (f, " virtual");
 533   if (DECL_ARTIFICIAL (node->symbol.decl))
 534     fprintf (f, " artificial");
 535   if (TREE_CODE (node->symbol.decl) == FUNCTION_DECL)
 536     {
 537       if (DECL_STATIC_CONSTRUCTOR (node->symbol.decl))
 538         fprintf (f, " constructor");
 539       if (DECL_STATIC_DESTRUCTOR (node->symbol.decl))
 540         fprintf (f, " destructor");
 541     }
 542   fprintf (f, "\n");
 543
 544   if (node->symbol.same_comdat_group)
 545     fprintf (f, "  Same comdat group as: %s/%i\n",
 546              symtab_node_asm_name (node->symbol.same_comdat_group),
 547              node->symbol.same_comdat_group->symbol.order);
 548   if (node->symbol.next_sharing_asm_name)
 549     fprintf (f, "  next sharing asm name: %i\n",
 550              node->symbol.next_sharing_asm_name->symbol.order);
 551   if (node->symbol.previous_sharing_asm_name)
 552     fprintf (f, "  previous sharing asm name: %i\n",
 553              node->symbol.previous_sharing_asm_name->symbol.order);
 554
 555   if (node->symbol.address_taken)
 556     fprintf (f, "  Address is taken.\n");
 557   if (node->symbol.aux)
 558     {
 559       fprintf (f, "  Aux:");
 560       dump_addr (f, " @", (void *)node->symbol.aux);
 561     }
 562
 563   fprintf (f, "  References: ");
 564   ipa_dump_references (f, &node->symbol.ref_list);
 565   fprintf (f, "  Referring: ");
 566   ipa_dump_referring (f, &node->symbol.ref_list);
 567   if (node->symbol.lto_file_data)
 568     fprintf (f, "  Read from file: %s\n",
 569              node->symbol.lto_file_data->file_name);
 570 }
 571
 572 /* Dump symtab node.  */
 573
 574 void
 575 dump_symtab_node (FILE *f, symtab_node node)
 576 {
 577   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 578     dump_cgraph_node (f, cnode);
 579   else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
 580     dump_varpool_node (f, vnode);
 581 }
 582
 583 /* Dump symbol table.  */
 584
 585 void
 586 dump_symtab (FILE *f)
 587 {
 588   symtab_node node;
 589   fprintf (f, "Symbol table:\n\n");
 590   FOR_EACH_SYMBOL (node)
 591     dump_symtab_node (f, node);
 592 }
 593
 594 /* Dump symtab node NODE to stderr.  */
 595
 596 DEBUG_FUNCTION void
 597 debug_symtab_node (symtab_node node)
 598 {
 599   dump_symtab_node (stderr, node);
 600 }
 601
 602 /* Dump symbol table to stderr.  */
 603
 604 DEBUG_FUNCTION void
 605 debug_symtab (void)
 606 {
 607   dump_symtab (stderr);
 608 }
 609
 610 /* Verify common part of symtab nodes.  */
 611
 612 DEBUG_FUNCTION bool
 613 verify_symtab_base (symtab_node node)
 614 {
 615   bool error_found = false;
 616   symtab_node hashed_node;
 617
 618   if (is_a <cgraph_node> (node))
 619     {
 620       if (TREE_CODE (node->symbol.decl) != FUNCTION_DECL)
 621         {
 622           error ("function symbol is not function");
 623           error_found = true;
 624         }
 625     }
 626   else if (is_a <varpool_node> (node))
 627     {
 628       if (TREE_CODE (node->symbol.decl) != VAR_DECL)
 629         {
 630           error ("variable symbol is not variable");
 631           error_found = true;
 632         }
 633     }
 634   else
 635     {
 636       error ("node has unknown type");
 637       error_found = true;
 638     }
 639
 640   hashed_node = symtab_get_node (node->symbol.decl);
 641   if (!hashed_node)
 642     {
 643       error ("node not found in symtab decl hashtable");
 644       error_found = true;
 645     }
 646   if (assembler_name_hash)
 647     {
 648       hashed_node = symtab_node_for_asm (DECL_ASSEMBLER_NAME (node->symbol.decl));
 649       if (hashed_node && hashed_node->symbol.previous_sharing_asm_name)
 650         {
 651           error ("assembler name hash list corrupted");
 652           error_found = true;
 653         }
 654       while (hashed_node)
 655         {
 656           if (hashed_node == node)
 657             break;
 658           hashed_node = hashed_node->symbol.next_sharing_asm_name;
 659         }
 660       if (!hashed_node
 661           && !(is_a <varpool_node> (node)
 662                || DECL_HARD_REGISTER (node->symbol.decl)))
 663         {
 664           error ("node not found in symtab assembler name hash");
 665           error_found = true;
 666         }
 667     }
 668   if (node->symbol.previous_sharing_asm_name
 669       && node->symbol.previous_sharing_asm_name->symbol.next_sharing_asm_name != node)
 670     {
 671       error ("double linked list of assembler names corrupted");
 672       error_found = true;
 673     }
 674   if (node->symbol.analyzed && !node->symbol.definition)
 675     {
 676       error ("node is analyzed byt it is not a definition");
 677       error_found = true;
 678     }
 679   if (node->symbol.cpp_implicit_alias && !node->symbol.alias)
 680     {
 681       error ("node is alias but not implicit alias");
 682       error_found = true;
 683     }
 684   if (node->symbol.alias && !node->symbol.definition
 685       && !lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
 686     {
 687       error ("node is alias but not definition");
 688       error_found = true;
 689     }
 690   if (node->symbol.same_comdat_group)
 691     {
 692       symtab_node n = node->symbol.same_comdat_group;
 693
 694       if (!DECL_ONE_ONLY (n->symbol.decl))
 695         {
 696           error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
 697           error_found = true;
 698         }
 699       if (n->symbol.type != node->symbol.type)
 700         {
 701           error ("mixing different types of symbol in same comdat groups is not supported");
 702           error_found = true;
 703         }
 704       if (n == node)
 705         {
 706           error ("node is alone in a comdat group");
 707           error_found = true;
 708         }
 709       do
 710         {
 711           if (!n->symbol.same_comdat_group)
 712             {
 713               error ("same_comdat_group is not a circular list");
 714               error_found = true;
 715               break;
 716             }
 717           n = n->symbol.same_comdat_group;
 718         }
 719       while (n != node);
 720     }
 721   return error_found;
 722 }
 723
 724 /* Verify consistency of NODE.  */
 725
 726 DEBUG_FUNCTION void
 727 verify_symtab_node (symtab_node node)
 728 {
 729   if (seen_error ())
 730     return;
 731
 732   timevar_push (TV_CGRAPH_VERIFY);
 733   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 734     verify_cgraph_node (cnode);
 735   else
 736     if (verify_symtab_base (node))
 737       {
 738         dump_symtab_node (stderr, node);
 739         internal_error ("verify_symtab_node failed");
 740       }
 741   timevar_pop (TV_CGRAPH_VERIFY);
 742 }
 743
 744 /* Verify symbol table for internal consistency.  */
 745
 746 DEBUG_FUNCTION void
 747 verify_symtab (void)
 748 {
 749   symtab_node node;
 750   FOR_EACH_SYMBOL (node)
 751    verify_symtab_node (node);
 752 }
 753
 754 /* Return true when RESOLUTION indicate that linker will use
 755    the symbol from non-LTO object files.  */
 756
 757 bool
 758 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
 759 {
 760   return (resolution == LDPR_PREVAILING_DEF
 761           || resolution == LDPR_PREEMPTED_REG
 762           || resolution == LDPR_RESOLVED_EXEC
 763           || resolution == LDPR_RESOLVED_DYN);
 764 }
 765
 766 /* Return true when NODE is known to be used from other (non-LTO) object file.
 767    Known only when doing LTO via linker plugin.  */
 768
 769 bool
 770 symtab_used_from_object_file_p (symtab_node node)
 771 {
 772   if (!TREE_PUBLIC (node->symbol.decl) || DECL_EXTERNAL (node->symbol.decl))
 773     return false;
 774   if (resolution_used_from_other_file_p (node->symbol.resolution))
 775     return true;
 776   return false;
 777 }
 778
 779 /* Make DECL local.  FIXME: We shouldn't need to mess with rtl this early,
 780    but other code such as notice_global_symbol generates rtl.  */
 781
 782 void
 783 symtab_make_decl_local (tree decl)
 784 {
 785   rtx rtl, symbol;
 786
 787   if (TREE_CODE (decl) == VAR_DECL)
 788     DECL_COMMON (decl) = 0;
 789   else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 790
 791   if (DECL_ONE_ONLY (decl) || DECL_COMDAT (decl))
 792     {
 793       DECL_SECTION_NAME (decl) = 0;
 794       DECL_COMDAT (decl) = 0;
 795     }
 796   DECL_COMDAT_GROUP (decl) = 0;
 797   DECL_WEAK (decl) = 0;
 798   DECL_EXTERNAL (decl) = 0;
 799   DECL_VISIBILITY_SPECIFIED (decl) = 0;
 800   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 801   TREE_PUBLIC (decl) = 0;
 802   DECL_VISIBILITY_SPECIFIED (decl) = 0;
 803   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 804   if (!DECL_RTL_SET_P (decl))
 805     return;
 806
 807   /* Update rtl flags.  */
 808   make_decl_rtl (decl);
 809
 810   rtl = DECL_RTL (decl);
 811   if (!MEM_P (rtl))
 812     return;
 813
 814   symbol = XEXP (rtl, 0);
 815   if (GET_CODE (symbol) != SYMBOL_REF)
 816     return;
 817
 818   SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
 819 }
 820
 821 /* Return availability of NODE.  */
 822
 823 enum availability
 824 symtab_node_availability (symtab_node node)
 825 {
 826   if (is_a <cgraph_node> (node))
 827     return cgraph_function_body_availability (cgraph (node));
 828   else
 829     return cgraph_variable_initializer_availability (varpool (node));
 830 }
 831
 832 /* Given NODE, walk the alias chain to return the symbol NODE is alias of.
 833    If NODE is not an alias, return NODE.
 834    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
 835
 836 symtab_node
 837 symtab_alias_ultimate_target (symtab_node node, enum availability *availability)
 838 {
 839   bool weakref_p = false;
 840
 841   if (!node->symbol.alias)
 842     {
 843       if (availability)
 844         *availability = symtab_node_availability (node);
 845       return node;
 846     }
 847
 848   /* To determine visibility of the target, we follow ELF semantic of aliases.
 849      Here alias is an alternative assembler name of a given definition. Its
 850      availablity prevails the availablity of its target (i.e. static alias of
 851      weak definition is available.
 852
 853      Weakref is a different animal (and not part of ELF per se). It is just
 854      alternative name of a given symbol used within one complation unit
 855      and is translated prior hitting the object file.  It inherits the
 856      visibility of its target (i.e. weakref of non-overwritable definition
 857      is non-overwritable, while weakref of weak definition is weak).
 858
 859      If we ever get into supporting targets with different semantics, a target
 860      hook will be needed here.  */
 861
 862   if (availability)
 863     {
 864       weakref_p = DECL_EXTERNAL (node->symbol.decl) && node->symbol.alias;
 865       if (!weakref_p)
 866         *availability = symtab_node_availability (node);
 867       else
 868         *availability = AVAIL_LOCAL;
 869     }
 870   while (node)
 871     {
 872       if (node->symbol.alias && node->symbol.analyzed)
 873         node = symtab_alias_target (node);
 874       else
 875         {
 876           if (!availability)
 877             ;
 878           else if (node->symbol.analyzed)
 879             {
 880               if (weakref_p)
 881                 {
 882                   enum availability a = symtab_node_availability (node);
 883                   if (a < *availability)
 884                     *availability = a;
 885                 }
 886             }
 887           else
 888             *availability = AVAIL_NOT_AVAILABLE;
 889           return node;
 890         }
 891       if (node && availability && weakref_p)
 892         {
 893           enum availability a = symtab_node_availability (node);
 894           if (a < *availability)
 895             *availability = a;
 896           weakref_p = DECL_EXTERNAL (node->symbol.decl) && node->symbol.alias;
 897         }
 898     }
 899   if (availability)
 900     *availability = AVAIL_NOT_AVAILABLE;
 901   return NULL;
 902 }
 903
 904 /* C++ FE sometimes change linkage flags after producing same body aliases.
 905
 906    FIXME: C++ produce implicit aliases for virtual functions and vtables that
 907    are obviously equivalent.  The way it is doing so is however somewhat
 908    kludgy and interferes with the visibility code. As a result we need to
 909    copy the visibility from the target to get things right.  */
 910
 911 void
 912 fixup_same_cpp_alias_visibility (symtab_node node, symtab_node target)
 913 {
 914   if (is_a <cgraph_node> (node))
 915     {
 916       DECL_DECLARED_INLINE_P (node->symbol.decl)
 917          = DECL_DECLARED_INLINE_P (target->symbol.decl);
 918       DECL_DISREGARD_INLINE_LIMITS (node->symbol.decl)
 919          = DECL_DISREGARD_INLINE_LIMITS (target->symbol.decl);
 920     }
 921   /* FIXME: It is not really clear why those flags should not be copied for
 922      functions, too.  */
 923   else
 924     {
 925       DECL_WEAK (node->symbol.decl) = DECL_WEAK (target->symbol.decl);
 926       DECL_EXTERNAL (node->symbol.decl) = DECL_EXTERNAL (target->symbol.decl);
 927       DECL_VISIBILITY (node->symbol.decl) = DECL_VISIBILITY (target->symbol.decl);
 928     }
 929   DECL_VIRTUAL_P (node->symbol.decl) = DECL_VIRTUAL_P (target->symbol.decl);
 930   if (TREE_PUBLIC (node->symbol.decl))
 931     {
 932       DECL_EXTERNAL (node->symbol.decl) = DECL_EXTERNAL (target->symbol.decl);
 933       DECL_COMDAT (node->symbol.decl) = DECL_COMDAT (target->symbol.decl);
 934       DECL_COMDAT_GROUP (node->symbol.decl)
 935          = DECL_COMDAT_GROUP (target->symbol.decl);
 936       if (DECL_ONE_ONLY (target->symbol.decl)
 937           && !node->symbol.same_comdat_group)
 938         symtab_add_to_same_comdat_group ((symtab_node)node, (symtab_node)target);
 939     }
 940   node->symbol.externally_visible = target->symbol.externally_visible;
 941 }
 942
 943 /* Add reference recording that NODE is alias of TARGET.
 944    The function can fail in the case of aliasing cycles; in this case
 945    it returns false.  */
 946
 947 bool
 948 symtab_resolve_alias (symtab_node node, symtab_node target)
 949 {
 950   symtab_node n;
 951
 952   gcc_assert (!node->symbol.analyzed
 953               && !vec_safe_length (node->symbol.ref_list.references));
 954
 955   /* Never let cycles to creep into the symbol table alias references;
 956      those will make alias walkers to be infinite.  */
 957   for (n = target; n && n->symbol.alias;
 958        n = n->symbol.analyzed ? symtab_alias_target (n) : NULL)
 959     if (n == node)
 960        {
 961          if (is_a <cgraph_node> (node))
 962            error ("function %q+D part of alias cycle", node->symbol.decl);
 963          else if (is_a <varpool_node> (node))
 964            error ("variable %q+D part of alias cycle", node->symbol.decl);
 965          else
 966            gcc_unreachable ();
 967          node->symbol.alias = false;
 968          return false;
 969        }
 970
 971   /* "analyze" the node - i.e. mark the reference.  */
 972   node->symbol.definition = true;
 973   node->symbol.alias = true;
 974   node->symbol.analyzed = true;
 975   ipa_record_reference (node, target, IPA_REF_ALIAS, NULL);
 976
 977   /* Alias targets become reudndant after alias is resolved into an reference.
 978      We do not want to keep it around or we would have to mind updating them
 979      when renaming symbols.  */
 980   node->symbol.alias_target = NULL;
 981
 982   if (node->symbol.cpp_implicit_alias && cgraph_state >= CGRAPH_STATE_CONSTRUCTION)
 983     fixup_same_cpp_alias_visibility (node, target);
 984
 985   /* If alias has address taken, so does the target.  */
 986   if (node->symbol.address_taken)
 987     symtab_alias_ultimate_target (target, NULL)->symbol.address_taken = true;
 988   return true;
 989 }
 990 #include "gt-symtab.h"