LCOV - code coverage report
Current view: top level - gcc - cgraph.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 397 402 98.8 %
Date: 2020-04-04 11:58:09 Functions: 32 32 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Callgraph handling code.
       2                 :            :    Copyright (C) 2003-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Jan Hubicka
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #ifndef GCC_CGRAPH_H
      22                 :            : #define GCC_CGRAPH_H
      23                 :            : 
      24                 :            : #include "profile-count.h"
      25                 :            : #include "ipa-ref.h"
      26                 :            : #include "plugin-api.h"
      27                 :            : #include "ipa-param-manipulation.h"
      28                 :            : 
      29                 :            : extern void debuginfo_early_init (void);
      30                 :            : extern void debuginfo_init (void);
      31                 :            : extern void debuginfo_fini (void);
      32                 :            : extern void debuginfo_start (void);
      33                 :            : extern void debuginfo_stop (void);
      34                 :            : extern void debuginfo_early_start (void);
      35                 :            : extern void debuginfo_early_stop (void);
      36                 :            : 
      37                 :            : class ipa_opt_pass_d;
      38                 :            : typedef ipa_opt_pass_d *ipa_opt_pass;
      39                 :            : 
      40                 :            : /* Symbol table consists of functions and variables.
      41                 :            :    TODO: add labels and CONST_DECLs.  */
      42                 :            : enum symtab_type
      43                 :            : {
      44                 :            :   SYMTAB_SYMBOL,
      45                 :            :   SYMTAB_FUNCTION,
      46                 :            :   SYMTAB_VARIABLE
      47                 :            : };
      48                 :            : 
      49                 :            : /* Section names are stored as reference counted strings in GGC safe hashtable
      50                 :            :    (to make them survive through PCH).  */
      51                 :            : 
      52                 :            : struct GTY((for_user)) section_hash_entry
      53                 :            : {
      54                 :            :   int ref_count;
      55                 :            :   char *name;  /* As long as this datastructure stays in GGC, we cannot put
      56                 :            :                   string at the tail of structure of GGC dies in horrible
      57                 :            :                   way  */
      58                 :            : };
      59                 :            : 
      60                 :            : struct section_name_hasher : ggc_ptr_hash<section_hash_entry>
      61                 :            : {
      62                 :            :   typedef const char *compare_type;
      63                 :            : 
      64                 :            :   static hashval_t hash (section_hash_entry *);
      65                 :            :   static bool equal (section_hash_entry *, const char *);
      66                 :            : };
      67                 :            : 
      68                 :            : enum availability
      69                 :            : {
      70                 :            :   /* Not yet set by cgraph_function_body_availability.  */
      71                 :            :   AVAIL_UNSET,
      72                 :            :   /* Function body/variable initializer is unknown.  */
      73                 :            :   AVAIL_NOT_AVAILABLE,
      74                 :            :   /* Function body/variable initializer is known but might be replaced
      75                 :            :      by a different one from other compilation unit and thus needs to
      76                 :            :      be dealt with a care.  Like AVAIL_NOT_AVAILABLE it can have
      77                 :            :      arbitrary side effects on escaping variables and functions, while
      78                 :            :      like AVAILABLE it might access static variables.  */
      79                 :            :   AVAIL_INTERPOSABLE,
      80                 :            :   /* Function body/variable initializer is known and will be used in final
      81                 :            :      program.  */
      82                 :            :   AVAIL_AVAILABLE,
      83                 :            :   /* Function body/variable initializer is known and all it's uses are
      84                 :            :      explicitly visible within current unit (i.e. it's address is never taken
      85                 :            :      and it is not exported to other units). Currently used only for
      86                 :            :      functions.  */
      87                 :            :   AVAIL_LOCAL
      88                 :            : };
      89                 :            : 
      90                 :            : /* Classification of symbols WRT partitioning.  */
      91                 :            : enum symbol_partitioning_class
      92                 :            : {
      93                 :            :    /* External declarations are ignored by partitioning algorithms and they are
      94                 :            :       added into the boundary later via compute_ltrans_boundary.  */
      95                 :            :    SYMBOL_EXTERNAL,
      96                 :            :    /* Partitioned symbols are put into one of partitions.  */
      97                 :            :    SYMBOL_PARTITION,
      98                 :            :    /* Duplicated symbols (such as comdat or constant pool references) are
      99                 :            :       copied into every node needing them via add_symbol_to_partition.  */
     100                 :            :    SYMBOL_DUPLICATE
     101                 :            : };
     102                 :            : 
     103                 :            : /* Base of all entries in the symbol table.
     104                 :            :    The symtab_node is inherited by cgraph and varpol nodes.  */
     105                 :            : struct GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
     106                 :            :             chain_next ("%h.next"), chain_prev ("%h.previous")))
     107                 :            :   symtab_node
     108                 :            : {
     109                 :            : public:
     110                 :            :   friend class symbol_table;
     111                 :            : 
     112                 :            :   /* Constructor.  */
     113                 :   48855796 :   explicit symtab_node (symtab_type t)
     114                 :   48855796 :     : type (t), resolution (LDPR_UNKNOWN), definition (false), alias (false),
     115                 :            :       transparent_alias (false), weakref (false), cpp_implicit_alias (false),
     116                 :            :       symver (false), analyzed (false), writeonly (false),
     117                 :            :       refuse_visibility_changes (false), externally_visible (false),
     118                 :            :       no_reorder (false), force_output (false), forced_by_abi (false),
     119                 :            :       unique_name (false), implicit_section (false), body_removed (false),
     120                 :            :       used_from_other_partition (false), in_other_partition (false),
     121                 :            :       address_taken (false), in_init_priority_hash (false),
     122                 :            :       need_lto_streaming (false), offloadable (false), ifunc_resolver (false),
     123                 :            :       order (false), next_sharing_asm_name (NULL),
     124                 :            :       previous_sharing_asm_name (NULL), same_comdat_group (NULL), ref_list (),
     125                 :            :       alias_target (NULL), lto_file_data (NULL), aux (NULL),
     126                 :   48855796 :       x_comdat_group (NULL_TREE), x_section (NULL)
     127                 :   48855796 :   {}
     128                 :            : 
     129                 :            :   /* Return name.  */
     130                 :            :   const char *name () const;
     131                 :            : 
     132                 :            :   /* Return dump name.  */
     133                 :            :   const char *dump_name () const;
     134                 :            : 
     135                 :            :   /* Return asm name.  */
     136                 :            :   const char *asm_name () const;
     137                 :            : 
     138                 :            :   /* Return dump name with assembler name.  */
     139                 :            :   const char *dump_asm_name () const;
     140                 :            : 
     141                 :            :   /* Return visibility name.  */
     142                 :            :   const char *get_visibility_string () const;
     143                 :            : 
     144                 :            :   /* Return type_name name.  */
     145                 :            :   const char *get_symtab_type_string () const;
     146                 :            : 
     147                 :            :   /* Add node into symbol table.  This function is not used directly, but via
     148                 :            :      cgraph/varpool node creation routines.  */
     149                 :            :   void register_symbol (void);
     150                 :            : 
     151                 :            :   /* Remove symbol from symbol table.  */
     152                 :            :   void remove (void);
     153                 :            : 
     154                 :            :   /* Dump symtab node to F.  */
     155                 :            :   void dump (FILE *f);
     156                 :            : 
     157                 :            :   /* Dump symtab callgraph in graphviz format.  */
     158                 :            :   void dump_graphviz (FILE *f);
     159                 :            : 
     160                 :            :   /* Dump symtab node to stderr.  */
     161                 :            :   void DEBUG_FUNCTION debug (void);
     162                 :            : 
     163                 :            :   /* Verify consistency of node.  */
     164                 :            :   void DEBUG_FUNCTION verify (void);
     165                 :            : 
     166                 :            :   /* Return ipa reference from this symtab_node to
     167                 :            :      REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
     168                 :            :      of the use and STMT the statement (if it exists).  */
     169                 :            :   ipa_ref *create_reference (symtab_node *referred_node,
     170                 :            :                              enum ipa_ref_use use_type);
     171                 :            : 
     172                 :            :   /* Return ipa reference from this symtab_node to
     173                 :            :      REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
     174                 :            :      of the use and STMT the statement (if it exists).  */
     175                 :            :   ipa_ref *create_reference (symtab_node *referred_node,
     176                 :            :                              enum ipa_ref_use use_type, gimple *stmt);
     177                 :            : 
     178                 :            :   /* If VAL is a reference to a function or a variable, add a reference from
     179                 :            :      this symtab_node to the corresponding symbol table node.  Return the new
     180                 :            :      reference or NULL if none was created.  */
     181                 :            :   ipa_ref *maybe_create_reference (tree val, gimple *stmt);
     182                 :            : 
     183                 :            :   /* Clone all references from symtab NODE to this symtab_node.  */
     184                 :            :   void clone_references (symtab_node *node);
     185                 :            : 
     186                 :            :   /* Remove all stmt references in non-speculative references.
     187                 :            :      Those are not maintained during inlining & clonning.
     188                 :            :      The exception are speculative references that are updated along
     189                 :            :      with callgraph edges associated with them.  */
     190                 :            :   void clone_referring (symtab_node *node);
     191                 :            : 
     192                 :            :   /* Clone reference REF to this symtab_node and set its stmt to STMT.  */
     193                 :            :   ipa_ref *clone_reference (ipa_ref *ref, gimple *stmt);
     194                 :            : 
     195                 :            :   /* Find the structure describing a reference to REFERRED_NODE
     196                 :            :      and associated with statement STMT.  */
     197                 :            :   ipa_ref *find_reference (symtab_node *referred_node, gimple *stmt,
     198                 :            :                            unsigned int lto_stmt_uid);
     199                 :            : 
     200                 :            :   /* Remove all references that are associated with statement STMT.  */
     201                 :            :   void remove_stmt_references (gimple *stmt);
     202                 :            : 
     203                 :            :   /* Remove all stmt references in non-speculative references.
     204                 :            :      Those are not maintained during inlining & clonning.
     205                 :            :      The exception are speculative references that are updated along
     206                 :            :      with callgraph edges associated with them.  */
     207                 :            :   void clear_stmts_in_references (void);
     208                 :            : 
     209                 :            :   /* Remove all references in ref list.  */
     210                 :            :   void remove_all_references (void);
     211                 :            : 
     212                 :            :   /* Remove all referring items in ref list.  */
     213                 :            :   void remove_all_referring (void);
     214                 :            : 
     215                 :            :   /* Dump references in ref list to FILE.  */
     216                 :            :   void dump_references (FILE *file);
     217                 :            : 
     218                 :            :   /* Dump referring in list to FILE.  */
     219                 :            :   void dump_referring (FILE *);
     220                 :            : 
     221                 :            :   /* Get number of references for this node.  */
     222                 :    1513229 :   inline unsigned num_references (void)
     223                 :            :   {
     224                 :     757649 :     return ref_list.references ? ref_list.references->length () : 0;
     225                 :            :   }
     226                 :            : 
     227                 :            :   /* Iterates I-th reference in the list, REF is also set.  */
     228                 :            :   ipa_ref *iterate_reference (unsigned i, ipa_ref *&ref);
     229                 :            : 
     230                 :            :   /* Iterates I-th referring item in the list, REF is also set.  */
     231                 :            :   ipa_ref *iterate_referring (unsigned i, ipa_ref *&ref);
     232                 :            : 
     233                 :            :   /* Iterates I-th referring alias item in the list, REF is also set.  */
     234                 :            :   ipa_ref *iterate_direct_aliases (unsigned i, ipa_ref *&ref);
     235                 :            : 
     236                 :            :   /* Return true if symtab node and TARGET represents
     237                 :            :      semantically equivalent symbols.  */
     238                 :            :   bool semantically_equivalent_p (symtab_node *target);
     239                 :            : 
     240                 :            :   /* Classify symbol symtab node for partitioning.  */
     241                 :            :   enum symbol_partitioning_class get_partitioning_class (void);
     242                 :            : 
     243                 :            :   /* Return comdat group.  */
     244                 :  401470243 :   tree get_comdat_group ()
     245                 :            :     {
     246                 :  388825862 :       return x_comdat_group;
     247                 :            :     }
     248                 :            : 
     249                 :            :   /* Return comdat group as identifier_node.  */
     250                 :      14127 :   tree get_comdat_group_id ()
     251                 :            :     {
     252                 :      14127 :       if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE)
     253                 :          0 :         x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group);
     254                 :      14127 :       return x_comdat_group;
     255                 :            :     }
     256                 :            : 
     257                 :            :   /* Set comdat group.  */
     258                 :    9564395 :   void set_comdat_group (tree group)
     259                 :            :     {
     260                 :    9564395 :       gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
     261                 :            :                            || DECL_P (group));
     262                 :    3294111 :       x_comdat_group = group;
     263                 :    6279768 :     }
     264                 :            : 
     265                 :            :   /* Return section as string.  */
     266                 :  521167360 :   const char * get_section ()
     267                 :            :     {
     268                 :  514791360 :       if (!x_section)
     269                 :            :         return NULL;
     270                 :  151929790 :       return x_section->name;
     271                 :            :     }
     272                 :            : 
     273                 :            :   /* Remove node from same comdat group.   */
     274                 :            :   void remove_from_same_comdat_group (void);
     275                 :            : 
     276                 :            :   /* Add this symtab_node to the same comdat group that OLD is in.  */
     277                 :            :   void add_to_same_comdat_group (symtab_node *old_node);
     278                 :            : 
     279                 :            :   /* Dissolve the same_comdat_group list in which NODE resides.  */
     280                 :            :   void dissolve_same_comdat_group_list (void);
     281                 :            : 
     282                 :            :   /* Return true when symtab_node is known to be used from other (non-LTO)
     283                 :            :      object file. Known only when doing LTO via linker plugin.  */
     284                 :            :   bool used_from_object_file_p (void);
     285                 :            : 
     286                 :            :   /* Walk the alias chain to return the symbol NODE is alias of.
     287                 :            :      If NODE is not an alias, return NODE.
     288                 :            :      When AVAILABILITY is non-NULL, get minimal availability in the chain.
     289                 :            :      When REF is non-NULL, assume that reference happens in symbol REF
     290                 :            :      when determining the availability.  */
     291                 :            :   symtab_node *ultimate_alias_target (enum availability *avail = NULL,
     292                 :            :                                       struct symtab_node *ref = NULL);
     293                 :            : 
     294                 :            :   /* Return next reachable static symbol with initializer after NODE.  */
     295                 :            :   inline symtab_node *next_defined_symbol (void);
     296                 :            : 
     297                 :            :   /* Add reference recording that symtab node is alias of TARGET.
     298                 :            :      If TRANSPARENT is true make the alias to be transparent alias.
     299                 :            :      The function can fail in the case of aliasing cycles; in this case
     300                 :            :      it returns false.  */
     301                 :            :   bool resolve_alias (symtab_node *target, bool transparent = false);
     302                 :            : 
     303                 :            :   /* C++ FE sometimes change linkage flags after producing same
     304                 :            :      body aliases.  */
     305                 :            :   void fixup_same_cpp_alias_visibility (symtab_node *target);
     306                 :            : 
     307                 :            :   /* Call callback on symtab node and aliases associated to this node.
     308                 :            :      When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
     309                 :            :      skipped.  */
     310                 :            :   bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
     311                 :            :                                     void *data,
     312                 :            :                                     bool include_overwrite);
     313                 :            : 
     314                 :            :   /* If node cannot be interposable by static or dynamic linker to point to
     315                 :            :      different definition, return this symbol. Otherwise look for alias with
     316                 :            :      such property and if none exists, introduce new one.  */
     317                 :            :   symtab_node *noninterposable_alias (void);
     318                 :            : 
     319                 :            :   /* Return node that alias is aliasing.  */
     320                 :            :   inline symtab_node *get_alias_target (void);
     321                 :            : 
     322                 :            :   /* Set section for symbol and its aliases.  */
     323                 :            :   void set_section (const char *section);
     324                 :            : 
     325                 :            :   /* Set section, do not recurse into aliases.
     326                 :            :      When one wants to change section of symbol and its aliases,
     327                 :            :      use set_section.  */
     328                 :            :   void set_section_for_node (const char *section);
     329                 :            : 
     330                 :            :   /* Set initialization priority to PRIORITY.  */
     331                 :            :   void set_init_priority (priority_type priority);
     332                 :            : 
     333                 :            :   /* Return the initialization priority.  */
     334                 :            :   priority_type get_init_priority ();
     335                 :            : 
     336                 :            :   /* Return availability of NODE when referenced from REF.  */
     337                 :            :   enum availability get_availability (symtab_node *ref = NULL);
     338                 :            : 
     339                 :            :   /* During LTO stream-in this predicate can be used to check whether node
     340                 :            :      in question prevails in the linking to save some memory usage.  */
     341                 :            :   bool prevailing_p (void);
     342                 :            : 
     343                 :            :   /* Return true if NODE binds to current definition in final executable
     344                 :            :      when referenced from REF.  If REF is NULL return conservative value
     345                 :            :      for any reference.  */
     346                 :            :   bool binds_to_current_def_p (symtab_node *ref = NULL);
     347                 :            : 
     348                 :            :   /* Make DECL local.  */
     349                 :            :   void make_decl_local (void);
     350                 :            : 
     351                 :            :   /* Copy visibility from N.  */
     352                 :            :   void copy_visibility_from (symtab_node *n);
     353                 :            : 
     354                 :            :   /* Return desired alignment of the definition.  This is NOT alignment useful
     355                 :            :      to access THIS, because THIS may be interposable and DECL_ALIGN should
     356                 :            :      be used instead.  It however must be guaranteed when output definition
     357                 :            :      of THIS.  */
     358                 :            :   unsigned int definition_alignment ();
     359                 :            : 
     360                 :            :   /* Return true if alignment can be increased.  */
     361                 :            :   bool can_increase_alignment_p ();
     362                 :            : 
     363                 :            :   /* Increase alignment of symbol to ALIGN.  */
     364                 :            :   void increase_alignment (unsigned int align);
     365                 :            : 
     366                 :            :   /* Return true if list contains an alias.  */
     367                 :            :   bool has_aliases_p (void);
     368                 :            : 
     369                 :            :   /* Return true when the symbol is real symbol, i.e. it is not inline clone
     370                 :            :      or abstract function kept for debug info purposes only.  */
     371                 :            :   bool real_symbol_p (void);
     372                 :            : 
     373                 :            :   /* Return true when the symbol needs to be output to the LTO symbol table.  */
     374                 :            :   bool output_to_lto_symbol_table_p (void);
     375                 :            : 
     376                 :            :   /* Determine if symbol declaration is needed.  That is, visible to something
     377                 :            :      either outside this translation unit, something magic in the system
     378                 :            :      configury. This function is used just during symbol creation.  */
     379                 :            :   bool needed_p (void);
     380                 :            : 
     381                 :            :   /* Return true if this symbol is a function from the C frontend specified
     382                 :            :      directly in RTL form (with "__RTL").  */
     383                 :            :   bool native_rtl_p () const;
     384                 :            : 
     385                 :            :   /* Return true when there are references to the node.  */
     386                 :            :   bool referred_to_p (bool include_self = true);
     387                 :            : 
     388                 :            :   /* Return true if symbol can be discarded by linker from the binary.
     389                 :            :      Assume that symbol is used (so there is no need to take into account
     390                 :            :      garbage collecting linkers)
     391                 :            : 
     392                 :            :      This can happen for comdats, commons and weaks when they are prevailed
     393                 :            :      by other definition at static linking time.  */
     394                 :            :   inline bool
     395                 :  326724868 :   can_be_discarded_p (void)
     396                 :            :   {
     397                 :  326724868 :     return (DECL_EXTERNAL (decl)
     398                 :  223931094 :             || ((get_comdat_group ()
     399                 :  203217865 :                  || DECL_COMMON (decl)
     400                 :  202067864 :                  || (DECL_SECTION_NAME (decl) && DECL_WEAK (decl)))
     401                 :   21863424 :                 && ((resolution != LDPR_PREVAILING_DEF
     402                 :   21863424 :                      && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP)
     403                 :        625 :                     || flag_incremental_link)
     404                 :  348588092 :                 && resolution != LDPR_PREVAILING_DEF_IRONLY));
     405                 :            :   }
     406                 :            : 
     407                 :            :   /* Return true if NODE is local to a particular COMDAT group, and must not
     408                 :            :      be named from outside the COMDAT.  This is used for C++ decloned
     409                 :            :      constructors.  */
     410                 :  159022238 :   inline bool comdat_local_p (void)
     411                 :            :   {
     412                 :  159022238 :     return (same_comdat_group && !TREE_PUBLIC (decl));
     413                 :            :   }
     414                 :            : 
     415                 :            :   /* Return true if ONE and TWO are part of the same COMDAT group.  */
     416                 :            :   inline bool in_same_comdat_group_p (symtab_node *target);
     417                 :            : 
     418                 :            :   /* Return true if symbol is known to be nonzero.  */
     419                 :            :   bool nonzero_address ();
     420                 :            : 
     421                 :            :   /* Return 0 if symbol is known to have different address than S2,
     422                 :            :      Return 1 if symbol is known to have same address as S2,
     423                 :            :      return 2 otherwise. 
     424                 :            : 
     425                 :            :      If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
     426                 :            :      and S2 is going to be accessed.  This eliminates the situations when
     427                 :            :      either THIS or S2 is NULL and is useful for comparing bases when deciding
     428                 :            :      about memory aliasing.  */
     429                 :            :   int equal_address_to (symtab_node *s2, bool memory_accessed = false);
     430                 :            : 
     431                 :            :   /* Return true if symbol's address may possibly be compared to other
     432                 :            :      symbol's address.  */
     433                 :            :   bool address_matters_p ();
     434                 :            : 
     435                 :            :   /* Return true if NODE's address can be compared.  This use properties
     436                 :            :      of NODE only and does not look if the address is actually taken in
     437                 :            :      interesting way.  For that use ADDRESS_MATTERS_P instead.  */
     438                 :            :   bool address_can_be_compared_p (void);
     439                 :            : 
     440                 :            :   /* Return symbol table node associated with DECL, if any,
     441                 :            :      and NULL otherwise.  */
     442                 : 3729510044 :   static inline symtab_node *get (const_tree decl)
     443                 :            :   {
     444                 :            :     /* Check that we are called for sane type of object - functions
     445                 :            :        and static or external variables.  */
     446                 : 3817282488 :     gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
     447                 :            :                          || (TREE_CODE (decl) == VAR_DECL
     448                 :            :                              && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
     449                 :            :                                  || in_lto_p)));
     450                 :            :     /* Check that the mapping is sane - perhaps this check can go away,
     451                 :            :        but at the moment frontends tends to corrupt the mapping by calling
     452                 :            :        memcpy/memset on the tree nodes.  */
     453                 : 3729510044 :     gcc_checking_assert (!decl->decl_with_vis.symtab_node
     454                 :            :                          || decl->decl_with_vis.symtab_node->decl == decl);
     455                 : 3729510044 :     return decl->decl_with_vis.symtab_node;
     456                 :            :   }
     457                 :            : 
     458                 :            :   /* Try to find a symtab node for declaration DECL and if it does not
     459                 :            :      exist or if it corresponds to an inline clone, create a new one.  */
     460                 :            :   static inline symtab_node * get_create (tree node);
     461                 :            : 
     462                 :            :   /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
     463                 :            :      Return NULL if there's no such node.  */
     464                 :            :   static symtab_node *get_for_asmname (const_tree asmname);
     465                 :            : 
     466                 :            :   /* Verify symbol table for internal consistency.  */
     467                 :            :   static DEBUG_FUNCTION void verify_symtab_nodes (void);
     468                 :            : 
     469                 :            :   /* Perform internal consistency checks, if they are enabled.  */
     470                 :            :   static inline void checking_verify_symtab_nodes (void);
     471                 :            : 
     472                 :            :   /* Type of the symbol.  */
     473                 :            :   ENUM_BITFIELD (symtab_type) type : 8;
     474                 :            : 
     475                 :            :   /* The symbols resolution.  */
     476                 :            :   ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;
     477                 :            : 
     478                 :            :   /*** Flags representing the symbol type.  ***/
     479                 :            : 
     480                 :            :   /* True when symbol corresponds to a definition in current unit.
     481                 :            :      set via finalize_function or finalize_decl  */
     482                 :            :   unsigned definition : 1;
     483                 :            :   /* True when symbol is an alias.
     484                 :            :      Set by assemble_alias.  */
     485                 :            :   unsigned alias : 1;
     486                 :            :   /* When true the alias is translated into its target symbol either by GCC
     487                 :            :      or assembler (it also may just be a duplicate declaration of the same
     488                 :            :      linker name).
     489                 :            : 
     490                 :            :      Currently transparent aliases come in three different flavors
     491                 :            :        - aliases having the same assembler name as their target (aka duplicated
     492                 :            :          declarations). In this case the assembler names compare via
     493                 :            :          assembler_names_equal_p and weakref is false
     494                 :            :        - aliases that are renamed at a time being output to final file
     495                 :            :          by varasm.c. For those DECL_ASSEMBLER_NAME have
     496                 :            :          IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
     497                 :            :          name must be unique.
     498                 :            :          Weakrefs belong to this category when we target assembler without
     499                 :            :          .weakref directive.
     500                 :            :        - weakrefs that are renamed by assembler via .weakref directive.
     501                 :            :          In this case the alias may or may not be definition (depending if
     502                 :            :          target declaration was seen by the compiler), weakref is set.
     503                 :            :          Unless we are before renaming statics, assembler names are different.
     504                 :            : 
     505                 :            :      Given that we now support duplicate declarations, the second option is
     506                 :            :      redundant and will be removed.  */
     507                 :            :   unsigned transparent_alias : 1;
     508                 :            :   /* True when alias is a weakref.  */
     509                 :            :   unsigned weakref : 1;
     510                 :            :   /* C++ frontend produce same body aliases and extra name aliases for
     511                 :            :      virtual functions and vtables that are obviously equivalent.
     512                 :            :      Those aliases are bit special, especially because C++ frontend
     513                 :            :      visibility code is so ugly it cannot get them right at first time
     514                 :            :      and their visibility needs to be copied from their "masters" at
     515                 :            :      the end of parsing.  */
     516                 :            :   unsigned cpp_implicit_alias : 1;
     517                 :            :   /* The alias is a symbol version.  */
     518                 :            :   unsigned symver : 1;
     519                 :            :   /* Set once the definition was analyzed.  The list of references and
     520                 :            :      other properties are built during analysis.  */
     521                 :            :   unsigned analyzed : 1;
     522                 :            :   /* Set for write-only variables.  */
     523                 :            :   unsigned writeonly : 1;
     524                 :            :   /* Visibility of symbol was used for further optimization; do not
     525                 :            :      permit further changes.  */
     526                 :            :   unsigned refuse_visibility_changes : 1;
     527                 :            : 
     528                 :            :   /*** Visibility and linkage flags.  ***/
     529                 :            : 
     530                 :            :   /* Set when function is visible by other units.  */
     531                 :            :   unsigned externally_visible : 1;
     532                 :            :   /* Don't reorder to other symbols having this set.  */
     533                 :            :   unsigned no_reorder : 1;
     534                 :            :   /* The symbol will be assumed to be used in an invisible way (like
     535                 :            :      by an toplevel asm statement).  */
     536                 :            :   unsigned force_output : 1;
     537                 :            :   /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
     538                 :            :      exported.  Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
     539                 :            :      to static and it does not inhibit optimization.  */
     540                 :            :   unsigned forced_by_abi : 1;
     541                 :            :   /* True when the name is known to be unique and thus it does not need mangling.  */
     542                 :            :   unsigned unique_name : 1;
     543                 :            :   /* Specify whether the section was set by user or by
     544                 :            :      compiler via -ffunction-sections.  */
     545                 :            :   unsigned implicit_section : 1;
     546                 :            :   /* True when body and other characteristics have been removed by
     547                 :            :      symtab_remove_unreachable_nodes. */
     548                 :            :   unsigned body_removed : 1;
     549                 :            : 
     550                 :            :   /*** WHOPR Partitioning flags.
     551                 :            :        These flags are used at ltrans stage when only part of the callgraph is
     552                 :            :        available. ***/
     553                 :            : 
     554                 :            :   /* Set when variable is used from other LTRANS partition.  */
     555                 :            :   unsigned used_from_other_partition : 1;
     556                 :            :   /* Set when function is available in the other LTRANS partition.
     557                 :            :      During WPA output it is used to mark nodes that are present in
     558                 :            :      multiple partitions.  */
     559                 :            :   unsigned in_other_partition : 1;
     560                 :            : 
     561                 :            : 
     562                 :            : 
     563                 :            :   /*** other flags.  ***/
     564                 :            : 
     565                 :            :   /* Set when symbol has address taken. */
     566                 :            :   unsigned address_taken : 1;
     567                 :            :   /* Set when init priority is set.  */
     568                 :            :   unsigned in_init_priority_hash : 1;
     569                 :            : 
     570                 :            :   /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
     571                 :            :      of offloading, for separate compilation for a different target.  */
     572                 :            :   unsigned need_lto_streaming : 1;
     573                 :            : 
     574                 :            :   /* Set when symbol can be streamed into bytecode for offloading.  */
     575                 :            :   unsigned offloadable : 1;
     576                 :            : 
     577                 :            :   /* Set when symbol is an IFUNC resolver.  */
     578                 :            :   unsigned ifunc_resolver : 1;
     579                 :            : 
     580                 :            : 
     581                 :            :   /* Ordering of all symtab entries.  */
     582                 :            :   int order;
     583                 :            : 
     584                 :            :   /* Declaration representing the symbol.  */
     585                 :            :   tree decl;
     586                 :            : 
     587                 :            :   /* Linked list of symbol table entries starting with symtab_nodes.  */
     588                 :            :   symtab_node *next;
     589                 :            :   symtab_node *previous;
     590                 :            : 
     591                 :            :   /* Linked list of symbols with the same asm name.  There may be multiple
     592                 :            :      entries for single symbol name during LTO, because symbols are renamed
     593                 :            :      only after partitioning.
     594                 :            : 
     595                 :            :      Because inline clones are kept in the assembler name has, they also produce
     596                 :            :      duplicate entries.
     597                 :            : 
     598                 :            :      There are also several long standing bugs where frontends and builtin
     599                 :            :      code produce duplicated decls.  */
     600                 :            :   symtab_node *next_sharing_asm_name;
     601                 :            :   symtab_node *previous_sharing_asm_name;
     602                 :            : 
     603                 :            :   /* Circular list of nodes in the same comdat group if non-NULL.  */
     604                 :            :   symtab_node *same_comdat_group;
     605                 :            : 
     606                 :            :   /* Vectors of referring and referenced entities.  */
     607                 :            :   ipa_ref_list ref_list;
     608                 :            : 
     609                 :            :   /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
     610                 :            :      depending to what was known to frontend on the creation time.
     611                 :            :      Once alias is resolved, this pointer become NULL.  */
     612                 :            :   tree alias_target;
     613                 :            : 
     614                 :            :   /* File stream where this node is being written to.  */
     615                 :            :   struct lto_file_decl_data * lto_file_data;
     616                 :            : 
     617                 :            :   PTR GTY ((skip)) aux;
     618                 :            : 
     619                 :            :   /* Comdat group the symbol is in.  Can be private if GGC allowed that.  */
     620                 :            :   tree x_comdat_group;
     621                 :            : 
     622                 :            :   /* Section name. Again can be private, if allowed.  */
     623                 :            :   section_hash_entry *x_section;
     624                 :            : 
     625                 :            : protected:
     626                 :            :   /* Dump base fields of symtab nodes to F.  Not to be used directly.  */
     627                 :            :   void dump_base (FILE *);
     628                 :            : 
     629                 :            :   /* Verify common part of symtab node.  */
     630                 :            :   bool DEBUG_FUNCTION verify_base (void);
     631                 :            : 
     632                 :            :   /* Remove node from symbol table.  This function is not used directly, but via
     633                 :            :      cgraph/varpool node removal routines.  */
     634                 :            :   void unregister (void);
     635                 :            : 
     636                 :            :   /* Return the initialization and finalization priority information for
     637                 :            :      DECL.  If there is no previous priority information, a freshly
     638                 :            :      allocated structure is returned.  */
     639                 :            :   struct symbol_priority_map *priority_info (void);
     640                 :            : 
     641                 :            :   /* Worker for call_for_symbol_and_aliases_1.  */
     642                 :            :   bool call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *, void *),
     643                 :            :                                       void *data,
     644                 :            :                                       bool include_overwrite);
     645                 :            : private:
     646                 :            :   /* Worker for set_section.  */
     647                 :            :   static bool set_section (symtab_node *n, void *s);
     648                 :            : 
     649                 :            :   /* Worker for symtab_resolve_alias.  */
     650                 :            :   static bool set_implicit_section (symtab_node *n, void *);
     651                 :            : 
     652                 :            :   /* Worker searching noninterposable alias.  */
     653                 :            :   static bool noninterposable_alias (symtab_node *node, void *data);
     654                 :            : 
     655                 :            :   /* Worker for ultimate_alias_target.  */
     656                 :            :   symtab_node *ultimate_alias_target_1 (enum availability *avail = NULL,
     657                 :            :                                         symtab_node *ref = NULL);
     658                 :            : 
     659                 :            :   /* Get dump name with normal or assembly name.  */
     660                 :            :   const char *get_dump_name (bool asm_name_p) const;
     661                 :            : };
     662                 :            : 
     663                 :            : inline void
     664                 :    1550120 : symtab_node::checking_verify_symtab_nodes (void)
     665                 :            : {
     666                 :    1550120 :   if (flag_checking)
     667                 :    1550005 :     symtab_node::verify_symtab_nodes ();
     668                 :            : }
     669                 :            : 
     670                 :            : /* Walk all aliases for NODE.  */
     671                 :            : #define FOR_EACH_ALIAS(NODE, ALIAS)                             \
     672                 :            :   for (unsigned ALIAS##_iter_ = 0;                              \
     673                 :            :        (NODE)->iterate_direct_aliases (ALIAS##_iter_, ALIAS);        \
     674                 :            :        ALIAS##_iter_++)
     675                 :            : 
     676                 :            : /* This is the information that is put into the cgraph local structure
     677                 :            :    to recover a function.  */
     678                 :            : struct lto_file_decl_data;
     679                 :            : 
     680                 :            : extern const char * const cgraph_availability_names[];
     681                 :            : extern const char * const ld_plugin_symbol_resolution_names[];
     682                 :            : extern const char * const tls_model_names[];
     683                 :            : 
     684                 :            : /* Sub-structure of cgraph_node.  Holds information about thunk, used only for
     685                 :            :    same body aliases.
     686                 :            : 
     687                 :            :    Thunks are basically wrappers around methods which are introduced in case
     688                 :            :    of multiple inheritance in order to adjust the value of the "this" pointer
     689                 :            :    or of the returned value.
     690                 :            : 
     691                 :            :    In the case of this-adjusting thunks, each back-end can override the
     692                 :            :    can_output_mi_thunk/output_mi_thunk target hooks to generate a minimal thunk
     693                 :            :    (with a tail call for instance) directly as assembly.  For the default hook
     694                 :            :    or for the case where the can_output_mi_thunk hooks return false, the thunk
     695                 :            :    is gimplified and lowered using the regular machinery.  */
     696                 :            : 
     697                 :            : struct GTY(()) cgraph_thunk_info {
     698                 :            :   /* Offset used to adjust "this".  */
     699                 :            :   HOST_WIDE_INT fixed_offset;
     700                 :            : 
     701                 :            :   /* Offset in the virtual table to get the offset to adjust "this".  Valid iff
     702                 :            :      VIRTUAL_OFFSET_P is true.  */
     703                 :            :   HOST_WIDE_INT virtual_value;
     704                 :            : 
     705                 :            :   /* Offset from "this" to get the offset to adjust "this".  Zero means: this
     706                 :            :      offset is to be ignored.  */
     707                 :            :   HOST_WIDE_INT indirect_offset;
     708                 :            : 
     709                 :            :   /* Thunk target, i.e. the method that this thunk wraps.  Depending on the
     710                 :            :      TARGET_USE_LOCAL_THUNK_ALIAS_P macro, this may have to be a new alias.  */
     711                 :            :   tree alias;
     712                 :            : 
     713                 :            :   /* Nonzero for a "this" adjusting thunk and zero for a result adjusting
     714                 :            :      thunk.  */
     715                 :            :   bool this_adjusting;
     716                 :            : 
     717                 :            :   /* If true, this thunk is what we call a virtual thunk.  In this case:
     718                 :            :      * for this-adjusting thunks, after the FIXED_OFFSET based adjustment is
     719                 :            :        done, add to the result the offset found in the vtable at:
     720                 :            :          vptr + VIRTUAL_VALUE
     721                 :            :      * for result-adjusting thunks, the FIXED_OFFSET adjustment is done after
     722                 :            :        the virtual one.  */
     723                 :            :   bool virtual_offset_p;
     724                 :            : 
     725                 :            :   /* Set to true when alias node (the cgraph_node to which this struct belong)
     726                 :            :      is a thunk.  Access to any other fields is invalid if this is false.  */
     727                 :            :   bool thunk_p;
     728                 :            : };
     729                 :            : 
     730                 :            : /* Represent which DECL tree (or reference to such tree)
     731                 :            :    will be replaced by another tree while versioning.  */
     732                 :            : struct GTY(()) ipa_replace_map
     733                 :            : {
     734                 :            :   /* The new (replacing) tree.  */
     735                 :            :   tree new_tree;
     736                 :            :   /* Parameter number to replace, when old_tree is NULL.  */
     737                 :            :   int parm_num;
     738                 :            : };
     739                 :            : 
     740                 :            : struct GTY(()) cgraph_clone_info
     741                 :            : {
     742                 :            :   /* Constants discovered by IPA-CP, i.e. which parameter should be replaced
     743                 :            :      with what.  */
     744                 :            :   vec<ipa_replace_map *, va_gc> *tree_map;
     745                 :            :   /* Parameter modification that IPA-SRA decided to perform.  */
     746                 :            :   ipa_param_adjustments *param_adjustments;
     747                 :            :   /* Lists of dummy-decl and offset pairs representing split formal parameters
     748                 :            :      in the caller.  Offsets of all new replacements are enumerated, those
     749                 :            :      coming from the same original parameter have the same dummy decl stored
     750                 :            :      along with them.
     751                 :            : 
     752                 :            :      Dummy decls sit in call statement arguments followed by new parameter
     753                 :            :      decls (or their SSA names) in between (caller) clone materialization and
     754                 :            :      call redirection.  Redirection then recognizes the dummy variable and
     755                 :            :      together with the stored offsets can reconstruct what exactly the new
     756                 :            :      parameter decls represent and can leave in place only those that the
     757                 :            :      callee expects.  */
     758                 :            :   vec<ipa_param_performed_split, va_gc> *performed_splits;
     759                 :            : };
     760                 :            : 
     761                 :            : enum cgraph_simd_clone_arg_type
     762                 :            : {
     763                 :            :   SIMD_CLONE_ARG_TYPE_VECTOR,
     764                 :            :   SIMD_CLONE_ARG_TYPE_UNIFORM,
     765                 :            :   /* These are only for integer/pointer arguments passed by value.  */
     766                 :            :   SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
     767                 :            :   SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
     768                 :            :   /* These 6 are only for reference type arguments or arguments passed
     769                 :            :      by reference.  */
     770                 :            :   SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP,
     771                 :            :   SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP,
     772                 :            :   SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP,
     773                 :            :   SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP,
     774                 :            :   SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP,
     775                 :            :   SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP,
     776                 :            :   SIMD_CLONE_ARG_TYPE_MASK
     777                 :            : };
     778                 :            : 
     779                 :            : /* Function arguments in the original function of a SIMD clone.
     780                 :            :    Supplementary data for `struct simd_clone'.  */
     781                 :            : 
     782                 :            : struct GTY(()) cgraph_simd_clone_arg {
     783                 :            :   /* Original function argument as it originally existed in
     784                 :            :      DECL_ARGUMENTS.  */
     785                 :            :   tree orig_arg;
     786                 :            : 
     787                 :            :   /* orig_arg's function (or for extern functions type from
     788                 :            :      TYPE_ARG_TYPES).  */
     789                 :            :   tree orig_type;
     790                 :            : 
     791                 :            :   /* If argument is a vector, this holds the vector version of
     792                 :            :      orig_arg that after adjusting the argument types will live in
     793                 :            :      DECL_ARGUMENTS.  Otherwise, this is NULL.
     794                 :            : 
     795                 :            :      This basically holds:
     796                 :            :        vector(simdlen) __typeof__(orig_arg) new_arg.  */
     797                 :            :   tree vector_arg;
     798                 :            : 
     799                 :            :   /* vector_arg's type (or for extern functions new vector type.  */
     800                 :            :   tree vector_type;
     801                 :            : 
     802                 :            :   /* If argument is a vector, this holds the array where the simd
     803                 :            :      argument is held while executing the simd clone function.  This
     804                 :            :      is a local variable in the cloned function.  Its content is
     805                 :            :      copied from vector_arg upon entry to the clone.
     806                 :            : 
     807                 :            :      This basically holds:
     808                 :            :        __typeof__(orig_arg) simd_array[simdlen].  */
     809                 :            :   tree simd_array;
     810                 :            : 
     811                 :            :   /* A SIMD clone's argument can be either linear (constant or
     812                 :            :      variable), uniform, or vector.  */
     813                 :            :   enum cgraph_simd_clone_arg_type arg_type;
     814                 :            : 
     815                 :            :   /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
     816                 :            :      the constant linear step, if arg_type is
     817                 :            :      SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
     818                 :            :      the uniform argument holding the step, otherwise 0.  */
     819                 :            :   HOST_WIDE_INT linear_step;
     820                 :            : 
     821                 :            :   /* Variable alignment if available, otherwise 0.  */
     822                 :            :   unsigned int alignment;
     823                 :            : };
     824                 :            : 
     825                 :            : /* Specific data for a SIMD function clone.  */
     826                 :            : 
     827                 :            : struct GTY(()) cgraph_simd_clone {
     828                 :            :   /* Number of words in the SIMD lane associated with this clone.  */
     829                 :            :   unsigned int simdlen;
     830                 :            : 
     831                 :            :   /* Number of annotated function arguments in `args'.  This is
     832                 :            :      usually the number of named arguments in FNDECL.  */
     833                 :            :   unsigned int nargs;
     834                 :            : 
     835                 :            :   /* Max hardware vector size in bits for integral vectors.  */
     836                 :            :   unsigned int vecsize_int;
     837                 :            : 
     838                 :            :   /* Max hardware vector size in bits for floating point vectors.  */
     839                 :            :   unsigned int vecsize_float;
     840                 :            : 
     841                 :            :   /* Machine mode of the mask argument(s), if they are to be passed
     842                 :            :      as bitmasks in integer argument(s).  VOIDmode if masks are passed
     843                 :            :      as vectors of characteristic type.  */
     844                 :            :   machine_mode mask_mode;
     845                 :            : 
     846                 :            :   /* The mangling character for a given vector size.  This is used
     847                 :            :      to determine the ISA mangling bit as specified in the Intel
     848                 :            :      Vector ABI.  */
     849                 :            :   unsigned char vecsize_mangle;
     850                 :            : 
     851                 :            :   /* True if this is the masked, in-branch version of the clone,
     852                 :            :      otherwise false.  */
     853                 :            :   unsigned int inbranch : 1;
     854                 :            : 
     855                 :            :   /* Doubly linked list of SIMD clones.  */
     856                 :            :   cgraph_node *prev_clone, *next_clone;
     857                 :            : 
     858                 :            :   /* Original cgraph node the SIMD clones were created for.  */
     859                 :            :   cgraph_node *origin;
     860                 :            : 
     861                 :            :   /* Annotated function arguments for the original function.  */
     862                 :            :   cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
     863                 :            : };
     864                 :            : 
     865                 :            : /* Function Multiversioning info.  */
     866                 :            : struct GTY((for_user)) cgraph_function_version_info {
     867                 :            :   /* The cgraph_node for which the function version info is stored.  */
     868                 :            :   cgraph_node *this_node;
     869                 :            :   /* Chains all the semantically identical function versions.  The
     870                 :            :      first function in this chain is the version_info node of the
     871                 :            :      default function.  */
     872                 :            :   cgraph_function_version_info *prev;
     873                 :            :   /* If this version node corresponds to a dispatcher for function
     874                 :            :      versions, this points to the version info node of the default
     875                 :            :      function, the first node in the chain.  */
     876                 :            :   cgraph_function_version_info *next;
     877                 :            :   /* If this node corresponds to a function version, this points
     878                 :            :      to the dispatcher function decl, which is the function that must
     879                 :            :      be called to execute the right function version at run-time.
     880                 :            : 
     881                 :            :      If this cgraph node is a dispatcher (if dispatcher_function is
     882                 :            :      true, in the cgraph_node struct) for function versions, this
     883                 :            :      points to resolver function, which holds the function body of the
     884                 :            :      dispatcher. The dispatcher decl is an alias to the resolver
     885                 :            :      function decl.  */
     886                 :            :   tree dispatcher_resolver;
     887                 :            : };
     888                 :            : 
     889                 :            : #define DEFCIFCODE(code, type, string)  CIF_ ## code,
     890                 :            : /* Reasons for inlining failures.  */
     891                 :            : 
     892                 :            : enum cgraph_inline_failed_t {
     893                 :            : #include "cif-code.def"
     894                 :            :   CIF_N_REASONS
     895                 :            : };
     896                 :            : 
     897                 :            : enum cgraph_inline_failed_type_t
     898                 :            : {
     899                 :            :   CIF_FINAL_NORMAL = 0,
     900                 :            :   CIF_FINAL_ERROR
     901                 :            : };
     902                 :            : 
     903                 :            : struct cgraph_edge;
     904                 :            : 
     905                 :            : struct cgraph_edge_hasher : ggc_ptr_hash<cgraph_edge>
     906                 :            : {
     907                 :            :   typedef gimple *compare_type;
     908                 :            : 
     909                 :            :   static hashval_t hash (cgraph_edge *);
     910                 :            :   static hashval_t hash (gimple *);
     911                 :            :   static bool equal (cgraph_edge *, gimple *);
     912                 :            : };
     913                 :            : 
     914                 :            : /* The cgraph data structure.
     915                 :            :    Each function decl has assigned cgraph_node listing callees and callers.  */
     916                 :            : 
     917                 :            : struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node
     918                 :            : {
     919                 :            :   friend class symbol_table;
     920                 :            : 
     921                 :            :   /* Constructor.  */
     922                 :   38530800 :   explicit cgraph_node (int uid)
     923                 :   38530800 :     : symtab_node (SYMTAB_FUNCTION), callees (NULL), callers (NULL),
     924                 :            :       indirect_calls (NULL), origin (NULL), nested (NULL), next_nested (NULL),
     925                 :            :       next_sibling_clone (NULL), prev_sibling_clone (NULL), clones (NULL),
     926                 :            :       clone_of (NULL), call_site_hash (NULL), former_clone_of (NULL),
     927                 :            :       simdclone (NULL), simd_clones (NULL), ipa_transforms_to_apply (vNULL),
     928                 :            :       inlined_to (NULL), rtl (NULL), clone (), thunk (),
     929                 :   38530800 :       count (profile_count::uninitialized ()),
     930                 :            :       count_materialization_scale (REG_BR_PROB_BASE), profile_id (0),
     931                 :            :       unit_id (0), tp_first_run (0), used_as_abstract_origin (false),
     932                 :            :       lowered (false), process (false), frequency (NODE_FREQUENCY_NORMAL),
     933                 :            :       only_called_at_startup (false), only_called_at_exit (false),
     934                 :            :       tm_clone (false), dispatcher_function (false), calls_comdat_local (false),
     935                 :            :       icf_merged (false), nonfreeing_fn (false), merged_comdat (false),
     936                 :            :       merged_extern_inline (false), parallelized_function (false),
     937                 :            :       split_part (false), indirect_call_target (false), local (false),
     938                 :            :       versionable (false), can_change_signature (false),
     939                 :            :       redefined_extern_inline (false), tm_may_enter_irr (false),
     940                 :   38530800 :       ipcp_clone (false), m_uid (uid), m_summary_id (-1)
     941                 :   38530800 :   {}
     942                 :            : 
     943                 :            :   /* Remove the node from cgraph and all inline clones inlined into it.
     944                 :            :      Skip however removal of FORBIDDEN_NODE and return true if it needs to be
     945                 :            :      removed.  This allows to call the function from outer loop walking clone
     946                 :            :      tree.  */
     947                 :            :   bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
     948                 :            : 
     949                 :            :   /* Record all references from cgraph_node that are taken
     950                 :            :      in statement STMT.  */
     951                 :            :   void record_stmt_references (gimple *stmt);
     952                 :            : 
     953                 :            :   /* Like cgraph_set_call_stmt but walk the clone tree and update all
     954                 :            :      clones sharing the same function body.
     955                 :            :      When WHOLE_SPECULATIVE_EDGES is true, all three components of
     956                 :            :      speculative edge gets updated.  Otherwise we update only direct
     957                 :            :      call.  */
     958                 :            :   void set_call_stmt_including_clones (gimple *old_stmt, gcall *new_stmt,
     959                 :            :                                        bool update_speculative = true);
     960                 :            : 
     961                 :            :   /* Walk the alias chain to return the function cgraph_node is alias of.
     962                 :            :      Walk through thunk, too.
     963                 :            :      When AVAILABILITY is non-NULL, get minimal availability in the chain. 
     964                 :            :      When REF is non-NULL, assume that reference happens in symbol REF
     965                 :            :      when determining the availability.  */
     966                 :            :   cgraph_node *function_symbol (enum availability *avail = NULL,
     967                 :            :                                 struct symtab_node *ref = NULL);
     968                 :            : 
     969                 :            :   /* Walk the alias chain to return the function cgraph_node is alias of.
     970                 :            :      Walk through non virtual thunks, too.  Thus we return either a function
     971                 :            :      or a virtual thunk node.
     972                 :            :      When AVAILABILITY is non-NULL, get minimal availability in the chain.  
     973                 :            :      When REF is non-NULL, assume that reference happens in symbol REF
     974                 :            :      when determining the availability.  */
     975                 :            :   cgraph_node *function_or_virtual_thunk_symbol
     976                 :            :                                 (enum availability *avail = NULL,
     977                 :            :                                  struct symtab_node *ref = NULL);
     978                 :            : 
     979                 :            :   /* Create node representing clone of N executed COUNT times.  Decrease
     980                 :            :      the execution counts from original node too.
     981                 :            :      The new clone will have decl set to DECL that may or may not be the same
     982                 :            :      as decl of N.
     983                 :            : 
     984                 :            :      When UPDATE_ORIGINAL is true, the counts are subtracted from the original
     985                 :            :      function's profile to reflect the fact that part of execution is handled
     986                 :            :      by node.
     987                 :            :      When CALL_DUPLICATION_HOOK is true, the ipa passes are acknowledged about
     988                 :            :      the new clone. Otherwise the caller is responsible for doing so later.
     989                 :            : 
     990                 :            :      If the new node is being inlined into another one, NEW_INLINED_TO should be
     991                 :            :      the outline function the new one is (even indirectly) inlined to.
     992                 :            :      All hooks will see this in node's inlined_to, when invoked.
     993                 :            :      Can be NULL if the node is not inlined.  SUFFIX is string that is appended
     994                 :            :      to the original name.  */
     995                 :            :   cgraph_node *create_clone (tree decl, profile_count count,
     996                 :            :                              bool update_original,
     997                 :            :                              vec<cgraph_edge *> redirect_callers,
     998                 :            :                              bool call_duplication_hook,
     999                 :            :                              cgraph_node *new_inlined_to,
    1000                 :            :                              ipa_param_adjustments *param_adjustments,
    1001                 :            :                              const char *suffix = NULL);
    1002                 :            : 
    1003                 :            :   /* Create callgraph node clone with new declaration.  The actual body will be
    1004                 :            :      copied later at compilation stage.  The name of the new clone will be
    1005                 :            :      constructed from the name of the original node, SUFFIX and NUM_SUFFIX.  */
    1006                 :            :   cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
    1007                 :            :                                      vec<ipa_replace_map *, va_gc> *tree_map,
    1008                 :            :                                      ipa_param_adjustments *param_adjustments,
    1009                 :            :                                      const char * suffix, unsigned num_suffix);
    1010                 :            : 
    1011                 :            :   /* Remove the node from the tree of virtual and inline clones and make it a
    1012                 :            :      standalone node - not a clone any more.  */
    1013                 :            :   void remove_from_clone_tree ();
    1014                 :            : 
    1015                 :            :   /* cgraph node being removed from symbol table; see if its entry can be
    1016                 :            :    replaced by other inline clone.  */
    1017                 :            :   cgraph_node *find_replacement (void);
    1018                 :            : 
    1019                 :            :   /* Create a new cgraph node which is the new version of
    1020                 :            :      callgraph node.  REDIRECT_CALLERS holds the callers
    1021                 :            :      edges which should be redirected to point to
    1022                 :            :      NEW_VERSION.  ALL the callees edges of the node
    1023                 :            :      are cloned to the new version node.  Return the new
    1024                 :            :      version node.
    1025                 :            : 
    1026                 :            :      If non-NULL BLOCK_TO_COPY determine what basic blocks
    1027                 :            :      was copied to prevent duplications of calls that are dead
    1028                 :            :      in the clone.
    1029                 :            : 
    1030                 :            :      SUFFIX is string that is appended to the original name.  */
    1031                 :            : 
    1032                 :            :   cgraph_node *create_version_clone (tree new_decl,
    1033                 :            :                                     vec<cgraph_edge *> redirect_callers,
    1034                 :            :                                     bitmap bbs_to_copy,
    1035                 :            :                                     const char *suffix = NULL);
    1036                 :            : 
    1037                 :            :   /* Perform function versioning.
    1038                 :            :      Function versioning includes copying of the tree and
    1039                 :            :      a callgraph update (creating a new cgraph node and updating
    1040                 :            :      its callees and callers).
    1041                 :            : 
    1042                 :            :      REDIRECT_CALLERS varray includes the edges to be redirected
    1043                 :            :      to the new version.
    1044                 :            : 
    1045                 :            :      TREE_MAP is a mapping of tree nodes we want to replace with
    1046                 :            :      new ones (according to results of prior analysis).
    1047                 :            : 
    1048                 :            :      If non-NULL ARGS_TO_SKIP determine function parameters to remove
    1049                 :            :      from new version.
    1050                 :            :      If SKIP_RETURN is true, the new version will return void.
    1051                 :            :      If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
    1052                 :            :      If non_NULL NEW_ENTRY determine new entry BB of the clone.
    1053                 :            : 
    1054                 :            :      If TARGET_ATTRIBUTES is non-null, when creating a new declaration,
    1055                 :            :      add the attributes to DECL_ATTRIBUTES.  And call valid_attribute_p
    1056                 :            :      that will promote value of the attribute DECL_FUNCTION_SPECIFIC_TARGET
    1057                 :            :      of the declaration.
    1058                 :            : 
    1059                 :            :      Return the new version's cgraph node.  */
    1060                 :            :   cgraph_node *create_version_clone_with_body
    1061                 :            :     (vec<cgraph_edge *> redirect_callers,
    1062                 :            :      vec<ipa_replace_map *, va_gc> *tree_map,
    1063                 :            :      ipa_param_adjustments *param_adjustments,
    1064                 :            :      bitmap bbs_to_copy, basic_block new_entry_block, const char *clone_name,
    1065                 :            :      tree target_attributes = NULL_TREE);
    1066                 :            : 
    1067                 :            :   /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
    1068                 :            :      corresponding to cgraph_node.  */
    1069                 :            :   cgraph_function_version_info *insert_new_function_version (void);
    1070                 :            : 
    1071                 :            :   /* Get the cgraph_function_version_info node corresponding to node.  */
    1072                 :            :   cgraph_function_version_info *function_version (void);
    1073                 :            : 
    1074                 :            :   /* Discover all functions and variables that are trivially needed, analyze
    1075                 :            :      them as well as all functions and variables referred by them  */
    1076                 :            :   void analyze (void);
    1077                 :            : 
    1078                 :            :   /* Add thunk alias into callgraph.  The alias declaration is ALIAS and it
    1079                 :            :      aliases DECL with an adjustments made into the first parameter.
    1080                 :            :      See comments in struct cgraph_thunk_info for detail on the parameters.  */
    1081                 :            :   cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
    1082                 :            :                               HOST_WIDE_INT fixed_offset,
    1083                 :            :                               HOST_WIDE_INT virtual_value,
    1084                 :            :                               HOST_WIDE_INT indirect_offset,
    1085                 :            :                               tree virtual_offset,
    1086                 :            :                               tree real_alias);
    1087                 :            : 
    1088                 :            : 
    1089                 :            :   /* Return node that alias is aliasing.  */
    1090                 :            :   inline cgraph_node *get_alias_target (void);
    1091                 :            : 
    1092                 :            :   /* Given function symbol, walk the alias chain to return the function node
    1093                 :            :      is alias of. Do not walk through thunks.
    1094                 :            :      When AVAILABILITY is non-NULL, get minimal availability in the chain.
    1095                 :            :      When REF is non-NULL, assume that reference happens in symbol REF
    1096                 :            :      when determining the availability.  */
    1097                 :            : 
    1098                 :            :   cgraph_node *ultimate_alias_target (availability *availability = NULL,
    1099                 :            :                                       symtab_node *ref = NULL);
    1100                 :            : 
    1101                 :            :   /* Expand thunk NODE to gimple if possible.
    1102                 :            :      When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
    1103                 :            :      no assembler is produced.
    1104                 :            :      When OUTPUT_ASM_THUNK is true, also produce assembler for
    1105                 :            :      thunks that are not lowered.  */
    1106                 :            :   bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk);
    1107                 :            : 
    1108                 :            :   /*  Call expand_thunk on all callers that are thunks and analyze those
    1109                 :            :       nodes that were expanded.  */
    1110                 :            :   void expand_all_artificial_thunks ();
    1111                 :            : 
    1112                 :            :   /* Assemble thunks and aliases associated to node.  */
    1113                 :            :   void assemble_thunks_and_aliases (void);
    1114                 :            : 
    1115                 :            :   /* Expand function specified by node.  */
    1116                 :            :   void expand (void);
    1117                 :            : 
    1118                 :            :   /* As an GCC extension we allow redefinition of the function.  The
    1119                 :            :      semantics when both copies of bodies differ is not well defined.
    1120                 :            :      We replace the old body with new body so in unit at a time mode
    1121                 :            :      we always use new body, while in normal mode we may end up with
    1122                 :            :      old body inlined into some functions and new body expanded and
    1123                 :            :      inlined in others.  */
    1124                 :            :   void reset (void);
    1125                 :            : 
    1126                 :            :   /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
    1127                 :            :      kind of wrapper method.  */
    1128                 :            :   void create_wrapper (cgraph_node *target);
    1129                 :            : 
    1130                 :            :   /* Verify cgraph nodes of the cgraph node.  */
    1131                 :            :   void DEBUG_FUNCTION verify_node (void);
    1132                 :            : 
    1133                 :            :   /* Remove function from symbol table.  */
    1134                 :            :   void remove (void);
    1135                 :            : 
    1136                 :            :   /* Dump call graph node to file F.  */
    1137                 :            :   void dump (FILE *f);
    1138                 :            : 
    1139                 :            :   /* Dump call graph node to file F.  */
    1140                 :            :   void dump_graphviz (FILE *f);
    1141                 :            : 
    1142                 :            :   /* Dump call graph node to stderr.  */
    1143                 :            :   void DEBUG_FUNCTION debug (void);
    1144                 :            : 
    1145                 :            :   /* When doing LTO, read cgraph_node's body from disk if it is not already
    1146                 :            :      present.  */
    1147                 :            :   bool get_untransformed_body (void);
    1148                 :            : 
    1149                 :            :   /* Prepare function body.  When doing LTO, read cgraph_node's body from disk 
    1150                 :            :      if it is not already present.  When some IPA transformations are scheduled,
    1151                 :            :      apply them.  */
    1152                 :            :   bool get_body (void);
    1153                 :            : 
    1154                 :            :   /* Release memory used to represent body of function.
    1155                 :            :      Use this only for functions that are released before being translated to
    1156                 :            :      target code (i.e. RTL).  Functions that are compiled to RTL and beyond
    1157                 :            :      are free'd in final.c via free_after_compilation().  */
    1158                 :            :   void release_body (bool keep_arguments = false);
    1159                 :            : 
    1160                 :            :   /* Return the DECL_STRUCT_FUNCTION of the function.  */
    1161                 :            :   struct function *get_fun () const;
    1162                 :            : 
    1163                 :            :   /* cgraph_node is no longer nested function; update cgraph accordingly.  */
    1164                 :            :   void unnest (void);
    1165                 :            : 
    1166                 :            :   /* Bring cgraph node local.  */
    1167                 :            :   void make_local (void);
    1168                 :            : 
    1169                 :            :   /* Likewise indicate that a node is having address taken.  */
    1170                 :            :   void mark_address_taken (void);
    1171                 :            : 
    1172                 :            :   /* Set finalization priority to PRIORITY.  */
    1173                 :            :   void set_fini_priority (priority_type priority);
    1174                 :            : 
    1175                 :            :   /* Return the finalization priority.  */
    1176                 :            :   priority_type get_fini_priority (void);
    1177                 :            : 
    1178                 :            :   /* Create edge from a given function to CALLEE in the cgraph.  */
    1179                 :            :   cgraph_edge *create_edge (cgraph_node *callee,
    1180                 :            :                             gcall *call_stmt, profile_count count,
    1181                 :            :                             bool cloning_p = false);
    1182                 :            : 
    1183                 :            :   /* Create an indirect edge with a yet-undetermined callee where the call
    1184                 :            :      statement destination is a formal parameter of the caller with index
    1185                 :            :      PARAM_INDEX. */
    1186                 :            :   cgraph_edge *create_indirect_edge (gcall *call_stmt, int ecf_flags,
    1187                 :            :                                      profile_count count,
    1188                 :            :                                      bool cloning_p = false);
    1189                 :            : 
    1190                 :            :   /* Like cgraph_create_edge walk the clone tree and update all clones sharing
    1191                 :            :    same function body.  If clones already have edge for OLD_STMT; only
    1192                 :            :    update the edge same way as cgraph_set_call_stmt_including_clones does.  */
    1193                 :            :   void create_edge_including_clones (cgraph_node *callee,
    1194                 :            :                                      gimple *old_stmt, gcall *stmt,
    1195                 :            :                                      profile_count count,
    1196                 :            :                                      cgraph_inline_failed_t reason);
    1197                 :            : 
    1198                 :            :   /* Return the callgraph edge representing the GIMPLE_CALL statement
    1199                 :            :      CALL_STMT.  */
    1200                 :            :   cgraph_edge *get_edge (gimple *call_stmt);
    1201                 :            : 
    1202                 :            :   /* Collect all callers of cgraph_node and its aliases that are known to lead
    1203                 :            :      to NODE (i.e. are not overwritable) and that are not thunks.  */
    1204                 :            :   vec<cgraph_edge *> collect_callers (void);
    1205                 :            : 
    1206                 :            :   /* Remove all callers from the node.  */
    1207                 :            :   void remove_callers (void);
    1208                 :            : 
    1209                 :            :   /* Remove all callees from the node.  */
    1210                 :            :   void remove_callees (void);
    1211                 :            : 
    1212                 :            :   /* Return function availability.  See cgraph.h for description of individual
    1213                 :            :      return values.  */
    1214                 :            :   enum availability get_availability (symtab_node *ref = NULL);
    1215                 :            : 
    1216                 :            :   /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
    1217                 :            :      if any to NOTHROW.  */
    1218                 :            :   bool set_nothrow_flag (bool nothrow);
    1219                 :            : 
    1220                 :            :   /* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node
    1221                 :            :      if any.  */
    1222                 :            :   bool set_malloc_flag (bool malloc_p);
    1223                 :            : 
    1224                 :            :   /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
    1225                 :            :     If SET_CONST if false, clear the flag.
    1226                 :            : 
    1227                 :            :     When setting the flag be careful about possible interposition and
    1228                 :            :     do not set the flag for functions that can be interposed and set pure
    1229                 :            :     flag for functions that can bind to other definition. 
    1230                 :            : 
    1231                 :            :     Return true if any change was done. */
    1232                 :            : 
    1233                 :            :   bool set_const_flag (bool set_const, bool looping);
    1234                 :            : 
    1235                 :            :   /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
    1236                 :            :      if any to PURE.
    1237                 :            : 
    1238                 :            :      When setting the flag, be careful about possible interposition.
    1239                 :            :      Return true if any change was done. */
    1240                 :            : 
    1241                 :            :   bool set_pure_flag (bool pure, bool looping);
    1242                 :            : 
    1243                 :            :   /* Call callback on function and aliases associated to the function.
    1244                 :            :      When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
    1245                 :            :      skipped. */
    1246                 :            : 
    1247                 :            :   bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
    1248                 :            :                                                       void *),
    1249                 :            :                                     void *data, bool include_overwritable);
    1250                 :            : 
    1251                 :            :   /* Call callback on cgraph_node, thunks and aliases associated to NODE.
    1252                 :            :      When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
    1253                 :            :      skipped.  When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
    1254                 :            :      skipped.  */
    1255                 :            :   bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
    1256                 :            :                                                              void *data),
    1257                 :            :                                            void *data,
    1258                 :            :                                            bool include_overwritable,
    1259                 :            :                                            bool exclude_virtual_thunks = false);
    1260                 :            : 
    1261                 :            :   /* Likewise indicate that a node is needed, i.e. reachable via some
    1262                 :            :      external means.  */
    1263                 :            :   inline void mark_force_output (void);
    1264                 :            : 
    1265                 :            :   /* Return true when function can be marked local.  */
    1266                 :            :   bool local_p (void);
    1267                 :            : 
    1268                 :            :   /* Return true if cgraph_node can be made local for API change.
    1269                 :            :      Extern inline functions and C++ COMDAT functions can be made local
    1270                 :            :      at the expense of possible code size growth if function is used in multiple
    1271                 :            :      compilation units.  */
    1272                 :            :   bool can_be_local_p (void);
    1273                 :            : 
    1274                 :            :   /* Return true when cgraph_node cannot return or throw and thus
    1275                 :            :      it is safe to ignore its side effects for IPA analysis.  */
    1276                 :            :   bool cannot_return_p (void);
    1277                 :            : 
    1278                 :            :   /* Return true when function cgraph_node and all its aliases are only called
    1279                 :            :      directly.
    1280                 :            :      i.e. it is not externally visible, address was not taken and
    1281                 :            :      it is not used in any other non-standard way.  */
    1282                 :            :   bool only_called_directly_p (void);
    1283                 :            : 
    1284                 :            :   /* Return true when function is only called directly or it has alias.
    1285                 :            :      i.e. it is not externally visible, address was not taken and
    1286                 :            :      it is not used in any other non-standard way.  */
    1287                 :            :   inline bool only_called_directly_or_aliased_p (void);
    1288                 :            : 
    1289                 :            :   /* Return true when function cgraph_node can be expected to be removed
    1290                 :            :      from program when direct calls in this compilation unit are removed.
    1291                 :            : 
    1292                 :            :      As a special case COMDAT functions are
    1293                 :            :      cgraph_can_remove_if_no_direct_calls_p while the are not
    1294                 :            :      cgraph_only_called_directly_p (it is possible they are called from other
    1295                 :            :      unit)
    1296                 :            : 
    1297                 :            :      This function behaves as cgraph_only_called_directly_p because eliminating
    1298                 :            :      all uses of COMDAT function does not make it necessarily disappear from
    1299                 :            :      the program unless we are compiling whole program or we do LTO.  In this
    1300                 :            :      case we know we win since dynamic linking will not really discard the
    1301                 :            :      linkonce section.  
    1302                 :            : 
    1303                 :            :      If WILL_INLINE is true, assume that function will be inlined into all the
    1304                 :            :      direct calls.  */
    1305                 :            :   bool will_be_removed_from_program_if_no_direct_calls_p
    1306                 :            :          (bool will_inline = false);
    1307                 :            : 
    1308                 :            :   /* Return true when function can be removed from callgraph
    1309                 :            :      if all direct calls and references are eliminated.  The function does
    1310                 :            :      not take into account comdat groups.  */
    1311                 :            :   bool can_remove_if_no_direct_calls_and_refs_p (void);
    1312                 :            : 
    1313                 :            :   /* Return true when function cgraph_node and its aliases can be removed from
    1314                 :            :      callgraph if all direct calls are eliminated. 
    1315                 :            :      If WILL_INLINE is true, assume that function will be inlined into all the
    1316                 :            :      direct calls.  */
    1317                 :            :   bool can_remove_if_no_direct_calls_p (bool will_inline = false);
    1318                 :            : 
    1319                 :            :   /* Return true when callgraph node is a function with Gimple body defined
    1320                 :            :      in current unit.  Functions can also be define externally or they
    1321                 :            :      can be thunks with no Gimple representation.
    1322                 :            : 
    1323                 :            :      Note that at WPA stage, the function body may not be present in memory.  */
    1324                 :            :   inline bool has_gimple_body_p (void);
    1325                 :            : 
    1326                 :            :   /* Return true if this node represents a former, i.e. an expanded, thunk.  */
    1327                 :            :   inline bool former_thunk_p (void);
    1328                 :            : 
    1329                 :            :   /* Check if function calls comdat local.  This is used to recompute
    1330                 :            :      calls_comdat_local flag after function transformations.  */
    1331                 :            :   bool check_calls_comdat_local_p ();
    1332                 :            : 
    1333                 :            :   /* Return true if function should be optimized for size.  */
    1334                 :            :   bool optimize_for_size_p (void);
    1335                 :            : 
    1336                 :            :   /* Dump the callgraph to file F.  */
    1337                 :            :   static void dump_cgraph (FILE *f);
    1338                 :            : 
    1339                 :            :   /* Dump the call graph to stderr.  */
    1340                 :            :   static inline
    1341                 :            :   void debug_cgraph (void)
    1342                 :            :   {
    1343                 :            :     dump_cgraph (stderr);
    1344                 :            :   }
    1345                 :            : 
    1346                 :            :   /* Get unique identifier of the node.  */
    1347                 :   84992944 :   inline int get_uid ()
    1348                 :            :   {
    1349                 :   84968044 :     return m_uid;
    1350                 :            :   }
    1351                 :            : 
    1352                 :            :   /* Get summary id of the node.  */
    1353                 :  298243996 :   inline int get_summary_id ()
    1354                 :            :   {
    1355                 :  293646796 :     return m_summary_id;
    1356                 :            :   }
    1357                 :            : 
    1358                 :            :   /* Record that DECL1 and DECL2 are semantically identical function
    1359                 :            :      versions.  */
    1360                 :            :   static void record_function_versions (tree decl1, tree decl2);
    1361                 :            : 
    1362                 :            :   /* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
    1363                 :            :      DECL is a duplicate declaration.  */
    1364                 :            :   static void delete_function_version_by_decl (tree decl);
    1365                 :            : 
    1366                 :            :   /* Add the function FNDECL to the call graph.
    1367                 :            :      Unlike finalize_function, this function is intended to be used
    1368                 :            :      by middle end and allows insertion of new function at arbitrary point
    1369                 :            :      of compilation.  The function can be either in high, low or SSA form
    1370                 :            :      GIMPLE.
    1371                 :            : 
    1372                 :            :      The function is assumed to be reachable and have address taken (so no
    1373                 :            :      API breaking optimizations are performed on it).
    1374                 :            : 
    1375                 :            :      Main work done by this function is to enqueue the function for later
    1376                 :            :      processing to avoid need the passes to be re-entrant.  */
    1377                 :            :   static void add_new_function (tree fndecl, bool lowered);
    1378                 :            : 
    1379                 :            :   /* Return callgraph node for given symbol and check it is a function. */
    1380                 : 2288719884 :   static inline cgraph_node *get (const_tree decl)
    1381                 :            :   {
    1382                 : 2288719884 :     gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
    1383                 : 2288719884 :     return dyn_cast <cgraph_node *> (symtab_node::get (decl));
    1384                 :            :   }
    1385                 :            : 
    1386                 :            :   /* DECL has been parsed.  Take it, queue it, compile it at the whim of the
    1387                 :            :      logic in effect.  If NO_COLLECT is true, then our caller cannot stand to
    1388                 :            :      have the garbage collector run at the moment.  We would need to either
    1389                 :            :      create a new GC context, or just not compile right now.  */
    1390                 :            :   static void finalize_function (tree, bool);
    1391                 :            : 
    1392                 :            :   /* Return cgraph node assigned to DECL.  Create new one when needed.  */
    1393                 :            :   static cgraph_node * create (tree decl);
    1394                 :            : 
    1395                 :            :   /* Try to find a call graph node for declaration DECL and if it does not
    1396                 :            :      exist or if it corresponds to an inline clone, create a new one.  */
    1397                 :            :   static cgraph_node * get_create (tree);
    1398                 :            : 
    1399                 :            :   /* Return local info for the compiled function.  */
    1400                 :            :   static cgraph_node *local_info_node (tree decl);
    1401                 :            : 
    1402                 :            :   /* Return RTL info for the compiled function.  */
    1403                 :            :   static struct cgraph_rtl_info *rtl_info (const_tree);
    1404                 :            : 
    1405                 :            :   /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
    1406                 :            :      Return NULL if there's no such node.  */
    1407                 :            :   static cgraph_node *get_for_asmname (tree asmname);
    1408                 :            : 
    1409                 :            :   /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if
    1410                 :            :      successful and NULL otherwise.
    1411                 :            :      Same body aliases are output whenever the body of DECL is output,
    1412                 :            :      and cgraph_node::get (ALIAS) transparently
    1413                 :            :      returns cgraph_node::get (DECL).  */
    1414                 :            :   static cgraph_node * create_same_body_alias (tree alias, tree decl);
    1415                 :            : 
    1416                 :            :   /* Verify whole cgraph structure.  */
    1417                 :            :   static void DEBUG_FUNCTION verify_cgraph_nodes (void);
    1418                 :            : 
    1419                 :            :   /* Verify cgraph, if consistency checking is enabled.  */
    1420                 :            :   static inline void checking_verify_cgraph_nodes (void);
    1421                 :            : 
    1422                 :            :   /* Worker to bring NODE local.  */
    1423                 :            :   static bool make_local (cgraph_node *node, void *);
    1424                 :            : 
    1425                 :            :   /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
    1426                 :            :      the function body is associated
    1427                 :            :      with (not necessarily cgraph_node (DECL).  */
    1428                 :            :   static cgraph_node *create_alias (tree alias, tree target);
    1429                 :            : 
    1430                 :            :   /* Return true if NODE has thunk.  */
    1431                 :            :   static bool has_thunk_p (cgraph_node *node, void *);
    1432                 :            : 
    1433                 :            :   cgraph_edge *callees;
    1434                 :            :   cgraph_edge *callers;
    1435                 :            :   /* List of edges representing indirect calls with a yet undetermined
    1436                 :            :      callee.  */
    1437                 :            :   cgraph_edge *indirect_calls;
    1438                 :            :   /* For nested functions points to function the node is nested in.  */
    1439                 :            :   cgraph_node *origin;
    1440                 :            :   /* Points to first nested function, if any.  */
    1441                 :            :   cgraph_node *nested;
    1442                 :            :   /* Pointer to the next function with same origin, if any.  */
    1443                 :            :   cgraph_node *next_nested;
    1444                 :            :   /* Pointer to the next clone.  */
    1445                 :            :   cgraph_node *next_sibling_clone;
    1446                 :            :   cgraph_node *prev_sibling_clone;
    1447                 :            :   cgraph_node *clones;
    1448                 :            :   cgraph_node *clone_of;
    1449                 :            :   /* For functions with many calls sites it holds map from call expression
    1450                 :            :      to the edge to speed up cgraph_edge function.  */
    1451                 :            :   hash_table<cgraph_edge_hasher> *GTY(()) call_site_hash;
    1452                 :            :   /* Declaration node used to be clone of. */
    1453                 :            :   tree former_clone_of;
    1454                 :            : 
    1455                 :            :   /* If this is a SIMD clone, this points to the SIMD specific
    1456                 :            :      information for it.  */
    1457                 :            :   cgraph_simd_clone *simdclone;
    1458                 :            :   /* If this function has SIMD clones, this points to the first clone.  */
    1459                 :            :   cgraph_node *simd_clones;
    1460                 :            : 
    1461                 :            :   /* Interprocedural passes scheduled to have their transform functions
    1462                 :            :      applied next time we execute local pass on them.  We maintain it
    1463                 :            :      per-function in order to allow IPA passes to introduce new functions.  */
    1464                 :            :   vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
    1465                 :            : 
    1466                 :            :   /* For inline clones this points to the function they will be
    1467                 :            :      inlined into.  */
    1468                 :            :   cgraph_node *inlined_to;
    1469                 :            : 
    1470                 :            :   struct cgraph_rtl_info *rtl;
    1471                 :            :   cgraph_clone_info clone;
    1472                 :            :   cgraph_thunk_info thunk;
    1473                 :            : 
    1474                 :            :   /* Expected number of executions: calculated in profile.c.  */
    1475                 :            :   profile_count count;
    1476                 :            :   /* How to scale counts at materialization time; used to merge
    1477                 :            :      LTO units with different number of profile runs.  */
    1478                 :            :   int count_materialization_scale;
    1479                 :            :   /* ID assigned by the profiling.  */
    1480                 :            :   unsigned int profile_id;
    1481                 :            :   /* ID of the translation unit.  */
    1482                 :            :   int unit_id;
    1483                 :            :   /* Time profiler: first run of function.  */
    1484                 :            :   int tp_first_run;
    1485                 :            : 
    1486                 :            :   /* Set when decl is an abstract function pointed to by the
    1487                 :            :      ABSTRACT_DECL_ORIGIN of a reachable function.  */
    1488                 :            :   unsigned used_as_abstract_origin : 1;
    1489                 :            :   /* Set once the function is lowered (i.e. its CFG is built).  */
    1490                 :            :   unsigned lowered : 1;
    1491                 :            :   /* Set once the function has been instantiated and its callee
    1492                 :            :      lists created.  */
    1493                 :            :   unsigned process : 1;
    1494                 :            :   /* How commonly executed the node is.  Initialized during branch
    1495                 :            :      probabilities pass.  */
    1496                 :            :   ENUM_BITFIELD (node_frequency) frequency : 2;
    1497                 :            :   /* True when function can only be called at startup (from static ctor).  */
    1498                 :            :   unsigned only_called_at_startup : 1;
    1499                 :            :   /* True when function can only be called at startup (from static dtor).  */
    1500                 :            :   unsigned only_called_at_exit : 1;
    1501                 :            :   /* True when function is the transactional clone of a function which
    1502                 :            :      is called only from inside transactions.  */
    1503                 :            :   /* ?? We should be able to remove this.  We have enough bits in
    1504                 :            :      cgraph to calculate it.  */
    1505                 :            :   unsigned tm_clone : 1;
    1506                 :            :   /* True if this decl is a dispatcher for function versions.  */
    1507                 :            :   unsigned dispatcher_function : 1;
    1508                 :            :   /* True if this decl calls a COMDAT-local function.  This is set up in
    1509                 :            :      compute_fn_summary and inline_call.  */
    1510                 :            :   unsigned calls_comdat_local : 1;
    1511                 :            :   /* True if node has been created by merge operation in IPA-ICF.  */
    1512                 :            :   unsigned icf_merged: 1;
    1513                 :            :   /* True if call to node can't result in a call to free, munmap or
    1514                 :            :      other operation that could make previously non-trapping memory
    1515                 :            :      accesses trapping.  */
    1516                 :            :   unsigned nonfreeing_fn : 1;
    1517                 :            :   /* True if there was multiple COMDAT bodies merged by lto-symtab.  */
    1518                 :            :   unsigned merged_comdat : 1;
    1519                 :            :   /* True if this def was merged with extern inlines.  */
    1520                 :            :   unsigned merged_extern_inline : 1;
    1521                 :            :   /* True if function was created to be executed in parallel.  */
    1522                 :            :   unsigned parallelized_function : 1;
    1523                 :            :   /* True if function is part split out by ipa-split.  */
    1524                 :            :   unsigned split_part : 1;
    1525                 :            :   /* True if the function appears as possible target of indirect call.  */
    1526                 :            :   unsigned indirect_call_target : 1;
    1527                 :            :   /* Set when function is visible in current compilation unit only and
    1528                 :            :      its address is never taken.  */
    1529                 :            :   unsigned local : 1;
    1530                 :            :   /* False when there is something makes versioning impossible.  */
    1531                 :            :   unsigned versionable : 1;
    1532                 :            :   /* False when function calling convention and signature cannot be changed.
    1533                 :            :      This is the case when __builtin_apply_args is used.  */
    1534                 :            :   unsigned can_change_signature : 1;
    1535                 :            :   /* True when the function has been originally extern inline, but it is
    1536                 :            :      redefined now.  */
    1537                 :            :   unsigned redefined_extern_inline : 1;
    1538                 :            :   /* True if the function may enter serial irrevocable mode.  */
    1539                 :            :   unsigned tm_may_enter_irr : 1;
    1540                 :            :   /* True if this was a clone created by ipa-cp.  */
    1541                 :            :   unsigned ipcp_clone : 1;
    1542                 :            : 
    1543                 :            : private:
    1544                 :            :   /* Unique id of the node.  */
    1545                 :            :   int m_uid;
    1546                 :            : 
    1547                 :            :   /* Summary id that is recycled.  */
    1548                 :            :   int m_summary_id;
    1549                 :            : 
    1550                 :            :   /* Worker for call_for_symbol_and_aliases.  */
    1551                 :            :   bool call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
    1552                 :            :                                                         void *),
    1553                 :            :                                       void *data, bool include_overwritable);
    1554                 :            : };
    1555                 :            : 
    1556                 :            : /* A cgraph node set is a collection of cgraph nodes.  A cgraph node
    1557                 :            :    can appear in multiple sets.  */
    1558                 :            : struct cgraph_node_set_def
    1559                 :            : {
    1560                 :            :   hash_map<cgraph_node *, size_t> *map;
    1561                 :            :   vec<cgraph_node *> nodes;
    1562                 :            : };
    1563                 :            : 
    1564                 :            : typedef cgraph_node_set_def *cgraph_node_set;
    1565                 :            : typedef struct varpool_node_set_def *varpool_node_set;
    1566                 :            : 
    1567                 :            : struct varpool_node;
    1568                 :            : 
    1569                 :            : /* A varpool node set is a collection of varpool nodes.  A varpool node
    1570                 :            :    can appear in multiple sets.  */
    1571                 :            : struct varpool_node_set_def
    1572                 :            : {
    1573                 :            :   hash_map<varpool_node *, size_t> * map;
    1574                 :            :   vec<varpool_node *> nodes;
    1575                 :            : };
    1576                 :            : 
    1577                 :            : /* Iterator structure for cgraph node sets.  */
    1578                 :            : struct cgraph_node_set_iterator
    1579                 :            : {
    1580                 :            :   cgraph_node_set set;
    1581                 :            :   unsigned index;
    1582                 :            : };
    1583                 :            : 
    1584                 :            : /* Iterator structure for varpool node sets.  */
    1585                 :            : struct varpool_node_set_iterator
    1586                 :            : {
    1587                 :            :   varpool_node_set set;
    1588                 :            :   unsigned index;
    1589                 :            : };
    1590                 :            : 
    1591                 :            : /* Context of polymorphic call. It represent information about the type of
    1592                 :            :    instance that may reach the call.  This is used by ipa-devirt walkers of the
    1593                 :            :    type inheritance graph.  */
    1594                 :            : 
    1595                 :            : class GTY(()) ipa_polymorphic_call_context {
    1596                 :            : public:
    1597                 :            :   /* The called object appears in an object of type OUTER_TYPE
    1598                 :            :      at offset OFFSET.  When information is not 100% reliable, we
    1599                 :            :      use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
    1600                 :            :   HOST_WIDE_INT offset;
    1601                 :            :   HOST_WIDE_INT speculative_offset;
    1602                 :            :   tree outer_type;
    1603                 :            :   tree speculative_outer_type;
    1604                 :            :   /* True if outer object may be in construction or destruction.  */
    1605                 :            :   unsigned maybe_in_construction : 1;
    1606                 :            :   /* True if outer object may be of derived type.  */
    1607                 :            :   unsigned maybe_derived_type : 1;
    1608                 :            :   /* True if speculative outer object may be of derived type.  We always
    1609                 :            :      speculate that construction does not happen.  */
    1610                 :            :   unsigned speculative_maybe_derived_type : 1;
    1611                 :            :   /* True if the context is invalid and all calls should be redirected
    1612                 :            :      to BUILTIN_UNREACHABLE.  */
    1613                 :            :   unsigned invalid : 1;
    1614                 :            :   /* True if the outer type is dynamic.  */
    1615                 :            :   unsigned dynamic : 1;
    1616                 :            : 
    1617                 :            :   /* Build empty "I know nothing" context.  */
    1618                 :            :   ipa_polymorphic_call_context ();
    1619                 :            :   /* Build polymorphic call context for indirect call E.  */
    1620                 :            :   ipa_polymorphic_call_context (cgraph_edge *e);
    1621                 :            :   /* Build polymorphic call context for IP invariant CST.
    1622                 :            :      If specified, OTR_TYPE specify the type of polymorphic call
    1623                 :            :      that takes CST+OFFSET as a parameter.  */
    1624                 :            :   ipa_polymorphic_call_context (tree cst, tree otr_type = NULL,
    1625                 :            :                                 HOST_WIDE_INT offset = 0);
    1626                 :            :   /* Build context for pointer REF contained in FNDECL at statement STMT.
    1627                 :            :      if INSTANCE is non-NULL, return pointer to the object described by
    1628                 :            :      the context.  */
    1629                 :            :   ipa_polymorphic_call_context (tree fndecl, tree ref, gimple *stmt,
    1630                 :            :                                 tree *instance = NULL);
    1631                 :            : 
    1632                 :            :   /* Look for vtable stores or constructor calls to work out dynamic type
    1633                 :            :      of memory location.  */
    1634                 :            :   bool get_dynamic_type (tree, tree, tree, gimple *, unsigned *);
    1635                 :            : 
    1636                 :            :   /* Make context non-speculative.  */
    1637                 :            :   void clear_speculation ();
    1638                 :            : 
    1639                 :            :   /* Produce context specifying all derived types of OTR_TYPE.  If OTR_TYPE is
    1640                 :            :      NULL, the context is set to dummy "I know nothing" setting.  */
    1641                 :            :   void clear_outer_type (tree otr_type = NULL);
    1642                 :            : 
    1643                 :            :   /* Walk container types and modify context to point to actual class
    1644                 :            :      containing OTR_TYPE (if non-NULL) as base class.
    1645                 :            :      Return true if resulting context is valid.
    1646                 :            : 
    1647                 :            :      When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
    1648                 :            :      valid only via allocation of new polymorphic type inside by means
    1649                 :            :      of placement new.
    1650                 :            : 
    1651                 :            :      When CONSIDER_BASES is false, only look for actual fields, not base types
    1652                 :            :      of TYPE.  */
    1653                 :            :   bool restrict_to_inner_class (tree otr_type,
    1654                 :            :                                 bool consider_placement_new = true,
    1655                 :            :                                 bool consider_bases = true);
    1656                 :            : 
    1657                 :            :   /* Adjust all offsets in contexts by given number of bits.  */
    1658                 :            :   void offset_by (HOST_WIDE_INT);
    1659                 :            :   /* Use when we cannot track dynamic type change.  This speculatively assume
    1660                 :            :      type change is not happening.  */
    1661                 :            :   void possible_dynamic_type_change (bool, tree otr_type = NULL);
    1662                 :            :   /* Assume that both THIS and a given context is valid and strengthen THIS
    1663                 :            :      if possible.  Return true if any strengthening was made.
    1664                 :            :      If actual type the context is being used in is known, OTR_TYPE should be
    1665                 :            :      set accordingly. This improves quality of combined result.  */
    1666                 :            :   bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULL);
    1667                 :            :   bool meet_with (ipa_polymorphic_call_context, tree otr_type = NULL);
    1668                 :            : 
    1669                 :            :   /* Return TRUE if context is fully useless.  */
    1670                 :            :   bool useless_p () const;
    1671                 :            :   /* Return TRUE if this context conveys the same information as X.  */
    1672                 :            :   bool equal_to (const ipa_polymorphic_call_context &x) const;
    1673                 :            : 
    1674                 :            :   /* Dump human readable context to F.  If NEWLINE is true, it will be
    1675                 :            :      terminated by a newline.  */
    1676                 :            :   void dump (FILE *f, bool newline = true) const;
    1677                 :            :   void DEBUG_FUNCTION debug () const;
    1678                 :            : 
    1679                 :            :   /* LTO streaming.  */
    1680                 :            :   void stream_out (struct output_block *) const;
    1681                 :            :   void stream_in (class lto_input_block *, class data_in *data_in);
    1682                 :            : 
    1683                 :            : private:
    1684                 :            :   bool combine_speculation_with (tree, HOST_WIDE_INT, bool, tree);
    1685                 :            :   bool meet_speculation_with (tree, HOST_WIDE_INT, bool, tree);
    1686                 :            :   void set_by_decl (tree, HOST_WIDE_INT);
    1687                 :            :   bool set_by_invariant (tree, tree, HOST_WIDE_INT);
    1688                 :            :   bool speculation_consistent_p (tree, HOST_WIDE_INT, bool, tree) const;
    1689                 :            :   void make_speculative (tree otr_type = NULL);
    1690                 :            : };
    1691                 :            : 
    1692                 :            : /* Structure containing additional information about an indirect call.  */
    1693                 :            : 
    1694                 :            : class GTY(()) cgraph_indirect_call_info
    1695                 :            : {
    1696                 :            : public:
    1697                 :            :   /* When agg_content is set, an offset where the call pointer is located
    1698                 :            :      within the aggregate.  */
    1699                 :            :   HOST_WIDE_INT offset;
    1700                 :            :   /* Context of the polymorphic call; use only when POLYMORPHIC flag is set.  */
    1701                 :            :   ipa_polymorphic_call_context context;
    1702                 :            :   /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set).  */
    1703                 :            :   HOST_WIDE_INT otr_token;
    1704                 :            :   /* Type of the object from OBJ_TYPE_REF_OBJECT. */
    1705                 :            :   tree otr_type;
    1706                 :            :   /* Index of the parameter that is called.  */
    1707                 :            :   int param_index;
    1708                 :            :   /* ECF flags determined from the caller.  */
    1709                 :            :   int ecf_flags;
    1710                 :            : 
    1711                 :            :   /* Number of speculative call targets, it's less than GCOV_TOPN_VALUES.  */
    1712                 :            :   unsigned num_speculative_call_targets : 16;
    1713                 :            : 
    1714                 :            :   /* Set when the call is a virtual call with the parameter being the
    1715                 :            :      associated object pointer rather than a simple direct call.  */
    1716                 :            :   unsigned polymorphic : 1;
    1717                 :            :   /* Set when the call is a call of a pointer loaded from contents of an
    1718                 :            :      aggregate at offset.  */
    1719                 :            :   unsigned agg_contents : 1;
    1720                 :            :   /* Set when this is a call through a member pointer.  */
    1721                 :            :   unsigned member_ptr : 1;
    1722                 :            :   /* When the agg_contents bit is set, this one determines whether the
    1723                 :            :      destination is loaded from a parameter passed by reference. */
    1724                 :            :   unsigned by_ref : 1;
    1725                 :            :   /* When the agg_contents bit is set, this one determines whether we can
    1726                 :            :      deduce from the function body that the loaded value from the reference is
    1727                 :            :      never modified between the invocation of the function and the load
    1728                 :            :      point.  */
    1729                 :            :   unsigned guaranteed_unmodified : 1;
    1730                 :            :   /* For polymorphic calls this specify whether the virtual table pointer
    1731                 :            :      may have changed in between function entry and the call.  */
    1732                 :            :   unsigned vptr_changed : 1;
    1733                 :            : };
    1734                 :            : 
    1735                 :            : class GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
    1736                 :            :            for_user)) cgraph_edge
    1737                 :            : {
    1738                 :            : public:
    1739                 :            :   friend struct cgraph_node;
    1740                 :            :   friend class symbol_table;
    1741                 :            : 
    1742                 :            :   /* Remove EDGE from the cgraph.  */
    1743                 :            :   static void remove (cgraph_edge *edge);
    1744                 :            : 
    1745                 :            :   /* Change field call_stmt of edge E to NEW_STMT.  If UPDATE_SPECULATIVE and E
    1746                 :            :      is any component of speculative edge, then update all components.
    1747                 :            :      Speculations can be resolved in the process and EDGE can be removed and
    1748                 :            :      deallocated.  Return the edge that now represents the call.  */
    1749                 :            :   static cgraph_edge *set_call_stmt (cgraph_edge *e, gcall *new_stmt,
    1750                 :            :                                      bool update_speculative = true);
    1751                 :            : 
    1752                 :            :   /* Redirect callee of the edge to N.  The function does not update underlying
    1753                 :            :      call expression.  */
    1754                 :            :   void redirect_callee (cgraph_node *n);
    1755                 :            : 
    1756                 :            :   /* If the edge does not lead to a thunk, simply redirect it to N.  Otherwise
    1757                 :            :      create one or more equivalent thunks for N and redirect E to the first in
    1758                 :            :      the chain.  Note that it is then necessary to call
    1759                 :            :      n->expand_all_artificial_thunks once all callers are redirected.  */
    1760                 :            :   void redirect_callee_duplicating_thunks (cgraph_node *n);
    1761                 :            : 
    1762                 :            :   /* Make an indirect edge with an unknown callee an ordinary edge leading to
    1763                 :            :      CALLEE.  Speculations can be resolved in the process and EDGE can be
    1764                 :            :      removed and deallocated.  Return the edge that now represents the
    1765                 :            :      call.  */
    1766                 :            :   static cgraph_edge *make_direct (cgraph_edge *edge, cgraph_node *callee);
    1767                 :            : 
    1768                 :            :   /* Turn edge into speculative call calling N2. Update
    1769                 :            :      the profile so the direct call is taken COUNT times
    1770                 :            :      with FREQUENCY.  speculative_id is used to link direct calls with their
    1771                 :            :      corresponding IPA_REF_ADDR references when representing speculative calls.
    1772                 :            :    */
    1773                 :            :   cgraph_edge *make_speculative (cgraph_node *n2, profile_count direct_count,
    1774                 :            :                                  unsigned int speculative_id = 0);
    1775                 :            : 
    1776                 :            :   /* Speculative call consists of an indirect edge and one or more
    1777                 :            :      direct edge+ref pairs.  Speculative will expand to the following sequence:
    1778                 :            : 
    1779                 :            :      if (call_dest == target1)          // reference to target1
    1780                 :            :         target1 ();                     // direct call to target1
    1781                 :            :      else if (call_dest == target2)     // reference to targt2
    1782                 :            :         target2 ();                     // direct call to target2
    1783                 :            :      else
    1784                 :            :         call_dest ();                   // indirect call
    1785                 :            : 
    1786                 :            :      Before the expansion we will have indirect call and the direct call+ref
    1787                 :            :      pairs all linked to single statement.
    1788                 :            : 
    1789                 :            :      Note that ref may point to different symbol than the corresponding call
    1790                 :            :      becuase the speculated edge may have been optimized (redirected to
    1791                 :            :      a clone) or inlined.
    1792                 :            : 
    1793                 :            :      Given an edge which is part of speculative call, return the first
    1794                 :            :      direct call edge in the speculative call sequence.
    1795                 :            : 
    1796                 :            :      In the example above called on any cgraph edge in the sequence it will
    1797                 :            :      return direct call to target1.  */
    1798                 :            :   cgraph_edge *first_speculative_call_target ();
    1799                 :            : 
    1800                 :            :   /* Return next speculative call target or NULL if there is none.
    1801                 :            :      All targets are required to form an interval in the callee list.
    1802                 :            : 
    1803                 :            :      In example above, if called on call to target1 it will return call to
    1804                 :            :      target2.  */
    1805                 :      25272 :   cgraph_edge *next_speculative_call_target ()
    1806                 :            :   {
    1807                 :      25272 :     cgraph_edge *e = this;
    1808                 :      25272 :     gcc_checking_assert (speculative && callee);
    1809                 :            : 
    1810                 :      25272 :     if (e->next_callee && e->next_callee->speculative
    1811                 :       1458 :         && e->next_callee->call_stmt == e->call_stmt
    1812                 :          7 :         && e->next_callee->lto_stmt_uid == e->lto_stmt_uid)
    1813                 :          7 :       return e->next_callee;
    1814                 :            :     return NULL;
    1815                 :            :   }
    1816                 :            : 
    1817                 :            :   /* When called on any edge in the speculative call return the (unique)
    1818                 :            :      indirect call edge in the speculative call sequence.  */
    1819                 :      21373 :   cgraph_edge *speculative_call_indirect_edge ()
    1820                 :            :   {
    1821                 :      21373 :     gcc_checking_assert (speculative);
    1822                 :      21373 :     if (!callee)
    1823                 :            :       return this;
    1824                 :      21084 :     for (cgraph_edge *e2 = caller->indirect_calls;
    1825                 :       6016 :          true; e2 = e2->next_callee)
    1826                 :      27100 :       if (e2->speculative
    1827                 :      27100 :           && call_stmt == e2->call_stmt
    1828                 :      21090 :           && lto_stmt_uid == e2->lto_stmt_uid)
    1829                 :      21084 :         return e2;
    1830                 :            :   }
    1831                 :            : 
    1832                 :            :   /* When called on any edge in speculative call and when given any target
    1833                 :            :      of ref which is speculated to it returns the corresponding direct call.
    1834                 :            : 
    1835                 :            :      In example above if called on function target2 it will return call to
    1836                 :            :      target2.  */
    1837                 :            :   cgraph_edge *speculative_call_for_target (cgraph_node *);
    1838                 :            : 
    1839                 :            :   /* Return REF corresponding to direct call in the specualtive call
    1840                 :            :      sequence.  */
    1841                 :      17796 :   ipa_ref *speculative_call_target_ref ()
    1842                 :            :   {
    1843                 :      17796 :     ipa_ref *ref;
    1844                 :            : 
    1845                 :      17796 :     gcc_checking_assert (speculative);
    1846                 :      49045 :     for (unsigned int i = 0; caller->iterate_reference (i, ref); i++)
    1847                 :      20172 :       if (ref->speculative && ref->speculative_id == speculative_id
    1848                 :      20166 :           && ref->stmt == (gimple *)call_stmt
    1849                 :      17802 :           && ref->lto_stmt_uid == lto_stmt_uid)
    1850                 :      17796 :         return ref;
    1851                 :          0 :     gcc_unreachable ();
    1852                 :            :   }
    1853                 :            : 
    1854                 :            :   /* Speculative call edge turned out to be direct call to CALLEE_DECL.  Remove
    1855                 :            :      the speculative call sequence and return edge representing the call, the
    1856                 :            :      original EDGE can be removed and deallocated.  It is up to caller to
    1857                 :            :      redirect the call as appropriate.  Return the edge that now represents the
    1858                 :            :      call.
    1859                 :            : 
    1860                 :            :      For "speculative" indirect call that contains multiple "speculative"
    1861                 :            :      targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
    1862                 :            :      decrease the count and only remove current direct edge.
    1863                 :            : 
    1864                 :            :      If no speculative direct call left to the speculative indirect call, remove
    1865                 :            :      the speculative of both the indirect call and corresponding direct edge.
    1866                 :            : 
    1867                 :            :      It is up to caller to iteratively resolve each "speculative" direct call
    1868                 :            :      and redirect the call as appropriate.  */
    1869                 :            :   static cgraph_edge *resolve_speculation (cgraph_edge *edge,
    1870                 :            :                                            tree callee_decl = NULL);
    1871                 :            : 
    1872                 :            :   /* If necessary, change the function declaration in the call statement
    1873                 :            :      associated with edge E so that it corresponds to the edge callee.
    1874                 :            :      Speculations can be resolved in the process and EDGE can be removed and
    1875                 :            :      deallocated.
    1876                 :            : 
    1877                 :            :      The edge could be one of speculative direct call generated from speculative
    1878                 :            :      indirect call.  In this circumstance, decrease the speculative targets
    1879                 :            :      count (i.e. num_speculative_call_targets) and redirect call stmt to the
    1880                 :            :      corresponding i-th target.  If no speculative direct call left to the
    1881                 :            :      speculative indirect call, remove "speculative" of the indirect call and
    1882                 :            :      also redirect stmt to it's final direct target.
    1883                 :            : 
    1884                 :            :      It is up to caller to iteratively transform each "speculative"
    1885                 :            :      direct call as appropriate.  */
    1886                 :            :   static gimple *redirect_call_stmt_to_callee (cgraph_edge *e);
    1887                 :            : 
    1888                 :            :   /* Create clone of edge in the node N represented
    1889                 :            :      by CALL_EXPR the callgraph.  */
    1890                 :            :   cgraph_edge * clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid,
    1891                 :            :                        profile_count num, profile_count den,
    1892                 :            :                        bool update_original);
    1893                 :            : 
    1894                 :            :   /* Verify edge count and frequency.  */
    1895                 :            :   bool verify_count ();
    1896                 :            : 
    1897                 :            :   /* Return true when call of edge cannot lead to return from caller
    1898                 :            :      and thus it is safe to ignore its side effects for IPA analysis
    1899                 :            :      when computing side effects of the caller.  */
    1900                 :            :   bool cannot_lead_to_return_p (void);
    1901                 :            : 
    1902                 :            :   /* Return true when the edge represents a direct recursion.  */
    1903                 :            :   bool recursive_p (void);
    1904                 :            : 
    1905                 :            :   /* Return true if the edge may be considered hot.  */
    1906                 :            :   bool maybe_hot_p (void);
    1907                 :            : 
    1908                 :            :   /* Get unique identifier of the edge.  */
    1909                 :   23429654 :   inline int get_uid ()
    1910                 :            :   {
    1911                 :   23429654 :     return m_uid;
    1912                 :            :   }
    1913                 :            : 
    1914                 :            :   /* Get summary id of the edge.  */
    1915                 :  231514668 :   inline int get_summary_id ()
    1916                 :            :   {
    1917                 :  231514668 :     return m_summary_id;
    1918                 :            :   }
    1919                 :            : 
    1920                 :            :   /* Rebuild cgraph edges for current function node.  This needs to be run after
    1921                 :            :      passes that don't update the cgraph.  */
    1922                 :            :   static unsigned int rebuild_edges (void);
    1923                 :            : 
    1924                 :            :   /* Rebuild cgraph references for current function node.  This needs to be run
    1925                 :            :      after passes that don't update the cgraph.  */
    1926                 :            :   static void rebuild_references (void);
    1927                 :            : 
    1928                 :            :   /* During LTO stream in this can be used to check whether call can possibly
    1929                 :            :      be internal to the current translation unit.  */
    1930                 :            :   bool possibly_call_in_translation_unit_p (void);
    1931                 :            : 
    1932                 :            :   /* Return num_speculative_targets of this edge.  */
    1933                 :            :   int num_speculative_call_targets_p (void);
    1934                 :            : 
    1935                 :            :   /* Expected number of executions: calculated in profile.c.  */
    1936                 :            :   profile_count count;
    1937                 :            :   cgraph_node *caller;
    1938                 :            :   cgraph_node *callee;
    1939                 :            :   cgraph_edge *prev_caller;
    1940                 :            :   cgraph_edge *next_caller;
    1941                 :            :   cgraph_edge *prev_callee;
    1942                 :            :   cgraph_edge *next_callee;
    1943                 :            :   gcall *call_stmt;
    1944                 :            :   /* Additional information about an indirect call.  Not cleared when an edge
    1945                 :            :      becomes direct.  */
    1946                 :            :   cgraph_indirect_call_info *indirect_info;
    1947                 :            :   PTR GTY ((skip (""))) aux;
    1948                 :            :   /* When equal to CIF_OK, inline this call.  Otherwise, points to the
    1949                 :            :      explanation why function was not inlined.  */
    1950                 :            :   enum cgraph_inline_failed_t inline_failed;
    1951                 :            :   /* The stmt_uid of call_stmt.  This is used by LTO to recover the call_stmt
    1952                 :            :      when the function is serialized in.  */
    1953                 :            :   unsigned int lto_stmt_uid;
    1954                 :            :   /* speculative id is used to link direct calls with their corresponding
    1955                 :            :      IPA_REF_ADDR references when representing speculative calls.  */
    1956                 :            :   unsigned int speculative_id : 16;
    1957                 :            :   /* Whether this edge was made direct by indirect inlining.  */
    1958                 :            :   unsigned int indirect_inlining_edge : 1;
    1959                 :            :   /* Whether this edge describes an indirect call with an undetermined
    1960                 :            :      callee.  */
    1961                 :            :   unsigned int indirect_unknown_callee : 1;
    1962                 :            :   /* Whether this edge is still a dangling  */
    1963                 :            :   /* True if the corresponding CALL stmt cannot be inlined.  */
    1964                 :            :   unsigned int call_stmt_cannot_inline_p : 1;
    1965                 :            :   /* Can this call throw externally?  */
    1966                 :            :   unsigned int can_throw_external : 1;
    1967                 :            :   /* Edges with SPECULATIVE flag represents indirect calls that was
    1968                 :            :      speculatively turned into direct (i.e. by profile feedback).
    1969                 :            :      The final code sequence will have form:
    1970                 :            : 
    1971                 :            :      if (call_target == expected_fn)
    1972                 :            :        expected_fn ();
    1973                 :            :      else
    1974                 :            :        call_target ();
    1975                 :            : 
    1976                 :            :      Every speculative call is represented by three components attached
    1977                 :            :      to a same call statement:
    1978                 :            :      1) a direct call (to expected_fn)
    1979                 :            :      2) an indirect call (to call_target)
    1980                 :            :      3) a IPA_REF_ADDR reference to expected_fn.
    1981                 :            : 
    1982                 :            :      Optimizers may later redirect direct call to clone, so 1) and 3)
    1983                 :            :      do not need to necessarily agree with destination.  */
    1984                 :            :   unsigned int speculative : 1;
    1985                 :            :   /* Set to true when caller is a constructor or destructor of polymorphic
    1986                 :            :      type.  */
    1987                 :            :   unsigned in_polymorphic_cdtor : 1;
    1988                 :            : 
    1989                 :            :   /* Return true if call must bind to current definition.  */
    1990                 :            :   bool binds_to_current_def_p ();
    1991                 :            : 
    1992                 :            :   /* Expected frequency of executions within the function.
    1993                 :            :      When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
    1994                 :            :      per function call.  The range is 0 to CGRAPH_FREQ_MAX.  */
    1995                 :            :   int frequency ();
    1996                 :            : 
    1997                 :            :   /* Expected frequency of executions within the function.  */
    1998                 :            :   sreal sreal_frequency ();
    1999                 :            : private:
    2000                 :            :   /* Unique id of the edge.  */
    2001                 :            :   int m_uid;
    2002                 :            : 
    2003                 :            :   /* Summary id that is recycled.  */
    2004                 :            :   int m_summary_id;
    2005                 :            : 
    2006                 :            :   /* Remove the edge from the list of the callers of the callee.  */
    2007                 :            :   void remove_caller (void);
    2008                 :            : 
    2009                 :            :   /* Remove the edge from the list of the callees of the caller.  */
    2010                 :            :   void remove_callee (void);
    2011                 :            : 
    2012                 :            :   /* Set callee N of call graph edge and add it to the corresponding set of
    2013                 :            :      callers. */
    2014                 :            :   void set_callee (cgraph_node *n);
    2015                 :            : 
    2016                 :            :   /* Output flags of edge to a file F.  */
    2017                 :            :   void dump_edge_flags (FILE *f);
    2018                 :            : 
    2019                 :            :   /* Verify that call graph edge corresponds to DECL from the associated
    2020                 :            :      statement.  Return true if the verification should fail.  */
    2021                 :            :   bool verify_corresponds_to_fndecl (tree decl);
    2022                 :            : };
    2023                 :            : 
    2024                 :            : #define CGRAPH_FREQ_BASE 1000
    2025                 :            : #define CGRAPH_FREQ_MAX 100000
    2026                 :            : 
    2027                 :            : /* The varpool data structure.
    2028                 :            :    Each static variable decl has assigned varpool_node.  */
    2029                 :            : 
    2030                 :            : struct GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node
    2031                 :            : {
    2032                 :            :   /* Constructor.  */
    2033                 :   10125000 :   explicit varpool_node ()
    2034                 :   10125000 :     : symtab_node (SYMTAB_VARIABLE), output (0), dynamically_initialized (0),
    2035                 :   10125000 :       tls_model (TLS_MODEL_NONE), used_by_single_function (0)
    2036                 :            :   {}
    2037                 :            : 
    2038                 :            :   /* Dump given varpool node to F.  */
    2039                 :            :   void dump (FILE *f);
    2040                 :            : 
    2041                 :            :   /* Dump given varpool node to stderr.  */
    2042                 :            :   void DEBUG_FUNCTION debug (void);
    2043                 :            : 
    2044                 :            :   /* Remove variable from symbol table.  */
    2045                 :            :   void remove (void);
    2046                 :            : 
    2047                 :            :   /* Remove node initializer when it is no longer needed.  */
    2048                 :            :   void remove_initializer (void);
    2049                 :            : 
    2050                 :            :   void analyze (void);
    2051                 :            : 
    2052                 :            :   /* Return variable availability.  */
    2053                 :            :   availability get_availability (symtab_node *ref = NULL);
    2054                 :            : 
    2055                 :            :   /* When doing LTO, read variable's constructor from disk if
    2056                 :            :      it is not already present.  */
    2057                 :            :   tree get_constructor (void);
    2058                 :            : 
    2059                 :            :   /* Return true if variable has constructor that can be used for folding.  */
    2060                 :            :   bool ctor_useable_for_folding_p (void);
    2061                 :            : 
    2062                 :            :   /* For given variable pool node, walk the alias chain to return the function
    2063                 :            :      the variable is alias of. Do not walk through thunks.
    2064                 :            :      When AVAILABILITY is non-NULL, get minimal availability in the chain.
    2065                 :            :      When REF is non-NULL, assume that reference happens in symbol REF
    2066                 :            :      when determining the availability.  */
    2067                 :            :   inline varpool_node *ultimate_alias_target
    2068                 :            :     (availability *availability = NULL, symtab_node *ref = NULL);
    2069                 :            : 
    2070                 :            :   /* Return node that alias is aliasing.  */
    2071                 :            :   inline varpool_node *get_alias_target (void);
    2072                 :            : 
    2073                 :            :   /* Output one variable, if necessary.  Return whether we output it.  */
    2074                 :            :   bool assemble_decl (void);
    2075                 :            : 
    2076                 :            :   /* For variables in named sections make sure get_variable_section
    2077                 :            :      is called before we switch to those sections.  Then section
    2078                 :            :      conflicts between read-only and read-only requiring relocations
    2079                 :            :      sections can be resolved.  */
    2080                 :            :   void finalize_named_section_flags (void);
    2081                 :            : 
    2082                 :            :   /* Call callback on varpool symbol and aliases associated to varpool symbol.
    2083                 :            :      When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
    2084                 :            :      skipped. */
    2085                 :            :   bool call_for_symbol_and_aliases (bool (*callback) (varpool_node *, void *),
    2086                 :            :                                     void *data,
    2087                 :            :                                     bool include_overwritable);
    2088                 :            : 
    2089                 :            :   /* Return true when variable should be considered externally visible.  */
    2090                 :            :   bool externally_visible_p (void);
    2091                 :            : 
    2092                 :            :   /* Return true when all references to variable must be visible
    2093                 :            :      in ipa_ref_list.
    2094                 :            :      i.e. if the variable is not externally visible or not used in some magic
    2095                 :            :      way (asm statement or such).
    2096                 :            :      The magic uses are all summarized in force_output flag.  */
    2097                 :            :   inline bool all_refs_explicit_p ();
    2098                 :            : 
    2099                 :            :   /* Return true when variable can be removed from variable pool
    2100                 :            :      if all direct calls are eliminated.  */
    2101                 :            :   inline bool can_remove_if_no_refs_p (void);
    2102                 :            : 
    2103                 :            :   /* Add the variable DECL to the varpool.
    2104                 :            :      Unlike finalize_decl function is intended to be used
    2105                 :            :      by middle end and allows insertion of new variable at arbitrary point
    2106                 :            :      of compilation.  */
    2107                 :            :   static void add (tree decl);
    2108                 :            : 
    2109                 :            :   /* Return varpool node for given symbol and check it is a function. */
    2110                 :            :   static inline varpool_node *get (const_tree decl);
    2111                 :            : 
    2112                 :            :   /* Mark DECL as finalized.  By finalizing the declaration, frontend instruct
    2113                 :            :      the middle end to output the variable to asm file, if needed or externally
    2114                 :            :      visible.  */
    2115                 :            :   static void finalize_decl (tree decl);
    2116                 :            : 
    2117                 :            :   /* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
    2118                 :            :      Extra name aliases are output whenever DECL is output.  */
    2119                 :            :   static varpool_node * create_extra_name_alias (tree alias, tree decl);
    2120                 :            : 
    2121                 :            :   /* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
    2122                 :            :      Extra name aliases are output whenever DECL is output.  */
    2123                 :            :   static varpool_node * create_alias (tree, tree);
    2124                 :            : 
    2125                 :            :   /* Dump the variable pool to F.  */
    2126                 :            :   static void dump_varpool (FILE *f);
    2127                 :            : 
    2128                 :            :   /* Dump the variable pool to stderr.  */
    2129                 :            :   static void DEBUG_FUNCTION debug_varpool (void);
    2130                 :            : 
    2131                 :            :   /* Allocate new callgraph node and insert it into basic data structures.  */
    2132                 :            :   static varpool_node *create_empty (void);
    2133                 :            : 
    2134                 :            :   /* Return varpool node assigned to DECL.  Create new one when needed.  */
    2135                 :            :   static varpool_node *get_create (tree decl);
    2136                 :            : 
    2137                 :            :   /* Given an assembler name, lookup node.  */
    2138                 :            :   static varpool_node *get_for_asmname (tree asmname);
    2139                 :            : 
    2140                 :            :   /* Set when variable is scheduled to be assembled.  */
    2141                 :            :   unsigned output : 1;
    2142                 :            : 
    2143                 :            :   /* Set if the variable is dynamically initialized, except for
    2144                 :            :      function local statics.   */
    2145                 :            :   unsigned dynamically_initialized : 1;
    2146                 :            : 
    2147                 :            :   ENUM_BITFIELD(tls_model) tls_model : 3;
    2148                 :            : 
    2149                 :            :   /* Set if the variable is known to be used by single function only.
    2150                 :            :      This is computed by ipa_single_use pass and used by late optimizations
    2151                 :            :      in places where optimization would be valid for local static variable
    2152                 :            :      if we did not do any inter-procedural code movement.  */
    2153                 :            :   unsigned used_by_single_function : 1;
    2154                 :            : 
    2155                 :            : private:
    2156                 :            :   /* Assemble thunks and aliases associated to varpool node.  */
    2157                 :            :   void assemble_aliases (void);
    2158                 :            : 
    2159                 :            :   /* Worker for call_for_node_and_aliases.  */
    2160                 :            :   bool call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *, void *),
    2161                 :            :                                       void *data,
    2162                 :            :                                       bool include_overwritable);
    2163                 :            : };
    2164                 :            : 
    2165                 :            : /* Every top level asm statement is put into a asm_node.  */
    2166                 :            : 
    2167                 :            : struct GTY(()) asm_node {
    2168                 :            : 
    2169                 :            : 
    2170                 :            :   /* Next asm node.  */
    2171                 :            :   asm_node *next;
    2172                 :            :   /* String for this asm node.  */
    2173                 :            :   tree asm_str;
    2174                 :            :   /* Ordering of all cgraph nodes.  */
    2175                 :            :   int order;
    2176                 :            : };
    2177                 :            : 
    2178                 :            : /* Report whether or not THIS symtab node is a function, aka cgraph_node.  */
    2179                 :            : 
    2180                 :            : template <>
    2181                 :            : template <>
    2182                 :            : inline bool
    2183                 : 5121091373 : is_a_helper <cgraph_node *>::test (symtab_node *p)
    2184                 :            : {
    2185                 : 4993079511 :   return p && p->type == SYMTAB_FUNCTION;
    2186                 :            : }
    2187                 :            : 
    2188                 :            : /* Report whether or not THIS symtab node is a variable, aka varpool_node.  */
    2189                 :            : 
    2190                 :            : template <>
    2191                 :            : template <>
    2192                 :            : inline bool
    2193                 : 1151979660 : is_a_helper <varpool_node *>::test (symtab_node *p)
    2194                 :            : {
    2195                 : 1151051803 :   return p && p->type == SYMTAB_VARIABLE;
    2196                 :            : }
    2197                 :            : 
    2198                 :            : typedef void (*cgraph_edge_hook)(cgraph_edge *, void *);
    2199                 :            : typedef void (*cgraph_node_hook)(cgraph_node *, void *);
    2200                 :            : typedef void (*varpool_node_hook)(varpool_node *, void *);
    2201                 :            : typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *);
    2202                 :            : typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *);
    2203                 :            : 
    2204                 :            : struct cgraph_edge_hook_list;
    2205                 :            : struct cgraph_node_hook_list;
    2206                 :            : struct varpool_node_hook_list;
    2207                 :            : struct cgraph_2edge_hook_list;
    2208                 :            : struct cgraph_2node_hook_list;
    2209                 :            : 
    2210                 :            : /* Map from a symbol to initialization/finalization priorities.  */
    2211                 :            : struct GTY(()) symbol_priority_map {
    2212                 :            :   priority_type init;
    2213                 :            :   priority_type fini;
    2214                 :            : };
    2215                 :            : 
    2216                 :            : enum symtab_state
    2217                 :            : {
    2218                 :            :   /* Frontend is parsing and finalizing functions.  */
    2219                 :            :   PARSING,
    2220                 :            :   /* Callgraph is being constructed.  It is safe to add new functions.  */
    2221                 :            :   CONSTRUCTION,
    2222                 :            :   /* Callgraph is being streamed-in at LTO time.  */
    2223                 :            :   LTO_STREAMING,
    2224                 :            :   /* Callgraph is built and early IPA passes are being run.  */
    2225                 :            :   IPA,
    2226                 :            :   /* Callgraph is built and all functions are transformed to SSA form.  */
    2227                 :            :   IPA_SSA,
    2228                 :            :   /* All inline decisions are done; it is now possible to remove extern inline
    2229                 :            :      functions and virtual call targets.  */
    2230                 :            :   IPA_SSA_AFTER_INLINING,
    2231                 :            :   /* Functions are now ordered and being passed to RTL expanders.  */
    2232                 :            :   EXPANSION,
    2233                 :            :   /* All cgraph expansion is done.  */
    2234                 :            :   FINISHED
    2235                 :            : };
    2236                 :            : 
    2237                 :            : struct asmname_hasher : ggc_ptr_hash <symtab_node>
    2238                 :            : {
    2239                 :            :   typedef const_tree compare_type;
    2240                 :            : 
    2241                 :            :   static hashval_t hash (symtab_node *n);
    2242                 :            :   static bool equal (symtab_node *n, const_tree t);
    2243                 :            : };
    2244                 :            : 
    2245                 :        852 : class GTY((tag ("SYMTAB"))) symbol_table
    2246                 :            : {
    2247                 :            : public:
    2248                 :            :   friend struct symtab_node;
    2249                 :            :   friend struct cgraph_node;
    2250                 :            :   friend struct cgraph_edge;
    2251                 :            : 
    2252                 :     200805 :   symbol_table (): 
    2253                 :            :   cgraph_count (0), cgraph_max_uid (1), cgraph_max_summary_id (0),
    2254                 :            :   edges_count (0), edges_max_uid (1), edges_max_summary_id (0),
    2255                 :            :   cgraph_released_summary_ids (), edge_released_summary_ids (),
    2256                 :            :   nodes (NULL), asmnodes (NULL), asm_last_node (NULL),
    2257                 :            :   order (0), max_unit (0), global_info_ready (false), state (PARSING),
    2258                 :            :   function_flags_ready (false), cpp_implicit_aliases_done (false),
    2259                 :            :   section_hash (NULL), assembler_name_hash (NULL), init_priority_hash (NULL),
    2260                 :            :   dump_file (NULL), ipa_clones_dump_file (NULL), cloned_nodes (),
    2261                 :            :   m_first_edge_removal_hook (NULL), m_first_cgraph_removal_hook (NULL),
    2262                 :            :   m_first_edge_duplicated_hook (NULL), m_first_cgraph_duplicated_hook (NULL),
    2263                 :            :   m_first_cgraph_insertion_hook (NULL), m_first_varpool_insertion_hook (NULL),
    2264                 :     200805 :   m_first_varpool_removal_hook (NULL)
    2265                 :            :   {
    2266                 :     200805 :   }
    2267                 :            : 
    2268                 :            :   /* Initialize callgraph dump file.  */
    2269                 :            :   void initialize (void);
    2270                 :            : 
    2271                 :            :   /* Register a top-level asm statement ASM_STR.  */
    2272                 :            :   inline asm_node *finalize_toplevel_asm (tree asm_str);
    2273                 :            : 
    2274                 :            :   /* Analyze the whole compilation unit once it is parsed completely.  */
    2275                 :            :   void finalize_compilation_unit (void);
    2276                 :            : 
    2277                 :            :   /* C++ frontend produce same body aliases all over the place, even before PCH
    2278                 :            :      gets streamed out. It relies on us linking the aliases with their function
    2279                 :            :      in order to do the fixups, but ipa-ref is not PCH safe.  Consequently we
    2280                 :            :      first produce aliases without links, but once C++ FE is sure it won't
    2281                 :            :      stream PCH we build the links via this function.  */
    2282                 :            :   void process_same_body_aliases (void);
    2283                 :            : 
    2284                 :            :   /* Perform simple optimizations based on callgraph.  */
    2285                 :            :   void compile (void);
    2286                 :            : 
    2287                 :            :   /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
    2288                 :            :      functions into callgraph in a way so they look like ordinary reachable
    2289                 :            :      functions inserted into callgraph already at construction time.  */
    2290                 :            :   void process_new_functions (void);
    2291                 :            : 
    2292                 :            :   /* Once all functions from compilation unit are in memory, produce all clones
    2293                 :            :      and update all calls.  We might also do this on demand if we don't want to
    2294                 :            :      bring all functions to memory prior compilation, but current WHOPR
    2295                 :            :      implementation does that and it is bit easier to keep everything right
    2296                 :            :      in this order.  */
    2297                 :            :   void materialize_all_clones (void);
    2298                 :            : 
    2299                 :            :   /* Register a symbol NODE.  */
    2300                 :            :   inline void register_symbol (symtab_node *node);
    2301                 :            : 
    2302                 :            :   inline void
    2303                 :     164036 :   clear_asm_symbols (void)
    2304                 :            :   {
    2305                 :     164036 :     asmnodes = NULL;
    2306                 :     164036 :     asm_last_node = NULL;
    2307                 :            :   }
    2308                 :            : 
    2309                 :            :   /* Perform reachability analysis and reclaim all unreachable nodes.  */
    2310                 :            :   bool remove_unreachable_nodes (FILE *file);
    2311                 :            : 
    2312                 :            :   /* Optimization of function bodies might've rendered some variables as
    2313                 :            :      unnecessary so we want to avoid these from being compiled.  Re-do
    2314                 :            :      reachability starting from variables that are either externally visible
    2315                 :            :      or was referred from the asm output routines.  */
    2316                 :            :   void remove_unreferenced_decls (void);
    2317                 :            : 
    2318                 :            :   /* Unregister a symbol NODE.  */
    2319                 :            :   inline void unregister (symtab_node *node);
    2320                 :            : 
    2321                 :            :   /* Allocate new callgraph node and insert it into basic data structures.  */
    2322                 :            :   cgraph_node *create_empty (void);
    2323                 :            : 
    2324                 :            :   /* Release a callgraph NODE.  */
    2325                 :            :   void release_symbol (cgraph_node *node);
    2326                 :            : 
    2327                 :            :   /* Output all variables enqueued to be assembled.  */
    2328                 :            :   bool output_variables (void);
    2329                 :            : 
    2330                 :            :   /* Weakrefs may be associated to external decls and thus not output
    2331                 :            :      at expansion time.  Emit all necessary aliases.  */
    2332                 :            :   void output_weakrefs (void);
    2333                 :            : 
    2334                 :            :   /* Return first static symbol with definition.  */
    2335                 :            :   inline symtab_node *first_symbol (void);
    2336                 :            : 
    2337                 :            :   /* Return first assembler symbol.  */
    2338                 :            :   inline asm_node *
    2339                 :     185562 :   first_asm_symbol (void)
    2340                 :            :   {
    2341                 :     185562 :     return asmnodes;
    2342                 :            :   }
    2343                 :            : 
    2344                 :            :   /* Return first static symbol with definition.  */
    2345                 :            :   inline symtab_node *first_defined_symbol (void);
    2346                 :            : 
    2347                 :            :   /* Return first variable.  */
    2348                 :            :   inline varpool_node *first_variable (void);
    2349                 :            : 
    2350                 :            :   /* Return next variable after NODE.  */
    2351                 :            :   inline varpool_node *next_variable (varpool_node *node);
    2352                 :            : 
    2353                 :            :   /* Return first static variable with initializer.  */
    2354                 :            :   inline varpool_node *first_static_initializer (void);
    2355                 :            : 
    2356                 :            :   /* Return next static variable with initializer after NODE.  */
    2357                 :            :   inline varpool_node *next_static_initializer (varpool_node *node);
    2358                 :            : 
    2359                 :            :   /* Return first static variable with definition.  */
    2360                 :            :   inline varpool_node *first_defined_variable (void);
    2361                 :            : 
    2362                 :            :   /* Return next static variable with definition after NODE.  */
    2363                 :            :   inline varpool_node *next_defined_variable (varpool_node *node);
    2364                 :            : 
    2365                 :            :   /* Return first function with body defined.  */
    2366                 :            :   inline cgraph_node *first_defined_function (void);
    2367                 :            : 
    2368                 :            :   /* Return next function with body defined after NODE.  */
    2369                 :            :   inline cgraph_node *next_defined_function (cgraph_node *node);
    2370                 :            : 
    2371                 :            :   /* Return first function.  */
    2372                 :            :   inline cgraph_node *first_function (void);
    2373                 :            : 
    2374                 :            :   /* Return next function.  */
    2375                 :            :   inline cgraph_node *next_function (cgraph_node *node);
    2376                 :            : 
    2377                 :            :   /* Return first function with body defined.  */
    2378                 :            :   cgraph_node *first_function_with_gimple_body (void);
    2379                 :            : 
    2380                 :            :   /* Return next reachable static variable with initializer after NODE.  */
    2381                 :            :   inline cgraph_node *next_function_with_gimple_body (cgraph_node *node);
    2382                 :            : 
    2383                 :            :   /* Register HOOK to be called with DATA on each removed edge.  */
    2384                 :            :   cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook,
    2385                 :            :                                                 void *data);
    2386                 :            : 
    2387                 :            :   /* Remove ENTRY from the list of hooks called on removing edges.  */
    2388                 :            :   void remove_edge_removal_hook (cgraph_edge_hook_list *entry);
    2389                 :            : 
    2390                 :            :   /* Register HOOK to be called with DATA on each removed node.  */
    2391                 :            :   cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook,
    2392                 :            :                                                   void *data);
    2393                 :            : 
    2394                 :            :   /* Remove ENTRY from the list of hooks called on removing nodes.  */
    2395                 :            :   void remove_cgraph_removal_hook (cgraph_node_hook_list *entry);
    2396                 :            : 
    2397                 :            :   /* Register HOOK to be called with DATA on each removed node.  */
    2398                 :            :   varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook,
    2399                 :            :                                                     void *data);
    2400                 :            : 
    2401                 :            :   /* Remove ENTRY from the list of hooks called on removing nodes.  */
    2402                 :            :   void remove_varpool_removal_hook (varpool_node_hook_list *entry);
    2403                 :            : 
    2404                 :            :   /* Register HOOK to be called with DATA on each inserted node.  */
    2405                 :            :   cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook,
    2406                 :            :                                                     void *data);
    2407                 :            : 
    2408                 :            :   /* Remove ENTRY from the list of hooks called on inserted nodes.  */
    2409                 :            :   void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry);
    2410                 :            : 
    2411                 :            :   /* Register HOOK to be called with DATA on each inserted node.  */
    2412                 :            :   varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook,
    2413                 :            :                                                       void *data);
    2414                 :            : 
    2415                 :            :   /* Remove ENTRY from the list of hooks called on inserted nodes.  */
    2416                 :            :   void remove_varpool_insertion_hook (varpool_node_hook_list *entry);
    2417                 :            : 
    2418                 :            :   /* Register HOOK to be called with DATA on each duplicated edge.  */
    2419                 :            :   cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook,
    2420                 :            :                                                      void *data);
    2421                 :            :   /* Remove ENTRY from the list of hooks called on duplicating edges.  */
    2422                 :            :   void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry);
    2423                 :            : 
    2424                 :            :   /* Register HOOK to be called with DATA on each duplicated node.  */
    2425                 :            :   cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook,
    2426                 :            :                                                        void *data);
    2427                 :            : 
    2428                 :            :   /* Remove ENTRY from the list of hooks called on duplicating nodes.  */
    2429                 :            :   void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry);
    2430                 :            : 
    2431                 :            :   /* Call all edge removal hooks.  */
    2432                 :            :   void call_edge_removal_hooks (cgraph_edge *e);
    2433                 :            : 
    2434                 :            :   /* Call all node insertion hooks.  */
    2435                 :            :   void call_cgraph_insertion_hooks (cgraph_node *node);
    2436                 :            : 
    2437                 :            :   /* Call all node removal hooks.  */
    2438                 :            :   void call_cgraph_removal_hooks (cgraph_node *node);
    2439                 :            : 
    2440                 :            :   /* Call all node duplication hooks.  */
    2441                 :            :   void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2);
    2442                 :            : 
    2443                 :            :   /* Call all edge duplication hooks.  */
    2444                 :            :   void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2);
    2445                 :            : 
    2446                 :            :   /* Call all node removal hooks.  */
    2447                 :            :   void call_varpool_removal_hooks (varpool_node *node);
    2448                 :            : 
    2449                 :            :   /* Call all node insertion hooks.  */
    2450                 :            :   void call_varpool_insertion_hooks (varpool_node *node);
    2451                 :            : 
    2452                 :            :   /* Arrange node to be first in its entry of assembler_name_hash.  */
    2453                 :            :   void symtab_prevail_in_asm_name_hash (symtab_node *node);
    2454                 :            : 
    2455                 :            :   /* Initialize asm name hash unless.  */
    2456                 :            :   void symtab_initialize_asm_name_hash (void);
    2457                 :            : 
    2458                 :            :   /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables.  */
    2459                 :            :   void change_decl_assembler_name (tree decl, tree name);
    2460                 :            : 
    2461                 :            :   /* Dump symbol table to F.  */
    2462                 :            :   void dump (FILE *f);
    2463                 :            : 
    2464                 :            :   /* Dump symbol table to F in graphviz format.  */
    2465                 :            :   void dump_graphviz (FILE *f);
    2466                 :            : 
    2467                 :            :   /* Dump symbol table to stderr.  */
    2468                 :            :   void DEBUG_FUNCTION debug (void);
    2469                 :            : 
    2470                 :            :   /* Assign a new summary ID for the callgraph NODE.  */
    2471                 :    3605010 :   inline int assign_summary_id (cgraph_node *node)
    2472                 :            :   {
    2473                 :    3605010 :     if (!cgraph_released_summary_ids.is_empty ())
    2474                 :    1734182 :       node->m_summary_id = cgraph_released_summary_ids.pop ();
    2475                 :            :     else
    2476                 :    1870828 :       node->m_summary_id = cgraph_max_summary_id++;
    2477                 :            : 
    2478                 :    3605010 :     return node->m_summary_id;
    2479                 :            :   }
    2480                 :            : 
    2481                 :            :   /* Assign a new summary ID for the callgraph EDGE.  */
    2482                 :   12788300 :   inline int assign_summary_id (cgraph_edge *edge)
    2483                 :            :   {
    2484                 :   12788300 :     if (!edge_released_summary_ids.is_empty ())
    2485                 :    7294640 :       edge->m_summary_id = edge_released_summary_ids.pop ();
    2486                 :            :     else
    2487                 :    5493710 :       edge->m_summary_id = edges_max_summary_id++;
    2488                 :            : 
    2489                 :   12788300 :     return edge->m_summary_id;
    2490                 :            :   }
    2491                 :            : 
    2492                 :            :   /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
    2493                 :            :      name.  */
    2494                 :            :   static bool assembler_names_equal_p (const char *name1, const char *name2);
    2495                 :            : 
    2496                 :            :   int cgraph_count;
    2497                 :            :   int cgraph_max_uid;
    2498                 :            :   int cgraph_max_summary_id;
    2499                 :            : 
    2500                 :            :   int edges_count;
    2501                 :            :   int edges_max_uid;
    2502                 :            :   int edges_max_summary_id;
    2503                 :            : 
    2504                 :            :   /* Vector of released summary IDS for cgraph nodes.  */
    2505                 :            :   vec<int> GTY ((skip)) cgraph_released_summary_ids;
    2506                 :            : 
    2507                 :            :   /* Vector of released summary IDS for cgraph nodes.  */
    2508                 :            :   vec<int> GTY ((skip)) edge_released_summary_ids;
    2509                 :            : 
    2510                 :            :   /* Return symbol used to separate symbol name from suffix.  */
    2511                 :            :   static char symbol_suffix_separator ();
    2512                 :            : 
    2513                 :            :   symtab_node* GTY(()) nodes;
    2514                 :            :   asm_node* GTY(()) asmnodes;
    2515                 :            :   asm_node* GTY(()) asm_last_node;
    2516                 :            : 
    2517                 :            :   /* The order index of the next symtab node to be created.  This is
    2518                 :            :      used so that we can sort the cgraph nodes in order by when we saw
    2519                 :            :      them, to support -fno-toplevel-reorder.  */
    2520                 :            :   int order;
    2521                 :            : 
    2522                 :            :   /* Maximal unit ID used.  */
    2523                 :            :   int max_unit;
    2524                 :            : 
    2525                 :            :   /* Set when whole unit has been analyzed so we can access global info.  */
    2526                 :            :   bool global_info_ready;
    2527                 :            :   /* What state callgraph is in right now.  */
    2528                 :            :   enum symtab_state state;
    2529                 :            :   /* Set when the cgraph is fully build and the basic flags are computed.  */
    2530                 :            :   bool function_flags_ready;
    2531                 :            : 
    2532                 :            :   bool cpp_implicit_aliases_done;
    2533                 :            : 
    2534                 :            :   /* Hash table used to hold sections.  */
    2535                 :            :   hash_table<section_name_hasher> *GTY(()) section_hash;
    2536                 :            : 
    2537                 :            :   /* Hash table used to convert assembler names into nodes.  */
    2538                 :            :   hash_table<asmname_hasher> *assembler_name_hash;
    2539                 :            : 
    2540                 :            :   /* Hash table used to hold init priorities.  */
    2541                 :            :   hash_map<symtab_node *, symbol_priority_map> *init_priority_hash;
    2542                 :            : 
    2543                 :            :   FILE* GTY ((skip)) dump_file;
    2544                 :            : 
    2545                 :            :   FILE* GTY ((skip)) ipa_clones_dump_file;
    2546                 :            : 
    2547                 :            :   hash_set <const cgraph_node *> GTY ((skip)) cloned_nodes;
    2548                 :            : 
    2549                 :            : private:
    2550                 :            :   /* Allocate a cgraph_edge structure and fill it with data according to the
    2551                 :            :      parameters of which only CALLEE can be NULL (when creating an indirect
    2552                 :            :      call edge).  CLONING_P should be set if properties that are copied from an
    2553                 :            :      original edge should not be calculated.  */
    2554                 :            :   cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee,
    2555                 :            :                             gcall *call_stmt, profile_count count,
    2556                 :            :                             bool indir_unknown_callee, bool cloning_p);
    2557                 :            : 
    2558                 :            :   /* Put the edge onto the free list.  */
    2559                 :            :   void free_edge (cgraph_edge *e);
    2560                 :            : 
    2561                 :            :   /* Insert NODE to assembler name hash.  */
    2562                 :            :   void insert_to_assembler_name_hash (symtab_node *node, bool with_clones);
    2563                 :            : 
    2564                 :            :   /* Remove NODE from assembler name hash.  */
    2565                 :            :   void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones);
    2566                 :            : 
    2567                 :            :   /* Hash asmnames ignoring the user specified marks.  */
    2568                 :            :   static hashval_t decl_assembler_name_hash (const_tree asmname);
    2569                 :            : 
    2570                 :            :   /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
    2571                 :            :   static bool decl_assembler_name_equal (tree decl, const_tree asmname);
    2572                 :            : 
    2573                 :            :   friend struct asmname_hasher;
    2574                 :            : 
    2575                 :            :   /* List of hooks triggered when an edge is removed.  */
    2576                 :            :   cgraph_edge_hook_list * GTY((skip)) m_first_edge_removal_hook;
    2577                 :            :   /* List of hooks trigger_red when a cgraph node is removed.  */
    2578                 :            :   cgraph_node_hook_list * GTY((skip)) m_first_cgraph_removal_hook;
    2579                 :            :   /* List of hooks triggered when an edge is duplicated.  */
    2580                 :            :   cgraph_2edge_hook_list * GTY((skip)) m_first_edge_duplicated_hook;
    2581                 :            :   /* List of hooks triggered when a node is duplicated.  */
    2582                 :            :   cgraph_2node_hook_list * GTY((skip)) m_first_cgraph_duplicated_hook;
    2583                 :            :   /* List of hooks triggered when an function is inserted.  */
    2584                 :            :   cgraph_node_hook_list * GTY((skip)) m_first_cgraph_insertion_hook;
    2585                 :            :   /* List of hooks triggered when an variable is inserted.  */
    2586                 :            :   varpool_node_hook_list * GTY((skip)) m_first_varpool_insertion_hook;
    2587                 :            :   /* List of hooks triggered when a node is removed.  */
    2588                 :            :   varpool_node_hook_list * GTY((skip)) m_first_varpool_removal_hook;
    2589                 :            : };
    2590                 :            : 
    2591                 :            : extern GTY(()) symbol_table *symtab;
    2592                 :            : 
    2593                 :            : extern vec<cgraph_node *> cgraph_new_nodes;
    2594                 :            : 
    2595                 :            : inline hashval_t
    2596                 :  627504000 : asmname_hasher::hash (symtab_node *n)
    2597                 :            : {
    2598                 :  627504000 :   return symbol_table::decl_assembler_name_hash
    2599                 :  627504000 :     (DECL_ASSEMBLER_NAME (n->decl));
    2600                 :            : }
    2601                 :            : 
    2602                 :            : inline bool
    2603                 :  752329000 : asmname_hasher::equal (symtab_node *n, const_tree t)
    2604                 :            : {
    2605                 :  752329000 :   return symbol_table::decl_assembler_name_equal (n->decl, t);
    2606                 :            : }
    2607                 :            : 
    2608                 :            : /* In cgraph.c  */
    2609                 :            : void cgraph_c_finalize (void);
    2610                 :            : void release_function_body (tree);
    2611                 :            : cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
    2612                 :            : 
    2613                 :            : void cgraph_update_edges_for_call_stmt (gimple *, tree, gimple *);
    2614                 :            : bool cgraph_function_possibly_inlined_p (tree);
    2615                 :            : 
    2616                 :            : const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
    2617                 :            : cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);
    2618                 :            : 
    2619                 :            : /* In cgraphunit.c  */
    2620                 :            : void cgraphunit_c_finalize (void);
    2621                 :            : int tp_first_run_node_cmp (const void *pa, const void *pb);
    2622                 :            : 
    2623                 :            : /*  Initialize datastructures so DECL is a function in lowered gimple form.
    2624                 :            :     IN_SSA is true if the gimple is in SSA.  */
    2625                 :            : basic_block init_lowered_empty_function (tree, bool, profile_count);
    2626                 :            : 
    2627                 :            : tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree,
    2628                 :            :                    HOST_WIDE_INT);
    2629                 :            : /* In cgraphclones.c  */
    2630                 :            : 
    2631                 :            : tree clone_function_name_numbered (const char *name, const char *suffix);
    2632                 :            : tree clone_function_name_numbered (tree decl, const char *suffix);
    2633                 :            : tree clone_function_name (const char *name, const char *suffix,
    2634                 :            :                           unsigned long number);
    2635                 :            : tree clone_function_name (tree decl, const char *suffix,
    2636                 :            :                           unsigned long number);
    2637                 :            : tree clone_function_name (tree decl, const char *suffix);
    2638                 :            : 
    2639                 :            : void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
    2640                 :            :                                ipa_param_adjustments *,
    2641                 :            :                                bool, bitmap, basic_block);
    2642                 :            : 
    2643                 :            : void dump_callgraph_transformation (const cgraph_node *original,
    2644                 :            :                                     const cgraph_node *clone,
    2645                 :            :                                     const char *suffix);
    2646                 :            : /* In cgraphbuild.c  */
    2647                 :            : int compute_call_stmt_bb_frequency (tree, basic_block bb);
    2648                 :            : void record_references_in_initializer (tree, bool);
    2649                 :            : 
    2650                 :            : /* In ipa.c  */
    2651                 :            : void cgraph_build_static_cdtor (char which, tree body, int priority);
    2652                 :            : bool ipa_discover_variable_flags (void);
    2653                 :            : 
    2654                 :            : /* In varpool.c  */
    2655                 :            : tree ctor_for_folding (tree);
    2656                 :            : 
    2657                 :            : /* In ipa-inline-analysis.c  */
    2658                 :            : void initialize_inline_failed (struct cgraph_edge *);
    2659                 :            : bool speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining);
    2660                 :            : 
    2661                 :            : /* Return true when the symbol is real symbol, i.e. it is not inline clone
    2662                 :            :    or abstract function kept for debug info purposes only.  */
    2663                 :            : inline bool
    2664                 :    8036748 : symtab_node::real_symbol_p (void)
    2665                 :            : {
    2666                 :    8036748 :   cgraph_node *cnode;
    2667                 :            : 
    2668                 :    8036748 :   if (DECL_ABSTRACT_P (decl))
    2669                 :            :     return false;
    2670                 :    7813490 :   if (transparent_alias && definition)
    2671                 :            :     return false;
    2672                 :    7813412 :   if (!is_a <cgraph_node *> (this))
    2673                 :            :     return true;
    2674                 :    3960261 :   cnode = dyn_cast <cgraph_node *> (this);
    2675                 :    3960261 :   if (cnode->inlined_to)
    2676                 :    1046644 :     return false;
    2677                 :            :   return true;
    2678                 :            : }
    2679                 :            : 
    2680                 :            : /* Return true if DECL should have entry in symbol table if used.
    2681                 :            :    Those are functions and static & external variables.  */
    2682                 :            : 
    2683                 :            : static inline bool
    2684                 :  957568468 : decl_in_symtab_p (const_tree decl)
    2685                 :            : {
    2686                 :  957568468 :   return (TREE_CODE (decl) == FUNCTION_DECL
    2687                 :  957568468 :           || (TREE_CODE (decl) == VAR_DECL
    2688                 : 1635965764 :               && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
    2689                 :            : }
    2690                 :            : 
    2691                 :            : inline bool
    2692                 :     137332 : symtab_node::in_same_comdat_group_p (symtab_node *target)
    2693                 :            : {
    2694                 :     137332 :   symtab_node *source = this;
    2695                 :            : 
    2696                 :     137332 :   if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
    2697                 :            :     {
    2698                 :     137314 :       if (cn->inlined_to)
    2699                 :       8922 :         source = cn->inlined_to;
    2700                 :            :     }
    2701                 :     137332 :   if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
    2702                 :            :     {
    2703                 :     137314 :       if (cn->inlined_to)
    2704                 :       8922 :         target = cn->inlined_to;
    2705                 :            :     }
    2706                 :            : 
    2707                 :     137332 :   return source->get_comdat_group () == target->get_comdat_group ();
    2708                 :            : }
    2709                 :            : 
    2710                 :            : /* Return node that alias is aliasing.  */
    2711                 :            : 
    2712                 :            : inline symtab_node *
    2713                 :   25092735 : symtab_node::get_alias_target (void)
    2714                 :            : {
    2715                 :   25092735 :   ipa_ref *ref = NULL;
    2716                 :   50185560 :   iterate_reference (0, ref);
    2717                 :          0 :   gcc_checking_assert (ref->use == IPA_REF_ALIAS);
    2718                 :   25092735 :   return ref->referred;
    2719                 :            : }
    2720                 :            : 
    2721                 :            : /* Return next reachable static symbol with initializer after the node.  */
    2722                 :            : 
    2723                 :            : inline symtab_node *
    2724                 :    7772760 : symtab_node::next_defined_symbol (void)
    2725                 :            : {
    2726                 :    7772760 :   symtab_node *node1 = next;
    2727                 :            : 
    2728                 :    9063180 :   for (; node1; node1 = node1->next)
    2729                 :    8753390 :     if (node1->definition)
    2730                 :            :       return node1;
    2731                 :            : 
    2732                 :            :   return NULL;
    2733                 :            : }
    2734                 :            : 
    2735                 :            : /* Iterates I-th reference in the list, REF is also set.  */
    2736                 :            : 
    2737                 :            : inline ipa_ref *
    2738                 :  390101254 : symtab_node::iterate_reference (unsigned i, ipa_ref *&ref)
    2739                 :            : {
    2740                 :  518972487 :   vec_safe_iterate (ref_list.references, i, &ref);
    2741                 :            : 
    2742                 :  274872972 :   return ref;
    2743                 :            : }
    2744                 :            : 
    2745                 :            : /* Iterates I-th referring item in the list, REF is also set.  */
    2746                 :            : 
    2747                 :            : inline ipa_ref *
    2748                 :  133442446 : symtab_node::iterate_referring (unsigned i, ipa_ref *&ref)
    2749                 :            : {
    2750                 :  223005186 :   ref_list.referring.iterate (i, &ref);
    2751                 :            : 
    2752                 :   23304233 :   return ref;
    2753                 :            : }
    2754                 :            : 
    2755                 :            : /* Iterates I-th referring alias item in the list, REF is also set.  */
    2756                 :            : 
    2757                 :            : inline ipa_ref *
    2758                 :   75641497 : symtab_node::iterate_direct_aliases (unsigned i, ipa_ref *&ref)
    2759                 :            : {
    2760                 :   71675487 :   ref_list.referring.iterate (i, &ref);
    2761                 :            : 
    2762                 :   10236883 :   if (ref && ref->use != IPA_REF_ALIAS)
    2763                 :            :     return NULL;
    2764                 :            : 
    2765                 :            :   return ref;
    2766                 :            : }
    2767                 :            : 
    2768                 :            : /* Return true if list contains an alias.  */
    2769                 :            : 
    2770                 :            : inline bool
    2771                 :   23700992 : symtab_node::has_aliases_p (void)
    2772                 :            : {
    2773                 :   23700992 :   ipa_ref *ref = NULL;
    2774                 :            : 
    2775                 :   20979772 :   return (iterate_direct_aliases (0, ref) != NULL);
    2776                 :            : }
    2777                 :            : 
    2778                 :            : /* Return true when RESOLUTION indicate that linker will use
    2779                 :            :    the symbol from non-LTO object files.  */
    2780                 :            : 
    2781                 :            : inline bool
    2782                 :   16011770 : resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
    2783                 :            : {
    2784                 :   16011770 :   return (resolution == LDPR_PREVAILING_DEF
    2785                 :   16011770 :           || resolution == LDPR_PREEMPTED_REG
    2786                 :            :           || resolution == LDPR_RESOLVED_EXEC
    2787                 :   15984448 :           || resolution == LDPR_RESOLVED_DYN);
    2788                 :            : }
    2789                 :            : 
    2790                 :            : /* Return true when symtab_node is known to be used from other (non-LTO)
    2791                 :            :    object file. Known only when doing LTO via linker plugin.  */
    2792                 :            : 
    2793                 :            : inline bool
    2794                 :   21372085 : symtab_node::used_from_object_file_p (void)
    2795                 :            : {
    2796                 :   21372085 :   if (!TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
    2797                 :            :     return false;
    2798                 :   16011770 :   if (resolution_used_from_other_file_p (resolution))
    2799                 :      27333 :     return true;
    2800                 :            :   return false;
    2801                 :            : }
    2802                 :            : 
    2803                 :            : /* Return varpool node for given symbol and check it is a function. */
    2804                 :            : 
    2805                 :            : inline varpool_node *
    2806                 :  261334954 : varpool_node::get (const_tree decl)
    2807                 :            : {
    2808                 :  261334954 :   gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
    2809                 :  261334954 :   return dyn_cast<varpool_node *> (symtab_node::get (decl));
    2810                 :            : }
    2811                 :            : 
    2812                 :            : /* Register a symbol NODE.  */
    2813                 :            : 
    2814                 :            : inline void
    2815                 :   48655800 : symbol_table::register_symbol (symtab_node *node)
    2816                 :            : {
    2817                 :   48655800 :   node->next = nodes;
    2818                 :   48655800 :   node->previous = NULL;
    2819                 :            : 
    2820                 :   48655800 :   if (nodes)
    2821                 :   48474500 :     nodes->previous = node;
    2822                 :   48655800 :   nodes = node;
    2823                 :            : 
    2824                 :   48655800 :   node->order = order++;
    2825                 :            : }
    2826                 :            : 
    2827                 :            : /* Register a top-level asm statement ASM_STR.  */
    2828                 :            : 
    2829                 :            : asm_node *
    2830                 :        308 : symbol_table::finalize_toplevel_asm (tree asm_str)
    2831                 :            : {
    2832                 :        308 :   asm_node *node;
    2833                 :            : 
    2834                 :        308 :   node = ggc_cleared_alloc<asm_node> ();
    2835                 :        308 :   node->asm_str = asm_str;
    2836                 :        308 :   node->order = order++;
    2837                 :        308 :   node->next = NULL;
    2838                 :            : 
    2839                 :        308 :   if (asmnodes == NULL)
    2840                 :         92 :     asmnodes = node;
    2841                 :            :   else
    2842                 :        216 :     asm_last_node->next = node;
    2843                 :            : 
    2844                 :        308 :   asm_last_node = node;
    2845                 :        308 :   return node;
    2846                 :            : }
    2847                 :            : 
    2848                 :            : /* Unregister a symbol NODE.  */
    2849                 :            : inline void
    2850                 :   55645800 : symbol_table::unregister (symtab_node *node)
    2851                 :            : {
    2852                 :   55645800 :   if (node->previous)
    2853                 :   54239100 :     node->previous->next = node->next;
    2854                 :            :   else
    2855                 :    1406680 :     nodes = node->next;
    2856                 :            : 
    2857                 :   55645800 :   if (node->next)
    2858                 :   55558300 :     node->next->previous = node->previous;
    2859                 :            : 
    2860                 :   55645800 :   node->next = NULL;
    2861                 :   55645800 :   node->previous = NULL;
    2862                 :            : }
    2863                 :            : 
    2864                 :            : /* Release a callgraph NODE with UID and put in to the list of free nodes.  */
    2865                 :            : 
    2866                 :            : inline void
    2867                 :   47936700 : symbol_table::release_symbol (cgraph_node *node)
    2868                 :            : {
    2869                 :   47936700 :   cgraph_count--;
    2870                 :   47936700 :   if (node->m_summary_id != -1)
    2871                 :    2555660 :     cgraph_released_summary_ids.safe_push (node->m_summary_id);
    2872                 :   47936700 :   ggc_free (node);
    2873                 :   47936700 : }
    2874                 :            : 
    2875                 :            : /* Return first static symbol with definition.  */
    2876                 :            : inline symtab_node *
    2877                 :    3807521 : symbol_table::first_symbol (void)
    2878                 :            : {
    2879                 :    3807521 :   return nodes;
    2880                 :            : }
    2881                 :            : 
    2882                 :            : /* Walk all symbols.  */
    2883                 :            : #define FOR_EACH_SYMBOL(node) \
    2884                 :            :    for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)
    2885                 :            : 
    2886                 :            : /* Return first static symbol with definition.  */
    2887                 :            : inline symtab_node *
    2888                 :     327410 : symbol_table::first_defined_symbol (void)
    2889                 :            : {
    2890                 :     327410 :   symtab_node *node;
    2891                 :            : 
    2892                 :    2312340 :   for (node = nodes; node; node = node->next)
    2893                 :    2294710 :     if (node->definition)
    2894                 :            :       return node;
    2895                 :            : 
    2896                 :            :   return NULL;
    2897                 :            : }
    2898                 :            : 
    2899                 :            : /* Walk all symbols with definitions in current unit.  */
    2900                 :            : #define FOR_EACH_DEFINED_SYMBOL(node) \
    2901                 :            :    for ((node) = symtab->first_defined_symbol (); (node); \
    2902                 :            :         (node) = node->next_defined_symbol ())
    2903                 :            : 
    2904                 :            : /* Return first variable.  */
    2905                 :            : inline varpool_node *
    2906                 :    3519558 : symbol_table::first_variable (void)
    2907                 :            : {
    2908                 :    3519558 :   symtab_node *node;
    2909                 :   99637395 :   for (node = nodes; node; node = node->next)
    2910                 :  179390824 :     if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
    2911                 :            :       return vnode;
    2912                 :            :   return NULL;
    2913                 :            : }
    2914                 :            : 
    2915                 :            : /* Return next variable after NODE.  */
    2916                 :            : inline varpool_node *
    2917                 :   77621579 : symbol_table::next_variable (varpool_node *node)
    2918                 :            : {
    2919                 :   77621579 :   symtab_node *node1 = node->next;
    2920                 :  168965046 :   for (; node1; node1 = node1->next)
    2921                 :  226502284 :     if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
    2922                 :            :       return vnode1;
    2923                 :            :   return NULL;
    2924                 :            : }
    2925                 :            : /* Walk all variables.  */
    2926                 :            : #define FOR_EACH_VARIABLE(node) \
    2927                 :            :    for ((node) = symtab->first_variable (); \
    2928                 :            :         (node); \
    2929                 :            :         (node) = symtab->next_variable ((node)))
    2930                 :            : 
    2931                 :            : /* Return first static variable with initializer.  */
    2932                 :            : inline varpool_node *
    2933                 :            : symbol_table::first_static_initializer (void)
    2934                 :            : {
    2935                 :            :   symtab_node *node;
    2936                 :            :   for (node = nodes; node; node = node->next)
    2937                 :            :     {
    2938                 :            :       varpool_node *vnode = dyn_cast <varpool_node *> (node);
    2939                 :            :       if (vnode && DECL_INITIAL (node->decl))
    2940                 :            :         return vnode;
    2941                 :            :     }
    2942                 :            :   return NULL;
    2943                 :            : }
    2944                 :            : 
    2945                 :            : /* Return next static variable with initializer after NODE.  */
    2946                 :            : inline varpool_node *
    2947                 :            : symbol_table::next_static_initializer (varpool_node *node)
    2948                 :            : {
    2949                 :            :   symtab_node *node1 = node->next;
    2950                 :            :   for (; node1; node1 = node1->next)
    2951                 :            :     {
    2952                 :            :       varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
    2953                 :            :       if (vnode1 && DECL_INITIAL (node1->decl))
    2954                 :            :         return vnode1;
    2955                 :            :     }
    2956                 :            :   return NULL;
    2957                 :            : }
    2958                 :            : 
    2959                 :            : /* Walk all static variables with initializer set.  */
    2960                 :            : #define FOR_EACH_STATIC_INITIALIZER(node) \
    2961                 :            :    for ((node) = symtab->first_static_initializer (); (node); \
    2962                 :            :         (node) = symtab->next_static_initializer (node))
    2963                 :            : 
    2964                 :            : /* Return first static variable with definition.  */
    2965                 :            : inline varpool_node *
    2966                 :    2466484 : symbol_table::first_defined_variable (void)
    2967                 :            : {
    2968                 :    2466484 :   symtab_node *node;
    2969                 :   36602388 :   for (node = nodes; node; node = node->next)
    2970                 :            :     {
    2971                 :   38603106 :       varpool_node *vnode = dyn_cast <varpool_node *> (node);
    2972                 :    4467199 :       if (vnode && vnode->definition)
    2973                 :            :         return vnode;
    2974                 :            :     }
    2975                 :            :   return NULL;
    2976                 :            : }
    2977                 :            : 
    2978                 :            : /* Return next static variable with definition after NODE.  */
    2979                 :            : inline varpool_node *
    2980                 :   37867151 : symbol_table::next_defined_variable (varpool_node *node)
    2981                 :            : {
    2982                 :   37867151 :   symtab_node *node1 = node->next;
    2983                 :   51672614 :   for (; node1; node1 = node1->next)
    2984                 :            :     {
    2985                 :   51060774 :       varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
    2986                 :   37255221 :       if (vnode1 && vnode1->definition)
    2987                 :            :         return vnode1;
    2988                 :            :     }
    2989                 :            :   return NULL;
    2990                 :            : }
    2991                 :            : /* Walk all variables with definitions in current unit.  */
    2992                 :            : #define FOR_EACH_DEFINED_VARIABLE(node) \
    2993                 :            :    for ((node) = symtab->first_defined_variable (); (node); \
    2994                 :            :         (node) = symtab->next_defined_variable (node))
    2995                 :            : 
    2996                 :            : /* Return first function with body defined.  */
    2997                 :            : inline cgraph_node *
    2998                 :   21336167 : symbol_table::first_defined_function (void)
    2999                 :            : {
    3000                 :   21336167 :   symtab_node *node;
    3001                 :  319852022 :   for (node = nodes; node; node = node->next)
    3002                 :            :     {
    3003                 :  475965699 :       cgraph_node *cn = dyn_cast <cgraph_node *> (node);
    3004                 :  177454523 :       if (cn && cn->definition)
    3005                 :            :         return cn;
    3006                 :            :     }
    3007                 :            :   return NULL;
    3008                 :            : }
    3009                 :            : 
    3010                 :            : /* Return next function with body defined after NODE.  */
    3011                 :            : inline cgraph_node *
    3012                 :  208721318 : symbol_table::next_defined_function (cgraph_node *node)
    3013                 :            : {
    3014                 :  208721318 :   symtab_node *node1 = node->next;
    3015                 :  473063492 :   for (; node1; node1 = node1->next)
    3016                 :            :     {
    3017                 :  489769869 :       cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
    3018                 :  225427462 :       if (cn1 && cn1->definition)
    3019                 :            :         return cn1;
    3020                 :            :     }
    3021                 :            :   return NULL;
    3022                 :            : }
    3023                 :            : 
    3024                 :            : /* Walk all functions with body defined.  */
    3025                 :            : #define FOR_EACH_DEFINED_FUNCTION(node) \
    3026                 :            :    for ((node) = symtab->first_defined_function (); (node); \
    3027                 :            :         (node) = symtab->next_defined_function ((node)))
    3028                 :            : 
    3029                 :            : /* Return first function.  */
    3030                 :            : inline cgraph_node *
    3031                 :   12420865 : symbol_table::first_function (void)
    3032                 :            : {
    3033                 :   12420865 :   symtab_node *node;
    3034                 :   72371250 :   for (node = nodes; node; node = node->next)
    3035                 :  378316586 :     if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
    3036                 :            :       return cn;
    3037                 :            :   return NULL;
    3038                 :            : }
    3039                 :            : 
    3040                 :            : /* Return next function.  */
    3041                 :            : inline cgraph_node *
    3042                 :  303575118 : symbol_table::next_function (cgraph_node *node)
    3043                 :            : {
    3044                 :  303575118 :   symtab_node *node1 = node->next;
    3045                 :  455850872 :   for (; node1; node1 = node1->next)
    3046                 :  729918458 :     if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
    3047                 :            :       return cn1;
    3048                 :            :   return NULL;
    3049                 :            : }
    3050                 :            : 
    3051                 :            : /* Return first function with body defined.  */
    3052                 :            : inline cgraph_node *
    3053                 :    1098709 : symbol_table::first_function_with_gimple_body (void)
    3054                 :            : {
    3055                 :    1098709 :   symtab_node *node;
    3056                 :   18245398 :   for (node = nodes; node; node = node->next)
    3057                 :            :     {
    3058                 :   27321223 :       cgraph_node *cn = dyn_cast <cgraph_node *> (node);
    3059                 :   28288704 :       if (cn && cn->has_gimple_body_p ())
    3060                 :            :         return cn;
    3061                 :            :     }
    3062                 :            :   return NULL;
    3063                 :            : }
    3064                 :            : 
    3065                 :            : /* Return next reachable static variable with initializer after NODE.  */
    3066                 :            : inline cgraph_node *
    3067                 :   10043319 : symbol_table::next_function_with_gimple_body (cgraph_node *node)
    3068                 :            : {
    3069                 :   10043319 :   symtab_node *node1 = node->next;
    3070                 :   26621805 :   for (; node1; node1 = node1->next)
    3071                 :            :     {
    3072                 :   28059366 :       cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
    3073                 :   27720485 :       if (cn1 && cn1->has_gimple_body_p ())
    3074                 :            :         return cn1;
    3075                 :            :     }
    3076                 :            :   return NULL;
    3077                 :            : }
    3078                 :            : 
    3079                 :            : /* Walk all functions.  */
    3080                 :            : #define FOR_EACH_FUNCTION(node) \
    3081                 :            :    for ((node) = symtab->first_function (); (node); \
    3082                 :            :         (node) = symtab->next_function ((node)))
    3083                 :            : 
    3084                 :            : /* Return true when callgraph node is a function with Gimple body defined
    3085                 :            :    in current unit.  Functions can also be define externally or they
    3086                 :            :    can be thunks with no Gimple representation.
    3087                 :            : 
    3088                 :            :    Note that at WPA stage, the function body may not be present in memory.  */
    3089                 :            : 
    3090                 :            : inline bool
    3091                 :   51002751 : cgraph_node::has_gimple_body_p (void)
    3092                 :            : {
    3093                 :   51002751 :   return definition && !thunk.thunk_p && !alias;
    3094                 :            : }
    3095                 :            : 
    3096                 :            : /* Return true if this node represents a former, i.e. an expanded, thunk.  */
    3097                 :            : 
    3098                 :            : inline bool
    3099                 :       6045 : cgraph_node::former_thunk_p (void)
    3100                 :            : {
    3101                 :       6045 :   return (!thunk.thunk_p
    3102                 :       6045 :           && (thunk.fixed_offset
    3103                 :       6001 :               || thunk.virtual_offset_p
    3104                 :       6001 :               || thunk.indirect_offset));
    3105                 :            : }
    3106                 :            : 
    3107                 :            : /* Walk all functions with body defined.  */
    3108                 :            : #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
    3109                 :            :    for ((node) = symtab->first_function_with_gimple_body (); (node); \
    3110                 :            :         (node) = symtab->next_function_with_gimple_body (node))
    3111                 :            : 
    3112                 :            : /* Uniquize all constants that appear in memory.
    3113                 :            :    Each constant in memory thus far output is recorded
    3114                 :            :    in `const_desc_table'.  */
    3115                 :            : 
    3116                 :            : struct GTY((for_user)) constant_descriptor_tree {
    3117                 :            :   /* A MEM for the constant.  */
    3118                 :            :   rtx rtl;
    3119                 :            : 
    3120                 :            :   /* The value of the constant.  */
    3121                 :            :   tree value;
    3122                 :            : 
    3123                 :            :   /* Hash of value.  Computing the hash from value each time
    3124                 :            :      hashfn is called can't work properly, as that means recursive
    3125                 :            :      use of the hash table during hash table expansion.  */
    3126                 :            :   hashval_t hash;
    3127                 :            : };
    3128                 :            : 
    3129                 :            : /* Return true when function is only called directly or it has alias.
    3130                 :            :    i.e. it is not externally visible, address was not taken and
    3131                 :            :    it is not used in any other non-standard way.  */
    3132                 :            : 
    3133                 :            : inline bool
    3134                 :   13551340 : cgraph_node::only_called_directly_or_aliased_p (void)
    3135                 :            : {
    3136                 :   13551340 :   gcc_assert (!inlined_to);
    3137                 :   13551340 :   return (!force_output && !address_taken
    3138                 :            :           && !ifunc_resolver
    3139                 :   13551340 :           && !used_from_other_partition
    3140                 :   11607010 :           && !DECL_VIRTUAL_P (decl)
    3141                 :   11544790 :           && !DECL_STATIC_CONSTRUCTOR (decl)
    3142                 :   11479110 :           && !DECL_STATIC_DESTRUCTOR (decl)
    3143                 :   11478770 :           && !used_from_object_file_p ()
    3144                 :   25007850 :           && !externally_visible);
    3145                 :            : }
    3146                 :            : 
    3147                 :            : /* Return true when function can be removed from callgraph
    3148                 :            :    if all direct calls are eliminated.  */
    3149                 :            : 
    3150                 :            : inline bool
    3151                 :   12304437 : cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
    3152                 :            : {
    3153                 :   12304437 :   gcc_checking_assert (!inlined_to);
    3154                 :            :   /* Extern inlines can always go, we will use the external definition.  */
    3155                 :   12304437 :   if (DECL_EXTERNAL (decl))
    3156                 :            :     return true;
    3157                 :            :   /* When function is needed, we cannot remove it.  */
    3158                 :   11830357 :   if (force_output || used_from_other_partition)
    3159                 :            :     return false;
    3160                 :   10051352 :   if (DECL_STATIC_CONSTRUCTOR (decl)
    3161                 :   10051352 :       || DECL_STATIC_DESTRUCTOR (decl))
    3162                 :            :     return false;
    3163                 :            :   /* Only COMDAT functions can be removed if externally visible.  */
    3164                 :    9989345 :   if (externally_visible
    3165                 :    8286677 :       && (!DECL_COMDAT (decl)
    3166                 :    4184418 :           || forced_by_abi
    3167                 :   14172570 :           || used_from_object_file_p ()))
    3168                 :    4103424 :     return false;
    3169                 :            :   return true;
    3170                 :            : }
    3171                 :            : 
    3172                 :            : /* Verify cgraph, if consistency checking is enabled.  */
    3173                 :            : 
    3174                 :            : inline void
    3175                 :     328934 : cgraph_node::checking_verify_cgraph_nodes (void)
    3176                 :            : {
    3177                 :     328934 :   if (flag_checking)
    3178                 :     328910 :     cgraph_node::verify_cgraph_nodes ();
    3179                 :            : }
    3180                 :            : 
    3181                 :            : /* Return true when variable can be removed from variable pool
    3182                 :            :    if all direct calls are eliminated.  */
    3183                 :            : 
    3184                 :            : inline bool
    3185                 :   21732604 : varpool_node::can_remove_if_no_refs_p (void)
    3186                 :            : {
    3187                 :   21732604 :   if (DECL_EXTERNAL (decl))
    3188                 :            :     return true;
    3189                 :   21715924 :   return (!force_output && !used_from_other_partition
    3190                 :   21715924 :           && ((DECL_COMDAT (decl)
    3191                 :   19404067 :                && !forced_by_abi
    3192                 :     563372 :                && !used_from_object_file_p ())
    3193                 :   18840927 :               || !externally_visible
    3194                 :    8492316 :               || DECL_HAS_VALUE_EXPR_P (decl)));
    3195                 :            : }
    3196                 :            : 
    3197                 :            : /* Return true when all references to variable must be visible in ipa_ref_list.
    3198                 :            :    i.e. if the variable is not externally visible or not used in some magic
    3199                 :            :    way (asm statement or such).
    3200                 :            :    The magic uses are all summarized in force_output flag.  */
    3201                 :            : 
    3202                 :            : inline bool
    3203                 :    6764081 : varpool_node::all_refs_explicit_p ()
    3204                 :            : {
    3205                 :    6764081 :   return (definition
    3206                 :            :           && !externally_visible
    3207                 :            :           && !used_from_other_partition
    3208                 :    6764081 :           && !force_output);
    3209                 :            : }
    3210                 :            : 
    3211                 :            : struct tree_descriptor_hasher : ggc_ptr_hash<constant_descriptor_tree>
    3212                 :            : {
    3213                 :            :   static hashval_t hash (constant_descriptor_tree *);
    3214                 :            :   static bool equal (constant_descriptor_tree *, constant_descriptor_tree *);
    3215                 :            : };
    3216                 :            : 
    3217                 :            : /* Constant pool accessor function.  */
    3218                 :            : hash_table<tree_descriptor_hasher> *constant_pool_htab (void);
    3219                 :            : 
    3220                 :            : /* Return node that alias is aliasing.  */
    3221                 :            : 
    3222                 :            : inline cgraph_node *
    3223                 :     216927 : cgraph_node::get_alias_target (void)
    3224                 :            : {
    3225                 :   32995032 :   return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
    3226                 :            : }
    3227                 :            : 
    3228                 :            : /* Return node that alias is aliasing.  */
    3229                 :            : 
    3230                 :            : inline varpool_node *
    3231                 :       6531 : varpool_node::get_alias_target (void)
    3232                 :            : {
    3233                 :      13062 :   return dyn_cast <varpool_node *> (symtab_node::get_alias_target ());
    3234                 :            : }
    3235                 :            : 
    3236                 :            : /* Walk the alias chain to return the symbol NODE is alias of.
    3237                 :            :    If NODE is not an alias, return NODE.
    3238                 :            :    When AVAILABILITY is non-NULL, get minimal availability in the chain.
    3239                 :            :    When REF is non-NULL, assume that reference happens in symbol REF
    3240                 :            :    when determining the availability.  */
    3241                 :            : 
    3242                 :            : inline symtab_node *
    3243                 :  696739032 : symtab_node::ultimate_alias_target (enum availability *availability,
    3244                 :            :                                     symtab_node *ref)
    3245                 :            : {
    3246                 :  696675032 :   if (!alias)
    3247                 :            :     {
    3248                 :  600189429 :       if (availability)
    3249                 :  292795894 :         *availability = get_availability (ref);
    3250                 :  600189429 :       return this;
    3251                 :            :     }
    3252                 :            : 
    3253                 :   19155777 :   return ultimate_alias_target_1 (availability, ref);
    3254                 :            : }
    3255                 :            : 
    3256                 :            : /* Given function symbol, walk the alias chain to return the function node
    3257                 :            :    is alias of. Do not walk through thunks.
    3258                 :            :    When AVAILABILITY is non-NULL, get minimal availability in the chain.
    3259                 :            :    When REF is non-NULL, assume that reference happens in symbol REF
    3260                 :            :    when determining the availability.  */
    3261                 :            : 
    3262                 :            : inline cgraph_node *
    3263                 :  403527050 : cgraph_node::ultimate_alias_target (enum availability *availability,
    3264                 :            :                                     symtab_node *ref)
    3265                 :            : {
    3266                 :  403527050 :   cgraph_node *n = dyn_cast <cgraph_node *>
    3267                 :  403527050 :     (symtab_node::ultimate_alias_target (availability, ref));
    3268                 :  403527050 :   if (!n && availability)
    3269                 :          0 :     *availability = AVAIL_NOT_AVAILABLE;
    3270                 :  403527050 :   return n;
    3271                 :            : }
    3272                 :            : 
    3273                 :            : /* For given variable pool node, walk the alias chain to return the function
    3274                 :            :    the variable is alias of. Do not walk through thunks.
    3275                 :            :    When AVAILABILITY is non-NULL, get minimal availability in the chain.
    3276                 :            :    When REF is non-NULL, assume that reference happens in symbol REF
    3277                 :            :    when determining the availability.  */
    3278                 :            : 
    3279                 :            : inline varpool_node *
    3280                 :   27942823 : varpool_node::ultimate_alias_target (availability *availability,
    3281                 :            :                                      symtab_node *ref)
    3282                 :            : {
    3283                 :   27942823 :   varpool_node *n = dyn_cast <varpool_node *>
    3284                 :   27942823 :     (symtab_node::ultimate_alias_target (availability, ref));
    3285                 :            : 
    3286                 :   27942823 :   if (!n && availability)
    3287                 :          0 :     *availability = AVAIL_NOT_AVAILABLE;
    3288                 :   27942823 :   return n;
    3289                 :            : }
    3290                 :            : 
    3291                 :            : /* Set callee N of call graph edge and add it to the corresponding set of
    3292                 :            :    callers. */
    3293                 :            : 
    3294                 :            : inline void
    3295                 :    2163840 : cgraph_edge::set_callee (cgraph_node *n)
    3296                 :            : {
    3297                 :    2163840 :   prev_caller = NULL;
    3298                 :    2163840 :   if (n->callers)
    3299                 :     147890 :     n->callers->prev_caller = this;
    3300                 :    2163840 :   next_caller = n->callers;
    3301                 :    2163840 :   n->callers = this;
    3302                 :    2163840 :   callee = n;
    3303                 :            : }
    3304                 :            : 
    3305                 :            : /* Return true when the edge represents a direct recursion.  */
    3306                 :            : 
    3307                 :            : inline bool
    3308                 :            : cgraph_edge::recursive_p (void)
    3309                 :            : {
    3310                 :            :   cgraph_node *c = callee->ultimate_alias_target ();
    3311                 :            :   if (caller->inlined_to)
    3312                 :            :     return caller->inlined_to->decl == c->decl;
    3313                 :            :   else
    3314                 :            :     return caller->decl == c->decl;
    3315                 :            : }
    3316                 :            : 
    3317                 :            : /* Remove the edge from the list of the callers of the callee.  */
    3318                 :            : 
    3319                 :            : inline void
    3320                 :   25826200 : cgraph_edge::remove_callee (void)
    3321                 :            : {
    3322                 :   25826200 :   gcc_assert (!indirect_unknown_callee);
    3323                 :   25826200 :   if (prev_caller)
    3324                 :   11007800 :     prev_caller->next_caller = next_caller;
    3325                 :   25826200 :   if (next_caller)
    3326                 :   15234200 :     next_caller->prev_caller = prev_caller;
    3327                 :   25826200 :   if (!prev_caller)
    3328                 :   14818400 :     callee->callers = next_caller;
    3329                 :   25826200 : }
    3330                 :            : 
    3331                 :            : /* Return true if call must bind to current definition.  */
    3332                 :            : 
    3333                 :            : inline bool
    3334                 :            : cgraph_edge::binds_to_current_def_p ()
    3335                 :            : {
    3336                 :            :   if (callee)
    3337                 :            :     return callee->binds_to_current_def_p (caller);
    3338                 :            :   else
    3339                 :            :     return false;
    3340                 :            : }
    3341                 :            : 
    3342                 :            : /* Expected frequency of executions within the function.
    3343                 :            :    When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
    3344                 :            :    per function call.  The range is 0 to CGRAPH_FREQ_MAX.  */
    3345                 :            : 
    3346                 :            : inline int
    3347                 :     283268 : cgraph_edge::frequency ()
    3348                 :            : {
    3349                 :     283268 :   return count.to_cgraph_frequency (caller->inlined_to
    3350                 :     283268 :                                     ? caller->inlined_to->count
    3351                 :            :                                     : caller->count);
    3352                 :            : }
    3353                 :            : 
    3354                 :            : 
    3355                 :            : /* Return true if the TM_CLONE bit is set for a given FNDECL.  */
    3356                 :            : static inline bool
    3357                 :     762246 : decl_is_tm_clone (const_tree fndecl)
    3358                 :            : {
    3359                 :     762246 :   cgraph_node *n = cgraph_node::get (fndecl);
    3360                 :     762246 :   if (n)
    3361                 :     679701 :     return n->tm_clone;
    3362                 :            :   return false;
    3363                 :            : }
    3364                 :            : 
    3365                 :            : /* Likewise indicate that a node is needed, i.e. reachable via some
    3366                 :            :    external means.  */
    3367                 :            : 
    3368                 :            : inline void
    3369                 :       3316 : cgraph_node::mark_force_output (void)
    3370                 :            : {
    3371                 :       3316 :   force_output = 1;
    3372                 :       3316 :   gcc_checking_assert (!inlined_to);
    3373                 :            : }
    3374                 :            : 
    3375                 :            : /* Return true if function should be optimized for size.  */
    3376                 :            : 
    3377                 :            : inline bool
    3378                 : 1165010465 : cgraph_node::optimize_for_size_p (void)
    3379                 :            : {
    3380                 : 1165010465 :   if (opt_for_fn (decl, optimize_size))
    3381                 :            :     return true;
    3382                 : 1126000454 :   if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
    3383                 :            :     return true;
    3384                 :            :   else
    3385                 :      40093 :     return false;
    3386                 :            : }
    3387                 :            : 
    3388                 :            : /* Return symtab_node for NODE or create one if it is not present
    3389                 :            :    in symtab.  */
    3390                 :            : 
    3391                 :            : inline symtab_node *
    3392                 :   12158919 : symtab_node::get_create (tree node)
    3393                 :            : {
    3394                 :   12158919 :   if (TREE_CODE (node) == VAR_DECL)
    3395                 :   11153528 :     return varpool_node::get_create (node);
    3396                 :            :   else
    3397                 :    1005394 :     return cgraph_node::get_create (node);
    3398                 :            : }
    3399                 :            : 
    3400                 :            : /* Return availability of NODE when referenced from REF.  */
    3401                 :            : 
    3402                 :            : inline enum availability
    3403                 :  298973044 : symtab_node::get_availability (symtab_node *ref)
    3404                 :            : {
    3405                 :  298973044 :   if (is_a <cgraph_node *> (this))
    3406                 :  112424443 :     return dyn_cast <cgraph_node *> (this)->get_availability (ref);
    3407                 :            :   else
    3408                 :  186548929 :     return dyn_cast <varpool_node *> (this)->get_availability (ref);
    3409                 :            : }
    3410                 :            : 
    3411                 :            : /* Call callback on symtab node and aliases associated to this node.
    3412                 :            :    When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */
    3413                 :            : 
    3414                 :            : inline bool
    3415                 :   14595938 : symtab_node::call_for_symbol_and_aliases (bool (*callback) (symtab_node *,
    3416                 :            :                                                             void *),
    3417                 :            :                                           void *data,
    3418                 :            :                                           bool include_overwritable)
    3419                 :            : {
    3420                 :   14595938 :   if (include_overwritable
    3421                 :   14595938 :       || get_availability () > AVAIL_INTERPOSABLE)
    3422                 :            :     {
    3423                 :   14595938 :       if (callback (this, data))
    3424                 :            :         return true;
    3425                 :            :     }
    3426                 :   11985047 :   if (has_aliases_p ())
    3427                 :     125343 :     return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
    3428                 :            :   return false;
    3429                 :            : }
    3430                 :            : 
    3431                 :            : /* Call callback on function and aliases associated to the function.
    3432                 :            :    When INCLUDE_OVERWRITABLE is false, overwritable symbols are
    3433                 :            :    skipped.  */
    3434                 :            : 
    3435                 :            : inline bool
    3436                 :   19634477 : cgraph_node::call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
    3437                 :            :                                                             void *),
    3438                 :            :                                           void *data,
    3439                 :            :                                           bool include_overwritable)
    3440                 :            : {
    3441                 :   19634477 :   if (include_overwritable
    3442                 :   19634477 :       || get_availability () > AVAIL_INTERPOSABLE)
    3443                 :            :     {
    3444                 :   19634477 :       if (callback (this, data))
    3445                 :            :         return true;
    3446                 :            :     }
    3447                 :   11479599 :   if (has_aliases_p ())
    3448                 :     263119 :     return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
    3449                 :            :   return false;
    3450                 :            : }
    3451                 :            : 
    3452                 :            : /* Call callback on varpool symbol and aliases associated to varpool symbol.
    3453                 :            :    When INCLUDE_OVERWRITABLE is false, overwritable symbols are
    3454                 :            :    skipped. */
    3455                 :            : 
    3456                 :            : inline bool
    3457                 :     149606 : varpool_node::call_for_symbol_and_aliases (bool (*callback) (varpool_node *,
    3458                 :            :                                                              void *),
    3459                 :            :                                            void *data,
    3460                 :            :                                            bool include_overwritable)
    3461                 :            : {
    3462                 :     149606 :   if (include_overwritable
    3463                 :     149606 :       || get_availability () > AVAIL_INTERPOSABLE)
    3464                 :            :     {
    3465                 :     149606 :       if (callback (this, data))
    3466                 :            :         return true;
    3467                 :            :     }
    3468                 :     154245 :   if (has_aliases_p ())
    3469                 :       4639 :     return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
    3470                 :            :   return false;
    3471                 :            : }
    3472                 :            : 
    3473                 :            : /* Return true if reference may be used in address compare.  */
    3474                 :            : 
    3475                 :            : inline bool
    3476                 :    5264245 : ipa_ref::address_matters_p ()
    3477                 :            : {
    3478                 :    5264245 :   if (use != IPA_REF_ADDR)
    3479                 :            :     return false;
    3480                 :            :   /* Addresses taken from virtual tables are never compared.  */
    3481                 :    4245004 :   if (is_a <varpool_node *> (referring)
    3482                 :    3176398 :       && DECL_VIRTUAL_P (referring->decl))
    3483                 :            :     return false;
    3484                 :    4172947 :   return referred->address_can_be_compared_p ();
    3485                 :            : }
    3486                 :            : 
    3487                 :            : /* Build polymorphic call context for indirect call E.  */
    3488                 :            : 
    3489                 :            : inline
    3490                 :     185901 : ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge *e)
    3491                 :            : {
    3492                 :     185901 :   gcc_checking_assert (e->indirect_info->polymorphic);
    3493                 :     185901 :   *this = e->indirect_info->context;
    3494                 :     185901 : }
    3495                 :            : 
    3496                 :            : /* Build empty "I know nothing" context.  */
    3497                 :            : 
    3498                 :            : inline
    3499                 :  392645764 : ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
    3500                 :            : {
    3501                 :  392645764 :   clear_speculation ();
    3502                 :  392645764 :   clear_outer_type ();
    3503                 :  392645764 :   invalid = false;
    3504                 :            : }
    3505                 :            : 
    3506                 :            : /* Make context non-speculative.  */
    3507                 :            : 
    3508                 :            : inline void
    3509                 :  396852600 : ipa_polymorphic_call_context::clear_speculation ()
    3510                 :            : {
    3511                 :  396852600 :   speculative_outer_type = NULL;
    3512                 :  396852600 :   speculative_offset = 0;
    3513                 :  396358470 :   speculative_maybe_derived_type = false;
    3514                 :     790888 : }
    3515                 :            : 
    3516                 :            : /* Produce context specifying all derived types of OTR_TYPE.  If OTR_TYPE is
    3517                 :            :    NULL, the context is set to dummy "I know nothing" setting.  */
    3518                 :            : 
    3519                 :            : inline void
    3520                 :  395294873 : ipa_polymorphic_call_context::clear_outer_type (tree otr_type)
    3521                 :            : {
    3522                 :  394503444 :   outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type) : NULL;
    3523                 :  395294873 :   offset = 0;
    3524                 :  395294873 :   maybe_derived_type = true;
    3525                 :  395294873 :   maybe_in_construction = true;
    3526                 :  393114120 :   dynamic = true;
    3527                 :    2171237 : }
    3528                 :            : 
    3529                 :            : /* Adjust all offsets in contexts by OFF bits.  */
    3530                 :            : 
    3531                 :            : inline void
    3532                 :      91305 : ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off)
    3533                 :            : {
    3534                 :      91305 :   if (outer_type)
    3535                 :      36162 :     offset += off;
    3536                 :      91305 :   if (speculative_outer_type)
    3537                 :      52592 :     speculative_offset += off;
    3538                 :            : }
    3539                 :            : 
    3540                 :            : /* Return TRUE if context is fully useless.  */
    3541                 :            : 
    3542                 :            : inline bool
    3543                 :    2577243 : ipa_polymorphic_call_context::useless_p () const
    3544                 :            : {
    3545                 :    2577212 :   return (!outer_type && !speculative_outer_type);
    3546                 :            : }
    3547                 :            : 
    3548                 :            : /* When using fprintf (or similar), problems can arise with
    3549                 :            :    transient generated strings.  Many string-generation APIs
    3550                 :            :    only support one result being alive at once (e.g. by
    3551                 :            :    returning a pointer to a statically-allocated buffer).
    3552                 :            : 
    3553                 :            :    If there is more than one generated string within one
    3554                 :            :    fprintf call: the first string gets evicted or overwritten
    3555                 :            :    by the second, before fprintf is fully evaluated.
    3556                 :            :    See e.g. PR/53136.
    3557                 :            : 
    3558                 :            :    This function provides a workaround for this, by providing
    3559                 :            :    a simple way to create copies of these transient strings,
    3560                 :            :    without the need to have explicit cleanup:
    3561                 :            : 
    3562                 :            :        fprintf (dumpfile, "string 1: %s string 2:%s\n",
    3563                 :            :                 xstrdup_for_dump (EXPR_1),
    3564                 :            :                 xstrdup_for_dump (EXPR_2));
    3565                 :            : 
    3566                 :            :    This is actually a simple wrapper around ggc_strdup, but
    3567                 :            :    the name documents the intent.  We require that no GC can occur
    3568                 :            :    within the fprintf call.  */
    3569                 :            : 
    3570                 :            : static inline const char *
    3571                 :     312167 : xstrdup_for_dump (const char *transient_str)
    3572                 :            : {
    3573                 :     312167 :   return ggc_strdup (transient_str);
    3574                 :            : }
    3575                 :            : 
    3576                 :            : /* During LTO stream-in this predicate can be used to check whether node
    3577                 :            :    in question prevails in the linking to save some memory usage.  */
    3578                 :            : inline bool
    3579                 :     491067 : symtab_node::prevailing_p (void)
    3580                 :            : {
    3581                 :     491067 :   return definition && ((!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
    3582                 :     915217 :                          || previous_sharing_asm_name == NULL);
    3583                 :            : }
    3584                 :            : 
    3585                 :            : extern GTY(()) symbol_table *saved_symtab;
    3586                 :            : 
    3587                 :            : #if CHECKING_P
    3588                 :            : 
    3589                 :            : namespace selftest {
    3590                 :            : 
    3591                 :            : /* An RAII-style class for use in selftests for temporarily using a different
    3592                 :            :    symbol_table, so that such tests can be isolated from each other.  */
    3593                 :            : 
    3594                 :            : class symbol_table_test
    3595                 :            : {
    3596                 :            :  public:
    3597                 :            :   /* Constructor.  Override "symtab".  */
    3598                 :            :   symbol_table_test ();
    3599                 :            : 
    3600                 :            :   /* Destructor.  Restore the saved_symtab.  */
    3601                 :            :   ~symbol_table_test ();
    3602                 :            : };
    3603                 :            : 
    3604                 :            : } // namespace selftest
    3605                 :            : 
    3606                 :            : #endif /* CHECKING_P */
    3607                 :            : 
    3608                 :            : #endif  /* GCC_CGRAPH_H  */

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.