LCOV - code coverage report
Current view: top level - gcc - ipa.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 571 606 94.2 %
Date: 2020-04-04 11:58:09 Functions: 30 31 96.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Basic IPA optimizations and utilities.
       2                 :            :    Copyright (C) 2003-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "target.h"
      25                 :            : #include "tree.h"
      26                 :            : #include "gimple.h"
      27                 :            : #include "alloc-pool.h"
      28                 :            : #include "tree-pass.h"
      29                 :            : #include "stringpool.h"
      30                 :            : #include "cgraph.h"
      31                 :            : #include "gimplify.h"
      32                 :            : #include "tree-iterator.h"
      33                 :            : #include "ipa-utils.h"
      34                 :            : #include "symbol-summary.h"
      35                 :            : #include "tree-vrp.h"
      36                 :            : #include "ipa-prop.h"
      37                 :            : #include "ipa-fnsummary.h"
      38                 :            : #include "dbgcnt.h"
      39                 :            : #include "debug.h"
      40                 :            : #include "stringpool.h"
      41                 :            : #include "attribs.h"
      42                 :            : 
      43                 :            : /* Return true when NODE has ADDR reference.  */
      44                 :            : 
      45                 :            : static bool
      46                 :    2346970 : has_addr_references_p (struct cgraph_node *node,
      47                 :            :                        void *)
      48                 :            : {
      49                 :    2346970 :   int i;
      50                 :    2346970 :   struct ipa_ref *ref = NULL;
      51                 :            : 
      52                 :    4843080 :   for (i = 0; node->iterate_referring (i, ref); i++)
      53                 :    2384630 :     if (ref->use == IPA_REF_ADDR)
      54                 :            :       return true;
      55                 :            :   return false;
      56                 :            : }
      57                 :            : 
      58                 :            : /* Return true when NODE can be target of an indirect call.  */
      59                 :            : 
      60                 :            : static bool
      61                 :        290 : is_indirect_call_target_p (struct cgraph_node *node, void *)
      62                 :            : {
      63                 :        290 :   return node->indirect_call_target;
      64                 :            : }
      65                 :            : 
      66                 :            : /* Look for all functions inlined to NODE and update their inlined_to pointers
      67                 :            :    to INLINED_TO.  */
      68                 :            : 
      69                 :            : static void
      70                 :          0 : update_inlined_to_pointer (struct cgraph_node *node, struct cgraph_node *inlined_to)
      71                 :            : {
      72                 :          0 :   struct cgraph_edge *e;
      73                 :          0 :   for (e = node->callees; e; e = e->next_callee)
      74                 :          0 :     if (e->callee->inlined_to)
      75                 :            :       {
      76                 :          0 :         e->callee->inlined_to = inlined_to;
      77                 :          0 :         update_inlined_to_pointer (e->callee, inlined_to);
      78                 :            :       }
      79                 :          0 : }
      80                 :            : 
      81                 :            : /* Add symtab NODE to queue starting at FIRST.
      82                 :            : 
      83                 :            :    The queue is linked via AUX pointers and terminated by pointer to 1.
      84                 :            :    We enqueue nodes at two occasions: when we find them reachable or when we find
      85                 :            :    their bodies needed for further clonning.  In the second case we mark them
      86                 :            :    by pointer to 2 after processing so they are re-queue when they become
      87                 :            :    reachable.  */
      88                 :            : 
      89                 :            : static void
      90                 :  115571000 : enqueue_node (symtab_node *node, symtab_node **first,
      91                 :            :               hash_set<symtab_node *> *reachable)
      92                 :            : {
      93                 :            :   /* Node is still in queue; do nothing.  */
      94                 :  115571000 :   if (node->aux && node->aux != (void *) 2)
      95                 :            :     return;
      96                 :            :   /* Node was already processed as unreachable, re-enqueue
      97                 :            :      only if it became reachable now.  */
      98                 :   89316000 :   if (node->aux == (void *)2 && !reachable->contains (node))
      99                 :            :     return;
     100                 :   43887000 :   node->aux = *first;
     101                 :   43887000 :   *first = node;
     102                 :            : }
     103                 :            : 
     104                 :            : /* Return true if NODE may get inlined later.
     105                 :            :    This is used to keep DECL_EXTERNAL function bodies around long enough
     106                 :            :    so inliner can proces them.  */
     107                 :            : 
     108                 :            : static bool
     109                 :    1196960 : possible_inline_candidate_p (symtab_node *node)
     110                 :            : {
     111                 :    1196960 :   if (symtab->state >= IPA_SSA_AFTER_INLINING)
     112                 :            :     return false;
     113                 :    1126020 :   cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
     114                 :    1105810 :   if (!cnode)
     115                 :            :     return false;
     116                 :    1105810 :   if (DECL_UNINLINABLE (cnode->decl))
     117                 :            :     return false;
     118                 :    1104530 :   if (opt_for_fn (cnode->decl, optimize))
     119                 :            :     return true;
     120                 :       3988 :   if (symtab->state >= IPA_SSA)
     121                 :            :     return false;
     122                 :       1516 :   return lookup_attribute ("always_inline", DECL_ATTRIBUTES (node->decl));
     123                 :            : }
     124                 :            : 
     125                 :            : /* Process references.  */
     126                 :            : 
     127                 :            : static void
     128                 :   31111800 : process_references (symtab_node *snode,
     129                 :            :                     symtab_node **first,
     130                 :            :                     hash_set<symtab_node *> *reachable)
     131                 :            : {
     132                 :   31111800 :   int i;
     133                 :   31111800 :   struct ipa_ref *ref = NULL;
     134                 :   90568700 :   for (i = 0; snode->iterate_reference (i, ref); i++)
     135                 :            :     {
     136                 :   59456900 :       symtab_node *node = ref->referred;
     137                 :   59456900 :       symtab_node *body = node->ultimate_alias_target ();
     138                 :            : 
     139                 :   59456900 :       if (node->definition && !node->in_other_partition
     140                 :   59456900 :           && ((!DECL_EXTERNAL (node->decl) || node->alias)
     141                 :      86901 :               || (possible_inline_candidate_p (node)
     142                 :            :                   /* We use variable constructors during late compilation for
     143                 :            :                      constant folding.  Keep references alive so partitioning
     144                 :            :                      knows about potential references.  */
     145                 :      25787 :                   || (VAR_P (node->decl)
     146                 :      20207 :                       && (flag_wpa
     147                 :      20207 :                           || flag_incremental_link
     148                 :            :                                  == INCREMENTAL_LINK_LTO)
     149                 :          0 :                       && dyn_cast <varpool_node *> (node)
     150                 :          0 :                            ->ctor_useable_for_folding_p ()))))
     151                 :            :         {
     152                 :            :           /* Be sure that we will not optimize out alias target
     153                 :            :              body.  */
     154                 :   41634600 :           if (DECL_EXTERNAL (node->decl)
     155                 :      62158 :               && node->alias
     156                 :   41635600 :               && symtab->state < IPA_SSA_AFTER_INLINING)
     157                 :        720 :             reachable->add (body);
     158                 :   41634600 :           reachable->add (node);
     159                 :            :         }
     160                 :   59456900 :       enqueue_node (node, first, reachable);
     161                 :            :     }
     162                 :   31111800 : }
     163                 :            : 
     164                 :            : /* EDGE is an polymorphic call.  If BEFORE_INLINING_P is set, mark
     165                 :            :    all its potential targets as reachable to permit later inlining if
     166                 :            :    devirtualization happens.  After inlining still keep their declarations
     167                 :            :    around, so we can devirtualize to a direct call.
     168                 :            : 
     169                 :            :    Also try to make trivial devirutalization when no or only one target is
     170                 :            :    possible.  */
     171                 :            : 
     172                 :            : static void
     173                 :     129602 : walk_polymorphic_call_targets (hash_set<void *> *reachable_call_targets,
     174                 :            :                                struct cgraph_edge *edge,
     175                 :            :                                symtab_node **first,
     176                 :            :                                hash_set<symtab_node *> *reachable)
     177                 :            : {
     178                 :     129602 :   unsigned int i;
     179                 :     129602 :   void *cache_token;
     180                 :     129602 :   bool final;
     181                 :     129602 :   vec <cgraph_node *>targets
     182                 :            :     = possible_polymorphic_call_targets
     183                 :     129602 :         (edge, &final, &cache_token);
     184                 :            : 
     185                 :     129602 :   if (!reachable_call_targets->add (cache_token))
     186                 :            :     {
     187                 :     353681 :       for (i = 0; i < targets.length (); i++)
     188                 :            :         {
     189                 :     105826 :           struct cgraph_node *n = targets[i];
     190                 :            : 
     191                 :            :           /* Do not bother to mark virtual methods in anonymous namespace;
     192                 :            :              either we will find use of virtual table defining it, or it is
     193                 :            :              unused.  */
     194                 :     105826 :           if (TREE_CODE (TREE_TYPE (n->decl)) == METHOD_TYPE
     195                 :     205841 :               && type_in_anonymous_namespace_p
     196                 :     100015 :                     (TYPE_METHOD_BASETYPE (TREE_TYPE (n->decl))))
     197                 :       2985 :             continue;
     198                 :            : 
     199                 :     102841 :           n->indirect_call_target = true;
     200                 :     102841 :           symtab_node *body = n->function_symbol ();
     201                 :            : 
     202                 :            :           /* Prior inlining, keep alive bodies of possible targets for
     203                 :            :              devirtualization.  */
     204                 :     102841 :           if (n->definition
     205                 :      80013 :               && (possible_inline_candidate_p (body)
     206                 :     171232 :                   && opt_for_fn (body->decl, flag_devirtualize)))
     207                 :            :              {
     208                 :            :                 /* Be sure that we will not optimize out alias target
     209                 :            :                    body.  */
     210                 :      68391 :                 if (DECL_EXTERNAL (n->decl)
     211                 :      11929 :                     && n->alias
     212                 :      68391 :                     && symtab->state < IPA_SSA_AFTER_INLINING)
     213                 :          0 :                   reachable->add (body);
     214                 :      68391 :                reachable->add (n);
     215                 :            :              }
     216                 :            :           /* Even after inlining we want to keep the possible targets in the
     217                 :            :              boundary, so late passes can still produce direct call even if
     218                 :            :              the chance for inlining is lost.  */
     219                 :     102841 :           enqueue_node (n, first, reachable);
     220                 :            :         }
     221                 :            :     }
     222                 :            : 
     223                 :            :   /* Very trivial devirtualization; when the type is
     224                 :            :      final or anonymous (so we know all its derivation)
     225                 :            :      and there is only one possible virtual call target,
     226                 :            :      make the edge direct.  */
     227                 :     129602 :   if (final)
     228                 :            :     {
     229                 :         48 :       if (targets.length () <= 1 && dbg_cnt (devirt))
     230                 :            :         {
     231                 :         16 :           cgraph_node *target, *node = edge->caller;
     232                 :         16 :           if (targets.length () == 1)
     233                 :          8 :             target = targets[0];
     234                 :            :           else
     235                 :          8 :             target = cgraph_node::get_create
     236                 :          8 :                        (builtin_decl_implicit (BUILT_IN_UNREACHABLE));
     237                 :            : 
     238                 :         16 :           if (dump_enabled_p ())
     239                 :            :             {
     240                 :          0 :               dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, edge->call_stmt,
     241                 :            :                                "devirtualizing call in %s to %s\n",
     242                 :          0 :                                edge->caller->dump_name (),
     243                 :            :                                target->dump_name ());
     244                 :            :             }
     245                 :         16 :           edge = cgraph_edge::make_direct (edge, target);
     246                 :         16 :           if (ipa_fn_summaries)
     247                 :          0 :             ipa_update_overall_fn_summary (node->inlined_to
     248                 :            :                                            ? node->inlined_to : node);
     249                 :         16 :           else if (edge->call_stmt)
     250                 :         16 :             cgraph_edge::redirect_call_stmt_to_callee (edge);
     251                 :            :         }
     252                 :            :     }
     253                 :     129602 : }
     254                 :            : 
     255                 :            : /* Perform reachability analysis and reclaim all unreachable nodes.
     256                 :            : 
     257                 :            :    The algorithm is basically mark&sweep but with some extra refinements:
     258                 :            : 
     259                 :            :    - reachable extern inline functions needs special handling; the bodies needs
     260                 :            :      to stay in memory until inlining in hope that they will be inlined.
     261                 :            :      After inlining we release their bodies and turn them into unanalyzed
     262                 :            :      nodes even when they are reachable.
     263                 :            : 
     264                 :            :    - virtual functions are kept in callgraph even if they seem unreachable in
     265                 :            :      hope calls to them will be devirtualized. 
     266                 :            : 
     267                 :            :      Again we remove them after inlining.  In late optimization some
     268                 :            :      devirtualization may happen, but it is not important since we won't inline
     269                 :            :      the call. In theory early opts and IPA should work out all important cases.
     270                 :            : 
     271                 :            :    - virtual clones needs bodies of their origins for later materialization;
     272                 :            :      this means that we want to keep the body even if the origin is unreachable
     273                 :            :      otherwise.  To avoid origin from sitting in the callgraph and being
     274                 :            :      walked by IPA passes, we turn them into unanalyzed nodes with body
     275                 :            :      defined.
     276                 :            : 
     277                 :            :      We maintain set of function declaration where body needs to stay in
     278                 :            :      body_needed_for_clonning
     279                 :            : 
     280                 :            :      Inline clones represent special case: their declaration match the
     281                 :            :      declaration of origin and cgraph_remove_node already knows how to
     282                 :            :      reshape callgraph and preserve body when offline copy of function or
     283                 :            :      inline clone is being removed.
     284                 :            : 
     285                 :            :    - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
     286                 :            :      variables with DECL_INITIAL set.  We finalize these and keep reachable
     287                 :            :      ones around for constant folding purposes.  After inlining we however
     288                 :            :      stop walking their references to let everything static referneced by them
     289                 :            :      to be removed when it is otherwise unreachable.
     290                 :            : 
     291                 :            :    We maintain queue of both reachable symbols (i.e. defined symbols that needs
     292                 :            :    to stay) and symbols that are in boundary (i.e. external symbols referenced
     293                 :            :    by reachable symbols or origins of clones).  The queue is represented
     294                 :            :    as linked list by AUX pointer terminated by 1.
     295                 :            : 
     296                 :            :    At the end we keep all reachable symbols. For symbols in boundary we always
     297                 :            :    turn definition into a declaration, but we may keep function body around
     298                 :            :    based on body_needed_for_clonning
     299                 :            : 
     300                 :            :    All symbols that enter the queue have AUX pointer non-zero and are in the
     301                 :            :    boundary.  Pointer set REACHABLE is used to track reachable symbols.
     302                 :            : 
     303                 :            :    Every symbol can be visited twice - once as part of boundary and once
     304                 :            :    as real reachable symbol. enqueue_node needs to decide whether the
     305                 :            :    node needs to be re-queued for second processing.  For this purpose
     306                 :            :    we set AUX pointer of processed symbols in the boundary to constant 2.  */
     307                 :            : 
     308                 :            : bool
     309                 :    1208660 : symbol_table::remove_unreachable_nodes (FILE *file)
     310                 :            : {
     311                 :    1208660 :   symtab_node *first = (symtab_node *) (void *) 1;
     312                 :    1208660 :   struct cgraph_node *node, *next;
     313                 :    1208660 :   varpool_node *vnode, *vnext;
     314                 :    1208660 :   bool changed = false;
     315                 :    1208660 :   hash_set<symtab_node *> reachable;
     316                 :    2417310 :   hash_set<tree> body_needed_for_clonning;
     317                 :    2417310 :   hash_set<void *> reachable_call_targets;
     318                 :            : 
     319                 :    1208660 :   timevar_push (TV_IPA_UNREACHABLE);
     320                 :    1208660 :   build_type_inheritance_graph ();
     321                 :    1208660 :   if (file)
     322                 :        755 :     fprintf (file, "\nReclaiming functions:");
     323                 :    1208660 :   if (flag_checking)
     324                 :            :     {
     325                 :   47998400 :       FOR_EACH_FUNCTION (node)
     326                 :   22790600 :         gcc_assert (!node->aux);
     327                 :   44001800 :       FOR_EACH_VARIABLE (vnode)
     328                 :   21396600 :         gcc_assert (!vnode->aux);
     329                 :            :     }
     330                 :            :   /* Mark functions whose bodies are obviously needed.
     331                 :            :      This is mostly when they can be referenced externally.  Inline clones
     332                 :            :      are special since their declarations are shared with master clone and thus
     333                 :            :      cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them.  */
     334                 :   47998700 :   FOR_EACH_FUNCTION (node)
     335                 :            :     {
     336                 :   22790700 :       node->used_as_abstract_origin = false;
     337                 :   22790700 :       node->indirect_call_target = false;
     338                 :   22790700 :       if (node->definition
     339                 :   11931700 :           && !node->inlined_to
     340                 :   10349700 :           && !node->in_other_partition
     341                 :   33140200 :           && !node->can_remove_if_no_direct_calls_and_refs_p ())
     342                 :            :         {
     343                 :    5776540 :           gcc_assert (!node->inlined_to);
     344                 :    5776540 :           reachable.add (node);
     345                 :    5776540 :           enqueue_node (node, &first, &reachable);
     346                 :            :         }
     347                 :            :       else
     348                 :   17014200 :         gcc_assert (!node->aux);
     349                 :            :      }
     350                 :            : 
     351                 :            :   /* Mark variables that are obviously needed.  */
     352                 :   41232700 :   FOR_EACH_DEFINED_VARIABLE (vnode)
     353                 :   19407700 :     if (!vnode->can_remove_if_no_refs_p()
     354                 :   19407700 :         && !vnode->in_other_partition)
     355                 :            :       {
     356                 :    9602790 :         reachable.add (vnode);
     357                 :    9602790 :         enqueue_node (vnode, &first, &reachable);
     358                 :            :       }
     359                 :            : 
     360                 :            :   /* Perform reachability analysis.  */
     361                 :   45095700 :   while (first != (symtab_node *) (void *) 1)
     362                 :            :     {
     363                 :   43887000 :       bool in_boundary_p = !reachable.contains (first);
     364                 :   43887000 :       symtab_node *node = first;
     365                 :            : 
     366                 :   43887000 :       first = (symtab_node *)first->aux;
     367                 :            : 
     368                 :            :       /* If we are processing symbol in boundary, mark its AUX pointer for
     369                 :            :          possible later re-processing in enqueue_node.  */
     370                 :   43887000 :       if (in_boundary_p)
     371                 :            :         {
     372                 :   12775300 :           node->aux = (void *)2;
     373                 :   12775300 :           if (node->alias && node->analyzed)
     374                 :       2867 :             enqueue_node (node->get_alias_target (), &first, &reachable);
     375                 :            :         }
     376                 :            :       else
     377                 :            :         {
     378                 :   31111800 :           if (TREE_CODE (node->decl) == FUNCTION_DECL
     379                 :   31111800 :               && DECL_ABSTRACT_ORIGIN (node->decl))
     380                 :            :             {
     381                 :    2299920 :               struct cgraph_node *origin_node
     382                 :    2299920 :               = cgraph_node::get (DECL_ABSTRACT_ORIGIN (node->decl));
     383                 :    2299920 :               if (origin_node && !origin_node->used_as_abstract_origin)
     384                 :            :                 {
     385                 :     305789 :                   origin_node->used_as_abstract_origin = true;
     386                 :     305789 :                   gcc_assert (!origin_node->prev_sibling_clone);
     387                 :     305789 :                   gcc_assert (!origin_node->next_sibling_clone);
     388                 :     398539 :                   for (cgraph_node *n = origin_node->clones; n;
     389                 :      92750 :                        n = n->next_sibling_clone)
     390                 :      92750 :                     if (n->decl == DECL_ABSTRACT_ORIGIN (node->decl))
     391                 :      81897 :                       n->used_as_abstract_origin = true;
     392                 :            :                 }
     393                 :            :             }
     394                 :            :           /* If any non-external and non-local symbol in a comdat group is
     395                 :            :              reachable, force all externally visible symbols in the same comdat
     396                 :            :              group to be reachable as well.  Comdat-local symbols
     397                 :            :              can be discarded if all uses were inlined.  */
     398                 :   31111800 :           if (node->same_comdat_group
     399                 :    1180790 :               && node->externally_visible
     400                 :   32267400 :               && !DECL_EXTERNAL (node->decl))
     401                 :            :             {
     402                 :    1155650 :               symtab_node *next;
     403                 :    1155650 :               for (next = node->same_comdat_group;
     404                 :    4233740 :                    next != node;
     405                 :    3078090 :                    next = next->same_comdat_group)
     406                 :    3078090 :                 if (!next->comdat_local_p ()
     407                 :    3008300 :                     && !DECL_EXTERNAL (next->decl)
     408                 :    3008290 :                     && !reachable.add (next))
     409                 :     537934 :                   enqueue_node (next, &first, &reachable);
     410                 :            :             }
     411                 :            :           /* Mark references as reachable.  */
     412                 :   31111800 :           process_references (node, &first, &reachable);
     413                 :            :         }
     414                 :            : 
     415                 :   43887000 :       if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
     416                 :            :         {
     417                 :            :           /* Mark the callees reachable unless they are direct calls to extern
     418                 :            :              inline functions we decided to not inline.  */
     419                 :   22518600 :           if (!in_boundary_p)
     420                 :            :             {
     421                 :   11730600 :               struct cgraph_edge *e;
     422                 :            :               /* Keep alive possible targets for devirtualization.  */
     423                 :   11730600 :               if (opt_for_fn (cnode->decl, optimize)
     424                 :   11730600 :                   && opt_for_fn (cnode->decl, flag_devirtualize))
     425                 :            :                 {
     426                 :    9672800 :                   struct cgraph_edge *next;
     427                 :   10795700 :                   for (e = cnode->indirect_calls; e; e = next)
     428                 :            :                     {
     429                 :    1122900 :                       next = e->next_callee;
     430                 :    1122900 :                       if (e->indirect_info->polymorphic)
     431                 :     129602 :                         walk_polymorphic_call_targets (&reachable_call_targets,
     432                 :            :                                                        e, &first, &reachable);
     433                 :            :                     }
     434                 :            :                 }
     435                 :   51395200 :               for (e = cnode->callees; e; e = e->next_callee)
     436                 :            :                 {
     437                 :   39664600 :                   symtab_node *body = e->callee->function_symbol ();
     438                 :   39664600 :                   if (e->callee->definition
     439                 :   39664600 :                       && !e->callee->in_other_partition
     440                 :   39664600 :                       && (!e->inline_failed
     441                 :   12455600 :                           || !DECL_EXTERNAL (e->callee->decl)
     442                 :    1249680 :                           || e->callee->alias
     443                 :    1030050 :                           || possible_inline_candidate_p (e->callee)))
     444                 :            :                     {
     445                 :            :                       /* Be sure that we will not optimize out alias target
     446                 :            :                          body.  */
     447                 :   13969500 :                       if (DECL_EXTERNAL (e->callee->decl)
     448                 :    1427950 :                           && e->callee->alias
     449                 :   14189100 :                           && symtab->state < IPA_SSA_AFTER_INLINING)
     450                 :     210441 :                         reachable.add (body);
     451                 :   13969500 :                       reachable.add (e->callee);
     452                 :            :                     }
     453                 :   39664600 :                   enqueue_node (e->callee, &first, &reachable);
     454                 :            :                 }
     455                 :            : 
     456                 :            :               /* When inline clone exists, mark body to be preserved so when removing
     457                 :            :                  offline copy of the function we don't kill it.  */
     458                 :   11730600 :               if (cnode->inlined_to)
     459                 :    1572240 :                 body_needed_for_clonning.add (cnode->decl);
     460                 :            : 
     461                 :            :               /* For non-inline clones, force their origins to the boundary and ensure
     462                 :            :                  that body is not removed.  */
     463                 :   13435500 :               while (cnode->clone_of)
     464                 :            :                 {
     465                 :    1704880 :                   bool noninline = cnode->clone_of->decl != cnode->decl;
     466                 :    1704880 :                   cnode = cnode->clone_of;
     467                 :    1704880 :                   if (noninline)
     468                 :            :                     {
     469                 :     351799 :                       body_needed_for_clonning.add (cnode->decl);
     470                 :     351799 :                       enqueue_node (cnode, &first, &reachable);
     471                 :            :                     }
     472                 :            :                 }
     473                 :            : 
     474                 :            :             }
     475                 :   10788000 :           else if (cnode->thunk.thunk_p)
     476                 :         48 :             enqueue_node (cnode->callees->callee, &first, &reachable);
     477                 :            : 
     478                 :            :           /* If any reachable function has simd clones, mark them as
     479                 :            :              reachable as well.  */
     480                 :   22518600 :           if (cnode->simd_clones)
     481                 :            :             {
     482                 :            :               cgraph_node *next;
     483                 :          0 :               for (next = cnode->simd_clones;
     484                 :          0 :                    next;
     485                 :          0 :                    next = next->simdclone->next_clone)
     486                 :          0 :                 if (in_boundary_p
     487                 :          0 :                     || !reachable.add (next))
     488                 :          0 :                   enqueue_node (next, &first, &reachable);
     489                 :            :             }
     490                 :            :         }
     491                 :            :       /* When we see constructor of external variable, keep referred nodes in the
     492                 :            :         boundary.  This will also hold initializers of the external vars NODE
     493                 :            :         refers to.  */
     494                 :   88982700 :       varpool_node *vnode = dyn_cast <varpool_node *> (node);
     495                 :   21368400 :       if (vnode
     496                 :   21368400 :           && DECL_EXTERNAL (node->decl)
     497                 :    1987060 :           && !vnode->alias
     498                 :    1987050 :           && in_boundary_p)
     499                 :            :         {
     500                 :    2061330 :           struct ipa_ref *ref = NULL;
     501                 :   47157000 :           for (int i = 0; node->iterate_reference (i, ref); i++)
     502                 :      74284 :             enqueue_node (ref->referred, &first, &reachable);
     503                 :            :         }
     504                 :            :     }
     505                 :            : 
     506                 :            :   /* Remove unreachable functions.   */
     507                 :    1208660 :   for (node = first_function (); node; node = next)
     508                 :            :     {
     509                 :   22796000 :       next = next_function (node);
     510                 :            : 
     511                 :            :       /* If node is not needed at all, remove it.  */
     512                 :   22796000 :       if (!node->aux)
     513                 :            :         {
     514                 :     283246 :           if (file)
     515                 :        139 :             fprintf (file, " %s", node->dump_name ());
     516                 :     283246 :           node->remove ();
     517                 :     283246 :           changed = true;
     518                 :            :         }
     519                 :            :       /* If node is unreachable, remove its body.  */
     520                 :   22512800 :       else if (!reachable.contains (node))
     521                 :            :         {
     522                 :            :           /* We keep definitions of thunks and aliases in the boundary so
     523                 :            :              we can walk to the ultimate alias targets and function symbols
     524                 :            :              reliably.  */
     525                 :   10782200 :           if (node->alias || node->thunk.thunk_p)
     526                 :            :             ;
     527                 :   10762700 :           else if (!body_needed_for_clonning.contains (node->decl))
     528                 :            :             {
     529                 :            :               /* Make the node a non-clone so that we do not attempt to
     530                 :            :                  materialize it later.  */
     531                 :   10542800 :               if (node->clone_of)
     532                 :          0 :                 node->remove_from_clone_tree ();
     533                 :   10542800 :               node->release_body ();
     534                 :            :             }
     535                 :     219901 :           else if (!node->clone_of)
     536                 :     216801 :             gcc_assert (in_lto_p || DECL_RESULT (node->decl));
     537                 :   10782200 :           if (node->definition && !node->alias && !node->thunk.thunk_p)
     538                 :            :             {
     539                 :      85083 :               if (file)
     540                 :        170 :                 fprintf (file, " %s", node->dump_name ());
     541                 :      85083 :               node->body_removed = true;
     542                 :      85083 :               node->analyzed = false;
     543                 :      85083 :               node->definition = false;
     544                 :      85083 :               node->cpp_implicit_alias = false;
     545                 :      85083 :               node->alias = false;
     546                 :      85083 :               node->transparent_alias = false;
     547                 :      85083 :               node->thunk.thunk_p = false;
     548                 :      85083 :               node->weakref = false;
     549                 :            :               /* After early inlining we drop always_inline attributes on
     550                 :            :                  bodies of functions that are still referenced (have their
     551                 :            :                  address taken).  */
     552                 :     170166 :               DECL_ATTRIBUTES (node->decl)
     553                 :     170166 :                 = remove_attribute ("always_inline",
     554                 :      85083 :                                     DECL_ATTRIBUTES (node->decl));
     555                 :      85083 :               if (!node->in_other_partition)
     556                 :      84927 :                 node->local = false;
     557                 :      85083 :               node->remove_callees ();
     558                 :      85083 :               node->remove_all_references ();
     559                 :      85083 :               changed = true;
     560                 :            :             }
     561                 :            :         }
     562                 :            :       else
     563                 :   45394800 :         gcc_assert (node->clone_of || !node->has_gimple_body_p ()
     564                 :            :                     || in_lto_p || DECL_RESULT (node->decl));
     565                 :            :     }
     566                 :            : 
     567                 :            :   /* Inline clones might be kept around so their materializing allows further
     568                 :            :      cloning.  If the function the clone is inlined into is removed, we need
     569                 :            :      to turn it into normal cone.  */
     570                 :   24930100 :   FOR_EACH_FUNCTION (node)
     571                 :            :     {
     572                 :   22512800 :       if (node->inlined_to
     573                 :    1572240 :           && !node->callers)
     574                 :            :         {
     575                 :          0 :           gcc_assert (node->clones);
     576                 :          0 :           node->inlined_to = NULL;
     577                 :          0 :           update_inlined_to_pointer (node, node);
     578                 :            :         }
     579                 :   22512800 :       node->aux = NULL;
     580                 :            :     }
     581                 :            : 
     582                 :            :   /* Remove unreachable variables.  */
     583                 :    1208660 :   if (file)
     584                 :        755 :     fprintf (file, "\nReclaiming variables:");
     585                 :   23814100 :   for (vnode = first_variable (); vnode; vnode = vnext)
     586                 :            :     {
     587                 :   21396800 :       vnext = next_variable (vnode);
     588                 :   21396800 :       if (!vnode->aux
     589                 :            :           /* For can_refer_decl_in_current_unit_p we want to track for
     590                 :            :              all external variables if they are defined in other partition
     591                 :            :              or not.  */
     592                 :   21396800 :           && (!flag_ltrans || !DECL_EXTERNAL (vnode->decl)))
     593                 :            :         {
     594                 :      28283 :           struct ipa_ref *ref = NULL;
     595                 :            : 
     596                 :            :           /* First remove the aliases, so varpool::remove can possibly lookup
     597                 :            :              the constructor and save it for future use.  */
     598                 :      49026 :           while (vnode->iterate_direct_aliases (0, ref))
     599                 :            :             {
     600                 :          0 :               if (file)
     601                 :          0 :                 fprintf (file, " %s", ref->referred->dump_name ());
     602                 :          0 :               ref->referring->remove ();
     603                 :            :             }
     604                 :      28283 :           if (file)
     605                 :          1 :             fprintf (file, " %s", vnode->dump_name ());
     606                 :      28283 :           vnext = next_variable (vnode);
     607                 :            :           /* Signal removal to the debug machinery.  */
     608                 :      28283 :           if (! flag_wpa || flag_incremental_link == INCREMENTAL_LINK_LTO)
     609                 :            :             {
     610                 :      27033 :               vnode->definition = false;
     611                 :      27033 :               (*debug_hooks->late_global_decl) (vnode->decl);
     612                 :            :             }
     613                 :      28283 :           vnode->remove ();
     614                 :      28283 :           changed = true;
     615                 :            :         }
     616                 :   21368500 :       else if (!reachable.contains (vnode) && !vnode->alias)
     617                 :            :         {
     618                 :    1987130 :           tree init;
     619                 :    1987130 :           if (vnode->definition)
     620                 :            :             {
     621                 :      11184 :               if (file)
     622                 :          0 :                 fprintf (file, " %s", vnode->dump_name ());
     623                 :            :               changed = true;
     624                 :            :             }
     625                 :            :           /* Keep body if it may be useful for constant folding.  */
     626                 :    1983900 :           if ((flag_wpa || flag_incremental_link == INCREMENTAL_LINK_LTO)
     627                 :    3970980 :               || ((init = ctor_for_folding (vnode->decl)) == error_mark_node))
     628                 :    1915520 :             vnode->remove_initializer ();
     629                 :            :           else
     630                 :      71616 :             DECL_INITIAL (vnode->decl) = init;
     631                 :    1987130 :           vnode->body_removed = true;
     632                 :    1987130 :           vnode->definition = false;
     633                 :    1987130 :           vnode->analyzed = false;
     634                 :    1987130 :           vnode->aux = NULL;
     635                 :            : 
     636                 :    1987130 :           vnode->remove_from_same_comdat_group ();
     637                 :            : 
     638                 :    1987130 :           vnode->remove_all_references ();
     639                 :            :         }
     640                 :            :       else
     641                 :   19381400 :         vnode->aux = NULL;
     642                 :            :     }
     643                 :            : 
     644                 :            :   /* Now update address_taken flags and try to promote functions to be local.  */
     645                 :    1208660 :   if (file)
     646                 :        755 :     fprintf (file, "\nClearing address taken flags:");
     647                 :   25883700 :   FOR_EACH_DEFINED_FUNCTION (node)
     648                 :   11733200 :     if (node->address_taken
     649                 :   11733200 :         && !node->used_from_other_partition)
     650                 :            :       {
     651                 :    2288840 :         if (!node->call_for_symbol_and_aliases
     652                 :    2288840 :             (has_addr_references_p, NULL, true))
     653                 :            :           {
     654                 :      15685 :             if (file)
     655                 :          2 :               fprintf (file, " %s", node->dump_name ());
     656                 :      15685 :             node->address_taken = false;
     657                 :      15685 :             changed = true;
     658                 :      15685 :             if (node->local_p ()
     659                 :            :                 /* Virtual functions may be kept in cgraph just because
     660                 :            :                    of possible later devirtualization.  Do not mark them as
     661                 :            :                    local too early so we won't optimize them out before
     662                 :            :                    we are done with polymorphic call analysis.  */
     663                 :      15685 :                 && (symtab->state >= IPA_SSA_AFTER_INLINING
     664                 :        290 :                     || !node->call_for_symbol_and_aliases
     665                 :        290 :                        (is_indirect_call_target_p, NULL, true)))
     666                 :            :               {
     667                 :        297 :                 node->local = true;
     668                 :        297 :                 if (file)
     669                 :          2 :                   fprintf (file, " (local)");
     670                 :            :               }
     671                 :            :           }
     672                 :            :       }
     673                 :    1208660 :   if (file)
     674                 :        755 :     fprintf (file, "\n");
     675                 :            : 
     676                 :    1208660 :   symtab_node::checking_verify_symtab_nodes ();
     677                 :            : 
     678                 :            :   /* If we removed something, perhaps profile could be improved.  */
     679                 :    1208660 :   if (changed && (optimize || in_lto_p) && ipa_call_summaries)
     680                 :    4618090 :     FOR_EACH_DEFINED_FUNCTION (node)
     681                 :    2254840 :       ipa_propagate_frequency (node);
     682                 :            : 
     683                 :    1208660 :   timevar_pop (TV_IPA_UNREACHABLE);
     684                 :    1208660 :   return changed;
     685                 :            : }
     686                 :            : 
     687                 :            : /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
     688                 :            :    as needed, also clear EXPLICIT_REFS if the references to given variable
     689                 :            :    do not need to be explicit.  */
     690                 :            : 
     691                 :            : void
     692                 :    4435190 : process_references (varpool_node *vnode,
     693                 :            :                     bool *written, bool *address_taken,
     694                 :            :                     bool *read, bool *explicit_refs)
     695                 :            : {
     696                 :    4435190 :   int i;
     697                 :    4435190 :   struct ipa_ref *ref;
     698                 :            : 
     699                 :    4435190 :   if (!vnode->all_refs_explicit_p ()
     700                 :    4435190 :       || TREE_THIS_VOLATILE (vnode->decl))
     701                 :    2429100 :     *explicit_refs = false;
     702                 :            : 
     703                 :   18730500 :   for (i = 0; vnode->iterate_referring (i, ref)
     704                 :   11445600 :               && *explicit_refs && (!*written || !*address_taken || !*read); i++)
     705                 :    2849680 :     switch (ref->use)
     706                 :            :       {
     707                 :    2160320 :       case IPA_REF_ADDR:
     708                 :    2160320 :         *address_taken = true;
     709                 :    2160320 :         break;
     710                 :     404922 :       case IPA_REF_LOAD:
     711                 :     404922 :         *read = true;
     712                 :     404922 :         break;
     713                 :     278768 :       case IPA_REF_STORE:
     714                 :     278768 :         *written = true;
     715                 :     278768 :         break;
     716                 :       5679 :       case IPA_REF_ALIAS:
     717                 :       5679 :         process_references (dyn_cast<varpool_node *> (ref->referring), written,
     718                 :            :                             address_taken, read, explicit_refs);
     719                 :       5679 :         break;
     720                 :            :       }
     721                 :    4435190 : }
     722                 :            : 
     723                 :            : /* Set TREE_READONLY bit.  */
     724                 :            : 
     725                 :            : bool
     726                 :      49761 : set_readonly_bit (varpool_node *vnode, void *data ATTRIBUTE_UNUSED)
     727                 :            : {
     728                 :      49761 :   TREE_READONLY (vnode->decl) = true;
     729                 :      49761 :   return false;
     730                 :            : }
     731                 :            : 
     732                 :            : /* Set writeonly bit and clear the initalizer, since it will not be needed.  */
     733                 :            : 
     734                 :            : bool
     735                 :       2069 : set_writeonly_bit (varpool_node *vnode, void *data)
     736                 :            : {
     737                 :       2069 :   vnode->writeonly = true;
     738                 :       2069 :   if (optimize || in_lto_p)
     739                 :            :     {
     740                 :       2069 :       DECL_INITIAL (vnode->decl) = NULL;
     741                 :       2069 :       if (!vnode->alias)
     742                 :            :         {
     743                 :       2069 :           if (vnode->num_references ())
     744                 :        156 :             *(bool *)data = true;
     745                 :       2069 :           vnode->remove_all_references ();
     746                 :            :         }
     747                 :            :     }
     748                 :       2069 :   return false;
     749                 :            : }
     750                 :            : 
     751                 :            : /* Clear addressale bit of VNODE.  */
     752                 :            : 
     753                 :            : bool
     754                 :      70115 : clear_addressable_bit (varpool_node *vnode, void *data ATTRIBUTE_UNUSED)
     755                 :            : {
     756                 :      70115 :   vnode->address_taken = false;
     757                 :      70115 :   TREE_ADDRESSABLE (vnode->decl) = 0;
     758                 :      70115 :   return false;
     759                 :            : }
     760                 :            : 
     761                 :            : /* Discover variables that have no longer address taken, are read-only or
     762                 :            :    write-only and update their flags.
     763                 :            : 
     764                 :            :    Return true when unreachable symbol removal should be done.
     765                 :            : 
     766                 :            :    FIXME: This cannot be done in between gimplify and omp_expand since
     767                 :            :    readonly flag plays role on what is shared and what is not.  Currently we do
     768                 :            :    this transformation as part of whole program visibility and re-do at
     769                 :            :    ipa-reference pass (to take into account clonning), but it would
     770                 :            :    make sense to do it before early optimizations.  */
     771                 :            : 
     772                 :            : bool
     773                 :     221839 : ipa_discover_variable_flags (void)
     774                 :            : {
     775                 :     221839 :   if (!flag_ipa_reference_addressable)
     776                 :            :     return false;
     777                 :            : 
     778                 :     220598 :   bool remove_p = false;
     779                 :     220598 :   varpool_node *vnode;
     780                 :     220598 :   if (dump_file)
     781                 :         52 :     fprintf (dump_file, "Clearing variable flags:");
     782                 :    9311970 :   FOR_EACH_VARIABLE (vnode)
     783                 :    4435390 :     if (!vnode->alias
     784                 :    4435390 :         && (TREE_ADDRESSABLE (vnode->decl)
     785                 :    4429510 :             || !vnode->writeonly
     786                 :       2017 :             || !TREE_READONLY (vnode->decl)))
     787                 :            :       {
     788                 :    4429510 :         bool written = false;
     789                 :    4429510 :         bool address_taken = false;
     790                 :    4429510 :         bool read = false;
     791                 :    4429510 :         bool explicit_refs = true;
     792                 :            : 
     793                 :    4429510 :         process_references (vnode, &written, &address_taken, &read,
     794                 :            :                             &explicit_refs);
     795                 :    4429510 :         if (!explicit_refs)
     796                 :    2429100 :           continue;
     797                 :    2000410 :         if (!address_taken)
     798                 :            :           {
     799                 :      64663 :             if (TREE_ADDRESSABLE (vnode->decl) && dump_file)
     800                 :          0 :               fprintf (dump_file, " %s (non-addressable)",
     801                 :            :                        vnode->dump_name ());
     802                 :      64663 :             vnode->call_for_symbol_and_aliases (clear_addressable_bit, NULL,
     803                 :            :                                                 true);
     804                 :            :           }
     805                 :      64663 :         if (!address_taken && !written
     806                 :            :             /* Making variable in explicit section readonly can cause section
     807                 :            :                type conflict. 
     808                 :            :                See e.g. gcc.c-torture/compile/pr23237.c */
     809                 :    2044750 :             && vnode->get_section () == NULL)
     810                 :            :           {
     811                 :      44313 :             if (!TREE_READONLY (vnode->decl) && dump_file)
     812                 :          4 :               fprintf (dump_file, " %s (read-only)", vnode->dump_name ());
     813                 :      44313 :             vnode->call_for_symbol_and_aliases (set_readonly_bit, NULL, true);
     814                 :            :           }
     815                 :    2000410 :         if (!vnode->writeonly && !read && !address_taken && written)
     816                 :            :           {
     817                 :       2069 :             if (dump_file)
     818                 :          0 :               fprintf (dump_file, " %s (write-only)", vnode->dump_name ());
     819                 :       2069 :             vnode->call_for_symbol_and_aliases (set_writeonly_bit, &remove_p, 
     820                 :            :                                                 true);
     821                 :            :           }
     822                 :            :       }
     823                 :     220598 :   if (dump_file)
     824                 :         52 :     fprintf (dump_file, "\n");
     825                 :     220598 :   return remove_p;
     826                 :            : }
     827                 :            : 
     828                 :            : /* Generate and emit a static constructor or destructor.  WHICH must
     829                 :            :    be one of 'I' (for a constructor), 'D' (for a destructor).
     830                 :            :    BODY is a STATEMENT_LIST containing GENERIC
     831                 :            :    statements.  PRIORITY is the initialization priority for this
     832                 :            :    constructor or destructor.
     833                 :            : 
     834                 :            :    FINAL specify whether the externally visible name for collect2 should
     835                 :            :    be produced. */
     836                 :            : 
     837                 :            : static void
     838                 :       3622 : cgraph_build_static_cdtor_1 (char which, tree body, int priority, bool final,
     839                 :            :                              tree optimization,
     840                 :            :                              tree target)
     841                 :            : {
     842                 :       3622 :   static int counter = 0;
     843                 :       3622 :   char which_buf[16];
     844                 :       3622 :   tree decl, name, resdecl;
     845                 :            : 
     846                 :            :   /* The priority is encoded in the constructor or destructor name.
     847                 :            :      collect2 will sort the names and arrange that they are called at
     848                 :            :      program startup.  */
     849                 :       3622 :   if (!targetm.have_ctors_dtors && final)
     850                 :            :     {
     851                 :          0 :       sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++);
     852                 :          0 :       name = get_file_function_name (which_buf);
     853                 :            :     }
     854                 :            :   else
     855                 :            :     {
     856                 :            :       /* Proudce sane name but one not recognizable by collect2, just for the
     857                 :            :          case we fail to inline the function.  */
     858                 :       3622 :       sprintf (which_buf, "_sub_%c_%.5d_%d", which, priority, counter++);
     859                 :       3622 :       name = get_identifier (which_buf);
     860                 :            :     }
     861                 :            : 
     862                 :       3622 :   decl = build_decl (input_location, FUNCTION_DECL, name,
     863                 :            :                      build_function_type_list (void_type_node, NULL_TREE));
     864                 :       3622 :   current_function_decl = decl;
     865                 :            : 
     866                 :       3622 :   resdecl = build_decl (input_location,
     867                 :            :                         RESULT_DECL, NULL_TREE, void_type_node);
     868                 :       3622 :   DECL_ARTIFICIAL (resdecl) = 1;
     869                 :       3622 :   DECL_RESULT (decl) = resdecl;
     870                 :       3622 :   DECL_CONTEXT (resdecl) = decl;
     871                 :            : 
     872                 :       3622 :   allocate_struct_function (decl, false);
     873                 :            : 
     874                 :       3622 :   TREE_STATIC (decl) = 1;
     875                 :       3622 :   TREE_USED (decl) = 1;
     876                 :       3622 :   DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl) = optimization;
     877                 :       3622 :   DECL_FUNCTION_SPECIFIC_TARGET (decl) = target;
     878                 :       3622 :   DECL_ARTIFICIAL (decl) = 1;
     879                 :       3622 :   DECL_IGNORED_P (decl) = 1;
     880                 :       3622 :   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
     881                 :       3622 :   DECL_SAVED_TREE (decl) = body;
     882                 :       3622 :   if (!targetm.have_ctors_dtors && final)
     883                 :            :     {
     884                 :          0 :       TREE_PUBLIC (decl) = 1;
     885                 :          0 :       DECL_PRESERVE_P (decl) = 1;
     886                 :            :     }
     887                 :       3622 :   DECL_UNINLINABLE (decl) = 1;
     888                 :            : 
     889                 :       3622 :   DECL_INITIAL (decl) = make_node (BLOCK);
     890                 :       3622 :   BLOCK_SUPERCONTEXT (DECL_INITIAL (decl)) = decl;
     891                 :       3622 :   TREE_USED (DECL_INITIAL (decl)) = 1;
     892                 :            : 
     893                 :       3622 :   DECL_SOURCE_LOCATION (decl) = input_location;
     894                 :       3622 :   cfun->function_end_locus = input_location;
     895                 :            : 
     896                 :       3622 :   switch (which)
     897                 :            :     {
     898                 :       2354 :     case 'I':
     899                 :       2354 :       DECL_STATIC_CONSTRUCTOR (decl) = 1;
     900                 :       2354 :       decl_init_priority_insert (decl, priority);
     901                 :       2354 :       break;
     902                 :       1268 :     case 'D':
     903                 :       1268 :       DECL_STATIC_DESTRUCTOR (decl) = 1;
     904                 :       1268 :       decl_fini_priority_insert (decl, priority);
     905                 :       1268 :       break;
     906                 :          0 :     default:
     907                 :          0 :       gcc_unreachable ();
     908                 :            :     }
     909                 :            : 
     910                 :       3622 :   gimplify_function_tree (decl);
     911                 :            : 
     912                 :       3622 :   cgraph_node::add_new_function (decl, false);
     913                 :            : 
     914                 :       3622 :   set_cfun (NULL);
     915                 :       3622 :   current_function_decl = NULL;
     916                 :       3622 : }
     917                 :            : 
     918                 :            : /* Generate and emit a static constructor or destructor.  WHICH must
     919                 :            :    be one of 'I' (for a constructor) or 'D' (for a destructor).
     920                 :            :    BODY is a STATEMENT_LIST containing GENERIC
     921                 :            :    statements.  PRIORITY is the initialization priority for this
     922                 :            :    constructor or destructor.  */
     923                 :            : 
     924                 :            : void
     925                 :       3614 : cgraph_build_static_cdtor (char which, tree body, int priority)
     926                 :            : {
     927                 :            :   /* FIXME: We should be able to
     928                 :            :      gcc_assert (!in_lto_p);
     929                 :            :      because at LTO time the global options are not safe to use.
     930                 :            :      Unfortunately ASAN finish_file will produce constructors late and they
     931                 :            :      may lead to surprises.  */
     932                 :       3614 :   cgraph_build_static_cdtor_1 (which, body, priority, false,
     933                 :            :                                optimization_default_node,
     934                 :            :                                target_option_default_node);
     935                 :       3614 : }
     936                 :            : 
     937                 :            : /* When target does not have ctors and dtors, we call all constructor
     938                 :            :    and destructor by special initialization/destruction function
     939                 :            :    recognized by collect2.
     940                 :            : 
     941                 :            :    When we are going to build this function, collect all constructors and
     942                 :            :    destructors and turn them into normal functions.  */
     943                 :            : 
     944                 :            : static void
     945                 :         84 : record_cdtor_fn (struct cgraph_node *node, vec<tree> *ctors, vec<tree> *dtors)
     946                 :            : {
     947                 :         84 :   if (DECL_STATIC_CONSTRUCTOR (node->decl))
     948                 :         70 :     ctors->safe_push (node->decl);
     949                 :         84 :   if (DECL_STATIC_DESTRUCTOR (node->decl))
     950                 :         15 :     dtors->safe_push (node->decl);
     951                 :         84 :   node = cgraph_node::get (node->decl);
     952                 :         84 :   DECL_DISREGARD_INLINE_LIMITS (node->decl) = 1;
     953                 :         84 : }
     954                 :            : 
     955                 :            : /* Define global constructors/destructor functions for the CDTORS, of
     956                 :            :    which they are LEN.  The CDTORS are sorted by initialization
     957                 :            :    priority.  If CTOR_P is true, these are constructors; otherwise,
     958                 :            :    they are destructors.  */
     959                 :            : 
     960                 :            : static void
     961                 :         71 : build_cdtor (bool ctor_p, const vec<tree> &cdtors)
     962                 :            : {
     963                 :         71 :   size_t i,j;
     964                 :         71 :   size_t len = cdtors.length ();
     965                 :            : 
     966                 :         71 :   i = 0;
     967                 :        148 :   while (i < len)
     968                 :            :     {
     969                 :         77 :       tree body;
     970                 :         77 :       tree fn;
     971                 :         77 :       priority_type priority;
     972                 :            : 
     973                 :         77 :       priority = 0;
     974                 :         77 :       body = NULL_TREE;
     975                 :         77 :       j = i;
     976                 :         91 :       do
     977                 :            :         {
     978                 :         91 :           priority_type p;
     979                 :         91 :           fn = cdtors[j];
     980                 :         91 :           p = ctor_p ? DECL_INIT_PRIORITY (fn) : DECL_FINI_PRIORITY (fn);
     981                 :         91 :           if (j == i)
     982                 :            :             priority = p;
     983                 :         14 :           else if (p != priority)
     984                 :            :             break;
     985                 :         85 :           j++;
     986                 :            :         }
     987                 :         85 :       while (j < len);
     988                 :            : 
     989                 :            :       /* When there is only one cdtor and target supports them, do nothing.  */
     990                 :         77 :       if (j == i + 1
     991                 :         69 :           && targetm.have_ctors_dtors)
     992                 :            :         {
     993                 :         69 :           i++;
     994                 :         69 :           continue;
     995                 :            :         }
     996                 :            :       /* Find the next batch of constructors/destructors with the same
     997                 :            :          initialization priority.  */
     998                 :         24 :       for (;i < j; i++)
     999                 :            :         {
    1000                 :         16 :           tree call;
    1001                 :         16 :           fn = cdtors[i];
    1002                 :         16 :           call = build_call_expr (fn, 0);
    1003                 :         16 :           if (ctor_p)
    1004                 :          8 :             DECL_STATIC_CONSTRUCTOR (fn) = 0;
    1005                 :            :           else
    1006                 :          8 :             DECL_STATIC_DESTRUCTOR (fn) = 0;
    1007                 :            :           /* We do not want to optimize away pure/const calls here.
    1008                 :            :              When optimizing, these should be already removed, when not
    1009                 :            :              optimizing, we want user to be able to breakpoint in them.  */
    1010                 :         16 :           TREE_SIDE_EFFECTS (call) = 1;
    1011                 :         16 :           append_to_statement_list (call, &body);
    1012                 :            :         }
    1013                 :          8 :       gcc_assert (body != NULL_TREE);
    1014                 :            :       /* Generate a function to call all the function of like
    1015                 :            :          priority.  */
    1016                 :          8 :       cgraph_build_static_cdtor_1 (ctor_p ? 'I' : 'D', body, priority, true,
    1017                 :          8 :                                    DECL_FUNCTION_SPECIFIC_OPTIMIZATION (cdtors[0]),
    1018                 :          8 :                                    DECL_FUNCTION_SPECIFIC_TARGET (cdtors[0]));
    1019                 :            :     }
    1020                 :         71 : }
    1021                 :            : 
    1022                 :            : /* Comparison function for qsort.  P1 and P2 are actually of type
    1023                 :            :    "tree *" and point to static constructors.  DECL_INIT_PRIORITY is
    1024                 :            :    used to determine the sort order.  */
    1025                 :            : 
    1026                 :            : static int
    1027                 :         36 : compare_ctor (const void *p1, const void *p2)
    1028                 :            : {
    1029                 :         36 :   tree f1;
    1030                 :         36 :   tree f2;
    1031                 :         36 :   int priority1;
    1032                 :         36 :   int priority2;
    1033                 :            : 
    1034                 :         36 :   f1 = *(const tree *)p1;
    1035                 :         36 :   f2 = *(const tree *)p2;
    1036                 :         36 :   priority1 = DECL_INIT_PRIORITY (f1);
    1037                 :         36 :   priority2 = DECL_INIT_PRIORITY (f2);
    1038                 :            : 
    1039                 :         36 :   if (priority1 < priority2)
    1040                 :            :     return -1;
    1041                 :         22 :   else if (priority1 > priority2)
    1042                 :            :     return 1;
    1043                 :            :   else
    1044                 :            :     /* Ensure a stable sort.  Constructors are executed in backwarding
    1045                 :            :        order to make LTO initialize braries first.  */
    1046                 :         16 :     return DECL_UID (f2) - DECL_UID (f1);
    1047                 :            : }
    1048                 :            : 
    1049                 :            : /* Comparison function for qsort.  P1 and P2 are actually of type
    1050                 :            :    "tree *" and point to static destructors.  DECL_FINI_PRIORITY is
    1051                 :            :    used to determine the sort order.  */
    1052                 :            : 
    1053                 :            : static int
    1054                 :         36 : compare_dtor (const void *p1, const void *p2)
    1055                 :            : {
    1056                 :         36 :   tree f1;
    1057                 :         36 :   tree f2;
    1058                 :         36 :   int priority1;
    1059                 :         36 :   int priority2;
    1060                 :            : 
    1061                 :         36 :   f1 = *(const tree *)p1;
    1062                 :         36 :   f2 = *(const tree *)p2;
    1063                 :         36 :   priority1 = DECL_FINI_PRIORITY (f1);
    1064                 :         36 :   priority2 = DECL_FINI_PRIORITY (f2);
    1065                 :            : 
    1066                 :         36 :   if (priority1 < priority2)
    1067                 :            :     return -1;
    1068                 :         22 :   else if (priority1 > priority2)
    1069                 :            :     return 1;
    1070                 :            :   else
    1071                 :            :     /* Ensure a stable sort.  */
    1072                 :         16 :     return DECL_UID (f1) - DECL_UID (f2);
    1073                 :            : }
    1074                 :            : 
    1075                 :            : /* Generate functions to call static constructors and destructors
    1076                 :            :    for targets that do not support .ctors/.dtors sections.  These
    1077                 :            :    functions have magic names which are detected by collect2.  */
    1078                 :            : 
    1079                 :            : static void
    1080                 :       8602 : build_cdtor_fns (vec<tree> *ctors, vec<tree> *dtors)
    1081                 :            : {
    1082                 :       8602 :   if (!ctors->is_empty ())
    1083                 :            :     {
    1084                 :         63 :       gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
    1085                 :         63 :       ctors->qsort (compare_ctor);
    1086                 :         63 :       build_cdtor (/*ctor_p=*/true, *ctors);
    1087                 :            :     }
    1088                 :            : 
    1089                 :       8602 :   if (!dtors->is_empty ())
    1090                 :            :     {
    1091                 :          8 :       gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
    1092                 :          8 :       dtors->qsort (compare_dtor);
    1093                 :          8 :       build_cdtor (/*ctor_p=*/false, *dtors);
    1094                 :            :     }
    1095                 :       8602 : }
    1096                 :            : 
    1097                 :            : /* Look for constructors and destructors and produce function calling them.
    1098                 :            :    This is needed for targets not supporting ctors or dtors, but we perform the
    1099                 :            :    transformation also at linktime to merge possibly numerous
    1100                 :            :    constructors/destructors into single function to improve code locality and
    1101                 :            :    reduce size.  */
    1102                 :            : 
    1103                 :            : static unsigned int
    1104                 :       8602 : ipa_cdtor_merge (void)
    1105                 :            : {
    1106                 :            :   /* A vector of FUNCTION_DECLs declared as static constructors.  */
    1107                 :       8602 :   auto_vec<tree, 20> ctors;
    1108                 :            :   /* A vector of FUNCTION_DECLs declared as static destructors.  */
    1109                 :       8602 :   auto_vec<tree, 20> dtors;
    1110                 :       8602 :   struct cgraph_node *node;
    1111                 :     155660 :   FOR_EACH_DEFINED_FUNCTION (node)
    1112                 :      69228 :     if (DECL_STATIC_CONSTRUCTOR (node->decl)
    1113                 :      69228 :         || DECL_STATIC_DESTRUCTOR (node->decl))
    1114                 :         84 :        record_cdtor_fn (node, &ctors, &dtors);
    1115                 :       8602 :   build_cdtor_fns (&ctors, &dtors);
    1116                 :       8602 :   return 0;
    1117                 :            : }
    1118                 :            : 
    1119                 :            : namespace {
    1120                 :            : 
    1121                 :            : const pass_data pass_data_ipa_cdtor_merge =
    1122                 :            : {
    1123                 :            :   IPA_PASS, /* type */
    1124                 :            :   "cdtor", /* name */
    1125                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    1126                 :            :   TV_CGRAPHOPT, /* tv_id */
    1127                 :            :   0, /* properties_required */
    1128                 :            :   0, /* properties_provided */
    1129                 :            :   0, /* properties_destroyed */
    1130                 :            :   0, /* todo_flags_start */
    1131                 :            :   0, /* todo_flags_finish */
    1132                 :            : };
    1133                 :            : 
    1134                 :            : class pass_ipa_cdtor_merge : public ipa_opt_pass_d
    1135                 :            : {
    1136                 :            : public:
    1137                 :     200773 :   pass_ipa_cdtor_merge (gcc::context *ctxt)
    1138                 :            :     : ipa_opt_pass_d (pass_data_ipa_cdtor_merge, ctxt,
    1139                 :            :                       NULL, /* generate_summary */
    1140                 :            :                       NULL, /* write_summary */
    1141                 :            :                       NULL, /* read_summary */
    1142                 :            :                       NULL, /* write_optimization_summary */
    1143                 :            :                       NULL, /* read_optimization_summary */
    1144                 :            :                       NULL, /* stmt_fixup */
    1145                 :            :                       0, /* function_transform_todo_flags_start */
    1146                 :            :                       NULL, /* function_transform */
    1147                 :     401546 :                       NULL) /* variable_transform */
    1148                 :            :   {}
    1149                 :            : 
    1150                 :            :   /* opt_pass methods: */
    1151                 :            :   virtual bool gate (function *);
    1152                 :       8602 :   virtual unsigned int execute (function *) { return ipa_cdtor_merge (); }
    1153                 :            : 
    1154                 :            : }; // class pass_ipa_cdtor_merge
    1155                 :            : 
    1156                 :            : bool
    1157                 :     415684 : pass_ipa_cdtor_merge::gate (function *)
    1158                 :            : {
    1159                 :            :   /* Perform the pass when we have no ctors/dtors support
    1160                 :            :      or at LTO time to merge multiple constructors into single
    1161                 :            :      function.  */
    1162                 :     415684 :   return !targetm.have_ctors_dtors || in_lto_p;
    1163                 :            : }
    1164                 :            : 
    1165                 :            : } // anon namespace
    1166                 :            : 
    1167                 :            : ipa_opt_pass_d *
    1168                 :     200773 : make_pass_ipa_cdtor_merge (gcc::context *ctxt)
    1169                 :            : {
    1170                 :     200773 :   return new pass_ipa_cdtor_merge (ctxt);
    1171                 :            : }
    1172                 :            : 
    1173                 :            : /* Invalid pointer representing BOTTOM for single user dataflow.  */
    1174                 :            : #define BOTTOM ((cgraph_node *)(size_t) 2)
    1175                 :            : 
    1176                 :            : /* Meet operation for single user dataflow.
    1177                 :            :    Here we want to associate variables with sigle function that may access it.
    1178                 :            : 
    1179                 :            :    FUNCTION is current single user of a variable, VAR is variable that uses it.
    1180                 :            :    Latttice is stored in SINGLE_USER_MAP.
    1181                 :            : 
    1182                 :            :    We represent: 
    1183                 :            :     - TOP by no entry in SIGNLE_USER_MAP
    1184                 :            :     - BOTTOM by BOTTOM in AUX pointer (to save lookups)
    1185                 :            :     - known single user by cgraph pointer in SINGLE_USER_MAP.  */
    1186                 :            : 
    1187                 :            : cgraph_node *
    1188                 :    3804850 : meet (cgraph_node *function, varpool_node *var,
    1189                 :            :        hash_map<varpool_node *, cgraph_node *> &single_user_map)
    1190                 :            : {
    1191                 :    3804850 :   struct cgraph_node *user, **f;
    1192                 :            : 
    1193                 :    3804850 :   if (var->aux == BOTTOM)
    1194                 :            :     return BOTTOM;
    1195                 :            : 
    1196                 :    2964200 :   f = single_user_map.get (var);
    1197                 :    1290590 :   if (!f)
    1198                 :            :     return function;
    1199                 :    1290590 :   user = *f;
    1200                 :    1290590 :   if (!function)
    1201                 :            :     return user;
    1202                 :    1274280 :   else if (function != user)
    1203                 :            :     return BOTTOM;
    1204                 :            :   else
    1205                 :    1271040 :     return function;
    1206                 :            : }
    1207                 :            : 
    1208                 :            : /* Propagation step of single-use dataflow.
    1209                 :            : 
    1210                 :            :    Check all uses of VNODE and see if they are used by single function FUNCTION.
    1211                 :            :    SINGLE_USER_MAP represents the dataflow lattice.  */
    1212                 :            : 
    1213                 :            : cgraph_node *
    1214                 :    1456630 : propagate_single_user (varpool_node *vnode, cgraph_node *function,
    1215                 :            :                        hash_map<varpool_node *, cgraph_node *> &single_user_map)
    1216                 :            : {
    1217                 :    1456630 :   int i;
    1218                 :    1456630 :   struct ipa_ref *ref;
    1219                 :            : 
    1220                 :    1456630 :   gcc_assert (!vnode->externally_visible);
    1221                 :            : 
    1222                 :            :   /* If node is an alias, first meet with its target.  */
    1223                 :    1456630 :   if (vnode->alias)
    1224                 :      13042 :     function = meet (function, vnode->get_alias_target (), single_user_map);
    1225                 :            : 
    1226                 :            :   /* Check all users and see if they correspond to a single function.  */
    1227                 :    9719310 :   for (i = 0; vnode->iterate_referring (i, ref) && function != BOTTOM; i++)
    1228                 :            :     {
    1229                 :    4125300 :       struct cgraph_node *cnode = dyn_cast <cgraph_node *> (ref->referring);
    1230                 :    4125300 :       if (cnode)
    1231                 :            :         {
    1232                 :     326970 :           if (cnode->inlined_to)
    1233                 :      68532 :             cnode = cnode->inlined_to;
    1234                 :     326970 :           if (!function)
    1235                 :            :             function = cnode;
    1236                 :     143651 :           else if (function != cnode)
    1237                 :      12711 :             function = BOTTOM;
    1238                 :            :         }
    1239                 :            :       else
    1240                 :    7596660 :         function = meet (function, dyn_cast <varpool_node *> (ref->referring),
    1241                 :            :                          single_user_map);
    1242                 :            :     }
    1243                 :    1456630 :   return function;
    1244                 :            : }
    1245                 :            : 
    1246                 :            : /* Pass setting used_by_single_function flag.
    1247                 :            :    This flag is set on variable when there is only one function that may
    1248                 :            :    possibly referr to it.  */
    1249                 :            : 
    1250                 :            : static unsigned int
    1251                 :     163705 : ipa_single_use (void)
    1252                 :            : {
    1253                 :     163705 :   varpool_node *first = (varpool_node *) (void *) 1;
    1254                 :     163705 :   varpool_node *var;
    1255                 :     163705 :   hash_map<varpool_node *, cgraph_node *> single_user_map;
    1256                 :            : 
    1257                 :    4929190 :   FOR_EACH_DEFINED_VARIABLE (var)
    1258                 :    2300890 :     if (!var->all_refs_explicit_p ())
    1259                 :    1261790 :       var->aux = BOTTOM;
    1260                 :            :     else
    1261                 :            :       {
    1262                 :            :         /* Enqueue symbol for dataflow.  */
    1263                 :    1039100 :         var->aux = first;
    1264                 :    1039100 :         first = var;
    1265                 :            :       }
    1266                 :            : 
    1267                 :            :   /* The actual dataflow.  */
    1268                 :            : 
    1269                 :    1620340 :   while (first != (void *) 1)
    1270                 :            :     {
    1271                 :    1456630 :       cgraph_node *user, *orig_user, **f;
    1272                 :            : 
    1273                 :    1456630 :       var = first;
    1274                 :    1456630 :       first = (varpool_node *)first->aux;
    1275                 :            : 
    1276                 :    1456630 :       f = single_user_map.get (var);
    1277                 :      28774 :       if (f)
    1278                 :      28774 :         orig_user = *f;
    1279                 :            :       else
    1280                 :            :         orig_user = NULL;
    1281                 :    1456630 :       user = propagate_single_user (var, orig_user, single_user_map);
    1282                 :            : 
    1283                 :    1456630 :       gcc_checking_assert (var->aux != BOTTOM);
    1284                 :            : 
    1285                 :            :       /* If user differs, enqueue all references.  */
    1286                 :    1456630 :       if (user != orig_user)
    1287                 :            :         {
    1288                 :    1041950 :           unsigned int i;
    1289                 :    1041950 :           ipa_ref *ref;
    1290                 :            : 
    1291                 :    1041950 :           single_user_map.put (var, user);
    1292                 :            : 
    1293                 :            :           /* Enqueue all aliases for re-processing.  */
    1294                 :    2096420 :           for (i = 0; var->iterate_direct_aliases (i, ref); i++)
    1295                 :       6263 :             if (!ref->referring->aux)
    1296                 :            :               {
    1297                 :        854 :                 ref->referring->aux = first;
    1298                 :       6263 :                 first = dyn_cast <varpool_node *> (ref->referring);
    1299                 :            :               }
    1300                 :            :           /* Enqueue all users for re-processing.  */
    1301                 :    2110210 :           for (i = 0; var->iterate_reference (i, ref); i++)
    1302                 :    1068260 :             if (!ref->referred->aux
    1303                 :     582904 :                 && ref->referred->definition
    1304                 :    2067840 :                 && is_a <varpool_node *> (ref->referred))
    1305                 :            :               {
    1306                 :     416678 :                 ref->referred->aux = first;
    1307                 :    1068260 :                 first = dyn_cast <varpool_node *> (ref->referred);
    1308                 :            :               }
    1309                 :            : 
    1310                 :            :           /* If user is BOTTOM, just punt on this var.  */
    1311                 :    1041950 :           if (user == BOTTOM)
    1312                 :     856594 :             var->aux = BOTTOM;
    1313                 :            :           else
    1314                 :     185354 :             var->aux = NULL;
    1315                 :            :         }
    1316                 :            :       else
    1317                 :     414686 :         var->aux = NULL;
    1318                 :            :     }
    1319                 :            : 
    1320                 :    2628300 :   FOR_EACH_DEFINED_VARIABLE (var)
    1321                 :            :     {
    1322                 :    2300890 :       if (var->aux != BOTTOM)
    1323                 :            :         {
    1324                 :            :           /* Not having the single user known means that the VAR is
    1325                 :            :              unreachable.  Either someone forgot to remove unreachable
    1326                 :            :              variables or the reachability here is wrong.  */
    1327                 :            : 
    1328                 :     182508 :           gcc_checking_assert (single_user_map.get (var));
    1329                 :            : 
    1330                 :     182508 :           if (dump_file)
    1331                 :            :             {
    1332                 :         10 :               fprintf (dump_file, "Variable %s is used by single function\n",
    1333                 :            :                        var->dump_name ());
    1334                 :            :             }
    1335                 :     182508 :           var->used_by_single_function = true;
    1336                 :            :         }
    1337                 :    2300890 :       var->aux = NULL;
    1338                 :            :     }
    1339                 :     163705 :   return 0;
    1340                 :            : }
    1341                 :            : 
    1342                 :            : namespace {
    1343                 :            : 
    1344                 :            : const pass_data pass_data_ipa_single_use =
    1345                 :            : {
    1346                 :            :   IPA_PASS, /* type */
    1347                 :            :   "single-use", /* name */
    1348                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    1349                 :            :   TV_CGRAPHOPT, /* tv_id */
    1350                 :            :   0, /* properties_required */
    1351                 :            :   0, /* properties_provided */
    1352                 :            :   0, /* properties_destroyed */
    1353                 :            :   0, /* todo_flags_start */
    1354                 :            :   0, /* todo_flags_finish */
    1355                 :            : };
    1356                 :            : 
    1357                 :            : class pass_ipa_single_use : public ipa_opt_pass_d
    1358                 :            : {
    1359                 :            : public:
    1360                 :     200773 :   pass_ipa_single_use (gcc::context *ctxt)
    1361                 :            :     : ipa_opt_pass_d (pass_data_ipa_single_use, ctxt,
    1362                 :            :                       NULL, /* generate_summary */
    1363                 :            :                       NULL, /* write_summary */
    1364                 :            :                       NULL, /* read_summary */
    1365                 :            :                       NULL, /* write_optimization_summary */
    1366                 :            :                       NULL, /* read_optimization_summary */
    1367                 :            :                       NULL, /* stmt_fixup */
    1368                 :            :                       0, /* function_transform_todo_flags_start */
    1369                 :            :                       NULL, /* function_transform */
    1370                 :     401546 :                       NULL) /* variable_transform */
    1371                 :            :   {}
    1372                 :            : 
    1373                 :            :   /* opt_pass methods: */
    1374                 :     163705 :   virtual unsigned int execute (function *) { return ipa_single_use (); }
    1375                 :            : 
    1376                 :            : }; // class pass_ipa_single_use
    1377                 :            : 
    1378                 :            : } // anon namespace
    1379                 :            : 
    1380                 :            : ipa_opt_pass_d *
    1381                 :     200773 : make_pass_ipa_single_use (gcc::context *ctxt)
    1382                 :            : {
    1383                 :     200773 :   return new pass_ipa_single_use (ctxt);
    1384                 :            : }
    1385                 :            : 
    1386                 :            : /* Materialize all clones.  */
    1387                 :            : 
    1388                 :            : namespace {
    1389                 :            : 
    1390                 :            : const pass_data pass_data_materialize_all_clones =
    1391                 :            : {
    1392                 :            :   SIMPLE_IPA_PASS, /* type */
    1393                 :            :   "materialize-all-clones", /* name */
    1394                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    1395                 :            :   TV_IPA_OPT, /* tv_id */
    1396                 :            :   0, /* properties_required */
    1397                 :            :   0, /* properties_provided */
    1398                 :            :   0, /* properties_destroyed */
    1399                 :            :   0, /* todo_flags_start */
    1400                 :            :   0, /* todo_flags_finish */
    1401                 :            : };
    1402                 :            : 
    1403                 :            : class pass_materialize_all_clones : public simple_ipa_opt_pass
    1404                 :            : {
    1405                 :            : public:
    1406                 :     200773 :   pass_materialize_all_clones (gcc::context *ctxt)
    1407                 :     401546 :     : simple_ipa_opt_pass (pass_data_materialize_all_clones, ctxt)
    1408                 :            :   {}
    1409                 :            : 
    1410                 :            :   /* opt_pass methods: */
    1411                 :     164036 :   virtual unsigned int execute (function *)
    1412                 :            :     {
    1413                 :     164036 :       symtab->materialize_all_clones ();
    1414                 :     164036 :       return 0;
    1415                 :            :     }
    1416                 :            : 
    1417                 :            : }; // class pass_materialize_all_clones
    1418                 :            : 
    1419                 :            : } // anon namespace
    1420                 :            : 
    1421                 :            : simple_ipa_opt_pass *
    1422                 :     200773 : make_pass_materialize_all_clones (gcc::context *ctxt)
    1423                 :            : {
    1424                 :     200773 :   return new pass_materialize_all_clones (ctxt);
    1425                 :            : }

Generated by: LCOV version 1.0

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