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