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 "rtl.h"
  26 #include "tree.h"
  27 #include "print-tree.h"
  28 #include "varasm.h"
  29 #include "function.h"
  30 #include "emit-rtl.h"
  31 #include "basic-block.h"
  32 #include "tree-ssa-alias.h"
  33 #include "internal-fn.h"
  34 #include "gimple-expr.h"
  35 #include "is-a.h"
  36 #include "gimple.h"
  37 #include "tree-inline.h"
  38 #include "langhooks.h"
  39 #include "hashtab.h"
  40 #include "cgraph.h"
  41 #include "diagnostic.h"
  42 #include "timevar.h"
  43 #include "lto-streamer.h"
  44 #include "output.h"
  45
  46 const char * const ld_plugin_symbol_resolution_names[]=
  47 {
  48   "",
  49   "undef",
  50   "prevailing_def",
  51   "prevailing_def_ironly",
  52   "preempted_reg",
  53   "preempted_ir",
  54   "resolved_ir",
  55   "resolved_exec",
  56   "resolved_dyn",
  57   "prevailing_def_ironly_exp"
  58 };
  59
  60 /* Hash table used to convert declarations into nodes.  */
  61 static GTY((param_is (symtab_node))) htab_t symtab_hash;
  62 /* Hash table used to convert assembler names into nodes.  */
  63 static GTY((param_is (symtab_node))) htab_t assembler_name_hash;
  64
  65 /* Linked list of symbol table nodes.  */
  66 symtab_node *symtab_nodes;
  67
  68 /* The order index of the next symtab node to be created.  This is
  69    used so that we can sort the cgraph nodes in order by when we saw
  70    them, to support -fno-toplevel-reorder.  */
  71 int symtab_order;
  72
  73 /* Returns a hash code for P.  */
  74
  75 static hashval_t
  76 hash_node (const void *p)
  77 {
  78   const symtab_node *n = (const symtab_node *) p;
  79   return (hashval_t) DECL_UID (n->decl);
  80 }
  81
  82
  83 /* Returns nonzero if P1 and P2 are equal.  */
  84
  85 static int
  86 eq_node (const void *p1, const void *p2)
  87 {
  88   const symtab_node *n1 = (const symtab_node *) p1;
  89   const symtab_node *n2 = (const symtab_node *) p2;
  90   return DECL_UID (n1->decl) == DECL_UID (n2->decl);
  91 }
  92
  93 /* Hash asmnames ignoring the user specified marks.  */
  94
  95 static hashval_t
  96 decl_assembler_name_hash (const_tree asmname)
  97 {
  98   if (IDENTIFIER_POINTER (asmname)[0] == '*')
  99     {
 100       const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
 101       size_t ulp_len = strlen (user_label_prefix);
 102
 103       if (ulp_len == 0)
 104         ;
 105       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
 106         decl_str += ulp_len;
 107
 108       return htab_hash_string (decl_str);
 109     }
 110
 111   return htab_hash_string (IDENTIFIER_POINTER (asmname));
 112 }
 113
 114
 115 /* Returns a hash code for P.  */
 116
 117 static hashval_t
 118 hash_node_by_assembler_name (const void *p)
 119 {
 120   const symtab_node *n = (const symtab_node *) p;
 121   return (hashval_t) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n->decl));
 122 }
 123
 124 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
 125
 126 static bool
 127 decl_assembler_name_equal (tree decl, const_tree asmname)
 128 {
 129   tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
 130   const char *decl_str;
 131   const char *asmname_str;
 132   bool test = false;
 133
 134   if (decl_asmname == asmname)
 135     return true;
 136
 137   decl_str = IDENTIFIER_POINTER (decl_asmname);
 138   asmname_str = IDENTIFIER_POINTER (asmname);
 139
 140
 141   /* If the target assembler name was set by the user, things are trickier.
 142      We have a leading '*' to begin with.  After that, it's arguable what
 143      is the correct thing to do with -fleading-underscore.  Arguably, we've
 144      historically been doing the wrong thing in assemble_alias by always
 145      printing the leading underscore.  Since we're not changing that, make
 146      sure user_label_prefix follows the '*' before matching.  */
 147   if (decl_str[0] == '*')
 148     {
 149       size_t ulp_len = strlen (user_label_prefix);
 150
 151       decl_str ++;
 152
 153       if (ulp_len == 0)
 154         test = true;
 155       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
 156         decl_str += ulp_len, test=true;
 157       else
 158         decl_str --;
 159     }
 160   if (asmname_str[0] == '*')
 161     {
 162       size_t ulp_len = strlen (user_label_prefix);
 163
 164       asmname_str ++;
 165
 166       if (ulp_len == 0)
 167         test = true;
 168       else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
 169         asmname_str += ulp_len, test=true;
 170       else
 171         asmname_str --;
 172     }
 173
 174   if (!test)
 175     return false;
 176   return strcmp (decl_str, asmname_str) == 0;
 177 }
 178
 179
 180 /* Returns nonzero if P1 and P2 are equal.  */
 181
 182 static int
 183 eq_assembler_name (const void *p1, const void *p2)
 184 {
 185   const symtab_node *n1 = (const symtab_node *) p1;
 186   const_tree name = (const_tree)p2;
 187   return (decl_assembler_name_equal (n1->decl, name));
 188 }
 189
 190 /* Insert NODE to assembler name hash.  */
 191
 192 static void
 193 insert_to_assembler_name_hash (symtab_node *node, bool with_clones)
 194 {
 195   if (is_a <varpool_node> (node) && DECL_HARD_REGISTER (node->decl))
 196     return;
 197   gcc_checking_assert (!node->previous_sharing_asm_name
 198                        && !node->next_sharing_asm_name);
 199   if (assembler_name_hash)
 200     {
 201       void **aslot;
 202       struct cgraph_node *cnode;
 203       tree decl = node->decl;
 204
 205       tree name = DECL_ASSEMBLER_NAME (node->decl);
 206
 207       aslot = htab_find_slot_with_hash (assembler_name_hash, name,
 208                                         decl_assembler_name_hash (name),
 209                                         INSERT);
 210       gcc_assert (*aslot != node);
 211       node->next_sharing_asm_name = (symtab_node *)*aslot;
 212       if (*aslot != NULL)
 213         ((symtab_node *)*aslot)->previous_sharing_asm_name = node;
 214       *aslot = node;
 215
 216       /* Update also possible inline clones sharing a decl.  */
 217       cnode = dyn_cast <cgraph_node> (node);
 218       if (cnode && cnode->clones && with_clones)
 219         for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
 220           if (cnode->decl == decl)
 221             insert_to_assembler_name_hash (cnode, true);
 222     }
 223
 224 }
 225
 226 /* Remove NODE from assembler name hash.  */
 227
 228 static void
 229 unlink_from_assembler_name_hash (symtab_node *node, bool with_clones)
 230 {
 231   if (assembler_name_hash)
 232     {
 233       struct cgraph_node *cnode;
 234       tree decl = node->decl;
 235
 236       if (node->next_sharing_asm_name)
 237         node->next_sharing_asm_name->previous_sharing_asm_name
 238           = node->previous_sharing_asm_name;
 239       if (node->previous_sharing_asm_name)
 240         {
 241           node->previous_sharing_asm_name->next_sharing_asm_name
 242             = node->next_sharing_asm_name;
 243         }
 244       else
 245         {
 246           tree name = DECL_ASSEMBLER_NAME (node->decl);
 247           void **slot;
 248           slot = htab_find_slot_with_hash (assembler_name_hash, name,
 249                                            decl_assembler_name_hash (name),
 250                                            NO_INSERT);
 251           gcc_assert (*slot == node);
 252           if (!node->next_sharing_asm_name)
 253             htab_clear_slot (assembler_name_hash, slot);
 254           else
 255             *slot = node->next_sharing_asm_name;
 256         }
 257       node->next_sharing_asm_name = NULL;
 258       node->previous_sharing_asm_name = NULL;
 259
 260       /* Update also possible inline clones sharing a decl.  */
 261       cnode = dyn_cast <cgraph_node> (node);
 262       if (cnode && cnode->clones && with_clones)
 263         for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
 264           if (cnode->decl == decl)
 265             unlink_from_assembler_name_hash (cnode, true);
 266     }
 267 }
 268
 269 /* Arrange node to be first in its entry of assembler_name_hash.  */
 270
 271 void
 272 symtab_prevail_in_asm_name_hash (symtab_node *node)
 273 {
 274   unlink_from_assembler_name_hash (node, false);
 275   insert_to_assembler_name_hash (node, false);
 276 }
 277
 278
 279 /* Add node into symbol table.  This function is not used directly, but via
 280    cgraph/varpool node creation routines.  */
 281
 282 void
 283 symtab_register_node (symtab_node *node)
 284 {
 285   struct symtab_node key;
 286   symtab_node **slot;
 287
 288   node->next = symtab_nodes;
 289   node->previous = NULL;
 290   if (symtab_nodes)
 291     symtab_nodes->previous = node;
 292   symtab_nodes = node;
 293
 294   if (!symtab_hash)
 295     symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
 296   key.decl = node->decl;
 297   slot = (symtab_node **) htab_find_slot (symtab_hash, &key, INSERT);
 298   if (*slot == NULL)
 299     *slot = node;
 300
 301   ipa_empty_ref_list (&node->ref_list);
 302
 303   node->order = symtab_order++;
 304
 305   /* Be sure to do this last; C++ FE might create new nodes via
 306      DECL_ASSEMBLER_NAME langhook!  */
 307   insert_to_assembler_name_hash (node, false);
 308 }
 309
 310 /* Make NODE to be the one symtab hash is pointing to.  Used when reshaping tree
 311    of inline clones.  */
 312
 313 void
 314 symtab_insert_node_to_hashtable (symtab_node *node)
 315 {
 316   struct symtab_node key;
 317   symtab_node **slot;
 318
 319   if (!symtab_hash)
 320     symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
 321   key.decl = node->decl;
 322   slot = (symtab_node **) htab_find_slot (symtab_hash, &key, INSERT);
 323   *slot = node;
 324 }
 325
 326 /* Remove node from symbol table.  This function is not used directly, but via
 327    cgraph/varpool node removal routines.  */
 328
 329 void
 330 symtab_unregister_node (symtab_node *node)
 331 {
 332   void **slot;
 333   ipa_remove_all_references (&node->ref_list);
 334   ipa_remove_all_referring (&node->ref_list);
 335
 336   if (node->same_comdat_group)
 337     {
 338       symtab_node *prev;
 339       for (prev = node->same_comdat_group;
 340            prev->same_comdat_group != node;
 341            prev = prev->same_comdat_group)
 342         ;
 343       if (node->same_comdat_group == prev)
 344         prev->same_comdat_group = NULL;
 345       else
 346         prev->same_comdat_group = node->same_comdat_group;
 347       node->same_comdat_group = NULL;
 348     }
 349
 350   if (node->previous)
 351     node->previous->next = node->next;
 352   else
 353     symtab_nodes = node->next;
 354   if (node->next)
 355     node->next->previous = node->previous;
 356   node->next = NULL;
 357   node->previous = NULL;
 358
 359   slot = htab_find_slot (symtab_hash, node, NO_INSERT);
 360
 361   /* During LTO symtab merging we temporarily corrupt decl to symtab node
 362      hash.  */
 363   gcc_assert ((slot && *slot) || in_lto_p);
 364   if (slot && *slot && *slot == node)
 365     {
 366       symtab_node *replacement_node = NULL;
 367       if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 368         replacement_node = cgraph_find_replacement_node (cnode);
 369       if (!replacement_node)
 370         htab_clear_slot (symtab_hash, slot);
 371       else
 372         *slot = replacement_node;
 373     }
 374   if (!is_a <varpool_node> (node) || !DECL_HARD_REGISTER (node->decl))
 375     unlink_from_assembler_name_hash (node, false);
 376 }
 377
 378 /* Return symbol table node associated with DECL, if any,
 379    and NULL otherwise.  */
 380
 381 symtab_node *
 382 symtab_get_node (const_tree decl)
 383 {
 384   symtab_node **slot;
 385   struct symtab_node key;
 386
 387 #ifdef ENABLE_CHECKING
 388   /* Check that we are called for sane type of object - functions
 389      and static or external variables.  */
 390   gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
 391                        || (TREE_CODE (decl) == VAR_DECL
 392                            && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
 393                                || in_lto_p)));
 394 #endif
 395
 396   if (!symtab_hash)
 397     return NULL;
 398
 399   key.decl = CONST_CAST2 (tree, const_tree, decl);
 400
 401   slot = (symtab_node **) htab_find_slot (symtab_hash, &key,
 402                                          NO_INSERT);
 403
 404   if (slot)
 405     return *slot;
 406   return NULL;
 407 }
 408
 409 /* Remove symtab NODE from the symbol table.  */
 410
 411 void
 412 symtab_remove_node (symtab_node *node)
 413 {
 414   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 415     cgraph_remove_node (cnode);
 416   else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
 417     varpool_remove_node (vnode);
 418 }
 419
 420 /* Initalize asm name hash unless.  */
 421
 422 void
 423 symtab_initialize_asm_name_hash (void)
 424 {
 425   symtab_node *node;
 426   if (!assembler_name_hash)
 427     {
 428       assembler_name_hash =
 429         htab_create_ggc (10, hash_node_by_assembler_name, eq_assembler_name,
 430                          NULL);
 431       FOR_EACH_SYMBOL (node)
 432         insert_to_assembler_name_hash (node, false);
 433     }
 434 }
 435
 436 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
 437    Return NULL if there's no such node.  */
 438
 439 symtab_node *
 440 symtab_node_for_asm (const_tree asmname)
 441 {
 442   symtab_node *node;
 443   void **slot;
 444
 445   symtab_initialize_asm_name_hash ();
 446   slot = htab_find_slot_with_hash (assembler_name_hash, asmname,
 447                                    decl_assembler_name_hash (asmname),
 448                                    NO_INSERT);
 449
 450   if (slot)
 451     {
 452       node = (symtab_node *) *slot;
 453       return node;
 454     }
 455   return NULL;
 456 }
 457
 458 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables.  */
 459
 460 void
 461 change_decl_assembler_name (tree decl, tree name)
 462 {
 463   symtab_node *node = NULL;
 464
 465   /* We can have user ASM names on things, like global register variables, that
 466      are not in the symbol table.  */
 467   if ((TREE_CODE (decl) == VAR_DECL
 468        && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
 469       || TREE_CODE (decl) == FUNCTION_DECL)
 470     node = symtab_get_node (decl);
 471   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 472     {
 473       SET_DECL_ASSEMBLER_NAME (decl, name);
 474       if (node)
 475         insert_to_assembler_name_hash (node, true);
 476     }
 477   else
 478     {
 479       if (name == DECL_ASSEMBLER_NAME (decl))
 480         return;
 481
 482       tree alias = (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl))
 483                     ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
 484                     : NULL);
 485       if (node)
 486         unlink_from_assembler_name_hash (node, true);
 487       if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
 488           && DECL_RTL_SET_P (decl))
 489         warning (0, "%D renamed after being referenced in assembly", decl);
 490
 491       SET_DECL_ASSEMBLER_NAME (decl, name);
 492       if (alias)
 493         {
 494           IDENTIFIER_TRANSPARENT_ALIAS (name) = 1;
 495           TREE_CHAIN (DECL_ASSEMBLER_NAME (name)) = alias;
 496         }
 497       if (node)
 498         insert_to_assembler_name_hash (node, true);
 499     }
 500 }
 501
 502 /* Add NEW_ to the same comdat group that OLD is in.  */
 503
 504 void
 505 symtab_add_to_same_comdat_group (symtab_node *new_node,
 506                                  symtab_node *old_node)
 507 {
 508   gcc_assert (DECL_ONE_ONLY (old_node->decl));
 509   gcc_assert (!new_node->same_comdat_group);
 510   gcc_assert (new_node != old_node);
 511
 512   DECL_COMDAT_GROUP (new_node->decl) = DECL_COMDAT_GROUP (old_node->decl);
 513   new_node->same_comdat_group = old_node;
 514   if (!old_node->same_comdat_group)
 515     old_node->same_comdat_group = new_node;
 516   else
 517     {
 518       symtab_node *n;
 519       for (n = old_node->same_comdat_group;
 520            n->same_comdat_group != old_node;
 521            n = n->same_comdat_group)
 522         ;
 523       n->same_comdat_group = new_node;
 524     }
 525 }
 526
 527 /* Dissolve the same_comdat_group list in which NODE resides.  */
 528
 529 void
 530 symtab_dissolve_same_comdat_group_list (symtab_node *node)
 531 {
 532   symtab_node *n = node;
 533   symtab_node *next;
 534
 535   if (!node->same_comdat_group)
 536     return;
 537   do
 538     {
 539       next = n->same_comdat_group;
 540       n->same_comdat_group = NULL;
 541       n = next;
 542     }
 543   while (n != node);
 544 }
 545
 546 /* Return printable assembler name of NODE.
 547    This function is used only for debugging.  When assembler name
 548    is unknown go with identifier name.  */
 549
 550 const char *
 551 symtab_node::asm_name () const
 552 {
 553   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 554     return lang_hooks.decl_printable_name (decl, 2);
 555   return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 556 }
 557
 558 /* Return printable identifier name.  */
 559
 560 const char *
 561 symtab_node::name () const
 562 {
 563   return lang_hooks.decl_printable_name (decl, 2);
 564 }
 565
 566 static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
 567
 568 /* Dump base fields of symtab nodes.  Not to be used directly.  */
 569
 570 void
 571 dump_symtab_base (FILE *f, symtab_node *node)
 572 {
 573   static const char * const visibility_types[] = {
 574     "default", "protected", "hidden", "internal"
 575   };
 576
 577   fprintf (f, "%s/%i (%s)",
 578            node->asm_name (),
 579            node->order,
 580            node->name ());
 581   dump_addr (f, " @", (void *)node);
 582   fprintf (f, "\n  Type: %s", symtab_type_names[node->type]);
 583
 584   if (node->definition)
 585     fprintf (f, " definition");
 586   if (node->analyzed)
 587     fprintf (f, " analyzed");
 588   if (node->alias)
 589     fprintf (f, " alias");
 590   if (node->weakref)
 591     fprintf (f, " weakref");
 592   if (node->cpp_implicit_alias)
 593     fprintf (f, " cpp_implicit_alias");
 594   if (node->alias_target)
 595     fprintf (f, " target:%s",
 596              DECL_P (node->alias_target)
 597              ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
 598                                      (node->alias_target))
 599              : IDENTIFIER_POINTER (node->alias_target));
 600   fprintf (f, "\n  Visibility:");
 601   if (node->in_other_partition)
 602     fprintf (f, " in_other_partition");
 603   if (node->used_from_other_partition)
 604     fprintf (f, " used_from_other_partition");
 605   if (node->force_output)
 606     fprintf (f, " force_output");
 607   if (node->forced_by_abi)
 608     fprintf (f, " forced_by_abi");
 609   if (node->externally_visible)
 610     fprintf (f, " externally_visible");
 611   if (node->resolution != LDPR_UNKNOWN)
 612     fprintf (f, " %s",
 613              ld_plugin_symbol_resolution_names[(int)node->resolution]);
 614   if (TREE_ASM_WRITTEN (node->decl))
 615     fprintf (f, " asm_written");
 616   if (DECL_EXTERNAL (node->decl))
 617     fprintf (f, " external");
 618   if (TREE_PUBLIC (node->decl))
 619     fprintf (f, " public");
 620   if (DECL_COMMON (node->decl))
 621     fprintf (f, " common");
 622   if (DECL_WEAK (node->decl))
 623     fprintf (f, " weak");
 624   if (DECL_DLLIMPORT_P (node->decl))
 625     fprintf (f, " dll_import");
 626   if (DECL_COMDAT (node->decl))
 627     fprintf (f, " comdat");
 628   if (DECL_COMDAT_GROUP (node->decl))
 629     fprintf (f, " comdat_group:%s",
 630              IDENTIFIER_POINTER (DECL_COMDAT_GROUP (node->decl)));
 631   if (DECL_ONE_ONLY (node->decl))
 632     fprintf (f, " one_only");
 633   if (DECL_SECTION_NAME (node->decl))
 634     fprintf (f, " section_name:%s",
 635              TREE_STRING_POINTER (DECL_SECTION_NAME (node->decl)));
 636   if (DECL_VISIBILITY_SPECIFIED (node->decl))
 637     fprintf (f, " visibility_specified");
 638   if (DECL_VISIBILITY (node->decl))
 639     fprintf (f, " visibility:%s",
 640              visibility_types [DECL_VISIBILITY (node->decl)]);
 641   if (DECL_VIRTUAL_P (node->decl))
 642     fprintf (f, " virtual");
 643   if (DECL_ARTIFICIAL (node->decl))
 644     fprintf (f, " artificial");
 645   if (TREE_CODE (node->decl) == FUNCTION_DECL)
 646     {
 647       if (DECL_STATIC_CONSTRUCTOR (node->decl))
 648         fprintf (f, " constructor");
 649       if (DECL_STATIC_DESTRUCTOR (node->decl))
 650         fprintf (f, " destructor");
 651     }
 652   fprintf (f, "\n");
 653
 654   if (node->same_comdat_group)
 655     fprintf (f, "  Same comdat group as: %s/%i\n",
 656              node->same_comdat_group->asm_name (),
 657              node->same_comdat_group->order);
 658   if (node->next_sharing_asm_name)
 659     fprintf (f, "  next sharing asm name: %i\n",
 660              node->next_sharing_asm_name->order);
 661   if (node->previous_sharing_asm_name)
 662     fprintf (f, "  previous sharing asm name: %i\n",
 663              node->previous_sharing_asm_name->order);
 664
 665   if (node->address_taken)
 666     fprintf (f, "  Address is taken.\n");
 667   if (node->aux)
 668     {
 669       fprintf (f, "  Aux:");
 670       dump_addr (f, " @", (void *)node->aux);
 671     }
 672
 673   fprintf (f, "  References: ");
 674   ipa_dump_references (f, &node->ref_list);
 675   fprintf (f, "  Referring: ");
 676   ipa_dump_referring (f, &node->ref_list);
 677   if (node->lto_file_data)
 678     fprintf (f, "  Read from file: %s\n",
 679              node->lto_file_data->file_name);
 680 }
 681
 682 /* Dump symtab node.  */
 683
 684 void
 685 dump_symtab_node (FILE *f, symtab_node *node)
 686 {
 687   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 688     dump_cgraph_node (f, cnode);
 689   else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
 690     dump_varpool_node (f, vnode);
 691 }
 692
 693 /* Dump symbol table.  */
 694
 695 void
 696 dump_symtab (FILE *f)
 697 {
 698   symtab_node *node;
 699   fprintf (f, "Symbol table:\n\n");
 700   FOR_EACH_SYMBOL (node)
 701     dump_symtab_node (f, node);
 702 }
 703
 704 /* Dump symtab node NODE to stderr.  */
 705
 706 DEBUG_FUNCTION void
 707 debug_symtab_node (symtab_node *node)
 708 {
 709   dump_symtab_node (stderr, node);
 710 }
 711
 712 /* Dump symbol table to stderr.  */
 713
 714 DEBUG_FUNCTION void
 715 debug_symtab (void)
 716 {
 717   dump_symtab (stderr);
 718 }
 719
 720 /* Verify common part of symtab nodes.  */
 721
 722 DEBUG_FUNCTION bool
 723 verify_symtab_base (symtab_node *node)
 724 {
 725   bool error_found = false;
 726   symtab_node *hashed_node;
 727
 728   if (is_a <cgraph_node> (node))
 729     {
 730       if (TREE_CODE (node->decl) != FUNCTION_DECL)
 731         {
 732           error ("function symbol is not function");
 733           error_found = true;
 734         }
 735     }
 736   else if (is_a <varpool_node> (node))
 737     {
 738       if (TREE_CODE (node->decl) != VAR_DECL)
 739         {
 740           error ("variable symbol is not variable");
 741           error_found = true;
 742         }
 743     }
 744   else
 745     {
 746       error ("node has unknown type");
 747       error_found = true;
 748     }
 749
 750   if (cgraph_state != CGRAPH_LTO_STREAMING)
 751     {
 752       hashed_node = symtab_get_node (node->decl);
 753       if (!hashed_node)
 754         {
 755           error ("node not found in symtab decl hashtable");
 756           error_found = true;
 757         }
 758       if (hashed_node != node
 759           && (!is_a <cgraph_node> (node)
 760               || !dyn_cast <cgraph_node> (node)->clone_of
 761               || dyn_cast <cgraph_node> (node)->clone_of->decl
 762                  != node->decl))
 763         {
 764           error ("node differs from symtab decl hashtable");
 765           error_found = true;
 766         }
 767     }
 768   if (assembler_name_hash)
 769     {
 770       hashed_node = symtab_node_for_asm (DECL_ASSEMBLER_NAME (node->decl));
 771       if (hashed_node && hashed_node->previous_sharing_asm_name)
 772         {
 773           error ("assembler name hash list corrupted");
 774           error_found = true;
 775         }
 776       while (hashed_node)
 777         {
 778           if (hashed_node == node)
 779             break;
 780           hashed_node = hashed_node->next_sharing_asm_name;
 781         }
 782       if (!hashed_node
 783           && !(is_a <varpool_node> (node)
 784                || DECL_HARD_REGISTER (node->decl)))
 785         {
 786           error ("node not found in symtab assembler name hash");
 787           error_found = true;
 788         }
 789     }
 790   if (node->previous_sharing_asm_name
 791       && node->previous_sharing_asm_name->next_sharing_asm_name != node)
 792     {
 793       error ("double linked list of assembler names corrupted");
 794       error_found = true;
 795     }
 796   if (node->analyzed && !node->definition)
 797     {
 798       error ("node is analyzed byt it is not a definition");
 799       error_found = true;
 800     }
 801   if (node->cpp_implicit_alias && !node->alias)
 802     {
 803       error ("node is alias but not implicit alias");
 804       error_found = true;
 805     }
 806   if (node->alias && !node->definition
 807       && !node->weakref)
 808     {
 809       error ("node is alias but not definition");
 810       error_found = true;
 811     }
 812   if (node->weakref && !node->alias)
 813     {
 814       error ("node is weakref but not an alias");
 815       error_found = true;
 816     }
 817   if (node->same_comdat_group)
 818     {
 819       symtab_node *n = node->same_comdat_group;
 820
 821       if (!DECL_ONE_ONLY (n->decl))
 822         {
 823           error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
 824           error_found = true;
 825         }
 826       if (n->type != node->type)
 827         {
 828           error ("mixing different types of symbol in same comdat groups is not supported");
 829           error_found = true;
 830         }
 831       if (n == node)
 832         {
 833           error ("node is alone in a comdat group");
 834           error_found = true;
 835         }
 836       do
 837         {
 838           if (!n->same_comdat_group)
 839             {
 840               error ("same_comdat_group is not a circular list");
 841               error_found = true;
 842               break;
 843             }
 844           n = n->same_comdat_group;
 845         }
 846       while (n != node);
 847     }
 848   return error_found;
 849 }
 850
 851 /* Verify consistency of NODE.  */
 852
 853 DEBUG_FUNCTION void
 854 verify_symtab_node (symtab_node *node)
 855 {
 856   if (seen_error ())
 857     return;
 858
 859   timevar_push (TV_CGRAPH_VERIFY);
 860   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 861     verify_cgraph_node (cnode);
 862   else
 863     if (verify_symtab_base (node))
 864       {
 865         dump_symtab_node (stderr, node);
 866         internal_error ("verify_symtab_node failed");
 867       }
 868   timevar_pop (TV_CGRAPH_VERIFY);
 869 }
 870
 871 /* Verify symbol table for internal consistency.  */
 872
 873 DEBUG_FUNCTION void
 874 verify_symtab (void)
 875 {
 876   symtab_node *node;
 877   FOR_EACH_SYMBOL (node)
 878    verify_symtab_node (node);
 879 }
 880
 881 /* Return true when RESOLUTION indicate that linker will use
 882    the symbol from non-LTO object files.  */
 883
 884 bool
 885 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
 886 {
 887   return (resolution == LDPR_PREVAILING_DEF
 888           || resolution == LDPR_PREEMPTED_REG
 889           || resolution == LDPR_RESOLVED_EXEC
 890           || resolution == LDPR_RESOLVED_DYN);
 891 }
 892
 893 /* Return true when NODE is known to be used from other (non-LTO) object file.
 894    Known only when doing LTO via linker plugin.  */
 895
 896 bool
 897 symtab_used_from_object_file_p (symtab_node *node)
 898 {
 899   if (!TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl))
 900     return false;
 901   if (resolution_used_from_other_file_p (node->resolution))
 902     return true;
 903   return false;
 904 }
 905
 906 /* Make DECL local.  FIXME: We shouldn't need to mess with rtl this early,
 907    but other code such as notice_global_symbol generates rtl.  */
 908
 909 void
 910 symtab_make_decl_local (tree decl)
 911 {
 912   rtx rtl, symbol;
 913
 914   if (TREE_CODE (decl) == VAR_DECL)
 915     DECL_COMMON (decl) = 0;
 916   else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 917
 918   if (DECL_ONE_ONLY (decl) || DECL_COMDAT (decl))
 919     {
 920       DECL_SECTION_NAME (decl) = 0;
 921       DECL_COMDAT (decl) = 0;
 922     }
 923   DECL_COMDAT_GROUP (decl) = 0;
 924   DECL_WEAK (decl) = 0;
 925   DECL_EXTERNAL (decl) = 0;
 926   DECL_VISIBILITY_SPECIFIED (decl) = 0;
 927   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 928   TREE_PUBLIC (decl) = 0;
 929   if (!DECL_RTL_SET_P (decl))
 930     return;
 931
 932   /* Update rtl flags.  */
 933   make_decl_rtl (decl);
 934
 935   rtl = DECL_RTL (decl);
 936   if (!MEM_P (rtl))
 937     return;
 938
 939   symbol = XEXP (rtl, 0);
 940   if (GET_CODE (symbol) != SYMBOL_REF)
 941     return;
 942
 943   SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
 944 }
 945
 946 /* Return availability of NODE.  */
 947
 948 enum availability
 949 symtab_node_availability (symtab_node *node)
 950 {
 951   if (is_a <cgraph_node> (node))
 952     return cgraph_function_body_availability (cgraph (node));
 953   else
 954     return cgraph_variable_initializer_availability (varpool (node));
 955 }
 956
 957 /* Given NODE, walk the alias chain to return the symbol NODE is alias of.
 958    If NODE is not an alias, return NODE.
 959    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
 960
 961 symtab_node *
 962 symtab_alias_ultimate_target (symtab_node *node, enum availability *availability)
 963 {
 964   bool weakref_p = false;
 965
 966   if (!node->alias)
 967     {
 968       if (availability)
 969         *availability = symtab_node_availability (node);
 970       return node;
 971     }
 972
 973   /* To determine visibility of the target, we follow ELF semantic of aliases.
 974      Here alias is an alternative assembler name of a given definition. Its
 975      availability prevails the availability of its target (i.e. static alias of
 976      weak definition is available.
 977
 978      Weakref is a different animal (and not part of ELF per se). It is just
 979      alternative name of a given symbol used within one complation unit
 980      and is translated prior hitting the object file.  It inherits the
 981      visibility of its target (i.e. weakref of non-overwritable definition
 982      is non-overwritable, while weakref of weak definition is weak).
 983
 984      If we ever get into supporting targets with different semantics, a target
 985      hook will be needed here.  */
 986
 987   if (availability)
 988     {
 989       weakref_p = node->weakref;
 990       if (!weakref_p)
 991         *availability = symtab_node_availability (node);
 992       else
 993         *availability = AVAIL_LOCAL;
 994     }
 995   while (node)
 996     {
 997       if (node->alias && node->analyzed)
 998         node = symtab_alias_target (node);
 999       else
1000         {
1001           if (!availability)
1002             ;
1003           else if (node->analyzed)
1004             {
1005               if (weakref_p)
1006                 {
1007                   enum availability a = symtab_node_availability (node);
1008                   if (a < *availability)
1009                     *availability = a;
1010                 }
1011             }
1012           else
1013             *availability = AVAIL_NOT_AVAILABLE;
1014           return node;
1015         }
1016       if (node && availability && weakref_p)
1017         {
1018           enum availability a = symtab_node_availability (node);
1019           if (a < *availability)
1020             *availability = a;
1021           weakref_p = node->weakref;
1022         }
1023     }
1024   if (availability)
1025     *availability = AVAIL_NOT_AVAILABLE;
1026   return NULL;
1027 }
1028
1029 /* C++ FE sometimes change linkage flags after producing same body aliases.
1030
1031    FIXME: C++ produce implicit aliases for virtual functions and vtables that
1032    are obviously equivalent.  The way it is doing so is however somewhat
1033    kludgy and interferes with the visibility code. As a result we need to
1034    copy the visibility from the target to get things right.  */
1035
1036 void
1037 fixup_same_cpp_alias_visibility (symtab_node *node, symtab_node *target)
1038 {
1039   if (is_a <cgraph_node> (node))
1040     {
1041       DECL_DECLARED_INLINE_P (node->decl)
1042          = DECL_DECLARED_INLINE_P (target->decl);
1043       DECL_DISREGARD_INLINE_LIMITS (node->decl)
1044          = DECL_DISREGARD_INLINE_LIMITS (target->decl);
1045     }
1046   /* FIXME: It is not really clear why those flags should not be copied for
1047      functions, too.  */
1048   else
1049     {
1050       DECL_WEAK (node->decl) = DECL_WEAK (target->decl);
1051       DECL_EXTERNAL (node->decl) = DECL_EXTERNAL (target->decl);
1052       DECL_VISIBILITY (node->decl) = DECL_VISIBILITY (target->decl);
1053     }
1054   DECL_VIRTUAL_P (node->decl) = DECL_VIRTUAL_P (target->decl);
1055   if (TREE_PUBLIC (node->decl))
1056     {
1057       DECL_EXTERNAL (node->decl) = DECL_EXTERNAL (target->decl);
1058       DECL_COMDAT (node->decl) = DECL_COMDAT (target->decl);
1059       DECL_COMDAT_GROUP (node->decl)
1060          = DECL_COMDAT_GROUP (target->decl);
1061       if (DECL_ONE_ONLY (target->decl)
1062           && !node->same_comdat_group)
1063         symtab_add_to_same_comdat_group (node, target);
1064     }
1065   node->externally_visible = target->externally_visible;
1066 }
1067
1068 /* Add reference recording that NODE is alias of TARGET.
1069    The function can fail in the case of aliasing cycles; in this case
1070    it returns false.  */
1071
1072 bool
1073 symtab_resolve_alias (symtab_node *node, symtab_node *target)
1074 {
1075   symtab_node *n;
1076
1077   gcc_assert (!node->analyzed
1078               && !vec_safe_length (node->ref_list.references));
1079
1080   /* Never let cycles to creep into the symbol table alias references;
1081      those will make alias walkers to be infinite.  */
1082   for (n = target; n && n->alias;
1083        n = n->analyzed ? symtab_alias_target (n) : NULL)
1084     if (n == node)
1085        {
1086          if (is_a <cgraph_node> (node))
1087            error ("function %q+D part of alias cycle", node->decl);
1088          else if (is_a <varpool_node> (node))
1089            error ("variable %q+D part of alias cycle", node->decl);
1090          else
1091            gcc_unreachable ();
1092          node->alias = false;
1093          return false;
1094        }
1095
1096   /* "analyze" the node - i.e. mark the reference.  */
1097   node->definition = true;
1098   node->alias = true;
1099   node->analyzed = true;
1100   ipa_record_reference (node, target, IPA_REF_ALIAS, NULL);
1101
1102   /* Alias targets become reudndant after alias is resolved into an reference.
1103      We do not want to keep it around or we would have to mind updating them
1104      when renaming symbols.  */
1105   node->alias_target = NULL;
1106
1107   if (node->cpp_implicit_alias && cgraph_state >= CGRAPH_STATE_CONSTRUCTION)
1108     fixup_same_cpp_alias_visibility (node, target);
1109
1110   /* If alias has address taken, so does the target.  */
1111   if (node->address_taken)
1112     symtab_alias_ultimate_target (target, NULL)->address_taken = true;
1113   return true;
1114 }
1115
1116 /* Call calback on NODE and aliases associated to NODE.
1117    When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1118    skipped. */
1119
1120 bool
1121 symtab_for_node_and_aliases (symtab_node *node,
1122                              bool (*callback) (symtab_node *, void *),
1123                              void *data,
1124                              bool include_overwritable)
1125 {
1126   int i;
1127   struct ipa_ref *ref;
1128
1129   if (callback (node, data))
1130     return true;
1131   for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
1132     if (ref->use == IPA_REF_ALIAS)
1133       {
1134         symtab_node *alias = ref->referring;
1135         if (include_overwritable
1136             || symtab_node_availability (alias) > AVAIL_OVERWRITABLE)
1137           if (symtab_for_node_and_aliases (alias, callback, data,
1138                                            include_overwritable))
1139             return true;
1140       }
1141   return false;
1142 }
1143
1144 /* Worker searching nonoverwritable alias.  */
1145
1146 static bool
1147 symtab_nonoverwritable_alias_1 (symtab_node *node, void *data)
1148 {
1149   if (decl_binds_to_current_def_p (node->decl))
1150     {
1151       *(symtab_node **)data = node;
1152       return true;
1153     }
1154   return false;
1155 }
1156
1157 /* If NODE can not be overwriten by static or dynamic linker to point to different
1158    definition, return NODE. Otherwise look for alias with such property and if
1159    none exists, introduce new one.  */
1160
1161 symtab_node *
1162 symtab_nonoverwritable_alias (symtab_node *node)
1163 {
1164   tree new_decl;
1165   symtab_node *new_node = NULL;
1166
1167   /* First try to look up existing alias or base object
1168      (if that is already non-overwritable).  */
1169   node = symtab_alias_ultimate_target (node, NULL);
1170   gcc_assert (!node->alias && !node->weakref);
1171   symtab_for_node_and_aliases (node, symtab_nonoverwritable_alias_1,
1172                                (void *)&new_node, true);
1173   if (new_node)
1174     return new_node;
1175 #ifndef ASM_OUTPUT_DEF
1176   /* If aliases aren't supported by the assembler, fail.  */
1177   return NULL;
1178 #endif
1179
1180   /* Otherwise create a new one.  */
1181   new_decl = copy_node (node->decl);
1182   DECL_NAME (new_decl) = clone_function_name (node->decl, "localalias");
1183   if (TREE_CODE (new_decl) == FUNCTION_DECL)
1184     DECL_STRUCT_FUNCTION (new_decl) = NULL;
1185   DECL_INITIAL (new_decl) = NULL;
1186   SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1187   SET_DECL_RTL (new_decl, NULL);
1188
1189   /* Update the properties.  */
1190   DECL_EXTERNAL (new_decl) = 0;
1191   if (DECL_ONE_ONLY (node->decl))
1192     DECL_SECTION_NAME (new_decl) = NULL;
1193   DECL_COMDAT_GROUP (new_decl) = 0;
1194   TREE_PUBLIC (new_decl) = 0;
1195   DECL_COMDAT (new_decl) = 0;
1196   DECL_WEAK (new_decl) = 0;
1197   DECL_VIRTUAL_P (new_decl) = 0;
1198   if (TREE_CODE (new_decl) == FUNCTION_DECL)
1199     {
1200       DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
1201       DECL_STATIC_DESTRUCTOR (new_decl) = 0;
1202       new_node = cgraph_create_function_alias
1203                                  (new_decl, node->decl);
1204     }
1205   else
1206     new_node = varpool_create_variable_alias (new_decl,
1207                                                             node->decl);
1208   symtab_resolve_alias (new_node, node);
1209   gcc_assert (decl_binds_to_current_def_p (new_decl));
1210   return new_node;
1211 }
1212
1213 /* Return true if A and B represents semantically equivalent symbols.  */
1214
1215 bool
1216 symtab_semantically_equivalent_p (symtab_node *a,
1217                                   symtab_node *b)
1218 {
1219   enum availability avail;
1220   symtab_node *ba;
1221   symtab_node *bb;
1222
1223   /* Equivalent functions are equivalent.  */
1224   if (a->decl == b->decl)
1225     return true;
1226
1227   /* If symbol is not overwritable by different implementation,
1228      walk to the base object it defines.  */
1229   ba = symtab_alias_ultimate_target (a, &avail);
1230   if (avail >= AVAIL_AVAILABLE)
1231     {
1232       if (ba == b)
1233         return true;
1234     }
1235   else
1236     ba = a;
1237   bb = symtab_alias_ultimate_target (b, &avail);
1238   if (avail >= AVAIL_AVAILABLE)
1239     {
1240       if (a == bb)
1241         return true;
1242     }
1243   else
1244     bb = b;
1245   return bb == ba;
1246 }
1247 #include "gt-symtab.h"