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