gcc/cgraph.h

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