LCOV - code coverage report
Current view: top level - gcc - cgraph.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 44 63 69.8 %
Date: 2023-07-19 08:18:47 Functions: 6 9 66.7 %

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

Generated by: LCOV version 1.16