LCOV - code coverage report
Current view: top level - gcc - symtab.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 974 1154 84.4 %
Date: 2020-04-04 11:58:09 Functions: 72 79 91.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Symbol table.
       2                 :            :    Copyright (C) 2012-2020 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 "backend.h"
      25                 :            : #include "target.h"
      26                 :            : #include "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "gimple.h"
      29                 :            : #include "timevar.h"
      30                 :            : #include "cgraph.h"
      31                 :            : #include "lto-streamer.h"
      32                 :            : #include "print-tree.h"
      33                 :            : #include "varasm.h"
      34                 :            : #include "langhooks.h"
      35                 :            : #include "output.h"
      36                 :            : #include "ipa-utils.h"
      37                 :            : #include "calls.h"
      38                 :            : #include "stringpool.h"
      39                 :            : #include "attribs.h"
      40                 :            : #include "builtins.h"
      41                 :            : 
      42                 :            : static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
      43                 :            : 
      44                 :            : const char * const ld_plugin_symbol_resolution_names[]=
      45                 :            : {
      46                 :            :   "",
      47                 :            :   "undef",
      48                 :            :   "prevailing_def",
      49                 :            :   "prevailing_def_ironly",
      50                 :            :   "preempted_reg",
      51                 :            :   "preempted_ir",
      52                 :            :   "resolved_ir",
      53                 :            :   "resolved_exec",
      54                 :            :   "resolved_dyn",
      55                 :            :   "prevailing_def_ironly_exp"
      56                 :            : };
      57                 :            : 
      58                 :            : /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
      59                 :            :    until we find an identifier that is not itself a transparent alias.  */
      60                 :            : 
      61                 :            : static inline tree
      62                 :        182 : ultimate_transparent_alias_target (tree alias)
      63                 :            : {
      64                 :        182 :   tree target = alias;
      65                 :            : 
      66                 :        182 :   while (IDENTIFIER_TRANSPARENT_ALIAS (target))
      67                 :            :     {
      68                 :          0 :       gcc_checking_assert (TREE_CHAIN (target));
      69                 :        182 :       target = TREE_CHAIN (target);
      70                 :            :     }
      71                 :        182 :   gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
      72                 :            :                        && ! TREE_CHAIN (target));
      73                 :            : 
      74                 :        182 :   return target;
      75                 :            : }
      76                 :            : 
      77                 :            : 
      78                 :            : /* Hash asmnames ignoring the user specified marks.  */
      79                 :            : 
      80                 :            : hashval_t
      81                 :  772989000 : symbol_table::decl_assembler_name_hash (const_tree asmname)
      82                 :            : {
      83                 :  772989000 :   if (IDENTIFIER_POINTER (asmname)[0] == '*')
      84                 :            :     {
      85                 :    3130000 :       const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
      86                 :    3130000 :       size_t ulp_len = strlen (user_label_prefix);
      87                 :            : 
      88                 :    3130000 :       if (ulp_len == 0)
      89                 :            :         ;
      90                 :        112 :       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
      91                 :        112 :         decl_str += ulp_len;
      92                 :            : 
      93                 :    3130000 :       return htab_hash_string (decl_str);
      94                 :            :     }
      95                 :            : 
      96                 :  769859000 :   return htab_hash_string (IDENTIFIER_POINTER (asmname));
      97                 :            : }
      98                 :            : 
      99                 :            : /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
     100                 :            :    name.  */
     101                 :            : 
     102                 :            : bool
     103                 :  640729000 : symbol_table::assembler_names_equal_p (const char *name1, const char *name2)
     104                 :            : {
     105                 :  640729000 :   if (name1 != name2)
     106                 :            :     {
     107                 :  640729000 :       if (name1[0] == '*')
     108                 :            :         {
     109                 :    2468750 :           size_t ulp_len = strlen (user_label_prefix);
     110                 :            : 
     111                 :    2468750 :           name1 ++;
     112                 :            : 
     113                 :    2468750 :           if (ulp_len == 0)
     114                 :            :             ;
     115                 :         39 :           else if (strncmp (name1, user_label_prefix, ulp_len) == 0)
     116                 :         39 :             name1 += ulp_len;
     117                 :            :           else
     118                 :            :             return false;
     119                 :            :         }
     120                 :  640729000 :       if (name2[0] == '*')
     121                 :            :         {
     122                 :    2542320 :           size_t ulp_len = strlen (user_label_prefix);
     123                 :            : 
     124                 :    2542320 :           name2 ++;
     125                 :            : 
     126                 :    2542320 :           if (ulp_len == 0)
     127                 :            :             ;
     128                 :         24 :           else if (strncmp (name2, user_label_prefix, ulp_len) == 0)
     129                 :         24 :             name2 += ulp_len;
     130                 :            :           else
     131                 :            :             return false;
     132                 :            :         }
     133                 :  640729000 :       return !strcmp (name1, name2);
     134                 :            :     }
     135                 :            :   return true;
     136                 :            : }
     137                 :            : 
     138                 :            : /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
     139                 :            : 
     140                 :            : bool
     141                 :  752329000 : symbol_table::decl_assembler_name_equal (tree decl, const_tree asmname)
     142                 :            : {
     143                 :  752329000 :   tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
     144                 :  752329000 :   const char *decl_str;
     145                 :  752329000 :   const char *asmname_str;
     146                 :            : 
     147                 :  752329000 :   if (decl_asmname == asmname)
     148                 :            :     return true;
     149                 :            : 
     150                 :  640729000 :   decl_str = IDENTIFIER_POINTER (decl_asmname);
     151                 :  640729000 :   asmname_str = IDENTIFIER_POINTER (asmname);
     152                 :  640729000 :   return assembler_names_equal_p (decl_str, asmname_str);
     153                 :            : }
     154                 :            : 
     155                 :            : 
     156                 :            : /* Returns nonzero if P1 and P2 are equal.  */
     157                 :            : 
     158                 :            : /* Insert NODE to assembler name hash.  */
     159                 :            : 
     160                 :            : void
     161                 :   85829000 : symbol_table::insert_to_assembler_name_hash (symtab_node *node,
     162                 :            :                                              bool with_clones)
     163                 :            : {
     164                 :  105870000 :   if (is_a <varpool_node *> (node) && DECL_HARD_REGISTER (node->decl))
     165                 :            :     return;
     166                 :   85828900 :   gcc_checking_assert (!node->previous_sharing_asm_name
     167                 :            :                        && !node->next_sharing_asm_name);
     168                 :   85828900 :   if (assembler_name_hash)
     169                 :            :     {
     170                 :   39096800 :       symtab_node **aslot;
     171                 :   39096800 :       cgraph_node *cnode;
     172                 :   39096800 :       tree decl = node->decl;
     173                 :            : 
     174                 :   39096800 :       tree name = DECL_ASSEMBLER_NAME (node->decl);
     175                 :            : 
     176                 :            :       /* C++ FE can produce decls without associated assembler name and insert
     177                 :            :          them to symtab to hold section or TLS information.  */
     178                 :   39096800 :       if (!name)
     179                 :            :         return;
     180                 :            : 
     181                 :   39096800 :       hashval_t hash = decl_assembler_name_hash (name);
     182                 :   39096800 :       aslot = assembler_name_hash->find_slot_with_hash (name, hash, INSERT);
     183                 :   39096800 :       gcc_assert (*aslot != node);
     184                 :   39096800 :       node->next_sharing_asm_name = (symtab_node *)*aslot;
     185                 :   39096800 :       if (*aslot != NULL)
     186                 :    1674250 :         (*aslot)->previous_sharing_asm_name = node;
     187                 :   39096800 :       *aslot = node;
     188                 :            : 
     189                 :            :       /* Update also possible inline clones sharing a decl.  */
     190                 :   39096800 :       cnode = dyn_cast <cgraph_node *> (node);
     191                 :   29110900 :       if (cnode && cnode->clones && with_clones)
     192                 :         16 :         for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
     193                 :         10 :           if (cnode->decl == decl)
     194                 :          2 :             insert_to_assembler_name_hash (cnode, true);
     195                 :            :     }
     196                 :            : 
     197                 :            : }
     198                 :            : 
     199                 :            : /* Remove NODE from assembler name hash.  */
     200                 :            : 
     201                 :            : void
     202                 :   55653100 : symbol_table::unlink_from_assembler_name_hash (symtab_node *node,
     203                 :            :                                                bool with_clones)
     204                 :            : {
     205                 :   55653100 :   if (assembler_name_hash)
     206                 :            :     {
     207                 :   33895600 :       cgraph_node *cnode;
     208                 :   33895600 :       tree decl = node->decl;
     209                 :            : 
     210                 :   33895600 :       if (node->next_sharing_asm_name)
     211                 :    1409820 :         node->next_sharing_asm_name->previous_sharing_asm_name
     212                 :    1409820 :           = node->previous_sharing_asm_name;
     213                 :   33895600 :       if (node->previous_sharing_asm_name)
     214                 :            :         {
     215                 :     511675 :           node->previous_sharing_asm_name->next_sharing_asm_name
     216                 :     511675 :             = node->next_sharing_asm_name;
     217                 :            :         }
     218                 :            :       else
     219                 :            :         {
     220                 :   33383900 :           tree name = DECL_ASSEMBLER_NAME (node->decl);
     221                 :   33383900 :           symtab_node **slot;
     222                 :            : 
     223                 :   33383900 :           if (!name)
     224                 :            :             return;
     225                 :            : 
     226                 :   33383900 :           hashval_t hash = decl_assembler_name_hash (name);
     227                 :   33383900 :           slot = assembler_name_hash->find_slot_with_hash (name, hash,
     228                 :            :                                                            NO_INSERT);
     229                 :   33383900 :           gcc_assert (*slot == node);
     230                 :   33383900 :           if (!node->next_sharing_asm_name)
     231                 :   32318500 :             assembler_name_hash->clear_slot (slot);
     232                 :            :           else
     233                 :    1065380 :             *slot = node->next_sharing_asm_name;
     234                 :            :         }
     235                 :   33895600 :       node->next_sharing_asm_name = NULL;
     236                 :   33895600 :       node->previous_sharing_asm_name = NULL;
     237                 :            : 
     238                 :            :       /* Update also possible inline clones sharing a decl.  */
     239                 :   33895600 :       cnode = dyn_cast <cgraph_node *> (node);
     240                 :   26581500 :       if (cnode && cnode->clones && with_clones)
     241                 :         16 :         for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
     242                 :         10 :           if (cnode->decl == decl)
     243                 :          2 :             unlink_from_assembler_name_hash (cnode, true);
     244                 :            :     }
     245                 :            : }
     246                 :            : 
     247                 :            : /* Arrange node to be first in its entry of assembler_name_hash.  */
     248                 :            : 
     249                 :            : void
     250                 :       1879 : symbol_table::symtab_prevail_in_asm_name_hash (symtab_node *node)
     251                 :            : {
     252                 :       1879 :   unlink_from_assembler_name_hash (node, false);
     253                 :       1879 :   insert_to_assembler_name_hash (node, false);
     254                 :       1879 : }
     255                 :            : 
     256                 :            : /* Initialize asm name hash unless.  */
     257                 :            : 
     258                 :            : void
     259                 :   73348300 : symbol_table::symtab_initialize_asm_name_hash (void)
     260                 :            : {
     261                 :   73348300 :   symtab_node *node;
     262                 :   73348300 :   if (!assembler_name_hash)
     263                 :            :     {
     264                 :     172445 :       assembler_name_hash = hash_table<asmname_hasher>::create_ggc (10);
     265                 :   37338300 :       FOR_EACH_SYMBOL (node)
     266                 :   37165800 :         insert_to_assembler_name_hash (node, false);
     267                 :            :     }
     268                 :   73348300 : }
     269                 :            : 
     270                 :            : /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables.  */
     271                 :            : 
     272                 :            : void
     273                 :    1325200 : symbol_table::change_decl_assembler_name (tree decl, tree name)
     274                 :            : {
     275                 :    1325200 :   symtab_node *node = NULL;
     276                 :            : 
     277                 :            :   /* We can have user ASM names on things, like global register variables, that
     278                 :            :      are not in the symbol table.  */
     279                 :      20422 :   if ((VAR_P (decl) && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
     280                 :    1325840 :       || TREE_CODE (decl) == FUNCTION_DECL)
     281                 :    1324570 :     node = symtab_node::get (decl);
     282                 :    1325200 :   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
     283                 :            :     {
     284                 :     672653 :       SET_DECL_ASSEMBLER_NAME (decl, name);
     285                 :     672653 :       if (node)
     286                 :         12 :         insert_to_assembler_name_hash (node, true);
     287                 :            :     }
     288                 :            :   else
     289                 :            :     {
     290                 :     652552 :       if (name == DECL_ASSEMBLER_NAME (decl))
     291                 :            :         return;
     292                 :            : 
     293                 :      76389 :       tree alias = (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl))
     294                 :          0 :                     ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
     295                 :      76389 :                     : NULL);
     296                 :      76389 :       if (node)
     297                 :       5424 :         unlink_from_assembler_name_hash (node, true);
     298                 :            : 
     299                 :      76389 :       const char *old_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
     300                 :      76389 :       if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
     301                 :      76389 :           && DECL_RTL_SET_P (decl))
     302                 :          0 :         warning (0, "%qD renamed after being referenced in assembly", decl);
     303                 :            : 
     304                 :      76389 :       SET_DECL_ASSEMBLER_NAME (decl, name);
     305                 :      76389 :       if (alias)
     306                 :            :         {
     307                 :          0 :           IDENTIFIER_TRANSPARENT_ALIAS (name) = 1;
     308                 :          0 :           TREE_CHAIN (name) = alias;
     309                 :            :         }
     310                 :            :       /* If we change assembler name, also all transparent aliases must
     311                 :            :          be updated.  There are three kinds - those having same assembler name,
     312                 :            :          those being renamed in varasm.c and weakref being renamed by the
     313                 :            :          assembler.  */
     314                 :      76389 :       if (node)
     315                 :            :         {
     316                 :       5424 :           insert_to_assembler_name_hash (node, true);
     317                 :       5424 :           ipa_ref *ref;
     318                 :       5546 :           for (unsigned i = 0; node->iterate_direct_aliases (i, ref); i++)
     319                 :            :             {
     320                 :         22 :               struct symtab_node *alias = ref->referring;
     321                 :         22 :               if (alias->transparent_alias && !alias->weakref
     322                 :         22 :                   && symbol_table::assembler_names_equal_p
     323                 :          0 :                          (old_name, IDENTIFIER_POINTER (
     324                 :            :                                       DECL_ASSEMBLER_NAME (alias->decl))))
     325                 :          0 :                 change_decl_assembler_name (alias->decl, name);
     326                 :         22 :               else if (alias->transparent_alias
     327                 :         22 :                        && IDENTIFIER_TRANSPARENT_ALIAS (alias->decl))
     328                 :            :                 {
     329                 :          0 :                   gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl))
     330                 :            :                               && IDENTIFIER_TRANSPARENT_ALIAS
     331                 :            :                                      (DECL_ASSEMBLER_NAME (alias->decl)));
     332                 :            : 
     333                 :          0 :                   TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl)) = 
     334                 :            :                     ultimate_transparent_alias_target
     335                 :          0 :                          (DECL_ASSEMBLER_NAME (node->decl));
     336                 :            :                 }
     337                 :            : #ifdef ASM_OUTPUT_WEAKREF
     338                 :         22 :              else gcc_assert (!alias->transparent_alias || alias->weakref);
     339                 :            : #else
     340                 :            :              else gcc_assert (!alias->transparent_alias);
     341                 :            : #endif
     342                 :            :             }
     343                 :       5424 :           gcc_assert (!node->transparent_alias || !node->definition
     344                 :            :                       || node->weakref
     345                 :            :                       || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
     346                 :            :                       || symbol_table::assembler_names_equal_p
     347                 :            :                           (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
     348                 :            :                            IDENTIFIER_POINTER
     349                 :            :                              (DECL_ASSEMBLER_NAME
     350                 :            :                                  (node->get_alias_target ()->decl))));
     351                 :            :         }
     352                 :            :     }
     353                 :            : }
     354                 :            : 
     355                 :            : /* Hash sections by their names.  */
     356                 :            : 
     357                 :            : hashval_t
     358                 :   10437200 : section_name_hasher::hash (section_hash_entry *n)
     359                 :            : {
     360                 :   10437200 :   return htab_hash_string (n->name);
     361                 :            : }
     362                 :            : 
     363                 :            : /* Return true if section P1 name equals to P2.  */
     364                 :            : 
     365                 :            : bool
     366                 :   10398800 : section_name_hasher::equal (section_hash_entry *n1, const char *name)
     367                 :            : {
     368                 :   10398800 :   return n1->name == name || !strcmp (n1->name, name);
     369                 :            : }
     370                 :            : 
     371                 :            : /* Add node into symbol table.  This function is not used directly, but via
     372                 :            :    cgraph/varpool node creation routines.  */
     373                 :            : 
     374                 :            : void
     375                 :   48655800 : symtab_node::register_symbol (void)
     376                 :            : {
     377                 :   48655800 :   symtab->register_symbol (this);
     378                 :            : 
     379                 :   48655800 :   if (!decl->decl_with_vis.symtab_node)
     380                 :   47128100 :     decl->decl_with_vis.symtab_node = this;
     381                 :            : 
     382                 :   48655800 :   ref_list.clear ();
     383                 :            : 
     384                 :            :   /* Be sure to do this last; C++ FE might create new nodes via
     385                 :            :      DECL_ASSEMBLER_NAME langhook!  */
     386                 :   48655800 :   symtab->insert_to_assembler_name_hash (this, false);
     387                 :   48655800 : }
     388                 :            : 
     389                 :            : /* Remove NODE from same comdat group.   */
     390                 :            : 
     391                 :            : void
     392                 :   61696300 : symtab_node::remove_from_same_comdat_group (void)
     393                 :            : {
     394                 :   61696300 :   if (same_comdat_group)
     395                 :            :     {
     396                 :            :       symtab_node *prev;
     397                 :            :       for (prev = same_comdat_group;
     398                 :    6594580 :            prev->same_comdat_group != this;
     399                 :            :            prev = prev->same_comdat_group)
     400                 :            :         ;
     401                 :    6227700 :       if (same_comdat_group == prev)
     402                 :    6102050 :         prev->same_comdat_group = NULL;
     403                 :            :       else
     404                 :     125652 :         prev->same_comdat_group = same_comdat_group;
     405                 :    6227700 :       same_comdat_group = NULL;
     406                 :    6227700 :       set_comdat_group (NULL);
     407                 :            :     }
     408                 :   61696300 : }
     409                 :            : 
     410                 :            : /* Remove node from symbol table.  This function is not used directly, but via
     411                 :            :    cgraph/varpool node removal routines.  */
     412                 :            : 
     413                 :            : void
     414                 :   55645800 : symtab_node::unregister (void)
     415                 :            : {
     416                 :   55645800 :   remove_all_references ();
     417                 :   55645800 :   remove_all_referring ();
     418                 :            : 
     419                 :            :   /* Remove reference to section.  */
     420                 :   55645800 :   set_section_for_node (NULL);
     421                 :            : 
     422                 :   55645800 :   remove_from_same_comdat_group ();
     423                 :            : 
     424                 :   55645800 :   symtab->unregister (this);
     425                 :            : 
     426                 :            :   /* During LTO symtab merging we temporarily corrupt decl to symtab node
     427                 :            :      hash.  */
     428                 :   55645800 :   gcc_assert (decl->decl_with_vis.symtab_node || in_lto_p);
     429                 :   55645800 :   if (decl->decl_with_vis.symtab_node == this)
     430                 :            :     {
     431                 :   54349800 :       symtab_node *replacement_node = NULL;
     432                 :   54349800 :       if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
     433                 :   46641000 :         replacement_node = cnode->find_replacement ();
     434                 :   54349800 :       decl->decl_with_vis.symtab_node = replacement_node;
     435                 :            :     }
     436                 :   55645800 :   if (!is_a <varpool_node *> (this) || !DECL_HARD_REGISTER (decl))
     437                 :   55645800 :     symtab->unlink_from_assembler_name_hash (this, false);
     438                 :   55645800 :   if (in_init_priority_hash)
     439                 :        116 :     symtab->init_priority_hash->remove (this);
     440                 :   55645800 : }
     441                 :            : 
     442                 :            : 
     443                 :            : /* Remove symbol from symbol table.  */
     444                 :            : 
     445                 :            : void
     446                 :   52759100 : symtab_node::remove (void)
     447                 :            : {
     448                 :   52759100 :   if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
     449                 :   45103300 :     cnode->remove ();
     450                 :    7655780 :   else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
     451                 :    7655780 :     vnode->remove ();
     452                 :   52759100 : }
     453                 :            : 
     454                 :            : /* Add NEW_ to the same comdat group that OLD is in.  */
     455                 :            : 
     456                 :            : void
     457                 :    5161480 : symtab_node::add_to_same_comdat_group (symtab_node *old_node)
     458                 :            : {
     459                 :    5161480 :   gcc_assert (old_node->get_comdat_group ());
     460                 :    5161480 :   gcc_assert (!same_comdat_group);
     461                 :    5161480 :   gcc_assert (this != old_node);
     462                 :            : 
     463                 :    5161480 :   set_comdat_group (old_node->get_comdat_group ());
     464                 :    5161480 :   same_comdat_group = old_node;
     465                 :    5161480 :   if (!old_node->same_comdat_group)
     466                 :    5032130 :     old_node->same_comdat_group = this;
     467                 :            :   else
     468                 :            :     {
     469                 :            :       symtab_node *n;
     470                 :            :       for (n = old_node->same_comdat_group;
     471                 :     480795 :            n->same_comdat_group != old_node;
     472                 :            :            n = n->same_comdat_group)
     473                 :            :         ;
     474                 :     129348 :       n->same_comdat_group = this;
     475                 :            :     }
     476                 :            : 
     477                 :    5161480 :   cgraph_node *n;
     478                 :    5161480 :   if (comdat_local_p ()
     479                 :    5169020 :       && (n = dyn_cast <cgraph_node *> (this)) != NULL)
     480                 :            :     {
     481                 :      11209 :       for (cgraph_edge *e = n->callers; e; e = e->next_caller)
     482                 :       3668 :         if (e->caller->inlined_to)
     483                 :       1726 :           e->caller->inlined_to->calls_comdat_local = true;
     484                 :            :         else
     485                 :       1942 :           e->caller->calls_comdat_local = true;
     486                 :            :     }
     487                 :    5161480 : }
     488                 :            : 
     489                 :            : /* Dissolve the same_comdat_group list in which NODE resides.  */
     490                 :            : 
     491                 :            : void
     492                 :       2052 : symtab_node::dissolve_same_comdat_group_list (void)
     493                 :            : {
     494                 :       2052 :   symtab_node *n = this;
     495                 :       2052 :   symtab_node *next;
     496                 :            : 
     497                 :       2052 :   if (!same_comdat_group)
     498                 :            :     return;
     499                 :       4024 :   do
     500                 :            :     {
     501                 :       4024 :       next = n->same_comdat_group;
     502                 :       4024 :       n->same_comdat_group = NULL;
     503                 :       4024 :       if (dyn_cast <cgraph_node *> (n))
     504                 :       3754 :         dyn_cast <cgraph_node *> (n)->calls_comdat_local = false;
     505                 :            :       /* Clear comdat_group for comdat locals, since
     506                 :            :          make_decl_local doesn't.  */
     507                 :       4024 :       if (!TREE_PUBLIC (n->decl))
     508                 :       2161 :         n->set_comdat_group (NULL);
     509                 :       4024 :       n = next;
     510                 :            :     }
     511                 :       4024 :   while (n != this);
     512                 :            : }
     513                 :            : 
     514                 :            : /* Return printable assembler name of NODE.
     515                 :            :    This function is used only for debugging.  When assembler name
     516                 :            :    is unknown go with identifier name.  */
     517                 :            : 
     518                 :            : const char *
     519                 :      45464 : symtab_node::asm_name () const
     520                 :            : {
     521                 :      45464 :   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
     522                 :        172 :     return name ();
     523                 :      45292 :   return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
     524                 :            : }
     525                 :            : 
     526                 :            : /* Return printable identifier name.  */
     527                 :            : 
     528                 :            : const char *
     529                 :      44255 : symtab_node::name () const
     530                 :            : {
     531                 :      44255 :   if (!DECL_NAME (decl))
     532                 :            :     {
     533                 :          0 :       if (DECL_ASSEMBLER_NAME_SET_P (decl))
     534                 :          0 :         return asm_name ();
     535                 :            :       else
     536                 :            :         return "<unnamed>";
     537                 :            :     }
     538                 :      44255 :   return lang_hooks.decl_printable_name (decl, 2);
     539                 :            : }
     540                 :            : 
     541                 :            : const char *
     542                 :      80623 : symtab_node::get_dump_name (bool asm_name_p) const
     543                 :            : {
     544                 :            : #define EXTRA 16
     545                 :      80623 :   const char *fname = asm_name_p ? asm_name () : name ();
     546                 :      80623 :   unsigned l = strlen (fname);
     547                 :            : 
     548                 :      80623 :   char *s = (char *)ggc_internal_cleared_alloc (l + EXTRA);
     549                 :      80623 :   snprintf (s, l + EXTRA, "%s/%d", fname, order);
     550                 :            : 
     551                 :      80623 :   return s;
     552                 :            : }
     553                 :            : 
     554                 :            : const char *
     555                 :      35317 : symtab_node::dump_name () const
     556                 :            : {
     557                 :      35317 :   return get_dump_name (false);
     558                 :            : }
     559                 :            : 
     560                 :            : const char *
     561                 :      45306 : symtab_node::dump_asm_name () const
     562                 :            : {
     563                 :      45306 :   return get_dump_name (true);
     564                 :            : }
     565                 :            : 
     566                 :            : /* Return ipa reference from this symtab_node to
     567                 :            :    REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
     568                 :            :    of the use.  */
     569                 :            : 
     570                 :            : ipa_ref *
     571                 :    5103750 : symtab_node::create_reference (symtab_node *referred_node,
     572                 :            :                                enum ipa_ref_use use_type)
     573                 :            : {
     574                 :    5103750 :   return create_reference (referred_node, use_type, NULL);
     575                 :            : }
     576                 :            : 
     577                 :            : 
     578                 :            : /* Return ipa reference from this symtab_node to
     579                 :            :    REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
     580                 :            :    of the use and STMT the statement (if it exists).  */
     581                 :            : 
     582                 :            : ipa_ref *
     583                 :   25539400 : symtab_node::create_reference (symtab_node *referred_node,
     584                 :            :                                enum ipa_ref_use use_type, gimple *stmt)
     585                 :            : {
     586                 :   25539400 :   ipa_ref *ref = NULL, *ref2 = NULL;
     587                 :   25539400 :   ipa_ref_list *list, *list2;
     588                 :   25539400 :   ipa_ref_t *old_references;
     589                 :            : 
     590                 :   25539400 :   gcc_checking_assert (!stmt || is_a <cgraph_node *> (this));
     591                 :   25539400 :   gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt);
     592                 :            : 
     593                 :   25539400 :   list = &ref_list;
     594                 :   25539400 :   old_references = vec_safe_address (list->references);
     595                 :   43950200 :   vec_safe_grow (list->references, vec_safe_length (list->references) + 1);
     596                 :   25539400 :   ref = &list->references->last ();
     597                 :            : 
     598                 :   25539400 :   list2 = &referred_node->ref_list;
     599                 :            : 
     600                 :            :   /* IPA_REF_ALIAS is always inserted at the beginning of the list.   */
     601                 :   25539400 :   if(use_type == IPA_REF_ALIAS)
     602                 :            :     {
     603                 :    3294330 :       list2->referring.safe_insert (0, ref);
     604                 :    3294330 :       ref->referred_index = 0;
     605                 :            : 
     606                 :    6721040 :       for (unsigned int i = 1; i < list2->referring.length (); i++)
     607                 :      66194 :         list2->referring[i]->referred_index = i;
     608                 :            :     }
     609                 :            :   else
     610                 :            :     {
     611                 :   22245100 :       list2->referring.safe_push (ref);
     612                 :   44490100 :       ref->referred_index = list2->referring.length () - 1;
     613                 :            :     }
     614                 :            : 
     615                 :   25539400 :   ref->referring = this;
     616                 :   25539400 :   ref->referred = referred_node;
     617                 :   25539400 :   ref->stmt = stmt;
     618                 :   25539400 :   ref->lto_stmt_uid = 0;
     619                 :   25539400 :   ref->speculative_id = 0;
     620                 :   25539400 :   ref->use = use_type;
     621                 :   25539400 :   ref->speculative = 0;
     622                 :            : 
     623                 :            :   /* If vector was moved in memory, update pointers.  */
     624                 :   25539400 :   if (old_references != list->references->address ())
     625                 :            :     {
     626                 :            :       int i;
     627                 :   57209500 :       for (i = 0; iterate_reference(i, ref2); i++)
     628                 :   44552200 :         ref2->referred_ref_list ()->referring[ref2->referred_index] = ref2;
     629                 :            :     }
     630                 :   25539400 :   return ref;
     631                 :            : }
     632                 :            : 
     633                 :            : ipa_ref *
     634                 :      44707 : symtab_node::maybe_create_reference (tree val, gimple *stmt)
     635                 :            : {
     636                 :      44707 :   STRIP_NOPS (val);
     637                 :      44707 :   ipa_ref_use use_type;
     638                 :            : 
     639                 :      44707 :   switch (TREE_CODE (val))
     640                 :            :     {
     641                 :            :     case VAR_DECL:
     642                 :            :       use_type = IPA_REF_LOAD;
     643                 :            :       break;
     644                 :       4319 :     case ADDR_EXPR:
     645                 :       4319 :       use_type = IPA_REF_ADDR;
     646                 :       4319 :       break;
     647                 :      40383 :     default:
     648                 :      40383 :       gcc_assert (!handled_component_p (val));
     649                 :            :       return NULL;
     650                 :            :     }
     651                 :            : 
     652                 :       4324 :   val = get_base_var (val);
     653                 :       4324 :   if (val && VAR_OR_FUNCTION_DECL_P (val))
     654                 :            :     {
     655                 :       2252 :       symtab_node *referred = symtab_node::get (val);
     656                 :       2252 :       gcc_checking_assert (referred);
     657                 :       2252 :       return create_reference (referred, use_type, stmt);
     658                 :            :     }
     659                 :            :   return NULL;
     660                 :            : }
     661                 :            : 
     662                 :            : /* Clone all references from symtab NODE to this symtab_node.  */
     663                 :            : 
     664                 :            : void
     665                 :    1598400 : symtab_node::clone_references (symtab_node *node)
     666                 :            : {
     667                 :    1598400 :   ipa_ref *ref = NULL, *ref2 = NULL;
     668                 :    1598400 :   int i;
     669                 :    1990220 :   for (i = 0; node->iterate_reference (i, ref); i++)
     670                 :            :     {
     671                 :     391819 :       bool speculative = ref->speculative;
     672                 :     391819 :       unsigned int stmt_uid = ref->lto_stmt_uid;
     673                 :     391819 :       unsigned int spec_id = ref->speculative_id;
     674                 :            : 
     675                 :     391819 :       ref2 = create_reference (ref->referred, ref->use, ref->stmt);
     676                 :     391819 :       ref2->speculative = speculative;
     677                 :     391819 :       ref2->lto_stmt_uid = stmt_uid;
     678                 :     391819 :       ref2->speculative_id = spec_id;
     679                 :            :     }
     680                 :    1598400 : }
     681                 :            : 
     682                 :            : /* Clone all referring from symtab NODE to this symtab_node.  */
     683                 :            : 
     684                 :            : void
     685                 :       2480 : symtab_node::clone_referring (symtab_node *node)
     686                 :            : {
     687                 :       2480 :   ipa_ref *ref = NULL, *ref2 = NULL;
     688                 :       2480 :   int i;
     689                 :       6234 :   for (i = 0; node->iterate_referring(i, ref); i++)
     690                 :            :     {
     691                 :       1877 :       bool speculative = ref->speculative;
     692                 :       1877 :       unsigned int stmt_uid = ref->lto_stmt_uid;
     693                 :       1877 :       unsigned int spec_id = ref->speculative_id;
     694                 :            : 
     695                 :       1877 :       ref2 = ref->referring->create_reference (this, ref->use, ref->stmt);
     696                 :       1877 :       ref2->speculative = speculative;
     697                 :       1877 :       ref2->lto_stmt_uid = stmt_uid;
     698                 :       1877 :       ref2->speculative_id = spec_id;
     699                 :            :     }
     700                 :       2480 : }
     701                 :            : 
     702                 :            : /* Clone reference REF to this symtab_node and set its stmt to STMT.  */
     703                 :            : 
     704                 :            : ipa_ref *
     705                 :       7068 : symtab_node::clone_reference (ipa_ref *ref, gimple *stmt)
     706                 :            : {
     707                 :       7068 :   bool speculative = ref->speculative;
     708                 :       7068 :   unsigned int stmt_uid = ref->lto_stmt_uid;
     709                 :       7068 :   unsigned int spec_id = ref->speculative_id;
     710                 :       7068 :   ipa_ref *ref2;
     711                 :            : 
     712                 :       7068 :   ref2 = create_reference (ref->referred, ref->use, stmt);
     713                 :       7068 :   ref2->speculative = speculative;
     714                 :       7068 :   ref2->lto_stmt_uid = stmt_uid;
     715                 :       7068 :   ref2->speculative_id = spec_id;
     716                 :       7068 :   return ref2;
     717                 :            : }
     718                 :            : 
     719                 :            : /* Find the structure describing a reference to REFERRED_NODE
     720                 :            :    and associated with statement STMT.  */
     721                 :            : 
     722                 :            : ipa_ref *
     723                 :        304 : symtab_node::find_reference (symtab_node *referred_node,
     724                 :            :                              gimple *stmt, unsigned int lto_stmt_uid)
     725                 :            : {
     726                 :        304 :   ipa_ref *r = NULL;
     727                 :        304 :   int i;
     728                 :            : 
     729                 :        436 :   for (i = 0; iterate_reference (i, r); i++)
     730                 :        436 :     if (r->referred == referred_node
     731                 :        327 :         && !r->speculative
     732                 :        327 :         && ((stmt && r->stmt == stmt)
     733                 :        147 :             || (lto_stmt_uid && r->lto_stmt_uid == lto_stmt_uid)
     734                 :        138 :             || (!stmt && !lto_stmt_uid && !r->stmt && !r->lto_stmt_uid)))
     735                 :        304 :       return r;
     736                 :            :   return NULL;
     737                 :            : }
     738                 :            : 
     739                 :            : /* Remove all references that are associated with statement STMT.  */
     740                 :            : 
     741                 :            : void
     742                 :      37660 : symtab_node::remove_stmt_references (gimple *stmt)
     743                 :            : {
     744                 :      37660 :   ipa_ref *r = NULL;
     745                 :      37660 :   int i = 0;
     746                 :            : 
     747                 :      38207 :   while (iterate_reference (i, r))
     748                 :        547 :     if (r->stmt == stmt)
     749                 :          0 :       r->remove_reference ();
     750                 :            :     else
     751                 :        547 :       i++;
     752                 :      37660 : }
     753                 :            : 
     754                 :            : /* Remove all stmt references in non-speculative references.
     755                 :            :    Those are not maintained during inlining & cloning.
     756                 :            :    The exception are speculative references that are updated along
     757                 :            :    with callgraph edges associated with them.  */
     758                 :            : 
     759                 :            : void
     760                 :    2986410 : symtab_node::clear_stmts_in_references (void)
     761                 :            : {
     762                 :    2986410 :   ipa_ref *r = NULL;
     763                 :    2986410 :   int i;
     764                 :            : 
     765                 :    7417990 :   for (i = 0; iterate_reference (i, r); i++)
     766                 :    4431580 :     if (!r->speculative)
     767                 :            :       {
     768                 :    4422250 :         r->stmt = NULL;
     769                 :    4422250 :         r->lto_stmt_uid = 0;
     770                 :    4422250 :         r->speculative_id = 0;
     771                 :            :       }
     772                 :    2986410 : }
     773                 :            : 
     774                 :            : /* Remove all references in ref list.  */
     775                 :            : 
     776                 :            : void
     777                 :   69471200 : symtab_node::remove_all_references (void)
     778                 :            : {
     779                 :   91386900 :   while (vec_safe_length (ref_list.references))
     780                 :   21915700 :     ref_list.references->last ().remove_reference ();
     781                 :   69471200 :   vec_free (ref_list.references);
     782                 :   69471200 : }
     783                 :            : 
     784                 :            : /* Remove all referring items in ref list.  */
     785                 :            : 
     786                 :            : void
     787                 :   55645800 : symtab_node::remove_all_referring (void)
     788                 :            : {
     789                 :   55722900 :   while (ref_list.referring.length ())
     790                 :      77103 :     ref_list.referring.last ()->remove_reference ();
     791                 :   55645800 :   ref_list.referring.release ();
     792                 :   55645800 : }
     793                 :            : 
     794                 :            : /* Dump references in ref list to FILE.  */
     795                 :            : 
     796                 :            : void
     797                 :       8630 : symtab_node::dump_references (FILE *file)
     798                 :            : {
     799                 :       8630 :   ipa_ref *ref = NULL;
     800                 :       8630 :   int i;
     801                 :      16171 :   for (i = 0; iterate_reference (i, ref); i++)
     802                 :            :     {
     803                 :       7541 :       fprintf (file, "%s (%s)",
     804                 :       7541 :                ref->referred->dump_asm_name (),
     805                 :       7541 :                ipa_ref_use_name [ref->use]);
     806                 :       7541 :       if (ref->speculative)
     807                 :         61 :         fprintf (file, " (speculative)");
     808                 :            :     }
     809                 :       8630 :   fprintf (file, "\n");
     810                 :       8630 : }
     811                 :            : 
     812                 :            : /* Dump referring in list to FILE.  */
     813                 :            : 
     814                 :            : void
     815                 :       8630 : symtab_node::dump_referring (FILE *file)
     816                 :            : {
     817                 :       8630 :   ipa_ref *ref = NULL;
     818                 :       8630 :   int i;
     819                 :      19478 :   for (i = 0; iterate_referring(i, ref); i++)
     820                 :            :     {
     821                 :       5424 :       fprintf (file, "%s (%s)",
     822                 :       5424 :                ref->referring->dump_asm_name (),
     823                 :       5424 :                ipa_ref_use_name [ref->use]);
     824                 :       5424 :       if (ref->speculative)
     825                 :         61 :         fprintf (file, " (speculative)");
     826                 :            :     }
     827                 :       8630 :   fprintf (file, "\n");
     828                 :       8630 : }
     829                 :            : 
     830                 :            : static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
     831                 :            : 
     832                 :            : /* Dump the visibility of the symbol.  */
     833                 :            : 
     834                 :            : const char *
     835                 :          0 : symtab_node::get_visibility_string () const
     836                 :            : {
     837                 :          0 :   static const char * const visibility_types[]
     838                 :            :     = { "default", "protected", "hidden", "internal" };
     839                 :          0 :   return visibility_types[DECL_VISIBILITY (decl)];
     840                 :            : }
     841                 :            : 
     842                 :            : /* Dump the type_name of the symbol.  */
     843                 :            : const char *
     844                 :          0 : symtab_node::get_symtab_type_string () const
     845                 :            : {
     846                 :          0 :   return symtab_type_names[type];
     847                 :            : }
     848                 :            : 
     849                 :            : /* Dump base fields of symtab nodes to F.  Not to be used directly.  */
     850                 :            : 
     851                 :            : void
     852                 :       8630 : symtab_node::dump_base (FILE *f)
     853                 :            : {
     854                 :       8630 :   static const char * const visibility_types[] = {
     855                 :            :     "default", "protected", "hidden", "internal"
     856                 :            :   };
     857                 :            : 
     858                 :       8630 :   fprintf (f, "%s (%s)", dump_asm_name (), name ());
     859                 :       8630 :   dump_addr (f, " @", (void *)this);
     860                 :       8630 :   fprintf (f, "\n  Type: %s", symtab_type_names[type]);
     861                 :            : 
     862                 :       8630 :   if (definition)
     863                 :       6695 :     fprintf (f, " definition");
     864                 :       8630 :   if (analyzed)
     865                 :       6691 :     fprintf (f, " analyzed");
     866                 :       8630 :   if (alias)
     867                 :        141 :     fprintf (f, " alias");
     868                 :       8630 :   if (transparent_alias)
     869                 :          0 :     fprintf (f, " transparent_alias");
     870                 :       8630 :   if (weakref)
     871                 :          0 :     fprintf (f, " weakref");
     872                 :       8630 :   if (symver)
     873                 :          0 :     fprintf (f, " symver");
     874                 :       8630 :   if (cpp_implicit_alias)
     875                 :        122 :     fprintf (f, " cpp_implicit_alias");
     876                 :       8630 :   if (alias_target)
     877                 :          0 :     fprintf (f, " target:%s",
     878                 :          0 :              DECL_P (alias_target)
     879                 :          0 :              ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
     880                 :            :                                      (alias_target))
     881                 :          0 :              : IDENTIFIER_POINTER (alias_target));
     882                 :       8630 :   if (body_removed)
     883                 :        676 :     fprintf (f, "\n  Body removed by symtab_remove_unreachable_nodes");
     884                 :       8630 :   fprintf (f, "\n  Visibility:");
     885                 :       8630 :   if (in_other_partition)
     886                 :          0 :     fprintf (f, " in_other_partition");
     887                 :       8630 :   if (used_from_other_partition)
     888                 :          0 :     fprintf (f, " used_from_other_partition");
     889                 :       8630 :   if (force_output)
     890                 :        561 :     fprintf (f, " force_output");
     891                 :       8630 :   if (forced_by_abi)
     892                 :        708 :     fprintf (f, " forced_by_abi");
     893                 :       8630 :   if (externally_visible)
     894                 :       4225 :     fprintf (f, " externally_visible");
     895                 :       8630 :   if (no_reorder)
     896                 :        537 :     fprintf (f, " no_reorder");
     897                 :       8630 :   if (resolution != LDPR_UNKNOWN)
     898                 :       1004 :     fprintf (f, " %s",
     899                 :       1004 :              ld_plugin_symbol_resolution_names[(int)resolution]);
     900                 :       8630 :   if (TREE_ASM_WRITTEN (decl))
     901                 :        196 :     fprintf (f, " asm_written");
     902                 :       8630 :   if (DECL_EXTERNAL (decl))
     903                 :       1698 :     fprintf (f, " external");
     904                 :       8630 :   if (TREE_PUBLIC (decl))
     905                 :       6852 :     fprintf (f, " public");
     906                 :       8630 :   if (DECL_COMMON (decl))
     907                 :         17 :     fprintf (f, " common");
     908                 :       8630 :   if (DECL_WEAK (decl))
     909                 :       2049 :     fprintf (f, " weak");
     910                 :       8630 :   if (DECL_DLLIMPORT_P (decl))
     911                 :          0 :     fprintf (f, " dll_import");
     912                 :       8630 :   if (DECL_COMDAT (decl))
     913                 :       2001 :     fprintf (f, " comdat");
     914                 :       8630 :   if (get_comdat_group ())
     915                 :       3662 :     fprintf (f, " comdat_group:%s",
     916                 :       1831 :              IDENTIFIER_POINTER (get_comdat_group_id ()));
     917                 :       8630 :   if (DECL_ONE_ONLY (decl))
     918                 :       1886 :     fprintf (f, " one_only");
     919                 :       8630 :   if (get_section ())
     920                 :         50 :     fprintf (f, " section:%s",
     921                 :            :              get_section ());
     922                 :       8630 :   if (implicit_section)
     923                 :         48 :     fprintf (f," (implicit_section)");
     924                 :       8630 :   if (DECL_VISIBILITY_SPECIFIED (decl))
     925                 :        640 :     fprintf (f, " visibility_specified");
     926                 :       8630 :   if (DECL_VISIBILITY (decl))
     927                 :         16 :     fprintf (f, " visibility:%s",
     928                 :         16 :              visibility_types [DECL_VISIBILITY (decl)]);
     929                 :       8630 :   if (DECL_VIRTUAL_P (decl))
     930                 :       1687 :     fprintf (f, " virtual");
     931                 :       8630 :   if (DECL_ARTIFICIAL (decl))
     932                 :       2835 :     fprintf (f, " artificial");
     933                 :       8630 :   if (TREE_CODE (decl) == FUNCTION_DECL)
     934                 :            :     {
     935                 :       5950 :       if (DECL_STATIC_CONSTRUCTOR (decl))
     936                 :         51 :         fprintf (f, " constructor");
     937                 :       5950 :       if (DECL_STATIC_DESTRUCTOR (decl))
     938                 :          6 :         fprintf (f, " destructor");
     939                 :            :     }
     940                 :       8630 :   if (ifunc_resolver)
     941                 :          4 :     fprintf (f, " ifunc_resolver");
     942                 :       8630 :   fprintf (f, "\n");
     943                 :            : 
     944                 :       8630 :   if (same_comdat_group)
     945                 :        247 :     fprintf (f, "  Same comdat group as: %s\n",
     946                 :            :              same_comdat_group->dump_asm_name ());
     947                 :       8630 :   if (next_sharing_asm_name)
     948                 :        383 :     fprintf (f, "  next sharing asm name: %i\n",
     949                 :            :              next_sharing_asm_name->order);
     950                 :       8630 :   if (previous_sharing_asm_name)
     951                 :        366 :     fprintf (f, "  previous sharing asm name: %i\n",
     952                 :            :              previous_sharing_asm_name->order);
     953                 :            : 
     954                 :       8630 :   if (address_taken)
     955                 :        961 :     fprintf (f, "  Address is taken.\n");
     956                 :       8630 :   if (aux)
     957                 :            :     {
     958                 :        530 :       fprintf (f, "  Aux:");
     959                 :        530 :       dump_addr (f, " @", (void *)aux);
     960                 :        530 :       fprintf (f, "\n");
     961                 :            :     }
     962                 :            : 
     963                 :       8630 :   fprintf (f, "  References: ");
     964                 :       8630 :   dump_references (f);
     965                 :       8630 :   fprintf (f, "  Referring: ");
     966                 :       8630 :   dump_referring (f);
     967                 :       8630 :   if (lto_file_data)
     968                 :        157 :     fprintf (f, "  Read from file: %s\n",
     969                 :            :              lto_file_data->file_name);
     970                 :       8630 : }
     971                 :            : 
     972                 :            : /* Dump symtab node to F.  */
     973                 :            : 
     974                 :            : void
     975                 :       7663 : symtab_node::dump (FILE *f)
     976                 :            : {
     977                 :       7663 :   if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
     978                 :       4983 :     cnode->dump (f);
     979                 :       2680 :   else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
     980                 :       2680 :     vnode->dump (f);
     981                 :       7663 : }
     982                 :            : 
     983                 :            : void
     984                 :          0 : symtab_node::dump_graphviz (FILE *f)
     985                 :            : {
     986                 :          0 :   if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
     987                 :          0 :     cnode->dump_graphviz (f);
     988                 :          0 : }
     989                 :            : 
     990                 :            : void
     991                 :       1178 : symbol_table::dump (FILE *f)
     992                 :            : {
     993                 :       1178 :   symtab_node *node;
     994                 :       1178 :   fprintf (f, "Symbol table:\n\n");
     995                 :       8837 :   FOR_EACH_SYMBOL (node)
     996                 :       7659 :     node->dump (f);
     997                 :       1178 : }
     998                 :            : 
     999                 :            : void
    1000                 :          0 : symbol_table::dump_graphviz (FILE *f)
    1001                 :            : {
    1002                 :          0 :   symtab_node *node;
    1003                 :          0 :   fprintf (f, "digraph symtab {\n");
    1004                 :          0 :   FOR_EACH_SYMBOL (node)
    1005                 :          0 :     node->dump_graphviz (f);
    1006                 :          0 :   fprintf (f, "}\n");
    1007                 :          0 : }
    1008                 :            : 
    1009                 :            : DEBUG_FUNCTION void
    1010                 :          0 : symbol_table::debug (void)
    1011                 :            : {
    1012                 :          0 :   dump (stderr);
    1013                 :          0 : }
    1014                 :            : 
    1015                 :            : /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
    1016                 :            :    Return NULL if there's no such node.  */
    1017                 :            : 
    1018                 :            : symtab_node *
    1019                 :   73004100 : symtab_node::get_for_asmname (const_tree asmname)
    1020                 :            : {
    1021                 :   73004100 :   symtab_node *node;
    1022                 :            : 
    1023                 :   73004100 :   symtab->symtab_initialize_asm_name_hash ();
    1024                 :   73004100 :   hashval_t hash = symtab->decl_assembler_name_hash (asmname);
    1025                 :   73004100 :   symtab_node **slot
    1026                 :   73004100 :     = symtab->assembler_name_hash->find_slot_with_hash (asmname, hash,
    1027                 :            :                                                         NO_INSERT);
    1028                 :            : 
    1029                 :   73004100 :   if (slot)
    1030                 :            :     {
    1031                 :   72524000 :       node = *slot;
    1032                 :   72524000 :       return node;
    1033                 :            :     }
    1034                 :            :   return NULL;
    1035                 :            : }
    1036                 :            : 
    1037                 :            : /* Dump symtab node NODE to stderr.  */
    1038                 :            : 
    1039                 :            : DEBUG_FUNCTION void
    1040                 :          0 : symtab_node::debug (void)
    1041                 :            : {
    1042                 :          0 :   dump (stderr);
    1043                 :          0 : }
    1044                 :            : 
    1045                 :            : /* Verify common part of symtab nodes.  */
    1046                 :            : 
    1047                 :            : #if __GNUC__ >= 10
    1048                 :            : /* Disable warnings about missing quoting in GCC diagnostics for
    1049                 :            :    the verification errors.  Their format strings don't follow GCC
    1050                 :            :    diagnostic conventions and the calls are ultimately followed by
    1051                 :            :    one to internal_error.  */
    1052                 :            : #  pragma GCC diagnostic push
    1053                 :            : #  pragma GCC diagnostic ignored "-Wformat-diag"
    1054                 :            : #endif
    1055                 :            : 
    1056                 :            : DEBUG_FUNCTION bool
    1057                 :   72982700 : symtab_node::verify_base (void)
    1058                 :            : {
    1059                 :   72982700 :   bool error_found = false;
    1060                 :   72982700 :   symtab_node *hashed_node;
    1061                 :            : 
    1062                 :   72982700 :   if (is_a <cgraph_node *> (this))
    1063                 :            :     {
    1064                 :   43832800 :       if (TREE_CODE (decl) != FUNCTION_DECL)
    1065                 :            :         {
    1066                 :          0 :           error ("function symbol is not function");
    1067                 :          0 :           error_found = true;
    1068                 :            :         }
    1069                 :   43832800 :       else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl))
    1070                 :   43832800 :                 != NULL)
    1071                 :   43832800 :                != dyn_cast <cgraph_node *> (this)->ifunc_resolver)
    1072                 :            :         {
    1073                 :          0 :           error ("inconsistent %<ifunc%> attribute");
    1074                 :          0 :           error_found = true;
    1075                 :            :         }
    1076                 :            :     }
    1077                 :   29149900 :   else if (is_a <varpool_node *> (this))
    1078                 :            :     {
    1079                 :   29149900 :       if (!VAR_P (decl))
    1080                 :            :         {
    1081                 :          0 :           error ("variable symbol is not variable");
    1082                 :          0 :           error_found = true;
    1083                 :            :         }
    1084                 :            :     }
    1085                 :            :   else
    1086                 :            :     {
    1087                 :          0 :       error ("node has unknown type");
    1088                 :          0 :       error_found = true;
    1089                 :            :     }
    1090                 :            :    
    1091                 :   72982700 :   if (symtab->state != LTO_STREAMING)
    1092                 :            :     {
    1093                 :   72851200 :       hashed_node = symtab_node::get (decl);
    1094                 :   72851200 :       if (!hashed_node)
    1095                 :            :         {
    1096                 :          0 :           error ("node not found node->decl->decl_with_vis.symtab_node");
    1097                 :          0 :           error_found = true;
    1098                 :            :         }
    1099                 :   72851200 :       if (hashed_node != this
    1100                 :   76530400 :           && (!is_a <cgraph_node *> (this)
    1101                 :    3679190 :               || !dyn_cast <cgraph_node *> (this)->clone_of
    1102                 :    3679190 :               || dyn_cast <cgraph_node *> (this)->clone_of->decl != decl))
    1103                 :            :         {
    1104                 :          0 :           error ("node differs from node->decl->decl_with_vis.symtab_node");
    1105                 :          0 :           error_found = true;
    1106                 :            :         }
    1107                 :            :     }
    1108                 :   72982700 :   if (symtab->assembler_name_hash)
    1109                 :            :     {
    1110                 :   72439500 :       hashed_node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl));
    1111                 :   72439500 :       if (hashed_node)
    1112                 :            :         {
    1113                 :   72439000 :           if (hashed_node->previous_sharing_asm_name)
    1114                 :            :             {
    1115                 :          0 :               error ("assembler name hash list corrupted");
    1116                 :          0 :               error_found = true;
    1117                 :            :             }
    1118                 :   72439000 :           else if (previous_sharing_asm_name == NULL)
    1119                 :            :             {
    1120                 :   68411200 :               if (hashed_node != this)
    1121                 :            :                 {
    1122                 :          0 :                   error ("assembler name hash list corrupted");
    1123                 :          0 :                   error_found = true;
    1124                 :            :                 }
    1125                 :            :             }
    1126                 :    4027760 :           else if (!(is_a <varpool_node *> (this) && DECL_HARD_REGISTER (decl)))
    1127                 :            :             {
    1128                 :    4027760 :               if (!asmname_hasher::equal (previous_sharing_asm_name,
    1129                 :    4027760 :                                           DECL_ASSEMBLER_NAME (decl)))
    1130                 :            :                 {
    1131                 :          0 :                   error ("node not found in symtab assembler name hash");
    1132                 :          0 :                   error_found = true;
    1133                 :            :                 }
    1134                 :            :             }
    1135                 :            :         }
    1136                 :            :     }
    1137                 :   72982700 :   if (previous_sharing_asm_name
    1138                 :    4027760 :       && previous_sharing_asm_name->next_sharing_asm_name != this)
    1139                 :            :     {
    1140                 :          0 :       error ("double linked list of assembler names corrupted");
    1141                 :          0 :       error_found = true;
    1142                 :            :     }
    1143                 :   72982700 :   if (body_removed && definition)
    1144                 :            :     {
    1145                 :          0 :       error ("node has body_removed but is definition");
    1146                 :          0 :       error_found = true;
    1147                 :            :     }
    1148                 :   72982700 :   if (analyzed && !definition)
    1149                 :            :     {
    1150                 :          0 :       error ("node is analyzed but it is not a definition");
    1151                 :          0 :       error_found = true;
    1152                 :            :     }
    1153                 :   72982700 :   if (cpp_implicit_alias && !alias)
    1154                 :            :     {
    1155                 :          0 :       error ("node is alias but not implicit alias");
    1156                 :          0 :       error_found = true;
    1157                 :            :     }
    1158                 :   72982700 :   if (alias && !definition && !weakref)
    1159                 :            :     {
    1160                 :          0 :       error ("node is alias but not definition");
    1161                 :          0 :       error_found = true;
    1162                 :            :     }
    1163                 :   72982700 :   if (weakref && !transparent_alias)
    1164                 :            :     {
    1165                 :          0 :       error ("node is weakref but not an transparent_alias");
    1166                 :          0 :       error_found = true;
    1167                 :            :     }
    1168                 :   72982700 :   if (transparent_alias && !alias)
    1169                 :            :     {
    1170                 :          0 :       error ("node is transparent_alias but not an alias");
    1171                 :          0 :       error_found = true;
    1172                 :            :     }
    1173                 :   72982700 :   if (symver && !alias)
    1174                 :            :     {
    1175                 :          0 :       error ("node is symver but not alias");
    1176                 :          0 :       error_found = true;
    1177                 :            :     }
    1178                 :            :   /* Limitation of gas requires us to output targets of symver aliases as
    1179                 :            :      global symbols.  This is binutils PR 25295.  */
    1180                 :   72982700 :   if (symver
    1181                 :          0 :       && (!TREE_PUBLIC (get_alias_target ()->decl)
    1182                 :   72982700 :           || DECL_VISIBILITY (get_alias_target ()->decl) != VISIBILITY_DEFAULT))
    1183                 :            :     {
    1184                 :          0 :       error ("symver target is not exported with default visibility");
    1185                 :          0 :       error_found = true;
    1186                 :            :     }
    1187                 :   72982700 :   if (symver
    1188                 :          0 :       && (!TREE_PUBLIC (decl)
    1189                 :   72982700 :           || DECL_VISIBILITY (decl) != VISIBILITY_DEFAULT))
    1190                 :            :     {
    1191                 :          0 :       error ("symver is not exported with default visibility");
    1192                 :          0 :       error_found = true;
    1193                 :            :     }
    1194                 :   72982700 :   if (same_comdat_group)
    1195                 :            :     {
    1196                 :    2426110 :       symtab_node *n = same_comdat_group;
    1197                 :            : 
    1198                 :    2426110 :       if (!n->get_comdat_group ())
    1199                 :            :         {
    1200                 :          0 :           error ("node is in same_comdat_group list but has no comdat_group");
    1201                 :          0 :           error_found = true;
    1202                 :            :         }
    1203                 :    2426110 :       if (n->get_comdat_group () != get_comdat_group ())
    1204                 :            :         {
    1205                 :          0 :           error ("same_comdat_group list across different groups");
    1206                 :          0 :           error_found = true;
    1207                 :            :         }
    1208                 :    2426110 :       if (n->type != type)
    1209                 :            :         {
    1210                 :          0 :           error ("mixing different types of symbol in same comdat groups is not supported");
    1211                 :          0 :           error_found = true;
    1212                 :            :         }
    1213                 :    2426110 :       if (n == this)
    1214                 :            :         {
    1215                 :          0 :           error ("node is alone in a comdat group");
    1216                 :          0 :           error_found = true;
    1217                 :            :         }
    1218                 :    5348530 :       do
    1219                 :            :         {
    1220                 :    5348530 :           if (!n->same_comdat_group)
    1221                 :            :             {
    1222                 :          0 :               error ("same_comdat_group is not a circular list");
    1223                 :          0 :               error_found = true;
    1224                 :          0 :               break;
    1225                 :            :             }
    1226                 :    5348530 :           n = n->same_comdat_group;
    1227                 :            :         }
    1228                 :    5348530 :       while (n != this);
    1229                 :    2426110 :       if (comdat_local_p ())
    1230                 :            :         {
    1231                 :      50509 :           ipa_ref *ref = NULL;
    1232                 :            : 
    1233                 :      53436 :           for (int i = 0; iterate_referring (i, ref); ++i)
    1234                 :            :             {
    1235                 :       5854 :               if (!in_same_comdat_group_p (ref->referring))
    1236                 :            :                 {
    1237                 :          0 :                   error ("comdat-local symbol referred to by %s outside its "
    1238                 :            :                          "comdat",
    1239                 :            :                          identifier_to_locale (ref->referring->name()));
    1240                 :          0 :                   error_found = true;
    1241                 :            :                 }
    1242                 :            :             }
    1243                 :            :         }
    1244                 :            :     }
    1245                 :   72982700 :   if (implicit_section && !get_section ())
    1246                 :            :     {
    1247                 :          0 :       error ("implicit_section flag is set but section isn%'t");
    1248                 :          0 :       error_found = true;
    1249                 :            :     }
    1250                 :   87684200 :   if (get_section () && get_comdat_group ()
    1251                 :    2982110 :       && !implicit_section
    1252                 :   14701600 :       && !lookup_attribute ("section", DECL_ATTRIBUTES (decl)))
    1253                 :            :     {
    1254                 :          0 :       error ("Both section and comdat group is set");
    1255                 :          0 :       error_found = true;
    1256                 :            :     }
    1257                 :            :   /* TODO: Add string table for sections, so we do not keep holding duplicated
    1258                 :            :      strings.  */
    1259                 :   72982700 :   if (alias && definition
    1260                 :    1346040 :       && get_section () != get_alias_target ()->get_section ()
    1261                 :   72982700 :       && (!get_section()
    1262                 :          0 :           || !get_alias_target ()->get_section ()
    1263                 :          0 :           || strcmp (get_section(),
    1264                 :            :                      get_alias_target ()->get_section ())))
    1265                 :            :     {
    1266                 :          0 :       error ("Alias and target%'s section differs");
    1267                 :          0 :       get_alias_target ()->dump (stderr);
    1268                 :          0 :       error_found = true;
    1269                 :            :     }
    1270                 :   72982700 :   if (alias && definition
    1271                 :   72982700 :       && get_comdat_group () != get_alias_target ()->get_comdat_group ())
    1272                 :            :     {
    1273                 :          0 :       error ("Alias and target%'s comdat groups differs");
    1274                 :          0 :       get_alias_target ()->dump (stderr);
    1275                 :          0 :       error_found = true;
    1276                 :            :     }
    1277                 :   72982700 :   if (transparent_alias && definition && !weakref)
    1278                 :            :     {
    1279                 :         91 :       symtab_node *to = get_alias_target ();
    1280                 :         91 :       const char *name1
    1281                 :         91 :         = IDENTIFIER_POINTER (
    1282                 :            :             ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl)));
    1283                 :         91 :       const char *name2
    1284                 :         91 :         = IDENTIFIER_POINTER (
    1285                 :            :             ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to->decl)));
    1286                 :         91 :       if (!symbol_table::assembler_names_equal_p (name1, name2))
    1287                 :            :         {
    1288                 :          0 :           error ("Transparent alias and target%'s assembler names differs");
    1289                 :          0 :           get_alias_target ()->dump (stderr);
    1290                 :          0 :           error_found = true;
    1291                 :            :         }
    1292                 :            :     }
    1293                 :   72982700 :   if (transparent_alias && definition
    1294                 :   72982700 :       && get_alias_target()->transparent_alias && get_alias_target()->analyzed)
    1295                 :            :     {
    1296                 :          0 :       error ("Chained transparent aliases");
    1297                 :          0 :       get_alias_target ()->dump (stderr);
    1298                 :          0 :       error_found = true;
    1299                 :            :     }
    1300                 :            : 
    1301                 :   72982700 :   return error_found;
    1302                 :            : }
    1303                 :            : 
    1304                 :            : /* Verify consistency of NODE.  */
    1305                 :            : 
    1306                 :            : DEBUG_FUNCTION void
    1307                 :   72984600 : symtab_node::verify (void)
    1308                 :            : {
    1309                 :   72984600 :   if (seen_error ())
    1310                 :            :     return;
    1311                 :            : 
    1312                 :   72982700 :   timevar_push (TV_CGRAPH_VERIFY);
    1313                 :   72982700 :   if (cgraph_node *node = dyn_cast <cgraph_node *> (this))
    1314                 :   43832800 :     node->verify_node ();
    1315                 :            :   else
    1316                 :   29149900 :     if (verify_base ())
    1317                 :            :       {
    1318                 :          0 :         debug ();
    1319                 :          0 :         internal_error ("symtab_node::verify failed");
    1320                 :            :       }
    1321                 :   72982700 :   timevar_pop (TV_CGRAPH_VERIFY);
    1322                 :            : }
    1323                 :            : 
    1324                 :            : /* Verify symbol table for internal consistency.  */
    1325                 :            : 
    1326                 :            : DEBUG_FUNCTION void
    1327                 :    1714030 : symtab_node::verify_symtab_nodes (void)
    1328                 :            : {
    1329                 :    1714030 :   symtab_node *node;
    1330                 :    1714030 :   hash_map<tree, symtab_node *> comdat_head_map (251);
    1331                 :            : 
    1332                 :   62421100 :   FOR_EACH_SYMBOL (node)
    1333                 :            :     {
    1334                 :   60707100 :       node->verify ();
    1335                 :   60707100 :       if (node->get_comdat_group ())
    1336                 :            :         {
    1337                 :    8043630 :           symtab_node **entry, *s;
    1338                 :    8043630 :           bool existed;
    1339                 :            : 
    1340                 :    8043630 :           entry = &comdat_head_map.get_or_insert (node->get_comdat_group (),
    1341                 :    8043630 :                                                   &existed);
    1342                 :    8043630 :           if (!existed)
    1343                 :    7058170 :             *entry = node;
    1344                 :     985456 :           else if (!DECL_EXTERNAL (node->decl))
    1345                 :            :             {
    1346                 :     980822 :               for (s = (*entry)->same_comdat_group;
    1347                 :    2286320 :                    s != NULL && s != node && s != *entry;
    1348                 :    1305490 :                    s = s->same_comdat_group)
    1349                 :            :                 ;
    1350                 :     980822 :               if (!s || s == *entry)
    1351                 :            :                 {
    1352                 :          0 :                   error ("Two symbols with same comdat_group are not linked by "
    1353                 :            :                          "the same_comdat_group list.");
    1354                 :          0 :                   (*entry)->debug ();
    1355                 :          0 :                   node->debug ();
    1356                 :          0 :                   internal_error ("symtab_node::verify failed");
    1357                 :            :                 }
    1358                 :            :             }
    1359                 :            :         }
    1360                 :            :     }
    1361                 :    1714030 : }
    1362                 :            : 
    1363                 :            : #if __GNUC__ >= 10
    1364                 :            : #  pragma GCC diagnostic pop
    1365                 :            : #endif
    1366                 :            : 
    1367                 :            : /* Make DECL local.  FIXME: We shouldn't need to mess with rtl this early,
    1368                 :            :    but other code such as notice_global_symbol generates rtl.  */
    1369                 :            : 
    1370                 :            : void
    1371                 :    2861780 : symtab_node::make_decl_local (void)
    1372                 :            : {
    1373                 :    2861780 :   rtx rtl, symbol;
    1374                 :            : 
    1375                 :    2861780 :   if (weakref)
    1376                 :            :     {
    1377                 :          0 :       weakref = false;
    1378                 :          0 :       IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) = 0;
    1379                 :          0 :       TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) = NULL_TREE;
    1380                 :          0 :       symtab->change_decl_assembler_name
    1381                 :          0 :          (decl, DECL_ASSEMBLER_NAME (get_alias_target ()->decl));
    1382                 :          0 :       DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
    1383                 :          0 :                                                  DECL_ATTRIBUTES (decl));
    1384                 :            :     }
    1385                 :            :   /* Avoid clearing comdat_groups on comdat-local decls.  */
    1386                 :    2861780 :   else if (TREE_PUBLIC (decl) == 0)
    1387                 :    2861780 :     return;
    1388                 :            : 
    1389                 :            :   /* Localizing a symbol also make all its transparent aliases local.  */
    1390                 :            :   ipa_ref *ref;
    1391                 :      73029 :   for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
    1392                 :            :     {
    1393                 :       1909 :       struct symtab_node *alias = ref->referring;
    1394                 :       1909 :       if (alias->transparent_alias)
    1395                 :          5 :         alias->make_decl_local ();
    1396                 :            :     }
    1397                 :            : 
    1398                 :      67354 :   if (VAR_P (decl))
    1399                 :            :     {
    1400                 :       7891 :       DECL_COMMON (decl) = 0;
    1401                 :            :       /* ADDRESSABLE flag is not defined for public symbols.  */
    1402                 :       7891 :       TREE_ADDRESSABLE (decl) = 1;
    1403                 :       7891 :       TREE_STATIC (decl) = 1;
    1404                 :            :     }
    1405                 :            :   else
    1406                 :      59463 :     gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
    1407                 :            : 
    1408                 :      67354 :   DECL_COMDAT (decl) = 0;
    1409                 :      67354 :   DECL_WEAK (decl) = 0;
    1410                 :      67354 :   DECL_EXTERNAL (decl) = 0;
    1411                 :      67354 :   DECL_VISIBILITY_SPECIFIED (decl) = 0;
    1412                 :      67354 :   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
    1413                 :      67354 :   TREE_PUBLIC (decl) = 0;
    1414                 :      67354 :   DECL_DLLIMPORT_P (decl) = 0;
    1415                 :      67354 :   if (!DECL_RTL_SET_P (decl))
    1416                 :            :     return;
    1417                 :            : 
    1418                 :            :   /* Update rtl flags.  */
    1419                 :         11 :   make_decl_rtl (decl);
    1420                 :            : 
    1421                 :         11 :   rtl = DECL_RTL (decl);
    1422                 :         11 :   if (!MEM_P (rtl))
    1423                 :            :     return;
    1424                 :            : 
    1425                 :         11 :   symbol = XEXP (rtl, 0);
    1426                 :         11 :   if (GET_CODE (symbol) != SYMBOL_REF)
    1427                 :            :     return;
    1428                 :            : 
    1429                 :         11 :   SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
    1430                 :            : }
    1431                 :            : 
    1432                 :            : /* Copy visibility from N.
    1433                 :            :    This is useful when THIS becomes a transparent alias of N.  */
    1434                 :            : 
    1435                 :            : void
    1436                 :          0 : symtab_node::copy_visibility_from (symtab_node *n)
    1437                 :            : {
    1438                 :          0 :   gcc_checking_assert (n->weakref == weakref);
    1439                 :            : 
    1440                 :            :   ipa_ref *ref;
    1441                 :          0 :   for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
    1442                 :            :     {
    1443                 :          0 :       struct symtab_node *alias = ref->referring;
    1444                 :          0 :       if (alias->transparent_alias)
    1445                 :          0 :         alias->copy_visibility_from (n);
    1446                 :            :     }
    1447                 :            : 
    1448                 :          0 :   if (VAR_P (decl))
    1449                 :            :     {
    1450                 :          0 :       DECL_COMMON (decl) = DECL_COMMON (n->decl);
    1451                 :            :       /* ADDRESSABLE flag is not defined for public symbols.  */
    1452                 :          0 :       if (TREE_PUBLIC (decl) && !TREE_PUBLIC (n->decl))
    1453                 :          0 :         TREE_ADDRESSABLE (decl) = 1;
    1454                 :          0 :       TREE_STATIC (decl) = TREE_STATIC (n->decl);
    1455                 :            :     }
    1456                 :          0 :   else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
    1457                 :            : 
    1458                 :          0 :   DECL_COMDAT (decl) = DECL_COMDAT (n->decl);
    1459                 :          0 :   DECL_WEAK (decl) = DECL_WEAK (n->decl);
    1460                 :          0 :   DECL_EXTERNAL (decl) = DECL_EXTERNAL (n->decl);
    1461                 :          0 :   DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (n->decl);
    1462                 :          0 :   DECL_VISIBILITY (decl) = DECL_VISIBILITY (n->decl);
    1463                 :          0 :   TREE_PUBLIC (decl) = TREE_PUBLIC (n->decl);
    1464                 :          0 :   DECL_DLLIMPORT_P (decl) = DECL_DLLIMPORT_P (n->decl);
    1465                 :          0 :   resolution = n->resolution;
    1466                 :          0 :   set_comdat_group (n->get_comdat_group ());
    1467                 :          0 :   call_for_symbol_and_aliases (symtab_node::set_section,
    1468                 :          0 :                              const_cast<char *>(n->get_section ()), true);
    1469                 :          0 :   externally_visible = n->externally_visible;
    1470                 :          0 :   if (!DECL_RTL_SET_P (decl))
    1471                 :          0 :     return;
    1472                 :            : 
    1473                 :            :   /* Update rtl flags.  */
    1474                 :          0 :   make_decl_rtl (decl);
    1475                 :            : 
    1476                 :          0 :   rtx rtl = DECL_RTL (decl);
    1477                 :          0 :   if (!MEM_P (rtl))
    1478                 :            :     return;
    1479                 :            : 
    1480                 :          0 :   rtx symbol = XEXP (rtl, 0);
    1481                 :          0 :   if (GET_CODE (symbol) != SYMBOL_REF)
    1482                 :            :     return;
    1483                 :            : 
    1484                 :          0 :   SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
    1485                 :            : }
    1486                 :            : 
    1487                 :            : /* Walk the alias chain to return the symbol NODE is alias of.
    1488                 :            :    If NODE is not an alias, return NODE.
    1489                 :            :    Assumes NODE is known to be alias.  */
    1490                 :            : 
    1491                 :            : symtab_node *
    1492                 :   19155800 : symtab_node::ultimate_alias_target_1 (enum availability *availability,
    1493                 :            :                                       symtab_node *ref)
    1494                 :            : {
    1495                 :   19155800 :   bool transparent_p = false;
    1496                 :            : 
    1497                 :            :   /* To determine visibility of the target, we follow ELF semantic of aliases.
    1498                 :            :      Here alias is an alternative assembler name of a given definition. Its
    1499                 :            :      availability prevails the availability of its target (i.e. static alias of
    1500                 :            :      weak definition is available.
    1501                 :            : 
    1502                 :            :      Transparent alias is just alternative name of a given symbol used within
    1503                 :            :      one compilation unit and is translated prior hitting the object file.  It
    1504                 :            :      inherits the visibility of its target.
    1505                 :            :      Weakref is a different animal (and noweak definition is weak).
    1506                 :            : 
    1507                 :            :      If we ever get into supporting targets with different semantics, a target
    1508                 :            :      hook will be needed here.  */
    1509                 :            : 
    1510                 :   19155800 :   if (availability)
    1511                 :            :     {
    1512                 :    3282280 :       transparent_p = transparent_alias;
    1513                 :    3282280 :       if (!transparent_p)
    1514                 :    3222210 :         *availability = get_availability (ref);
    1515                 :            :       else
    1516                 :      60068 :         *availability = AVAIL_NOT_AVAILABLE;
    1517                 :            :     }
    1518                 :            : 
    1519                 :            :   symtab_node *node = this;
    1520                 :   38070700 :   while (node)
    1521                 :            :     {
    1522                 :   38070700 :       if (node->alias && node->analyzed)
    1523                 :   18914900 :         node = node->get_alias_target ();
    1524                 :            :       else
    1525                 :            :         {
    1526                 :   19155800 :           if (!availability || (!transparent_p && node->analyzed))
    1527                 :            :             ;
    1528                 :      80291 :           else if (node->analyzed && !node->transparent_alias)
    1529                 :        222 :             *availability = node->get_availability (ref);
    1530                 :            :           else
    1531                 :      80069 :             *availability = AVAIL_NOT_AVAILABLE;
    1532                 :   19155800 :           return node;
    1533                 :            :         }
    1534                 :   18914900 :       if (node && availability && transparent_p
    1535                 :        690 :           && node->transparent_alias)
    1536                 :            :         {
    1537                 :         20 :           *availability = node->get_availability (ref);
    1538                 :         20 :           transparent_p = false;
    1539                 :            :         }
    1540                 :            :     }
    1541                 :          0 :   if (availability)
    1542                 :          0 :     *availability = AVAIL_NOT_AVAILABLE;
    1543                 :            :   return NULL;
    1544                 :            : }
    1545                 :            : 
    1546                 :            : /* C++ FE sometimes change linkage flags after producing same body aliases.
    1547                 :            : 
    1548                 :            :    FIXME: C++ produce implicit aliases for virtual functions and vtables that
    1549                 :            :    are obviously equivalent.  The way it is doing so is however somewhat
    1550                 :            :    kludgy and interferes with the visibility code. As a result we need to
    1551                 :            :    copy the visibility from the target to get things right.  */
    1552                 :            : 
    1553                 :            : void
    1554                 :    3498080 : symtab_node::fixup_same_cpp_alias_visibility (symtab_node *target)
    1555                 :            : {
    1556                 :    3498080 :   if (is_a <cgraph_node *> (this))
    1557                 :            :     {
    1558                 :   10493900 :       DECL_DECLARED_INLINE_P (decl)
    1559                 :    3497970 :          = DECL_DECLARED_INLINE_P (target->decl);
    1560                 :   10493900 :       DECL_DISREGARD_INLINE_LIMITS (decl)
    1561                 :    3497970 :          = DECL_DISREGARD_INLINE_LIMITS (target->decl);
    1562                 :            :     }
    1563                 :            :   /* FIXME: It is not really clear why those flags should not be copied for
    1564                 :            :      functions, too.  */
    1565                 :            :   else
    1566                 :            :     {
    1567                 :        114 :       DECL_WEAK (decl) = DECL_WEAK (target->decl);
    1568                 :        114 :       DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
    1569                 :        114 :       DECL_VISIBILITY (decl) = DECL_VISIBILITY (target->decl);
    1570                 :            :     }
    1571                 :    3498080 :   if (TREE_PUBLIC (decl))
    1572                 :            :     {
    1573                 :    3483470 :       tree group;
    1574                 :            : 
    1575                 :    3483470 :       DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
    1576                 :    3483470 :       DECL_COMDAT (decl) = DECL_COMDAT (target->decl);
    1577                 :    3483470 :       group = target->get_comdat_group ();
    1578                 :    3483470 :       set_comdat_group (group);
    1579                 :    3483470 :       if (group && !same_comdat_group)
    1580                 :          0 :         add_to_same_comdat_group (target);
    1581                 :            :     }
    1582                 :    3498080 :   externally_visible = target->externally_visible;
    1583                 :    3498080 : }
    1584                 :            : 
    1585                 :            : /* Set section, do not recurse into aliases.
    1586                 :            :    When one wants to change section of a symbol and its aliases,
    1587                 :            :    use set_section.  */
    1588                 :            : 
    1589                 :            : void
    1590                 :   64643800 : symtab_node::set_section_for_node (const char *section)
    1591                 :            : {
    1592                 :   64643800 :   const char *current = get_section ();
    1593                 :   64643800 :   section_hash_entry **slot;
    1594                 :            : 
    1595                 :   64643800 :   if (current == section
    1596                 :    1614290 :       || (current && section
    1597                 :        438 :           && !strcmp (current, section)))
    1598                 :            :     return;
    1599                 :            : 
    1600                 :    1614290 :   if (current)
    1601                 :            :     {
    1602                 :      62901 :       x_section->ref_count--;
    1603                 :      62901 :       if (!x_section->ref_count)
    1604                 :            :         {
    1605                 :      59360 :           hashval_t hash = htab_hash_string (x_section->name);
    1606                 :      59360 :           slot = symtab->section_hash->find_slot_with_hash (x_section->name,
    1607                 :            :                                                             hash, INSERT);
    1608                 :      59360 :           ggc_free (x_section);
    1609                 :      59360 :           symtab->section_hash->clear_slot (slot);
    1610                 :            :         }
    1611                 :      62901 :       x_section = NULL;
    1612                 :            :     }
    1613                 :    1614290 :   if (!section)
    1614                 :            :     {
    1615                 :      62463 :       implicit_section = false;
    1616                 :      62463 :       return;
    1617                 :            :     }
    1618                 :    1551820 :   if (!symtab->section_hash)
    1619                 :      30083 :     symtab->section_hash = hash_table<section_name_hasher>::create_ggc (10);
    1620                 :    1551820 :   slot = symtab->section_hash->find_slot_with_hash (section,
    1621                 :            :                                                     htab_hash_string (section),
    1622                 :            :                                                     INSERT);
    1623                 :    1551820 :   if (*slot)
    1624                 :      41026 :     x_section = (section_hash_entry *)*slot;
    1625                 :            :   else
    1626                 :            :     {
    1627                 :    1510800 :       int len = strlen (section);
    1628                 :    1510800 :       *slot = x_section = ggc_cleared_alloc<section_hash_entry> ();
    1629                 :    1510800 :       x_section->name = ggc_vec_alloc<char> (len + 1);
    1630                 :    1510800 :       memcpy (x_section->name, section, len + 1);
    1631                 :            :     }
    1632                 :    1551820 :   x_section->ref_count++;
    1633                 :            : }
    1634                 :            : 
    1635                 :            : /* Worker for set_section.  */
    1636                 :            : 
    1637                 :            : bool
    1638                 :    8996150 : symtab_node::set_section (symtab_node *n, void *s)
    1639                 :            : {
    1640                 :    8996150 :   n->set_section_for_node ((char *)s);
    1641                 :    8996150 :   return false;
    1642                 :            : }
    1643                 :            : 
    1644                 :            : /* Set section of symbol and its aliases.  */
    1645                 :            : 
    1646                 :            : void
    1647                 :    5678140 : symtab_node::set_section (const char *section)
    1648                 :            : {
    1649                 :    5678140 :   gcc_assert (!this->alias || !this->analyzed);
    1650                 :    5678140 :   call_for_symbol_and_aliases
    1651                 :    5678140 :     (symtab_node::set_section, const_cast<char *>(section), true);
    1652                 :    5678140 : }
    1653                 :            : 
    1654                 :            : /* Return the initialization priority.  */
    1655                 :            : 
    1656                 :            : priority_type
    1657                 :      23422 : symtab_node::get_init_priority ()
    1658                 :            : {
    1659                 :      23422 :   if (!this->in_init_priority_hash)
    1660                 :            :     return DEFAULT_INIT_PRIORITY;
    1661                 :            : 
    1662                 :       2639 :   symbol_priority_map *h = symtab->init_priority_hash->get (this);
    1663                 :       2639 :   return h ? h->init : DEFAULT_INIT_PRIORITY;
    1664                 :            : }
    1665                 :            : 
    1666                 :            : /* Return the finalization priority.  */
    1667                 :            : 
    1668                 :            : priority_type
    1669                 :       1465 : cgraph_node::get_fini_priority ()
    1670                 :            : {
    1671                 :       1465 :   if (!this->in_init_priority_hash)
    1672                 :            :     return DEFAULT_INIT_PRIORITY;
    1673                 :       1406 :   symbol_priority_map *h = symtab->init_priority_hash->get (this);
    1674                 :       1406 :   return h ? h->fini : DEFAULT_INIT_PRIORITY;
    1675                 :            : }
    1676                 :            : 
    1677                 :            : /* Return the initialization and finalization priority information for
    1678                 :            :    DECL.  If there is no previous priority information, a freshly
    1679                 :            :    allocated structure is returned.  */
    1680                 :            : 
    1681                 :            : symbol_priority_map *
    1682                 :       3889 : symtab_node::priority_info (void)
    1683                 :            : {
    1684                 :       3889 :   if (!symtab->init_priority_hash)
    1685                 :       2419 :     symtab->init_priority_hash = hash_map<symtab_node *, symbol_priority_map>::create_ggc (13);
    1686                 :            : 
    1687                 :       3889 :   bool existed;
    1688                 :       3889 :   symbol_priority_map *h
    1689                 :       3889 :     = &symtab->init_priority_hash->get_or_insert (this, &existed);
    1690                 :       3889 :   if (!existed)
    1691                 :            :     {
    1692                 :       3884 :       h->init = DEFAULT_INIT_PRIORITY;
    1693                 :       3884 :       h->fini = DEFAULT_INIT_PRIORITY;
    1694                 :       3884 :       in_init_priority_hash = true;
    1695                 :            :     }
    1696                 :            : 
    1697                 :       3889 :   return h;
    1698                 :            : }
    1699                 :            : 
    1700                 :            : /* Set initialization priority to PRIORITY.  */
    1701                 :            : 
    1702                 :            : void
    1703                 :      13306 : symtab_node::set_init_priority (priority_type priority)
    1704                 :            : {
    1705                 :      13306 :   symbol_priority_map *h;
    1706                 :            : 
    1707                 :      13306 :   if (is_a <cgraph_node *> (this))
    1708                 :      13280 :     gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl));
    1709                 :            : 
    1710                 :      13306 :   if (priority == DEFAULT_INIT_PRIORITY)
    1711                 :            :     {
    1712                 :      10771 :       gcc_assert (get_init_priority() == priority);
    1713                 :            :       return;
    1714                 :            :     }
    1715                 :       2535 :   h = priority_info ();
    1716                 :       2535 :   h->init = priority;
    1717                 :            : }
    1718                 :            : 
    1719                 :            : /* Set finalization priority to PRIORITY.  */
    1720                 :            : 
    1721                 :            : void
    1722                 :       1364 : cgraph_node::set_fini_priority (priority_type priority)
    1723                 :            : {
    1724                 :       1364 :   symbol_priority_map *h;
    1725                 :            : 
    1726                 :       1364 :   gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl));
    1727                 :            : 
    1728                 :       1364 :   if (priority == DEFAULT_INIT_PRIORITY)
    1729                 :            :     {
    1730                 :         10 :       gcc_assert (get_fini_priority() == priority);
    1731                 :            :       return;
    1732                 :            :     }
    1733                 :       1354 :   h = priority_info ();
    1734                 :       1354 :   h->fini = priority;
    1735                 :            : }
    1736                 :            : 
    1737                 :            : /* Worker for symtab_resolve_alias.  */
    1738                 :            : 
    1739                 :            : bool
    1740                 :       2874 : symtab_node::set_implicit_section (symtab_node *n,
    1741                 :            :                                    void *data ATTRIBUTE_UNUSED)
    1742                 :            : {
    1743                 :       2874 :   n->implicit_section = true;
    1744                 :       2874 :   return false;
    1745                 :            : }
    1746                 :            : 
    1747                 :            : /* Add reference recording that symtab node is alias of TARGET.
    1748                 :            :    The function can fail in the case of aliasing cycles; in this case
    1749                 :            :    it returns false.  */
    1750                 :            : 
    1751                 :            : bool
    1752                 :    3282060 : symtab_node::resolve_alias (symtab_node *target, bool transparent)
    1753                 :            : {
    1754                 :    3282060 :   symtab_node *n;
    1755                 :            : 
    1756                 :    3282060 :   gcc_assert (!analyzed && !vec_safe_length (ref_list.references));
    1757                 :            : 
    1758                 :            :   /* Never let cycles to creep into the symbol table alias references;
    1759                 :            :      those will make alias walkers to be infinite.  */
    1760                 :    3287020 :   for (n = target; n && n->alias;
    1761                 :       5116 :        n = n->analyzed ? n->get_alias_target () : NULL)
    1762                 :       5118 :     if (n == this)
    1763                 :            :        {
    1764                 :          2 :          if (is_a <cgraph_node *> (this))
    1765                 :          2 :            error ("function %q+D part of alias cycle", decl);
    1766                 :          0 :          else if (is_a <varpool_node *> (this))
    1767                 :          0 :            error ("variable %q+D part of alias cycle", decl);
    1768                 :            :          else
    1769                 :          0 :            gcc_unreachable ();
    1770                 :          2 :          alias = false;
    1771                 :          2 :          return false;
    1772                 :            :        }
    1773                 :            : 
    1774                 :            :   /* "analyze" the node - i.e. mark the reference.  */
    1775                 :    3282060 :   definition = true;
    1776                 :    3282060 :   alias = true;
    1777                 :    3282060 :   analyzed = true;
    1778                 :    3282060 :   transparent |= transparent_alias;
    1779                 :    3282060 :   transparent_alias = transparent;
    1780                 :    3282060 :   if (transparent)
    1781                 :         83 :     while (target->transparent_alias && target->analyzed)
    1782                 :          0 :       target = target->get_alias_target ();
    1783                 :    3282060 :   create_reference (target, IPA_REF_ALIAS, NULL);
    1784                 :            : 
    1785                 :            :   /* Add alias into the comdat group of its target unless it is already there.  */
    1786                 :    3282060 :   if (same_comdat_group)
    1787                 :    1359420 :     remove_from_same_comdat_group ();
    1788                 :    3282060 :   set_comdat_group (NULL);
    1789                 :    3282060 :   if (target->get_comdat_group ())
    1790                 :    3093580 :     add_to_same_comdat_group (target);
    1791                 :            : 
    1792                 :    3282070 :   if ((get_section () != target->get_section ()
    1793                 :    3282060 :        || target->get_comdat_group ()) && get_section () && !implicit_section)
    1794                 :            :     {
    1795                 :          2 :       error ("section of alias %q+D must match section of its target", decl);
    1796                 :            :     }
    1797                 :    3282060 :   call_for_symbol_and_aliases (symtab_node::set_section,
    1798                 :    3282060 :                              const_cast<char *>(target->get_section ()), true);
    1799                 :    3282060 :   if (target->implicit_section)
    1800                 :       2747 :     call_for_symbol_and_aliases (set_implicit_section, NULL, true);
    1801                 :            : 
    1802                 :            :   /* Alias targets become redundant after alias is resolved into an reference.
    1803                 :            :      We do not want to keep it around or we would have to mind updating them
    1804                 :            :      when renaming symbols.  */
    1805                 :    3282060 :   alias_target = NULL;
    1806                 :            : 
    1807                 :    3282060 :   if (!transparent && cpp_implicit_alias && symtab->state >= CONSTRUCTION)
    1808                 :        324 :     fixup_same_cpp_alias_visibility (target);
    1809                 :            : 
    1810                 :            :   /* If alias has address taken, so does the target.  */
    1811                 :    3282060 :   if (address_taken)
    1812                 :        949 :     target->ultimate_alias_target ()->address_taken = true;
    1813                 :            : 
    1814                 :            :   /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
    1815                 :            :      If alias is transparent, also all transparent aliases of THIS are now
    1816                 :            :      aliases of TARGET.
    1817                 :            :      Also merge same comdat group lists.  */
    1818                 :            :   ipa_ref *ref;
    1819                 :    3282660 :   for (unsigned i = 0; iterate_direct_aliases (i, ref);)
    1820                 :            :     {
    1821                 :        181 :       struct symtab_node *alias_alias = ref->referring;
    1822                 :        181 :       if (alias_alias->get_comdat_group ())
    1823                 :            :         {
    1824                 :        127 :           alias_alias->remove_from_same_comdat_group ();
    1825                 :        127 :           alias_alias->set_comdat_group (NULL);
    1826                 :        127 :           if (target->get_comdat_group ())
    1827                 :        127 :             alias_alias->add_to_same_comdat_group (target);
    1828                 :            :         }
    1829                 :        181 :       if ((!alias_alias->transparent_alias
    1830                 :        181 :            && !alias_alias->symver)
    1831                 :         12 :           || transparent)
    1832                 :            :         {
    1833                 :        181 :           alias_alias->remove_all_references ();
    1834                 :        181 :           alias_alias->create_reference (target, IPA_REF_ALIAS, NULL);
    1835                 :            :         }
    1836                 :          0 :       else i++;
    1837                 :            :     }
    1838                 :            :   return true;
    1839                 :            : }
    1840                 :            : 
    1841                 :            : /* Worker searching noninterposable alias.  */
    1842                 :            : 
    1843                 :            : bool
    1844                 :      57318 : symtab_node::noninterposable_alias (symtab_node *node, void *data)
    1845                 :            : {
    1846                 :      57318 :   if (!node->transparent_alias && decl_binds_to_current_def_p (node->decl))
    1847                 :            :     {
    1848                 :      55109 :       symtab_node *fn = node->ultimate_alias_target ();
    1849                 :            : 
    1850                 :            :       /* Ensure that the alias is well formed this may not be the case
    1851                 :            :          of user defined aliases and currently it is not always the case
    1852                 :            :          of C++ same body aliases (that is a bug).  */
    1853                 :      55109 :       if (TREE_TYPE (node->decl) != TREE_TYPE (fn->decl)
    1854                 :      55109 :           || DECL_CONTEXT (node->decl) != DECL_CONTEXT (fn->decl)
    1855                 :      55109 :           || (TREE_CODE (node->decl) == FUNCTION_DECL
    1856                 :     110218 :               && flags_from_decl_or_type (node->decl)
    1857                 :      55109 :                  != flags_from_decl_or_type (fn->decl))
    1858                 :     110194 :           || DECL_ATTRIBUTES (node->decl) != DECL_ATTRIBUTES (fn->decl))
    1859                 :         24 :         return false;
    1860                 :      55085 :       *(symtab_node **)data = node;
    1861                 :      55085 :       return true;
    1862                 :            :     }
    1863                 :            :   return false;
    1864                 :            : }
    1865                 :            : 
    1866                 :            : /* If node cannot be overwriten by static or dynamic linker to point to
    1867                 :            :    different definition, return NODE. Otherwise look for alias with such
    1868                 :            :    property and if none exists, introduce new one.  */
    1869                 :            : 
    1870                 :            : symtab_node *
    1871                 :      55942 : symtab_node::noninterposable_alias (void)
    1872                 :            : {
    1873                 :      55942 :   tree new_decl;
    1874                 :      55942 :   symtab_node *new_node = NULL;
    1875                 :            : 
    1876                 :            :   /* First try to look up existing alias or base object
    1877                 :            :      (if that is already non-overwritable).  */
    1878                 :      55942 :   symtab_node *node = ultimate_alias_target ();
    1879                 :      55942 :   gcc_assert (!node->alias && !node->weakref);
    1880                 :      55942 :   node->call_for_symbol_and_aliases (symtab_node::noninterposable_alias,
    1881                 :            :                                      (void *)&new_node, true);
    1882                 :      55942 :   if (new_node)
    1883                 :            :     return new_node;
    1884                 :            : 
    1885                 :            :   /* If aliases aren't supported by the assembler, fail.  */
    1886                 :        857 :   if (!TARGET_SUPPORTS_ALIASES)
    1887                 :            :     return NULL;
    1888                 :            : 
    1889                 :            :   /* Otherwise create a new one.  */
    1890                 :        857 :   new_decl = copy_node (node->decl);
    1891                 :        857 :   DECL_DLLIMPORT_P (new_decl) = 0;
    1892                 :        857 :   tree name = clone_function_name (node->decl, "localalias");
    1893                 :        857 :   if (!flag_wpa)
    1894                 :            :     {
    1895                 :            :       unsigned long num = 0;
    1896                 :            :       /* In the rare case we already have a localalias, but the above
    1897                 :            :          node->call_for_symbol_and_aliases call didn't find any suitable,
    1898                 :            :          iterate until we find one not used yet.  */
    1899                 :        853 :       while (symtab_node::get_for_asmname (name))
    1900                 :          1 :         name = clone_function_name (node->decl, "localalias", num++);
    1901                 :            :     }
    1902                 :        857 :   DECL_NAME (new_decl) = name;
    1903                 :        857 :   if (TREE_CODE (new_decl) == FUNCTION_DECL)
    1904                 :        855 :     DECL_STRUCT_FUNCTION (new_decl) = NULL;
    1905                 :        857 :   DECL_INITIAL (new_decl) = NULL;
    1906                 :        857 :   SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
    1907                 :        857 :   SET_DECL_RTL (new_decl, NULL);
    1908                 :            : 
    1909                 :            :   /* Update the properties.  */
    1910                 :        857 :   DECL_EXTERNAL (new_decl) = 0;
    1911                 :        857 :   TREE_PUBLIC (new_decl) = 0;
    1912                 :        857 :   DECL_COMDAT (new_decl) = 0;
    1913                 :        857 :   DECL_WEAK (new_decl) = 0;
    1914                 :            : 
    1915                 :            :   /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag.  */
    1916                 :        857 :   DECL_VIRTUAL_P (new_decl) = DECL_VIRTUAL_P (node->decl);
    1917                 :        857 :   if (TREE_CODE (new_decl) == FUNCTION_DECL)
    1918                 :            :     {
    1919                 :        855 :       DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
    1920                 :        855 :       DECL_STATIC_DESTRUCTOR (new_decl) = 0;
    1921                 :        855 :       new_node = cgraph_node::create_alias (new_decl, node->decl);
    1922                 :            : 
    1923                 :       1710 :       cgraph_node *new_cnode = dyn_cast <cgraph_node *> (new_node),
    1924                 :        855 :                    *cnode = dyn_cast <cgraph_node *> (node);
    1925                 :            : 
    1926                 :        855 :       new_cnode->unit_id = cnode->unit_id;
    1927                 :        855 :       new_cnode->merged_comdat = cnode->merged_comdat;
    1928                 :        855 :       new_cnode->merged_extern_inline = cnode->merged_extern_inline;
    1929                 :            :     }
    1930                 :            :   else
    1931                 :            :     {
    1932                 :          2 :       TREE_READONLY (new_decl) = TREE_READONLY (node->decl);
    1933                 :          2 :       DECL_INITIAL (new_decl) = error_mark_node;
    1934                 :          2 :       new_node = varpool_node::create_alias (new_decl, node->decl);
    1935                 :            :     }
    1936                 :        857 :   new_node->resolve_alias (node);
    1937                 :        857 :   gcc_assert (decl_binds_to_current_def_p (new_decl)
    1938                 :            :               && targetm.binds_local_p (new_decl));
    1939                 :        857 :   return new_node;
    1940                 :            : }
    1941                 :            : 
    1942                 :            : /* Return true if symtab node and TARGET represents
    1943                 :            :    semantically equivalent symbols.  */
    1944                 :            : 
    1945                 :            : bool
    1946                 :     380923 : symtab_node::semantically_equivalent_p (symtab_node *target)
    1947                 :            : {
    1948                 :     380923 :   enum availability avail;
    1949                 :     380923 :   symtab_node *ba;
    1950                 :     380923 :   symtab_node *bb;
    1951                 :            : 
    1952                 :            :   /* Equivalent functions are equivalent.  */
    1953                 :     380923 :   if (decl == target->decl)
    1954                 :            :     return true;
    1955                 :            : 
    1956                 :            :   /* If symbol is not overwritable by different implementation,
    1957                 :            :      walk to the base object it defines.  */
    1958                 :     302654 :   ba = ultimate_alias_target (&avail);
    1959                 :     302654 :   if (avail >= AVAIL_AVAILABLE)
    1960                 :            :     {
    1961                 :      49341 :       if (target == ba)
    1962                 :            :         return true;
    1963                 :            :     }
    1964                 :            :   else
    1965                 :            :     ba = this;
    1966                 :     302654 :   bb = target->ultimate_alias_target (&avail);
    1967                 :     302654 :   if (avail >= AVAIL_AVAILABLE)
    1968                 :            :     {
    1969                 :      51857 :       if (this == bb)
    1970                 :            :         return true;
    1971                 :            :     }
    1972                 :            :   else
    1973                 :            :     bb = target;
    1974                 :     302637 :   return bb == ba;
    1975                 :            : }
    1976                 :            : 
    1977                 :            : /* Classify symbol symtab node for partitioning.  */
    1978                 :            : 
    1979                 :            : enum symbol_partitioning_class
    1980                 :    1289630 : symtab_node::get_partitioning_class (void)
    1981                 :            : {
    1982                 :            :   /* Inline clones are always duplicated.
    1983                 :            :      This include external declarations.   */
    1984                 :    1289630 :   cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
    1985                 :            : 
    1986                 :    1289630 :   if (DECL_ABSTRACT_P (decl))
    1987                 :            :     return SYMBOL_EXTERNAL;
    1988                 :            : 
    1989                 :    1289630 :   if (cnode && cnode->inlined_to)
    1990                 :            :     return SYMBOL_DUPLICATE;
    1991                 :            : 
    1992                 :            :   /* Transparent aliases are always duplicated.  */
    1993                 :    1283460 :   if (transparent_alias)
    1994                 :         79 :     return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL;
    1995                 :            : 
    1996                 :            :   /* External declarations are external.  */
    1997                 :    1283380 :   if (DECL_EXTERNAL (decl))
    1998                 :            :     return SYMBOL_EXTERNAL;
    1999                 :            : 
    2000                 :            :   /* Even static aliases of external functions as external.  Those can happen
    2001                 :            :      when COMDAT got resolved to non-IL implementation.  */
    2002                 :    1270620 :   if (alias && DECL_EXTERNAL (ultimate_alias_target ()->decl))
    2003                 :            :     return SYMBOL_EXTERNAL;
    2004                 :            : 
    2005                 :    1206250 :   if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
    2006                 :            :     {
    2007                 :     618756 :       if (alias && definition && !ultimate_alias_target ()->definition)
    2008                 :            :         return SYMBOL_EXTERNAL;
    2009                 :            :       /* Constant pool references use local symbol names that cannot
    2010                 :            :          be promoted global.  We should never put into a constant pool
    2011                 :            :          objects that cannot be duplicated across partitions.  */
    2012                 :     617132 :       if (DECL_IN_CONSTANT_POOL (decl))
    2013                 :            :         return SYMBOL_DUPLICATE;
    2014                 :     617058 :       if (DECL_HARD_REGISTER (decl))
    2015                 :            :         return SYMBOL_DUPLICATE;
    2016                 :     616977 :       gcc_checking_assert (vnode->definition);
    2017                 :            :     }
    2018                 :            :   /* Functions that are cloned may stay in callgraph even if they are unused.
    2019                 :            :      Handle them as external; compute_ltrans_boundary take care to make
    2020                 :            :      proper things to happen (i.e. to make them appear in the boundary but
    2021                 :            :      with body streamed, so clone can me materialized).  */
    2022                 :     589118 :   else if (!dyn_cast <cgraph_node *> (this)->function_symbol ()->definition)
    2023                 :            :     return SYMBOL_EXTERNAL;
    2024                 :            : 
    2025                 :            :   /* Linker discardable symbols are duplicated to every use unless they are
    2026                 :            :      keyed.  */
    2027                 :    1218860 :   if (DECL_ONE_ONLY (decl)
    2028                 :            :       && !force_output
    2029                 :      14304 :       && !forced_by_abi
    2030                 :    1217240 :       && !used_from_object_file_p ())
    2031                 :      12829 :     return SYMBOL_DUPLICATE;
    2032                 :            : 
    2033                 :            :   return SYMBOL_PARTITION;
    2034                 :            : }
    2035                 :            : 
    2036                 :            : /* Return true when symbol is known to be non-zero.  */
    2037                 :            : 
    2038                 :            : bool
    2039                 :   15003400 : symtab_node::nonzero_address ()
    2040                 :            : {
    2041                 :            :   /* Weakrefs may be NULL when their target is not defined.  */
    2042                 :   15003400 :   if (alias && weakref)
    2043                 :            :     {
    2044                 :     698277 :       if (analyzed)
    2045                 :            :         {
    2046                 :        354 :           symtab_node *target = ultimate_alias_target ();
    2047                 :            : 
    2048                 :        354 :           if (target->alias && target->weakref)
    2049                 :            :             return false;
    2050                 :            :           /* We cannot recurse to target::nonzero.  It is possible that the
    2051                 :            :              target is used only via the alias.
    2052                 :            :              We may walk references and look for strong use, but we do not know
    2053                 :            :              if this strong use will survive to final binary, so be
    2054                 :            :              conservative here.  
    2055                 :            :              ??? Maybe we could do the lookup during late optimization that
    2056                 :            :              could be useful to eliminate the NULL pointer checks in LTO
    2057                 :            :              programs.  */
    2058                 :        118 :           if (target->definition && !DECL_EXTERNAL (target->decl))
    2059                 :            :               return true;
    2060                 :        118 :           if (target->resolution != LDPR_UNKNOWN
    2061                 :            :               && target->resolution != LDPR_UNDEF
    2062                 :          0 :               && !target->can_be_discarded_p ()
    2063                 :        118 :               && flag_delete_null_pointer_checks)
    2064                 :            :             return true;
    2065                 :        118 :           return false;
    2066                 :            :         }
    2067                 :            :       else
    2068                 :            :         return false;
    2069                 :            :     }
    2070                 :            : 
    2071                 :            :   /* With !flag_delete_null_pointer_checks we assume that symbols may
    2072                 :            :      bind to NULL. This is on by default on embedded targets only.
    2073                 :            : 
    2074                 :            :      Otherwise all non-WEAK symbols must be defined and thus non-NULL or
    2075                 :            :      linking fails.  Important case of WEAK we want to do well are comdats,
    2076                 :            :      which also must be defined somewhere.
    2077                 :            : 
    2078                 :            :      When parsing, beware the cases when WEAK attribute is added later.  */
    2079                 :   18678500 :   if ((!DECL_WEAK (decl) || DECL_COMDAT (decl))
    2080                 :   14963700 :       && flag_delete_null_pointer_checks)
    2081                 :            :     {
    2082                 :   10574700 :       refuse_visibility_changes = true;
    2083                 :   10574700 :       return true;
    2084                 :            :     }
    2085                 :            : 
    2086                 :            :   /* If target is defined and not extern, we know it will be
    2087                 :            :      output and thus it will bind to non-NULL.
    2088                 :            :      Play safe for flag_delete_null_pointer_checks where weak definition may
    2089                 :            :      be re-defined by NULL.  */
    2090                 :    3688050 :   if (definition && !DECL_EXTERNAL (decl)
    2091                 :    7418500 :       && (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
    2092                 :            :     {
    2093                 :    3685140 :       if (!DECL_WEAK (decl))
    2094                 :       9399 :         refuse_visibility_changes = true;
    2095                 :    3685140 :       return true;
    2096                 :            :     }
    2097                 :            : 
    2098                 :            :   /* As the last resort, check the resolution info.  */
    2099                 :      45309 :   if (resolution != LDPR_UNKNOWN
    2100                 :            :       && resolution != LDPR_UNDEF
    2101                 :          0 :       && !can_be_discarded_p ()
    2102                 :      45309 :       && flag_delete_null_pointer_checks)
    2103                 :          0 :     return true;
    2104                 :            :   return false;
    2105                 :            : }
    2106                 :            : 
    2107                 :            : /* Return 0 if symbol is known to have different address than S2,
    2108                 :            :    Return 1 if symbol is known to have same address as S2,
    2109                 :            :    return -1 otherwise.  
    2110                 :            : 
    2111                 :            :    If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
    2112                 :            :    and S2 is going to be accessed.  This eliminates the situations when
    2113                 :            :    either THIS or S2 is NULL and is useful for comparing bases when deciding
    2114                 :            :    about memory aliasing.  */
    2115                 :            : int
    2116                 :   93748800 : symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
    2117                 :            : {
    2118                 :   93748800 :   enum availability avail1, avail2;
    2119                 :            : 
    2120                 :            :   /* A Shortcut: equivalent symbols are always equivalent.  */
    2121                 :   93748800 :   if (this == s2)
    2122                 :            :     return 1;
    2123                 :            : 
    2124                 :            :   /* Unwind transparent aliases first; those are always equal to their
    2125                 :            :      target.  */
    2126                 :   93166000 :   if (this->transparent_alias && this->analyzed)
    2127                 :          0 :     return this->get_alias_target ()->equal_address_to (s2);
    2128                 :   93166000 :   while (s2->transparent_alias && s2->analyzed)
    2129                 :          0 :     s2 = s2->get_alias_target();
    2130                 :            : 
    2131                 :   93166000 :   if (this == s2)
    2132                 :            :     return 1;
    2133                 :            : 
    2134                 :            :   /* For non-interposable aliases, lookup and compare their actual definitions.
    2135                 :            :      Also check if the symbol needs to bind to given definition.  */
    2136                 :   93166000 :   symtab_node *rs1 = ultimate_alias_target (&avail1);
    2137                 :   93166000 :   symtab_node *rs2 = s2->ultimate_alias_target (&avail2);
    2138                 :   93166000 :   bool binds_local1 = rs1->analyzed && decl_binds_to_current_def_p (this->decl);
    2139                 :   93166000 :   bool binds_local2 = rs2->analyzed && decl_binds_to_current_def_p (s2->decl);
    2140                 :   93166000 :   bool really_binds_local1 = binds_local1;
    2141                 :   93166000 :   bool really_binds_local2 = binds_local2;
    2142                 :            : 
    2143                 :            :   /* Addresses of vtables and virtual functions cannot be used by user
    2144                 :            :      code and are used only within speculation.  In this case we may make
    2145                 :            :      symbol equivalent to its alias even if interposition may break this
    2146                 :            :      rule.  Doing so will allow us to turn speculative inlining into
    2147                 :            :      non-speculative more aggressively.  */
    2148                 :   93166000 :   if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
    2149                 :            :     binds_local1 = true;
    2150                 :   93166000 :   if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
    2151                 :            :     binds_local2 = true;
    2152                 :            : 
    2153                 :            :   /* If both definitions are available we know that even if they are bound
    2154                 :            :      to other unit they must be defined same way and therefore we can use
    2155                 :            :      equivalence test.  */
    2156                 :   93166000 :   if (rs1 != rs2 && avail1 >= AVAIL_AVAILABLE && avail2 >= AVAIL_AVAILABLE)
    2157                 :   44503000 :     binds_local1 = binds_local2 = true;
    2158                 :            : 
    2159                 :   93166000 :   if (binds_local1 && binds_local2 && rs1 == rs2)
    2160                 :            :     {
    2161                 :            :       /* We made use of the fact that alias is not weak.  */
    2162                 :        327 :       if (rs1 != this)
    2163                 :        163 :         refuse_visibility_changes = true;
    2164                 :        327 :       if (rs2 != s2)
    2165                 :        164 :         s2->refuse_visibility_changes = true;
    2166                 :        327 :       return 1;
    2167                 :            :     }
    2168                 :            : 
    2169                 :            :   /* If both symbols may resolve to NULL, we cannot really prove them
    2170                 :            :      different.  */
    2171                 :   93165700 :   if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
    2172                 :            :     return -1;
    2173                 :            : 
    2174                 :            :   /* Except for NULL, functions and variables never overlap.  */
    2175                 :   93164600 :   if (TREE_CODE (decl) != TREE_CODE (s2->decl))
    2176                 :            :     return 0;
    2177                 :            : 
    2178                 :            :   /* If one of the symbols is unresolved alias, punt.  */
    2179                 :   93047200 :   if (rs1->alias || rs2->alias)
    2180                 :            :     return -1;
    2181                 :            : 
    2182                 :            :   /* If we have a non-interposale definition of at least one of the symbols
    2183                 :            :      and the other symbol is different, we know other unit cannot interpose
    2184                 :            :      it to the first symbol; all aliases of the definition needs to be 
    2185                 :            :      present in the current unit.  */
    2186                 :   93047200 :   if (((really_binds_local1 || really_binds_local2)
    2187                 :            :       /* If we have both definitions and they are different, we know they
    2188                 :            :          will be different even in units they binds to.  */
    2189                 :   15833100 :        || (binds_local1 && binds_local2))
    2190                 :   77302500 :       && rs1 != rs2)
    2191                 :            :     {
    2192                 :            :       /* We make use of the fact that one symbol is not alias of the other
    2193                 :            :          and that the definition is non-interposable.  */
    2194                 :   77302400 :       refuse_visibility_changes = true;
    2195                 :   77302400 :       s2->refuse_visibility_changes = true;
    2196                 :   77302400 :       rs1->refuse_visibility_changes = true;
    2197                 :   77302400 :       rs2->refuse_visibility_changes = true;
    2198                 :   77302400 :       return 0;
    2199                 :            :     }
    2200                 :            : 
    2201                 :            :   /* TODO: Alias oracle basically assume that addresses of global variables
    2202                 :            :      are different unless they are declared as alias of one to another while
    2203                 :            :      the code folding comparisons doesn't.
    2204                 :            :      We probably should be consistent and use this fact here, too, but for
    2205                 :            :      the moment return false only when we are called from the alias oracle.  */
    2206                 :            : 
    2207                 :   15744800 :   return memory_accessed && rs1 != rs2 ? 0 : -1;
    2208                 :            : }
    2209                 :            : 
    2210                 :            : /* Worker for call_for_symbol_and_aliases.  */
    2211                 :            : 
    2212                 :            : bool
    2213                 :     125343 : symtab_node::call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *,
    2214                 :            :                                                               void *),
    2215                 :            :                                             void *data,
    2216                 :            :                                             bool include_overwritable)
    2217                 :            : {
    2218                 :     125343 :   ipa_ref *ref;
    2219                 :     526075 :   FOR_EACH_ALIAS (this, ref)
    2220                 :            :     {
    2221                 :     141941 :       symtab_node *alias = ref->referring;
    2222                 :     141941 :       if (include_overwritable
    2223                 :     141941 :           || alias->get_availability () > AVAIL_INTERPOSABLE)
    2224                 :     141941 :         if (alias->call_for_symbol_and_aliases (callback, data,
    2225                 :            :                                               include_overwritable))
    2226                 :            :           return true;
    2227                 :            :     }
    2228                 :            :   return false;
    2229                 :            : }
    2230                 :            : 
    2231                 :            : /* Return true if address of N is possibly compared.  */
    2232                 :            : 
    2233                 :            : static bool
    2234                 :     517778 : address_matters_1 (symtab_node *n, void *)
    2235                 :            : {
    2236                 :     517778 :   struct ipa_ref *ref;
    2237                 :            : 
    2238                 :     517778 :   if (!n->address_can_be_compared_p ())
    2239                 :            :     return false;
    2240                 :     508510 :   if (n->externally_visible || n->force_output)
    2241                 :            :     return true;
    2242                 :            : 
    2243                 :     791411 :   for (unsigned int i = 0; n->iterate_referring (i, ref); i++)
    2244                 :     375198 :     if (ref->address_matters_p ())
    2245                 :            :       return true;
    2246                 :            :   return false;
    2247                 :            : }
    2248                 :            : 
    2249                 :            : /* Return true if symbol's address may possibly be compared to other
    2250                 :            :    symbol's address.  */
    2251                 :            : 
    2252                 :            : bool
    2253                 :     500012 : symtab_node::address_matters_p ()
    2254                 :            : {
    2255                 :     500012 :   gcc_assert (!alias);
    2256                 :     500012 :   return call_for_symbol_and_aliases (address_matters_1, NULL, true);
    2257                 :            : }
    2258                 :            : 
    2259                 :            : /* Return true if symbol's alignment may be increased.  */
    2260                 :            : 
    2261                 :            : bool
    2262                 :       2275 : symtab_node::can_increase_alignment_p (void)
    2263                 :            : {
    2264                 :       2275 :   symtab_node *target = ultimate_alias_target ();
    2265                 :            : 
    2266                 :            :   /* For now support only variables.  */
    2267                 :       2275 :   if (!VAR_P (decl))
    2268                 :            :     return false;
    2269                 :            : 
    2270                 :            :   /* With -fno-toplevel-reorder we may have already output the constant.  */
    2271                 :       2275 :   if (TREE_ASM_WRITTEN (target->decl))
    2272                 :            :     return false;
    2273                 :            : 
    2274                 :            :   /* If target is already placed in an anchor, we cannot touch its
    2275                 :            :      alignment.  */
    2276                 :       2275 :   if (DECL_RTL_SET_P (target->decl)
    2277                 :        148 :       && MEM_P (DECL_RTL (target->decl))
    2278                 :       2423 :       && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target->decl), 0)))
    2279                 :            :     return false;
    2280                 :            : 
    2281                 :            :   /* Constant pool entries may be shared.  */
    2282                 :       2275 :   if (DECL_IN_CONSTANT_POOL (target->decl))
    2283                 :            :     return false;
    2284                 :            : 
    2285                 :            :   /* We cannot change alignment of symbols that may bind to symbols
    2286                 :            :      in other translation unit that may contain a definition with lower
    2287                 :            :      alignment.  */
    2288                 :       2275 :   if (!decl_binds_to_current_def_p (decl))
    2289                 :            :     return false;
    2290                 :            : 
    2291                 :            :   /* When compiling partition, be sure the symbol is not output by other
    2292                 :            :      partition.  */
    2293                 :        965 :   if (flag_ltrans
    2294                 :        965 :       && (target->in_other_partition
    2295                 :         63 :           || target->get_partitioning_class () == SYMBOL_DUPLICATE))
    2296                 :          0 :     return false;
    2297                 :            : 
    2298                 :            :   /* Do not override the alignment as specified by the ABI when the used
    2299                 :            :      attribute is set.  */
    2300                 :        965 :   if (DECL_PRESERVE_P (decl) || DECL_PRESERVE_P (target->decl))
    2301                 :            :     return false;
    2302                 :            : 
    2303                 :            :   /* Do not override explicit alignment set by the user when an explicit
    2304                 :            :      section name is also used.  This is a common idiom used by many
    2305                 :            :      software projects.  */
    2306                 :        964 :   if (DECL_SECTION_NAME (target->decl) != NULL && !target->implicit_section)
    2307                 :          0 :     return false;
    2308                 :            : 
    2309                 :            :   return true;
    2310                 :            : }
    2311                 :            : 
    2312                 :            : /* Worker for symtab_node::increase_alignment.  */
    2313                 :            : 
    2314                 :            : static bool
    2315                 :        259 : increase_alignment_1 (symtab_node *n, void *v)
    2316                 :            : {
    2317                 :        259 :   unsigned int align = (size_t)v;
    2318                 :        259 :   if (DECL_ALIGN (n->decl) < align
    2319                 :        259 :       && n->can_increase_alignment_p ())
    2320                 :            :     {
    2321                 :        230 :       SET_DECL_ALIGN (n->decl, align);
    2322                 :        230 :       DECL_USER_ALIGN (n->decl) = 1;
    2323                 :            :     }
    2324                 :        259 :   return false;
    2325                 :            : }
    2326                 :            : 
    2327                 :            : /* Increase alignment of THIS to ALIGN.  */
    2328                 :            : 
    2329                 :            : void
    2330                 :        259 : symtab_node::increase_alignment (unsigned int align)
    2331                 :            : {
    2332                 :        259 :   gcc_assert (can_increase_alignment_p () && align <= MAX_OFILE_ALIGNMENT);
    2333                 :        259 :   ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1,
    2334                 :        259 :                                                         (void *)(size_t) align,
    2335                 :            :                                                         true);
    2336                 :        259 :   gcc_assert (DECL_ALIGN (decl) >= align);
    2337                 :        259 : }
    2338                 :            : 
    2339                 :            : /* Helper for symtab_node::definition_alignment.  */
    2340                 :            : 
    2341                 :            : static bool
    2342                 :    1092050 : get_alignment_1 (symtab_node *n, void *v)
    2343                 :            : {
    2344                 :    1092050 :   *((unsigned int *)v) = MAX (*((unsigned int *)v), DECL_ALIGN (n->decl));
    2345                 :    1092050 :   return false;
    2346                 :            : }
    2347                 :            : 
    2348                 :            : /* Return desired alignment of the definition.  This is NOT alignment useful
    2349                 :            :    to access THIS, because THIS may be interposable and DECL_ALIGN should
    2350                 :            :    be used instead.  It however must be guaranteed when output definition
    2351                 :            :    of THIS.  */
    2352                 :            : 
    2353                 :            : unsigned int
    2354                 :    1039340 : symtab_node::definition_alignment ()
    2355                 :            : {
    2356                 :    1039340 :   unsigned int align = 0;
    2357                 :    1039340 :   gcc_assert (!alias);
    2358                 :    1039340 :   call_for_symbol_and_aliases (get_alignment_1, &align, true);
    2359                 :    1039340 :   return align;
    2360                 :            : }
    2361                 :            : 
    2362                 :            : /* Return symbol used to separate symbol name from suffix.  */
    2363                 :            : 
    2364                 :            : char 
    2365                 :     188678 : symbol_table::symbol_suffix_separator ()
    2366                 :            : {
    2367                 :            : #ifndef NO_DOT_IN_LABEL
    2368                 :     188678 :   return '.';
    2369                 :            : #elif !defined NO_DOLLAR_IN_LABEL
    2370                 :            :   return '$';
    2371                 :            : #else
    2372                 :            :   return '_';
    2373                 :            : #endif
    2374                 :            : }
    2375                 :            : 
    2376                 :            : /* Return true when references to this symbol from REF must bind to current
    2377                 :            :    definition in final executable.  */
    2378                 :            : 
    2379                 :            : bool
    2380                 :     663760 : symtab_node::binds_to_current_def_p (symtab_node *ref)
    2381                 :            : {
    2382                 :     663760 :   if (!definition)
    2383                 :            :     return false;
    2384                 :     662212 :   if (transparent_alias)
    2385                 :          0 :     return definition
    2386                 :          0 :            && get_alias_target()->binds_to_current_def_p (ref);
    2387                 :     662212 :   cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
    2388                 :     662212 :   if (cnode && cnode->ifunc_resolver)
    2389                 :            :     return false;
    2390                 :     662208 :   if (decl_binds_to_current_def_p (decl))
    2391                 :            :     return true;
    2392                 :            : 
    2393                 :            :   /* Inline clones always binds locally.  */
    2394                 :     377112 :   if (cnode && cnode->inlined_to)
    2395                 :            :     return true;
    2396                 :            : 
    2397                 :     359084 :   if (DECL_EXTERNAL (decl))
    2398                 :            :     return false;
    2399                 :            : 
    2400                 :     318134 :   gcc_assert (externally_visible);
    2401                 :            : 
    2402                 :     318134 :   if (ref)
    2403                 :            :     {
    2404                 :        272 :       cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
    2405                 :        272 :       if (cref)
    2406                 :        272 :         ref = cref->inlined_to;
    2407                 :            :     }
    2408                 :            : 
    2409                 :            :   /* If this is a reference from symbol itself and there are no aliases, we
    2410                 :            :      may be sure that the symbol was not interposed by something else because
    2411                 :            :      the symbol itself would be unreachable otherwise.  This is important
    2412                 :            :      to optimize recursive functions well.
    2413                 :            : 
    2414                 :            :      This assumption may be broken by inlining: if symbol is interposable
    2415                 :            :      but the body is available (i.e. declared inline), inliner may make
    2416                 :            :      the body reachable even with interposition.  */
    2417                 :          0 :   if (this == ref && !has_aliases_p ()
    2418                 :     318185 :       && (!cnode
    2419                 :         51 :           || symtab->state >= IPA_SSA_AFTER_INLINING
    2420                 :          0 :           || get_availability () >= AVAIL_INTERPOSABLE))
    2421                 :         51 :     return true;
    2422                 :            : 
    2423                 :            : 
    2424                 :            :   /* References within one comdat group are always bound in a group.  */
    2425                 :     318083 :   if (ref
    2426                 :         29 :       && symtab->state >= IPA_SSA_AFTER_INLINING
    2427                 :         29 :       && get_comdat_group ()
    2428                 :     318108 :       && get_comdat_group () == ref->get_comdat_group ())
    2429                 :          4 :     return true;
    2430                 :            : 
    2431                 :            :   return false;
    2432                 :            : }
    2433                 :            : 
    2434                 :            : /* Return true if symbol should be output to the symbol table.  */
    2435                 :            : 
    2436                 :            : bool
    2437                 :    1130890 : symtab_node::output_to_lto_symbol_table_p (void)
    2438                 :            : {
    2439                 :            :   /* Only externally visible symbols matter.  */
    2440                 :    1130890 :   if (!TREE_PUBLIC (decl))
    2441                 :            :     return false;
    2442                 :    1063100 :   if (!real_symbol_p ())
    2443                 :            :     return false;
    2444                 :            :   /* FIXME: variables probably should not be considered as real symbols at
    2445                 :            :      first place.  */
    2446                 :    1063100 :   if (VAR_P (decl) && DECL_HARD_REGISTER (decl))
    2447                 :            :     return false;
    2448                 :     614086 :   if (TREE_CODE (decl) == FUNCTION_DECL && !definition
    2449                 :    1513350 :       && fndecl_built_in_p (decl))
    2450                 :            :     {
    2451                 :            :       /* Builtins like those for most math functions have actual implementations
    2452                 :            :          in libraries so make sure to output references into the symbol table to
    2453                 :            :          make those libraries referenced.  Note this is incomplete handling for
    2454                 :            :          now and only covers math functions.  */
    2455                 :      31310 :       if (builtin_with_linkage_p (decl))
    2456                 :            :         return true;
    2457                 :            :       else
    2458                 :      30126 :         return false;
    2459                 :            :     }
    2460                 :            : 
    2461                 :            :   /* We have real symbol that should be in symbol table.  However try to trim
    2462                 :            :      down the references to libraries bit more because linker will otherwise
    2463                 :            :      bring unnecessary object files into the final link.
    2464                 :            :      FIXME: The following checks can easily be confused i.e. by self recursive
    2465                 :            :      function or self-referring variable.  */
    2466                 :            : 
    2467                 :            :   /* We keep external functions in symtab for sake of inlining
    2468                 :            :      and devirtualization.  We do not want to see them in symbol table as
    2469                 :            :      references unless they are really used.  */
    2470                 :    1031770 :   cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
    2471                 :     582776 :   if (cnode && (!definition || DECL_EXTERNAL (decl))
    2472                 :     419498 :       && cnode->callers)
    2473                 :            :     return true;
    2474                 :            : 
    2475                 :            :  /* Ignore all references from external vars initializers - they are not really
    2476                 :            :     part of the compilation unit until they are used by folding.  Some symbols,
    2477                 :            :     like references to external construction vtables cannot be referred to at
    2478                 :            :     all.  We decide this at can_refer_decl_in_current_unit_p.  */
    2479                 :    1014070 :  if (!definition || DECL_EXTERNAL (decl))
    2480                 :            :     {
    2481                 :            :       int i;
    2482                 :            :       struct ipa_ref *ref;
    2483                 :     814508 :       for (i = 0; iterate_referring (i, ref); i++)
    2484                 :            :         {
    2485                 :     407172 :           if (ref->use == IPA_REF_ALIAS)
    2486                 :        160 :             continue;
    2487                 :     407012 :           if (is_a <cgraph_node *> (ref->referring))
    2488                 :            :             return true;
    2489                 :     402962 :           if (!DECL_EXTERNAL (ref->referring->decl))
    2490                 :            :             return true;
    2491                 :            :         }
    2492                 :            :       return false;
    2493                 :            :     }
    2494                 :            :   return true;
    2495                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.