1 /* Callgraph handling code.
2 Copyright (C) 2003-2018 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
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
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/>. */
24 #include "profile-count.h"
26 #include "plugin-api.h"
28 extern void debuginfo_early_init (void);
29 extern void debuginfo_init (void);
30 extern void debuginfo_fini (void);
31 extern void debuginfo_start (void);
32 extern void debuginfo_stop (void);
33 extern void debuginfo_early_start (void);
34 extern void debuginfo_early_stop (void);
37 typedef ipa_opt_pass_d
*ipa_opt_pass
;
39 /* Symbol table consists of functions and variables.
40 TODO: add labels and CONST_DECLs. */
48 /* Section names are stored as reference counted strings in GGC safe hashtable
49 (to make them survive through PCH). */
51 struct GTY((for_user
)) section_hash_entry
54 char *name
; /* As long as this datastructure stays in GGC, we can not put
55 string at the tail of structure of GGC dies in horrible
59 struct section_name_hasher
: ggc_ptr_hash
<section_hash_entry
>
61 typedef const char *compare_type
;
63 static hashval_t
hash (section_hash_entry
*);
64 static bool equal (section_hash_entry
*, const char *);
69 /* Not yet set by cgraph_function_body_availability. */
71 /* Function body/variable initializer is unknown. */
73 /* Function body/variable initializer is known but might be replaced
74 by a different one from other compilation unit and thus needs to
75 be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have
76 arbitrary side effects on escaping variables and functions, while
77 like AVAILABLE it might access static variables. */
79 /* Function body/variable initializer is known and will be used in final
82 /* Function body/variable initializer is known and all it's uses are
83 explicitly visible within current unit (ie it's address is never taken and
84 it is not exported to other units). Currently used only for functions. */
88 /* Classification of symbols WRT partitioning. */
89 enum symbol_partitioning_class
91 /* External declarations are ignored by partitioning algorithms and they are
92 added into the boundary later via compute_ltrans_boundary. */
94 /* Partitioned symbols are pur into one of partitions. */
96 /* Duplicated symbols (such as comdat or constant pool references) are
97 copied into every node needing them via add_symbol_to_partition. */
101 /* Base of all entries in the symbol table.
102 The symtab_node is inherited by cgraph and varpol nodes. */
103 class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
104 chain_next ("%h.next"), chain_prev ("%h.previous")))
108 friend class symbol_table
;
111 const char *name () const;
113 /* Return dump name. */
114 const char *dump_name () const;
116 /* Return asm name. */
117 const char *asm_name () const;
119 /* Return dump name with assembler name. */
120 const char *dump_asm_name () const;
122 /* Add node into symbol table. This function is not used directly, but via
123 cgraph/varpool node creation routines. */
124 void register_symbol (void);
126 /* Remove symbol from symbol table. */
129 /* Dump symtab node to F. */
132 /* Dump symtab node to stderr. */
133 void DEBUG_FUNCTION
debug (void);
135 /* Verify consistency of node. */
136 void DEBUG_FUNCTION
verify (void);
138 /* Return ipa reference from this symtab_node to
139 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
140 of the use and STMT the statement (if it exists). */
141 ipa_ref
*create_reference (symtab_node
*referred_node
,
142 enum ipa_ref_use use_type
);
144 /* Return ipa reference from this symtab_node to
145 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
146 of the use and STMT the statement (if it exists). */
147 ipa_ref
*create_reference (symtab_node
*referred_node
,
148 enum ipa_ref_use use_type
, gimple
*stmt
);
150 /* If VAL is a reference to a function or a variable, add a reference from
151 this symtab_node to the corresponding symbol table node. Return the new
152 reference or NULL if none was created. */
153 ipa_ref
*maybe_create_reference (tree val
, gimple
*stmt
);
155 /* Clone all references from symtab NODE to this symtab_node. */
156 void clone_references (symtab_node
*node
);
158 /* Remove all stmt references in non-speculative references.
159 Those are not maintained during inlining & clonning.
160 The exception are speculative references that are updated along
161 with callgraph edges associated with them. */
162 void clone_referring (symtab_node
*node
);
164 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
165 ipa_ref
*clone_reference (ipa_ref
*ref
, gimple
*stmt
);
167 /* Find the structure describing a reference to REFERRED_NODE
168 and associated with statement STMT. */
169 ipa_ref
*find_reference (symtab_node
*referred_node
, gimple
*stmt
,
170 unsigned int lto_stmt_uid
);
172 /* Remove all references that are associated with statement STMT. */
173 void remove_stmt_references (gimple
*stmt
);
175 /* Remove all stmt references in non-speculative references.
176 Those are not maintained during inlining & clonning.
177 The exception are speculative references that are updated along
178 with callgraph edges associated with them. */
179 void clear_stmts_in_references (void);
181 /* Remove all references in ref list. */
182 void remove_all_references (void);
184 /* Remove all referring items in ref list. */
185 void remove_all_referring (void);
187 /* Dump references in ref list to FILE. */
188 void dump_references (FILE *file
);
190 /* Dump referring in list to FILE. */
191 void dump_referring (FILE *);
193 /* Get number of references for this node. */
194 inline unsigned num_references (void)
196 return ref_list
.references
? ref_list
.references
->length () : 0;
199 /* Iterates I-th reference in the list, REF is also set. */
200 ipa_ref
*iterate_reference (unsigned i
, ipa_ref
*&ref
);
202 /* Iterates I-th referring item in the list, REF is also set. */
203 ipa_ref
*iterate_referring (unsigned i
, ipa_ref
*&ref
);
205 /* Iterates I-th referring alias item in the list, REF is also set. */
206 ipa_ref
*iterate_direct_aliases (unsigned i
, ipa_ref
*&ref
);
208 /* Return true if symtab node and TARGET represents
209 semantically equivalent symbols. */
210 bool semantically_equivalent_p (symtab_node
*target
);
212 /* Classify symbol symtab node for partitioning. */
213 enum symbol_partitioning_class
get_partitioning_class (void);
215 /* Return comdat group. */
216 tree
get_comdat_group ()
218 return x_comdat_group
;
221 /* Return comdat group as identifier_node. */
222 tree
get_comdat_group_id ()
224 if (x_comdat_group
&& TREE_CODE (x_comdat_group
) != IDENTIFIER_NODE
)
225 x_comdat_group
= DECL_ASSEMBLER_NAME (x_comdat_group
);
226 return x_comdat_group
;
229 /* Set comdat group. */
230 void set_comdat_group (tree group
)
232 gcc_checking_assert (!group
|| TREE_CODE (group
) == IDENTIFIER_NODE
234 x_comdat_group
= group
;
237 /* Return section as string. */
238 const char * get_section ()
242 return x_section
->name
;
245 /* Remove node from same comdat group. */
246 void remove_from_same_comdat_group (void);
248 /* Add this symtab_node to the same comdat group that OLD is in. */
249 void add_to_same_comdat_group (symtab_node
*old_node
);
251 /* Dissolve the same_comdat_group list in which NODE resides. */
252 void dissolve_same_comdat_group_list (void);
254 /* Return true when symtab_node is known to be used from other (non-LTO)
255 object file. Known only when doing LTO via linker plugin. */
256 bool used_from_object_file_p (void);
258 /* Walk the alias chain to return the symbol NODE is alias of.
259 If NODE is not an alias, return NODE.
260 When AVAILABILITY is non-NULL, get minimal availability in the chain.
261 When REF is non-NULL, assume that reference happens in symbol REF
262 when determining the availability. */
263 symtab_node
*ultimate_alias_target (enum availability
*avail
= NULL
,
264 struct symtab_node
*ref
= NULL
);
266 /* Return next reachable static symbol with initializer after NODE. */
267 inline symtab_node
*next_defined_symbol (void);
269 /* Add reference recording that symtab node is alias of TARGET.
270 If TRANSPARENT is true make the alias to be transparent alias.
271 The function can fail in the case of aliasing cycles; in this case
273 bool resolve_alias (symtab_node
*target
, bool transparent
= false);
275 /* C++ FE sometimes change linkage flags after producing same
277 void fixup_same_cpp_alias_visibility (symtab_node
*target
);
279 /* Call callback on symtab node and aliases associated to this node.
280 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
282 bool call_for_symbol_and_aliases (bool (*callback
) (symtab_node
*, void *),
284 bool include_overwrite
);
286 /* If node can not be interposable by static or dynamic linker to point to
287 different definition, return this symbol. Otherwise look for alias with
288 such property and if none exists, introduce new one. */
289 symtab_node
*noninterposable_alias (void);
291 /* Return node that alias is aliasing. */
292 inline symtab_node
*get_alias_target (void);
294 /* Set section for symbol and its aliases. */
295 void set_section (const char *section
);
297 /* Set section, do not recurse into aliases.
298 When one wants to change section of symbol and its aliases,
300 void set_section_for_node (const char *section
);
302 /* Set initialization priority to PRIORITY. */
303 void set_init_priority (priority_type priority
);
305 /* Return the initialization priority. */
306 priority_type
get_init_priority ();
308 /* Return availability of NODE when referenced from REF. */
309 enum availability
get_availability (symtab_node
*ref
= NULL
);
311 /* During LTO stream-in this predicate can be used to check whether node
312 in question prevails in the linking to save some memory usage. */
313 bool prevailing_p (void);
315 /* Return true if NODE binds to current definition in final executable
316 when referenced from REF. If REF is NULL return conservative value
317 for any reference. */
318 bool binds_to_current_def_p (symtab_node
*ref
= NULL
);
320 /* Make DECL local. */
321 void make_decl_local (void);
323 /* Copy visibility from N. */
324 void copy_visibility_from (symtab_node
*n
);
326 /* Return desired alignment of the definition. This is NOT alignment useful
327 to access THIS, because THIS may be interposable and DECL_ALIGN should
328 be used instead. It however must be guaranteed when output definition
330 unsigned int definition_alignment ();
332 /* Return true if alignment can be increased. */
333 bool can_increase_alignment_p ();
335 /* Increase alignment of symbol to ALIGN. */
336 void increase_alignment (unsigned int align
);
338 /* Return true if list contains an alias. */
339 bool has_aliases_p (void);
341 /* Return true when the symbol is real symbol, i.e. it is not inline clone
342 or abstract function kept for debug info purposes only. */
343 bool real_symbol_p (void);
345 /* Return true when the symbol needs to be output to the LTO symbol table. */
346 bool output_to_lto_symbol_table_p (void);
348 /* Determine if symbol declaration is needed. That is, visible to something
349 either outside this translation unit, something magic in the system
350 configury. This function is used just during symbol creation. */
351 bool needed_p (void);
353 /* Return true if this symbol is a function from the C frontend specified
354 directly in RTL form (with "__RTL"). */
355 bool native_rtl_p () const;
357 /* Return true when there are references to the node. */
358 bool referred_to_p (bool include_self
= true);
360 /* Return true if symbol can be discarded by linker from the binary.
361 Assume that symbol is used (so there is no need to take into account
362 garbage collecting linkers)
364 This can happen for comdats, commons and weaks when they are previaled
365 by other definition at static linking time. */
367 can_be_discarded_p (void)
369 return (DECL_EXTERNAL (decl
)
370 || ((get_comdat_group ()
371 || DECL_COMMON (decl
)
372 || (DECL_SECTION_NAME (decl
) && DECL_WEAK (decl
)))
373 && ((resolution
!= LDPR_PREVAILING_DEF
374 && resolution
!= LDPR_PREVAILING_DEF_IRONLY_EXP
)
375 || flag_incremental_link
)
376 && resolution
!= LDPR_PREVAILING_DEF_IRONLY
));
379 /* Return true if NODE is local to a particular COMDAT group, and must not
380 be named from outside the COMDAT. This is used for C++ decloned
382 inline bool comdat_local_p (void)
384 return (same_comdat_group
&& !TREE_PUBLIC (decl
));
387 /* Return true if ONE and TWO are part of the same COMDAT group. */
388 inline bool in_same_comdat_group_p (symtab_node
*target
);
390 /* Return true if symbol is known to be nonzero. */
391 bool nonzero_address ();
393 /* Return 0 if symbol is known to have different address than S2,
394 Return 1 if symbol is known to have same address as S2,
397 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
398 and S2 is going to be accessed. This eliminates the situations when
399 either THIS or S2 is NULL and is seful for comparing bases when deciding
400 about memory aliasing. */
401 int equal_address_to (symtab_node
*s2
, bool memory_accessed
= false);
403 /* Return true if symbol's address may possibly be compared to other
405 bool address_matters_p ();
407 /* Return true if NODE's address can be compared. This use properties
408 of NODE only and does not look if the address is actually taken in
409 interesting way. For that use ADDRESS_MATTERS_P instead. */
410 bool address_can_be_compared_p (void);
412 /* Return symbol table node associated with DECL, if any,
413 and NULL otherwise. */
414 static inline symtab_node
*get (const_tree decl
)
416 /* Check that we are called for sane type of object - functions
417 and static or external variables. */
418 gcc_checking_assert (TREE_CODE (decl
) == FUNCTION_DECL
419 || (TREE_CODE (decl
) == VAR_DECL
420 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)
422 /* Check that the mapping is sane - perhaps this check can go away,
423 but at the moment frontends tends to corrupt the mapping by calling
424 memcpy/memset on the tree nodes. */
425 gcc_checking_assert (!decl
->decl_with_vis
.symtab_node
426 || decl
->decl_with_vis
.symtab_node
->decl
== decl
);
427 return decl
->decl_with_vis
.symtab_node
;
430 /* Try to find a symtab node for declaration DECL and if it does not
431 exist or if it corresponds to an inline clone, create a new one. */
432 static inline symtab_node
* get_create (tree node
);
434 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
435 Return NULL if there's no such node. */
436 static symtab_node
*get_for_asmname (const_tree asmname
);
438 /* Verify symbol table for internal consistency. */
439 static DEBUG_FUNCTION
void verify_symtab_nodes (void);
441 /* Perform internal consistency checks, if they are enabled. */
442 static inline void checking_verify_symtab_nodes (void);
444 /* Type of the symbol. */
445 ENUM_BITFIELD (symtab_type
) type
: 8;
447 /* The symbols resolution. */
448 ENUM_BITFIELD (ld_plugin_symbol_resolution
) resolution
: 8;
450 /*** Flags representing the symbol type. ***/
452 /* True when symbol corresponds to a definition in current unit.
453 set via finalize_function or finalize_decl */
454 unsigned definition
: 1;
455 /* True when symbol is an alias.
456 Set by ssemble_alias. */
458 /* When true the alias is translated into its target symbol either by GCC
459 or assembler (it also may just be a duplicate declaration of the same
462 Currently transparent aliases come in three different flavors
463 - aliases having the same assembler name as their target (aka duplicated
464 declarations). In this case the assembler names compare via
465 assembler_names_equal_p and weakref is false
466 - aliases that are renamed at a time being output to final file
467 by varasm.c. For those DECL_ASSEMBLER_NAME have
468 IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
470 Weakrefs belong to this cateogry when we target assembler without
472 - weakrefs that are renamed by assembler via .weakref directive.
473 In this case the alias may or may not be definition (depending if
474 target declaration was seen by the compiler), weakref is set.
475 Unless we are before renaming statics, assembler names are different.
477 Given that we now support duplicate declarations, the second option is
478 redundant and will be removed. */
479 unsigned transparent_alias
: 1;
480 /* True when alias is a weakref. */
481 unsigned weakref
: 1;
482 /* C++ frontend produce same body aliases and extra name aliases for
483 virtual functions and vtables that are obviously equivalent.
484 Those aliases are bit special, especially because C++ frontend
485 visibility code is so ugly it can not get them right at first time
486 and their visibility needs to be copied from their "masters" at
487 the end of parsing. */
488 unsigned cpp_implicit_alias
: 1;
489 /* Set once the definition was analyzed. The list of references and
490 other properties are built during analysis. */
491 unsigned analyzed
: 1;
492 /* Set for write-only variables. */
493 unsigned writeonly
: 1;
494 /* Visibility of symbol was used for further optimization; do not
495 permit further changes. */
496 unsigned refuse_visibility_changes
: 1;
498 /*** Visibility and linkage flags. ***/
500 /* Set when function is visible by other units. */
501 unsigned externally_visible
: 1;
502 /* Don't reorder to other symbols having this set. */
503 unsigned no_reorder
: 1;
504 /* The symbol will be assumed to be used in an invisible way (like
505 by an toplevel asm statement). */
506 unsigned force_output
: 1;
507 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
508 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
509 to static and it does not inhibit optimization. */
510 unsigned forced_by_abi
: 1;
511 /* True when the name is known to be unique and thus it does not need mangling. */
512 unsigned unique_name
: 1;
513 /* Specify whether the section was set by user or by
514 compiler via -ffunction-sections. */
515 unsigned implicit_section
: 1;
516 /* True when body and other characteristics have been removed by
517 symtab_remove_unreachable_nodes. */
518 unsigned body_removed
: 1;
520 /*** WHOPR Partitioning flags.
521 These flags are used at ltrans stage when only part of the callgraph is
524 /* Set when variable is used from other LTRANS partition. */
525 unsigned used_from_other_partition
: 1;
526 /* Set when function is available in the other LTRANS partition.
527 During WPA output it is used to mark nodes that are present in
528 multiple partitions. */
529 unsigned in_other_partition
: 1;
533 /*** other flags. ***/
535 /* Set when symbol has address taken. */
536 unsigned address_taken
: 1;
537 /* Set when init priority is set. */
538 unsigned in_init_priority_hash
: 1;
540 /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
541 of offloading, for separate compilation for a different target. */
542 unsigned need_lto_streaming
: 1;
544 /* Set when symbol can be streamed into bytecode for offloading. */
545 unsigned offloadable
: 1;
547 /* Set when symbol is an IFUNC resolver. */
548 unsigned ifunc_resolver
: 1;
551 /* Ordering of all symtab entries. */
554 /* Declaration representing the symbol. */
557 /* Linked list of symbol table entries starting with symtab_nodes. */
559 symtab_node
*previous
;
561 /* Linked list of symbols with the same asm name. There may be multiple
562 entries for single symbol name during LTO, because symbols are renamed
563 only after partitioning.
565 Because inline clones are kept in the assembler name has, they also produce
568 There are also several long standing bugs where frontends and builtin
569 code produce duplicated decls. */
570 symtab_node
*next_sharing_asm_name
;
571 symtab_node
*previous_sharing_asm_name
;
573 /* Circular list of nodes in the same comdat group if non-NULL. */
574 symtab_node
*same_comdat_group
;
576 /* Vectors of referring and referenced entities. */
577 ipa_ref_list ref_list
;
579 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
580 depending to what was known to frontend on the creation time.
581 Once alias is resolved, this pointer become NULL. */
584 /* File stream where this node is being written to. */
585 struct lto_file_decl_data
* lto_file_data
;
587 PTR
GTY ((skip
)) aux
;
589 /* Comdat group the symbol is in. Can be private if GGC allowed that. */
592 /* Section name. Again can be private, if allowed. */
593 section_hash_entry
*x_section
;
596 /* Dump base fields of symtab nodes to F. Not to be used directly. */
597 void dump_base (FILE *);
599 /* Verify common part of symtab node. */
600 bool DEBUG_FUNCTION
verify_base (void);
602 /* Remove node from symbol table. This function is not used directly, but via
603 cgraph/varpool node removal routines. */
604 void unregister (void);
606 /* Return the initialization and finalization priority information for
607 DECL. If there is no previous priority information, a freshly
608 allocated structure is returned. */
609 struct symbol_priority_map
*priority_info (void);
611 /* Worker for call_for_symbol_and_aliases_1. */
612 bool call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*, void *),
614 bool include_overwrite
);
616 /* Worker for set_section. */
617 static bool set_section (symtab_node
*n
, void *s
);
619 /* Worker for symtab_resolve_alias. */
620 static bool set_implicit_section (symtab_node
*n
, void *);
622 /* Worker searching noninterposable alias. */
623 static bool noninterposable_alias (symtab_node
*node
, void *data
);
625 /* Worker for ultimate_alias_target. */
626 symtab_node
*ultimate_alias_target_1 (enum availability
*avail
= NULL
,
627 symtab_node
*ref
= NULL
);
629 /* Get dump name with normal or assembly name. */
630 const char *get_dump_name (bool asm_name_p
) const;
634 symtab_node::checking_verify_symtab_nodes (void)
637 symtab_node::verify_symtab_nodes ();
640 /* Walk all aliases for NODE. */
641 #define FOR_EACH_ALIAS(node, alias) \
642 for (unsigned x_i = 0; node->iterate_direct_aliases (x_i, alias); x_i++)
644 /* This is the information that is put into the cgraph local structure
645 to recover a function. */
646 struct lto_file_decl_data
;
648 extern const char * const cgraph_availability_names
[];
649 extern const char * const ld_plugin_symbol_resolution_names
[];
650 extern const char * const tls_model_names
[];
652 /* Sub-structure of cgraph_node. Holds information about thunk, used only for
655 Thunks are basically wrappers around methods which are introduced in case
656 of multiple inheritance in order to adjust the value of the "this" pointer
657 or of the returned value.
659 In the case of this-adjusting thunks, each back-end can override the
660 can_output_mi_thunk/output_mi_thunk target hooks to generate a minimal thunk
661 (with a tail call for instance) directly as assembly. For the default hook
662 or for the case where the can_output_mi_thunk hooks return false, the thunk
663 is gimplified and lowered using the regular machinery. */
665 struct GTY(()) cgraph_thunk_info
{
666 /* Offset used to adjust "this". */
667 HOST_WIDE_INT fixed_offset
;
669 /* Offset in the virtual table to get the offset to adjust "this". Valid iff
670 VIRTUAL_OFFSET_P is true. */
671 HOST_WIDE_INT virtual_value
;
673 /* Offset from "this" to get the offset to adjust "this". Zero means: this
674 offset is to be ignored. */
675 HOST_WIDE_INT indirect_offset
;
677 /* Thunk target, i.e. the method that this thunk wraps. Depending on the
678 TARGET_USE_LOCAL_THUNK_ALIAS_P macro, this may have to be a new alias. */
681 /* Nonzero for a "this" adjusting thunk and zero for a result adjusting
685 /* If true, this thunk is what we call a virtual thunk. In this case:
686 * for this-adjusting thunks, after the FIXED_OFFSET based adjustment is
687 done, add to the result the offset found in the vtable at:
689 * for result-adjusting thunks, the FIXED_OFFSET adjustment is done after
691 bool virtual_offset_p
;
693 /* ??? True for special kind of thunks, seems related to instrumentation. */
694 bool add_pointer_bounds_args
;
696 /* Set to true when alias node (the cgraph_node to which this struct belong)
697 is a thunk. Access to any other fields is invalid if this is false. */
701 /* Information about the function collected locally.
702 Available after function is analyzed. */
704 struct GTY(()) cgraph_local_info
{
705 /* Set when function is visible in current compilation unit only and
706 its address is never taken. */
709 /* False when there is something makes versioning impossible. */
710 unsigned versionable
: 1;
712 /* False when function calling convention and signature can not be changed.
713 This is the case when __builtin_apply_args is used. */
714 unsigned can_change_signature
: 1;
716 /* True when the function has been originally extern inline, but it is
718 unsigned redefined_extern_inline
: 1;
720 /* True if the function may enter serial irrevocable mode. */
721 unsigned tm_may_enter_irr
: 1;
724 /* Information about the function that needs to be computed globally
725 once compilation is finished. Available only with -funit-at-a-time. */
727 struct GTY(()) cgraph_global_info
{
728 /* For inline clones this points to the function they will be
730 cgraph_node
*inlined_to
;
733 /* Represent which DECL tree (or reference to such tree)
734 will be replaced by another tree while versioning. */
735 struct GTY(()) ipa_replace_map
737 /* The tree that will be replaced. */
739 /* The new (replacing) tree. */
741 /* Parameter number to replace, when old_tree is NULL. */
743 /* True when a substitution should be done, false otherwise. */
745 /* True when we replace a reference to old_tree. */
749 struct GTY(()) cgraph_clone_info
751 vec
<ipa_replace_map
*, va_gc
> *tree_map
;
753 bitmap combined_args_to_skip
;
756 enum cgraph_simd_clone_arg_type
758 SIMD_CLONE_ARG_TYPE_VECTOR
,
759 SIMD_CLONE_ARG_TYPE_UNIFORM
,
760 /* These are only for integer/pointer arguments passed by value. */
761 SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP
,
762 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP
,
763 /* These 6 are only for reference type arguments or arguments passed
765 SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP
,
766 SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP
,
767 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP
,
768 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP
,
769 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP
,
770 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP
,
771 SIMD_CLONE_ARG_TYPE_MASK
774 /* Function arguments in the original function of a SIMD clone.
775 Supplementary data for `struct simd_clone'. */
777 struct GTY(()) cgraph_simd_clone_arg
{
778 /* Original function argument as it originally existed in
782 /* orig_arg's function (or for extern functions type from
786 /* If argument is a vector, this holds the vector version of
787 orig_arg that after adjusting the argument types will live in
788 DECL_ARGUMENTS. Otherwise, this is NULL.
790 This basically holds:
791 vector(simdlen) __typeof__(orig_arg) new_arg. */
794 /* vector_arg's type (or for extern functions new vector type. */
797 /* If argument is a vector, this holds the array where the simd
798 argument is held while executing the simd clone function. This
799 is a local variable in the cloned function. Its content is
800 copied from vector_arg upon entry to the clone.
802 This basically holds:
803 __typeof__(orig_arg) simd_array[simdlen]. */
806 /* A SIMD clone's argument can be either linear (constant or
807 variable), uniform, or vector. */
808 enum cgraph_simd_clone_arg_type arg_type
;
810 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
811 the constant linear step, if arg_type is
812 SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
813 the uniform argument holding the step, otherwise 0. */
814 HOST_WIDE_INT linear_step
;
816 /* Variable alignment if available, otherwise 0. */
817 unsigned int alignment
;
820 /* Specific data for a SIMD function clone. */
822 struct GTY(()) cgraph_simd_clone
{
823 /* Number of words in the SIMD lane associated with this clone. */
824 unsigned int simdlen
;
826 /* Number of annotated function arguments in `args'. This is
827 usually the number of named arguments in FNDECL. */
830 /* Max hardware vector size in bits for integral vectors. */
831 unsigned int vecsize_int
;
833 /* Max hardware vector size in bits for floating point vectors. */
834 unsigned int vecsize_float
;
836 /* Machine mode of the mask argument(s), if they are to be passed
837 as bitmasks in integer argument(s). VOIDmode if masks are passed
838 as vectors of characteristic type. */
839 machine_mode mask_mode
;
841 /* The mangling character for a given vector size. This is used
842 to determine the ISA mangling bit as specified in the Intel
844 unsigned char vecsize_mangle
;
846 /* True if this is the masked, in-branch version of the clone,
848 unsigned int inbranch
: 1;
850 /* Doubly linked list of SIMD clones. */
851 cgraph_node
*prev_clone
, *next_clone
;
853 /* Original cgraph node the SIMD clones were created for. */
856 /* Annotated function arguments for the original function. */
857 cgraph_simd_clone_arg
GTY((length ("%h.nargs"))) args
[1];
860 /* Function Multiversioning info. */
861 struct GTY((for_user
)) cgraph_function_version_info
{
862 /* The cgraph_node for which the function version info is stored. */
863 cgraph_node
*this_node
;
864 /* Chains all the semantically identical function versions. The
865 first function in this chain is the version_info node of the
867 cgraph_function_version_info
*prev
;
868 /* If this version node corresponds to a dispatcher for function
869 versions, this points to the version info node of the default
870 function, the first node in the chain. */
871 cgraph_function_version_info
*next
;
872 /* If this node corresponds to a function version, this points
873 to the dispatcher function decl, which is the function that must
874 be called to execute the right function version at run-time.
876 If this cgraph node is a dispatcher (if dispatcher_function is
877 true, in the cgraph_node struct) for function versions, this
878 points to resolver function, which holds the function body of the
879 dispatcher. The dispatcher decl is an alias to the resolver
881 tree dispatcher_resolver
;
884 #define DEFCIFCODE(code, type, string) CIF_ ## code,
885 /* Reasons for inlining failures. */
887 enum cgraph_inline_failed_t
{
888 #include "cif-code.def"
892 enum cgraph_inline_failed_type_t
894 CIF_FINAL_NORMAL
= 0,
900 struct cgraph_edge_hasher
: ggc_ptr_hash
<cgraph_edge
>
902 typedef gimple
*compare_type
;
904 static hashval_t
hash (cgraph_edge
*);
905 static hashval_t
hash (gimple
*);
906 static bool equal (cgraph_edge
*, gimple
*);
909 /* The cgraph data structure.
910 Each function decl has assigned cgraph_node listing callees and callers. */
912 struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node
: public symtab_node
{
914 friend class symbol_table
;
916 /* Remove the node from cgraph and all inline clones inlined into it.
917 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
918 removed. This allows to call the function from outer loop walking clone
920 bool remove_symbol_and_inline_clones (cgraph_node
*forbidden_node
= NULL
);
922 /* Record all references from cgraph_node that are taken
923 in statement STMT. */
924 void record_stmt_references (gimple
*stmt
);
926 /* Like cgraph_set_call_stmt but walk the clone tree and update all
927 clones sharing the same function body.
928 When WHOLE_SPECULATIVE_EDGES is true, all three components of
929 speculative edge gets updated. Otherwise we update only direct
931 void set_call_stmt_including_clones (gimple
*old_stmt
, gcall
*new_stmt
,
932 bool update_speculative
= true);
934 /* Walk the alias chain to return the function cgraph_node is alias of.
935 Walk through thunk, too.
936 When AVAILABILITY is non-NULL, get minimal availability in the chain.
937 When REF is non-NULL, assume that reference happens in symbol REF
938 when determining the availability. */
939 cgraph_node
*function_symbol (enum availability
*avail
= NULL
,
940 struct symtab_node
*ref
= NULL
);
942 /* Walk the alias chain to return the function cgraph_node is alias of.
943 Walk through non virtual thunks, too. Thus we return either a function
944 or a virtual thunk node.
945 When AVAILABILITY is non-NULL, get minimal availability in the chain.
946 When REF is non-NULL, assume that reference happens in symbol REF
947 when determining the availability. */
948 cgraph_node
*function_or_virtual_thunk_symbol
949 (enum availability
*avail
= NULL
,
950 struct symtab_node
*ref
= NULL
);
952 /* Create node representing clone of N executed COUNT times. Decrease
953 the execution counts from original node too.
954 The new clone will have decl set to DECL that may or may not be the same
957 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
958 function's profile to reflect the fact that part of execution is handled
960 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
961 the new clone. Otherwise the caller is responsible for doing so later.
963 If the new node is being inlined into another one, NEW_INLINED_TO should be
964 the outline function the new one is (even indirectly) inlined to.
965 All hooks will see this in node's global.inlined_to, when invoked.
966 Can be NULL if the node is not inlined. SUFFIX is string that is appended
967 to the original name. */
968 cgraph_node
*create_clone (tree decl
, profile_count count
,
969 bool update_original
,
970 vec
<cgraph_edge
*> redirect_callers
,
971 bool call_duplication_hook
,
972 cgraph_node
*new_inlined_to
,
973 bitmap args_to_skip
, const char *suffix
= NULL
);
975 /* Create callgraph node clone with new declaration. The actual body will be
976 copied later at compilation stage. The name of the new clone will be
977 constructed from the name of the original node, SUFFIX and NUM_SUFFIX. */
978 cgraph_node
*create_virtual_clone (vec
<cgraph_edge
*> redirect_callers
,
979 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
980 bitmap args_to_skip
, const char * suffix
,
981 unsigned num_suffix
);
983 /* cgraph node being removed from symbol table; see if its entry can be
984 replaced by other inline clone. */
985 cgraph_node
*find_replacement (void);
987 /* Create a new cgraph node which is the new version of
988 callgraph node. REDIRECT_CALLERS holds the callers
989 edges which should be redirected to point to
990 NEW_VERSION. ALL the callees edges of the node
991 are cloned to the new version node. Return the new
994 If non-NULL BLOCK_TO_COPY determine what basic blocks
995 was copied to prevent duplications of calls that are dead
998 SUFFIX is string that is appended to the original name. */
1000 cgraph_node
*create_version_clone (tree new_decl
,
1001 vec
<cgraph_edge
*> redirect_callers
,
1003 const char *suffix
= NULL
);
1005 /* Perform function versioning.
1006 Function versioning includes copying of the tree and
1007 a callgraph update (creating a new cgraph node and updating
1008 its callees and callers).
1010 REDIRECT_CALLERS varray includes the edges to be redirected
1013 TREE_MAP is a mapping of tree nodes we want to replace with
1014 new ones (according to results of prior analysis).
1016 If non-NULL ARGS_TO_SKIP determine function parameters to remove
1018 If SKIP_RETURN is true, the new version will return void.
1019 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
1020 If non_NULL NEW_ENTRY determine new entry BB of the clone.
1022 Return the new version's cgraph node. */
1023 cgraph_node
*create_version_clone_with_body
1024 (vec
<cgraph_edge
*> redirect_callers
,
1025 vec
<ipa_replace_map
*, va_gc
> *tree_map
, bitmap args_to_skip
,
1026 bool skip_return
, bitmap bbs_to_copy
, basic_block new_entry_block
,
1027 const char *clone_name
);
1029 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
1030 corresponding to cgraph_node. */
1031 cgraph_function_version_info
*insert_new_function_version (void);
1033 /* Get the cgraph_function_version_info node corresponding to node. */
1034 cgraph_function_version_info
*function_version (void);
1036 /* Discover all functions and variables that are trivially needed, analyze
1037 them as well as all functions and variables referred by them */
1038 void analyze (void);
1040 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
1041 aliases DECL with an adjustments made into the first parameter.
1042 See comments in struct cgraph_thunk_info for detail on the parameters. */
1043 cgraph_node
* create_thunk (tree alias
, tree
, bool this_adjusting
,
1044 HOST_WIDE_INT fixed_offset
,
1045 HOST_WIDE_INT virtual_value
,
1046 HOST_WIDE_INT indirect_offset
,
1047 tree virtual_offset
,
1051 /* Return node that alias is aliasing. */
1052 inline cgraph_node
*get_alias_target (void);
1054 /* Given function symbol, walk the alias chain to return the function node
1055 is alias of. Do not walk through thunks.
1056 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1057 When REF is non-NULL, assume that reference happens in symbol REF
1058 when determining the availability. */
1060 cgraph_node
*ultimate_alias_target (availability
*availability
= NULL
,
1061 symtab_node
*ref
= NULL
);
1063 /* Expand thunk NODE to gimple if possible.
1064 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1065 no assembler is produced.
1066 When OUTPUT_ASM_THUNK is true, also produce assembler for
1067 thunks that are not lowered. */
1068 bool expand_thunk (bool output_asm_thunks
, bool force_gimple_thunk
);
1070 /* Call expand_thunk on all callers that are thunks and analyze those
1071 nodes that were expanded. */
1072 void expand_all_artificial_thunks ();
1074 /* Assemble thunks and aliases associated to node. */
1075 void assemble_thunks_and_aliases (void);
1077 /* Expand function specified by node. */
1080 /* As an GCC extension we allow redefinition of the function. The
1081 semantics when both copies of bodies differ is not well defined.
1082 We replace the old body with new body so in unit at a time mode
1083 we always use new body, while in normal mode we may end up with
1084 old body inlined into some functions and new body expanded and
1085 inlined in others. */
1088 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
1089 kind of wrapper method. */
1090 void create_wrapper (cgraph_node
*target
);
1092 /* Verify cgraph nodes of the cgraph node. */
1093 void DEBUG_FUNCTION
verify_node (void);
1095 /* Remove function from symbol table. */
1098 /* Dump call graph node to file F. */
1099 void dump (FILE *f
);
1101 /* Dump call graph node to stderr. */
1102 void DEBUG_FUNCTION
debug (void);
1104 /* When doing LTO, read cgraph_node's body from disk if it is not already
1106 bool get_untransformed_body (void);
1108 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
1109 if it is not already present. When some IPA transformations are scheduled,
1111 bool get_body (void);
1113 /* Release memory used to represent body of function.
1114 Use this only for functions that are released before being translated to
1115 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1116 are free'd in final.c via free_after_compilation(). */
1117 void release_body (bool keep_arguments
= false);
1119 /* Return the DECL_STRUCT_FUNCTION of the function. */
1120 struct function
*get_fun (void);
1122 /* cgraph_node is no longer nested function; update cgraph accordingly. */
1125 /* Bring cgraph node local. */
1126 void make_local (void);
1128 /* Likewise indicate that a node is having address taken. */
1129 void mark_address_taken (void);
1131 /* Set fialization priority to PRIORITY. */
1132 void set_fini_priority (priority_type priority
);
1134 /* Return the finalization priority. */
1135 priority_type
get_fini_priority (void);
1137 /* Create edge from a given function to CALLEE in the cgraph. */
1138 cgraph_edge
*create_edge (cgraph_node
*callee
,
1139 gcall
*call_stmt
, profile_count count
);
1141 /* Create an indirect edge with a yet-undetermined callee where the call
1142 statement destination is a formal parameter of the caller with index
1144 cgraph_edge
*create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
1145 profile_count count
,
1146 bool compute_indirect_info
= true);
1148 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
1149 same function body. If clones already have edge for OLD_STMT; only
1150 update the edge same way as cgraph_set_call_stmt_including_clones does. */
1151 void create_edge_including_clones (cgraph_node
*callee
,
1152 gimple
*old_stmt
, gcall
*stmt
,
1153 profile_count count
,
1154 cgraph_inline_failed_t reason
);
1156 /* Return the callgraph edge representing the GIMPLE_CALL statement
1158 cgraph_edge
*get_edge (gimple
*call_stmt
);
1160 /* Collect all callers of cgraph_node and its aliases that are known to lead
1161 to NODE (i.e. are not overwritable) and that are not thunks. */
1162 vec
<cgraph_edge
*> collect_callers (void);
1164 /* Remove all callers from the node. */
1165 void remove_callers (void);
1167 /* Remove all callees from the node. */
1168 void remove_callees (void);
1170 /* Return function availability. See cgraph.h for description of individual
1172 enum availability
get_availability (symtab_node
*ref
= NULL
);
1174 /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
1175 if any to NOTHROW. */
1176 bool set_nothrow_flag (bool nothrow
);
1178 /* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node
1180 bool set_malloc_flag (bool malloc_p
);
1182 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
1183 If SET_CONST if false, clear the flag.
1185 When setting the flag be careful about possible interposition and
1186 do not set the flag for functions that can be interposet and set pure
1187 flag for functions that can bind to other definition.
1189 Return true if any change was done. */
1191 bool set_const_flag (bool set_const
, bool looping
);
1193 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
1196 When setting the flag, be careful about possible interposition.
1197 Return true if any change was done. */
1199 bool set_pure_flag (bool pure
, bool looping
);
1201 /* Call callback on function and aliases associated to the function.
1202 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1205 bool call_for_symbol_and_aliases (bool (*callback
) (cgraph_node
*,
1207 void *data
, bool include_overwritable
);
1209 /* Call callback on cgraph_node, thunks and aliases associated to NODE.
1210 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1211 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
1213 bool call_for_symbol_thunks_and_aliases (bool (*callback
) (cgraph_node
*node
,
1216 bool include_overwritable
,
1217 bool exclude_virtual_thunks
= false);
1219 /* Likewise indicate that a node is needed, i.e. reachable via some
1221 inline void mark_force_output (void);
1223 /* Return true when function can be marked local. */
1224 bool local_p (void);
1226 /* Return true if cgraph_node can be made local for API change.
1227 Extern inline functions and C++ COMDAT functions can be made local
1228 at the expense of possible code size growth if function is used in multiple
1229 compilation units. */
1230 bool can_be_local_p (void);
1232 /* Return true when cgraph_node can not return or throw and thus
1233 it is safe to ignore its side effects for IPA analysis. */
1234 bool cannot_return_p (void);
1236 /* Return true when function cgraph_node and all its aliases are only called
1238 i.e. it is not externally visible, address was not taken and
1239 it is not used in any other non-standard way. */
1240 bool only_called_directly_p (void);
1242 /* Return true when function is only called directly or it has alias.
1243 i.e. it is not externally visible, address was not taken and
1244 it is not used in any other non-standard way. */
1245 inline bool only_called_directly_or_aliased_p (void);
1247 /* Return true when function cgraph_node can be expected to be removed
1248 from program when direct calls in this compilation unit are removed.
1250 As a special case COMDAT functions are
1251 cgraph_can_remove_if_no_direct_calls_p while the are not
1252 cgraph_only_called_directly_p (it is possible they are called from other
1255 This function behaves as cgraph_only_called_directly_p because eliminating
1256 all uses of COMDAT function does not make it necessarily disappear from
1257 the program unless we are compiling whole program or we do LTO. In this
1258 case we know we win since dynamic linking will not really discard the
1261 If WILL_INLINE is true, assume that function will be inlined into all the
1263 bool will_be_removed_from_program_if_no_direct_calls_p
1264 (bool will_inline
= false);
1266 /* Return true when function can be removed from callgraph
1267 if all direct calls and references are eliminated. The function does
1268 not take into account comdat groups. */
1269 bool can_remove_if_no_direct_calls_and_refs_p (void);
1271 /* Return true when function cgraph_node and its aliases can be removed from
1272 callgraph if all direct calls are eliminated.
1273 If WILL_INLINE is true, assume that function will be inlined into all the
1275 bool can_remove_if_no_direct_calls_p (bool will_inline
= false);
1277 /* Return true when callgraph node is a function with Gimple body defined
1278 in current unit. Functions can also be define externally or they
1279 can be thunks with no Gimple representation.
1281 Note that at WPA stage, the function body may not be present in memory. */
1282 inline bool has_gimple_body_p (void);
1284 /* Return true if function should be optimized for size. */
1285 bool optimize_for_size_p (void);
1287 /* Dump the callgraph to file F. */
1288 static void dump_cgraph (FILE *f
);
1290 /* Dump the call graph to stderr. */
1292 void debug_cgraph (void)
1294 dump_cgraph (stderr
);
1297 /* Get unique identifier of the node. */
1298 inline int get_uid ()
1303 /* Record that DECL1 and DECL2 are semantically identical function
1305 static void record_function_versions (tree decl1
, tree decl2
);
1307 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
1308 DECL is a duplicate declaration. */
1309 static void delete_function_version_by_decl (tree decl
);
1311 /* Add the function FNDECL to the call graph.
1312 Unlike finalize_function, this function is intended to be used
1313 by middle end and allows insertion of new function at arbitrary point
1314 of compilation. The function can be either in high, low or SSA form
1317 The function is assumed to be reachable and have address taken (so no
1318 API breaking optimizations are performed on it).
1320 Main work done by this function is to enqueue the function for later
1321 processing to avoid need the passes to be re-entrant. */
1322 static void add_new_function (tree fndecl
, bool lowered
);
1324 /* Return callgraph node for given symbol and check it is a function. */
1325 static inline cgraph_node
*get (const_tree decl
)
1327 gcc_checking_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1328 return dyn_cast
<cgraph_node
*> (symtab_node::get (decl
));
1331 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
1332 logic in effect. If NO_COLLECT is true, then our caller cannot stand to
1333 have the garbage collector run at the moment. We would need to either
1334 create a new GC context, or just not compile right now. */
1335 static void finalize_function (tree
, bool);
1337 /* Return cgraph node assigned to DECL. Create new one when needed. */
1338 static cgraph_node
* create (tree decl
);
1340 /* Try to find a call graph node for declaration DECL and if it does not
1341 exist or if it corresponds to an inline clone, create a new one. */
1342 static cgraph_node
* get_create (tree
);
1344 /* Return local info for the compiled function. */
1345 static cgraph_local_info
*local_info (tree decl
);
1347 /* Return local info for the compiled function. */
1348 static struct cgraph_rtl_info
*rtl_info (tree
);
1350 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1351 Return NULL if there's no such node. */
1352 static cgraph_node
*get_for_asmname (tree asmname
);
1354 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if
1355 successful and NULL otherwise.
1356 Same body aliases are output whenever the body of DECL is output,
1357 and cgraph_node::get (ALIAS) transparently
1358 returns cgraph_node::get (DECL). */
1359 static cgraph_node
* create_same_body_alias (tree alias
, tree decl
);
1361 /* Verify whole cgraph structure. */
1362 static void DEBUG_FUNCTION
verify_cgraph_nodes (void);
1364 /* Verify cgraph, if consistency checking is enabled. */
1365 static inline void checking_verify_cgraph_nodes (void);
1367 /* Worker to bring NODE local. */
1368 static bool make_local (cgraph_node
*node
, void *);
1370 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
1371 the function body is associated
1372 with (not necessarily cgraph_node (DECL). */
1373 static cgraph_node
*create_alias (tree alias
, tree target
);
1375 /* Return true if NODE has thunk. */
1376 static bool has_thunk_p (cgraph_node
*node
, void *);
1378 cgraph_edge
*callees
;
1379 cgraph_edge
*callers
;
1380 /* List of edges representing indirect calls with a yet undetermined
1382 cgraph_edge
*indirect_calls
;
1383 /* For nested functions points to function the node is nested in. */
1384 cgraph_node
*origin
;
1385 /* Points to first nested function, if any. */
1386 cgraph_node
*nested
;
1387 /* Pointer to the next function with same origin, if any. */
1388 cgraph_node
*next_nested
;
1389 /* Pointer to the next clone. */
1390 cgraph_node
*next_sibling_clone
;
1391 cgraph_node
*prev_sibling_clone
;
1392 cgraph_node
*clones
;
1393 cgraph_node
*clone_of
;
1394 /* For functions with many calls sites it holds map from call expression
1395 to the edge to speed up cgraph_edge function. */
1396 hash_table
<cgraph_edge_hasher
> *GTY(()) call_site_hash
;
1397 /* Declaration node used to be clone of. */
1398 tree former_clone_of
;
1400 /* If this is a SIMD clone, this points to the SIMD specific
1401 information for it. */
1402 cgraph_simd_clone
*simdclone
;
1403 /* If this function has SIMD clones, this points to the first clone. */
1404 cgraph_node
*simd_clones
;
1406 /* Interprocedural passes scheduled to have their transform functions
1407 applied next time we execute local pass on them. We maintain it
1408 per-function in order to allow IPA passes to introduce new functions. */
1409 vec
<ipa_opt_pass
> GTY((skip
)) ipa_transforms_to_apply
;
1411 cgraph_local_info local
;
1412 cgraph_global_info global
;
1413 struct cgraph_rtl_info
*rtl
;
1414 cgraph_clone_info clone
;
1415 cgraph_thunk_info thunk
;
1417 /* Expected number of executions: calculated in profile.c. */
1418 profile_count count
;
1419 /* How to scale counts at materialization time; used to merge
1420 LTO units with different number of profile runs. */
1421 int count_materialization_scale
;
1422 /* ID assigned by the profiling. */
1423 unsigned int profile_id
;
1424 /* Time profiler: first run of function. */
1427 /* Set when decl is an abstract function pointed to by the
1428 ABSTRACT_DECL_ORIGIN of a reachable function. */
1429 unsigned used_as_abstract_origin
: 1;
1430 /* Set once the function is lowered (i.e. its CFG is built). */
1431 unsigned lowered
: 1;
1432 /* Set once the function has been instantiated and its callee
1434 unsigned process
: 1;
1435 /* How commonly executed the node is. Initialized during branch
1436 probabilities pass. */
1437 ENUM_BITFIELD (node_frequency
) frequency
: 2;
1438 /* True when function can only be called at startup (from static ctor). */
1439 unsigned only_called_at_startup
: 1;
1440 /* True when function can only be called at startup (from static dtor). */
1441 unsigned only_called_at_exit
: 1;
1442 /* True when function is the transactional clone of a function which
1443 is called only from inside transactions. */
1444 /* ?? We should be able to remove this. We have enough bits in
1445 cgraph to calculate it. */
1446 unsigned tm_clone
: 1;
1447 /* True if this decl is a dispatcher for function versions. */
1448 unsigned dispatcher_function
: 1;
1449 /* True if this decl calls a COMDAT-local function. This is set up in
1450 compute_fn_summary and inline_call. */
1451 unsigned calls_comdat_local
: 1;
1452 /* True if node has been created by merge operation in IPA-ICF. */
1453 unsigned icf_merged
: 1;
1454 /* True if call to node can't result in a call to free, munmap or
1455 other operation that could make previously non-trapping memory
1456 accesses trapping. */
1457 unsigned nonfreeing_fn
: 1;
1458 /* True if there was multiple COMDAT bodies merged by lto-symtab. */
1459 unsigned merged_comdat
: 1;
1460 /* True if function was created to be executed in parallel. */
1461 unsigned parallelized_function
: 1;
1462 /* True if function is part split out by ipa-split. */
1463 unsigned split_part
: 1;
1464 /* True if the function appears as possible target of indirect call. */
1465 unsigned indirect_call_target
: 1;
1468 /* Unique id of the node. */
1471 /* Worker for call_for_symbol_and_aliases. */
1472 bool call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
1474 void *data
, bool include_overwritable
);
1477 /* A cgraph node set is a collection of cgraph nodes. A cgraph node
1478 can appear in multiple sets. */
1479 struct cgraph_node_set_def
1481 hash_map
<cgraph_node
*, size_t> *map
;
1482 vec
<cgraph_node
*> nodes
;
1485 typedef cgraph_node_set_def
*cgraph_node_set
;
1486 typedef struct varpool_node_set_def
*varpool_node_set
;
1490 /* A varpool node set is a collection of varpool nodes. A varpool node
1491 can appear in multiple sets. */
1492 struct varpool_node_set_def
1494 hash_map
<varpool_node
*, size_t> * map
;
1495 vec
<varpool_node
*> nodes
;
1498 /* Iterator structure for cgraph node sets. */
1499 struct cgraph_node_set_iterator
1501 cgraph_node_set set
;
1505 /* Iterator structure for varpool node sets. */
1506 struct varpool_node_set_iterator
1508 varpool_node_set set
;
1512 /* Context of polymorphic call. It represent information about the type of
1513 instance that may reach the call. This is used by ipa-devirt walkers of the
1514 type inheritance graph. */
1516 class GTY(()) ipa_polymorphic_call_context
{
1518 /* The called object appears in an object of type OUTER_TYPE
1519 at offset OFFSET. When information is not 100% reliable, we
1520 use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
1521 HOST_WIDE_INT offset
;
1522 HOST_WIDE_INT speculative_offset
;
1524 tree speculative_outer_type
;
1525 /* True if outer object may be in construction or destruction. */
1526 unsigned maybe_in_construction
: 1;
1527 /* True if outer object may be of derived type. */
1528 unsigned maybe_derived_type
: 1;
1529 /* True if speculative outer object may be of derived type. We always
1530 speculate that construction does not happen. */
1531 unsigned speculative_maybe_derived_type
: 1;
1532 /* True if the context is invalid and all calls should be redirected
1533 to BUILTIN_UNREACHABLE. */
1534 unsigned invalid
: 1;
1535 /* True if the outer type is dynamic. */
1536 unsigned dynamic
: 1;
1538 /* Build empty "I know nothing" context. */
1539 ipa_polymorphic_call_context ();
1540 /* Build polymorphic call context for indirect call E. */
1541 ipa_polymorphic_call_context (cgraph_edge
*e
);
1542 /* Build polymorphic call context for IP invariant CST.
1543 If specified, OTR_TYPE specify the type of polymorphic call
1544 that takes CST+OFFSET as a prameter. */
1545 ipa_polymorphic_call_context (tree cst
, tree otr_type
= NULL
,
1546 HOST_WIDE_INT offset
= 0);
1547 /* Build context for pointer REF contained in FNDECL at statement STMT.
1548 if INSTANCE is non-NULL, return pointer to the object described by
1550 ipa_polymorphic_call_context (tree fndecl
, tree ref
, gimple
*stmt
,
1551 tree
*instance
= NULL
);
1553 /* Look for vtable stores or constructor calls to work out dynamic type
1554 of memory location. */
1555 bool get_dynamic_type (tree
, tree
, tree
, gimple
*);
1557 /* Make context non-speculative. */
1558 void clear_speculation ();
1560 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
1561 NULL, the context is set to dummy "I know nothing" setting. */
1562 void clear_outer_type (tree otr_type
= NULL
);
1564 /* Walk container types and modify context to point to actual class
1565 containing OTR_TYPE (if non-NULL) as base class.
1566 Return true if resulting context is valid.
1568 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
1569 valid only via allocation of new polymorphic type inside by means
1572 When CONSIDER_BASES is false, only look for actual fields, not base types
1574 bool restrict_to_inner_class (tree otr_type
,
1575 bool consider_placement_new
= true,
1576 bool consider_bases
= true);
1578 /* Adjust all offsets in contexts by given number of bits. */
1579 void offset_by (HOST_WIDE_INT
);
1580 /* Use when we can not track dynamic type change. This speculatively assume
1581 type change is not happening. */
1582 void possible_dynamic_type_change (bool, tree otr_type
= NULL
);
1583 /* Assume that both THIS and a given context is valid and strenghten THIS
1584 if possible. Return true if any strenghtening was made.
1585 If actual type the context is being used in is known, OTR_TYPE should be
1586 set accordingly. This improves quality of combined result. */
1587 bool combine_with (ipa_polymorphic_call_context
, tree otr_type
= NULL
);
1588 bool meet_with (ipa_polymorphic_call_context
, tree otr_type
= NULL
);
1590 /* Return TRUE if context is fully useless. */
1591 bool useless_p () const;
1592 /* Return TRUE if this context conveys the same information as X. */
1593 bool equal_to (const ipa_polymorphic_call_context
&x
) const;
1595 /* Dump human readable context to F. If NEWLINE is true, it will be
1596 terminated by a newline. */
1597 void dump (FILE *f
, bool newline
= true) const;
1598 void DEBUG_FUNCTION
debug () const;
1600 /* LTO streaming. */
1601 void stream_out (struct output_block
*) const;
1602 void stream_in (struct lto_input_block
*, struct data_in
*data_in
);
1605 bool combine_speculation_with (tree
, HOST_WIDE_INT
, bool, tree
);
1606 bool meet_speculation_with (tree
, HOST_WIDE_INT
, bool, tree
);
1607 void set_by_decl (tree
, HOST_WIDE_INT
);
1608 bool set_by_invariant (tree
, tree
, HOST_WIDE_INT
);
1609 bool speculation_consistent_p (tree
, HOST_WIDE_INT
, bool, tree
) const;
1610 void make_speculative (tree otr_type
= NULL
);
1613 /* Structure containing additional information about an indirect call. */
1615 struct GTY(()) cgraph_indirect_call_info
1617 /* When agg_content is set, an offset where the call pointer is located
1618 within the aggregate. */
1619 HOST_WIDE_INT offset
;
1620 /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */
1621 ipa_polymorphic_call_context context
;
1622 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
1623 HOST_WIDE_INT otr_token
;
1624 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
1626 /* Index of the parameter that is called. */
1628 /* ECF flags determined from the caller. */
1630 /* Profile_id of common target obtrained from profile. */
1631 int common_target_id
;
1632 /* Probability that call will land in function with COMMON_TARGET_ID. */
1633 int common_target_probability
;
1635 /* Set when the call is a virtual call with the parameter being the
1636 associated object pointer rather than a simple direct call. */
1637 unsigned polymorphic
: 1;
1638 /* Set when the call is a call of a pointer loaded from contents of an
1639 aggregate at offset. */
1640 unsigned agg_contents
: 1;
1641 /* Set when this is a call through a member pointer. */
1642 unsigned member_ptr
: 1;
1643 /* When the agg_contents bit is set, this one determines whether the
1644 destination is loaded from a parameter passed by reference. */
1645 unsigned by_ref
: 1;
1646 /* When the agg_contents bit is set, this one determines whether we can
1647 deduce from the function body that the loaded value from the reference is
1648 never modified between the invocation of the function and the load
1650 unsigned guaranteed_unmodified
: 1;
1651 /* For polymorphic calls this specify whether the virtual table pointer
1652 may have changed in between function entry and the call. */
1653 unsigned vptr_changed
: 1;
1656 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
1657 for_user
)) cgraph_edge
{
1658 friend class cgraph_node
;
1659 friend class symbol_table
;
1661 /* Remove the edge in the cgraph. */
1664 /* Change field call_stmt of edge to NEW_STMT.
1665 If UPDATE_SPECULATIVE and E is any component of speculative
1666 edge, then update all components. */
1667 void set_call_stmt (gcall
*new_stmt
, bool update_speculative
= true);
1669 /* Redirect callee of the edge to N. The function does not update underlying
1671 void redirect_callee (cgraph_node
*n
);
1673 /* If the edge does not lead to a thunk, simply redirect it to N. Otherwise
1674 create one or more equivalent thunks for N and redirect E to the first in
1675 the chain. Note that it is then necessary to call
1676 n->expand_all_artificial_thunks once all callers are redirected. */
1677 void redirect_callee_duplicating_thunks (cgraph_node
*n
);
1679 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1680 CALLEE. DELTA is an integer constant that is to be added to the this
1681 pointer (first parameter) to compensate for skipping
1682 a thunk adjustment. */
1683 cgraph_edge
*make_direct (cgraph_node
*callee
);
1685 /* Turn edge into speculative call calling N2. Update
1686 the profile so the direct call is taken COUNT times
1688 cgraph_edge
*make_speculative (cgraph_node
*n2
, profile_count direct_count
);
1690 /* Given speculative call edge, return all three components. */
1691 void speculative_call_info (cgraph_edge
*&direct
, cgraph_edge
*&indirect
,
1692 ipa_ref
*&reference
);
1694 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1695 Remove the speculative call sequence and return edge representing the call.
1696 It is up to caller to redirect the call as appropriate. */
1697 cgraph_edge
*resolve_speculation (tree callee_decl
= NULL
);
1699 /* If necessary, change the function declaration in the call statement
1700 associated with the edge so that it corresponds to the edge callee. */
1701 gimple
*redirect_call_stmt_to_callee (void);
1703 /* Create clone of edge in the node N represented
1704 by CALL_EXPR the callgraph. */
1705 cgraph_edge
* clone (cgraph_node
*n
, gcall
*call_stmt
, unsigned stmt_uid
,
1706 profile_count num
, profile_count den
,
1707 bool update_original
);
1709 /* Verify edge count and frequency. */
1710 bool verify_count ();
1712 /* Return true when call of edge can not lead to return from caller
1713 and thus it is safe to ignore its side effects for IPA analysis
1714 when computing side effects of the caller. */
1715 bool cannot_lead_to_return_p (void);
1717 /* Return true when the edge represents a direct recursion. */
1718 bool recursive_p (void);
1720 /* Return true if the call can be hot. */
1721 bool maybe_hot_p (void);
1723 /* Get unique identifier of the edge. */
1724 inline int get_uid ()
1729 /* Rebuild cgraph edges for current function node. This needs to be run after
1730 passes that don't update the cgraph. */
1731 static unsigned int rebuild_edges (void);
1733 /* Rebuild cgraph references for current function node. This needs to be run
1734 after passes that don't update the cgraph. */
1735 static void rebuild_references (void);
1737 /* During LTO stream in this can be used to check whether call can possibly
1738 be internal to the current translation unit. */
1739 bool possibly_call_in_translation_unit_p (void);
1741 /* Expected number of executions: calculated in profile.c. */
1742 profile_count count
;
1743 cgraph_node
*caller
;
1744 cgraph_node
*callee
;
1745 cgraph_edge
*prev_caller
;
1746 cgraph_edge
*next_caller
;
1747 cgraph_edge
*prev_callee
;
1748 cgraph_edge
*next_callee
;
1750 /* Additional information about an indirect call. Not cleared when an edge
1752 cgraph_indirect_call_info
*indirect_info
;
1753 PTR
GTY ((skip (""))) aux
;
1754 /* When equal to CIF_OK, inline this call. Otherwise, points to the
1755 explanation why function was not inlined. */
1756 enum cgraph_inline_failed_t inline_failed
;
1757 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
1758 when the function is serialized in. */
1759 unsigned int lto_stmt_uid
;
1760 /* Whether this edge was made direct by indirect inlining. */
1761 unsigned int indirect_inlining_edge
: 1;
1762 /* Whether this edge describes an indirect call with an undetermined
1764 unsigned int indirect_unknown_callee
: 1;
1765 /* Whether this edge is still a dangling */
1766 /* True if the corresponding CALL stmt cannot be inlined. */
1767 unsigned int call_stmt_cannot_inline_p
: 1;
1768 /* Can this call throw externally? */
1769 unsigned int can_throw_external
: 1;
1770 /* Edges with SPECULATIVE flag represents indirect calls that was
1771 speculatively turned into direct (i.e. by profile feedback).
1772 The final code sequence will have form:
1774 if (call_target == expected_fn)
1779 Every speculative call is represented by three components attached
1780 to a same call statement:
1781 1) a direct call (to expected_fn)
1782 2) an indirect call (to call_target)
1783 3) a IPA_REF_ADDR refrence to expected_fn.
1785 Optimizers may later redirect direct call to clone, so 1) and 3)
1786 do not need to necesarily agree with destination. */
1787 unsigned int speculative
: 1;
1788 /* Set to true when caller is a constructor or destructor of polymorphic
1790 unsigned in_polymorphic_cdtor
: 1;
1792 /* Return true if call must bind to current definition. */
1793 bool binds_to_current_def_p ();
1795 /* Expected frequency of executions within the function.
1796 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
1797 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
1800 /* Expected frequency of executions within the function. */
1801 sreal
sreal_frequency ();
1803 /* Unique id of the edge. */
1806 /* Remove the edge from the list of the callers of the callee. */
1807 void remove_caller (void);
1809 /* Remove the edge from the list of the callees of the caller. */
1810 void remove_callee (void);
1812 /* Set callee N of call graph edge and add it to the corresponding set of
1814 void set_callee (cgraph_node
*n
);
1816 /* Output flags of edge to a file F. */
1817 void dump_edge_flags (FILE *f
);
1819 /* Verify that call graph edge corresponds to DECL from the associated
1820 statement. Return true if the verification should fail. */
1821 bool verify_corresponds_to_fndecl (tree decl
);
1824 #define CGRAPH_FREQ_BASE 1000
1825 #define CGRAPH_FREQ_MAX 100000
1827 /* The varpool data structure.
1828 Each static variable decl has assigned varpool_node. */
1830 class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node
: public symtab_node
{
1832 /* Dump given varpool node to F. */
1833 void dump (FILE *f
);
1835 /* Dump given varpool node to stderr. */
1836 void DEBUG_FUNCTION
debug (void);
1838 /* Remove variable from symbol table. */
1841 /* Remove node initializer when it is no longer needed. */
1842 void remove_initializer (void);
1844 void analyze (void);
1846 /* Return variable availability. */
1847 availability
get_availability (symtab_node
*ref
= NULL
);
1849 /* When doing LTO, read variable's constructor from disk if
1850 it is not already present. */
1851 tree
get_constructor (void);
1853 /* Return true if variable has constructor that can be used for folding. */
1854 bool ctor_useable_for_folding_p (void);
1856 /* For given variable pool node, walk the alias chain to return the function
1857 the variable is alias of. Do not walk through thunks.
1858 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1859 When REF is non-NULL, assume that reference happens in symbol REF
1860 when determining the availability. */
1861 inline varpool_node
*ultimate_alias_target
1862 (availability
*availability
= NULL
, symtab_node
*ref
= NULL
);
1864 /* Return node that alias is aliasing. */
1865 inline varpool_node
*get_alias_target (void);
1867 /* Output one variable, if necessary. Return whether we output it. */
1868 bool assemble_decl (void);
1870 /* For variables in named sections make sure get_variable_section
1871 is called before we switch to those sections. Then section
1872 conflicts between read-only and read-only requiring relocations
1873 sections can be resolved. */
1874 void finalize_named_section_flags (void);
1876 /* Call calback on varpool symbol and aliases associated to varpool symbol.
1877 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1879 bool call_for_symbol_and_aliases (bool (*callback
) (varpool_node
*, void *),
1881 bool include_overwritable
);
1883 /* Return true when variable should be considered externally visible. */
1884 bool externally_visible_p (void);
1886 /* Return true when all references to variable must be visible
1888 i.e. if the variable is not externally visible or not used in some magic
1889 way (asm statement or such).
1890 The magic uses are all summarized in force_output flag. */
1891 inline bool all_refs_explicit_p ();
1893 /* Return true when variable can be removed from variable pool
1894 if all direct calls are eliminated. */
1895 inline bool can_remove_if_no_refs_p (void);
1897 /* Add the variable DECL to the varpool.
1898 Unlike finalize_decl function is intended to be used
1899 by middle end and allows insertion of new variable at arbitrary point
1901 static void add (tree decl
);
1903 /* Return varpool node for given symbol and check it is a function. */
1904 static inline varpool_node
*get (const_tree decl
);
1906 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
1907 the middle end to output the variable to asm file, if needed or externally
1909 static void finalize_decl (tree decl
);
1911 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1912 Extra name aliases are output whenever DECL is output. */
1913 static varpool_node
* create_extra_name_alias (tree alias
, tree decl
);
1915 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1916 Extra name aliases are output whenever DECL is output. */
1917 static varpool_node
* create_alias (tree
, tree
);
1919 /* Dump the variable pool to F. */
1920 static void dump_varpool (FILE *f
);
1922 /* Dump the variable pool to stderr. */
1923 static void DEBUG_FUNCTION
debug_varpool (void);
1925 /* Allocate new callgraph node and insert it into basic data structures. */
1926 static varpool_node
*create_empty (void);
1928 /* Return varpool node assigned to DECL. Create new one when needed. */
1929 static varpool_node
*get_create (tree decl
);
1931 /* Given an assembler name, lookup node. */
1932 static varpool_node
*get_for_asmname (tree asmname
);
1934 /* Set when variable is scheduled to be assembled. */
1935 unsigned output
: 1;
1937 /* Set when variable has statically initialized pointer
1938 or is a static bounds variable and needs initalization. */
1939 unsigned need_bounds_init
: 1;
1941 /* Set if the variable is dynamically initialized, except for
1942 function local statics. */
1943 unsigned dynamically_initialized
: 1;
1945 ENUM_BITFIELD(tls_model
) tls_model
: 3;
1947 /* Set if the variable is known to be used by single function only.
1948 This is computed by ipa_signle_use pass and used by late optimizations
1949 in places where optimization would be valid for local static variable
1950 if we did not do any inter-procedural code movement. */
1951 unsigned used_by_single_function
: 1;
1954 /* Assemble thunks and aliases associated to varpool node. */
1955 void assemble_aliases (void);
1957 /* Worker for call_for_node_and_aliases. */
1958 bool call_for_symbol_and_aliases_1 (bool (*callback
) (varpool_node
*, void *),
1960 bool include_overwritable
);
1963 /* Every top level asm statement is put into a asm_node. */
1965 struct GTY(()) asm_node
{
1968 /* Next asm node. */
1970 /* String for this asm node. */
1972 /* Ordering of all cgraph nodes. */
1976 /* Report whether or not THIS symtab node is a function, aka cgraph_node. */
1981 is_a_helper
<cgraph_node
*>::test (symtab_node
*p
)
1983 return p
&& p
->type
== SYMTAB_FUNCTION
;
1986 /* Report whether or not THIS symtab node is a vriable, aka varpool_node. */
1991 is_a_helper
<varpool_node
*>::test (symtab_node
*p
)
1993 return p
&& p
->type
== SYMTAB_VARIABLE
;
1996 /* Macros to access the next item in the list of free cgraph nodes and
1998 #define NEXT_FREE_NODE(NODE) dyn_cast<cgraph_node *> ((NODE)->next)
1999 #define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->next = NODE2
2000 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
2002 typedef void (*cgraph_edge_hook
)(cgraph_edge
*, void *);
2003 typedef void (*cgraph_node_hook
)(cgraph_node
*, void *);
2004 typedef void (*varpool_node_hook
)(varpool_node
*, void *);
2005 typedef void (*cgraph_2edge_hook
)(cgraph_edge
*, cgraph_edge
*, void *);
2006 typedef void (*cgraph_2node_hook
)(cgraph_node
*, cgraph_node
*, void *);
2008 struct cgraph_edge_hook_list
;
2009 struct cgraph_node_hook_list
;
2010 struct varpool_node_hook_list
;
2011 struct cgraph_2edge_hook_list
;
2012 struct cgraph_2node_hook_list
;
2014 /* Map from a symbol to initialization/finalization priorities. */
2015 struct GTY(()) symbol_priority_map
{
2022 /* Frontend is parsing and finalizing functions. */
2024 /* Callgraph is being constructed. It is safe to add new functions. */
2026 /* Callgraph is being streamed-in at LTO time. */
2028 /* Callgraph is built and early IPA passes are being run. */
2030 /* Callgraph is built and all functions are transformed to SSA form. */
2032 /* All inline decisions are done; it is now possible to remove extern inline
2033 functions and virtual call targets. */
2034 IPA_SSA_AFTER_INLINING
,
2035 /* Functions are now ordered and being passed to RTL expanders. */
2037 /* All cgraph expansion is done. */
2041 struct asmname_hasher
: ggc_ptr_hash
<symtab_node
>
2043 typedef const_tree compare_type
;
2045 static hashval_t
hash (symtab_node
*n
);
2046 static bool equal (symtab_node
*n
, const_tree t
);
2049 class GTY((tag ("SYMTAB"))) symbol_table
2052 friend class symtab_node
;
2053 friend class cgraph_node
;
2054 friend class cgraph_edge
;
2056 symbol_table (): cgraph_max_uid (1), edges_max_uid (1)
2060 /* Initialize callgraph dump file. */
2061 void initialize (void);
2063 /* Register a top-level asm statement ASM_STR. */
2064 inline asm_node
*finalize_toplevel_asm (tree asm_str
);
2066 /* Analyze the whole compilation unit once it is parsed completely. */
2067 void finalize_compilation_unit (void);
2069 /* C++ frontend produce same body aliases all over the place, even before PCH
2070 gets streamed out. It relies on us linking the aliases with their function
2071 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
2072 first produce aliases without links, but once C++ FE is sure he won't sream
2073 PCH we build the links via this function. */
2074 void process_same_body_aliases (void);
2076 /* Perform simple optimizations based on callgraph. */
2077 void compile (void);
2079 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
2080 functions into callgraph in a way so they look like ordinary reachable
2081 functions inserted into callgraph already at construction time. */
2082 void process_new_functions (void);
2084 /* Once all functions from compilation unit are in memory, produce all clones
2085 and update all calls. We might also do this on demand if we don't want to
2086 bring all functions to memory prior compilation, but current WHOPR
2087 implementation does that and it is bit easier to keep everything right
2089 void materialize_all_clones (void);
2091 /* Register a symbol NODE. */
2092 inline void register_symbol (symtab_node
*node
);
2095 clear_asm_symbols (void)
2098 asm_last_node
= NULL
;
2101 /* Perform reachability analysis and reclaim all unreachable nodes. */
2102 bool remove_unreachable_nodes (FILE *file
);
2104 /* Optimization of function bodies might've rendered some variables as
2105 unnecessary so we want to avoid these from being compiled. Re-do
2106 reachability starting from variables that are either externally visible
2107 or was referred from the asm output routines. */
2108 void remove_unreferenced_decls (void);
2110 /* Unregister a symbol NODE. */
2111 inline void unregister (symtab_node
*node
);
2113 /* Allocate new callgraph node and insert it into basic data structures. */
2114 cgraph_node
*create_empty (void);
2116 /* Release a callgraph NODE. */
2117 void release_symbol (cgraph_node
*node
);
2119 /* Output all variables enqueued to be assembled. */
2120 bool output_variables (void);
2122 /* Weakrefs may be associated to external decls and thus not output
2123 at expansion time. Emit all necessary aliases. */
2124 void output_weakrefs (void);
2126 /* Return first static symbol with definition. */
2127 inline symtab_node
*first_symbol (void);
2129 /* Return first assembler symbol. */
2131 first_asm_symbol (void)
2136 /* Return first static symbol with definition. */
2137 inline symtab_node
*first_defined_symbol (void);
2139 /* Return first variable. */
2140 inline varpool_node
*first_variable (void);
2142 /* Return next variable after NODE. */
2143 inline varpool_node
*next_variable (varpool_node
*node
);
2145 /* Return first static variable with initializer. */
2146 inline varpool_node
*first_static_initializer (void);
2148 /* Return next static variable with initializer after NODE. */
2149 inline varpool_node
*next_static_initializer (varpool_node
*node
);
2151 /* Return first static variable with definition. */
2152 inline varpool_node
*first_defined_variable (void);
2154 /* Return next static variable with definition after NODE. */
2155 inline varpool_node
*next_defined_variable (varpool_node
*node
);
2157 /* Return first function with body defined. */
2158 inline cgraph_node
*first_defined_function (void);
2160 /* Return next function with body defined after NODE. */
2161 inline cgraph_node
*next_defined_function (cgraph_node
*node
);
2163 /* Return first function. */
2164 inline cgraph_node
*first_function (void);
2166 /* Return next function. */
2167 inline cgraph_node
*next_function (cgraph_node
*node
);
2169 /* Return first function with body defined. */
2170 cgraph_node
*first_function_with_gimple_body (void);
2172 /* Return next reachable static variable with initializer after NODE. */
2173 inline cgraph_node
*next_function_with_gimple_body (cgraph_node
*node
);
2175 /* Register HOOK to be called with DATA on each removed edge. */
2176 cgraph_edge_hook_list
*add_edge_removal_hook (cgraph_edge_hook hook
,
2179 /* Remove ENTRY from the list of hooks called on removing edges. */
2180 void remove_edge_removal_hook (cgraph_edge_hook_list
*entry
);
2182 /* Register HOOK to be called with DATA on each removed node. */
2183 cgraph_node_hook_list
*add_cgraph_removal_hook (cgraph_node_hook hook
,
2186 /* Remove ENTRY from the list of hooks called on removing nodes. */
2187 void remove_cgraph_removal_hook (cgraph_node_hook_list
*entry
);
2189 /* Register HOOK to be called with DATA on each removed node. */
2190 varpool_node_hook_list
*add_varpool_removal_hook (varpool_node_hook hook
,
2193 /* Remove ENTRY from the list of hooks called on removing nodes. */
2194 void remove_varpool_removal_hook (varpool_node_hook_list
*entry
);
2196 /* Register HOOK to be called with DATA on each inserted node. */
2197 cgraph_node_hook_list
*add_cgraph_insertion_hook (cgraph_node_hook hook
,
2200 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2201 void remove_cgraph_insertion_hook (cgraph_node_hook_list
*entry
);
2203 /* Register HOOK to be called with DATA on each inserted node. */
2204 varpool_node_hook_list
*add_varpool_insertion_hook (varpool_node_hook hook
,
2207 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2208 void remove_varpool_insertion_hook (varpool_node_hook_list
*entry
);
2210 /* Register HOOK to be called with DATA on each duplicated edge. */
2211 cgraph_2edge_hook_list
*add_edge_duplication_hook (cgraph_2edge_hook hook
,
2213 /* Remove ENTRY from the list of hooks called on duplicating edges. */
2214 void remove_edge_duplication_hook (cgraph_2edge_hook_list
*entry
);
2216 /* Register HOOK to be called with DATA on each duplicated node. */
2217 cgraph_2node_hook_list
*add_cgraph_duplication_hook (cgraph_2node_hook hook
,
2220 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
2221 void remove_cgraph_duplication_hook (cgraph_2node_hook_list
*entry
);
2223 /* Call all edge removal hooks. */
2224 void call_edge_removal_hooks (cgraph_edge
*e
);
2226 /* Call all node insertion hooks. */
2227 void call_cgraph_insertion_hooks (cgraph_node
*node
);
2229 /* Call all node removal hooks. */
2230 void call_cgraph_removal_hooks (cgraph_node
*node
);
2232 /* Call all node duplication hooks. */
2233 void call_cgraph_duplication_hooks (cgraph_node
*node
, cgraph_node
*node2
);
2235 /* Call all edge duplication hooks. */
2236 void call_edge_duplication_hooks (cgraph_edge
*cs1
, cgraph_edge
*cs2
);
2238 /* Call all node removal hooks. */
2239 void call_varpool_removal_hooks (varpool_node
*node
);
2241 /* Call all node insertion hooks. */
2242 void call_varpool_insertion_hooks (varpool_node
*node
);
2244 /* Arrange node to be first in its entry of assembler_name_hash. */
2245 void symtab_prevail_in_asm_name_hash (symtab_node
*node
);
2247 /* Initalize asm name hash unless. */
2248 void symtab_initialize_asm_name_hash (void);
2250 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
2251 void change_decl_assembler_name (tree decl
, tree name
);
2253 /* Dump symbol table to F. */
2254 void dump (FILE *f
);
2256 /* Dump symbol table to stderr. */
2257 void DEBUG_FUNCTION
debug (void);
2259 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
2261 static bool assembler_names_equal_p (const char *name1
, const char *name2
);
2269 symtab_node
* GTY(()) nodes
;
2270 asm_node
* GTY(()) asmnodes
;
2271 asm_node
* GTY(()) asm_last_node
;
2272 cgraph_node
* GTY(()) free_nodes
;
2274 /* Head of a linked list of unused (freed) call graph edges.
2275 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
2276 cgraph_edge
* GTY(()) free_edges
;
2278 /* The order index of the next symtab node to be created. This is
2279 used so that we can sort the cgraph nodes in order by when we saw
2280 them, to support -fno-toplevel-reorder. */
2283 /* Set when whole unit has been analyzed so we can access global info. */
2284 bool global_info_ready
;
2285 /* What state callgraph is in right now. */
2286 enum symtab_state state
;
2287 /* Set when the cgraph is fully build and the basic flags are computed. */
2288 bool function_flags_ready
;
2290 bool cpp_implicit_aliases_done
;
2292 /* Hash table used to hold sectoons. */
2293 hash_table
<section_name_hasher
> *GTY(()) section_hash
;
2295 /* Hash table used to convert assembler names into nodes. */
2296 hash_table
<asmname_hasher
> *assembler_name_hash
;
2298 /* Hash table used to hold init priorities. */
2299 hash_map
<symtab_node
*, symbol_priority_map
> *init_priority_hash
;
2301 FILE* GTY ((skip
)) dump_file
;
2303 /* Return symbol used to separate symbol name from suffix. */
2304 static char symbol_suffix_separator ();
2306 FILE* GTY ((skip
)) ipa_clones_dump_file
;
2308 hash_set
<const cgraph_node
*> GTY ((skip
)) cloned_nodes
;
2311 /* Allocate new callgraph node. */
2312 inline cgraph_node
* allocate_cgraph_symbol (void);
2314 /* Allocate a cgraph_edge structure and fill it with data according to the
2315 parameters of which only CALLEE can be NULL (when creating an indirect call
2317 cgraph_edge
*create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
2318 gcall
*call_stmt
, profile_count count
,
2319 bool indir_unknown_callee
);
2321 /* Put the edge onto the free list. */
2322 void free_edge (cgraph_edge
*e
);
2324 /* Insert NODE to assembler name hash. */
2325 void insert_to_assembler_name_hash (symtab_node
*node
, bool with_clones
);
2327 /* Remove NODE from assembler name hash. */
2328 void unlink_from_assembler_name_hash (symtab_node
*node
, bool with_clones
);
2330 /* Hash asmnames ignoring the user specified marks. */
2331 static hashval_t
decl_assembler_name_hash (const_tree asmname
);
2333 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
2334 static bool decl_assembler_name_equal (tree decl
, const_tree asmname
);
2336 friend struct asmname_hasher
;
2338 /* List of hooks triggered when an edge is removed. */
2339 cgraph_edge_hook_list
* GTY((skip
)) m_first_edge_removal_hook
;
2340 /* List of hooks triggem_red when a cgraph node is removed. */
2341 cgraph_node_hook_list
* GTY((skip
)) m_first_cgraph_removal_hook
;
2342 /* List of hooks triggered when an edge is duplicated. */
2343 cgraph_2edge_hook_list
* GTY((skip
)) m_first_edge_duplicated_hook
;
2344 /* List of hooks triggered when a node is duplicated. */
2345 cgraph_2node_hook_list
* GTY((skip
)) m_first_cgraph_duplicated_hook
;
2346 /* List of hooks triggered when an function is inserted. */
2347 cgraph_node_hook_list
* GTY((skip
)) m_first_cgraph_insertion_hook
;
2348 /* List of hooks triggered when an variable is inserted. */
2349 varpool_node_hook_list
* GTY((skip
)) m_first_varpool_insertion_hook
;
2350 /* List of hooks triggered when a node is removed. */
2351 varpool_node_hook_list
* GTY((skip
)) m_first_varpool_removal_hook
;
2354 extern GTY(()) symbol_table
*symtab
;
2356 extern vec
<cgraph_node
*> cgraph_new_nodes
;
2359 asmname_hasher::hash (symtab_node
*n
)
2361 return symbol_table::decl_assembler_name_hash
2362 (DECL_ASSEMBLER_NAME (n
->decl
));
2366 asmname_hasher::equal (symtab_node
*n
, const_tree t
)
2368 return symbol_table::decl_assembler_name_equal (n
->decl
, t
);
2372 void cgraph_c_finalize (void);
2373 void release_function_body (tree
);
2374 cgraph_indirect_call_info
*cgraph_allocate_init_indirect_info (void);
2376 void cgraph_update_edges_for_call_stmt (gimple
*, tree
, gimple
*);
2377 bool cgraph_function_possibly_inlined_p (tree
);
2379 const char* cgraph_inline_failed_string (cgraph_inline_failed_t
);
2380 cgraph_inline_failed_type_t
cgraph_inline_failed_type (cgraph_inline_failed_t
);
2382 extern bool gimple_check_call_matching_types (gimple
*, tree
, bool);
2384 /* In cgraphunit.c */
2385 void cgraphunit_c_finalize (void);
2387 /* Initialize datastructures so DECL is a function in lowered gimple form.
2388 IN_SSA is true if the gimple is in SSA. */
2389 basic_block
init_lowered_empty_function (tree
, bool, profile_count
);
2391 tree
thunk_adjust (gimple_stmt_iterator
*, tree
, bool, HOST_WIDE_INT
, tree
,
2393 /* In cgraphclones.c */
2395 tree
clone_function_name_numbered (const char *name
, const char *suffix
);
2396 tree
clone_function_name_numbered (tree decl
, const char *suffix
);
2397 tree
clone_function_name (const char *name
, const char *suffix
,
2398 unsigned long number
);
2399 tree
clone_function_name (tree decl
, const char *suffix
,
2400 unsigned long number
);
2401 tree
clone_function_name (tree decl
, const char *suffix
);
2403 void tree_function_versioning (tree
, tree
, vec
<ipa_replace_map
*, va_gc
> *,
2404 bool, bitmap
, bool, bitmap
, basic_block
);
2406 void dump_callgraph_transformation (const cgraph_node
*original
,
2407 const cgraph_node
*clone
,
2408 const char *suffix
);
2409 tree
cgraph_build_function_type_skip_args (tree orig_type
, bitmap args_to_skip
,
2412 /* In cgraphbuild.c */
2413 int compute_call_stmt_bb_frequency (tree
, basic_block bb
);
2414 void record_references_in_initializer (tree
, bool);
2417 void cgraph_build_static_cdtor (char which
, tree body
, int priority
);
2418 bool ipa_discover_variable_flags (void);
2421 tree
ctor_for_folding (tree
);
2423 /* In ipa-inline-analysis.c */
2424 void initialize_inline_failed (struct cgraph_edge
*);
2425 bool speculation_useful_p (struct cgraph_edge
*e
, bool anticipate_inlining
);
2427 /* Return true when the symbol is real symbol, i.e. it is not inline clone
2428 or abstract function kept for debug info purposes only. */
2430 symtab_node::real_symbol_p (void)
2434 if (DECL_ABSTRACT_P (decl
))
2436 if (transparent_alias
&& definition
)
2438 if (!is_a
<cgraph_node
*> (this))
2440 cnode
= dyn_cast
<cgraph_node
*> (this);
2441 if (cnode
->global
.inlined_to
)
2446 /* Return true if DECL should have entry in symbol table if used.
2447 Those are functions and static & external veriables*/
2450 decl_in_symtab_p (const_tree decl
)
2452 return (TREE_CODE (decl
) == FUNCTION_DECL
2453 || (TREE_CODE (decl
) == VAR_DECL
2454 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))));
2458 symtab_node::in_same_comdat_group_p (symtab_node
*target
)
2460 symtab_node
*source
= this;
2462 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (target
))
2464 if (cn
->global
.inlined_to
)
2465 source
= cn
->global
.inlined_to
;
2467 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (target
))
2469 if (cn
->global
.inlined_to
)
2470 target
= cn
->global
.inlined_to
;
2473 return source
->get_comdat_group () == target
->get_comdat_group ();
2476 /* Return node that alias is aliasing. */
2478 inline symtab_node
*
2479 symtab_node::get_alias_target (void)
2481 ipa_ref
*ref
= NULL
;
2482 iterate_reference (0, ref
);
2483 gcc_checking_assert (ref
->use
== IPA_REF_ALIAS
);
2484 return ref
->referred
;
2487 /* Return next reachable static symbol with initializer after the node. */
2489 inline symtab_node
*
2490 symtab_node::next_defined_symbol (void)
2492 symtab_node
*node1
= next
;
2494 for (; node1
; node1
= node1
->next
)
2495 if (node1
->definition
)
2501 /* Iterates I-th reference in the list, REF is also set. */
2504 symtab_node::iterate_reference (unsigned i
, ipa_ref
*&ref
)
2506 vec_safe_iterate (ref_list
.references
, i
, &ref
);
2511 /* Iterates I-th referring item in the list, REF is also set. */
2514 symtab_node::iterate_referring (unsigned i
, ipa_ref
*&ref
)
2516 ref_list
.referring
.iterate (i
, &ref
);
2521 /* Iterates I-th referring alias item in the list, REF is also set. */
2524 symtab_node::iterate_direct_aliases (unsigned i
, ipa_ref
*&ref
)
2526 ref_list
.referring
.iterate (i
, &ref
);
2528 if (ref
&& ref
->use
!= IPA_REF_ALIAS
)
2534 /* Return true if list contains an alias. */
2537 symtab_node::has_aliases_p (void)
2539 ipa_ref
*ref
= NULL
;
2541 return (iterate_direct_aliases (0, ref
) != NULL
);
2544 /* Return true when RESOLUTION indicate that linker will use
2545 the symbol from non-LTO object files. */
2548 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution
)
2550 return (resolution
== LDPR_PREVAILING_DEF
2551 || resolution
== LDPR_PREEMPTED_REG
2552 || resolution
== LDPR_RESOLVED_EXEC
2553 || resolution
== LDPR_RESOLVED_DYN
);
2556 /* Return true when symtab_node is known to be used from other (non-LTO)
2557 object file. Known only when doing LTO via linker plugin. */
2560 symtab_node::used_from_object_file_p (void)
2562 if (!TREE_PUBLIC (decl
) || DECL_EXTERNAL (decl
))
2564 if (resolution_used_from_other_file_p (resolution
))
2569 /* Return varpool node for given symbol and check it is a function. */
2571 inline varpool_node
*
2572 varpool_node::get (const_tree decl
)
2574 gcc_checking_assert (TREE_CODE (decl
) == VAR_DECL
);
2575 return dyn_cast
<varpool_node
*> (symtab_node::get (decl
));
2578 /* Register a symbol NODE. */
2581 symbol_table::register_symbol (symtab_node
*node
)
2584 node
->previous
= NULL
;
2587 nodes
->previous
= node
;
2590 node
->order
= order
++;
2593 /* Register a top-level asm statement ASM_STR. */
2596 symbol_table::finalize_toplevel_asm (tree asm_str
)
2600 node
= ggc_cleared_alloc
<asm_node
> ();
2601 node
->asm_str
= asm_str
;
2602 node
->order
= order
++;
2605 if (asmnodes
== NULL
)
2608 asm_last_node
->next
= node
;
2610 asm_last_node
= node
;
2614 /* Unregister a symbol NODE. */
2616 symbol_table::unregister (symtab_node
*node
)
2619 node
->previous
->next
= node
->next
;
2624 node
->next
->previous
= node
->previous
;
2627 node
->previous
= NULL
;
2630 /* Release a callgraph NODE with UID and put in to the list of free nodes. */
2633 symbol_table::release_symbol (cgraph_node
*node
)
2637 /* Clear out the node to NULL all pointers and add the node to the free
2639 memset (node
, 0, sizeof (*node
));
2640 node
->type
= SYMTAB_FUNCTION
;
2641 SET_NEXT_FREE_NODE (node
, free_nodes
);
2645 /* Allocate new callgraph node. */
2647 inline cgraph_node
*
2648 symbol_table::allocate_cgraph_symbol (void)
2655 free_nodes
= NEXT_FREE_NODE (node
);
2658 node
= ggc_cleared_alloc
<cgraph_node
> ();
2660 node
->m_uid
= cgraph_max_uid
++;
2665 /* Return first static symbol with definition. */
2666 inline symtab_node
*
2667 symbol_table::first_symbol (void)
2672 /* Walk all symbols. */
2673 #define FOR_EACH_SYMBOL(node) \
2674 for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)
2676 /* Return first static symbol with definition. */
2677 inline symtab_node
*
2678 symbol_table::first_defined_symbol (void)
2682 for (node
= nodes
; node
; node
= node
->next
)
2683 if (node
->definition
)
2689 /* Walk all symbols with definitions in current unit. */
2690 #define FOR_EACH_DEFINED_SYMBOL(node) \
2691 for ((node) = symtab->first_defined_symbol (); (node); \
2692 (node) = node->next_defined_symbol ())
2694 /* Return first variable. */
2695 inline varpool_node
*
2696 symbol_table::first_variable (void)
2699 for (node
= nodes
; node
; node
= node
->next
)
2700 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
))
2705 /* Return next variable after NODE. */
2706 inline varpool_node
*
2707 symbol_table::next_variable (varpool_node
*node
)
2709 symtab_node
*node1
= node
->next
;
2710 for (; node1
; node1
= node1
->next
)
2711 if (varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
))
2715 /* Walk all variables. */
2716 #define FOR_EACH_VARIABLE(node) \
2717 for ((node) = symtab->first_variable (); \
2719 (node) = symtab->next_variable ((node)))
2721 /* Return first static variable with initializer. */
2722 inline varpool_node
*
2723 symbol_table::first_static_initializer (void)
2726 for (node
= nodes
; node
; node
= node
->next
)
2728 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2729 if (vnode
&& DECL_INITIAL (node
->decl
))
2735 /* Return next static variable with initializer after NODE. */
2736 inline varpool_node
*
2737 symbol_table::next_static_initializer (varpool_node
*node
)
2739 symtab_node
*node1
= node
->next
;
2740 for (; node1
; node1
= node1
->next
)
2742 varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
);
2743 if (vnode1
&& DECL_INITIAL (node1
->decl
))
2749 /* Walk all static variables with initializer set. */
2750 #define FOR_EACH_STATIC_INITIALIZER(node) \
2751 for ((node) = symtab->first_static_initializer (); (node); \
2752 (node) = symtab->next_static_initializer (node))
2754 /* Return first static variable with definition. */
2755 inline varpool_node
*
2756 symbol_table::first_defined_variable (void)
2759 for (node
= nodes
; node
; node
= node
->next
)
2761 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2762 if (vnode
&& vnode
->definition
)
2768 /* Return next static variable with definition after NODE. */
2769 inline varpool_node
*
2770 symbol_table::next_defined_variable (varpool_node
*node
)
2772 symtab_node
*node1
= node
->next
;
2773 for (; node1
; node1
= node1
->next
)
2775 varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
);
2776 if (vnode1
&& vnode1
->definition
)
2781 /* Walk all variables with definitions in current unit. */
2782 #define FOR_EACH_DEFINED_VARIABLE(node) \
2783 for ((node) = symtab->first_defined_variable (); (node); \
2784 (node) = symtab->next_defined_variable (node))
2786 /* Return first function with body defined. */
2787 inline cgraph_node
*
2788 symbol_table::first_defined_function (void)
2791 for (node
= nodes
; node
; node
= node
->next
)
2793 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
2794 if (cn
&& cn
->definition
)
2800 /* Return next function with body defined after NODE. */
2801 inline cgraph_node
*
2802 symbol_table::next_defined_function (cgraph_node
*node
)
2804 symtab_node
*node1
= node
->next
;
2805 for (; node1
; node1
= node1
->next
)
2807 cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
);
2808 if (cn1
&& cn1
->definition
)
2814 /* Walk all functions with body defined. */
2815 #define FOR_EACH_DEFINED_FUNCTION(node) \
2816 for ((node) = symtab->first_defined_function (); (node); \
2817 (node) = symtab->next_defined_function ((node)))
2819 /* Return first function. */
2820 inline cgraph_node
*
2821 symbol_table::first_function (void)
2824 for (node
= nodes
; node
; node
= node
->next
)
2825 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
))
2830 /* Return next function. */
2831 inline cgraph_node
*
2832 symbol_table::next_function (cgraph_node
*node
)
2834 symtab_node
*node1
= node
->next
;
2835 for (; node1
; node1
= node1
->next
)
2836 if (cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
))
2841 /* Return first function with body defined. */
2842 inline cgraph_node
*
2843 symbol_table::first_function_with_gimple_body (void)
2846 for (node
= nodes
; node
; node
= node
->next
)
2848 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
2849 if (cn
&& cn
->has_gimple_body_p ())
2855 /* Return next reachable static variable with initializer after NODE. */
2856 inline cgraph_node
*
2857 symbol_table::next_function_with_gimple_body (cgraph_node
*node
)
2859 symtab_node
*node1
= node
->next
;
2860 for (; node1
; node1
= node1
->next
)
2862 cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
);
2863 if (cn1
&& cn1
->has_gimple_body_p ())
2869 /* Walk all functions. */
2870 #define FOR_EACH_FUNCTION(node) \
2871 for ((node) = symtab->first_function (); (node); \
2872 (node) = symtab->next_function ((node)))
2874 /* Return true when callgraph node is a function with Gimple body defined
2875 in current unit. Functions can also be define externally or they
2876 can be thunks with no Gimple representation.
2878 Note that at WPA stage, the function body may not be present in memory. */
2881 cgraph_node::has_gimple_body_p (void)
2883 return definition
&& !thunk
.thunk_p
&& !alias
;
2886 /* Walk all functions with body defined. */
2887 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
2888 for ((node) = symtab->first_function_with_gimple_body (); (node); \
2889 (node) = symtab->next_function_with_gimple_body (node))
2891 /* Uniquize all constants that appear in memory.
2892 Each constant in memory thus far output is recorded
2893 in `const_desc_table'. */
2895 struct GTY((for_user
)) constant_descriptor_tree
{
2896 /* A MEM for the constant. */
2899 /* The value of the constant. */
2902 /* Hash of value. Computing the hash from value each time
2903 hashfn is called can't work properly, as that means recursive
2904 use of the hash table during hash table expansion. */
2908 /* Return true when function is only called directly or it has alias.
2909 i.e. it is not externally visible, address was not taken and
2910 it is not used in any other non-standard way. */
2913 cgraph_node::only_called_directly_or_aliased_p (void)
2915 gcc_assert (!global
.inlined_to
);
2916 return (!force_output
&& !address_taken
2918 && !used_from_other_partition
2919 && !DECL_VIRTUAL_P (decl
)
2920 && !DECL_STATIC_CONSTRUCTOR (decl
)
2921 && !DECL_STATIC_DESTRUCTOR (decl
)
2922 && !used_from_object_file_p ()
2923 && !externally_visible
);
2926 /* Return true when function can be removed from callgraph
2927 if all direct calls are eliminated. */
2930 cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
2932 gcc_checking_assert (!global
.inlined_to
);
2933 /* Extern inlines can always go, we will use the external definition. */
2934 if (DECL_EXTERNAL (decl
))
2936 /* When function is needed, we can not remove it. */
2937 if (force_output
|| used_from_other_partition
)
2939 if (DECL_STATIC_CONSTRUCTOR (decl
)
2940 || DECL_STATIC_DESTRUCTOR (decl
))
2942 /* Only COMDAT functions can be removed if externally visible. */
2943 if (externally_visible
2944 && (!DECL_COMDAT (decl
)
2946 || used_from_object_file_p ()))
2951 /* Verify cgraph, if consistency checking is enabled. */
2954 cgraph_node::checking_verify_cgraph_nodes (void)
2957 cgraph_node::verify_cgraph_nodes ();
2960 /* Return true when variable can be removed from variable pool
2961 if all direct calls are eliminated. */
2964 varpool_node::can_remove_if_no_refs_p (void)
2966 if (DECL_EXTERNAL (decl
))
2968 return (!force_output
&& !used_from_other_partition
2969 && ((DECL_COMDAT (decl
)
2971 && !used_from_object_file_p ())
2972 || !externally_visible
2973 || DECL_HAS_VALUE_EXPR_P (decl
)));
2976 /* Return true when all references to variable must be visible in ipa_ref_list.
2977 i.e. if the variable is not externally visible or not used in some magic
2978 way (asm statement or such).
2979 The magic uses are all summarized in force_output flag. */
2982 varpool_node::all_refs_explicit_p ()
2985 && !externally_visible
2986 && !used_from_other_partition
2990 struct tree_descriptor_hasher
: ggc_ptr_hash
<constant_descriptor_tree
>
2992 static hashval_t
hash (constant_descriptor_tree
*);
2993 static bool equal (constant_descriptor_tree
*, constant_descriptor_tree
*);
2996 /* Constant pool accessor function. */
2997 hash_table
<tree_descriptor_hasher
> *constant_pool_htab (void);
2999 /* Return node that alias is aliasing. */
3001 inline cgraph_node
*
3002 cgraph_node::get_alias_target (void)
3004 return dyn_cast
<cgraph_node
*> (symtab_node::get_alias_target ());
3007 /* Return node that alias is aliasing. */
3009 inline varpool_node
*
3010 varpool_node::get_alias_target (void)
3012 return dyn_cast
<varpool_node
*> (symtab_node::get_alias_target ());
3015 /* Walk the alias chain to return the symbol NODE is alias of.
3016 If NODE is not an alias, return NODE.
3017 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3018 When REF is non-NULL, assume that reference happens in symbol REF
3019 when determining the availability. */
3021 inline symtab_node
*
3022 symtab_node::ultimate_alias_target (enum availability
*availability
,
3028 *availability
= get_availability (ref
);
3032 return ultimate_alias_target_1 (availability
, ref
);
3035 /* Given function symbol, walk the alias chain to return the function node
3036 is alias of. Do not walk through thunks.
3037 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3038 When REF is non-NULL, assume that reference happens in symbol REF
3039 when determining the availability. */
3041 inline cgraph_node
*
3042 cgraph_node::ultimate_alias_target (enum availability
*availability
,
3045 cgraph_node
*n
= dyn_cast
<cgraph_node
*>
3046 (symtab_node::ultimate_alias_target (availability
, ref
));
3047 if (!n
&& availability
)
3048 *availability
= AVAIL_NOT_AVAILABLE
;
3052 /* For given variable pool node, walk the alias chain to return the function
3053 the variable is alias of. Do not walk through thunks.
3054 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3055 When REF is non-NULL, assume that reference happens in symbol REF
3056 when determining the availability. */
3058 inline varpool_node
*
3059 varpool_node::ultimate_alias_target (availability
*availability
,
3062 varpool_node
*n
= dyn_cast
<varpool_node
*>
3063 (symtab_node::ultimate_alias_target (availability
, ref
));
3065 if (!n
&& availability
)
3066 *availability
= AVAIL_NOT_AVAILABLE
;
3070 /* Set callee N of call graph edge and add it to the corresponding set of
3074 cgraph_edge::set_callee (cgraph_node
*n
)
3078 n
->callers
->prev_caller
= this;
3079 next_caller
= n
->callers
;
3084 /* Redirect callee of the edge to N. The function does not update underlying
3088 cgraph_edge::redirect_callee (cgraph_node
*n
)
3090 /* Remove from callers list of the current callee. */
3093 /* Insert to callers list of the new callee. */
3097 /* Return true when the edge represents a direct recursion. */
3100 cgraph_edge::recursive_p (void)
3102 cgraph_node
*c
= callee
->ultimate_alias_target ();
3103 if (caller
->global
.inlined_to
)
3104 return caller
->global
.inlined_to
->decl
== c
->decl
;
3106 return caller
->decl
== c
->decl
;
3109 /* Remove the edge from the list of the callers of the callee. */
3112 cgraph_edge::remove_callee (void)
3114 gcc_assert (!indirect_unknown_callee
);
3116 prev_caller
->next_caller
= next_caller
;
3118 next_caller
->prev_caller
= prev_caller
;
3120 callee
->callers
= next_caller
;
3123 /* Return true if call must bind to current definition. */
3126 cgraph_edge::binds_to_current_def_p ()
3129 return callee
->binds_to_current_def_p (caller
);
3134 /* Expected frequency of executions within the function.
3135 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
3136 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
3139 cgraph_edge::frequency ()
3141 return count
.to_cgraph_frequency (caller
->global
.inlined_to
3142 ? caller
->global
.inlined_to
->count
3147 /* Return true if the TM_CLONE bit is set for a given FNDECL. */
3149 decl_is_tm_clone (const_tree fndecl
)
3151 cgraph_node
*n
= cgraph_node::get (fndecl
);
3157 /* Likewise indicate that a node is needed, i.e. reachable via some
3161 cgraph_node::mark_force_output (void)
3164 gcc_checking_assert (!global
.inlined_to
);
3167 /* Return true if function should be optimized for size. */
3170 cgraph_node::optimize_for_size_p (void)
3172 if (opt_for_fn (decl
, optimize_size
))
3174 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3180 /* Return symtab_node for NODE or create one if it is not present
3183 inline symtab_node
*
3184 symtab_node::get_create (tree node
)
3186 if (TREE_CODE (node
) == VAR_DECL
)
3187 return varpool_node::get_create (node
);
3189 return cgraph_node::get_create (node
);
3192 /* Return availability of NODE when referenced from REF. */
3194 inline enum availability
3195 symtab_node::get_availability (symtab_node
*ref
)
3197 if (is_a
<cgraph_node
*> (this))
3198 return dyn_cast
<cgraph_node
*> (this)->get_availability (ref
);
3200 return dyn_cast
<varpool_node
*> (this)->get_availability (ref
);
3203 /* Call calback on symtab node and aliases associated to this node.
3204 When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */
3207 symtab_node::call_for_symbol_and_aliases (bool (*callback
) (symtab_node
*,
3210 bool include_overwritable
)
3212 if (include_overwritable
3213 || get_availability () > AVAIL_INTERPOSABLE
)
3215 if (callback (this, data
))
3218 if (has_aliases_p ())
3219 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3223 /* Call callback on function and aliases associated to the function.
3224 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3228 cgraph_node::call_for_symbol_and_aliases (bool (*callback
) (cgraph_node
*,
3231 bool include_overwritable
)
3233 if (include_overwritable
3234 || get_availability () > AVAIL_INTERPOSABLE
)
3236 if (callback (this, data
))
3239 if (has_aliases_p ())
3240 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3244 /* Call calback on varpool symbol and aliases associated to varpool symbol.
3245 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3249 varpool_node::call_for_symbol_and_aliases (bool (*callback
) (varpool_node
*,
3252 bool include_overwritable
)
3254 if (include_overwritable
3255 || get_availability () > AVAIL_INTERPOSABLE
)
3257 if (callback (this, data
))
3260 if (has_aliases_p ())
3261 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3265 /* Return true if refernece may be used in address compare. */
3268 ipa_ref::address_matters_p ()
3270 if (use
!= IPA_REF_ADDR
)
3272 /* Addresses taken from virtual tables are never compared. */
3273 if (is_a
<varpool_node
*> (referring
)
3274 && DECL_VIRTUAL_P (referring
->decl
))
3276 return referred
->address_can_be_compared_p ();
3279 /* Build polymorphic call context for indirect call E. */
3282 ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge
*e
)
3284 gcc_checking_assert (e
->indirect_info
->polymorphic
);
3285 *this = e
->indirect_info
->context
;
3288 /* Build empty "I know nothing" context. */
3291 ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
3293 clear_speculation ();
3294 clear_outer_type ();
3298 /* Make context non-speculative. */
3301 ipa_polymorphic_call_context::clear_speculation ()
3303 speculative_outer_type
= NULL
;
3304 speculative_offset
= 0;
3305 speculative_maybe_derived_type
= false;
3308 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
3309 NULL, the context is set to dummy "I know nothing" setting. */
3312 ipa_polymorphic_call_context::clear_outer_type (tree otr_type
)
3314 outer_type
= otr_type
? TYPE_MAIN_VARIANT (otr_type
) : NULL
;
3316 maybe_derived_type
= true;
3317 maybe_in_construction
= true;
3321 /* Adjust all offsets in contexts by OFF bits. */
3324 ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off
)
3328 if (speculative_outer_type
)
3329 speculative_offset
+= off
;
3332 /* Return TRUE if context is fully useless. */
3335 ipa_polymorphic_call_context::useless_p () const
3337 return (!outer_type
&& !speculative_outer_type
);
3340 /* When using fprintf (or similar), problems can arise with
3341 transient generated strings. Many string-generation APIs
3342 only support one result being alive at once (e.g. by
3343 returning a pointer to a statically-allocated buffer).
3345 If there is more than one generated string within one
3346 fprintf call: the first string gets evicted or overwritten
3347 by the second, before fprintf is fully evaluated.
3350 This function provides a workaround for this, by providing
3351 a simple way to create copies of these transient strings,
3352 without the need to have explicit cleanup:
3354 fprintf (dumpfile, "string 1: %s string 2:%s\n",
3355 xstrdup_for_dump (EXPR_1),
3356 xstrdup_for_dump (EXPR_2));
3358 This is actually a simple wrapper around ggc_strdup, but
3359 the name documents the intent. We require that no GC can occur
3360 within the fprintf call. */
3362 static inline const char *
3363 xstrdup_for_dump (const char *transient_str
)
3365 return ggc_strdup (transient_str
);
3368 /* During LTO stream-in this predicate can be used to check whether node
3369 in question prevails in the linking to save some memory usage. */
3371 symtab_node::prevailing_p (void)
3373 return definition
&& ((!TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
3374 || previous_sharing_asm_name
== NULL
);
3377 extern GTY(()) symbol_table
*saved_symtab
;
3381 namespace selftest
{
3383 /* An RAII-style class for use in selftests for temporarily using a different
3384 symbol_table, so that such tests can be isolated from each other. */
3386 class symbol_table_test
3389 /* Constructor. Override "symtab". */
3390 symbol_table_test ();
3392 /* Destructor. Restore the saved_symtab. */
3393 ~symbol_table_test ();
3396 } // namespace selftest
3398 #endif /* CHECKING_P */
3400 #endif /* GCC_CGRAPH_H */