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