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