1 /* Callgraph handling code.
2 Copyright (C) 2003-2019 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
24 #include "profile-count.h"
26 #include "plugin-api.h"
27 #include "ipa-param-manipulation.h"
29 extern void debuginfo_early_init (void);
30 extern void debuginfo_init (void);
31 extern void debuginfo_fini (void);
32 extern void debuginfo_start (void);
33 extern void debuginfo_stop (void);
34 extern void debuginfo_early_start (void);
35 extern void debuginfo_early_stop (void);
38 typedef ipa_opt_pass_d
*ipa_opt_pass
;
40 /* Symbol table consists of functions and variables.
41 TODO: add labels and CONST_DECLs. */
49 /* Section names are stored as reference counted strings in GGC safe hashtable
50 (to make them survive through PCH). */
52 struct GTY((for_user
)) section_hash_entry
55 char *name
; /* As long as this datastructure stays in GGC, we cannot put
56 string at the tail of structure of GGC dies in horrible
60 struct section_name_hasher
: ggc_ptr_hash
<section_hash_entry
>
62 typedef const char *compare_type
;
64 static hashval_t
hash (section_hash_entry
*);
65 static bool equal (section_hash_entry
*, const char *);
70 /* Not yet set by cgraph_function_body_availability. */
72 /* Function body/variable initializer is unknown. */
74 /* Function body/variable initializer is known but might be replaced
75 by a different one from other compilation unit and thus needs to
76 be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have
77 arbitrary side effects on escaping variables and functions, while
78 like AVAILABLE it might access static variables. */
80 /* Function body/variable initializer is known and will be used in final
83 /* Function body/variable initializer is known and all it's uses are
84 explicitly visible within current unit (ie it's address is never taken and
85 it is not exported to other units). Currently used only for functions. */
89 /* Classification of symbols WRT partitioning. */
90 enum symbol_partitioning_class
92 /* External declarations are ignored by partitioning algorithms and they are
93 added into the boundary later via compute_ltrans_boundary. */
95 /* Partitioned symbols are pur into one of partitions. */
97 /* Duplicated symbols (such as comdat or constant pool references) are
98 copied into every node needing them via add_symbol_to_partition. */
102 /* Base of all entries in the symbol table.
103 The symtab_node is inherited by cgraph and varpol nodes. */
104 struct GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
105 chain_next ("%h.next"), chain_prev ("%h.previous")))
109 friend class symbol_table
;
112 const char *name () const;
114 /* Return dump name. */
115 const char *dump_name () const;
117 /* Return asm name. */
118 const char *asm_name () const;
120 /* Return dump name with assembler name. */
121 const char *dump_asm_name () const;
123 /* Return visibility name. */
124 const char *get_visibility_string () const;
126 /* Return type_name name. */
127 const char *get_symtab_type_string () const;
129 /* Add node into symbol table. This function is not used directly, but via
130 cgraph/varpool node creation routines. */
131 void register_symbol (void);
133 /* Remove symbol from symbol table. */
136 /* Dump symtab node to F. */
139 /* Dump symtab callgraph in graphviz format. */
140 void dump_graphviz (FILE *f
);
142 /* Dump symtab node to stderr. */
143 void DEBUG_FUNCTION
debug (void);
145 /* Verify consistency of node. */
146 void DEBUG_FUNCTION
verify (void);
148 /* Return ipa reference from this symtab_node to
149 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
150 of the use and STMT the statement (if it exists). */
151 ipa_ref
*create_reference (symtab_node
*referred_node
,
152 enum ipa_ref_use use_type
);
154 /* Return ipa reference from this symtab_node to
155 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
156 of the use and STMT the statement (if it exists). */
157 ipa_ref
*create_reference (symtab_node
*referred_node
,
158 enum ipa_ref_use use_type
, gimple
*stmt
);
160 /* If VAL is a reference to a function or a variable, add a reference from
161 this symtab_node to the corresponding symbol table node. Return the new
162 reference or NULL if none was created. */
163 ipa_ref
*maybe_create_reference (tree val
, gimple
*stmt
);
165 /* Clone all references from symtab NODE to this symtab_node. */
166 void clone_references (symtab_node
*node
);
168 /* Remove all stmt references in non-speculative references.
169 Those are not maintained during inlining & clonning.
170 The exception are speculative references that are updated along
171 with callgraph edges associated with them. */
172 void clone_referring (symtab_node
*node
);
174 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
175 ipa_ref
*clone_reference (ipa_ref
*ref
, gimple
*stmt
);
177 /* Find the structure describing a reference to REFERRED_NODE
178 and associated with statement STMT. */
179 ipa_ref
*find_reference (symtab_node
*referred_node
, gimple
*stmt
,
180 unsigned int lto_stmt_uid
);
182 /* Remove all references that are associated with statement STMT. */
183 void remove_stmt_references (gimple
*stmt
);
185 /* Remove all stmt references in non-speculative references.
186 Those are not maintained during inlining & clonning.
187 The exception are speculative references that are updated along
188 with callgraph edges associated with them. */
189 void clear_stmts_in_references (void);
191 /* Remove all references in ref list. */
192 void remove_all_references (void);
194 /* Remove all referring items in ref list. */
195 void remove_all_referring (void);
197 /* Dump references in ref list to FILE. */
198 void dump_references (FILE *file
);
200 /* Dump referring in list to FILE. */
201 void dump_referring (FILE *);
203 /* Get number of references for this node. */
204 inline unsigned num_references (void)
206 return ref_list
.references
? ref_list
.references
->length () : 0;
209 /* Iterates I-th reference in the list, REF is also set. */
210 ipa_ref
*iterate_reference (unsigned i
, ipa_ref
*&ref
);
212 /* Iterates I-th referring item in the list, REF is also set. */
213 ipa_ref
*iterate_referring (unsigned i
, ipa_ref
*&ref
);
215 /* Iterates I-th referring alias item in the list, REF is also set. */
216 ipa_ref
*iterate_direct_aliases (unsigned i
, ipa_ref
*&ref
);
218 /* Return true if symtab node and TARGET represents
219 semantically equivalent symbols. */
220 bool semantically_equivalent_p (symtab_node
*target
);
222 /* Classify symbol symtab node for partitioning. */
223 enum symbol_partitioning_class
get_partitioning_class (void);
225 /* Return comdat group. */
226 tree
get_comdat_group ()
228 return x_comdat_group
;
231 /* Return comdat group as identifier_node. */
232 tree
get_comdat_group_id ()
234 if (x_comdat_group
&& TREE_CODE (x_comdat_group
) != IDENTIFIER_NODE
)
235 x_comdat_group
= DECL_ASSEMBLER_NAME (x_comdat_group
);
236 return x_comdat_group
;
239 /* Set comdat group. */
240 void set_comdat_group (tree group
)
242 gcc_checking_assert (!group
|| TREE_CODE (group
) == IDENTIFIER_NODE
244 x_comdat_group
= group
;
247 /* Return section as string. */
248 const char * get_section ()
252 return x_section
->name
;
255 /* Remove node from same comdat group. */
256 void remove_from_same_comdat_group (void);
258 /* Add this symtab_node to the same comdat group that OLD is in. */
259 void add_to_same_comdat_group (symtab_node
*old_node
);
261 /* Dissolve the same_comdat_group list in which NODE resides. */
262 void dissolve_same_comdat_group_list (void);
264 /* Return true when symtab_node is known to be used from other (non-LTO)
265 object file. Known only when doing LTO via linker plugin. */
266 bool used_from_object_file_p (void);
268 /* Walk the alias chain to return the symbol NODE is alias of.
269 If NODE is not an alias, return NODE.
270 When AVAILABILITY is non-NULL, get minimal availability in the chain.
271 When REF is non-NULL, assume that reference happens in symbol REF
272 when determining the availability. */
273 symtab_node
*ultimate_alias_target (enum availability
*avail
= NULL
,
274 struct symtab_node
*ref
= NULL
);
276 /* Return next reachable static symbol with initializer after NODE. */
277 inline symtab_node
*next_defined_symbol (void);
279 /* Add reference recording that symtab node is alias of TARGET.
280 If TRANSPARENT is true make the alias to be transparent alias.
281 The function can fail in the case of aliasing cycles; in this case
283 bool resolve_alias (symtab_node
*target
, bool transparent
= false);
285 /* C++ FE sometimes change linkage flags after producing same
287 void fixup_same_cpp_alias_visibility (symtab_node
*target
);
289 /* Call callback on symtab node and aliases associated to this node.
290 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
292 bool call_for_symbol_and_aliases (bool (*callback
) (symtab_node
*, void *),
294 bool include_overwrite
);
296 /* If node cannot be interposable by static or dynamic linker to point to
297 different definition, return this symbol. Otherwise look for alias with
298 such property and if none exists, introduce new one. */
299 symtab_node
*noninterposable_alias (void);
301 /* Return node that alias is aliasing. */
302 inline symtab_node
*get_alias_target (void);
304 /* Set section for symbol and its aliases. */
305 void set_section (const char *section
);
307 /* Set section, do not recurse into aliases.
308 When one wants to change section of symbol and its aliases,
310 void set_section_for_node (const char *section
);
312 /* Set initialization priority to PRIORITY. */
313 void set_init_priority (priority_type priority
);
315 /* Return the initialization priority. */
316 priority_type
get_init_priority ();
318 /* Return availability of NODE when referenced from REF. */
319 enum availability
get_availability (symtab_node
*ref
= NULL
);
321 /* During LTO stream-in this predicate can be used to check whether node
322 in question prevails in the linking to save some memory usage. */
323 bool prevailing_p (void);
325 /* Return true if NODE binds to current definition in final executable
326 when referenced from REF. If REF is NULL return conservative value
327 for any reference. */
328 bool binds_to_current_def_p (symtab_node
*ref
= NULL
);
330 /* Make DECL local. */
331 void make_decl_local (void);
333 /* Copy visibility from N. */
334 void copy_visibility_from (symtab_node
*n
);
336 /* Return desired alignment of the definition. This is NOT alignment useful
337 to access THIS, because THIS may be interposable and DECL_ALIGN should
338 be used instead. It however must be guaranteed when output definition
340 unsigned int definition_alignment ();
342 /* Return true if alignment can be increased. */
343 bool can_increase_alignment_p ();
345 /* Increase alignment of symbol to ALIGN. */
346 void increase_alignment (unsigned int align
);
348 /* Return true if list contains an alias. */
349 bool has_aliases_p (void);
351 /* Return true when the symbol is real symbol, i.e. it is not inline clone
352 or abstract function kept for debug info purposes only. */
353 bool real_symbol_p (void);
355 /* Return true when the symbol needs to be output to the LTO symbol table. */
356 bool output_to_lto_symbol_table_p (void);
358 /* Determine if symbol declaration is needed. That is, visible to something
359 either outside this translation unit, something magic in the system
360 configury. This function is used just during symbol creation. */
361 bool needed_p (void);
363 /* Return true if this symbol is a function from the C frontend specified
364 directly in RTL form (with "__RTL"). */
365 bool native_rtl_p () const;
367 /* Return true when there are references to the node. */
368 bool referred_to_p (bool include_self
= true);
370 /* Return true if symbol can be discarded by linker from the binary.
371 Assume that symbol is used (so there is no need to take into account
372 garbage collecting linkers)
374 This can happen for comdats, commons and weaks when they are previaled
375 by other definition at static linking time. */
377 can_be_discarded_p (void)
379 return (DECL_EXTERNAL (decl
)
380 || ((get_comdat_group ()
381 || DECL_COMMON (decl
)
382 || (DECL_SECTION_NAME (decl
) && DECL_WEAK (decl
)))
383 && ((resolution
!= LDPR_PREVAILING_DEF
384 && resolution
!= LDPR_PREVAILING_DEF_IRONLY_EXP
)
385 || flag_incremental_link
)
386 && resolution
!= LDPR_PREVAILING_DEF_IRONLY
));
389 /* Return true if NODE is local to a particular COMDAT group, and must not
390 be named from outside the COMDAT. This is used for C++ decloned
392 inline bool comdat_local_p (void)
394 return (same_comdat_group
&& !TREE_PUBLIC (decl
));
397 /* Return true if ONE and TWO are part of the same COMDAT group. */
398 inline bool in_same_comdat_group_p (symtab_node
*target
);
400 /* Return true if symbol is known to be nonzero. */
401 bool nonzero_address ();
403 /* Return 0 if symbol is known to have different address than S2,
404 Return 1 if symbol is known to have same address as S2,
407 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
408 and S2 is going to be accessed. This eliminates the situations when
409 either THIS or S2 is NULL and is seful for comparing bases when deciding
410 about memory aliasing. */
411 int equal_address_to (symtab_node
*s2
, bool memory_accessed
= false);
413 /* Return true if symbol's address may possibly be compared to other
415 bool address_matters_p ();
417 /* Return true if NODE's address can be compared. This use properties
418 of NODE only and does not look if the address is actually taken in
419 interesting way. For that use ADDRESS_MATTERS_P instead. */
420 bool address_can_be_compared_p (void);
422 /* Return symbol table node associated with DECL, if any,
423 and NULL otherwise. */
424 static inline symtab_node
*get (const_tree decl
)
426 /* Check that we are called for sane type of object - functions
427 and static or external variables. */
428 gcc_checking_assert (TREE_CODE (decl
) == FUNCTION_DECL
429 || (TREE_CODE (decl
) == VAR_DECL
430 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)
432 /* Check that the mapping is sane - perhaps this check can go away,
433 but at the moment frontends tends to corrupt the mapping by calling
434 memcpy/memset on the tree nodes. */
435 gcc_checking_assert (!decl
->decl_with_vis
.symtab_node
436 || decl
->decl_with_vis
.symtab_node
->decl
== decl
);
437 return decl
->decl_with_vis
.symtab_node
;
440 /* Try to find a symtab node for declaration DECL and if it does not
441 exist or if it corresponds to an inline clone, create a new one. */
442 static inline symtab_node
* get_create (tree node
);
444 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
445 Return NULL if there's no such node. */
446 static symtab_node
*get_for_asmname (const_tree asmname
);
448 /* Verify symbol table for internal consistency. */
449 static DEBUG_FUNCTION
void verify_symtab_nodes (void);
451 /* Perform internal consistency checks, if they are enabled. */
452 static inline void checking_verify_symtab_nodes (void);
454 /* Type of the symbol. */
455 ENUM_BITFIELD (symtab_type
) type
: 8;
457 /* The symbols resolution. */
458 ENUM_BITFIELD (ld_plugin_symbol_resolution
) resolution
: 8;
460 /*** Flags representing the symbol type. ***/
462 /* True when symbol corresponds to a definition in current unit.
463 set via finalize_function or finalize_decl */
464 unsigned definition
: 1;
465 /* True when symbol is an alias.
466 Set by ssemble_alias. */
468 /* When true the alias is translated into its target symbol either by GCC
469 or assembler (it also may just be a duplicate declaration of the same
472 Currently transparent aliases come in three different flavors
473 - aliases having the same assembler name as their target (aka duplicated
474 declarations). In this case the assembler names compare via
475 assembler_names_equal_p and weakref is false
476 - aliases that are renamed at a time being output to final file
477 by varasm.c. For those DECL_ASSEMBLER_NAME have
478 IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
480 Weakrefs belong to this cateogry when we target assembler without
482 - weakrefs that are renamed by assembler via .weakref directive.
483 In this case the alias may or may not be definition (depending if
484 target declaration was seen by the compiler), weakref is set.
485 Unless we are before renaming statics, assembler names are different.
487 Given that we now support duplicate declarations, the second option is
488 redundant and will be removed. */
489 unsigned transparent_alias
: 1;
490 /* True when alias is a weakref. */
491 unsigned weakref
: 1;
492 /* C++ frontend produce same body aliases and extra name aliases for
493 virtual functions and vtables that are obviously equivalent.
494 Those aliases are bit special, especially because C++ frontend
495 visibility code is so ugly it cannot get them right at first time
496 and their visibility needs to be copied from their "masters" at
497 the end of parsing. */
498 unsigned cpp_implicit_alias
: 1;
499 /* Set once the definition was analyzed. The list of references and
500 other properties are built during analysis. */
501 unsigned analyzed
: 1;
502 /* Set for write-only variables. */
503 unsigned writeonly
: 1;
504 /* Visibility of symbol was used for further optimization; do not
505 permit further changes. */
506 unsigned refuse_visibility_changes
: 1;
508 /*** Visibility and linkage flags. ***/
510 /* Set when function is visible by other units. */
511 unsigned externally_visible
: 1;
512 /* Don't reorder to other symbols having this set. */
513 unsigned no_reorder
: 1;
514 /* The symbol will be assumed to be used in an invisible way (like
515 by an toplevel asm statement). */
516 unsigned force_output
: 1;
517 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
518 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
519 to static and it does not inhibit optimization. */
520 unsigned forced_by_abi
: 1;
521 /* True when the name is known to be unique and thus it does not need mangling. */
522 unsigned unique_name
: 1;
523 /* Specify whether the section was set by user or by
524 compiler via -ffunction-sections. */
525 unsigned implicit_section
: 1;
526 /* True when body and other characteristics have been removed by
527 symtab_remove_unreachable_nodes. */
528 unsigned body_removed
: 1;
530 /*** WHOPR Partitioning flags.
531 These flags are used at ltrans stage when only part of the callgraph is
534 /* Set when variable is used from other LTRANS partition. */
535 unsigned used_from_other_partition
: 1;
536 /* Set when function is available in the other LTRANS partition.
537 During WPA output it is used to mark nodes that are present in
538 multiple partitions. */
539 unsigned in_other_partition
: 1;
543 /*** other flags. ***/
545 /* Set when symbol has address taken. */
546 unsigned address_taken
: 1;
547 /* Set when init priority is set. */
548 unsigned in_init_priority_hash
: 1;
550 /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
551 of offloading, for separate compilation for a different target. */
552 unsigned need_lto_streaming
: 1;
554 /* Set when symbol can be streamed into bytecode for offloading. */
555 unsigned offloadable
: 1;
557 /* Set when symbol is an IFUNC resolver. */
558 unsigned ifunc_resolver
: 1;
561 /* Ordering of all symtab entries. */
564 /* Declaration representing the symbol. */
567 /* Linked list of symbol table entries starting with symtab_nodes. */
569 symtab_node
*previous
;
571 /* Linked list of symbols with the same asm name. There may be multiple
572 entries for single symbol name during LTO, because symbols are renamed
573 only after partitioning.
575 Because inline clones are kept in the assembler name has, they also produce
578 There are also several long standing bugs where frontends and builtin
579 code produce duplicated decls. */
580 symtab_node
*next_sharing_asm_name
;
581 symtab_node
*previous_sharing_asm_name
;
583 /* Circular list of nodes in the same comdat group if non-NULL. */
584 symtab_node
*same_comdat_group
;
586 /* Vectors of referring and referenced entities. */
587 ipa_ref_list ref_list
;
589 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
590 depending to what was known to frontend on the creation time.
591 Once alias is resolved, this pointer become NULL. */
594 /* File stream where this node is being written to. */
595 struct lto_file_decl_data
* lto_file_data
;
597 PTR
GTY ((skip
)) aux
;
599 /* Comdat group the symbol is in. Can be private if GGC allowed that. */
602 /* Section name. Again can be private, if allowed. */
603 section_hash_entry
*x_section
;
606 /* Dump base fields of symtab nodes to F. Not to be used directly. */
607 void dump_base (FILE *);
609 /* Verify common part of symtab node. */
610 bool DEBUG_FUNCTION
verify_base (void);
612 /* Remove node from symbol table. This function is not used directly, but via
613 cgraph/varpool node removal routines. */
614 void unregister (void);
616 /* Return the initialization and finalization priority information for
617 DECL. If there is no previous priority information, a freshly
618 allocated structure is returned. */
619 struct symbol_priority_map
*priority_info (void);
621 /* Worker for call_for_symbol_and_aliases_1. */
622 bool call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*, void *),
624 bool include_overwrite
);
626 /* Worker for set_section. */
627 static bool set_section (symtab_node
*n
, void *s
);
629 /* Worker for symtab_resolve_alias. */
630 static bool set_implicit_section (symtab_node
*n
, void *);
632 /* Worker searching noninterposable alias. */
633 static bool noninterposable_alias (symtab_node
*node
, void *data
);
635 /* Worker for ultimate_alias_target. */
636 symtab_node
*ultimate_alias_target_1 (enum availability
*avail
= NULL
,
637 symtab_node
*ref
= NULL
);
639 /* Get dump name with normal or assembly name. */
640 const char *get_dump_name (bool asm_name_p
) const;
644 symtab_node::checking_verify_symtab_nodes (void)
647 symtab_node::verify_symtab_nodes ();
650 /* Walk all aliases for NODE. */
651 #define FOR_EACH_ALIAS(NODE, ALIAS) \
652 for (unsigned ALIAS##_iter_ = 0; \
653 (NODE)->iterate_direct_aliases (ALIAS##_iter_, ALIAS); \
656 /* This is the information that is put into the cgraph local structure
657 to recover a function. */
658 struct lto_file_decl_data
;
660 extern const char * const cgraph_availability_names
[];
661 extern const char * const ld_plugin_symbol_resolution_names
[];
662 extern const char * const tls_model_names
[];
664 /* Sub-structure of cgraph_node. Holds information about thunk, used only for
667 Thunks are basically wrappers around methods which are introduced in case
668 of multiple inheritance in order to adjust the value of the "this" pointer
669 or of the returned value.
671 In the case of this-adjusting thunks, each back-end can override the
672 can_output_mi_thunk/output_mi_thunk target hooks to generate a minimal thunk
673 (with a tail call for instance) directly as assembly. For the default hook
674 or for the case where the can_output_mi_thunk hooks return false, the thunk
675 is gimplified and lowered using the regular machinery. */
677 struct GTY(()) cgraph_thunk_info
{
678 /* Offset used to adjust "this". */
679 HOST_WIDE_INT fixed_offset
;
681 /* Offset in the virtual table to get the offset to adjust "this". Valid iff
682 VIRTUAL_OFFSET_P is true. */
683 HOST_WIDE_INT virtual_value
;
685 /* Offset from "this" to get the offset to adjust "this". Zero means: this
686 offset is to be ignored. */
687 HOST_WIDE_INT indirect_offset
;
689 /* Thunk target, i.e. the method that this thunk wraps. Depending on the
690 TARGET_USE_LOCAL_THUNK_ALIAS_P macro, this may have to be a new alias. */
693 /* Nonzero for a "this" adjusting thunk and zero for a result adjusting
697 /* If true, this thunk is what we call a virtual thunk. In this case:
698 * for this-adjusting thunks, after the FIXED_OFFSET based adjustment is
699 done, add to the result the offset found in the vtable at:
701 * for result-adjusting thunks, the FIXED_OFFSET adjustment is done after
703 bool virtual_offset_p
;
705 /* Set to true when alias node (the cgraph_node to which this struct belong)
706 is a thunk. Access to any other fields is invalid if this is false. */
710 /* Information about the function collected locally.
711 Available after function is analyzed. */
713 struct GTY(()) cgraph_local_info
{
714 /* Set when function is visible in current compilation unit only and
715 its address is never taken. */
718 /* False when there is something makes versioning impossible. */
719 unsigned versionable
: 1;
721 /* False when function calling convention and signature cannot be changed.
722 This is the case when __builtin_apply_args is used. */
723 unsigned can_change_signature
: 1;
725 /* True when the function has been originally extern inline, but it is
727 unsigned redefined_extern_inline
: 1;
729 /* True if the function may enter serial irrevocable mode. */
730 unsigned tm_may_enter_irr
: 1;
733 /* Represent which DECL tree (or reference to such tree)
734 will be replaced by another tree while versioning. */
735 struct GTY(()) ipa_replace_map
737 /* The new (replacing) tree. */
739 /* Parameter number to replace, when old_tree is NULL. */
743 struct GTY(()) cgraph_clone_info
745 /* Constants discovered by IPA-CP, i.e. which parameter should be replaced
747 vec
<ipa_replace_map
*, va_gc
> *tree_map
;
748 /* Parameter modification that IPA-SRA decided to perform. */
749 ipa_param_adjustments
*param_adjustments
;
750 /* Lists of dummy-decl and offset pairs representing split formal parameters
751 in the caller. Offsets of all new replacements are enumerated, those
752 coming from the same original parameter have the same dummy decl stored
755 Dummy decls sit in call statement arguments followed by new parameter
756 decls (or their SSA names) in between (caller) clone materialization and
757 call redirection. Redirection then recognizes the dummy variable and
758 together with the stored offsets can reconstruct what exactly the new
759 parameter decls represent and can leave in place only those that the
761 vec
<ipa_param_performed_split
, va_gc
> *performed_splits
;
764 enum cgraph_simd_clone_arg_type
766 SIMD_CLONE_ARG_TYPE_VECTOR
,
767 SIMD_CLONE_ARG_TYPE_UNIFORM
,
768 /* These are only for integer/pointer arguments passed by value. */
769 SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP
,
770 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP
,
771 /* These 6 are only for reference type arguments or arguments passed
773 SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP
,
774 SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP
,
775 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP
,
776 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP
,
777 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP
,
778 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP
,
779 SIMD_CLONE_ARG_TYPE_MASK
782 /* Function arguments in the original function of a SIMD clone.
783 Supplementary data for `struct simd_clone'. */
785 struct GTY(()) cgraph_simd_clone_arg
{
786 /* Original function argument as it originally existed in
790 /* orig_arg's function (or for extern functions type from
794 /* If argument is a vector, this holds the vector version of
795 orig_arg that after adjusting the argument types will live in
796 DECL_ARGUMENTS. Otherwise, this is NULL.
798 This basically holds:
799 vector(simdlen) __typeof__(orig_arg) new_arg. */
802 /* vector_arg's type (or for extern functions new vector type. */
805 /* If argument is a vector, this holds the array where the simd
806 argument is held while executing the simd clone function. This
807 is a local variable in the cloned function. Its content is
808 copied from vector_arg upon entry to the clone.
810 This basically holds:
811 __typeof__(orig_arg) simd_array[simdlen]. */
814 /* A SIMD clone's argument can be either linear (constant or
815 variable), uniform, or vector. */
816 enum cgraph_simd_clone_arg_type arg_type
;
818 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
819 the constant linear step, if arg_type is
820 SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
821 the uniform argument holding the step, otherwise 0. */
822 HOST_WIDE_INT linear_step
;
824 /* Variable alignment if available, otherwise 0. */
825 unsigned int alignment
;
828 /* Specific data for a SIMD function clone. */
830 struct GTY(()) cgraph_simd_clone
{
831 /* Number of words in the SIMD lane associated with this clone. */
832 unsigned int simdlen
;
834 /* Number of annotated function arguments in `args'. This is
835 usually the number of named arguments in FNDECL. */
838 /* Max hardware vector size in bits for integral vectors. */
839 unsigned int vecsize_int
;
841 /* Max hardware vector size in bits for floating point vectors. */
842 unsigned int vecsize_float
;
844 /* Machine mode of the mask argument(s), if they are to be passed
845 as bitmasks in integer argument(s). VOIDmode if masks are passed
846 as vectors of characteristic type. */
847 machine_mode mask_mode
;
849 /* The mangling character for a given vector size. This is used
850 to determine the ISA mangling bit as specified in the Intel
852 unsigned char vecsize_mangle
;
854 /* True if this is the masked, in-branch version of the clone,
856 unsigned int inbranch
: 1;
858 /* Doubly linked list of SIMD clones. */
859 cgraph_node
*prev_clone
, *next_clone
;
861 /* Original cgraph node the SIMD clones were created for. */
864 /* Annotated function arguments for the original function. */
865 cgraph_simd_clone_arg
GTY((length ("%h.nargs"))) args
[1];
868 /* Function Multiversioning info. */
869 struct GTY((for_user
)) cgraph_function_version_info
{
870 /* The cgraph_node for which the function version info is stored. */
871 cgraph_node
*this_node
;
872 /* Chains all the semantically identical function versions. The
873 first function in this chain is the version_info node of the
875 cgraph_function_version_info
*prev
;
876 /* If this version node corresponds to a dispatcher for function
877 versions, this points to the version info node of the default
878 function, the first node in the chain. */
879 cgraph_function_version_info
*next
;
880 /* If this node corresponds to a function version, this points
881 to the dispatcher function decl, which is the function that must
882 be called to execute the right function version at run-time.
884 If this cgraph node is a dispatcher (if dispatcher_function is
885 true, in the cgraph_node struct) for function versions, this
886 points to resolver function, which holds the function body of the
887 dispatcher. The dispatcher decl is an alias to the resolver
889 tree dispatcher_resolver
;
892 #define DEFCIFCODE(code, type, string) CIF_ ## code,
893 /* Reasons for inlining failures. */
895 enum cgraph_inline_failed_t
{
896 #include "cif-code.def"
900 enum cgraph_inline_failed_type_t
902 CIF_FINAL_NORMAL
= 0,
908 struct cgraph_edge_hasher
: ggc_ptr_hash
<cgraph_edge
>
910 typedef gimple
*compare_type
;
912 static hashval_t
hash (cgraph_edge
*);
913 static hashval_t
hash (gimple
*);
914 static bool equal (cgraph_edge
*, gimple
*);
917 /* The cgraph data structure.
918 Each function decl has assigned cgraph_node listing callees and callers. */
920 struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node
: public symtab_node
922 friend class symbol_table
;
924 /* Remove the node from cgraph and all inline clones inlined into it.
925 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
926 removed. This allows to call the function from outer loop walking clone
928 bool remove_symbol_and_inline_clones (cgraph_node
*forbidden_node
= NULL
);
930 /* Record all references from cgraph_node that are taken
931 in statement STMT. */
932 void record_stmt_references (gimple
*stmt
);
934 /* Like cgraph_set_call_stmt but walk the clone tree and update all
935 clones sharing the same function body.
936 When WHOLE_SPECULATIVE_EDGES is true, all three components of
937 speculative edge gets updated. Otherwise we update only direct
939 void set_call_stmt_including_clones (gimple
*old_stmt
, gcall
*new_stmt
,
940 bool update_speculative
= true);
942 /* Walk the alias chain to return the function cgraph_node is alias of.
943 Walk through thunk, too.
944 When AVAILABILITY is non-NULL, get minimal availability in the chain.
945 When REF is non-NULL, assume that reference happens in symbol REF
946 when determining the availability. */
947 cgraph_node
*function_symbol (enum availability
*avail
= NULL
,
948 struct symtab_node
*ref
= NULL
);
950 /* Walk the alias chain to return the function cgraph_node is alias of.
951 Walk through non virtual thunks, too. Thus we return either a function
952 or a virtual thunk node.
953 When AVAILABILITY is non-NULL, get minimal availability in the chain.
954 When REF is non-NULL, assume that reference happens in symbol REF
955 when determining the availability. */
956 cgraph_node
*function_or_virtual_thunk_symbol
957 (enum availability
*avail
= NULL
,
958 struct symtab_node
*ref
= NULL
);
960 /* Create node representing clone of N executed COUNT times. Decrease
961 the execution counts from original node too.
962 The new clone will have decl set to DECL that may or may not be the same
965 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
966 function's profile to reflect the fact that part of execution is handled
968 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
969 the new clone. Otherwise the caller is responsible for doing so later.
971 If the new node is being inlined into another one, NEW_INLINED_TO should be
972 the outline function the new one is (even indirectly) inlined to.
973 All hooks will see this in node's inlined_to, when invoked.
974 Can be NULL if the node is not inlined. SUFFIX is string that is appended
975 to the original name. */
976 cgraph_node
*create_clone (tree decl
, profile_count count
,
977 bool update_original
,
978 vec
<cgraph_edge
*> redirect_callers
,
979 bool call_duplication_hook
,
980 cgraph_node
*new_inlined_to
,
981 ipa_param_adjustments
*param_adjustments
,
982 const char *suffix
= NULL
);
984 /* Create callgraph node clone with new declaration. The actual body will be
985 copied later at compilation stage. The name of the new clone will be
986 constructed from the name of the original node, SUFFIX and NUM_SUFFIX. */
987 cgraph_node
*create_virtual_clone (vec
<cgraph_edge
*> redirect_callers
,
988 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
989 ipa_param_adjustments
*param_adjustments
,
990 const char * suffix
, unsigned num_suffix
);
992 /* cgraph node being removed from symbol table; see if its entry can be
993 replaced by other inline clone. */
994 cgraph_node
*find_replacement (void);
996 /* Create a new cgraph node which is the new version of
997 callgraph node. REDIRECT_CALLERS holds the callers
998 edges which should be redirected to point to
999 NEW_VERSION. ALL the callees edges of the node
1000 are cloned to the new version node. Return the new
1003 If non-NULL BLOCK_TO_COPY determine what basic blocks
1004 was copied to prevent duplications of calls that are dead
1007 SUFFIX is string that is appended to the original name. */
1009 cgraph_node
*create_version_clone (tree new_decl
,
1010 vec
<cgraph_edge
*> redirect_callers
,
1012 const char *suffix
= NULL
);
1014 /* Perform function versioning.
1015 Function versioning includes copying of the tree and
1016 a callgraph update (creating a new cgraph node and updating
1017 its callees and callers).
1019 REDIRECT_CALLERS varray includes the edges to be redirected
1022 TREE_MAP is a mapping of tree nodes we want to replace with
1023 new ones (according to results of prior analysis).
1025 If non-NULL ARGS_TO_SKIP determine function parameters to remove
1027 If SKIP_RETURN is true, the new version will return void.
1028 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
1029 If non_NULL NEW_ENTRY determine new entry BB of the clone.
1031 If TARGET_ATTRIBUTES is non-null, when creating a new declaration,
1032 add the attributes to DECL_ATTRIBUTES. And call valid_attribute_p
1033 that will promote value of the attribute DECL_FUNCTION_SPECIFIC_TARGET
1036 Return the new version's cgraph node. */
1037 cgraph_node
*create_version_clone_with_body
1038 (vec
<cgraph_edge
*> redirect_callers
,
1039 vec
<ipa_replace_map
*, va_gc
> *tree_map
,
1040 ipa_param_adjustments
*param_adjustments
,
1041 bitmap bbs_to_copy
, basic_block new_entry_block
, const char *clone_name
,
1042 tree target_attributes
= NULL_TREE
);
1044 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
1045 corresponding to cgraph_node. */
1046 cgraph_function_version_info
*insert_new_function_version (void);
1048 /* Get the cgraph_function_version_info node corresponding to node. */
1049 cgraph_function_version_info
*function_version (void);
1051 /* Discover all functions and variables that are trivially needed, analyze
1052 them as well as all functions and variables referred by them */
1053 void analyze (void);
1055 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
1056 aliases DECL with an adjustments made into the first parameter.
1057 See comments in struct cgraph_thunk_info for detail on the parameters. */
1058 cgraph_node
* create_thunk (tree alias
, tree
, bool this_adjusting
,
1059 HOST_WIDE_INT fixed_offset
,
1060 HOST_WIDE_INT virtual_value
,
1061 HOST_WIDE_INT indirect_offset
,
1062 tree virtual_offset
,
1066 /* Return node that alias is aliasing. */
1067 inline cgraph_node
*get_alias_target (void);
1069 /* Given function symbol, walk the alias chain to return the function node
1070 is alias of. Do not walk through thunks.
1071 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1072 When REF is non-NULL, assume that reference happens in symbol REF
1073 when determining the availability. */
1075 cgraph_node
*ultimate_alias_target (availability
*availability
= NULL
,
1076 symtab_node
*ref
= NULL
);
1078 /* Expand thunk NODE to gimple if possible.
1079 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1080 no assembler is produced.
1081 When OUTPUT_ASM_THUNK is true, also produce assembler for
1082 thunks that are not lowered. */
1083 bool expand_thunk (bool output_asm_thunks
, bool force_gimple_thunk
);
1085 /* Call expand_thunk on all callers that are thunks and analyze those
1086 nodes that were expanded. */
1087 void expand_all_artificial_thunks ();
1089 /* Assemble thunks and aliases associated to node. */
1090 void assemble_thunks_and_aliases (void);
1092 /* Expand function specified by node. */
1095 /* As an GCC extension we allow redefinition of the function. The
1096 semantics when both copies of bodies differ is not well defined.
1097 We replace the old body with new body so in unit at a time mode
1098 we always use new body, while in normal mode we may end up with
1099 old body inlined into some functions and new body expanded and
1100 inlined in others. */
1103 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
1104 kind of wrapper method. */
1105 void create_wrapper (cgraph_node
*target
);
1107 /* Verify cgraph nodes of the cgraph node. */
1108 void DEBUG_FUNCTION
verify_node (void);
1110 /* Remove function from symbol table. */
1113 /* Dump call graph node to file F. */
1114 void dump (FILE *f
);
1116 /* Dump call graph node to file F. */
1117 void dump_graphviz (FILE *f
);
1119 /* Dump call graph node to stderr. */
1120 void DEBUG_FUNCTION
debug (void);
1122 /* When doing LTO, read cgraph_node's body from disk if it is not already
1124 bool get_untransformed_body (void);
1126 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
1127 if it is not already present. When some IPA transformations are scheduled,
1129 bool get_body (void);
1131 /* Release memory used to represent body of function.
1132 Use this only for functions that are released before being translated to
1133 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1134 are free'd in final.c via free_after_compilation(). */
1135 void release_body (bool keep_arguments
= false);
1137 /* Return the DECL_STRUCT_FUNCTION of the function. */
1138 struct function
*get_fun () const;
1140 /* cgraph_node is no longer nested function; update cgraph accordingly. */
1143 /* Bring cgraph node local. */
1144 void make_local (void);
1146 /* Likewise indicate that a node is having address taken. */
1147 void mark_address_taken (void);
1149 /* Set fialization priority to PRIORITY. */
1150 void set_fini_priority (priority_type priority
);
1152 /* Return the finalization priority. */
1153 priority_type
get_fini_priority (void);
1155 /* Create edge from a given function to CALLEE in the cgraph. */
1156 cgraph_edge
*create_edge (cgraph_node
*callee
,
1157 gcall
*call_stmt
, profile_count count
,
1158 bool cloning_p
= false);
1160 /* Create an indirect edge with a yet-undetermined callee where the call
1161 statement destination is a formal parameter of the caller with index
1163 cgraph_edge
*create_indirect_edge (gcall
*call_stmt
, int ecf_flags
,
1164 profile_count count
,
1165 bool cloning_p
= false);
1167 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
1168 same function body. If clones already have edge for OLD_STMT; only
1169 update the edge same way as cgraph_set_call_stmt_including_clones does. */
1170 void create_edge_including_clones (cgraph_node
*callee
,
1171 gimple
*old_stmt
, gcall
*stmt
,
1172 profile_count count
,
1173 cgraph_inline_failed_t reason
);
1175 /* Return the callgraph edge representing the GIMPLE_CALL statement
1177 cgraph_edge
*get_edge (gimple
*call_stmt
);
1179 /* Collect all callers of cgraph_node and its aliases that are known to lead
1180 to NODE (i.e. are not overwritable) and that are not thunks. */
1181 vec
<cgraph_edge
*> collect_callers (void);
1183 /* Remove all callers from the node. */
1184 void remove_callers (void);
1186 /* Remove all callees from the node. */
1187 void remove_callees (void);
1189 /* Return function availability. See cgraph.h for description of individual
1191 enum availability
get_availability (symtab_node
*ref
= NULL
);
1193 /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
1194 if any to NOTHROW. */
1195 bool set_nothrow_flag (bool nothrow
);
1197 /* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node
1199 bool set_malloc_flag (bool malloc_p
);
1201 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
1202 If SET_CONST if false, clear the flag.
1204 When setting the flag be careful about possible interposition and
1205 do not set the flag for functions that can be interposet and set pure
1206 flag for functions that can bind to other definition.
1208 Return true if any change was done. */
1210 bool set_const_flag (bool set_const
, bool looping
);
1212 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
1215 When setting the flag, be careful about possible interposition.
1216 Return true if any change was done. */
1218 bool set_pure_flag (bool pure
, bool looping
);
1220 /* Call callback on function and aliases associated to the function.
1221 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1224 bool call_for_symbol_and_aliases (bool (*callback
) (cgraph_node
*,
1226 void *data
, bool include_overwritable
);
1228 /* Call callback on cgraph_node, thunks and aliases associated to NODE.
1229 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1230 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
1232 bool call_for_symbol_thunks_and_aliases (bool (*callback
) (cgraph_node
*node
,
1235 bool include_overwritable
,
1236 bool exclude_virtual_thunks
= false);
1238 /* Likewise indicate that a node is needed, i.e. reachable via some
1240 inline void mark_force_output (void);
1242 /* Return true when function can be marked local. */
1243 bool local_p (void);
1245 /* Return true if cgraph_node can be made local for API change.
1246 Extern inline functions and C++ COMDAT functions can be made local
1247 at the expense of possible code size growth if function is used in multiple
1248 compilation units. */
1249 bool can_be_local_p (void);
1251 /* Return true when cgraph_node cannot return or throw and thus
1252 it is safe to ignore its side effects for IPA analysis. */
1253 bool cannot_return_p (void);
1255 /* Return true when function cgraph_node and all its aliases are only called
1257 i.e. it is not externally visible, address was not taken and
1258 it is not used in any other non-standard way. */
1259 bool only_called_directly_p (void);
1261 /* Return true when function is only called directly or it has alias.
1262 i.e. it is not externally visible, address was not taken and
1263 it is not used in any other non-standard way. */
1264 inline bool only_called_directly_or_aliased_p (void);
1266 /* Return true when function cgraph_node can be expected to be removed
1267 from program when direct calls in this compilation unit are removed.
1269 As a special case COMDAT functions are
1270 cgraph_can_remove_if_no_direct_calls_p while the are not
1271 cgraph_only_called_directly_p (it is possible they are called from other
1274 This function behaves as cgraph_only_called_directly_p because eliminating
1275 all uses of COMDAT function does not make it necessarily disappear from
1276 the program unless we are compiling whole program or we do LTO. In this
1277 case we know we win since dynamic linking will not really discard the
1280 If WILL_INLINE is true, assume that function will be inlined into all the
1282 bool will_be_removed_from_program_if_no_direct_calls_p
1283 (bool will_inline
= false);
1285 /* Return true when function can be removed from callgraph
1286 if all direct calls and references are eliminated. The function does
1287 not take into account comdat groups. */
1288 bool can_remove_if_no_direct_calls_and_refs_p (void);
1290 /* Return true when function cgraph_node and its aliases can be removed from
1291 callgraph if all direct calls are eliminated.
1292 If WILL_INLINE is true, assume that function will be inlined into all the
1294 bool can_remove_if_no_direct_calls_p (bool will_inline
= false);
1296 /* Return true when callgraph node is a function with Gimple body defined
1297 in current unit. Functions can also be define externally or they
1298 can be thunks with no Gimple representation.
1300 Note that at WPA stage, the function body may not be present in memory. */
1301 inline bool has_gimple_body_p (void);
1303 /* Return true if this node represents a former, i.e. an expanded, thunk. */
1304 inline bool former_thunk_p (void);
1306 /* Return true if function should be optimized for size. */
1307 bool optimize_for_size_p (void);
1309 /* Dump the callgraph to file F. */
1310 static void dump_cgraph (FILE *f
);
1312 /* Dump the call graph to stderr. */
1314 void debug_cgraph (void)
1316 dump_cgraph (stderr
);
1319 /* Get unique identifier of the node. */
1320 inline int get_uid ()
1325 /* Get summary id of the node. */
1326 inline int get_summary_id ()
1328 return m_summary_id
;
1331 /* Record that DECL1 and DECL2 are semantically identical function
1333 static void record_function_versions (tree decl1
, tree decl2
);
1335 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
1336 DECL is a duplicate declaration. */
1337 static void delete_function_version_by_decl (tree decl
);
1339 /* Add the function FNDECL to the call graph.
1340 Unlike finalize_function, this function is intended to be used
1341 by middle end and allows insertion of new function at arbitrary point
1342 of compilation. The function can be either in high, low or SSA form
1345 The function is assumed to be reachable and have address taken (so no
1346 API breaking optimizations are performed on it).
1348 Main work done by this function is to enqueue the function for later
1349 processing to avoid need the passes to be re-entrant. */
1350 static void add_new_function (tree fndecl
, bool lowered
);
1352 /* Return callgraph node for given symbol and check it is a function. */
1353 static inline cgraph_node
*get (const_tree decl
)
1355 gcc_checking_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1356 return dyn_cast
<cgraph_node
*> (symtab_node::get (decl
));
1359 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
1360 logic in effect. If NO_COLLECT is true, then our caller cannot stand to
1361 have the garbage collector run at the moment. We would need to either
1362 create a new GC context, or just not compile right now. */
1363 static void finalize_function (tree
, bool);
1365 /* Return cgraph node assigned to DECL. Create new one when needed. */
1366 static cgraph_node
* create (tree decl
);
1368 /* Try to find a call graph node for declaration DECL and if it does not
1369 exist or if it corresponds to an inline clone, create a new one. */
1370 static cgraph_node
* get_create (tree
);
1372 /* Return local info for the compiled function. */
1373 static cgraph_local_info
*local_info (tree decl
);
1375 /* Return RTL info for the compiled function. */
1376 static struct cgraph_rtl_info
*rtl_info (const_tree
);
1378 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1379 Return NULL if there's no such node. */
1380 static cgraph_node
*get_for_asmname (tree asmname
);
1382 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if
1383 successful and NULL otherwise.
1384 Same body aliases are output whenever the body of DECL is output,
1385 and cgraph_node::get (ALIAS) transparently
1386 returns cgraph_node::get (DECL). */
1387 static cgraph_node
* create_same_body_alias (tree alias
, tree decl
);
1389 /* Verify whole cgraph structure. */
1390 static void DEBUG_FUNCTION
verify_cgraph_nodes (void);
1392 /* Verify cgraph, if consistency checking is enabled. */
1393 static inline void checking_verify_cgraph_nodes (void);
1395 /* Worker to bring NODE local. */
1396 static bool make_local (cgraph_node
*node
, void *);
1398 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
1399 the function body is associated
1400 with (not necessarily cgraph_node (DECL). */
1401 static cgraph_node
*create_alias (tree alias
, tree target
);
1403 /* Return true if NODE has thunk. */
1404 static bool has_thunk_p (cgraph_node
*node
, void *);
1406 cgraph_edge
*callees
;
1407 cgraph_edge
*callers
;
1408 /* List of edges representing indirect calls with a yet undetermined
1410 cgraph_edge
*indirect_calls
;
1411 /* For nested functions points to function the node is nested in. */
1412 cgraph_node
*origin
;
1413 /* Points to first nested function, if any. */
1414 cgraph_node
*nested
;
1415 /* Pointer to the next function with same origin, if any. */
1416 cgraph_node
*next_nested
;
1417 /* Pointer to the next clone. */
1418 cgraph_node
*next_sibling_clone
;
1419 cgraph_node
*prev_sibling_clone
;
1420 cgraph_node
*clones
;
1421 cgraph_node
*clone_of
;
1422 /* For functions with many calls sites it holds map from call expression
1423 to the edge to speed up cgraph_edge function. */
1424 hash_table
<cgraph_edge_hasher
> *GTY(()) call_site_hash
;
1425 /* Declaration node used to be clone of. */
1426 tree former_clone_of
;
1428 /* If this is a SIMD clone, this points to the SIMD specific
1429 information for it. */
1430 cgraph_simd_clone
*simdclone
;
1431 /* If this function has SIMD clones, this points to the first clone. */
1432 cgraph_node
*simd_clones
;
1434 /* Interprocedural passes scheduled to have their transform functions
1435 applied next time we execute local pass on them. We maintain it
1436 per-function in order to allow IPA passes to introduce new functions. */
1437 vec
<ipa_opt_pass
> GTY((skip
)) ipa_transforms_to_apply
;
1439 cgraph_local_info local
;
1441 /* For inline clones this points to the function they will be
1443 cgraph_node
*inlined_to
;
1445 struct cgraph_rtl_info
*rtl
;
1446 cgraph_clone_info clone
;
1447 cgraph_thunk_info thunk
;
1449 /* Expected number of executions: calculated in profile.c. */
1450 profile_count count
;
1451 /* How to scale counts at materialization time; used to merge
1452 LTO units with different number of profile runs. */
1453 int count_materialization_scale
;
1454 /* ID assigned by the profiling. */
1455 unsigned int profile_id
;
1456 /* Time profiler: first run of function. */
1459 /* Set when decl is an abstract function pointed to by the
1460 ABSTRACT_DECL_ORIGIN of a reachable function. */
1461 unsigned used_as_abstract_origin
: 1;
1462 /* Set once the function is lowered (i.e. its CFG is built). */
1463 unsigned lowered
: 1;
1464 /* Set once the function has been instantiated and its callee
1466 unsigned process
: 1;
1467 /* How commonly executed the node is. Initialized during branch
1468 probabilities pass. */
1469 ENUM_BITFIELD (node_frequency
) frequency
: 2;
1470 /* True when function can only be called at startup (from static ctor). */
1471 unsigned only_called_at_startup
: 1;
1472 /* True when function can only be called at startup (from static dtor). */
1473 unsigned only_called_at_exit
: 1;
1474 /* True when function is the transactional clone of a function which
1475 is called only from inside transactions. */
1476 /* ?? We should be able to remove this. We have enough bits in
1477 cgraph to calculate it. */
1478 unsigned tm_clone
: 1;
1479 /* True if this decl is a dispatcher for function versions. */
1480 unsigned dispatcher_function
: 1;
1481 /* True if this decl calls a COMDAT-local function. This is set up in
1482 compute_fn_summary and inline_call. */
1483 unsigned calls_comdat_local
: 1;
1484 /* True if node has been created by merge operation in IPA-ICF. */
1485 unsigned icf_merged
: 1;
1486 /* True if call to node can't result in a call to free, munmap or
1487 other operation that could make previously non-trapping memory
1488 accesses trapping. */
1489 unsigned nonfreeing_fn
: 1;
1490 /* True if there was multiple COMDAT bodies merged by lto-symtab. */
1491 unsigned merged_comdat
: 1;
1492 /* True if function was created to be executed in parallel. */
1493 unsigned parallelized_function
: 1;
1494 /* True if function is part split out by ipa-split. */
1495 unsigned split_part
: 1;
1496 /* True if the function appears as possible target of indirect call. */
1497 unsigned indirect_call_target
: 1;
1500 /* Unique id of the node. */
1503 /* Summary id that is recycled. */
1506 /* Worker for call_for_symbol_and_aliases. */
1507 bool call_for_symbol_and_aliases_1 (bool (*callback
) (cgraph_node
*,
1509 void *data
, bool include_overwritable
);
1512 /* A cgraph node set is a collection of cgraph nodes. A cgraph node
1513 can appear in multiple sets. */
1514 struct cgraph_node_set_def
1516 hash_map
<cgraph_node
*, size_t> *map
;
1517 vec
<cgraph_node
*> nodes
;
1520 typedef cgraph_node_set_def
*cgraph_node_set
;
1521 typedef struct varpool_node_set_def
*varpool_node_set
;
1523 struct varpool_node
;
1525 /* A varpool node set is a collection of varpool nodes. A varpool node
1526 can appear in multiple sets. */
1527 struct varpool_node_set_def
1529 hash_map
<varpool_node
*, size_t> * map
;
1530 vec
<varpool_node
*> nodes
;
1533 /* Iterator structure for cgraph node sets. */
1534 struct cgraph_node_set_iterator
1536 cgraph_node_set set
;
1540 /* Iterator structure for varpool node sets. */
1541 struct varpool_node_set_iterator
1543 varpool_node_set set
;
1547 /* Context of polymorphic call. It represent information about the type of
1548 instance that may reach the call. This is used by ipa-devirt walkers of the
1549 type inheritance graph. */
1551 class GTY(()) ipa_polymorphic_call_context
{
1553 /* The called object appears in an object of type OUTER_TYPE
1554 at offset OFFSET. When information is not 100% reliable, we
1555 use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
1556 HOST_WIDE_INT offset
;
1557 HOST_WIDE_INT speculative_offset
;
1559 tree speculative_outer_type
;
1560 /* True if outer object may be in construction or destruction. */
1561 unsigned maybe_in_construction
: 1;
1562 /* True if outer object may be of derived type. */
1563 unsigned maybe_derived_type
: 1;
1564 /* True if speculative outer object may be of derived type. We always
1565 speculate that construction does not happen. */
1566 unsigned speculative_maybe_derived_type
: 1;
1567 /* True if the context is invalid and all calls should be redirected
1568 to BUILTIN_UNREACHABLE. */
1569 unsigned invalid
: 1;
1570 /* True if the outer type is dynamic. */
1571 unsigned dynamic
: 1;
1573 /* Build empty "I know nothing" context. */
1574 ipa_polymorphic_call_context ();
1575 /* Build polymorphic call context for indirect call E. */
1576 ipa_polymorphic_call_context (cgraph_edge
*e
);
1577 /* Build polymorphic call context for IP invariant CST.
1578 If specified, OTR_TYPE specify the type of polymorphic call
1579 that takes CST+OFFSET as a prameter. */
1580 ipa_polymorphic_call_context (tree cst
, tree otr_type
= NULL
,
1581 HOST_WIDE_INT offset
= 0);
1582 /* Build context for pointer REF contained in FNDECL at statement STMT.
1583 if INSTANCE is non-NULL, return pointer to the object described by
1585 ipa_polymorphic_call_context (tree fndecl
, tree ref
, gimple
*stmt
,
1586 tree
*instance
= NULL
);
1588 /* Look for vtable stores or constructor calls to work out dynamic type
1589 of memory location. */
1590 bool get_dynamic_type (tree
, tree
, tree
, gimple
*, unsigned *);
1592 /* Make context non-speculative. */
1593 void clear_speculation ();
1595 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
1596 NULL, the context is set to dummy "I know nothing" setting. */
1597 void clear_outer_type (tree otr_type
= NULL
);
1599 /* Walk container types and modify context to point to actual class
1600 containing OTR_TYPE (if non-NULL) as base class.
1601 Return true if resulting context is valid.
1603 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
1604 valid only via allocation of new polymorphic type inside by means
1607 When CONSIDER_BASES is false, only look for actual fields, not base types
1609 bool restrict_to_inner_class (tree otr_type
,
1610 bool consider_placement_new
= true,
1611 bool consider_bases
= true);
1613 /* Adjust all offsets in contexts by given number of bits. */
1614 void offset_by (HOST_WIDE_INT
);
1615 /* Use when we cannot track dynamic type change. This speculatively assume
1616 type change is not happening. */
1617 void possible_dynamic_type_change (bool, tree otr_type
= NULL
);
1618 /* Assume that both THIS and a given context is valid and strenghten THIS
1619 if possible. Return true if any strenghtening was made.
1620 If actual type the context is being used in is known, OTR_TYPE should be
1621 set accordingly. This improves quality of combined result. */
1622 bool combine_with (ipa_polymorphic_call_context
, tree otr_type
= NULL
);
1623 bool meet_with (ipa_polymorphic_call_context
, tree otr_type
= NULL
);
1625 /* Return TRUE if context is fully useless. */
1626 bool useless_p () const;
1627 /* Return TRUE if this context conveys the same information as X. */
1628 bool equal_to (const ipa_polymorphic_call_context
&x
) const;
1630 /* Dump human readable context to F. If NEWLINE is true, it will be
1631 terminated by a newline. */
1632 void dump (FILE *f
, bool newline
= true) const;
1633 void DEBUG_FUNCTION
debug () const;
1635 /* LTO streaming. */
1636 void stream_out (struct output_block
*) const;
1637 void stream_in (class lto_input_block
*, class data_in
*data_in
);
1640 bool combine_speculation_with (tree
, HOST_WIDE_INT
, bool, tree
);
1641 bool meet_speculation_with (tree
, HOST_WIDE_INT
, bool, tree
);
1642 void set_by_decl (tree
, HOST_WIDE_INT
);
1643 bool set_by_invariant (tree
, tree
, HOST_WIDE_INT
);
1644 bool speculation_consistent_p (tree
, HOST_WIDE_INT
, bool, tree
) const;
1645 void make_speculative (tree otr_type
= NULL
);
1648 /* Structure containing additional information about an indirect call. */
1650 class GTY(()) cgraph_indirect_call_info
1653 /* When agg_content is set, an offset where the call pointer is located
1654 within the aggregate. */
1655 HOST_WIDE_INT offset
;
1656 /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */
1657 ipa_polymorphic_call_context context
;
1658 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
1659 HOST_WIDE_INT otr_token
;
1660 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
1662 /* Index of the parameter that is called. */
1664 /* ECF flags determined from the caller. */
1666 /* Profile_id of common target obtrained from profile. */
1667 int common_target_id
;
1668 /* Probability that call will land in function with COMMON_TARGET_ID. */
1669 int common_target_probability
;
1671 /* Set when the call is a virtual call with the parameter being the
1672 associated object pointer rather than a simple direct call. */
1673 unsigned polymorphic
: 1;
1674 /* Set when the call is a call of a pointer loaded from contents of an
1675 aggregate at offset. */
1676 unsigned agg_contents
: 1;
1677 /* Set when this is a call through a member pointer. */
1678 unsigned member_ptr
: 1;
1679 /* When the agg_contents bit is set, this one determines whether the
1680 destination is loaded from a parameter passed by reference. */
1681 unsigned by_ref
: 1;
1682 /* When the agg_contents bit is set, this one determines whether we can
1683 deduce from the function body that the loaded value from the reference is
1684 never modified between the invocation of the function and the load
1686 unsigned guaranteed_unmodified
: 1;
1687 /* For polymorphic calls this specify whether the virtual table pointer
1688 may have changed in between function entry and the call. */
1689 unsigned vptr_changed
: 1;
1692 class GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
1693 for_user
)) cgraph_edge
1696 friend struct cgraph_node
;
1697 friend class symbol_table
;
1699 /* Remove the edge in the cgraph. */
1702 /* Change field call_stmt of edge to NEW_STMT.
1703 If UPDATE_SPECULATIVE and E is any component of speculative
1704 edge, then update all components. */
1705 void set_call_stmt (gcall
*new_stmt
, bool update_speculative
= true);
1707 /* Redirect callee of the edge to N. The function does not update underlying
1709 void redirect_callee (cgraph_node
*n
);
1711 /* If the edge does not lead to a thunk, simply redirect it to N. Otherwise
1712 create one or more equivalent thunks for N and redirect E to the first in
1713 the chain. Note that it is then necessary to call
1714 n->expand_all_artificial_thunks once all callers are redirected. */
1715 void redirect_callee_duplicating_thunks (cgraph_node
*n
);
1717 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1718 CALLEE. DELTA is an integer constant that is to be added to the this
1719 pointer (first parameter) to compensate for skipping
1720 a thunk adjustment. */
1721 cgraph_edge
*make_direct (cgraph_node
*callee
);
1723 /* Turn edge into speculative call calling N2. Update
1724 the profile so the direct call is taken COUNT times
1726 cgraph_edge
*make_speculative (cgraph_node
*n2
, profile_count direct_count
);
1728 /* Given speculative call edge, return all three components. */
1729 void speculative_call_info (cgraph_edge
*&direct
, cgraph_edge
*&indirect
,
1730 ipa_ref
*&reference
);
1732 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1733 Remove the speculative call sequence and return edge representing the call.
1734 It is up to caller to redirect the call as appropriate. */
1735 cgraph_edge
*resolve_speculation (tree callee_decl
= NULL
);
1737 /* If necessary, change the function declaration in the call statement
1738 associated with the edge so that it corresponds to the edge callee. */
1739 gimple
*redirect_call_stmt_to_callee (void);
1741 /* Create clone of edge in the node N represented
1742 by CALL_EXPR the callgraph. */
1743 cgraph_edge
* clone (cgraph_node
*n
, gcall
*call_stmt
, unsigned stmt_uid
,
1744 profile_count num
, profile_count den
,
1745 bool update_original
);
1747 /* Verify edge count and frequency. */
1748 bool verify_count ();
1750 /* Return true when call of edge cannot lead to return from caller
1751 and thus it is safe to ignore its side effects for IPA analysis
1752 when computing side effects of the caller. */
1753 bool cannot_lead_to_return_p (void);
1755 /* Return true when the edge represents a direct recursion. */
1756 bool recursive_p (void);
1758 /* Return true if the edge may be considered hot. */
1759 bool maybe_hot_p (void);
1761 /* Get unique identifier of the edge. */
1762 inline int get_uid ()
1767 /* Get summary id of the edge. */
1768 inline int get_summary_id ()
1770 return m_summary_id
;
1773 /* Rebuild cgraph edges for current function node. This needs to be run after
1774 passes that don't update the cgraph. */
1775 static unsigned int rebuild_edges (void);
1777 /* Rebuild cgraph references for current function node. This needs to be run
1778 after passes that don't update the cgraph. */
1779 static void rebuild_references (void);
1781 /* During LTO stream in this can be used to check whether call can possibly
1782 be internal to the current translation unit. */
1783 bool possibly_call_in_translation_unit_p (void);
1785 /* Expected number of executions: calculated in profile.c. */
1786 profile_count count
;
1787 cgraph_node
*caller
;
1788 cgraph_node
*callee
;
1789 cgraph_edge
*prev_caller
;
1790 cgraph_edge
*next_caller
;
1791 cgraph_edge
*prev_callee
;
1792 cgraph_edge
*next_callee
;
1794 /* Additional information about an indirect call. Not cleared when an edge
1796 cgraph_indirect_call_info
*indirect_info
;
1797 PTR
GTY ((skip (""))) aux
;
1798 /* When equal to CIF_OK, inline this call. Otherwise, points to the
1799 explanation why function was not inlined. */
1800 enum cgraph_inline_failed_t inline_failed
;
1801 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
1802 when the function is serialized in. */
1803 unsigned int lto_stmt_uid
;
1804 /* Whether this edge was made direct by indirect inlining. */
1805 unsigned int indirect_inlining_edge
: 1;
1806 /* Whether this edge describes an indirect call with an undetermined
1808 unsigned int indirect_unknown_callee
: 1;
1809 /* Whether this edge is still a dangling */
1810 /* True if the corresponding CALL stmt cannot be inlined. */
1811 unsigned int call_stmt_cannot_inline_p
: 1;
1812 /* Can this call throw externally? */
1813 unsigned int can_throw_external
: 1;
1814 /* Edges with SPECULATIVE flag represents indirect calls that was
1815 speculatively turned into direct (i.e. by profile feedback).
1816 The final code sequence will have form:
1818 if (call_target == expected_fn)
1823 Every speculative call is represented by three components attached
1824 to a same call statement:
1825 1) a direct call (to expected_fn)
1826 2) an indirect call (to call_target)
1827 3) a IPA_REF_ADDR refrence to expected_fn.
1829 Optimizers may later redirect direct call to clone, so 1) and 3)
1830 do not need to necesarily agree with destination. */
1831 unsigned int speculative
: 1;
1832 /* Set to true when caller is a constructor or destructor of polymorphic
1834 unsigned in_polymorphic_cdtor
: 1;
1836 /* Return true if call must bind to current definition. */
1837 bool binds_to_current_def_p ();
1839 /* Expected frequency of executions within the function.
1840 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
1841 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
1844 /* Expected frequency of executions within the function. */
1845 sreal
sreal_frequency ();
1847 /* Unique id of the edge. */
1850 /* Summary id that is recycled. */
1853 /* Remove the edge from the list of the callers of the callee. */
1854 void remove_caller (void);
1856 /* Remove the edge from the list of the callees of the caller. */
1857 void remove_callee (void);
1859 /* Set callee N of call graph edge and add it to the corresponding set of
1861 void set_callee (cgraph_node
*n
);
1863 /* Output flags of edge to a file F. */
1864 void dump_edge_flags (FILE *f
);
1866 /* Verify that call graph edge corresponds to DECL from the associated
1867 statement. Return true if the verification should fail. */
1868 bool verify_corresponds_to_fndecl (tree decl
);
1871 #define CGRAPH_FREQ_BASE 1000
1872 #define CGRAPH_FREQ_MAX 100000
1874 /* The varpool data structure.
1875 Each static variable decl has assigned varpool_node. */
1877 struct GTY((tag ("SYMTAB_VARIABLE"))) varpool_node
: public symtab_node
1879 /* Dump given varpool node to F. */
1880 void dump (FILE *f
);
1882 /* Dump given varpool node to stderr. */
1883 void DEBUG_FUNCTION
debug (void);
1885 /* Remove variable from symbol table. */
1888 /* Remove node initializer when it is no longer needed. */
1889 void remove_initializer (void);
1891 void analyze (void);
1893 /* Return variable availability. */
1894 availability
get_availability (symtab_node
*ref
= NULL
);
1896 /* When doing LTO, read variable's constructor from disk if
1897 it is not already present. */
1898 tree
get_constructor (void);
1900 /* Return true if variable has constructor that can be used for folding. */
1901 bool ctor_useable_for_folding_p (void);
1903 /* For given variable pool node, walk the alias chain to return the function
1904 the variable is alias of. Do not walk through thunks.
1905 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1906 When REF is non-NULL, assume that reference happens in symbol REF
1907 when determining the availability. */
1908 inline varpool_node
*ultimate_alias_target
1909 (availability
*availability
= NULL
, symtab_node
*ref
= NULL
);
1911 /* Return node that alias is aliasing. */
1912 inline varpool_node
*get_alias_target (void);
1914 /* Output one variable, if necessary. Return whether we output it. */
1915 bool assemble_decl (void);
1917 /* For variables in named sections make sure get_variable_section
1918 is called before we switch to those sections. Then section
1919 conflicts between read-only and read-only requiring relocations
1920 sections can be resolved. */
1921 void finalize_named_section_flags (void);
1923 /* Call calback on varpool symbol and aliases associated to varpool symbol.
1924 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1926 bool call_for_symbol_and_aliases (bool (*callback
) (varpool_node
*, void *),
1928 bool include_overwritable
);
1930 /* Return true when variable should be considered externally visible. */
1931 bool externally_visible_p (void);
1933 /* Return true when all references to variable must be visible
1935 i.e. if the variable is not externally visible or not used in some magic
1936 way (asm statement or such).
1937 The magic uses are all summarized in force_output flag. */
1938 inline bool all_refs_explicit_p ();
1940 /* Return true when variable can be removed from variable pool
1941 if all direct calls are eliminated. */
1942 inline bool can_remove_if_no_refs_p (void);
1944 /* Add the variable DECL to the varpool.
1945 Unlike finalize_decl function is intended to be used
1946 by middle end and allows insertion of new variable at arbitrary point
1948 static void add (tree decl
);
1950 /* Return varpool node for given symbol and check it is a function. */
1951 static inline varpool_node
*get (const_tree decl
);
1953 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
1954 the middle end to output the variable to asm file, if needed or externally
1956 static void finalize_decl (tree decl
);
1958 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1959 Extra name aliases are output whenever DECL is output. */
1960 static varpool_node
* create_extra_name_alias (tree alias
, tree decl
);
1962 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1963 Extra name aliases are output whenever DECL is output. */
1964 static varpool_node
* create_alias (tree
, tree
);
1966 /* Dump the variable pool to F. */
1967 static void dump_varpool (FILE *f
);
1969 /* Dump the variable pool to stderr. */
1970 static void DEBUG_FUNCTION
debug_varpool (void);
1972 /* Allocate new callgraph node and insert it into basic data structures. */
1973 static varpool_node
*create_empty (void);
1975 /* Return varpool node assigned to DECL. Create new one when needed. */
1976 static varpool_node
*get_create (tree decl
);
1978 /* Given an assembler name, lookup node. */
1979 static varpool_node
*get_for_asmname (tree asmname
);
1981 /* Set when variable is scheduled to be assembled. */
1982 unsigned output
: 1;
1984 /* Set if the variable is dynamically initialized, except for
1985 function local statics. */
1986 unsigned dynamically_initialized
: 1;
1988 ENUM_BITFIELD(tls_model
) tls_model
: 3;
1990 /* Set if the variable is known to be used by single function only.
1991 This is computed by ipa_signle_use pass and used by late optimizations
1992 in places where optimization would be valid for local static variable
1993 if we did not do any inter-procedural code movement. */
1994 unsigned used_by_single_function
: 1;
1997 /* Assemble thunks and aliases associated to varpool node. */
1998 void assemble_aliases (void);
2000 /* Worker for call_for_node_and_aliases. */
2001 bool call_for_symbol_and_aliases_1 (bool (*callback
) (varpool_node
*, void *),
2003 bool include_overwritable
);
2006 /* Every top level asm statement is put into a asm_node. */
2008 struct GTY(()) asm_node
{
2011 /* Next asm node. */
2013 /* String for this asm node. */
2015 /* Ordering of all cgraph nodes. */
2019 /* Report whether or not THIS symtab node is a function, aka cgraph_node. */
2024 is_a_helper
<cgraph_node
*>::test (symtab_node
*p
)
2026 return p
&& p
->type
== SYMTAB_FUNCTION
;
2029 /* Report whether or not THIS symtab node is a vriable, aka varpool_node. */
2034 is_a_helper
<varpool_node
*>::test (symtab_node
*p
)
2036 return p
&& p
->type
== SYMTAB_VARIABLE
;
2039 typedef void (*cgraph_edge_hook
)(cgraph_edge
*, void *);
2040 typedef void (*cgraph_node_hook
)(cgraph_node
*, void *);
2041 typedef void (*varpool_node_hook
)(varpool_node
*, void *);
2042 typedef void (*cgraph_2edge_hook
)(cgraph_edge
*, cgraph_edge
*, void *);
2043 typedef void (*cgraph_2node_hook
)(cgraph_node
*, cgraph_node
*, void *);
2045 struct cgraph_edge_hook_list
;
2046 struct cgraph_node_hook_list
;
2047 struct varpool_node_hook_list
;
2048 struct cgraph_2edge_hook_list
;
2049 struct cgraph_2node_hook_list
;
2051 /* Map from a symbol to initialization/finalization priorities. */
2052 struct GTY(()) symbol_priority_map
{
2059 /* Frontend is parsing and finalizing functions. */
2061 /* Callgraph is being constructed. It is safe to add new functions. */
2063 /* Callgraph is being streamed-in at LTO time. */
2065 /* Callgraph is built and early IPA passes are being run. */
2067 /* Callgraph is built and all functions are transformed to SSA form. */
2069 /* All inline decisions are done; it is now possible to remove extern inline
2070 functions and virtual call targets. */
2071 IPA_SSA_AFTER_INLINING
,
2072 /* Functions are now ordered and being passed to RTL expanders. */
2074 /* All cgraph expansion is done. */
2078 struct asmname_hasher
: ggc_ptr_hash
<symtab_node
>
2080 typedef const_tree compare_type
;
2082 static hashval_t
hash (symtab_node
*n
);
2083 static bool equal (symtab_node
*n
, const_tree t
);
2086 class GTY((tag ("SYMTAB"))) symbol_table
2089 friend struct symtab_node
;
2090 friend struct cgraph_node
;
2091 friend struct cgraph_edge
;
2094 cgraph_count (0), cgraph_max_uid (1), cgraph_max_summary_id (0),
2095 edges_count (0), edges_max_uid (1), edges_max_summary_id (0),
2096 cgraph_released_summary_ids (), edge_released_summary_ids (),
2097 nodes (NULL
), asmnodes (NULL
), asm_last_node (NULL
),
2098 order (0), global_info_ready (false), state (PARSING
),
2099 function_flags_ready (false), cpp_implicit_aliases_done (false),
2100 section_hash (NULL
), assembler_name_hash (NULL
), init_priority_hash (NULL
),
2101 dump_file (NULL
), ipa_clones_dump_file (NULL
), cloned_nodes (),
2102 m_first_edge_removal_hook (NULL
), m_first_cgraph_removal_hook (NULL
),
2103 m_first_edge_duplicated_hook (NULL
), m_first_cgraph_duplicated_hook (NULL
),
2104 m_first_cgraph_insertion_hook (NULL
), m_first_varpool_insertion_hook (NULL
),
2105 m_first_varpool_removal_hook (NULL
)
2109 /* Initialize callgraph dump file. */
2110 void initialize (void);
2112 /* Register a top-level asm statement ASM_STR. */
2113 inline asm_node
*finalize_toplevel_asm (tree asm_str
);
2115 /* Analyze the whole compilation unit once it is parsed completely. */
2116 void finalize_compilation_unit (void);
2118 /* C++ frontend produce same body aliases all over the place, even before PCH
2119 gets streamed out. It relies on us linking the aliases with their function
2120 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
2121 first produce aliases without links, but once C++ FE is sure he won't sream
2122 PCH we build the links via this function. */
2123 void process_same_body_aliases (void);
2125 /* Perform simple optimizations based on callgraph. */
2126 void compile (void);
2128 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
2129 functions into callgraph in a way so they look like ordinary reachable
2130 functions inserted into callgraph already at construction time. */
2131 void process_new_functions (void);
2133 /* Once all functions from compilation unit are in memory, produce all clones
2134 and update all calls. We might also do this on demand if we don't want to
2135 bring all functions to memory prior compilation, but current WHOPR
2136 implementation does that and it is bit easier to keep everything right
2138 void materialize_all_clones (void);
2140 /* Register a symbol NODE. */
2141 inline void register_symbol (symtab_node
*node
);
2144 clear_asm_symbols (void)
2147 asm_last_node
= NULL
;
2150 /* Perform reachability analysis and reclaim all unreachable nodes. */
2151 bool remove_unreachable_nodes (FILE *file
);
2153 /* Optimization of function bodies might've rendered some variables as
2154 unnecessary so we want to avoid these from being compiled. Re-do
2155 reachability starting from variables that are either externally visible
2156 or was referred from the asm output routines. */
2157 void remove_unreferenced_decls (void);
2159 /* Unregister a symbol NODE. */
2160 inline void unregister (symtab_node
*node
);
2162 /* Allocate new callgraph node and insert it into basic data structures. */
2163 cgraph_node
*create_empty (void);
2165 /* Release a callgraph NODE. */
2166 void release_symbol (cgraph_node
*node
);
2168 /* Output all variables enqueued to be assembled. */
2169 bool output_variables (void);
2171 /* Weakrefs may be associated to external decls and thus not output
2172 at expansion time. Emit all necessary aliases. */
2173 void output_weakrefs (void);
2175 /* Return first static symbol with definition. */
2176 inline symtab_node
*first_symbol (void);
2178 /* Return first assembler symbol. */
2180 first_asm_symbol (void)
2185 /* Return first static symbol with definition. */
2186 inline symtab_node
*first_defined_symbol (void);
2188 /* Return first variable. */
2189 inline varpool_node
*first_variable (void);
2191 /* Return next variable after NODE. */
2192 inline varpool_node
*next_variable (varpool_node
*node
);
2194 /* Return first static variable with initializer. */
2195 inline varpool_node
*first_static_initializer (void);
2197 /* Return next static variable with initializer after NODE. */
2198 inline varpool_node
*next_static_initializer (varpool_node
*node
);
2200 /* Return first static variable with definition. */
2201 inline varpool_node
*first_defined_variable (void);
2203 /* Return next static variable with definition after NODE. */
2204 inline varpool_node
*next_defined_variable (varpool_node
*node
);
2206 /* Return first function with body defined. */
2207 inline cgraph_node
*first_defined_function (void);
2209 /* Return next function with body defined after NODE. */
2210 inline cgraph_node
*next_defined_function (cgraph_node
*node
);
2212 /* Return first function. */
2213 inline cgraph_node
*first_function (void);
2215 /* Return next function. */
2216 inline cgraph_node
*next_function (cgraph_node
*node
);
2218 /* Return first function with body defined. */
2219 cgraph_node
*first_function_with_gimple_body (void);
2221 /* Return next reachable static variable with initializer after NODE. */
2222 inline cgraph_node
*next_function_with_gimple_body (cgraph_node
*node
);
2224 /* Register HOOK to be called with DATA on each removed edge. */
2225 cgraph_edge_hook_list
*add_edge_removal_hook (cgraph_edge_hook hook
,
2228 /* Remove ENTRY from the list of hooks called on removing edges. */
2229 void remove_edge_removal_hook (cgraph_edge_hook_list
*entry
);
2231 /* Register HOOK to be called with DATA on each removed node. */
2232 cgraph_node_hook_list
*add_cgraph_removal_hook (cgraph_node_hook hook
,
2235 /* Remove ENTRY from the list of hooks called on removing nodes. */
2236 void remove_cgraph_removal_hook (cgraph_node_hook_list
*entry
);
2238 /* Register HOOK to be called with DATA on each removed node. */
2239 varpool_node_hook_list
*add_varpool_removal_hook (varpool_node_hook hook
,
2242 /* Remove ENTRY from the list of hooks called on removing nodes. */
2243 void remove_varpool_removal_hook (varpool_node_hook_list
*entry
);
2245 /* Register HOOK to be called with DATA on each inserted node. */
2246 cgraph_node_hook_list
*add_cgraph_insertion_hook (cgraph_node_hook hook
,
2249 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2250 void remove_cgraph_insertion_hook (cgraph_node_hook_list
*entry
);
2252 /* Register HOOK to be called with DATA on each inserted node. */
2253 varpool_node_hook_list
*add_varpool_insertion_hook (varpool_node_hook hook
,
2256 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2257 void remove_varpool_insertion_hook (varpool_node_hook_list
*entry
);
2259 /* Register HOOK to be called with DATA on each duplicated edge. */
2260 cgraph_2edge_hook_list
*add_edge_duplication_hook (cgraph_2edge_hook hook
,
2262 /* Remove ENTRY from the list of hooks called on duplicating edges. */
2263 void remove_edge_duplication_hook (cgraph_2edge_hook_list
*entry
);
2265 /* Register HOOK to be called with DATA on each duplicated node. */
2266 cgraph_2node_hook_list
*add_cgraph_duplication_hook (cgraph_2node_hook hook
,
2269 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
2270 void remove_cgraph_duplication_hook (cgraph_2node_hook_list
*entry
);
2272 /* Call all edge removal hooks. */
2273 void call_edge_removal_hooks (cgraph_edge
*e
);
2275 /* Call all node insertion hooks. */
2276 void call_cgraph_insertion_hooks (cgraph_node
*node
);
2278 /* Call all node removal hooks. */
2279 void call_cgraph_removal_hooks (cgraph_node
*node
);
2281 /* Call all node duplication hooks. */
2282 void call_cgraph_duplication_hooks (cgraph_node
*node
, cgraph_node
*node2
);
2284 /* Call all edge duplication hooks. */
2285 void call_edge_duplication_hooks (cgraph_edge
*cs1
, cgraph_edge
*cs2
);
2287 /* Call all node removal hooks. */
2288 void call_varpool_removal_hooks (varpool_node
*node
);
2290 /* Call all node insertion hooks. */
2291 void call_varpool_insertion_hooks (varpool_node
*node
);
2293 /* Arrange node to be first in its entry of assembler_name_hash. */
2294 void symtab_prevail_in_asm_name_hash (symtab_node
*node
);
2296 /* Initalize asm name hash unless. */
2297 void symtab_initialize_asm_name_hash (void);
2299 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
2300 void change_decl_assembler_name (tree decl
, tree name
);
2302 /* Dump symbol table to F. */
2303 void dump (FILE *f
);
2305 /* Dump symbol table to F in graphviz format. */
2306 void dump_graphviz (FILE *f
);
2308 /* Dump symbol table to stderr. */
2309 void DEBUG_FUNCTION
debug (void);
2311 /* Assign a new summary ID for the callgraph NODE. */
2312 inline int assign_summary_id (cgraph_node
*node
)
2314 if (!cgraph_released_summary_ids
.is_empty ())
2315 node
->m_summary_id
= cgraph_released_summary_ids
.pop ();
2317 node
->m_summary_id
= cgraph_max_summary_id
++;
2319 return node
->m_summary_id
;
2322 /* Assign a new summary ID for the callgraph EDGE. */
2323 inline int assign_summary_id (cgraph_edge
*edge
)
2325 if (!edge_released_summary_ids
.is_empty ())
2326 edge
->m_summary_id
= edge_released_summary_ids
.pop ();
2328 edge
->m_summary_id
= edges_max_summary_id
++;
2330 return edge
->m_summary_id
;
2333 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
2335 static bool assembler_names_equal_p (const char *name1
, const char *name2
);
2339 int cgraph_max_summary_id
;
2343 int edges_max_summary_id
;
2345 /* Vector of released summary IDS for cgraph nodes. */
2346 vec
<int> GTY ((skip
)) cgraph_released_summary_ids
;
2348 /* Vector of released summary IDS for cgraph nodes. */
2349 vec
<int> GTY ((skip
)) edge_released_summary_ids
;
2351 /* Return symbol used to separate symbol name from suffix. */
2352 static char symbol_suffix_separator ();
2354 symtab_node
* GTY(()) nodes
;
2355 asm_node
* GTY(()) asmnodes
;
2356 asm_node
* GTY(()) asm_last_node
;
2358 /* The order index of the next symtab node to be created. This is
2359 used so that we can sort the cgraph nodes in order by when we saw
2360 them, to support -fno-toplevel-reorder. */
2363 /* Set when whole unit has been analyzed so we can access global info. */
2364 bool global_info_ready
;
2365 /* What state callgraph is in right now. */
2366 enum symtab_state state
;
2367 /* Set when the cgraph is fully build and the basic flags are computed. */
2368 bool function_flags_ready
;
2370 bool cpp_implicit_aliases_done
;
2372 /* Hash table used to hold sectoons. */
2373 hash_table
<section_name_hasher
> *GTY(()) section_hash
;
2375 /* Hash table used to convert assembler names into nodes. */
2376 hash_table
<asmname_hasher
> *assembler_name_hash
;
2378 /* Hash table used to hold init priorities. */
2379 hash_map
<symtab_node
*, symbol_priority_map
> *init_priority_hash
;
2381 FILE* GTY ((skip
)) dump_file
;
2383 FILE* GTY ((skip
)) ipa_clones_dump_file
;
2385 hash_set
<const cgraph_node
*> GTY ((skip
)) cloned_nodes
;
2388 /* Allocate new callgraph node. */
2389 inline cgraph_node
* allocate_cgraph_symbol (void);
2391 /* Allocate a cgraph_edge structure and fill it with data according to the
2392 parameters of which only CALLEE can be NULL (when creating an indirect
2393 call edge). CLONING_P should be set if properties that are copied from an
2394 original edge should not be calculated. */
2395 cgraph_edge
*create_edge (cgraph_node
*caller
, cgraph_node
*callee
,
2396 gcall
*call_stmt
, profile_count count
,
2397 bool indir_unknown_callee
, bool cloning_p
);
2399 /* Put the edge onto the free list. */
2400 void free_edge (cgraph_edge
*e
);
2402 /* Insert NODE to assembler name hash. */
2403 void insert_to_assembler_name_hash (symtab_node
*node
, bool with_clones
);
2405 /* Remove NODE from assembler name hash. */
2406 void unlink_from_assembler_name_hash (symtab_node
*node
, bool with_clones
);
2408 /* Hash asmnames ignoring the user specified marks. */
2409 static hashval_t
decl_assembler_name_hash (const_tree asmname
);
2411 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
2412 static bool decl_assembler_name_equal (tree decl
, const_tree asmname
);
2414 friend struct asmname_hasher
;
2416 /* List of hooks triggered when an edge is removed. */
2417 cgraph_edge_hook_list
* GTY((skip
)) m_first_edge_removal_hook
;
2418 /* List of hooks triggem_red when a cgraph node is removed. */
2419 cgraph_node_hook_list
* GTY((skip
)) m_first_cgraph_removal_hook
;
2420 /* List of hooks triggered when an edge is duplicated. */
2421 cgraph_2edge_hook_list
* GTY((skip
)) m_first_edge_duplicated_hook
;
2422 /* List of hooks triggered when a node is duplicated. */
2423 cgraph_2node_hook_list
* GTY((skip
)) m_first_cgraph_duplicated_hook
;
2424 /* List of hooks triggered when an function is inserted. */
2425 cgraph_node_hook_list
* GTY((skip
)) m_first_cgraph_insertion_hook
;
2426 /* List of hooks triggered when an variable is inserted. */
2427 varpool_node_hook_list
* GTY((skip
)) m_first_varpool_insertion_hook
;
2428 /* List of hooks triggered when a node is removed. */
2429 varpool_node_hook_list
* GTY((skip
)) m_first_varpool_removal_hook
;
2432 extern GTY(()) symbol_table
*symtab
;
2434 extern vec
<cgraph_node
*> cgraph_new_nodes
;
2437 asmname_hasher::hash (symtab_node
*n
)
2439 return symbol_table::decl_assembler_name_hash
2440 (DECL_ASSEMBLER_NAME (n
->decl
));
2444 asmname_hasher::equal (symtab_node
*n
, const_tree t
)
2446 return symbol_table::decl_assembler_name_equal (n
->decl
, t
);
2450 void cgraph_c_finalize (void);
2451 void release_function_body (tree
);
2452 cgraph_indirect_call_info
*cgraph_allocate_init_indirect_info (void);
2454 void cgraph_update_edges_for_call_stmt (gimple
*, tree
, gimple
*);
2455 bool cgraph_function_possibly_inlined_p (tree
);
2457 const char* cgraph_inline_failed_string (cgraph_inline_failed_t
);
2458 cgraph_inline_failed_type_t
cgraph_inline_failed_type (cgraph_inline_failed_t
);
2460 extern bool gimple_check_call_matching_types (gimple
*, tree
, bool);
2462 /* In cgraphunit.c */
2463 void cgraphunit_c_finalize (void);
2465 /* Initialize datastructures so DECL is a function in lowered gimple form.
2466 IN_SSA is true if the gimple is in SSA. */
2467 basic_block
init_lowered_empty_function (tree
, bool, profile_count
);
2469 tree
thunk_adjust (gimple_stmt_iterator
*, tree
, bool, HOST_WIDE_INT
, tree
,
2471 /* In cgraphclones.c */
2473 tree
clone_function_name_numbered (const char *name
, const char *suffix
);
2474 tree
clone_function_name_numbered (tree decl
, const char *suffix
);
2475 tree
clone_function_name (const char *name
, const char *suffix
,
2476 unsigned long number
);
2477 tree
clone_function_name (tree decl
, const char *suffix
,
2478 unsigned long number
);
2479 tree
clone_function_name (tree decl
, const char *suffix
);
2481 void tree_function_versioning (tree
, tree
, vec
<ipa_replace_map
*, va_gc
> *,
2482 ipa_param_adjustments
*,
2483 bool, bitmap
, basic_block
);
2485 void dump_callgraph_transformation (const cgraph_node
*original
,
2486 const cgraph_node
*clone
,
2487 const char *suffix
);
2488 /* In cgraphbuild.c */
2489 int compute_call_stmt_bb_frequency (tree
, basic_block bb
);
2490 void record_references_in_initializer (tree
, bool);
2493 void cgraph_build_static_cdtor (char which
, tree body
, int priority
);
2494 bool ipa_discover_variable_flags (void);
2497 tree
ctor_for_folding (tree
);
2499 /* In ipa-inline-analysis.c */
2500 void initialize_inline_failed (struct cgraph_edge
*);
2501 bool speculation_useful_p (struct cgraph_edge
*e
, bool anticipate_inlining
);
2503 /* Return true when the symbol is real symbol, i.e. it is not inline clone
2504 or abstract function kept for debug info purposes only. */
2506 symtab_node::real_symbol_p (void)
2510 if (DECL_ABSTRACT_P (decl
))
2512 if (transparent_alias
&& definition
)
2514 if (!is_a
<cgraph_node
*> (this))
2516 cnode
= dyn_cast
<cgraph_node
*> (this);
2517 if (cnode
->inlined_to
)
2522 /* Return true if DECL should have entry in symbol table if used.
2523 Those are functions and static & external veriables*/
2526 decl_in_symtab_p (const_tree decl
)
2528 return (TREE_CODE (decl
) == FUNCTION_DECL
2529 || (TREE_CODE (decl
) == VAR_DECL
2530 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))));
2534 symtab_node::in_same_comdat_group_p (symtab_node
*target
)
2536 symtab_node
*source
= this;
2538 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (target
))
2541 source
= cn
->inlined_to
;
2543 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (target
))
2546 target
= cn
->inlined_to
;
2549 return source
->get_comdat_group () == target
->get_comdat_group ();
2552 /* Return node that alias is aliasing. */
2554 inline symtab_node
*
2555 symtab_node::get_alias_target (void)
2557 ipa_ref
*ref
= NULL
;
2558 iterate_reference (0, ref
);
2559 gcc_checking_assert (ref
->use
== IPA_REF_ALIAS
);
2560 return ref
->referred
;
2563 /* Return next reachable static symbol with initializer after the node. */
2565 inline symtab_node
*
2566 symtab_node::next_defined_symbol (void)
2568 symtab_node
*node1
= next
;
2570 for (; node1
; node1
= node1
->next
)
2571 if (node1
->definition
)
2577 /* Iterates I-th reference in the list, REF is also set. */
2580 symtab_node::iterate_reference (unsigned i
, ipa_ref
*&ref
)
2582 vec_safe_iterate (ref_list
.references
, i
, &ref
);
2587 /* Iterates I-th referring item in the list, REF is also set. */
2590 symtab_node::iterate_referring (unsigned i
, ipa_ref
*&ref
)
2592 ref_list
.referring
.iterate (i
, &ref
);
2597 /* Iterates I-th referring alias item in the list, REF is also set. */
2600 symtab_node::iterate_direct_aliases (unsigned i
, ipa_ref
*&ref
)
2602 ref_list
.referring
.iterate (i
, &ref
);
2604 if (ref
&& ref
->use
!= IPA_REF_ALIAS
)
2610 /* Return true if list contains an alias. */
2613 symtab_node::has_aliases_p (void)
2615 ipa_ref
*ref
= NULL
;
2617 return (iterate_direct_aliases (0, ref
) != NULL
);
2620 /* Return true when RESOLUTION indicate that linker will use
2621 the symbol from non-LTO object files. */
2624 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution
)
2626 return (resolution
== LDPR_PREVAILING_DEF
2627 || resolution
== LDPR_PREEMPTED_REG
2628 || resolution
== LDPR_RESOLVED_EXEC
2629 || resolution
== LDPR_RESOLVED_DYN
);
2632 /* Return true when symtab_node is known to be used from other (non-LTO)
2633 object file. Known only when doing LTO via linker plugin. */
2636 symtab_node::used_from_object_file_p (void)
2638 if (!TREE_PUBLIC (decl
) || DECL_EXTERNAL (decl
))
2640 if (resolution_used_from_other_file_p (resolution
))
2645 /* Return varpool node for given symbol and check it is a function. */
2647 inline varpool_node
*
2648 varpool_node::get (const_tree decl
)
2650 gcc_checking_assert (TREE_CODE (decl
) == VAR_DECL
);
2651 return dyn_cast
<varpool_node
*> (symtab_node::get (decl
));
2654 /* Register a symbol NODE. */
2657 symbol_table::register_symbol (symtab_node
*node
)
2660 node
->previous
= NULL
;
2663 nodes
->previous
= node
;
2666 node
->order
= order
++;
2669 /* Register a top-level asm statement ASM_STR. */
2672 symbol_table::finalize_toplevel_asm (tree asm_str
)
2676 node
= ggc_cleared_alloc
<asm_node
> ();
2677 node
->asm_str
= asm_str
;
2678 node
->order
= order
++;
2681 if (asmnodes
== NULL
)
2684 asm_last_node
->next
= node
;
2686 asm_last_node
= node
;
2690 /* Unregister a symbol NODE. */
2692 symbol_table::unregister (symtab_node
*node
)
2695 node
->previous
->next
= node
->next
;
2700 node
->next
->previous
= node
->previous
;
2703 node
->previous
= NULL
;
2706 /* Release a callgraph NODE with UID and put in to the list of free nodes. */
2709 symbol_table::release_symbol (cgraph_node
*node
)
2712 if (node
->m_summary_id
!= -1)
2713 cgraph_released_summary_ids
.safe_push (node
->m_summary_id
);
2717 /* Allocate new callgraph node. */
2719 inline cgraph_node
*
2720 symbol_table::allocate_cgraph_symbol (void)
2724 node
= ggc_cleared_alloc
<cgraph_node
> ();
2725 node
->type
= SYMTAB_FUNCTION
;
2726 node
->m_summary_id
= -1;
2727 node
->m_uid
= cgraph_max_uid
++;
2732 /* Return first static symbol with definition. */
2733 inline symtab_node
*
2734 symbol_table::first_symbol (void)
2739 /* Walk all symbols. */
2740 #define FOR_EACH_SYMBOL(node) \
2741 for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)
2743 /* Return first static symbol with definition. */
2744 inline symtab_node
*
2745 symbol_table::first_defined_symbol (void)
2749 for (node
= nodes
; node
; node
= node
->next
)
2750 if (node
->definition
)
2756 /* Walk all symbols with definitions in current unit. */
2757 #define FOR_EACH_DEFINED_SYMBOL(node) \
2758 for ((node) = symtab->first_defined_symbol (); (node); \
2759 (node) = node->next_defined_symbol ())
2761 /* Return first variable. */
2762 inline varpool_node
*
2763 symbol_table::first_variable (void)
2766 for (node
= nodes
; node
; node
= node
->next
)
2767 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
))
2772 /* Return next variable after NODE. */
2773 inline varpool_node
*
2774 symbol_table::next_variable (varpool_node
*node
)
2776 symtab_node
*node1
= node
->next
;
2777 for (; node1
; node1
= node1
->next
)
2778 if (varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
))
2782 /* Walk all variables. */
2783 #define FOR_EACH_VARIABLE(node) \
2784 for ((node) = symtab->first_variable (); \
2786 (node) = symtab->next_variable ((node)))
2788 /* Return first static variable with initializer. */
2789 inline varpool_node
*
2790 symbol_table::first_static_initializer (void)
2793 for (node
= nodes
; node
; node
= node
->next
)
2795 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2796 if (vnode
&& DECL_INITIAL (node
->decl
))
2802 /* Return next static variable with initializer after NODE. */
2803 inline varpool_node
*
2804 symbol_table::next_static_initializer (varpool_node
*node
)
2806 symtab_node
*node1
= node
->next
;
2807 for (; node1
; node1
= node1
->next
)
2809 varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
);
2810 if (vnode1
&& DECL_INITIAL (node1
->decl
))
2816 /* Walk all static variables with initializer set. */
2817 #define FOR_EACH_STATIC_INITIALIZER(node) \
2818 for ((node) = symtab->first_static_initializer (); (node); \
2819 (node) = symtab->next_static_initializer (node))
2821 /* Return first static variable with definition. */
2822 inline varpool_node
*
2823 symbol_table::first_defined_variable (void)
2826 for (node
= nodes
; node
; node
= node
->next
)
2828 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2829 if (vnode
&& vnode
->definition
)
2835 /* Return next static variable with definition after NODE. */
2836 inline varpool_node
*
2837 symbol_table::next_defined_variable (varpool_node
*node
)
2839 symtab_node
*node1
= node
->next
;
2840 for (; node1
; node1
= node1
->next
)
2842 varpool_node
*vnode1
= dyn_cast
<varpool_node
*> (node1
);
2843 if (vnode1
&& vnode1
->definition
)
2848 /* Walk all variables with definitions in current unit. */
2849 #define FOR_EACH_DEFINED_VARIABLE(node) \
2850 for ((node) = symtab->first_defined_variable (); (node); \
2851 (node) = symtab->next_defined_variable (node))
2853 /* Return first function with body defined. */
2854 inline cgraph_node
*
2855 symbol_table::first_defined_function (void)
2858 for (node
= nodes
; node
; node
= node
->next
)
2860 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
2861 if (cn
&& cn
->definition
)
2867 /* Return next function with body defined after NODE. */
2868 inline cgraph_node
*
2869 symbol_table::next_defined_function (cgraph_node
*node
)
2871 symtab_node
*node1
= node
->next
;
2872 for (; node1
; node1
= node1
->next
)
2874 cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
);
2875 if (cn1
&& cn1
->definition
)
2881 /* Walk all functions with body defined. */
2882 #define FOR_EACH_DEFINED_FUNCTION(node) \
2883 for ((node) = symtab->first_defined_function (); (node); \
2884 (node) = symtab->next_defined_function ((node)))
2886 /* Return first function. */
2887 inline cgraph_node
*
2888 symbol_table::first_function (void)
2891 for (node
= nodes
; node
; node
= node
->next
)
2892 if (cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
))
2897 /* Return next function. */
2898 inline cgraph_node
*
2899 symbol_table::next_function (cgraph_node
*node
)
2901 symtab_node
*node1
= node
->next
;
2902 for (; node1
; node1
= node1
->next
)
2903 if (cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
))
2908 /* Return first function with body defined. */
2909 inline cgraph_node
*
2910 symbol_table::first_function_with_gimple_body (void)
2913 for (node
= nodes
; node
; node
= node
->next
)
2915 cgraph_node
*cn
= dyn_cast
<cgraph_node
*> (node
);
2916 if (cn
&& cn
->has_gimple_body_p ())
2922 /* Return next reachable static variable with initializer after NODE. */
2923 inline cgraph_node
*
2924 symbol_table::next_function_with_gimple_body (cgraph_node
*node
)
2926 symtab_node
*node1
= node
->next
;
2927 for (; node1
; node1
= node1
->next
)
2929 cgraph_node
*cn1
= dyn_cast
<cgraph_node
*> (node1
);
2930 if (cn1
&& cn1
->has_gimple_body_p ())
2936 /* Walk all functions. */
2937 #define FOR_EACH_FUNCTION(node) \
2938 for ((node) = symtab->first_function (); (node); \
2939 (node) = symtab->next_function ((node)))
2941 /* Return true when callgraph node is a function with Gimple body defined
2942 in current unit. Functions can also be define externally or they
2943 can be thunks with no Gimple representation.
2945 Note that at WPA stage, the function body may not be present in memory. */
2948 cgraph_node::has_gimple_body_p (void)
2950 return definition
&& !thunk
.thunk_p
&& !alias
;
2953 /* Return true if this node represents a former, i.e. an expanded, thunk. */
2956 cgraph_node::former_thunk_p (void)
2958 return (!thunk
.thunk_p
2959 && (thunk
.fixed_offset
2960 || thunk
.virtual_offset_p
2961 || thunk
.indirect_offset
));
2964 /* Walk all functions with body defined. */
2965 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
2966 for ((node) = symtab->first_function_with_gimple_body (); (node); \
2967 (node) = symtab->next_function_with_gimple_body (node))
2969 /* Uniquize all constants that appear in memory.
2970 Each constant in memory thus far output is recorded
2971 in `const_desc_table'. */
2973 struct GTY((for_user
)) constant_descriptor_tree
{
2974 /* A MEM for the constant. */
2977 /* The value of the constant. */
2980 /* Hash of value. Computing the hash from value each time
2981 hashfn is called can't work properly, as that means recursive
2982 use of the hash table during hash table expansion. */
2986 /* Return true when function is only called directly or it has alias.
2987 i.e. it is not externally visible, address was not taken and
2988 it is not used in any other non-standard way. */
2991 cgraph_node::only_called_directly_or_aliased_p (void)
2993 gcc_assert (!inlined_to
);
2994 return (!force_output
&& !address_taken
2996 && !used_from_other_partition
2997 && !DECL_VIRTUAL_P (decl
)
2998 && !DECL_STATIC_CONSTRUCTOR (decl
)
2999 && !DECL_STATIC_DESTRUCTOR (decl
)
3000 && !used_from_object_file_p ()
3001 && !externally_visible
);
3004 /* Return true when function can be removed from callgraph
3005 if all direct calls are eliminated. */
3008 cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
3010 gcc_checking_assert (!inlined_to
);
3011 /* Extern inlines can always go, we will use the external definition. */
3012 if (DECL_EXTERNAL (decl
))
3014 /* When function is needed, we cannot remove it. */
3015 if (force_output
|| used_from_other_partition
)
3017 if (DECL_STATIC_CONSTRUCTOR (decl
)
3018 || DECL_STATIC_DESTRUCTOR (decl
))
3020 /* Only COMDAT functions can be removed if externally visible. */
3021 if (externally_visible
3022 && (!DECL_COMDAT (decl
)
3024 || used_from_object_file_p ()))
3029 /* Verify cgraph, if consistency checking is enabled. */
3032 cgraph_node::checking_verify_cgraph_nodes (void)
3035 cgraph_node::verify_cgraph_nodes ();
3038 /* Return true when variable can be removed from variable pool
3039 if all direct calls are eliminated. */
3042 varpool_node::can_remove_if_no_refs_p (void)
3044 if (DECL_EXTERNAL (decl
))
3046 return (!force_output
&& !used_from_other_partition
3047 && ((DECL_COMDAT (decl
)
3049 && !used_from_object_file_p ())
3050 || !externally_visible
3051 || DECL_HAS_VALUE_EXPR_P (decl
)));
3054 /* Return true when all references to variable must be visible in ipa_ref_list.
3055 i.e. if the variable is not externally visible or not used in some magic
3056 way (asm statement or such).
3057 The magic uses are all summarized in force_output flag. */
3060 varpool_node::all_refs_explicit_p ()
3063 && !externally_visible
3064 && !used_from_other_partition
3068 struct tree_descriptor_hasher
: ggc_ptr_hash
<constant_descriptor_tree
>
3070 static hashval_t
hash (constant_descriptor_tree
*);
3071 static bool equal (constant_descriptor_tree
*, constant_descriptor_tree
*);
3074 /* Constant pool accessor function. */
3075 hash_table
<tree_descriptor_hasher
> *constant_pool_htab (void);
3077 /* Return node that alias is aliasing. */
3079 inline cgraph_node
*
3080 cgraph_node::get_alias_target (void)
3082 return dyn_cast
<cgraph_node
*> (symtab_node::get_alias_target ());
3085 /* Return node that alias is aliasing. */
3087 inline varpool_node
*
3088 varpool_node::get_alias_target (void)
3090 return dyn_cast
<varpool_node
*> (symtab_node::get_alias_target ());
3093 /* Walk the alias chain to return the symbol NODE is alias of.
3094 If NODE is not an alias, return NODE.
3095 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3096 When REF is non-NULL, assume that reference happens in symbol REF
3097 when determining the availability. */
3099 inline symtab_node
*
3100 symtab_node::ultimate_alias_target (enum availability
*availability
,
3106 *availability
= get_availability (ref
);
3110 return ultimate_alias_target_1 (availability
, ref
);
3113 /* Given function symbol, walk the alias chain to return the function node
3114 is alias of. Do not walk through thunks.
3115 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3116 When REF is non-NULL, assume that reference happens in symbol REF
3117 when determining the availability. */
3119 inline cgraph_node
*
3120 cgraph_node::ultimate_alias_target (enum availability
*availability
,
3123 cgraph_node
*n
= dyn_cast
<cgraph_node
*>
3124 (symtab_node::ultimate_alias_target (availability
, ref
));
3125 if (!n
&& availability
)
3126 *availability
= AVAIL_NOT_AVAILABLE
;
3130 /* For given variable pool node, walk the alias chain to return the function
3131 the variable is alias of. Do not walk through thunks.
3132 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3133 When REF is non-NULL, assume that reference happens in symbol REF
3134 when determining the availability. */
3136 inline varpool_node
*
3137 varpool_node::ultimate_alias_target (availability
*availability
,
3140 varpool_node
*n
= dyn_cast
<varpool_node
*>
3141 (symtab_node::ultimate_alias_target (availability
, ref
));
3143 if (!n
&& availability
)
3144 *availability
= AVAIL_NOT_AVAILABLE
;
3148 /* Set callee N of call graph edge and add it to the corresponding set of
3152 cgraph_edge::set_callee (cgraph_node
*n
)
3156 n
->callers
->prev_caller
= this;
3157 next_caller
= n
->callers
;
3162 /* Redirect callee of the edge to N. The function does not update underlying
3166 cgraph_edge::redirect_callee (cgraph_node
*n
)
3168 /* Remove from callers list of the current callee. */
3171 /* Insert to callers list of the new callee. */
3175 /* Return true when the edge represents a direct recursion. */
3178 cgraph_edge::recursive_p (void)
3180 cgraph_node
*c
= callee
->ultimate_alias_target ();
3181 if (caller
->inlined_to
)
3182 return caller
->inlined_to
->decl
== c
->decl
;
3184 return caller
->decl
== c
->decl
;
3187 /* Remove the edge from the list of the callers of the callee. */
3190 cgraph_edge::remove_callee (void)
3192 gcc_assert (!indirect_unknown_callee
);
3194 prev_caller
->next_caller
= next_caller
;
3196 next_caller
->prev_caller
= prev_caller
;
3198 callee
->callers
= next_caller
;
3201 /* Return true if call must bind to current definition. */
3204 cgraph_edge::binds_to_current_def_p ()
3207 return callee
->binds_to_current_def_p (caller
);
3212 /* Expected frequency of executions within the function.
3213 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
3214 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
3217 cgraph_edge::frequency ()
3219 return count
.to_cgraph_frequency (caller
->inlined_to
3220 ? caller
->inlined_to
->count
3225 /* Return true if the TM_CLONE bit is set for a given FNDECL. */
3227 decl_is_tm_clone (const_tree fndecl
)
3229 cgraph_node
*n
= cgraph_node::get (fndecl
);
3235 /* Likewise indicate that a node is needed, i.e. reachable via some
3239 cgraph_node::mark_force_output (void)
3242 gcc_checking_assert (!inlined_to
);
3245 /* Return true if function should be optimized for size. */
3248 cgraph_node::optimize_for_size_p (void)
3250 if (opt_for_fn (decl
, optimize_size
))
3252 if (frequency
== NODE_FREQUENCY_UNLIKELY_EXECUTED
)
3258 /* Return symtab_node for NODE or create one if it is not present
3261 inline symtab_node
*
3262 symtab_node::get_create (tree node
)
3264 if (TREE_CODE (node
) == VAR_DECL
)
3265 return varpool_node::get_create (node
);
3267 return cgraph_node::get_create (node
);
3270 /* Return availability of NODE when referenced from REF. */
3272 inline enum availability
3273 symtab_node::get_availability (symtab_node
*ref
)
3275 if (is_a
<cgraph_node
*> (this))
3276 return dyn_cast
<cgraph_node
*> (this)->get_availability (ref
);
3278 return dyn_cast
<varpool_node
*> (this)->get_availability (ref
);
3281 /* Call calback on symtab node and aliases associated to this node.
3282 When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */
3285 symtab_node::call_for_symbol_and_aliases (bool (*callback
) (symtab_node
*,
3288 bool include_overwritable
)
3290 if (include_overwritable
3291 || get_availability () > AVAIL_INTERPOSABLE
)
3293 if (callback (this, data
))
3296 if (has_aliases_p ())
3297 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3301 /* Call callback on function and aliases associated to the function.
3302 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3306 cgraph_node::call_for_symbol_and_aliases (bool (*callback
) (cgraph_node
*,
3309 bool include_overwritable
)
3311 if (include_overwritable
3312 || get_availability () > AVAIL_INTERPOSABLE
)
3314 if (callback (this, data
))
3317 if (has_aliases_p ())
3318 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3322 /* Call calback on varpool symbol and aliases associated to varpool symbol.
3323 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3327 varpool_node::call_for_symbol_and_aliases (bool (*callback
) (varpool_node
*,
3330 bool include_overwritable
)
3332 if (include_overwritable
3333 || get_availability () > AVAIL_INTERPOSABLE
)
3335 if (callback (this, data
))
3338 if (has_aliases_p ())
3339 return call_for_symbol_and_aliases_1 (callback
, data
, include_overwritable
);
3343 /* Return true if refernece may be used in address compare. */
3346 ipa_ref::address_matters_p ()
3348 if (use
!= IPA_REF_ADDR
)
3350 /* Addresses taken from virtual tables are never compared. */
3351 if (is_a
<varpool_node
*> (referring
)
3352 && DECL_VIRTUAL_P (referring
->decl
))
3354 return referred
->address_can_be_compared_p ();
3357 /* Build polymorphic call context for indirect call E. */
3360 ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge
*e
)
3362 gcc_checking_assert (e
->indirect_info
->polymorphic
);
3363 *this = e
->indirect_info
->context
;
3366 /* Build empty "I know nothing" context. */
3369 ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
3371 clear_speculation ();
3372 clear_outer_type ();
3376 /* Make context non-speculative. */
3379 ipa_polymorphic_call_context::clear_speculation ()
3381 speculative_outer_type
= NULL
;
3382 speculative_offset
= 0;
3383 speculative_maybe_derived_type
= false;
3386 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
3387 NULL, the context is set to dummy "I know nothing" setting. */
3390 ipa_polymorphic_call_context::clear_outer_type (tree otr_type
)
3392 outer_type
= otr_type
? TYPE_MAIN_VARIANT (otr_type
) : NULL
;
3394 maybe_derived_type
= true;
3395 maybe_in_construction
= true;
3399 /* Adjust all offsets in contexts by OFF bits. */
3402 ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off
)
3406 if (speculative_outer_type
)
3407 speculative_offset
+= off
;
3410 /* Return TRUE if context is fully useless. */
3413 ipa_polymorphic_call_context::useless_p () const
3415 return (!outer_type
&& !speculative_outer_type
);
3418 /* When using fprintf (or similar), problems can arise with
3419 transient generated strings. Many string-generation APIs
3420 only support one result being alive at once (e.g. by
3421 returning a pointer to a statically-allocated buffer).
3423 If there is more than one generated string within one
3424 fprintf call: the first string gets evicted or overwritten
3425 by the second, before fprintf is fully evaluated.
3428 This function provides a workaround for this, by providing
3429 a simple way to create copies of these transient strings,
3430 without the need to have explicit cleanup:
3432 fprintf (dumpfile, "string 1: %s string 2:%s\n",
3433 xstrdup_for_dump (EXPR_1),
3434 xstrdup_for_dump (EXPR_2));
3436 This is actually a simple wrapper around ggc_strdup, but
3437 the name documents the intent. We require that no GC can occur
3438 within the fprintf call. */
3440 static inline const char *
3441 xstrdup_for_dump (const char *transient_str
)
3443 return ggc_strdup (transient_str
);
3446 /* During LTO stream-in this predicate can be used to check whether node
3447 in question prevails in the linking to save some memory usage. */
3449 symtab_node::prevailing_p (void)
3451 return definition
&& ((!TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
3452 || previous_sharing_asm_name
== NULL
);
3455 extern GTY(()) symbol_table
*saved_symtab
;
3459 namespace selftest
{
3461 /* An RAII-style class for use in selftests for temporarily using a different
3462 symbol_table, so that such tests can be isolated from each other. */
3464 class symbol_table_test
3467 /* Constructor. Override "symtab". */
3468 symbol_table_test ();
3470 /* Destructor. Restore the saved_symtab. */
3471 ~symbol_table_test ();
3474 } // namespace selftest
3476 #endif /* CHECKING_P */
3478 #endif /* GCC_CGRAPH_H */