LCOV - code coverage report
Current view: top level - gcc - cgraph.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 82.9 % 2069 1715
Test Date: 2024-11-30 13:30:02 Functions: 93.5 % 123 115
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Callgraph handling code.
       2                 :             :    Copyright (C) 2003-2024 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                 :             : /*  This file contains basic routines manipulating call graph
      22                 :             : 
      23                 :             :     The call-graph is a data structure designed for inter-procedural
      24                 :             :     optimization.  It represents a multi-graph where nodes are functions
      25                 :             :     (symbols within symbol table) and edges are call sites. */
      26                 :             : 
      27                 :             : #include "config.h"
      28                 :             : #include "system.h"
      29                 :             : #include "coretypes.h"
      30                 :             : #include "backend.h"
      31                 :             : #include "target.h"
      32                 :             : #include "rtl.h"
      33                 :             : #include "tree.h"
      34                 :             : #include "gimple.h"
      35                 :             : #include "predict.h"
      36                 :             : #include "alloc-pool.h"
      37                 :             : #include "gimple-ssa.h"
      38                 :             : #include "cgraph.h"
      39                 :             : #include "lto-streamer.h"
      40                 :             : #include "fold-const.h"
      41                 :             : #include "varasm.h"
      42                 :             : #include "calls.h"
      43                 :             : #include "print-tree.h"
      44                 :             : #include "langhooks.h"
      45                 :             : #include "intl.h"
      46                 :             : #include "tree-eh.h"
      47                 :             : #include "gimple-iterator.h"
      48                 :             : #include "tree-cfg.h"
      49                 :             : #include "tree-ssa.h"
      50                 :             : #include "value-prof.h"
      51                 :             : #include "ipa-utils.h"
      52                 :             : #include "symbol-summary.h"
      53                 :             : #include "tree-vrp.h"
      54                 :             : #include "sreal.h"
      55                 :             : #include "ipa-cp.h"
      56                 :             : #include "ipa-prop.h"
      57                 :             : #include "ipa-fnsummary.h"
      58                 :             : #include "cfgloop.h"
      59                 :             : #include "gimple-pretty-print.h"
      60                 :             : #include "tree-dfa.h"
      61                 :             : #include "profile.h"
      62                 :             : #include "context.h"
      63                 :             : #include "gimplify.h"
      64                 :             : #include "stringpool.h"
      65                 :             : #include "attribs.h"
      66                 :             : #include "selftest.h"
      67                 :             : #include "tree-into-ssa.h"
      68                 :             : #include "ipa-inline.h"
      69                 :             : #include "tree-nested.h"
      70                 :             : #include "symtab-thunks.h"
      71                 :             : #include "symtab-clones.h"
      72                 :             : 
      73                 :             : /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this.  */
      74                 :             : #include "tree-pass.h"
      75                 :             : 
      76                 :             : /* Queue of cgraph nodes scheduled to be lowered.  */
      77                 :             : symtab_node *x_cgraph_nodes_queue;
      78                 :             : #define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
      79                 :             : 
      80                 :             : /* Symbol table global context.  */
      81                 :             : symbol_table *symtab;
      82                 :             : 
      83                 :             : /* List of hooks triggered on cgraph_edge events.  */
      84                 :             : struct cgraph_edge_hook_list {
      85                 :             :   cgraph_edge_hook hook;
      86                 :             :   void *data;
      87                 :             :   struct cgraph_edge_hook_list *next;
      88                 :             : };
      89                 :             : 
      90                 :             : /* List of hooks triggered on cgraph_node events.  */
      91                 :             : struct cgraph_node_hook_list {
      92                 :             :   cgraph_node_hook hook;
      93                 :             :   void *data;
      94                 :             :   struct cgraph_node_hook_list *next;
      95                 :             : };
      96                 :             : 
      97                 :             : /* List of hooks triggered on events involving two cgraph_edges.  */
      98                 :             : struct cgraph_2edge_hook_list {
      99                 :             :   cgraph_2edge_hook hook;
     100                 :             :   void *data;
     101                 :             :   struct cgraph_2edge_hook_list *next;
     102                 :             : };
     103                 :             : 
     104                 :             : /* List of hooks triggered on events involving two cgraph_nodes.  */
     105                 :             : struct cgraph_2node_hook_list {
     106                 :             :   cgraph_2node_hook hook;
     107                 :             :   void *data;
     108                 :             :   struct cgraph_2node_hook_list *next;
     109                 :             : };
     110                 :             : 
     111                 :             : /* Hash descriptor for cgraph_function_version_info.  */
     112                 :             : 
     113                 :             : struct function_version_hasher : ggc_ptr_hash<cgraph_function_version_info>
     114                 :             : {
     115                 :             :   static hashval_t hash (cgraph_function_version_info *);
     116                 :             :   static bool equal (cgraph_function_version_info *,
     117                 :             :                      cgraph_function_version_info *);
     118                 :             : };
     119                 :             : 
     120                 :             : /* Map a cgraph_node to cgraph_function_version_info using this htab.
     121                 :             :    The cgraph_function_version_info has a THIS_NODE field that is the
     122                 :             :    corresponding cgraph_node..  */
     123                 :             : 
     124                 :             : static GTY(()) hash_table<function_version_hasher> *cgraph_fnver_htab = NULL;
     125                 :             : 
     126                 :             : /* Hash function for cgraph_fnver_htab.  */
     127                 :             : hashval_t
     128                 :       91347 : function_version_hasher::hash (cgraph_function_version_info *ptr)
     129                 :             : {
     130                 :       91347 :   int uid = ptr->this_node->get_uid ();
     131                 :       91347 :   return (hashval_t)(uid);
     132                 :             : }
     133                 :             : 
     134                 :             : /* eq function for cgraph_fnver_htab.  */
     135                 :             : bool
     136                 :       74959 : function_version_hasher::equal (cgraph_function_version_info *n1,
     137                 :             :                                 cgraph_function_version_info *n2)
     138                 :             : {
     139                 :       74959 :   return n1->this_node->get_uid () == n2->this_node->get_uid ();
     140                 :             : }
     141                 :             : 
     142                 :             : /* Mark as GC root all allocated nodes.  */
     143                 :             : static GTY(()) struct cgraph_function_version_info *
     144                 :             :   version_info_node = NULL;
     145                 :             : 
     146                 :             : /* Return true if NODE's address can be compared.  */
     147                 :             : 
     148                 :             : bool
     149                 :     5053980 : symtab_node::address_can_be_compared_p ()
     150                 :             : {
     151                 :             :   /* Address of virtual tables and functions is never compared.  */
     152                 :     5053980 :   if (DECL_VIRTUAL_P (decl))
     153                 :             :     return false;
     154                 :             :   /* Address of C++ cdtors is never compared.  */
     155                 :     4972289 :   if (is_a <cgraph_node *> (this)
     156                 :      525019 :       && (DECL_CXX_CONSTRUCTOR_P (decl)
     157                 :      520684 :           || DECL_CXX_DESTRUCTOR_P (decl)))
     158                 :             :     return false;
     159                 :             :   /* Constant pool symbols addresses are never compared.
     160                 :             :      flag_merge_constants permits us to assume the same on readonly vars.  */
     161                 :     4966710 :   if (is_a <varpool_node *> (this)
     162                 :     4447270 :       && (DECL_IN_CONSTANT_POOL (decl)
     163                 :     4447267 :           || ((flag_merge_constants >= 2 || DECL_MERGEABLE (decl))
     164                 :        1579 :               && TREE_READONLY (decl) && !TREE_THIS_VOLATILE (decl))))
     165                 :        1575 :     return false;
     166                 :             :   return true;
     167                 :             : }
     168                 :             : 
     169                 :             : /* Get the cgraph_function_version_info node corresponding to node.  */
     170                 :             : cgraph_function_version_info *
     171                 :    94186667 : cgraph_node::function_version (void)
     172                 :             : {
     173                 :    94186667 :   cgraph_function_version_info key;
     174                 :    94186667 :   key.this_node = this;
     175                 :             : 
     176                 :    94186667 :   if (cgraph_fnver_htab == NULL)
     177                 :             :     return NULL;
     178                 :             : 
     179                 :       21055 :   return cgraph_fnver_htab->find (&key);
     180                 :             : }
     181                 :             : 
     182                 :             : /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
     183                 :             :    corresponding to cgraph_node NODE.  */
     184                 :             : cgraph_function_version_info *
     185                 :        1322 : cgraph_node::insert_new_function_version (void)
     186                 :             : {
     187                 :        1322 :   version_info_node = NULL;
     188                 :        1322 :   version_info_node = ggc_cleared_alloc<cgraph_function_version_info> ();
     189                 :        1322 :   version_info_node->this_node = this;
     190                 :             : 
     191                 :        1322 :   if (cgraph_fnver_htab == NULL)
     192                 :         171 :     cgraph_fnver_htab = hash_table<function_version_hasher>::create_ggc (2);
     193                 :             : 
     194                 :        1322 :   *cgraph_fnver_htab->find_slot (version_info_node, INSERT)
     195                 :        1322 :     = version_info_node;
     196                 :        1322 :   return version_info_node;
     197                 :             : }
     198                 :             : 
     199                 :             : /* Remove the cgraph_function_version_info node given by DECL_V.  */
     200                 :             : static void
     201                 :    90653293 : delete_function_version (cgraph_function_version_info *decl_v)
     202                 :             : {
     203                 :    90653293 :   if (decl_v == NULL)
     204                 :             :     return;
     205                 :             : 
     206                 :         247 :   if (version_info_node == decl_v)
     207                 :         205 :     version_info_node = NULL;
     208                 :             : 
     209                 :         247 :   if (decl_v->prev != NULL)
     210                 :         219 :     decl_v->prev->next = decl_v->next;
     211                 :             : 
     212                 :         247 :   if (decl_v->next != NULL)
     213                 :          13 :     decl_v->next->prev = decl_v->prev;
     214                 :             : 
     215                 :         247 :   if (cgraph_fnver_htab != NULL)
     216                 :         247 :     cgraph_fnver_htab->remove_elt (decl_v);
     217                 :             : }
     218                 :             : 
     219                 :             : /* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
     220                 :             :    DECL is a duplicate declaration.  */
     221                 :             : void
     222                 :         258 : cgraph_node::delete_function_version_by_decl (tree decl)
     223                 :             : {
     224                 :         258 :   cgraph_node *decl_node = cgraph_node::get (decl);
     225                 :             : 
     226                 :         258 :   if (decl_node == NULL)
     227                 :             :     return;
     228                 :             : 
     229                 :         204 :   delete_function_version (decl_node->function_version ());
     230                 :             : 
     231                 :         204 :   decl_node->remove ();
     232                 :             : }
     233                 :             : 
     234                 :             : /* Record that DECL1 and DECL2 are semantically identical function
     235                 :             :    versions.  */
     236                 :             : void
     237                 :         837 : cgraph_node::record_function_versions (tree decl1, tree decl2)
     238                 :             : {
     239                 :         837 :   cgraph_node *decl1_node = cgraph_node::get_create (decl1);
     240                 :         837 :   cgraph_node *decl2_node = cgraph_node::get_create (decl2);
     241                 :         837 :   cgraph_function_version_info *decl1_v = NULL;
     242                 :         837 :   cgraph_function_version_info *decl2_v = NULL;
     243                 :         837 :   cgraph_function_version_info *before;
     244                 :         837 :   cgraph_function_version_info *after;
     245                 :             : 
     246                 :         837 :   gcc_assert (decl1_node != NULL && decl2_node != NULL);
     247                 :         837 :   decl1_v = decl1_node->function_version ();
     248                 :         837 :   decl2_v = decl2_node->function_version ();
     249                 :             : 
     250                 :         837 :   if (decl1_v != NULL && decl2_v != NULL)
     251                 :             :     return;
     252                 :             : 
     253                 :         837 :   if (decl1_v == NULL)
     254                 :         141 :     decl1_v = decl1_node->insert_new_function_version ();
     255                 :             : 
     256                 :         837 :   if (decl2_v == NULL)
     257                 :         837 :     decl2_v = decl2_node->insert_new_function_version ();
     258                 :             : 
     259                 :             :   /* Chain decl2_v and decl1_v.  All semantically identical versions
     260                 :             :      will be chained together.  */
     261                 :             : 
     262                 :         837 :   before = decl1_v;
     263                 :         837 :   after = decl2_v;
     264                 :             : 
     265                 :         837 :   while (before->next != NULL)
     266                 :             :     before = before->next;
     267                 :             : 
     268                 :         837 :   while (after->prev != NULL)
     269                 :             :     after= after->prev;
     270                 :             : 
     271                 :         837 :   before->next = after;
     272                 :         837 :   after->prev = before;
     273                 :             : }
     274                 :             : 
     275                 :             : /* Initialize callgraph dump file.  */
     276                 :             : 
     277                 :             : void
     278                 :      298097 : symbol_table::initialize (void)
     279                 :             : {
     280                 :      298097 :   if (!dump_file)
     281                 :      298095 :     dump_file = dump_begin (TDI_cgraph, NULL);
     282                 :             : 
     283                 :      298097 :   if (!ipa_clones_dump_file)
     284                 :      298097 :     ipa_clones_dump_file = dump_begin (TDI_clones, NULL);
     285                 :      298097 : }
     286                 :             : 
     287                 :             : /* Allocate new callgraph node and insert it into basic data structures.  */
     288                 :             : 
     289                 :             : cgraph_node *
     290                 :    94332218 : symbol_table::create_empty (void)
     291                 :             : {
     292                 :    94332218 :   cgraph_count++;
     293                 :    94332218 :   return new (ggc_alloc<cgraph_node> ()) cgraph_node (cgraph_max_uid++);
     294                 :             : }
     295                 :             : 
     296                 :             : /* Register HOOK to be called with DATA on each removed edge.  */
     297                 :             : cgraph_edge_hook_list *
     298                 :     1848770 : symbol_table::add_edge_removal_hook (cgraph_edge_hook hook, void *data)
     299                 :             : {
     300                 :     1848770 :   cgraph_edge_hook_list *entry;
     301                 :     3697540 :   cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;
     302                 :             : 
     303                 :     1848770 :   entry = (cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
     304                 :     1848770 :   entry->hook = hook;
     305                 :     1848770 :   entry->data = data;
     306                 :     1848770 :   entry->next = NULL;
     307                 :     6383465 :   while (*ptr)
     308                 :     4534695 :     ptr = &(*ptr)->next;
     309                 :     1848770 :   *ptr = entry;
     310                 :     1848770 :   return entry;
     311                 :             : }
     312                 :             : 
     313                 :             : /* Remove ENTRY from the list of hooks called on removing edges.  */
     314                 :             : void
     315                 :     1848756 : symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list *entry)
     316                 :             : {
     317                 :     1848756 :   cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;
     318                 :             : 
     319                 :     5033803 :   while (*ptr != entry)
     320                 :     3185047 :     ptr = &(*ptr)->next;
     321                 :     1848756 :   *ptr = entry->next;
     322                 :     1848756 :   free (entry);
     323                 :     1848756 : }
     324                 :             : 
     325                 :             : /* Call all edge removal hooks.  */
     326                 :             : void
     327                 :    41480763 : symbol_table::call_edge_removal_hooks (cgraph_edge *e)
     328                 :             : {
     329                 :    41480763 :   cgraph_edge_hook_list *entry = m_first_edge_removal_hook;
     330                 :    66856290 :   while (entry)
     331                 :             :   {
     332                 :    25375527 :     entry->hook (e, entry->data);
     333                 :    25375527 :     entry = entry->next;
     334                 :             :   }
     335                 :    41480763 : }
     336                 :             : 
     337                 :             : /* Register HOOK to be called with DATA on each removed node.  */
     338                 :             : cgraph_node_hook_list *
     339                 :     7564871 : symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook, void *data)
     340                 :             : {
     341                 :     7564871 :   cgraph_node_hook_list *entry;
     342                 :    15129742 :   cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;
     343                 :             : 
     344                 :     7564871 :   entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
     345                 :     7564871 :   entry->hook = hook;
     346                 :     7564871 :   entry->data = data;
     347                 :     7564871 :   entry->next = NULL;
     348                 :    38980904 :   while (*ptr)
     349                 :    31416033 :     ptr = &(*ptr)->next;
     350                 :     7564871 :   *ptr = entry;
     351                 :     7564871 :   return entry;
     352                 :             : }
     353                 :             : 
     354                 :             : /* Remove ENTRY from the list of hooks called on removing nodes.  */
     355                 :             : void
     356                 :     7466068 : symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list *entry)
     357                 :             : {
     358                 :     7466068 :   cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;
     359                 :             : 
     360                 :    34619281 :   while (*ptr != entry)
     361                 :    27153213 :     ptr = &(*ptr)->next;
     362                 :     7466068 :   *ptr = entry->next;
     363                 :     7466068 :   free (entry);
     364                 :     7466068 : }
     365                 :             : 
     366                 :             : /* Call all node removal hooks.  */
     367                 :             : void
     368                 :    90684221 : symbol_table::call_cgraph_removal_hooks (cgraph_node *node)
     369                 :             : {
     370                 :    90684221 :   cgraph_node_hook_list *entry = m_first_cgraph_removal_hook;
     371                 :   125228050 :   while (entry)
     372                 :             :   {
     373                 :    34543829 :     entry->hook (node, entry->data);
     374                 :    34543829 :     entry = entry->next;
     375                 :             :   }
     376                 :    90684221 : }
     377                 :             : 
     378                 :             : /* Call all node removal hooks.  */
     379                 :             : void
     380                 :      108959 : symbol_table::call_cgraph_insertion_hooks (cgraph_node *node)
     381                 :             : {
     382                 :      108959 :   cgraph_node_hook_list *entry = m_first_cgraph_insertion_hook;
     383                 :      326817 :   while (entry)
     384                 :             :   {
     385                 :      217858 :     entry->hook (node, entry->data);
     386                 :      217858 :     entry = entry->next;
     387                 :             :   }
     388                 :      108959 : }
     389                 :             : 
     390                 :             : 
     391                 :             : /* Register HOOK to be called with DATA on each inserted node.  */
     392                 :             : cgraph_node_hook_list *
     393                 :     8039076 : symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook, void *data)
     394                 :             : {
     395                 :     8039076 :   cgraph_node_hook_list *entry;
     396                 :    16078152 :   cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;
     397                 :             : 
     398                 :     8039076 :   entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
     399                 :     8039076 :   entry->hook = hook;
     400                 :     8039076 :   entry->data = data;
     401                 :     8039076 :   entry->next = NULL;
     402                 :    23767957 :   while (*ptr)
     403                 :    15728881 :     ptr = &(*ptr)->next;
     404                 :     8039076 :   *ptr = entry;
     405                 :     8039076 :   return entry;
     406                 :             : }
     407                 :             : 
     408                 :             : /* Remove ENTRY from the list of hooks called on inserted nodes.  */
     409                 :             : void
     410                 :     7896629 : symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list *entry)
     411                 :             : {
     412                 :     7896629 :   cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;
     413                 :             : 
     414                 :    21716918 :   while (*ptr != entry)
     415                 :    13820289 :     ptr = &(*ptr)->next;
     416                 :     7896629 :   *ptr = entry->next;
     417                 :     7896629 :   free (entry);
     418                 :     7896629 : }
     419                 :             : 
     420                 :             : /* Register HOOK to be called with DATA on each duplicated edge.  */
     421                 :             : cgraph_2edge_hook_list *
     422                 :     1623632 : symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
     423                 :             : {
     424                 :     1623632 :   cgraph_2edge_hook_list *entry;
     425                 :     3247264 :   cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;
     426                 :             : 
     427                 :     1623632 :   entry = (cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
     428                 :     1623632 :   entry->hook = hook;
     429                 :     1623632 :   entry->data = data;
     430                 :     1623632 :   entry->next = NULL;
     431                 :     5200861 :   while (*ptr)
     432                 :     3577229 :     ptr = &(*ptr)->next;
     433                 :     1623632 :   *ptr = entry;
     434                 :     1623632 :   return entry;
     435                 :             : }
     436                 :             : 
     437                 :             : /* Remove ENTRY from the list of hooks called on duplicating edges.  */
     438                 :             : void
     439                 :     1623618 : symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list *entry)
     440                 :             : {
     441                 :     1623618 :   cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;
     442                 :             : 
     443                 :     3851199 :   while (*ptr != entry)
     444                 :     2227581 :     ptr = &(*ptr)->next;
     445                 :     1623618 :   *ptr = entry->next;
     446                 :     1623618 :   free (entry);
     447                 :     1623618 : }
     448                 :             : 
     449                 :             : /* Call all edge duplication hooks.  */
     450                 :             : void
     451                 :     5800705 : symbol_table::call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2)
     452                 :             : {
     453                 :     5800705 :   cgraph_2edge_hook_list *entry = m_first_edge_duplicated_hook;
     454                 :    17073663 :   while (entry)
     455                 :             :   {
     456                 :    11272958 :     entry->hook (cs1, cs2, entry->data);
     457                 :    11272958 :     entry = entry->next;
     458                 :             :   }
     459                 :     5800705 : }
     460                 :             : 
     461                 :             : /* Register HOOK to be called with DATA on each duplicated node.  */
     462                 :             : cgraph_2node_hook_list *
     463                 :     7427845 : symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook, void *data)
     464                 :             : {
     465                 :     7427845 :   cgraph_2node_hook_list *entry;
     466                 :    14855690 :   cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;
     467                 :             : 
     468                 :     7427845 :   entry = (cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
     469                 :     7427845 :   entry->hook = hook;
     470                 :     7427845 :   entry->data = data;
     471                 :     7427845 :   entry->next = NULL;
     472                 :    36255925 :   while (*ptr)
     473                 :    28828080 :     ptr = &(*ptr)->next;
     474                 :     7427845 :   *ptr = entry;
     475                 :     7427845 :   return entry;
     476                 :             : }
     477                 :             : 
     478                 :             : /* Remove ENTRY from the list of hooks called on duplicating nodes.  */
     479                 :             : void
     480                 :     7341537 : symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry)
     481                 :             : {
     482                 :     7341537 :   cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;
     483                 :             : 
     484                 :    32809038 :   while (*ptr != entry)
     485                 :    25467501 :     ptr = &(*ptr)->next;
     486                 :     7341537 :   *ptr = entry->next;
     487                 :     7341537 :   free (entry);
     488                 :     7341537 : }
     489                 :             : 
     490                 :             : /* Call all node duplication hooks.  */
     491                 :             : void
     492                 :     2538989 : symbol_table::call_cgraph_duplication_hooks (cgraph_node *node,
     493                 :             :                                              cgraph_node *node2)
     494                 :             : {
     495                 :     2538989 :   cgraph_2node_hook_list *entry = m_first_cgraph_duplicated_hook;
     496                 :    17932750 :   while (entry)
     497                 :             :   {
     498                 :    15393761 :     entry->hook (node, node2, entry->data);
     499                 :    15393761 :     entry = entry->next;
     500                 :             :   }
     501                 :     2538989 : }
     502                 :             : 
     503                 :             : /* Return cgraph node assigned to DECL.  Create new one when needed.  */
     504                 :             : 
     505                 :             : cgraph_node *
     506                 :    91569359 : cgraph_node::create (tree decl)
     507                 :             : {
     508                 :    91569359 :   cgraph_node *node = symtab->create_empty ();
     509                 :    91569359 :   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
     510                 :             : 
     511                 :    91569359 :   node->decl = decl;
     512                 :    91569359 :   node->semantic_interposition = opt_for_fn (decl, flag_semantic_interposition);
     513                 :             : 
     514                 :    91521101 :   if ((flag_openacc || flag_openmp)
     515                 :    91736124 :       && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl)))
     516                 :             :     {
     517                 :        7380 :       node->offloadable = 1;
     518                 :        7380 :       if (ENABLE_OFFLOADING)
     519                 :             :         g->have_offload = true;
     520                 :             :     }
     521                 :             : 
     522                 :    91569359 :   if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl)))
     523                 :         120 :     node->ifunc_resolver = true;
     524                 :             : 
     525                 :    91569359 :   node->register_symbol ();
     526                 :    91569359 :   maybe_record_nested_function (node);
     527                 :             : 
     528                 :    91569359 :   return node;
     529                 :             : }
     530                 :             : 
     531                 :             : /* Try to find a call graph node for declaration DECL and if it does not exist
     532                 :             :    or if it corresponds to an inline clone, create a new one.  */
     533                 :             : 
     534                 :             : cgraph_node *
     535                 :   480484796 : cgraph_node::get_create (tree decl)
     536                 :             : {
     537                 :   480484796 :   cgraph_node *first_clone = cgraph_node::get (decl);
     538                 :             : 
     539                 :   480484796 :   if (first_clone && !first_clone->inlined_to)
     540                 :             :     return first_clone;
     541                 :             : 
     542                 :    91509959 :   cgraph_node *node = cgraph_node::create (decl);
     543                 :    91509959 :   if (first_clone)
     544                 :             :     {
     545                 :           7 :       first_clone->clone_of = node;
     546                 :           7 :       node->clones = first_clone;
     547                 :           7 :       node->order = first_clone->order;
     548                 :           7 :       symtab->symtab_prevail_in_asm_name_hash (node);
     549                 :           7 :       node->decl->decl_with_vis.symtab_node = node;
     550                 :           7 :       if (dump_file && symtab->state != PARSING)
     551                 :           2 :         fprintf (dump_file, "Introduced new external node "
     552                 :             :                  "(%s) and turned into root of the clone tree.\n",
     553                 :             :                  node->dump_name ());
     554                 :             :     }
     555                 :    91509952 :   else if (dump_file && symtab->state != PARSING)
     556                 :        1129 :     fprintf (dump_file, "Introduced new external node "
     557                 :             :              "(%s).\n", node->dump_name ());
     558                 :             :   return node;
     559                 :             : }
     560                 :             : 
     561                 :             : /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
     562                 :             :    the function body is associated with
     563                 :             :    (not necessarily cgraph_node (DECL)).  */
     564                 :             : 
     565                 :             : cgraph_node *
     566                 :     6575312 : cgraph_node::create_alias (tree alias, tree target)
     567                 :             : {
     568                 :     6575312 :   cgraph_node *alias_node;
     569                 :             : 
     570                 :     6575312 :   gcc_assert (TREE_CODE (target) == FUNCTION_DECL
     571                 :             :               || TREE_CODE (target) == IDENTIFIER_NODE);
     572                 :     6575312 :   gcc_assert (TREE_CODE (alias) == FUNCTION_DECL);
     573                 :     6575312 :   alias_node = cgraph_node::get_create (alias);
     574                 :     6575312 :   gcc_assert (!alias_node->definition);
     575                 :     6575312 :   alias_node->alias_target = target;
     576                 :     6575312 :   alias_node->definition = true;
     577                 :     6575312 :   alias_node->alias = true;
     578                 :     6575312 :   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
     579                 :          47 :     alias_node->transparent_alias = alias_node->weakref = true;
     580                 :     6575312 :   if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias)))
     581                 :         280 :     alias_node->ifunc_resolver = true;
     582                 :     6575312 :   return alias_node;
     583                 :             : }
     584                 :             : 
     585                 :             : /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if successful
     586                 :             :    and NULL otherwise.
     587                 :             :    Same body aliases are output whenever the body of DECL is output,
     588                 :             :    and cgraph_node::get (ALIAS) transparently returns
     589                 :             :    cgraph_node::get (DECL).  */
     590                 :             : 
     591                 :             : cgraph_node *
     592                 :     6556181 : cgraph_node::create_same_body_alias (tree alias, tree decl)
     593                 :             : {
     594                 :     6556181 :   cgraph_node *n;
     595                 :             : 
     596                 :             :   /* If aliases aren't supported by the assembler, fail.  */
     597                 :     6556181 :   if (!TARGET_SUPPORTS_ALIASES)
     598                 :             :     return NULL;
     599                 :             : 
     600                 :             :   /* Langhooks can create same body aliases of symbols not defined.
     601                 :             :      Those are useless. Drop them on the floor.  */
     602                 :     6556181 :   if (symtab->global_info_ready)
     603                 :             :     return NULL;
     604                 :             : 
     605                 :     6556181 :   n = cgraph_node::create_alias (alias, decl);
     606                 :     6556181 :   n->cpp_implicit_alias = true;
     607                 :     6556181 :   if (symtab->cpp_implicit_aliases_done)
     608                 :     3581190 :     n->resolve_alias (cgraph_node::get (decl));
     609                 :             :   return n;
     610                 :             : }
     611                 :             : 
     612                 :             : /* Add thunk alias into callgraph.  The alias declaration is ALIAS and it
     613                 :             :    aliases DECL with an adjustments made into the first parameter.
     614                 :             :    See comments in struct cgraph_thunk_info for detail on the parameters.  */
     615                 :             : 
     616                 :             : cgraph_node *
     617                 :        4348 : cgraph_node::create_thunk (tree alias, tree, bool this_adjusting,
     618                 :             :                            HOST_WIDE_INT fixed_offset,
     619                 :             :                            HOST_WIDE_INT virtual_value,
     620                 :             :                            HOST_WIDE_INT indirect_offset,
     621                 :             :                            tree virtual_offset,
     622                 :             :                            tree real_alias)
     623                 :             : {
     624                 :        4348 :   cgraph_node *node;
     625                 :             : 
     626                 :        4348 :   node = cgraph_node::get (alias);
     627                 :        4348 :   if (node)
     628                 :        3615 :     node->reset ();
     629                 :             :   else
     630                 :         733 :     node = cgraph_node::create (alias);
     631                 :             : 
     632                 :             :   /* Make sure that if VIRTUAL_OFFSET is in sync with VIRTUAL_VALUE.  */
     633                 :        4348 :   gcc_checking_assert (virtual_offset
     634                 :             :                        ? virtual_value == wi::to_wide (virtual_offset)
     635                 :             :                        : virtual_value == 0);
     636                 :             : 
     637                 :        4348 :   node->thunk = true;
     638                 :        4348 :   node->definition = true;
     639                 :             : 
     640                 :        4348 :   thunk_info *i;
     641                 :        4348 :   thunk_info local_info;
     642                 :        4348 :   if (symtab->state < CONSTRUCTION)
     643                 :             :     i = &local_info;
     644                 :             :   else
     645                 :           0 :     i = thunk_info::get_create (node);
     646                 :        4348 :   i->fixed_offset = fixed_offset;
     647                 :        4348 :   i->virtual_value = virtual_value;
     648                 :        4348 :   i->indirect_offset = indirect_offset;
     649                 :        4348 :   i->alias = real_alias;
     650                 :        4348 :   i->this_adjusting = this_adjusting;
     651                 :        4348 :   i->virtual_offset_p = virtual_offset != NULL;
     652                 :        4348 :   if (symtab->state < CONSTRUCTION)
     653                 :        4348 :     i->register_early (node);
     654                 :             : 
     655                 :        4348 :   return node;
     656                 :             : }
     657                 :             : 
     658                 :             : /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
     659                 :             :    Return NULL if there's no such node.  */
     660                 :             : 
     661                 :             : cgraph_node *
     662                 :           0 : cgraph_node::get_for_asmname (tree asmname)
     663                 :             : {
     664                 :             :   /* We do not want to look at inline clones.  */
     665                 :           0 :   for (symtab_node *node = symtab_node::get_for_asmname (asmname);
     666                 :           0 :        node;
     667                 :           0 :        node = node->next_sharing_asm_name)
     668                 :             :     {
     669                 :           0 :       cgraph_node *cn = dyn_cast <cgraph_node *> (node);
     670                 :           0 :       if (cn && !cn->inlined_to)
     671                 :             :         return cn;
     672                 :             :     }
     673                 :             :   return NULL;
     674                 :             : }
     675                 :             : 
     676                 :             : /* Returns a hash value for X (which really is a cgraph_edge).  */
     677                 :             : 
     678                 :             : hashval_t
     679                 :   206442971 : cgraph_edge_hasher::hash (cgraph_edge *e)
     680                 :             : {
     681                 :             :   /* This is a really poor hash function, but it is what htab_hash_pointer
     682                 :             :      uses.  */
     683                 :   206442971 :   return (hashval_t) ((intptr_t)e->call_stmt >> 3);
     684                 :             : }
     685                 :             : 
     686                 :             : /* Returns a hash value for X (which really is a cgraph_edge).  */
     687                 :             : 
     688                 :             : hashval_t
     689                 :    40806308 : cgraph_edge_hasher::hash (gimple *call_stmt)
     690                 :             : {
     691                 :             :   /* This is a really poor hash function, but it is what htab_hash_pointer
     692                 :             :      uses.  */
     693                 :    40806308 :   return (hashval_t) ((intptr_t)call_stmt >> 3);
     694                 :             : }
     695                 :             : 
     696                 :             : /* Return nonzero if the call_stmt of cgraph_edge X is stmt *Y.  */
     697                 :             : 
     698                 :             : inline bool
     699                 :   256090901 : cgraph_edge_hasher::equal (cgraph_edge *x, gimple *y)
     700                 :             : {
     701                 :   256090901 :   return x->call_stmt == y;
     702                 :             : }
     703                 :             : 
     704                 :             : /* Add call graph edge E to call site hash of its caller.  */
     705                 :             : 
     706                 :             : static inline void
     707                 :        2276 : cgraph_update_edge_in_call_site_hash (cgraph_edge *e)
     708                 :             : {
     709                 :        2276 :   gimple *call = e->call_stmt;
     710                 :        2276 :   *e->caller->call_site_hash->find_slot_with_hash
     711                 :        2276 :       (call, cgraph_edge_hasher::hash (call), INSERT) = e;
     712                 :        2276 : }
     713                 :             : 
     714                 :             : /* Add call graph edge E to call site hash of its caller.  */
     715                 :             : 
     716                 :             : static inline void
     717                 :     7736721 : cgraph_add_edge_to_call_site_hash (cgraph_edge *e)
     718                 :             : {
     719                 :             :   /* There are two speculative edges for every statement (one direct,
     720                 :             :      one indirect); always hash the direct one.  */
     721                 :     7736721 :   if (e->speculative && e->indirect_unknown_callee)
     722                 :             :     return;
     723                 :     7736716 :   cgraph_edge **slot = e->caller->call_site_hash->find_slot_with_hash
     724                 :     7736716 :       (e->call_stmt, cgraph_edge_hasher::hash (e->call_stmt), INSERT);
     725                 :     7736716 :   if (*slot)
     726                 :             :     {
     727                 :        2271 :       gcc_assert (((cgraph_edge *)*slot)->speculative);
     728                 :        2271 :       if (e->callee && (!e->prev_callee
     729                 :           0 :                         || !e->prev_callee->speculative
     730                 :           0 :                         || e->prev_callee->call_stmt != e->call_stmt))
     731                 :           0 :         *slot = e;
     732                 :        2271 :       return;
     733                 :             :     }
     734                 :     7734445 :   gcc_assert (!*slot || e->speculative);
     735                 :     7734445 :   *slot = e;
     736                 :             : }
     737                 :             : 
     738                 :             : /* Return the callgraph edge representing the GIMPLE_CALL statement
     739                 :             :    CALL_STMT.  */
     740                 :             : 
     741                 :             : cgraph_edge *
     742                 :   191968679 : cgraph_node::get_edge (gimple *call_stmt)
     743                 :             : {
     744                 :   191968679 :   cgraph_edge *e, *e2;
     745                 :   191968679 :   int n = 0;
     746                 :             : 
     747                 :   191968679 :   if (call_site_hash)
     748                 :    32125004 :     return call_site_hash->find_with_hash
     749                 :    32125004 :         (call_stmt, cgraph_edge_hasher::hash (call_stmt));
     750                 :             : 
     751                 :             :   /* This loop may turn out to be performance problem.  In such case adding
     752                 :             :      hashtables into call nodes with very many edges is probably best
     753                 :             :      solution.  It is not good idea to add pointer into CALL_EXPR itself
     754                 :             :      because we want to make possible having multiple cgraph nodes representing
     755                 :             :      different clones of the same body before the body is actually cloned.  */
     756                 :  1521073551 :   for (e = callees; e; e = e->next_callee)
     757                 :             :     {
     758                 :  1478391775 :       if (e->call_stmt == call_stmt)
     759                 :             :         break;
     760                 :  1361229876 :       n++;
     761                 :             :     }
     762                 :             : 
     763                 :   159843675 :   if (!e)
     764                 :    55568697 :     for (e = indirect_calls; e; e = e->next_callee)
     765                 :             :       {
     766                 :    15656553 :         if (e->call_stmt == call_stmt)
     767                 :             :           break;
     768                 :    12886921 :         n++;
     769                 :             :       }
     770                 :             : 
     771                 :   159843675 :   if (n > 100)
     772                 :             :     {
     773                 :       26767 :       call_site_hash = hash_table<cgraph_edge_hasher>::create_ggc (120);
     774                 :     2768257 :       for (e2 = callees; e2; e2 = e2->next_callee)
     775                 :     2741490 :         cgraph_add_edge_to_call_site_hash (e2);
     776                 :      108780 :       for (e2 = indirect_calls; e2; e2 = e2->next_callee)
     777                 :       82013 :         cgraph_add_edge_to_call_site_hash (e2);
     778                 :             :     }
     779                 :             : 
     780                 :             :   return e;
     781                 :             : }
     782                 :             : 
     783                 :             : 
     784                 :             : /* Change field call_stmt of edge E to NEW_STMT.  If UPDATE_SPECULATIVE and E
     785                 :             :    is any component of speculative edge, then update all components.
     786                 :             :    Speculations can be resolved in the process and EDGE can be removed and
     787                 :             :    deallocated.  Return the edge that now represents the call.  */
     788                 :             : 
     789                 :             : cgraph_edge *
     790                 :     2211030 : cgraph_edge::set_call_stmt (cgraph_edge *e, gcall *new_stmt,
     791                 :             :                             bool update_speculative)
     792                 :             : {
     793                 :     2211030 :   tree decl;
     794                 :             : 
     795                 :     2211030 :   cgraph_node *new_direct_callee = NULL;
     796                 :     2211030 :   if ((e->indirect_unknown_callee || e->speculative)
     797                 :     2242272 :       && (decl = gimple_call_fndecl (new_stmt)))
     798                 :             :     {
     799                 :             :       /* Constant propagation and especially inlining can turn an indirect call
     800                 :             :          into a direct one.  */
     801                 :           0 :       new_direct_callee = cgraph_node::get (decl);
     802                 :           0 :       gcc_checking_assert (new_direct_callee);
     803                 :             :     }
     804                 :             : 
     805                 :             :   /* Speculative edges has three component, update all of them
     806                 :             :      when asked to.  */
     807                 :     2211030 :   if (update_speculative && e->speculative
     808                 :             :       /* If we are about to resolve the speculation by calling make_direct
     809                 :             :          below, do not bother going over all the speculative edges now.  */
     810                 :        1896 :       && !new_direct_callee)
     811                 :             :     {
     812                 :        1896 :       cgraph_edge *direct, *indirect, *next;
     813                 :        1896 :       ipa_ref *ref;
     814                 :        1896 :       bool e_indirect = e->indirect_unknown_callee;
     815                 :        1896 :       int n = 0;
     816                 :             : 
     817                 :        1896 :       direct = e->first_speculative_call_target ();
     818                 :        1896 :       indirect = e->speculative_call_indirect_edge ();
     819                 :             : 
     820                 :        1896 :       gcall *old_stmt = direct->call_stmt;
     821                 :        3792 :       for (cgraph_edge *d = direct; d; d = next)
     822                 :             :         {
     823                 :        1896 :           next = d->next_speculative_call_target ();
     824                 :        1896 :           cgraph_edge *d2 = set_call_stmt (d, new_stmt, false);
     825                 :        1896 :           gcc_assert (d2 == d);
     826                 :        1896 :           n++;
     827                 :             :         }
     828                 :        1896 :       gcc_checking_assert (indirect->num_speculative_call_targets_p () == n);
     829                 :        4887 :       for (unsigned int i = 0; e->caller->iterate_reference (i, ref); i++)
     830                 :        2991 :         if (ref->speculative && ref->stmt == old_stmt)
     831                 :             :           {
     832                 :        1896 :             ref->stmt = new_stmt;
     833                 :        1896 :             n--;
     834                 :             :           }
     835                 :             : 
     836                 :        1896 :       indirect = set_call_stmt (indirect, new_stmt, false);
     837                 :        1896 :       return e_indirect ? indirect : direct;
     838                 :             :     }
     839                 :             : 
     840                 :     2209134 :   if (new_direct_callee)
     841                 :           0 :     e = make_direct (e, new_direct_callee);
     842                 :             : 
     843                 :             :   /* Only direct speculative edges go to call_site_hash.  */
     844                 :     2209134 :   if (e->caller->call_site_hash
     845                 :      444567 :       && (!e->speculative || !e->indirect_unknown_callee)
     846                 :             :       /* It is possible that edge was previously speculative.  In this case
     847                 :             :          we have different value in call stmt hash which needs preserving.  */
     848                 :     2653701 :       && e->caller->get_edge (e->call_stmt) == e)
     849                 :      442291 :     e->caller->call_site_hash->remove_elt_with_hash
     850                 :      442291 :       (e->call_stmt, cgraph_edge_hasher::hash (e->call_stmt));
     851                 :             : 
     852                 :     2209134 :   e->call_stmt = new_stmt;
     853                 :             : 
     854                 :     2209134 :   function *fun = DECL_STRUCT_FUNCTION (e->caller->decl);
     855                 :     2209134 :   e->can_throw_external = stmt_can_throw_external (fun, new_stmt);
     856                 :             :   /* Update call stite hash.  For speculative calls we only record the first
     857                 :             :      direct edge.  */
     858                 :     2209134 :   if (e->caller->call_site_hash
     859                 :      444567 :       && (!e->speculative
     860                 :           0 :           || (e->callee
     861                 :           0 :               && (!e->prev_callee || !e->prev_callee->speculative
     862                 :           0 :                   || e->prev_callee->call_stmt != e->call_stmt))
     863                 :           0 :           || (e->speculative && !e->callee)))
     864                 :      444567 :     cgraph_add_edge_to_call_site_hash (e);
     865                 :             :   return e;
     866                 :             : }
     867                 :             : 
     868                 :             : /* Allocate a cgraph_edge structure and fill it with data according to the
     869                 :             :    parameters of which only CALLEE can be NULL (when creating an indirect call
     870                 :             :    edge).  CLONING_P should be set if properties that are copied from an
     871                 :             :    original edge should not be calculated.  */
     872                 :             : 
     873                 :             : cgraph_edge *
     874                 :    41981173 : symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee,
     875                 :             :                            gcall *call_stmt, profile_count count,
     876                 :             :                            bool indir_unknown_callee, bool cloning_p)
     877                 :             : {
     878                 :    41981173 :   cgraph_edge *edge;
     879                 :             : 
     880                 :             :   /* LTO does not actually have access to the call_stmt since these
     881                 :             :      have not been loaded yet.  */
     882                 :    41981173 :   if (call_stmt)
     883                 :             :     {
     884                 :             :       /* This is a rather expensive check possibly triggering
     885                 :             :          construction of call stmt hashtable.  */
     886                 :    41022593 :       cgraph_edge *e;
     887                 :    41022593 :       gcc_checking_assert (!(e = caller->get_edge (call_stmt))
     888                 :             :                            || e->speculative);
     889                 :             : 
     890                 :    41022593 :       gcc_assert (is_gimple_call (call_stmt));
     891                 :             :     }
     892                 :             : 
     893                 :    41981173 :   edge = ggc_alloc<cgraph_edge> ();
     894                 :    41981173 :   edge->m_summary_id = -1;
     895                 :    41981173 :   edges_count++;
     896                 :             : 
     897                 :    41981173 :   ++edges_max_uid;
     898                 :    41981173 :   gcc_assert (edges_max_uid != 0);
     899                 :    41981173 :   edge->m_uid = edges_max_uid;
     900                 :    41981173 :   edge->aux = NULL;
     901                 :    41981173 :   edge->caller = caller;
     902                 :    41981173 :   edge->callee = callee;
     903                 :    41981173 :   edge->prev_caller = NULL;
     904                 :    41981173 :   edge->next_caller = NULL;
     905                 :    41981173 :   edge->prev_callee = NULL;
     906                 :    41981173 :   edge->next_callee = NULL;
     907                 :    41981173 :   edge->lto_stmt_uid = 0;
     908                 :    41981173 :   edge->speculative_id = 0;
     909                 :             : 
     910                 :    41981173 :   edge->count = count;
     911                 :    41981173 :   edge->call_stmt = call_stmt;
     912                 :    41981173 :   edge->indirect_info = NULL;
     913                 :    41981173 :   edge->indirect_inlining_edge = 0;
     914                 :    41981173 :   edge->speculative = false;
     915                 :    41981173 :   edge->indirect_unknown_callee = indir_unknown_callee;
     916                 :    41981173 :   if (call_stmt && caller->call_site_hash)
     917                 :     4468651 :     cgraph_add_edge_to_call_site_hash (edge);
     918                 :             : 
     919                 :    41981173 :   if (cloning_p)
     920                 :             :     return edge;
     921                 :             : 
     922                 :    36185308 :   edge->can_throw_external
     923                 :    36185308 :     = call_stmt ? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller->decl),
     924                 :             :                                            call_stmt) : false;
     925                 :    36185308 :   edge->inline_failed = CIF_FUNCTION_NOT_CONSIDERED;
     926                 :    36185308 :   edge->call_stmt_cannot_inline_p = false;
     927                 :             : 
     928                 :    36185308 :   if (opt_for_fn (edge->caller->decl, flag_devirtualize)
     929                 :    36185308 :       && call_stmt && DECL_STRUCT_FUNCTION (caller->decl))
     930                 :    27894086 :     edge->in_polymorphic_cdtor
     931                 :    27894086 :       = decl_maybe_in_construction_p (NULL, NULL, call_stmt,
     932                 :             :                                       caller->decl);
     933                 :             :   else
     934                 :     8291222 :     edge->in_polymorphic_cdtor = caller->thunk;
     935                 :    36185308 :   if (callee)
     936                 :    35530707 :     caller->calls_declare_variant_alt |= callee->declare_variant_alt;
     937                 :             : 
     938                 :    35530707 :   if (callee && symtab->state != LTO_STREAMING
     939                 :    34823279 :       && edge->callee->comdat_local_p ())
     940                 :        7265 :     edge->caller->calls_comdat_local = true;
     941                 :             : 
     942                 :             :   return edge;
     943                 :             : }
     944                 :             : 
     945                 :             : /* Create edge from a given function to CALLEE in the cgraph.  CLONING_P should
     946                 :             :    be set if properties that are copied from an original edge should not be
     947                 :             :    calculated.  */
     948                 :             : 
     949                 :             : cgraph_edge *
     950                 :    41170810 : cgraph_node::create_edge (cgraph_node *callee,
     951                 :             :                           gcall *call_stmt, profile_count count, bool cloning_p)
     952                 :             : {
     953                 :    41170810 :   cgraph_edge *edge = symtab->create_edge (this, callee, call_stmt, count,
     954                 :             :                                            false, cloning_p);
     955                 :             : 
     956                 :    41170810 :   if (!cloning_p)
     957                 :    35530707 :     initialize_inline_failed (edge);
     958                 :             : 
     959                 :    41170810 :   edge->next_caller = callee->callers;
     960                 :    41170810 :   if (callee->callers)
     961                 :    31928645 :     callee->callers->prev_caller = edge;
     962                 :    41170810 :   edge->next_callee = callees;
     963                 :    41170810 :   if (callees)
     964                 :    31954216 :     callees->prev_callee = edge;
     965                 :    41170810 :   callees = edge;
     966                 :    41170810 :   callee->callers = edge;
     967                 :             : 
     968                 :    41170810 :   return edge;
     969                 :             : }
     970                 :             : 
     971                 :             : /* Allocate cgraph_indirect_call_info and set its fields to default values. */
     972                 :             : 
     973                 :             : cgraph_indirect_call_info *
     974                 :      810363 : cgraph_allocate_init_indirect_info (void)
     975                 :             : {
     976                 :      810363 :   cgraph_indirect_call_info *ii;
     977                 :             : 
     978                 :      810363 :   ii = ggc_cleared_alloc<cgraph_indirect_call_info> ();
     979                 :      810363 :   ii->param_index = -1;
     980                 :      810363 :   return ii;
     981                 :             : }
     982                 :             : 
     983                 :             : /* Create an indirect edge with a yet-undetermined callee where the call
     984                 :             :    statement destination is a formal parameter of the caller with index
     985                 :             :    PARAM_INDEX. CLONING_P should be set if properties that are copied from an
     986                 :             :    original edge should not be calculated and indirect_info structure should
     987                 :             :    not be calculated.  */
     988                 :             : 
     989                 :             : cgraph_edge *
     990                 :      810363 : cgraph_node::create_indirect_edge (gcall *call_stmt, int ecf_flags,
     991                 :             :                                    profile_count count,
     992                 :             :                                    bool cloning_p)
     993                 :             : {
     994                 :      810363 :   cgraph_edge *edge = symtab->create_edge (this, NULL, call_stmt, count, true,
     995                 :             :                                            cloning_p);
     996                 :      810363 :   tree target;
     997                 :             : 
     998                 :      810363 :   if (!cloning_p)
     999                 :      654601 :     initialize_inline_failed (edge);
    1000                 :             : 
    1001                 :      810363 :   edge->indirect_info = cgraph_allocate_init_indirect_info ();
    1002                 :      810363 :   edge->indirect_info->ecf_flags = ecf_flags;
    1003                 :      810363 :   edge->indirect_info->vptr_changed = true;
    1004                 :             : 
    1005                 :             :   /* Record polymorphic call info.  */
    1006                 :      810363 :   if (!cloning_p
    1007                 :      810363 :       && call_stmt
    1008                 :      652538 :       && (target = gimple_call_fn (call_stmt))
    1009                 :     1462901 :       && virtual_method_call_p (target))
    1010                 :             :     {
    1011                 :       92035 :       ipa_polymorphic_call_context context (decl, target, call_stmt);
    1012                 :             : 
    1013                 :             :       /* Only record types can have virtual calls.  */
    1014                 :       92035 :       edge->indirect_info->polymorphic = true;
    1015                 :       92035 :       edge->indirect_info->param_index = -1;
    1016                 :       92035 :       edge->indirect_info->otr_token
    1017                 :       92035 :          = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target));
    1018                 :       92035 :       edge->indirect_info->otr_type = obj_type_ref_class (target);
    1019                 :       92035 :       gcc_assert (TREE_CODE (edge->indirect_info->otr_type) == RECORD_TYPE);
    1020                 :       92035 :       edge->indirect_info->context = context;
    1021                 :             :     }
    1022                 :             : 
    1023                 :      810363 :   edge->next_callee = indirect_calls;
    1024                 :      810363 :   if (indirect_calls)
    1025                 :      392323 :     indirect_calls->prev_callee = edge;
    1026                 :      810363 :   indirect_calls = edge;
    1027                 :             : 
    1028                 :      810363 :   return edge;
    1029                 :             : }
    1030                 :             : 
    1031                 :             : /* Remove the edge from the list of the callees of the caller.  */
    1032                 :             : 
    1033                 :             : void
    1034                 :     3790532 : cgraph_edge::remove_caller (void)
    1035                 :             : {
    1036                 :     3790532 :   if (prev_callee)
    1037                 :     3070934 :     prev_callee->next_callee = next_callee;
    1038                 :     3790532 :   if (next_callee)
    1039                 :     2581876 :     next_callee->prev_callee = prev_callee;
    1040                 :     3790532 :   if (!prev_callee)
    1041                 :             :     {
    1042                 :      719598 :       if (indirect_unknown_callee)
    1043                 :         682 :         caller->indirect_calls = next_callee;
    1044                 :             :       else
    1045                 :      718916 :         caller->callees = next_callee;
    1046                 :             :     }
    1047                 :     3790532 :   if (caller->call_site_hash
    1048                 :     3790532 :       && this == caller->get_edge (call_stmt))
    1049                 :      500021 :     caller->call_site_hash->remove_elt_with_hash
    1050                 :      500021 :         (call_stmt, cgraph_edge_hasher::hash (call_stmt));
    1051                 :     3790532 : }
    1052                 :             : 
    1053                 :             : /* Put the edge onto the free list.  */
    1054                 :             : 
    1055                 :             : void
    1056                 :    41480763 : symbol_table::free_edge (cgraph_edge *e)
    1057                 :             : {
    1058                 :    41480763 :   edges_count--;
    1059                 :    41480763 :   if (e->m_summary_id != -1)
    1060                 :    19483482 :     edge_released_summary_ids.safe_push (e->m_summary_id);
    1061                 :             : 
    1062                 :    41480763 :   if (e->indirect_info)
    1063                 :      805023 :     ggc_free (e->indirect_info);
    1064                 :    41480763 :   ggc_free (e);
    1065                 :    41480763 : }
    1066                 :             : 
    1067                 :             : /* Remove the edge in the cgraph.  */
    1068                 :             : 
    1069                 :             : void
    1070                 :       91896 : cgraph_edge::remove (cgraph_edge *edge)
    1071                 :             : {
    1072                 :             :   /* Call all edge removal hooks.  */
    1073                 :       91896 :   symtab->call_edge_removal_hooks (edge);
    1074                 :             : 
    1075                 :       91896 :   if (!edge->indirect_unknown_callee)
    1076                 :             :     /* Remove from callers list of the callee.  */
    1077                 :       89831 :     edge->remove_callee ();
    1078                 :             : 
    1079                 :             :   /* Remove from callees list of the callers.  */
    1080                 :       91896 :   edge->remove_caller ();
    1081                 :             : 
    1082                 :             :   /* Put the edge onto the free list.  */
    1083                 :       91896 :   symtab->free_edge (edge);
    1084                 :       91896 : }
    1085                 :             : 
    1086                 :             : /* Turn edge into speculative call calling N2. Update
    1087                 :             :    the profile so the direct call is taken COUNT times
    1088                 :             :    with FREQUENCY.
    1089                 :             : 
    1090                 :             :    At clone materialization time, the indirect call E will
    1091                 :             :    be expanded as:
    1092                 :             : 
    1093                 :             :    if (call_dest == N2)
    1094                 :             :      n2 ();
    1095                 :             :    else
    1096                 :             :      call call_dest
    1097                 :             : 
    1098                 :             :    At this time the function just creates the direct call,
    1099                 :             :    the reference representing the if conditional and attaches
    1100                 :             :    them all to the original indirect call statement.
    1101                 :             : 
    1102                 :             :    speculative_id is used to link direct calls with their corresponding
    1103                 :             :    IPA_REF_ADDR references when representing speculative calls.
    1104                 :             : 
    1105                 :             :    Return direct edge created.  */
    1106                 :             : 
    1107                 :             : cgraph_edge *
    1108                 :        4809 : cgraph_edge::make_speculative (cgraph_node *n2, profile_count direct_count,
    1109                 :             :                                unsigned int speculative_id)
    1110                 :             : {
    1111                 :        4809 :   cgraph_node *n = caller;
    1112                 :        4809 :   ipa_ref *ref = NULL;
    1113                 :        4809 :   cgraph_edge *e2;
    1114                 :             : 
    1115                 :        4809 :   if (dump_file)
    1116                 :          26 :     fprintf (dump_file, "Indirect call -> speculative call %s => %s\n",
    1117                 :             :              n->dump_name (), n2->dump_name ());
    1118                 :        4809 :   speculative = true;
    1119                 :        4809 :   e2 = n->create_edge (n2, call_stmt, direct_count);
    1120                 :        4809 :   initialize_inline_failed (e2);
    1121                 :        4809 :   e2->speculative = true;
    1122                 :        4809 :   if (TREE_NOTHROW (n2->decl))
    1123                 :        3348 :     e2->can_throw_external = false;
    1124                 :             :   else
    1125                 :        1461 :     e2->can_throw_external = can_throw_external;
    1126                 :        4809 :   e2->lto_stmt_uid = lto_stmt_uid;
    1127                 :        4809 :   e2->speculative_id = speculative_id;
    1128                 :        4809 :   e2->in_polymorphic_cdtor = in_polymorphic_cdtor;
    1129                 :        4809 :   indirect_info->num_speculative_call_targets++;
    1130                 :        4809 :   count -= e2->count;
    1131                 :        4809 :   symtab->call_edge_duplication_hooks (this, e2);
    1132                 :        4809 :   ref = n->create_reference (n2, IPA_REF_ADDR, call_stmt);
    1133                 :        4809 :   ref->lto_stmt_uid = lto_stmt_uid;
    1134                 :        4809 :   ref->speculative_id = speculative_id;
    1135                 :        4809 :   ref->speculative = speculative;
    1136                 :        4809 :   n2->mark_address_taken ();
    1137                 :        4809 :   return e2;
    1138                 :             : }
    1139                 :             : 
    1140                 :             : /* Speculative call consists of an indirect edge and one or more
    1141                 :             :    direct edge+ref pairs.
    1142                 :             : 
    1143                 :             :    Given an edge which is part of speculative call, return the first
    1144                 :             :    direct call edge in the speculative call sequence.  */
    1145                 :             : 
    1146                 :             : cgraph_edge *
    1147                 :       17858 : cgraph_edge::first_speculative_call_target ()
    1148                 :             : {
    1149                 :       17858 :   cgraph_edge *e = this;
    1150                 :             : 
    1151                 :       17858 :   gcc_checking_assert (e->speculative);
    1152                 :       17858 :   if (e->callee)
    1153                 :             :     {
    1154                 :        1927 :       while (e->prev_callee && e->prev_callee->speculative
    1155                 :         280 :              && e->prev_callee->call_stmt == e->call_stmt
    1156                 :       13464 :              && e->prev_callee->lto_stmt_uid == e->lto_stmt_uid)
    1157                 :             :         e = e->prev_callee;
    1158                 :             :       return e;
    1159                 :             :     }
    1160                 :             :   /* Call stmt site hash always points to the first target of the
    1161                 :             :      speculative call sequence.  */
    1162                 :        4394 :   if (e->call_stmt)
    1163                 :        4383 :     return e->caller->get_edge (e->call_stmt);
    1164                 :          22 :   for (cgraph_edge *e2 = e->caller->callees; true; e2 = e2->next_callee)
    1165                 :          22 :     if (e2->speculative
    1166                 :          17 :         && e->call_stmt == e2->call_stmt
    1167                 :          17 :         && e->lto_stmt_uid == e2->lto_stmt_uid)
    1168                 :             :       return e2;
    1169                 :             : }
    1170                 :             : 
    1171                 :             : /* We always maintain first direct edge in the call site hash, if one
    1172                 :             :    exists.  E is going to be removed.  See if it is first one and update
    1173                 :             :    hash accordingly.  INDIRECT is the indirect edge of speculative call.
    1174                 :             :    We assume that INDIRECT->num_speculative_call_targets_p () is already
    1175                 :             :    updated for removal of E.  */
    1176                 :             : static void
    1177                 :       12792 : update_call_stmt_hash_for_removing_direct_edge (cgraph_edge *e,
    1178                 :             :                                                 cgraph_edge *indirect)
    1179                 :             : {
    1180                 :       12792 :   if (e->caller->call_site_hash)
    1181                 :             :     {
    1182                 :        2276 :       if (e->caller->get_edge (e->call_stmt) != e)
    1183                 :             :         ;
    1184                 :        2276 :       else if (!indirect->num_speculative_call_targets_p ())
    1185                 :        2276 :         cgraph_update_edge_in_call_site_hash (indirect);
    1186                 :             :       else
    1187                 :             :         {
    1188                 :           0 :           gcc_checking_assert (e->next_callee && e->next_callee->speculative
    1189                 :             :                                && e->next_callee->call_stmt == e->call_stmt);
    1190                 :           0 :           cgraph_update_edge_in_call_site_hash (e->next_callee);
    1191                 :             :         }
    1192                 :             :     }
    1193                 :       12792 : }
    1194                 :             : 
    1195                 :             : /* Speculative call EDGE turned out to be direct call to CALLEE_DECL.  Remove
    1196                 :             :    the speculative call sequence and return edge representing the call, the
    1197                 :             :    original EDGE can be removed and deallocated.  Return the edge that now
    1198                 :             :    represents the call.
    1199                 :             : 
    1200                 :             :    For "speculative" indirect call that contains multiple "speculative"
    1201                 :             :    targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
    1202                 :             :    decrease the count and only remove current direct edge.
    1203                 :             : 
    1204                 :             :    If no speculative direct call left to the speculative indirect call, remove
    1205                 :             :    the speculative of both the indirect call and corresponding direct edge.
    1206                 :             : 
    1207                 :             :    It is up to caller to iteratively resolve each "speculative" direct call and
    1208                 :             :    redirect the call as appropriate.  */
    1209                 :             : 
    1210                 :             : cgraph_edge *
    1211                 :        1224 : cgraph_edge::resolve_speculation (cgraph_edge *edge, tree callee_decl)
    1212                 :             : {
    1213                 :        1224 :   cgraph_edge *e2;
    1214                 :        1224 :   ipa_ref *ref;
    1215                 :             : 
    1216                 :        1224 :   gcc_assert (edge->speculative && (!callee_decl || edge->callee));
    1217                 :        1224 :   if (!edge->callee)
    1218                 :           0 :     e2 = edge->first_speculative_call_target ();
    1219                 :             :   else
    1220                 :             :     e2 = edge;
    1221                 :        1224 :   ref = e2->speculative_call_target_ref ();
    1222                 :        1224 :   edge = edge->speculative_call_indirect_edge ();
    1223                 :        1224 :   if (!callee_decl
    1224                 :        1722 :       || !ref->referred->semantically_equivalent_p
    1225                 :         498 :            (symtab_node::get (callee_decl)))
    1226                 :             :     {
    1227                 :         935 :       if (dump_file)
    1228                 :             :         {
    1229                 :           0 :           if (callee_decl)
    1230                 :             :             {
    1231                 :           0 :               fprintf (dump_file, "Speculative indirect call %s => %s has "
    1232                 :             :                        "turned out to have contradicting known target ",
    1233                 :           0 :                        edge->caller->dump_name (),
    1234                 :           0 :                        e2->callee->dump_name ());
    1235                 :           0 :               print_generic_expr (dump_file, callee_decl);
    1236                 :           0 :               fprintf (dump_file, "\n");
    1237                 :             :             }
    1238                 :             :           else
    1239                 :             :             {
    1240                 :           0 :               fprintf (dump_file, "Removing speculative call %s => %s\n",
    1241                 :           0 :                        edge->caller->dump_name (),
    1242                 :           0 :                        e2->callee->dump_name ());
    1243                 :             :             }
    1244                 :             :         }
    1245                 :             :     }
    1246                 :             :   else
    1247                 :             :     {
    1248                 :         289 :       cgraph_edge *tmp = edge;
    1249                 :         289 :       if (dump_file)
    1250                 :          37 :         fprintf (dump_file, "Speculative call turned into direct call.\n");
    1251                 :             :       edge = e2;
    1252                 :             :       e2 = tmp;
    1253                 :             :       /* FIXME:  If EDGE is inlined, we should scale up the frequencies
    1254                 :             :          and counts in the functions inlined through it.  */
    1255                 :             :     }
    1256                 :        1224 :   edge->count += e2->count;
    1257                 :        1224 :   if (edge->num_speculative_call_targets_p ())
    1258                 :             :     {
    1259                 :             :       /* The indirect edge has multiple speculative targets, don't remove
    1260                 :             :          speculative until all related direct edges are resolved.  */
    1261                 :         935 :       edge->indirect_info->num_speculative_call_targets--;
    1262                 :         935 :       if (!edge->indirect_info->num_speculative_call_targets)
    1263                 :         931 :         edge->speculative = false;
    1264                 :             :     }
    1265                 :             :   else
    1266                 :         289 :     edge->speculative = false;
    1267                 :        1224 :   e2->speculative = false;
    1268                 :        1224 :   update_call_stmt_hash_for_removing_direct_edge (e2, edge);
    1269                 :        1224 :   ref->remove_reference ();
    1270                 :        1224 :   if (e2->indirect_unknown_callee || e2->inline_failed)
    1271                 :        1199 :     remove (e2);
    1272                 :             :   else
    1273                 :          25 :     e2->callee->remove_symbol_and_inline_clones ();
    1274                 :        1224 :   return edge;
    1275                 :             : }
    1276                 :             : 
    1277                 :             : /* Return edge corresponding to speculative call to a given target.
    1278                 :             :    NULL if speculative call does not have one.  */
    1279                 :             : 
    1280                 :             : cgraph_edge *
    1281                 :           0 : cgraph_edge::speculative_call_for_target (cgraph_node *target)
    1282                 :             : {
    1283                 :           0 :   for (cgraph_edge *direct = first_speculative_call_target ();
    1284                 :           0 :        direct;
    1285                 :           0 :        direct = direct->next_speculative_call_target ())
    1286                 :           0 :     if (direct->speculative_call_target_ref ()
    1287                 :           0 :         ->referred->semantically_equivalent_p (target))
    1288                 :             :       return direct;
    1289                 :             :   return NULL;
    1290                 :             : }
    1291                 :             : 
    1292                 :             : /* Make an indirect or speculative EDGE with an unknown callee an ordinary edge
    1293                 :             :    leading to CALLEE.  Speculations can be resolved in the process and EDGE can
    1294                 :             :    be removed and deallocated.  Return the edge that now represents the
    1295                 :             :    call.  */
    1296                 :             : 
    1297                 :             : cgraph_edge *
    1298                 :        3181 : cgraph_edge::make_direct (cgraph_edge *edge, cgraph_node *callee)
    1299                 :             : {
    1300                 :        3181 :   gcc_assert (edge->indirect_unknown_callee || edge->speculative);
    1301                 :             : 
    1302                 :             :   /* If we are redirecting speculative call, make it non-speculative.  */
    1303                 :        3181 :   if (edge->speculative)
    1304                 :             :     {
    1305                 :         313 :       cgraph_edge *found = NULL;
    1306                 :         313 :       cgraph_edge *direct, *next;
    1307                 :             : 
    1308                 :         313 :       edge = edge->speculative_call_indirect_edge ();
    1309                 :             : 
    1310                 :             :       /* Look all speculative targets and remove all but one corresponding
    1311                 :             :          to callee (if it exists).  */
    1312                 :         313 :       for (direct = edge->first_speculative_call_target ();
    1313                 :         630 :            direct;
    1314                 :             :            direct = next)
    1315                 :             :         {
    1316                 :         317 :           next = direct->next_speculative_call_target ();
    1317                 :             : 
    1318                 :             :           /* Compare ref not direct->callee.  Direct edge is possibly
    1319                 :             :              inlined or redirected.  */
    1320                 :         634 :           if (!direct->speculative_call_target_ref ()
    1321                 :         317 :                ->referred->semantically_equivalent_p (callee))
    1322                 :          28 :             edge = direct->resolve_speculation (direct, NULL);
    1323                 :             :           else
    1324                 :             :             {
    1325                 :         289 :               gcc_checking_assert (!found);
    1326                 :             :               found = direct;
    1327                 :             :             }
    1328                 :             :         }
    1329                 :             : 
    1330                 :             :       /* On successful speculation just remove the indirect edge and
    1331                 :             :          return the pre existing direct edge.
    1332                 :             :          It is important to not remove it and redirect because the direct
    1333                 :             :          edge may be inlined or redirected.  */
    1334                 :         313 :       if (found)
    1335                 :             :         {
    1336                 :         289 :           cgraph_edge *e2 = resolve_speculation (found, callee->decl);
    1337                 :         289 :           gcc_checking_assert (!found->speculative && e2 == found);
    1338                 :             :           return found;
    1339                 :             :         }
    1340                 :          24 :       gcc_checking_assert (!edge->speculative);
    1341                 :             :     }
    1342                 :             : 
    1343                 :        2892 :   edge->indirect_unknown_callee = 0;
    1344                 :        2892 :   ggc_free (edge->indirect_info);
    1345                 :        2892 :   edge->indirect_info = NULL;
    1346                 :             : 
    1347                 :             :   /* Get the edge out of the indirect edge list. */
    1348                 :        2892 :   if (edge->prev_callee)
    1349                 :          61 :     edge->prev_callee->next_callee = edge->next_callee;
    1350                 :        2892 :   if (edge->next_callee)
    1351                 :         378 :     edge->next_callee->prev_callee = edge->prev_callee;
    1352                 :        2892 :   if (!edge->prev_callee)
    1353                 :        2831 :     edge->caller->indirect_calls = edge->next_callee;
    1354                 :             : 
    1355                 :             :   /* Put it into the normal callee list */
    1356                 :        2892 :   edge->prev_callee = NULL;
    1357                 :        2892 :   edge->next_callee = edge->caller->callees;
    1358                 :        2892 :   if (edge->caller->callees)
    1359                 :        1584 :     edge->caller->callees->prev_callee = edge;
    1360                 :        2892 :   edge->caller->callees = edge;
    1361                 :             : 
    1362                 :             :   /* Insert to callers list of the new callee.  */
    1363                 :        2892 :   edge->set_callee (callee);
    1364                 :             : 
    1365                 :             :   /* We need to re-determine the inlining status of the edge.  */
    1366                 :        2892 :   initialize_inline_failed (edge);
    1367                 :        2892 :   return edge;
    1368                 :             : }
    1369                 :             : 
    1370                 :             : /* Redirect callee of the edge to N.  The function does not update underlying
    1371                 :             :    call expression.  */
    1372                 :             : 
    1373                 :             : void
    1374                 :     3508312 : cgraph_edge::redirect_callee (cgraph_node *n)
    1375                 :             : {
    1376                 :     3508312 :   bool loc = callee->comdat_local_p ();
    1377                 :             :   /* Remove from callers list of the current callee.  */
    1378                 :     3508312 :   remove_callee ();
    1379                 :             : 
    1380                 :             :   /* Insert to callers list of the new callee.  */
    1381                 :     3508312 :   set_callee (n);
    1382                 :             : 
    1383                 :     3508312 :   if (!inline_failed)
    1384                 :             :     return;
    1385                 :      460354 :   if (!loc && n->comdat_local_p ())
    1386                 :             :     {
    1387                 :          56 :       cgraph_node *to = caller->inlined_to ? caller->inlined_to : caller;
    1388                 :          56 :       to->calls_comdat_local = true;
    1389                 :             :     }
    1390                 :      460298 :   else if (loc && !n->comdat_local_p ())
    1391                 :             :     {
    1392                 :         134 :       cgraph_node *to = caller->inlined_to ? caller->inlined_to : caller;
    1393                 :         134 :       gcc_checking_assert (to->calls_comdat_local);
    1394                 :         134 :       to->calls_comdat_local = to->check_calls_comdat_local_p ();
    1395                 :             :     }
    1396                 :             : }
    1397                 :             : 
    1398                 :             : /* If necessary, change the function declaration in the call statement
    1399                 :             :    associated with E so that it corresponds to the edge callee.  Speculations
    1400                 :             :    can be resolved in the process and EDGE can be removed and deallocated.
    1401                 :             : 
    1402                 :             :    The edge could be one of speculative direct call generated from speculative
    1403                 :             :    indirect call.  In this circumstance, decrease the speculative targets
    1404                 :             :    count (i.e. num_speculative_call_targets) and redirect call stmt to the
    1405                 :             :    corresponding i-th target.  If no speculative direct call left to the
    1406                 :             :    speculative indirect call, remove "speculative" of the indirect call and
    1407                 :             :    also redirect stmt to it's final direct target.
    1408                 :             : 
    1409                 :             :    When called from within tree-inline, KILLED_SSAs has to contain the pointer
    1410                 :             :    to killed_new_ssa_names within the copy_body_data structure and SSAs
    1411                 :             :    discovered to be useless (if LHS is removed) will be added to it, otherwise
    1412                 :             :    it needs to be NULL.
    1413                 :             : 
    1414                 :             :    It is up to caller to iteratively transform each "speculative"
    1415                 :             :    direct call as appropriate.  */
    1416                 :             : 
    1417                 :             : gimple *
    1418                 :     9069399 : cgraph_edge::redirect_call_stmt_to_callee (cgraph_edge *e,
    1419                 :             :                                            hash_set <tree> *killed_ssas)
    1420                 :             : {
    1421                 :     9069399 :   tree decl = gimple_call_fndecl (e->call_stmt);
    1422                 :     9069399 :   gcall *new_stmt;
    1423                 :             : 
    1424                 :     9069399 :   if (e->speculative)
    1425                 :             :     {
    1426                 :             :       /* If there already is an direct call (i.e. as a result of inliner's
    1427                 :             :          substitution), forget about speculating.  */
    1428                 :       11568 :       if (decl)
    1429                 :           0 :         e = make_direct (e->speculative_call_indirect_edge (),
    1430                 :             :                          cgraph_node::get (decl));
    1431                 :             :       else
    1432                 :             :         {
    1433                 :             :           /* Be sure we redirect all speculative targets before poking
    1434                 :             :              about indirect edge.  */
    1435                 :       11568 :           gcc_checking_assert (e->callee);
    1436                 :       11568 :           cgraph_edge *indirect = e->speculative_call_indirect_edge ();
    1437                 :       11568 :           gcall *new_stmt;
    1438                 :       11568 :           ipa_ref *ref;
    1439                 :             : 
    1440                 :             :           /* Expand speculation into GIMPLE code.  */
    1441                 :       11568 :           if (dump_file)
    1442                 :             :             {
    1443                 :          42 :               fprintf (dump_file,
    1444                 :             :                        "Expanding speculative call of %s -> %s count: ",
    1445                 :          21 :                        e->caller->dump_name (),
    1446                 :             :                        e->callee->dump_name ());
    1447                 :          21 :               e->count.dump (dump_file);
    1448                 :          21 :               fprintf (dump_file, "\n");
    1449                 :             :             }
    1450                 :       11568 :           push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
    1451                 :             : 
    1452                 :       11568 :           profile_count all = indirect->count;
    1453                 :       11568 :           for (cgraph_edge *e2 = e->first_speculative_call_target ();
    1454                 :       23139 :                e2;
    1455                 :       11571 :                e2 = e2->next_speculative_call_target ())
    1456                 :       11571 :             all = all + e2->count;
    1457                 :       11568 :           profile_probability prob = e->count.probability_in (all);
    1458                 :       11568 :           if (!prob.initialized_p ())
    1459                 :         261 :             prob = profile_probability::even ();
    1460                 :       11568 :           ref = e->speculative_call_target_ref ();
    1461                 :       23136 :           new_stmt = gimple_ic (e->call_stmt,
    1462                 :             :                                 dyn_cast<cgraph_node *> (ref->referred),
    1463                 :             :                                 prob);
    1464                 :       11568 :           e->speculative = false;
    1465                 :       11568 :           if (indirect->num_speculative_call_targets_p ())
    1466                 :             :             {
    1467                 :             :               /* The indirect edge has multiple speculative targets, don't
    1468                 :             :                  remove speculative until all related direct edges are
    1469                 :             :                  redirected.  */
    1470                 :       11568 :               indirect->indirect_info->num_speculative_call_targets--;
    1471                 :       11568 :               if (!indirect->indirect_info->num_speculative_call_targets)
    1472                 :       11565 :                 indirect->speculative = false;
    1473                 :             :             }
    1474                 :             :           else
    1475                 :           0 :             indirect->speculative = false;
    1476                 :             :           /* Indirect edges are not both in the call site hash.
    1477                 :             :              get it updated.  */
    1478                 :       11568 :           update_call_stmt_hash_for_removing_direct_edge (e, indirect);
    1479                 :       11568 :           cgraph_edge::set_call_stmt (e, new_stmt, false);
    1480                 :       11568 :           e->count = gimple_bb (e->call_stmt)->count;
    1481                 :             : 
    1482                 :             :           /* Once we are done with expanding the sequence, update also indirect
    1483                 :             :              call probability.  Until then the basic block accounts for the
    1484                 :             :              sum of indirect edge and all non-expanded speculations.  */
    1485                 :       11568 :           if (!indirect->speculative)
    1486                 :       11565 :             indirect->count = gimple_bb (indirect->call_stmt)->count;
    1487                 :       11568 :           ref->speculative = false;
    1488                 :       11568 :           ref->stmt = NULL;
    1489                 :       11568 :           pop_cfun ();
    1490                 :             :           /* Continue redirecting E to proper target.  */
    1491                 :             :         }
    1492                 :             :     }
    1493                 :             : 
    1494                 :             : 
    1495                 :     9069399 :   if (e->indirect_unknown_callee
    1496                 :     8989807 :       || decl == e->callee->decl)
    1497                 :     8279402 :     return e->call_stmt;
    1498                 :             : 
    1499                 :      789997 :   if (decl && ipa_saved_clone_sources)
    1500                 :             :     {
    1501                 :      654771 :       tree *p = ipa_saved_clone_sources->get (e->callee);
    1502                 :      654771 :       if (p && decl == *p)
    1503                 :             :         {
    1504                 :       28523 :           gimple_call_set_fndecl (e->call_stmt, e->callee->decl);
    1505                 :       28523 :           return e->call_stmt;
    1506                 :             :         }
    1507                 :             :     }
    1508                 :      761474 :   if (flag_checking && decl)
    1509                 :             :     {
    1510                 :      747179 :       if (cgraph_node *node = cgraph_node::get (decl))
    1511                 :             :         {
    1512                 :      628970 :           clone_info *info = clone_info::get (node);
    1513                 :      628970 :           gcc_assert (!info || !info->param_adjustments);
    1514                 :             :         }
    1515                 :             :     }
    1516                 :             : 
    1517                 :      761474 :   clone_info *callee_info = clone_info::get (e->callee);
    1518                 :      761474 :   if (symtab->dump_file)
    1519                 :             :     {
    1520                 :           0 :       fprintf (symtab->dump_file, "updating call of %s -> %s: ",
    1521                 :           0 :                e->caller->dump_name (), e->callee->dump_name ());
    1522                 :           0 :       print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
    1523                 :           0 :       if (callee_info && callee_info->param_adjustments)
    1524                 :           0 :         callee_info->param_adjustments->dump (symtab->dump_file);
    1525                 :             :     }
    1526                 :             : 
    1527                 :           0 :   if (ipa_param_adjustments *padjs
    1528                 :      761474 :          = callee_info ? callee_info->param_adjustments : NULL)
    1529                 :             :     {
    1530                 :             :       /* We need to defer cleaning EH info on the new statement to
    1531                 :             :          fixup-cfg.  We may not have dominator information at this point
    1532                 :             :          and thus would end up with unreachable blocks and have no way
    1533                 :             :          to communicate that we need to run CFG cleanup then.  */
    1534                 :      371401 :       int lp_nr = lookup_stmt_eh_lp (e->call_stmt);
    1535                 :      371401 :       if (lp_nr != 0)
    1536                 :      126304 :         remove_stmt_from_eh_lp (e->call_stmt);
    1537                 :             : 
    1538                 :      371401 :       tree old_fntype = gimple_call_fntype (e->call_stmt);
    1539                 :      371401 :       new_stmt = padjs->modify_call (e, false, killed_ssas);
    1540                 :      371401 :       cgraph_node *origin = e->callee;
    1541                 :      535746 :       while (origin->clone_of)
    1542                 :             :         origin = origin->clone_of;
    1543                 :             : 
    1544                 :      371401 :       if ((origin->former_clone_of
    1545                 :      295617 :            && old_fntype == TREE_TYPE (origin->former_clone_of))
    1546                 :      373387 :           || old_fntype == TREE_TYPE (origin->decl))
    1547                 :      293633 :         gimple_call_set_fntype (new_stmt, TREE_TYPE (e->callee->decl));
    1548                 :             :       else
    1549                 :             :         {
    1550                 :       77768 :           tree new_fntype = padjs->build_new_function_type (old_fntype, true);
    1551                 :       77768 :           gimple_call_set_fntype (new_stmt, new_fntype);
    1552                 :             :         }
    1553                 :             : 
    1554                 :      371401 :       if (lp_nr != 0)
    1555                 :      126304 :         add_stmt_to_eh_lp (new_stmt, lp_nr);
    1556                 :             :     }
    1557                 :             :   else
    1558                 :             :     {
    1559                 :      390073 :       if (flag_checking
    1560                 :      390073 :           && !fndecl_built_in_p (e->callee->decl, BUILT_IN_UNREACHABLE,
    1561                 :             :                                                   BUILT_IN_UNREACHABLE_TRAP))
    1562                 :      271064 :         ipa_verify_edge_has_no_modifications (e);
    1563                 :      390073 :       new_stmt = e->call_stmt;
    1564                 :      390073 :       gimple_call_set_fndecl (new_stmt, e->callee->decl);
    1565                 :      390073 :       update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
    1566                 :             :     }
    1567                 :             : 
    1568                 :             :   /* If changing the call to __cxa_pure_virtual or similar noreturn function,
    1569                 :             :      adjust gimple_call_fntype too.  */
    1570                 :      761474 :   if (gimple_call_noreturn_p (new_stmt)
    1571                 :      126120 :       && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e->callee->decl)))
    1572                 :      126018 :       && TYPE_ARG_TYPES (TREE_TYPE (e->callee->decl))
    1573                 :      887486 :       && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e->callee->decl)))
    1574                 :      126012 :           == void_type_node))
    1575                 :      125296 :     gimple_call_set_fntype (new_stmt, TREE_TYPE (e->callee->decl));
    1576                 :             : 
    1577                 :             :   /* If the call becomes noreturn, remove the LHS if possible.  */
    1578                 :      761474 :   tree lhs = gimple_call_lhs (new_stmt);
    1579                 :      761474 :   if (lhs
    1580                 :      204475 :       && gimple_call_noreturn_p (new_stmt)
    1581                 :      791302 :       && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt)))
    1582                 :          93 :           || should_remove_lhs_p (lhs)))
    1583                 :             :     {
    1584                 :       29802 :       gimple_call_set_lhs (new_stmt, NULL_TREE);
    1585                 :             :       /* We need to fix up the SSA name to avoid checking errors.  */
    1586                 :       29802 :       if (TREE_CODE (lhs) == SSA_NAME)
    1587                 :             :         {
    1588                 :       21754 :           tree var = create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e->caller->decl),
    1589                 :       21754 :                                         TREE_TYPE (lhs), NULL);
    1590                 :       21754 :           SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs, var);
    1591                 :       21754 :           SSA_NAME_DEF_STMT (lhs) = gimple_build_nop ();
    1592                 :       21754 :           set_ssa_default_def (DECL_STRUCT_FUNCTION (e->caller->decl),
    1593                 :             :                                var, lhs);
    1594                 :             :         }
    1595                 :       29802 :       update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
    1596                 :             :     }
    1597                 :             : 
    1598                 :             :   /* If new callee has no static chain, remove it.  */
    1599                 :      761474 :   if (gimple_call_chain (new_stmt) && !DECL_STATIC_CHAIN (e->callee->decl))
    1600                 :             :     {
    1601                 :          53 :       gimple_call_set_chain (new_stmt, NULL);
    1602                 :          53 :       update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
    1603                 :             :     }
    1604                 :             : 
    1605                 :      761474 :   maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e->caller->decl),
    1606                 :             :                                  new_stmt);
    1607                 :             : 
    1608                 :      761474 :   e->caller->set_call_stmt_including_clones (e->call_stmt, new_stmt, false);
    1609                 :             : 
    1610                 :      761474 :   if (symtab->dump_file)
    1611                 :             :     {
    1612                 :           0 :       fprintf (symtab->dump_file, "  updated to:");
    1613                 :           0 :       print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
    1614                 :             :     }
    1615                 :             :   return new_stmt;
    1616                 :             : }
    1617                 :             : 
    1618                 :             : /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
    1619                 :             :    OLD_STMT changed into NEW_STMT.  OLD_CALL is gimple_call_fndecl
    1620                 :             :    of OLD_STMT if it was previously call statement.
    1621                 :             :    If NEW_STMT is NULL, the call has been dropped without any
    1622                 :             :    replacement.  */
    1623                 :             : 
    1624                 :             : static void
    1625                 :      113008 : cgraph_update_edges_for_call_stmt_node (cgraph_node *node,
    1626                 :             :                                         gimple *old_stmt, tree old_call,
    1627                 :             :                                         gimple *new_stmt)
    1628                 :             : {
    1629                 :      113008 :   tree new_call = (new_stmt && is_gimple_call (new_stmt))
    1630                 :      117182 :                   ? gimple_call_fndecl (new_stmt) : 0;
    1631                 :             : 
    1632                 :             :   /* We are seeing indirect calls, then there is nothing to update.  */
    1633                 :      113008 :   if (!new_call && !old_call)
    1634                 :             :     return;
    1635                 :             :   /* See if we turned indirect call into direct call or folded call to one builtin
    1636                 :             :      into different builtin.  */
    1637                 :      111652 :   if (old_call != new_call)
    1638                 :             :     {
    1639                 :      110872 :       cgraph_edge *e = node->get_edge (old_stmt);
    1640                 :      110872 :       cgraph_edge *ne = NULL;
    1641                 :      110872 :       profile_count count;
    1642                 :             : 
    1643                 :      110872 :       if (e)
    1644                 :             :         {
    1645                 :             :           /* Keep calls marked as dead dead.  */
    1646                 :       89597 :           if (new_stmt && is_gimple_call (new_stmt) && e->callee
    1647                 :       90045 :               && fndecl_built_in_p (e->callee->decl, BUILT_IN_UNREACHABLE,
    1648                 :             :                                     BUILT_IN_UNREACHABLE_TRAP))
    1649                 :             :             {
    1650                 :           2 :               cgraph_edge::set_call_stmt (node->get_edge (old_stmt),
    1651                 :             :                                           as_a <gcall *> (new_stmt));
    1652                 :          26 :               return;
    1653                 :             :             }
    1654                 :             :           /* See if the edge is already there and has the correct callee.  It
    1655                 :             :              might be so because of indirect inlining has already updated
    1656                 :             :              it.  We also might've cloned and redirected the edge.  */
    1657                 :       89595 :           if (new_call && e->callee)
    1658                 :             :             {
    1659                 :             :               cgraph_node *callee = e->callee;
    1660                 :         893 :               while (callee)
    1661                 :             :                 {
    1662                 :         469 :                   if (callee->decl == new_call
    1663                 :         469 :                       || callee->former_clone_of == new_call)
    1664                 :             :                     {
    1665                 :          22 :                       cgraph_edge::set_call_stmt (e, as_a <gcall *> (new_stmt));
    1666                 :          22 :                       return;
    1667                 :             :                     }
    1668                 :         447 :                   callee = callee->clone_of;
    1669                 :             :                 }
    1670                 :             :             }
    1671                 :             : 
    1672                 :             :           /* Otherwise remove edge and create new one; we can't simply redirect
    1673                 :             :              since function has changed, so inline plan and other information
    1674                 :             :              attached to edge is invalid.  */
    1675                 :       89573 :           count = e->count;
    1676                 :       89573 :           if (e->indirect_unknown_callee || e->inline_failed)
    1677                 :       89573 :             cgraph_edge::remove (e);
    1678                 :             :           else
    1679                 :           0 :             e->callee->remove_symbol_and_inline_clones ();
    1680                 :             :         }
    1681                 :       21275 :       else if (new_call)
    1682                 :             :         {
    1683                 :             :           /* We are seeing new direct call; compute profile info based on BB.  */
    1684                 :           4 :           basic_block bb = gimple_bb (new_stmt);
    1685                 :           4 :           count = bb->count;
    1686                 :             :         }
    1687                 :             : 
    1688                 :       89577 :       if (new_call)
    1689                 :             :         {
    1690                 :        2191 :           ne = node->create_edge (cgraph_node::get_create (new_call),
    1691                 :             :                                   as_a <gcall *> (new_stmt), count);
    1692                 :        2191 :           gcc_assert (ne->inline_failed);
    1693                 :             :         }
    1694                 :             :     }
    1695                 :             :   /* We only updated the call stmt; update pointer in cgraph edge..  */
    1696                 :         780 :   else if (old_stmt != new_stmt)
    1697                 :           0 :     cgraph_edge::set_call_stmt (node->get_edge (old_stmt),
    1698                 :             :                                 as_a <gcall *> (new_stmt));
    1699                 :             : }
    1700                 :             : 
    1701                 :             : /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
    1702                 :             :    OLD_STMT changed into NEW_STMT.  OLD_DECL is gimple_call_fndecl
    1703                 :             :    of OLD_STMT before it was updated (updating can happen inplace).  */
    1704                 :             : 
    1705                 :             : void
    1706                 :       91411 : cgraph_update_edges_for_call_stmt (gimple *old_stmt, tree old_decl,
    1707                 :             :                                    gimple *new_stmt)
    1708                 :             : {
    1709                 :       91411 :   cgraph_node *orig = cgraph_node::get (cfun->decl);
    1710                 :       91411 :   cgraph_node *node;
    1711                 :             : 
    1712                 :       91411 :   gcc_checking_assert (orig);
    1713                 :       91411 :   cgraph_update_edges_for_call_stmt_node (orig, old_stmt, old_decl, new_stmt);
    1714                 :       91411 :   if (orig->clones)
    1715                 :       42554 :     for (node = orig->clones; node != orig;)
    1716                 :             :       {
    1717                 :       21597 :         cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_decl,
    1718                 :             :                                                 new_stmt);
    1719                 :       21597 :         if (node->clones)
    1720                 :             :           node = node->clones;
    1721                 :       21585 :         else if (node->next_sibling_clone)
    1722                 :             :           node = node->next_sibling_clone;
    1723                 :             :         else
    1724                 :             :           {
    1725                 :       41926 :             while (node != orig && !node->next_sibling_clone)
    1726                 :       20969 :               node = node->clone_of;
    1727                 :       20957 :             if (node != orig)
    1728                 :           0 :               node = node->next_sibling_clone;
    1729                 :             :           }
    1730                 :             :       }
    1731                 :       91411 : }
    1732                 :             : 
    1733                 :             : 
    1734                 :             : /* Remove all callees from the node.  */
    1735                 :             : 
    1736                 :             : void
    1737                 :   203533895 : cgraph_node::remove_callees (void)
    1738                 :             : {
    1739                 :   203533895 :   cgraph_edge *e, *f;
    1740                 :             : 
    1741                 :   203533895 :   calls_comdat_local = false;
    1742                 :             : 
    1743                 :             :   /* It is sufficient to remove the edges from the lists of callers of
    1744                 :             :      the callees.  The callee list of the node can be zapped with one
    1745                 :             :      assignment.  */
    1746                 :   240421168 :   for (e = callees; e; e = f)
    1747                 :             :     {
    1748                 :    36887273 :       f = e->next_callee;
    1749                 :    36887273 :       symtab->call_edge_removal_hooks (e);
    1750                 :    36887273 :       if (!e->indirect_unknown_callee)
    1751                 :    36887273 :         e->remove_callee ();
    1752                 :    36887273 :       symtab->free_edge (e);
    1753                 :             :     }
    1754                 :   204336853 :   for (e = indirect_calls; e; e = f)
    1755                 :             :     {
    1756                 :      802958 :       f = e->next_callee;
    1757                 :      802958 :       symtab->call_edge_removal_hooks (e);
    1758                 :      802958 :       if (!e->indirect_unknown_callee)
    1759                 :           0 :         e->remove_callee ();
    1760                 :      802958 :       symtab->free_edge (e);
    1761                 :             :     }
    1762                 :   203533895 :   indirect_calls = NULL;
    1763                 :   203533895 :   callees = NULL;
    1764                 :   203533895 :   if (call_site_hash)
    1765                 :             :     {
    1766                 :       26690 :       call_site_hash->empty ();
    1767                 :       26690 :       call_site_hash = NULL;
    1768                 :             :     }
    1769                 :   203533895 : }
    1770                 :             : 
    1771                 :             : /* Remove all callers from the node.  */
    1772                 :             : 
    1773                 :             : void
    1774                 :    90653089 : cgraph_node::remove_callers (void)
    1775                 :             : {
    1776                 :    90653089 :   cgraph_edge *e, *f;
    1777                 :             : 
    1778                 :             :   /* It is sufficient to remove the edges from the lists of callees of
    1779                 :             :      the callers.  The caller list of the node can be zapped with one
    1780                 :             :      assignment.  */
    1781                 :    94351725 :   for (e = callers; e; e = f)
    1782                 :             :     {
    1783                 :     3698636 :       f = e->next_caller;
    1784                 :     3698636 :       symtab->call_edge_removal_hooks (e);
    1785                 :     3698636 :       e->remove_caller ();
    1786                 :     3698636 :       symtab->free_edge (e);
    1787                 :             :     }
    1788                 :    90653089 :   callers = NULL;
    1789                 :    90653089 : }
    1790                 :             : 
    1791                 :             : /* Helper function for cgraph_release_function_body and free_lang_data.
    1792                 :             :    It releases body from function DECL without having to inspect its
    1793                 :             :    possibly non-existent symtab node.  */
    1794                 :             : 
    1795                 :             : void
    1796                 :   107991326 : release_function_body (tree decl)
    1797                 :             : {
    1798                 :   107991326 :   function *fn = DECL_STRUCT_FUNCTION (decl);
    1799                 :   107991326 :   if (fn)
    1800                 :             :     {
    1801                 :    89518576 :       if (fn->cfg
    1802                 :    89518576 :           && loops_for_fn (fn))
    1803                 :             :         {
    1804                 :     1485976 :           fn->curr_properties &= ~PROP_loops;
    1805                 :     1485976 :           loop_optimizer_finalize (fn);
    1806                 :             :         }
    1807                 :    89518576 :       if (fn->gimple_df)
    1808                 :             :         {
    1809                 :     1494270 :           delete_tree_ssa (fn);
    1810                 :     1494270 :           fn->eh = NULL;
    1811                 :             :         }
    1812                 :    89518576 :       if (fn->cfg)
    1813                 :             :         {
    1814                 :     1485977 :           gcc_assert (!dom_info_available_p (fn, CDI_DOMINATORS));
    1815                 :     1485977 :           gcc_assert (!dom_info_available_p (fn, CDI_POST_DOMINATORS));
    1816                 :     1485977 :           delete_tree_cfg_annotations (fn);
    1817                 :     1485977 :           free_cfg (fn);
    1818                 :     1485977 :           fn->cfg = NULL;
    1819                 :             :         }
    1820                 :    89518576 :       if (fn->value_histograms)
    1821                 :          12 :         free_histograms (fn);
    1822                 :    89518576 :       gimple_set_body (decl, NULL);
    1823                 :             :       /* Struct function hangs a lot of data that would leak if we didn't
    1824                 :             :          removed all pointers to it.   */
    1825                 :    89518576 :       ggc_free (fn);
    1826                 :    89518576 :       DECL_STRUCT_FUNCTION (decl) = NULL;
    1827                 :             :     }
    1828                 :   107991326 :   DECL_SAVED_TREE (decl) = NULL;
    1829                 :   107991326 : }
    1830                 :             : 
    1831                 :             : /* Release memory used to represent body of function.
    1832                 :             :    Use this only for functions that are released before being translated to
    1833                 :             :    target code (i.e. RTL).  Functions that are compiled to RTL and beyond
    1834                 :             :    are free'd in final.cc via free_after_compilation().
    1835                 :             :    KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk.  */
    1836                 :             : 
    1837                 :             : void
    1838                 :   101115854 : cgraph_node::release_body (bool keep_arguments)
    1839                 :             : {
    1840                 :   101115854 :   ipa_transforms_to_apply.release ();
    1841                 :   101115854 :   if (!used_as_abstract_origin && symtab->state != PARSING)
    1842                 :             :     {
    1843                 :   100593443 :       DECL_RESULT (decl) = NULL;
    1844                 :             : 
    1845                 :   100593443 :       if (!keep_arguments)
    1846                 :   100564248 :         DECL_ARGUMENTS (decl) = NULL;
    1847                 :             :     }
    1848                 :             :   /* If the node is abstract and needed, then do not clear
    1849                 :             :      DECL_INITIAL of its associated function declaration because it's
    1850                 :             :      needed to emit debug info later.  */
    1851                 :   101115854 :   if (!used_as_abstract_origin && DECL_INITIAL (decl))
    1852                 :    89269130 :     DECL_INITIAL (decl) = error_mark_node;
    1853                 :   101115854 :   release_function_body (decl);
    1854                 :   101115854 :   if (lto_file_data)
    1855                 :             :     {
    1856                 :       55083 :       lto_free_function_in_decl_state_for_node (this);
    1857                 :       55083 :       lto_file_data = NULL;
    1858                 :             :     }
    1859                 :   101115854 :   if (flag_checking && clones)
    1860                 :             :     {
    1861                 :             :       /* It is invalid to release body before materializing clones except
    1862                 :             :          for thunks that don't really need a body.  Verify also that we do
    1863                 :             :          not leak pointers to the call statements.  */
    1864                 :          40 :       for (cgraph_node *node = clones; node;
    1865                 :          23 :            node = node->next_sibling_clone)
    1866                 :          23 :         gcc_assert (node->thunk && !node->callees->call_stmt);
    1867                 :             :     }
    1868                 :   101115854 :   remove_callees ();
    1869                 :   101115854 :   remove_all_references ();
    1870                 :   101115854 : }
    1871                 :             : 
    1872                 :             : /* Remove function from symbol table.  */
    1873                 :             : 
    1874                 :             : void
    1875                 :    90653089 : cgraph_node::remove (void)
    1876                 :             : {
    1877                 :    90653089 :   bool clone_info_set = false;
    1878                 :    90653089 :   clone_info *info, saved_info;
    1879                 :    90653089 :   if (symtab->ipa_clones_dump_file && symtab->cloned_nodes.contains (this))
    1880                 :           0 :     fprintf (symtab->ipa_clones_dump_file,
    1881                 :             :              "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order,
    1882                 :           0 :              DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
    1883                 :           0 :              DECL_SOURCE_COLUMN (decl));
    1884                 :             : 
    1885                 :    90653089 :   if ((info = clone_info::get (this)) != NULL)
    1886                 :             :     {
    1887                 :      298423 :       saved_info = *info;
    1888                 :      298423 :       clone_info_set = true;
    1889                 :             :     }
    1890                 :    90653089 :   symtab->call_cgraph_removal_hooks (this);
    1891                 :    90653089 :   remove_callers ();
    1892                 :    90653089 :   remove_callees ();
    1893                 :    90653089 :   ipa_transforms_to_apply.release ();
    1894                 :    90653089 :   delete_function_version (function_version ());
    1895                 :             : 
    1896                 :             :   /* Incremental inlining access removed nodes stored in the postorder list.
    1897                 :             :      */
    1898                 :    90653089 :   force_output = false;
    1899                 :    90653089 :   forced_by_abi = false;
    1900                 :             : 
    1901                 :   181007755 :   unregister (clone_info_set ? &saved_info : NULL);
    1902                 :    90653089 :   if (prev_sibling_clone)
    1903                 :      607082 :     prev_sibling_clone->next_sibling_clone = next_sibling_clone;
    1904                 :    90046007 :   else if (clone_of)
    1905                 :             :     {
    1906                 :     1443388 :       clone_of->clones = next_sibling_clone;
    1907                 :     1443388 :       if (!clones)
    1908                 :             :         {
    1909                 :     1442688 :           bool need_body = false;
    1910                 :     1442688 :           for (cgraph_node *n = clone_of; n; n = n->clone_of)
    1911                 :     1437233 :             if (n->analyzed || n->clones)
    1912                 :             :               {
    1913                 :             :                 need_body = true;
    1914                 :             :                 break;
    1915                 :             :               }
    1916                 :     1437229 :           if (!need_body)
    1917                 :        5455 :             clone_of->release_body ();
    1918                 :             :         }
    1919                 :             :     }
    1920                 :    90653089 :   if (next_sibling_clone)
    1921                 :      742757 :     next_sibling_clone->prev_sibling_clone = prev_sibling_clone;
    1922                 :    90653089 :   if (clones)
    1923                 :             :     {
    1924                 :       30983 :       cgraph_node *n, *next;
    1925                 :             : 
    1926                 :       30983 :       if (clone_of)
    1927                 :             :         {
    1928                 :      144580 :           for (n = clones; n->next_sibling_clone; n = n->next_sibling_clone)
    1929                 :      113597 :             n->clone_of = clone_of;
    1930                 :       30983 :           n->clone_of = clone_of;
    1931                 :       30983 :           n->next_sibling_clone = clone_of->clones;
    1932                 :       30983 :           if (clone_of->clones)
    1933                 :       27303 :             clone_of->clones->prev_sibling_clone = n;
    1934                 :       30983 :           clone_of->clones = clones;
    1935                 :             :         }
    1936                 :             :       else
    1937                 :             :         {
    1938                 :             :           /* We are removing node with clones.  This makes clones inconsistent,
    1939                 :             :              but assume they will be removed subsequently and just keep clone
    1940                 :             :              tree intact.  This can happen in unreachable function removal since
    1941                 :             :              we remove unreachable functions in random order, not by bottom-up
    1942                 :             :              walk of clone trees.  */
    1943                 :           0 :           for (n = clones; n; n = next)
    1944                 :             :             {
    1945                 :           0 :                next = n->next_sibling_clone;
    1946                 :           0 :                n->next_sibling_clone = NULL;
    1947                 :           0 :                n->prev_sibling_clone = NULL;
    1948                 :           0 :                n->clone_of = NULL;
    1949                 :             :             }
    1950                 :             :         }
    1951                 :             :     }
    1952                 :             : 
    1953                 :             :   /* While all the clones are removed after being proceeded, the function
    1954                 :             :      itself is kept in the cgraph even after it is compiled.  Check whether
    1955                 :             :      we are done with this body and reclaim it proactively if this is the case.
    1956                 :             :      */
    1957                 :    90653089 :   if (symtab->state != LTO_STREAMING)
    1958                 :             :     {
    1959                 :    90651066 :       cgraph_node *n = cgraph_node::get (decl);
    1960                 :    90651066 :       if (!n
    1961                 :    90651066 :           || (!n->clones && !n->clone_of && !n->inlined_to
    1962                 :      927205 :               && ((symtab->global_info_ready || in_lto_p)
    1963                 :        8961 :                   && (TREE_ASM_WRITTEN (n->decl)
    1964                 :        8934 :                       || DECL_EXTERNAL (n->decl)
    1965                 :        4455 :                       || !n->analyzed
    1966                 :        4415 :                       || (!flag_wpa && n->in_other_partition)))))
    1967                 :    88265286 :         release_body ();
    1968                 :             :     }
    1969                 :             :   else
    1970                 :             :     {
    1971                 :        2023 :       lto_free_function_in_decl_state_for_node (this);
    1972                 :        2023 :       lto_file_data = NULL;
    1973                 :             :     }
    1974                 :             : 
    1975                 :    90653089 :   decl = NULL;
    1976                 :    90653089 :   if (call_site_hash)
    1977                 :             :     {
    1978                 :           0 :       call_site_hash->empty ();
    1979                 :           0 :       call_site_hash = NULL;
    1980                 :             :     }
    1981                 :             : 
    1982                 :    90653089 :   symtab->release_symbol (this);
    1983                 :    90653089 : }
    1984                 :             : 
    1985                 :             : /* Likewise indicate that a node is having address taken.  */
    1986                 :             : 
    1987                 :             : void
    1988                 :     4328368 : cgraph_node::mark_address_taken (void)
    1989                 :             : {
    1990                 :             :   /* Indirect inlining can figure out that all uses of the address are
    1991                 :             :      inlined.  */
    1992                 :     4328368 :   if (inlined_to)
    1993                 :             :     {
    1994                 :           0 :       gcc_assert (cfun->after_inlining);
    1995                 :           0 :       gcc_assert (callers->indirect_inlining_edge);
    1996                 :             :       return;
    1997                 :             :     }
    1998                 :             :   /* FIXME: address_taken flag is used both as a shortcut for testing whether
    1999                 :             :      IPA_REF_ADDR reference exists (and thus it should be set on node
    2000                 :             :      representing alias we take address of) and as a test whether address
    2001                 :             :      of the object was taken (and thus it should be set on node alias is
    2002                 :             :      referring to).  We should remove the first use and the remove the
    2003                 :             :      following set.  */
    2004                 :     4328368 :   address_taken = 1;
    2005                 :     4328368 :   cgraph_node *node = ultimate_alias_target ();
    2006                 :     4328368 :   node->address_taken = 1;
    2007                 :             : }
    2008                 :             : 
    2009                 :             : /* Return local info node for the compiled function.  */
    2010                 :             : 
    2011                 :             : cgraph_node *
    2012                 :    12231658 : cgraph_node::local_info_node (tree decl)
    2013                 :             : {
    2014                 :    12231658 :   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
    2015                 :    12231658 :   cgraph_node *node = get (decl);
    2016                 :    12231658 :   if (!node)
    2017                 :             :     return NULL;
    2018                 :    12231658 :   return node->ultimate_alias_target ();
    2019                 :             : }
    2020                 :             : 
    2021                 :             : /* Return RTL info for the compiled function.  */
    2022                 :             : 
    2023                 :             : cgraph_rtl_info *
    2024                 :    56503986 : cgraph_node::rtl_info (const_tree decl)
    2025                 :             : {
    2026                 :    56503986 :   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
    2027                 :    56503986 :   cgraph_node *node = get (decl);
    2028                 :    56503986 :   if (!node)
    2029                 :             :     return NULL;
    2030                 :    56397751 :   enum availability avail;
    2031                 :    56397751 :   node = node->ultimate_alias_target (&avail);
    2032                 :    56397751 :   if (decl != current_function_decl
    2033                 :    53428037 :       && (avail < AVAIL_AVAILABLE
    2034                 :    48541829 :           || (node->decl != current_function_decl
    2035                 :    48471062 :               && !TREE_ASM_WRITTEN (node->decl))))
    2036                 :             :     return NULL;
    2037                 :             :   /* Allocate if it doesn't exist.  */
    2038                 :    47767142 :   if (node->rtl == NULL)
    2039                 :             :     {
    2040                 :     1364358 :       node->rtl = ggc_cleared_alloc<cgraph_rtl_info> ();
    2041                 :     1364358 :       SET_HARD_REG_SET (node->rtl->function_used_regs);
    2042                 :             :     }
    2043                 :    47767142 :   return node->rtl;
    2044                 :             : }
    2045                 :             : 
    2046                 :             : /* Return a string describing the failure REASON.  */
    2047                 :             : 
    2048                 :             : const char*
    2049                 :        9722 : cgraph_inline_failed_string (cgraph_inline_failed_t reason)
    2050                 :             : {
    2051                 :             : #undef DEFCIFCODE
    2052                 :             : #define DEFCIFCODE(code, type, string)  string,
    2053                 :             : 
    2054                 :        9722 :   static const char *cif_string_table[CIF_N_REASONS] = {
    2055                 :             : #include "cif-code.def"
    2056                 :             :   };
    2057                 :             : 
    2058                 :             :   /* Signedness of an enum type is implementation defined, so cast it
    2059                 :             :      to unsigned before testing. */
    2060                 :        9722 :   gcc_assert ((unsigned) reason < CIF_N_REASONS);
    2061                 :        9722 :   return cif_string_table[reason];
    2062                 :             : }
    2063                 :             : 
    2064                 :             : /* Return a type describing the failure REASON.  */
    2065                 :             : 
    2066                 :             : cgraph_inline_failed_type_t
    2067                 :    66616256 : cgraph_inline_failed_type (cgraph_inline_failed_t reason)
    2068                 :             : {
    2069                 :             : #undef DEFCIFCODE
    2070                 :             : #define DEFCIFCODE(code, type, string)  type,
    2071                 :             : 
    2072                 :    66616256 :   static cgraph_inline_failed_type_t cif_type_table[CIF_N_REASONS] = {
    2073                 :             : #include "cif-code.def"
    2074                 :             :   };
    2075                 :             : 
    2076                 :             :   /* Signedness of an enum type is implementation defined, so cast it
    2077                 :             :      to unsigned before testing. */
    2078                 :    66616256 :   gcc_assert ((unsigned) reason < CIF_N_REASONS);
    2079                 :    66616256 :   return cif_type_table[reason];
    2080                 :             : }
    2081                 :             : 
    2082                 :             : /* Names used to print out the availability enum.  */
    2083                 :             : const char * const cgraph_availability_names[] =
    2084                 :             :   {"unset", "not_available", "overwritable", "available", "local"};
    2085                 :             : 
    2086                 :             : /* Output flags of edge to a file F.  */
    2087                 :             : 
    2088                 :             : void
    2089                 :       22329 : cgraph_edge::dump_edge_flags (FILE *f)
    2090                 :             : {
    2091                 :       22329 :   if (speculative)
    2092                 :         138 :     fprintf (f, "(speculative) ");
    2093                 :       22329 :   if (!inline_failed)
    2094                 :        1652 :     fprintf (f, "(inlined) ");
    2095                 :       22329 :   if (call_stmt_cannot_inline_p)
    2096                 :           0 :     fprintf (f, "(call_stmt_cannot_inline_p) ");
    2097                 :       22329 :   if (indirect_inlining_edge)
    2098                 :         325 :     fprintf (f, "(indirect_inlining) ");
    2099                 :       22329 :   if (count.initialized_p ())
    2100                 :             :     {
    2101                 :       21570 :       fprintf (f, "(");
    2102                 :       21570 :       count.dump (f);
    2103                 :       21570 :       fprintf (f, ",");
    2104                 :       21570 :       fprintf (f, "%.2f per call) ", sreal_frequency ().to_double ());
    2105                 :             :     }
    2106                 :       22329 :   if (can_throw_external)
    2107                 :        2658 :     fprintf (f, "(can throw external) ");
    2108                 :       22329 : }
    2109                 :             : 
    2110                 :             : /* Dump edge to stderr.  */
    2111                 :             : 
    2112                 :             : void
    2113                 :           0 : cgraph_edge::debug (void)
    2114                 :             : {
    2115                 :           0 :   fprintf (stderr, "%s -> %s ", caller->dump_asm_name (),
    2116                 :           0 :            callee == NULL ? "(null)" : callee->dump_asm_name ());
    2117                 :           0 :   dump_edge_flags (stderr);
    2118                 :           0 :   fprintf (stderr, "\n\n");
    2119                 :           0 :   caller->debug ();
    2120                 :           0 :   if (callee != NULL)
    2121                 :           0 :     callee->debug ();
    2122                 :           0 : }
    2123                 :             : 
    2124                 :             : /* Dump call graph node to file F.  */
    2125                 :             : 
    2126                 :             : void
    2127                 :        5675 : cgraph_node::dump (FILE *f)
    2128                 :             : {
    2129                 :        5675 :   cgraph_edge *edge;
    2130                 :             : 
    2131                 :        5675 :   dump_base (f);
    2132                 :             : 
    2133                 :        5675 :   if (inlined_to)
    2134                 :         712 :     fprintf (f, "  Function %s is inline copy in %s\n",
    2135                 :             :              dump_name (),
    2136                 :             :              inlined_to->dump_name ());
    2137                 :        5675 :   if (clone_of)
    2138                 :         682 :     fprintf (f, "  Clone of %s\n", clone_of->dump_asm_name ());
    2139                 :        5675 :   if (symtab->function_flags_ready)
    2140                 :       10218 :     fprintf (f, "  Availability: %s\n",
    2141                 :        5109 :              cgraph_availability_names [get_availability ()]);
    2142                 :             : 
    2143                 :        5675 :   if (profile_id)
    2144                 :         143 :     fprintf (f, "  Profile id: %i\n",
    2145                 :             :              profile_id);
    2146                 :        5675 :   if (unit_id)
    2147                 :         129 :     fprintf (f, "  Unit id: %i\n",
    2148                 :             :              unit_id);
    2149                 :        5675 :   cgraph_function_version_info *vi = function_version ();
    2150                 :        5675 :   if (vi != NULL)
    2151                 :             :     {
    2152                 :           0 :       fprintf (f, "  Version info: ");
    2153                 :           0 :       if (vi->prev != NULL)
    2154                 :             :         {
    2155                 :           0 :           fprintf (f, "prev: ");
    2156                 :           0 :           fprintf (f, "%s ", vi->prev->this_node->dump_asm_name ());
    2157                 :             :         }
    2158                 :           0 :       if (vi->next != NULL)
    2159                 :             :         {
    2160                 :           0 :           fprintf (f, "next: ");
    2161                 :           0 :           fprintf (f, "%s ", vi->next->this_node->dump_asm_name ());
    2162                 :             :         }
    2163                 :           0 :       if (vi->dispatcher_resolver != NULL_TREE)
    2164                 :           0 :         fprintf (f, "dispatcher: %s",
    2165                 :           0 :                  lang_hooks.decl_printable_name (vi->dispatcher_resolver, 2));
    2166                 :             : 
    2167                 :           0 :       fprintf (f, "\n");
    2168                 :             :     }
    2169                 :        5675 :   fprintf (f, "  Function flags:");
    2170                 :        5675 :   if (count.initialized_p ())
    2171                 :             :     {
    2172                 :        3476 :       fprintf (f, " count:");
    2173                 :        3476 :       count.dump (f);
    2174                 :             :     }
    2175                 :        5675 :   if (tp_first_run > 0)
    2176                 :          62 :     fprintf (f, " first_run:%" PRId64, (int64_t) tp_first_run);
    2177                 :        5675 :   if (cgraph_node *origin = nested_function_origin (this))
    2178                 :           0 :     fprintf (f, " nested in:%s", origin->dump_asm_name ());
    2179                 :        5675 :   if (gimple_has_body_p (decl))
    2180                 :        3738 :     fprintf (f, " body");
    2181                 :        5675 :   if (process)
    2182                 :           0 :     fprintf (f, " process");
    2183                 :        5675 :   if (local)
    2184                 :        1051 :     fprintf (f, " local");
    2185                 :        5675 :   if (redefined_extern_inline)
    2186                 :           0 :     fprintf (f, " redefined_extern_inline");
    2187                 :        5675 :   if (only_called_at_startup)
    2188                 :         387 :     fprintf (f, " only_called_at_startup");
    2189                 :        5675 :   if (only_called_at_exit)
    2190                 :           6 :     fprintf (f, " only_called_at_exit");
    2191                 :        5675 :   if (tm_clone)
    2192                 :           0 :     fprintf (f, " tm_clone");
    2193                 :        5675 :   if (calls_comdat_local)
    2194                 :           9 :     fprintf (f, " calls_comdat_local");
    2195                 :        5675 :   if (icf_merged)
    2196                 :          24 :     fprintf (f, " icf_merged");
    2197                 :        5675 :   if (merged_comdat)
    2198                 :           0 :     fprintf (f, " merged_comdat");
    2199                 :        5675 :   if (merged_extern_inline)
    2200                 :           0 :     fprintf (f, " merged_extern_inline");
    2201                 :        5675 :   if (split_part)
    2202                 :          23 :     fprintf (f, " split_part");
    2203                 :        5675 :   if (indirect_call_target)
    2204                 :         206 :     fprintf (f, " indirect_call_target");
    2205                 :        5675 :   if (nonfreeing_fn)
    2206                 :         333 :     fprintf (f, " nonfreeing_fn");
    2207                 :        5675 :   if (DECL_STATIC_CONSTRUCTOR (decl))
    2208                 :          44 :     fprintf (f," static_constructor (priority:%i)", get_init_priority ());
    2209                 :        5675 :   if (DECL_STATIC_DESTRUCTOR (decl))
    2210                 :           6 :     fprintf (f," static_destructor (priority:%i)", get_fini_priority ());
    2211                 :        5675 :   if (frequency == NODE_FREQUENCY_HOT)
    2212                 :          55 :     fprintf (f, " hot");
    2213                 :        5675 :   if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
    2214                 :          39 :     fprintf (f, " unlikely_executed");
    2215                 :        5675 :   if (frequency == NODE_FREQUENCY_EXECUTED_ONCE)
    2216                 :         675 :     fprintf (f, " executed_once");
    2217                 :        5675 :   if (opt_for_fn (decl, optimize_size))
    2218                 :         176 :     fprintf (f, " optimize_size");
    2219                 :        5675 :   if (parallelized_function)
    2220                 :           0 :     fprintf (f, " parallelized_function");
    2221                 :        5675 :   if (DECL_IS_MALLOC (decl))
    2222                 :          70 :     fprintf (f, " decl_is_malloc");
    2223                 :        5675 :   if (DECL_IS_OPERATOR_NEW_P (decl))
    2224                 :          35 :     fprintf (f, " %soperator_new",
    2225                 :          35 :              DECL_IS_REPLACEABLE_OPERATOR (decl) ? "replaceable_" : "");
    2226                 :        5675 :   if (DECL_IS_OPERATOR_DELETE_P (decl))
    2227                 :          26 :     fprintf (f, " %soperator_delete",
    2228                 :          26 :              DECL_IS_REPLACEABLE_OPERATOR (decl) ? "replaceable_" : "");
    2229                 :             : 
    2230                 :        5675 :   if (DECL_STATIC_CHAIN (decl))
    2231                 :           6 :     fprintf (f, " static_chain");
    2232                 :             : 
    2233                 :        5675 :   fprintf (f, "\n");
    2234                 :             : 
    2235                 :        5675 :   if (thunk)
    2236                 :             :     {
    2237                 :          43 :       fprintf (f, "  Thunk");
    2238                 :          43 :       thunk_info::get (this)->dump (f);
    2239                 :             :     }
    2240                 :        5632 :   else if (former_thunk_p ())
    2241                 :             :     {
    2242                 :          27 :       fprintf (f, "  Former thunk ");
    2243                 :          27 :       thunk_info::get (this)->dump (f);
    2244                 :             :     }
    2245                 :        5605 :   else gcc_checking_assert (!thunk_info::get (this));
    2246                 :             : 
    2247                 :        5675 :   fprintf (f, "  Called by: ");
    2248                 :             : 
    2249                 :        5675 :   profile_count sum = profile_count::zero ();
    2250                 :       13237 :   for (edge = callers; edge; edge = edge->next_caller)
    2251                 :             :     {
    2252                 :        7562 :       fprintf (f, "%s ", edge->caller->dump_asm_name ());
    2253                 :        7562 :       edge->dump_edge_flags (f);
    2254                 :        7562 :       if (edge->count.initialized_p ())
    2255                 :        7302 :         sum += edge->count.ipa ();
    2256                 :             :     }
    2257                 :             : 
    2258                 :        5675 :   fprintf (f, "\n  Calls: ");
    2259                 :       19691 :   for (edge = callees; edge; edge = edge->next_callee)
    2260                 :             :     {
    2261                 :       14016 :       fprintf (f, "%s ", edge->callee->dump_asm_name ());
    2262                 :       14016 :       edge->dump_edge_flags (f);
    2263                 :             :     }
    2264                 :        5675 :   fprintf (f, "\n");
    2265                 :             : 
    2266                 :        5675 :   if (!body_removed && count.ipa ().initialized_p ())
    2267                 :             :     {
    2268                 :         101 :       bool ok = true;
    2269                 :         101 :       bool min = false;
    2270                 :             :       ipa_ref *ref;
    2271                 :             : 
    2272                 :         101 :       FOR_EACH_ALIAS (this, ref)
    2273                 :           0 :         if (dyn_cast <cgraph_node *> (ref->referring)->count.initialized_p ())
    2274                 :           0 :           sum += dyn_cast <cgraph_node *> (ref->referring)->count.ipa ();
    2275                 :             : 
    2276                 :         101 :       if (inlined_to
    2277                 :         101 :           || (symtab->state < EXPANSION
    2278                 :         101 :               && ultimate_alias_target () == this && only_called_directly_p ()))
    2279                 :           1 :         ok = !count.ipa ().differs_from_p (sum);
    2280                 :         100 :       else if (count.ipa () > profile_count::from_gcov_type (100)
    2281                 :         100 :                && count.ipa () < sum.apply_scale (99, 100))
    2282                 :           0 :         ok = false, min = true;
    2283                 :         101 :       if (!ok)
    2284                 :             :         {
    2285                 :           0 :           fprintf (f, "   Invalid sum of caller counts ");
    2286                 :           0 :           sum.dump (f);
    2287                 :           0 :           if (min)
    2288                 :           0 :             fprintf (f, ", should be at most ");
    2289                 :             :           else
    2290                 :           0 :             fprintf (f, ", should be ");
    2291                 :           0 :           count.ipa ().dump (f);
    2292                 :           0 :           fprintf (f, "\n");
    2293                 :             :         }
    2294                 :             :     }
    2295                 :             : 
    2296                 :        6426 :   for (edge = indirect_calls; edge; edge = edge->next_callee)
    2297                 :             :     {
    2298                 :         751 :       if (edge->indirect_info->polymorphic)
    2299                 :             :         {
    2300                 :         277 :           fprintf (f, "   Polymorphic indirect call of type ");
    2301                 :         277 :           print_generic_expr (f, edge->indirect_info->otr_type, TDF_SLIM);
    2302                 :         277 :           fprintf (f, " token:%i", (int) edge->indirect_info->otr_token);
    2303                 :             :         }
    2304                 :             :       else
    2305                 :         474 :         fprintf (f, "   Indirect call");
    2306                 :         751 :       edge->dump_edge_flags (f);
    2307                 :         751 :       if (edge->indirect_info->param_index != -1)
    2308                 :             :         {
    2309                 :         201 :           fprintf (f, "of param:%i ", edge->indirect_info->param_index);
    2310                 :         201 :           if (edge->indirect_info->agg_contents)
    2311                 :          19 :            fprintf (f, "loaded from %s %s at offset %i ",
    2312                 :          19 :                     edge->indirect_info->member_ptr ? "member ptr" : "aggregate",
    2313                 :          19 :                     edge->indirect_info->by_ref ? "passed by reference" : "",
    2314                 :          19 :                     (int)edge->indirect_info->offset);
    2315                 :         201 :           if (edge->indirect_info->vptr_changed)
    2316                 :          23 :             fprintf (f, "(vptr maybe changed) ");
    2317                 :             :         }
    2318                 :         751 :       fprintf (f, "num speculative call targets: %i\n",
    2319                 :         751 :                edge->indirect_info->num_speculative_call_targets);
    2320                 :         751 :       if (edge->indirect_info->polymorphic)
    2321                 :         277 :         edge->indirect_info->context.dump (f);
    2322                 :             :     }
    2323                 :        5675 : }
    2324                 :             : 
    2325                 :             : /* Dump call graph node to file F in graphviz format.  */
    2326                 :             : 
    2327                 :             : void
    2328                 :           0 : cgraph_node::dump_graphviz (FILE *f)
    2329                 :             : {
    2330                 :           0 :   cgraph_edge *edge;
    2331                 :             : 
    2332                 :           0 :   for (edge = callees; edge; edge = edge->next_callee)
    2333                 :             :     {
    2334                 :           0 :       cgraph_node *callee = edge->callee;
    2335                 :             : 
    2336                 :           0 :       fprintf (f, "\t\"%s\" -> \"%s\"\n", dump_name (), callee->dump_name ());
    2337                 :             :     }
    2338                 :           0 : }
    2339                 :             : 
    2340                 :             : 
    2341                 :             : /* Dump call graph node NODE to stderr.  */
    2342                 :             : 
    2343                 :             : DEBUG_FUNCTION void
    2344                 :           0 : cgraph_node::debug (void)
    2345                 :             : {
    2346                 :           0 :   dump (stderr);
    2347                 :           0 : }
    2348                 :             : 
    2349                 :             : /* Dump the callgraph to file F.  */
    2350                 :             : 
    2351                 :             : void
    2352                 :          77 : cgraph_node::dump_cgraph (FILE *f)
    2353                 :             : {
    2354                 :          77 :   cgraph_node *node;
    2355                 :             : 
    2356                 :          77 :   fprintf (f, "callgraph:\n\n");
    2357                 :         724 :   FOR_EACH_FUNCTION (node)
    2358                 :         285 :     node->dump (f);
    2359                 :          77 : }
    2360                 :             : 
    2361                 :             : /* Return true when the DECL can possibly be inlined.  */
    2362                 :             : 
    2363                 :             : bool
    2364                 :    78350497 : cgraph_function_possibly_inlined_p (tree decl)
    2365                 :             : {
    2366                 :    78350497 :   if (!symtab->global_info_ready)
    2367                 :    72124293 :     return !DECL_UNINLINABLE (decl);
    2368                 :     6226204 :   return DECL_POSSIBLY_INLINED (decl);
    2369                 :             : }
    2370                 :             : 
    2371                 :             : /* Return function availability.  See cgraph.h for description of individual
    2372                 :             :    return values.  */
    2373                 :             : enum availability
    2374                 :   750153206 : cgraph_node::get_availability (symtab_node *ref)
    2375                 :             : {
    2376                 :   750153206 :   if (ref)
    2377                 :             :     {
    2378                 :   527736389 :       cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
    2379                 :   527736389 :       if (cref)
    2380                 :   527736389 :         ref = cref->inlined_to;
    2381                 :             :     }
    2382                 :   750153206 :   enum availability avail;
    2383                 :   750153206 :   if (!analyzed && !in_other_partition)
    2384                 :   460658967 :     avail = AVAIL_NOT_AVAILABLE;
    2385                 :   289494239 :   else if (local)
    2386                 :    85123206 :     avail = AVAIL_LOCAL;
    2387                 :   204371033 :   else if (inlined_to)
    2388                 :     1789731 :     avail = AVAIL_AVAILABLE;
    2389                 :   202581302 :   else if (transparent_alias)
    2390                 :         134 :     ultimate_alias_target (&avail, ref);
    2391                 :   202581168 :   else if (ifunc_resolver
    2392                 :   202581168 :            || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl)))
    2393                 :     2980624 :     avail = AVAIL_INTERPOSABLE;
    2394                 :   199600544 :   else if (!externally_visible)
    2395                 :    27434351 :     avail = AVAIL_AVAILABLE;
    2396                 :             :   /* If this is a reference from symbol itself and there are no aliases, we
    2397                 :             :      may be sure that the symbol was not interposed by something else because
    2398                 :             :      the symbol itself would be unreachable otherwise.
    2399                 :             : 
    2400                 :             :      Also comdat groups are always resolved in groups.  */
    2401                 :       38412 :   else if ((this == ref && !has_aliases_p ())
    2402                 :   172167011 :            || (ref && get_comdat_group ()
    2403                 :     1070857 :                && get_comdat_group () == ref->get_comdat_group ()))
    2404                 :       39893 :     avail = AVAIL_AVAILABLE;
    2405                 :             :   /* Inline functions are safe to be analyzed even if their symbol can
    2406                 :             :      be overwritten at runtime.  It is not meaningful to enforce any sane
    2407                 :             :      behavior on replacing inline function by different body.  */
    2408                 :   172126300 :   else if (DECL_DECLARED_INLINE_P (decl))
    2409                 :    52106592 :     avail = AVAIL_AVAILABLE;
    2410                 :             : 
    2411                 :             :   /* If the function can be overwritten, return OVERWRITABLE.  Take
    2412                 :             :      care at least of two notable extensions - the COMDAT functions
    2413                 :             :      used to share template instantiations in C++ (this is symmetric
    2414                 :             :      to code cp_cannot_inline_tree_fn and probably shall be shared and
    2415                 :             :      the inlinability hooks completely eliminated).  */
    2416                 :             : 
    2417                 :   120019708 :   else if (decl_replaceable_p (decl, semantic_interposition)
    2418                 :   120019708 :            && !DECL_EXTERNAL (decl))
    2419                 :     9160804 :     avail = AVAIL_INTERPOSABLE;
    2420                 :   110858904 :   else avail = AVAIL_AVAILABLE;
    2421                 :             : 
    2422                 :   750153206 :   return avail;
    2423                 :             : }
    2424                 :             : 
    2425                 :             : /* Worker for cgraph_node_can_be_local_p.  */
    2426                 :             : static bool
    2427                 :      818873 : cgraph_node_cannot_be_local_p_1 (cgraph_node *node, void *)
    2428                 :             : {
    2429                 :     1227713 :   return !(!node->force_output
    2430                 :             :            && !node->ifunc_resolver
    2431                 :             :            /* Limitation of gas requires us to output targets of symver aliases
    2432                 :             :               as global symbols.  This is binutils PR 25295.  */
    2433                 :      818873 :            && !node->symver
    2434                 :      798150 :            && ((DECL_COMDAT (node->decl)
    2435                 :      294470 :                 && !node->forced_by_abi
    2436                 :      273427 :                 && !node->used_from_object_file_p ()
    2437                 :      273427 :                 && !node->same_comdat_group)
    2438                 :      568640 :                || !node->externally_visible)
    2439                 :      410297 :            && !DECL_STATIC_CONSTRUCTOR (node->decl)
    2440                 :      408840 :            && !DECL_STATIC_DESTRUCTOR (node->decl));
    2441                 :             : }
    2442                 :             : 
    2443                 :             : /* Return true if cgraph_node can be made local for API change.
    2444                 :             :    Extern inline functions and C++ COMDAT functions can be made local
    2445                 :             :    at the expense of possible code size growth if function is used in multiple
    2446                 :             :    compilation units.  */
    2447                 :             : bool
    2448                 :     1120336 : cgraph_node::can_be_local_p (void)
    2449                 :             : {
    2450                 :     1120336 :   return (!address_taken
    2451                 :     1120336 :           && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1,
    2452                 :     1120336 :                                                 NULL, true));
    2453                 :             : }
    2454                 :             : 
    2455                 :             : /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
    2456                 :             :    When INCLUDE_OVERWRITABLE is false, overwritable symbols are
    2457                 :             :    skipped.  When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
    2458                 :             :    skipped.  */
    2459                 :             : bool
    2460                 :   108511245 : cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback)
    2461                 :             :                                                    (cgraph_node *, void *),
    2462                 :             :                                                  void *data,
    2463                 :             :                                                  bool include_overwritable,
    2464                 :             :                                                  bool exclude_virtual_thunks)
    2465                 :             : {
    2466                 :   108511245 :   cgraph_edge *e;
    2467                 :   108511245 :   ipa_ref *ref;
    2468                 :   108511245 :   enum availability avail = AVAIL_AVAILABLE;
    2469                 :             : 
    2470                 :   108511245 :   if (include_overwritable
    2471                 :   108511245 :       || (avail = get_availability ()) > AVAIL_INTERPOSABLE)
    2472                 :             :     {
    2473                 :   108499977 :       if (callback (this, data))
    2474                 :             :         return true;
    2475                 :             :     }
    2476                 :   114476571 :   FOR_EACH_ALIAS (this, ref)
    2477                 :             :     {
    2478                 :    10946726 :       cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    2479                 :    10946726 :       if (include_overwritable
    2480                 :    10946726 :           || alias->get_availability () > AVAIL_INTERPOSABLE)
    2481                 :    10946484 :         if (alias->call_for_symbol_thunks_and_aliases (callback, data,
    2482                 :             :                                                      include_overwritable,
    2483                 :             :                                                      exclude_virtual_thunks))
    2484                 :             :           return true;
    2485                 :             :     }
    2486                 :   103529845 :   if (avail <= AVAIL_INTERPOSABLE)
    2487                 :             :     return false;
    2488                 :   108485669 :   for (e = callers; e; e = e->next_caller)
    2489                 :     4967092 :     if (e->caller->thunk
    2490                 :        2699 :         && (include_overwritable
    2491                 :         407 :             || e->caller->get_availability () > AVAIL_INTERPOSABLE)
    2492                 :     4969791 :         && !(exclude_virtual_thunks
    2493                 :          22 :              && thunk_info::get (e->caller)->virtual_offset_p))
    2494                 :        2687 :       if (e->caller->call_for_symbol_thunks_and_aliases (callback, data,
    2495                 :             :                                                        include_overwritable,
    2496                 :             :                                                        exclude_virtual_thunks))
    2497                 :             :         return true;
    2498                 :             : 
    2499                 :             :   return false;
    2500                 :             : }
    2501                 :             : 
    2502                 :             : /* Worker to bring NODE local.  */
    2503                 :             : 
    2504                 :             : bool
    2505                 :           0 : cgraph_node::make_local (cgraph_node *node, void *)
    2506                 :             : {
    2507                 :           0 :   gcc_checking_assert (node->can_be_local_p ());
    2508                 :           0 :   if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
    2509                 :             :     {
    2510                 :           0 :       node->make_decl_local ();
    2511                 :           0 :       node->set_section (NULL);
    2512                 :           0 :       node->set_comdat_group (NULL);
    2513                 :           0 :       node->externally_visible = false;
    2514                 :           0 :       node->forced_by_abi = false;
    2515                 :           0 :       node->local = true;
    2516                 :           0 :       node->unique_name = ((node->resolution == LDPR_PREVAILING_DEF_IRONLY
    2517                 :           0 :                            || node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP)
    2518                 :           0 :                            && !flag_incremental_link);
    2519                 :           0 :       node->resolution = LDPR_PREVAILING_DEF_IRONLY;
    2520                 :           0 :       gcc_assert (node->get_availability () == AVAIL_LOCAL);
    2521                 :             :     }
    2522                 :           0 :   return false;
    2523                 :             : }
    2524                 :             : 
    2525                 :             : /* Bring cgraph node local.  */
    2526                 :             : 
    2527                 :             : void
    2528                 :           0 : cgraph_node::make_local (void)
    2529                 :             : {
    2530                 :           0 :   call_for_symbol_thunks_and_aliases (cgraph_node::make_local, NULL, true);
    2531                 :           0 : }
    2532                 :             : 
    2533                 :             : /* Worker to set nothrow flag.  */
    2534                 :             : 
    2535                 :             : static void
    2536                 :      914992 : set_nothrow_flag_1 (cgraph_node *node, bool nothrow, bool non_call,
    2537                 :             :                     bool *changed)
    2538                 :             : {
    2539                 :      914992 :   cgraph_edge *e;
    2540                 :             : 
    2541                 :      914992 :   if (nothrow && !TREE_NOTHROW (node->decl))
    2542                 :             :     {
    2543                 :             :       /* With non-call exceptions we can't say for sure if other function body
    2544                 :             :          was not possibly optimized to still throw.  */
    2545                 :      914967 :       if (!non_call || node->binds_to_current_def_p ())
    2546                 :             :         {
    2547                 :      910161 :           TREE_NOTHROW (node->decl) = true;
    2548                 :      910161 :           *changed = true;
    2549                 :     2170404 :           for (e = node->callers; e; e = e->next_caller)
    2550                 :     1260243 :             e->can_throw_external = false;
    2551                 :             :         }
    2552                 :             :     }
    2553                 :           0 :   else if (!nothrow && TREE_NOTHROW (node->decl))
    2554                 :             :     {
    2555                 :           0 :       TREE_NOTHROW (node->decl) = false;
    2556                 :           0 :       *changed = true;
    2557                 :             :     }
    2558                 :             :   ipa_ref *ref;
    2559                 :      968245 :   FOR_EACH_ALIAS (node, ref)
    2560                 :             :     {
    2561                 :       53253 :       cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    2562                 :       53253 :       if (!nothrow || alias->get_availability () > AVAIL_INTERPOSABLE)
    2563                 :       52830 :         set_nothrow_flag_1 (alias, nothrow, non_call, changed);
    2564                 :             :     }
    2565                 :     2212028 :   for (cgraph_edge *e = node->callers; e; e = e->next_caller)
    2566                 :     1297036 :     if (e->caller->thunk
    2567                 :     1297036 :         && (!nothrow || e->caller->get_availability () > AVAIL_INTERPOSABLE))
    2568                 :         134 :       set_nothrow_flag_1 (e->caller, nothrow, non_call, changed);
    2569                 :      914992 : }
    2570                 :             : 
    2571                 :             : /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
    2572                 :             :    if any to NOTHROW.  */
    2573                 :             : 
    2574                 :             : bool
    2575                 :      873287 : cgraph_node::set_nothrow_flag (bool nothrow)
    2576                 :             : {
    2577                 :      873287 :   bool changed = false;
    2578                 :      873287 :   bool non_call = opt_for_fn (decl, flag_non_call_exceptions);
    2579                 :             : 
    2580                 :      873287 :   if (!nothrow || get_availability () > AVAIL_INTERPOSABLE)
    2581                 :      861661 :     set_nothrow_flag_1 (this, nothrow, non_call, &changed);
    2582                 :             :   else
    2583                 :             :     {
    2584                 :             :       ipa_ref *ref;
    2585                 :             : 
    2586                 :       19089 :       FOR_EACH_ALIAS (this, ref)
    2587                 :             :         {
    2588                 :        7463 :           cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    2589                 :        7463 :           if (!nothrow || alias->get_availability () > AVAIL_INTERPOSABLE)
    2590                 :         367 :             set_nothrow_flag_1 (alias, nothrow, non_call, &changed);
    2591                 :             :         }
    2592                 :             :     }
    2593                 :      873287 :   return changed;
    2594                 :             : }
    2595                 :             : 
    2596                 :             : /* Worker to set malloc flag.  */
    2597                 :             : static void
    2598                 :       20315 : set_malloc_flag_1 (cgraph_node *node, bool malloc_p, bool *changed)
    2599                 :             : {
    2600                 :       20315 :   if (malloc_p && !DECL_IS_MALLOC (node->decl))
    2601                 :             :     {
    2602                 :       19901 :       DECL_IS_MALLOC (node->decl) = true;
    2603                 :       19901 :       *changed = true;
    2604                 :             :     }
    2605                 :             : 
    2606                 :             :   ipa_ref *ref;
    2607                 :       20319 :   FOR_EACH_ALIAS (node, ref)
    2608                 :             :     {
    2609                 :           4 :       cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
    2610                 :           4 :       if (!malloc_p || alias->get_availability () > AVAIL_INTERPOSABLE)
    2611                 :           4 :         set_malloc_flag_1 (alias, malloc_p, changed);
    2612                 :             :     }
    2613                 :             : 
    2614                 :       44616 :   for (cgraph_edge *e = node->callers; e; e = e->next_caller)
    2615                 :       24301 :     if (e->caller->thunk
    2616                 :       24301 :         && (!malloc_p || e->caller->get_availability () > AVAIL_INTERPOSABLE))
    2617                 :           0 :       set_malloc_flag_1 (e->caller, malloc_p, changed);
    2618                 :       20315 : }
    2619                 :             : 
    2620                 :             : /* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any.  */
    2621                 :             : 
    2622                 :             : bool
    2623                 :       20311 : cgraph_node::set_malloc_flag (bool malloc_p)
    2624                 :             : {
    2625                 :       20311 :   bool changed = false;
    2626                 :             : 
    2627                 :       20311 :   if (!malloc_p || get_availability () > AVAIL_INTERPOSABLE)
    2628                 :       20311 :     set_malloc_flag_1 (this, malloc_p, &changed);
    2629                 :             :   else
    2630                 :             :     {
    2631                 :             :       ipa_ref *ref;
    2632                 :             : 
    2633                 :           0 :       FOR_EACH_ALIAS (this, ref)
    2634                 :             :         {
    2635                 :           0 :           cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
    2636                 :           0 :           if (!malloc_p || alias->get_availability () > AVAIL_INTERPOSABLE)
    2637                 :           0 :             set_malloc_flag_1 (alias, malloc_p, &changed);
    2638                 :             :         }
    2639                 :             :     }
    2640                 :       20311 :   return changed;
    2641                 :             : }
    2642                 :             : 
    2643                 :             : /* Worker to set malloc flag.  */
    2644                 :             : static void
    2645                 :      208238 : add_detected_attribute_1 (cgraph_node *node, const char *attr, bool *changed)
    2646                 :             : {
    2647                 :      208238 :   if (!lookup_attribute (attr, DECL_ATTRIBUTES (node->decl)))
    2648                 :             :     {
    2649                 :      183179 :       DECL_ATTRIBUTES (node->decl) = tree_cons (get_identifier (attr),
    2650                 :      183179 :                                          NULL_TREE, DECL_ATTRIBUTES (node->decl));
    2651                 :      183179 :       *changed = true;
    2652                 :             :     }
    2653                 :             : 
    2654                 :             :   ipa_ref *ref;
    2655                 :      209757 :   FOR_EACH_ALIAS (node, ref)
    2656                 :             :     {
    2657                 :        1519 :       cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
    2658                 :        1519 :       if (alias->get_availability () > AVAIL_INTERPOSABLE)
    2659                 :        1107 :         add_detected_attribute_1 (alias, attr, changed);
    2660                 :             :     }
    2661                 :             : 
    2662                 :      641040 :   for (cgraph_edge *e = node->callers; e; e = e->next_caller)
    2663                 :      432802 :     if (e->caller->thunk
    2664                 :      432802 :         && (e->caller->get_availability () > AVAIL_INTERPOSABLE))
    2665                 :          14 :       add_detected_attribute_1 (e->caller, attr, changed);
    2666                 :      208238 : }
    2667                 :             : 
    2668                 :             : /* Add attribyte ATTR to function and its aliases.  */
    2669                 :             : 
    2670                 :             : bool
    2671                 :      210880 : cgraph_node::add_detected_attribute (const char *attr)
    2672                 :             : {
    2673                 :      210880 :   bool changed = false;
    2674                 :             : 
    2675                 :      210880 :   if (get_availability () > AVAIL_INTERPOSABLE)
    2676                 :      207117 :     add_detected_attribute_1 (this, attr, &changed);
    2677                 :             :   else
    2678                 :             :     {
    2679                 :             :       ipa_ref *ref;
    2680                 :             : 
    2681                 :        3787 :       FOR_EACH_ALIAS (this, ref)
    2682                 :             :         {
    2683                 :          24 :           cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
    2684                 :          24 :           if (alias->get_availability () > AVAIL_INTERPOSABLE)
    2685                 :           0 :             add_detected_attribute_1 (alias, attr, &changed);
    2686                 :             :         }
    2687                 :             :     }
    2688                 :      210880 :   return changed;
    2689                 :             : }
    2690                 :             : 
    2691                 :             : /* Worker to set noreturng flag.  */
    2692                 :             : static void
    2693                 :       31332 : set_noreturn_flag_1 (cgraph_node *node, bool noreturn_p, bool *changed)
    2694                 :             : {
    2695                 :       31332 :   if (noreturn_p && !TREE_THIS_VOLATILE (node->decl))
    2696                 :             :     {
    2697                 :       31332 :       TREE_THIS_VOLATILE (node->decl) = true;
    2698                 :       31332 :       *changed = true;
    2699                 :             :     }
    2700                 :             : 
    2701                 :             :   ipa_ref *ref;
    2702                 :       32014 :   FOR_EACH_ALIAS (node, ref)
    2703                 :             :     {
    2704                 :         682 :       cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
    2705                 :         682 :       if (!noreturn_p || alias->get_availability () > AVAIL_INTERPOSABLE)
    2706                 :         682 :         set_noreturn_flag_1 (alias, noreturn_p, changed);
    2707                 :             :     }
    2708                 :             : 
    2709                 :       54355 :   for (cgraph_edge *e = node->callers; e; e = e->next_caller)
    2710                 :       23023 :     if (e->caller->thunk
    2711                 :       23023 :         && (!noreturn_p || e->caller->get_availability () > AVAIL_INTERPOSABLE))
    2712                 :          20 :       set_noreturn_flag_1 (e->caller, noreturn_p, changed);
    2713                 :       31332 : }
    2714                 :             : 
    2715                 :             : /* Set TREE_THIS_VOLATILE on NODE's decl and on NODE's aliases if any.  */
    2716                 :             : 
    2717                 :             : bool
    2718                 :       30778 : cgraph_node::set_noreturn_flag (bool noreturn_p)
    2719                 :             : {
    2720                 :       30778 :   bool changed = false;
    2721                 :             : 
    2722                 :       30778 :   if (!noreturn_p || get_availability () > AVAIL_INTERPOSABLE)
    2723                 :       30627 :     set_noreturn_flag_1 (this, noreturn_p, &changed);
    2724                 :             :   else
    2725                 :             :     {
    2726                 :             :       ipa_ref *ref;
    2727                 :             : 
    2728                 :         162 :       FOR_EACH_ALIAS (this, ref)
    2729                 :             :         {
    2730                 :          11 :           cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
    2731                 :          11 :           if (!noreturn_p || alias->get_availability () > AVAIL_INTERPOSABLE)
    2732                 :           3 :             set_noreturn_flag_1 (alias, noreturn_p, &changed);
    2733                 :             :         }
    2734                 :             :     }
    2735                 :       30778 :   return changed;
    2736                 :             : }
    2737                 :             : 
    2738                 :             : /* Worker to set_const_flag.  */
    2739                 :             : 
    2740                 :             : static void
    2741                 :      954476 : set_const_flag_1 (cgraph_node *node, bool set_const, bool looping,
    2742                 :             :                   bool *changed)
    2743                 :             : {
    2744                 :             :   /* Static constructors and destructors without a side effect can be
    2745                 :             :      optimized out.  */
    2746                 :      954476 :   if (set_const && !looping)
    2747                 :             :     {
    2748                 :      948718 :       if (DECL_STATIC_CONSTRUCTOR (node->decl))
    2749                 :             :         {
    2750                 :         231 :           DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
    2751                 :         231 :           *changed = true;
    2752                 :             :         }
    2753                 :      948718 :       if (DECL_STATIC_DESTRUCTOR (node->decl))
    2754                 :             :         {
    2755                 :           1 :           DECL_STATIC_DESTRUCTOR (node->decl) = 0;
    2756                 :           1 :           *changed = true;
    2757                 :             :         }
    2758                 :             :     }
    2759                 :      954476 :   if (!set_const)
    2760                 :             :     {
    2761                 :        1875 :       if (TREE_READONLY (node->decl))
    2762                 :             :         {
    2763                 :         159 :           TREE_READONLY (node->decl) = 0;
    2764                 :         159 :           DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
    2765                 :         159 :           *changed = true;
    2766                 :             :         }
    2767                 :             :     }
    2768                 :             :   else
    2769                 :             :     {
    2770                 :             :       /* Consider function:
    2771                 :             : 
    2772                 :             :          bool a(int *p)
    2773                 :             :          {
    2774                 :             :            return *p==*p;
    2775                 :             :          }
    2776                 :             : 
    2777                 :             :          During early optimization we will turn this into:
    2778                 :             : 
    2779                 :             :          bool a(int *p)
    2780                 :             :          {
    2781                 :             :            return true;
    2782                 :             :          }
    2783                 :             : 
    2784                 :             :          Now if this function will be detected as CONST however when interposed
    2785                 :             :          it may end up being just pure.  We always must assume the worst
    2786                 :             :          scenario here.  */
    2787                 :      952601 :       if (TREE_READONLY (node->decl))
    2788                 :             :         {
    2789                 :         854 :           if (!looping && DECL_LOOPING_CONST_OR_PURE_P (node->decl))
    2790                 :             :             {
    2791                 :         527 :               DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
    2792                 :         527 :               *changed = true;
    2793                 :             :             }
    2794                 :             :         }
    2795                 :      951747 :       else if (node->binds_to_current_def_p ())
    2796                 :             :         {
    2797                 :      167407 :           TREE_READONLY (node->decl) = true;
    2798                 :      167407 :           DECL_LOOPING_CONST_OR_PURE_P (node->decl) = looping;
    2799                 :      167407 :           DECL_PURE_P (node->decl) = false;
    2800                 :      167407 :           *changed = true;
    2801                 :             :         }
    2802                 :             :       else
    2803                 :             :         {
    2804                 :      784340 :           if (dump_file && (dump_flags & TDF_DETAILS))
    2805                 :           0 :             fprintf (dump_file, "Dropping state to PURE because function does "
    2806                 :             :                      "not bind to current def.\n");
    2807                 :      784340 :           if (!DECL_PURE_P (node->decl))
    2808                 :             :             {
    2809                 :      376198 :               DECL_PURE_P (node->decl) = true;
    2810                 :      376198 :               DECL_LOOPING_CONST_OR_PURE_P (node->decl) = looping;
    2811                 :      376198 :               *changed = true;
    2812                 :             :             }
    2813                 :      408142 :           else if (!looping && DECL_LOOPING_CONST_OR_PURE_P (node->decl))
    2814                 :             :             {
    2815                 :         147 :               DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
    2816                 :         147 :               *changed = true;
    2817                 :             :             }
    2818                 :             :         }
    2819                 :             :     }
    2820                 :             : 
    2821                 :             :   ipa_ref *ref;
    2822                 :     1082180 :   FOR_EACH_ALIAS (node, ref)
    2823                 :             :     {
    2824                 :      127704 :       cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    2825                 :      127704 :       if (!set_const || alias->get_availability () > AVAIL_INTERPOSABLE)
    2826                 :      127641 :         set_const_flag_1 (alias, set_const, looping, changed);
    2827                 :             :     }
    2828                 :      954572 :   for (struct cgraph_node *n = node->simd_clones; n != NULL;
    2829                 :          96 :        n = n->simdclone->next_clone)
    2830                 :          96 :     set_const_flag_1 (n, set_const, looping, changed);
    2831                 :     2415973 :   for (cgraph_edge *e = node->callers; e; e = e->next_caller)
    2832                 :     1461497 :     if (e->caller->thunk
    2833                 :     1461497 :         && (!set_const || e->caller->get_availability () > AVAIL_INTERPOSABLE))
    2834                 :             :       {
    2835                 :             :         /* Virtual thunks access virtual offset in the vtable, so they can
    2836                 :             :            only be pure, never const.  */
    2837                 :         373 :         if (set_const
    2838                 :         373 :             && (thunk_info::get (e->caller)->virtual_offset_p
    2839                 :         242 :                 || !node->binds_to_current_def_p (e->caller)))
    2840                 :         131 :           *changed |= e->caller->set_pure_flag (true, looping);
    2841                 :             :         else
    2842                 :         242 :           set_const_flag_1 (e->caller, set_const, looping, changed);
    2843                 :             :       }
    2844                 :      954476 : }
    2845                 :             : 
    2846                 :             : /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
    2847                 :             :    If SET_CONST if false, clear the flag.
    2848                 :             : 
    2849                 :             :    When setting the flag be careful about possible interposition and
    2850                 :             :    do not set the flag for functions that can be interposed and set pure
    2851                 :             :    flag for functions that can bind to other definition.
    2852                 :             : 
    2853                 :             :    Return true if any change was done. */
    2854                 :             : 
    2855                 :             : bool
    2856                 :      851706 : cgraph_node::set_const_flag (bool set_const, bool looping)
    2857                 :             : {
    2858                 :      851706 :   bool changed = false;
    2859                 :      851706 :   if (!set_const || get_availability () > AVAIL_INTERPOSABLE)
    2860                 :      826290 :     set_const_flag_1 (this, set_const, looping, &changed);
    2861                 :             :   else
    2862                 :             :     {
    2863                 :             :       ipa_ref *ref;
    2864                 :             : 
    2865                 :       26307 :       FOR_EACH_ALIAS (this, ref)
    2866                 :             :         {
    2867                 :         891 :           cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    2868                 :         891 :           if (!set_const || alias->get_availability () > AVAIL_INTERPOSABLE)
    2869                 :         207 :             set_const_flag_1 (alias, set_const, looping, &changed);
    2870                 :             :         }
    2871                 :             :     }
    2872                 :      851706 :   return changed;
    2873                 :             : }
    2874                 :             : 
    2875                 :             : /* Info used by set_pure_flag_1.  */
    2876                 :             : 
    2877                 :             : struct set_pure_flag_info
    2878                 :             : {
    2879                 :             :   bool pure;
    2880                 :             :   bool looping;
    2881                 :             :   bool changed;
    2882                 :             : };
    2883                 :             : 
    2884                 :             : /* Worker to set_pure_flag.  */
    2885                 :             : 
    2886                 :             : static bool
    2887                 :      306766 : set_pure_flag_1 (cgraph_node *node, void *data)
    2888                 :             : {
    2889                 :      306766 :   struct set_pure_flag_info *info = (struct set_pure_flag_info *)data;
    2890                 :             :   /* Static constructors and destructors without a side effect can be
    2891                 :             :      optimized out.  */
    2892                 :      306766 :   if (info->pure && !info->looping)
    2893                 :             :     {
    2894                 :      242955 :       if (DECL_STATIC_CONSTRUCTOR (node->decl))
    2895                 :             :         {
    2896                 :           0 :           DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
    2897                 :           0 :           info->changed = true;
    2898                 :             :         }
    2899                 :      242955 :       if (DECL_STATIC_DESTRUCTOR (node->decl))
    2900                 :             :         {
    2901                 :           0 :           DECL_STATIC_DESTRUCTOR (node->decl) = 0;
    2902                 :           0 :           info->changed = true;
    2903                 :             :         }
    2904                 :             :     }
    2905                 :      306766 :   if (info->pure)
    2906                 :             :     {
    2907                 :      304891 :       if (!DECL_PURE_P (node->decl) && !TREE_READONLY (node->decl))
    2908                 :             :         {
    2909                 :      304332 :           DECL_PURE_P (node->decl) = true;
    2910                 :      304332 :           DECL_LOOPING_CONST_OR_PURE_P (node->decl) = info->looping;
    2911                 :      304332 :           info->changed = true;
    2912                 :             :         }
    2913                 :         559 :       else if (DECL_LOOPING_CONST_OR_PURE_P (node->decl)
    2914                 :         559 :                && !info->looping)
    2915                 :             :         {
    2916                 :         290 :           DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
    2917                 :         290 :           info->changed = true;
    2918                 :             :         }
    2919                 :             :     }
    2920                 :             :   else
    2921                 :             :     {
    2922                 :        1875 :       if (DECL_PURE_P (node->decl))
    2923                 :             :         {
    2924                 :          71 :           DECL_PURE_P (node->decl) = false;
    2925                 :          71 :           DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
    2926                 :          71 :           info->changed = true;
    2927                 :             :         }
    2928                 :             :     }
    2929                 :      306766 :   return false;
    2930                 :             : }
    2931                 :             : 
    2932                 :             : /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
    2933                 :             :    if any to PURE.
    2934                 :             : 
    2935                 :             :    When setting the flag, be careful about possible interposition.
    2936                 :             :    Return true if any change was done. */
    2937                 :             : 
    2938                 :             : bool
    2939                 :      315268 : cgraph_node::set_pure_flag (bool pure, bool looping)
    2940                 :             : {
    2941                 :      315268 :   struct set_pure_flag_info info = {pure, looping, false};
    2942                 :      315268 :   call_for_symbol_thunks_and_aliases (set_pure_flag_1, &info, !pure, true);
    2943                 :      315268 :   for (struct cgraph_node *n = simd_clones; n != NULL;
    2944                 :           0 :        n = n->simdclone->next_clone)
    2945                 :           0 :     set_pure_flag_1 (n, &info);
    2946                 :      315268 :   return info.changed;
    2947                 :             : }
    2948                 :             : 
    2949                 :             : /* Return true when cgraph_node cannot return or throw and thus
    2950                 :             :    it is safe to ignore its side effects for IPA analysis.  */
    2951                 :             : 
    2952                 :             : bool
    2953                 :    13029982 : cgraph_node::cannot_return_p (void)
    2954                 :             : {
    2955                 :    13029982 :   int flags = flags_from_decl_or_type (decl);
    2956                 :    13029982 :   if (!opt_for_fn (decl, flag_exceptions))
    2957                 :     4801110 :     return (flags & ECF_NORETURN) != 0;
    2958                 :             :   else
    2959                 :     8228872 :     return ((flags & (ECF_NORETURN | ECF_NOTHROW))
    2960                 :     8228872 :              == (ECF_NORETURN | ECF_NOTHROW));
    2961                 :             : }
    2962                 :             : 
    2963                 :             : /* Return true when call of edge cannot lead to return from caller
    2964                 :             :    and thus it is safe to ignore its side effects for IPA analysis
    2965                 :             :    when computing side effects of the caller.
    2966                 :             :    FIXME: We could actually mark all edges that have no reaching
    2967                 :             :    patch to the exit block or throw to get better results.  */
    2968                 :             : bool
    2969                 :     2660799 : cgraph_edge::cannot_lead_to_return_p (void)
    2970                 :             : {
    2971                 :     2660799 :   if (caller->cannot_return_p ())
    2972                 :             :     return true;
    2973                 :     2572805 :   if (indirect_unknown_callee)
    2974                 :             :     {
    2975                 :       86240 :       int flags = indirect_info->ecf_flags;
    2976                 :       86240 :       if (!opt_for_fn (caller->decl, flag_exceptions))
    2977                 :       18868 :         return (flags & ECF_NORETURN) != 0;
    2978                 :             :       else
    2979                 :       67372 :         return ((flags & (ECF_NORETURN | ECF_NOTHROW))
    2980                 :       67372 :                  == (ECF_NORETURN | ECF_NOTHROW));
    2981                 :             :     }
    2982                 :             :   else
    2983                 :     2486565 :     return callee->cannot_return_p ();
    2984                 :             : }
    2985                 :             : 
    2986                 :             : /* Return true if the edge may be considered hot.  */
    2987                 :             : 
    2988                 :             : bool
    2989                 :     5241940 : cgraph_edge::maybe_hot_p (void)
    2990                 :             : {
    2991                 :     5241940 :   if (!maybe_hot_count_p (NULL, count.ipa ()))
    2992                 :             :     return false;
    2993                 :     4640424 :   if (caller->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
    2994                 :     4637688 :       || (callee
    2995                 :     3990258 :           && callee->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED))
    2996                 :             :     return false;
    2997                 :     4635260 :   if (caller->frequency > NODE_FREQUENCY_UNLIKELY_EXECUTED
    2998                 :     4635260 :       && (callee
    2999                 :     3987830 :           && callee->frequency <= NODE_FREQUENCY_EXECUTED_ONCE))
    3000                 :             :     return false;
    3001                 :     4492350 :   if (opt_for_fn (caller->decl, optimize_size))
    3002                 :             :     return false;
    3003                 :     4447470 :   if (caller->frequency == NODE_FREQUENCY_HOT)
    3004                 :             :     return true;
    3005                 :     4446930 :   if (!count.initialized_p ())
    3006                 :             :     return true;
    3007                 :     3380422 :   cgraph_node *where = caller->inlined_to ? caller->inlined_to : caller;
    3008                 :     3380422 :   if (!where->count.initialized_p ())
    3009                 :             :     return false;
    3010                 :     3380422 :   if (caller->frequency == NODE_FREQUENCY_EXECUTED_ONCE)
    3011                 :             :     {
    3012                 :       75056 :       if (count * 2 < where->count * 3)
    3013                 :             :         return false;
    3014                 :             :     }
    3015                 :     3305366 :   else if (count * param_hot_bb_frequency_fraction < where->count)
    3016                 :             :     return false;
    3017                 :             :   return true;
    3018                 :             : }
    3019                 :             : 
    3020                 :             : /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
    3021                 :             : 
    3022                 :             : static bool
    3023                 :      770203 : nonremovable_p (cgraph_node *node, void *)
    3024                 :             : {
    3025                 :      770203 :   return !node->can_remove_if_no_direct_calls_and_refs_p ();
    3026                 :             : }
    3027                 :             : 
    3028                 :             : /* Return true if whole comdat group can be removed if there are no direct
    3029                 :             :    calls to THIS.  */
    3030                 :             : 
    3031                 :             : bool
    3032                 :      959491 : cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline)
    3033                 :             : {
    3034                 :      959491 :   struct ipa_ref *ref;
    3035                 :             : 
    3036                 :             :   /* For local symbols or non-comdat group it is the same as
    3037                 :             :      can_remove_if_no_direct_calls_p.  */
    3038                 :      959491 :   if (!externally_visible || !same_comdat_group)
    3039                 :             :     {
    3040                 :      771692 :       if (DECL_EXTERNAL (decl))
    3041                 :             :         return true;
    3042                 :      771692 :       if (address_taken)
    3043                 :             :         return false;
    3044                 :      743015 :       return !call_for_symbol_and_aliases (nonremovable_p, NULL, true);
    3045                 :             :     }
    3046                 :             : 
    3047                 :      187799 :   if (will_inline && address_taken)
    3048                 :             :     return false;
    3049                 :             : 
    3050                 :             :   /* Otherwise check if we can remove the symbol itself and then verify
    3051                 :             :      that only uses of the comdat groups are direct call to THIS
    3052                 :             :      or its aliases.   */
    3053                 :      187799 :   if (!can_remove_if_no_direct_calls_and_refs_p ())
    3054                 :             :     return false;
    3055                 :             : 
    3056                 :             :   /* Check that all refs come from within the comdat group.  */
    3057                 :      358943 :   for (int i = 0; iterate_referring (i, ref); i++)
    3058                 :      182753 :     if (ref->referring->get_comdat_group () != get_comdat_group ())
    3059                 :             :       return false;
    3060                 :             : 
    3061                 :      176190 :   struct cgraph_node *target = ultimate_alias_target ();
    3062                 :      176190 :   for (cgraph_node *next = dyn_cast<cgraph_node *> (same_comdat_group);
    3063                 :      538524 :        next != this; next = dyn_cast<cgraph_node *> (next->same_comdat_group))
    3064                 :             :     {
    3065                 :      191288 :       if (!externally_visible)
    3066                 :           0 :         continue;
    3067                 :      191288 :       if (!next->alias
    3068                 :      191288 :           && !next->can_remove_if_no_direct_calls_and_refs_p ())
    3069                 :             :         return false;
    3070                 :             : 
    3071                 :             :       /* If we see different symbol than THIS, be sure to check calls.  */
    3072                 :      191288 :       if (next->ultimate_alias_target () != target)
    3073                 :       23023 :         for (cgraph_edge *e = next->callers; e; e = e->next_caller)
    3074                 :        3969 :           if (e->caller->get_comdat_group () != get_comdat_group ()
    3075                 :        3969 :               || will_inline)
    3076                 :             :             return false;
    3077                 :             : 
    3078                 :             :       /* If function is not being inlined, we care only about
    3079                 :             :          references outside of the comdat group.  */
    3080                 :      189854 :       if (!will_inline)
    3081                 :      191829 :         for (int i = 0; next->iterate_referring (i, ref); i++)
    3082                 :       10662 :           if (ref->referring->get_comdat_group () != get_comdat_group ())
    3083                 :             :             return false;
    3084                 :             :     }
    3085                 :             :   return true;
    3086                 :             : }
    3087                 :             : 
    3088                 :             : /* Return true when function cgraph_node can be expected to be removed
    3089                 :             :    from program when direct calls in this compilation unit are removed.
    3090                 :             : 
    3091                 :             :    As a special case COMDAT functions are
    3092                 :             :    cgraph_can_remove_if_no_direct_calls_p while the are not
    3093                 :             :    cgraph_only_called_directly_p (it is possible they are called from other
    3094                 :             :    unit)
    3095                 :             : 
    3096                 :             :    This function behaves as cgraph_only_called_directly_p because eliminating
    3097                 :             :    all uses of COMDAT function does not make it necessarily disappear from
    3098                 :             :    the program unless we are compiling whole program or we do LTO.  In this
    3099                 :             :    case we know we win since dynamic linking will not really discard the
    3100                 :             :    linkonce section.  */
    3101                 :             : 
    3102                 :             : bool
    3103                 :     3156011 : cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
    3104                 :             :          (bool will_inline)
    3105                 :             : {
    3106                 :     3156011 :   gcc_assert (!inlined_to);
    3107                 :     3156011 :   if (DECL_EXTERNAL (decl))
    3108                 :             :     return true;
    3109                 :             : 
    3110                 :     3156011 :   if (!in_lto_p && !flag_whole_program)
    3111                 :             :     {
    3112                 :             :       /* If the symbol is in comdat group, we need to verify that whole comdat
    3113                 :             :          group becomes unreachable.  Technically we could skip references from
    3114                 :             :          within the group, too.  */
    3115                 :     2850795 :       if (!only_called_directly_p ())
    3116                 :             :         return false;
    3117                 :      751848 :       if (same_comdat_group && externally_visible)
    3118                 :             :         {
    3119                 :           0 :           struct cgraph_node *target = ultimate_alias_target ();
    3120                 :             : 
    3121                 :           0 :           if (will_inline && address_taken)
    3122                 :             :             return true;
    3123                 :           0 :           for (cgraph_node *next = dyn_cast<cgraph_node *> (same_comdat_group);
    3124                 :           0 :                next != this;
    3125                 :           0 :                next = dyn_cast<cgraph_node *> (next->same_comdat_group))
    3126                 :             :             {
    3127                 :           0 :               if (!externally_visible)
    3128                 :           0 :                 continue;
    3129                 :           0 :               if (!next->alias
    3130                 :           0 :                   && !next->only_called_directly_p ())
    3131                 :             :                 return false;
    3132                 :             : 
    3133                 :             :               /* If we see different symbol than THIS,
    3134                 :             :                  be sure to check calls.  */
    3135                 :           0 :               if (next->ultimate_alias_target () != target)
    3136                 :           0 :                 for (cgraph_edge *e = next->callers; e; e = e->next_caller)
    3137                 :           0 :                   if (e->caller->get_comdat_group () != get_comdat_group ()
    3138                 :           0 :                       || will_inline)
    3139                 :             :                     return false;
    3140                 :             :             }
    3141                 :             :         }
    3142                 :      751848 :       return true;
    3143                 :             :     }
    3144                 :             :   else
    3145                 :      305216 :     return can_remove_if_no_direct_calls_p (will_inline);
    3146                 :             : }
    3147                 :             : 
    3148                 :             : 
    3149                 :             : /* Worker for cgraph_only_called_directly_p.  */
    3150                 :             : 
    3151                 :             : static bool
    3152                 :    15662963 : cgraph_not_only_called_directly_p_1 (cgraph_node *node, void *)
    3153                 :             : {
    3154                 :    15662963 :   return !node->only_called_directly_or_aliased_p ();
    3155                 :             : }
    3156                 :             : 
    3157                 :             : /* Return true when function cgraph_node and all its aliases are only called
    3158                 :             :    directly.
    3159                 :             :    i.e. it is not externally visible, address was not taken and
    3160                 :             :    it is not used in any other non-standard way.  */
    3161                 :             : 
    3162                 :             : bool
    3163                 :    15596254 : cgraph_node::only_called_directly_p (void)
    3164                 :             : {
    3165                 :    15596254 :   gcc_assert (ultimate_alias_target () == this);
    3166                 :    15596254 :   return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1,
    3167                 :    15596254 :                                        NULL, true);
    3168                 :             : }
    3169                 :             : 
    3170                 :             : 
    3171                 :             : /* Collect all callers of NODE.  Worker for collect_callers_of_node.  */
    3172                 :             : 
    3173                 :             : static bool
    3174                 :      110209 : collect_callers_of_node_1 (cgraph_node *node, void *data)
    3175                 :             : {
    3176                 :      110209 :   vec<cgraph_edge *> *redirect_callers = (vec<cgraph_edge *> *)data;
    3177                 :      110209 :   cgraph_edge *cs;
    3178                 :      110209 :   enum availability avail;
    3179                 :      110209 :   node->ultimate_alias_target (&avail);
    3180                 :             : 
    3181                 :      110209 :   if (avail > AVAIL_INTERPOSABLE)
    3182                 :      377959 :     for (cs = node->callers; cs != NULL; cs = cs->next_caller)
    3183                 :      267750 :       if (!cs->indirect_inlining_edge
    3184                 :      267750 :           && !cs->caller->thunk)
    3185                 :      267710 :         redirect_callers->safe_push (cs);
    3186                 :      110209 :   return false;
    3187                 :             : }
    3188                 :             : 
    3189                 :             : /* Collect all callers of cgraph_node and its aliases that are known to lead to
    3190                 :             :    cgraph_node (i.e. are not overwritable).  */
    3191                 :             : 
    3192                 :             : auto_vec<cgraph_edge *>
    3193                 :      108363 : cgraph_node::collect_callers (void)
    3194                 :             : {
    3195                 :      108363 :   auto_vec<cgraph_edge *> redirect_callers;
    3196                 :      108363 :   call_for_symbol_thunks_and_aliases (collect_callers_of_node_1,
    3197                 :             :                                     &redirect_callers, false);
    3198                 :      108363 :   return redirect_callers;
    3199                 :             : }
    3200                 :             : 
    3201                 :             : 
    3202                 :             : /* Return TRUE if NODE2 a clone of NODE or is equivalent to it.  Return
    3203                 :             :    optimistically true if this cannot be determined.  */
    3204                 :             : 
    3205                 :             : static bool
    3206                 :       18431 : clone_of_p (cgraph_node *node, cgraph_node *node2)
    3207                 :             : {
    3208                 :       18431 :   node = node->ultimate_alias_target ();
    3209                 :       18431 :   node2 = node2->ultimate_alias_target ();
    3210                 :             : 
    3211                 :       18431 :   if (node2->clone_of == node
    3212                 :        1125 :       || node2->former_clone_of == node->decl)
    3213                 :             :     return true;
    3214                 :             : 
    3215                 :        1187 :   if (!node->thunk && !node->former_thunk_p ())
    3216                 :             :     {
    3217                 :             :       while (node2
    3218                 :        3188 :              && node->decl != node2->decl
    3219                 :        5314 :              && node->decl != node2->former_clone_of)
    3220                 :        2125 :         node2 = node2->clone_of;
    3221                 :        1063 :       return node2 != NULL;
    3222                 :             :     }
    3223                 :             : 
    3224                 :             :   /* There are no virtual clones of thunks so check former_clone_of or if we
    3225                 :             :      might have skipped thunks because this adjustments are no longer
    3226                 :             :      necessary.  */
    3227                 :          62 :   while (node->thunk || node->former_thunk_p ())
    3228                 :             :     {
    3229                 :          62 :       if (!thunk_info::get (node)->this_adjusting)
    3230                 :             :         return false;
    3231                 :             :       /* In case of instrumented expanded thunks, which can have multiple calls
    3232                 :             :          in them, we do not know how to continue and just have to be
    3233                 :             :          optimistic.  The same applies if all calls have already been inlined
    3234                 :             :          into the thunk.  */
    3235                 :          62 :       if (!node->callees || node->callees->next_callee)
    3236                 :             :         return true;
    3237                 :          59 :       node = node->callees->callee->ultimate_alias_target ();
    3238                 :             : 
    3239                 :          59 :       clone_info *info = clone_info::get (node2);
    3240                 :          59 :       if (!info || !info->param_adjustments
    3241                 :         118 :           || info->param_adjustments->first_param_intact_p ())
    3242                 :           0 :         return false;
    3243                 :          59 :       if (node2->former_clone_of == node->decl
    3244                 :          59 :           || node2->former_clone_of == node->former_clone_of)
    3245                 :             :         return true;
    3246                 :             : 
    3247                 :             :       cgraph_node *n2 = node2;
    3248                 :           0 :       while (n2 && node->decl != n2->decl)
    3249                 :           0 :         n2 = n2->clone_of;
    3250                 :           0 :       if (n2)
    3251                 :             :         return true;
    3252                 :             :     }
    3253                 :             : 
    3254                 :             :   return false;
    3255                 :             : }
    3256                 :             : 
    3257                 :             : /* Verify edge count and frequency.  */
    3258                 :             : 
    3259                 :             : bool
    3260                 :   186122718 : cgraph_edge::verify_count ()
    3261                 :             : {
    3262                 :   186122718 :   bool error_found = false;
    3263                 :   186122718 :   if (!count.verify ())
    3264                 :             :     {
    3265                 :           0 :       error ("caller edge count invalid");
    3266                 :           0 :       error_found = true;
    3267                 :             :     }
    3268                 :   186122718 :   return error_found;
    3269                 :             : }
    3270                 :             : 
    3271                 :             : /* Switch to THIS_CFUN if needed and print STMT to stderr.  */
    3272                 :             : static void
    3273                 :           0 : cgraph_debug_gimple_stmt (function *this_cfun, gimple *stmt)
    3274                 :             : {
    3275                 :           0 :   bool fndecl_was_null = false;
    3276                 :             :   /* debug_gimple_stmt needs correct cfun */
    3277                 :           0 :   if (cfun != this_cfun)
    3278                 :           0 :     set_cfun (this_cfun);
    3279                 :             :   /* ...and an actual current_function_decl */
    3280                 :           0 :   if (!current_function_decl)
    3281                 :             :     {
    3282                 :           0 :       current_function_decl = this_cfun->decl;
    3283                 :           0 :       fndecl_was_null = true;
    3284                 :             :     }
    3285                 :           0 :   debug_gimple_stmt (stmt);
    3286                 :           0 :   if (fndecl_was_null)
    3287                 :           0 :     current_function_decl = NULL;
    3288                 :           0 : }
    3289                 :             : 
    3290                 :             : /* Verify that call graph edge corresponds to DECL from the associated
    3291                 :             :    statement.  Return true if the verification should fail.  */
    3292                 :             : 
    3293                 :             : bool
    3294                 :    91677258 : cgraph_edge::verify_corresponds_to_fndecl (tree decl)
    3295                 :             : {
    3296                 :    91677258 :   cgraph_node *node;
    3297                 :             : 
    3298                 :    91677258 :   if (!decl || callee->inlined_to)
    3299                 :             :     return false;
    3300                 :    88608108 :   if (symtab->state == LTO_STREAMING)
    3301                 :             :     return false;
    3302                 :    88608108 :   node = cgraph_node::get (decl);
    3303                 :             : 
    3304                 :             :   /* We do not know if a node from a different partition is an alias or what it
    3305                 :             :      aliases and therefore cannot do the former_clone_of check reliably.  When
    3306                 :             :      body_removed is set, we have lost all information about what was alias or
    3307                 :             :      thunk of and also cannot proceed.  */
    3308                 :    88608108 :   if (!node
    3309                 :             :       || node->body_removed
    3310                 :    88515473 :       || node->in_other_partition
    3311                 :    87844620 :       || callee->icf_merged
    3312                 :    87755833 :       || callee->in_other_partition)
    3313                 :             :     return false;
    3314                 :             : 
    3315                 :    87755833 :   node = node->ultimate_alias_target ();
    3316                 :             : 
    3317                 :             :   /* Optimizers can redirect unreachable calls or calls triggering undefined
    3318                 :             :      behavior to __builtin_unreachable or __builtin_unreachable trap.  */
    3319                 :             : 
    3320                 :    87755833 :   if (fndecl_built_in_p (callee->decl, BUILT_IN_UNREACHABLE,
    3321                 :             :                                        BUILT_IN_UNREACHABLE_TRAP))
    3322                 :             :     return false;
    3323                 :             : 
    3324                 :    85716161 :   if (callee->former_clone_of != node->decl
    3325                 :    85715757 :       && (node != callee->ultimate_alias_target ())
    3326                 :    85734592 :       && !clone_of_p (node, callee))
    3327                 :             :     return true;
    3328                 :             :   else
    3329                 :    85716161 :     return false;
    3330                 :             : }
    3331                 :             : 
    3332                 :             : /* Disable warnings about missing quoting in GCC diagnostics for
    3333                 :             :    the verification errors.  Their format strings don't follow GCC
    3334                 :             :    diagnostic conventions and the calls are ultimately followed by
    3335                 :             :    one to internal_error.  */
    3336                 :             : #if __GNUC__ >= 10
    3337                 :             : #  pragma GCC diagnostic push
    3338                 :             : #  pragma GCC diagnostic ignored "-Wformat-diag"
    3339                 :             : #endif
    3340                 :             : 
    3341                 :             : /* Verify consistency of speculative call in NODE corresponding to STMT
    3342                 :             :    and LTO_STMT_UID.  If INDIRECT is set, assume that it is the indirect
    3343                 :             :    edge of call sequence. Return true if error is found.
    3344                 :             : 
    3345                 :             :    This function is called to every component of indirect call (direct edges,
    3346                 :             :    indirect edge and refs).  To save duplicated work, do full testing only
    3347                 :             :    in that case.  */
    3348                 :             : static bool
    3349                 :      164833 : verify_speculative_call (struct cgraph_node *node, gimple *stmt,
    3350                 :             :                          unsigned int lto_stmt_uid,
    3351                 :             :                          struct cgraph_edge *indirect)
    3352                 :             : {
    3353                 :      164833 :   if (indirect == NULL)
    3354                 :             :     {
    3355                 :      142460 :       for (indirect = node->indirect_calls; indirect;
    3356                 :       32556 :            indirect = indirect->next_callee)
    3357                 :      142460 :         if (indirect->call_stmt == stmt
    3358                 :      110038 :             && indirect->lto_stmt_uid == lto_stmt_uid)
    3359                 :             :           break;
    3360                 :      109904 :       if (!indirect)
    3361                 :             :         {
    3362                 :           0 :           error ("missing indirect call in speculative call sequence");
    3363                 :           0 :           return true;
    3364                 :             :         }
    3365                 :      109904 :       if (!indirect->speculative)
    3366                 :             :         {
    3367                 :           0 :           error ("indirect call in speculative call sequence has no "
    3368                 :             :                  "speculative flag");
    3369                 :           0 :           return true;
    3370                 :             :         }
    3371                 :             :       return false;
    3372                 :             :     }
    3373                 :             : 
    3374                 :             :   /* Maximal number of targets.  We probably will never want to have more than
    3375                 :             :      this.  */
    3376                 :             :   const unsigned int num = 256;
    3377                 :             :   cgraph_edge *direct_calls[num];
    3378                 :             :   ipa_ref *refs[num];
    3379                 :             : 
    3380                 :    14116753 :   for (unsigned int i = 0; i < num; i++)
    3381                 :             :     {
    3382                 :    14061824 :       direct_calls[i] = NULL;
    3383                 :    14061824 :       refs[i] = NULL;
    3384                 :             :     }
    3385                 :             : 
    3386                 :       54929 :   cgraph_edge *first_call = NULL;
    3387                 :       54929 :   cgraph_edge *prev_call = NULL;
    3388                 :             : 
    3389                 :      279554 :   for (cgraph_edge *direct = node->callees; direct;
    3390                 :      224625 :        direct = direct->next_callee)
    3391                 :      224625 :     if (direct->call_stmt == stmt && direct->lto_stmt_uid == lto_stmt_uid)
    3392                 :             :       {
    3393                 :       54952 :         if (!first_call)
    3394                 :       54929 :           first_call = direct;
    3395                 :       54952 :         if (prev_call && direct != prev_call->next_callee)
    3396                 :             :           {
    3397                 :           0 :             error ("speculative edges are not adjacent");
    3398                 :           0 :             return true;
    3399                 :             :           }
    3400                 :       54952 :         prev_call = direct;
    3401                 :       54952 :         if (!direct->speculative)
    3402                 :             :           {
    3403                 :           0 :             error ("direct call to %s in speculative call sequence has no "
    3404                 :           0 :                    "speculative flag", direct->callee->dump_name ());
    3405                 :           0 :             return true;
    3406                 :             :           }
    3407                 :       54952 :         if (direct->speculative_id >= num)
    3408                 :             :           {
    3409                 :           0 :             error ("direct call to %s in speculative call sequence has "
    3410                 :             :                    "speculative_id %i out of range",
    3411                 :           0 :                    direct->callee->dump_name (), direct->speculative_id);
    3412                 :           0 :             return true;
    3413                 :             :           }
    3414                 :       54952 :         if (direct_calls[direct->speculative_id])
    3415                 :             :           {
    3416                 :           0 :             error ("duplicate direct call to %s in speculative call sequence "
    3417                 :             :                    "with speculative_id %i",
    3418                 :           0 :                    direct->callee->dump_name (), direct->speculative_id);
    3419                 :           0 :             return true;
    3420                 :             :           }
    3421                 :       54952 :         direct_calls[direct->speculative_id] = direct;
    3422                 :             :       }
    3423                 :             : 
    3424                 :       54929 :   if (first_call->call_stmt
    3425                 :       54929 :       && first_call != node->get_edge (first_call->call_stmt))
    3426                 :             :     {
    3427                 :           0 :       error ("call stmt hash does not point to first direct edge of "
    3428                 :             :              "speculative call sequence");
    3429                 :           0 :       return true;
    3430                 :             :     }
    3431                 :             : 
    3432                 :             :   ipa_ref *ref;
    3433                 :      157794 :   for (int i = 0; node->iterate_reference (i, ref); i++)
    3434                 :      102865 :     if (ref->speculative
    3435                 :       77206 :         && ref->stmt == stmt && ref->lto_stmt_uid == lto_stmt_uid)
    3436                 :             :       {
    3437                 :       54952 :         if (ref->speculative_id >= num)
    3438                 :             :           {
    3439                 :           0 :             error ("direct call to %s in speculative call sequence has "
    3440                 :             :                    "speculative_id %i out of range",
    3441                 :           0 :                    ref->referred->dump_name (), ref->speculative_id);
    3442                 :           0 :             return true;
    3443                 :             :           }
    3444                 :       54952 :         if (refs[ref->speculative_id])
    3445                 :             :           {
    3446                 :           0 :             error ("duplicate reference %s in speculative call sequence "
    3447                 :             :                    "with speculative_id %i",
    3448                 :           0 :                    ref->referred->dump_name (), ref->speculative_id);
    3449                 :           0 :             return true;
    3450                 :             :           }
    3451                 :       54952 :         refs[ref->speculative_id] = ref;
    3452                 :             :       }
    3453                 :             : 
    3454                 :             :   int num_targets = 0;
    3455                 :    14116753 :   for (unsigned int i = 0 ; i < num ; i++)
    3456                 :             :     {
    3457                 :    14061824 :       if (refs[i] && !direct_calls[i])
    3458                 :             :         {
    3459                 :           0 :           error ("missing direct call for speculation %i", i);
    3460                 :           0 :           return true;
    3461                 :             :         }
    3462                 :    14061824 :       if (!refs[i] && direct_calls[i])
    3463                 :             :         {
    3464                 :           0 :           error ("missing ref for speculation %i", i);
    3465                 :           0 :           return true;
    3466                 :             :         }
    3467                 :    14061824 :       if (refs[i] != NULL)
    3468                 :       54952 :         num_targets++;
    3469                 :             :     }
    3470                 :             : 
    3471                 :       54929 :   if (num_targets != indirect->num_speculative_call_targets_p ())
    3472                 :             :     {
    3473                 :           0 :       error ("number of speculative targets %i mismatched with "
    3474                 :             :              "num_speculative_call_targets %i",
    3475                 :             :              num_targets,
    3476                 :             :              indirect->num_speculative_call_targets_p ());
    3477                 :           0 :       return true;
    3478                 :             :     }
    3479                 :             :   return false;
    3480                 :             : }
    3481                 :             : 
    3482                 :             : /* Verify cgraph nodes of given cgraph node.  */
    3483                 :             : DEBUG_FUNCTION void
    3484                 :    49196128 : cgraph_node::verify_node (void)
    3485                 :             : {
    3486                 :    49196128 :   cgraph_edge *e;
    3487                 :    49196128 :   function *this_cfun = DECL_STRUCT_FUNCTION (decl);
    3488                 :    49196128 :   basic_block this_block;
    3489                 :    49196128 :   gimple_stmt_iterator gsi;
    3490                 :    49196128 :   bool error_found = false;
    3491                 :    49196128 :   int i;
    3492                 :    49196128 :   ipa_ref *ref = NULL;
    3493                 :             : 
    3494                 :    49196128 :   if (seen_error ())
    3495                 :    49196128 :     return;
    3496                 :             : 
    3497                 :    49196128 :   timevar_push (TV_CGRAPH_VERIFY);
    3498                 :    49196128 :   error_found |= verify_base ();
    3499                 :   148810914 :   for (e = callees; e; e = e->next_callee)
    3500                 :    99614786 :     if (e->aux)
    3501                 :             :       {
    3502                 :           0 :         error ("aux field set for edge %s->%s",
    3503                 :           0 :                identifier_to_locale (e->caller->name ()),
    3504                 :           0 :                identifier_to_locale (e->callee->name ()));
    3505                 :           0 :         error_found = true;
    3506                 :             :       }
    3507                 :    49196128 :   if (!count.verify ())
    3508                 :             :     {
    3509                 :           0 :       error ("cgraph count invalid");
    3510                 :           0 :       error_found = true;
    3511                 :             :     }
    3512                 :    49196128 :   if (inlined_to && same_comdat_group)
    3513                 :             :     {
    3514                 :           0 :       error ("inline clone in same comdat group list");
    3515                 :           0 :       error_found = true;
    3516                 :             :     }
    3517                 :    49196128 :   if (inlined_to && !count.compatible_p (inlined_to->count))
    3518                 :             :     {
    3519                 :           0 :       error ("inline clone count is not compatible");
    3520                 :           0 :       count.debug ();
    3521                 :           0 :       inlined_to->count.debug ();
    3522                 :           0 :       error_found = true;
    3523                 :             :     }
    3524                 :    49196128 :   if (tp_first_run < 0)
    3525                 :             :     {
    3526                 :           0 :       error ("tp_first_run must be non-negative");
    3527                 :           0 :       error_found = true;
    3528                 :             :     }
    3529                 :    49196128 :   if (!definition && !in_other_partition && local)
    3530                 :             :     {
    3531                 :           0 :       error ("local symbols must be defined");
    3532                 :           0 :       error_found = true;
    3533                 :             :     }
    3534                 :    49196128 :   if (inlined_to && externally_visible)
    3535                 :             :     {
    3536                 :           0 :       error ("externally visible inline clone");
    3537                 :           0 :       error_found = true;
    3538                 :             :     }
    3539                 :    49196128 :   if (inlined_to && address_taken)
    3540                 :             :     {
    3541                 :           0 :       error ("inline clone with address taken");
    3542                 :           0 :       error_found = true;
    3543                 :             :     }
    3544                 :    49196128 :   if (inlined_to && force_output)
    3545                 :             :     {
    3546                 :           0 :       error ("inline clone is forced to output");
    3547                 :           0 :       error_found = true;
    3548                 :             :     }
    3549                 :    49196128 :   if (symtab->state != LTO_STREAMING)
    3550                 :             :     {
    3551                 :    49071717 :       if (calls_comdat_local && !same_comdat_group)
    3552                 :             :         {
    3553                 :           0 :           error ("calls_comdat_local is set outside of a comdat group");
    3554                 :           0 :           error_found = true;
    3555                 :             :         }
    3556                 :    49071717 :       if (!inlined_to && calls_comdat_local != check_calls_comdat_local_p ())
    3557                 :             :         {
    3558                 :           0 :           error ("invalid calls_comdat_local flag");
    3559                 :           0 :           error_found = true;
    3560                 :             :         }
    3561                 :             :     }
    3562                 :    49196128 :   if (DECL_IS_MALLOC (decl)
    3563                 :    49196128 :       && !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
    3564                 :             :     {
    3565                 :           0 :       error ("malloc attribute should be used for a function that "
    3566                 :             :              "returns a pointer");
    3567                 :           0 :       error_found = true;
    3568                 :             :     }
    3569                 :    49196128 :   if (definition
    3570                 :    49196128 :       && externally_visible
    3571                 :             :       /* For aliases in lto1 free_lang_data doesn't guarantee preservation
    3572                 :             :          of opt_for_fn (decl, flag_semantic_interposition).  See PR105399.  */
    3573                 :    17721744 :       && (!alias || !in_lto_p)
    3574                 :    49196128 :       && semantic_interposition
    3575                 :    17718861 :          != opt_for_fn (decl, flag_semantic_interposition))
    3576                 :             :     {
    3577                 :           0 :       error ("semantic interposition mismatch");
    3578                 :           0 :       error_found = true;
    3579                 :             :     }
    3580                 :    51465067 :   for (e = indirect_calls; e; e = e->next_callee)
    3581                 :             :     {
    3582                 :     2268939 :       if (e->aux)
    3583                 :             :         {
    3584                 :           0 :           error ("aux field set for indirect edge from %s",
    3585                 :           0 :                  identifier_to_locale (e->caller->name ()));
    3586                 :           0 :           error_found = true;
    3587                 :             :         }
    3588                 :     2268939 :       if (!e->count.compatible_p (count))
    3589                 :             :         {
    3590                 :           0 :           error ("edge count is not compatible with function count");
    3591                 :           0 :           e->count.debug ();
    3592                 :           0 :           count.debug ();
    3593                 :           0 :           error_found = true;
    3594                 :             :         }
    3595                 :     2268939 :       if (!e->indirect_unknown_callee
    3596                 :     2268939 :           || !e->indirect_info)
    3597                 :             :         {
    3598                 :           0 :           error ("An indirect edge from %s is not marked as indirect or has "
    3599                 :             :                  "associated indirect_info, the corresponding statement is: ",
    3600                 :           0 :                  identifier_to_locale (e->caller->name ()));
    3601                 :           0 :           cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
    3602                 :           0 :           error_found = true;
    3603                 :             :         }
    3604                 :     2268939 :       if (e->call_stmt && e->lto_stmt_uid)
    3605                 :             :         {
    3606                 :           0 :           error ("edge has both call_stmt and lto_stmt_uid set");
    3607                 :           0 :           error_found = true;
    3608                 :             :         }
    3609                 :             :     }
    3610                 :    49196128 :   bool check_comdat = comdat_local_p ();
    3611                 :   133435121 :   for (e = callers; e; e = e->next_caller)
    3612                 :             :     {
    3613                 :    84238993 :       if (e->verify_count ())
    3614                 :           0 :         error_found = true;
    3615                 :    84238993 :       if (check_comdat
    3616                 :    84238993 :           && !in_same_comdat_group_p (e->caller))
    3617                 :             :         {
    3618                 :           0 :           error ("comdat-local function called by %s outside its comdat",
    3619                 :             :                  identifier_to_locale (e->caller->name ()));
    3620                 :           0 :           error_found = true;
    3621                 :             :         }
    3622                 :    84238993 :       if (!e->inline_failed)
    3623                 :             :         {
    3624                 :     6794757 :           if (inlined_to
    3625                 :     6794757 :               != (e->caller->inlined_to
    3626                 :     6794757 :                   ? e->caller->inlined_to : e->caller))
    3627                 :             :             {
    3628                 :           0 :               error ("inlined_to pointer is wrong");
    3629                 :           0 :               error_found = true;
    3630                 :             :             }
    3631                 :     6794757 :           if (callers->next_caller)
    3632                 :             :             {
    3633                 :           0 :               error ("multiple inline callers");
    3634                 :           0 :               error_found = true;
    3635                 :             :             }
    3636                 :             :         }
    3637                 :             :       else
    3638                 :    77444236 :         if (inlined_to)
    3639                 :             :           {
    3640                 :           0 :             error ("inlined_to pointer set for noninline callers");
    3641                 :           0 :             error_found = true;
    3642                 :             :           }
    3643                 :             :     }
    3644                 :   148810914 :   for (e = callees; e; e = e->next_callee)
    3645                 :             :     {
    3646                 :    99614786 :       if (e->verify_count ())
    3647                 :           0 :         error_found = true;
    3648                 :    99614786 :       if (!e->count.compatible_p (count))
    3649                 :             :         {
    3650                 :           0 :           error ("edge count is not compatible with function count");
    3651                 :           0 :           e->count.debug ();
    3652                 :           0 :           count.debug ();
    3653                 :           0 :           error_found = true;
    3654                 :             :         }
    3655                 :    99614786 :       if (gimple_has_body_p (e->caller->decl)
    3656                 :    93328849 :           && !e->caller->inlined_to
    3657                 :    86057816 :           && !e->speculative
    3658                 :             :           /* Optimized out calls are redirected to __builtin_unreachable.  */
    3659                 :    86040063 :           && (e->count.nonzero_p ()
    3660                 :    49312788 :               || ! e->callee->decl
    3661                 :    49312788 :               || !fndecl_built_in_p (e->callee->decl, BUILT_IN_UNREACHABLE,
    3662                 :             :                                      BUILT_IN_UNREACHABLE_TRAP))
    3663                 :             :           && count
    3664                 :    84800409 :               == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl))->count
    3665                 :   184407425 :           && (!e->count.ipa_p ()
    3666                 :    38621396 :               && e->count.differs_from_p (gimple_bb (e->call_stmt)->count)))
    3667                 :             :         {
    3668                 :           0 :           error ("caller edge count does not match BB count");
    3669                 :           0 :           fprintf (stderr, "edge count: ");
    3670                 :           0 :           e->count.dump (stderr);
    3671                 :           0 :           fprintf (stderr, "\n bb count: ");
    3672                 :           0 :           gimple_bb (e->call_stmt)->count.dump (stderr);
    3673                 :           0 :           fprintf (stderr, "\n");
    3674                 :           0 :           error_found = true;
    3675                 :             :         }
    3676                 :    99614786 :       if (e->call_stmt && e->lto_stmt_uid)
    3677                 :             :         {
    3678                 :           0 :           error ("edge has both call_stmt and lto_stmt_uid set");
    3679                 :           0 :           error_found = true;
    3680                 :             :         }
    3681                 :    99614786 :       if (e->speculative
    3682                 :    99614786 :           && verify_speculative_call (e->caller, e->call_stmt, e->lto_stmt_uid,
    3683                 :             :                                       NULL))
    3684                 :             :         error_found = true;
    3685                 :             :     }
    3686                 :    51465067 :   for (e = indirect_calls; e; e = e->next_callee)
    3687                 :             :     {
    3688                 :     2268939 :       if (e->verify_count ())
    3689                 :           0 :         error_found = true;
    3690                 :     2268939 :       if (gimple_has_body_p (e->caller->decl)
    3691                 :     2220765 :           && !e->caller->inlined_to
    3692                 :     2000395 :           && !e->speculative
    3693                 :     1982648 :           && e->count.ipa_p ()
    3694                 :             :           && count
    3695                 :      730930 :               == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl))->count
    3696                 :     2999867 :           && (!e->count.ipa_p ()
    3697                 :           0 :               && e->count.differs_from_p (gimple_bb (e->call_stmt)->count)))
    3698                 :             :         {
    3699                 :           0 :           error ("indirect call count does not match BB count");
    3700                 :           0 :           fprintf (stderr, "edge count: ");
    3701                 :           0 :           e->count.dump (stderr);
    3702                 :           0 :           fprintf (stderr, "\n bb count: ");
    3703                 :           0 :           gimple_bb (e->call_stmt)->count.dump (stderr);
    3704                 :           0 :           fprintf (stderr, "\n");
    3705                 :           0 :           error_found = true;
    3706                 :             :         }
    3707                 :     2268939 :       if (e->speculative
    3708                 :     2268939 :           && verify_speculative_call (e->caller, e->call_stmt, e->lto_stmt_uid,
    3709                 :             :                                       e))
    3710                 :             :         error_found = true;
    3711                 :             :     }
    3712                 :   116718364 :   for (i = 0; iterate_reference (i, ref); i++)
    3713                 :             :     {
    3714                 :    67522236 :       if (ref->stmt && ref->lto_stmt_uid)
    3715                 :             :         {
    3716                 :           0 :           error ("reference has both stmt and lto_stmt_uid set");
    3717                 :           0 :           error_found = true;
    3718                 :             :         }
    3719                 :    67522236 :       if (ref->speculative
    3720                 :    67522236 :           && verify_speculative_call (this, ref->stmt,
    3721                 :             :                                       ref->lto_stmt_uid, NULL))
    3722                 :             :         error_found = true;
    3723                 :             :     }
    3724                 :             : 
    3725                 :    49196128 :   if (!callers && inlined_to)
    3726                 :             :     {
    3727                 :           0 :       error ("inlined_to pointer is set but no predecessors found");
    3728                 :           0 :       error_found = true;
    3729                 :             :     }
    3730                 :    49196128 :   if (inlined_to == this)
    3731                 :             :     {
    3732                 :           0 :       error ("inlined_to pointer refers to itself");
    3733                 :           0 :       error_found = true;
    3734                 :             :     }
    3735                 :             : 
    3736                 :    49196128 :   if (clone_of)
    3737                 :             :     {
    3738                 :     4856160 :       cgraph_node *first_clone = clone_of->clones;
    3739                 :     4856160 :       if (first_clone != this)
    3740                 :             :         {
    3741                 :     2469651 :           if (prev_sibling_clone->clone_of != clone_of)
    3742                 :             :             {
    3743                 :           0 :               error ("cgraph_node has wrong clone_of");
    3744                 :           0 :               error_found = true;
    3745                 :             :             }
    3746                 :             :         }
    3747                 :             :     }
    3748                 :    49196128 :   if (clones)
    3749                 :             :     {
    3750                 :             :       cgraph_node *n;
    3751                 :     6895094 :       for (n = clones; n; n = n->next_sibling_clone)
    3752                 :     5551824 :         if (n->clone_of != this)
    3753                 :             :           break;
    3754                 :     1343270 :       if (n)
    3755                 :             :         {
    3756                 :           0 :           error ("cgraph_node has wrong clone list");
    3757                 :           0 :           error_found = true;
    3758                 :             :         }
    3759                 :             :     }
    3760                 :    49196128 :   if ((prev_sibling_clone || next_sibling_clone) && !clone_of)
    3761                 :             :     {
    3762                 :           0 :        error ("cgraph_node is in clone list but it is not clone");
    3763                 :           0 :        error_found = true;
    3764                 :             :     }
    3765                 :    49196128 :   if (!prev_sibling_clone && clone_of && clone_of->clones != this)
    3766                 :             :     {
    3767                 :           0 :       error ("cgraph_node has wrong prev_clone pointer");
    3768                 :           0 :       error_found = true;
    3769                 :             :     }
    3770                 :    49196128 :   if (prev_sibling_clone && prev_sibling_clone->next_sibling_clone != this)
    3771                 :             :     {
    3772                 :           0 :       error ("double linked list of clones corrupted");
    3773                 :           0 :       error_found = true;
    3774                 :             :     }
    3775                 :             : 
    3776                 :    49196128 :   if (analyzed && alias)
    3777                 :             :     {
    3778                 :     1374920 :       bool ref_found = false;
    3779                 :     1374920 :       int i;
    3780                 :     1374920 :       ipa_ref *ref = NULL;
    3781                 :             : 
    3782                 :     1374920 :       if (callees)
    3783                 :             :         {
    3784                 :           0 :           error ("Alias has call edges");
    3785                 :           0 :           error_found = true;
    3786                 :             :         }
    3787                 :     2749840 :       for (i = 0; iterate_reference (i, ref); i++)
    3788                 :     1374920 :         if (ref->use != IPA_REF_ALIAS)
    3789                 :             :           {
    3790                 :           0 :             error ("Alias has non-alias reference");
    3791                 :           0 :             error_found = true;
    3792                 :             :           }
    3793                 :     1374920 :         else if (ref_found)
    3794                 :             :           {
    3795                 :           0 :             error ("Alias has more than one alias reference");
    3796                 :           0 :             error_found = true;
    3797                 :             :           }
    3798                 :             :         else
    3799                 :             :           ref_found = true;
    3800                 :     1374920 :       if (!ref_found)
    3801                 :             :         {
    3802                 :           0 :           error ("Analyzed alias has no reference");
    3803                 :           0 :           error_found = true;
    3804                 :             :         }
    3805                 :             :     }
    3806                 :             : 
    3807                 :    49196128 :   if (analyzed && thunk)
    3808                 :             :     {
    3809                 :       22182 :       if (!callees)
    3810                 :             :         {
    3811                 :           0 :           error ("No edge out of thunk node");
    3812                 :           0 :           error_found = true;
    3813                 :             :         }
    3814                 :       22182 :       else if (callees->next_callee)
    3815                 :             :         {
    3816                 :           0 :           error ("More than one edge out of thunk node");
    3817                 :           0 :           error_found = true;
    3818                 :             :         }
    3819                 :       22182 :       if (gimple_has_body_p (decl) && !inlined_to)
    3820                 :             :         {
    3821                 :           0 :           error ("Thunk is not supposed to have body");
    3822                 :           0 :           error_found = true;
    3823                 :             :         }
    3824                 :             :     }
    3825                 :    32563398 :   else if (analyzed && gimple_has_body_p (decl)
    3826                 :    27952417 :            && !TREE_ASM_WRITTEN (decl)
    3827                 :    27952417 :            && (!DECL_EXTERNAL (decl) || inlined_to)
    3828                 :    76250746 :            && !flag_wpa)
    3829                 :             :     {
    3830                 :    27050801 :       if ((this_cfun->curr_properties & PROP_assumptions_done) != 0)
    3831                 :             :         ;
    3832                 :    27050693 :       else if (this_cfun->cfg)
    3833                 :             :         {
    3834                 :    27050693 :           hash_set<gimple *> stmts;
    3835                 :             : 
    3836                 :             :           /* Reach the trees by walking over the CFG, and note the
    3837                 :             :              enclosing basic-blocks in the call edges.  */
    3838                 :   229334008 :           FOR_EACH_BB_FN (this_block, this_cfun)
    3839                 :             :             {
    3840                 :   202283315 :               for (gsi = gsi_start_phis (this_block);
    3841                 :   245151092 :                    !gsi_end_p (gsi); gsi_next (&gsi))
    3842                 :    42867777 :                 stmts.add (gsi_stmt (gsi));
    3843                 :   404566630 :               for (gsi = gsi_start_bb (this_block);
    3844                 :  1158538518 :                    !gsi_end_p (gsi);
    3845                 :   956255203 :                    gsi_next (&gsi))
    3846                 :             :                 {
    3847                 :   956255203 :                   gimple *stmt = gsi_stmt (gsi);
    3848                 :   956255203 :                   stmts.add (stmt);
    3849                 :   956255203 :                   if (is_gimple_call (stmt))
    3850                 :             :                     {
    3851                 :    96992892 :                       cgraph_edge *e = get_edge (stmt);
    3852                 :    96992892 :                       tree decl = gimple_call_fndecl (stmt);
    3853                 :    96992892 :                       if (e)
    3854                 :             :                         {
    3855                 :    93822269 :                           if (e->aux)
    3856                 :             :                             {
    3857                 :           0 :                               error ("shared call_stmt:");
    3858                 :           0 :                               cgraph_debug_gimple_stmt (this_cfun, stmt);
    3859                 :           0 :                               error_found = true;
    3860                 :             :                             }
    3861                 :    93822269 :                           if (!e->indirect_unknown_callee)
    3862                 :             :                             {
    3863                 :    91677258 :                               if (e->verify_corresponds_to_fndecl (decl))
    3864                 :             :                                 {
    3865                 :           0 :                                   error ("edge points to wrong declaration:");
    3866                 :           0 :                                   debug_tree (e->callee->decl);
    3867                 :           0 :                                   fprintf (stderr," Instead of:");
    3868                 :           0 :                                   debug_tree (decl);
    3869                 :           0 :                                   error_found = true;
    3870                 :             :                                 }
    3871                 :             :                             }
    3872                 :     2145011 :                           else if (decl)
    3873                 :             :                             {
    3874                 :           0 :                               error ("an indirect edge with unknown callee "
    3875                 :             :                                      "corresponding to a call_stmt with "
    3876                 :             :                                      "a known declaration:");
    3877                 :           0 :                               error_found = true;
    3878                 :           0 :                               cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
    3879                 :             :                             }
    3880                 :    93822269 :                           e->aux = (void *)1;
    3881                 :             :                         }
    3882                 :     3170623 :                       else if (decl)
    3883                 :             :                         {
    3884                 :           0 :                           error ("missing callgraph edge for call stmt:");
    3885                 :           0 :                           cgraph_debug_gimple_stmt (this_cfun, stmt);
    3886                 :           0 :                           error_found = true;
    3887                 :             :                         }
    3888                 :             :                     }
    3889                 :             :                 }
    3890                 :             :               }
    3891                 :    98139654 :             for (i = 0; iterate_reference (i, ref); i++)
    3892                 :    62271647 :               if (ref->stmt && !stmts.contains (ref->stmt))
    3893                 :             :                 {
    3894                 :           0 :                   error ("reference to dead statement");
    3895                 :           0 :                   cgraph_debug_gimple_stmt (this_cfun, ref->stmt);
    3896                 :           0 :                   error_found = true;
    3897                 :             :                 }
    3898                 :    27050693 :         }
    3899                 :             :       else
    3900                 :             :         /* No CFG available?!  */
    3901                 :           0 :         gcc_unreachable ();
    3902                 :             : 
    3903                 :   118728066 :       for (e = callees; e; e = e->next_callee)
    3904                 :             :         {
    3905                 :    91677265 :           if (!e->aux && !e->speculative)
    3906                 :             :             {
    3907                 :           0 :               error ("edge %s->%s has no corresponding call_stmt",
    3908                 :           0 :                      identifier_to_locale (e->caller->name ()),
    3909                 :           0 :                      identifier_to_locale (e->callee->name ()));
    3910                 :           0 :               cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
    3911                 :           0 :               error_found = true;
    3912                 :             :             }
    3913                 :    91677265 :           e->aux = 0;
    3914                 :             :         }
    3915                 :    29247684 :       for (e = indirect_calls; e; e = e->next_callee)
    3916                 :             :         {
    3917                 :     2196883 :           if (!e->aux && !e->speculative)
    3918                 :             :             {
    3919                 :           0 :               error ("an indirect edge from %s has no corresponding call_stmt",
    3920                 :           0 :                      identifier_to_locale (e->caller->name ()));
    3921                 :           0 :               cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
    3922                 :           0 :               error_found = true;
    3923                 :             :             }
    3924                 :     2196883 :           e->aux = 0;
    3925                 :             :         }
    3926                 :             :     }
    3927                 :             : 
    3928                 :    49196128 :   if (nested_function_info *info = nested_function_info::get (this))
    3929                 :             :     {
    3930                 :           0 :       if (info->nested != NULL)
    3931                 :             :         {
    3932                 :           0 :           for (cgraph_node *n = info->nested; n != NULL;
    3933                 :           0 :                n = next_nested_function (n))
    3934                 :             :             {
    3935                 :           0 :               nested_function_info *ninfo = nested_function_info::get (n);
    3936                 :           0 :               if (ninfo->origin == NULL)
    3937                 :             :                 {
    3938                 :           0 :                   error ("missing origin for a node in a nested list");
    3939                 :           0 :                   error_found = true;
    3940                 :             :                 }
    3941                 :           0 :               else if (ninfo->origin != this)
    3942                 :             :                 {
    3943                 :           0 :                   error ("origin points to a different parent");
    3944                 :           0 :                   error_found = true;
    3945                 :           0 :                   break;
    3946                 :             :                 }
    3947                 :             :             }
    3948                 :             :         }
    3949                 :           0 :       if (info->next_nested != NULL && info->origin == NULL)
    3950                 :             :         {
    3951                 :           0 :           error ("missing origin for a node in a nested list");
    3952                 :           0 :           error_found = true;
    3953                 :             :         }
    3954                 :             :     }
    3955                 :             : 
    3956                 :    49196128 :   if (error_found)
    3957                 :             :     {
    3958                 :           0 :       dump (stderr);
    3959                 :           0 :       internal_error ("verify_cgraph_node failed");
    3960                 :             :     }
    3961                 :    49196128 :   timevar_pop (TV_CGRAPH_VERIFY);
    3962                 :             : }
    3963                 :             : 
    3964                 :             : /* Verify whole cgraph structure.  */
    3965                 :             : DEBUG_FUNCTION void
    3966                 :         878 : cgraph_node::verify_cgraph_nodes (void)
    3967                 :             : {
    3968                 :         878 :   cgraph_node *node;
    3969                 :             : 
    3970                 :         878 :   if (seen_error ())
    3971                 :             :     return;
    3972                 :             : 
    3973                 :       10492 :   FOR_EACH_FUNCTION (node)
    3974                 :        4392 :     node->verify ();
    3975                 :             : }
    3976                 :             : 
    3977                 :             : #if __GNUC__ >= 10
    3978                 :             : #  pragma GCC diagnostic pop
    3979                 :             : #endif
    3980                 :             : 
    3981                 :             : /* Walk the alias chain to return the function cgraph_node is alias of.
    3982                 :             :    Walk through thunks, too.
    3983                 :             :    When AVAILABILITY is non-NULL, get minimal availability in the chain.
    3984                 :             :    When REF is non-NULL, assume that reference happens in symbol REF
    3985                 :             :    when determining the availability.  */
    3986                 :             : 
    3987                 :             : cgraph_node *
    3988                 :   125812978 : cgraph_node::function_symbol (enum availability *availability,
    3989                 :             :                               struct symtab_node *ref)
    3990                 :             : {
    3991                 :   125812978 :   cgraph_node *node = ultimate_alias_target (availability, ref);
    3992                 :             : 
    3993                 :   251630739 :   while (node->thunk)
    3994                 :             :     {
    3995                 :        4783 :       enum availability a;
    3996                 :             : 
    3997                 :        4783 :       ref = node;
    3998                 :        4783 :       node = node->callees->callee;
    3999                 :        8647 :       node = node->ultimate_alias_target (availability ? &a : NULL, ref);
    4000                 :        4783 :       if (availability && a < *availability)
    4001                 :         158 :         *availability = a;
    4002                 :             :     }
    4003                 :   125812978 :   return node;
    4004                 :             : }
    4005                 :             : 
    4006                 :             : /* Walk the alias chain to return the function cgraph_node is alias of.
    4007                 :             :    Walk through non virtual thunks, too.  Thus we return either a function
    4008                 :             :    or a virtual thunk node.
    4009                 :             :    When AVAILABILITY is non-NULL, get minimal availability in the chain.
    4010                 :             :    When REF is non-NULL, assume that reference happens in symbol REF
    4011                 :             :    when determining the availability.  */
    4012                 :             : 
    4013                 :             : cgraph_node *
    4014                 :    31353560 : cgraph_node::function_or_virtual_thunk_symbol
    4015                 :             :                                 (enum availability *availability,
    4016                 :             :                                  struct symtab_node *ref)
    4017                 :             : {
    4018                 :    31353560 :   cgraph_node *node = ultimate_alias_target (availability, ref);
    4019                 :             : 
    4020                 :    62708430 :   while (node->thunk && !thunk_info::get (node)->virtual_offset_p)
    4021                 :             :     {
    4022                 :        1310 :       enum availability a;
    4023                 :             : 
    4024                 :        1310 :       ref = node;
    4025                 :        1310 :       node = node->callees->callee;
    4026                 :        1310 :       node = node->ultimate_alias_target (availability ? &a : NULL, ref);
    4027                 :        1310 :       if (availability && a < *availability)
    4028                 :         647 :         *availability = a;
    4029                 :             :     }
    4030                 :    31353560 :   return node;
    4031                 :             : }
    4032                 :             : 
    4033                 :             : /* When doing LTO, read cgraph_node's body from disk if it is not already
    4034                 :             :    present.  Also perform any necessary clone materializations.  */
    4035                 :             : 
    4036                 :             : bool
    4037                 :     5404509 : cgraph_node::get_untransformed_body ()
    4038                 :             : {
    4039                 :     5404509 :   lto_file_decl_data *file_data;
    4040                 :     5404509 :   const char *data, *name;
    4041                 :     5404509 :   size_t len;
    4042                 :     5404509 :   tree decl = this->decl;
    4043                 :             : 
    4044                 :             :   /* See if there is clone to be materialized.
    4045                 :             :      (inline clones does not need materialization, but we can be seeing
    4046                 :             :       an inline clone of real clone).  */
    4047                 :     5404509 :   cgraph_node *p = this;
    4048                 :     7578215 :   for (cgraph_node *c = clone_of; c; c = c->clone_of)
    4049                 :             :     {
    4050                 :     2173706 :       if (c->decl != decl)
    4051                 :      106186 :         p->materialize_clone ();
    4052                 :     2173706 :       p = c;
    4053                 :             :     }
    4054                 :             : 
    4055                 :             :   /* Check if body is already there.  Either we have gimple body or
    4056                 :             :      the function is thunk and in that case we set DECL_ARGUMENTS.  */
    4057                 :     5404509 :   if (DECL_ARGUMENTS (decl) || gimple_has_body_p (decl))
    4058                 :     5304852 :     return false;
    4059                 :             : 
    4060                 :      199314 :   gcc_assert (in_lto_p && !DECL_RESULT (decl));
    4061                 :             : 
    4062                 :       99657 :   timevar_push (TV_IPA_LTO_GIMPLE_IN);
    4063                 :             : 
    4064                 :       99657 :   file_data = lto_file_data;
    4065                 :       99657 :   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
    4066                 :             : 
    4067                 :             :   /* We may have renamed the declaration, e.g., a static function.  */
    4068                 :       99657 :   name = lto_get_decl_name_mapping (file_data, name);
    4069                 :       99657 :   struct lto_in_decl_state *decl_state
    4070                 :       99657 :          = lto_get_function_in_decl_state (file_data, decl);
    4071                 :             : 
    4072                 :       99657 :   cgraph_node *origin = this;
    4073                 :      199455 :   while (origin->clone_of)
    4074                 :             :     origin = origin->clone_of;
    4075                 :             : 
    4076                 :       99657 :   int stream_order = origin->order - file_data->order_base;
    4077                 :      199314 :   data = lto_get_section_data (file_data, LTO_section_function_body,
    4078                 :             :                                name, stream_order, &len,
    4079                 :       99657 :                                decl_state->compressed);
    4080                 :       99657 :   if (!data)
    4081                 :           0 :     fatal_error (input_location, "%s: section %s.%d is missing",
    4082                 :             :                  file_data->file_name, name, stream_order);
    4083                 :             : 
    4084                 :       99657 :   gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
    4085                 :             : 
    4086                 :       99657 :   if (!quiet_flag)
    4087                 :           0 :     fprintf (stderr, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
    4088                 :       99657 :   lto_input_function_body (file_data, this, data);
    4089                 :       99657 :   lto_stats.num_function_bodies++;
    4090                 :       99657 :   lto_free_section_data (file_data, LTO_section_function_body, name,
    4091                 :       99657 :                          data, len, decl_state->compressed);
    4092                 :       99657 :   lto_free_function_in_decl_state_for_node (this);
    4093                 :             :   /* Keep lto file data so ipa-inline-analysis knows about cross module
    4094                 :             :      inlining.  */
    4095                 :             : 
    4096                 :       99657 :   timevar_pop (TV_IPA_LTO_GIMPLE_IN);
    4097                 :             : 
    4098                 :       99657 :   return true;
    4099                 :             : }
    4100                 :             : 
    4101                 :             : /* Prepare function body.  When doing LTO, read cgraph_node's body from disk
    4102                 :             :    if it is not already present.  When some IPA transformations are scheduled,
    4103                 :             :    apply them.  */
    4104                 :             : 
    4105                 :             : bool
    4106                 :       27640 : cgraph_node::get_body (void)
    4107                 :             : {
    4108                 :       27640 :   bool updated;
    4109                 :             : 
    4110                 :       27640 :   updated = get_untransformed_body ();
    4111                 :             : 
    4112                 :             :   /* Getting transformed body makes no sense for inline clones;
    4113                 :             :      we should never use this on real clones because they are materialized
    4114                 :             :      early.
    4115                 :             :      TODO: Materializing clones here will likely lead to smaller LTRANS
    4116                 :             :      footprint. */
    4117                 :       27640 :   gcc_assert (!inlined_to && !clone_of);
    4118                 :       27640 :   if (ipa_transforms_to_apply.exists ())
    4119                 :             :     {
    4120                 :       11791 :       opt_pass *saved_current_pass = current_pass;
    4121                 :       11791 :       FILE *saved_dump_file = dump_file;
    4122                 :       11791 :       const char *saved_dump_file_name = dump_file_name;
    4123                 :       11791 :       dump_flags_t saved_dump_flags = dump_flags;
    4124                 :       11791 :       dump_file_name = NULL;
    4125                 :       11791 :       set_dump_file (NULL);
    4126                 :             : 
    4127                 :       11791 :       push_cfun (DECL_STRUCT_FUNCTION (decl));
    4128                 :             : 
    4129                 :       11791 :       update_ssa (TODO_update_ssa_only_virtuals);
    4130                 :       11791 :       execute_all_ipa_transforms (true);
    4131                 :       11791 :       cgraph_edge::rebuild_edges ();
    4132                 :       11791 :       free_dominance_info (CDI_DOMINATORS);
    4133                 :       11791 :       free_dominance_info (CDI_POST_DOMINATORS);
    4134                 :       11791 :       pop_cfun ();
    4135                 :       11791 :       updated = true;
    4136                 :             : 
    4137                 :       11791 :       current_pass = saved_current_pass;
    4138                 :       11791 :       set_dump_file (saved_dump_file);
    4139                 :       11791 :       dump_file_name = saved_dump_file_name;
    4140                 :       11791 :       dump_flags = saved_dump_flags;
    4141                 :             :     }
    4142                 :       27640 :   return updated;
    4143                 :             : }
    4144                 :             : 
    4145                 :             : /* Return the DECL_STRUCT_FUNCTION of the function.  */
    4146                 :             : 
    4147                 :             : struct function *
    4148                 :      162888 : cgraph_node::get_fun () const
    4149                 :             : {
    4150                 :      162888 :   const cgraph_node *node = this;
    4151                 :      162888 :   struct function *fun = DECL_STRUCT_FUNCTION (node->decl);
    4152                 :             : 
    4153                 :      162888 :   while (!fun && node->clone_of)
    4154                 :             :     {
    4155                 :           0 :       node = node->clone_of;
    4156                 :           0 :       fun = DECL_STRUCT_FUNCTION (node->decl);
    4157                 :             :     }
    4158                 :             : 
    4159                 :      162888 :   return fun;
    4160                 :             : }
    4161                 :             : 
    4162                 :             : /* Reset all state within cgraph.cc so that we can rerun the compiler
    4163                 :             :    within the same process.  For use by toplev::finalize.  */
    4164                 :             : 
    4165                 :             : void
    4166                 :      254120 : cgraph_cc_finalize (void)
    4167                 :             : {
    4168                 :      254120 :   nested_function_info::release ();
    4169                 :      254120 :   thunk_info::release ();
    4170                 :      254120 :   clone_info::release ();
    4171                 :      254120 :   symtab = NULL;
    4172                 :             : 
    4173                 :      254120 :   x_cgraph_nodes_queue = NULL;
    4174                 :             : 
    4175                 :      254120 :   cgraph_fnver_htab = NULL;
    4176                 :      254120 :   version_info_node = NULL;
    4177                 :      254120 : }
    4178                 :             : 
    4179                 :             : /* A worker for call_for_symbol_and_aliases.  */
    4180                 :             : 
    4181                 :             : bool
    4182                 :      691775 : cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
    4183                 :             :                                                               void *),
    4184                 :             :                                             void *data,
    4185                 :             :                                             bool include_overwritable)
    4186                 :             : {
    4187                 :      691775 :   ipa_ref *ref;
    4188                 :     1343997 :   FOR_EACH_ALIAS (this, ref)
    4189                 :             :     {
    4190                 :      746119 :       cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    4191                 :      746119 :       if (include_overwritable
    4192                 :      746119 :           || alias->get_availability () > AVAIL_INTERPOSABLE)
    4193                 :      746119 :         if (alias->call_for_symbol_and_aliases (callback, data,
    4194                 :             :                                                 include_overwritable))
    4195                 :             :           return true;
    4196                 :             :     }
    4197                 :             :   return false;
    4198                 :             : }
    4199                 :             : 
    4200                 :             : /* Return true if NODE has thunk.  */
    4201                 :             : 
    4202                 :             : bool
    4203                 :       39186 : cgraph_node::has_thunk_p (cgraph_node *node, void *)
    4204                 :             : {
    4205                 :       73317 :   for (cgraph_edge *e = node->callers; e; e = e->next_caller)
    4206                 :       34131 :     if (e->caller->thunk)
    4207                 :             :       return true;
    4208                 :             :   return false;
    4209                 :             : }
    4210                 :             : 
    4211                 :             : /* Expected frequency of executions within the function.  */
    4212                 :             : 
    4213                 :             : sreal
    4214                 :   178636080 : cgraph_edge::sreal_frequency ()
    4215                 :             : {
    4216                 :   178636080 :   return count.to_sreal_scale (caller->inlined_to
    4217                 :   178636080 :                                ? caller->inlined_to->count
    4218                 :   178636080 :                                : caller->count);
    4219                 :             : }
    4220                 :             : 
    4221                 :             : 
    4222                 :             : /* During LTO stream in this can be used to check whether call can possibly
    4223                 :             :    be internal to the current translation unit.  */
    4224                 :             : 
    4225                 :             : bool
    4226                 :      504465 : cgraph_edge::possibly_call_in_translation_unit_p (void)
    4227                 :             : {
    4228                 :      504465 :   gcc_checking_assert (in_lto_p && caller->prevailing_p ());
    4229                 :             : 
    4230                 :             :   /* While incremental linking we may end up getting function body later.  */
    4231                 :      504465 :   if (flag_incremental_link == INCREMENTAL_LINK_LTO)
    4232                 :             :     return true;
    4233                 :             : 
    4234                 :             :   /* We may be smarter here and avoid streaming in indirect calls we can't
    4235                 :             :      track, but that would require arranging streaming the indirect call
    4236                 :             :      summary first.  */
    4237                 :      504239 :   if (!callee)
    4238                 :             :     return true;
    4239                 :             : 
    4240                 :             :   /* If callee is local to the original translation unit, it will be
    4241                 :             :      defined.  */
    4242                 :      501641 :   if (!TREE_PUBLIC (callee->decl) && !DECL_EXTERNAL (callee->decl))
    4243                 :             :     return true;
    4244                 :             : 
    4245                 :             :   /* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
    4246                 :             :      yet) and see if it is a definition.  In fact we may also resolve aliases,
    4247                 :             :      but that is probably not too important.  */
    4248                 :      506020 :   symtab_node *node = callee;
    4249                 :      506020 :   for (int n = 10; node->previous_sharing_asm_name && n ; n--)
    4250                 :       10079 :     node = node->previous_sharing_asm_name;
    4251                 :      495941 :   if (node->previous_sharing_asm_name)
    4252                 :         234 :     node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee->decl));
    4253                 :      495941 :   gcc_assert (TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl));
    4254                 :      495941 :   return node->get_availability () >= AVAIL_INTERPOSABLE;
    4255                 :             : }
    4256                 :             : 
    4257                 :             : /* Return num_speculative_targets of this edge.  */
    4258                 :             : 
    4259                 :             : int
    4260                 :       81333 : cgraph_edge::num_speculative_call_targets_p (void)
    4261                 :             : {
    4262                 :       81333 :   return indirect_info ? indirect_info->num_speculative_call_targets : 0;
    4263                 :             : }
    4264                 :             : 
    4265                 :             : /* Check if function calls comdat local.  This is used to recompute
    4266                 :             :    calls_comdat_local flag after function transformations.  */
    4267                 :             : bool
    4268                 :    46529336 : cgraph_node::check_calls_comdat_local_p ()
    4269                 :             : {
    4270                 :   148481278 :   for (cgraph_edge *e = callees; e; e = e->next_callee)
    4271                 :     3081639 :     if (e->inline_failed
    4272                 :   109262883 :         ? e->callee->comdat_local_p ()
    4273                 :     3081639 :         : e->callee->check_calls_comdat_local_p ())
    4274                 :       44175 :       return true;
    4275                 :             :   return false;
    4276                 :             : }
    4277                 :             : 
    4278                 :             : /* Return true if this node represents a former, i.e. an expanded, thunk.  */
    4279                 :             : 
    4280                 :             : bool
    4281                 :     2900329 : cgraph_node::former_thunk_p (void)
    4282                 :             : {
    4283                 :     2900329 :   if (thunk)
    4284                 :             :     return false;
    4285                 :     2900329 :   thunk_info *i = thunk_info::get (this);
    4286                 :     2900329 :   if (!i)
    4287                 :             :     return false;
    4288                 :          73 :   gcc_checking_assert (i->fixed_offset || i->virtual_offset_p
    4289                 :             :                        || i->indirect_offset);
    4290                 :             :   return true;
    4291                 :             : }
    4292                 :             : 
    4293                 :             : /* A stashed copy of "symtab" for use by selftest::symbol_table_test.
    4294                 :             :    This needs to be a global so that it can be a GC root, and thus
    4295                 :             :    prevent the stashed copy from being garbage-collected if the GC runs
    4296                 :             :    during a symbol_table_test.  */
    4297                 :             : 
    4298                 :             : symbol_table *saved_symtab;
    4299                 :             : 
    4300                 :             : #if CHECKING_P
    4301                 :             : 
    4302                 :             : namespace selftest {
    4303                 :             : 
    4304                 :             : /* class selftest::symbol_table_test.  */
    4305                 :             : 
    4306                 :             : /* Constructor.  Store the old value of symtab, and create a new one.  */
    4307                 :             : 
    4308                 :          64 : symbol_table_test::symbol_table_test ()
    4309                 :             : {
    4310                 :          64 :   gcc_assert (saved_symtab == NULL);
    4311                 :          64 :   saved_symtab = symtab;
    4312                 :          64 :   symtab = new (ggc_alloc<symbol_table> ()) symbol_table ();
    4313                 :          64 : }
    4314                 :             : 
    4315                 :             : /* Destructor.  Restore the old value of symtab.  */
    4316                 :             : 
    4317                 :          64 : symbol_table_test::~symbol_table_test ()
    4318                 :             : {
    4319                 :          64 :   gcc_assert (saved_symtab != NULL);
    4320                 :          64 :   symtab = saved_symtab;
    4321                 :          64 :   saved_symtab = NULL;
    4322                 :          64 : }
    4323                 :             : 
    4324                 :             : /* Verify that symbol_table_test works.  */
    4325                 :             : 
    4326                 :             : static void
    4327                 :           4 : test_symbol_table_test ()
    4328                 :             : {
    4329                 :             :   /* Simulate running two selftests involving symbol tables.  */
    4330                 :          12 :   for (int i = 0; i < 2; i++)
    4331                 :             :     {
    4332                 :           8 :       symbol_table_test stt;
    4333                 :           8 :       tree test_decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
    4334                 :             :                                    get_identifier ("test_decl"),
    4335                 :             :                                    build_function_type_list (void_type_node,
    4336                 :             :                                                              NULL_TREE));
    4337                 :           8 :       cgraph_node *node = cgraph_node::get_create (test_decl);
    4338                 :           8 :       gcc_assert (node);
    4339                 :             : 
    4340                 :             :       /* Verify that the node has order 0 on both iterations,
    4341                 :             :          and thus that nodes have predictable dump names in selftests.  */
    4342                 :           8 :       ASSERT_EQ (node->order, 0);
    4343                 :           8 :       ASSERT_STREQ (node->dump_name (), "test_decl/0");
    4344                 :           8 :     }
    4345                 :           4 : }
    4346                 :             : 
    4347                 :             : /* Run all of the selftests within this file.  */
    4348                 :             : 
    4349                 :             : void
    4350                 :           4 : cgraph_cc_tests ()
    4351                 :             : {
    4352                 :           4 :   test_symbol_table_test ();
    4353                 :           4 : }
    4354                 :             : 
    4355                 :             : } // namespace selftest
    4356                 :             : 
    4357                 :             : #endif /* CHECKING_P */
    4358                 :             : 
    4359                 :             : #include "gt-cgraph.h"
        

Generated by: LCOV version 2.1-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.