Add support for ARMv8-R architecture
[official-gcc.git] / gcc / cgraph.h
blob57cdaa4568148c99d6cb171dcd6de79735492acc
1 /* Callgraph handling code.
2 Copyright (C) 2003-2017 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
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.
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.
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/>. */
21 #ifndef GCC_CGRAPH_H
22 #define GCC_CGRAPH_H
24 #include "profile-count.h"
25 #include "ipa-ref.h"
26 #include "plugin-api.h"
28 class ipa_opt_pass_d;
29 typedef ipa_opt_pass_d *ipa_opt_pass;
31 /* Symbol table consists of functions and variables.
32 TODO: add labels and CONST_DECLs. */
33 enum symtab_type
35 SYMTAB_SYMBOL,
36 SYMTAB_FUNCTION,
37 SYMTAB_VARIABLE
40 /* Section names are stored as reference counted strings in GGC safe hashtable
41 (to make them survive through PCH). */
43 struct GTY((for_user)) section_hash_entry
45 int ref_count;
46 char *name; /* As long as this datastructure stays in GGC, we can not put
47 string at the tail of structure of GGC dies in horrible
48 way */
51 struct section_name_hasher : ggc_ptr_hash<section_hash_entry>
53 typedef const char *compare_type;
55 static hashval_t hash (section_hash_entry *);
56 static bool equal (section_hash_entry *, const char *);
59 enum availability
61 /* Not yet set by cgraph_function_body_availability. */
62 AVAIL_UNSET,
63 /* Function body/variable initializer is unknown. */
64 AVAIL_NOT_AVAILABLE,
65 /* Function body/variable initializer is known but might be replaced
66 by a different one from other compilation unit and thus needs to
67 be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have
68 arbitrary side effects on escaping variables and functions, while
69 like AVAILABLE it might access static variables. */
70 AVAIL_INTERPOSABLE,
71 /* Function body/variable initializer is known and will be used in final
72 program. */
73 AVAIL_AVAILABLE,
74 /* Function body/variable initializer is known and all it's uses are
75 explicitly visible within current unit (ie it's address is never taken and
76 it is not exported to other units). Currently used only for functions. */
77 AVAIL_LOCAL
80 /* Classification of symbols WRT partitioning. */
81 enum symbol_partitioning_class
83 /* External declarations are ignored by partitioning algorithms and they are
84 added into the boundary later via compute_ltrans_boundary. */
85 SYMBOL_EXTERNAL,
86 /* Partitioned symbols are pur into one of partitions. */
87 SYMBOL_PARTITION,
88 /* Duplicated symbols (such as comdat or constant pool references) are
89 copied into every node needing them via add_symbol_to_partition. */
90 SYMBOL_DUPLICATE
93 /* Base of all entries in the symbol table.
94 The symtab_node is inherited by cgraph and varpol nodes. */
95 class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
96 chain_next ("%h.next"), chain_prev ("%h.previous")))
97 symtab_node
99 public:
100 /* Return name. */
101 const char *name () const;
103 /* Return dump name. */
104 const char *dump_name () const;
106 /* Return asm name. */
107 const char *asm_name () const;
109 /* Return dump name with assembler name. */
110 const char *dump_asm_name () const;
112 /* Add node into symbol table. This function is not used directly, but via
113 cgraph/varpool node creation routines. */
114 void register_symbol (void);
116 /* Remove symbol from symbol table. */
117 void remove (void);
119 /* Dump symtab node to F. */
120 void dump (FILE *f);
122 /* Dump symtab node to stderr. */
123 void DEBUG_FUNCTION debug (void);
125 /* Verify consistency of node. */
126 void DEBUG_FUNCTION verify (void);
128 /* Return ipa reference from this symtab_node to
129 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
130 of the use and STMT the statement (if it exists). */
131 ipa_ref *create_reference (symtab_node *referred_node,
132 enum ipa_ref_use use_type);
134 /* Return ipa reference from this symtab_node to
135 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
136 of the use and STMT the statement (if it exists). */
137 ipa_ref *create_reference (symtab_node *referred_node,
138 enum ipa_ref_use use_type, gimple *stmt);
140 /* If VAL is a reference to a function or a variable, add a reference from
141 this symtab_node to the corresponding symbol table node. Return the new
142 reference or NULL if none was created. */
143 ipa_ref *maybe_create_reference (tree val, gimple *stmt);
145 /* Clone all references from symtab NODE to this symtab_node. */
146 void clone_references (symtab_node *node);
148 /* Remove all stmt references in non-speculative references.
149 Those are not maintained during inlining & clonning.
150 The exception are speculative references that are updated along
151 with callgraph edges associated with them. */
152 void clone_referring (symtab_node *node);
154 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
155 ipa_ref *clone_reference (ipa_ref *ref, gimple *stmt);
157 /* Find the structure describing a reference to REFERRED_NODE
158 and associated with statement STMT. */
159 ipa_ref *find_reference (symtab_node *referred_node, gimple *stmt,
160 unsigned int lto_stmt_uid);
162 /* Remove all references that are associated with statement STMT. */
163 void remove_stmt_references (gimple *stmt);
165 /* Remove all stmt references in non-speculative references.
166 Those are not maintained during inlining & clonning.
167 The exception are speculative references that are updated along
168 with callgraph edges associated with them. */
169 void clear_stmts_in_references (void);
171 /* Remove all references in ref list. */
172 void remove_all_references (void);
174 /* Remove all referring items in ref list. */
175 void remove_all_referring (void);
177 /* Dump references in ref list to FILE. */
178 void dump_references (FILE *file);
180 /* Dump referring in list to FILE. */
181 void dump_referring (FILE *);
183 /* Get number of references for this node. */
184 inline unsigned num_references (void)
186 return ref_list.references ? ref_list.references->length () : 0;
189 /* Iterates I-th reference in the list, REF is also set. */
190 ipa_ref *iterate_reference (unsigned i, ipa_ref *&ref);
192 /* Iterates I-th referring item in the list, REF is also set. */
193 ipa_ref *iterate_referring (unsigned i, ipa_ref *&ref);
195 /* Iterates I-th referring alias item in the list, REF is also set. */
196 ipa_ref *iterate_direct_aliases (unsigned i, ipa_ref *&ref);
198 /* Return true if symtab node and TARGET represents
199 semantically equivalent symbols. */
200 bool semantically_equivalent_p (symtab_node *target);
202 /* Classify symbol symtab node for partitioning. */
203 enum symbol_partitioning_class get_partitioning_class (void);
205 /* Return comdat group. */
206 tree get_comdat_group ()
208 return x_comdat_group;
211 /* Return comdat group as identifier_node. */
212 tree get_comdat_group_id ()
214 if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE)
215 x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group);
216 return x_comdat_group;
219 /* Set comdat group. */
220 void set_comdat_group (tree group)
222 gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
223 || DECL_P (group));
224 x_comdat_group = group;
227 /* Return section as string. */
228 const char * get_section ()
230 if (!x_section)
231 return NULL;
232 return x_section->name;
235 /* Remove node from same comdat group. */
236 void remove_from_same_comdat_group (void);
238 /* Add this symtab_node to the same comdat group that OLD is in. */
239 void add_to_same_comdat_group (symtab_node *old_node);
241 /* Dissolve the same_comdat_group list in which NODE resides. */
242 void dissolve_same_comdat_group_list (void);
244 /* Return true when symtab_node is known to be used from other (non-LTO)
245 object file. Known only when doing LTO via linker plugin. */
246 bool used_from_object_file_p (void);
248 /* Walk the alias chain to return the symbol NODE is alias of.
249 If NODE is not an alias, return NODE.
250 When AVAILABILITY is non-NULL, get minimal availability in the chain.
251 When REF is non-NULL, assume that reference happens in symbol REF
252 when determining the availability. */
253 symtab_node *ultimate_alias_target (enum availability *avail = NULL,
254 struct symtab_node *ref = NULL);
256 /* Return next reachable static symbol with initializer after NODE. */
257 inline symtab_node *next_defined_symbol (void);
259 /* Add reference recording that symtab node is alias of TARGET.
260 If TRANSPARENT is true make the alias to be transparent alias.
261 The function can fail in the case of aliasing cycles; in this case
262 it returns false. */
263 bool resolve_alias (symtab_node *target, bool transparent = false);
265 /* C++ FE sometimes change linkage flags after producing same
266 body aliases. */
267 void fixup_same_cpp_alias_visibility (symtab_node *target);
269 /* Call callback on symtab node and aliases associated to this node.
270 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
271 skipped. */
272 bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
273 void *data,
274 bool include_overwrite);
276 /* If node can not be interposable by static or dynamic linker to point to
277 different definition, return this symbol. Otherwise look for alias with
278 such property and if none exists, introduce new one. */
279 symtab_node *noninterposable_alias (void);
281 /* Return node that alias is aliasing. */
282 inline symtab_node *get_alias_target (void);
284 /* Set section for symbol and its aliases. */
285 void set_section (const char *section);
287 /* Set section, do not recurse into aliases.
288 When one wants to change section of symbol and its aliases,
289 use set_section. */
290 void set_section_for_node (const char *section);
292 /* Set initialization priority to PRIORITY. */
293 void set_init_priority (priority_type priority);
295 /* Return the initialization priority. */
296 priority_type get_init_priority ();
298 /* Return availability of NODE when referenced from REF. */
299 enum availability get_availability (symtab_node *ref = NULL);
301 /* Return true if NODE binds to current definition in final executable
302 when referenced from REF. If REF is NULL return conservative value
303 for any reference. */
304 bool binds_to_current_def_p (symtab_node *ref = NULL);
306 /* Make DECL local. */
307 void make_decl_local (void);
309 /* Copy visibility from N. */
310 void copy_visibility_from (symtab_node *n);
312 /* Return desired alignment of the definition. This is NOT alignment useful
313 to access THIS, because THIS may be interposable and DECL_ALIGN should
314 be used instead. It however must be guaranteed when output definition
315 of THIS. */
316 unsigned int definition_alignment ();
318 /* Return true if alignment can be increased. */
319 bool can_increase_alignment_p ();
321 /* Increase alignment of symbol to ALIGN. */
322 void increase_alignment (unsigned int align);
324 /* Return true if list contains an alias. */
325 bool has_aliases_p (void);
327 /* Return true when the symbol is real symbol, i.e. it is not inline clone
328 or abstract function kept for debug info purposes only. */
329 bool real_symbol_p (void);
331 /* Determine if symbol declaration is needed. That is, visible to something
332 either outside this translation unit, something magic in the system
333 configury. This function is used just during symbol creation. */
334 bool needed_p (void);
336 /* Return true if this symbol is a function from the C frontend specified
337 directly in RTL form (with "__RTL"). */
338 bool native_rtl_p () const;
340 /* Return true when there are references to the node. */
341 bool referred_to_p (bool include_self = true);
343 /* Return true if symbol can be discarded by linker from the binary.
344 Assume that symbol is used (so there is no need to take into account
345 garbage collecting linkers)
347 This can happen for comdats, commons and weaks when they are previaled
348 by other definition at static linking time. */
349 inline bool
350 can_be_discarded_p (void)
352 return (DECL_EXTERNAL (decl)
353 || ((get_comdat_group ()
354 || DECL_COMMON (decl)
355 || (DECL_SECTION_NAME (decl) && DECL_WEAK (decl)))
356 && ((resolution != LDPR_PREVAILING_DEF
357 && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP)
358 || flag_incremental_link)
359 && resolution != LDPR_PREVAILING_DEF_IRONLY));
362 /* Return true if NODE is local to a particular COMDAT group, and must not
363 be named from outside the COMDAT. This is used for C++ decloned
364 constructors. */
365 inline bool comdat_local_p (void)
367 return (same_comdat_group && !TREE_PUBLIC (decl));
370 /* Return true if ONE and TWO are part of the same COMDAT group. */
371 inline bool in_same_comdat_group_p (symtab_node *target);
373 /* Return true if symbol is known to be nonzero. */
374 bool nonzero_address ();
376 /* Return 0 if symbol is known to have different address than S2,
377 Return 1 if symbol is known to have same address as S2,
378 return 2 otherwise.
380 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
381 and S2 is going to be accessed. This eliminates the situations when
382 either THIS or S2 is NULL and is seful for comparing bases when deciding
383 about memory aliasing. */
384 int equal_address_to (symtab_node *s2, bool memory_accessed = false);
386 /* Return true if symbol's address may possibly be compared to other
387 symbol's address. */
388 bool address_matters_p ();
390 /* Return true if NODE's address can be compared. This use properties
391 of NODE only and does not look if the address is actually taken in
392 interesting way. For that use ADDRESS_MATTERS_P instead. */
393 bool address_can_be_compared_p (void);
395 /* Return symbol table node associated with DECL, if any,
396 and NULL otherwise. */
397 static inline symtab_node *get (const_tree decl)
399 /* Check that we are called for sane type of object - functions
400 and static or external variables. */
401 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
402 || (TREE_CODE (decl) == VAR_DECL
403 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
404 || in_lto_p)));
405 /* Check that the mapping is sane - perhaps this check can go away,
406 but at the moment frontends tends to corrupt the mapping by calling
407 memcpy/memset on the tree nodes. */
408 gcc_checking_assert (!decl->decl_with_vis.symtab_node
409 || decl->decl_with_vis.symtab_node->decl == decl);
410 return decl->decl_with_vis.symtab_node;
413 /* Try to find a symtab node for declaration DECL and if it does not
414 exist or if it corresponds to an inline clone, create a new one. */
415 static inline symtab_node * get_create (tree node);
417 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
418 Return NULL if there's no such node. */
419 static symtab_node *get_for_asmname (const_tree asmname);
421 /* Verify symbol table for internal consistency. */
422 static DEBUG_FUNCTION void verify_symtab_nodes (void);
424 /* Perform internal consistency checks, if they are enabled. */
425 static inline void checking_verify_symtab_nodes (void);
427 /* Type of the symbol. */
428 ENUM_BITFIELD (symtab_type) type : 8;
430 /* The symbols resolution. */
431 ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;
433 /*** Flags representing the symbol type. ***/
435 /* True when symbol corresponds to a definition in current unit.
436 set via finalize_function or finalize_decl */
437 unsigned definition : 1;
438 /* True when symbol is an alias.
439 Set by ssemble_alias. */
440 unsigned alias : 1;
441 /* When true the alias is translated into its target symbol either by GCC
442 or assembler (it also may just be a duplicate declaration of the same
443 linker name).
445 Currently transparent aliases come in three different flavors
446 - aliases having the same assembler name as their target (aka duplicated
447 declarations). In this case the assembler names compare via
448 assembler_names_equal_p and weakref is false
449 - aliases that are renamed at a time being output to final file
450 by varasm.c. For those DECL_ASSEMBLER_NAME have
451 IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
452 name must be unique.
453 Weakrefs belong to this cateogry when we target assembler without
454 .weakref directive.
455 - weakrefs that are renamed by assembler via .weakref directive.
456 In this case the alias may or may not be definition (depending if
457 target declaration was seen by the compiler), weakref is set.
458 Unless we are before renaming statics, assembler names are different.
460 Given that we now support duplicate declarations, the second option is
461 redundant and will be removed. */
462 unsigned transparent_alias : 1;
463 /* True when alias is a weakref. */
464 unsigned weakref : 1;
465 /* C++ frontend produce same body aliases and extra name aliases for
466 virtual functions and vtables that are obviously equivalent.
467 Those aliases are bit special, especially because C++ frontend
468 visibility code is so ugly it can not get them right at first time
469 and their visibility needs to be copied from their "masters" at
470 the end of parsing. */
471 unsigned cpp_implicit_alias : 1;
472 /* Set once the definition was analyzed. The list of references and
473 other properties are built during analysis. */
474 unsigned analyzed : 1;
475 /* Set for write-only variables. */
476 unsigned writeonly : 1;
477 /* Visibility of symbol was used for further optimization; do not
478 permit further changes. */
479 unsigned refuse_visibility_changes : 1;
481 /*** Visibility and linkage flags. ***/
483 /* Set when function is visible by other units. */
484 unsigned externally_visible : 1;
485 /* Don't reorder to other symbols having this set. */
486 unsigned no_reorder : 1;
487 /* The symbol will be assumed to be used in an invisible way (like
488 by an toplevel asm statement). */
489 unsigned force_output : 1;
490 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
491 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
492 to static and it does not inhibit optimization. */
493 unsigned forced_by_abi : 1;
494 /* True when the name is known to be unique and thus it does not need mangling. */
495 unsigned unique_name : 1;
496 /* Specify whether the section was set by user or by
497 compiler via -ffunction-sections. */
498 unsigned implicit_section : 1;
499 /* True when body and other characteristics have been removed by
500 symtab_remove_unreachable_nodes. */
501 unsigned body_removed : 1;
503 /*** WHOPR Partitioning flags.
504 These flags are used at ltrans stage when only part of the callgraph is
505 available. ***/
507 /* Set when variable is used from other LTRANS partition. */
508 unsigned used_from_other_partition : 1;
509 /* Set when function is available in the other LTRANS partition.
510 During WPA output it is used to mark nodes that are present in
511 multiple partitions. */
512 unsigned in_other_partition : 1;
516 /*** other flags. ***/
518 /* Set when symbol has address taken. */
519 unsigned address_taken : 1;
520 /* Set when init priority is set. */
521 unsigned in_init_priority_hash : 1;
523 /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
524 of offloading, for separate compilation for a different target. */
525 unsigned need_lto_streaming : 1;
527 /* Set when symbol can be streamed into bytecode for offloading. */
528 unsigned offloadable : 1;
531 /* Ordering of all symtab entries. */
532 int order;
534 /* Declaration representing the symbol. */
535 tree decl;
537 /* Linked list of symbol table entries starting with symtab_nodes. */
538 symtab_node *next;
539 symtab_node *previous;
541 /* Linked list of symbols with the same asm name. There may be multiple
542 entries for single symbol name during LTO, because symbols are renamed
543 only after partitioning.
545 Because inline clones are kept in the assembler name has, they also produce
546 duplicate entries.
548 There are also several long standing bugs where frontends and builtin
549 code produce duplicated decls. */
550 symtab_node *next_sharing_asm_name;
551 symtab_node *previous_sharing_asm_name;
553 /* Circular list of nodes in the same comdat group if non-NULL. */
554 symtab_node *same_comdat_group;
556 /* Vectors of referring and referenced entities. */
557 ipa_ref_list ref_list;
559 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
560 depending to what was known to frontend on the creation time.
561 Once alias is resolved, this pointer become NULL. */
562 tree alias_target;
564 /* File stream where this node is being written to. */
565 struct lto_file_decl_data * lto_file_data;
567 PTR GTY ((skip)) aux;
569 /* Comdat group the symbol is in. Can be private if GGC allowed that. */
570 tree x_comdat_group;
572 /* Section name. Again can be private, if allowed. */
573 section_hash_entry *x_section;
575 protected:
576 /* Dump base fields of symtab nodes to F. Not to be used directly. */
577 void dump_base (FILE *);
579 /* Verify common part of symtab node. */
580 bool DEBUG_FUNCTION verify_base (void);
582 /* Remove node from symbol table. This function is not used directly, but via
583 cgraph/varpool node removal routines. */
584 void unregister (void);
586 /* Return the initialization and finalization priority information for
587 DECL. If there is no previous priority information, a freshly
588 allocated structure is returned. */
589 struct symbol_priority_map *priority_info (void);
591 /* Worker for call_for_symbol_and_aliases_1. */
592 bool call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *, void *),
593 void *data,
594 bool include_overwrite);
595 private:
596 /* Worker for set_section. */
597 static bool set_section (symtab_node *n, void *s);
599 /* Worker for symtab_resolve_alias. */
600 static bool set_implicit_section (symtab_node *n, void *);
602 /* Worker searching noninterposable alias. */
603 static bool noninterposable_alias (symtab_node *node, void *data);
605 /* Worker for ultimate_alias_target. */
606 symtab_node *ultimate_alias_target_1 (enum availability *avail = NULL,
607 symtab_node *ref = NULL);
609 /* Get dump name with normal or assembly name. */
610 const char *get_dump_name (bool asm_name_p) const;
613 inline void
614 symtab_node::checking_verify_symtab_nodes (void)
616 if (flag_checking)
617 symtab_node::verify_symtab_nodes ();
620 /* Walk all aliases for NODE. */
621 #define FOR_EACH_ALIAS(node, alias) \
622 for (unsigned x_i = 0; node->iterate_direct_aliases (x_i, alias); x_i++)
624 /* This is the information that is put into the cgraph local structure
625 to recover a function. */
626 struct lto_file_decl_data;
628 extern const char * const cgraph_availability_names[];
629 extern const char * const ld_plugin_symbol_resolution_names[];
630 extern const char * const tls_model_names[];
632 /* Information about thunk, used only for same body aliases. */
634 struct GTY(()) cgraph_thunk_info {
635 /* Information about the thunk. */
636 HOST_WIDE_INT fixed_offset;
637 HOST_WIDE_INT virtual_value;
638 tree alias;
639 bool this_adjusting;
640 bool virtual_offset_p;
641 bool add_pointer_bounds_args;
642 /* Set to true when alias node is thunk. */
643 bool thunk_p;
646 /* Information about the function collected locally.
647 Available after function is analyzed. */
649 struct GTY(()) cgraph_local_info {
650 /* Set when function is visible in current compilation unit only and
651 its address is never taken. */
652 unsigned local : 1;
654 /* False when there is something makes versioning impossible. */
655 unsigned versionable : 1;
657 /* False when function calling convention and signature can not be changed.
658 This is the case when __builtin_apply_args is used. */
659 unsigned can_change_signature : 1;
661 /* True when the function has been originally extern inline, but it is
662 redefined now. */
663 unsigned redefined_extern_inline : 1;
665 /* True if the function may enter serial irrevocable mode. */
666 unsigned tm_may_enter_irr : 1;
669 /* Information about the function that needs to be computed globally
670 once compilation is finished. Available only with -funit-at-a-time. */
672 struct GTY(()) cgraph_global_info {
673 /* For inline clones this points to the function they will be
674 inlined into. */
675 cgraph_node *inlined_to;
678 /* Represent which DECL tree (or reference to such tree)
679 will be replaced by another tree while versioning. */
680 struct GTY(()) ipa_replace_map
682 /* The tree that will be replaced. */
683 tree old_tree;
684 /* The new (replacing) tree. */
685 tree new_tree;
686 /* Parameter number to replace, when old_tree is NULL. */
687 int parm_num;
688 /* True when a substitution should be done, false otherwise. */
689 bool replace_p;
690 /* True when we replace a reference to old_tree. */
691 bool ref_p;
694 struct GTY(()) cgraph_clone_info
696 vec<ipa_replace_map *, va_gc> *tree_map;
697 bitmap args_to_skip;
698 bitmap combined_args_to_skip;
701 enum cgraph_simd_clone_arg_type
703 SIMD_CLONE_ARG_TYPE_VECTOR,
704 SIMD_CLONE_ARG_TYPE_UNIFORM,
705 /* These are only for integer/pointer arguments passed by value. */
706 SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
707 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
708 /* These 6 are only for reference type arguments or arguments passed
709 by reference. */
710 SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP,
711 SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP,
712 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP,
713 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP,
714 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP,
715 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP,
716 SIMD_CLONE_ARG_TYPE_MASK
719 /* Function arguments in the original function of a SIMD clone.
720 Supplementary data for `struct simd_clone'. */
722 struct GTY(()) cgraph_simd_clone_arg {
723 /* Original function argument as it originally existed in
724 DECL_ARGUMENTS. */
725 tree orig_arg;
727 /* orig_arg's function (or for extern functions type from
728 TYPE_ARG_TYPES). */
729 tree orig_type;
731 /* If argument is a vector, this holds the vector version of
732 orig_arg that after adjusting the argument types will live in
733 DECL_ARGUMENTS. Otherwise, this is NULL.
735 This basically holds:
736 vector(simdlen) __typeof__(orig_arg) new_arg. */
737 tree vector_arg;
739 /* vector_arg's type (or for extern functions new vector type. */
740 tree vector_type;
742 /* If argument is a vector, this holds the array where the simd
743 argument is held while executing the simd clone function. This
744 is a local variable in the cloned function. Its content is
745 copied from vector_arg upon entry to the clone.
747 This basically holds:
748 __typeof__(orig_arg) simd_array[simdlen]. */
749 tree simd_array;
751 /* A SIMD clone's argument can be either linear (constant or
752 variable), uniform, or vector. */
753 enum cgraph_simd_clone_arg_type arg_type;
755 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
756 the constant linear step, if arg_type is
757 SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
758 the uniform argument holding the step, otherwise 0. */
759 HOST_WIDE_INT linear_step;
761 /* Variable alignment if available, otherwise 0. */
762 unsigned int alignment;
765 /* Specific data for a SIMD function clone. */
767 struct GTY(()) cgraph_simd_clone {
768 /* Number of words in the SIMD lane associated with this clone. */
769 unsigned int simdlen;
771 /* Number of annotated function arguments in `args'. This is
772 usually the number of named arguments in FNDECL. */
773 unsigned int nargs;
775 /* Max hardware vector size in bits for integral vectors. */
776 unsigned int vecsize_int;
778 /* Max hardware vector size in bits for floating point vectors. */
779 unsigned int vecsize_float;
781 /* Machine mode of the mask argument(s), if they are to be passed
782 as bitmasks in integer argument(s). VOIDmode if masks are passed
783 as vectors of characteristic type. */
784 machine_mode mask_mode;
786 /* The mangling character for a given vector size. This is used
787 to determine the ISA mangling bit as specified in the Intel
788 Vector ABI. */
789 unsigned char vecsize_mangle;
791 /* True if this is the masked, in-branch version of the clone,
792 otherwise false. */
793 unsigned int inbranch : 1;
795 /* True if this is a Cilk Plus variant. */
796 unsigned int cilk_elemental : 1;
798 /* Doubly linked list of SIMD clones. */
799 cgraph_node *prev_clone, *next_clone;
801 /* Original cgraph node the SIMD clones were created for. */
802 cgraph_node *origin;
804 /* Annotated function arguments for the original function. */
805 cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
808 /* Function Multiversioning info. */
809 struct GTY((for_user)) cgraph_function_version_info {
810 /* The cgraph_node for which the function version info is stored. */
811 cgraph_node *this_node;
812 /* Chains all the semantically identical function versions. The
813 first function in this chain is the version_info node of the
814 default function. */
815 cgraph_function_version_info *prev;
816 /* If this version node corresponds to a dispatcher for function
817 versions, this points to the version info node of the default
818 function, the first node in the chain. */
819 cgraph_function_version_info *next;
820 /* If this node corresponds to a function version, this points
821 to the dispatcher function decl, which is the function that must
822 be called to execute the right function version at run-time.
824 If this cgraph node is a dispatcher (if dispatcher_function is
825 true, in the cgraph_node struct) for function versions, this
826 points to resolver function, which holds the function body of the
827 dispatcher. The dispatcher decl is an alias to the resolver
828 function decl. */
829 tree dispatcher_resolver;
832 #define DEFCIFCODE(code, type, string) CIF_ ## code,
833 /* Reasons for inlining failures. */
835 enum cgraph_inline_failed_t {
836 #include "cif-code.def"
837 CIF_N_REASONS
840 enum cgraph_inline_failed_type_t
842 CIF_FINAL_NORMAL = 0,
843 CIF_FINAL_ERROR
846 struct cgraph_edge;
848 struct cgraph_edge_hasher : ggc_ptr_hash<cgraph_edge>
850 typedef gimple *compare_type;
852 static hashval_t hash (cgraph_edge *);
853 static hashval_t hash (gimple *);
854 static bool equal (cgraph_edge *, gimple *);
857 /* The cgraph data structure.
858 Each function decl has assigned cgraph_node listing callees and callers. */
860 struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node {
861 public:
862 /* Remove the node from cgraph and all inline clones inlined into it.
863 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
864 removed. This allows to call the function from outer loop walking clone
865 tree. */
866 bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
868 /* Record all references from cgraph_node that are taken
869 in statement STMT. */
870 void record_stmt_references (gimple *stmt);
872 /* Like cgraph_set_call_stmt but walk the clone tree and update all
873 clones sharing the same function body.
874 When WHOLE_SPECULATIVE_EDGES is true, all three components of
875 speculative edge gets updated. Otherwise we update only direct
876 call. */
877 void set_call_stmt_including_clones (gimple *old_stmt, gcall *new_stmt,
878 bool update_speculative = true);
880 /* Walk the alias chain to return the function cgraph_node is alias of.
881 Walk through thunk, too.
882 When AVAILABILITY is non-NULL, get minimal availability in the chain.
883 When REF is non-NULL, assume that reference happens in symbol REF
884 when determining the availability. */
885 cgraph_node *function_symbol (enum availability *avail = NULL,
886 struct symtab_node *ref = NULL);
888 /* Walk the alias chain to return the function cgraph_node is alias of.
889 Walk through non virtual thunks, too. Thus we return either a function
890 or a virtual thunk node.
891 When AVAILABILITY is non-NULL, get minimal availability in the chain.
892 When REF is non-NULL, assume that reference happens in symbol REF
893 when determining the availability. */
894 cgraph_node *function_or_virtual_thunk_symbol
895 (enum availability *avail = NULL,
896 struct symtab_node *ref = NULL);
898 /* Create node representing clone of N executed COUNT times. Decrease
899 the execution counts from original node too.
900 The new clone will have decl set to DECL that may or may not be the same
901 as decl of N.
903 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
904 function's profile to reflect the fact that part of execution is handled
905 by node.
906 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
907 the new clone. Otherwise the caller is responsible for doing so later.
909 If the new node is being inlined into another one, NEW_INLINED_TO should be
910 the outline function the new one is (even indirectly) inlined to.
911 All hooks will see this in node's global.inlined_to, when invoked.
912 Can be NULL if the node is not inlined. SUFFIX is string that is appended
913 to the original name. */
914 cgraph_node *create_clone (tree decl, profile_count count, int freq,
915 bool update_original,
916 vec<cgraph_edge *> redirect_callers,
917 bool call_duplication_hook,
918 cgraph_node *new_inlined_to,
919 bitmap args_to_skip, const char *suffix = NULL);
921 /* Create callgraph node clone with new declaration. The actual body will
922 be copied later at compilation stage. */
923 cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
924 vec<ipa_replace_map *, va_gc> *tree_map,
925 bitmap args_to_skip, const char * suffix);
927 /* cgraph node being removed from symbol table; see if its entry can be
928 replaced by other inline clone. */
929 cgraph_node *find_replacement (void);
931 /* Create a new cgraph node which is the new version of
932 callgraph node. REDIRECT_CALLERS holds the callers
933 edges which should be redirected to point to
934 NEW_VERSION. ALL the callees edges of the node
935 are cloned to the new version node. Return the new
936 version node.
938 If non-NULL BLOCK_TO_COPY determine what basic blocks
939 was copied to prevent duplications of calls that are dead
940 in the clone.
942 SUFFIX is string that is appended to the original name. */
944 cgraph_node *create_version_clone (tree new_decl,
945 vec<cgraph_edge *> redirect_callers,
946 bitmap bbs_to_copy,
947 const char *suffix = NULL);
949 /* Perform function versioning.
950 Function versioning includes copying of the tree and
951 a callgraph update (creating a new cgraph node and updating
952 its callees and callers).
954 REDIRECT_CALLERS varray includes the edges to be redirected
955 to the new version.
957 TREE_MAP is a mapping of tree nodes we want to replace with
958 new ones (according to results of prior analysis).
960 If non-NULL ARGS_TO_SKIP determine function parameters to remove
961 from new version.
962 If SKIP_RETURN is true, the new version will return void.
963 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
964 If non_NULL NEW_ENTRY determine new entry BB of the clone.
966 Return the new version's cgraph node. */
967 cgraph_node *create_version_clone_with_body
968 (vec<cgraph_edge *> redirect_callers,
969 vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip,
970 bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block,
971 const char *clone_name);
973 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
974 corresponding to cgraph_node. */
975 cgraph_function_version_info *insert_new_function_version (void);
977 /* Get the cgraph_function_version_info node corresponding to node. */
978 cgraph_function_version_info *function_version (void);
980 /* Discover all functions and variables that are trivially needed, analyze
981 them as well as all functions and variables referred by them */
982 void analyze (void);
984 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
985 aliases DECL with an adjustments made into the first parameter.
986 See comments in thunk_adjust for detail on the parameters. */
987 cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
988 HOST_WIDE_INT fixed_offset,
989 HOST_WIDE_INT virtual_value,
990 tree virtual_offset,
991 tree real_alias);
994 /* Return node that alias is aliasing. */
995 inline cgraph_node *get_alias_target (void);
997 /* Given function symbol, walk the alias chain to return the function node
998 is alias of. Do not walk through thunks.
999 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1000 When REF is non-NULL, assume that reference happens in symbol REF
1001 when determining the availability. */
1003 cgraph_node *ultimate_alias_target (availability *availability = NULL,
1004 symtab_node *ref = NULL);
1006 /* Expand thunk NODE to gimple if possible.
1007 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1008 no assembler is produced.
1009 When OUTPUT_ASM_THUNK is true, also produce assembler for
1010 thunks that are not lowered. */
1011 bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk);
1013 /* Call expand_thunk on all callers that are thunks and analyze those
1014 nodes that were expanded. */
1015 void expand_all_artificial_thunks ();
1017 /* Assemble thunks and aliases associated to node. */
1018 void assemble_thunks_and_aliases (void);
1020 /* Expand function specified by node. */
1021 void expand (void);
1023 /* As an GCC extension we allow redefinition of the function. The
1024 semantics when both copies of bodies differ is not well defined.
1025 We replace the old body with new body so in unit at a time mode
1026 we always use new body, while in normal mode we may end up with
1027 old body inlined into some functions and new body expanded and
1028 inlined in others. */
1029 void reset (void);
1031 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
1032 kind of wrapper method. */
1033 void create_wrapper (cgraph_node *target);
1035 /* Verify cgraph nodes of the cgraph node. */
1036 void DEBUG_FUNCTION verify_node (void);
1038 /* Remove function from symbol table. */
1039 void remove (void);
1041 /* Dump call graph node to file F. */
1042 void dump (FILE *f);
1044 /* Dump call graph node to stderr. */
1045 void DEBUG_FUNCTION debug (void);
1047 /* When doing LTO, read cgraph_node's body from disk if it is not already
1048 present. */
1049 bool get_untransformed_body (void);
1051 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
1052 if it is not already present. When some IPA transformations are scheduled,
1053 apply them. */
1054 bool get_body (void);
1056 /* Release memory used to represent body of function.
1057 Use this only for functions that are released before being translated to
1058 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1059 are free'd in final.c via free_after_compilation(). */
1060 void release_body (bool keep_arguments = false);
1062 /* Return the DECL_STRUCT_FUNCTION of the function. */
1063 struct function *get_fun (void);
1065 /* cgraph_node is no longer nested function; update cgraph accordingly. */
1066 void unnest (void);
1068 /* Bring cgraph node local. */
1069 void make_local (void);
1071 /* Likewise indicate that a node is having address taken. */
1072 void mark_address_taken (void);
1074 /* Set fialization priority to PRIORITY. */
1075 void set_fini_priority (priority_type priority);
1077 /* Return the finalization priority. */
1078 priority_type get_fini_priority (void);
1080 /* Create edge from a given function to CALLEE in the cgraph. */
1081 cgraph_edge *create_edge (cgraph_node *callee,
1082 gcall *call_stmt, profile_count count,
1083 int freq);
1085 /* Create an indirect edge with a yet-undetermined callee where the call
1086 statement destination is a formal parameter of the caller with index
1087 PARAM_INDEX. */
1088 cgraph_edge *create_indirect_edge (gcall *call_stmt, int ecf_flags,
1089 profile_count count, int freq,
1090 bool compute_indirect_info = true);
1092 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
1093 same function body. If clones already have edge for OLD_STMT; only
1094 update the edge same way as cgraph_set_call_stmt_including_clones does. */
1095 void create_edge_including_clones (cgraph_node *callee,
1096 gimple *old_stmt, gcall *stmt,
1097 profile_count count,
1098 int freq,
1099 cgraph_inline_failed_t reason);
1101 /* Return the callgraph edge representing the GIMPLE_CALL statement
1102 CALL_STMT. */
1103 cgraph_edge *get_edge (gimple *call_stmt);
1105 /* Collect all callers of cgraph_node and its aliases that are known to lead
1106 to NODE (i.e. are not overwritable) and that are not thunks. */
1107 vec<cgraph_edge *> collect_callers (void);
1109 /* Remove all callers from the node. */
1110 void remove_callers (void);
1112 /* Remove all callees from the node. */
1113 void remove_callees (void);
1115 /* Return function availability. See cgraph.h for description of individual
1116 return values. */
1117 enum availability get_availability (symtab_node *ref = NULL);
1119 /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
1120 if any to NOTHROW. */
1121 bool set_nothrow_flag (bool nothrow);
1123 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
1124 If SET_CONST if false, clear the flag.
1126 When setting the flag be careful about possible interposition and
1127 do not set the flag for functions that can be interposet and set pure
1128 flag for functions that can bind to other definition.
1130 Return true if any change was done. */
1132 bool set_const_flag (bool set_const, bool looping);
1134 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
1135 if any to PURE.
1137 When setting the flag, be careful about possible interposition.
1138 Return true if any change was done. */
1140 bool set_pure_flag (bool pure, bool looping);
1142 /* Call callback on function and aliases associated to the function.
1143 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1144 skipped. */
1146 bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
1147 void *),
1148 void *data, bool include_overwritable);
1150 /* Call callback on cgraph_node, thunks and aliases associated to NODE.
1151 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1152 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
1153 skipped. */
1154 bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
1155 void *data),
1156 void *data,
1157 bool include_overwritable,
1158 bool exclude_virtual_thunks = false);
1160 /* Likewise indicate that a node is needed, i.e. reachable via some
1161 external means. */
1162 inline void mark_force_output (void);
1164 /* Return true when function can be marked local. */
1165 bool local_p (void);
1167 /* Return true if cgraph_node can be made local for API change.
1168 Extern inline functions and C++ COMDAT functions can be made local
1169 at the expense of possible code size growth if function is used in multiple
1170 compilation units. */
1171 bool can_be_local_p (void);
1173 /* Return true when cgraph_node can not return or throw and thus
1174 it is safe to ignore its side effects for IPA analysis. */
1175 bool cannot_return_p (void);
1177 /* Return true when function cgraph_node and all its aliases are only called
1178 directly.
1179 i.e. it is not externally visible, address was not taken and
1180 it is not used in any other non-standard way. */
1181 bool only_called_directly_p (void);
1183 /* Return true when function is only called directly or it has alias.
1184 i.e. it is not externally visible, address was not taken and
1185 it is not used in any other non-standard way. */
1186 inline bool only_called_directly_or_aliased_p (void);
1188 /* Return true when function cgraph_node can be expected to be removed
1189 from program when direct calls in this compilation unit are removed.
1191 As a special case COMDAT functions are
1192 cgraph_can_remove_if_no_direct_calls_p while the are not
1193 cgraph_only_called_directly_p (it is possible they are called from other
1194 unit)
1196 This function behaves as cgraph_only_called_directly_p because eliminating
1197 all uses of COMDAT function does not make it necessarily disappear from
1198 the program unless we are compiling whole program or we do LTO. In this
1199 case we know we win since dynamic linking will not really discard the
1200 linkonce section.
1202 If WILL_INLINE is true, assume that function will be inlined into all the
1203 direct calls. */
1204 bool will_be_removed_from_program_if_no_direct_calls_p
1205 (bool will_inline = false);
1207 /* Return true when function can be removed from callgraph
1208 if all direct calls and references are eliminated. The function does
1209 not take into account comdat groups. */
1210 bool can_remove_if_no_direct_calls_and_refs_p (void);
1212 /* Return true when function cgraph_node and its aliases can be removed from
1213 callgraph if all direct calls are eliminated.
1214 If WILL_INLINE is true, assume that function will be inlined into all the
1215 direct calls. */
1216 bool can_remove_if_no_direct_calls_p (bool will_inline = false);
1218 /* Return true when callgraph node is a function with Gimple body defined
1219 in current unit. Functions can also be define externally or they
1220 can be thunks with no Gimple representation.
1222 Note that at WPA stage, the function body may not be present in memory. */
1223 inline bool has_gimple_body_p (void);
1225 /* Return true if function should be optimized for size. */
1226 bool optimize_for_size_p (void);
1228 /* Dump the callgraph to file F. */
1229 static void dump_cgraph (FILE *f);
1231 /* Dump the call graph to stderr. */
1232 static inline
1233 void debug_cgraph (void)
1235 dump_cgraph (stderr);
1238 /* Record that DECL1 and DECL2 are semantically identical function
1239 versions. */
1240 static void record_function_versions (tree decl1, tree decl2);
1242 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
1243 DECL is a duplicate declaration. */
1244 static void delete_function_version (tree decl);
1246 /* Add the function FNDECL to the call graph.
1247 Unlike finalize_function, this function is intended to be used
1248 by middle end and allows insertion of new function at arbitrary point
1249 of compilation. The function can be either in high, low or SSA form
1250 GIMPLE.
1252 The function is assumed to be reachable and have address taken (so no
1253 API breaking optimizations are performed on it).
1255 Main work done by this function is to enqueue the function for later
1256 processing to avoid need the passes to be re-entrant. */
1257 static void add_new_function (tree fndecl, bool lowered);
1259 /* Return callgraph node for given symbol and check it is a function. */
1260 static inline cgraph_node *get (const_tree decl)
1262 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
1263 return dyn_cast <cgraph_node *> (symtab_node::get (decl));
1266 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
1267 logic in effect. If NO_COLLECT is true, then our caller cannot stand to
1268 have the garbage collector run at the moment. We would need to either
1269 create a new GC context, or just not compile right now. */
1270 static void finalize_function (tree, bool);
1272 /* Return cgraph node assigned to DECL. Create new one when needed. */
1273 static cgraph_node * create (tree decl);
1275 /* Try to find a call graph node for declaration DECL and if it does not
1276 exist or if it corresponds to an inline clone, create a new one. */
1277 static cgraph_node * get_create (tree);
1279 /* Return local info for the compiled function. */
1280 static cgraph_local_info *local_info (tree decl);
1282 /* Return local info for the compiled function. */
1283 static struct cgraph_rtl_info *rtl_info (tree);
1285 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1286 Return NULL if there's no such node. */
1287 static cgraph_node *get_for_asmname (tree asmname);
1289 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if
1290 successful and NULL otherwise.
1291 Same body aliases are output whenever the body of DECL is output,
1292 and cgraph_node::get (ALIAS) transparently
1293 returns cgraph_node::get (DECL). */
1294 static cgraph_node * create_same_body_alias (tree alias, tree decl);
1296 /* Verify whole cgraph structure. */
1297 static void DEBUG_FUNCTION verify_cgraph_nodes (void);
1299 /* Verify cgraph, if consistency checking is enabled. */
1300 static inline void checking_verify_cgraph_nodes (void);
1302 /* Worker to bring NODE local. */
1303 static bool make_local (cgraph_node *node, void *);
1305 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
1306 the function body is associated
1307 with (not necessarily cgraph_node (DECL). */
1308 static cgraph_node *create_alias (tree alias, tree target);
1310 /* Return true if NODE has thunk. */
1311 static bool has_thunk_p (cgraph_node *node, void *);
1313 cgraph_edge *callees;
1314 cgraph_edge *callers;
1315 /* List of edges representing indirect calls with a yet undetermined
1316 callee. */
1317 cgraph_edge *indirect_calls;
1318 /* For nested functions points to function the node is nested in. */
1319 cgraph_node *origin;
1320 /* Points to first nested function, if any. */
1321 cgraph_node *nested;
1322 /* Pointer to the next function with same origin, if any. */
1323 cgraph_node *next_nested;
1324 /* Pointer to the next clone. */
1325 cgraph_node *next_sibling_clone;
1326 cgraph_node *prev_sibling_clone;
1327 cgraph_node *clones;
1328 cgraph_node *clone_of;
1329 /* If instrumentation_clone is 1 then instrumented_version points
1330 to the original function used to make instrumented version.
1331 Otherwise points to instrumented version of the function. */
1332 cgraph_node *instrumented_version;
1333 /* If instrumentation_clone is 1 then orig_decl is the original
1334 function declaration. */
1335 tree orig_decl;
1336 /* For functions with many calls sites it holds map from call expression
1337 to the edge to speed up cgraph_edge function. */
1338 hash_table<cgraph_edge_hasher> *GTY(()) call_site_hash;
1339 /* Declaration node used to be clone of. */
1340 tree former_clone_of;
1342 /* If this is a SIMD clone, this points to the SIMD specific
1343 information for it. */
1344 cgraph_simd_clone *simdclone;
1345 /* If this function has SIMD clones, this points to the first clone. */
1346 cgraph_node *simd_clones;
1348 /* Interprocedural passes scheduled to have their transform functions
1349 applied next time we execute local pass on them. We maintain it
1350 per-function in order to allow IPA passes to introduce new functions. */
1351 vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
1353 cgraph_local_info local;
1354 cgraph_global_info global;
1355 struct cgraph_rtl_info *rtl;
1356 cgraph_clone_info clone;
1357 cgraph_thunk_info thunk;
1359 /* Expected number of executions: calculated in profile.c. */
1360 profile_count count;
1361 /* How to scale counts at materialization time; used to merge
1362 LTO units with different number of profile runs. */
1363 int count_materialization_scale;
1364 /* Unique id of the node. */
1365 int uid;
1366 /* Summary unique id of the node. */
1367 int summary_uid;
1368 /* ID assigned by the profiling. */
1369 unsigned int profile_id;
1370 /* Time profiler: first run of function. */
1371 int tp_first_run;
1373 /* Set when decl is an abstract function pointed to by the
1374 ABSTRACT_DECL_ORIGIN of a reachable function. */
1375 unsigned used_as_abstract_origin : 1;
1376 /* Set once the function is lowered (i.e. its CFG is built). */
1377 unsigned lowered : 1;
1378 /* Set once the function has been instantiated and its callee
1379 lists created. */
1380 unsigned process : 1;
1381 /* How commonly executed the node is. Initialized during branch
1382 probabilities pass. */
1383 ENUM_BITFIELD (node_frequency) frequency : 2;
1384 /* True when function can only be called at startup (from static ctor). */
1385 unsigned only_called_at_startup : 1;
1386 /* True when function can only be called at startup (from static dtor). */
1387 unsigned only_called_at_exit : 1;
1388 /* True when function is the transactional clone of a function which
1389 is called only from inside transactions. */
1390 /* ?? We should be able to remove this. We have enough bits in
1391 cgraph to calculate it. */
1392 unsigned tm_clone : 1;
1393 /* True if this decl is a dispatcher for function versions. */
1394 unsigned dispatcher_function : 1;
1395 /* True if this decl calls a COMDAT-local function. This is set up in
1396 compute_fn_summary and inline_call. */
1397 unsigned calls_comdat_local : 1;
1398 /* True if node has been created by merge operation in IPA-ICF. */
1399 unsigned icf_merged: 1;
1400 /* True when function is clone created for Pointer Bounds Checker
1401 instrumentation. */
1402 unsigned instrumentation_clone : 1;
1403 /* True if call to node can't result in a call to free, munmap or
1404 other operation that could make previously non-trapping memory
1405 accesses trapping. */
1406 unsigned nonfreeing_fn : 1;
1407 /* True if there was multiple COMDAT bodies merged by lto-symtab. */
1408 unsigned merged_comdat : 1;
1409 /* True if function was created to be executed in parallel. */
1410 unsigned parallelized_function : 1;
1411 /* True if function is part split out by ipa-split. */
1412 unsigned split_part : 1;
1413 /* True if the function appears as possible target of indirect call. */
1414 unsigned indirect_call_target : 1;
1416 private:
1417 /* Worker for call_for_symbol_and_aliases. */
1418 bool call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
1419 void *),
1420 void *data, bool include_overwritable);
1423 /* A cgraph node set is a collection of cgraph nodes. A cgraph node
1424 can appear in multiple sets. */
1425 struct cgraph_node_set_def
1427 hash_map<cgraph_node *, size_t> *map;
1428 vec<cgraph_node *> nodes;
1431 typedef cgraph_node_set_def *cgraph_node_set;
1432 typedef struct varpool_node_set_def *varpool_node_set;
1434 class varpool_node;
1436 /* A varpool node set is a collection of varpool nodes. A varpool node
1437 can appear in multiple sets. */
1438 struct varpool_node_set_def
1440 hash_map<varpool_node *, size_t> * map;
1441 vec<varpool_node *> nodes;
1444 /* Iterator structure for cgraph node sets. */
1445 struct cgraph_node_set_iterator
1447 cgraph_node_set set;
1448 unsigned index;
1451 /* Iterator structure for varpool node sets. */
1452 struct varpool_node_set_iterator
1454 varpool_node_set set;
1455 unsigned index;
1458 /* Context of polymorphic call. It represent information about the type of
1459 instance that may reach the call. This is used by ipa-devirt walkers of the
1460 type inheritance graph. */
1462 class GTY(()) ipa_polymorphic_call_context {
1463 public:
1464 /* The called object appears in an object of type OUTER_TYPE
1465 at offset OFFSET. When information is not 100% reliable, we
1466 use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
1467 HOST_WIDE_INT offset;
1468 HOST_WIDE_INT speculative_offset;
1469 tree outer_type;
1470 tree speculative_outer_type;
1471 /* True if outer object may be in construction or destruction. */
1472 unsigned maybe_in_construction : 1;
1473 /* True if outer object may be of derived type. */
1474 unsigned maybe_derived_type : 1;
1475 /* True if speculative outer object may be of derived type. We always
1476 speculate that construction does not happen. */
1477 unsigned speculative_maybe_derived_type : 1;
1478 /* True if the context is invalid and all calls should be redirected
1479 to BUILTIN_UNREACHABLE. */
1480 unsigned invalid : 1;
1481 /* True if the outer type is dynamic. */
1482 unsigned dynamic : 1;
1484 /* Build empty "I know nothing" context. */
1485 ipa_polymorphic_call_context ();
1486 /* Build polymorphic call context for indirect call E. */
1487 ipa_polymorphic_call_context (cgraph_edge *e);
1488 /* Build polymorphic call context for IP invariant CST.
1489 If specified, OTR_TYPE specify the type of polymorphic call
1490 that takes CST+OFFSET as a prameter. */
1491 ipa_polymorphic_call_context (tree cst, tree otr_type = NULL,
1492 HOST_WIDE_INT offset = 0);
1493 /* Build context for pointer REF contained in FNDECL at statement STMT.
1494 if INSTANCE is non-NULL, return pointer to the object described by
1495 the context. */
1496 ipa_polymorphic_call_context (tree fndecl, tree ref, gimple *stmt,
1497 tree *instance = NULL);
1499 /* Look for vtable stores or constructor calls to work out dynamic type
1500 of memory location. */
1501 bool get_dynamic_type (tree, tree, tree, gimple *);
1503 /* Make context non-speculative. */
1504 void clear_speculation ();
1506 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
1507 NULL, the context is set to dummy "I know nothing" setting. */
1508 void clear_outer_type (tree otr_type = NULL);
1510 /* Walk container types and modify context to point to actual class
1511 containing OTR_TYPE (if non-NULL) as base class.
1512 Return true if resulting context is valid.
1514 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
1515 valid only via allocation of new polymorphic type inside by means
1516 of placement new.
1518 When CONSIDER_BASES is false, only look for actual fields, not base types
1519 of TYPE. */
1520 bool restrict_to_inner_class (tree otr_type,
1521 bool consider_placement_new = true,
1522 bool consider_bases = true);
1524 /* Adjust all offsets in contexts by given number of bits. */
1525 void offset_by (HOST_WIDE_INT);
1526 /* Use when we can not track dynamic type change. This speculatively assume
1527 type change is not happening. */
1528 void possible_dynamic_type_change (bool, tree otr_type = NULL);
1529 /* Assume that both THIS and a given context is valid and strenghten THIS
1530 if possible. Return true if any strenghtening was made.
1531 If actual type the context is being used in is known, OTR_TYPE should be
1532 set accordingly. This improves quality of combined result. */
1533 bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULL);
1534 bool meet_with (ipa_polymorphic_call_context, tree otr_type = NULL);
1536 /* Return TRUE if context is fully useless. */
1537 bool useless_p () const;
1538 /* Return TRUE if this context conveys the same information as X. */
1539 bool equal_to (const ipa_polymorphic_call_context &x) const;
1541 /* Dump human readable context to F. If NEWLINE is true, it will be
1542 terminated by a newline. */
1543 void dump (FILE *f, bool newline = true) const;
1544 void DEBUG_FUNCTION debug () const;
1546 /* LTO streaming. */
1547 void stream_out (struct output_block *) const;
1548 void stream_in (struct lto_input_block *, struct data_in *data_in);
1550 private:
1551 bool combine_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1552 bool meet_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1553 void set_by_decl (tree, HOST_WIDE_INT);
1554 bool set_by_invariant (tree, tree, HOST_WIDE_INT);
1555 bool speculation_consistent_p (tree, HOST_WIDE_INT, bool, tree) const;
1556 void make_speculative (tree otr_type = NULL);
1559 /* Structure containing additional information about an indirect call. */
1561 struct GTY(()) cgraph_indirect_call_info
1563 /* When agg_content is set, an offset where the call pointer is located
1564 within the aggregate. */
1565 HOST_WIDE_INT offset;
1566 /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */
1567 ipa_polymorphic_call_context context;
1568 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
1569 HOST_WIDE_INT otr_token;
1570 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
1571 tree otr_type;
1572 /* Index of the parameter that is called. */
1573 int param_index;
1574 /* ECF flags determined from the caller. */
1575 int ecf_flags;
1576 /* Profile_id of common target obtrained from profile. */
1577 int common_target_id;
1578 /* Probability that call will land in function with COMMON_TARGET_ID. */
1579 int common_target_probability;
1581 /* Set when the call is a virtual call with the parameter being the
1582 associated object pointer rather than a simple direct call. */
1583 unsigned polymorphic : 1;
1584 /* Set when the call is a call of a pointer loaded from contents of an
1585 aggregate at offset. */
1586 unsigned agg_contents : 1;
1587 /* Set when this is a call through a member pointer. */
1588 unsigned member_ptr : 1;
1589 /* When the agg_contents bit is set, this one determines whether the
1590 destination is loaded from a parameter passed by reference. */
1591 unsigned by_ref : 1;
1592 /* When the agg_contents bit is set, this one determines whether we can
1593 deduce from the function body that the loaded value from the reference is
1594 never modified between the invocation of the function and the load
1595 point. */
1596 unsigned guaranteed_unmodified : 1;
1597 /* For polymorphic calls this specify whether the virtual table pointer
1598 may have changed in between function entry and the call. */
1599 unsigned vptr_changed : 1;
1602 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
1603 for_user)) cgraph_edge {
1604 friend class cgraph_node;
1606 /* Remove the edge in the cgraph. */
1607 void remove (void);
1609 /* Change field call_stmt of edge to NEW_STMT.
1610 If UPDATE_SPECULATIVE and E is any component of speculative
1611 edge, then update all components. */
1612 void set_call_stmt (gcall *new_stmt, bool update_speculative = true);
1614 /* Redirect callee of the edge to N. The function does not update underlying
1615 call expression. */
1616 void redirect_callee (cgraph_node *n);
1618 /* If the edge does not lead to a thunk, simply redirect it to N. Otherwise
1619 create one or more equivalent thunks for N and redirect E to the first in
1620 the chain. Note that it is then necessary to call
1621 n->expand_all_artificial_thunks once all callers are redirected. */
1622 void redirect_callee_duplicating_thunks (cgraph_node *n);
1624 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1625 CALLEE. DELTA is an integer constant that is to be added to the this
1626 pointer (first parameter) to compensate for skipping
1627 a thunk adjustment. */
1628 cgraph_edge *make_direct (cgraph_node *callee);
1630 /* Turn edge into speculative call calling N2. Update
1631 the profile so the direct call is taken COUNT times
1632 with FREQUENCY. */
1633 cgraph_edge *make_speculative (cgraph_node *n2, profile_count direct_count,
1634 int direct_frequency);
1636 /* Given speculative call edge, return all three components. */
1637 void speculative_call_info (cgraph_edge *&direct, cgraph_edge *&indirect,
1638 ipa_ref *&reference);
1640 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1641 Remove the speculative call sequence and return edge representing the call.
1642 It is up to caller to redirect the call as appropriate. */
1643 cgraph_edge *resolve_speculation (tree callee_decl = NULL);
1645 /* If necessary, change the function declaration in the call statement
1646 associated with the edge so that it corresponds to the edge callee. */
1647 gimple *redirect_call_stmt_to_callee (void);
1649 /* Create clone of edge in the node N represented
1650 by CALL_EXPR the callgraph. */
1651 cgraph_edge * clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid,
1652 profile_count num, profile_count den, int freq_scale,
1653 bool update_original);
1655 /* Verify edge count and frequency. */
1656 bool verify_count_and_frequency ();
1658 /* Return true when call of edge can not lead to return from caller
1659 and thus it is safe to ignore its side effects for IPA analysis
1660 when computing side effects of the caller. */
1661 bool cannot_lead_to_return_p (void);
1663 /* Return true when the edge represents a direct recursion. */
1664 bool recursive_p (void);
1666 /* Return true if the call can be hot. */
1667 bool maybe_hot_p (void);
1669 /* Rebuild cgraph edges for current function node. This needs to be run after
1670 passes that don't update the cgraph. */
1671 static unsigned int rebuild_edges (void);
1673 /* Rebuild cgraph references for current function node. This needs to be run
1674 after passes that don't update the cgraph. */
1675 static void rebuild_references (void);
1677 /* Expected number of executions: calculated in profile.c. */
1678 profile_count count;
1679 cgraph_node *caller;
1680 cgraph_node *callee;
1681 cgraph_edge *prev_caller;
1682 cgraph_edge *next_caller;
1683 cgraph_edge *prev_callee;
1684 cgraph_edge *next_callee;
1685 gcall *call_stmt;
1686 /* Additional information about an indirect call. Not cleared when an edge
1687 becomes direct. */
1688 cgraph_indirect_call_info *indirect_info;
1689 PTR GTY ((skip (""))) aux;
1690 /* When equal to CIF_OK, inline this call. Otherwise, points to the
1691 explanation why function was not inlined. */
1692 enum cgraph_inline_failed_t inline_failed;
1693 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
1694 when the function is serialized in. */
1695 unsigned int lto_stmt_uid;
1696 /* Expected frequency of executions within the function.
1697 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
1698 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
1699 int frequency;
1700 /* Unique id of the edge. */
1701 int uid;
1702 /* Whether this edge was made direct by indirect inlining. */
1703 unsigned int indirect_inlining_edge : 1;
1704 /* Whether this edge describes an indirect call with an undetermined
1705 callee. */
1706 unsigned int indirect_unknown_callee : 1;
1707 /* Whether this edge is still a dangling */
1708 /* True if the corresponding CALL stmt cannot be inlined. */
1709 unsigned int call_stmt_cannot_inline_p : 1;
1710 /* Can this call throw externally? */
1711 unsigned int can_throw_external : 1;
1712 /* Edges with SPECULATIVE flag represents indirect calls that was
1713 speculatively turned into direct (i.e. by profile feedback).
1714 The final code sequence will have form:
1716 if (call_target == expected_fn)
1717 expected_fn ();
1718 else
1719 call_target ();
1721 Every speculative call is represented by three components attached
1722 to a same call statement:
1723 1) a direct call (to expected_fn)
1724 2) an indirect call (to call_target)
1725 3) a IPA_REF_ADDR refrence to expected_fn.
1727 Optimizers may later redirect direct call to clone, so 1) and 3)
1728 do not need to necesarily agree with destination. */
1729 unsigned int speculative : 1;
1730 /* Set to true when caller is a constructor or destructor of polymorphic
1731 type. */
1732 unsigned in_polymorphic_cdtor : 1;
1734 /* Return true if call must bind to current definition. */
1735 bool binds_to_current_def_p ();
1737 private:
1738 /* Remove the edge from the list of the callers of the callee. */
1739 void remove_caller (void);
1741 /* Remove the edge from the list of the callees of the caller. */
1742 void remove_callee (void);
1744 /* Set callee N of call graph edge and add it to the corresponding set of
1745 callers. */
1746 void set_callee (cgraph_node *n);
1748 /* Output flags of edge to a file F. */
1749 void dump_edge_flags (FILE *f);
1751 /* Verify that call graph edge corresponds to DECL from the associated
1752 statement. Return true if the verification should fail. */
1753 bool verify_corresponds_to_fndecl (tree decl);
1756 #define CGRAPH_FREQ_BASE 1000
1757 #define CGRAPH_FREQ_MAX 100000
1759 /* The varpool data structure.
1760 Each static variable decl has assigned varpool_node. */
1762 class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node {
1763 public:
1764 /* Dump given varpool node to F. */
1765 void dump (FILE *f);
1767 /* Dump given varpool node to stderr. */
1768 void DEBUG_FUNCTION debug (void);
1770 /* Remove variable from symbol table. */
1771 void remove (void);
1773 /* Remove node initializer when it is no longer needed. */
1774 void remove_initializer (void);
1776 void analyze (void);
1778 /* Return variable availability. */
1779 availability get_availability (symtab_node *ref = NULL);
1781 /* When doing LTO, read variable's constructor from disk if
1782 it is not already present. */
1783 tree get_constructor (void);
1785 /* Return true if variable has constructor that can be used for folding. */
1786 bool ctor_useable_for_folding_p (void);
1788 /* For given variable pool node, walk the alias chain to return the function
1789 the variable is alias of. Do not walk through thunks.
1790 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1791 When REF is non-NULL, assume that reference happens in symbol REF
1792 when determining the availability. */
1793 inline varpool_node *ultimate_alias_target
1794 (availability *availability = NULL, symtab_node *ref = NULL);
1796 /* Return node that alias is aliasing. */
1797 inline varpool_node *get_alias_target (void);
1799 /* Output one variable, if necessary. Return whether we output it. */
1800 bool assemble_decl (void);
1802 /* For variables in named sections make sure get_variable_section
1803 is called before we switch to those sections. Then section
1804 conflicts between read-only and read-only requiring relocations
1805 sections can be resolved. */
1806 void finalize_named_section_flags (void);
1808 /* Call calback on varpool symbol and aliases associated to varpool symbol.
1809 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1810 skipped. */
1811 bool call_for_symbol_and_aliases (bool (*callback) (varpool_node *, void *),
1812 void *data,
1813 bool include_overwritable);
1815 /* Return true when variable should be considered externally visible. */
1816 bool externally_visible_p (void);
1818 /* Return true when all references to variable must be visible
1819 in ipa_ref_list.
1820 i.e. if the variable is not externally visible or not used in some magic
1821 way (asm statement or such).
1822 The magic uses are all summarized in force_output flag. */
1823 inline bool all_refs_explicit_p ();
1825 /* Return true when variable can be removed from variable pool
1826 if all direct calls are eliminated. */
1827 inline bool can_remove_if_no_refs_p (void);
1829 /* Add the variable DECL to the varpool.
1830 Unlike finalize_decl function is intended to be used
1831 by middle end and allows insertion of new variable at arbitrary point
1832 of compilation. */
1833 static void add (tree decl);
1835 /* Return varpool node for given symbol and check it is a function. */
1836 static inline varpool_node *get (const_tree decl);
1838 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
1839 the middle end to output the variable to asm file, if needed or externally
1840 visible. */
1841 static void finalize_decl (tree decl);
1843 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1844 Extra name aliases are output whenever DECL is output. */
1845 static varpool_node * create_extra_name_alias (tree alias, tree decl);
1847 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1848 Extra name aliases are output whenever DECL is output. */
1849 static varpool_node * create_alias (tree, tree);
1851 /* Dump the variable pool to F. */
1852 static void dump_varpool (FILE *f);
1854 /* Dump the variable pool to stderr. */
1855 static void DEBUG_FUNCTION debug_varpool (void);
1857 /* Allocate new callgraph node and insert it into basic data structures. */
1858 static varpool_node *create_empty (void);
1860 /* Return varpool node assigned to DECL. Create new one when needed. */
1861 static varpool_node *get_create (tree decl);
1863 /* Given an assembler name, lookup node. */
1864 static varpool_node *get_for_asmname (tree asmname);
1866 /* Set when variable is scheduled to be assembled. */
1867 unsigned output : 1;
1869 /* Set when variable has statically initialized pointer
1870 or is a static bounds variable and needs initalization. */
1871 unsigned need_bounds_init : 1;
1873 /* Set if the variable is dynamically initialized, except for
1874 function local statics. */
1875 unsigned dynamically_initialized : 1;
1877 ENUM_BITFIELD(tls_model) tls_model : 3;
1879 /* Set if the variable is known to be used by single function only.
1880 This is computed by ipa_signle_use pass and used by late optimizations
1881 in places where optimization would be valid for local static variable
1882 if we did not do any inter-procedural code movement. */
1883 unsigned used_by_single_function : 1;
1885 private:
1886 /* Assemble thunks and aliases associated to varpool node. */
1887 void assemble_aliases (void);
1889 /* Worker for call_for_node_and_aliases. */
1890 bool call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *, void *),
1891 void *data,
1892 bool include_overwritable);
1895 /* Every top level asm statement is put into a asm_node. */
1897 struct GTY(()) asm_node {
1900 /* Next asm node. */
1901 asm_node *next;
1902 /* String for this asm node. */
1903 tree asm_str;
1904 /* Ordering of all cgraph nodes. */
1905 int order;
1908 /* Report whether or not THIS symtab node is a function, aka cgraph_node. */
1910 template <>
1911 template <>
1912 inline bool
1913 is_a_helper <cgraph_node *>::test (symtab_node *p)
1915 return p && p->type == SYMTAB_FUNCTION;
1918 /* Report whether or not THIS symtab node is a vriable, aka varpool_node. */
1920 template <>
1921 template <>
1922 inline bool
1923 is_a_helper <varpool_node *>::test (symtab_node *p)
1925 return p && p->type == SYMTAB_VARIABLE;
1928 /* Macros to access the next item in the list of free cgraph nodes and
1929 edges. */
1930 #define NEXT_FREE_NODE(NODE) dyn_cast<cgraph_node *> ((NODE)->next)
1931 #define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->next = NODE2
1932 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
1934 typedef void (*cgraph_edge_hook)(cgraph_edge *, void *);
1935 typedef void (*cgraph_node_hook)(cgraph_node *, void *);
1936 typedef void (*varpool_node_hook)(varpool_node *, void *);
1937 typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *);
1938 typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *);
1940 struct cgraph_edge_hook_list;
1941 struct cgraph_node_hook_list;
1942 struct varpool_node_hook_list;
1943 struct cgraph_2edge_hook_list;
1944 struct cgraph_2node_hook_list;
1946 /* Map from a symbol to initialization/finalization priorities. */
1947 struct GTY(()) symbol_priority_map {
1948 priority_type init;
1949 priority_type fini;
1952 enum symtab_state
1954 /* Frontend is parsing and finalizing functions. */
1955 PARSING,
1956 /* Callgraph is being constructed. It is safe to add new functions. */
1957 CONSTRUCTION,
1958 /* Callgraph is being streamed-in at LTO time. */
1959 LTO_STREAMING,
1960 /* Callgraph is built and early IPA passes are being run. */
1961 IPA,
1962 /* Callgraph is built and all functions are transformed to SSA form. */
1963 IPA_SSA,
1964 /* All inline decisions are done; it is now possible to remove extern inline
1965 functions and virtual call targets. */
1966 IPA_SSA_AFTER_INLINING,
1967 /* Functions are now ordered and being passed to RTL expanders. */
1968 EXPANSION,
1969 /* All cgraph expansion is done. */
1970 FINISHED
1973 struct asmname_hasher : ggc_ptr_hash <symtab_node>
1975 typedef const_tree compare_type;
1977 static hashval_t hash (symtab_node *n);
1978 static bool equal (symtab_node *n, const_tree t);
1981 class GTY((tag ("SYMTAB"))) symbol_table
1983 public:
1984 friend class symtab_node;
1985 friend class cgraph_node;
1986 friend class cgraph_edge;
1988 symbol_table (): cgraph_max_summary_uid (1)
1992 /* Initialize callgraph dump file. */
1993 void initialize (void);
1995 /* Register a top-level asm statement ASM_STR. */
1996 inline asm_node *finalize_toplevel_asm (tree asm_str);
1998 /* Analyze the whole compilation unit once it is parsed completely. */
1999 void finalize_compilation_unit (void);
2001 /* C++ frontend produce same body aliases all over the place, even before PCH
2002 gets streamed out. It relies on us linking the aliases with their function
2003 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
2004 first produce aliases without links, but once C++ FE is sure he won't sream
2005 PCH we build the links via this function. */
2006 void process_same_body_aliases (void);
2008 /* Perform simple optimizations based on callgraph. */
2009 void compile (void);
2011 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
2012 functions into callgraph in a way so they look like ordinary reachable
2013 functions inserted into callgraph already at construction time. */
2014 void process_new_functions (void);
2016 /* Once all functions from compilation unit are in memory, produce all clones
2017 and update all calls. We might also do this on demand if we don't want to
2018 bring all functions to memory prior compilation, but current WHOPR
2019 implementation does that and it is bit easier to keep everything right
2020 in this order. */
2021 void materialize_all_clones (void);
2023 /* Register a symbol NODE. */
2024 inline void register_symbol (symtab_node *node);
2026 inline void
2027 clear_asm_symbols (void)
2029 asmnodes = NULL;
2030 asm_last_node = NULL;
2033 /* Perform reachability analysis and reclaim all unreachable nodes. */
2034 bool remove_unreachable_nodes (FILE *file);
2036 /* Optimization of function bodies might've rendered some variables as
2037 unnecessary so we want to avoid these from being compiled. Re-do
2038 reachability starting from variables that are either externally visible
2039 or was referred from the asm output routines. */
2040 void remove_unreferenced_decls (void);
2042 /* Unregister a symbol NODE. */
2043 inline void unregister (symtab_node *node);
2045 /* Allocate new callgraph node and insert it into basic data structures. */
2046 cgraph_node *create_empty (void);
2048 /* Release a callgraph NODE with UID and put in to the list
2049 of free nodes. */
2050 void release_symbol (cgraph_node *node, int uid);
2052 /* Output all variables enqueued to be assembled. */
2053 bool output_variables (void);
2055 /* Weakrefs may be associated to external decls and thus not output
2056 at expansion time. Emit all necessary aliases. */
2057 void output_weakrefs (void);
2059 /* Return first static symbol with definition. */
2060 inline symtab_node *first_symbol (void);
2062 /* Return first assembler symbol. */
2063 inline asm_node *
2064 first_asm_symbol (void)
2066 return asmnodes;
2069 /* Return first static symbol with definition. */
2070 inline symtab_node *first_defined_symbol (void);
2072 /* Return first variable. */
2073 inline varpool_node *first_variable (void);
2075 /* Return next variable after NODE. */
2076 inline varpool_node *next_variable (varpool_node *node);
2078 /* Return first static variable with initializer. */
2079 inline varpool_node *first_static_initializer (void);
2081 /* Return next static variable with initializer after NODE. */
2082 inline varpool_node *next_static_initializer (varpool_node *node);
2084 /* Return first static variable with definition. */
2085 inline varpool_node *first_defined_variable (void);
2087 /* Return next static variable with definition after NODE. */
2088 inline varpool_node *next_defined_variable (varpool_node *node);
2090 /* Return first function with body defined. */
2091 inline cgraph_node *first_defined_function (void);
2093 /* Return next function with body defined after NODE. */
2094 inline cgraph_node *next_defined_function (cgraph_node *node);
2096 /* Return first function. */
2097 inline cgraph_node *first_function (void);
2099 /* Return next function. */
2100 inline cgraph_node *next_function (cgraph_node *node);
2102 /* Return first function with body defined. */
2103 cgraph_node *first_function_with_gimple_body (void);
2105 /* Return next reachable static variable with initializer after NODE. */
2106 inline cgraph_node *next_function_with_gimple_body (cgraph_node *node);
2108 /* Register HOOK to be called with DATA on each removed edge. */
2109 cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook,
2110 void *data);
2112 /* Remove ENTRY from the list of hooks called on removing edges. */
2113 void remove_edge_removal_hook (cgraph_edge_hook_list *entry);
2115 /* Register HOOK to be called with DATA on each removed node. */
2116 cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook,
2117 void *data);
2119 /* Remove ENTRY from the list of hooks called on removing nodes. */
2120 void remove_cgraph_removal_hook (cgraph_node_hook_list *entry);
2122 /* Register HOOK to be called with DATA on each removed node. */
2123 varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook,
2124 void *data);
2126 /* Remove ENTRY from the list of hooks called on removing nodes. */
2127 void remove_varpool_removal_hook (varpool_node_hook_list *entry);
2129 /* Register HOOK to be called with DATA on each inserted node. */
2130 cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook,
2131 void *data);
2133 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2134 void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry);
2136 /* Register HOOK to be called with DATA on each inserted node. */
2137 varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook,
2138 void *data);
2140 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2141 void remove_varpool_insertion_hook (varpool_node_hook_list *entry);
2143 /* Register HOOK to be called with DATA on each duplicated edge. */
2144 cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook,
2145 void *data);
2146 /* Remove ENTRY from the list of hooks called on duplicating edges. */
2147 void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry);
2149 /* Register HOOK to be called with DATA on each duplicated node. */
2150 cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook,
2151 void *data);
2153 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
2154 void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry);
2156 /* Call all edge removal hooks. */
2157 void call_edge_removal_hooks (cgraph_edge *e);
2159 /* Call all node insertion hooks. */
2160 void call_cgraph_insertion_hooks (cgraph_node *node);
2162 /* Call all node removal hooks. */
2163 void call_cgraph_removal_hooks (cgraph_node *node);
2165 /* Call all node duplication hooks. */
2166 void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2);
2168 /* Call all edge duplication hooks. */
2169 void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2);
2171 /* Call all node removal hooks. */
2172 void call_varpool_removal_hooks (varpool_node *node);
2174 /* Call all node insertion hooks. */
2175 void call_varpool_insertion_hooks (varpool_node *node);
2177 /* Arrange node to be first in its entry of assembler_name_hash. */
2178 void symtab_prevail_in_asm_name_hash (symtab_node *node);
2180 /* Initalize asm name hash unless. */
2181 void symtab_initialize_asm_name_hash (void);
2183 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
2184 void change_decl_assembler_name (tree decl, tree name);
2186 /* Dump symbol table to F. */
2187 void dump (FILE *f);
2189 /* Dump symbol table to stderr. */
2190 inline DEBUG_FUNCTION void debug (void)
2192 dump (stderr);
2195 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
2196 name. */
2197 static bool assembler_names_equal_p (const char *name1, const char *name2);
2199 int cgraph_count;
2200 int cgraph_max_uid;
2201 int cgraph_max_summary_uid;
2203 int edges_count;
2204 int edges_max_uid;
2206 symtab_node* GTY(()) nodes;
2207 asm_node* GTY(()) asmnodes;
2208 asm_node* GTY(()) asm_last_node;
2209 cgraph_node* GTY(()) free_nodes;
2211 /* Head of a linked list of unused (freed) call graph edges.
2212 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
2213 cgraph_edge * GTY(()) free_edges;
2215 /* The order index of the next symtab node to be created. This is
2216 used so that we can sort the cgraph nodes in order by when we saw
2217 them, to support -fno-toplevel-reorder. */
2218 int order;
2220 /* Set when whole unit has been analyzed so we can access global info. */
2221 bool global_info_ready;
2222 /* What state callgraph is in right now. */
2223 enum symtab_state state;
2224 /* Set when the cgraph is fully build and the basic flags are computed. */
2225 bool function_flags_ready;
2227 bool cpp_implicit_aliases_done;
2229 /* Hash table used to hold sectoons. */
2230 hash_table<section_name_hasher> *GTY(()) section_hash;
2232 /* Hash table used to convert assembler names into nodes. */
2233 hash_table<asmname_hasher> *assembler_name_hash;
2235 /* Hash table used to hold init priorities. */
2236 hash_map<symtab_node *, symbol_priority_map> *init_priority_hash;
2238 FILE* GTY ((skip)) dump_file;
2240 /* Return symbol used to separate symbol name from suffix. */
2241 static char symbol_suffix_separator ();
2243 FILE* GTY ((skip)) ipa_clones_dump_file;
2245 hash_set <const cgraph_node *> GTY ((skip)) cloned_nodes;
2247 private:
2248 /* Allocate new callgraph node. */
2249 inline cgraph_node * allocate_cgraph_symbol (void);
2251 /* Allocate a cgraph_edge structure and fill it with data according to the
2252 parameters of which only CALLEE can be NULL (when creating an indirect call
2253 edge). */
2254 cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee,
2255 gcall *call_stmt, profile_count count, int freq,
2256 bool indir_unknown_callee);
2258 /* Put the edge onto the free list. */
2259 void free_edge (cgraph_edge *e);
2261 /* Insert NODE to assembler name hash. */
2262 void insert_to_assembler_name_hash (symtab_node *node, bool with_clones);
2264 /* Remove NODE from assembler name hash. */
2265 void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones);
2267 /* Hash asmnames ignoring the user specified marks. */
2268 static hashval_t decl_assembler_name_hash (const_tree asmname);
2270 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
2271 static bool decl_assembler_name_equal (tree decl, const_tree asmname);
2273 friend struct asmname_hasher;
2275 /* List of hooks triggered when an edge is removed. */
2276 cgraph_edge_hook_list * GTY((skip)) m_first_edge_removal_hook;
2277 /* List of hooks triggem_red when a cgraph node is removed. */
2278 cgraph_node_hook_list * GTY((skip)) m_first_cgraph_removal_hook;
2279 /* List of hooks triggered when an edge is duplicated. */
2280 cgraph_2edge_hook_list * GTY((skip)) m_first_edge_duplicated_hook;
2281 /* List of hooks triggered when a node is duplicated. */
2282 cgraph_2node_hook_list * GTY((skip)) m_first_cgraph_duplicated_hook;
2283 /* List of hooks triggered when an function is inserted. */
2284 cgraph_node_hook_list * GTY((skip)) m_first_cgraph_insertion_hook;
2285 /* List of hooks triggered when an variable is inserted. */
2286 varpool_node_hook_list * GTY((skip)) m_first_varpool_insertion_hook;
2287 /* List of hooks triggered when a node is removed. */
2288 varpool_node_hook_list * GTY((skip)) m_first_varpool_removal_hook;
2291 extern GTY(()) symbol_table *symtab;
2293 extern vec<cgraph_node *> cgraph_new_nodes;
2295 inline hashval_t
2296 asmname_hasher::hash (symtab_node *n)
2298 return symbol_table::decl_assembler_name_hash
2299 (DECL_ASSEMBLER_NAME (n->decl));
2302 inline bool
2303 asmname_hasher::equal (symtab_node *n, const_tree t)
2305 return symbol_table::decl_assembler_name_equal (n->decl, t);
2308 /* In cgraph.c */
2309 void cgraph_c_finalize (void);
2310 void release_function_body (tree);
2311 cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
2313 void cgraph_update_edges_for_call_stmt (gimple *, tree, gimple *);
2314 bool cgraph_function_possibly_inlined_p (tree);
2316 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
2317 cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);
2319 extern bool gimple_check_call_matching_types (gimple *, tree, bool);
2321 /* In cgraphunit.c */
2322 void cgraphunit_c_finalize (void);
2324 /* Initialize datastructures so DECL is a function in lowered gimple form.
2325 IN_SSA is true if the gimple is in SSA. */
2326 basic_block init_lowered_empty_function (tree, bool, profile_count);
2328 tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree);
2329 /* In cgraphclones.c */
2331 tree clone_function_name_1 (const char *, const char *);
2332 tree clone_function_name (tree decl, const char *);
2334 void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
2335 bool, bitmap, bool, bitmap, basic_block);
2337 void dump_callgraph_transformation (const cgraph_node *original,
2338 const cgraph_node *clone,
2339 const char *suffix);
2340 tree cgraph_build_function_type_skip_args (tree orig_type, bitmap args_to_skip,
2341 bool skip_return);
2343 /* In cgraphbuild.c */
2344 int compute_call_stmt_bb_frequency (tree, basic_block bb);
2345 void record_references_in_initializer (tree, bool);
2347 /* In ipa.c */
2348 void cgraph_build_static_cdtor (char which, tree body, int priority);
2349 bool ipa_discover_readonly_nonaddressable_vars (void);
2351 /* In varpool.c */
2352 tree ctor_for_folding (tree);
2354 /* In tree-chkp.c */
2355 extern bool chkp_function_instrumented_p (tree fndecl);
2357 /* In ipa-inline-analysis.c */
2358 void initialize_inline_failed (struct cgraph_edge *);
2359 bool speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining);
2361 /* Return true when the symbol is real symbol, i.e. it is not inline clone
2362 or abstract function kept for debug info purposes only. */
2363 inline bool
2364 symtab_node::real_symbol_p (void)
2366 cgraph_node *cnode;
2368 if (DECL_ABSTRACT_P (decl))
2369 return false;
2370 if (transparent_alias && definition)
2371 return false;
2372 if (!is_a <cgraph_node *> (this))
2373 return true;
2374 cnode = dyn_cast <cgraph_node *> (this);
2375 if (cnode->global.inlined_to)
2376 return false;
2377 return true;
2380 /* Return true if DECL should have entry in symbol table if used.
2381 Those are functions and static & external veriables*/
2383 static inline bool
2384 decl_in_symtab_p (const_tree decl)
2386 return (TREE_CODE (decl) == FUNCTION_DECL
2387 || (TREE_CODE (decl) == VAR_DECL
2388 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
2391 inline bool
2392 symtab_node::in_same_comdat_group_p (symtab_node *target)
2394 symtab_node *source = this;
2396 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
2398 if (cn->global.inlined_to)
2399 source = cn->global.inlined_to;
2401 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
2403 if (cn->global.inlined_to)
2404 target = cn->global.inlined_to;
2407 return source->get_comdat_group () == target->get_comdat_group ();
2410 /* Return node that alias is aliasing. */
2412 inline symtab_node *
2413 symtab_node::get_alias_target (void)
2415 ipa_ref *ref = NULL;
2416 iterate_reference (0, ref);
2417 if (ref->use == IPA_REF_CHKP)
2418 iterate_reference (1, ref);
2419 gcc_checking_assert (ref->use == IPA_REF_ALIAS);
2420 return ref->referred;
2423 /* Return next reachable static symbol with initializer after the node. */
2425 inline symtab_node *
2426 symtab_node::next_defined_symbol (void)
2428 symtab_node *node1 = next;
2430 for (; node1; node1 = node1->next)
2431 if (node1->definition)
2432 return node1;
2434 return NULL;
2437 /* Iterates I-th reference in the list, REF is also set. */
2439 inline ipa_ref *
2440 symtab_node::iterate_reference (unsigned i, ipa_ref *&ref)
2442 vec_safe_iterate (ref_list.references, i, &ref);
2444 return ref;
2447 /* Iterates I-th referring item in the list, REF is also set. */
2449 inline ipa_ref *
2450 symtab_node::iterate_referring (unsigned i, ipa_ref *&ref)
2452 ref_list.referring.iterate (i, &ref);
2454 return ref;
2457 /* Iterates I-th referring alias item in the list, REF is also set. */
2459 inline ipa_ref *
2460 symtab_node::iterate_direct_aliases (unsigned i, ipa_ref *&ref)
2462 ref_list.referring.iterate (i, &ref);
2464 if (ref && ref->use != IPA_REF_ALIAS)
2465 return NULL;
2467 return ref;
2470 /* Return true if list contains an alias. */
2472 inline bool
2473 symtab_node::has_aliases_p (void)
2475 ipa_ref *ref = NULL;
2477 return (iterate_direct_aliases (0, ref) != NULL);
2480 /* Return true when RESOLUTION indicate that linker will use
2481 the symbol from non-LTO object files. */
2483 inline bool
2484 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
2486 return (resolution == LDPR_PREVAILING_DEF
2487 || resolution == LDPR_PREEMPTED_REG
2488 || resolution == LDPR_RESOLVED_EXEC
2489 || resolution == LDPR_RESOLVED_DYN);
2492 /* Return true when symtab_node is known to be used from other (non-LTO)
2493 object file. Known only when doing LTO via linker plugin. */
2495 inline bool
2496 symtab_node::used_from_object_file_p (void)
2498 if (!TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
2499 return false;
2500 if (resolution_used_from_other_file_p (resolution))
2501 return true;
2502 return false;
2505 /* Return varpool node for given symbol and check it is a function. */
2507 inline varpool_node *
2508 varpool_node::get (const_tree decl)
2510 gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
2511 return dyn_cast<varpool_node *> (symtab_node::get (decl));
2514 /* Register a symbol NODE. */
2516 inline void
2517 symbol_table::register_symbol (symtab_node *node)
2519 node->next = nodes;
2520 node->previous = NULL;
2522 if (nodes)
2523 nodes->previous = node;
2524 nodes = node;
2526 node->order = order++;
2529 /* Register a top-level asm statement ASM_STR. */
2531 asm_node *
2532 symbol_table::finalize_toplevel_asm (tree asm_str)
2534 asm_node *node;
2536 node = ggc_cleared_alloc<asm_node> ();
2537 node->asm_str = asm_str;
2538 node->order = order++;
2539 node->next = NULL;
2541 if (asmnodes == NULL)
2542 asmnodes = node;
2543 else
2544 asm_last_node->next = node;
2546 asm_last_node = node;
2547 return node;
2550 /* Unregister a symbol NODE. */
2551 inline void
2552 symbol_table::unregister (symtab_node *node)
2554 if (node->previous)
2555 node->previous->next = node->next;
2556 else
2557 nodes = node->next;
2559 if (node->next)
2560 node->next->previous = node->previous;
2562 node->next = NULL;
2563 node->previous = NULL;
2566 /* Release a callgraph NODE with UID and put in to the list of free nodes. */
2568 inline void
2569 symbol_table::release_symbol (cgraph_node *node, int uid)
2571 cgraph_count--;
2573 /* Clear out the node to NULL all pointers and add the node to the free
2574 list. */
2575 memset (node, 0, sizeof (*node));
2576 node->type = SYMTAB_FUNCTION;
2577 node->uid = uid;
2578 SET_NEXT_FREE_NODE (node, free_nodes);
2579 free_nodes = node;
2582 /* Allocate new callgraph node. */
2584 inline cgraph_node *
2585 symbol_table::allocate_cgraph_symbol (void)
2587 cgraph_node *node;
2589 if (free_nodes)
2591 node = free_nodes;
2592 free_nodes = NEXT_FREE_NODE (node);
2594 else
2596 node = ggc_cleared_alloc<cgraph_node> ();
2597 node->uid = cgraph_max_uid++;
2600 node->summary_uid = cgraph_max_summary_uid++;
2601 return node;
2605 /* Return first static symbol with definition. */
2606 inline symtab_node *
2607 symbol_table::first_symbol (void)
2609 return nodes;
2612 /* Walk all symbols. */
2613 #define FOR_EACH_SYMBOL(node) \
2614 for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)
2616 /* Return first static symbol with definition. */
2617 inline symtab_node *
2618 symbol_table::first_defined_symbol (void)
2620 symtab_node *node;
2622 for (node = nodes; node; node = node->next)
2623 if (node->definition)
2624 return node;
2626 return NULL;
2629 /* Walk all symbols with definitions in current unit. */
2630 #define FOR_EACH_DEFINED_SYMBOL(node) \
2631 for ((node) = symtab->first_defined_symbol (); (node); \
2632 (node) = node->next_defined_symbol ())
2634 /* Return first variable. */
2635 inline varpool_node *
2636 symbol_table::first_variable (void)
2638 symtab_node *node;
2639 for (node = nodes; node; node = node->next)
2640 if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
2641 return vnode;
2642 return NULL;
2645 /* Return next variable after NODE. */
2646 inline varpool_node *
2647 symbol_table::next_variable (varpool_node *node)
2649 symtab_node *node1 = node->next;
2650 for (; node1; node1 = node1->next)
2651 if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
2652 return vnode1;
2653 return NULL;
2655 /* Walk all variables. */
2656 #define FOR_EACH_VARIABLE(node) \
2657 for ((node) = symtab->first_variable (); \
2658 (node); \
2659 (node) = symtab->next_variable ((node)))
2661 /* Return first static variable with initializer. */
2662 inline varpool_node *
2663 symbol_table::first_static_initializer (void)
2665 symtab_node *node;
2666 for (node = nodes; node; node = node->next)
2668 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2669 if (vnode && DECL_INITIAL (node->decl))
2670 return vnode;
2672 return NULL;
2675 /* Return next static variable with initializer after NODE. */
2676 inline varpool_node *
2677 symbol_table::next_static_initializer (varpool_node *node)
2679 symtab_node *node1 = node->next;
2680 for (; node1; node1 = node1->next)
2682 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
2683 if (vnode1 && DECL_INITIAL (node1->decl))
2684 return vnode1;
2686 return NULL;
2689 /* Walk all static variables with initializer set. */
2690 #define FOR_EACH_STATIC_INITIALIZER(node) \
2691 for ((node) = symtab->first_static_initializer (); (node); \
2692 (node) = symtab->next_static_initializer (node))
2694 /* Return first static variable with definition. */
2695 inline varpool_node *
2696 symbol_table::first_defined_variable (void)
2698 symtab_node *node;
2699 for (node = nodes; node; node = node->next)
2701 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2702 if (vnode && vnode->definition)
2703 return vnode;
2705 return NULL;
2708 /* Return next static variable with definition after NODE. */
2709 inline varpool_node *
2710 symbol_table::next_defined_variable (varpool_node *node)
2712 symtab_node *node1 = node->next;
2713 for (; node1; node1 = node1->next)
2715 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
2716 if (vnode1 && vnode1->definition)
2717 return vnode1;
2719 return NULL;
2721 /* Walk all variables with definitions in current unit. */
2722 #define FOR_EACH_DEFINED_VARIABLE(node) \
2723 for ((node) = symtab->first_defined_variable (); (node); \
2724 (node) = symtab->next_defined_variable (node))
2726 /* Return first function with body defined. */
2727 inline cgraph_node *
2728 symbol_table::first_defined_function (void)
2730 symtab_node *node;
2731 for (node = nodes; node; node = node->next)
2733 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
2734 if (cn && cn->definition)
2735 return cn;
2737 return NULL;
2740 /* Return next function with body defined after NODE. */
2741 inline cgraph_node *
2742 symbol_table::next_defined_function (cgraph_node *node)
2744 symtab_node *node1 = node->next;
2745 for (; node1; node1 = node1->next)
2747 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
2748 if (cn1 && cn1->definition)
2749 return cn1;
2751 return NULL;
2754 /* Walk all functions with body defined. */
2755 #define FOR_EACH_DEFINED_FUNCTION(node) \
2756 for ((node) = symtab->first_defined_function (); (node); \
2757 (node) = symtab->next_defined_function ((node)))
2759 /* Return first function. */
2760 inline cgraph_node *
2761 symbol_table::first_function (void)
2763 symtab_node *node;
2764 for (node = nodes; node; node = node->next)
2765 if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
2766 return cn;
2767 return NULL;
2770 /* Return next function. */
2771 inline cgraph_node *
2772 symbol_table::next_function (cgraph_node *node)
2774 symtab_node *node1 = node->next;
2775 for (; node1; node1 = node1->next)
2776 if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
2777 return cn1;
2778 return NULL;
2781 /* Return first function with body defined. */
2782 inline cgraph_node *
2783 symbol_table::first_function_with_gimple_body (void)
2785 symtab_node *node;
2786 for (node = nodes; node; node = node->next)
2788 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
2789 if (cn && cn->has_gimple_body_p ())
2790 return cn;
2792 return NULL;
2795 /* Return next reachable static variable with initializer after NODE. */
2796 inline cgraph_node *
2797 symbol_table::next_function_with_gimple_body (cgraph_node *node)
2799 symtab_node *node1 = node->next;
2800 for (; node1; node1 = node1->next)
2802 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
2803 if (cn1 && cn1->has_gimple_body_p ())
2804 return cn1;
2806 return NULL;
2809 /* Walk all functions. */
2810 #define FOR_EACH_FUNCTION(node) \
2811 for ((node) = symtab->first_function (); (node); \
2812 (node) = symtab->next_function ((node)))
2814 /* Return true when callgraph node is a function with Gimple body defined
2815 in current unit. Functions can also be define externally or they
2816 can be thunks with no Gimple representation.
2818 Note that at WPA stage, the function body may not be present in memory. */
2820 inline bool
2821 cgraph_node::has_gimple_body_p (void)
2823 return definition && !thunk.thunk_p && !alias;
2826 /* Walk all functions with body defined. */
2827 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
2828 for ((node) = symtab->first_function_with_gimple_body (); (node); \
2829 (node) = symtab->next_function_with_gimple_body (node))
2831 /* Uniquize all constants that appear in memory.
2832 Each constant in memory thus far output is recorded
2833 in `const_desc_table'. */
2835 struct GTY((for_user)) constant_descriptor_tree {
2836 /* A MEM for the constant. */
2837 rtx rtl;
2839 /* The value of the constant. */
2840 tree value;
2842 /* Hash of value. Computing the hash from value each time
2843 hashfn is called can't work properly, as that means recursive
2844 use of the hash table during hash table expansion. */
2845 hashval_t hash;
2848 /* Return true when function is only called directly or it has alias.
2849 i.e. it is not externally visible, address was not taken and
2850 it is not used in any other non-standard way. */
2852 inline bool
2853 cgraph_node::only_called_directly_or_aliased_p (void)
2855 gcc_assert (!global.inlined_to);
2856 return (!force_output && !address_taken
2857 && !used_from_other_partition
2858 && !DECL_VIRTUAL_P (decl)
2859 && !DECL_STATIC_CONSTRUCTOR (decl)
2860 && !DECL_STATIC_DESTRUCTOR (decl)
2861 && !used_from_object_file_p ()
2862 && !externally_visible);
2865 /* Return true when function can be removed from callgraph
2866 if all direct calls are eliminated. */
2868 inline bool
2869 cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
2871 gcc_checking_assert (!global.inlined_to);
2872 /* Instrumentation clones should not be removed before
2873 instrumentation happens. New callers may appear after
2874 instrumentation. */
2875 if (instrumentation_clone
2876 && !chkp_function_instrumented_p (decl))
2877 return false;
2878 /* Extern inlines can always go, we will use the external definition. */
2879 if (DECL_EXTERNAL (decl))
2880 return true;
2881 /* When function is needed, we can not remove it. */
2882 if (force_output || used_from_other_partition)
2883 return false;
2884 if (DECL_STATIC_CONSTRUCTOR (decl)
2885 || DECL_STATIC_DESTRUCTOR (decl))
2886 return false;
2887 /* Only COMDAT functions can be removed if externally visible. */
2888 if (externally_visible
2889 && (!DECL_COMDAT (decl)
2890 || forced_by_abi
2891 || used_from_object_file_p ()))
2892 return false;
2893 return true;
2896 /* Verify cgraph, if consistency checking is enabled. */
2898 inline void
2899 cgraph_node::checking_verify_cgraph_nodes (void)
2901 if (flag_checking)
2902 cgraph_node::verify_cgraph_nodes ();
2905 /* Return true when variable can be removed from variable pool
2906 if all direct calls are eliminated. */
2908 inline bool
2909 varpool_node::can_remove_if_no_refs_p (void)
2911 if (DECL_EXTERNAL (decl))
2912 return true;
2913 return (!force_output && !used_from_other_partition
2914 && ((DECL_COMDAT (decl)
2915 && !forced_by_abi
2916 && !used_from_object_file_p ())
2917 || !externally_visible
2918 || DECL_HAS_VALUE_EXPR_P (decl)));
2921 /* Return true when all references to variable must be visible in ipa_ref_list.
2922 i.e. if the variable is not externally visible or not used in some magic
2923 way (asm statement or such).
2924 The magic uses are all summarized in force_output flag. */
2926 inline bool
2927 varpool_node::all_refs_explicit_p ()
2929 return (definition
2930 && !externally_visible
2931 && !used_from_other_partition
2932 && !force_output);
2935 struct tree_descriptor_hasher : ggc_ptr_hash<constant_descriptor_tree>
2937 static hashval_t hash (constant_descriptor_tree *);
2938 static bool equal (constant_descriptor_tree *, constant_descriptor_tree *);
2941 /* Constant pool accessor function. */
2942 hash_table<tree_descriptor_hasher> *constant_pool_htab (void);
2944 /* Return node that alias is aliasing. */
2946 inline cgraph_node *
2947 cgraph_node::get_alias_target (void)
2949 return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
2952 /* Return node that alias is aliasing. */
2954 inline varpool_node *
2955 varpool_node::get_alias_target (void)
2957 return dyn_cast <varpool_node *> (symtab_node::get_alias_target ());
2960 /* Walk the alias chain to return the symbol NODE is alias of.
2961 If NODE is not an alias, return NODE.
2962 When AVAILABILITY is non-NULL, get minimal availability in the chain.
2963 When REF is non-NULL, assume that reference happens in symbol REF
2964 when determining the availability. */
2966 inline symtab_node *
2967 symtab_node::ultimate_alias_target (enum availability *availability,
2968 symtab_node *ref)
2970 if (!alias)
2972 if (availability)
2973 *availability = get_availability (ref);
2974 return this;
2977 return ultimate_alias_target_1 (availability, ref);
2980 /* Given function symbol, walk the alias chain to return the function node
2981 is alias of. Do not walk through thunks.
2982 When AVAILABILITY is non-NULL, get minimal availability in the chain.
2983 When REF is non-NULL, assume that reference happens in symbol REF
2984 when determining the availability. */
2986 inline cgraph_node *
2987 cgraph_node::ultimate_alias_target (enum availability *availability,
2988 symtab_node *ref)
2990 cgraph_node *n = dyn_cast <cgraph_node *>
2991 (symtab_node::ultimate_alias_target (availability, ref));
2992 if (!n && availability)
2993 *availability = AVAIL_NOT_AVAILABLE;
2994 return n;
2997 /* For given variable pool node, walk the alias chain to return the function
2998 the variable is alias of. Do not walk through thunks.
2999 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3000 When REF is non-NULL, assume that reference happens in symbol REF
3001 when determining the availability. */
3003 inline varpool_node *
3004 varpool_node::ultimate_alias_target (availability *availability,
3005 symtab_node *ref)
3007 varpool_node *n = dyn_cast <varpool_node *>
3008 (symtab_node::ultimate_alias_target (availability, ref));
3010 if (!n && availability)
3011 *availability = AVAIL_NOT_AVAILABLE;
3012 return n;
3015 /* Set callee N of call graph edge and add it to the corresponding set of
3016 callers. */
3018 inline void
3019 cgraph_edge::set_callee (cgraph_node *n)
3021 prev_caller = NULL;
3022 if (n->callers)
3023 n->callers->prev_caller = this;
3024 next_caller = n->callers;
3025 n->callers = this;
3026 callee = n;
3029 /* Redirect callee of the edge to N. The function does not update underlying
3030 call expression. */
3032 inline void
3033 cgraph_edge::redirect_callee (cgraph_node *n)
3035 /* Remove from callers list of the current callee. */
3036 remove_callee ();
3038 /* Insert to callers list of the new callee. */
3039 set_callee (n);
3042 /* Return true when the edge represents a direct recursion. */
3044 inline bool
3045 cgraph_edge::recursive_p (void)
3047 cgraph_node *c = callee->ultimate_alias_target ();
3048 if (caller->global.inlined_to)
3049 return caller->global.inlined_to->decl == c->decl;
3050 else
3051 return caller->decl == c->decl;
3054 /* Remove the edge from the list of the callers of the callee. */
3056 inline void
3057 cgraph_edge::remove_callee (void)
3059 gcc_assert (!indirect_unknown_callee);
3060 if (prev_caller)
3061 prev_caller->next_caller = next_caller;
3062 if (next_caller)
3063 next_caller->prev_caller = prev_caller;
3064 if (!prev_caller)
3065 callee->callers = next_caller;
3068 /* Return true if call must bind to current definition. */
3070 inline bool
3071 cgraph_edge::binds_to_current_def_p ()
3073 if (callee)
3074 return callee->binds_to_current_def_p (caller);
3075 else
3076 return false;
3079 /* Return true if the TM_CLONE bit is set for a given FNDECL. */
3080 static inline bool
3081 decl_is_tm_clone (const_tree fndecl)
3083 cgraph_node *n = cgraph_node::get (fndecl);
3084 if (n)
3085 return n->tm_clone;
3086 return false;
3089 /* Likewise indicate that a node is needed, i.e. reachable via some
3090 external means. */
3092 inline void
3093 cgraph_node::mark_force_output (void)
3095 force_output = 1;
3096 gcc_checking_assert (!global.inlined_to);
3099 /* Return true if function should be optimized for size. */
3101 inline bool
3102 cgraph_node::optimize_for_size_p (void)
3104 if (opt_for_fn (decl, optimize_size))
3105 return true;
3106 if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
3107 return true;
3108 else
3109 return false;
3112 /* Return symtab_node for NODE or create one if it is not present
3113 in symtab. */
3115 inline symtab_node *
3116 symtab_node::get_create (tree node)
3118 if (TREE_CODE (node) == VAR_DECL)
3119 return varpool_node::get_create (node);
3120 else
3121 return cgraph_node::get_create (node);
3124 /* Return availability of NODE when referenced from REF. */
3126 inline enum availability
3127 symtab_node::get_availability (symtab_node *ref)
3129 if (is_a <cgraph_node *> (this))
3130 return dyn_cast <cgraph_node *> (this)->get_availability (ref);
3131 else
3132 return dyn_cast <varpool_node *> (this)->get_availability (ref);
3135 /* Call calback on symtab node and aliases associated to this node.
3136 When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */
3138 inline bool
3139 symtab_node::call_for_symbol_and_aliases (bool (*callback) (symtab_node *,
3140 void *),
3141 void *data,
3142 bool include_overwritable)
3144 if (include_overwritable
3145 || get_availability () > AVAIL_INTERPOSABLE)
3147 if (callback (this, data))
3148 return true;
3150 if (has_aliases_p ())
3151 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3152 return false;
3155 /* Call callback on function and aliases associated to the function.
3156 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3157 skipped. */
3159 inline bool
3160 cgraph_node::call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
3161 void *),
3162 void *data,
3163 bool include_overwritable)
3165 if (include_overwritable
3166 || get_availability () > AVAIL_INTERPOSABLE)
3168 if (callback (this, data))
3169 return true;
3171 if (has_aliases_p ())
3172 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3173 return false;
3176 /* Call calback on varpool symbol and aliases associated to varpool symbol.
3177 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3178 skipped. */
3180 inline bool
3181 varpool_node::call_for_symbol_and_aliases (bool (*callback) (varpool_node *,
3182 void *),
3183 void *data,
3184 bool include_overwritable)
3186 if (include_overwritable
3187 || get_availability () > AVAIL_INTERPOSABLE)
3189 if (callback (this, data))
3190 return true;
3192 if (has_aliases_p ())
3193 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3194 return false;
3197 /* Return true if refernece may be used in address compare. */
3199 inline bool
3200 ipa_ref::address_matters_p ()
3202 if (use != IPA_REF_ADDR)
3203 return false;
3204 /* Addresses taken from virtual tables are never compared. */
3205 if (is_a <varpool_node *> (referring)
3206 && DECL_VIRTUAL_P (referring->decl))
3207 return false;
3208 return referred->address_can_be_compared_p ();
3211 /* Build polymorphic call context for indirect call E. */
3213 inline
3214 ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge *e)
3216 gcc_checking_assert (e->indirect_info->polymorphic);
3217 *this = e->indirect_info->context;
3220 /* Build empty "I know nothing" context. */
3222 inline
3223 ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
3225 clear_speculation ();
3226 clear_outer_type ();
3227 invalid = false;
3230 /* Make context non-speculative. */
3232 inline void
3233 ipa_polymorphic_call_context::clear_speculation ()
3235 speculative_outer_type = NULL;
3236 speculative_offset = 0;
3237 speculative_maybe_derived_type = false;
3240 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
3241 NULL, the context is set to dummy "I know nothing" setting. */
3243 inline void
3244 ipa_polymorphic_call_context::clear_outer_type (tree otr_type)
3246 outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type) : NULL;
3247 offset = 0;
3248 maybe_derived_type = true;
3249 maybe_in_construction = true;
3250 dynamic = true;
3253 /* Adjust all offsets in contexts by OFF bits. */
3255 inline void
3256 ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off)
3258 if (outer_type)
3259 offset += off;
3260 if (speculative_outer_type)
3261 speculative_offset += off;
3264 /* Return TRUE if context is fully useless. */
3266 inline bool
3267 ipa_polymorphic_call_context::useless_p () const
3269 return (!outer_type && !speculative_outer_type);
3272 /* Return true if NODE is local. Instrumentation clones are counted as local
3273 only when original function is local. */
3275 static inline bool
3276 cgraph_local_p (cgraph_node *node)
3278 if (!node->instrumentation_clone || !node->instrumented_version)
3279 return node->local.local;
3281 return node->local.local && node->instrumented_version->local.local;
3284 /* When using fprintf (or similar), problems can arise with
3285 transient generated strings. Many string-generation APIs
3286 only support one result being alive at once (e.g. by
3287 returning a pointer to a statically-allocated buffer).
3289 If there is more than one generated string within one
3290 fprintf call: the first string gets evicted or overwritten
3291 by the second, before fprintf is fully evaluated.
3292 See e.g. PR/53136.
3294 This function provides a workaround for this, by providing
3295 a simple way to create copies of these transient strings,
3296 without the need to have explicit cleanup:
3298 fprintf (dumpfile, "string 1: %s string 2:%s\n",
3299 xstrdup_for_dump (EXPR_1),
3300 xstrdup_for_dump (EXPR_2));
3302 This is actually a simple wrapper around ggc_strdup, but
3303 the name documents the intent. We require that no GC can occur
3304 within the fprintf call. */
3306 static inline const char *
3307 xstrdup_for_dump (const char *transient_str)
3309 return ggc_strdup (transient_str);
3312 #endif /* GCC_CGRAPH_H */