gcc/cgraph.h

   1 /* Callgraph handling code.
   2    Copyright (C) 2003-2013 Free Software Foundation, Inc.
   3    Contributed by Jan Hubicka
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_CGRAPH_H
  22 #define GCC_CGRAPH_H
  23
  24 #include "is-a.h"
  25 #include "plugin-api.h"
  26 #include "vec.h"
  27 #include "tree.h"
  28 #include "basic-block.h"
  29 #include "function.h"
  30 #include "ipa-ref.h"
  31
  32 /* Symbol table consists of functions and variables.
  33    TODO: add labels and CONST_DECLs.  */
  34 enum symtab_type
  35 {
  36   SYMTAB_SYMBOL,
  37   SYMTAB_FUNCTION,
  38   SYMTAB_VARIABLE
  39 };
  40
  41 /* Base of all entries in the symbol table.
  42    The symtab_node is inherited by cgraph and varpol nodes.  */
  43 struct GTY(()) symtab_node_base
  44 {
  45   /* Type of the symbol.  */
  46   ENUM_BITFIELD (symtab_type) type : 8;
  47
  48   /* The symbols resolution.  */
  49   ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;
  50
  51   /*** Flags representing the symbol type.  ***/
  52
  53   /* True when symbol corresponds to a definition in current unit.
  54      set via cgraph_finalize_function or varpool_finalize_decl  */
  55   unsigned definition : 1;
  56   /* True when symbol is an alias.
  57      Set by assemble_alias.  */
  58   unsigned alias : 1;
  59   /* True when alias is a weakref.  */
  60   unsigned weakref : 1;
  61   /* C++ frontend produce same body aliases and extra name aliases for
  62      virtual functions and vtables that are obviously equivalent.
  63      Those aliases are bit special, especially because C++ frontend
  64      visibility code is so ugly it can not get them right at first time
  65      and their visibility needs to be copied from their "masters" at
  66      the end of parsing.  */
  67   unsigned cpp_implicit_alias : 1;
  68   /* Set once the definition was analyzed.  The list of references and
  69      other properties are built during analysis.  */
  70   unsigned analyzed : 1;
  71
  72
  73   /*** Visibility and linkage flags.  ***/
  74
  75   /* Set when function is visible by other units.  */
  76   unsigned externally_visible : 1;
  77   /* The symbol will be assumed to be used in an invisiable way (like
  78      by an toplevel asm statement).  */
  79   unsigned force_output : 1;
  80   /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
  81      exported.  Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
  82      to static and it does not inhibit optimization.  */
  83   unsigned forced_by_abi : 1;
  84   /* True when the name is known to be unique and thus it does not need mangling.  */
  85   unsigned unique_name : 1;
  86
  87
  88   /*** WHOPR Partitioning flags.
  89        These flags are used at ltrans stage when only part of the callgraph is
  90        available. ***/
  91
  92   /* Set when variable is used from other LTRANS partition.  */
  93   unsigned used_from_other_partition : 1;
  94   /* Set when function is available in the other LTRANS partition.
  95      During WPA output it is used to mark nodes that are present in
  96      multiple partitions.  */
  97   unsigned in_other_partition : 1;
  98
  99
 100
 101   /*** other flags.  ***/
 102
 103   /* Set when symbol has address taken. */
 104   unsigned address_taken : 1;
 105
 106
 107   /* Ordering of all symtab entries.  */
 108   int order;
 109
 110   /* Declaration representing the symbol.  */
 111   tree decl;
 112
 113   /* Linked list of symbol table entries starting with symtab_nodes.  */
 114   symtab_node next;
 115   symtab_node previous;
 116
 117   /* Linked list of symbols with the same asm name.  There may be multiple
 118      entries for single symbol name during LTO, because symbols are renamed
 119      only after partitioning.
 120
 121      Because inline clones are kept in the assembler name has, they also produce
 122      duplicate entries.
 123
 124      There are also several long standing bugs where frontends and builtin
 125      code produce duplicated decls.  */
 126   symtab_node next_sharing_asm_name;
 127   symtab_node previous_sharing_asm_name;
 128
 129   /* Circular list of nodes in the same comdat group if non-NULL.  */
 130   symtab_node same_comdat_group;
 131
 132   /* Vectors of referring and referenced entities.  */
 133   struct ipa_ref_list ref_list;
 134
 135   /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
 136      depending to what was known to frontend on the creation time.
 137      Once alias is resolved, this pointer become NULL.  */
 138   tree alias_target;
 139
 140   /* File stream where this node is being written to.  */
 141   struct lto_file_decl_data * lto_file_data;
 142
 143   PTR GTY ((skip)) aux;
 144 };
 145
 146 enum availability
 147 {
 148   /* Not yet set by cgraph_function_body_availability.  */
 149   AVAIL_UNSET,
 150   /* Function body/variable initializer is unknown.  */
 151   AVAIL_NOT_AVAILABLE,
 152   /* Function body/variable initializer is known but might be replaced
 153      by a different one from other compilation unit and thus needs to
 154      be dealt with a care.  Like AVAIL_NOT_AVAILABLE it can have
 155      arbitrary side effects on escaping variables and functions, while
 156      like AVAILABLE it might access static variables.  */
 157   AVAIL_OVERWRITABLE,
 158   /* Function body/variable initializer is known and will be used in final
 159      program.  */
 160   AVAIL_AVAILABLE,
 161   /* Function body/variable initializer is known and all it's uses are explicitly
 162      visible within current unit (ie it's address is never taken and it is not
 163      exported to other units).
 164      Currently used only for functions.  */
 165   AVAIL_LOCAL
 166 };
 167
 168 /* This is the information that is put into the cgraph local structure
 169    to recover a function.  */
 170 struct lto_file_decl_data;
 171
 172 extern const char * const cgraph_availability_names[];
 173 extern const char * const ld_plugin_symbol_resolution_names[];
 174
 175 /* Information about thunk, used only for same body aliases.  */
 176
 177 struct GTY(()) cgraph_thunk_info {
 178   /* Information about the thunk.  */
 179   HOST_WIDE_INT fixed_offset;
 180   HOST_WIDE_INT virtual_value;
 181   tree alias;
 182   bool this_adjusting;
 183   bool virtual_offset_p;
 184   /* Set to true when alias node is thunk.  */
 185   bool thunk_p;
 186 };
 187
 188 /* Information about the function collected locally.
 189    Available after function is analyzed.  */
 190
 191 struct GTY(()) cgraph_local_info {
 192   /* Set when function function is visible in current compilation unit only
 193      and its address is never taken.  */
 194   unsigned local : 1;
 195
 196   /* False when there is something makes versioning impossible.  */
 197   unsigned versionable : 1;
 198
 199   /* False when function calling convention and signature can not be changed.
 200      This is the case when __builtin_apply_args is used.  */
 201   unsigned can_change_signature : 1;
 202
 203   /* True when the function has been originally extern inline, but it is
 204      redefined now.  */
 205   unsigned redefined_extern_inline : 1;
 206
 207   /* True if the function may enter serial irrevocable mode.  */
 208   unsigned tm_may_enter_irr : 1;
 209 };
 210
 211 /* Information about the function that needs to be computed globally
 212    once compilation is finished.  Available only with -funit-at-a-time.  */
 213
 214 struct GTY(()) cgraph_global_info {
 215   /* For inline clones this points to the function they will be
 216      inlined into.  */
 217   struct cgraph_node *inlined_to;
 218 };
 219
 220 /* Information about the function that is propagated by the RTL backend.
 221    Available only for functions that has been already assembled.  */
 222
 223 struct GTY(()) cgraph_rtl_info {
 224    unsigned int preferred_incoming_stack_boundary;
 225 };
 226
 227 /* Represent which DECL tree (or reference to such tree)
 228    will be replaced by another tree while versioning.  */
 229 struct GTY(()) ipa_replace_map
 230 {
 231   /* The tree that will be replaced.  */
 232   tree old_tree;
 233   /* The new (replacing) tree.  */
 234   tree new_tree;
 235   /* Parameter number to replace, when old_tree is NULL.  */
 236   int parm_num;
 237   /* True when a substitution should be done, false otherwise.  */
 238   bool replace_p;
 239   /* True when we replace a reference to old_tree.  */
 240   bool ref_p;
 241 };
 242 typedef struct ipa_replace_map *ipa_replace_map_p;
 243
 244 struct GTY(()) cgraph_clone_info
 245 {
 246   vec<ipa_replace_map_p, va_gc> *tree_map;
 247   bitmap args_to_skip;
 248   bitmap combined_args_to_skip;
 249 };
 250
 251
 252 /* The cgraph data structure.
 253    Each function decl has assigned cgraph_node listing callees and callers.  */
 254
 255 struct GTY(()) cgraph_node {
 256   struct symtab_node_base symbol;
 257   struct cgraph_edge *callees;
 258   struct cgraph_edge *callers;
 259   /* List of edges representing indirect calls with a yet undetermined
 260      callee.  */
 261   struct cgraph_edge *indirect_calls;
 262   /* For nested functions points to function the node is nested in.  */
 263   struct cgraph_node *
 264     GTY ((nested_ptr (union symtab_node_def, "(struct cgraph_node *)(%h)", "(symtab_node)%h")))
 265     origin;
 266   /* Points to first nested function, if any.  */
 267   struct cgraph_node *
 268     GTY ((nested_ptr (union symtab_node_def, "(struct cgraph_node *)(%h)", "(symtab_node)%h")))
 269     nested;
 270   /* Pointer to the next function with same origin, if any.  */
 271   struct cgraph_node *
 272     GTY ((nested_ptr (union symtab_node_def, "(struct cgraph_node *)(%h)", "(symtab_node)%h")))
 273     next_nested;
 274   /* Pointer to the next clone.  */
 275   struct cgraph_node *next_sibling_clone;
 276   struct cgraph_node *prev_sibling_clone;
 277   struct cgraph_node *clones;
 278   struct cgraph_node *clone_of;
 279   /* For functions with many calls sites it holds map from call expression
 280      to the edge to speed up cgraph_edge function.  */
 281   htab_t GTY((param_is (struct cgraph_edge))) call_site_hash;
 282   /* Declaration node used to be clone of. */
 283   tree former_clone_of;
 284
 285   /* Interprocedural passes scheduled to have their transform functions
 286      applied next time we execute local pass on them.  We maintain it
 287      per-function in order to allow IPA passes to introduce new functions.  */
 288   vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
 289
 290   struct cgraph_local_info local;
 291   struct cgraph_global_info global;
 292   struct cgraph_rtl_info rtl;
 293   struct cgraph_clone_info clone;
 294   struct cgraph_thunk_info thunk;
 295
 296   /* Expected number of executions: calculated in profile.c.  */
 297   gcov_type count;
 298   /* How to scale counts at materialization time; used to merge
 299      LTO units with different number of profile runs.  */
 300   int count_materialization_scale;
 301   /* Unique id of the node.  */
 302   int uid;
 303   /* ID assigned by the profiling.  */
 304   unsigned int profile_id;
 305
 306   /* Set when decl is an abstract function pointed to by the
 307      ABSTRACT_DECL_ORIGIN of a reachable function.  */
 308   unsigned used_as_abstract_origin : 1;
 309   /* Set once the function is lowered (i.e. its CFG is built).  */
 310   unsigned lowered : 1;
 311   /* Set once the function has been instantiated and its callee
 312      lists created.  */
 313   unsigned process : 1;
 314   /* How commonly executed the node is.  Initialized during branch
 315      probabilities pass.  */
 316   ENUM_BITFIELD (node_frequency) frequency : 2;
 317   /* True when function can only be called at startup (from static ctor).  */
 318   unsigned only_called_at_startup : 1;
 319   /* True when function can only be called at startup (from static dtor).  */
 320   unsigned only_called_at_exit : 1;
 321   /* True when function is the transactional clone of a function which
 322      is called only from inside transactions.  */
 323   /* ?? We should be able to remove this.  We have enough bits in
 324      cgraph to calculate it.  */
 325   unsigned tm_clone : 1;
 326   /* True if this decl is a dispatcher for function versions.  */
 327   unsigned dispatcher_function : 1;
 328 };
 329
 330
 331 typedef struct cgraph_node *cgraph_node_ptr;
 332
 333
 334 /* Function Multiversioning info.  */
 335 struct GTY(()) cgraph_function_version_info {
 336   /* The cgraph_node for which the function version info is stored.  */
 337   struct cgraph_node *this_node;
 338   /* Chains all the semantically identical function versions.  The
 339      first function in this chain is the version_info node of the
 340      default function.  */
 341   struct cgraph_function_version_info *prev;
 342   /* If this version node corresponds to a dispatcher for function
 343      versions, this points to the version info node of the default
 344      function, the first node in the chain.  */
 345   struct cgraph_function_version_info *next;
 346   /* If this node corresponds to a function version, this points
 347      to the dispatcher function decl, which is the function that must
 348      be called to execute the right function version at run-time.
 349
 350      If this cgraph node is a dispatcher (if dispatcher_function is
 351      true, in the cgraph_node struct) for function versions, this
 352      points to resolver function, which holds the function body of the
 353      dispatcher. The dispatcher decl is an alias to the resolver
 354      function decl.  */
 355   tree dispatcher_resolver;
 356 };
 357
 358 /* Get the cgraph_function_version_info node corresponding to node.  */
 359 struct cgraph_function_version_info *
 360   get_cgraph_node_version (struct cgraph_node *node);
 361
 362 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
 363    corresponding to cgraph_node NODE.  */
 364 struct cgraph_function_version_info *
 365   insert_new_cgraph_node_version (struct cgraph_node *node);
 366
 367 /* Record that DECL1 and DECL2 are semantically identical function
 368    versions.  */
 369 void record_function_versions (tree decl1, tree decl2);
 370
 371 /* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
 372    DECL is a duplicate declaration.  */
 373 void delete_function_version (tree decl);
 374
 375 /* A cgraph node set is a collection of cgraph nodes.  A cgraph node
 376    can appear in multiple sets.  */
 377 struct cgraph_node_set_def
 378 {
 379   struct pointer_map_t *map;
 380   vec<cgraph_node_ptr> nodes;
 381 };
 382
 383 typedef struct varpool_node *varpool_node_ptr;
 384
 385
 386 /* A varpool node set is a collection of varpool nodes.  A varpool node
 387    can appear in multiple sets.  */
 388 struct varpool_node_set_def
 389 {
 390   struct pointer_map_t * map;
 391   vec<varpool_node_ptr> nodes;
 392 };
 393
 394 typedef struct cgraph_node_set_def *cgraph_node_set;
 395
 396
 397 typedef struct varpool_node_set_def *varpool_node_set;
 398
 399
 400 /* Iterator structure for cgraph node sets.  */
 401 typedef struct
 402 {
 403   cgraph_node_set set;
 404   unsigned index;
 405 } cgraph_node_set_iterator;
 406
 407 /* Iterator structure for varpool node sets.  */
 408 typedef struct
 409 {
 410   varpool_node_set set;
 411   unsigned index;
 412 } varpool_node_set_iterator;
 413
 414 #define DEFCIFCODE(code, string)        CIF_ ## code,
 415 /* Reasons for inlining failures.  */
 416 typedef enum cgraph_inline_failed_enum {
 417 #include "cif-code.def"
 418   CIF_N_REASONS
 419 } cgraph_inline_failed_t;
 420
 421 /* Structure containing additional information about an indirect call.  */
 422
 423 struct GTY(()) cgraph_indirect_call_info
 424 {
 425   /* When polymorphic is set, this field contains offset where the object which
 426      was actually used in the polymorphic resides within a larger structure.
 427      If agg_contents is set, the field contains the offset within the aggregate
 428      from which the address to call was loaded.  */
 429   HOST_WIDE_INT offset;
 430   /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set).  */
 431   HOST_WIDE_INT otr_token;
 432   /* Type of the object from OBJ_TYPE_REF_OBJECT. */
 433   tree otr_type;
 434   /* Index of the parameter that is called.  */
 435   int param_index;
 436   /* ECF flags determined from the caller.  */
 437   int ecf_flags;
 438
 439   /* Set when the call is a virtual call with the parameter being the
 440      associated object pointer rather than a simple direct call.  */
 441   unsigned polymorphic : 1;
 442   /* Set when the call is a call of a pointer loaded from contents of an
 443      aggregate at offset.  */
 444   unsigned agg_contents : 1;
 445   /* Set when this is a call through a member pointer.  */
 446   unsigned member_ptr : 1;
 447   /* When the previous bit is set, this one determines whether the destination
 448      is loaded from a parameter passed by reference. */
 449   unsigned by_ref : 1;
 450 };
 451
 452 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgraph_edge {
 453   /* Expected number of executions: calculated in profile.c.  */
 454   gcov_type count;
 455   struct cgraph_node *caller;
 456   struct cgraph_node *callee;
 457   struct cgraph_edge *prev_caller;
 458   struct cgraph_edge *next_caller;
 459   struct cgraph_edge *prev_callee;
 460   struct cgraph_edge *next_callee;
 461   gimple call_stmt;
 462   /* Additional information about an indirect call.  Not cleared when an edge
 463      becomes direct.  */
 464   struct cgraph_indirect_call_info *indirect_info;
 465   PTR GTY ((skip (""))) aux;
 466   /* When equal to CIF_OK, inline this call.  Otherwise, points to the
 467      explanation why function was not inlined.  */
 468   cgraph_inline_failed_t inline_failed;
 469   /* The stmt_uid of call_stmt.  This is used by LTO to recover the call_stmt
 470      when the function is serialized in.  */
 471   unsigned int lto_stmt_uid;
 472   /* Expected frequency of executions within the function.
 473      When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
 474      per function call.  The range is 0 to CGRAPH_FREQ_MAX.  */
 475   int frequency;
 476   /* Unique id of the edge.  */
 477   int uid;
 478   /* Whether this edge was made direct by indirect inlining.  */
 479   unsigned int indirect_inlining_edge : 1;
 480   /* Whether this edge describes an indirect call with an undetermined
 481      callee.  */
 482   unsigned int indirect_unknown_callee : 1;
 483   /* Whether this edge is still a dangling  */
 484   /* True if the corresponding CALL stmt cannot be inlined.  */
 485   unsigned int call_stmt_cannot_inline_p : 1;
 486   /* Can this call throw externally?  */
 487   unsigned int can_throw_external : 1;
 488   /* Edges with SPECULATIVE flag represents indirect calls that was
 489      speculatively turned into direct (i.e. by profile feedback).
 490      The final code sequence will have form:
 491
 492      if (call_target == expected_fn)
 493        expected_fn ();
 494      else
 495        call_target ();
 496
 497      Every speculative call is represented by three components attached
 498      to a same call statement:
 499      1) a direct call (to expected_fn)
 500      2) an indirect call (to call_target)
 501      3) a IPA_REF_ADDR refrence to expected_fn.
 502
 503      Optimizers may later redirect direct call to clone, so 1) and 3)
 504      do not need to necesarily agree with destination.  */
 505   unsigned int speculative : 1;
 506 };
 507
 508 #define CGRAPH_FREQ_BASE 1000
 509 #define CGRAPH_FREQ_MAX 100000
 510
 511 typedef struct cgraph_edge *cgraph_edge_p;
 512
 513
 514 /* The varpool data structure.
 515    Each static variable decl has assigned varpool_node.  */
 516
 517 struct GTY(()) varpool_node {
 518   struct symtab_node_base symbol;
 519
 520   /* Set when variable is scheduled to be assembled.  */
 521   unsigned output : 1;
 522 };
 523
 524 /* Every top level asm statement is put into a asm_node.  */
 525
 526 struct GTY(()) asm_node {
 527   /* Next asm node.  */
 528   struct asm_node *next;
 529   /* String for this asm node.  */
 530   tree asm_str;
 531   /* Ordering of all cgraph nodes.  */
 532   int order;
 533 };
 534
 535 /* Symbol table entry.  */
 536 union GTY((desc ("%h.symbol.type"), chain_next ("%h.symbol.next"),
 537            chain_prev ("%h.symbol.previous"))) symtab_node_def {
 538   struct symtab_node_base GTY ((tag ("SYMTAB_SYMBOL"))) symbol;
 539   /* To access the following fields,
 540      use the use dyn_cast or as_a to obtain the concrete type.  */
 541   struct cgraph_node GTY ((tag ("SYMTAB_FUNCTION"))) x_function;
 542   struct varpool_node GTY ((tag ("SYMTAB_VARIABLE"))) x_variable;
 543 };
 544
 545 /* Report whether or not THIS symtab node is a function, aka cgraph_node.  */
 546
 547 template <>
 548 template <>
 549 inline bool
 550 is_a_helper <cgraph_node>::test (symtab_node_def *p)
 551 {
 552   return p->symbol.type == SYMTAB_FUNCTION;
 553 }
 554
 555 /* Report whether or not THIS symtab node is a vriable, aka varpool_node.  */
 556
 557 template <>
 558 template <>
 559 inline bool
 560 is_a_helper <varpool_node>::test (symtab_node_def *p)
 561 {
 562   return p->symbol.type == SYMTAB_VARIABLE;
 563 }
 564
 565 extern GTY(()) symtab_node symtab_nodes;
 566 extern GTY(()) int cgraph_n_nodes;
 567 extern GTY(()) int cgraph_max_uid;
 568 extern GTY(()) int cgraph_edge_max_uid;
 569 extern bool cgraph_global_info_ready;
 570 enum cgraph_state
 571 {
 572   /* Frontend is parsing and finalizing functions.  */
 573   CGRAPH_STATE_PARSING,
 574   /* Callgraph is being constructed.  It is safe to add new functions.  */
 575   CGRAPH_STATE_CONSTRUCTION,
 576   /* Callgraph is being at LTO time.  */
 577   CGRAPH_LTO_STREAMING,
 578   /* Callgraph is built and IPA passes are being run.  */
 579   CGRAPH_STATE_IPA,
 580   /* Callgraph is built and all functions are transformed to SSA form.  */
 581   CGRAPH_STATE_IPA_SSA,
 582   /* Functions are now ordered and being passed to RTL expanders.  */
 583   CGRAPH_STATE_EXPANSION,
 584   /* All cgraph expansion is done.  */
 585   CGRAPH_STATE_FINISHED
 586 };
 587 extern enum cgraph_state cgraph_state;
 588 extern bool cgraph_function_flags_ready;
 589 extern cgraph_node_set cgraph_new_nodes;
 590
 591 extern GTY(()) struct asm_node *asm_nodes;
 592 extern GTY(()) int symtab_order;
 593 extern bool cpp_implicit_aliases_done;
 594
 595 /* In symtab.c  */
 596 void symtab_register_node (symtab_node);
 597 void symtab_unregister_node (symtab_node);
 598 void symtab_remove_node (symtab_node);
 599 symtab_node symtab_get_node (const_tree);
 600 symtab_node symtab_node_for_asm (const_tree asmname);
 601 const char * symtab_node_asm_name (symtab_node);
 602 const char * symtab_node_name (symtab_node);
 603 void symtab_insert_node_to_hashtable (symtab_node);
 604 void symtab_add_to_same_comdat_group (symtab_node, symtab_node);
 605 void symtab_dissolve_same_comdat_group_list (symtab_node node);
 606 void dump_symtab (FILE *);
 607 void debug_symtab (void);
 608 void dump_symtab_node (FILE *, symtab_node);
 609 void debug_symtab_node (symtab_node);
 610 void dump_symtab_base (FILE *, symtab_node);
 611 void verify_symtab (void);
 612 void verify_symtab_node (symtab_node);
 613 bool verify_symtab_base (symtab_node);
 614 bool symtab_used_from_object_file_p (symtab_node);
 615 void symtab_make_decl_local (tree);
 616 symtab_node symtab_alias_ultimate_target (symtab_node,
 617                                           enum availability *avail = NULL);
 618 bool symtab_resolve_alias (symtab_node node, symtab_node target);
 619 void fixup_same_cpp_alias_visibility (symtab_node node, symtab_node target);
 620 bool symtab_for_node_and_aliases (symtab_node,
 621                                   bool (*) (symtab_node, void *),
 622                                   void *,
 623                                   bool);
 624 symtab_node symtab_nonoverwritable_alias (symtab_node);
 625 enum availability symtab_node_availability (symtab_node);
 626
 627 /* In cgraph.c  */
 628 void dump_cgraph (FILE *);
 629 void debug_cgraph (void);
 630 void dump_cgraph_node (FILE *, struct cgraph_node *);
 631 void debug_cgraph_node (struct cgraph_node *);
 632 void cgraph_remove_edge (struct cgraph_edge *);
 633 void cgraph_remove_node (struct cgraph_node *);
 634 void cgraph_release_function_body (struct cgraph_node *);
 635 void release_function_body (tree);
 636 void cgraph_node_remove_callees (struct cgraph_node *node);
 637 struct cgraph_edge *cgraph_create_edge (struct cgraph_node *,
 638                                         struct cgraph_node *,
 639                                         gimple, gcov_type, int);
 640 struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple,
 641                                                  int, gcov_type, int);
 642 struct cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
 643 struct cgraph_node * cgraph_create_node (tree);
 644 struct cgraph_node * cgraph_create_empty_node (void);
 645 struct cgraph_node * cgraph_get_create_node (tree);
 646 struct cgraph_node * cgraph_get_create_real_symbol_node (tree);
 647 struct cgraph_node * cgraph_same_body_alias (struct cgraph_node *, tree, tree);
 648 struct cgraph_node * cgraph_add_thunk (struct cgraph_node *, tree, tree, bool, HOST_WIDE_INT,
 649                                        HOST_WIDE_INT, tree, tree);
 650 struct cgraph_node *cgraph_node_for_asm (tree);
 651 struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple);
 652 void cgraph_set_call_stmt (struct cgraph_edge *, gimple, bool update_speculative = true);
 653 void cgraph_update_edges_for_call_stmt (gimple, tree, gimple);
 654 struct cgraph_local_info *cgraph_local_info (tree);
 655 struct cgraph_global_info *cgraph_global_info (tree);
 656 struct cgraph_rtl_info *cgraph_rtl_info (tree);
 657 struct cgraph_node *cgraph_create_function_alias (tree, tree);
 658 void cgraph_call_node_duplication_hooks (struct cgraph_node *,
 659                                          struct cgraph_node *);
 660 void cgraph_call_edge_duplication_hooks (struct cgraph_edge *,
 661                                          struct cgraph_edge *);
 662
 663 void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *);
 664 struct cgraph_edge *cgraph_make_edge_direct (struct cgraph_edge *, struct cgraph_node *);
 665 bool cgraph_only_called_directly_p (struct cgraph_node *);
 666
 667 bool cgraph_function_possibly_inlined_p (tree);
 668 void cgraph_unnest_node (struct cgraph_node *);
 669
 670 enum availability cgraph_function_body_availability (struct cgraph_node *);
 671 void cgraph_add_new_function (tree, bool);
 672 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
 673
 674 void cgraph_set_nothrow_flag (struct cgraph_node *, bool);
 675 void cgraph_set_const_flag (struct cgraph_node *, bool, bool);
 676 void cgraph_set_pure_flag (struct cgraph_node *, bool, bool);
 677 bool cgraph_node_cannot_return (struct cgraph_node *);
 678 bool cgraph_edge_cannot_lead_to_return (struct cgraph_edge *);
 679 bool cgraph_will_be_removed_from_program_if_no_direct_calls
 680   (struct cgraph_node *node);
 681 bool cgraph_can_remove_if_no_direct_calls_and_refs_p
 682   (struct cgraph_node *node);
 683 bool cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node);
 684 bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution);
 685 bool cgraph_for_node_thunks_and_aliases (struct cgraph_node *,
 686                                          bool (*) (struct cgraph_node *, void *),
 687                                          void *,
 688                                          bool);
 689 bool cgraph_for_node_and_aliases (struct cgraph_node *,
 690                                   bool (*) (struct cgraph_node *, void *),
 691                                   void *, bool);
 692 vec<cgraph_edge_p>  collect_callers_of_node (struct cgraph_node *node);
 693 void verify_cgraph (void);
 694 void verify_cgraph_node (struct cgraph_node *);
 695 void cgraph_mark_address_taken_node (struct cgraph_node *);
 696
 697 typedef void (*cgraph_edge_hook)(struct cgraph_edge *, void *);
 698 typedef void (*cgraph_node_hook)(struct cgraph_node *, void *);
 699 typedef void (*cgraph_2edge_hook)(struct cgraph_edge *, struct cgraph_edge *,
 700                                   void *);
 701 typedef void (*cgraph_2node_hook)(struct cgraph_node *, struct cgraph_node *,
 702                                   void *);
 703 struct cgraph_edge_hook_list;
 704 struct cgraph_node_hook_list;
 705 struct cgraph_2edge_hook_list;
 706 struct cgraph_2node_hook_list;
 707 struct cgraph_edge_hook_list *cgraph_add_edge_removal_hook (cgraph_edge_hook, void *);
 708 void cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *);
 709 struct cgraph_node_hook_list *cgraph_add_node_removal_hook (cgraph_node_hook,
 710                                                             void *);
 711 void cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *);
 712 struct cgraph_node_hook_list *cgraph_add_function_insertion_hook (cgraph_node_hook,
 713                                                                   void *);
 714 void cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *);
 715 void cgraph_call_function_insertion_hooks (struct cgraph_node *node);
 716 struct cgraph_2edge_hook_list *cgraph_add_edge_duplication_hook (cgraph_2edge_hook, void *);
 717 void cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *);
 718 struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook (cgraph_2node_hook, void *);
 719 void cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *);
 720 gimple cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *);
 721 bool cgraph_propagate_frequency (struct cgraph_node *node);
 722 struct cgraph_node * cgraph_function_node (struct cgraph_node *,
 723                                            enum availability *avail = NULL);
 724 bool cgraph_get_body (struct cgraph_node *node);
 725 void
 726 cgraph_turn_edge_to_speculative (struct cgraph_edge *,
 727                                  struct cgraph_node *,
 728                                  gcov_type, int);
 729 void cgraph_speculative_call_info (struct cgraph_edge *,
 730                                    struct cgraph_edge *&,
 731                                    struct cgraph_edge *&,
 732                                    struct ipa_ref *&);
 733
 734 /* In cgraphunit.c  */
 735 struct asm_node *add_asm_node (tree);
 736 extern FILE *cgraph_dump_file;
 737 void cgraph_finalize_function (tree, bool);
 738 void finalize_compilation_unit (void);
 739 void compile (void);
 740 void init_cgraph (void);
 741 bool cgraph_process_new_functions (void);
 742 void cgraph_process_same_body_aliases (void);
 743 void fixup_same_cpp_alias_visibility (symtab_node, symtab_node target, tree);
 744 /*  Initialize datastructures so DECL is a function in lowered gimple form.
 745     IN_SSA is true if the gimple is in SSA.  */
 746 basic_block init_lowered_empty_function (tree, bool);
 747 void cgraph_reset_node (struct cgraph_node *);
 748 void expand_thunk (struct cgraph_node *);
 749
 750 /* In cgraphclones.c  */
 751
 752 struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *,
 753                                         struct cgraph_node *, gimple,
 754                                         unsigned, gcov_type, int, bool);
 755 struct cgraph_node * cgraph_clone_node (struct cgraph_node *, tree, gcov_type,
 756                                         int, bool, vec<cgraph_edge_p>,
 757                                         bool, struct cgraph_node *);
 758 tree clone_function_name (tree decl, const char *);
 759 struct cgraph_node * cgraph_create_virtual_clone (struct cgraph_node *old_node,
 760                                                   vec<cgraph_edge_p>,
 761                                                   vec<ipa_replace_map_p, va_gc> *tree_map,
 762                                                   bitmap args_to_skip,
 763                                                   const char *clone_name);
 764 struct cgraph_node *cgraph_find_replacement_node (struct cgraph_node *);
 765 bool cgraph_remove_node_and_inline_clones (struct cgraph_node *, struct cgraph_node *);
 766 void cgraph_set_call_stmt_including_clones (struct cgraph_node *, gimple, gimple,
 767                                             bool update_speculative = true);
 768 void cgraph_create_edge_including_clones (struct cgraph_node *,
 769                                           struct cgraph_node *,
 770                                           gimple, gimple, gcov_type, int,
 771                                           cgraph_inline_failed_t);
 772 void cgraph_materialize_all_clones (void);
 773 struct cgraph_node * cgraph_copy_node_for_versioning (struct cgraph_node *,
 774                 tree, vec<cgraph_edge_p>, bitmap);
 775 struct cgraph_node *cgraph_function_versioning (struct cgraph_node *,
 776                                                 vec<cgraph_edge_p>,
 777                                                 vec<ipa_replace_map_p, va_gc> *,
 778                                                 bitmap, bool, bitmap,
 779                                                 basic_block, const char *);
 780 void tree_function_versioning (tree, tree, vec<ipa_replace_map_p, va_gc> *,
 781                                bool, bitmap, bool, bitmap, basic_block);
 782
 783 /* In cgraphbuild.c  */
 784 unsigned int rebuild_cgraph_edges (void);
 785 void cgraph_rebuild_references (void);
 786 int compute_call_stmt_bb_frequency (tree, basic_block bb);
 787 void record_references_in_initializer (tree, bool);
 788 void ipa_record_stmt_references (struct cgraph_node *, gimple);
 789
 790 /* In ipa.c  */
 791 bool symtab_remove_unreachable_nodes (bool, FILE *);
 792 cgraph_node_set cgraph_node_set_new (void);
 793 cgraph_node_set_iterator cgraph_node_set_find (cgraph_node_set,
 794                                                struct cgraph_node *);
 795 void cgraph_node_set_add (cgraph_node_set, struct cgraph_node *);
 796 void cgraph_node_set_remove (cgraph_node_set, struct cgraph_node *);
 797 void dump_cgraph_node_set (FILE *, cgraph_node_set);
 798 void debug_cgraph_node_set (cgraph_node_set);
 799 void free_cgraph_node_set (cgraph_node_set);
 800 void cgraph_build_static_cdtor (char which, tree body, int priority);
 801
 802 varpool_node_set varpool_node_set_new (void);
 803 varpool_node_set_iterator varpool_node_set_find (varpool_node_set,
 804                                                struct varpool_node *);
 805 void varpool_node_set_add (varpool_node_set, struct varpool_node *);
 806 void varpool_node_set_remove (varpool_node_set, struct varpool_node *);
 807 void dump_varpool_node_set (FILE *, varpool_node_set);
 808 void debug_varpool_node_set (varpool_node_set);
 809 void free_varpool_node_set (varpool_node_set);
 810 void ipa_discover_readonly_nonaddressable_vars (void);
 811 bool varpool_externally_visible_p (struct varpool_node *);
 812
 813 /* In predict.c  */
 814 bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
 815 bool cgraph_optimize_for_size_p (struct cgraph_node *);
 816
 817 /* In varpool.c  */
 818 struct varpool_node *varpool_create_empty_node (void);
 819 struct varpool_node *varpool_node_for_decl (tree);
 820 struct varpool_node *varpool_node_for_asm (tree asmname);
 821 void varpool_mark_needed_node (struct varpool_node *);
 822 void debug_varpool (void);
 823 void dump_varpool (FILE *);
 824 void dump_varpool_node (FILE *, struct varpool_node *);
 825
 826 void varpool_finalize_decl (tree);
 827 enum availability cgraph_variable_initializer_availability (struct varpool_node *);
 828 void cgraph_make_node_local (struct cgraph_node *);
 829 bool cgraph_node_can_be_local_p (struct cgraph_node *);
 830
 831
 832 void varpool_remove_node (struct varpool_node *node);
 833 void varpool_finalize_named_section_flags (struct varpool_node *node);
 834 bool varpool_output_variables (void);
 835 bool varpool_assemble_decl (struct varpool_node *node);
 836 void varpool_analyze_node (struct varpool_node *);
 837 struct varpool_node * varpool_extra_name_alias (tree, tree);
 838 struct varpool_node * varpool_create_variable_alias (tree, tree);
 839 void varpool_reset_queue (void);
 840 tree ctor_for_folding (tree);
 841 bool varpool_for_node_and_aliases (struct varpool_node *,
 842                                    bool (*) (struct varpool_node *, void *),
 843                                    void *, bool);
 844 void varpool_add_new_variable (tree);
 845 void symtab_initialize_asm_name_hash (void);
 846 void symtab_prevail_in_asm_name_hash (symtab_node node);
 847 void varpool_remove_initializer (struct varpool_node *);
 848
 849
 850 /* Return callgraph node for given symbol and check it is a function. */
 851 static inline struct cgraph_node *
 852 cgraph (symtab_node node)
 853 {
 854   gcc_checking_assert (!node || node->symbol.type == SYMTAB_FUNCTION);
 855   return (struct cgraph_node *)node;
 856 }
 857
 858 /* Return varpool node for given symbol and check it is a variable.  */
 859 static inline struct varpool_node *
 860 varpool (symtab_node node)
 861 {
 862   gcc_checking_assert (!node || node->symbol.type == SYMTAB_VARIABLE);
 863   return (struct varpool_node *)node;
 864 }
 865
 866 /* Return callgraph node for given symbol and check it is a function. */
 867 static inline struct cgraph_node *
 868 cgraph_get_node (const_tree decl)
 869 {
 870   gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
 871   return cgraph (symtab_get_node (decl));
 872 }
 873
 874 /* Return varpool node for given symbol and check it is a function. */
 875 static inline struct varpool_node *
 876 varpool_get_node (const_tree decl)
 877 {
 878   gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
 879   return varpool (symtab_get_node (decl));
 880 }
 881
 882 /* Return asm name of cgraph node.  */
 883 static inline const char *
 884 cgraph_node_asm_name (struct cgraph_node *node)
 885 {
 886   return symtab_node_asm_name ((symtab_node)node);
 887 }
 888
 889 /* Return asm name of varpool node.  */
 890 static inline const char *
 891 varpool_node_asm_name(struct varpool_node *node)
 892 {
 893   return symtab_node_asm_name ((symtab_node)node);
 894 }
 895
 896 /* Return name of cgraph node.  */
 897 static inline const char *
 898 cgraph_node_name(struct cgraph_node *node)
 899 {
 900   return symtab_node_name ((symtab_node)node);
 901 }
 902
 903 /* Return name of varpool node.  */
 904 static inline const char *
 905 varpool_node_name(struct varpool_node *node)
 906 {
 907   return symtab_node_name ((symtab_node)node);
 908 }
 909
 910 /* Walk all symbols.  */
 911 #define FOR_EACH_SYMBOL(node) \
 912    for ((node) = symtab_nodes; (node); (node) = (node)->symbol.next)
 913
 914
 915 /* Return first variable.  */
 916 static inline struct varpool_node *
 917 varpool_first_variable (void)
 918 {
 919   symtab_node node;
 920   for (node = symtab_nodes; node; node = node->symbol.next)
 921     if (varpool_node *vnode = dyn_cast <varpool_node> (node))
 922       return vnode;
 923   return NULL;
 924 }
 925
 926 /* Return next variable after NODE.  */
 927 static inline struct varpool_node *
 928 varpool_next_variable (struct varpool_node *node)
 929 {
 930   symtab_node node1 = (symtab_node) node->symbol.next;
 931   for (; node1; node1 = node1->symbol.next)
 932     if (varpool_node *vnode1 = dyn_cast <varpool_node> (node1))
 933       return vnode1;
 934   return NULL;
 935 }
 936 /* Walk all variables.  */
 937 #define FOR_EACH_VARIABLE(node) \
 938    for ((node) = varpool_first_variable (); \
 939         (node); \
 940         (node) = varpool_next_variable ((node)))
 941
 942 /* Return first reachable static variable with initializer.  */
 943 static inline struct varpool_node *
 944 varpool_first_static_initializer (void)
 945 {
 946   symtab_node node;
 947   for (node = symtab_nodes; node; node = node->symbol.next)
 948     {
 949       varpool_node *vnode = dyn_cast <varpool_node> (node);
 950       if (vnode && DECL_INITIAL (node->symbol.decl))
 951         return vnode;
 952     }
 953   return NULL;
 954 }
 955
 956 /* Return next reachable static variable with initializer after NODE.  */
 957 static inline struct varpool_node *
 958 varpool_next_static_initializer (struct varpool_node *node)
 959 {
 960   symtab_node node1 = (symtab_node) node->symbol.next;
 961   for (; node1; node1 = node1->symbol.next)
 962     {
 963       varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
 964       if (vnode1 && DECL_INITIAL (node1->symbol.decl))
 965         return vnode1;
 966     }
 967   return NULL;
 968 }
 969
 970 /* Walk all static variables with initializer set.  */
 971 #define FOR_EACH_STATIC_INITIALIZER(node) \
 972    for ((node) = varpool_first_static_initializer (); (node); \
 973         (node) = varpool_next_static_initializer (node))
 974
 975 /* Return first reachable static variable with initializer.  */
 976 static inline struct varpool_node *
 977 varpool_first_defined_variable (void)
 978 {
 979   symtab_node node;
 980   for (node = symtab_nodes; node; node = node->symbol.next)
 981     {
 982       varpool_node *vnode = dyn_cast <varpool_node> (node);
 983       if (vnode && vnode->symbol.definition)
 984         return vnode;
 985     }
 986   return NULL;
 987 }
 988
 989 /* Return next reachable static variable with initializer after NODE.  */
 990 static inline struct varpool_node *
 991 varpool_next_defined_variable (struct varpool_node *node)
 992 {
 993   symtab_node node1 = (symtab_node) node->symbol.next;
 994   for (; node1; node1 = node1->symbol.next)
 995     {
 996       varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
 997       if (vnode1 && vnode1->symbol.definition)
 998         return vnode1;
 999     }
1000   return NULL;
1001 }
1002 /* Walk all variables with definitions in current unit.  */
1003 #define FOR_EACH_DEFINED_VARIABLE(node) \
1004    for ((node) = varpool_first_defined_variable (); (node); \
1005         (node) = varpool_next_defined_variable (node))
1006
1007 /* Return first function with body defined.  */
1008 static inline struct cgraph_node *
1009 cgraph_first_defined_function (void)
1010 {
1011   symtab_node node;
1012   for (node = symtab_nodes; node; node = node->symbol.next)
1013     {
1014       cgraph_node *cn = dyn_cast <cgraph_node> (node);
1015       if (cn && cn->symbol.definition)
1016         return cn;
1017     }
1018   return NULL;
1019 }
1020
1021 /* Return next function with body defined after NODE.  */
1022 static inline struct cgraph_node *
1023 cgraph_next_defined_function (struct cgraph_node *node)
1024 {
1025   symtab_node node1 = (symtab_node) node->symbol.next;
1026   for (; node1; node1 = node1->symbol.next)
1027     {
1028       cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
1029       if (cn1 && cn1->symbol.definition)
1030         return cn1;
1031     }
1032   return NULL;
1033 }
1034
1035 /* Walk all functions with body defined.  */
1036 #define FOR_EACH_DEFINED_FUNCTION(node) \
1037    for ((node) = cgraph_first_defined_function (); (node); \
1038         (node) = cgraph_next_defined_function ((node)))
1039
1040 /* Return first function.  */
1041 static inline struct cgraph_node *
1042 cgraph_first_function (void)
1043 {
1044   symtab_node node;
1045   for (node = symtab_nodes; node; node = node->symbol.next)
1046     if (cgraph_node *cn = dyn_cast <cgraph_node> (node))
1047       return cn;
1048   return NULL;
1049 }
1050
1051 /* Return next function.  */
1052 static inline struct cgraph_node *
1053 cgraph_next_function (struct cgraph_node *node)
1054 {
1055   symtab_node node1 = (symtab_node) node->symbol.next;
1056   for (; node1; node1 = node1->symbol.next)
1057     if (cgraph_node *cn1 = dyn_cast <cgraph_node> (node1))
1058       return cn1;
1059   return NULL;
1060 }
1061 /* Walk all functions.  */
1062 #define FOR_EACH_FUNCTION(node) \
1063    for ((node) = cgraph_first_function (); (node); \
1064         (node) = cgraph_next_function ((node)))
1065
1066 /* Return true when NODE is a function with Gimple body defined
1067    in current unit.  Functions can also be define externally or they
1068    can be thunks with no Gimple representation.
1069
1070    Note that at WPA stage, the function body may not be present in memory.  */
1071
1072 static inline bool
1073 cgraph_function_with_gimple_body_p (struct cgraph_node *node)
1074 {
1075   return node->symbol.definition && !node->thunk.thunk_p && !node->symbol.alias;
1076 }
1077
1078 /* Return first function with body defined.  */
1079 static inline struct cgraph_node *
1080 cgraph_first_function_with_gimple_body (void)
1081 {
1082   symtab_node node;
1083   for (node = symtab_nodes; node; node = node->symbol.next)
1084     {
1085       cgraph_node *cn = dyn_cast <cgraph_node> (node);
1086       if (cn && cgraph_function_with_gimple_body_p (cn))
1087         return cn;
1088     }
1089   return NULL;
1090 }
1091
1092 /* Return next reachable static variable with initializer after NODE.  */
1093 static inline struct cgraph_node *
1094 cgraph_next_function_with_gimple_body (struct cgraph_node *node)
1095 {
1096   symtab_node node1 = node->symbol.next;
1097   for (; node1; node1 = node1->symbol.next)
1098     {
1099       cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
1100       if (cn1 && cgraph_function_with_gimple_body_p (cn1))
1101         return cn1;
1102     }
1103   return NULL;
1104 }
1105
1106 /* Walk all functions with body defined.  */
1107 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
1108    for ((node) = cgraph_first_function_with_gimple_body (); (node); \
1109         (node) = cgraph_next_function_with_gimple_body (node))
1110
1111 /* Create a new static variable of type TYPE.  */
1112 tree add_new_static_var (tree type);
1113
1114 /* Return true if iterator CSI points to nothing.  */
1115 static inline bool
1116 csi_end_p (cgraph_node_set_iterator csi)
1117 {
1118   return csi.index >= csi.set->nodes.length ();
1119 }
1120
1121 /* Advance iterator CSI.  */
1122 static inline void
1123 csi_next (cgraph_node_set_iterator *csi)
1124 {
1125   csi->index++;
1126 }
1127
1128 /* Return the node pointed to by CSI.  */
1129 static inline struct cgraph_node *
1130 csi_node (cgraph_node_set_iterator csi)
1131 {
1132   return csi.set->nodes[csi.index];
1133 }
1134
1135 /* Return an iterator to the first node in SET.  */
1136 static inline cgraph_node_set_iterator
1137 csi_start (cgraph_node_set set)
1138 {
1139   cgraph_node_set_iterator csi;
1140
1141   csi.set = set;
1142   csi.index = 0;
1143   return csi;
1144 }
1145
1146 /* Return true if SET contains NODE.  */
1147 static inline bool
1148 cgraph_node_in_set_p (struct cgraph_node *node, cgraph_node_set set)
1149 {
1150   cgraph_node_set_iterator csi;
1151   csi = cgraph_node_set_find (set, node);
1152   return !csi_end_p (csi);
1153 }
1154
1155 /* Return number of nodes in SET.  */
1156 static inline size_t
1157 cgraph_node_set_size (cgraph_node_set set)
1158 {
1159   return set->nodes.length ();
1160 }
1161
1162 /* Return true if iterator VSI points to nothing.  */
1163 static inline bool
1164 vsi_end_p (varpool_node_set_iterator vsi)
1165 {
1166   return vsi.index >= vsi.set->nodes.length ();
1167 }
1168
1169 /* Advance iterator VSI.  */
1170 static inline void
1171 vsi_next (varpool_node_set_iterator *vsi)
1172 {
1173   vsi->index++;
1174 }
1175
1176 /* Return the node pointed to by VSI.  */
1177 static inline struct varpool_node *
1178 vsi_node (varpool_node_set_iterator vsi)
1179 {
1180   return vsi.set->nodes[vsi.index];
1181 }
1182
1183 /* Return an iterator to the first node in SET.  */
1184 static inline varpool_node_set_iterator
1185 vsi_start (varpool_node_set set)
1186 {
1187   varpool_node_set_iterator vsi;
1188
1189   vsi.set = set;
1190   vsi.index = 0;
1191   return vsi;
1192 }
1193
1194 /* Return true if SET contains NODE.  */
1195 static inline bool
1196 varpool_node_in_set_p (struct varpool_node *node, varpool_node_set set)
1197 {
1198   varpool_node_set_iterator vsi;
1199   vsi = varpool_node_set_find (set, node);
1200   return !vsi_end_p (vsi);
1201 }
1202
1203 /* Return number of nodes in SET.  */
1204 static inline size_t
1205 varpool_node_set_size (varpool_node_set set)
1206 {
1207   return set->nodes.length ();
1208 }
1209
1210 /* Uniquize all constants that appear in memory.
1211    Each constant in memory thus far output is recorded
1212    in `const_desc_table'.  */
1213
1214 struct GTY(()) constant_descriptor_tree {
1215   /* A MEM for the constant.  */
1216   rtx rtl;
1217
1218   /* The value of the constant.  */
1219   tree value;
1220
1221   /* Hash of value.  Computing the hash from value each time
1222      hashfn is called can't work properly, as that means recursive
1223      use of the hash table during hash table expansion.  */
1224   hashval_t hash;
1225 };
1226
1227 /* Return true if set is nonempty.  */
1228 static inline bool
1229 cgraph_node_set_nonempty_p (cgraph_node_set set)
1230 {
1231   return !set->nodes.is_empty ();
1232 }
1233
1234 /* Return true if set is nonempty.  */
1235 static inline bool
1236 varpool_node_set_nonempty_p (varpool_node_set set)
1237 {
1238   return !set->nodes.is_empty ();
1239 }
1240
1241 /* Return true when function NODE is only called directly or it has alias.
1242    i.e. it is not externally visible, address was not taken and
1243    it is not used in any other non-standard way.  */
1244
1245 static inline bool
1246 cgraph_only_called_directly_or_aliased_p (struct cgraph_node *node)
1247 {
1248   gcc_assert (!node->global.inlined_to);
1249   return (!node->symbol.force_output && !node->symbol.address_taken
1250           && !node->symbol.used_from_other_partition
1251           && !DECL_VIRTUAL_P (node->symbol.decl)
1252           && !DECL_STATIC_CONSTRUCTOR (node->symbol.decl)
1253           && !DECL_STATIC_DESTRUCTOR (node->symbol.decl)
1254           && !node->symbol.externally_visible);
1255 }
1256
1257 /* Return true when function NODE can be removed from callgraph
1258    if all direct calls are eliminated.  */
1259
1260 static inline bool
1261 varpool_can_remove_if_no_refs (struct varpool_node *node)
1262 {
1263   if (DECL_EXTERNAL (node->symbol.decl))
1264     return true;
1265   return (!node->symbol.force_output && !node->symbol.used_from_other_partition
1266           && ((DECL_COMDAT (node->symbol.decl)
1267                && !node->symbol.forced_by_abi
1268                && !symtab_used_from_object_file_p ((symtab_node) node))
1269               || !node->symbol.externally_visible
1270               || DECL_HAS_VALUE_EXPR_P (node->symbol.decl)));
1271 }
1272
1273 /* Return true when all references to VNODE must be visible in ipa_ref_list.
1274    i.e. if the variable is not externally visible or not used in some magic
1275    way (asm statement or such).
1276    The magic uses are all summarized in force_output flag.  */
1277
1278 static inline bool
1279 varpool_all_refs_explicit_p (struct varpool_node *vnode)
1280 {
1281   return (vnode->symbol.definition
1282           && !vnode->symbol.externally_visible
1283           && !vnode->symbol.used_from_other_partition
1284           && !vnode->symbol.force_output);
1285 }
1286
1287 /* Constant pool accessor function.  */
1288 htab_t constant_pool_htab (void);
1289
1290 /* FIXME: inappropriate dependency of cgraph on IPA.  */
1291 #include "ipa-ref-inline.h"
1292
1293 /* Return node that alias N is aliasing.  */
1294
1295 static inline symtab_node
1296 symtab_alias_target (symtab_node n)
1297 {
1298   struct ipa_ref *ref;
1299   ipa_ref_list_reference_iterate (&n->symbol.ref_list, 0, ref);
1300   gcc_checking_assert (ref->use == IPA_REF_ALIAS);
1301   return ref->referred;
1302 }
1303
1304 static inline struct cgraph_node *
1305 cgraph_alias_target (struct cgraph_node *n)
1306 {
1307   return dyn_cast <cgraph_node> (symtab_alias_target ((symtab_node) n));
1308 }
1309
1310 static inline struct varpool_node *
1311 varpool_alias_target (struct varpool_node *n)
1312 {
1313   return dyn_cast <varpool_node> (symtab_alias_target ((symtab_node) n));
1314 }
1315
1316 /* Given NODE, walk the alias chain to return the function NODE is alias of.
1317    Do not walk through thunks.
1318    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
1319
1320 static inline struct cgraph_node *
1321 cgraph_function_or_thunk_node (struct cgraph_node *node,
1322                                enum availability *availability = NULL)
1323 {
1324   struct cgraph_node *n;
1325
1326   n = dyn_cast <cgraph_node> (symtab_alias_ultimate_target ((symtab_node)node,
1327                                                             availability));
1328   if (!n && availability)
1329     *availability = AVAIL_NOT_AVAILABLE;
1330   return n;
1331 }
1332 /* Given NODE, walk the alias chain to return the function NODE is alias of.
1333    Do not walk through thunks.
1334    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
1335
1336 static inline struct varpool_node *
1337 varpool_variable_node (struct varpool_node *node,
1338                        enum availability *availability = NULL)
1339 {
1340   struct varpool_node *n;
1341
1342   n = dyn_cast <varpool_node> (symtab_alias_ultimate_target ((symtab_node)node,
1343                                                              availability));
1344   if (!n && availability)
1345     *availability = AVAIL_NOT_AVAILABLE;
1346   return n;
1347 }
1348
1349 /* Return true when the edge E represents a direct recursion.  */
1350 static inline bool
1351 cgraph_edge_recursive_p (struct cgraph_edge *e)
1352 {
1353   struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
1354   if (e->caller->global.inlined_to)
1355     return e->caller->global.inlined_to->symbol.decl == callee->symbol.decl;
1356   else
1357     return e->caller->symbol.decl == callee->symbol.decl;
1358 }
1359
1360 /* Return true if the TM_CLONE bit is set for a given FNDECL.  */
1361 static inline bool
1362 decl_is_tm_clone (const_tree fndecl)
1363 {
1364   struct cgraph_node *n = cgraph_get_node (fndecl);
1365   if (n)
1366     return n->tm_clone;
1367   return false;
1368 }
1369
1370 /* Likewise indicate that a node is needed, i.e. reachable via some
1371    external means.  */
1372
1373 static inline void
1374 cgraph_mark_force_output_node (struct cgraph_node *node)
1375 {
1376   node->symbol.force_output = 1;
1377   gcc_checking_assert (!node->global.inlined_to);
1378 }
1379
1380 /* Return true when the symbol is real symbol, i.e. it is not inline clone
1381    or abstract function kept for debug info purposes only.  */
1382
1383 static inline bool
1384 symtab_real_symbol_p (symtab_node node)
1385 {
1386   struct cgraph_node *cnode;
1387
1388   if (DECL_ABSTRACT (node->symbol.decl))
1389     return false;
1390   if (!is_a <cgraph_node> (node))
1391     return true;
1392   cnode = cgraph (node);
1393   if (cnode->global.inlined_to)
1394     return false;
1395   return true;
1396 }
1397 #endif  /* GCC_CGRAPH_H  */