gcc/symtab.c

   1 /* Symbol table.
   2    Copyright (C) 2012-2014 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       /* Clear DECL_COMDAT_GROUP for comdat locals, since
 542          make_decl_local doesn't.  */
 543       if (!TREE_PUBLIC (n->decl))
 544         DECL_COMDAT_GROUP (n->decl) = NULL_TREE;
 545       n = next;
 546     }
 547   while (n != node);
 548 }
 549
 550 /* Return printable assembler name of NODE.
 551    This function is used only for debugging.  When assembler name
 552    is unknown go with identifier name.  */
 553
 554 const char *
 555 symtab_node::asm_name () const
 556 {
 557   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 558     return lang_hooks.decl_printable_name (decl, 2);
 559   return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 560 }
 561
 562 /* Return printable identifier name.  */
 563
 564 const char *
 565 symtab_node::name () const
 566 {
 567   return lang_hooks.decl_printable_name (decl, 2);
 568 }
 569
 570 static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
 571
 572 /* Dump base fields of symtab nodes.  Not to be used directly.  */
 573
 574 void
 575 dump_symtab_base (FILE *f, symtab_node *node)
 576 {
 577   static const char * const visibility_types[] = {
 578     "default", "protected", "hidden", "internal"
 579   };
 580
 581   fprintf (f, "%s/%i (%s)",
 582            node->asm_name (),
 583            node->order,
 584            node->name ());
 585   dump_addr (f, " @", (void *)node);
 586   fprintf (f, "\n  Type: %s", symtab_type_names[node->type]);
 587
 588   if (node->definition)
 589     fprintf (f, " definition");
 590   if (node->analyzed)
 591     fprintf (f, " analyzed");
 592   if (node->alias)
 593     fprintf (f, " alias");
 594   if (node->weakref)
 595     fprintf (f, " weakref");
 596   if (node->cpp_implicit_alias)
 597     fprintf (f, " cpp_implicit_alias");
 598   if (node->alias_target)
 599     fprintf (f, " target:%s",
 600              DECL_P (node->alias_target)
 601              ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
 602                                      (node->alias_target))
 603              : IDENTIFIER_POINTER (node->alias_target));
 604   fprintf (f, "\n  Visibility:");
 605   if (node->in_other_partition)
 606     fprintf (f, " in_other_partition");
 607   if (node->used_from_other_partition)
 608     fprintf (f, " used_from_other_partition");
 609   if (node->force_output)
 610     fprintf (f, " force_output");
 611   if (node->forced_by_abi)
 612     fprintf (f, " forced_by_abi");
 613   if (node->externally_visible)
 614     fprintf (f, " externally_visible");
 615   if (node->resolution != LDPR_UNKNOWN)
 616     fprintf (f, " %s",
 617              ld_plugin_symbol_resolution_names[(int)node->resolution]);
 618   if (TREE_ASM_WRITTEN (node->decl))
 619     fprintf (f, " asm_written");
 620   if (DECL_EXTERNAL (node->decl))
 621     fprintf (f, " external");
 622   if (TREE_PUBLIC (node->decl))
 623     fprintf (f, " public");
 624   if (DECL_COMMON (node->decl))
 625     fprintf (f, " common");
 626   if (DECL_WEAK (node->decl))
 627     fprintf (f, " weak");
 628   if (DECL_DLLIMPORT_P (node->decl))
 629     fprintf (f, " dll_import");
 630   if (DECL_COMDAT (node->decl))
 631     fprintf (f, " comdat");
 632   if (DECL_COMDAT_GROUP (node->decl))
 633     fprintf (f, " comdat_group:%s",
 634              IDENTIFIER_POINTER (DECL_COMDAT_GROUP (node->decl)));
 635   if (DECL_ONE_ONLY (node->decl))
 636     fprintf (f, " one_only");
 637   if (DECL_SECTION_NAME (node->decl))
 638     fprintf (f, " section_name:%s",
 639              TREE_STRING_POINTER (DECL_SECTION_NAME (node->decl)));
 640   if (DECL_VISIBILITY_SPECIFIED (node->decl))
 641     fprintf (f, " visibility_specified");
 642   if (DECL_VISIBILITY (node->decl))
 643     fprintf (f, " visibility:%s",
 644              visibility_types [DECL_VISIBILITY (node->decl)]);
 645   if (DECL_VIRTUAL_P (node->decl))
 646     fprintf (f, " virtual");
 647   if (DECL_ARTIFICIAL (node->decl))
 648     fprintf (f, " artificial");
 649   if (TREE_CODE (node->decl) == FUNCTION_DECL)
 650     {
 651       if (DECL_STATIC_CONSTRUCTOR (node->decl))
 652         fprintf (f, " constructor");
 653       if (DECL_STATIC_DESTRUCTOR (node->decl))
 654         fprintf (f, " destructor");
 655     }
 656   fprintf (f, "\n");
 657
 658   if (node->same_comdat_group)
 659     fprintf (f, "  Same comdat group as: %s/%i\n",
 660              node->same_comdat_group->asm_name (),
 661              node->same_comdat_group->order);
 662   if (node->next_sharing_asm_name)
 663     fprintf (f, "  next sharing asm name: %i\n",
 664              node->next_sharing_asm_name->order);
 665   if (node->previous_sharing_asm_name)
 666     fprintf (f, "  previous sharing asm name: %i\n",
 667              node->previous_sharing_asm_name->order);
 668
 669   if (node->address_taken)
 670     fprintf (f, "  Address is taken.\n");
 671   if (node->aux)
 672     {
 673       fprintf (f, "  Aux:");
 674       dump_addr (f, " @", (void *)node->aux);
 675     }
 676
 677   fprintf (f, "  References: ");
 678   ipa_dump_references (f, &node->ref_list);
 679   fprintf (f, "  Referring: ");
 680   ipa_dump_referring (f, &node->ref_list);
 681   if (node->lto_file_data)
 682     fprintf (f, "  Read from file: %s\n",
 683              node->lto_file_data->file_name);
 684 }
 685
 686 /* Dump symtab node.  */
 687
 688 void
 689 dump_symtab_node (FILE *f, symtab_node *node)
 690 {
 691   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 692     dump_cgraph_node (f, cnode);
 693   else if (varpool_node *vnode = dyn_cast <varpool_node> (node))
 694     dump_varpool_node (f, vnode);
 695 }
 696
 697 /* Dump symbol table.  */
 698
 699 void
 700 dump_symtab (FILE *f)
 701 {
 702   symtab_node *node;
 703   fprintf (f, "Symbol table:\n\n");
 704   FOR_EACH_SYMBOL (node)
 705     dump_symtab_node (f, node);
 706 }
 707
 708 /* Dump symtab node NODE to stderr.  */
 709
 710 DEBUG_FUNCTION void
 711 debug_symtab_node (symtab_node *node)
 712 {
 713   dump_symtab_node (stderr, node);
 714 }
 715
 716 /* Dump symbol table to stderr.  */
 717
 718 DEBUG_FUNCTION void
 719 debug_symtab (void)
 720 {
 721   dump_symtab (stderr);
 722 }
 723
 724 /* Verify common part of symtab nodes.  */
 725
 726 DEBUG_FUNCTION bool
 727 verify_symtab_base (symtab_node *node)
 728 {
 729   bool error_found = false;
 730   symtab_node *hashed_node;
 731
 732   if (is_a <cgraph_node> (node))
 733     {
 734       if (TREE_CODE (node->decl) != FUNCTION_DECL)
 735         {
 736           error ("function symbol is not function");
 737           error_found = true;
 738         }
 739     }
 740   else if (is_a <varpool_node> (node))
 741     {
 742       if (TREE_CODE (node->decl) != VAR_DECL)
 743         {
 744           error ("variable symbol is not variable");
 745           error_found = true;
 746         }
 747     }
 748   else
 749     {
 750       error ("node has unknown type");
 751       error_found = true;
 752     }
 753
 754   if (cgraph_state != CGRAPH_LTO_STREAMING)
 755     {
 756       hashed_node = symtab_get_node (node->decl);
 757       if (!hashed_node)
 758         {
 759           error ("node not found in symtab decl hashtable");
 760           error_found = true;
 761         }
 762       if (hashed_node != node
 763           && (!is_a <cgraph_node> (node)
 764               || !dyn_cast <cgraph_node> (node)->clone_of
 765               || dyn_cast <cgraph_node> (node)->clone_of->decl
 766                  != node->decl))
 767         {
 768           error ("node differs from symtab decl hashtable");
 769           error_found = true;
 770         }
 771     }
 772   if (assembler_name_hash)
 773     {
 774       hashed_node = symtab_node_for_asm (DECL_ASSEMBLER_NAME (node->decl));
 775       if (hashed_node && hashed_node->previous_sharing_asm_name)
 776         {
 777           error ("assembler name hash list corrupted");
 778           error_found = true;
 779         }
 780       while (hashed_node)
 781         {
 782           if (hashed_node == node)
 783             break;
 784           hashed_node = hashed_node->next_sharing_asm_name;
 785         }
 786       if (!hashed_node
 787           && !(is_a <varpool_node> (node)
 788                || DECL_HARD_REGISTER (node->decl)))
 789         {
 790           error ("node not found in symtab assembler name hash");
 791           error_found = true;
 792         }
 793     }
 794   if (node->previous_sharing_asm_name
 795       && node->previous_sharing_asm_name->next_sharing_asm_name != node)
 796     {
 797       error ("double linked list of assembler names corrupted");
 798       error_found = true;
 799     }
 800   if (node->analyzed && !node->definition)
 801     {
 802       error ("node is analyzed byt it is not a definition");
 803       error_found = true;
 804     }
 805   if (node->cpp_implicit_alias && !node->alias)
 806     {
 807       error ("node is alias but not implicit alias");
 808       error_found = true;
 809     }
 810   if (node->alias && !node->definition
 811       && !node->weakref)
 812     {
 813       error ("node is alias but not definition");
 814       error_found = true;
 815     }
 816   if (node->weakref && !node->alias)
 817     {
 818       error ("node is weakref but not an alias");
 819       error_found = true;
 820     }
 821   if (node->same_comdat_group)
 822     {
 823       symtab_node *n = node->same_comdat_group;
 824
 825       if (!DECL_ONE_ONLY (n->decl))
 826         {
 827           error ("non-DECL_ONE_ONLY node in a same_comdat_group list");
 828           error_found = true;
 829         }
 830       if (n->type != node->type)
 831         {
 832           error ("mixing different types of symbol in same comdat groups is not supported");
 833           error_found = true;
 834         }
 835       if (n == node)
 836         {
 837           error ("node is alone in a comdat group");
 838           error_found = true;
 839         }
 840       do
 841         {
 842           if (!n->same_comdat_group)
 843             {
 844               error ("same_comdat_group is not a circular list");
 845               error_found = true;
 846               break;
 847             }
 848           n = n->same_comdat_group;
 849         }
 850       while (n != node);
 851       if (symtab_comdat_local_p (node))
 852         {
 853           struct ipa_ref_list *refs = &node->ref_list;
 854           struct ipa_ref *ref;
 855           for (int i = 0; ipa_ref_list_referring_iterate (refs, i, ref); ++i)
 856             {
 857               if (!symtab_in_same_comdat_p (ref->referring, node))
 858                 {
 859                   error ("comdat-local symbol referred to by %s outside its "
 860                          "comdat",
 861                          identifier_to_locale (ref->referring->name()));
 862                   error_found = true;
 863                 }
 864             }
 865         }
 866     }
 867   return error_found;
 868 }
 869
 870 /* Verify consistency of NODE.  */
 871
 872 DEBUG_FUNCTION void
 873 verify_symtab_node (symtab_node *node)
 874 {
 875   if (seen_error ())
 876     return;
 877
 878   timevar_push (TV_CGRAPH_VERIFY);
 879   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 880     verify_cgraph_node (cnode);
 881   else
 882     if (verify_symtab_base (node))
 883       {
 884         dump_symtab_node (stderr, node);
 885         internal_error ("verify_symtab_node failed");
 886       }
 887   timevar_pop (TV_CGRAPH_VERIFY);
 888 }
 889
 890 /* Verify symbol table for internal consistency.  */
 891
 892 DEBUG_FUNCTION void
 893 verify_symtab (void)
 894 {
 895   symtab_node *node;
 896   FOR_EACH_SYMBOL (node)
 897    verify_symtab_node (node);
 898 }
 899
 900 /* Return true when RESOLUTION indicate that linker will use
 901    the symbol from non-LTO object files.  */
 902
 903 bool
 904 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
 905 {
 906   return (resolution == LDPR_PREVAILING_DEF
 907           || resolution == LDPR_PREEMPTED_REG
 908           || resolution == LDPR_RESOLVED_EXEC
 909           || resolution == LDPR_RESOLVED_DYN);
 910 }
 911
 912 /* Return true when NODE is known to be used from other (non-LTO) object file.
 913    Known only when doing LTO via linker plugin.  */
 914
 915 bool
 916 symtab_used_from_object_file_p (symtab_node *node)
 917 {
 918   if (!TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl))
 919     return false;
 920   if (resolution_used_from_other_file_p (node->resolution))
 921     return true;
 922   return false;
 923 }
 924
 925 /* Make DECL local.  FIXME: We shouldn't need to mess with rtl this early,
 926    but other code such as notice_global_symbol generates rtl.  */
 927
 928 void
 929 symtab_make_decl_local (tree decl)
 930 {
 931   rtx rtl, symbol;
 932
 933   /* Avoid clearing DECL_COMDAT_GROUP on comdat-local decls.  */
 934   if (TREE_PUBLIC (decl) == 0)
 935     return;
 936
 937   if (TREE_CODE (decl) == VAR_DECL)
 938     DECL_COMMON (decl) = 0;
 939   else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 940
 941   if (DECL_ONE_ONLY (decl) || DECL_COMDAT (decl))
 942     {
 943       DECL_SECTION_NAME (decl) = 0;
 944       DECL_COMDAT (decl) = 0;
 945     }
 946   DECL_COMDAT_GROUP (decl) = 0;
 947   DECL_WEAK (decl) = 0;
 948   DECL_EXTERNAL (decl) = 0;
 949   DECL_VISIBILITY_SPECIFIED (decl) = 0;
 950   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
 951   TREE_PUBLIC (decl) = 0;
 952   if (!DECL_RTL_SET_P (decl))
 953     return;
 954
 955   /* Update rtl flags.  */
 956   make_decl_rtl (decl);
 957
 958   rtl = DECL_RTL (decl);
 959   if (!MEM_P (rtl))
 960     return;
 961
 962   symbol = XEXP (rtl, 0);
 963   if (GET_CODE (symbol) != SYMBOL_REF)
 964     return;
 965
 966   SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
 967 }
 968
 969 /* Return availability of NODE.  */
 970
 971 enum availability
 972 symtab_node_availability (symtab_node *node)
 973 {
 974   if (is_a <cgraph_node> (node))
 975     return cgraph_function_body_availability (cgraph (node));
 976   else
 977     return cgraph_variable_initializer_availability (varpool (node));
 978 }
 979
 980 /* Given NODE, walk the alias chain to return the symbol NODE is alias of.
 981    If NODE is not an alias, return NODE.
 982    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
 983
 984 symtab_node *
 985 symtab_alias_ultimate_target (symtab_node *node, enum availability *availability)
 986 {
 987   bool weakref_p = false;
 988
 989   if (!node->alias)
 990     {
 991       if (availability)
 992         *availability = symtab_node_availability (node);
 993       return node;
 994     }
 995
 996   /* To determine visibility of the target, we follow ELF semantic of aliases.
 997      Here alias is an alternative assembler name of a given definition. Its
 998      availability prevails the availability of its target (i.e. static alias of
 999      weak definition is available.
1000
1001      Weakref is a different animal (and not part of ELF per se). It is just
1002      alternative name of a given symbol used within one complation unit
1003      and is translated prior hitting the object file.  It inherits the
1004      visibility of its target (i.e. weakref of non-overwritable definition
1005      is non-overwritable, while weakref of weak definition is weak).
1006
1007      If we ever get into supporting targets with different semantics, a target
1008      hook will be needed here.  */
1009
1010   if (availability)
1011     {
1012       weakref_p = node->weakref;
1013       if (!weakref_p)
1014         *availability = symtab_node_availability (node);
1015       else
1016         *availability = AVAIL_LOCAL;
1017     }
1018   while (node)
1019     {
1020       if (node->alias && node->analyzed)
1021         node = symtab_alias_target (node);
1022       else
1023         {
1024           if (!availability)
1025             ;
1026           else if (node->analyzed)
1027             {
1028               if (weakref_p)
1029                 {
1030                   enum availability a = symtab_node_availability (node);
1031                   if (a < *availability)
1032                     *availability = a;
1033                 }
1034             }
1035           else
1036             *availability = AVAIL_NOT_AVAILABLE;
1037           return node;
1038         }
1039       if (node && availability && weakref_p)
1040         {
1041           enum availability a = symtab_node_availability (node);
1042           if (a < *availability)
1043             *availability = a;
1044           weakref_p = node->weakref;
1045         }
1046     }
1047   if (availability)
1048     *availability = AVAIL_NOT_AVAILABLE;
1049   return NULL;
1050 }
1051
1052 /* C++ FE sometimes change linkage flags after producing same body aliases.
1053
1054    FIXME: C++ produce implicit aliases for virtual functions and vtables that
1055    are obviously equivalent.  The way it is doing so is however somewhat
1056    kludgy and interferes with the visibility code. As a result we need to
1057    copy the visibility from the target to get things right.  */
1058
1059 void
1060 fixup_same_cpp_alias_visibility (symtab_node *node, symtab_node *target)
1061 {
1062   if (is_a <cgraph_node> (node))
1063     {
1064       DECL_DECLARED_INLINE_P (node->decl)
1065          = DECL_DECLARED_INLINE_P (target->decl);
1066       DECL_DISREGARD_INLINE_LIMITS (node->decl)
1067          = DECL_DISREGARD_INLINE_LIMITS (target->decl);
1068     }
1069   /* FIXME: It is not really clear why those flags should not be copied for
1070      functions, too.  */
1071   else
1072     {
1073       DECL_WEAK (node->decl) = DECL_WEAK (target->decl);
1074       DECL_EXTERNAL (node->decl) = DECL_EXTERNAL (target->decl);
1075       DECL_VISIBILITY (node->decl) = DECL_VISIBILITY (target->decl);
1076     }
1077   DECL_VIRTUAL_P (node->decl) = DECL_VIRTUAL_P (target->decl);
1078   if (TREE_PUBLIC (node->decl))
1079     {
1080       DECL_EXTERNAL (node->decl) = DECL_EXTERNAL (target->decl);
1081       DECL_COMDAT (node->decl) = DECL_COMDAT (target->decl);
1082       DECL_COMDAT_GROUP (node->decl)
1083          = DECL_COMDAT_GROUP (target->decl);
1084       if (DECL_ONE_ONLY (target->decl)
1085           && !node->same_comdat_group)
1086         symtab_add_to_same_comdat_group (node, target);
1087     }
1088   node->externally_visible = target->externally_visible;
1089 }
1090
1091 /* Add reference recording that NODE is alias of TARGET.
1092    The function can fail in the case of aliasing cycles; in this case
1093    it returns false.  */
1094
1095 bool
1096 symtab_resolve_alias (symtab_node *node, symtab_node *target)
1097 {
1098   symtab_node *n;
1099
1100   gcc_assert (!node->analyzed
1101               && !vec_safe_length (node->ref_list.references));
1102
1103   /* Never let cycles to creep into the symbol table alias references;
1104      those will make alias walkers to be infinite.  */
1105   for (n = target; n && n->alias;
1106        n = n->analyzed ? symtab_alias_target (n) : NULL)
1107     if (n == node)
1108        {
1109          if (is_a <cgraph_node> (node))
1110            error ("function %q+D part of alias cycle", node->decl);
1111          else if (is_a <varpool_node> (node))
1112            error ("variable %q+D part of alias cycle", node->decl);
1113          else
1114            gcc_unreachable ();
1115          node->alias = false;
1116          return false;
1117        }
1118
1119   /* "analyze" the node - i.e. mark the reference.  */
1120   node->definition = true;
1121   node->alias = true;
1122   node->analyzed = true;
1123   ipa_record_reference (node, target, IPA_REF_ALIAS, NULL);
1124
1125   /* Alias targets become reudndant after alias is resolved into an reference.
1126      We do not want to keep it around or we would have to mind updating them
1127      when renaming symbols.  */
1128   node->alias_target = NULL;
1129
1130   if (node->cpp_implicit_alias && cgraph_state >= CGRAPH_STATE_CONSTRUCTION)
1131     fixup_same_cpp_alias_visibility (node, target);
1132
1133   /* If alias has address taken, so does the target.  */
1134   if (node->address_taken)
1135     symtab_alias_ultimate_target (target, NULL)->address_taken = true;
1136   return true;
1137 }
1138
1139 /* Call calback on NODE and aliases associated to NODE.
1140    When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1141    skipped. */
1142
1143 bool
1144 symtab_for_node_and_aliases (symtab_node *node,
1145                              bool (*callback) (symtab_node *, void *),
1146                              void *data,
1147                              bool include_overwritable)
1148 {
1149   int i;
1150   struct ipa_ref *ref;
1151
1152   if (callback (node, data))
1153     return true;
1154   for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
1155     if (ref->use == IPA_REF_ALIAS)
1156       {
1157         symtab_node *alias = ref->referring;
1158         if (include_overwritable
1159             || symtab_node_availability (alias) > AVAIL_OVERWRITABLE)
1160           if (symtab_for_node_and_aliases (alias, callback, data,
1161                                            include_overwritable))
1162             return true;
1163       }
1164   return false;
1165 }
1166
1167 /* Worker searching nonoverwritable alias.  */
1168
1169 static bool
1170 symtab_nonoverwritable_alias_1 (symtab_node *node, void *data)
1171 {
1172   if (decl_binds_to_current_def_p (node->decl))
1173     {
1174       *(symtab_node **)data = node;
1175       return true;
1176     }
1177   return false;
1178 }
1179
1180 /* If NODE can not be overwriten by static or dynamic linker to point to different
1181    definition, return NODE. Otherwise look for alias with such property and if
1182    none exists, introduce new one.  */
1183
1184 symtab_node *
1185 symtab_nonoverwritable_alias (symtab_node *node)
1186 {
1187   tree new_decl;
1188   symtab_node *new_node = NULL;
1189
1190   /* First try to look up existing alias or base object
1191      (if that is already non-overwritable).  */
1192   node = symtab_alias_ultimate_target (node, NULL);
1193   gcc_assert (!node->alias && !node->weakref);
1194   symtab_for_node_and_aliases (node, symtab_nonoverwritable_alias_1,
1195                                (void *)&new_node, true);
1196   if (new_node)
1197     return new_node;
1198 #ifndef ASM_OUTPUT_DEF
1199   /* If aliases aren't supported by the assembler, fail.  */
1200   return NULL;
1201 #endif
1202
1203   /* Otherwise create a new one.  */
1204   new_decl = copy_node (node->decl);
1205   DECL_NAME (new_decl) = clone_function_name (node->decl, "localalias");
1206   if (TREE_CODE (new_decl) == FUNCTION_DECL)
1207     DECL_STRUCT_FUNCTION (new_decl) = NULL;
1208   DECL_INITIAL (new_decl) = NULL;
1209   SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1210   SET_DECL_RTL (new_decl, NULL);
1211
1212   /* Update the properties.  */
1213   DECL_EXTERNAL (new_decl) = 0;
1214   if (DECL_ONE_ONLY (node->decl))
1215     DECL_SECTION_NAME (new_decl) = NULL;
1216   DECL_COMDAT_GROUP (new_decl) = 0;
1217   TREE_PUBLIC (new_decl) = 0;
1218   DECL_COMDAT (new_decl) = 0;
1219   DECL_WEAK (new_decl) = 0;
1220   DECL_VIRTUAL_P (new_decl) = 0;
1221   if (TREE_CODE (new_decl) == FUNCTION_DECL)
1222     {
1223       DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
1224       DECL_STATIC_DESTRUCTOR (new_decl) = 0;
1225       new_node = cgraph_create_function_alias
1226                                  (new_decl, node->decl);
1227     }
1228   else
1229     new_node = varpool_create_variable_alias (new_decl,
1230                                                             node->decl);
1231   symtab_resolve_alias (new_node, node);
1232   gcc_assert (decl_binds_to_current_def_p (new_decl));
1233   return new_node;
1234 }
1235
1236 /* Return true if A and B represents semantically equivalent symbols.  */
1237
1238 bool
1239 symtab_semantically_equivalent_p (symtab_node *a,
1240                                   symtab_node *b)
1241 {
1242   enum availability avail;
1243   symtab_node *ba;
1244   symtab_node *bb;
1245
1246   /* Equivalent functions are equivalent.  */
1247   if (a->decl == b->decl)
1248     return true;
1249
1250   /* If symbol is not overwritable by different implementation,
1251      walk to the base object it defines.  */
1252   ba = symtab_alias_ultimate_target (a, &avail);
1253   if (avail >= AVAIL_AVAILABLE)
1254     {
1255       if (ba == b)
1256         return true;
1257     }
1258   else
1259     ba = a;
1260   bb = symtab_alias_ultimate_target (b, &avail);
1261   if (avail >= AVAIL_AVAILABLE)
1262     {
1263       if (a == bb)
1264         return true;
1265     }
1266   else
1267     bb = b;
1268   return bb == ba;
1269 }
1270
1271 /* Classify symbol NODE for partitioning.  */
1272
1273 enum symbol_partitioning_class
1274 symtab_get_symbol_partitioning_class (symtab_node *node)
1275 {
1276   /* Inline clones are always duplicated.
1277      This include external delcarations.   */
1278   cgraph_node *cnode = dyn_cast <cgraph_node> (node);
1279
1280   if (DECL_ABSTRACT (node->decl))
1281     return SYMBOL_EXTERNAL;
1282
1283   if (cnode && cnode->global.inlined_to)
1284     return SYMBOL_DUPLICATE;
1285
1286   /* Weakref aliases are always duplicated.  */
1287   if (node->weakref)
1288     return SYMBOL_DUPLICATE;
1289
1290   /* External declarations are external.  */
1291   if (DECL_EXTERNAL (node->decl))
1292     return SYMBOL_EXTERNAL;
1293
1294   if (varpool_node *vnode = dyn_cast <varpool_node> (node))
1295     {
1296       /* Constant pool references use local symbol names that can not
1297          be promoted global.  We should never put into a constant pool
1298          objects that can not be duplicated across partitions.  */
1299       if (DECL_IN_CONSTANT_POOL (node->decl))
1300         return SYMBOL_DUPLICATE;
1301       gcc_checking_assert (vnode->definition);
1302     }
1303   /* Functions that are cloned may stay in callgraph even if they are unused.
1304      Handle them as external; compute_ltrans_boundary take care to make
1305      proper things to happen (i.e. to make them appear in the boundary but
1306      with body streamed, so clone can me materialized).  */
1307   else if (!cgraph (node)->definition)
1308     return SYMBOL_EXTERNAL;
1309
1310   /* Linker discardable symbols are duplicated to every use unless they are
1311      keyed.
1312      Keyed symbols or those.  */
1313   if (DECL_ONE_ONLY (node->decl)
1314       && !node->force_output
1315       && !node->forced_by_abi
1316       && !symtab_used_from_object_file_p (node))
1317     return SYMBOL_DUPLICATE;
1318
1319   return SYMBOL_PARTITION;
1320 }
1321 #include "gt-symtab.h"