gcc/cgraph.h

   1 /* Callgraph handling code.
   2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
   3    Free Software Foundation, Inc.
   4    Contributed by Jan Hubicka
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #ifndef GCC_CGRAPH_H
  23 #define GCC_CGRAPH_H
  24 #include "tree.h"
  25 #include "basic-block.h"
  26
  27 enum availability
  28 {
  29   /* Not yet set by cgraph_function_body_availability.  */
  30   AVAIL_UNSET,
  31   /* Function body/variable initializer is unknown.  */
  32   AVAIL_NOT_AVAILABLE,
  33   /* Function body/variable initializer is known but might be replaced
  34      by a different one from other compilation unit and thus needs to
  35      be dealt with a care.  Like AVAIL_NOT_AVAILABLE it can have
  36      arbitrary side effects on escaping variables and functions, while
  37      like AVAILABLE it might access static variables.  */
  38   AVAIL_OVERWRITABLE,
  39   /* Function body/variable initializer is known and will be used in final
  40      program.  */
  41   AVAIL_AVAILABLE,
  42   /* Function body/variable initializer is known and all it's uses are explicitly
  43      visible within current unit (ie it's address is never taken and it is not
  44      exported to other units).
  45      Currently used only for functions.  */
  46   AVAIL_LOCAL
  47 };
  48
  49 extern const char * const cgraph_availability_names[];
  50
  51 /* Function inlining information.  */
  52
  53 struct GTY(()) inline_summary
  54 {
  55   /* Estimated stack frame consumption by the function.  */
  56   HOST_WIDE_INT estimated_self_stack_size;
  57
  58   /* Size of the function body.  */
  59   int self_size;
  60   /* How many instructions are likely going to disappear after inlining.  */
  61   int size_inlining_benefit;
  62   /* Estimated time spent executing the function body.  */
  63   int self_time;
  64   /* How much time is going to be saved by inlining.  */
  65   int time_inlining_benefit;
  66 };
  67
  68 /* Information about the function collected locally.
  69    Available after function is analyzed.  */
  70
  71 struct GTY(()) cgraph_local_info {
  72   struct inline_summary inline_summary;
  73
  74   /* Set when function function is visible in current compilation unit only
  75      and its address is never taken.  */
  76   unsigned local : 1;
  77
  78   /* Set when function is visible by other units.  */
  79   unsigned externally_visible : 1;
  80
  81   /* Set once it has been finalized so we consider it to be output.  */
  82   unsigned finalized : 1;
  83
  84   /* False when there something makes inlining impossible (such as va_arg).  */
  85   unsigned inlinable : 1;
  86
  87   /* True when function should be inlined independently on its size.  */
  88   unsigned disregard_inline_limits : 1;
  89
  90   /* True when the function has been originally extern inline, but it is
  91      redefined now.  */
  92   unsigned redefined_extern_inline : 1;
  93
  94   /* True if statics_read_for_function and
  95      statics_written_for_function contain valid data.  */
  96   unsigned for_functions_valid : 1;
  97
  98   /* True if the function is going to be emitted in some other translation
  99      unit, referenced from vtable.  */
 100   unsigned vtable_method : 1;
 101 };
 102
 103 /* Information about the function that needs to be computed globally
 104    once compilation is finished.  Available only with -funit-at-a-time.  */
 105
 106 struct GTY(()) cgraph_global_info {
 107   /* Estimated stack frame consumption by the function.  */
 108   HOST_WIDE_INT estimated_stack_size;
 109   /* Expected offset of the stack frame of inlined function.  */
 110   HOST_WIDE_INT stack_frame_offset;
 111
 112   /* For inline clones this points to the function they will be
 113      inlined into.  */
 114   struct cgraph_node *inlined_to;
 115
 116   /* Estimated size of the function after inlining.  */
 117   int time;
 118   int size;
 119
 120   /* Estimated growth after inlining.  INT_MIN if not computed.  */
 121   int estimated_growth;
 122
 123   /* Set iff the function has been inlined at least once.  */
 124   bool inlined;
 125 };
 126
 127 /* Information about the function that is propagated by the RTL backend.
 128    Available only for functions that has been already assembled.  */
 129
 130 struct GTY(()) cgraph_rtl_info {
 131    unsigned int preferred_incoming_stack_boundary;
 132 };
 133
 134 /* Represent which DECL tree (or reference to such tree)
 135    will be replaced by another tree while versioning.  */
 136 struct GTY(()) ipa_replace_map
 137 {
 138   /* The tree that will be replaced.  */
 139   tree old_tree;
 140   /* The new (replacing) tree.  */
 141   tree new_tree;
 142   /* True when a substitution should be done, false otherwise.  */
 143   bool replace_p;
 144   /* True when we replace a reference to old_tree.  */
 145   bool ref_p;
 146 };
 147 typedef struct ipa_replace_map *ipa_replace_map_p;
 148 DEF_VEC_P(ipa_replace_map_p);
 149 DEF_VEC_ALLOC_P(ipa_replace_map_p,gc);
 150
 151 struct GTY(()) cgraph_clone_info
 152 {
 153   VEC(ipa_replace_map_p,gc)* tree_map;
 154   bitmap args_to_skip;
 155 };
 156
 157 /* The cgraph data structure.
 158    Each function decl has assigned cgraph_node listing callees and callers.  */
 159
 160 struct GTY((chain_next ("%h.next"), chain_prev ("%h.previous"))) cgraph_node {
 161   tree decl;
 162   struct cgraph_edge *callees;
 163   struct cgraph_edge *callers;
 164   struct cgraph_node *next;
 165   struct cgraph_node *previous;
 166   /* For nested functions points to function the node is nested in.  */
 167   struct cgraph_node *origin;
 168   /* Points to first nested function, if any.  */
 169   struct cgraph_node *nested;
 170   /* Pointer to the next function with same origin, if any.  */
 171   struct cgraph_node *next_nested;
 172   /* Pointer to the next function in cgraph_nodes_queue.  */
 173   struct cgraph_node *next_needed;
 174   /* Pointer to the next clone.  */
 175   struct cgraph_node *next_sibling_clone;
 176   struct cgraph_node *prev_sibling_clone;
 177   struct cgraph_node *clones;
 178   struct cgraph_node *clone_of;
 179   /* For functions with many calls sites it holds map from call expression
 180      to the edge to speed up cgraph_edge function.  */
 181   htab_t GTY((param_is (struct cgraph_edge))) call_site_hash;
 182
 183   PTR GTY ((skip)) aux;
 184
 185   struct cgraph_local_info local;
 186   struct cgraph_global_info global;
 187   struct cgraph_rtl_info rtl;
 188   struct cgraph_clone_info clone;
 189
 190   /* Expected number of executions: calculated in profile.c.  */
 191   gcov_type count;
 192   /* Unique id of the node.  */
 193   int uid;
 194   /* Ordering of all cgraph nodes.  */
 195   int order;
 196
 197   /* unique id for profiling. pid is not suitable because of different
 198      number of cfg nodes with -fprofile-generate and -fprofile-use */
 199   int pid;
 200
 201   /* Set when function must be output - it is externally visible
 202      or its address is taken.  */
 203   unsigned needed : 1;
 204   /* Set when function has address taken.  */
 205   unsigned address_taken : 1;
 206   /* Set when decl is an abstract function pointed to by the
 207      ABSTRACT_DECL_ORIGIN of a reachable function.  */
 208   unsigned abstract_and_needed : 1;
 209   /* Set when function is reachable by call from other function
 210      that is either reachable or needed.  */
 211   unsigned reachable : 1;
 212   /* Set once the function is lowered (i.e. its CFG is built).  */
 213   unsigned lowered : 1;
 214   /* Set once the function has been instantiated and its callee
 215      lists created.  */
 216   unsigned analyzed : 1;
 217   /* Set when function is scheduled to be processed by local passes.  */
 218   unsigned process : 1;
 219   /* Set for aliases once they got through assemble_alias.  */
 220   unsigned alias : 1;
 221   /* Set for nodes that was constructed and finalized by frontend.  */
 222   unsigned finalized_by_frontend : 1;
 223 };
 224
 225 typedef struct cgraph_node *cgraph_node_ptr;
 226
 227 DEF_VEC_P(cgraph_node_ptr);
 228 DEF_VEC_ALLOC_P(cgraph_node_ptr,heap);
 229 DEF_VEC_ALLOC_P(cgraph_node_ptr,gc);
 230
 231 /* A cgraph node set is a collection of cgraph nodes.  A cgraph node
 232    can appear in multiple sets.  */
 233 struct GTY(()) cgraph_node_set_def
 234 {
 235   htab_t GTY((param_is (struct cgraph_node_set_element_def))) hashtab;
 236   VEC(cgraph_node_ptr, gc) *nodes;
 237   PTR GTY ((skip)) aux;
 238 };
 239
 240 typedef struct cgraph_node_set_def *cgraph_node_set;
 241
 242 DEF_VEC_P(cgraph_node_set);
 243 DEF_VEC_ALLOC_P(cgraph_node_set,gc);
 244 DEF_VEC_ALLOC_P(cgraph_node_set,heap);
 245
 246 /* A cgraph node set element contains an index in the vector of nodes in
 247    the set.  */
 248 struct GTY(()) cgraph_node_set_element_def
 249 {
 250   struct cgraph_node *node;
 251   HOST_WIDE_INT index;
 252 };
 253
 254 typedef struct cgraph_node_set_element_def *cgraph_node_set_element;
 255 typedef const struct cgraph_node_set_element_def *const_cgraph_node_set_element;
 256
 257 /* Iterator structure for cgraph node sets.  */
 258 typedef struct
 259 {
 260   cgraph_node_set set;
 261   unsigned index;
 262 } cgraph_node_set_iterator;
 263
 264 #define DEFCIFCODE(code, string)        CIF_ ## code,
 265 /* Reasons for inlining failures.  */
 266 typedef enum {
 267 #include "cif-code.def"
 268   CIF_N_REASONS
 269 } cgraph_inline_failed_t;
 270
 271 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgraph_edge {
 272   struct cgraph_node *caller;
 273   struct cgraph_node *callee;
 274   struct cgraph_edge *prev_caller;
 275   struct cgraph_edge *next_caller;
 276   struct cgraph_edge *prev_callee;
 277   struct cgraph_edge *next_callee;
 278   gimple call_stmt;
 279   PTR GTY ((skip (""))) aux;
 280   /* When equal to CIF_OK, inline this call.  Otherwise, points to the
 281      explanation why function was not inlined.  */
 282   cgraph_inline_failed_t inline_failed;
 283   /* Expected number of executions: calculated in profile.c.  */
 284   gcov_type count;
 285   /* Expected frequency of executions within the function.
 286      When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
 287      per function call.  The range is 0 to CGRAPH_FREQ_MAX.  */
 288   int frequency;
 289   /* Depth of loop nest, 1 means no loop nest.  */
 290   unsigned int loop_nest : 30;
 291   /* Whether this edge describes a call that was originally indirect.  */
 292   unsigned int indirect_call : 1;
 293   /* Can this call throw externally?  */
 294   unsigned int can_throw_external : 1;
 295   /* Unique id of the edge.  */
 296   int uid;
 297 };
 298
 299 #define CGRAPH_FREQ_BASE 1000
 300 #define CGRAPH_FREQ_MAX 100000
 301
 302 typedef struct cgraph_edge *cgraph_edge_p;
 303
 304 DEF_VEC_P(cgraph_edge_p);
 305 DEF_VEC_ALLOC_P(cgraph_edge_p,heap);
 306
 307 /* The varpool data structure.
 308    Each static variable decl has assigned varpool_node.  */
 309
 310 struct GTY((chain_next ("%h.next"))) varpool_node {
 311   tree decl;
 312   /* Pointer to the next function in varpool_nodes.  */
 313   struct varpool_node *next;
 314   /* Pointer to the next function in varpool_nodes_queue.  */
 315   struct varpool_node *next_needed;
 316   /* Ordering of all cgraph nodes.  */
 317   int order;
 318
 319   /* Set when function must be output - it is externally visible
 320      or its address is taken.  */
 321   unsigned needed : 1;
 322   /* Needed variables might become dead by optimization.  This flag
 323      forces the variable to be output even if it appears dead otherwise.  */
 324   unsigned force_output : 1;
 325   /* Set once the variable has been instantiated and its callee
 326      lists created.  */
 327   unsigned analyzed : 1;
 328   /* Set once it has been finalized so we consider it to be output.  */
 329   unsigned finalized : 1;
 330   /* Set when variable is scheduled to be assembled.  */
 331   unsigned output : 1;
 332   /* Set when function is visible by other units.  */
 333   unsigned externally_visible : 1;
 334   /* Set for aliases once they got through assemble_alias.  */
 335   unsigned alias : 1;
 336 };
 337
 338 /* Every top level asm statement is put into a cgraph_asm_node.  */
 339
 340 struct GTY(()) cgraph_asm_node {
 341   /* Next asm node.  */
 342   struct cgraph_asm_node *next;
 343   /* String for this asm node.  */
 344   tree asm_str;
 345   /* Ordering of all cgraph nodes.  */
 346   int order;
 347 };
 348
 349 extern GTY(()) struct cgraph_node *cgraph_nodes;
 350 extern GTY(()) int cgraph_n_nodes;
 351 extern GTY(()) int cgraph_max_uid;
 352 extern GTY(()) int cgraph_edge_max_uid;
 353 extern GTY(()) int cgraph_max_pid;
 354 extern bool cgraph_global_info_ready;
 355 enum cgraph_state
 356 {
 357   /* Callgraph is being constructed.  It is safe to add new functions.  */
 358   CGRAPH_STATE_CONSTRUCTION,
 359   /* Callgraph is built and IPA passes are being run.  */
 360   CGRAPH_STATE_IPA,
 361   /* Callgraph is built and all functions are transformed to SSA form.  */
 362   CGRAPH_STATE_IPA_SSA,
 363   /* Functions are now ordered and being passed to RTL expanders.  */
 364   CGRAPH_STATE_EXPANSION,
 365   /* All cgraph expansion is done.  */
 366   CGRAPH_STATE_FINISHED
 367 };
 368 extern enum cgraph_state cgraph_state;
 369 extern bool cgraph_function_flags_ready;
 370 extern GTY(()) struct cgraph_node *cgraph_nodes_queue;
 371 extern GTY(()) struct cgraph_node *cgraph_new_nodes;
 372
 373 extern GTY(()) struct cgraph_asm_node *cgraph_asm_nodes;
 374 extern GTY(()) int cgraph_order;
 375
 376 /* In cgraph.c  */
 377 void dump_cgraph (FILE *);
 378 void debug_cgraph (void);
 379 void dump_cgraph_node (FILE *, struct cgraph_node *);
 380 void debug_cgraph_node (struct cgraph_node *);
 381 void cgraph_insert_node_to_hashtable (struct cgraph_node *node);
 382 void cgraph_remove_edge (struct cgraph_edge *);
 383 void cgraph_remove_node (struct cgraph_node *);
 384 void cgraph_remove_node_and_inline_clones (struct cgraph_node *);
 385 void cgraph_release_function_body (struct cgraph_node *);
 386 void cgraph_node_remove_callees (struct cgraph_node *node);
 387 struct cgraph_edge *cgraph_create_edge (struct cgraph_node *,
 388                                         struct cgraph_node *,
 389                                         gimple, gcov_type, int, int);
 390 struct cgraph_node *cgraph_node (tree);
 391 struct cgraph_node *cgraph_node_for_asm (tree asmname);
 392 struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple);
 393 void cgraph_set_call_stmt (struct cgraph_edge *, gimple);
 394 void cgraph_set_call_stmt_including_clones (struct cgraph_node *, gimple, gimple);
 395 void cgraph_create_edge_including_clones (struct cgraph_node *,
 396                                           struct cgraph_node *,
 397                                           gimple, gcov_type, int, int,
 398                                           cgraph_inline_failed_t);
 399 void cgraph_update_edges_for_call_stmt (gimple, tree, gimple);
 400 struct cgraph_local_info *cgraph_local_info (tree);
 401 struct cgraph_global_info *cgraph_global_info (tree);
 402 struct cgraph_rtl_info *cgraph_rtl_info (tree);
 403 const char * cgraph_node_name (struct cgraph_node *);
 404 struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *,
 405                                         struct cgraph_node *,
 406                                         gimple, gcov_type, int, int, bool);
 407 struct cgraph_node * cgraph_clone_node (struct cgraph_node *, gcov_type, int,
 408                                         int, bool);
 409
 410 void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *);
 411
 412 struct cgraph_asm_node *cgraph_add_asm_node (tree);
 413
 414 bool cgraph_function_possibly_inlined_p (tree);
 415 void cgraph_unnest_node (struct cgraph_node *);
 416
 417 enum availability cgraph_function_body_availability (struct cgraph_node *);
 418 void cgraph_add_new_function (tree, bool);
 419 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
 420 struct cgraph_node * cgraph_create_virtual_clone (struct cgraph_node *old_node,
 421                                                   VEC(cgraph_edge_p,heap)*,
 422                                                   VEC(ipa_replace_map_p,gc)* tree_map,
 423                                                   bitmap args_to_skip);
 424
 425 /* In cgraphunit.c  */
 426 void cgraph_finalize_function (tree, bool);
 427 void cgraph_mark_if_needed (tree);
 428 void cgraph_finalize_compilation_unit (void);
 429 void cgraph_optimize (void);
 430 void cgraph_mark_needed_node (struct cgraph_node *);
 431 void cgraph_mark_address_taken_node (struct cgraph_node *);
 432 void cgraph_mark_reachable_node (struct cgraph_node *);
 433 bool cgraph_inline_p (struct cgraph_edge *, cgraph_inline_failed_t *reason);
 434 bool cgraph_preserve_function_body_p (tree);
 435 void verify_cgraph (void);
 436 void verify_cgraph_node (struct cgraph_node *);
 437 void cgraph_build_static_cdtor (char which, tree body, int priority);
 438 void cgraph_reset_static_var_maps (void);
 439 void init_cgraph (void);
 440 struct cgraph_node *cgraph_function_versioning (struct cgraph_node *,
 441                                                 VEC(cgraph_edge_p,heap)*,
 442                                                 VEC(ipa_replace_map_p,gc)*,
 443                                                 bitmap);
 444 void tree_function_versioning (tree, tree, VEC (ipa_replace_map_p,gc)*, bool, bitmap);
 445 void cgraph_analyze_function (struct cgraph_node *);
 446 struct cgraph_node *save_inline_function_body (struct cgraph_node *);
 447 void record_references_in_initializer (tree);
 448 bool cgraph_process_new_functions (void);
 449
 450 typedef void (*cgraph_edge_hook)(struct cgraph_edge *, void *);
 451 typedef void (*cgraph_node_hook)(struct cgraph_node *, void *);
 452 typedef void (*cgraph_2edge_hook)(struct cgraph_edge *, struct cgraph_edge *,
 453                                   void *);
 454 typedef void (*cgraph_2node_hook)(struct cgraph_node *, struct cgraph_node *,
 455                                   void *);
 456 struct cgraph_edge_hook_list;
 457 struct cgraph_node_hook_list;
 458 struct cgraph_2edge_hook_list;
 459 struct cgraph_2node_hook_list;
 460 struct cgraph_edge_hook_list *cgraph_add_edge_removal_hook (cgraph_edge_hook, void *);
 461 void cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *);
 462 struct cgraph_node_hook_list *cgraph_add_node_removal_hook (cgraph_node_hook,
 463                                                             void *);
 464 void cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *);
 465 struct cgraph_node_hook_list *cgraph_add_function_insertion_hook (cgraph_node_hook,
 466                                                                   void *);
 467 void cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *);
 468 void cgraph_call_function_insertion_hooks (struct cgraph_node *node);
 469 struct cgraph_2edge_hook_list *cgraph_add_edge_duplication_hook (cgraph_2edge_hook, void *);
 470 void cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *);
 471 struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook (cgraph_2node_hook, void *);
 472 void cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *);
 473 void cgraph_materialize_all_clones (void);
 474
 475 /* In cgraphbuild.c  */
 476 unsigned int rebuild_cgraph_edges (void);
 477 int compute_call_stmt_bb_frequency (tree, basic_block bb);
 478
 479 /* In ipa.c  */
 480 bool cgraph_remove_unreachable_nodes (bool, FILE *);
 481 int cgraph_postorder (struct cgraph_node **);
 482 cgraph_node_set cgraph_node_set_new (void);
 483 cgraph_node_set_iterator cgraph_node_set_find (cgraph_node_set,
 484                                                struct cgraph_node *);
 485 void cgraph_node_set_add (cgraph_node_set, struct cgraph_node *);
 486 void cgraph_node_set_remove (cgraph_node_set, struct cgraph_node *);
 487 void dump_cgraph_node_set (FILE *, cgraph_node_set);
 488 void debug_cgraph_node_set (cgraph_node_set);
 489
 490
 491 /* In predict.c  */
 492 bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
 493
 494 /* In varpool.c  */
 495 extern GTY(()) struct varpool_node *varpool_nodes_queue;
 496 extern GTY(()) struct varpool_node *varpool_nodes;
 497
 498 struct varpool_node *varpool_node (tree);
 499 struct varpool_node *varpool_node_for_asm (tree asmname);
 500 void varpool_mark_needed_node (struct varpool_node *);
 501 void debug_varpool (void);
 502 void dump_varpool (FILE *);
 503 void dump_varpool_node (FILE *, struct varpool_node *);
 504
 505 void varpool_finalize_decl (tree);
 506 bool decide_is_variable_needed (struct varpool_node *, tree);
 507 enum availability cgraph_variable_initializer_availability (struct varpool_node *);
 508
 509 bool varpool_assemble_pending_decls (void);
 510 bool varpool_assemble_decl (struct varpool_node *node);
 511 bool varpool_analyze_pending_decls (void);
 512 void varpool_remove_unreferenced_decls (void);
 513 void varpool_empty_needed_queue (void);
 514
 515 /* Walk all reachable static variables.  */
 516 #define FOR_EACH_STATIC_VARIABLE(node) \
 517    for ((node) = varpool_nodes_queue; (node); (node) = (node)->next_needed)
 518
 519 /* Return first reachable static variable with initializer.  */
 520 static inline struct varpool_node *
 521 varpool_first_static_initializer (void)
 522 {
 523   struct varpool_node *node;
 524   for (node = varpool_nodes_queue; node; node = node->next_needed)
 525     {
 526       gcc_assert (TREE_CODE (node->decl) == VAR_DECL);
 527       if (DECL_INITIAL (node->decl))
 528         return node;
 529     }
 530   return NULL;
 531 }
 532
 533 /* Return next reachable static variable with initializer after NODE.  */
 534 static inline struct varpool_node *
 535 varpool_next_static_initializer (struct varpool_node *node)
 536 {
 537   for (node = node->next_needed; node; node = node->next_needed)
 538     {
 539       gcc_assert (TREE_CODE (node->decl) == VAR_DECL);
 540       if (DECL_INITIAL (node->decl))
 541         return node;
 542     }
 543   return NULL;
 544 }
 545
 546 /* Walk all static variables with initializer set.  */
 547 #define FOR_EACH_STATIC_INITIALIZER(node) \
 548    for ((node) = varpool_first_static_initializer (); (node); \
 549         (node) = varpool_next_static_initializer (node))
 550
 551 /* In ipa-inline.c  */
 552 void cgraph_clone_inlined_nodes (struct cgraph_edge *, bool, bool);
 553 unsigned int compute_inline_parameters (struct cgraph_node *);
 554
 555
 556 /* Create a new static variable of type TYPE.  */
 557 tree add_new_static_var (tree type);
 558
 559
 560 /* Return true if iterator CSI points to nothing.  */
 561 static inline bool
 562 csi_end_p (cgraph_node_set_iterator csi)
 563 {
 564   return csi.index >= VEC_length (cgraph_node_ptr, csi.set->nodes);
 565 }
 566
 567 /* Advance iterator CSI.  */
 568 static inline void
 569 csi_next (cgraph_node_set_iterator *csi)
 570 {
 571   csi->index++;
 572 }
 573
 574 /* Return the node pointed to by CSI.  */
 575 static inline struct cgraph_node *
 576 csi_node (cgraph_node_set_iterator csi)
 577 {
 578   return VEC_index (cgraph_node_ptr, csi.set->nodes, csi.index);
 579 }
 580
 581 /* Return an iterator to the first node in SET.  */
 582 static inline cgraph_node_set_iterator
 583 csi_start (cgraph_node_set set)
 584 {
 585   cgraph_node_set_iterator csi;
 586
 587   csi.set = set;
 588   csi.index = 0;
 589   return csi;
 590 }
 591
 592 /* Return true if SET contains NODE.  */
 593 static inline bool
 594 cgraph_node_in_set_p (struct cgraph_node *node, cgraph_node_set set)
 595 {
 596   cgraph_node_set_iterator csi;
 597   csi = cgraph_node_set_find (set, node);
 598   return !csi_end_p (csi);
 599 }
 600
 601 /* Return number of nodes in SET.  */
 602 static inline size_t
 603 cgraph_node_set_size (cgraph_node_set set)
 604 {
 605   return htab_elements (set->hashtab);
 606 }
 607
 608
 609 #endif  /* GCC_CGRAPH_H  */