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\n", symtab_type_names[node->symbol.type]);
 477   fprintf (f, "  Visibility:");
 478
 479   if (node->symbol.in_other_partition)
 480     fprintf (f, " in_other_partition");
 481   if (node->symbol.used_from_other_partition)
 482     fprintf (f, " used_from_other_partition");
 483   if (node->symbol.force_output)
 484     fprintf (f, " force_output");
 485   if (node->symbol.resolution != LDPR_UNKNOWN)
 486     fprintf (f, " %s",
 487              ld_plugin_symbol_resolution_names[(int)node->symbol.resolution]);
 488   if (TREE_ASM_WRITTEN (node->symbol.decl))
 489     fprintf (f, " asm_written");
 490   if (DECL_EXTERNAL (node->symbol.decl))
 491     fprintf (f, " external");
 492   if (TREE_PUBLIC (node->symbol.decl))
 493     fprintf (f, " public");
 494   if (DECL_COMMON (node->symbol.decl))
 495     fprintf (f, " common");
 496   if (DECL_WEAK (node->symbol.decl))
 497     fprintf (f, " weak");
 498   if (DECL_DLLIMPORT_P (node->symbol.decl))
 499     fprintf (f, " dll_import");
 500   if (DECL_COMDAT (node->symbol.decl))
 501     fprintf (f, " comdat");
 502   if (DECL_COMDAT_GROUP (node->symbol.decl))
 503     fprintf (f, " comdat_group:%s",
 504              IDENTIFIER_POINTER (DECL_COMDAT_GROUP (node->symbol.decl)));
 505   if (DECL_ONE_ONLY (node->symbol.decl))
 506     fprintf (f, " one_only");
 507   if (DECL_SECTION_NAME (node->symbol.decl))
 508     fprintf (f, " section_name:%s",
 509              TREE_STRING_POINTER (DECL_SECTION_NAME (node->symbol.decl)));
 510   if (DECL_VISIBILITY_SPECIFIED (node->symbol.decl))
 511     fprintf (f, " visibility_specified");
 512   if (DECL_VISIBILITY (node->symbol.decl))
 513     fprintf (f, " visibility:%s",
 514              visibility_types [DECL_VISIBILITY (node->symbol.decl)]);
 515   if (DECL_VIRTUAL_P (node->symbol.decl))
 516     fprintf (f, " virtual");
 517   if (DECL_ARTIFICIAL (node->symbol.decl))
 518     fprintf (f, " artificial");
 519   if (TREE_CODE (node->symbol.decl) == FUNCTION_DECL)
 520     {
 521       if (DECL_STATIC_CONSTRUCTOR (node->symbol.decl))
 522         fprintf (f, " constructor");
 523       if (DECL_STATIC_DESTRUCTOR (node->symbol.decl))
 524         fprintf (f, " destructor");
 525     }
 526   fprintf (f, "\n");
 527
 528   if (node->symbol.same_comdat_group)
 529     fprintf (f, "  Same comdat group as: %s/%i\n",
 530              symtab_node_asm_name (node->symbol.same_comdat_group),
 531              node->symbol.same_comdat_group->symbol.order);
 532   if (node->symbol.next_sharing_asm_name)
 533     fprintf (f, "  next sharing asm name: %i\n",
 534              node->symbol.next_sharing_asm_name->symbol.order);
 535   if (node->symbol.previous_sharing_asm_name)
 536     fprintf (f, "  previous sharing asm name: %i\n",
 537              node->symbol.previous_sharing_asm_name->symbol.order);
 538
 539   if (node->symbol.address_taken)
 540     fprintf (f, "  Address is taken.\n");
 541   if (node->symbol.aux)
 542     {
 543       fprintf (f, "  Aux:");
 544       dump_addr (f, " @", (void *)node->symbol.aux);
 545     }
 546
 547   fprintf (f, "  References: ");
 548   ipa_dump_references (f, &node->symbol.ref_list);
 549   fprintf (f, "  Referring: ");
 550   ipa_dump_referring (f, &node->symbol.ref_list);
 551   if (node->symbol.lto_file_data)
 552     fprintf (f, "  Read from file: %s\n",
 553              node->symbol.lto_file_data->file_name);
 554 }
 555
 556 /* Dump symtab node.  */
 557
 558 void
 559 dump_symtab_node (FILE *f, symtab_node node)
 560 {
 561   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 562     dump_cgraph_node (f, cnode);
 563   else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
 564     dump_varpool_node (f, vnode);
 565 }
 566
 567 /* Dump symbol table.  */
 568
 569 void
 570 dump_symtab (FILE *f)
 571 {
 572   symtab_node node;
 573   fprintf (f, "Symbol table:\n\n");
 574   FOR_EACH_SYMBOL (node)
 575     dump_symtab_node (f, node);
 576 }
 577
 578 /* Dump symtab node NODE to stderr.  */
 579
 580 DEBUG_FUNCTION void
 581 debug_symtab_node (symtab_node node)
 582 {
 583   dump_symtab_node (stderr, node);
 584 }
 585
 586 /* Dump symbol table to stderr.  */
 587
 588 DEBUG_FUNCTION void
 589 debug_symtab (void)
 590 {
 591   dump_symtab (stderr);
 592 }
 593
 594 /* Verify common part of symtab nodes.  */
 595
 596 DEBUG_FUNCTION bool
 597 verify_symtab_base (symtab_node node)
 598 {
 599   bool error_found = false;
 600   symtab_node hashed_node;
 601
 602   if (is_a <cgraph_node> (node))
 603     {
 604       if (TREE_CODE (node->symbol.decl) != FUNCTION_DECL)
 605         {
 606           error ("function symbol is not function");
 607           error_found = true;
 608         }
 609     }
 610   else if (is_a <varpool_node> (node))
 611     {
 612       if (TREE_CODE (node->symbol.decl) != VAR_DECL)
 613         {
 614           error ("variable symbol is not variable");
 615           error_found = true;
 616         }
 617     }
 618   else
 619     {
 620       error ("node has unknown type");
 621       error_found = true;
 622     }
 623
 624   hashed_node = symtab_get_node (node->symbol.decl);
 625   if (!hashed_node)
 626     {
 627       error ("node not found in symtab decl hashtable");
 628       error_found = true;
 629     }
 630   if (assembler_name_hash)
 631     {
 632       hashed_node = symtab_node_for_asm (DECL_ASSEMBLER_NAME (node->symbol.decl));
 633       if (hashed_node && hashed_node->symbol.previous_sharing_asm_name)
 634         {
 635           error ("assembler name hash list corrupted");
 636           error_found = true;
 637         }
 638       while (hashed_node)
 639         {
 640           if (hashed_node == node)
 641             break;
 642           hashed_node = hashed_node->symbol.next_sharing_asm_name;
 643         }
 644       if (!hashed_node
 645           && !(is_a <varpool_node> (node)
 646                || DECL_HARD_REGISTER (node->symbol.decl)))
 647         {
 648           error ("node not found in symtab assembler name hash");
 649           error_found = true;
 650         }
 651     }
 652   if (node->symbol.previous_sharing_asm_name
 653       && node->symbol.previous_sharing_asm_name->symbol.next_sharing_asm_name != node)
 654     {
 655       error ("double linked list of assembler names corrupted");
 656     }
 657   if (node->symbol.same_comdat_group)
 658     {
 659       symtab_node n = node->symbol.same_comdat_group;
 660
 661       if (!DECL_ONE_ONLY (n->symbol.decl))
 662         {
 663           error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
 664           error_found = true;
 665         }
 666       if (n->symbol.type != node->symbol.type)
 667         {
 668           error ("mixing different types of symbol in same comdat groups is not supported");
 669           error_found = true;
 670         }
 671       if (n == node)
 672         {
 673           error ("node is alone in a comdat group");
 674           error_found = true;
 675         }
 676       do
 677         {
 678           if (!n->symbol.same_comdat_group)
 679             {
 680               error ("same_comdat_group is not a circular list");
 681               error_found = true;
 682               break;
 683             }
 684           n = n->symbol.same_comdat_group;
 685         }
 686       while (n != node);
 687     }
 688   return error_found;
 689 }
 690
 691 /* Verify consistency of NODE.  */
 692
 693 DEBUG_FUNCTION void
 694 verify_symtab_node (symtab_node node)
 695 {
 696   if (seen_error ())
 697     return;
 698
 699   timevar_push (TV_CGRAPH_VERIFY);
 700   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 701     verify_cgraph_node (cnode);
 702   else
 703     if (verify_symtab_base (node))
 704       {
 705         dump_symtab_node (stderr, node);
 706         internal_error ("verify_symtab_node failed");
 707       }
 708   timevar_pop (TV_CGRAPH_VERIFY);
 709 }
 710
 711 /* Verify symbol table for internal consistency.  */
 712
 713 DEBUG_FUNCTION void
 714 verify_symtab (void)
 715 {
 716   symtab_node node;
 717   FOR_EACH_SYMBOL (node)
 718    verify_symtab_node (node);
 719 }
 720
 721 /* Return true when RESOLUTION indicate that linker will use
 722    the symbol from non-LTO object files.  */
 723
 724 bool
 725 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
 726 {
 727   return (resolution == LDPR_PREVAILING_DEF
 728           || resolution == LDPR_PREEMPTED_REG
 729           || resolution == LDPR_RESOLVED_EXEC
 730           || resolution == LDPR_RESOLVED_DYN);
 731 }
 732
 733 /* Return true when NODE is known to be used from other (non-LTO) object file.
 734    Known only when doing LTO via linker plugin.  */
 735
 736 bool
 737 symtab_used_from_object_file_p (symtab_node node)
 738 {
 739   if (!TREE_PUBLIC (node->symbol.decl) || DECL_EXTERNAL (node->symbol.decl))
 740     return false;
 741   if (resolution_used_from_other_file_p (node->symbol.resolution))
 742     return true;
 743   return false;
 744 }
 745
 746 /* Make DECL local.  FIXME: We shouldn't need to mess with rtl this early,
 747    but other code such as notice_global_symbol generates rtl.  */
 748 void
 749 symtab_make_decl_local (tree decl)
 750 {
 751   rtx rtl, symbol;
 752
 753   if (TREE_CODE (decl) == VAR_DECL)
 754     DECL_COMMON (decl) = 0;
 755   else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 756
 757   if (DECL_ONE_ONLY (decl) || DECL_COMDAT (decl))
 758     {
 759       DECL_SECTION_NAME (decl) = 0;
 760       DECL_COMDAT (decl) = 0;
 761     }
 762   DECL_COMDAT_GROUP (decl) = 0;
 763   DECL_WEAK (decl) = 0;
 764   DECL_EXTERNAL (decl) = 0;
 765   DECL_VISIBILITY_SPECIFIED (decl) = 0;
 766   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 767   TREE_PUBLIC (decl) = 0;
 768   DECL_VISIBILITY_SPECIFIED (decl) = 0;
 769   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 770   if (!DECL_RTL_SET_P (decl))
 771     return;
 772
 773   /* Update rtl flags.  */
 774   make_decl_rtl (decl);
 775
 776   rtl = DECL_RTL (decl);
 777   if (!MEM_P (rtl))
 778     return;
 779
 780   symbol = XEXP (rtl, 0);
 781   if (GET_CODE (symbol) != SYMBOL_REF)
 782     return;
 783
 784   SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
 785 }
 786 #include "gt-symtab.h"