1 /* Callgraph handling code.
2 Copyright (C) 2003-2015 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/>. */
25 #include "plugin-api.h"
28 typedef ipa_opt_pass_d
*ipa_opt_pass
;
30 /* Symbol table consists of functions and variables.
31 TODO: add labels and CONST_DECLs. */
39 /* Section names are stored as reference counted strings in GGC safe hashtable
40 (to make them survive through PCH). */
42 struct GTY((for_user
)) section_hash_entry
45 char *name
; /* As long as this datastructure stays in GGC, we can not put
46 string at the tail of structure of GGC dies in horrible
50 struct section_name_hasher
: ggc_ptr_hash
<section_hash_entry
>
52 typedef const char *compare_type
;
54 static hashval_t
hash (section_hash_entry
*);
55 static bool equal (section_hash_entry
*, const char *);
60 /* Not yet set by cgraph_function_body_availability. */
62 /* Function body/variable initializer is unknown. */
64 /* Function body/variable initializer is known but might be replaced
65 by a different one from other compilation unit and thus needs to
66 be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have
67 arbitrary side effects on escaping variables and functions, while
68 like AVAILABLE it might access static variables. */
70 /* Function body/variable initializer is known and will be used in final
73 /* Function body/variable initializer is known and all it's uses are
74 explicitly visible within current unit (ie it's address is never taken and
75 it is not exported to other units). Currently used only for functions. */
79 /* Classification of symbols WRT partitioning. */
80 enum symbol_partitioning_class
82 /* External declarations are ignored by partitioning algorithms and they are
83 added into the boundary later via compute_ltrans_boundary. */
85 /* Partitioned symbols are pur into one of partitions. */
87 /* Duplicated symbols (such as comdat or constant pool references) are
88 copied into every node needing them via add_symbol_to_partition. */
92 /* Base of all entries in the symbol table.
93 The symtab_node is inherited by cgraph and varpol nodes. */
94 class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
95 chain_next ("%h.next"), chain_prev ("%h.previous")))
100 const char *name () const;
102 /* Return asm name. */
103 const char * asm_name () const;
105 /* Add node into symbol table. This function is not used directly, but via
106 cgraph/varpool node creation routines. */
107 void register_symbol (void);
109 /* Remove symbol from symbol table. */
112 /* Dump symtab node to F. */
115 /* Dump symtab node to stderr. */
116 void DEBUG_FUNCTION
debug (void);
118 /* Verify consistency of node. */
119 void DEBUG_FUNCTION
verify (void);
121 /* Return ipa reference from this symtab_node to
122 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
123 of the use and STMT the statement (if it exists). */
124 ipa_ref
*create_reference (symtab_node
*referred_node
,
125 enum ipa_ref_use use_type
);
127 /* Return ipa reference from this symtab_node to
128 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
129 of the use and STMT the statement (if it exists). */
130 ipa_ref
*create_reference (symtab_node
*referred_node
,
131 enum ipa_ref_use use_type
, gimple
*stmt
);
133 /* If VAL is a reference to a function or a variable, add a reference from
134 this symtab_node to the corresponding symbol table node. USE_TYPE specify
135 type of the use and STMT the statement (if it exists). Return the new
136 reference or NULL if none was created. */
137 ipa_ref
*maybe_create_reference (tree val
, enum ipa_ref_use use_type
,
140 /* Clone all references from symtab NODE to this symtab_node. */
141 void clone_references (symtab_node
*node
);
143 /* Remove all stmt references in non-speculative references.
144 Those are not maintained during inlining & clonning.
145 The exception are speculative references that are updated along
146 with callgraph edges associated with them. */
147 void clone_referring (symtab_node
*node
);
149 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
150 ipa_ref
*clone_reference (ipa_ref
*ref
, gimple
*stmt
);
152 /* Find the structure describing a reference to REFERRED_NODE
153 and associated with statement STMT. */
154 ipa_ref
*find_reference (symtab_node
*referred_node
, gimple
*stmt
,
155 unsigned int lto_stmt_uid
);
157 /* Remove all references that are associated with statement STMT. */
158 void remove_stmt_references (gimple
*stmt
);
160 /* Remove all stmt references in non-speculative references.
161 Those are not maintained during inlining & clonning.
162 The exception are speculative references that are updated along
163 with callgraph edges associated with them. */
164 void clear_stmts_in_references (void);
166 /* Remove all references in ref list. */
167 void remove_all_references (void);
169 /* Remove all referring items in ref list. */
170 void remove_all_referring (void);
172 /* Dump references in ref list to FILE. */
173 void dump_references (FILE *file
);
175 /* Dump referring in list to FILE. */
176 void dump_referring (FILE *);
178 /* Get number of references for this node. */
179 inline unsigned num_references (void)
181 return ref_list
.references
? ref_list
.references
->length () : 0;
184 /* Iterates I-th reference in the list, REF is also set. */
185 ipa_ref
*iterate_reference (unsigned i
, ipa_ref
*&ref
);
187 /* Iterates I-th referring item in the list, REF is also set. */
188 ipa_ref
*iterate_referring (unsigned i
, ipa_ref
*&ref
);
190 /* Iterates I-th referring alias item in the list, REF is also set. */
191 ipa_ref
*iterate_direct_aliases (unsigned i
, ipa_ref
*&ref
);
193 /* Return true if symtab node and TARGET represents
194 semantically equivalent symbols. */
195 bool semantically_equivalent_p (symtab_node
*target
);
197 /* Classify symbol symtab node for partitioning. */
198 enum symbol_partitioning_class
get_partitioning_class (void);
200 /* Return comdat group. */
201 tree
get_comdat_group ()
203 return x_comdat_group
;
206 /* Return comdat group as identifier_node. */
207 tree
get_comdat_group_id ()
209 if (x_comdat_group
&& TREE_CODE (x_comdat_group
) != IDENTIFIER_NODE
)
210 x_comdat_group
= DECL_ASSEMBLER_NAME (x_comdat_group
);
211 return x_comdat_group
;
214 /* Set comdat group. */
215 void set_comdat_group (tree group
)
217 gcc_checking_assert (!group
|| TREE_CODE (group
) == IDENTIFIER_NODE
219 x_comdat_group
= group
;
222 /* Return section as string. */
223 const char * get_section ()
227 return x_section
->name
;
230 /* Remove node from same comdat group. */
231 void remove_from_same_comdat_group (void);
233 /* Add this symtab_node to the same comdat group that OLD is in. */
234 void add_to_same_comdat_group (symtab_node
*old_node
);
236 /* Dissolve the same_comdat_group list in which NODE resides. */
237 void dissolve_same_comdat_group_list (void);
239 /* Return true when symtab_node is known to be used from other (non-LTO)
240 object file. Known only when doing LTO via linker plugin. */
241 bool used_from_object_file_p (void);
243 /* Walk the alias chain to return the symbol NODE is alias of.
244 If NODE is not an alias, return NODE.
245 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
246 symtab_node
*ultimate_alias_target (enum availability
*avail
= NULL
);
248 /* Return next reachable static symbol with initializer after NODE. */
249 inline symtab_node
*next_defined_symbol (void);
251 /* Add reference recording that symtab node is alias of TARGET.
252 The function can fail in the case of aliasing cycles; in this case
254 bool resolve_alias (symtab_node
*target
);
256 /* C++ FE sometimes change linkage flags after producing same
258 void fixup_same_cpp_alias_visibility (symtab_node
*target
);
260 /* Call callback on symtab node and aliases associated to this node.
261 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
263 bool call_for_symbol_and_aliases (bool (*callback
) (symtab_node
*, void *),
265 bool include_overwrite
);
267 /* If node can not be interposable by static or dynamic linker to point to
268 different definition, return this symbol. Otherwise look for alias with
269 such property and if none exists, introduce new one. */
270 symtab_node
*noninterposable_alias (void);
272 /* Return node that alias is aliasing. */
273 inline symtab_node
*get_alias_target (void);
275 /* Set section for symbol and its aliases. */
276 void set_section (const char *section
);
278 /* Set section, do not recurse into aliases.
279 When one wants to change section of symbol and its aliases,
281 void set_section_for_node (const char *section
);
283 /* Set initialization priority to PRIORITY. */
284 void set_init_priority (priority_type priority
);
286 /* Return the initialization priority. */
287 priority_type
get_init_priority ();
289 /* Return availability of NODE. */
290 enum availability
get_availability (void);
292 /* Make DECL local. */
293 void make_decl_local (void);
295 /* Return desired alignment of the definition. This is NOT alignment useful
296 to access THIS, because THIS may be interposable and DECL_ALIGN should
297 be used instead. It however must be guaranteed when output definition
299 unsigned int definition_alignment ();
301 /* Return true if alignment can be increased. */
302 bool can_increase_alignment_p ();
304 /* Increase alignment of symbol to ALIGN. */
305 void increase_alignment (unsigned int align
);
307 /* Return true if list contains an alias. */
308 bool has_aliases_p (void);
310 /* Return true when the symbol is real symbol, i.e. it is not inline clone
311 or abstract function kept for debug info purposes only. */
312 bool real_symbol_p (void);
314 /* Determine if symbol declaration is needed. That is, visible to something
315 either outside this translation unit, something magic in the system
316 configury. This function is used just during symbol creation. */
317 bool needed_p (void);
319 /* Return true when there are references to the node. */
320 bool referred_to_p (bool include_self
= true);
322 /* Return true if symbol can be discarded by linker from the binary.
323 Assume that symbol is used (so there is no need to take into account
324 garbage collecting linkers)
326 This can happen for comdats, commons and weaks when they are previaled
327 by other definition at static linking time. */
329 can_be_discarded_p (void)
331 return (DECL_EXTERNAL (decl
)
332 || ((get_comdat_group ()
333 || DECL_COMMON (decl
)
334 || (DECL_SECTION_NAME (decl
) && DECL_WEAK (decl
)))
335 && ((resolution
!= LDPR_PREVAILING_DEF
336 && resolution
!= LDPR_PREVAILING_DEF_IRONLY_EXP
)
337 || flag_incremental_link
)
338 && resolution
!= LDPR_PREVAILING_DEF_IRONLY
));
341 /* Return true if NODE is local to a particular COMDAT group, and must not
342 be named from outside the COMDAT. This is used for C++ decloned
344 inline bool comdat_local_p (void)
346 return (same_comdat_group
&& !TREE_PUBLIC (decl
));
349 /* Return true if ONE and TWO are part of the same COMDAT group. */
350 inline bool in_same_comdat_group_p (symtab_node
*target
);
352 /* Return true if symbol is known to be nonzero. */
353 bool nonzero_address ();
355 /* Return 0 if symbol is known to have different address than S2,
356 Return 1 if symbol is known to have same address as S2,
357 return 2 otherwise. */
358 int equal_address_to (symtab_node
*s2
);
360 /* Return true if symbol's address may possibly be compared to other
362 bool address_matters_p ();
364 /* Return true if NODE's address can be compared. This use properties
365 of NODE only and does not look if the address is actually taken in
366 interesting way. For that use ADDRESS_MATTERS_P instead. */
367 bool address_can_be_compared_p (void);
369 /* Return symbol table node associated with DECL, if any,
370 and NULL otherwise. */
371 static inline symtab_node
*get (const_tree decl
)
373 /* Check that we are called for sane type of object - functions
374 and static or external variables. */
375 gcc_checking_assert (TREE_CODE (decl
) == FUNCTION_DECL
376 || (TREE_CODE (decl
) == VAR_DECL
377 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)
379 /* Check that the mapping is sane - perhaps this check can go away,
380 but at the moment frontends tends to corrupt the mapping by calling
381 memcpy/memset on the tree nodes. */
382 gcc_checking_assert (!decl
->decl_with_vis
.symtab_node
383 || decl
->decl_with_vis
.symtab_node
->decl
== decl
);
384 return decl
->decl_with_vis
.symtab_node
;
387 /* Try to find a symtab node for declaration DECL and if it does not
388 exist or if it corresponds to an inline clone, create a new one. */
389 static inline symtab_node
* get_create (tree node
);
391 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
392 Return NULL if there's no such node. */
393 static symtab_node
*get_for_asmname (const_tree asmname
);
395 /* Dump symbol table to F. */
396 static void dump_table (FILE *);
398 /* Dump symbol table to stderr. */
399 static inline DEBUG_FUNCTION
void debug_symtab (void)
404 /* Verify symbol table for internal consistency. */
405 static DEBUG_FUNCTION
void verify_symtab_nodes (void);
407 /* Perform internal consistency checks, if they are enabled. */
408 static inline void checking_verify_symtab_nodes (void);
410 /* Type of the symbol. */
411 ENUM_BITFIELD (symtab_type
) type
: 8;
413 /* The symbols resolution. */
414 ENUM_BITFIELD (ld_plugin_symbol_resolution
) resolution
: 8;
416 /*** Flags representing the symbol type. ***/
418 /* True when symbol corresponds to a definition in current unit.
419 set via finalize_function or finalize_decl */
420 unsigned definition
: 1;
421 /* True when symbol is an alias.
422 Set by ssemble_alias. */
424 /* True when alias is a weakref. */
425 unsigned weakref
: 1;
426 /* C++ frontend produce same body aliases and extra name aliases for
427 virtual functions and vtables that are obviously equivalent.
428 Those aliases are bit special, especially because C++ frontend
429 visibility code is so ugly it can not get them right at first time
430 and their visibility needs to be copied from their "masters" at
431 the end of parsing. */
432 unsigned cpp_implicit_alias
: 1;
433 /* Set once the definition was analyzed. The list of references and
434 other properties are built during analysis. */
435 unsigned analyzed
: 1;
436 /* Set for write-only variables. */
437 unsigned writeonly
: 1;
438 /* Visibility of symbol was used for further optimization; do not
439 permit further changes. */
440 unsigned refuse_visibility_changes
: 1;
442 /*** Visibility and linkage flags. ***/
444 /* Set when function is visible by other units. */
445 unsigned externally_visible
: 1;
446 /* Don't reorder to other symbols having this set. */
447 unsigned no_reorder
: 1;
448 /* The symbol will be assumed to be used in an invisible way (like
449 by an toplevel asm statement). */
450 unsigned force_output
: 1;
451 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
452 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
453 to static and it does not inhibit optimization. */
454 unsigned forced_by_abi
: 1;
455 /* True when the name is known to be unique and thus it does not need mangling. */
456 unsigned unique_name
: 1;
457 /* Specify whether the section was set by user or by
458 compiler via -ffunction-sections. */
459 unsigned implicit_section
: 1;
460 /* True when body and other characteristics have been removed by
461 symtab_remove_unreachable_nodes. */
462 unsigned body_removed
: 1;
464 /*** WHOPR Partitioning flags.
465 These flags are used at ltrans stage when only part of the callgraph is
468 /* Set when variable is used from other LTRANS partition. */
469 unsigned used_from_other_partition
: 1;
470 /* Set when function is available in the other LTRANS partition.
471 During WPA output it is used to mark nodes that are present in
472 multiple partitions. */
473 unsigned in_other_partition
: 1;
477 /*** other flags. ***/
479 /* Set when symbol has address taken. */
480 unsigned address_taken
: 1;
481 /* Set when init priority is set. */
482 unsigned in_init_priority_hash
: 1;
484 /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
485 of offloading, for separate compilation for a different target. */
486 unsigned need_lto_streaming
: 1;
488 /* Set when symbol can be streamed into bytecode for offloading. */
489 unsigned offloadable
: 1;
492 /* Ordering of all symtab entries. */
495 /* Declaration representing the symbol. */
498 /* Linked list of symbol table entries starting with symtab_nodes. */
500 symtab_node
*previous
;
502 /* Linked list of symbols with the same asm name. There may be multiple
503 entries for single symbol name during LTO, because symbols are renamed
504 only after partitioning.
506 Because inline clones are kept in the assembler name has, they also produce
509 There are also several long standing bugs where frontends and builtin
510 code produce duplicated decls. */
511 symtab_node
*next_sharing_asm_name
;
512 symtab_node
*previous_sharing_asm_name
;
514 /* Circular list of nodes in the same comdat group if non-NULL. */
515 symtab_node
*same_comdat_group
;
517 /* Vectors of referring and referenced entities. */
518 ipa_ref_list ref_list
;
520 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
521 depending to what was known to frontend on the creation time.
522 Once alias is resolved, this pointer become NULL. */
525 /* File stream where this node is being written to. */
526 struct lto_file_decl_data
* lto_file_data
;
528 PTR
GTY ((skip
)) aux
;
530 /* Comdat group the symbol is in. Can be private if GGC allowed that. */
533 /* Section name. Again can be private, if allowed. */
534 section_hash_entry
*x_section
;
537 /* Dump base fields of symtab nodes to F. Not to be used directly. */
538 void dump_base (FILE *);
540 /* Verify common part of symtab node. */
541 bool DEBUG_FUNCTION
verify_base (void);
543 /* Remove node from symbol table. This function is not used directly, but via
544 cgraph/varpool node removal routines. */
545 void unregister (void);
547 /* Return the initialization and finalization priority information for
548 DECL. If there is no previous priority information, a freshly
549 allocated structure is returned. */
550 struct symbol_priority_map
*priority_info (void);
552 /* Worker for call_for_symbol_and_aliases_1. */
553 bool call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*, void *),
555 bool include_overwrite
);
557 /* Worker for set_section. */
558 static bool set_section (symtab_node
*n
, void *s
);
560 /* Worker for symtab_resolve_alias. */
561 static bool set_implicit_section (symtab_node
*n
, void *);
563 /* Worker searching noninterposable alias. */
564 static bool noninterposable_alias (symtab_node
*node
, void *data
);
566 /* Worker for ultimate_alias_target. */
567 symtab_node
*ultimate_alias_target_1 (enum availability
*avail
= NULL
);
571 symtab_node::checking_verify_symtab_nodes (void)
574 symtab_node::verify_symtab_nodes ();
577 /* Walk all aliases for NODE. */
578 #define FOR_EACH_ALIAS(node, alias) \
579 for (unsigned x_i = 0; node->iterate_direct_aliases (x_i, alias); x_i++)
581 /* This is the information that is put into the cgraph local structure
582 to recover a function. */
583 struct lto_file_decl_data
;
585 extern const char * const cgraph_availability_names
[];
586 extern const char * const ld_plugin_symbol_resolution_names
[];
587 extern const char * const tls_model_names
[];
589 /* Information about thunk, used only for same body aliases. */
591 struct GTY(()) cgraph_thunk_info
{
592 /* Information about the thunk. */
593 HOST_WIDE_INT fixed_offset
;
594 HOST_WIDE_INT virtual_value
;
597 bool virtual_offset_p
;
598 bool add_pointer_bounds_args
;
599 /* Set to true when alias node is thunk. */
603 /* Information about the function collected locally.
604 Available after function is analyzed. */
606 struct GTY(()) cgraph_local_info
{
607 /* Set when function is visible in current compilation unit only and
608 its address is never taken. */
611 /* False when there is something makes versioning impossible. */
612 unsigned versionable
: 1;
614 /* False when function calling convention and signature can not be changed.
615 This is the case when __builtin_apply_args is used. */
616 unsigned can_change_signature
: 1;
618 /* True when the function has been originally extern inline, but it is
620 unsigned redefined_extern_inline
: 1;
622 /* True if the function may enter serial irrevocable mode. */
623 unsigned tm_may_enter_irr
: 1;
626 /* Information about the function that needs to be computed globally
627 once compilation is finished. Available only with -funit-at-a-time. */
629 struct GTY(()) cgraph_global_info
{
630 /* For inline clones this points to the function they will be
632 cgraph_node
*inlined_to
;
635 /* Represent which DECL tree (or reference to such tree)
636 will be replaced by another tree while versioning. */
637 struct GTY(()) ipa_replace_map
639 /* The tree that will be replaced. */
641 /* The new (replacing) tree. */
643 /* Parameter number to replace, when old_tree is NULL. */
645 /* True when a substitution should be done, false otherwise. */
647 /* True when we replace a reference to old_tree. */
651 struct GTY(()) cgraph_clone_info
653 vec
<ipa_replace_map
*, va_gc
> *tree_map
;
655 bitmap combined_args_to_skip
;
658 enum cgraph_simd_clone_arg_type
660 SIMD_CLONE_ARG_TYPE_VECTOR
,
661 SIMD_CLONE_ARG_TYPE_UNIFORM
,
662 /* These are only for integer/pointer arguments passed by value. */
663 SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP
,
664 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP
,
665 /* These 6 are only for reference type arguments or arguments passed
667 SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP
,
668 SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP
,
669 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP
,
670 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP
,
671 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP
,
672 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP
,
673 SIMD_CLONE_ARG_TYPE_MASK
676 /* Function arguments in the original function of a SIMD clone.
677 Supplementary data for `struct simd_clone'. */
679 struct GTY(()) cgraph_simd_clone_arg
{
680 /* Original function argument as it originally existed in
684 /* orig_arg's function (or for extern functions type from
688 /* If argument is a vector, this holds the vector version of
689 orig_arg that after adjusting the argument types will live in
690 DECL_ARGUMENTS. Otherwise, this is NULL.
692 This basically holds:
693 vector(simdlen) __typeof__(orig_arg) new_arg. */
696 /* vector_arg's type (or for extern functions new vector type. */
699 /* If argument is a vector, this holds the array where the simd
700 argument is held while executing the simd clone function. This
701 is a local variable in the cloned function. Its content is
702 copied from vector_arg upon entry to the clone.
704 This basically holds:
705 __typeof__(orig_arg) simd_array[simdlen]. */
708 /* A SIMD clone's argument can be either linear (constant or
709 variable), uniform, or vector. */
710 enum cgraph_simd_clone_arg_type arg_type
;
712 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
713 the constant linear step, if arg_type is
714 SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
715 the uniform argument holding the step, otherwise 0. */
716 HOST_WIDE_INT linear_step
;
718 /* Variable alignment if available, otherwise 0. */
719 unsigned int alignment
;
722 /* Specific data for a SIMD function clone. */
724 struct GTY(()) cgraph_simd_clone
{
725 /* Number of words in the SIMD lane associated with this clone. */
726 unsigned int simdlen
;
728 /* Number of annotated function arguments in `args'. This is
729 usually the number of named arguments in FNDECL. */
732 /* Max hardware vector size in bits for integral vectors. */
733 unsigned int vecsize_int
;
735 /* Max hardware vector size in bits for floating point vectors. */
736 unsigned int vecsize_float
;
738 /* The mangling character for a given vector size. This is used
739 to determine the ISA mangling bit as specified in the Intel
741 unsigned char vecsize_mangle
;
743 /* True if this is the masked, in-branch version of the clone,
745 unsigned int inbranch
: 1;
747 /* True if this is a Cilk Plus variant. */
748 unsigned int cilk_elemental
: 1;
750 /* Doubly linked list of SIMD clones. */
751 cgraph_node
*prev_clone
, *next_clone
;
753 /* Original cgraph node the SIMD clones were created for. */
756 /* Annotated function arguments for the original function. */
757 cgraph_simd_clone_arg
GTY((length ("%h.nargs"))) args
[1];
760 /* Function Multiversioning info. */
761 struct GTY((for_user
)) cgraph_function_version_info
{
762 /* The cgraph_node for which the function version info is stored. */
763 cgraph_node
*this_node
;
764 /* Chains all the semantically identical function versions. The
765 first function in this chain is the version_info node of the
767 cgraph_function_version_info
*prev
;
768 /* If this version node corresponds to a dispatcher for function
769 versions, this points to the version info node of the default
770 function, the first node in the chain. */
771 cgraph_function_version_info
*next
;
772 /* If this node corresponds to a function version, this points
773 to the dispatcher function decl, which is the function that must
774 be called to execute the right function version at run-time.
776 If this cgraph node is a dispatcher (if dispatcher_function is
777 true, in the cgraph_node struct) for function versions, this
778 points to resolver function, which holds the function body of the
779 dispatcher. The dispatcher decl is an alias to the resolver
781 tree dispatcher_resolver
;
784 #define DEFCIFCODE(code, type, string) CIF_ ## code,
785 /* Reasons for inlining failures. */
787 enum cgraph_inline_failed_t
{
788 #include "cif-code.def"
792 enum cgraph_inline_failed_type_t
794 CIF_FINAL_NORMAL
= 0,
800 struct cgraph_edge_hasher
: ggc_ptr_hash
<cgraph_edge
>
802 typedef gimple
*compare_type
;
804 static hashval_t
hash (cgraph_edge
*);
805 static hashval_t
hash (gimple
*);
806 static bool equal (cgraph_edge
*, gimple
*);
809 /* The cgraph data structure.
810 Each function decl has assigned cgraph_node listing callees and callers. */
812 struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node
: public symtab_node
{
814 /* Remove the node from cgraph and all inline clones inlined into it.
815 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
816 removed. This allows to call the function from outer loop walking clone
818 bool remove_symbol_and_inline_clones (cgraph_node
*forbidden_node
= NULL
);
820 /* Record all references from cgraph_node that are taken
821 in statement STMT. */
822 void record_stmt_references (gimple
*stmt
);
824 /* Like cgraph_set_call_stmt but walk the clone tree and update all
825 clones sharing the same function body.
826 When WHOLE_SPECULATIVE_EDGES is true, all three components of
827 speculative edge gets updated. Otherwise we update only direct
829 void set_call_stmt_including_clones (gimple
*old_stmt
, gcall
*new_stmt
,
830 bool update_speculative
= true);
832 /* Walk the alias chain to return the function cgraph_node is alias of.
833 Walk through thunk, too.
834 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
835 cgraph_node
*function_symbol (enum availability
*avail
= NULL
);
837 /* Walk the alias chain to return the function cgraph_node is alias of.
838 Walk through non virtual thunks, too. Thus we return either a function
839 or a virtual thunk node.
840 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
841 cgraph_node
*function_or_virtual_thunk_symbol
842 (enum availability
*avail
= NULL
);
844 /* Create node representing clone of N executed COUNT times. Decrease
845 the execution counts from original node too.
846 The new clone will have decl set to DECL that may or may not be the same
849 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
850 function's profile to reflect the fact that part of execution is handled
852 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
853 the new clone. Otherwise the caller is responsible for doing so later.
855 If the new node is being inlined into another one, NEW_INLINED_TO should be
856 the outline function the new one is (even indirectly) inlined to.
857 All hooks will see this in node's global.inlined_to, when invoked.
858 Can be NULL if the node is not inlined. */
859 cgraph_node
*create_clone (tree decl
, gcov_type count
, int freq
,
860 bool update_original
,
861 vec
<cgraph_edge
*> redirect_callers
,
862 bool call_duplication_hook
,
863 cgraph_node
*new_inlined_to
,
864 bitmap args_to_skip
);
866 /* Create callgraph node clone with new declaration. The actual body will
867 be copied later at compilation stage. */
868 cgraph_node
*create_virtual_clone (vec
<cgraph_edge
*> redirect_callers
,
869 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
870 bitmap args_to_skip
, const char * suffix
);
872 /* cgraph node being removed from symbol table; see if its entry can be
873 replaced by other inline clone. */
874 cgraph_node
*find_replacement (void);
876 /* Create a new cgraph node which is the new version of
877 callgraph node. REDIRECT_CALLERS holds the callers
878 edges which should be redirected to point to
879 NEW_VERSION. ALL the callees edges of the node
880 are cloned to the new version node. Return the new
883 If non-NULL BLOCK_TO_COPY determine what basic blocks
884 was copied to prevent duplications of calls that are dead
887 cgraph_node
*create_version_clone (tree new_decl
,
888 vec
<cgraph_edge
*> redirect_callers
,
891 /* Perform function versioning.
892 Function versioning includes copying of the tree and
893 a callgraph update (creating a new cgraph node and updating
894 its callees and callers).
896 REDIRECT_CALLERS varray includes the edges to be redirected
899 TREE_MAP is a mapping of tree nodes we want to replace with
900 new ones (according to results of prior analysis).
902 If non-NULL ARGS_TO_SKIP determine function parameters to remove
904 If SKIP_RETURN is true, the new version will return void.
905 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
906 If non_NULL NEW_ENTRY determine new entry BB of the clone.
908 Return the new version's cgraph node. */
909 cgraph_node
*create_version_clone_with_body
910 (vec
<cgraph_edge
*> redirect_callers
,
911 vec
<ipa_replace_map
*, va_gc
> *tree_map
, bitmap args_to_skip
,
912 bool skip_return
, bitmap bbs_to_copy
, basic_block new_entry_block
,
913 const char *clone_name
);
915 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
916 corresponding to cgraph_node. */
917 cgraph_function_version_info
*insert_new_function_version (void);
919 /* Get the cgraph_function_version_info node corresponding to node. */
920 cgraph_function_version_info
*function_version (void);
922 /* Discover all functions and variables that are trivially needed, analyze
923 them as well as all functions and variables referred by them */
926 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
927 aliases DECL with an adjustments made into the first parameter.
928 See comments in thunk_adjust for detail on the parameters. */
929 cgraph_node
* create_thunk (tree alias
, tree
, bool this_adjusting
,
930 HOST_WIDE_INT fixed_offset
,
931 HOST_WIDE_INT virtual_value
,
936 /* Return node that alias is aliasing. */
937 inline cgraph_node
*get_alias_target (void);
939 /* Given function symbol, walk the alias chain to return the function node
940 is alias of. Do not walk through thunks.
941 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
943 cgraph_node
*ultimate_alias_target (availability
*availability
= NULL
);
945 /* Expand thunk NODE to gimple if possible.
946 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
947 no assembler is produced.
948 When OUTPUT_ASM_THUNK is true, also produce assembler for
949 thunks that are not lowered. */
950 bool expand_thunk (bool output_asm_thunks
, bool force_gimple_thunk
);
952 /* Call expand_thunk on all callers that are thunks and analyze those
953 nodes that were expanded. */
954 void expand_all_artificial_thunks ();
956 /* Assemble thunks and aliases associated to node. */
957 void assemble_thunks_and_aliases (void);
959 /* Expand function specified by node. */
962 /* As an GCC extension we allow redefinition of the function. The
963 semantics when both copies of bodies differ is not well defined.
964 We replace the old body with new body so in unit at a time mode
965 we always use new body, while in normal mode we may end up with
966 old body inlined into some functions and new body expanded and
967 inlined in others. */
970 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
971 kind of wrapper method. */
972 void create_wrapper (cgraph_node
*target
);
974 /* Verify cgraph nodes of the cgraph node. */
975 void DEBUG_FUNCTION
verify_node (void);
977 /* Remove function from symbol table. */
980 /* Dump call graph node to file F. */
983 /* Dump call graph node to stderr. */
984 void DEBUG_FUNCTION
debug (void);
986 /* When doing LTO, read cgraph_node's body from disk if it is not already
988 bool get_untransformed_body (void);
990 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
991 if it is not already present. When some IPA transformations are scheduled,
993 bool get_body (void);
995 /* Release memory used to represent body of function.
996 Use this only for functions that are released before being translated to
997 target code (i.e. RTL). Functions that are compiled to RTL and beyond
998 are free'd in final.c via free_after_compilation(). */
999 void release_body (bool keep_arguments
= false);
1001 /* Return the DECL_STRUCT_FUNCTION of the function. */
1002 struct function
*get_fun (void);
1004 /* cgraph_node is no longer nested function; update cgraph accordingly. */
1007 /* Bring cgraph node local. */
1008 void make_local (void);
1010 /* Likewise indicate that a node is having address taken. */
1011 void mark_address_taken (void);
1013 /* Set fialization priority to PRIORITY. */
1014 void set_fini_priority (priority_type priority
);
1016 /* Return the finalization priority. */
1017 priority_type
get_fini_priority (void);
1019 /* Create edge from a given function to CALLEE in the cgraph. */
1020 cgraph_edge
*create_edge (cgraph_node
*callee
,
1021 gcall
*call_stmt
, gcov_type count
,
1024 /* Create an indirect edge with a yet-undetermined callee where the call
1025 statement destination is a formal parameter of the caller with index
1027 cgraph_edge
*create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
1028 gcov_type count
, int freq
,
1029 bool compute_indirect_info
= true);
1031 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
1032 same function body. If clones already have edge for OLD_STMT; only
1033 update the edge same way as cgraph_set_call_stmt_including_clones does. */
1034 void create_edge_including_clones (cgraph_node
*callee
,
1035 gimple
*old_stmt
, gcall
*stmt
,
1038 cgraph_inline_failed_t reason
);
1040 /* Return the callgraph edge representing the GIMPLE_CALL statement
1042 cgraph_edge
*get_edge (gimple
*call_stmt
);
1044 /* Collect all callers of cgraph_node and its aliases that are known to lead
1045 to NODE (i.e. are not overwritable). */
1046 vec
<cgraph_edge
*> collect_callers (void);
1048 /* Remove all callers from the node. */
1049 void remove_callers (void);
1051 /* Remove all callees from the node. */
1052 void remove_callees (void);
1054 /* Return function availability. See cgraph.h for description of individual
1056 enum availability
get_availability (void);
1058 /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
1059 if any to NOTHROW. */
1060 void set_nothrow_flag (bool nothrow
);
1062 /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
1063 if any to READONLY. */
1064 void set_const_flag (bool readonly
, bool looping
);
1066 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
1068 void set_pure_flag (bool pure
, bool looping
);
1070 /* Call callback on function and aliases associated to the function.
1071 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1074 bool call_for_symbol_and_aliases (bool (*callback
) (cgraph_node
*,
1076 void *data
, bool include_overwritable
);
1078 /* Call callback on cgraph_node, thunks and aliases associated to NODE.
1079 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1080 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
1082 bool call_for_symbol_thunks_and_aliases (bool (*callback
) (cgraph_node
*node
,
1085 bool include_overwritable
,
1086 bool exclude_virtual_thunks
= false);
1088 /* Likewise indicate that a node is needed, i.e. reachable via some
1090 inline void mark_force_output (void);
1092 /* Return true when function can be marked local. */
1093 bool local_p (void);
1095 /* Return true if cgraph_node can be made local for API change.
1096 Extern inline functions and C++ COMDAT functions can be made local
1097 at the expense of possible code size growth if function is used in multiple
1098 compilation units. */
1099 bool can_be_local_p (void);
1101 /* Return true when cgraph_node can not return or throw and thus
1102 it is safe to ignore its side effects for IPA analysis. */
1103 bool cannot_return_p (void);
1105 /* Return true when function cgraph_node and all its aliases are only called
1107 i.e. it is not externally visible, address was not taken and
1108 it is not used in any other non-standard way. */
1109 bool only_called_directly_p (void);
1111 /* Return true when function is only called directly or it has alias.
1112 i.e. it is not externally visible, address was not taken and
1113 it is not used in any other non-standard way. */
1114 inline bool only_called_directly_or_aliased_p (void);
1116 /* Return true when function cgraph_node can be expected to be removed
1117 from program when direct calls in this compilation unit are removed.
1119 As a special case COMDAT functions are
1120 cgraph_can_remove_if_no_direct_calls_p while the are not
1121 cgraph_only_called_directly_p (it is possible they are called from other
1124 This function behaves as cgraph_only_called_directly_p because eliminating
1125 all uses of COMDAT function does not make it necessarily disappear from
1126 the program unless we are compiling whole program or we do LTO. In this
1127 case we know we win since dynamic linking will not really discard the
1130 If WILL_INLINE is true, assume that function will be inlined into all the
1132 bool will_be_removed_from_program_if_no_direct_calls_p
1133 (bool will_inline
= false);
1135 /* Return true when function can be removed from callgraph
1136 if all direct calls and references are eliminated. The function does
1137 not take into account comdat groups. */
1138 bool can_remove_if_no_direct_calls_and_refs_p (void);
1140 /* Return true when function cgraph_node and its aliases can be removed from
1141 callgraph if all direct calls are eliminated.
1142 If WILL_INLINE is true, assume that function will be inlined into all the
1144 bool can_remove_if_no_direct_calls_p (bool will_inline
= false);
1146 /* Return true when callgraph node is a function with Gimple body defined
1147 in current unit. Functions can also be define externally or they
1148 can be thunks with no Gimple representation.
1150 Note that at WPA stage, the function body may not be present in memory. */
1151 inline bool has_gimple_body_p (void);
1153 /* Return true if function should be optimized for size. */
1154 bool optimize_for_size_p (void);
1156 /* Dump the callgraph to file F. */
1157 static void dump_cgraph (FILE *f
);
1159 /* Dump the call graph to stderr. */
1161 void debug_cgraph (void)
1163 dump_cgraph (stderr
);
1166 /* Record that DECL1 and DECL2 are semantically identical function
1168 static void record_function_versions (tree decl1
, tree decl2
);
1170 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
1171 DECL is a duplicate declaration. */
1172 static void delete_function_version (tree decl
);
1174 /* Add the function FNDECL to the call graph.
1175 Unlike finalize_function, this function is intended to be used
1176 by middle end and allows insertion of new function at arbitrary point
1177 of compilation. The function can be either in high, low or SSA form
1180 The function is assumed to be reachable and have address taken (so no
1181 API breaking optimizations are performed on it).
1183 Main work done by this function is to enqueue the function for later
1184 processing to avoid need the passes to be re-entrant. */
1185 static void add_new_function (tree fndecl
, bool lowered
);
1187 /* Return callgraph node for given symbol and check it is a function. */
1188 static inline cgraph_node
*get (const_tree decl
)
1190 gcc_checking_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1191 return dyn_cast
<cgraph_node
*> (symtab_node::get (decl
));
1194 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
1195 logic in effect. If NO_COLLECT is true, then our caller cannot stand to
1196 have the garbage collector run at the moment. We would need to either
1197 create a new GC context, or just not compile right now. */
1198 static void finalize_function (tree
, bool);
1200 /* Return cgraph node assigned to DECL. Create new one when needed. */
1201 static cgraph_node
* create (tree decl
);
1203 /* Try to find a call graph node for declaration DECL and if it does not
1204 exist or if it corresponds to an inline clone, create a new one. */
1205 static cgraph_node
* get_create (tree
);
1207 /* Return local info for the compiled function. */
1208 static cgraph_local_info
*local_info (tree decl
);
1210 /* Return local info for the compiled function. */
1211 static struct cgraph_rtl_info
*rtl_info (tree
);
1213 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1214 Return NULL if there's no such node. */
1215 static cgraph_node
*get_for_asmname (tree asmname
);
1217 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if
1218 successful and NULL otherwise.
1219 Same body aliases are output whenever the body of DECL is output,
1220 and cgraph_node::get (ALIAS) transparently
1221 returns cgraph_node::get (DECL). */
1222 static cgraph_node
* create_same_body_alias (tree alias
, tree decl
);
1224 /* Verify whole cgraph structure. */
1225 static void DEBUG_FUNCTION
verify_cgraph_nodes (void);
1227 /* Verify cgraph, if consistency checking is enabled. */
1228 static inline void checking_verify_cgraph_nodes (void);
1230 /* Worker to bring NODE local. */
1231 static bool make_local (cgraph_node
*node
, void *);
1233 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
1234 the function body is associated
1235 with (not necessarily cgraph_node (DECL). */
1236 static cgraph_node
*create_alias (tree alias
, tree target
);
1238 /* Return true if NODE has thunk. */
1239 static bool has_thunk_p (cgraph_node
*node
, void *);
1241 cgraph_edge
*callees
;
1242 cgraph_edge
*callers
;
1243 /* List of edges representing indirect calls with a yet undetermined
1245 cgraph_edge
*indirect_calls
;
1246 /* For nested functions points to function the node is nested in. */
1247 cgraph_node
*origin
;
1248 /* Points to first nested function, if any. */
1249 cgraph_node
*nested
;
1250 /* Pointer to the next function with same origin, if any. */
1251 cgraph_node
*next_nested
;
1252 /* Pointer to the next clone. */
1253 cgraph_node
*next_sibling_clone
;
1254 cgraph_node
*prev_sibling_clone
;
1255 cgraph_node
*clones
;
1256 cgraph_node
*clone_of
;
1257 /* If instrumentation_clone is 1 then instrumented_version points
1258 to the original function used to make instrumented version.
1259 Otherwise points to instrumented version of the function. */
1260 cgraph_node
*instrumented_version
;
1261 /* If instrumentation_clone is 1 then orig_decl is the original
1262 function declaration. */
1264 /* For functions with many calls sites it holds map from call expression
1265 to the edge to speed up cgraph_edge function. */
1266 hash_table
<cgraph_edge_hasher
> *GTY(()) call_site_hash
;
1267 /* Declaration node used to be clone of. */
1268 tree former_clone_of
;
1270 /* If this is a SIMD clone, this points to the SIMD specific
1271 information for it. */
1272 cgraph_simd_clone
*simdclone
;
1273 /* If this function has SIMD clones, this points to the first clone. */
1274 cgraph_node
*simd_clones
;
1276 /* Interprocedural passes scheduled to have their transform functions
1277 applied next time we execute local pass on them. We maintain it
1278 per-function in order to allow IPA passes to introduce new functions. */
1279 vec
<ipa_opt_pass
> GTY((skip
)) ipa_transforms_to_apply
;
1281 cgraph_local_info local
;
1282 cgraph_global_info global
;
1283 struct cgraph_rtl_info
*rtl
;
1284 cgraph_clone_info clone
;
1285 cgraph_thunk_info thunk
;
1287 /* Expected number of executions: calculated in profile.c. */
1289 /* How to scale counts at materialization time; used to merge
1290 LTO units with different number of profile runs. */
1291 int count_materialization_scale
;
1292 /* Unique id of the node. */
1294 /* Summary unique id of the node. */
1296 /* ID assigned by the profiling. */
1297 unsigned int profile_id
;
1298 /* Time profiler: first run of function. */
1301 /* Set when decl is an abstract function pointed to by the
1302 ABSTRACT_DECL_ORIGIN of a reachable function. */
1303 unsigned used_as_abstract_origin
: 1;
1304 /* Set once the function is lowered (i.e. its CFG is built). */
1305 unsigned lowered
: 1;
1306 /* Set once the function has been instantiated and its callee
1308 unsigned process
: 1;
1309 /* How commonly executed the node is. Initialized during branch
1310 probabilities pass. */
1311 ENUM_BITFIELD (node_frequency
) frequency
: 2;
1312 /* True when function can only be called at startup (from static ctor). */
1313 unsigned only_called_at_startup
: 1;
1314 /* True when function can only be called at startup (from static dtor). */
1315 unsigned only_called_at_exit
: 1;
1316 /* True when function is the transactional clone of a function which
1317 is called only from inside transactions. */
1318 /* ?? We should be able to remove this. We have enough bits in
1319 cgraph to calculate it. */
1320 unsigned tm_clone
: 1;
1321 /* True if this decl is a dispatcher for function versions. */
1322 unsigned dispatcher_function
: 1;
1323 /* True if this decl calls a COMDAT-local function. This is set up in
1324 compute_inline_parameters and inline_call. */
1325 unsigned calls_comdat_local
: 1;
1326 /* True if node has been created by merge operation in IPA-ICF. */
1327 unsigned icf_merged
: 1;
1328 /* True when function is clone created for Pointer Bounds Checker
1330 unsigned instrumentation_clone
: 1;
1331 /* True if call to node can't result in a call to free, munmap or
1332 other operation that could make previously non-trapping memory
1333 accesses trapping. */
1334 unsigned nonfreeing_fn
: 1;
1335 /* True if there was multiple COMDAT bodies merged by lto-symtab. */
1336 unsigned merged
: 1;
1337 /* True if function was created to be executed in parallel. */
1338 unsigned parallelized_function
: 1;
1339 /* True if function is part split out by ipa-split. */
1340 unsigned split_part
: 1;
1343 /* Worker for call_for_symbol_and_aliases. */
1344 bool call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
1346 void *data
, bool include_overwritable
);
1349 /* A cgraph node set is a collection of cgraph nodes. A cgraph node
1350 can appear in multiple sets. */
1351 struct cgraph_node_set_def
1353 hash_map
<cgraph_node
*, size_t> *map
;
1354 vec
<cgraph_node
*> nodes
;
1357 typedef cgraph_node_set_def
*cgraph_node_set
;
1358 typedef struct varpool_node_set_def
*varpool_node_set
;
1362 /* A varpool node set is a collection of varpool nodes. A varpool node
1363 can appear in multiple sets. */
1364 struct varpool_node_set_def
1366 hash_map
<varpool_node
*, size_t> * map
;
1367 vec
<varpool_node
*> nodes
;
1370 /* Iterator structure for cgraph node sets. */
1371 struct cgraph_node_set_iterator
1373 cgraph_node_set set
;
1377 /* Iterator structure for varpool node sets. */
1378 struct varpool_node_set_iterator
1380 varpool_node_set set
;
1384 /* Context of polymorphic call. It represent information about the type of
1385 instance that may reach the call. This is used by ipa-devirt walkers of the
1386 type inheritance graph. */
1388 class GTY(()) ipa_polymorphic_call_context
{
1390 /* The called object appears in an object of type OUTER_TYPE
1391 at offset OFFSET. When information is not 100% reliable, we
1392 use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
1393 HOST_WIDE_INT offset
;
1394 HOST_WIDE_INT speculative_offset
;
1396 tree speculative_outer_type
;
1397 /* True if outer object may be in construction or destruction. */
1398 unsigned maybe_in_construction
: 1;
1399 /* True if outer object may be of derived type. */
1400 unsigned maybe_derived_type
: 1;
1401 /* True if speculative outer object may be of derived type. We always
1402 speculate that construction does not happen. */
1403 unsigned speculative_maybe_derived_type
: 1;
1404 /* True if the context is invalid and all calls should be redirected
1405 to BUILTIN_UNREACHABLE. */
1406 unsigned invalid
: 1;
1407 /* True if the outer type is dynamic. */
1408 unsigned dynamic
: 1;
1410 /* Build empty "I know nothing" context. */
1411 ipa_polymorphic_call_context ();
1412 /* Build polymorphic call context for indirect call E. */
1413 ipa_polymorphic_call_context (cgraph_edge
*e
);
1414 /* Build polymorphic call context for IP invariant CST.
1415 If specified, OTR_TYPE specify the type of polymorphic call
1416 that takes CST+OFFSET as a prameter. */
1417 ipa_polymorphic_call_context (tree cst
, tree otr_type
= NULL
,
1418 HOST_WIDE_INT offset
= 0);
1419 /* Build context for pointer REF contained in FNDECL at statement STMT.
1420 if INSTANCE is non-NULL, return pointer to the object described by
1422 ipa_polymorphic_call_context (tree fndecl
, tree ref
, gimple
*stmt
,
1423 tree
*instance
= NULL
);
1425 /* Look for vtable stores or constructor calls to work out dynamic type
1426 of memory location. */
1427 bool get_dynamic_type (tree
, tree
, tree
, gimple
*);
1429 /* Make context non-speculative. */
1430 void clear_speculation ();
1432 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
1433 NULL, the context is set to dummy "I know nothing" setting. */
1434 void clear_outer_type (tree otr_type
= NULL
);
1436 /* Walk container types and modify context to point to actual class
1437 containing OTR_TYPE (if non-NULL) as base class.
1438 Return true if resulting context is valid.
1440 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
1441 valid only via alocation of new polymorphic type inside by means
1444 When CONSIDER_BASES is false, only look for actual fields, not base types
1446 bool restrict_to_inner_class (tree otr_type
,
1447 bool consider_placement_new
= true,
1448 bool consider_bases
= true);
1450 /* Adjust all offsets in contexts by given number of bits. */
1451 void offset_by (HOST_WIDE_INT
);
1452 /* Use when we can not track dynamic type change. This speculatively assume
1453 type change is not happening. */
1454 void possible_dynamic_type_change (bool, tree otr_type
= NULL
);
1455 /* Assume that both THIS and a given context is valid and strenghten THIS
1456 if possible. Return true if any strenghtening was made.
1457 If actual type the context is being used in is known, OTR_TYPE should be
1458 set accordingly. This improves quality of combined result. */
1459 bool combine_with (ipa_polymorphic_call_context
, tree otr_type
= NULL
);
1460 bool meet_with (ipa_polymorphic_call_context
, tree otr_type
= NULL
);
1462 /* Return TRUE if context is fully useless. */
1463 bool useless_p () const;
1464 /* Return TRUE if this context conveys the same information as X. */
1465 bool equal_to (const ipa_polymorphic_call_context
&x
) const;
1467 /* Dump human readable context to F. If NEWLINE is true, it will be
1468 terminated by a newline. */
1469 void dump (FILE *f
, bool newline
= true) const;
1470 void DEBUG_FUNCTION
debug () const;
1472 /* LTO streaming. */
1473 void stream_out (struct output_block
*) const;
1474 void stream_in (struct lto_input_block
*, struct data_in
*data_in
);
1477 bool combine_speculation_with (tree
, HOST_WIDE_INT
, bool, tree
);
1478 bool meet_speculation_with (tree
, HOST_WIDE_INT
, bool, tree
);
1479 void set_by_decl (tree
, HOST_WIDE_INT
);
1480 bool set_by_invariant (tree
, tree
, HOST_WIDE_INT
);
1481 bool speculation_consistent_p (tree
, HOST_WIDE_INT
, bool, tree
) const;
1482 void make_speculative (tree otr_type
= NULL
);
1485 /* Structure containing additional information about an indirect call. */
1487 struct GTY(()) cgraph_indirect_call_info
1489 /* When agg_content is set, an offset where the call pointer is located
1490 within the aggregate. */
1491 HOST_WIDE_INT offset
;
1492 /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */
1493 ipa_polymorphic_call_context context
;
1494 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
1495 HOST_WIDE_INT otr_token
;
1496 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
1498 /* Index of the parameter that is called. */
1500 /* ECF flags determined from the caller. */
1502 /* Profile_id of common target obtrained from profile. */
1503 int common_target_id
;
1504 /* Probability that call will land in function with COMMON_TARGET_ID. */
1505 int common_target_probability
;
1507 /* Set when the call is a virtual call with the parameter being the
1508 associated object pointer rather than a simple direct call. */
1509 unsigned polymorphic
: 1;
1510 /* Set when the call is a call of a pointer loaded from contents of an
1511 aggregate at offset. */
1512 unsigned agg_contents
: 1;
1513 /* Set when this is a call through a member pointer. */
1514 unsigned member_ptr
: 1;
1515 /* When the previous bit is set, this one determines whether the destination
1516 is loaded from a parameter passed by reference. */
1517 unsigned by_ref
: 1;
1518 /* For polymorphic calls this specify whether the virtual table pointer
1519 may have changed in between function entry and the call. */
1520 unsigned vptr_changed
: 1;
1523 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
1524 for_user
)) cgraph_edge
{
1525 friend class cgraph_node
;
1527 /* Remove the edge in the cgraph. */
1530 /* Change field call_stmt of edge to NEW_STMT.
1531 If UPDATE_SPECULATIVE and E is any component of speculative
1532 edge, then update all components. */
1533 void set_call_stmt (gcall
*new_stmt
, bool update_speculative
= true);
1535 /* Redirect callee of the edge to N. The function does not update underlying
1537 void redirect_callee (cgraph_node
*n
);
1539 /* If the edge does not lead to a thunk, simply redirect it to N. Otherwise
1540 create one or more equivalent thunks for N and redirect E to the first in
1541 the chain. Note that it is then necessary to call
1542 n->expand_all_artificial_thunks once all callers are redirected. */
1543 void redirect_callee_duplicating_thunks (cgraph_node
*n
);
1545 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1546 CALLEE. DELTA is an integer constant that is to be added to the this
1547 pointer (first parameter) to compensate for skipping
1548 a thunk adjustment. */
1549 cgraph_edge
*make_direct (cgraph_node
*callee
);
1551 /* Turn edge into speculative call calling N2. Update
1552 the profile so the direct call is taken COUNT times
1554 cgraph_edge
*make_speculative (cgraph_node
*n2
, gcov_type direct_count
,
1555 int direct_frequency
);
1557 /* Given speculative call edge, return all three components. */
1558 void speculative_call_info (cgraph_edge
*&direct
, cgraph_edge
*&indirect
,
1559 ipa_ref
*&reference
);
1561 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1562 Remove the speculative call sequence and return edge representing the call.
1563 It is up to caller to redirect the call as appropriate. */
1564 cgraph_edge
*resolve_speculation (tree callee_decl
= NULL
);
1566 /* If necessary, change the function declaration in the call statement
1567 associated with the edge so that it corresponds to the edge callee. */
1568 gimple
*redirect_call_stmt_to_callee (void);
1570 /* Create clone of edge in the node N represented
1571 by CALL_EXPR the callgraph. */
1572 cgraph_edge
* clone (cgraph_node
*n
, gcall
*call_stmt
, unsigned stmt_uid
,
1573 gcov_type count_scale
, int freq_scale
, bool update_original
);
1575 /* Verify edge count and frequency. */
1576 bool verify_count_and_frequency ();
1578 /* Return true when call of edge can not lead to return from caller
1579 and thus it is safe to ignore its side effects for IPA analysis
1580 when computing side effects of the caller. */
1581 bool cannot_lead_to_return_p (void);
1583 /* Return true when the edge represents a direct recursion. */
1584 bool recursive_p (void);
1586 /* Return true if the call can be hot. */
1587 bool maybe_hot_p (void);
1589 /* Rebuild cgraph edges for current function node. This needs to be run after
1590 passes that don't update the cgraph. */
1591 static unsigned int rebuild_edges (void);
1593 /* Rebuild cgraph references for current function node. This needs to be run
1594 after passes that don't update the cgraph. */
1595 static void rebuild_references (void);
1597 /* Expected number of executions: calculated in profile.c. */
1599 cgraph_node
*caller
;
1600 cgraph_node
*callee
;
1601 cgraph_edge
*prev_caller
;
1602 cgraph_edge
*next_caller
;
1603 cgraph_edge
*prev_callee
;
1604 cgraph_edge
*next_callee
;
1606 /* Additional information about an indirect call. Not cleared when an edge
1608 cgraph_indirect_call_info
*indirect_info
;
1609 PTR
GTY ((skip (""))) aux
;
1610 /* When equal to CIF_OK, inline this call. Otherwise, points to the
1611 explanation why function was not inlined. */
1612 enum cgraph_inline_failed_t inline_failed
;
1613 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
1614 when the function is serialized in. */
1615 unsigned int lto_stmt_uid
;
1616 /* Expected frequency of executions within the function.
1617 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
1618 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
1620 /* Unique id of the edge. */
1622 /* Whether this edge was made direct by indirect inlining. */
1623 unsigned int indirect_inlining_edge
: 1;
1624 /* Whether this edge describes an indirect call with an undetermined
1626 unsigned int indirect_unknown_callee
: 1;
1627 /* Whether this edge is still a dangling */
1628 /* True if the corresponding CALL stmt cannot be inlined. */
1629 unsigned int call_stmt_cannot_inline_p
: 1;
1630 /* Can this call throw externally? */
1631 unsigned int can_throw_external
: 1;
1632 /* Edges with SPECULATIVE flag represents indirect calls that was
1633 speculatively turned into direct (i.e. by profile feedback).
1634 The final code sequence will have form:
1636 if (call_target == expected_fn)
1641 Every speculative call is represented by three components attached
1642 to a same call statement:
1643 1) a direct call (to expected_fn)
1644 2) an indirect call (to call_target)
1645 3) a IPA_REF_ADDR refrence to expected_fn.
1647 Optimizers may later redirect direct call to clone, so 1) and 3)
1648 do not need to necesarily agree with destination. */
1649 unsigned int speculative
: 1;
1650 /* Set to true when caller is a constructor or destructor of polymorphic
1652 unsigned in_polymorphic_cdtor
: 1;
1655 /* Remove the edge from the list of the callers of the callee. */
1656 void remove_caller (void);
1658 /* Remove the edge from the list of the callees of the caller. */
1659 void remove_callee (void);
1661 /* Set callee N of call graph edge and add it to the corresponding set of
1663 void set_callee (cgraph_node
*n
);
1665 /* Output flags of edge to a file F. */
1666 void dump_edge_flags (FILE *f
);
1668 /* Verify that call graph edge corresponds to DECL from the associated
1669 statement. Return true if the verification should fail. */
1670 bool verify_corresponds_to_fndecl (tree decl
);
1673 #define CGRAPH_FREQ_BASE 1000
1674 #define CGRAPH_FREQ_MAX 100000
1676 /* The varpool data structure.
1677 Each static variable decl has assigned varpool_node. */
1679 class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node
: public symtab_node
{
1681 /* Dump given varpool node to F. */
1682 void dump (FILE *f
);
1684 /* Dump given varpool node to stderr. */
1685 void DEBUG_FUNCTION
debug (void);
1687 /* Remove variable from symbol table. */
1690 /* Remove node initializer when it is no longer needed. */
1691 void remove_initializer (void);
1693 void analyze (void);
1695 /* Return variable availability. */
1696 availability
get_availability (void);
1698 /* When doing LTO, read variable's constructor from disk if
1699 it is not already present. */
1700 tree
get_constructor (void);
1702 /* Return true if variable has constructor that can be used for folding. */
1703 bool ctor_useable_for_folding_p (void);
1705 /* For given variable pool node, walk the alias chain to return the function
1706 the variable is alias of. Do not walk through thunks.
1707 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
1708 inline varpool_node
*ultimate_alias_target
1709 (availability
*availability
= NULL
);
1711 /* Return node that alias is aliasing. */
1712 inline varpool_node
*get_alias_target (void);
1714 /* Output one variable, if necessary. Return whether we output it. */
1715 bool assemble_decl (void);
1717 /* For variables in named sections make sure get_variable_section
1718 is called before we switch to those sections. Then section
1719 conflicts between read-only and read-only requiring relocations
1720 sections can be resolved. */
1721 void finalize_named_section_flags (void);
1723 /* Call calback on varpool symbol and aliases associated to varpool symbol.
1724 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1726 bool call_for_symbol_and_aliases (bool (*callback
) (varpool_node
*, void *),
1728 bool include_overwritable
);
1730 /* Return true when variable should be considered externally visible. */
1731 bool externally_visible_p (void);
1733 /* Return true when all references to variable must be visible
1735 i.e. if the variable is not externally visible or not used in some magic
1736 way (asm statement or such).
1737 The magic uses are all summarized in force_output flag. */
1738 inline bool all_refs_explicit_p ();
1740 /* Return true when variable can be removed from variable pool
1741 if all direct calls are eliminated. */
1742 inline bool can_remove_if_no_refs_p (void);
1744 /* Add the variable DECL to the varpool.
1745 Unlike finalize_decl function is intended to be used
1746 by middle end and allows insertion of new variable at arbitrary point
1748 static void add (tree decl
);
1750 /* Return varpool node for given symbol and check it is a function. */
1751 static inline varpool_node
*get (const_tree decl
);
1753 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
1754 the middle end to output the variable to asm file, if needed or externally
1756 static void finalize_decl (tree decl
);
1758 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1759 Extra name aliases are output whenever DECL is output. */
1760 static varpool_node
* create_extra_name_alias (tree alias
, tree decl
);
1762 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1763 Extra name aliases are output whenever DECL is output. */
1764 static varpool_node
* create_alias (tree
, tree
);
1766 /* Dump the variable pool to F. */
1767 static void dump_varpool (FILE *f
);
1769 /* Dump the variable pool to stderr. */
1770 static void DEBUG_FUNCTION
debug_varpool (void);
1772 /* Allocate new callgraph node and insert it into basic data structures. */
1773 static varpool_node
*create_empty (void);
1775 /* Return varpool node assigned to DECL. Create new one when needed. */
1776 static varpool_node
*get_create (tree decl
);
1778 /* Given an assembler name, lookup node. */
1779 static varpool_node
*get_for_asmname (tree asmname
);
1781 /* Set when variable is scheduled to be assembled. */
1782 unsigned output
: 1;
1784 /* Set when variable has statically initialized pointer
1785 or is a static bounds variable and needs initalization. */
1786 unsigned need_bounds_init
: 1;
1788 /* Set if the variable is dynamically initialized, except for
1789 function local statics. */
1790 unsigned dynamically_initialized
: 1;
1792 ENUM_BITFIELD(tls_model
) tls_model
: 3;
1794 /* Set if the variable is known to be used by single function only.
1795 This is computed by ipa_signle_use pass and used by late optimizations
1796 in places where optimization would be valid for local static variable
1797 if we did not do any inter-procedural code movement. */
1798 unsigned used_by_single_function
: 1;
1801 /* Assemble thunks and aliases associated to varpool node. */
1802 void assemble_aliases (void);
1804 /* Worker for call_for_node_and_aliases. */
1805 bool call_for_symbol_and_aliases_1 (bool (*callback
) (varpool_node
*, void *),
1807 bool include_overwritable
);
1810 /* Every top level asm statement is put into a asm_node. */
1812 struct GTY(()) asm_node
{
1815 /* Next asm node. */
1817 /* String for this asm node. */
1819 /* Ordering of all cgraph nodes. */
1823 /* Report whether or not THIS symtab node is a function, aka cgraph_node. */
1828 is_a_helper
<cgraph_node
*>::test (symtab_node
*p
)
1830 return p
&& p
->type
== SYMTAB_FUNCTION
;
1833 /* Report whether or not THIS symtab node is a vriable, aka varpool_node. */
1838 is_a_helper
<varpool_node
*>::test (symtab_node
*p
)
1840 return p
&& p
->type
== SYMTAB_VARIABLE
;
1843 /* Macros to access the next item in the list of free cgraph nodes and
1845 #define NEXT_FREE_NODE(NODE) dyn_cast<cgraph_node *> ((NODE)->next)
1846 #define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->next = NODE2
1847 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
1849 typedef void (*cgraph_edge_hook
)(cgraph_edge
*, void *);
1850 typedef void (*cgraph_node_hook
)(cgraph_node
*, void *);
1851 typedef void (*varpool_node_hook
)(varpool_node
*, void *);
1852 typedef void (*cgraph_2edge_hook
)(cgraph_edge
*, cgraph_edge
*, void *);
1853 typedef void (*cgraph_2node_hook
)(cgraph_node
*, cgraph_node
*, void *);
1855 struct cgraph_edge_hook_list
;
1856 struct cgraph_node_hook_list
;
1857 struct varpool_node_hook_list
;
1858 struct cgraph_2edge_hook_list
;
1859 struct cgraph_2node_hook_list
;
1861 /* Map from a symbol to initialization/finalization priorities. */
1862 struct GTY(()) symbol_priority_map
{
1869 /* Frontend is parsing and finalizing functions. */
1871 /* Callgraph is being constructed. It is safe to add new functions. */
1873 /* Callgraph is being streamed-in at LTO time. */
1875 /* Callgraph is built and early IPA passes are being run. */
1877 /* Callgraph is built and all functions are transformed to SSA form. */
1879 /* All inline decisions are done; it is now possible to remove extern inline
1880 functions and virtual call targets. */
1881 IPA_SSA_AFTER_INLINING
,
1882 /* Functions are now ordered and being passed to RTL expanders. */
1884 /* All cgraph expansion is done. */
1888 struct asmname_hasher
: ggc_ptr_hash
<symtab_node
>
1890 typedef const_tree compare_type
;
1892 static hashval_t
hash (symtab_node
*n
);
1893 static bool equal (symtab_node
*n
, const_tree t
);
1896 class GTY((tag ("SYMTAB"))) symbol_table
1899 friend class symtab_node
;
1900 friend class cgraph_node
;
1901 friend class cgraph_edge
;
1903 symbol_table (): cgraph_max_summary_uid (1)
1907 /* Initialize callgraph dump file. */
1908 void initialize (void);
1910 /* Register a top-level asm statement ASM_STR. */
1911 inline asm_node
*finalize_toplevel_asm (tree asm_str
);
1913 /* Analyze the whole compilation unit once it is parsed completely. */
1914 void finalize_compilation_unit (void);
1916 /* C++ frontend produce same body aliases all over the place, even before PCH
1917 gets streamed out. It relies on us linking the aliases with their function
1918 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
1919 first produce aliases without links, but once C++ FE is sure he won't sream
1920 PCH we build the links via this function. */
1921 void process_same_body_aliases (void);
1923 /* Perform simple optimizations based on callgraph. */
1924 void compile (void);
1926 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
1927 functions into callgraph in a way so they look like ordinary reachable
1928 functions inserted into callgraph already at construction time. */
1929 void process_new_functions (void);
1931 /* Once all functions from compilation unit are in memory, produce all clones
1932 and update all calls. We might also do this on demand if we don't want to
1933 bring all functions to memory prior compilation, but current WHOPR
1934 implementation does that and it is bit easier to keep everything right
1936 void materialize_all_clones (void);
1938 /* Register a symbol NODE. */
1939 inline void register_symbol (symtab_node
*node
);
1942 clear_asm_symbols (void)
1945 asm_last_node
= NULL
;
1948 /* Perform reachability analysis and reclaim all unreachable nodes. */
1949 bool remove_unreachable_nodes (FILE *file
);
1951 /* Optimization of function bodies might've rendered some variables as
1952 unnecessary so we want to avoid these from being compiled. Re-do
1953 reachability starting from variables that are either externally visible
1954 or was referred from the asm output routines. */
1955 void remove_unreferenced_decls (void);
1957 /* Unregister a symbol NODE. */
1958 inline void unregister (symtab_node
*node
);
1960 /* Allocate new callgraph node and insert it into basic data structures. */
1961 cgraph_node
*create_empty (void);
1963 /* Release a callgraph NODE with UID and put in to the list
1965 void release_symbol (cgraph_node
*node
, int uid
);
1967 /* Output all variables enqueued to be assembled. */
1968 bool output_variables (void);
1970 /* Weakrefs may be associated to external decls and thus not output
1971 at expansion time. Emit all necessary aliases. */
1972 void output_weakrefs (void);
1974 /* Return first static symbol with definition. */
1975 inline symtab_node
*first_symbol (void);
1977 /* Return first assembler symbol. */
1979 first_asm_symbol (void)
1984 /* Return first static symbol with definition. */
1985 inline symtab_node
*first_defined_symbol (void);
1987 /* Return first variable. */
1988 inline varpool_node
*first_variable (void);
1990 /* Return next variable after NODE. */
1991 inline varpool_node
*next_variable (varpool_node
*node
);
1993 /* Return first static variable with initializer. */
1994 inline varpool_node
*first_static_initializer (void);
1996 /* Return next static variable with initializer after NODE. */
1997 inline varpool_node
*next_static_initializer (varpool_node
*node
);
1999 /* Return first static variable with definition. */
2000 inline varpool_node
*first_defined_variable (void);
2002 /* Return next static variable with definition after NODE. */
2003 inline varpool_node
*next_defined_variable (varpool_node
*node
);
2005 /* Return first function with body defined. */
2006 inline cgraph_node
*first_defined_function (void);
2008 /* Return next function with body defined after NODE. */
2009 inline cgraph_node
*next_defined_function (cgraph_node
*node
);
2011 /* Return first function. */
2012 inline cgraph_node
*first_function (void);
2014 /* Return next function. */
2015 inline cgraph_node
*next_function (cgraph_node
*node
);
2017 /* Return first function with body defined. */
2018 cgraph_node
*first_function_with_gimple_body (void);
2020 /* Return next reachable static variable with initializer after NODE. */
2021 inline cgraph_node
*next_function_with_gimple_body (cgraph_node
*node
);
2023 /* Register HOOK to be called with DATA on each removed edge. */
2024 cgraph_edge_hook_list
*add_edge_removal_hook (cgraph_edge_hook hook
,
2027 /* Remove ENTRY from the list of hooks called on removing edges. */
2028 void remove_edge_removal_hook (cgraph_edge_hook_list
*entry
);
2030 /* Register HOOK to be called with DATA on each removed node. */
2031 cgraph_node_hook_list
*add_cgraph_removal_hook (cgraph_node_hook hook
,
2034 /* Remove ENTRY from the list of hooks called on removing nodes. */
2035 void remove_cgraph_removal_hook (cgraph_node_hook_list
*entry
);
2037 /* Register HOOK to be called with DATA on each removed node. */
2038 varpool_node_hook_list
*add_varpool_removal_hook (varpool_node_hook hook
,
2041 /* Remove ENTRY from the list of hooks called on removing nodes. */
2042 void remove_varpool_removal_hook (varpool_node_hook_list
*entry
);
2044 /* Register HOOK to be called with DATA on each inserted node. */
2045 cgraph_node_hook_list
*add_cgraph_insertion_hook (cgraph_node_hook hook
,
2048 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2049 void remove_cgraph_insertion_hook (cgraph_node_hook_list
*entry
);
2051 /* Register HOOK to be called with DATA on each inserted node. */
2052 varpool_node_hook_list
*add_varpool_insertion_hook (varpool_node_hook hook
,
2055 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2056 void remove_varpool_insertion_hook (varpool_node_hook_list
*entry
);
2058 /* Register HOOK to be called with DATA on each duplicated edge. */
2059 cgraph_2edge_hook_list
*add_edge_duplication_hook (cgraph_2edge_hook hook
,
2061 /* Remove ENTRY from the list of hooks called on duplicating edges. */
2062 void remove_edge_duplication_hook (cgraph_2edge_hook_list
*entry
);
2064 /* Register HOOK to be called with DATA on each duplicated node. */
2065 cgraph_2node_hook_list
*add_cgraph_duplication_hook (cgraph_2node_hook hook
,
2068 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
2069 void remove_cgraph_duplication_hook (cgraph_2node_hook_list
*entry
);
2071 /* Call all edge removal hooks. */
2072 void call_edge_removal_hooks (cgraph_edge
*e
);
2074 /* Call all node insertion hooks. */
2075 void call_cgraph_insertion_hooks (cgraph_node
*node
);
2077 /* Call all node removal hooks. */
2078 void call_cgraph_removal_hooks (cgraph_node
*node
);
2080 /* Call all node duplication hooks. */
2081 void call_cgraph_duplication_hooks (cgraph_node
*node
, cgraph_node
*node2
);
2083 /* Call all edge duplication hooks. */
2084 void call_edge_duplication_hooks (cgraph_edge
*cs1
, cgraph_edge
*cs2
);
2086 /* Call all node removal hooks. */
2087 void call_varpool_removal_hooks (varpool_node
*node
);
2089 /* Call all node insertion hooks. */
2090 void call_varpool_insertion_hooks (varpool_node
*node
);
2092 /* Arrange node to be first in its entry of assembler_name_hash. */
2093 void symtab_prevail_in_asm_name_hash (symtab_node
*node
);
2095 /* Initalize asm name hash unless. */
2096 void symtab_initialize_asm_name_hash (void);
2098 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
2099 void change_decl_assembler_name (tree decl
, tree name
);
2103 int cgraph_max_summary_uid
;
2108 symtab_node
* GTY(()) nodes
;
2109 asm_node
* GTY(()) asmnodes
;
2110 asm_node
* GTY(()) asm_last_node
;
2111 cgraph_node
* GTY(()) free_nodes
;
2113 /* Head of a linked list of unused (freed) call graph edges.
2114 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
2115 cgraph_edge
* GTY(()) free_edges
;
2117 /* The order index of the next symtab node to be created. This is
2118 used so that we can sort the cgraph nodes in order by when we saw
2119 them, to support -fno-toplevel-reorder. */
2122 /* Set when whole unit has been analyzed so we can access global info. */
2123 bool global_info_ready
;
2124 /* What state callgraph is in right now. */
2125 enum symtab_state state
;
2126 /* Set when the cgraph is fully build and the basic flags are computed. */
2127 bool function_flags_ready
;
2129 bool cpp_implicit_aliases_done
;
2131 /* Hash table used to hold sectoons. */
2132 hash_table
<section_name_hasher
> *GTY(()) section_hash
;
2134 /* Hash table used to convert assembler names into nodes. */
2135 hash_table
<asmname_hasher
> *assembler_name_hash
;
2137 /* Hash table used to hold init priorities. */
2138 hash_map
<symtab_node
*, symbol_priority_map
> *init_priority_hash
;
2140 FILE* GTY ((skip
)) dump_file
;
2143 /* Allocate new callgraph node. */
2144 inline cgraph_node
* allocate_cgraph_symbol (void);
2146 /* Allocate a cgraph_edge structure and fill it with data according to the
2147 parameters of which only CALLEE can be NULL (when creating an indirect call
2149 cgraph_edge
*create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
2150 gcall
*call_stmt
, gcov_type count
, int freq
,
2151 bool indir_unknown_callee
);
2153 /* Put the edge onto the free list. */
2154 void free_edge (cgraph_edge
*e
);
2156 /* Insert NODE to assembler name hash. */
2157 void insert_to_assembler_name_hash (symtab_node
*node
, bool with_clones
);
2159 /* Remove NODE from assembler name hash. */
2160 void unlink_from_assembler_name_hash (symtab_node
*node
, bool with_clones
);
2162 /* Hash asmnames ignoring the user specified marks. */
2163 static hashval_t
decl_assembler_name_hash (const_tree asmname
);
2165 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
2166 static bool decl_assembler_name_equal (tree decl
, const_tree asmname
);
2168 friend struct asmname_hasher
;
2170 /* List of hooks triggered when an edge is removed. */
2171 cgraph_edge_hook_list
* GTY((skip
)) m_first_edge_removal_hook
;
2172 /* List of hooks triggem_red when a cgraph node is removed. */
2173 cgraph_node_hook_list
* GTY((skip
)) m_first_cgraph_removal_hook
;
2174 /* List of hooks triggered when an edge is duplicated. */
2175 cgraph_2edge_hook_list
* GTY((skip
)) m_first_edge_duplicated_hook
;
2176 /* List of hooks triggered when a node is duplicated. */
2177 cgraph_2node_hook_list
* GTY((skip
)) m_first_cgraph_duplicated_hook
;
2178 /* List of hooks triggered when an function is inserted. */
2179 cgraph_node_hook_list
* GTY((skip
)) m_first_cgraph_insertion_hook
;
2180 /* List of hooks triggered when an variable is inserted. */
2181 varpool_node_hook_list
* GTY((skip
)) m_first_varpool_insertion_hook
;
2182 /* List of hooks triggered when a node is removed. */
2183 varpool_node_hook_list
* GTY((skip
)) m_first_varpool_removal_hook
;
2186 extern GTY(()) symbol_table
*symtab
;
2188 extern vec
<cgraph_node
*> cgraph_new_nodes
;
2191 asmname_hasher::hash (symtab_node
*n
)
2193 return symbol_table::decl_assembler_name_hash
2194 (DECL_ASSEMBLER_NAME (n
->decl
));
2198 asmname_hasher::equal (symtab_node
*n
, const_tree t
)
2200 return symbol_table::decl_assembler_name_equal (n
->decl
, t
);
2204 void cgraph_c_finalize (void);
2205 void release_function_body (tree
);
2206 cgraph_indirect_call_info
*cgraph_allocate_init_indirect_info (void);
2208 void cgraph_update_edges_for_call_stmt (gimple
*, tree
, gimple
*);
2209 bool cgraph_function_possibly_inlined_p (tree
);
2211 const char* cgraph_inline_failed_string (cgraph_inline_failed_t
);
2212 cgraph_inline_failed_type_t
cgraph_inline_failed_type (cgraph_inline_failed_t
);
2214 extern bool gimple_check_call_matching_types (gimple
*, tree
, bool);
2216 /* In cgraphunit.c */
2217 void cgraphunit_c_finalize (void);
2219 /* Initialize datastructures so DECL is a function in lowered gimple form.
2220 IN_SSA is true if the gimple is in SSA. */
2221 basic_block
init_lowered_empty_function (tree
, bool, gcov_type
);
2223 /* In cgraphclones.c */
2225 tree
clone_function_name_1 (const char *, const char *);
2226 tree
clone_function_name (tree decl
, const char *);
2228 void tree_function_versioning (tree
, tree
, vec
<ipa_replace_map
*, va_gc
> *,
2229 bool, bitmap
, bool, bitmap
, basic_block
);
2231 /* In cgraphbuild.c */
2232 int compute_call_stmt_bb_frequency (tree
, basic_block bb
);
2233 void record_references_in_initializer (tree
, bool);
2236 void cgraph_build_static_cdtor (char which
, tree body
, int priority
);
2237 bool ipa_discover_readonly_nonaddressable_vars (void);
2240 tree
ctor_for_folding (tree
);
2242 /* In tree-chkp.c */
2243 extern bool chkp_function_instrumented_p (tree fndecl
);
2245 /* Return true when the symbol is real symbol, i.e. it is not inline clone
2246 or abstract function kept for debug info purposes only. */
2248 symtab_node::real_symbol_p (void)
2252 if (DECL_ABSTRACT_P (decl
))
2254 if (!is_a
<cgraph_node
*> (this))
2256 cnode
= dyn_cast
<cgraph_node
*> (this);
2257 if (cnode
->global
.inlined_to
)
2262 /* Return true if DECL should have entry in symbol table if used.
2263 Those are functions and static & external veriables*/
2266 decl_in_symtab_p (const_tree decl
)
2268 return (TREE_CODE (decl
) == FUNCTION_DECL
2269 || (TREE_CODE (decl
) == VAR_DECL
2270 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))));
2274 symtab_node::in_same_comdat_group_p (symtab_node
*target
)
2276 symtab_node
*source
= this;
2278 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (target
))
2280 if (cn
->global
.inlined_to
)
2281 source
= cn
->global
.inlined_to
;
2283 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (target
))
2285 if (cn
->global
.inlined_to
)
2286 target
= cn
->global
.inlined_to
;
2289 return source
->get_comdat_group () == target
->get_comdat_group ();
2292 /* Return node that alias is aliasing. */
2294 inline symtab_node
*
2295 symtab_node::get_alias_target (void)
2297 ipa_ref
*ref
= NULL
;
2298 iterate_reference (0, ref
);
2299 if (ref
->use
== IPA_REF_CHKP
)
2300 iterate_reference (1, ref
);
2301 gcc_checking_assert (ref
->use
== IPA_REF_ALIAS
);
2302 return ref
->referred
;
2305 /* Return next reachable static symbol with initializer after the node. */
2307 inline symtab_node
*
2308 symtab_node::next_defined_symbol (void)
2310 symtab_node
*node1
= next
;
2312 for (; node1
; node1
= node1
->next
)
2313 if (node1
->definition
)
2319 /* Iterates I-th reference in the list, REF is also set. */
2322 symtab_node::iterate_reference (unsigned i
, ipa_ref
*&ref
)
2324 vec_safe_iterate (ref_list
.references
, i
, &ref
);
2329 /* Iterates I-th referring item in the list, REF is also set. */
2332 symtab_node::iterate_referring (unsigned i
, ipa_ref
*&ref
)
2334 ref_list
.referring
.iterate (i
, &ref
);
2339 /* Iterates I-th referring alias item in the list, REF is also set. */
2342 symtab_node::iterate_direct_aliases (unsigned i
, ipa_ref
*&ref
)
2344 ref_list
.referring
.iterate (i
, &ref
);
2346 if (ref
&& ref
->use
!= IPA_REF_ALIAS
)
2352 /* Return true if list contains an alias. */
2355 symtab_node::has_aliases_p (void)
2357 ipa_ref
*ref
= NULL
;
2359 return (iterate_direct_aliases (0, ref
) != NULL
);
2362 /* Return true when RESOLUTION indicate that linker will use
2363 the symbol from non-LTO object files. */
2366 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution
)
2368 return (resolution
== LDPR_PREVAILING_DEF
2369 || resolution
== LDPR_PREEMPTED_REG
2370 || resolution
== LDPR_RESOLVED_EXEC
2371 || resolution
== LDPR_RESOLVED_DYN
);
2374 /* Return true when symtab_node is known to be used from other (non-LTO)
2375 object file. Known only when doing LTO via linker plugin. */
2378 symtab_node::used_from_object_file_p (void)
2380 if (!TREE_PUBLIC (decl
) || DECL_EXTERNAL (decl
))
2382 if (resolution_used_from_other_file_p (resolution
))
2387 /* Return varpool node for given symbol and check it is a function. */
2389 inline varpool_node
*
2390 varpool_node::get (const_tree decl
)
2392 gcc_checking_assert (TREE_CODE (decl
) == VAR_DECL
);
2393 return dyn_cast
<varpool_node
*> (symtab_node::get (decl
));
2396 /* Register a symbol NODE. */
2399 symbol_table::register_symbol (symtab_node
*node
)
2402 node
->previous
= NULL
;
2405 nodes
->previous
= node
;
2408 node
->order
= order
++;
2411 /* Register a top-level asm statement ASM_STR. */
2414 symbol_table::finalize_toplevel_asm (tree asm_str
)
2418 node
= ggc_cleared_alloc
<asm_node
> ();
2419 node
->asm_str
= asm_str
;
2420 node
->order
= order
++;
2423 if (asmnodes
== NULL
)
2426 asm_last_node
->next
= node
;
2428 asm_last_node
= node
;
2432 /* Unregister a symbol NODE. */
2434 symbol_table::unregister (symtab_node
*node
)
2437 node
->previous
->next
= node
->next
;
2442 node
->next
->previous
= node
->previous
;
2445 node
->previous
= NULL
;
2448 /* Release a callgraph NODE with UID and put in to the list of free nodes. */
2451 symbol_table::release_symbol (cgraph_node
*node
, int uid
)
2455 /* Clear out the node to NULL all pointers and add the node to the free
2457 memset (node
, 0, sizeof (*node
));
2458 node
->type
= SYMTAB_FUNCTION
;
2460 SET_NEXT_FREE_NODE (node
, free_nodes
);
2464 /* Allocate new callgraph node. */
2466 inline cgraph_node
*
2467 symbol_table::allocate_cgraph_symbol (void)
2474 free_nodes
= NEXT_FREE_NODE (node
);
2478 node
= ggc_cleared_alloc
<cgraph_node
> ();
2479 node
->uid
= cgraph_max_uid
++;
2482 node
->summary_uid
= cgraph_max_summary_uid
++;
2487 /* Return first static symbol with definition. */
2488 inline symtab_node
*
2489 symbol_table::first_symbol (void)
2494 /* Walk all symbols. */
2495 #define FOR_EACH_SYMBOL(node) \
2496 for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)
2498 /* Return first static symbol with definition. */
2499 inline symtab_node
*
2500 symbol_table::first_defined_symbol (void)
2504 for (node
= nodes
; node
; node
= node
->next
)
2505 if (node
->definition
)
2511 /* Walk all symbols with definitions in current unit. */
2512 #define FOR_EACH_DEFINED_SYMBOL(node) \
2513 for ((node) = symtab->first_defined_symbol (); (node); \
2514 (node) = node->next_defined_symbol ())
2516 /* Return first variable. */
2517 inline varpool_node
*
2518 symbol_table::first_variable (void)
2521 for (node
= nodes
; node
; node
= node
->next
)
2522 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
))
2527 /* Return next variable after NODE. */
2528 inline varpool_node
*
2529 symbol_table::next_variable (varpool_node
*node
)
2531 symtab_node
*node1
= node
->next
;
2532 for (; node1
; node1
= node1
->next
)
2533 if (varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
))
2537 /* Walk all variables. */
2538 #define FOR_EACH_VARIABLE(node) \
2539 for ((node) = symtab->first_variable (); \
2541 (node) = symtab->next_variable ((node)))
2543 /* Return first static variable with initializer. */
2544 inline varpool_node
*
2545 symbol_table::first_static_initializer (void)
2548 for (node
= nodes
; node
; node
= node
->next
)
2550 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2551 if (vnode
&& DECL_INITIAL (node
->decl
))
2557 /* Return next static variable with initializer after NODE. */
2558 inline varpool_node
*
2559 symbol_table::next_static_initializer (varpool_node
*node
)
2561 symtab_node
*node1
= node
->next
;
2562 for (; node1
; node1
= node1
->next
)
2564 varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
);
2565 if (vnode1
&& DECL_INITIAL (node1
->decl
))
2571 /* Walk all static variables with initializer set. */
2572 #define FOR_EACH_STATIC_INITIALIZER(node) \
2573 for ((node) = symtab->first_static_initializer (); (node); \
2574 (node) = symtab->next_static_initializer (node))
2576 /* Return first static variable with definition. */
2577 inline varpool_node
*
2578 symbol_table::first_defined_variable (void)
2581 for (node
= nodes
; node
; node
= node
->next
)
2583 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2584 if (vnode
&& vnode
->definition
)
2590 /* Return next static variable with definition after NODE. */
2591 inline varpool_node
*
2592 symbol_table::next_defined_variable (varpool_node
*node
)
2594 symtab_node
*node1
= node
->next
;
2595 for (; node1
; node1
= node1
->next
)
2597 varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
);
2598 if (vnode1
&& vnode1
->definition
)
2603 /* Walk all variables with definitions in current unit. */
2604 #define FOR_EACH_DEFINED_VARIABLE(node) \
2605 for ((node) = symtab->first_defined_variable (); (node); \
2606 (node) = symtab->next_defined_variable (node))
2608 /* Return first function with body defined. */
2609 inline cgraph_node
*
2610 symbol_table::first_defined_function (void)
2613 for (node
= nodes
; node
; node
= node
->next
)
2615 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
2616 if (cn
&& cn
->definition
)
2622 /* Return next function with body defined after NODE. */
2623 inline cgraph_node
*
2624 symbol_table::next_defined_function (cgraph_node
*node
)
2626 symtab_node
*node1
= node
->next
;
2627 for (; node1
; node1
= node1
->next
)
2629 cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
);
2630 if (cn1
&& cn1
->definition
)
2636 /* Walk all functions with body defined. */
2637 #define FOR_EACH_DEFINED_FUNCTION(node) \
2638 for ((node) = symtab->first_defined_function (); (node); \
2639 (node) = symtab->next_defined_function ((node)))
2641 /* Return first function. */
2642 inline cgraph_node
*
2643 symbol_table::first_function (void)
2646 for (node
= nodes
; node
; node
= node
->next
)
2647 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
))
2652 /* Return next function. */
2653 inline cgraph_node
*
2654 symbol_table::next_function (cgraph_node
*node
)
2656 symtab_node
*node1
= node
->next
;
2657 for (; node1
; node1
= node1
->next
)
2658 if (cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
))
2663 /* Return first function with body defined. */
2664 inline cgraph_node
*
2665 symbol_table::first_function_with_gimple_body (void)
2668 for (node
= nodes
; node
; node
= node
->next
)
2670 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
2671 if (cn
&& cn
->has_gimple_body_p ())
2677 /* Return next reachable static variable with initializer after NODE. */
2678 inline cgraph_node
*
2679 symbol_table::next_function_with_gimple_body (cgraph_node
*node
)
2681 symtab_node
*node1
= node
->next
;
2682 for (; node1
; node1
= node1
->next
)
2684 cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
);
2685 if (cn1
&& cn1
->has_gimple_body_p ())
2691 /* Walk all functions. */
2692 #define FOR_EACH_FUNCTION(node) \
2693 for ((node) = symtab->first_function (); (node); \
2694 (node) = symtab->next_function ((node)))
2696 /* Return true when callgraph node is a function with Gimple body defined
2697 in current unit. Functions can also be define externally or they
2698 can be thunks with no Gimple representation.
2700 Note that at WPA stage, the function body may not be present in memory. */
2703 cgraph_node::has_gimple_body_p (void)
2705 return definition
&& !thunk
.thunk_p
&& !alias
;
2708 /* Walk all functions with body defined. */
2709 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
2710 for ((node) = symtab->first_function_with_gimple_body (); (node); \
2711 (node) = symtab->next_function_with_gimple_body (node))
2713 /* Uniquize all constants that appear in memory.
2714 Each constant in memory thus far output is recorded
2715 in `const_desc_table'. */
2717 struct GTY((for_user
)) constant_descriptor_tree
{
2718 /* A MEM for the constant. */
2721 /* The value of the constant. */
2724 /* Hash of value. Computing the hash from value each time
2725 hashfn is called can't work properly, as that means recursive
2726 use of the hash table during hash table expansion. */
2730 /* Return true when function is only called directly or it has alias.
2731 i.e. it is not externally visible, address was not taken and
2732 it is not used in any other non-standard way. */
2735 cgraph_node::only_called_directly_or_aliased_p (void)
2737 gcc_assert (!global
.inlined_to
);
2738 return (!force_output
&& !address_taken
2739 && !used_from_other_partition
2740 && !DECL_VIRTUAL_P (decl
)
2741 && !DECL_STATIC_CONSTRUCTOR (decl
)
2742 && !DECL_STATIC_DESTRUCTOR (decl
)
2743 && !used_from_object_file_p ()
2744 && !externally_visible
);
2747 /* Return true when function can be removed from callgraph
2748 if all direct calls are eliminated. */
2751 cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
2753 gcc_checking_assert (!global
.inlined_to
);
2754 /* Instrumentation clones should not be removed before
2755 instrumentation happens. New callers may appear after
2757 if (instrumentation_clone
2758 && !chkp_function_instrumented_p (decl
))
2760 /* Extern inlines can always go, we will use the external definition. */
2761 if (DECL_EXTERNAL (decl
))
2763 /* When function is needed, we can not remove it. */
2764 if (force_output
|| used_from_other_partition
)
2766 if (DECL_STATIC_CONSTRUCTOR (decl
)
2767 || DECL_STATIC_DESTRUCTOR (decl
))
2769 /* Only COMDAT functions can be removed if externally visible. */
2770 if (externally_visible
2771 && (!DECL_COMDAT (decl
)
2773 || used_from_object_file_p ()))
2778 /* Verify cgraph, if consistency checking is enabled. */
2781 cgraph_node::checking_verify_cgraph_nodes (void)
2784 cgraph_node::verify_cgraph_nodes ();
2787 /* Return true when variable can be removed from variable pool
2788 if all direct calls are eliminated. */
2791 varpool_node::can_remove_if_no_refs_p (void)
2793 if (DECL_EXTERNAL (decl
))
2795 return (!force_output
&& !used_from_other_partition
2796 && ((DECL_COMDAT (decl
)
2798 && !used_from_object_file_p ())
2799 || !externally_visible
2800 || DECL_HAS_VALUE_EXPR_P (decl
)));
2803 /* Return true when all references to variable must be visible in ipa_ref_list.
2804 i.e. if the variable is not externally visible or not used in some magic
2805 way (asm statement or such).
2806 The magic uses are all summarized in force_output flag. */
2809 varpool_node::all_refs_explicit_p ()
2812 && !externally_visible
2813 && !used_from_other_partition
2817 struct tree_descriptor_hasher
: ggc_ptr_hash
<constant_descriptor_tree
>
2819 static hashval_t
hash (constant_descriptor_tree
*);
2820 static bool equal (constant_descriptor_tree
*, constant_descriptor_tree
*);
2823 /* Constant pool accessor function. */
2824 hash_table
<tree_descriptor_hasher
> *constant_pool_htab (void);
2826 /* Return node that alias is aliasing. */
2828 inline cgraph_node
*
2829 cgraph_node::get_alias_target (void)
2831 return dyn_cast
<cgraph_node
*> (symtab_node::get_alias_target ());
2834 /* Return node that alias is aliasing. */
2836 inline varpool_node
*
2837 varpool_node::get_alias_target (void)
2839 return dyn_cast
<varpool_node
*> (symtab_node::get_alias_target ());
2842 /* Walk the alias chain to return the symbol NODE is alias of.
2843 If NODE is not an alias, return NODE.
2844 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
2846 inline symtab_node
*
2847 symtab_node::ultimate_alias_target (enum availability
*availability
)
2852 *availability
= get_availability ();
2856 return ultimate_alias_target_1 (availability
);
2859 /* Given function symbol, walk the alias chain to return the function node
2860 is alias of. Do not walk through thunks.
2861 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
2863 inline cgraph_node
*
2864 cgraph_node::ultimate_alias_target (enum availability
*availability
)
2866 cgraph_node
*n
= dyn_cast
<cgraph_node
*>
2867 (symtab_node::ultimate_alias_target (availability
));
2868 if (!n
&& availability
)
2869 *availability
= AVAIL_NOT_AVAILABLE
;
2873 /* For given variable pool node, walk the alias chain to return the function
2874 the variable is alias of. Do not walk through thunks.
2875 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
2877 inline varpool_node
*
2878 varpool_node::ultimate_alias_target (availability
*availability
)
2880 varpool_node
*n
= dyn_cast
<varpool_node
*>
2881 (symtab_node::ultimate_alias_target (availability
));
2883 if (!n
&& availability
)
2884 *availability
= AVAIL_NOT_AVAILABLE
;
2888 /* Set callee N of call graph edge and add it to the corresponding set of
2892 cgraph_edge::set_callee (cgraph_node
*n
)
2896 n
->callers
->prev_caller
= this;
2897 next_caller
= n
->callers
;
2902 /* Redirect callee of the edge to N. The function does not update underlying
2906 cgraph_edge::redirect_callee (cgraph_node
*n
)
2908 /* Remove from callers list of the current callee. */
2911 /* Insert to callers list of the new callee. */
2915 /* Return true when the edge represents a direct recursion. */
2918 cgraph_edge::recursive_p (void)
2920 cgraph_node
*c
= callee
->ultimate_alias_target ();
2921 if (caller
->global
.inlined_to
)
2922 return caller
->global
.inlined_to
->decl
== c
->decl
;
2924 return caller
->decl
== c
->decl
;
2927 /* Remove the edge from the list of the callers of the callee. */
2930 cgraph_edge::remove_callee (void)
2932 gcc_assert (!indirect_unknown_callee
);
2934 prev_caller
->next_caller
= next_caller
;
2936 next_caller
->prev_caller
= prev_caller
;
2938 callee
->callers
= next_caller
;
2941 /* Return true if the TM_CLONE bit is set for a given FNDECL. */
2943 decl_is_tm_clone (const_tree fndecl
)
2945 cgraph_node
*n
= cgraph_node::get (fndecl
);
2951 /* Likewise indicate that a node is needed, i.e. reachable via some
2955 cgraph_node::mark_force_output (void)
2958 gcc_checking_assert (!global
.inlined_to
);
2961 /* Return true if function should be optimized for size. */
2964 cgraph_node::optimize_for_size_p (void)
2966 if (opt_for_fn (decl
, optimize_size
))
2968 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
2974 /* Return symtab_node for NODE or create one if it is not present
2977 inline symtab_node
*
2978 symtab_node::get_create (tree node
)
2980 if (TREE_CODE (node
) == VAR_DECL
)
2981 return varpool_node::get_create (node
);
2983 return cgraph_node::get_create (node
);
2986 /* Return availability of NODE. */
2988 inline enum availability
2989 symtab_node::get_availability (void)
2991 if (is_a
<cgraph_node
*> (this))
2992 return dyn_cast
<cgraph_node
*> (this)->get_availability ();
2994 return dyn_cast
<varpool_node
*> (this)->get_availability ();
2997 /* Call calback on symtab node and aliases associated to this node.
2998 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
3002 symtab_node::call_for_symbol_and_aliases (bool (*callback
) (symtab_node
*,
3005 bool include_overwritable
)
3007 if (callback (this, data
))
3009 if (has_aliases_p ())
3010 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3014 /* Call callback on function and aliases associated to the function.
3015 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
3019 cgraph_node::call_for_symbol_and_aliases (bool (*callback
) (cgraph_node
*,
3022 bool include_overwritable
)
3024 if (callback (this, data
))
3026 if (has_aliases_p ())
3027 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3031 /* Call calback on varpool symbol and aliases associated to varpool symbol.
3032 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
3036 varpool_node::call_for_symbol_and_aliases (bool (*callback
) (varpool_node
*,
3039 bool include_overwritable
)
3041 if (callback (this, data
))
3043 if (has_aliases_p ())
3044 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3048 /* Return true if refernece may be used in address compare. */
3051 ipa_ref::address_matters_p ()
3053 if (use
!= IPA_REF_ADDR
)
3055 /* Addresses taken from virtual tables are never compared. */
3056 if (is_a
<varpool_node
*> (referring
)
3057 && DECL_VIRTUAL_P (referring
->decl
))
3059 return referred
->address_can_be_compared_p ();
3062 /* Build polymorphic call context for indirect call E. */
3065 ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge
*e
)
3067 gcc_checking_assert (e
->indirect_info
->polymorphic
);
3068 *this = e
->indirect_info
->context
;
3071 /* Build empty "I know nothing" context. */
3074 ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
3076 clear_speculation ();
3077 clear_outer_type ();
3081 /* Make context non-speculative. */
3084 ipa_polymorphic_call_context::clear_speculation ()
3086 speculative_outer_type
= NULL
;
3087 speculative_offset
= 0;
3088 speculative_maybe_derived_type
= false;
3091 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
3092 NULL, the context is set to dummy "I know nothing" setting. */
3095 ipa_polymorphic_call_context::clear_outer_type (tree otr_type
)
3097 outer_type
= otr_type
? TYPE_MAIN_VARIANT (otr_type
) : NULL
;
3099 maybe_derived_type
= true;
3100 maybe_in_construction
= true;
3104 /* Adjust all offsets in contexts by OFF bits. */
3107 ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off
)
3111 if (speculative_outer_type
)
3112 speculative_offset
+= off
;
3115 /* Return TRUE if context is fully useless. */
3118 ipa_polymorphic_call_context::useless_p () const
3120 return (!outer_type
&& !speculative_outer_type
);
3123 /* Return true if NODE is local. Instrumentation clones are counted as local
3124 only when original function is local. */
3127 cgraph_local_p (cgraph_node
*node
)
3129 if (!node
->instrumentation_clone
|| !node
->instrumented_version
)
3130 return node
->local
.local
;
3132 return node
->local
.local
&& node
->instrumented_version
->local
.local
;
3135 /* When using fprintf (or similar), problems can arise with
3136 transient generated strings. Many string-generation APIs
3137 only support one result being alive at once (e.g. by
3138 returning a pointer to a statically-allocated buffer).
3140 If there is more than one generated string within one
3141 fprintf call: the first string gets evicted or overwritten
3142 by the second, before fprintf is fully evaluated.
3145 This function provides a workaround for this, by providing
3146 a simple way to create copies of these transient strings,
3147 without the need to have explicit cleanup:
3149 fprintf (dumpfile, "string 1: %s string 2:%s\n",
3150 xstrdup_for_dump (EXPR_1),
3151 xstrdup_for_dump (EXPR_2));
3153 This is actually a simple wrapper around ggc_strdup, but
3154 the name documents the intent. We require that no GC can occur
3155 within the fprintf call. */
3157 static inline const char *
3158 xstrdup_for_dump (const char *transient_str
)
3160 return ggc_strdup (transient_str
);
3163 #endif /* GCC_CGRAPH_H */